webpack 5.110.2 → 5.110.3

package/lib/dependencies/RequireHeaderDependency.js

@@ -76,30 +76,29 @@ RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends
 		{ moduleGraph, runtime, runtimeRequirements, concatenationScope }
 	) {
 		const dep = /** @type {RequireHeaderDependency} */ (dependency);
-
-		// the paired require dependency already replaced the whole call
-		if (
-			concatenationScope !== undefined &&
-			concatenationScope.isInsideReplacedRequire(dep.range[0])
-		) {
-			return;
-		}
-
 		const requireDep = dep.requireDependency;
-		// Skip when the paired call became `0`; dead-branch still needs the header.
 		if (requireDep) {
 			const connection = moduleGraph.getConnection(requireDep);
-			if (
-				connection &&
-				!connection.isTargetActive(runtime) &&
-				requireDep.isEvaluationOnly()
-			) {
-				const guards = requireDep.branchGuards;
-				if (
-					guards === undefined ||
-					!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
-				) {
-					return;
+			if (connection) {
+				if (connection.isTargetActive(runtime)) {
+					if (
+						concatenationScope !== undefined &&
+						requireDep.rendersAsConcatenatedReference(
+							connection,
+							concatenationScope
+						)
+					) {
+						return;
+					}
+				} else if (requireDep.isEvaluationOnly()) {
+					// Skip when the paired call became `0`; dead-branch still needs the header.
+					const guards = requireDep.branchGuards;
+					if (
+						guards === undefined ||
+						!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+					) {
+						return;
+					}
 				}
 			}
 		}

package/lib/dependencies/importOptionsCheck.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const Template = require("../Template");
+
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+
+/**
+ * Wraps an import so its arguments evaluate in source order and the options are
+ * checked, rejecting rather than throwing. The last parameter holds them.
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {string[]} parameters parameter names, the options one last
+ * @param {string} content the import expression to return once the check passes
+ * @returns {string} the wrapping function
+ */
+const importOptionsCheck = (runtimeTemplate, parameters, content) => {
+	const options = parameters[parameters.length - 1];
+	return runtimeTemplate.basicFunction(parameters.join(", "), [
+		"try {",
+		Template.indent([
+			`if (${options} !== undefined) {`,
+			Template.indent([
+				`if ((typeof ${options} !== "object" && typeof ${options} !== "function") || ${options} === null) throw new TypeError("The second argument to import() must be an object");`,
+				`var a = ${options}["with"];`,
+				"if (a !== undefined) {",
+				Template.indent([
+					'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
+					"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
+					Template.indent([
+						'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
+					]),
+					"}"
+				]),
+				"}"
+			]),
+			"}"
+		]),
+		"} catch (e) { return Promise.reject(e); }",
+		`return ${content};`
+	]);
+};
+
+module.exports = importOptionsCheck;

package/lib/errors/DotenvFileError.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * Error for a dotenv file that exists but could not be read. An absent file is
+ * normal and reported through `missingDependencies` instead.
+ */
+class DotenvFileError extends WebpackError {
+	/**
+	 * @param {string} file path of the dotenv file
+	 * @param {Error} error underlying file system error
+	 */
+	constructor(file, error) {
+		super(`Unable to read the dotenv file ${file}\n${error.message}`);
+
+		this.name = "DotenvFileError";
+		/** @type {string} */
+		this.file = file;
+		this.error = error;
+	}
+}
+
+module.exports = DotenvFileError;

package/lib/errors/ImportedBindingAssignmentError.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
+
+class ImportedBindingAssignmentError extends WebpackError {
+	/**
+	 * Creates an instance of ImportedBindingAssignmentError.
+	 * @param {string} name the local name of the namespace binding
+	 */
+	constructor(name) {
+		super(
+			`Assignment to the imported binding '${name}'. A namespace import is immutable, so this throws a TypeError where the module is a real ES module.`
+		);
+
+		this.name = "ImportedBindingAssignmentError";
+	}
+}
+
+makeSerializable(
+	ImportedBindingAssignmentError,
+	"webpack/lib/errors/ImportedBindingAssignmentError"
+);
+
+module.exports = ImportedBindingAssignmentError;

package/lib/html/HtmlModulesPlugin.js

@@ -241,7 +241,12 @@ const collectHtmlEntryRequests = (name, entries) => {
 	const seenRequests = new Set();
 	/** @type {Set<string>} */
 	const visited = new Set();
-	const walk = (/** @type {string} */ entryName) => {
+	/**
+	 * Collects an entry's non-html requests, `dependOn` entries included.
+	 * @param {string} entryName entry to walk
+	 * @returns {void}
+	 */
+	const walk = (entryName) => {
 		if (visited.has(entryName)) return;
 		visited.add(entryName);
 		const desc = entries[entryName];
@@ -613,12 +618,13 @@ class HtmlModulesPlugin {
 					);
 				}
 				const { htmlModules } = getState(compilation);
-				// Record HTML modules as they appear — freshly built
-				// (`succeedModule`) or restored from cache (`stillValidModule`) —
-				// so `finishMake` creates their entries without scanning every
-				// module in the graph. Tracking only records; entries are still
-				// added (and awaited) in `finishMake`.
-				const trackHtmlModule = (/** @type {import("../Module")} */ module) => {
+				/**
+				 * Records HTML modules as they are built or restored, so `finishMake`
+				 * creates their entries without scanning the whole module graph.
+				 * @param {import("../Module")} module built or restored module
+				 * @returns {void}
+				 */
+				const trackHtmlModule = (module) => {
 					if (module.type !== HTML_MODULE_TYPE) return;
 					// enabled here, not on the compilation hook: an integrity build
 					// with no html module must not load the generator
@@ -981,15 +987,15 @@ class HtmlModulesPlugin {
 				/** @type {WeakMap<import("webpack-sources").Source, { resolvedContent: string, contentHash: string }>} */
 				const resolvedSentinelHashCache = new WeakMap();
 
-				// Compute a linked/entry HTML page's emitted filename + chunk-URL-resolved
-				// content + content hash for one (module, chunk). Shared by the emit loop
-				// below and the page-link resolver. The content hash covers only the
-				// chunk-URL-resolved source — links to *other* pages stay sentinels here,
-				// so a page's filename doesn't depend on the filenames of pages it links to.
-				const computePageEmit = (
-					/** @type {NormalModule} */ module,
-					/** @type {import("../Chunk")} */ chunk
-				) => {
+				/**
+				 * Computes an HTML page's emitted filename, chunk-URL-resolved content and
+				 * content hash. Links to other pages stay sentinels, so a page's filename
+				 * never depends on the filenames of the pages it links to.
+				 * @param {NormalModule} module the page's html module
+				 * @param {import("../Chunk")} chunk chunk the page is emitted from
+				 * @returns {{ resolvedContent: string, contentHash: string, filename: string, info: import("../Compilation").AssetInfo } | undefined} the page's emit, or `undefined` when it generates no html
+				 */
+				const computePageEmit = (module, chunk) => {
 					const { chunkGraph, outputOptions } = compilation;
 					const codeGenResult =
 						/** @type {import("../CodeGenerationResults")} */ (
@@ -1066,14 +1072,15 @@ class HtmlModulesPlugin {
 					};
 				};
 
-				// Emitted filename of a linked `type: "html"` page, keyed by its entry
-				// name. Looked up from the page's own entry chunk so it's independent of
-				// chunk render order; cached for the compilation.
 				/** @type {Map<string, string>} */
 				const htmlPageFilenameCache = new Map();
-				const computePageFilenameByEntry = (
-					/** @type {string} */ entryName
-				) => {
+				/**
+				 * Emitted filename of a linked `type: "html"` page, read from the page's
+				 * own entry chunk so chunk render order cannot affect it.
+				 * @param {string} entryName entry name of the linked page
+				 * @returns {string} the page's emitted filename, `"data:,"` when it has none
+				 */
+				const computePageFilenameByEntry = (entryName) => {
 					const cached = htmlPageFilenameCache.get(entryName);
 					if (cached !== undefined) return cached;
 					let filename = "data:,";