@depup/webpack 5.105.4-depup.37

package/lib/TemplatedPathPlugin.js

@@ -0,0 +1,400 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Jason Anderson @diurnalist
+*/
+
+"use strict";
+
+const { basename, extname } = require("path");
+const util = require("util");
+const mime = require("mime-types");
+const Chunk = require("./Chunk");
+const Module = require("./Module");
+const { parseResource } = require("./util/identifier");
+
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./Compiler")} Compiler */
+
+const REGEXP = /\[\\*([\w:]+)\\*\]/g;
+
+/** @type {PathData["prepareId"]} */
+const prepareId = (id) => {
+	if (typeof id !== "string") return id;
+
+	if (/^"\s\+*.*\+\s*"$/.test(id)) {
+		const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
+
+		return `" + (${
+			/** @type {string[]} */ (match)[1]
+		} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
+	}
+
+	return id.replace(/(^[.-]|[^a-z0-9_-])+/gi, "_");
+};
+
+/**
+ * @callback ReplacerFunction
+ * @param {string} match
+ * @param {string | undefined} arg
+ * @param {string} input
+ */
+
+/**
+ * @param {ReplacerFunction} replacer replacer
+ * @param {((arg0: number) => string) | undefined} handler handler
+ * @param {AssetInfo | undefined} assetInfo asset info
+ * @param {string} hashName hash name
+ * @returns {Replacer} hash replacer function
+ */
+const hashLength = (replacer, handler, assetInfo, hashName) => {
+	/** @type {Replacer} */
+	const fn = (match, arg, input) => {
+		/** @type {string} */
+		let result;
+		const length = arg && Number.parseInt(arg, 10);
+
+		if (length && handler) {
+			result = handler(length);
+		} else {
+			const hash = replacer(match, arg, input);
+
+			result = length ? hash.slice(0, length) : hash;
+		}
+		if (assetInfo) {
+			assetInfo.immutable = true;
+			if (Array.isArray(assetInfo[hashName])) {
+				assetInfo[hashName] = [...assetInfo[hashName], result];
+			} else if (assetInfo[hashName]) {
+				assetInfo[hashName] = [assetInfo[hashName], result];
+			} else {
+				assetInfo[hashName] = result;
+			}
+		}
+		return result;
+	};
+
+	return fn;
+};
+
+/** @typedef {(match: string, arg: string | undefined, input: string) => string} Replacer */
+
+/**
+ * @param {string | number | null | undefined | (() => string | number | null | undefined)} value value
+ * @param {boolean=} allowEmpty allow empty
+ * @returns {Replacer} replacer
+ */
+const replacer = (value, allowEmpty) => {
+	/** @type {Replacer} */
+	const fn = (match, arg, input) => {
+		if (typeof value === "function") {
+			value = value();
+		}
+		if (value === null || value === undefined) {
+			if (!allowEmpty) {
+				throw new Error(
+					`Path variable ${match} not implemented in this context: ${input}`
+				);
+			}
+
+			return "";
+		}
+
+		return `${value}`;
+	};
+
+	return fn;
+};
+
+/** @type {Map<string, (...args: EXPECTED_ANY[]) => EXPECTED_ANY>} */
+const deprecationCache = new Map();
+const deprecatedFunction = (() => () => {})();
+/**
+ * @template {(...args: EXPECTED_ANY[]) => EXPECTED_ANY} T
+ * @param {T} fn function
+ * @param {string} message message
+ * @param {string} code code
+ * @returns {T} function with deprecation output
+ */
+const deprecated = (fn, message, code) => {
+	let d = deprecationCache.get(message);
+	if (d === undefined) {
+		d = util.deprecate(deprecatedFunction, message, code);
+		deprecationCache.set(message, d);
+	}
+	return /** @type {T} */ (
+		(...args) => {
+			d();
+			return fn(...args);
+		}
+	);
+};
+
+/** @typedef {(pathData: PathData, assetInfo?: AssetInfo) => string} TemplatePathFn */
+/** @typedef {string | TemplatePathFn} TemplatePath */
+
+/**
+ * @param {TemplatePath} path the raw path
+ * @param {PathData} data context data
+ * @param {AssetInfo | undefined} assetInfo extra info about the asset (will be written to)
+ * @returns {string} the interpolated path
+ */
+const replacePathVariables = (path, data, assetInfo) => {
+	const chunkGraph = data.chunkGraph;
+
+	/** @type {Map<string, Replacer>} */
+	const replacements = new Map();
+
+	// Filename context
+	//
+	// Placeholders
+	//
+	// for /some/path/file.js?query#fragment:
+	// [file] - /some/path/file.js
+	// [query] - ?query
+	// [fragment] - #fragment
+	// [base] - file.js
+	// [path] - /some/path/
+	// [name] - file
+	// [ext] - .js
+	if (typeof data.filename === "string") {
+		// check that filename is data uri
+		const match = data.filename.match(/^data:([^;,]+)/);
+		if (match) {
+			const ext = mime.extension(match[1]);
+			const emptyReplacer = replacer("", true);
+			// "XXXX" used for `updateHash`, so we don't need it here
+			const contentHash =
+				data.contentHash && !/X+/.test(data.contentHash)
+					? data.contentHash
+					: false;
+			const baseReplacer = contentHash ? replacer(contentHash) : emptyReplacer;
+
+			replacements.set("file", emptyReplacer);
+			replacements.set("query", emptyReplacer);
+			replacements.set("fragment", emptyReplacer);
+			replacements.set("path", emptyReplacer);
+			replacements.set("base", baseReplacer);
+			replacements.set("name", baseReplacer);
+			replacements.set("ext", replacer(ext ? `.${ext}` : "", true));
+			// Legacy
+			replacements.set(
+				"filebase",
+				deprecated(
+					baseReplacer,
+					"[filebase] is now [base]",
+					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+				)
+			);
+		} else {
+			const { path: file, query, fragment } = parseResource(data.filename);
+
+			const ext = extname(file);
+			const base = basename(file);
+			const name = base.slice(0, base.length - ext.length);
+			const path = file.slice(0, file.length - base.length);
+
+			replacements.set("file", replacer(file));
+			replacements.set("query", replacer(query, true));
+			replacements.set("fragment", replacer(fragment, true));
+			replacements.set("path", replacer(path, true));
+			replacements.set("base", replacer(base));
+			replacements.set("name", replacer(name));
+			replacements.set("ext", replacer(ext, true));
+			// Legacy
+			replacements.set(
+				"filebase",
+				deprecated(
+					replacer(base),
+					"[filebase] is now [base]",
+					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+				)
+			);
+		}
+	}
+
+	// Compilation context
+	//
+	// Placeholders
+	//
+	// [fullhash] - data.hash (3a4b5c6e7f)
+	//
+	// Legacy Placeholders
+	//
+	// [hash] - data.hash (3a4b5c6e7f)
+	if (data.hash) {
+		const hashReplacer = hashLength(
+			replacer(data.hash),
+			data.hashWithLength,
+			assetInfo,
+			"fullhash"
+		);
+
+		replacements.set("fullhash", hashReplacer);
+
+		// Legacy
+		replacements.set(
+			"hash",
+			deprecated(
+				hashReplacer,
+				"[hash] is now [fullhash] (also consider using [chunkhash] or [contenthash], see documentation for details)",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_HASH"
+			)
+		);
+	}
+
+	// Chunk Context
+	//
+	// Placeholders
+	//
+	// [id] - chunk.id (0.js)
+	// [name] - chunk.name (app.js)
+	// [chunkhash] - chunk.hash (7823t4t4.js)
+	// [contenthash] - chunk.contentHash[type] (3256u3zg.js)
+	if (data.chunk) {
+		const chunk = data.chunk;
+
+		const contentHashType = data.contentHashType;
+
+		const idReplacer = replacer(chunk.id);
+		const nameReplacer = replacer(chunk.name || chunk.id);
+		const chunkhashReplacer = hashLength(
+			replacer(chunk instanceof Chunk ? chunk.renderedHash : chunk.hash),
+			"hashWithLength" in chunk ? chunk.hashWithLength : undefined,
+			assetInfo,
+			"chunkhash"
+		);
+		const contenthashReplacer = hashLength(
+			replacer(
+				data.contentHash ||
+					(contentHashType &&
+						chunk.contentHash &&
+						chunk.contentHash[contentHashType])
+			),
+			data.contentHashWithLength ||
+				("contentHashWithLength" in chunk && chunk.contentHashWithLength
+					? chunk.contentHashWithLength[/** @type {string} */ (contentHashType)]
+					: undefined),
+			assetInfo,
+			"contenthash"
+		);
+
+		replacements.set("id", idReplacer);
+		replacements.set("name", nameReplacer);
+		replacements.set("chunkhash", chunkhashReplacer);
+		replacements.set("contenthash", contenthashReplacer);
+	}
+
+	// Module Context
+	//
+	// Placeholders
+	//
+	// [id] - module.id (2.png)
+	// [hash] - module.hash (6237543873.png)
+	//
+	// Legacy Placeholders
+	//
+	// [moduleid] - module.id (2.png)
+	// [modulehash] - module.hash (6237543873.png)
+	if (data.module) {
+		const module = data.module;
+
+		const idReplacer = replacer(() =>
+			(data.prepareId || prepareId)(
+				module instanceof Module
+					? /** @type {ModuleId} */
+						(/** @type {ChunkGraph} */ (chunkGraph).getModuleId(module))
+					: module.id
+			)
+		);
+		const moduleHashReplacer = hashLength(
+			replacer(() =>
+				module instanceof Module
+					? /** @type {ChunkGraph} */
+						(chunkGraph).getRenderedModuleHash(module, data.runtime)
+					: module.hash
+			),
+			"hashWithLength" in module ? module.hashWithLength : undefined,
+			assetInfo,
+			"modulehash"
+		);
+		const contentHashReplacer = hashLength(
+			replacer(/** @type {string} */ (data.contentHash)),
+			undefined,
+			assetInfo,
+			"contenthash"
+		);
+
+		replacements.set("id", idReplacer);
+		replacements.set("modulehash", moduleHashReplacer);
+		replacements.set("contenthash", contentHashReplacer);
+		replacements.set(
+			"hash",
+			data.contentHash ? contentHashReplacer : moduleHashReplacer
+		);
+		// Legacy
+		replacements.set(
+			"moduleid",
+			deprecated(
+				idReplacer,
+				"[moduleid] is now [id]",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_MODULE_ID"
+			)
+		);
+	}
+
+	// Other things
+	if (data.url) {
+		replacements.set("url", replacer(data.url));
+	}
+	if (typeof data.runtime === "string") {
+		replacements.set(
+			"runtime",
+			replacer(() =>
+				(data.prepareId || prepareId)(/** @type {string} */ (data.runtime))
+			)
+		);
+	} else {
+		replacements.set("runtime", replacer("_"));
+	}
+
+	if (typeof path === "function") {
+		path = path(data, assetInfo);
+	}
+
+	path = path.replace(REGEXP, (match, content) => {
+		if (content.length + 2 === match.length) {
+			const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content);
+			if (!contentMatch) return match;
+			const [, kind, arg] = contentMatch;
+			const replacer = replacements.get(kind);
+			if (replacer !== undefined) {
+				return replacer(match, arg, /** @type {string} */ (path));
+			}
+		} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
+			return `[${match.slice(2, -2)}]`;
+		}
+		return match;
+	});
+
+	return path;
+};
+
+const plugin = "TemplatedPathPlugin";
+
+class TemplatedPathPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(plugin, (compilation) => {
+			compilation.hooks.assetPath.tap(plugin, replacePathVariables);
+		});
+	}
+}
+
+module.exports = TemplatedPathPlugin;

package/lib/UnhandledSchemeError.js

@@ -0,0 +1,34 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+const makeSerializable = require("./util/makeSerializable");
+
+class UnhandledSchemeError extends WebpackError {
+	/**
+	 * @param {string} scheme scheme
+	 * @param {string} resource resource
+	 */
+	constructor(scheme, resource) {
+		super(
+			`Reading from "${resource}" is not handled by plugins (Unhandled scheme).` +
+				'\nWebpack supports "data:" and "file:" URIs by default.' +
+				`\nYou may need an additional plugin to handle "${scheme}:" URIs.`
+		);
+		this.file = resource;
+		/** @type {string} */
+		this.name = "UnhandledSchemeError";
+	}
+}
+
+makeSerializable(
+	UnhandledSchemeError,
+	"webpack/lib/UnhandledSchemeError",
+	"UnhandledSchemeError"
+);
+
+module.exports = UnhandledSchemeError;

package/lib/UnsupportedFeatureWarning.js

@@ -0,0 +1,35 @@
+/*
+	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 */
+
+class UnsupportedFeatureWarning extends WebpackError {
+	/**
+	 * @param {string} message description of warning
+	 * @param {DependencyLocation} loc location start and end positions of the module
+	 */
+	constructor(message, loc) {
+		super(message);
+
+		/** @type {string} */
+		this.name = "UnsupportedFeatureWarning";
+		/** @type {DependencyLocation} */
+		this.loc = loc;
+		/** @type {boolean} */
+		this.hideStack = true;
+	}
+}
+
+makeSerializable(
+	UnsupportedFeatureWarning,
+	"webpack/lib/UnsupportedFeatureWarning"
+);
+
+module.exports = UnsupportedFeatureWarning;

package/lib/UseStrictPlugin.js

@@ -0,0 +1,81 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
+const ConstDependency = require("./dependencies/ConstDependency");
+
+/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "UseStrictPlugin";
+
+class UseStrictPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {JavascriptParserOptions} parserOptions the javascript parser options
+				 */
+				const handler = (parser, parserOptions) => {
+					parser.hooks.program.tap(PLUGIN_NAME, (ast) => {
+						const firstNode = ast.body[0];
+						if (
+							firstNode &&
+							firstNode.type === "ExpressionStatement" &&
+							firstNode.expression.type === "Literal" &&
+							firstNode.expression.value === "use strict"
+						) {
+							// Remove "use strict" expression. It will be added later by the renderer again.
+							// This is necessary in order to not break the strict mode when webpack prepends code.
+							// @see https://github.com/webpack/webpack/issues/1970
+							const dep = new ConstDependency(
+								"",
+								/** @type {Range} */ (firstNode.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (firstNode.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).strict = true;
+						}
+						if (parserOptions.overrideStrict) {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).strict =
+								parserOptions.overrideStrict === "strict";
+						}
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+
+module.exports = UseStrictPlugin;

package/lib/WarnCaseSensitiveModulesPlugin.js

@@ -0,0 +1,64 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const CaseSensitiveModulesWarning = require("./CaseSensitiveModulesWarning");
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule")} NormalModule */
+
+const PLUGIN_NAME = "WarnCaseSensitiveModulesPlugin";
+
+class WarnCaseSensitiveModulesPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.seal.tap(PLUGIN_NAME, () => {
+				/** @type {Map<string, Map<string, Module>>} */
+				const moduleWithoutCase = new Map();
+				for (const module of compilation.modules) {
+					const identifier = module.identifier();
+
+					// Ignore `data:` URLs, because it's not a real path
+					if (
+						/** @type {NormalModule} */
+						(module).resourceResolveData !== undefined &&
+						/** @type {NormalModule} */
+						(module).resourceResolveData.encodedContent !== undefined
+					) {
+						continue;
+					}
+
+					const lowerIdentifier = identifier.toLowerCase();
+					let map = moduleWithoutCase.get(lowerIdentifier);
+					if (map === undefined) {
+						map = new Map();
+						moduleWithoutCase.set(lowerIdentifier, map);
+					}
+					map.set(identifier, module);
+				}
+				for (const pair of moduleWithoutCase) {
+					const map = pair[1];
+					if (map.size > 1) {
+						compilation.warnings.push(
+							new CaseSensitiveModulesWarning(
+								map.values(),
+								compilation.moduleGraph
+							)
+						);
+					}
+				}
+			});
+		});
+	}
+}
+
+module.exports = WarnCaseSensitiveModulesPlugin;

package/lib/WarnDeprecatedOptionPlugin.js

@@ -0,0 +1,60 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("./Compiler")} Compiler */
+
+const PLUGIN_NAME = "WarnDeprecatedOptionPlugin";
+
+class WarnDeprecatedOptionPlugin {
+	/**
+	 * Create an instance of the plugin
+	 * @param {string} option the target option
+	 * @param {string | number} value the deprecated option value
+	 * @param {string} suggestion the suggestion replacement
+	 */
+	constructor(option, value, suggestion) {
+		this.option = option;
+		this.value = value;
+		this.suggestion = suggestion;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.warnings.push(
+				new DeprecatedOptionWarning(this.option, this.value, this.suggestion)
+			);
+		});
+	}
+}
+
+class DeprecatedOptionWarning extends WebpackError {
+	/**
+	 * Create an instance deprecated option warning
+	 * @param {string} option the target option
+	 * @param {string | number} value the deprecated option value
+	 * @param {string} suggestion the suggestion replacement
+	 */
+	constructor(option, value, suggestion) {
+		super();
+
+		/** @type {string} */
+		this.name = "DeprecatedOptionWarning";
+		this.message =
+			"configuration\n" +
+			`The value '${value}' for option '${option}' is deprecated. ` +
+			`Use '${suggestion}' instead.`;
+	}
+}
+
+module.exports = WarnDeprecatedOptionPlugin;

package/lib/WarnNoModeSetPlugin.js

@@ -0,0 +1,27 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const NoModeWarning = require("./NoModeWarning");
+
+/** @typedef {import("./Compiler")} Compiler */
+
+const PLUGIN_NAME = "WarnNoModeSetPlugin";
+
+class WarnNoModeSetPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.warnings.push(new NoModeWarning());
+		});
+	}
+}
+
+module.exports = WarnNoModeSetPlugin;