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

package/dist/collection/node_modules/@storybook/builder-webpack5/node_modules/webpack/lib/NormalModule.js

@@ -1,1402 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const parseJson = require("json-parse-better-errors");
-const { getContext, runLoaders } = require("loader-runner");
-const querystring = require("querystring");
-const { HookMap, SyncHook, AsyncSeriesBailHook } = require("tapable");
-const {
-	CachedSource,
-	OriginalSource,
-	RawSource,
-	SourceMapSource
-} = require("webpack-sources");
-const Compilation = require("./Compilation");
-const HookWebpackError = require("./HookWebpackError");
-const Module = require("./Module");
-const ModuleBuildError = require("./ModuleBuildError");
-const ModuleError = require("./ModuleError");
-const ModuleGraphConnection = require("./ModuleGraphConnection");
-const ModuleParseError = require("./ModuleParseError");
-const ModuleWarning = require("./ModuleWarning");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const UnhandledSchemeError = require("./UnhandledSchemeError");
-const WebpackError = require("./WebpackError");
-const formatLocation = require("./formatLocation");
-const LazySet = require("./util/LazySet");
-const { isSubset } = require("./util/SetHelpers");
-const { getScheme } = require("./util/URLAbsoluteSpecifier");
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	keepOriginalOrder
-} = require("./util/comparators");
-const createHash = require("./util/createHash");
-const { createFakeHook } = require("./util/deprecation");
-const { join } = require("./util/fs");
-const {
-	contextify,
-	absolutify,
-	makePathsRelative
-} = require("./util/identifier");
-const makeSerializable = require("./util/makeSerializable");
-const memoize = require("./util/memoize");
-
-/** @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(() =>
-	require("./InvalidDependenciesModuleWarning")
-);
-const getValidate = memoize(() => require("schema-utils").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=} */
-		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) {
-		return contextify(
-			options.context,
-			this.userRequest,
-			options.associatedObjectForCache
-		);
-	}
-
-	/**
-	 * @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=): 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
-	}) {
-		/** @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,
-						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=, 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;