@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/util/async.js

@@ -0,0 +1,292 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * Wraps the shared completion callback for one item, so an iterator that
+ * reports twice fails loudly instead of settling the run early.
+ * @template E
+ * @param {(err?: E | null) => void} done shared completion callback
+ * @returns {(err?: E | null) => void} completion callback for a single item
+ */
+const once = (done) => {
+	/** @type {((err?: E | null) => void) | undefined} */
+	let pending = done;
+	return (err) => {
+		const fn = pending;
+		if (fn === undefined) throw new Error("Callback was already called");
+		pending = undefined;
+		fn(err);
+	};
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency.
+ * Every item is started from one flat loop, so a synchronous iterator never
+ * grows the stack.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const each = (collection, iterator, callback) => {
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	if (Array.isArray(collection)) {
+		const array = /** @type {T[]} */ (collection);
+		const length = array.length;
+		if (length === 0) return callback(null);
+		remaining = length;
+		// Dispatching continues past an error on purpose: callers rely on every
+		// item being started, e.g. to close every watcher when one close fails.
+		for (let i = 0; i < length; i++) iterator(array[i], once(done));
+		return;
+	}
+
+	// `remaining` starts at 1 so that completion cannot fire while items of a
+	// collection of unknown length are still being dispatched.
+	for (const item of collection) {
+		remaining++;
+		iterator(item, once(done));
+	}
+	done(null);
+};
+
+/**
+ * Runs `iterator` over every item, keeping at most `limit` of them in flight.
+ * A synchronous iterator is drained by the dispatch loop instead of by
+ * recursion, so the stack stays flat however long the collection is.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const eachLimit = (collection, limit, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	const length = array === undefined ? 0 : array.length;
+	const values =
+		array === undefined ? collection[Symbol.iterator]() : undefined;
+	let index = 0;
+	let running = 0;
+	let exhausted = false;
+	let finished = false;
+	let dispatching = false;
+
+	const dispatch = () => {
+		// A re-entrant call returns at once; the loop already running sees the
+		// slot the completed item freed and takes the next one itself.
+		if (dispatching) return;
+		dispatching = true;
+		while (running < limit && !exhausted) {
+			// `finished` is set from `done`, which an iterator may call before it
+			// returns, so it has to be re-read on every turn of this loop.
+			if (finished) break;
+			/** @type {T} */
+			let item;
+			if (array === undefined) {
+				const next = /** @type {Iterator<T>} */ (values).next();
+				if (next.done) {
+					exhausted = true;
+					break;
+				}
+				item = next.value;
+			} else {
+				if (index === length) {
+					exhausted = true;
+					break;
+				}
+				item = array[index++];
+			}
+			running++;
+			iterator(item, once(done));
+		}
+		dispatching = false;
+		if (exhausted && running === 0 && !finished) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		running--;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		dispatch();
+	};
+
+	if (limit < 1) return callback(null);
+
+	dispatch();
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency and collects the
+ * results in the order of the collection, not the order of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const map = (collection, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	// Pre-sized, because growing it or `Array.from` costs measurably more on
+	// the small collections this is called with.
+	/** @type {R[]} */
+	// eslint-disable-next-line unicorn/no-new-array
+	const results = array === undefined ? [] : new Array(array.length);
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const settle = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err, results);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null, results);
+		}
+	};
+
+	/**
+	 * @param {number} index position the result of that item belongs at
+	 * @returns {(err?: E | null, result?: R) => void} completion callback for that item
+	 */
+	const createCallback = (index) => {
+		let position = index;
+		return (err, result) => {
+			const at = position;
+			if (at === -1) throw new Error("Callback was already called");
+			position = -1;
+			// A result arriving after the run settled must not reach `results`,
+			// which the callback already handed to the caller.
+			if (finished) return;
+			if (!err) results[at] = /** @type {R} */ (result);
+			settle(err);
+		};
+	};
+
+	if (array !== undefined) {
+		const length = array.length;
+		if (length === 0) return callback(null, results);
+		remaining = length;
+		for (let i = 0; i < length; i++) iterator(array[i], createCallback(i));
+		return;
+	}
+
+	let index = 0;
+	for (const item of collection) {
+		remaining++;
+		iterator(item, createCallback(index++));
+	}
+	results.length = index;
+	settle(null);
+};
+
+/**
+ * Runs `iterator` over every item, at most `limit` of them in flight, and
+ * collects the results in the order of the collection, not of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const mapLimit = (collection, limit, iterator, callback) => {
+	/** @type {R[]} */
+	const results = [];
+	let index = 0;
+	eachLimit(
+		collection,
+		limit,
+		(item, done) => {
+			// the dispatch loop hands out one item at a time, so this counts the
+			// position of the item rather than of whichever finishes first
+			const position = index++;
+			iterator(item, (err, result) => {
+				if (err) return done(err);
+				results[position] = /** @type {R} */ (result);
+				done(null);
+			});
+		},
+		(err) => {
+			if (err) return callback(err);
+			callback(null, results);
+		}
+	);
+};
+
+/**
+ * @template R
+ * @template E
+ * @param {(callback: (err?: E | null, result?: R) => void) => void} task task to run
+ * @param {(err?: E | null, result?: R) => void} callback called when the task is done
+ * @returns {void}
+ */
+const runTask = (task, callback) => task(callback);
+
+/**
+ * Runs every task in parallel and collects the results in task order.
+ * @template R
+ * @template E
+ * @param {((callback: (err?: E | null, result?: R) => void) => void)[]} tasks tasks to run
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const parallel = (tasks, callback) => map(tasks, runTask, callback);
+
+module.exports.each = each;
+module.exports.eachLimit = eachLimit;
+module.exports.map = map;
+module.exports.mapLimit = mapLimit;
+module.exports.parallel = parallel;

package/lib/util/buildDiagnostics.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+/** @import Module, { BuildDiagnostics, BuildInfo } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+
+/**
+ * The diagnostics record of a build info, created on first use so a module nothing reports about carries none.
+ * @param {BuildInfo} buildInfo the build info of the module
+ * @returns {BuildDiagnostics} the record
+ */
+const getBuildDiagnostics = (buildInfo) => {
+	let diagnostics = buildInfo.diagnostics;
+	if (diagnostics === undefined) {
+		diagnostics = buildInfo.diagnostics = {
+			optimizationBailouts: undefined,
+			sideEffectStatement: undefined,
+			ineffectivePureAnnotations: undefined,
+			topLevelThis: undefined,
+			usesEval: undefined,
+			notCacheableReasons: undefined
+		};
+	}
+	return diagnostics;
+};
+
+/**
+ * Records a bailout a parser plugin found, where a module restored from the cache still has it for the module graph to report.
+ * @param {BuildInfo} buildInfo the build info of the module being parsed
+ * @param {string} reason the bailout as reported
+ * @returns {void}
+ */
+const recordOptimizationBailout = (buildInfo, reason) => {
+	const diagnostics = getBuildDiagnostics(buildInfo);
+	const bailouts =
+		diagnostics.optimizationBailouts || (diagnostics.optimizationBailouts = []);
+	bailouts.push(reason);
+};
+
+/**
+ * Replays the bailouts parser plugins recorded for a module into the module graph,
+ * which a module reused from the cache never parses into.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the built or still valid module
+ * @returns {void}
+ */
+const replayOptimizationBailouts = (moduleGraph, module) => {
+	const buildInfo = module.buildInfo;
+	if (buildInfo === undefined) return;
+	const diagnostics = buildInfo.diagnostics;
+	if (
+		diagnostics === undefined ||
+		diagnostics.optimizationBailouts === undefined
+	) {
+		return;
+	}
+	const bailouts = moduleGraph.getOptimizationBailout(module);
+	for (const reason of diagnostics.optimizationBailouts) bailouts.push(reason);
+};
+
+module.exports = {
+	getBuildDiagnostics,
+	recordOptimizationBailout,
+	replayOptimizationBailouts
+};

package/lib/util/chainedImports.js

@@ -39,10 +39,9 @@ module.exports.getTrimmedIdsAndRange = (
 	);
 	let trimmedRange = untrimmedRange;
 	if (trimmedIds.length !== untrimmedIds.length) {
-		// The array returned from dep.idRanges is right-aligned with the array returned from dep.names.
-		// Meaning, the two arrays may not always have the same number of elements, but the last element of
-		// dep.idRanges corresponds to [the expression fragment to the left of] the last element of dep.names.
-		// Use this to find the correct replacement range based on the number of ids that were trimmed.
+		// `dep.idRanges` is right-aligned with `dep.names`: the two may differ in
+		// length, but their last elements correspond, which is what turns the count
+		// of trimmed ids into the replacement range.
 		const idx =
 			ranges === undefined
 				? -1 /* trigger failure case below */

package/lib/util/concatenate.js

@@ -324,10 +324,10 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	}
 };
 
-// Declared by the chunk bootstrap in the scope module code is hoisted into.
-// Hit when a webpack bundle is bundled again, since its output declares exactly
-// these: the `const` one then fails to parse, the `var` one silently clobbers
-// the module table. CompatibilityPlugin renames the other two runtime names.
+// WHY: Declared by the chunk bootstrap in the scope module code is hoisted
+// into, so re-bundling a webpack bundle collides with them: the `const` one
+// fails to parse and the `var` one silently clobbers the module table.
+// CompatibilityPlugin renames the other two runtime names.
 const CHUNK_RUNTIME_DECLARATIONS = new Set([
 	"__webpack_modules__",
 	"__webpack_module_cache__"

package/lib/util/conventions.js

@@ -115,7 +115,11 @@ module.exports.cssExportConvention = (input, convention) => {
 	const set = new Set();
 	if (typeof convention === "function") {
 		const result = convention(input);
-		const validate = (/** @type {string} */ name) => {
+		/**
+		 * @param {string} name name returned by the convention function
+		 * @returns {void}
+		 */
+		const validate = (name) => {
 			if (typeof name !== "string" || name.length === 0) {
 				throw new Error(
 					`exportsConvention function must return a non-empty string or an array of non-empty strings, got ${safeStringify(result)}`

package/lib/util/createHooksRegistry.js

@@ -15,8 +15,7 @@ const createHooksRegistry = (createHooks) => {
 	return (compilation) => {
 		let hooks = map.get(compilation);
 		if (hooks === undefined) {
-			// validated once per compilation — this runs on every render and
-			// codegen. Matched by class name, not `instanceof`: a compilation from
+			// Matched by class name rather than `instanceof`: a compilation from
 			// another webpack copy has to pass too, and importing `Compilation`
 			// here cycles.
 			const candidate =

package/lib/util/createMappings.js

@@ -13,9 +13,9 @@
  * while richer call sites can pass arrays of segments.
  *
  * TODO move this encoder into `webpack-sources` and replace the body of this
- * file with re-exports. The public shape (`encodeVLQ`, `encodeMappings(lines)`,
- * `MappingSegment`, `LineMappings`) is intended to match what would land
- * upstream so call sites don't have to change.
+ * file with re-exports. The public shape (`encodeVLQ`, `decodeVLQ`,
+ * `encodeMappings(lines)`, `MappingSegment`, `LineMappings`) is intended to
+ * match what would land upstream so call sites don't have to change.
  */
 
 const VLQ_BASE64 =
@@ -38,6 +38,27 @@ const encodeVLQ = (value) => {
 	return result;
 };
 
+/**
+ * Decode one base64 VLQ value per the source-map V3 spec.
+ * @param {string} mappings a VLQ encoded `mappings` string
+ * @param {number} start index of the value's first character
+ * @returns {{ value: number, end: number }} the decoded value and the index just past it; `end` equals `start` when there is no valid value at `start`
+ */
+const decodeVLQ = (mappings, start) => {
+	let value = 0;
+	let shift = 0;
+	let index = start;
+	let digit;
+	do {
+		digit = index < mappings.length ? VLQ_BASE64.indexOf(mappings[index]) : -1;
+		if (digit < 0) return { value: 0, end: start };
+		value += (digit & 0x1f) << shift;
+		shift += 5;
+		index++;
+	} while (digit & 0x20);
+	return { value: value & 1 ? -(value >>> 1) : value >>> 1, end: index };
+};
+
 /**
  * @typedef {object} MappingSegment
  * @property {number=} generatedColumn 0-based generated column (defaults to 0)
@@ -114,5 +135,6 @@ const encodeMappings = (lines) => {
 	return encodedLines.join(";");
 };
 
+module.exports.decodeVLQ = decodeVLQ;
 module.exports.encodeMappings = encodeMappings;
 module.exports.encodeVLQ = encodeVLQ;

package/lib/util/dataURL.js

@@ -44,9 +44,8 @@ const decodeDataURI = (uri) => {
  */
 
 // `URIRegEx`'s `.` stops at a newline, which a raw `<svg>` payload carries, and
-// its `base64` group is optional in a way that reads `;charset=utf8` as one.
-// This one is the strict split a rewriter needs; that one stays as the matcher
-// module requests are recognized by.
+// its optional `base64` group reads `;charset=utf8` as one. This is the strict
+// split a rewriter needs; that one stays as the matcher for module requests.
 const STRICT_URI_REGEXP = /^data:([^,;]*)((?:;[^,;]*)*),([\s\S]*)$/i;
 
 const JSON_TYPE = "json";

package/lib/util/deterministicGrouping.js

@@ -450,12 +450,11 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					right--;
 				}
 
+				// WHY: both sides already clear minSize here.
 				//      left v   v right
 				// [ O O O ] O O O [ O O O ]
 				// ^^^^^^^^^ leftSize
 				//       rightSize ^^^^^^^^^
-				// leftSize > minSize
-				// rightSize > minSize
 
 				// Perfect split: [ O O O ] [ O O O ]
 				//                right === left - 1
@@ -476,26 +475,22 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 						queue.push(group);
 						continue;
 					}
-					// can't split group while holding minSize
-					// because minSize is preferred of maxSize we return
-					// the problematic nodes as result here even while it's too big
-					// To avoid this make sure maxSize > minSize * 3
+					// No split holds minSize, which is preferred over maxSize, so these
+					// nodes are returned oversized. Keeping maxSize > minSize * 3
+					// avoids it.
 					result.push(group);
 					continue;
 				}
 				if (left <= right) {
-					// when there is a area between left and right
-					// we look for best split point
-					// we split at the minimum similarity
-					// here key space is separated the most
-					// But we also need to make sure to not create too small groups
+					// In the area between left and right, split at the minimum
+					// similarity, where the key space is separated the most — without
+					// creating groups that are too small.
 					let best = -1;
 					let bestSimilarity = Infinity;
 					let pos = left;
 					const rightSize = sumSize(group.nodes, pos);
 
-					//       pos v   v right
-					// [ O O O ] O O O [ O O O ]
+					// [ O O O ] O O O [ O O O ]   pos, then right
 					// ^^^^^^^^^ leftSize
 					// rightSize ^^^^^^^^^^^^^^^
 

package/lib/util/findGraphRoots.js

@@ -125,12 +125,9 @@ module.exports = (items, getDependencies) => {
 							depSCC.marker = IN_PROGRESS_MARKER;
 							break;
 						case IN_PROGRESS_MARKER: {
-							// Back-edge to an SCC that is still on the stack
-							// Example:
-							//   A -> B -> C -> D
-							//        ^         |
-							//        |_________|
-							// If we are at `D` and traverse `D` -> `B`, then `B/C/D` must be in one SCC
+							// A back-edge to an SCC still on the stack merges every SCC
+							// above it — in `A -> B -> C -> D` with `D -> B`, reaching `B`
+							// from `D` puts `B`, `C` and `D` into one SCC.
 							/** @type {Set<SCC<T>>} */
 							const sccsToMerge = new Set();
 							for (
@@ -162,13 +159,9 @@ module.exports = (items, getDependencies) => {
 					// All dependencies of the current node have been processed
 					// So we leave the node
 					stack.pop();
-					// Mark an SCC as DONE only when the popped node is the last
-					// node from that SCC remaining on the current stack.
-					//   A -> B -> C -> D
-					//        ^         |
-					//        |_________|
-					// If `B` is popped and the new stack top is `A`, they are in
-					// different SCCs, so B's SCC can be finalized.
+					// An SCC is DONE only once the popped node is its last one on
+					// the stack. In `A -> B -> C -> D` with `D -> B`, popping `B` onto a
+					// stack topped by `A` — a different SCC — finalizes B's.
 					if (
 						stack.length &&
 						topOfStack.node.scc !== stack[stack.length - 1].node.scc

package/lib/util/fs.js

@@ -167,7 +167,7 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @typedef {{
  * (path: PathOrFileDescriptor, options?: { encoding?: null | undefined, flag?: string | undefined } | null): Buffer,
  * (path: PathOrFileDescriptor, options: { encoding: BufferEncoding, flag?: string | undefined } | BufferEncoding): string,
- * (path: PathOrFileDescriptor, options?: (ObjectEncodingOptions & { flag?: string | undefined }) | BufferEncoding | null): string | Buffer,
+ * (path: PathOrFileDescriptor, options: ObjectEncodingOptions & { flag?: string | undefined }): string | Buffer,
  * }} ReadFileSync
  */
 
@@ -402,6 +402,21 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @typedef {(path: PathLike, options?: BufferEncoding | ReadStreamOptions) => NodeJS.ReadableStream} CreateReadStream
  */
 
+/**
+ * Defines the symlink type used by this module.
+ * @typedef {(target: PathLike, path: PathLike, type: "dir" | "file" | "junction" | null | undefined, callback: NoParamCallback) => void} Symlink
+ */
+
+/**
+ * Defines the chmod type used by this module.
+ * @typedef {(path: PathLike, mode: number | string, callback: NoParamCallback) => void} Chmod
+ */
+
+/**
+ * Defines the utimes type used by this module.
+ * @typedef {(path: PathLike, atime: number | string | Date, mtime: number | string | Date, callback: NoParamCallback) => void} Utimes
+ */
+
 /**
  * Defines the output file system type used by this module.
  * @typedef {object} OutputFileSystem
@@ -410,6 +425,10 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @property {Rmdir=} rmdir
  * @property {WriteFile} writeFile
  * @property {Unlink=} unlink
+ * @property {Symlink=} symlink
+ * @property {Readlink=} readlink
+ * @property {Chmod=} chmod
+ * @property {Utimes=} utimes
  * @property {Stat} stat
  * @property {LStat=} lstat
  * @property {ReadFile} readFile
@@ -755,6 +774,13 @@ const lstatReadlinkAbsolute = (fs, p, callback) => {
  */
 const isAbsolute = (pathname) => ABSOLUTE_PATH_REGEXP.test(pathname);
 
+/**
+ * What of a file's mode is its permissions — the type bits above them are not
+ * settable, and the set-user-id and sticky bits are not carried over a copy.
+ */
+const PERMISSIONS_MASK = 0o777;
+
+module.exports.PERMISSIONS_MASK = PERMISSIONS_MASK;
 module.exports.dirname = dirname;
 module.exports.isAbsolute = isAbsolute;
 module.exports.join = join;

package/lib/util/globUtils.js

@@ -558,7 +558,7 @@ const braceFreeGlobToPathRegExpSource = (glob) => {
  * pattern built with `path.resolve` works everywhere; use `[*]` to match a
  * literal `*`), and a relative pattern matches at any depth. Matching follows
  * `path.matchesGlob`, except where its minimatch shows through — see the
- * divergences listed above the corpus in `test/globUtils.unittest.js`.
+ * divergences listed above the corpus in `test/unitCases/globUtils.unittest.js`.
  * @param {string} pattern glob pattern
  * @param {GlobMatchOptions=} options options
  * @returns {((str: string) => boolean) | null} matcher, null for un-compilable patterns

package/lib/util/handlerKeys.js

@@ -0,0 +1,40 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @import RuntimeModule from "../RuntimeModule" */
+
+/**
+ * The one key a chunk's runtime modules install on a handler map, or `null` when
+ * they install several, none, or one a module could not name. Every module states
+ * what it installs, so nothing has to be rendered to find out.
+ * @param {RuntimeModule} runtimeModule the runtime module rendering the dispatch
+ * @param {string} handlers the handler map global
+ * @returns {string | null} the sole handler key, or `null`
+ */
+const getOnlyHandlerKey = (runtimeModule, handlers) => {
+	const { chunkGraph, chunk } = runtimeModule;
+	if (chunkGraph === undefined || chunk === undefined) return null;
+	/** @type {string | null} */
+	let only = null;
+	for (const module of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
+		// TODO webpack 6: call it directly, every runtime module answers by then. A
+		// module built against an older webpack extends a base class without it.
+		const installed =
+			typeof module.getInstalledChunkHandlers === "function"
+				? module.getInstalledChunkHandlers()
+				: null;
+		// A module that cannot name what it installs leaves every map unknowable.
+		if (!Array.isArray(installed)) return null;
+		for (const [map, key] of installed) {
+			if (map !== handlers) continue;
+			if (only !== null && only !== key) return null;
+			only = key;
+		}
+	}
+	return only;
+};
+
+module.exports.getOnlyHandlerKey = getOnlyHandlerKey;