webpack 5.51.2 → 5.54.0

package/lib/optimize/InnerGraph.js

@@ -16,7 +16,7 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {Map<TopLevelSymbol, Set<string | TopLevelSymbol> | true>} InnerGraph */
+/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
 /** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
 
 /**
@@ -75,7 +75,7 @@ exports.isEnabled = parserState => {
 
 /**
  * @param {ParserState} state parser state
- * @param {TopLevelSymbol} symbol the symbol
+ * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
  * @param {string | TopLevelSymbol | true} usage usage data
  * @returns {void}
  */
@@ -172,6 +172,26 @@ exports.inferDependencyUsage = state => {
 			}
 			if (isTerminal) {
 				nonTerminal.delete(key);
+
+				// For the global key, merge with all other keys
+				if (key === null) {
+					const globalValue = innerGraph.get(null);
+					if (globalValue) {
+						for (const [key, value] of innerGraph) {
+							if (key !== null && value !== true) {
+								if (globalValue === true) {
+									innerGraph.set(key, true);
+								} else {
+									const newSet = new Set(value);
+									for (const item of globalValue) {
+										newSet.add(item);
+									}
+									innerGraph.set(key, newSet);
+								}
+							}
+						}
+					}
+				}
 			}
 		}
 	}

package/lib/optimize/MangleExportsPlugin.js

@@ -39,13 +39,28 @@ const comparator = compareSelect(e => e.name, compareStringsNumeric);
 /**
  * @param {boolean} deterministic use deterministic names
  * @param {ExportsInfo} exportsInfo exports info
+ * @param {boolean} isNamespace is namespace object
  * @returns {void}
  */
-const mangleExportsInfo = (deterministic, exportsInfo) => {
+const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	if (!canMangle(exportsInfo)) return;
 	const usedNames = new Set();
 	/** @type {ExportInfo[]} */
 	const mangleableExports = [];
+
+	// Avoid to renamed exports that are not provided when
+	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
+	// 2. there are other provided exports and deterministic mode is chosen:
+	//    non-provided exports would break the determinism
+	let avoidMangleNonProvided = !isNamespace;
+	if (!avoidMangleNonProvided && deterministic) {
+		for (const exportInfo of exportsInfo.ownedExports) {
+			if (exportInfo.provided !== false) {
+				avoidMangleNonProvided = true;
+				break;
+			}
+		}
+	}
 	for (const exportInfo of exportsInfo.ownedExports) {
 		const name = exportInfo.name;
 		if (!exportInfo.hasUsedName()) {
@@ -59,7 +74,7 @@ const mangleExportsInfo = (deterministic, exportsInfo) => {
 					name.length === 2 &&
 					/^[a-zA-Z_$][a-zA-Z0-9_$]|^[1-9][0-9]/.test(name)) ||
 				// Don't rename exports that are not provided
-				exportInfo.provided !== true
+				(avoidMangleNonProvided && exportInfo.provided !== true)
 			) {
 				exportInfo.setUsedName(name);
 				usedNames.add(name);
@@ -73,7 +88,7 @@ const mangleExportsInfo = (deterministic, exportsInfo) => {
 				used === UsageState.OnlyPropertiesUsed ||
 				used === UsageState.Unused
 			) {
-				mangleExportsInfo(deterministic, exportInfo.exportsInfo);
+				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
 			}
 		}
 	}
@@ -143,8 +158,10 @@ class MangleExportsPlugin {
 				"MangleExportsPlugin",
 				modules => {
 					for (const module of modules) {
+						const isNamespace =
+							module.buildMeta && module.buildMeta.exportsType === "namespace";
 						const exportsInfo = moduleGraph.getExportsInfo(module);
-						mangleExportsInfo(deterministic, exportsInfo);
+						mangleExportsInfo(deterministic, exportsInfo, isNamespace);
 					}
 				}
 			);

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -366,7 +366,8 @@ class ModuleConcatenationPlugin {
 								rootModule,
 								modules,
 								concatConfiguration.runtime,
-								compiler.root
+								compiler.root,
+								compilation.outputOptions.hashFunction
 							);
 
 							const build = () => {

package/lib/runtime/RelativeUrlRuntimeModule.js

@@ -30,7 +30,7 @@ class RelativeUrlRuntimeModule extends HelperRuntimeModule {
 				`values.toString = values.toJSON = ${runtimeTemplate.returningFunction(
 					"url"
 				)};`,
-				"for (var key in values) Object.defineProperty(this, key, Object.assign({ enumerable: true, configurable: true, value: values[key] }));"
+				"for (var key in values) Object.defineProperty(this, key, { enumerable: true, configurable: true, value: values[key] });"
 			]),
 			"};",
 			`${RuntimeGlobals.relativeUrl}.prototype = URL.prototype;`

package/lib/schemes/HttpUriPlugin.js

@@ -311,8 +311,7 @@ class HttpUriPlugin {
 						: lockfileLocation + ".data";
 				const upgrade = this._upgrade || false;
 				const frozen = this._frozen || false;
-				const hashFunction =
-					this._hashFunction || compilation.outputOptions.hashFunction;
+				const hashFunction = this._hashFunction || "sha512";
 				const hashDigest =
 					this._hashDigest || compilation.outputOptions.hashDigest;
 				const hashDigestLength =

package/lib/serialization/BinaryMiddleware.js

@@ -299,12 +299,21 @@ class BinaryMiddleware extends SerializerMiddleware {
 						writeU8(STRING_HEADER);
 						writeU32(len);
 						currentBuffer.write(thing, currentPosition);
-					} else {
+						currentPosition += len;
+					} else if (len >= 70) {
 						allocate(len + HEADER_SIZE);
 						writeU8(SHORT_STRING_HEADER | len);
+
 						currentBuffer.write(thing, currentPosition, "latin1");
+						currentPosition += len;
+					} else {
+						allocate(len + HEADER_SIZE);
+						writeU8(SHORT_STRING_HEADER | len);
+
+						for (let i = 0; i < len; i++) {
+							currentBuffer[currentPosition++] = thing.charCodeAt(i);
+						}
 					}
-					currentPosition += len;
 					break;
 				}
 				case "number": {

package/lib/serialization/FileMiddleware.js

@@ -18,6 +18,7 @@ const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
+/** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 
@@ -39,8 +40,14 @@ Section -> Buffer
 
 // "wpc" + 1 in little-endian
 const VERSION = 0x01637077;
-const hashForName = buffers => {
-	const hash = createHash("md4");
+
+/**
+ * @param {Buffer[]} buffers buffers
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
+ */
+const hashForName = (buffers, hashFunction) => {
+	const hash = createHash(hashFunction);
 	for (const buf of buffers) hash.update(buf);
 	return /** @type {string} */ (hash.digest("hex"));
 };
@@ -81,9 +88,16 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
  * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
  * @param {string | boolean} name file base name
  * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
+ * @param {string | Hash} hashFunction hash function to use
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
-const serialize = async (middleware, data, name, writeFile) => {
+const serialize = async (
+	middleware,
+	data,
+	name,
+	writeFile,
+	hashFunction = "md4"
+) => {
 	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
 	const processedData = [];
 	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
@@ -118,7 +132,8 @@ const serialize = async (middleware, data, name, writeFile) => {
 							middleware,
 							content,
 							(options && options.name) || true,
-							writeFile
+							writeFile,
+							hashFunction
 						).then(result => {
 							/** @type {any} */ (item).options.size = result.size;
 							resultToLazy.set(result, item);
@@ -195,7 +210,7 @@ const serialize = async (middleware, data, name, writeFile) => {
 		}
 	}
 	if (name === true) {
-		name = hashForName(buf);
+		name = hashForName(buf, hashFunction);
 	}
 	backgroundJobs.push(writeFile(name, buf));
 	let size = 0;
@@ -386,10 +401,12 @@ const deserialize = async (middleware, name, readFile) => {
 class FileMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {IntermediateFileSystem} fs filesystem
+	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	constructor(fs) {
+	constructor(fs, hashFunction = "md4") {
 		super();
 		this.fs = fs;
+		this._hashFunction = hashFunction;
 	}
 	/**
 	 * @param {DeserializedType} data data
@@ -446,7 +463,7 @@ class FileMiddleware extends SerializerMiddleware {
 				};
 
 				resolve(
-					serialize(this, data, false, writeFile).then(
+					serialize(this, data, false, writeFile, this._hashFunction).then(
 						async ({ backgroundJob }) => {
 							await backgroundJob;
 

package/lib/serialization/ObjectMiddleware.js

@@ -15,6 +15,7 @@ const RegExpObjectSerializer = require("./RegExpObjectSerializer");
 const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
+/** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
@@ -76,8 +77,13 @@ const setMapSize = (map, size) => {
 	}
 };
 
-const toHash = buffer => {
-	const hash = createHash("md4");
+/**
+ * @param {Buffer} buffer buffer
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
+ */
+const toHash = (buffer, hashFunction) => {
+	const hash = createHash(hashFunction);
 	hash.update(buffer);
 	return /** @type {string} */ (hash.digest("latin1"));
 };
@@ -149,9 +155,14 @@ const loaders = new Map();
  * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
-	constructor(extendContext) {
+	/**
+	 * @param {function(any): void} extendContext context extensions
+	 * @param {string | Hash} hashFunction hash function to use
+	 */
+	constructor(extendContext, hashFunction = "md4") {
 		super();
 		this.extendContext = extendContext;
+		this._hashFunction = hashFunction;
 	}
 	/**
 	 * @param {RegExp} regExp RegExp for which the request is tested
@@ -275,11 +286,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 					bufferDedupeMap.set(len, [entry, buf]);
 					return buf;
 				} else {
-					const hash = toHash(entry);
+					const hash = toHash(entry, this._hashFunction);
 					const newMap = new Map();
 					newMap.set(hash, entry);
 					bufferDedupeMap.set(len, newMap);
-					const hashBuf = toHash(buf);
+					const hashBuf = toHash(buf, this._hashFunction);
 					if (hash === hashBuf) {
 						return entry;
 					}
@@ -296,10 +307,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					return buf;
 				} else {
 					const newMap = new Map();
-					const hash = toHash(buf);
+					const hash = toHash(buf, this._hashFunction);
 					let found;
 					for (const item of entry) {
-						const itemHash = toHash(item);
+						const itemHash = toHash(item, this._hashFunction);
 						newMap.set(itemHash, item);
 						if (found === undefined && itemHash === hash) found = item;
 					}
@@ -312,7 +323,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 				}
 			} else {
-				const hash = toHash(buf);
+				const hash = toHash(buf, this._hashFunction);
 				const item = entry.get(hash);
 				if (item !== undefined) {
 					return item;
@@ -510,11 +521,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 				} else if (SerializerMiddleware.isLazy(item, this)) {
 					throw new Error("Not implemented");
 				} else {
-					result.push(
-						SerializerMiddleware.serializeLazy(item, data =>
-							this.serialize([data], context)
-						)
+					const data = SerializerMiddleware.serializeLazy(item, data =>
+						this.serialize([data], context)
 					);
+					SerializerMiddleware.setLazySerializedValue(item, data);
+					result.push(data);
 				}
 			} else if (item === undefined) {
 				result.push(ESCAPE, ESCAPE_UNDEFINED);

package/lib/util/createHash.js

@@ -125,6 +125,8 @@ class DebugHash extends Hash {
 }
 
 let crypto = undefined;
+let createXXHash64 = undefined;
+let BatchedHash = undefined;
 
 /**
  * Creates a hash by name or function
@@ -139,6 +141,14 @@ module.exports = algorithm => {
 		// TODO add non-cryptographic algorithm here
 		case "debug":
 			return new DebugHash();
+		case "xxhash64":
+			if (createXXHash64 === undefined) {
+				createXXHash64 = require("./hash/xxhash64");
+				if (BatchedHash === undefined) {
+					BatchedHash = require("./hash/BatchedHash");
+				}
+			}
+			return new BatchedHash(createXXHash64());
 		default:
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(

package/lib/util/hash/BatchedHash.js

@@ -0,0 +1,65 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Hash = require("../Hash");
+
+const MAX_STRING_LENGTH = 21845;
+
+class BatchedHash extends Hash {
+	constructor(hash) {
+		super();
+		this.string = undefined;
+		this.encoding = undefined;
+		this.hash = hash;
+	}
+
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		if (this.string !== undefined) {
+			if (
+				typeof data === "string" &&
+				inputEncoding === this.encoding &&
+				this.string.length + data.length < MAX_STRING_LENGTH
+			) {
+				this.string += data;
+				return this;
+			}
+			this.hash.update(this.string, this.encoding);
+			this.string = undefined;
+		}
+		if (typeof data === "string") {
+			if (data.length < MAX_STRING_LENGTH) {
+				this.string = data;
+				this.encoding = inputEncoding;
+			} else {
+				this.hash.update(data, inputEncoding);
+			}
+		} else {
+			this.hash.update(data);
+		}
+		return this;
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		if (this.string !== undefined) {
+			this.hash.update(this.string, this.encoding);
+		}
+		return this.hash.digest(encoding);
+	}
+}
+
+module.exports = BatchedHash;

package/lib/util/hash/xxhash64.js

@@ -0,0 +1,154 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
+const xxhash64 = new WebAssembly.Module(
+	Buffer.from(
+		// 1180 bytes
+		"AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrwIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLsgYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEACfyACIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGoLIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAiACQh2IhUL5893xmfaZqxZ+IgIgAkIgiIUiAjcDAEEAIAJCIIgiA0L//wODQiCGIANCgID8/w+DQhCIhCIDQv+BgIDwH4NCEIYgA0KA/oOAgOA/g0IIiIQiA0KPgLyA8IHAB4NCCIYgA0LwgcCHgJ6A+ACDQgSIhCIDQoaMmLDgwIGDBnxCBIhCgYKEiJCgwIABg0InfiADQrDgwIGDhoyYMIR8NwMAQQggAkL/////D4MiAkL//wODQiCGIAJCgID8/w+DQhCIhCICQv+BgIDwH4NCEIYgAkKA/oOAgOA/g0IIiIQiAkKPgLyA8IHAB4NCCIYgAkLwgcCHgJ6A+ACDQgSIhCICQoaMmLDgwIGDBnxCBIhCgYKEiJCgwIABg0InfiACQrDgwIGDhoyYMIR8NwMACw==",
+		"base64"
+	)
+);
+//#endregion
+
+class XxHash64 {
+	/**
+	 * @param {WebAssembly.Instance} instance wasm instance
+	 */
+	constructor(instance) {
+		const exports = /** @type {any} */ (instance.exports);
+		exports.init();
+		this.exports = exports;
+		this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+		this.buffered = 0;
+	}
+
+	reset() {
+		this.buffered = 0;
+		this.exports.init();
+	}
+
+	/**
+	 * @param {Buffer | string} data data
+	 * @param {BufferEncoding=} encoding encoding
+	 * @returns {this} itself
+	 */
+	update(data, encoding) {
+		if (typeof data === "string") {
+			if (data.length < 21845) {
+				this._updateWithShortString(data, encoding);
+				return this;
+			} else {
+				data = Buffer.from(data, encoding);
+			}
+		}
+		this._updateWithBuffer(data);
+		return this;
+	}
+
+	/**
+	 * @param {string} data data
+	 * @param {BufferEncoding=} encoding encoding
+	 * @returns {void}
+	 */
+	_updateWithShortString(data, encoding) {
+		const { exports, buffered, mem } = this;
+		let endPos;
+		if (data.length < 70) {
+			if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					if (cc < 0x80) mem[endPos++] = cc;
+					else if (cc < 0x800) {
+						mem[endPos] = (cc >> 6) | 0xc0;
+						mem[endPos + 1] = (cc & 0x3f) | 0x80;
+						endPos += 2;
+					} else {
+						// bail-out for weird chars
+						endPos += mem.write(data.slice(endPos), endPos, encoding);
+						break;
+					}
+				}
+			} else if (encoding === "latin1") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					mem[endPos++] = cc;
+				}
+			} else {
+				endPos = buffered + mem.write(data, buffered, encoding);
+			}
+		} else {
+			endPos = buffered + mem.write(data, buffered, encoding);
+		}
+		if (endPos < 32) {
+			this.buffered = endPos;
+		} else {
+			const l = (endPos >> 5) << 5;
+			exports.update(l);
+			const newBuffered = endPos - l;
+			this.buffered = newBuffered;
+			if (newBuffered > 0) mem.copyWithin(0, l, endPos);
+		}
+	}
+
+	/**
+	 * @param {Buffer} data data
+	 * @returns {void}
+	 */
+	_updateWithBuffer(data) {
+		const { exports, buffered, mem } = this;
+		const length = data.length;
+		if (buffered + length < 32) {
+			data.copy(mem, buffered, 0, length);
+			this.buffered += length;
+		} else {
+			const l = ((buffered + length) >> 5) << 5;
+			if (l > 65536) {
+				let i = 65536 - buffered;
+				data.copy(mem, buffered, 0, i);
+				exports.update(65536);
+				const stop = l - buffered - 65536;
+				while (i < stop) {
+					data.copy(mem, 0, i, i + 65536);
+					exports.update(65536);
+					i += 65536;
+				}
+				data.copy(mem, 0, i, l - buffered);
+				exports.update(l - buffered - i);
+			} else {
+				data.copy(mem, buffered, 0, l - buffered);
+				exports.update(l);
+			}
+			const newBuffered = length + buffered - l;
+			this.buffered = newBuffered;
+			if (newBuffered > 0) data.copy(mem, 0, length - newBuffered, length);
+		}
+	}
+
+	digest(type) {
+		const { exports, buffered, mem } = this;
+		exports.final(buffered);
+		instancesPool.push(this);
+		return mem.toString("latin1", 0, 16);
+	}
+}
+
+const instancesPool = [];
+
+const create = () => {
+	if (instancesPool.length > 0) {
+		const old = instancesPool.pop();
+		old.reset();
+		return old;
+	} else {
+		return new XxHash64(new WebAssembly.Instance(xxhash64));
+	}
+};
+
+module.exports = create;

package/lib/util/internalSerializables.js

@@ -164,6 +164,7 @@ module.exports = {
 	DllModule: () => require("../DllModule"),
 	ExternalModule: () => require("../ExternalModule"),
 	FileSystemInfo: () => require("../FileSystemInfo"),
+	InitFragment: () => require("../InitFragment"),
 	InvalidDependenciesModuleWarning: () =>
 		require("../InvalidDependenciesModuleWarning"),
 	Module: () => require("../Module"),
@@ -188,6 +189,7 @@ module.exports = {
 	UnsupportedFeatureWarning: () => require("../UnsupportedFeatureWarning"),
 	"util/LazySet": () => require("../util/LazySet"),
 	UnhandledSchemeError: () => require("../UnhandledSchemeError"),
+	NodeStuffInWebError: () => require("../NodeStuffInWebError"),
 	WebpackError: () => require("../WebpackError"),
 
 	"util/registerExternalSerializer": () => {

package/lib/util/serialization.js

@@ -89,15 +89,15 @@ module.exports = {
 						);
 					};
 				}
-			}),
+			}, "md4"),
 			binaryMiddleware
 		]));
 	},
-	createFileSerializer: fs => {
+	createFileSerializer: (fs, hashFunction) => {
 		registerSerializers();
 		const Serializer = getSerializer();
 		const FileMiddleware = require("../serialization/FileMiddleware");
-		const fileMiddleware = new FileMiddleware(fs);
+		const fileMiddleware = new FileMiddleware(fs, hashFunction);
 		const binaryMiddleware = getBinaryMiddlewareInstance();
 		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
@@ -111,12 +111,16 @@ module.exports = {
 						);
 					};
 					context.writeSeparate = (value, options) => {
-						context.write(
-							SerializerMiddleware.createLazy(value, fileMiddleware, options)
+						const lazy = SerializerMiddleware.createLazy(
+							value,
+							fileMiddleware,
+							options
 						);
+						context.write(lazy);
+						return lazy;
 					};
 				}
-			}),
+			}, hashFunction),
 			binaryMiddleware,
 			fileMiddleware
 		]);