alexander-akait · Sep 7, 2026 · Sep 6, 2026 · Sep 7, 2026 · Sep 7, 2026 · coderabbitai
diff --git a/.changeset/040-css-html-printer-speed.md b/.changeset/040-css-html-printer-speed.md
@@ -0,0 +1,5 @@
+---
+"webpack": patch
+---
+
+Cut allocation and scanning in the CSS and HTML printers, output unchanged.
diff --git a/lib/css/syntax.js b/lib/css/syntax.js
diff --git a/lib/html/htmlMinify.js b/lib/html/htmlMinify.js
@@ -132,13 +132,22 @@ const htmlMinify = async (input, sourceMap, minimizerOptions = {}) => {
 	 * @param {string} text a whole document
 	 * @returns {Promise<string>} the same document, printed
 	 */
-	const printDocument = async (text) =>
-		(
+	const printDocument = async (text) => {
+		// The built-in renderer is synchronous, so with no caller's renderer only
+		// a nested document needs the async pass — and no `srcdoc`, none is there.
+		if (renderEmbeddedSource === undefined && !/srcdoc/i.test(text)) {
+			return new SourceProcessor().process(text, {
+				...printOptions,
+				renderEmbeddedSource: builtin
+			}).code;
+		}
+		return (
 			await new SourceProcessor().processAsync(text, {
 				...printOptions,
 				renderEmbeddedSource: renderer
 			})
 		).code;
+	};
 
 	// Recursion goes through this local name, never the module's own: the plugin
 	// ships this function to its workers as source, where that binding is absent.

diff --git a/lib/html/syntax.js b/lib/html/syntax.js
@@ -7403,6 +7403,9 @@ const startTagInBody = (t) => {
 				isSpecial(node) &&
 				!(_namespaceOf(node) === NS_HTML && ADDRESS_DIV_P.has(_tagNameOf(node)))
 			) {
+				// A list-item-scope boundary (`ul`, `ol`, a table cell) keeps every item
+				// below it out of reach of any `</li>`, whatever the print writes or drops.
+				if (isBoundaryForKind(node, SCOPE_LIST_ITEM)) break;
 				// Inlined rather than a call: this runs for every `<li>` in a list.
 				for (let j = i - 1; j >= 0 && !_printFromSource; j--) {
 					const below = open[j];

diff --git a/lib/util/SourceProcessor.js b/lib/util/SourceProcessor.js
@@ -288,7 +288,7 @@ class PrintContext {
 		this._flattened = 0;
 		/** @type {[number, number, number, number][]} `[chunkIndex, offsetInChunk, srcLine, srcCol]`, output-ordered; a `srcLine` of -1 is one {@link retract} took back with its piece */
 		this._mappings = [];
-		/** @type {Map<number, number> | null} a retractable piece -> the mapping anchored to it, so taking the piece back takes its mapping too */
+		/** @type {number[] | null} by retractable piece index, the mapping anchored to it, so taking the piece back takes its mapping too */
 		this._retractableMappings = null;
 		// A map is built only for a caller that named the input, and that is known
 		// before printing — so a print nobody asks a map of collects none.
@@ -574,7 +574,7 @@ class PrintContext {
 	retract(index) {
 		this._chunks[index] = "";
 		if (this._retractableMappings === null) return;
-		const mapping = this._retractableMappings.get(index);
+		const mapping = this._retractableMappings[index];
 		if (mapping !== undefined) this._mappings[mapping][2] = -1;
 	}
 
@@ -622,10 +622,10 @@ class PrintContext {
 		const at = this.emitRetractable(text === undefined ? this.get(node) : text);
 		this._moveEpoch();
 		if (mapping !== -1) {
-			if (this._retractableMappings === null) {
-				this._retractableMappings = new Map();
-			}
-			this._retractableMappings.set(at, mapping);
+			// Indexed by piece rather than a `Map`: pieces are dense integers, and
+			// nearly every rule minifying goes out as one.
+			if (this._retractableMappings === null) this._retractableMappings = [];
+			this._retractableMappings[at] = mapping;
 		}
 		return at;
 	}
@@ -761,68 +761,44 @@ class PrintContext {
 
 	/**
 	 * @param {SourceMapOptions} options the input's name / content
+	 * @param {string=} code the output {@link result} built, walked for its line breaks
 	 * @returns {SourceMap} the input->output source map
 	 */
-	sourceMap(options) {
+	sourceMap(options, code) {
 		let out = "";
 		let genLine = 0;
 		let genCol = 0;
 		let srcLine = 0;
 		let srcCol = 0;
 		let atLineStart = true;
-		// Where each anchor landed, walked once alongside the mappings — both are
-		// in output order, so this is one pass over the output, not a position
-		// recomputed per mapping. An anchor can sit inside a piece rather than at
-		// its start, since output accumulates into the piece it is appending to.
+		// Walked over the flat output rather than piece by piece: a piece is a rope
+		// until something reads it, and reading each one flattens each one.
+		const text = code === undefined ? this.result() : code;
 		const chunks = this._chunks;
-		const tail = this._tail;
-		/**
-		 * @param {number} i piece index, `chunks.length` being the tail
-		 * @returns {string} that piece
-		 */
-		const pieceAt = (i) => (i === chunks.length ? tail : chunks[i]);
 		let atChunk = 0;
+		let chunkStart = 0;
 		let atOffset = 0;
 		let atLine = 0;
 		let atCol = 0;
-		// Offset of the next newline at or after the cursor, `-1` for none left in
-		// this piece. Carried rather than searched for per mapping: `indexOf` has no
-		// end bound, so asking it again for each of a piece's mappings scans again to
-		// the end of the piece every time — and minified output, the case with no
-		// newlines at all, is the one where that is the whole piece.
-		let nextNewline = pieceAt(0).indexOf("\n");
-		/**
-		 * @param {string} text the piece to walk
-		 * @param {number} to offset to walk to
-		 */
-		const advanceOver = (text, to) => {
-			while (nextNewline !== -1 && nextNewline < to) {
-				atLine++;
-				atCol = 0;
-				atOffset = nextNewline + 1;
-				nextNewline = text.indexOf("\n", atOffset);
-			}
-			atCol += to - atOffset;
-			atOffset = to;
-		};
-		/**
-		 * @param {number} chunk piece index to advance to
-		 * @param {number} offset offset within it
-		 */
-		const advanceTo = (chunk, offset) => {
-			while (atChunk < chunk) {
-				const text = pieceAt(atChunk);
-				advanceOver(text, text.length);
-				atChunk++;
-				atOffset = 0;
-				nextNewline = pieceAt(atChunk).indexOf("\n");
-			}
-			if (offset > atOffset) advanceOver(pieceAt(atChunk), offset);
-		};
+		// Offset of the next newline at or after the cursor, `-1` for none left.
+		// Carried rather than searched for per mapping: `indexOf` has no end bound.
+		let nextNewline = text.indexOf("\n");
 		for (const [chunkIndex, chunkOffset, sl, sc] of this._mappings) {
 			// Its piece was taken back, so there is no output left to anchor.
 			if (sl === -1) continue;
-			advanceTo(chunkIndex, chunkOffset);
+			// A piece's length is stored, so summing them costs nothing per byte.
+			while (atChunk < chunkIndex) chunkStart += chunks[atChunk++].length;
+			const to = chunkStart + chunkOffset;
+			if (to > atOffset) {
+				while (nextNewline !== -1 && nextNewline < to) {
+					atLine++;
+					atCol = 0;
+					atOffset = nextNewline + 1;
+					nextNewline = text.indexOf("\n", atOffset);
+				}
+				atCol += to - atOffset;
+				atOffset = to;
+			}
 			const gl = atLine;
 			const gc = atCol;
 			while (genLine < gl) {
@@ -937,7 +913,11 @@ class PrintContext {
 		if (this._insertIdx < this._inserts.length) this._flushBefore(Infinity);
 		// Nothing was ever cut into its own piece, so there is nothing to join.
 		const chunks = this._chunks;
-		return chunks.length === 0 ? this._tail : chunks.join("") + this._tail;
+		if (chunks.length === 0) return this._tail;
+		// The tail joins as a piece of its own, so the output comes back flat
+		// rather than as a rope over the join that every reader flattens again.
+		this._cutTail();
+		return chunks.join("");
 	}
 }
 
@@ -1052,16 +1032,21 @@ class SourceProcessor {
 		);
 		this._grammar(input, this._visitors, ctx, opts);
 		const name = /** @type {{ source?: string, content?: string }} */ (opts);
-		const build = () => ({
-			code: ctx.result(),
-			// Built only for a caller that named the input: building one walks the
-			// whole output for its line breaks, and the minifier prints an inline
-			// `style=""` — which asks for no map — thousands of times a document.
-			map:
-				name.source === undefined
-					? undefined
-					: ctx.sourceMap({ source: name.source, content: name.content })
-		});
+		const build = () => {
+			const code = ctx.result();
+			return {
+				code,
+				// Built only for a caller that named the input: a map walks the whole
+				// output, and an inline `style=""` asks for none thousands of times a page.
+				map:
+					name.source === undefined
+						? undefined
+						: ctx.sourceMap(
+								{ source: name.source, content: name.content },
+								code
+							)
+			};
+		};
 		if (this._deferred !== null) {
 			const finish = this._deferred;
 

diff --git a/test/HtmlSyntax.unittest.js b/test/HtmlSyntax.unittest.js
@@ -5158,6 +5158,57 @@ describe("SourceProcessor — removeImpliedTags", () => {
 		).toBe("<body><!--c--><p>x");
 	});
 
+	// A `<li>` closes the item it is a sibling of, and no item held below a
+	// list-item-scope boundary — a list it nests into, or the cell it sits in.
+	describe("a later <li> against a list-item-scope boundary", () => {
+		/**
+		 * @param {string} html the source
+		 * @returns {string} the minified serialization
+		 */
+		const item = (html) =>
+			new SourceProcessor().process(html, {
+				mode: "minify",
+				removeImpliedTags: true
+			}).code;
+
+		it("omits the end tag of the item it is a sibling of", () => {
+			expect(item("<ul><li>a</li><li>b</li></ul>")).toBe("<ul><li>a<li>b</ul>");
+			expect(item("<li>a</li><li>b</li>")).toBe("<li>a<li>b");
+		});
+
+		it("keeps the end tag of an item the nested list holds", () => {
+			// The `<script>` after the nested item is content its end tag cannot be
+			// omitted in front of, so only the outer `<li>c` closes a sibling.
+			expect(
+				item("<ul><li>a<ul><li>b</li><script></script></ul><li>c</li></ul>")
+			).toBe("<ul><li>a<ul><li>b</li><script></script></ul><li>c</ul>");
+			expect(item("<ul><li>a<ul><li>b</li>tail</ul><li>c</li></ul>")).toBe(
+				"<ul><li>a<ul><li>b</li>tail</ul><li>c</ul>"
+			);
+		});
+
+		it("omits it where the nested item ends its own list", () => {
+			expect(item("<ul><li>a<ul><li>b</li></ul><li>c</li></ul>")).toBe(
+				"<ul><li>a<ul><li>b</ul><li>c</ul>"
+			);
+		});
+
+		it("keeps the end tag of an item another cell holds", () => {
+			expect(
+				item(
+					"<table><tr><td><ul><li>a</li><script></script></ul><td><ul><li>b</li></ul></table>"
+				)
+			).toBe(
+				"<table><tr><td><ul><li>a</li><script></script></ul><td><ul><li>b</ul></table>"
+			);
+			expect(
+				item(
+					"<table><tr><th><ol><li>a</li></ol><th><ol><li>b</li></ol></table>"
+				)
+			).toBe("<table><tr><th><ol><li>a</ol><th><ol><li>b</ol></table>");
+		});
+	});
+
 	it("keeps a <html> that carries an attribute", () => {
 		expect(
 			new SourceProcessor().process("<html lang=en><body>x", { mode: "minify" })

diff --git a/test/SourceProcessor.unittest.js b/test/SourceProcessor.unittest.js
@@ -201,6 +201,48 @@ describe("SourceProcessor", () => {
 			});
 		}
 
+		// The map is walked over the flat output, so a piece the print took back
+		// takes its mapping with it and a newline still opens a generated line.
+		describe("over the flat output", () => {
+			// cspell:ignore CAIA
+
+			// The first declaration is the one the second overrides, so minifying
+			// retracts the piece it was written into.
+			const SOURCE =
+				"a {\n  color : red ;\n  color : blue ;\n}\nb {\n  color : lime ;\n}\n";
+
+			/**
+			 * @param {"minify" | "beautify"} mode how to print
+			 * @returns {{ code: string, mappings: string }} output and its mappings
+			 */
+			const printed = (mode) => {
+				const { code, map } = new CssSourceProcessor().process(SOURCE, {
+					mode,
+					source: "in.css",
+					content: SOURCE
+				});
+				return { code, mappings: map.mappings };
+			};
+
+			it("drops the mapping of a piece the print took back", () => {
+				// Two mappings, not three: the anchor written with `color:red` is gone,
+				// and `b` still maps to its own line rather than to the dropped one.
+				expect(printed("minify")).toEqual({
+					code: "a{color:blue}b{color:lime}",
+					mappings: "AAAA,aAIA"
+				});
+			});
+
+			it("counts a generated line for each newline the output holds", () => {
+				// `;;;` is the three line breaks before `b`, found in the flat output
+				// rather than in the pieces it was built from.
+				expect(printed("beautify")).toEqual({
+					code: "a {\ncolor: red;\ncolor: blue;\n}b {\ncolor: lime;\n}",
+					mappings: "AAAA;;;CAIA"
+				});
+			});
+		});
+
 		// A prefixed rule an unprefixed twin makes dead weight is taken back after
 		// it was written, so the mapping anchored to it has to go with it.
 		it("css anchors nothing at a rule the prefix pass took back", () => {

diff --git a/types.d.ts b/types.d.ts
@@ -22774,7 +22774,7 @@ declare class PrintContext<TPath, TNode, TPrintOptions = object> {
 	 * them ahead of the next top-level node as well.
 	 */
 	takeInserts(start: number, end: number): string;
-	sourceMap(options: SourceMapOptions): SourceMap;
+	sourceMap(options: SourceMapOptions, code?: string): SourceMap;
 
 	/**
 	 * Stand the text `resolve` gives back in place of every deferred write left
@@ -28882,6 +28882,12 @@ declare class TokenStream {
 	 */
 	advance(): void;
 
+	/**
+	 * Step over the whitespace the next token would be, without tokenizing it —
+	 * for the sites that discard whitespace tokens. No-op while a token is cached.
+	 */
+	skipWhitespace(): void;
+
 	/**
 	 * Mark (CSS Syntax §3 "mark") — push the current cursor position.
 	 */