@@ -0,0 +1,5 @@
+---
+"webpack": patch
+---
+
+Read a regular expression repeating a capture group name in linear time.
@@ -8,6 +8,7 @@
     "absolutify",
     "accesskey",
     "acircular",
+    "acornjs",
     "akait",
     "amaro",
     "amdmodule",
 
@@ -34,6 +34,10 @@ const hasProp = (obj) => {
 	return false;
 };
 
+// Which comparison last marked a disjunction, so that a walk's marks are
+// told apart from the previous walk's without clearing them.
+let branchWalk = 0;
+
 /**
  * Which disjunction branch a named group sits in, so that the same name in two
  * alternatives of one disjunction is allowed and a repeat in one is not.
@@ -47,24 +51,41 @@ class BranchID {
 		this.parent = parent;
 		/** @type {BranchID} */
 		this.base = base || this;
+		// which walk last marked this disjunction, and with which of its branches
+		this.walk = 0;
+		/** @type {BranchID | null} */
+		this.taken = null;
 	}
 
 	/**
+	 * Two branches are separated when some disjunction they both sit under took
+	 * a different alternative for each, so nothing can match both.
 	 * @param {BranchID} alt the other branch
 	 * @returns {boolean} whether the two are alternatives of one disjunction
 	 */
 	separatedFrom(alt) {
+		// WHY: a chain holds at most one branch per disjunction — siblings share
+		// a parent, so a chain takes one of them — so marking each disjunction
+		// this chain passed answers the whole comparison in one walk of the
+		// other. acorn walks one chain per node of the other, which is quadratic
+		// in the nesting depth and re-walked per same-named group (acorn#1445).
+		const walk = ++branchWalk;
 		/** @type {BranchID | null} */
 		let self = this;
 		while (self) {
-			/** @type {BranchID | null} */
-			let other = alt;
-			while (other) {
-				if (self.base === other.base && self !== other) return true;
-				other = other.parent;
-			}
+			self.base.walk = walk;
+			self.base.taken = self;
 			self = self.parent;
 		}
+		/** @type {BranchID | null} */
+		let other = alt;
+		while (other) {
+			const disjunction = /** @type {BranchID} */ (other.base);
+			if (disjunction.walk === walk && disjunction.taken !== other) {
+				return true;
+			}
+			other = other.parent;
+		}
 		return false;
 	}
 
 
@@ -49,6 +49,14 @@ const PATTERNS = [
 	["(?:(?<x>a)|(?<x>b))\\k<x>", "u"],
 	["(?<x>a)(?:(?<x>b))", "u"],
 	["(?<x>a)(?:(?<x>b)|c)", "u"],
+	// a name repeated across nested disjunctions, where the two are separated
+	// only when one alternative of one disjunction rules the other out
+	["(?:(?<x>a)|b)(?:(?<x>c)|d)", "u"],
+	["(?:(?:(?<x>a)|b)|(?:(?<x>c)|d))", "u"],
+	["(?:(?<x>a)|(?:(?<x>b)|c))", "u"],
+	["(?:(?<x>a)|(?:b(?<x>c)))|(?<x>d)", "u"],
+	["(?:(?:(?:(?<x>a))))|(?:(?:(?:(?<x>b))))", "u"],
+	["(?:(?:(?:(?<x>a))))(?:(?:(?:(?<x>b))))", "u"],
 	["(?<n>a)\\k<m>", ""],
 	["(?<n>a)\\k<m>", "u"],
 	["\\k<n>", ""],
@@ -351,4 +359,47 @@ describe("RegExpValidator", () => {
 			/Unterminated group/
 		);
 	});
+
+	it("reads a name repeated across alternatives at the cost of distinct ones", () => {
+		// Both patterns are legal and the same size; only the duplicate one asks
+		// which alternatives rule each other out, which acorn answers by walking
+		// one branch chain per node of the other (acornjs/acorn#1445).
+		/**
+		 * @param {number} depth how many disjunctions enclose the group
+		 * @param {string} name the group's name
+		 * @returns {string} one named group, nested that deep
+		 */
+		const nest = (depth, name) =>
+			`${"(?:".repeat(depth)}(?<${name}>a)${")".repeat(depth)}`;
+
+		/**
+		 * @param {number} count how many alternatives to write
+		 * @param {number} depth how deep each one nests its group
+		 * @param {boolean} duplicate whether every group carries the same name
+		 * @returns {string} the program holding that regexp literal
+		 */
+		const pattern = (count, depth, duplicate) =>
+			`/${Array.from({ length: count }, (_, i) =>
+				nest(depth, duplicate ? "x" : `x${i}`)
+			).join("|")}/v;`;
+
+		/**
+		 * @param {string} source the program to parse
+		 * @returns {number} the fastest of three parses, in nanoseconds
+		 */
+		const best = (source) => {
+			let fastest = Infinity;
+			for (let run = 0; run < 3; run++) {
+				const started = process.hrtime.bigint();
+				Parser.parse(source, { ecmaVersion: "latest" });
+				fastest = Math.min(fastest, Number(process.hrtime.bigint() - started));
+			}
+			return fastest;
+		};
+		const distinct = best(pattern(160, 160, false));
+		const repeated = best(pattern(160, 160, true));
+		// The two were ~80x apart before the rewrite and are within noise of each
+		// other after it, so the bound only has to catch the quadratic walk.
+		expect(repeated).toBeLessThan(distinct * 10);
+	});
 });
@@ -1270,6 +1270,13 @@ declare interface Bootstrap {
 declare abstract class BranchID {
 	parent: null | BranchID;
 	base: BranchID;
+	walk: number;
+	taken: null | BranchID;
+
+	/**
+	 * Two branches are separated when some disjunction they both sit under took
+	 * a different alternative for each, so nothing can match both.
+	 */
 	separatedFrom(alt: BranchID): boolean;
 	sibling(): BranchID;
 }
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"webpack": patch
 +---
++
 +Read a regular expression repeating a capture group name in linear time.