webpack 5.97.1 → 5.104.1

package/lib/logging/Logger.js

@@ -30,15 +30,18 @@ const LogType = Object.freeze({
 module.exports.LogType = LogType;
 
 /** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
+/** @typedef {Map<string | undefined, [number, number]>} TimersMap */
 
 const LOG_SYMBOL = Symbol("webpack logger raw log method");
 const TIMERS_SYMBOL = Symbol("webpack logger times");
 const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
+/** @typedef {EXPECTED_ANY[]} Args */
+
 class WebpackLogger {
 	/**
-	 * @param {function(LogTypeEnum, EXPECTED_ANY[]=): void} log log function
-	 * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
+	 * @param {(type: LogTypeEnum, args?: Args) => void} log log function
+	 * @param {(name: string | (() => string)) => WebpackLogger} getChildLogger function to create child logger
 	 */
 	constructor(log, getChildLogger) {
 		this[LOG_SYMBOL] = log;
@@ -46,35 +49,35 @@ class WebpackLogger {
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	error(...args) {
 		this[LOG_SYMBOL](LogType.error, args);
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	warn(...args) {
 		this[LOG_SYMBOL](LogType.warn, args);
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	info(...args) {
 		this[LOG_SYMBOL](LogType.info, args);
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	log(...args) {
 		this[LOG_SYMBOL](LogType.log, args);
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	debug(...args) {
 		this[LOG_SYMBOL](LogType.debug, args);
@@ -82,7 +85,7 @@ class WebpackLogger {
 
 	/**
 	 * @param {EXPECTED_ANY} assertion assertion
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	assert(assertion, ...args) {
 		if (!assertion) {
@@ -99,21 +102,21 @@ class WebpackLogger {
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	status(...args) {
 		this[LOG_SYMBOL](LogType.status, args);
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	group(...args) {
 		this[LOG_SYMBOL](LogType.group, args);
 	}
 
 	/**
-	 * @param {...EXPECTED_ANY} args args
+	 * @param {Args} args args
 	 */
 	groupCollapsed(...args) {
 		this[LOG_SYMBOL](LogType.groupCollapsed, args);
@@ -141,7 +144,7 @@ class WebpackLogger {
 	 * @param {string} label label
 	 */
 	time(label) {
-		/** @type {Map<string | undefined, [number, number]>} */
+		/** @type {TimersMap} */
 		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
 		this[TIMERS_SYMBOL].set(label, process.hrtime());
 	}
@@ -167,7 +170,7 @@ class WebpackLogger {
 			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
 		}
 		const time = process.hrtime(prev);
-		/** @type {Map<string | undefined, [number, number]>} */
+		/** @type {TimersMap} */
 		(this[TIMERS_SYMBOL]).delete(label);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
@@ -183,9 +186,9 @@ class WebpackLogger {
 			);
 		}
 		const time = process.hrtime(prev);
-		/** @type {Map<string | undefined, [number, number]>} */
+		/** @type {TimersMap} */
 		(this[TIMERS_SYMBOL]).delete(label);
-		/** @type {Map<string | undefined, [number, number]>} */
+		/** @type {TimersMap} */
 		this[TIMERS_AGGREGATES_SYMBOL] =
 			this[TIMERS_AGGREGATES_SYMBOL] || new Map();
 		const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);

package/lib/logging/createConsoleLogger.js

@@ -10,32 +10,33 @@ const { LogType } = require("./Logger");
 /** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
 /** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
 /** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
+/** @typedef {import("./Logger").Args} Args */
 
-/** @typedef {function(string): boolean} FilterFunction */
-/** @typedef {function(string, LogTypeEnum, EXPECTED_ANY[]=): void} LoggingFunction */
+/** @typedef {(item: string) => boolean} FilterFunction */
+/** @typedef {(value: string, type: LogTypeEnum, args?: Args) => void} LoggingFunction */
 
 /**
  * @typedef {object} LoggerConsole
- * @property {function(): void} clear
- * @property {function(): void} trace
- * @property {(...args: EXPECTED_ANY[]) => void} info
- * @property {(...args: EXPECTED_ANY[]) => void} log
- * @property {(...args: EXPECTED_ANY[]) => void} warn
- * @property {(...args: EXPECTED_ANY[]) => void} error
- * @property {(...args: EXPECTED_ANY[]) => void=} debug
- * @property {(...args: EXPECTED_ANY[]) => void=} group
- * @property {(...args: EXPECTED_ANY[]) => void=} groupCollapsed
- * @property {(...args: EXPECTED_ANY[]) => void=} groupEnd
- * @property {(...args: EXPECTED_ANY[]) => void=} status
- * @property {(...args: EXPECTED_ANY[]) => void=} profile
- * @property {(...args: EXPECTED_ANY[]) => void=} profileEnd
- * @property {(...args: EXPECTED_ANY[]) => void=} logTime
+ * @property {() => void} clear
+ * @property {() => void} trace
+ * @property {(...args: Args) => void} info
+ * @property {(...args: Args) => void} log
+ * @property {(...args: Args) => void} warn
+ * @property {(...args: Args) => void} error
+ * @property {(...args: Args) => void=} debug
+ * @property {(...args: Args) => void=} group
+ * @property {(...args: Args) => void=} groupCollapsed
+ * @property {(...args: Args) => void=} groupEnd
+ * @property {(...args: Args) => void=} status
+ * @property {(...args: Args) => void=} profile
+ * @property {(...args: Args) => void=} profileEnd
+ * @property {(...args: Args) => void=} logTime
  */
 
 /**
  * @typedef {object} LoggerOptions
- * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
- * @property {FilterTypes|boolean} debug filter for debug logging
+ * @property {false | true | "none" | "error" | "warn" | "info" | "log" | "verbose"} level loglevel
+ * @property {FilterTypes | boolean} debug filter for debug logging
  * @property {LoggerConsole} console the console to log to
  */
 
@@ -43,15 +44,15 @@ const { LogType } = require("./Logger");
  * @param {FilterItemTypes} item an input item
  * @returns {FilterFunction | undefined} filter function
  */
-const filterToFunction = item => {
+const filterToFunction = (item) => {
 	if (typeof item === "string") {
 		const regExp = new RegExp(
 			`[\\\\/]${item.replace(/[-[\]{}()*+?.\\^$|]/g, "\\$&")}([\\\\/]|$|!|\\?)`
 		);
-		return ident => regExp.test(ident);
+		return (ident) => regExp.test(ident);
 	}
 	if (item && typeof item === "object" && typeof item.test === "function") {
-		return ident => item.test(ident);
+		return (ident) => item.test(ident);
 	}
 	if (typeof item === "function") {
 		return item;
@@ -85,17 +86,16 @@ module.exports = ({ level = "info", debug = false, console }) => {
 		(
 			typeof debug === "boolean"
 				? [() => debug]
-				: /** @type {FilterItemTypes[]} */ ([])
-						.concat(debug)
-						.map(filterToFunction)
+				: /** @type {FilterItemTypes[]} */ ([
+						...(Array.isArray(debug) ? debug : [debug])
+					]).map(filterToFunction)
 		);
-	/** @type {number} */
 	const loglevel = LogLevel[`${level}`] || 0;
 
 	/**
 	 * @param {string} name name of the logger
 	 * @param {LogTypeEnum} type type of the log entry
-	 * @param {EXPECTED_ANY[]=} args arguments of the log entry
+	 * @param {Args=} args arguments of the log entry
 	 * @returns {void}
 	 */
 	const logger = (name, type, args) => {
@@ -108,7 +108,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
 			}
 			return [];
 		};
-		const debug = debugFilters.some(f => f(name));
+		const debug = debugFilters.some((f) => f(name));
 		switch (type) {
 			case LogType.debug:
 				if (!debug) return;

package/lib/logging/runtime.js

@@ -17,29 +17,29 @@ const currentDefaultLoggerOptions = {
 };
 let currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
 
+/**
+ * @param {createConsoleLogger.LoggerOptions} options new options, merge with old options
+ * @returns {void}
+ */
+module.exports.configureDefaultLogger = (options) => {
+	Object.assign(currentDefaultLoggerOptions, options);
+	currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
+};
+
 /**
  * @param {string} name name of the logger
  * @returns {Logger} a logger
  */
-module.exports.getLogger = name =>
+module.exports.getLogger = (name) =>
 	new Logger(
 		(type, args) => {
 			if (module.exports.hooks.log.call(name, type, args) === undefined) {
 				currentDefaultLogger(name, type, args);
 			}
 		},
-		childName => module.exports.getLogger(`${name}/${childName}`)
+		(childName) => module.exports.getLogger(`${name}/${childName}`)
 	);
 
-/**
- * @param {createConsoleLogger.LoggerOptions} options new options, merge with old options
- * @returns {void}
- */
-module.exports.configureDefaultLogger = options => {
-	Object.assign(currentDefaultLoggerOptions, options);
-	currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
-};
-
 module.exports.hooks = {
 	log: new SyncBailHook(["origin", "type", "args"])
 };

package/lib/logging/truncateArgs.js

@@ -6,10 +6,10 @@
 "use strict";
 
 /**
- * @param {Array<number>} array array of numbers
+ * @param {number[]} array array of numbers
  * @returns {number} sum of all numbers in array
  */
-const arraySum = array => {
+const arraySum = (array) => {
 	let sum = 0;
 	for (const item of array) sum += item;
 	return sum;
@@ -21,7 +21,7 @@ const arraySum = array => {
  * @returns {string[]} truncated args
  */
 const truncateArgs = (args, maxLength) => {
-	const lengths = args.map(a => `${a}`.length);
+	const lengths = args.map((a) => `${a}`.length);
 	const availableLength = maxLength - lengths.length + 1;
 
 	if (availableLength > 0 && args.length === 1) {
@@ -34,7 +34,7 @@ const truncateArgs = (args, maxLength) => {
 	}
 
 	// Check if there is space for at least 4 chars per arg
-	if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
+	if (availableLength < arraySum(lengths.map((i) => Math.min(i, 6)))) {
 		// remove args
 		if (args.length > 1) return truncateArgs(args.slice(0, -1), maxLength);
 		return [];
@@ -48,7 +48,7 @@ const truncateArgs = (args, maxLength) => {
 	// Try to remove chars from the longest items until it fits
 	while (currentLength > availableLength) {
 		const maxLength = Math.max(...lengths);
-		const shorterItems = lengths.filter(l => l !== maxLength);
+		const shorterItems = lengths.filter((l) => l !== maxLength);
 		const nextToMaxLength =
 			shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
 		const maxReduce = maxLength - nextToMaxLength;

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -10,15 +10,18 @@ const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenc
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 
 /**
  * @typedef {object} CommonJsChunkLoadingPluginOptions
- * @property {boolean} [asyncChunkLoading] enable async chunk loading
+ * @property {boolean=} asyncChunkLoading enable async chunk loading
  */
 
+const PLUGIN_NAME = "CommonJsChunkLoadingPlugin";
+
 class CommonJsChunkLoadingPlugin {
 	/**
-	 * @param {CommonJsChunkLoadingPluginOptions} [options] options
+	 * @param {CommonJsChunkLoadingPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this._asyncChunkLoading = options.asyncChunkLoading;
@@ -40,81 +43,75 @@ class CommonJsChunkLoadingPlugin {
 			chunkLoading: chunkLoadingValue,
 			asyncChunkLoading: this._asyncChunkLoading
 		}).apply(compiler);
-		compiler.hooks.thisCompilation.tap(
-			"CommonJsChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				/**
-				 * @param {Chunk} chunk chunk
-				 * @returns {boolean} true, if wasm loading is enabled for the chunk
-				 */
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === chunkLoadingValue;
-				};
-				const onceForChunkSet = new WeakSet();
-				/**
-				 * @param {Chunk} chunk chunk
-				 * @param {Set<string>} set runtime requirements
-				 */
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					compilation.addRuntimeModule(
-						chunk,
-						new ChunkLoadingRuntimeModule(set)
-					);
-				};
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @returns {boolean} true, if wasm loading is enabled for the chunk
+			 */
+			const isEnabledForChunk = (chunk) => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === chunkLoadingValue;
+			};
+			const onceForChunkSet = new WeakSet();
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const handler = (chunk, set) => {
+				if (onceForChunkSet.has(chunk)) return;
+				onceForChunkSet.add(chunk);
+				if (!isEnabledForChunk(chunk)) return;
+				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				set.add(RuntimeGlobals.hasOwnProperty);
+				compilation.addRuntimeModule(chunk, new ChunkLoadingRuntimeModule(set));
+			};
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("CommonJsChunkLoadingPlugin", handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadManifest)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.baseURI)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.externalInstallChunk)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.onChunksLoaded)
+				.tap(PLUGIN_NAME, handler);
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.hmrModuleData);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getUpdateManifestFilename);
-					});
-			}
-		);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.getChunkScriptFilename);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+					set.add(RuntimeGlobals.moduleCache);
+					set.add(RuntimeGlobals.hmrModuleData);
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadManifest)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.getUpdateManifestFilename);
+				});
+		});
 	}
 }
 

package/lib/node/NodeEnvironmentPlugin.js

@@ -15,10 +15,16 @@ const nodeConsole = require("./nodeConsole");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
+/**
+ * @typedef {object} NodeEnvironmentPluginOptions
+ * @property {InfrastructureLogging} infrastructureLogging infrastructure logging options
+ */
+
+const PLUGIN_NAME = "NodeEnvironmentPlugin";
+
 class NodeEnvironmentPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
+	 * @param {NodeEnvironmentPluginOptions} options options
 	 */
 	constructor(options) {
 		this.options = options;
@@ -51,7 +57,7 @@ class NodeEnvironmentPlugin {
 		compiler.outputFileSystem = fs;
 		compiler.intermediateFileSystem = fs;
 		compiler.watchFileSystem = new NodeWatchFileSystem(inputFileSystem);
-		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
+		compiler.hooks.beforeRun.tap(PLUGIN_NAME, (compiler) => {
 			if (
 				compiler.inputFileSystem === inputFileSystem &&
 				inputFileSystem.purge

package/lib/node/NodeTargetPlugin.js

@@ -7,6 +7,7 @@
 
 const ExternalsPlugin = require("../ExternalsPlugin");
 
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
 /** @typedef {import("../Compiler")} Compiler */
 
 const builtins = [
@@ -72,13 +73,20 @@ const builtins = [
 ];
 
 class NodeTargetPlugin {
+	/**
+	 * @param {ExternalsType} type default external type
+	 */
+	constructor(type = "node-commonjs") {
+		this.type = type;
+	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
+		new ExternalsPlugin(this.type, builtins).apply(compiler);
 	}
 }
 

package/lib/node/NodeTemplatePlugin.js

@@ -12,12 +12,12 @@ const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin
 
 /**
  * @typedef {object} NodeTemplatePluginOptions
- * @property {boolean} [asyncChunkLoading] enable async chunk loading
+ * @property {boolean=} asyncChunkLoading enable async chunk loading
  */
 
 class NodeTemplatePlugin {
 	/**
-	 * @param {NodeTemplatePluginOptions} [options] options object
+	 * @param {NodeTemplatePluginOptions=} options options object
 	 */
 	constructor(options = {}) {
 		this._options = options;

package/lib/node/NodeWatchFileSystem.js

@@ -8,10 +8,10 @@
 const util = require("util");
 const Watchpack = require("watchpack");
 
-/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/fs").WatchMethod} WatchMethod */
+/** @typedef {import("../util/fs").Changes} Changes */
+/** @typedef {import("../util/fs").Removals} Removals */
 
 class NodeWatchFileSystem {
 	/**
@@ -78,8 +78,8 @@ class NodeWatchFileSystem {
 		this.watcher.once(
 			"aggregated",
 			/**
-			 * @param {Set<string>} changes changes
-			 * @param {Set<string>} removals removals
+			 * @param {Changes} changes changes
+			 * @param {Removals} removals removals
 			 */
 			(changes, removals) => {
 				// pause emitting events (avoids clearing aggregated changes and removals on timeout)