@utrecht/web-component-library-stencil 1.0.0-alpha.159 → 1.0.0-alpha.162

package/dist/collection/node_modules/@storybook/manager-webpack5/node_modules/webpack/lib/ContextModule.js

@@ -1,1079 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const { OriginalSource, RawSource } = require("webpack-sources");
-const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
-const { makeWebpackError } = require("./HookWebpackError");
-const Module = require("./Module");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const Template = require("./Template");
-const WebpackError = require("./WebpackError");
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	keepOriginalOrder,
-	compareModulesById
-} = require("./util/comparators");
-const { contextify, parseResource } = require("./util/identifier");
-const makeSerializable = require("./util/makeSerializable");
-
-/** @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=} 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;
-		}
-
-		if (options && typeof options.mode !== "string") {
-			throw new Error("options.mode is a required option");
-		}
-
-		this._identifier = this._createIdentifier();
-		this._forceBuild = true;
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return 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}
-	 */
-	updateCacheModule(module) {
-		const m = /** @type {ContextModule} */ (module);
-		this.resolveDependencies = m.resolveDependencies;
-		this.options = m.options;
-	}
-
-	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
-	 */
-	cleanupForCache() {
-		super.cleanupForCache();
-		this.resolveDependencies = undefined;
-	}
-
-	prettyRegExp(regexString) {
-		// remove the "/" at the front and the beginning
-		// "/foo/" -> "foo"
-		return regexString
-			.substring(1, regexString.length - 1)
-			.replace(/!/g, "%21");
-	}
-
-	_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.options.regExp}`;
-		}
-		if (this.options.include) {
-			identifier += `|include: ${this.options.include}`;
-		}
-		if (this.options.exclude) {
-			identifier += `|exclude: ${this.options.exclude}`;
-		}
-		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;
-	}
-
-	/**
-	 * @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) {
-		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 {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		let identifier = contextify(
-			options.context,
-			this.context,
-			options.associatedObjectForCache
-		);
-		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;
-	}
-
-	/**
-	 * @returns {void}
-	 */
-	invalidateBuild() {
-		this._forceBuild = true;
-	}
-
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, 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);
-
-		// 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);
-		});
-	}
-
-	/**
-	 * @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;
-			}
-
-			// 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 {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);
-	}
-
-	/**
-	 * @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;
-	}
-
-	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)};`;
-		}
-		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;`;
-	}
-
-	/**
-	 * @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);
-
-		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 {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;
-		}
-		return map[req];
-	});
-}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.resolve = webpackAsyncContextResolve;
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
-	}
-
-	/**
-	 * @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;`;
-	}
-
-	/**
-	 * @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)
-				);
-			}
-		}
-
-		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 this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
-		}
-		if (asyncMode === "eager") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getEagerSource(this.dependencies, id, {
-					chunkGraph,
-					runtimeTemplate
-				});
-			}
-			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
-				});
-			}
-			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);
-	}
-
-	getSource(sourceString) {
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			return new OriginalSource(sourceString, this.identifier());
-		}
-		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 (this.getFakeMap(allDeps, chunkGraph) !== 9) {
-				set.add(RuntimeGlobals.createFakeNamespaceObject);
-			}
-		}
-		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;
-
-		// 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;