webpack 5.90.3 → 5.91.0

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -23,6 +23,7 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -49,6 +50,9 @@ const formatBailoutReason = msg => {
 };
 
 class ModuleConcatenationPlugin {
+	/**
+	 * @param {TODO} options options
+	 */
 	constructor(options) {
 		if (typeof options !== "object") options = {};
 		this.options = options;
@@ -171,7 +175,7 @@ class ModuleConcatenationPlugin {
 						}
 
 						// Must be in strict mode
-						if (!module.buildInfo.strict) {
+						if (!(/** @type {BuildInfo} */ (module.buildInfo).strict)) {
 							setBailoutReason(module, `Module is not in strict mode`);
 							continue;
 						}
@@ -242,7 +246,10 @@ class ModuleConcatenationPlugin {
 					// this improves performance, because modules already selected as inner are skipped
 					logger.time("sort relevant modules");
 					relevantModules.sort((a, b) => {
-						return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
+						return (
+							/** @type {number} */ (moduleGraph.getDepth(a)) -
+							/** @type {number} */ (moduleGraph.getDepth(b))
+						);
 					});
 					logger.timeEnd("sort relevant modules");
 
@@ -927,6 +934,9 @@ class ConcatConfiguration {
 		return this.modules.size;
 	}
 
+	/**
+	 * @param {number} snapshot snapshot
+	 */
 	rollback(snapshot) {
 		const modules = this.modules;
 		for (const m of modules) {

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -77,6 +77,7 @@ class RemoveParentModulesPlugin {
 
 				let nextModuleMask = ONE_BIGINT;
 				const maskByModule = new WeakMap();
+				/** @type {Module[]} */
 				const ordinalModules = [];
 
 				/**

package/lib/optimize/RuntimeChunkPlugin.js

@@ -10,6 +10,9 @@
 /** @typedef {import("../Entrypoint")} Entrypoint */
 
 class RuntimeChunkPlugin {
+	/**
+	 * @param {{ name?: (entrypoint: { name: string }) => string }} options options
+	 */
 	constructor(options) {
 		this.options = {
 			/**
@@ -37,7 +40,9 @@ class RuntimeChunkPlugin {
 						(compilation.entries.get(entryName));
 					if (data.options.runtime === undefined && !data.options.dependOn) {
 						// Determine runtime chunk name
-						let name = this.options.name;
+						let name =
+							/** @type {string | ((entrypoint: { name: string }) => string)} */
+							(this.options.name);
 						if (typeof name === "function") {
 							name = name({ name: entryName });
 						}

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -20,8 +20,11 @@ const formatLocation = require("../formatLocation");
 /** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 /**
  * @typedef {Object} ExportInModule
@@ -36,7 +39,9 @@ const formatLocation = require("../formatLocation");
  * @property {Map<Module, Set<string>>} dynamic
  */
 
-/** @type {WeakMap<any, Map<string, RegExp>>} */
+/** @typedef {Map<string, RegExp>} CacheItem */
+
+/** @type {WeakMap<any, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
 /**
@@ -96,7 +101,7 @@ class SideEffectsFlagPlugin {
 							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
 								resolveData.relativePath,
 								sideEffects,
-								cache
+								/** @type {CacheItem} */ (cache)
 							);
 							module.factoryMeta.sideEffectFree = !hasSideEffects;
 						}
@@ -132,7 +137,10 @@ class SideEffectsFlagPlugin {
 								switch (statement.type) {
 									case "ExpressionStatement":
 										if (
-											!parser.isPure(statement.expression, statement.range[0])
+											!parser.isPure(
+												statement.expression,
+												/** @type {Range} */ (statement.range)[0]
+											)
 										) {
 											sideEffectsStatement = statement;
 										}
@@ -140,27 +148,35 @@ class SideEffectsFlagPlugin {
 									case "IfStatement":
 									case "WhileStatement":
 									case "DoWhileStatement":
-										if (!parser.isPure(statement.test, statement.range[0])) {
+										if (
+											!parser.isPure(
+												statement.test,
+												/** @type {Range} */ (statement.range)[0]
+											)
+										) {
 											sideEffectsStatement = statement;
 										}
 										// statement hook will be called for child statements too
 										break;
 									case "ForStatement":
 										if (
-											!parser.isPure(statement.init, statement.range[0]) ||
+											!parser.isPure(
+												statement.init,
+												/** @type {Range} */ (statement.range)[0]
+											) ||
 											!parser.isPure(
 												statement.test,
 												statement.init
-													? statement.init.range[1]
-													: statement.range[0]
+													? /** @type {Range} */ (statement.init.range)[1]
+													: /** @type {Range} */ (statement.range)[0]
 											) ||
 											!parser.isPure(
 												statement.update,
 												statement.test
-													? statement.test.range[1]
+													? /** @type {Range} */ (statement.test.range)[1]
 													: statement.init
-														? statement.init.range[1]
-														: statement.range[0]
+														? /** @type {Range} */ (statement.init.range)[1]
+														: /** @type {Range} */ (statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -169,7 +185,10 @@ class SideEffectsFlagPlugin {
 										break;
 									case "SwitchStatement":
 										if (
-											!parser.isPure(statement.discriminant, statement.range[0])
+											!parser.isPure(
+												statement.discriminant,
+												/** @type {Range} */ (statement.range)[0]
+											)
 										) {
 											sideEffectsStatement = statement;
 										}
@@ -178,14 +197,22 @@ class SideEffectsFlagPlugin {
 									case "VariableDeclaration":
 									case "ClassDeclaration":
 									case "FunctionDeclaration":
-										if (!parser.isPure(statement, statement.range[0])) {
+										if (
+											!parser.isPure(
+												statement,
+												/** @type {Range} */ (statement.range)[0]
+											)
+										) {
 											sideEffectsStatement = statement;
 										}
 										break;
 									case "ExportNamedDeclaration":
 									case "ExportDefaultDeclaration":
 										if (
-											!parser.isPure(statement.declaration, statement.range[0])
+											!parser.isPure(
+												statement.declaration,
+												/** @type {Range} */ (statement.range)[0]
+											)
 										) {
 											sideEffectsStatement = statement;
 										}
@@ -208,7 +235,8 @@ class SideEffectsFlagPlugin {
 						);
 						parser.hooks.finish.tap(PLUGIN_NAME, () => {
 							if (sideEffectsStatement === undefined) {
-								parser.state.module.buildMeta.sideEffectFree = true;
+								/** @type {BuildMeta} */
+								(parser.state.module.buildMeta).sideEffectFree = true;
 							} else {
 								const { loc, type } = sideEffectsStatement;
 								moduleGraph
@@ -216,7 +244,7 @@ class SideEffectsFlagPlugin {
 									.push(
 										() =>
 											`Statement (${type}) with side effects in source code at ${formatLocation(
-												loc
+												/** @type {DependencyLocation} */ (loc)
 											)}`
 									);
 							}
@@ -246,6 +274,9 @@ class SideEffectsFlagPlugin {
 
 						const optimizedModules = new Set();
 
+						/**
+						 * @param {Module} module module
+						 */
 						const optimizeIncomingConnections = module => {
 							if (optimizedModules.has(module)) return;
 							optimizedModules.add(module);

package/lib/optimize/SplitChunksPlugin.js

@@ -160,7 +160,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {string} name
  * @property {Record<string, number>} sizes
  * @property {Set<Chunk>} chunks
- * @property {Set<Chunk>} reuseableChunks
+ * @property {Set<Chunk>} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
@@ -1177,7 +1177,7 @@ module.exports = class SplitChunksPlugin {
 									name,
 									sizes: {},
 									chunks: new Set(),
-									reuseableChunks: new Set(),
+									reusableChunks: new Set(),
 									chunksKeys: new Set()
 								})
 							);

package/lib/performance/SizeLimitsPlugin.js

@@ -13,6 +13,7 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation").Asset} Asset */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../WebpackError")} WebpackError */
@@ -32,6 +33,12 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
 
 const isOverSizeLimitSet = new WeakSet();
 
+/**
+ * @param {Asset["name"]} name the name
+ * @param {Asset["source"]} source the source
+ * @param {Asset["info"]} info the info
+ * @returns {boolean} result
+ */
 const excludeSourceMap = (name, source, info) => !info.development;
 
 module.exports = class SizeLimitsPlugin {
@@ -104,6 +111,10 @@ module.exports = class SizeLimitsPlugin {
 				}
 			}
 
+			/**
+			 * @param {Asset["name"]} name the name
+			 * @returns {boolean | undefined} result
+			 */
 			const fileFilter = name => {
 				const asset = compilation.getAsset(name);
 				return asset && assetFilter(asset.name, asset.source, asset.info);

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -9,6 +9,10 @@
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 
 class ObjectMatcherRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 */
 	constructor(ruleProperty, dataProperty) {
 		this.ruleProperty = ruleProperty;
 		this.dataProperty = dataProperty || ruleProperty;

package/lib/runtime/EnsureChunkRuntimeModule.js

@@ -9,10 +9,11 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 class EnsureChunkRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("ensure chunk");

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -9,10 +9,11 @@ const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 	/**
-	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("trusted types policy");

package/lib/serialization/FileMiddleware.js

@@ -576,6 +576,7 @@ class FileMiddleware extends SerializerMiddleware {
 					/** @type {number | undefined} */
 					let currentBufferUsed;
 					const buf = [];
+					/** @type {import("zlib").Zlib & import("stream").Transform | undefined} */
 					let decompression;
 					if (file.endsWith(".gz")) {
 						decompression = createGunzip({

package/lib/serialization/ObjectMiddleware.js

@@ -46,6 +46,8 @@ Technically any value can be used.
 /**
  * @typedef {Object} ObjectSerializerContext
  * @property {function(any): void} write
+ * @property {(function(any): void)=} writeLazy
+ * @property {(function(any, object=): (() => Promise<any> | any))=} writeSeparate
  * @property {function(any): void} setCircularReference
  */
 

package/lib/serialization/Serializer.js

@@ -4,13 +4,27 @@
 
 "use strict";
 
+/**
+ * @template T, K
+ * @typedef {import("./SerializerMiddleware")<T, K>} SerializerMiddleware
+ */
+
 class Serializer {
+	/**
+	 * @param {SerializerMiddleware<any, any>[]} middlewares serializer middlewares
+	 * @param {TODO=} context context
+	 */
 	constructor(middlewares, context) {
 		this.serializeMiddlewares = middlewares.slice();
 		this.deserializeMiddlewares = middlewares.slice().reverse();
 		this.context = context;
 	}
 
+	/**
+	 * @param {any} obj object
+	 * @param {TODO} context content
+	 * @returns {Promise<any>} result
+	 */
 	serialize(obj, context) {
 		const ctx = { ...context, ...this.context };
 		let current = obj;
@@ -28,6 +42,11 @@ class Serializer {
 		return current;
 	}
 
+	/**
+	 * @param {any} value value
+	 * @param {TODO} context context
+	 * @returns {Promise<any>} result
+	 */
 	deserialize(value, context) {
 		const ctx = { ...context, ...this.context };
 		/** @type {any} */

package/lib/sharing/ConsumeSharedModule.js

@@ -42,7 +42,7 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
  * @property {string} shareKey global share key
  * @property {string} shareScope share scope
  * @property {SemVerRange | false | undefined} requiredVersion version requirement
- * @property {string} packageName package name to determine required version automatically
+ * @property {string=} packageName package name to determine required version automatically
  * @property {boolean} strictVersion don't use shared version even if version isn't valid
  * @property {boolean} singleton use single global version
  * @property {boolean} eager include the fallback module in a sync way

package/lib/sharing/ConsumeSharedPlugin.js

@@ -117,7 +117,12 @@ class ConsumeSharedPlugin {
 					normalModuleFactory
 				);
 
-				let unresolvedConsumes, resolvedConsumes, prefixedConsumes;
+				/** @type {Map<string, ConsumeOptions>} */
+				let unresolvedConsumes;
+				/** @type {Map<string, ConsumeOptions>} */
+				let resolvedConsumes;
+				/** @type {Map<string, ConsumeOptions>} */
+				let prefixedConsumes;
 				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
 					({ resolved, unresolved, prefixed }) => {
 						resolvedConsumes = resolved;
@@ -138,6 +143,9 @@ class ConsumeSharedPlugin {
 				 * @returns {Promise<ConsumeSharedModule>} create module
 				 */
 				const createConsumeSharedModule = (context, request, config) => {
+					/**
+					 * @param {string} details details
+					 */
 					const requiredVersionWarning = details => {
 						const error = new WebpackError(
 							`No required version specified and unable to automatically determine one. ${details}`
@@ -293,9 +301,15 @@ class ConsumeSharedPlugin {
 						) {
 							return Promise.resolve();
 						}
-						const options = resolvedConsumes.get(resource);
+						const options = resolvedConsumes.get(
+							/** @type {string} */ (resource)
+						);
 						if (options !== undefined) {
-							return createConsumeSharedModule(context, resource, options);
+							return createConsumeSharedModule(
+								context,
+								/** @type {string} */ (resource),
+								options
+							);
 						}
 						return Promise.resolve();
 					}

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -17,14 +17,16 @@ const {
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
 
 class ConsumeSharedRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("consumes", RuntimeModule.STAGE_ATTACH);
@@ -38,6 +40,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const { runtimeTemplate, codeGenerationResults } = compilation;
+		/** @type {Record<ChunkId, (string | number)[]>} */
 		const chunkToModuleMapping = {};
 		/** @type {Map<string | number, Source>} */
 		const moduleIdToSourceMapping = new Map();
@@ -70,7 +73,11 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				"consume-shared"
 			);
 			if (!modules) continue;
-			addModules(modules, chunk, (chunkToModuleMapping[chunk.id] = []));
+			addModules(
+				modules,
+				chunk,
+				(chunkToModuleMapping[/** @type {ChunkId} */ (chunk.id)] = [])
+			);
 		}
 		for (const chunk of /** @type {Chunk} */ (
 			this.chunk

package/lib/sharing/ProvideSharedPlugin.js

@@ -15,6 +15,7 @@ const ProvideSharedModuleFactory = require("./ProvideSharedModuleFactory");
 /** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModuleFactory").NormalModuleCreateData} NormalModuleCreateData */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/sharing/ProvideSharedPlugin.check.js"),
@@ -112,6 +113,12 @@ class ProvideSharedPlugin {
 					}
 				}
 				compilationData.set(compilation, resolvedProvideMap);
+				/**
+				 * @param {string} key key
+				 * @param {ProvideOptions} config config
+				 * @param {NormalModuleCreateData["resource"]} resource resource
+				 * @param {NormalModuleCreateData["resourceResolveData"]} resourceResolveData resource resolve data
+				 */
 				const provideSharedModule = (
 					key,
 					config,
@@ -151,7 +158,7 @@ class ProvideSharedPlugin {
 				normalModuleFactory.hooks.module.tap(
 					"ProvideSharedPlugin",
 					(module, { resource, resourceResolveData }, resolveData) => {
-						if (resolvedProvideMap.has(resource)) {
+						if (resolvedProvideMap.has(/** @type {string} */ (resource))) {
 							return module;
 						}
 						const { request } = resolveData;
@@ -161,7 +168,7 @@ class ProvideSharedPlugin {
 								provideSharedModule(
 									request,
 									config,
-									resource,
+									/** @type {string} */ (resource),
 									resourceResolveData
 								);
 								resolveData.cacheable = false;
@@ -171,12 +178,12 @@ class ProvideSharedPlugin {
 							if (request.startsWith(prefix)) {
 								const remainder = request.slice(prefix.length);
 								provideSharedModule(
-									resource,
+									/** @type {string} */ (resource),
 									{
 										...config,
 										shareKey: config.shareKey + remainder
 									},
-									resource,
+									/** @type {string} */ (resource),
 									resourceResolveData
 								);
 								resolveData.cacheable = false;
@@ -209,7 +216,7 @@ class ProvideSharedPlugin {
 								},
 								err => {
 									if (err) return reject(err);
-									resolve();
+									resolve(null);
 								}
 							);
 						})

package/lib/sharing/resolveMatchedConfigs.js

@@ -64,10 +64,10 @@ exports.resolveMatchedConfigs = (compilation, configs) => {
 										name: `shared module ${request}`
 									})
 								);
-								return resolve();
+								return resolve(null);
 							}
 							resolved.set(/** @type {string} */ (result), config);
-							resolve();
+							resolve(null);
 						}
 					);
 				});

package/lib/sharing/utils.js

@@ -8,6 +8,8 @@
 const { join, dirname, readJson } = require("../util/fs");
 
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/fs").JsonObject} JsonObject */
+/** @typedef {import("../util/fs").JsonPrimitive} JsonPrimitive */
 
 // Extreme shorthand only for github. eg: foo/bar
 const RE_URL_GITHUB_EXTREME_SHORT = /^[^/@:.\s][^/@:\s]*\/[^@:\s]*[^/@:\s]#\S+/;
@@ -373,9 +375,9 @@ exports.getDescriptionFile = getDescriptionFile;
 
 /**
  *
- * @param {object} data description file data i.e.: package.json
+ * @param {JsonObject} data description file data i.e.: package.json
  * @param {string} packageName name of the dependency
- * @returns {string} normalized version
+ * @returns {string | undefined} normalized version
  */
 const getRequiredVersionFromDescriptionFile = (data, packageName) => {
 	const dependencyTypes = [
@@ -386,12 +388,17 @@ const getRequiredVersionFromDescriptionFile = (data, packageName) => {
 	];
 
 	for (const dependencyType of dependencyTypes) {
+		const dependency = /** @type {JsonObject} */ (data[dependencyType]);
 		if (
-			data[dependencyType] &&
-			typeof data[dependencyType] === "object" &&
-			packageName in data[dependencyType]
+			dependency &&
+			typeof dependency === "object" &&
+			packageName in dependency
 		) {
-			return normalizeVersion(data[dependencyType][packageName]);
+			return normalizeVersion(
+				/** @type {Exclude<JsonPrimitive, null | boolean| number>} */ (
+					dependency[packageName]
+				)
+			);
 		}
 	}
 };

package/lib/util/StackedCacheMap.js

@@ -8,6 +8,29 @@
 /**
  * @template K
  * @template V
+ *
+ * The StackedCacheMap is a data structure designed as an alternative to a Map
+ * in situations where you need to handle multiple item additions and
+ * frequently access the largest map.
+ *
+ * It is particularly optimized for efficiently adding multiple items
+ * at once, which can be achieved using the `addAll` method.
+ *
+ * It has a fallback Map that is used when the map to be added is mutable.
+ *
+ * Note: `delete` and `has` are not supported for performance reasons.
+ *
+ * @example
+ * ```js
+ * const map = new StackedCacheMap();
+ * map.addAll(new Map([["a", 1], ["b", 2]]), true);
+ * map.addAll(new Map([["c", 3], ["d", 4]]), true);
+ * map.get("a"); // 1
+ * map.get("d"); // 4
+ * for (const [key, value] of map) {
+ * 		console.log(key, value);
+ * }
+ * ```
  */
 class StackedCacheMap {
 	constructor() {
@@ -18,6 +41,9 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * If `immutable` is true, the map can be referenced by the StackedCacheMap
+	 * and should not be changed afterwards. If the map is mutable, all items
+	 * are copied into a fallback Map.
 	 * @param {ReadonlyMap<K, V>} map map to add
 	 * @param {boolean=} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
 	 */