webpack 5.53.0 → 5.54.0

package/lib/FlagDependencyExportsPlugin.js

@@ -28,12 +28,14 @@ class FlagDependencyExportsPlugin {
 			compilation => {
 				const moduleGraph = compilation.moduleGraph;
 				const cache = compilation.getCache("FlagDependencyExportsPlugin");
+				const { moduleMemCaches } = compilation;
 				compilation.hooks.finishModules.tapAsync(
 					"FlagDependencyExportsPlugin",
 					(modules, callback) => {
 						const logger = compilation.getLogger(
 							"webpack.FlagDependencyExportsPlugin"
 						);
+						let statRestoredFromMemCache = 0;
 						let statRestoredFromCache = 0;
 						let statNoExports = 0;
 						let statFlaggedUncached = 0;
@@ -58,16 +60,22 @@ class FlagDependencyExportsPlugin {
 										return callback();
 									}
 								}
-								if (
-									module.buildInfo.cacheable !== true ||
-									typeof module.buildInfo.hash !== "string"
-								) {
+								if (typeof module.buildInfo.hash !== "string") {
 									statFlaggedUncached++;
 									// Enqueue uncacheable module for determining the exports
 									queue.enqueue(module);
 									exportsInfo.setHasProvideInfo();
 									return callback();
 								}
+								const memCache = moduleMemCaches && moduleMemCaches.get(module);
+								const memCacheValue = memCache && memCache.get(this, module);
+								if (memCacheValue !== undefined) {
+									statRestoredFromMemCache++;
+									moduleGraph
+										.getExportsInfo(module)
+										.restoreProvided(memCacheValue);
+									return callback();
+								}
 								cache.get(
 									module.identifier(),
 									module.buildInfo.hash,
@@ -94,7 +102,9 @@ class FlagDependencyExportsPlugin {
 								if (err) return callback(err);
 
 								/** @type {Set<Module>} */
-								const modulesToStore = new Set();
+								const modulesToStorePersistent = new Set();
+								/** @type {Set<Module>} */
+								const modulesToStoreTransient = new Set();
 
 								/** @type {Map<Module, Set<Module>>} */
 								const dependencies = new Map();
@@ -328,7 +338,9 @@ class FlagDependencyExportsPlugin {
 									}
 
 									if (cacheable) {
-										modulesToStore.add(module);
+										modulesToStorePersistent.add(module);
+									} else {
+										modulesToStoreTransient.add(module);
 									}
 
 									if (changed) {
@@ -340,11 +352,12 @@ class FlagDependencyExportsPlugin {
 								logger.log(
 									`${Math.round(
 										(100 * (statFlaggedUncached + statNotCached)) /
-											(statRestoredFromCache +
+											(statRestoredFromMemCache +
+												statRestoredFromCache +
 												statNotCached +
 												statFlaggedUncached +
 												statNoExports)
-									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${
+									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${
 										statQueueItemsProcessed -
 										statNotCached -
 										statFlaggedUncached
@@ -353,26 +366,40 @@ class FlagDependencyExportsPlugin {
 
 								logger.time("store provided exports into cache");
 								asyncLib.each(
-									modulesToStore,
+									modulesToStorePersistent,
 									(module, callback) => {
-										if (
-											module.buildInfo.cacheable !== true ||
-											typeof module.buildInfo.hash !== "string"
-										) {
+										if (typeof module.buildInfo.hash !== "string") {
 											// not cacheable
 											return callback();
 										}
+										const cachedData = moduleGraph
+											.getExportsInfo(module)
+											.getRestoreProvidedData();
+										const memCache =
+											moduleMemCaches && moduleMemCaches.get(module);
+										if (memCache) {
+											memCache.set(this, module, cachedData);
+										}
 										cache.store(
 											module.identifier(),
 											module.buildInfo.hash,
-											moduleGraph
-												.getExportsInfo(module)
-												.getRestoreProvidedData(),
+											cachedData,
 											callback
 										);
 									},
 									err => {
 										logger.timeEnd("store provided exports into cache");
+										if (moduleMemCaches) {
+											for (const module of modulesToStoreTransient) {
+												const memCache = moduleMemCaches.get(module);
+												if (memCache) {
+													const cachedData = moduleGraph
+														.getExportsInfo(module)
+														.getRestoreProvidedData();
+													memCache.set(this, module, cachedData);
+												}
+											}
+										}
 										callback(err);
 									}
 								);

package/lib/JavascriptMetaInfoPlugin.js

@@ -28,7 +28,12 @@ class JavascriptMetaInfoPlugin {
 					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
 						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
 						parser.state.module.buildInfo.usingEval = true;
-						InnerGraph.bailout(parser.state);
+						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
+						if (currentSymbol) {
+							InnerGraph.addUsage(parser.state, null, currentSymbol);
+						} else {
+							InnerGraph.bailout(parser.state);
+						}
 					});
 					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
 						let topLevelDeclarations =

package/lib/MemCache.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WeakTupleMap = require("./util/WeakTupleMap");
+
+class MemCache {
+	constructor() {
+		this._cache = new WeakTupleMap();
+	}
+
+	/**
+	 * @template {any[]} T
+	 * @template V
+	 * @param {T} args arguments
+	 * @returns {V | undefined} cached value
+	 */
+	get(...args) {
+		return this._cache.get(...args);
+	}
+
+	/**
+	 * @template {[...any[], any]} T
+	 * @param {T} args arguments
+	 * @returns {void}
+	 */
+	set(...args) {
+		this._cache.set(...args);
+	}
+
+	/**
+	 * @template {[...any[], (...args: any[]) => V]} T
+	 * @template V
+	 * @param {T} args arguments
+	 * @returns {V} computed value or cached
+	 */
+	provide(...args) {
+		return this._cache.provide(...args);
+	}
+}
+
+module.exports = MemCache;

package/lib/ModuleFilenameHelpers.js

@@ -8,6 +8,11 @@
 const createHash = require("./util/createHash");
 const memoize = require("./util/memoize");
 
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {typeof import("./util/Hash")} Hash */
+
 const ModuleFilenameHelpers = exports;
 
 // TODO webpack 6: consider removing these
@@ -53,9 +58,9 @@ const getBefore = (strFn, token) => {
 	};
 };
 
-const getHash = strFn => {
+const getHash = (strFn, hashFunction) => {
 	return () => {
-		const hash = createHash("md4");
+		const hash = createHash(hashFunction);
 		hash.update(strFn());
 		const digest = /** @type {string} */ (hash.digest("hex"));
 		return digest.substr(0, 4);
@@ -91,10 +96,20 @@ const lazyObject = obj => {
 
 const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
 
+/**
+ *
+ * @param {Module | string} module the module
+ * @param {TODO} options options
+ * @param {Object} contextInfo context info
+ * @param {RequestShortener} contextInfo.requestShortener requestShortener
+ * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
+ * @param {string | Hash} contextInfo.hashFunction the hash function to use
+ * @returns {string} the filename
+ */
 ModuleFilenameHelpers.createFilename = (
-	module,
+	module = "",
 	options,
-	{ requestShortener, chunkGraph }
+	{ requestShortener, chunkGraph, hashFunction = "md4" }
 ) => {
 	const opts = {
 		namespace: "",
@@ -111,13 +126,12 @@ ModuleFilenameHelpers.createFilename = (
 	let identifier;
 	let moduleId;
 	let shortIdentifier;
-	if (module === undefined) module = "";
 	if (typeof module === "string") {
 		shortIdentifier = memoize(() => requestShortener.shorten(module));
 		identifier = shortIdentifier;
 		moduleId = () => "";
 		absoluteResourcePath = () => module.split("!").pop();
-		hash = getHash(identifier);
+		hash = getHash(identifier, hashFunction);
 	} else {
 		shortIdentifier = memoize(() =>
 			module.readableIdentifier(requestShortener)
@@ -125,7 +139,7 @@ ModuleFilenameHelpers.createFilename = (
 		identifier = memoize(() => requestShortener.shorten(module.identifier()));
 		moduleId = () => chunkGraph.getModuleId(module);
 		absoluteResourcePath = () => module.identifier().split("!").pop();
-		hash = getHash(identifier);
+		hash = getHash(identifier, hashFunction);
 	}
 	const resource = memoize(() => shortIdentifier().split("!").pop());
 

package/lib/SourceMapDevToolPlugin.js

@@ -297,7 +297,8 @@ class SourceMapDevToolPlugin {
 													},
 													{
 														requestShortener,
-														chunkGraph
+														chunkGraph,
+														hashFunction: compilation.outputOptions.hashFunction
 													}
 												)
 											);
@@ -358,7 +359,8 @@ class SourceMapDevToolPlugin {
 									},
 									{
 										requestShortener,
-										chunkGraph
+										chunkGraph,
+										hashFunction: compilation.outputOptions.hashFunction
 									}
 								);
 								hasName = usedNamesSet.has(sourceName);
@@ -442,7 +444,9 @@ class SourceMapDevToolPlugin {
 										const sourceMapContentHash =
 											usesContentHash &&
 											/** @type {string} */ (
-												createHash("md4").update(sourceMapString).digest("hex")
+												createHash(compilation.outputOptions.hashFunction)
+													.update(sourceMapString)
+													.digest("hex")
 											);
 										const pathParams = {
 											chunk,

package/lib/WebpackOptionsApply.js

@@ -431,7 +431,9 @@ class WebpackOptionsApply extends OptionsApply {
 						"hashed",
 						"deterministic"
 					).apply(compiler);
-					new HashedModuleIdsPlugin().apply(compiler);
+					new HashedModuleIdsPlugin({
+						hashFunction: options.output.hashFunction
+					}).apply(compiler);
 					break;
 				}
 				case "deterministic": {
@@ -542,6 +544,14 @@ class WebpackOptionsApply extends OptionsApply {
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
 						new MemoryCachePlugin().apply(compiler);
 					}
+					if (cacheOptions.cacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new WeakMap();
+					}
 					break;
 				}
 				case "filesystem": {
@@ -561,6 +571,14 @@ class WebpackOptionsApply extends OptionsApply {
 							maxGenerations: cacheOptions.maxMemoryGenerations
 						}).apply(compiler);
 					}
+					if (cacheOptions.memoryCacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new WeakMap();
+					}
 					switch (cacheOptions.store) {
 						case "pack": {
 							const IdleFileCachePlugin = require("./cache/IdleFileCachePlugin");

package/lib/cache/PackFileCacheStrategy.js

@@ -995,7 +995,8 @@ class PackFileCacheStrategy {
 		this.fileSystemInfo = new FileSystemInfo(fs, {
 			managedPaths: snapshot.managedPaths,
 			immutablePaths: snapshot.immutablePaths,
-			logger: logger.getChildLogger("webpack.FileSystemInfo")
+			logger: logger.getChildLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
 		});
 		this.compiler = compiler;
 		this.context = context;

package/lib/cache/getLazyHashedEtag.js

@@ -8,6 +8,7 @@
 const createHash = require("../util/createHash");
 
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
 
 /**
  * @typedef {Object} HashableObject
@@ -17,10 +18,12 @@ const createHash = require("../util/createHash");
 class LazyHashedEtag {
 	/**
 	 * @param {HashableObject} obj object with updateHash method
+	 * @param {string | HashConstructor} hashFunction the hash function to use
 	 */
-	constructor(obj) {
+	constructor(obj, hashFunction = "md4") {
 		this._obj = obj;
 		this._hash = undefined;
+		this._hashFunction = hashFunction;
 	}
 
 	/**
@@ -28,7 +31,7 @@ class LazyHashedEtag {
 	 */
 	toString() {
 		if (this._hash === undefined) {
-			const hash = createHash("md4");
+			const hash = createHash(this._hashFunction);
 			this._obj.updateHash(hash);
 			this._hash = /** @type {string} */ (hash.digest("base64"));
 		}
@@ -36,18 +39,42 @@ class LazyHashedEtag {
 	}
 }
 
-/** @type {WeakMap<HashableObject, LazyHashedEtag>} */
-const map = new WeakMap();
+/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapStrings = new Map();
+
+/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapObjects = new WeakMap();
 
 /**
  * @param {HashableObject} obj object with updateHash method
+ * @param {string | HashConstructor} hashFunction the hash function to use
  * @returns {LazyHashedEtag} etag
  */
-const getter = obj => {
-	const hash = map.get(obj);
+const getter = (obj, hashFunction = "md4") => {
+	let innerMap;
+	if (typeof hashFunction === "string") {
+		innerMap = mapStrings.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapStrings.set(hashFunction, innerMap);
+			return newHash;
+		}
+	} else {
+		innerMap = mapObjects.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapObjects.set(hashFunction, innerMap);
+			return newHash;
+		}
+	}
+	const hash = innerMap.get(obj);
 	if (hash !== undefined) return hash;
-	const newHash = new LazyHashedEtag(obj);
-	map.set(obj, newHash);
+	const newHash = new LazyHashedEtag(obj, hashFunction);
+	innerMap.set(obj, newHash);
 	return newHash;
 };
 

package/lib/config/defaults.js

@@ -159,20 +159,21 @@ const applyWebpackOptionsDefaults = options => {
 	D(options, "recordsInputPath", false);
 	D(options, "recordsOutputPath", false);
 
+	applyExperimentsDefaults(options.experiments, { production, development });
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
 	applyCacheDefaults(options.cache, {
 		name: name || "default",
 		mode: mode || "production",
-		development
+		development,
+		cacheUnaffected: options.experiments.cacheUnaffected
 	});
 	const cache = !!options.cache;
 
 	applySnapshotDefaults(options.snapshot, { production });
 
-	applyExperimentsDefaults(options.experiments, { production, development });
-
 	applyModuleDefaults(options.module, {
 		cache,
 		syncWebAssembly: options.experiments.syncWebAssembly,
@@ -190,7 +191,8 @@ const applyWebpackOptionsDefaults = options => {
 		outputModule: options.experiments.outputModule,
 		development,
 		entry: options.entry,
-		module: options.module
+		module: options.module,
+		futureDefaults: options.experiments.futureDefaults
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -266,6 +268,7 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
 	D(experiments, "lazyCompilation", false);
 	D(experiments, "buildHttp", false);
 	D(experiments, "futureDefaults", false);
+	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
@@ -279,9 +282,13 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
  * @param {string} options.name name
  * @param {string} options.mode mode
  * @param {boolean} options.development is development mode
+ * @param {boolean} options.cacheUnaffected the cacheUnaffected experiment is enabled
  * @returns {void}
  */
-const applyCacheDefaults = (cache, { name, mode, development }) => {
+const applyCacheDefaults = (
+	cache,
+	{ name, mode, development, cacheUnaffected }
+) => {
 	if (cache === false) return;
 	switch (cache.type) {
 		case "filesystem":
@@ -325,12 +332,14 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
 			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
 			D(cache, "allowCollectingMemory", development);
+			D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
 			D(cache.buildDependencies, "defaultWebpack", [
 				path.resolve(__dirname, "..") + path.sep
 			]);
 			break;
 		case "memory":
 			D(cache, "maxGenerations", Infinity);
+			D(cache, "cacheUnaffected", development && cacheUnaffected);
 			break;
 	}
 };
@@ -580,6 +589,7 @@ const applyModuleDefaults = (
  * @param {boolean} options.development is development mode
  * @param {Entry} options.entry entry option
  * @param {ModuleOptions} options.module module option
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
 const applyOutputDefaults = (
@@ -591,7 +601,8 @@ const applyOutputDefaults = (
 		outputModule,
 		development,
 		entry,
-		module
+		module,
+		futureDefaults
 	}
 ) => {
 	/**
@@ -788,7 +799,7 @@ const applyOutputDefaults = (
 			: ""
 	);
 	D(output, "chunkLoadTimeout", 120000);
-	D(output, "hashFunction", "md4");
+	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
 	D(output, "hashDigest", "hex");
 	D(output, "hashDigestLength", 20);
 	D(output, "strictModuleExceptionHandling", false);

package/lib/dependencies/CachedConstDependency.js

@@ -27,6 +27,7 @@ class CachedConstDependency extends NullDependency {
 		this.expression = expression;
 		this.range = range;
 		this.identifier = identifier;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -36,9 +37,9 @@ class CachedConstDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.identifier + "");
-		hash.update(this.range + "");
-		hash.update(this.expression + "");
+		if (this._hashUpdate === undefined)
+			this._hashUpdate = "" + this.identifier + this.range + this.expression;
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

package/lib/dependencies/ConstDependency.js

@@ -30,6 +30,7 @@ class ConstDependency extends NullDependency {
 		this.runtimeRequirements = runtimeRequirements
 			? new Set(runtimeRequirements)
 			: null;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -39,10 +40,17 @@ class ConstDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.range + "");
-		hash.update(this.expression + "");
-		if (this.runtimeRequirements)
-			hash.update(Array.from(this.runtimeRequirements).join() + "");
+		if (this._hashUpdate === undefined) {
+			let hashUpdate = "" + this.range + "|" + this.expression;
+			if (this.runtimeRequirements) {
+				for (const item of this.runtimeRequirements) {
+					hashUpdate += "|";
+					hashUpdate += item;
+				}
+			}
+			this._hashUpdate = hashUpdate;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	/**

package/lib/dependencies/JsonExportsDependency.js

@@ -47,6 +47,7 @@ class JsonExportsDependency extends NullDependency {
 	constructor(exports) {
 		super();
 		this.exports = exports;
+		this._hashUpdate = undefined;
 	}
 
 	get type() {
@@ -72,7 +73,12 @@ class JsonExportsDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.exports ? JSON.stringify(this.exports) : "undefined");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.exports
+				? JSON.stringify(this.exports)
+				: "undefined";
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -30,6 +30,7 @@ class ModuleDecoratorDependency extends NullDependency {
 		super();
 		this.decorator = decorator;
 		this.allowExportsAccess = allowExportsAccess;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -69,8 +70,10 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.decorator);
-		hash.update(`${this.allowExportsAccess}`);
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

package/lib/dependencies/ProvidedDependency.js

@@ -34,6 +34,7 @@ class ProvidedDependency extends ModuleDependency {
 		this.identifier = identifier;
 		this.path = path;
 		this.range = range;
+		this._hashUpdate = undefined;
 	}
 
 	get type() {
@@ -51,8 +52,11 @@ class ProvidedDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.identifier);
-		hash.update(this.path ? this.path.join(",") : "null");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate =
+				this.identifier + (this.path ? this.path.join(",") : "null");
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

package/lib/dependencies/PureExpressionDependency.js

@@ -28,6 +28,7 @@ class PureExpressionDependency extends NullDependency {
 		this.range = range;
 		/** @type {Set<string> | false} */
 		this.usedByExports = false;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -37,7 +38,10 @@ class PureExpressionDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.range + "");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.range + "";
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	/**

package/lib/dependencies/RuntimeRequirementsDependency.js

@@ -23,6 +23,7 @@ class RuntimeRequirementsDependency extends NullDependency {
 	constructor(runtimeRequirements) {
 		super();
 		this.runtimeRequirements = new Set(runtimeRequirements);
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -32,7 +33,10 @@ class RuntimeRequirementsDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(Array.from(this.runtimeRequirements).join() + "");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {