@depup/webpack 5.105.4-depup.37

package/lib/ModuleParseError.js

@@ -0,0 +1,125 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").SourcePosition} SourcePosition */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
+
+class ModuleParseError extends WebpackError {
+	/**
+	 * @param {string | Buffer} source source code
+	 * @param {Error & { loc?: SourcePosition }} err the parse error
+	 * @param {string[]} loaders the loaders used
+	 * @param {string} type module type
+	 */
+	constructor(source, err, loaders, type) {
+		let message = `Module parse failed: ${err && err.message}`;
+		/** @type {undefined | DependencyLocation} */
+		let loc;
+
+		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. " +
+				"See https://webpack.js.org/concepts/loaders";
+		} 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";
+		}
+
+		if (
+			err &&
+			err.loc &&
+			typeof err.loc === "object" &&
+			typeof err.loc.line === "number"
+		) {
+			const lineNumber = err.loc.line;
+
+			if (
+				Buffer.isBuffer(source) ||
+				// eslint-disable-next-line no-control-regex
+				/[\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);
+
+		/** @type {string} */
+		this.name = "ModuleParseError";
+		this.loc = loc;
+		this.error = err;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.error);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.error = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(ModuleParseError, "webpack/lib/ModuleParseError");
+
+module.exports = ModuleParseError;

package/lib/ModuleProfile.js

@@ -0,0 +1,108 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+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;
+
+		/** @type {{ start: number, end: number }[] | undefined} */
+		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;
+	}
+
+	// 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
+		});
+	}
+}
+
+module.exports = ModuleProfile;

package/lib/ModuleRestoreError.js

@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @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: ";
+		/** @type {string | undefined} */
+		const 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);
+
+		/** @type {string} */
+		this.name = "ModuleRestoreError";
+		/** @type {string | undefined} */
+		this.details = details;
+		this.module = module;
+		this.error = err;
+	}
+}
+
+/** @type {typeof ModuleRestoreError} */
+module.exports = ModuleRestoreError;

package/lib/ModuleSourceTypeConstants.js

@@ -0,0 +1,179 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * @type {Readonly<"javascript">}
+ */
+const JAVASCRIPT_TYPE = "javascript";
+
+/**
+ * @type {Readonly<"runtime">}
+ */
+const RUNTIME_TYPE = "runtime";
+
+/**
+ * @type {Readonly<"webassembly">}
+ */
+const WEBASSEMBLY_TYPE = "webassembly";
+
+/**
+ * @type {Readonly<"asset">}
+ */
+const ASSET_TYPE = "asset";
+
+/**
+ * @type {Readonly<"css">}
+ */
+const CSS_TYPE = "css";
+
+/**
+ * @type {Readonly<"css-import">}
+ */
+const CSS_IMPORT_TYPE = "css-import";
+
+/**
+ * @type {Readonly<"css-url">}
+ */
+const CSS_URL_TYPE = "css-url";
+
+/**
+ * @type {Readonly<"share-init">}
+ */
+const SHARED_INIT_TYPE = "share-init";
+
+/**
+ * @type {Readonly<"remote">}
+ */
+const REMOTE_GENERATOR_TYPE = "remote";
+
+/**
+ * @type {Readonly<"consume-shared">}
+ */
+const CONSUME_SHARED_GENERATOR_TYPE = "consume-shared";
+
+/**
+ * @type {Readonly<"unknown">}
+ */
+const UNKNOWN_TYPE = "unknown";
+
+/**
+ * @typedef {JAVASCRIPT_TYPE | RUNTIME_TYPE | WEBASSEMBLY_TYPE | ASSET_TYPE | CSS_TYPE | CSS_IMPORT_TYPE | CSS_URL_TYPE | SHARED_INIT_TYPE | REMOTE_GENERATOR_TYPE | CONSUME_SHARED_GENERATOR_TYPE | UNKNOWN_TYPE} AllTypes
+ */
+
+/**
+ * @type {ReadonlySet<never>}
+ */
+const NO_TYPES = new Set();
+
+/**
+ * @type {ReadonlySet<"asset">}
+ */
+const ASSET_TYPES = new Set([ASSET_TYPE]);
+
+/**
+ * @type {ReadonlySet<"asset" | "javascript" | "asset">}
+ */
+const ASSET_AND_JAVASCRIPT_TYPES = new Set([ASSET_TYPE, JAVASCRIPT_TYPE]);
+
+/**
+ * @type {ReadonlySet<"css-url" | "asset">}
+ */
+const ASSET_AND_CSS_URL_TYPES = new Set([ASSET_TYPE, CSS_URL_TYPE]);
+
+/**
+ * @type {ReadonlySet<"javascript" | "css-url" | "asset">}
+ */
+const ASSET_AND_JAVASCRIPT_AND_CSS_URL_TYPES = new Set([
+	ASSET_TYPE,
+	JAVASCRIPT_TYPE,
+	CSS_URL_TYPE
+]);
+
+/**
+ * @type {ReadonlySet<"javascript">}
+ */
+const JAVASCRIPT_TYPES = new Set([JAVASCRIPT_TYPE]);
+
+/**
+ * @type {ReadonlySet<"javascript" | "css-url">}
+ */
+const JAVASCRIPT_AND_CSS_URL_TYPES = new Set([JAVASCRIPT_TYPE, CSS_URL_TYPE]);
+
+/**
+ * @type {ReadonlySet<"javascript" | "css">}
+ */
+const JAVASCRIPT_AND_CSS_TYPES = new Set([JAVASCRIPT_TYPE, CSS_TYPE]);
+
+/**
+ * @type {ReadonlySet<"css">}
+ */
+const CSS_TYPES = new Set([CSS_TYPE]);
+
+/**
+ * @type {ReadonlySet<"css-url">}
+ */
+const CSS_URL_TYPES = new Set([CSS_URL_TYPE]);
+/**
+ * @type {ReadonlySet<"css-import">}
+ */
+const CSS_IMPORT_TYPES = new Set([CSS_IMPORT_TYPE]);
+
+/**
+ * @type {ReadonlySet<"webassembly">}
+ */
+const WEBASSEMBLY_TYPES = new Set([WEBASSEMBLY_TYPE]);
+
+/**
+ * @type {ReadonlySet<"runtime">}
+ */
+const RUNTIME_TYPES = new Set([RUNTIME_TYPE]);
+
+/**
+ * @type {ReadonlySet<"remote" | "share-init">}
+ */
+const REMOTE_AND_SHARE_INIT_TYPES = new Set([
+	REMOTE_GENERATOR_TYPE,
+	SHARED_INIT_TYPE
+]);
+
+/**
+ * @type {ReadonlySet<"consume-shared">}
+ */
+const CONSUME_SHARED_TYPES = new Set([CONSUME_SHARED_GENERATOR_TYPE]);
+
+/**
+ * @type {ReadonlySet<"share-init">}
+ */
+const SHARED_INIT_TYPES = new Set([SHARED_INIT_TYPE]);
+
+module.exports.ASSET_AND_CSS_URL_TYPES = ASSET_AND_CSS_URL_TYPES;
+module.exports.ASSET_AND_JAVASCRIPT_AND_CSS_URL_TYPES =
+	ASSET_AND_JAVASCRIPT_AND_CSS_URL_TYPES;
+module.exports.ASSET_AND_JAVASCRIPT_TYPES = ASSET_AND_JAVASCRIPT_TYPES;
+module.exports.ASSET_TYPE = ASSET_TYPE;
+module.exports.ASSET_TYPES = ASSET_TYPES;
+module.exports.CONSUME_SHARED_TYPES = CONSUME_SHARED_TYPES;
+module.exports.CSS_IMPORT_TYPE = CSS_IMPORT_TYPE;
+module.exports.CSS_IMPORT_TYPES = CSS_IMPORT_TYPES;
+module.exports.CSS_TYPE = CSS_TYPE;
+module.exports.CSS_TYPE = CSS_TYPE;
+module.exports.CSS_TYPES = CSS_TYPES;
+module.exports.CSS_URL_TYPE = CSS_URL_TYPE;
+module.exports.CSS_URL_TYPES = CSS_URL_TYPES;
+module.exports.JAVASCRIPT_AND_CSS_TYPES = JAVASCRIPT_AND_CSS_TYPES;
+module.exports.JAVASCRIPT_AND_CSS_URL_TYPES = JAVASCRIPT_AND_CSS_URL_TYPES;
+module.exports.JAVASCRIPT_TYPE = JAVASCRIPT_TYPE;
+module.exports.JAVASCRIPT_TYPES = JAVASCRIPT_TYPES;
+module.exports.NO_TYPES = NO_TYPES;
+module.exports.REMOTE_AND_SHARE_INIT_TYPES = REMOTE_AND_SHARE_INIT_TYPES;
+module.exports.RUNTIME_TYPE = RUNTIME_TYPE;
+module.exports.RUNTIME_TYPES = RUNTIME_TYPES;
+module.exports.SHARED_INIT_TYPE = SHARED_INIT_TYPE;
+module.exports.SHARED_INIT_TYPES = SHARED_INIT_TYPES;
+module.exports.UNKNOWN_TYPE = UNKNOWN_TYPE;
+module.exports.WEBASSEMBLY_TYPE = WEBASSEMBLY_TYPE;
+module.exports.WEBASSEMBLY_TYPES = WEBASSEMBLY_TYPES;

package/lib/ModuleStoreError.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @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: ";
+		/** @type {string | undefined} */
+		const 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);
+
+		/** @type {string} */
+		this.name = "ModuleStoreError";
+		this.details = /** @type {string | undefined} */ (details);
+		this.module = module;
+		this.error = err;
+	}
+}
+
+/** @type {typeof ModuleStoreError} */
+module.exports = ModuleStoreError;

package/lib/ModuleTemplate.js

@@ -0,0 +1,173 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+const memoize = require("./util/memoize");
+
+/** @typedef {import("tapable").Tap} Tap */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ModuleRenderContext}  ModuleRenderContext */
+/** @typedef {import("./util/Hash")} Hash */
+
+/**
+ * @template T
+ * @typedef {import("tapable").IfSet<T>} IfSet
+ */
+
+const getJavascriptModulesPlugin = memoize(() =>
+	require("./javascript/JavascriptModulesPlugin")
+);
+
+// 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(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 */
+					(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(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 */
+					(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(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 */
+					(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(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 */
+					(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(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {(hash: Hash) => void} fn fn
+					 */
+					(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 {RuntimeTemplate} output options
+		 */
+		function runtimeTemplate() {
+			return this._runtimeTemplate;
+		},
+		"ModuleTemplate.runtimeTemplate is deprecated (use Compilation.runtimeTemplate instead)",
+		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
+	)
+});
+
+module.exports = ModuleTemplate;