webpack 5.107.2 → 5.108.0

package/lib/ExternalModule.js

@@ -65,8 +65,8 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined]>} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -148,18 +148,36 @@ const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
 /**
  * Gets external module node commonjs init fragment.
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean=} universal target may also run outside node (e.g. `["node", "web"]`)
  * @returns {InitFragment<ChunkRenderContext>} code
  */
-const getExternalModuleNodeCommonjsInitFragment = (runtimeTemplate) => {
+const getExternalModuleNodeCommonjsInitFragment = (
+	runtimeTemplate,
+	universal = false
+) => {
 	const importMetaName = runtimeTemplate.outputOptions.importMetaName;
+	const moduleId = runtimeTemplate.renderNodePrefixForCoreModule("module");
+
+	if (!universal) {
+		return new InitFragment(
+			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${moduleId};\n${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = __WEBPACK_EXTERNAL_createRequire(${importMetaName}.url);\n`,
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			"external module node-commonjs"
+		);
+	}
+
+	// defensively obtain `createRequire` so the universal bundle still loads off node
+	const content = `${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = ${runtimeTemplate.getBuiltinModule(
+		moduleId,
+		`.createRequire(${importMetaName}.url)`
+	)};\n`;
 
 	return new InitFragment(
-		`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${runtimeTemplate.renderNodePrefixForCoreModule(
-			"module"
-		)};\n${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = __WEBPACK_EXTERNAL_createRequire(${importMetaName}.url);\n`,
+		content,
 		InitFragment.STAGE_HARMONY_IMPORTS,
 		0,
-		"external module node-commonjs"
+		"external module node-commonjs universal"
 	);
 };
 
@@ -167,14 +185,16 @@ const getExternalModuleNodeCommonjsInitFragment = (runtimeTemplate) => {
  * Gets source for common js external in node module.
  * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean=} universal target may also run outside node (e.g. `["node", "web"]`)
  * @returns {SourceData} the generated source
  */
 const getSourceForCommonJsExternalInNodeModule = (
 	moduleAndSpecifiers,
-	runtimeTemplate
+	runtimeTemplate,
+	universal = false
 ) => {
 	const chunkInitFragments = [
-		getExternalModuleNodeCommonjsInitFragment(runtimeTemplate)
+		getExternalModuleNodeCommonjsInitFragment(runtimeTemplate, universal)
 	];
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
@@ -310,10 +330,15 @@ class ModuleExternalInitFragment extends InitFragment {
 				imported === true ? imported : imported.join(" ")
 			}`
 		);
+		/** @type {string} */
 		this._ident = ident;
+		/** @type {string} */
 		this._request = request;
+		/** @type {ImportDependencyMeta | undefined} */
 		this._dependencyMeta = dependencyMeta;
+		/** @type {string} */
 		this._identifier = this.buildIdentifier(ident);
+		/** @type {Imported} */
 		this._imported = this.buildImported(imported);
 	}
 
@@ -562,10 +587,10 @@ const getSourceForModuleExternal = (
 	return {
 		expression,
 		init: moduleRemapping
-			? `var x = ${runtimeTemplate.basicFunction(
+			? `${runtimeTemplate.renderConst()} x = ${runtimeTemplate.basicFunction(
 					"y",
-					`var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x`
-				)} \nvar y = ${runtimeTemplate.returningFunction(
+					`${runtimeTemplate.renderConst()} x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x`
+				)} \n${runtimeTemplate.renderConst()} y = ${runtimeTemplate.returningFunction(
 					runtimeTemplate.returningFunction("x"),
 					"x"
 				)}`
@@ -593,7 +618,7 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 	const url = urlAndGlobal[0];
 	const globalName = urlAndGlobal[1];
 	return {
-		init: "var __webpack_error__ = new Error();",
+		init: `${runtimeTemplate.renderConst()} __webpack_error__ = new Error();`,
 		expression: `new Promise(${runtimeTemplate.basicFunction(
 			"resolve, reject",
 			[
@@ -602,8 +627,8 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 					url
 				)}, ${runtimeTemplate.basicFunction("event", [
 					`if(typeof ${globalName} !== "undefined") return resolve();`,
-					"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-					"var realSrc = event && event.target && event.target.src;",
+					`${runtimeTemplate.renderConst()} errorType = event && (event.type === 'load' ? 'missing' : event.type);`,
+					`${runtimeTemplate.renderConst()} realSrc = event && event.target && event.target.src;`,
 					"__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
 					"__webpack_error__.name = 'ScriptExternalLoadError';",
 					"__webpack_error__.type = errorType;",
@@ -694,6 +719,14 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 /** @type {WeakMap<Compilation, ExternalModuleHooks>} */
 const compilationHooksMap = new WeakMap();
 
+/**
+ * Defines the build info properties specific to external modules.
+ * @typedef {object} KnownExternalModuleBuildInfo
+ * @property {boolean=} javascriptModule true when emitting an ESM external (`output.module`)
+ */
+
+/** @typedef {BuildInfo & KnownExternalModuleBuildInfo} ExternalModuleBuildInfo */
+
 class ExternalModule extends Module {
 	/**
 	 * Creates an instance of ExternalModule.
@@ -705,6 +738,10 @@ class ExternalModule extends Module {
 	constructor(request, type, userRequest, dependencyMeta) {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
+		// Redeclared with the external module specific shape
+		/** @type {ExternalModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+
 		// Info from Factory
 		/** @type {ExternalModuleRequest} */
 		this.request = request;
@@ -1019,11 +1056,22 @@ class ExternalModule extends Module {
 			case "commonjs2":
 			case "commonjs-module":
 			case "commonjs-static":
-				return getSourceForCommonJsExternal(request);
-			case "node-commonjs":
-				return /** @type {BuildInfo} */ (this.buildInfo).javascriptModule
-					? getSourceForCommonJsExternalInNodeModule(request, runtimeTemplate)
-					: getSourceForCommonJsExternal(request);
+			case "node-commonjs": {
+				const { node } = runtimeTemplate.compilation.options.externalsPresets;
+				// ESM has no `require`; load via `createRequire` when the target is node
+				const createRequireInModule =
+					/** @type {BuildInfo} */ (this.buildInfo).javascriptModule &&
+					(externalType === "node-commonjs" || Boolean(node));
+				if (!createRequireInModule) {
+					return getSourceForCommonJsExternal(request);
+				}
+				// for a universal target (e.g. `["node", "web"]`) load defensively so the browser doesn't crash
+				return getSourceForCommonJsExternalInNodeModule(
+					request,
+					runtimeTemplate,
+					runtimeTemplate.isUniversalTarget()
+				);
+			}
 			case "amd":
 			case "amd-require":
 			case "umd":
@@ -1271,12 +1319,11 @@ class ExternalModule extends Module {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.request);
-		write(this.externalType);
-		write(this.userRequest);
-		write(this.dependencyMeta);
+		context
+			.write(this.request)
+			.write(this.externalType)
+			.write(this.userRequest)
+			.write(this.dependencyMeta);
 
 		super.serialize(context);
 	}
@@ -1286,14 +1333,15 @@ class ExternalModule extends Module {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.request = read();
-		this.externalType = read();
-		this.userRequest = read();
-		this.dependencyMeta = read();
-
-		super.deserialize(context);
+		this.request = context.read();
+		const c1 = context.rest;
+		this.externalType = c1.read();
+		const c2 = c1.rest;
+		this.userRequest = c2.read();
+		const c3 = c2.rest;
+		this.dependencyMeta = c3.read();
+
+		super.deserialize(c3.rest);
 	}
 }
 

package/lib/ExternalModuleFactoryPlugin.js

@@ -110,6 +110,7 @@ class ExternalModuleFactoryPlugin {
 	 */
 	constructor(type, externals) {
 		this.type = type;
+		/** @type {Externals} */
 		this.externals = externals;
 	}
 

package/lib/ExternalsPlugin.js

@@ -25,6 +25,7 @@ class ExternalsPlugin {
 	 */
 	constructor(type, externals) {
 		this.type = type;
+		/** @type {Externals} */
 		this.externals = externals;
 	}
 

package/lib/FileSystemInfo.js

@@ -201,7 +201,9 @@ class SnapshotIterable {
 	 * @param {GetMapsFunction<T>} getMaps get maps function
 	 */
 	constructor(snapshot, getMaps) {
+		/** @type {Snapshot} */
 		this.snapshot = snapshot;
+		/** @type {GetMapsFunction<T>} */
 		this.getMaps = getMaps;
 	}
 
@@ -297,6 +299,7 @@ class SnapshotIterable {
 
 class Snapshot {
 	constructor() {
+		/** @type {number} */
 		this._flags = 0;
 		/** @type {Iterable<string> | undefined} */
 		this._cachedFileIterable = undefined;
@@ -672,14 +675,19 @@ class SnapshotOptimization {
 		this._has = has;
 		this._get = get;
 		this._set = set;
+		/** @type {boolean} */
 		this._useStartTime = useStartTime;
 		/** @type {U} */
 		this._isSet = isSet;
 		/** @type {Map<string, SnapshotOptimizationEntry>} */
 		this._map = new Map();
+		/** @type {number} */
 		this._statItemsShared = 0;
+		/** @type {number} */
 		this._statItemsUnshared = 0;
+		/** @type {number} */
 		this._statSharedSnapshots = 0;
+		/** @type {number} */
 		this._statReusedSharedSnapshots = 0;
 	}
 
@@ -929,16 +937,120 @@ class SnapshotOptimization {
 	}
 }
 
+/** @type {Record<string, string>} */
+const ESCAPES = {
+	n: "\n",
+	r: "\r",
+	t: "\t",
+	b: "\b",
+	f: "\f",
+	v: "\v"
+};
+
 /**
- * Returns result.
- * @param {string} str input
- * @returns {string} result
+ * Cooks a JS string/template literal specifier into its evaluated value,
+ * matching ECMAScript escape semantics (sloppy-mode for string literals).
+ * @param {string} str input including the surrounding quotes
+ * @returns {string | null} result, or null when not a quoted literal
+ * @throws {Error} on a malformed escape sequence, like the JS parser would
  */
 const parseString = (str) => {
-	if (str[0] === "'" || str[0] === "`") {
-		str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`;
+	const q = str[0];
+
+	if (q !== '"' && q !== "'" && q !== "`") {
+		return null;
 	}
-	return JSON.parse(str);
+
+	const template = q === "`";
+	const inner = str.slice(1, -1);
+	const len = inner.length;
+	let result = "";
+	let i = 0;
+
+	while (i < len) {
+		const ch = inner[i];
+		if (ch !== "\\") {
+			// Template value normalizes raw <CR> and <CRLF> to <LF>
+			if (template && ch === "\r") {
+				result += "\n";
+				i += inner[i + 1] === "\n" ? 2 : 1;
+			} else {
+				result += ch;
+				i++;
+			}
+			continue;
+		}
+
+		i++;
+		if (i >= len) throw new Error("Unterminated escape sequence");
+		const esc = inner[i];
+
+		if (esc === "x") {
+			const hex = inner.slice(i + 1, i + 3);
+			if (!/^[0-9a-fA-F]{2}$/.test(hex)) {
+				throw new Error("Invalid hexadecimal escape sequence");
+			}
+			result += String.fromCharCode(Number.parseInt(hex, 16));
+			i += 3;
+		} else if (esc === "u") {
+			if (inner[i + 1] === "{") {
+				// \u{N...}
+				const closeIdx = inner.indexOf("}", i + 2);
+				const codeStr = closeIdx === -1 ? "" : inner.slice(i + 2, closeIdx);
+				const code = Number.parseInt(codeStr, 16);
+				if (!/^[0-9a-fA-F]+$/.test(codeStr) || code > 0x10ffff) {
+					throw new Error("Invalid Unicode escape sequence");
+				}
+				result += String.fromCodePoint(code);
+				i = closeIdx + 1;
+			} else {
+				// \uNNNN
+				const hex = inner.slice(i + 1, i + 5);
+				if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+					throw new Error("Invalid Unicode escape sequence");
+				}
+				result += String.fromCharCode(Number.parseInt(hex, 16));
+				i += 5;
+			}
+		} else if (esc === "\r") {
+			// Line continuation: \<CR> or \<CRLF>
+			i += inner[i + 1] === "\n" ? 2 : 1;
+		} else if (esc === "\n" || esc === "\u2028" || esc === "\u2029") {
+			// Line continuation: \<LF>, \<LS>, \<PS>
+			i++;
+		} else if (ESCAPES[esc] !== undefined) {
+			result += ESCAPES[esc];
+			i++;
+		} else if (esc >= "0" && esc <= "7") {
+			// \0 not followed by a digit is NUL, otherwise a legacy octal escape
+			const next = inner[i + 1];
+			if (esc === "0" && !(next >= "0" && next <= "9")) {
+				result += "\0";
+				i++;
+				continue;
+			}
+			if (template) throw new Error("Octal escape not allowed in template");
+			// Up to 3 octal digits, value capped at \377
+			let oct = esc;
+			i++;
+			const max = esc <= "3" ? 3 : 2;
+			while (oct.length < max && inner[i] >= "0" && inner[i] <= "7") {
+				oct += inner[i];
+				i++;
+			}
+			result += String.fromCharCode(Number.parseInt(oct, 8));
+		} else if (esc === "8" || esc === "9") {
+			if (template) throw new Error("\\8 and \\9 not allowed in template");
+			result += esc;
+			i++;
+		} else {
+			// \', \", \\, \`, and any other NonEscapeCharacter — the char itself
+			result += esc;
+			i++;
+		}
+	}
+
+	return result;
 };
 
 /* istanbul ignore next */
@@ -1157,52 +1269,63 @@ class FileSystemInfo {
 			hashFunction = DEFAULTS.HASH_FUNCTION
 		} = {}
 	) {
+		/** @type {InputFileSystem} */
 		this.fs = fs;
 		this.logger = logger;
+		/** @type {number} */
 		this._remainingLogs = logger ? 40 : 0;
 		/** @type {LoggedPaths | undefined} */
 		this._loggedPaths = logger ? new Set() : undefined;
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 		/** @type {WeakMap<Snapshot, boolean | CheckSnapshotValidCallback[]>} */
 		this._snapshotCache = new WeakMap();
+		/** @type {SnapshotOptimization<FileSystemInfoEntry | null, false>} */
 		this._fileTimestampsOptimization = new SnapshotOptimization(
 			(s) => s.hasFileTimestamps(),
 			(s) => s.fileTimestamps,
 			(s, v) => s.setFileTimestamps(v)
 		);
+		/** @type {SnapshotOptimization<string | null, false>} */
 		this._fileHashesOptimization = new SnapshotOptimization(
 			(s) => s.hasFileHashes(),
 			(s) => s.fileHashes,
 			(s, v) => s.setFileHashes(v),
 			false
 		);
+		/** @type {SnapshotOptimization<string | TimestampAndHash | null, false>} */
 		this._fileTshsOptimization = new SnapshotOptimization(
 			(s) => s.hasFileTshs(),
 			(s) => s.fileTshs,
 			(s, v) => s.setFileTshs(v)
 		);
+		/** @type {SnapshotOptimization<ResolvedContextFileSystemInfoEntry | null, false>} */
 		this._contextTimestampsOptimization = new SnapshotOptimization(
 			(s) => s.hasContextTimestamps(),
 			(s) => s.contextTimestamps,
 			(s, v) => s.setContextTimestamps(v)
 		);
+		/** @type {SnapshotOptimization<string | null, false>} */
 		this._contextHashesOptimization = new SnapshotOptimization(
 			(s) => s.hasContextHashes(),
 			(s) => s.contextHashes,
 			(s, v) => s.setContextHashes(v),
 			false
 		);
+		/** @type {SnapshotOptimization<ResolvedContextTimestampAndHash | null, false>} */
 		this._contextTshsOptimization = new SnapshotOptimization(
 			(s) => s.hasContextTshs(),
 			(s) => s.contextTshs,
 			(s, v) => s.setContextTshs(v)
 		);
+		/** @type {SnapshotOptimization<boolean, false>} */
 		this._missingExistenceOptimization = new SnapshotOptimization(
 			(s) => s.hasMissingExistence(),
 			(s) => s.missingExistence,
 			(s, v) => s.setMissingExistence(v),
 			false
 		);
+		/** @type {SnapshotOptimization<string, false>} */
 		this._managedItemInfoOptimization = new SnapshotOptimization(
 			(s) => s.hasManagedItemInfo(),
 			(s) => s.managedItemInfo,
@@ -1316,16 +1439,25 @@ class FileSystemInfo {
 			(p) => typeof p !== "string"
 		);
 
+		/** @type {Map<string, number | null> | undefined} */
 		this._cachedDeprecatedFileTimestamps = undefined;
+		/** @type {Map<string, number | null> | undefined} */
 		this._cachedDeprecatedContextTimestamps = undefined;
 
+		/** @type {boolean} */
 		this._warnAboutExperimentalEsmTracking = false;
 
+		/** @type {number} */
 		this._statCreatedSnapshots = 0;
+		/** @type {number} */
 		this._statTestedSnapshotsCached = 0;
+		/** @type {number} */
 		this._statTestedSnapshotsNotCached = 0;
+		/** @type {number} */
 		this._statTestedChildrenCached = 0;
+		/** @type {number} */
 		this._statTestedChildrenNotCached = 0;
+		/** @type {number} */
 		this._statTestedEntries = 0;
 	}
 
@@ -2084,19 +2216,17 @@ class FileSystemInfo {
 										const added = new Set();
 										for (const imp of imports) {
 											try {
-												/** @type {string} */
-												let dependency;
-												if (imp.d === -1) {
-													// import ... from "..."
-													dependency = parseString(
-														source.slice(imp.s - 1, imp.e + 1)
-													);
-												} else if (imp.d > -1) {
-													// import()
-													const expr = source.slice(imp.s, imp.e).trim();
-													dependency = parseString(expr);
-												} else {
-													// e.g. import.meta
+												// import.meta
+												if (imp.d === -2) {
+													continue;
+												}
+
+												/** @type {string | null} */
+												const dependency =
+													imp.n ||
+													parseString(source.slice(imp.s, imp.e).trim());
+
+												if (!dependency) {
 													continue;
 												}
 
@@ -3411,7 +3541,6 @@ class FileSystemInfo {
 							if (
 								!checkContext(
 									path,
-									// TODO: test with `"ignore"`
 									/** @type {ResolvedContextFileSystemInfoEntry | null} */
 									(entry),
 									tsh,
@@ -3875,6 +4004,8 @@ class FileSystemInfo {
 		/** @type {string[]} */
 		const hashes = [];
 		let safeTime = 0;
+		// Skip already-visited symlink targets so cyclic pnpm/peer-variant graphs terminate (#21084).
+		const seen = new Set(entry.symlinks);
 		processAsyncTree(
 			/** @type {NonNullable<ContextHash["symlinks"]>} */ (entry.symlinks),
 			10,
@@ -3887,7 +4018,12 @@ class FileSystemInfo {
 							safeTime = Math.max(safeTime, entry.safeTime);
 						}
 						if (entry.symlinks !== undefined) {
-							for (const target of entry.symlinks) push(target);
+							for (const target of entry.symlinks) {
+								if (!seen.has(target)) {
+									seen.add(target);
+									push(target);
+								}
+							}
 						}
 					}
 					callback();
@@ -3997,6 +4133,8 @@ class FileSystemInfo {
 	_resolveContextHash(entry, callback) {
 		/** @type {string[]} */
 		const hashes = [];
+		// Skip already-visited symlink targets so cyclic pnpm/peer-variant graphs terminate (#21084).
+		const seen = new Set(entry.symlinks);
 		processAsyncTree(
 			/** @type {NonNullable<ContextHash["symlinks"]>} */ (entry.symlinks),
 			10,
@@ -4006,7 +4144,12 @@ class FileSystemInfo {
 					if (hash) {
 						hashes.push(hash.hash);
 						if (hash.symlinks !== undefined) {
-							for (const target of hash.symlinks) push(target);
+							for (const target of hash.symlinks) {
+								if (!seen.has(target)) {
+									seen.add(target);
+									push(target);
+								}
+							}
 						}
 					}
 					callback();
@@ -4170,6 +4313,8 @@ class FileSystemInfo {
 		/** @type {string[]} */
 		const tsHashes = [];
 		let safeTime = 0;
+		// Skip already-visited symlink targets so cyclic pnpm/peer-variant graphs terminate (#21084).
+		const seen = new Set(entry.symlinks);
 		processAsyncTree(
 			/** @type {NonNullable<ContextHash["symlinks"]>} */ (entry.symlinks),
 			10,
@@ -4183,7 +4328,12 @@ class FileSystemInfo {
 							safeTime = Math.max(safeTime, entry.safeTime);
 						}
 						if (entry.symlinks !== undefined) {
-							for (const target of entry.symlinks) push(target);
+							for (const target of entry.symlinks) {
+								if (!seen.has(target)) {
+									seen.add(target);
+									push(target);
+								}
+							}
 						}
 					}
 					callback();

package/lib/FlagAllModulesAsUsedPlugin.js

@@ -18,6 +18,7 @@ class FlagAllModulesAsUsedPlugin {
 	 * @param {string} explanation explanation
 	 */
 	constructor(explanation) {
+		/** @type {string} */
 		this.explanation = explanation;
 	}
 
@@ -42,11 +43,6 @@ class FlagAllModulesAsUsedPlugin {
 					const exportsInfo = moduleGraph.getExportsInfo(module);
 					exportsInfo.setUsedInUnknownWay(runtime);
 					moduleGraph.addExtraReason(module, this.explanation);
-					if (module.factoryMeta === undefined) {
-						module.factoryMeta = {};
-					}
-					/** @type {FactoryMeta} */
-					(module.factoryMeta).sideEffectFree = false;
 				}
 			});
 		});

package/lib/FlagDependencyExportsPlugin.js

@@ -166,6 +166,7 @@ class FlagDependencyExportsPlugin {
 								const globalPriority = exportDesc.priority;
 								const globalTerminalBinding =
 									exportDesc.terminalBinding || false;
+								const globalPure = exportDesc.isPure || false;
 								const exportDeps = exportDesc.dependencies;
 								if (exportDesc.hideExports) {
 									for (const name of exportDesc.hideExports) {
@@ -198,6 +199,7 @@ class FlagDependencyExportsPlugin {
 											let name;
 											let canMangle = globalCanMangle;
 											let terminalBinding = globalTerminalBinding;
+											let pure = globalPure;
 											/** @type {ExportSpec["exports"]} */
 											let exports;
 											let from = globalFrom;
@@ -205,6 +207,8 @@ class FlagDependencyExportsPlugin {
 											let fromExport;
 											let priority = globalPriority;
 											let hidden = false;
+											/** @type {ExportSpec["inlined"]} */
+											let inlined;
 											if (typeof exportNameOrSpec === "string") {
 												name = exportNameOrSpec;
 											} else {
@@ -227,9 +231,15 @@ class FlagDependencyExportsPlugin {
 												if (exportNameOrSpec.terminalBinding !== undefined) {
 													terminalBinding = exportNameOrSpec.terminalBinding;
 												}
+												if (exportNameOrSpec.isPure !== undefined) {
+													pure = exportNameOrSpec.isPure;
+												}
 												if (exportNameOrSpec.hidden !== undefined) {
 													hidden = exportNameOrSpec.hidden;
 												}
+												if (exportNameOrSpec.inlined !== undefined) {
+													inlined = exportNameOrSpec.inlined;
+												}
 											}
 											const exportInfo = exportsInfo.getExportInfo(name);
 
@@ -249,11 +259,24 @@ class FlagDependencyExportsPlugin {
 												changed = true;
 											}
 
+											if (
+												inlined !== undefined &&
+												exportInfo.canInlineProvide === undefined
+											) {
+												exportInfo.canInlineProvide = inlined;
+												changed = true;
+											}
+
 											if (terminalBinding && !exportInfo.terminalBinding) {
 												exportInfo.terminalBinding = true;
 												changed = true;
 											}
 
+											if (pure && exportInfo.pureProvide !== true) {
+												exportInfo.pureProvide = true;
+												changed = true;
+											}
+
 											if (exports) {
 												const nestedExportsInfo =
 													exportInfo.createNestedExportsInfo();