@@ -0,0 +1,5 @@
+---
+"webpack": patch
+---
+
+Speed up externals matching, including the built-in modules of node targets.
@@ -968,6 +968,8 @@ class ExternalModule extends Module {
 		this.interop = interop;
 		/** @type {boolean | undefined} declared side-effects state (undefined = assume side effects, webpack can't analyze an external) */
 		this.sideEffects = sideEffects;
+		/** @type {string | undefined} */
+		this._identifier = undefined;
 		if (sideEffects !== undefined) {
 			this.factoryMeta = { sideEffectFree: !sideEffects };
 		}
@@ -1038,6 +1040,8 @@ class ExternalModule extends Module {
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
+		// Concatenation asks once per reference, and building it stringifies the request.
+		if (this._identifier !== undefined) return this._identifier;
 		let id = `external ${this._resolveExternalType(
 			this.externalType
 		)} ${JSON.stringify(this.request)}`;
@@ -1058,7 +1062,7 @@ class ExternalModule extends Module {
 		if (this.sideEffects !== undefined) {
 			id += `|sideEffects=${this.sideEffects}`;
 		}
-		return id;
+		return (this._identifier = id);
 	}
 
 	/**
 
@@ -129,6 +129,38 @@ const OPTIONS_FORM_KEYS = new Set(["external", "sideEffects"]);
 
 const PLUGIN_NAME = "ExternalModuleFactoryPlugin";
 
+/**
+ * An externals array with each run of strings merged into one set.
+ * @typedef {object} GroupedExternals
+ * @property {Externals[]} source the entries the grouping was built from
+ * @property {(Externals | Set<string>)[]} entries the entries, each run of strings as one set
+ * @property {number[]} ends for each entry, the index in the array just past it
+ */
+
+/**
+ * Whether matching an externals entry can call user code, which may change the array.
+ * Only a set of strings is matched without it: a RegExp may override `test`, an object may hold a `byLayer` function.
+ * @param {Externals | Set<string>} entry a grouped entry
+ * @returns {boolean} true unless the entry is a set of strings
+ */
+const mayRunUserCode = (entry) => !(entry instanceof Set);
+
+/**
+ * Whether an externals array still holds the entries it was grouped from.
+ * An externals function may change the array while requests are matched.
+ * @param {Externals[]} externals externals array
+ * @param {GroupedExternals} grouped its grouping
+ * @returns {boolean} true when the grouping is current
+ */
+const isCurrentGrouping = (externals, grouped) => {
+	const { source } = grouped;
+	if (externals.length !== source.length) return false;
+	for (let i = 0; i < source.length; i++) {
+		if (externals[i] !== source[i]) return false;
+	}
+	return true;
+};
+
 class ExternalModuleFactoryPlugin {
 	/**
 	 * Creates an instance of ExternalModuleFactoryPlugin.
@@ -148,6 +180,47 @@ class ExternalModuleFactoryPlugin {
 	 */
 	apply(normalModuleFactory) {
 		const globalType = this.type;
+		/** @type {WeakMap<Externals[], GroupedExternals>} */
+		const groupedArrays = new WeakMap();
+
+		/**
+		 * Merges each run of request strings in an externals array into one set.
+		 * A string entry always externalizes the request as written, so which string of a run matched never matters.
+		 * @param {Externals[]} externals externals array
+		 * @returns {GroupedExternals} the entries with each run of strings as a set, regrouped when the array changed
+		 */
+		const getGroupedArray = (externals) => {
+			const cached = groupedArrays.get(externals);
+			if (cached !== undefined && isCurrentGrouping(externals, cached)) {
+				return cached;
+			}
+			/** @type {GroupedExternals["entries"]} */
+			const entries = [];
+			/** @type {number[]} */
+			const ends = [];
+			/** @type {Set<string> | undefined} */
+			let strings;
+			for (let i = 0; i < externals.length; i++) {
+				const item = externals[i];
+				if (typeof item === "string") {
+					if (strings === undefined) {
+						strings = new Set();
+						entries.push(strings);
+						ends.push(i + 1);
+					}
+					strings.add(item);
+					ends[ends.length - 1] = i + 1;
+				} else {
+					strings = undefined;
+					entries.push(item);
+					ends.push(i + 1);
+				}
+			}
+			/** @type {GroupedExternals} */
+			const grouped = { source: [...externals], entries, ends };
+			groupedArrays.set(externals, grouped);
+			return grouped;
+		};
 		normalModuleFactory.hooks.factorize.tapAsync(
 			PLUGIN_NAME,
 			(data, callback) => {
@@ -162,6 +235,7 @@ class ExternalModuleFactoryPlugin {
 					? dependency.originalRequest
 					: request;
 				const hasOriginalRequest = originalRequest !== request;
+				const alternateRequest = getAlternateCoreModuleRequest(request);
 
 				/** @typedef {(err?: Error | null, externalModule?: ExternalModule) => void} HandleExternalCallback */
 
@@ -322,12 +396,16 @@ class ExternalModuleFactoryPlugin {
 						if (
 							externals === request ||
 							(hasOriginalRequest && externals === originalRequest) ||
-							externals === getAlternateCoreModuleRequest(request)
+							externals === alternateRequest
 						) {
 							return handleExternal(originalRequest, undefined, callback);
 						}
 					} else if (Array.isArray(externals)) {
-						let i = 0;
+						const grouped = getGroupedArray(externals);
+						const { entries, ends } = grouped;
+						let groupIndex = 0;
+						// The index into `externals` once a non-string entry changed the array.
+						let liveIndex = -1;
 						const next = () => {
 							/** @type {boolean | undefined} */
 							let asyncFlag;
@@ -351,8 +429,37 @@ class ExternalModuleFactoryPlugin {
 
 							do {
 								asyncFlag = true;
-								if (i >= externals.length) return callback();
-								handleExternals(externals[i++], handleExternalsAndCallback);
+								if (
+									liveIndex === -1 &&
+									groupIndex > 0 &&
+									mayRunUserCode(entries[groupIndex - 1]) &&
+									!isCurrentGrouping(externals, grouped)
+								) {
+									liveIndex = ends[groupIndex - 1];
+								}
+								if (liveIndex !== -1) {
+									if (liveIndex >= externals.length) return callback();
+									handleExternals(
+										externals[liveIndex++],
+										handleExternalsAndCallback
+									);
+									continue;
+								}
+								if (groupIndex >= entries.length) return callback();
+								const item = entries[groupIndex++];
+								if (item instanceof Set) {
+									if (
+										item.has(request) ||
+										(hasOriginalRequest && item.has(originalRequest)) ||
+										(alternateRequest !== undefined &&
+											item.has(alternateRequest))
+									) {
+										return handleExternal(originalRequest, undefined, callback);
+									}
+									asyncFlag = false;
+								} else {
+									handleExternals(item, handleExternalsAndCallback);
+								}
 							} while (!asyncFlag);
 							asyncFlag = false;
 						};
@@ -470,7 +577,6 @@ class ExternalModuleFactoryPlugin {
 							);
 						}
 						// Fall back to the `node:`-prefixed/unprefixed core module form.
-						const alternateRequest = getAlternateCoreModuleRequest(request);
 						if (
 							alternateRequest !== undefined &&
 							Object.prototype.hasOwnProperty.call(
 
@@ -0,0 +1,11 @@
+it("should keep the order of string entries in an externals array", () => {
+	const os = require("os");
+	expect(typeof os.platform).toBe("function");
+	const path = require("path");
+	expect(typeof path.join).toBe("function");
+	expect(path.platform).toBeUndefined();
+	expect(require("node:path")).toBe(path);
+	expect(typeof require("util").inspect).toBe("function");
+	expect(require("os-alias")).toBe(os);
+	expect(typeof require("zlib").gzipSync).toBe("function");
+});
@@ -0,0 +1,39 @@
+"use strict";
+
+/** @type {import("../../../../").ExternalItem[]} */
+const externals = [
+	"path",
+	"util",
+	// Runs between two runs of strings, so it must still win for "os-alias".
+	({ request }, callback) => {
+		if (request === "os-alias") return callback(null, "os");
+		// Appends an entry while matching: this walk and later ones must see it.
+		if (request === "os" && !externals.includes("os")) externals.push("os");
+		// Replaces an entry in place while matching a request nothing externalizes.
+		if (request.startsWith("./index")) externals[4] = { path: "os" };
+		callback();
+	},
+	"os-alias",
+	// The strings above match "path" first, so this mapping never applies.
+	{ path: "os" },
+	// A RegExp subclass runs user code too, and may append an entry the same way.
+	new (class extends RegExp {
+		/**
+		 * @param {string} request the request
+		 * @returns {boolean} never a match itself
+		 */
+		test(request) {
+			if (request === "zlib" && !externals.includes("zlib")) {
+				externals.push("zlib");
+			}
+			return false;
+		}
+	})("^$")
+];
+
+/** @type {import("../../../../").Configuration} */
+module.exports = {
+	target: "web",
+	externalsType: "commonjs",
+	externals
+};
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"webpack": patch
 +---
++
 +Speed up externals matching, including the built-in modules of node targets.