webpack 5.112.0 → 5.112.2

package/lib/css/syntax-parser.js

@@ -285,6 +285,8 @@ const CC_LOW_LINE = "_".charCodeAt(0);
 const CC_LOWER_A = "a".charCodeAt(0);
 const CC_LOWER_D = "d".charCodeAt(0);
 const CC_LOWER_F = "f".charCodeAt(0);
+const CC_LOWER_I = "i".charCodeAt(0);
+const CC_LOWER_S = "s".charCodeAt(0);
 const CC_LOWER_E = "e".charCodeAt(0);
 const CC_LOWER_U = "u".charCodeAt(0);
 const CC_LOWER_R = "r".charCodeAt(0);
@@ -1790,13 +1792,13 @@ const _NO_SKIP_TYPES = new Uint8Array(32);
 // rules, the common case. Every consumer reads these lists read-only, so one
 // instance replaces an empty array per rule, and freezing makes a push fail.
 const _EMPTY_LIST = /** @type {Rule[]} */ (
-	/** @type {unknown} */ (Object.freeze([]))
+	/** @type {Rule[] | ReadonlyArray<never>} */ (Object.freeze([]))
 );
 // `consumeABlock`'s and `consumeABlocksContentsInto`'s results, written instead
 // of returned — see there. Read them immediately; the next block overwrites them.
 /** @type {Declaration[]} */
 let _blockDecls = /** @type {Declaration[]} */ (
-	/** @type {unknown} */ (_EMPTY_LIST)
+	/** @type {Declaration[] | Rule[]} */ (_EMPTY_LIST)
 );
 /** @type {Rule[]} */
 let _blockRules = _EMPTY_LIST;
@@ -1804,7 +1806,7 @@ let _blockStart = 0;
 let _blockEnd = 0;
 /** @type {Declaration[]} */
 let _bcDecls = /** @type {Declaration[]} */ (
-	/** @type {unknown} */ (_EMPTY_LIST)
+	/** @type {Declaration[] | Rule[]} */ (_EMPTY_LIST)
 );
 /** @type {Rule[]} */
 let _bcRules = _EMPTY_LIST;
@@ -1888,7 +1890,9 @@ let _declBodies = [];
 /** @type {Node[][]} */
 let _ruleBodies = [];
 
-let _locConverter = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+let _locConverter = /** @type {LocConverter} */ (
+	/** @type {LocConverter | null} */ (null)
+);
 // The caller's input before §3.3 replaced its NULs, the same length, which
 // `A.source` slices so a node reads exactly as written.
 let _originalInput = "";
@@ -1896,9 +1900,10 @@ let _originalInput = "";
 // Node refs are integers here but typed `Node` across the parser; these are
 // identity casts that just satisfy the type system at the boundary.
 /** @type {(n: Node) => number} */
-const _nodeIndex = (n) => /** @type {number} */ (/** @type {unknown} */ (n));
+const _nodeIndex = (n) =>
+	/** @type {number} */ (/** @type {number | Node} */ (n));
 /** @type {(i: number) => Node} */
-const _nodeRef = (i) => /** @type {Node} */ (/** @type {unknown} */ (i));
+const _nodeRef = (i) => /** @type {Node} */ (/** @type {Node | number} */ (i));
 
 /** @param {number} need minimum capacity */
 const _grow = (need) => {
@@ -2105,6 +2110,16 @@ const _setValue = (r, list) => {
 	}
 	_listPool.push(list);
 };
+/**
+ * Empties the body arrays between top-level nodes by popping: `length = 0`
+ * drops the backing store, so the next rule's first push reallocates it.
+ */
+const _dropBodies = () => {
+	for (let k = _declBodies.length; k > 0; k--) {
+		_declBodies.pop();
+		_ruleBodies.pop();
+	}
+};
 /** @type {(r: Node, decls: Node[], childRules: Node[]) => void} */
 const _setBody = (r, decls, childRules) => {
 	_bodyIdx[_nodeIndex(r)] = _declBodies.length + 1;
@@ -2583,7 +2598,7 @@ const normalizeIntoTokenStream = (input, pos, onComment) => {
 // Shared frozen empty list for a block body with no declarations / child rules,
 // so equal-empty reads return one reference (mirrors `_EMPTY_LIST`).
 const _READER_EMPTY = /** @type {Rule[]} */ (
-	/** @type {unknown} */ (Object.freeze([]))
+	/** @type {Rule[] | ReadonlyArray<never>} */ (Object.freeze([]))
 );
 
 /**
@@ -2651,7 +2666,7 @@ const _readRefList = (store, list) => {
 // that reader's `_store` snapshot by `_i`. Created once rather than per store,
 // so all readers share one hidden map and stay monomorphic across parses.
 const NODE_READER_PROTO = /** @type {NodeReader} */ ({
-	_store: /** @type {NodeStore} */ (/** @type {unknown} */ (null)),
+	_store: /** @type {NodeStore} */ (/** @type {NodeStore | null} */ (null)),
 	_i: 0,
 	get type() {
 		return this._store.types[this._i];
@@ -2880,7 +2895,9 @@ const _finishStore = () => {
 	_ruleBodies = [];
 	_listPool.length = 0;
 	_S._input = "";
-	_locConverter = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+	_locConverter = /** @type {LocConverter} */ (
+		/** @type {LocConverter | null} */ (null)
+	);
 	return store;
 };
 
@@ -3271,8 +3288,8 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 	// two non-whitespace tokens the `--foo: {` disambiguation below needs.
 	const skip = _skipSelectorPrelude;
 	// Non-skip: first two non-whitespace prelude nodes (computed at the `{`).
-	let first = /** @type {Node} */ (/** @type {unknown} */ (0));
-	let second = /** @type {Node} */ (/** @type {unknown} */ (0));
+	let first = /** @type {Node} */ (/** @type {Node | number} */ (0));
+	let second = /** @type {Node} */ (/** @type {Node | number} */ (0));
 	// Skip mode: the same two tokens tracked by token type + start, so a dropped
 	// leaf selector token needs no materialized node just for the disambiguation.
 	// `0` (no token type) = unset.
@@ -4445,7 +4462,7 @@ const TOP_LEVEL_CONSUMERS = {
  * @property {boolean=} convertLengthUnits rewrite a length into a shorter unit it is exactly equal in (`16px` -> `1pc`); off by default because it earns nothing once the asset is compressed, and only read while printing. A time is always rewritten
  * @property {boolean=} convertApproximateColors write a polar or Lab color as the nearest hex even where that hex only approximates it: a channel too near a `.5` boundary for two engines to round it alike, and a color outside the sRGB gamut, which hex can only clip. Off by default, and only read while printing; a space engines read through transfers of their own (`a98-rgb`, `prophoto-rgb`) is left alone either way
  * @property {boolean=} mergeDistantRules give a rule the selectors of a later one printing the same block, and an at-rule the block of a later one stating the same condition, past the rules between them; off by default, since it reorders the cascade and is sound only where nothing between declares what the block being moved does for an element it can match — a condition between counting for what its own rules declare
- * @property {boolean=} dropOverriddenDeclarations drop a declaration a later one in the same block overrides even where nothing states that the target can read the later value; off by default, and only read while printing. With a `browserslist` selection the drop is already made wherever every browser it names is known to read the later value, so this widens the case where no target is selected — a selection naming a browser the tables do not cover still answers for the whole of it
+ * @property {boolean=} dropOverriddenDeclarations drop a declaration a later one in the same block overrides even where no target is selected, wherever Chromium, Gecko and WebKit each read the later value; off by default, and only read while printing. With a `browserslist` selection the drop is already made wherever every browser it names is known to read the later value, so this widens the case where no target is selected — a selection naming a browser the tables do not cover still answers for the whole of it
  * @property {boolean=} rewriteCustomProperties shorten a custom property's value the way any other value is shortened (`--x:#ffffff` -> `#fff`); off by default because `getPropertyValue()` hands that text back, and only read while printing. What it may rewrite is what any other value's tokens may be, a color in a substitution's fallback included — that being the property's value rather than the function's own argument
  * @property {EmbeddedSourceRenderer=} renderEmbeddedSource renders source this stylesheet embeds: the payload of a `url()` `data:` URL whose media type names a language webpack knows (SVG, CSS, HTML, JSON, JavaScript). Absent, a data URL is emitted exactly as written
  * @property {{ [name: string]: string }=} pseudoClasses each pseudo-class to write as a class instead (`{ "focus-visible": "focus-visible" }`), so a script can apply it where the engine does not. Only read while printing
@@ -4475,8 +4492,38 @@ const TOP_LEVEL_CONSUMERS = {
 // recursive call sites monomorphic and allocates no closure per parse.
 /** @typedef {import("../util/SourceProcessor").CompiledVisitorBucket<CssPath>} CompiledVisitorBucket */
 /** @type {CompiledVisitorMap} */
-let _visitors = /** @type {CompiledVisitorMap} */ (/** @type {unknown} */ ([]));
+let _visitors = /** @type {CompiledVisitorMap} */ (
+	/** @type {CompiledVisitorMap | never[]} */ ([])
+);
 let _recurseBlocks = true;
+// WHY: a block of declarations alone prints the same wherever its source text
+// and the few rules read around it are the same, and half the blocks a sheet
+// holds are written again; each body is composed once and handed back after.
+/** @type {Map<string, string> | null} */
+let _blockMemo = null;
+/** @type {Node | null} the rule `_blockMemoBody` was found for */
+let _blockMemoNode = null;
+/** @type {string | undefined} the body found for it, undefined to compose one */
+let _blockMemoBody;
+/** @type {string} the key a miss stores its body under, "" for none */
+let _blockMemoKey = "";
+// The tables a block is looked up in, one per what encloses it: the top level's
+// is `_blockMemo`. `_blockMemoTable` is the last one keyed, and
+// `_blockMemoKeyTable` the one `_blockMemoKey` belongs to.
+/** @type {Map<string, Map<string, string>>} */
+const _blockMemoScopes = new Map();
+/** @type {Map<string, string>} */
+let _blockMemoTable = new Map();
+/** @type {Map<string, string>} */
+let _blockMemoKeyTable = _blockMemoTable;
+// The same for one declaration, where its block is not one written before.
+/** @type {Map<string, string> | null} */
+let _declarationMemo = null;
+/** @type {string} the key the declaration being walked stores its text under */
+let _declarationMemoKey = "";
+// The declaration memo's keys whose value is one component.
+/** @type {Set<string> | null} */
+let _singleValueKeys = null;
 // Printing needs a faithful serialization, so it keeps dropped input as `NodeType.Raw`
 // nodes; a walk-only parse leaves this false and allocates none.
 let _printing = false;
@@ -4518,7 +4565,7 @@ const _grammarOnComment = (_src, start, end) => {
 	_S._currentNode = node;
 	_currentParent = null;
 	_currentIndex = 0;
-	const bucket = /** @type {CompiledVisitorBucket} */ (_commentBucket);
+	const bucket = _commentBucket;
 	const e = bucket.enter;
 	for (let i = 0; i < e.length; i++) e[i](A);
 	const x = bucket.exit;
@@ -4572,6 +4619,76 @@ const _mayBeMathFunction = (start) => {
 	return (_MATH_NAME_FIRST_LETTERS & (1 << (first - 0x61))) !== 0;
 };
 
+// The leaves the CSS printer writes as their source text, whitespace as `_SEP`
+// and an identifier or hash outside a value (`_printVerbatimLeaf`).
+const _VERBATIM_LEAVES = new Uint8Array(32);
+_VERBATIM_LEAVES[NodeType.Whitespace] = 1;
+_VERBATIM_LEAVES[NodeType.Delim] = 1;
+_VERBATIM_LEAVES[NodeType.Comma] = 1;
+_VERBATIM_LEAVES[NodeType.Colon] = 1;
+_VERBATIM_LEAVES[NodeType.Ident] = 1;
+_VERBATIM_LEAVES[NodeType.Hash] = 1;
+/** @type {EXPECTED_FUNCTION | null} */
+let _verbatimLeafPrinter = null;
+
+/**
+ * Name the printer that writes `_VERBATIM_LEAVES` as their source text, so a
+ * walk printing through it stores their text without calling it.
+ * @param {EXPECTED_FUNCTION} printer the CSS printer
+ * @returns {void}
+ */
+const setVerbatimLeafPrinter = (printer) => {
+	_verbatimLeafPrinter = printer;
+};
+
+/**
+ * Store what the CSS printer writes for a `_VERBATIM_LEAVES` node, without a
+ * call through it: they are half the nodes a stylesheet holds. Most print as
+ * their source, which the writer reads only once something asks for it.
+ * @param {number} ty the node's type
+ * @param {Node} node the node
+ * @param {Node | null} parent its parent
+ * @param {PrintContext} writer the print context
+ * @returns {boolean} false to call the printer instead
+ */
+const _printVerbatimLeaf = (ty, node, parent, writer) => {
+	if (ty === NodeType.Whitespace) {
+		writer.printedAs(node, _SEP);
+		return true;
+	}
+	// An identifier is a keyword and a hash a color the printer may rewrite only
+	// in a value, and their escapes are respelled anywhere.
+	const ident = ty === NodeType.Ident || ty === NodeType.Hash;
+	if (ident && parent !== null && _within[NodeType.Declaration] !== 0) {
+		return false;
+	}
+	const i = _nodeIndex(node);
+	const start = _starts[i];
+	const end = _ends[i];
+	// The end of the input is where `_printedSource` resolves a trailing escape.
+	if (end === _S._input.length) {
+		const text = _printedSource(node);
+		if (ident) {
+			if (text.includes("\\")) return false;
+			writer.printedAs(node, text);
+		} else {
+			writer.printedAs(node, text === "\\" ? "\\\n" : text);
+		}
+		return true;
+	}
+	if (ident) {
+		if (_rangeHasEscape(start, end)) return false;
+	} else if (
+		end - start === 1 &&
+		_S._input.charCodeAt(start) === CC_REVERSE_SOLIDUS
+	) {
+		writer.printedAs(node, "\\\n");
+		return true;
+	}
+	writer.printedSource(node, _printedSource);
+	return true;
+};
+
 /**
  * Walk a component-value subtree; children are already materialized. Fetches
  * the node's visitor bucket once (reused for enter + exit) and uses index
@@ -4665,7 +4782,15 @@ const _walkValue = (node, parent, index, writer) => {
 		_within[ty]--;
 		_S._inColorOperand = previousColorOperand;
 	}
-	_exitNode(node, parent, index, b, writer);
+	if (
+		b !== undefined ||
+		writer === undefined ||
+		_VERBATIM_LEAVES[ty] === 0 ||
+		writer._printer !== _verbatimLeafPrinter ||
+		!_printVerbatimLeaf(ty, node, parent, writer)
+	) {
+		_exitNode(node, parent, index, b, writer);
+	}
 	if (enteredMath) _S._mathFunctionDepth--;
 	if (enteredStepped) _S._steppedFunctionDepth--;
 	if (enteredSupports) {
@@ -4871,6 +4996,74 @@ const _enterAtRulePrelude = (i0) => {
 	}
 };
 
+/**
+ * The key a declaration prints under: its source, with the at-rules that read
+ * one as a descriptor.
+ * @param {Node} node the declaration
+ * @param {number} i0 its node index
+ * @returns {string} the key, "" where it is not one to reuse
+ */
+const _declarationMemoKeyOf = (node, i0) => {
+	const start = _starts[i0];
+	const end = _ends[i0];
+	const input = _S._input;
+	if (end === input.length) return "";
+	const text = input.slice(start, end);
+	// A comment kept in the value is written where it stands, once.
+	if (text.includes("/*")) return "";
+	// Bare where no descriptor at-rule is around, which no other key can equal:
+	// those start with a letter naming one, and no source holds a NUL.
+	return !_S._inPropertyRule && !_S._inFunctionRule && !_S._inFeatureValuesRule
+		? text
+		: `${_S._inPropertyRule ? "p" : ""}${_S._inFunctionRule ? "f" : ""}${
+				_S._inFeatureValuesRule ? "v" : ""
+			}\0${text}`;
+};
+
+/**
+ * The key a qualified rule's block of declarations is composed under: its
+ * source, with what the walk around it decides of how it prints.
+ * @param {number} i0 the rule's node index
+ * @param {Node | null} parent the node it sits in
+ * @returns {string} the key, "" where the block is not one to reuse
+ */
+const _blockMemoKeyOf = (i0, parent) => {
+	const start = _aux1[i0];
+	const end = _ends[i0];
+	const input = _S._input;
+	if (start === -1 || end === input.length) return "";
+	// A comment kept in the block is written where it stands, once.
+	const block = input.slice(start, end);
+	if (block.includes("/*")) return "";
+	let around = "";
+	if (parent !== null) {
+		const p = _nodeIndex(parent);
+		if (_types[p] !== NodeType.AtRule) return "";
+		around = input.slice(_starts[p], _aux0[p]);
+	}
+	// What is around it picks the table, so the key is the block alone and no
+	// copy of it is built per lookup.
+	if (
+		around.length === 0 &&
+		!_S._inPropertyRule &&
+		!_S._inFunctionRule &&
+		!_S._inFeatureValuesRule
+	) {
+		_blockMemoTable = /** @type {Map<string, string>} */ (_blockMemo);
+		return block;
+	}
+	const scope = `${_S._inPropertyRule ? "p" : ""}${_S._inFunctionRule ? "f" : ""}${
+		_S._inFeatureValuesRule ? "v" : ""
+	}${around}`;
+	let table = _blockMemoScopes.get(scope);
+	if (table === undefined) {
+		table = new Map();
+		_blockMemoScopes.set(scope, table);
+	}
+	_blockMemoTable = table;
+	return block;
+};
+
 /**
  * Walk a structural subtree; an at-rule / qualified-rule's block was parsed
  * eagerly (§5.4.4), so its `value` holds the nested rules / declarations. When
@@ -4920,9 +5113,24 @@ const _walkRule = (node, parent, index, writer) => {
 				const bi = _bodyIdx[i0];
 				if (bi !== 0) {
 					const decls = _declBodies[bi - 1];
-					for (let i = 0; i < decls.length; i++) {
-						_walkRule(decls[i], node, i, writer);
+					const key =
+						_blockMemo !== null &&
+						ty === NodeType.QualifiedRule &&
+						decls.length !== 0 &&
+						_ruleBodies[bi - 1].length === 0
+							? _blockMemoKeyOf(i0, parent)
+							: "";
+					const table = _blockMemoTable;
+					const memo = key === "" ? undefined : table.get(key);
+					if (memo === undefined) {
+						for (let i = 0; i < decls.length; i++) {
+							_walkRule(decls[i], node, i, writer);
+						}
 					}
+					_blockMemoNode = node;
+					_blockMemoBody = memo;
+					_blockMemoKey = memo === undefined ? key : "";
+					_blockMemoKeyTable = table;
 					const ch = _ruleBodies[bi - 1];
 					for (let i = 0; i < ch.length; i++) _walkRule(ch[i], node, i, writer);
 				}
@@ -4931,6 +5139,28 @@ const _walkRule = (node, parent, index, writer) => {
 			_S._inFunctionRule = prevFunction;
 			_S._inFeatureValuesRule = prevFeatureValues;
 		} else if (ty === NodeType.Declaration) {
+			const key =
+				_declarationMemo !== null && b === undefined
+					? _declarationMemoKeyOf(node, i0)
+					: "";
+			if (key !== "") {
+				const memo = /** @type {Map<string, string>} */ (_declarationMemo).get(
+					key
+				);
+				if (memo !== undefined) {
+					_within[ty]--;
+					// Its value's tokens print no text, so a box merge reads what it
+					// needs of them off the flags.
+					if (_mayBeMergeableName(node)) {
+						_flags[i0] |= /** @type {Set<string>} */ (_singleValueKeys).has(key)
+							? _FLAG_MEMO_PRINTED | _FLAG_SINGLE_VALUE
+							: _FLAG_MEMO_PRINTED;
+					}
+					/** @type {PrintContext} */ (writer).printedAs(node, memo);
+					return;
+				}
+				_declarationMemoKey = key;
+			}
 			const vs = _listStarts[i0];
 			const ve = vs + _listLens[i0];
 			// A declaration's value is a value context (its hashes are colors, not
@@ -4978,6 +5208,47 @@ const _walkRule = (node, parent, index, writer) => {
 		_within[ty]--;
 	}
 	_exitNode(node, parent, index, b, writer);
+	if (_declarationMemoKey !== "") {
+		const context = /** @type {PrintContext} */ (writer);
+		const printed = context.get(node);
+		if (!_mayBeMergeableName(node)) {
+			/** @type {Map<string, string>} */ (_declarationMemo).set(
+				_declarationMemoKey,
+				printed
+			);
+		} else if (printed.includes(":")) {
+			/** @type {Map<string, string>} */ (_declarationMemo).set(
+				_declarationMemoKey,
+				printed
+			);
+			if (_valueComponents(A, node, context).length === 1) {
+				/** @type {Set<string>} */ (_singleValueKeys).add(_declarationMemoKey);
+			}
+		}
+		_declarationMemoKey = "";
+	}
+};
+
+// What a declaration printed from the memo carries in its flags, past the
+// public `Flag` bits: that its value's tokens printed nothing, and whether that
+// value is one component, which is all a box merge reads of them.
+const _FLAG_MEMO_PRINTED = 8;
+const _FLAG_SINGLE_VALUE = 16;
+
+/**
+ * Whether a declaration's value is one component, as `_valueComponents` splits
+ * it, answered off its flags where it printed from the memo.
+ * @param {CssPath} path the accessor
+ * @param {Node} node the declaration
+ * @param {PrintContext} writer the print context (children's printed text)
+ * @returns {boolean} true when it is one component
+ */
+const _isSingleValue = (path, node, writer) => {
+	const flags = _flags[_nodeIndex(node)];
+	if ((flags & _FLAG_MEMO_PRINTED) !== 0) {
+		return (flags & _FLAG_SINGLE_VALUE) !== 0;
+	}
+	return _valueComponents(path, node, writer).length === 1;
 };
 
 // WHY: nested-block streaming.
@@ -5078,8 +5349,8 @@ const _frameChainKey = Array.from({ length: _STREAM_MAX_DEPTH }, () => null);
  * travels outward — only `scope` is replaced, by one standing for more — so the
  * collected and the streamed path split a rule the same way, which is what makes
  * the two agree on what a duplicate is.
- * @typedef {{ scope: RuleScope, key: string, at: number, len: number }} RuleSpan
- * @typedef {{ prefix: string, rules: Map<string, { taken: TakenPiece, span: RuleSpan }>, selectors: Map<string, { taken: TakenPiece, span: RuleSpan }[]>, inner: Map<string, RuleScope> }} RuleScope
+ * @typedef {{ scope: RuleScope, key: string, at: number, len: number, taken: TakenPiece | null }} RuleSpan
+ * @typedef {{ prefix: string, rules: Map<string, RuleSpan>, selectors: Map<string, RuleSpan | RuleSpan[]>, inner: Map<string, RuleScope>, noShadow: boolean }} RuleScope
  * @typedef {{ bodyAt: number, prelude: string, keyPrelude: string, qualified: boolean, spans: RuleSpan[] }} BlockSpans
  */
 // A span no later copy is read against: it is there to be cut, not to key a
@@ -5090,14 +5361,108 @@ const UNKEYED = "";
 /** @type {BlockSpans[]} */
 const _blockSpans = [];
 const _NO_RULE_SPANS = /** @type {RuleSpan[]} */ (
-	/** @type {unknown} */ (Object.freeze([]))
+	/** @type {RuleSpan[] | ReadonlyArray<never>} */ (Object.freeze([]))
 );
 const _NO_BLOCK_SPANS = /** @type {BlockSpans[]} */ (
-	/** @type {unknown} */ (Object.freeze([]))
+	/** @type {BlockSpans[] | ReadonlyArray<never>} */ (Object.freeze([]))
 );
 /**
- * @typedef {{ piece: number, text: string, spans: RuleSpan[], empties: number }} TakenPiece
+ * A top-level node's text as written out, which later rules cut dead rules from.
+ * A cut is recorded against the text the piece last held, so a run of cuts builds
+ * the text once, when something reads it, rather than once per cut.
  */
+class TakenPiece {
+	/**
+	 * @param {number} piece the writer's index for it
+	 * @param {string} text the text it went out as
+	 * @param {number} empties its length with every rule it holds cut, less one, or -1
+	 */
+	constructor(piece, text, empties) {
+		/** @type {number} */
+		this.piece = piece;
+		/** @type {RuleSpan[]} shared and empty until `_noteSpans` gives it its own */
+		this.spans = _NO_RULE_SPANS;
+		/** @type {number} */
+		this.empties = empties;
+		/** @type {string} */
+		this._text = text;
+		/** @type {number[] | null} the ranges of `_text` cut since, as sorted start, end pairs */
+		this._cuts = null;
+		/** @type {number} */
+		this.length = text.length;
+	}
+
+	/**
+	 * @returns {string} what the piece reads now
+	 */
+	get text() {
+		const cuts = this._cuts;
+		if (cuts !== null) {
+			/** @type {string[]} */
+			const parts = [];
+			let from = 0;
+			for (let i = 0; i < cuts.length; i += 2) {
+				parts.push(this._text.slice(from, cuts[i]));
+				from = cuts[i + 1];
+			}
+			parts.push(this._text.slice(from));
+			this._text = parts.join("");
+			this._cuts = null;
+		}
+		return this._text;
+	}
+
+	/**
+	 * @param {string} value what the piece reads from now on
+	 */
+	set text(value) {
+		this._text = value;
+		this._cuts = null;
+		this.length = value.length;
+	}
+
+	/**
+	 * @param {number} at an offset in what the piece reads now
+	 * @returns {number} the code unit there, read without building the text
+	 */
+	charCodeAt(at) {
+		return this._text.charCodeAt(this._uncut(at));
+	}
+
+	/**
+	 * Take `len` code units out at `from`, offsets in what the piece reads now.
+	 * @param {number} from where the cut starts
+	 * @param {number} len how much it takes
+	 * @returns {void}
+	 */
+	cut(from, len) {
+		const start = this._uncut(from);
+		const end = this._uncut(from + len - 1) + 1;
+		const cuts = this._cuts === null ? [] : this._cuts;
+		// The ranges cut before inside this one are taken with it.
+		let at = 0;
+		while (at < cuts.length && cuts[at] < start) at += 2;
+		let past = at;
+		while (past < cuts.length && cuts[past + 1] <= end) past += 2;
+		cuts.splice(at, past - at, start, end);
+		this._cuts = cuts;
+		this.length -= len;
+	}
+
+	/**
+	 * @param {number} at an offset in what the piece reads now
+	 * @returns {number} the same offset in `_text`
+	 */
+	_uncut(at) {
+		const cuts = this._cuts;
+		if (cuts === null) return at;
+		let offset = at;
+		for (let i = 0; i < cuts.length && cuts[i] <= offset; i += 2) {
+			offset += cuts[i + 1] - cuts[i];
+		}
+		return offset;
+	}
+}
 // Every rule taken so far, sheet-wide, by what encloses it and then by the text
 // it printed to — neither of which changes once written (see `RuleSpan`).
 /** @type {Map<string, RuleScope> | null} */
@@ -5123,7 +5488,8 @@ const _ruleScopeFor = (prefix) => {
 			prefix,
 			rules: new Map(),
 			selectors: new Map(),
-			inner: new Map()
+			inner: new Map(),
+			noShadow: _NO_SHADOW_SCOPE_RE.test(prefix)
 		};
 		scopes.set(prefix, scope);
 	}
@@ -5406,10 +5772,7 @@ const _streamEmitChild = (d, child) => {
 			const opener = _namedLayerOpener(text);
 			if (opener === null) {
 				if (_frameSeenLayers[d] !== null) {
-					_forgetLayersWritten(
-						/** @type {Map<string, SeenLayer>} */ (_frameSeenLayers[d]),
-						text
-					);
+					_forgetLayersWritten(_frameSeenLayers[d], text);
 				}
 			} else {
 				let layers = _frameSeenLayers[d];
@@ -5855,7 +6218,7 @@ const _streamConsumeBlock = (ts, rule) => {
 /** @type {HeldTopLevel | null} */
 let _heldTopLevel = null;
 
-/** @typedef {{ taken: TakenPiece, span: RuleSpan, entry: RuleEntry, prelude: number, listable: boolean, grown: boolean }} PriorTopLevel the top-level rule last written out, the piece it stands in, how far into it its block starts, whether its selectors may join a list, and whether a later rule's did */
+/** @typedef {{ taken: TakenPiece, span: RuleSpan, entry: RuleEntry, prelude: number, grown: boolean }} PriorTopLevel the top-level rule last written out, the piece it stands in, how far into it its block starts, and whether a later rule's selectors joined its list */
 
 // The rule written out before the held one, kept so a join only its settled
 // block qualifies for can still be made. Null when that was not one whole rule.
@@ -5943,18 +6306,23 @@ const _drainTopLevelSpans = (node) => {
 const _topLevelSpans = (own, text) => {
 	if (own === undefined) return null;
 	if (own === _WHOLE_TEXT_SPANS) {
-		return [{ scope: _rootScope(), key: text, at: 0, len: text.length }];
+		return [
+			{ scope: _rootScope(), key: text, at: 0, len: text.length, taken: null }
+		];
 	}
 	/** @type {RuleSpan[]} */
 	const out = own.qualified
-		? [{ scope: _rootScope(), key: text, at: 0, len: text.length }]
+		? [{ scope: _rootScope(), key: text, at: 0, len: text.length, taken: null }]
 		: [];
-	for (const span of own.spans) {
+	const spans = own.spans;
+	for (let i = 0; i < spans.length; i++) {
+		const span = spans[i];
 		out.push({
 			scope: _enclosingRuleScope(span.scope, own.keyPrelude),
 			key: span.key,
 			at: own.bodyAt + span.at,
-			len: span.len
+			len: span.len,
+			taken: null
 		});
 	}
 	return out;
@@ -5985,8 +6353,7 @@ const _takeDeduped = (writer, piece, text, spans, own, chain) => {
 				DROPPABLE_WHEN_EMPTY_AT_RULES.has(_atRuleName(own.prelude))))
 			? own.bodyAt
 			: -1;
-	/** @type {TakenPiece} */
-	const taken = { piece, text, spans: [], empties };
+	const taken = new TakenPiece(piece, text, empties);
 	_noteSpans(writer, taken, spans, chain);
 	return taken;
 };
@@ -6005,18 +6372,29 @@ const _noteSpans = (writer, taken, spans, chain) => {
 	// `taken.spans` holds, and one not yet pushed would keep its old offset.
 	for (const span of spans) {
 		if (chain.length !== 0) span.scope = _enclosingRuleScope(span.scope, chain);
-		taken.spans.push(span);
+		span.taken = taken;
+	}
+	// A copy its own size: a first push would give the list room for 17, and
+	// the piece holds it until the sheet ends.
+	if (taken.spans.length === 0) {
+		taken.spans = [...spans];
+	} else {
+		for (const span of spans) taken.spans.push(span);
 	}
 	for (const span of spans) {
 		if (span.key === UNKEYED) continue;
 		const rules = span.scope.rules;
 		const before = rules.get(span.key);
-		if (before !== undefined) _cutSpan(writer, before.taken, before.span);
-		rules.set(span.key, { taken, span });
+		if (before !== undefined) {
+			_cutSpan(writer, /** @type {TakenPiece} */ (before.taken), before);
+		}
+		rules.set(span.key, span);
 	}
 	// After every copy is taken back, so an earlier rule a cut here left flat is
 	// read as flat. A distant merge moves a block up past others, out of this order.
 	if (!_S._transforms.removeDeadRules || _mergingDistantRules) return;
+	// TODO add an option to make this opt-in: over the CSS corpus it costs ~10% of
+	// minify CPU for 248 of 2,456,527 gzip bytes.
 	for (const span of spans) {
 		if (span.key !== UNKEYED && span.len !== 0) {
 			_shadowEarlierRule(writer, taken, span);
@@ -6032,6 +6410,29 @@ const _ROLLBACK_RE = /^revert(?:-[a-z]+)?$/i;
 // blocks are gathered into one without their rules noted, so none is there.
 const _NO_SHADOW_SCOPE_RE = /@(?:-[a-z]+-)?keyframes|@layer/i;
 
+// What each prior `_shadowEarlierRule` compared against declares, with the text
+// that was read from, so a prior a later rule writes nothing of is passed over.
+/** @type {Map<RuleSpan, { text: string, names: Set<string> }>} */
+const _shadowDeclared = new Map();
+
+/**
+ * The names a printed flat rule's declarations write, as `_cascadeName` reads
+ * them.
+ * @param {string} rule the rule's printed text
+ * @param {number} open where its `{` sits
+ * @returns {Set<string>} the names
+ */
+const _declaredNames = (rule, open) => {
+	/** @type {Set<string>} */
+	const names = new Set();
+	for (const declaration of _splitPrintedDeclarations(
+		rule.slice(open + 1, -1)
+	)) {
+		if (declaration.indexOf(":") > 0) names.add(_cascadeName(declaration));
+	}
+	return names;
+};
+
 /**
  * The declarations of a printed block body, split on the `;` between them; a
  * nested block is a piece of its own.
@@ -6114,24 +6515,30 @@ const _readWherever = (values, earlier) => {
  * @returns {void}
  */
 const _shadowEarlierRule = (writer, taken, span) => {
-	const text = taken.text.slice(span.at, span.at + span.len);
-	const open = text.indexOf("{");
+	const whole = taken.text;
+	const at = span.at;
+	const brace = whole.indexOf("{", at);
 	// Only a qualified rule: an at-rule is no one cascade. One a later cut
 	// leaves flat is read as one, so every rule is noted, flat or not.
 	if (
-		open <= 0 ||
-		text.charCodeAt(0) === CC_AT_SIGN ||
-		_NO_SHADOW_SCOPE_RE.test(span.scope.prefix)
+		brace <= at ||
+		brace >= at + span.len ||
+		whole.charCodeAt(at) === CC_AT_SIGN ||
+		span.scope.noShadow
 	) {
 		return;
 	}
-	const selector = text.slice(0, open);
+	const open = brace - at;
+	const selector = whole.slice(at, brace);
 	const selectors = span.scope.selectors;
-	const priors = selectors.get(selector);
-	if (priors === undefined) {
-		selectors.set(selector, [{ taken, span }]);
+	const noted = selectors.get(selector);
+	// A lone prior is held bare: almost every selector is written once.
+	if (noted === undefined) {
+		selectors.set(selector, span);
 		return;
 	}
+	const priors = Array.isArray(noted) ? noted : [noted];
+	const text = whole.slice(at, at + span.len);
 	// Per name, the later values and whether one every target reads is among
 	// them, and whether one of those is `!important`.
 	/** @type {Map<string, { values: Set<string>, read: boolean, important: boolean }>} */
@@ -6161,11 +6568,24 @@ const _shadowEarlierRule = (writer, taken, span) => {
 		}
 	}
 	for (const prior of priors) {
-		if (prior.span.len === 0) continue;
-		const before = prior.taken.text.slice(
-			prior.span.at,
-			prior.span.at + prior.span.len
-		);
+		if (prior.len === 0) continue;
+		const priorTaken = /** @type {TakenPiece} */ (prior.taken);
+		const before = priorTaken.text.slice(prior.at, prior.at + prior.len);
+		// A prior writing none of the names this rule writes keeps all it has, so
+		// it is not split again for every later rule under its selector.
+		let declared = _shadowDeclared.get(prior);
+		if (declared === undefined || declared.text !== before) {
+			declared = { text: before, names: _declaredNames(before, open) };
+			_shadowDeclared.set(prior, declared);
+		}
+		let shared = false;
+		for (const name of later.keys()) {
+			if (declared.names.has(name)) {
+				shared = true;
+				break;
+			}
+		}
+		if (!shared) continue;
 		/* istanbul ignore if -- @preserve: a join grows a list only before its rule
 		   is noted unless distant merges are on, which skip this; kept as the guard */
 		if (
@@ -6207,18 +6627,17 @@ const _shadowEarlierRule = (writer, taken, span) => {
 		}
 		if (!dropped) continue;
 		if (kept.length === 0) {
-			_cutSpan(writer, prior.taken, prior.span);
+			_cutSpan(writer, priorTaken, prior);
 			continue;
 		}
-		_rewriteSpan(
-			writer,
-			prior.taken,
-			prior.span,
-			`${selector}{${kept.join(";")}}`
-		);
-		_rekeyShrunkSpan(writer, prior.taken, prior.span);
+		_rewriteSpan(writer, priorTaken, prior, `${selector}{${kept.join(";")}}`);
+		_rekeyShrunkSpan(writer, priorTaken, prior);
+	}
+	if (priors === noted) {
+		priors.push(span);
+	} else {
+		selectors.set(selector, [/** @type {RuleSpan} */ (noted), span]);
 	}
-	priors.push({ taken, span });
 };
 
 /**
@@ -6315,15 +6734,7 @@ const _joinGatheredSeam = (writer, taken, at, entry) => {
 	) {
 		return;
 	}
-	if (
-		!_lendSelectorsTo(
-			writer,
-			taken,
-			before,
-			prelude,
-			first.text.slice(0, first.prelude)
-		)
-	) {
+	if (!_lendSelectorsTo(writer, taken, before, prelude, _entryPrelude(first))) {
 		return;
 	}
 	_cutSpan(writer, taken, after);
@@ -6335,18 +6746,19 @@ const _joinGatheredSeam = (writer, taken, at, entry) => {
  * it, so this runs until none is left.
  * @param {PrintContext} writer the print context
  * @param {TakenPiece} taken the piece the cut was made in
+ * @param {RuleSpan[]} held the rules that held what was cut, the only ones it can have emptied
  * @returns {void}
  */
-const _cutEmptiedSpans = (writer, taken) => {
+const _cutEmptiedSpans = (writer, taken, held) => {
 	if (!_S._transforms.removeDeadRules) return;
 	// Every span is a rule dropped empty wherever it stands: a qualified rule, or
 	// one of the at-rules `DROPPABLE_WHEN_EMPTY_AT_RULES` names (`_collectRuleSpans`).
-	for (const other of taken.spans) {
+	for (const other of held) {
 		const end = other.at + other.len;
 		if (
 			other.len > 2 &&
-			taken.text.charCodeAt(end - 1) === CC_RIGHT_CURLY &&
-			taken.text.charCodeAt(end - 2) === CC_LEFT_CURLY
+			taken.charCodeAt(end - 1) === CC_RIGHT_CURLY &&
+			taken.charCodeAt(end - 2) === CC_LEFT_CURLY
 		) {
 			_cutSpan(writer, taken, other);
 			return;
@@ -6369,17 +6781,17 @@ const _cutSpan = (writer, taken, span) => {
 	// The rule stood last in its block, so the `;` in front of it is one the
 	// printer drops itself — it goes with the rule rather than being left behind.
 	if (
-		taken.text.charCodeAt(from + len) === CC_RIGHT_CURLY &&
-		taken.text.charCodeAt(from - 1) === CC_SEMICOLON
+		taken.charCodeAt(from + len) === CC_RIGHT_CURLY &&
+		taken.charCodeAt(from - 1) === CC_SEMICOLON
 	) {
 		from -= 1;
 		len += 1;
 	}
-	taken.text = `${taken.text.slice(0, from)}${taken.text.slice(from + len)}`;
-	if (taken.empties !== -1 && taken.text.length === taken.empties + 1) {
+	taken.cut(from, len);
+	if (taken.empties !== -1 && taken.length === taken.empties + 1) {
 		taken.text = "";
 	}
-	writer.rewriteRetractable(taken.piece, taken.text);
+	writer.deferRetractable(taken.piece, taken);
 	const end = from + len;
 	/** @type {RuleSpan[] | null} */
 	let shrunk = null;
@@ -6401,8 +6813,8 @@ const _cutSpan = (writer, taken, span) => {
 	span.len = 0;
 	if (shrunk !== null) {
 		for (const other of shrunk) _rekeyShrunkSpan(writer, taken, other);
+		_cutEmptiedSpans(writer, taken, shrunk);
 	}
-	_cutEmptiedSpans(writer, taken);
 };
 
 /**
@@ -6419,15 +6831,14 @@ const _rekeyShrunkSpan = (writer, taken, span) => {
 	const rules = span.scope.rules;
 	const other = rules.get(key);
 	_rekeySpan(taken, span);
-	if (other === undefined || other.span === span || other.span.len === 0) {
-		return;
-	}
+	if (other === undefined || other === span || other.len === 0) return;
+	const otherTaken = /** @type {TakenPiece} */ (other.taken);
 	const earlier =
-		other.taken.piece < taken.piece ||
-		(other.taken.piece === taken.piece && other.span.at < span.at);
+		otherTaken.piece < taken.piece ||
+		(otherTaken.piece === taken.piece && other.at < span.at);
 	if (earlier) {
-		rules.set(key, { taken, span });
-		_cutSpan(writer, other.taken, other.span);
+		rules.set(key, span);
+		_cutSpan(writer, otherTaken, other);
 	} else {
 		_cutSpan(writer, taken, span);
 	}
@@ -6647,13 +7058,13 @@ const _priorOf = (taken, entry) => {
 		return null;
 	}
 	// A rule whose selectors may not join a list is still a neighbor: the copy
-	// that only restates it goes whatever its block holds.
+	// that only restates it goes whatever its block holds. Whether they may is
+	// asked of `entry` once a later rule prints the same block.
 	return {
 		taken,
 		span,
 		entry,
 		prelude: entry.prelude,
-		listable: _entryListable(entry),
 		grown: false
 	};
 };
@@ -6682,12 +7093,9 @@ const _settlePrior = (writer) => {
 const _rekeySpan = (taken, span) => {
 	if (span.key === UNKEYED) return;
 	const rules = span.scope.rules;
-	const registered = rules.get(span.key);
-	if (registered !== undefined && registered.span === span) {
-		rules.delete(span.key);
-	}
+	if (rules.get(span.key) === span) rules.delete(span.key);
 	span.key = taken.text.slice(span.at, span.at + span.len);
-	if (!rules.has(span.key)) rules.set(span.key, { taken, span });
+	if (!rules.has(span.key)) rules.set(span.key, span);
 };
 
 /**
@@ -6727,7 +7135,10 @@ const _spanEntry = (text, prelude) => ({
 	listKind: LIST_KIND_SELECTOR,
 	children: null,
 	head: "",
-	unordered: false
+	unordered: false,
+	list: null,
+	block: null,
+	declarations: null
 });
 
 /**
@@ -6832,7 +7243,9 @@ const _joinsNeighbor = (writer, before, rule) => {
 		return same && _foldsNeighborBody(writer, before, rule);
 	}
 	if (!same) {
-		if (!before.listable || !rule.listable) return false;
+		if (!_entryListable(before.entry) || !_entryListable(rule.entry)) {
+			return false;
+		}
 		const selector = tail.slice(second.at, second.at + rule.prelude);
 		if (
 			!_lendSelectorsTo(writer, before.taken, first, before.prelude, selector)
@@ -6918,14 +7331,11 @@ const _joinsPrior = (writer, prior, held) =>
  */
 const _joinsPriorEntry = (writer, prior, entry, parted) => {
 	if (!_S._transforms.mergeRules) return false;
-	if (entry.prelude === -1 || entry.atRule || !_entryListable(entry)) {
-		return false;
-	}
+	if (entry.prelude === -1 || entry.atRule) return false;
 	// A kept comment between the two was written above the later rule, which is
 	// read where it still stands rather than here, the flush having cleared it.
 	if (parted) return false;
 	const span = prior.span;
-	if (!prior.listable) return false;
 	// Read where the rule now stands, never where it was taken: a cut inside its
 	// block, or a list this already grew, leaves the entry it went out as stale.
 	if (span.len <= prior.prelude) return false;
@@ -6942,6 +7352,8 @@ const _joinsPriorEntry = (writer, prior, entry, parted) => {
 	) {
 		return false;
 	}
+	// After the blocks compare, which almost none do: the shape test is a regex.
+	if (!_entryListable(entry) || !_entryListable(prior.entry)) return false;
 	// The same rule twice is one rule: nothing stands between them, so the later
 	// copy only restates what the earlier already says.
 	if (
@@ -6963,7 +7375,7 @@ const _joinsPriorEntry = (writer, prior, entry, parted) => {
 			prior.taken,
 			span,
 			prior.prelude,
-			entry.text.slice(0, entry.prelude)
+			_entryPrelude(entry)
 		)
 	) {
 		return false;
@@ -7161,13 +7573,7 @@ const _mergeIntoDistantRule = (writer, entry) => {
 	// grew is longer than the one that was taken.
 	const preludeNow = span.len - block.length;
 	if (
-		!_lendSelectorsTo(
-			writer,
-			taken,
-			span,
-			preludeNow,
-			entry.text.slice(0, entry.prelude)
-		)
+		!_lendSelectorsTo(writer, taken, span, preludeNow, _entryPrelude(entry))
 	) {
 		return false;
 	}
@@ -7227,13 +7633,11 @@ const _orderDistantLists = (writer) => {
  * Merge the box families whose four longhands two joined blocks wrote between
  * them, as `_mergeBoxLonghands` does for one block, so the join prints what the
  * one rule written whole would.
- * @param {string} body the joined block's declarations
- * @returns {string} the body, each family it could merge merged
+ * @param {PrintedDeclaration[]} declarations the joined block's declarations
+ * @returns {PrintedDeclaration[]} them, each family it could merge merged
  */
-const _mergeJoinedBoxLonghands = (body) => {
-	if (!_S._transforms.mergeLonghands) return body;
-	const declarations = _blockDeclarations(body);
-	if (declarations === null) return body;
+const _mergeJoinedBoxLonghands = (declarations) => {
+	if (!_S._transforms.mergeLonghands) return declarations;
 	/** @type {Map<string, number>} */
 	const at = new Map();
 	/** @type {Set<string>} */
@@ -7285,13 +7689,29 @@ const _mergeJoinedBoxLonghands = (body) => {
 		const box = _collapseBox(values);
 		if (box === null) continue;
 		if (texts === null) texts = declarations.map((one) => one.text);
-		texts[first] =
-			`${shorthand}:${_joinSlots(box)}${important ? "!important" : ""}`;
+		texts[first] = `${shorthand}:${_joinSlots(box)}${
+			important ? "!important" : ""
+		}`;
 		for (const index of indexes) if (index !== first) texts[index] = "";
 	}
-	return texts === null
-		? body
-		: texts.filter((text) => text.length !== 0).join(";");
+	if (texts === null) return declarations;
+	/** @type {PrintedDeclaration[]} */
+	const out = [];
+	for (let i = 0; i < texts.length; i++) {
+		const text = texts[i];
+		if (text.length === 0) continue;
+		if (text === declarations[i].text) {
+			out.push(declarations[i]);
+			continue;
+		}
+		const colon = text.indexOf(":");
+		out.push({
+			property: text.slice(0, colon),
+			value: text.slice(colon + 1),
+			text
+		});
+	}
+	return out;
 };
 
 /**
@@ -7304,7 +7724,7 @@ const _mergeJoinedBoxLonghands = (body) => {
 const _joinedAtRuleSpans = (merged) => {
 	// An at-rule's entry is always built with its children, never `null`.
 	const children = /** @type {RuleEntry[]} */ (merged.children);
-	const prelude = merged.text.slice(0, merged.prelude);
+	const prelude = _entryPrelude(merged);
 	/** @type {RuleSpan[]} */
 	const spans = [];
 	let at = 0;
@@ -7322,7 +7742,8 @@ const _joinedAtRuleSpans = (merged) => {
 				scope: _rootScope(),
 				key: child.text,
 				at,
-				len: child.text.length
+				len: child.text.length,
+				taken: null
 			});
 		} else {
 			const inner = _joinedAtRuleSpans(child);
@@ -7332,7 +7753,8 @@ const _joinedAtRuleSpans = (merged) => {
 					scope: _rootScope(),
 					key: UNKEYED,
 					at,
-					len: child.text.length
+					len: child.text.length,
+					taken: null
 				});
 			}
 			for (const span of inner.spans) {
@@ -7340,7 +7762,8 @@ const _joinedAtRuleSpans = (merged) => {
 					scope: _enclosingRuleScope(span.scope, inner.keyPrelude),
 					key: span.key,
 					at: at + inner.bodyAt + span.at,
-					len: span.len
+					len: span.len,
+					taken: null
 				});
 			}
 		}
@@ -7388,7 +7811,7 @@ const _joinedSpans = (before, beforeOwn, entry, own, merged) => {
 	) {
 		return _WHOLE_TEXT_SPANS;
 	}
-	const prelude = merged.text.slice(0, merged.prelude);
+	const prelude = _entryPrelude(merged);
 	const length = entry.text.length - entry.prelude - 2;
 	const at = merged.text.length - 1 - length - (merged.prelude + 1);
 	const shift = at + own.bodyAt - (entry.prelude + 1);
@@ -7399,7 +7822,8 @@ const _joinedSpans = (before, beforeOwn, entry, own, merged) => {
 			scope: span.scope,
 			key: span.key,
 			at: span.at + shift,
-			len: span.len
+			len: span.len,
+			taken: null
 		});
 	}
 	return {
@@ -7444,8 +7868,7 @@ const _takeTopLevel = (node, writer, offset, line, column) => {
 		const at = writer.takeRetractable(node, offset, line, column, own);
 		_settlePrior(writer);
 		if (_topLevelRules !== null) {
-			/** @type {TakenPiece} */
-			const taken = { piece: at, text: own, spans: [], empties: -1 };
+			const taken = new TakenPiece(at, own, -1);
 			if (_prefixPieces === null) _prefixPieces = new Map();
 			_prefixPieces.set(at, taken);
 			_topLevelRules.push(taken);
@@ -7697,8 +8120,7 @@ const _walkTopLevel = (node, writer) => {
 	_nodeCount = 0;
 	_flatTop = 0;
 	// Body indices recycle with node ids.
-	_declBodies.length = 0;
-	_ruleBodies.length = 0;
+	_dropBodies();
 	if (_walkStopped && writer === undefined) throw WALK_STOPPED;
 };
 
@@ -7712,8 +8134,7 @@ const _recycleTopLevel = (node) => {
 	if (_flatTop > _flatPeak) _flatPeak = _flatTop;
 	_nodeCount = 0;
 	_flatTop = 0;
-	_declBodies.length = 0;
-	_ruleBodies.length = 0;
+	_dropBodies();
 };
 
 // The store buffers grow to the largest single top-level rule ever parsed and
@@ -8048,6 +8469,21 @@ const grammar = (input, visitors, writer, options) => {
 	}
 	_visitors = visitors;
 	_commentBucket = visitors[NodeType.Comment];
+	_blockMemo =
+		writer !== undefined &&
+		writer.options.mode === "minify" &&
+		visitors.length === 0 &&
+		_unusedSymbols === null &&
+		!_S._prefixingOn &&
+		!_colorFallbacksNeeded &&
+		_S._renderEmbeddedSource === undefined &&
+		_S._deferEmbeddedSource === undefined
+			? new Map()
+			: null;
+	_declarationMemo = _blockMemo === null ? null : new Map();
+	_blockMemoScopes.clear();
+	_singleValueKeys = _blockMemo === null ? null : new Set();
+	_declarationMemoKey = "";
 	_walkStopped = false;
 
 	// WHY: the comment sink fires the `Comment` visitor bucket and, while
@@ -8210,6 +8646,15 @@ const grammar = (input, visitors, writer, options) => {
 		_blockSpans.length = 0;
 		_ruleScopes = null;
 		_rootRuleScope = null;
+		_shadowDeclared.clear();
+		_blockMemo = null;
+		_blockMemoScopes.clear();
+		_blockMemoTable = _blockMemoKeyTable = new Map();
+		_declarationMemo = null;
+		_singleValueKeys = null;
+		_blockMemoNode = null;
+		_blockMemoBody = undefined;
+		_blockMemoKey = "";
 		// Each holds a piece of the sheet just printed, so the last one printed
 		// would be held until the next parse replaces them.
 		_distantRules.clear();
@@ -8221,7 +8666,9 @@ const grammar = (input, visitors, writer, options) => {
 		_anonymousLayers = 0;
 		_S._input = "";
 		_originalInput = "";
-		_locConverter = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+		_locConverter = /** @type {LocConverter} */ (
+			/** @type {LocConverter | null} */ (null)
+		);
 		_declBodies.length = 0;
 		_ruleBodies.length = 0;
 		_flatTop = 0;
@@ -8230,7 +8677,9 @@ const grammar = (input, visitors, writer, options) => {
 			_flatGrowHint = _flatPeak;
 			_flat = EMPTY_I32;
 		}
-		_visitors = /** @type {CompiledVisitorMap} */ (/** @type {unknown} */ ([]));
+		_visitors = /** @type {CompiledVisitorMap} */ (
+			/** @type {CompiledVisitorMap | never[]} */ ([])
+		);
 		_commentBucket = undefined;
 		if (_capacity > _SHRINK_CAPACITY) {
 			// +1: node ids are 1-based and grow fires at `id >= capacity`.
@@ -8891,6 +9340,10 @@ const _landsAlike = (value, shorter) => {
  * @returns {string} the rounded number, or `num`
  */
 const _roundSignificant = (num, unit = "") => {
+	// A number written in at most six characters carries at most six significant
+	// digits, a sign and dot only taking away, so rounding hands back what it was
+	// given. Almost every number is this short.
+	if (num.length <= _SIGNIFICANT_DIGITS) return num;
 	const digits =
 		unit === "" ||
 		unit === "%" ||
@@ -8898,15 +9351,24 @@ const _roundSignificant = (num, unit = "") => {
 		ANGLE_UNITS.has(unit)
 			? _SIGNIFICANT_DIGITS
 			: _SCALED_LENGTH_DIGITS;
-	// A number written in at most six characters carries at most six significant
-	// digits, a sign and dot only taking away, so rounding hands back what it was
-	// given. Almost every number is this short.
-	if (num.length <= _SIGNIFICANT_DIGITS) return num;
 	if (num.includes("e") || num.includes("E")) return num;
 	const value = Number(num);
 	if (!Number.isFinite(value) || Math.abs(value) >= _ROUNDING_LIMIT) return num;
 	let rounded = value.toPrecision(digits);
-	if (digits === _SCALED_LENGTH_DIGITS) {
+	if (unit === "%") {
+		// Gecko parses a percentage as a single-precision fraction laid out in 1/60px,
+		// so the digits must reach that float: `14.285714%` drifts, `14.2857143%` not.
+		const parsed = Math.fround(value / 100);
+		for (
+			let more = digits;
+			more < _SCALED_LENGTH_DIGITS &&
+			Math.fround(Number(rounded) / 100) !== parsed;
+			more++
+		) {
+			rounded = value.toPrecision(more + 1);
+		}
+		if (Math.fround(Number(rounded) / 100) !== parsed) return num;
+	} else if (digits === _SCALED_LENGTH_DIGITS) {
 		// The fewest digits landing where the written length does, asked again of
 		// each answer until it holds, which is what a second pass would ask.
 		let from = value;
@@ -9651,6 +10113,17 @@ const _readByEveryEngine = (profile) => {
 	return true;
 };
 
+/**
+ * Whether the targets read an ability: the selection's browsers, or with none
+ * each engine shipping today, which is what `dropOverriddenDeclarations` assumes.
+ * @param {number | undefined} profile its `getSupportProfiles()` row
+ * @returns {boolean} true when the later value it names is read
+ */
+const _readsOverridingValue = (profile) =>
+	_prefixBrowsers === null
+		? profile !== undefined && _readByEveryEngine(profile)
+		: _readsAll(profile);
+
 /**
  * The vendor spellings at least one target browser still needs for a construct —
  * a target at version V needs spelling S when some `[browser, from, to]` of S has
@@ -10776,6 +11249,20 @@ const _minifyPolarColorFunction = (
 			fn === "lab" || fn === "lch"
 				? _labToLinearSrgb(l, a, b)
 				: _oklabToLinearSrgb(l, a, b);
+		// WHY: a hex mixed in `oklch` reaches it through a conversion, and Chromium
+		// reads a hue there as missing below a chroma of 0.02 — so `color-mix(in
+		// oklch, currentColor 35%, #0000)` paints hue 0 where `oklch()` named one.
+		if (fn === "oklch" && (a !== 0 || b !== 0)) {
+			const space = getColorSpaceModel().get(fn);
+			const clamped = linear.map((c) => Math.min(1, Math.max(0, c)));
+			if (
+				space !== undefined &&
+				space.uncertainHue !== null &&
+				space.uncertainHue(space.to(clamped))
+			) {
+				return null;
+			}
+		}
 		// `_channelByte` decides the gamut from the encoded value, where the
 		// question is whether clamping would move the byte.
 		raw = linear.map((c) => _gammaEncode(c) * 255);
@@ -10999,7 +11486,7 @@ const _resolveColor = (text) => {
 		}
 		// Every call that answers records them, so a non-null answer is one.
 		const raw = /** @type {number[]} */ (
-			/** @type {unknown} */ (_fallbackChannels)
+			/** @type {number[] | null} */ (_fallbackChannels)
 		);
 		return {
 			linear: raw.map((channel) => _gammaDecode(channel / 255)),
@@ -11832,7 +12319,7 @@ const _CUSTOM_MEDIA_REFERENCE_RE = /^\(\s*(--[^\s()]+)\s*\)$/;
 // The same, anywhere in a printed `(…)` group.
 const _NESTED_CUSTOM_MEDIA_REFERENCE_RE = /\(\s*(--[^\s()]+)\s*\)/g;
 // A media type: an identifier, which no keyword between conditions is.
-const _MEDIA_TYPE_RE = /^-?[a-z_\u0080-￿][\w\u0080-￿-]*$/i;
+const _MEDIA_TYPE_RE = /^-?[a-zA-Z_\u0080-￿][\w\u0080-￿-]*$/;
 
 /**
  * @param {string} token a printed query token
@@ -12374,10 +12861,11 @@ const _lowerDirSelector = (parts) => {
  * Empty parts are stepped over — a comment between the colons printed away, and
  * the tokenizer had already dropped it anyway.
  * @param {string[]} parts the prelude's printed parts
- * @returns {void}
+ * @returns {boolean} whether a pseudo it read may be an `:is()` for `_unwrapLoneIs`
  */
 const _foldPseudoNames = (parts) => {
 	const dropping = _S._transforms.shortenSelectors;
+	let mayUnwrap = false;
 	// The two non-empty parts before the current one.
 	let first = -1;
 	let second = -1;
@@ -12388,10 +12876,19 @@ const _foldPseudoNames = (parts) => {
 		// not, `linearGradient` being an SVG element, and nor does an id, class or
 		// attribute value. A functional pseudo folds its own name alone.
 		if (second !== -1 && parts[second] === ":") {
-			const lowered = asciiLowercaseName(part);
-			if (_S._transforms.foldCase && lowered !== part && !part.includes("(")) {
-				part = lowered;
-				parts[i] = lowered;
+			if (
+				part.length > 4 &&
+				part.charCodeAt(2) === CC_LEFT_PARENTHESIS &&
+				(part.charCodeAt(0) | 0x20) === CC_LOWER_I
+			) {
+				mayUnwrap = true;
+			}
+			if (_S._transforms.foldCase && !part.includes("(")) {
+				const lowered = asciiLowercaseName(part);
+				if (lowered !== part) {
+					part = lowered;
+					parts[i] = lowered;
+				}
 			}
 			// Folded first, so the legacy name below is matched against the folded
 			// text rather than folded a second time.
@@ -12407,6 +12904,7 @@ const _foldPseudoNames = (parts) => {
 		first = second;
 		second = i;
 	}
+	return mayUnwrap;
 };
 
 // A legacy pseudo-element written with one colon, which `:is()` cannot hold.
@@ -12450,7 +12948,7 @@ const _isCompoundText = (selector) => {
  * Unwrap each `:is()` holding one compound, which matches the same elements with
  * the same specificity. Only where the targets read every pseudo it names, since
  * `:is()` forgives an argument it cannot parse and a bare compound does not.
- * @param {string[]} parts a selector's printed parts, rewritten in place
+ * @param {string[]} parts a selector's printed parts, rewritten in place, called only where `_foldPseudoNames` read a pseudo that may be an `:is()`
  */
 const _unwrapLoneIs = (parts) => {
 	let before = -1;
@@ -12473,12 +12971,16 @@ const _unwrapLoneIs = (parts) => {
 			) {
 				pastElement = true;
 			}
-			const inner = call.slice(3, -1);
-			if (
+			const isCall =
 				!pastElement &&
 				call.length > 4 &&
-				asciiCaseInsensitiveMatch(call.slice(0, 3), "is(") &&
-				call.charCodeAt(call.length - 1) === CC_RIGHT_PARENTHESIS &&
+				(call.charCodeAt(0) | 0x20) === CC_LOWER_I &&
+				(call.charCodeAt(1) | 0x20) === CC_LOWER_S &&
+				call.charCodeAt(2) === CC_LEFT_PARENTHESIS &&
+				call.charCodeAt(call.length - 1) === CC_RIGHT_PARENTHESIS;
+			const inner = isCall ? call.slice(3, -1) : "";
+			if (
+				isCall &&
 				_isCompoundText(inner) &&
 				!inner.includes("::") &&
 				!_LEGACY_PSEUDO_ELEMENT_RE.test(inner) &&
@@ -12697,7 +13199,8 @@ const _dropRedundantSupportsParens = (parts) => {
 			continue;
 		}
 		let text = part;
-		for (;;) {
+		// Only an opening pair is one to drop, which almost no condition holds.
+		while (text.includes("((")) {
 			const close = _matchingParens(text);
 			if (close === null) break;
 			let at = -1;
@@ -12725,6 +13228,7 @@ const _dropRedundantSupportsParens = (parts) => {
 	}
 	if (groups !== 1) return;
 	const text = parts[only];
+	if (text.charCodeAt(1) !== CC_LEFT_PARENTHESIS) return;
 	const close = _matchingParens(text);
 	if (
 		close !== null &&
@@ -12891,7 +13395,8 @@ const _selectsFeatureless = (parts, at) => {
  * @returns {void}
  */
 const _dropImpliedUniversalSelector = (parts) => {
-	if (!_S._transforms.shortenSelectors) return;
+	// A native search first: almost no selector holds a `*` at all.
+	if (!_S._transforms.shortenSelectors || !parts.includes("*")) return;
 	let previous = -1;
 	for (let i = 0; i < parts.length; i++) {
 		const part = parts[i];
@@ -13581,6 +14086,47 @@ const _foldFollowingLonghands = (path, items, texts, superseded) => {
 		}
 		return written.has(base) && _prefixedPropertyRemovable(base, property);
 	};
+	// Each declaration's property, read once: the walk back from every longhand
+	// asks again of the ones before it, and a fold keeps the property it rewrites.
+	/** @type {(string | undefined)[]} */
+	const properties = [];
+	// The number `_declarationTable` gives each, or -1 for one it does not name.
+	/** @type {number[]} */
+	const ids = [];
+	const table = _declarationTable();
+	/**
+	 * The property a declaration sets, read through `_canonicalProperty`.
+	 * @param {number} at the declaration's index
+	 * @returns {string} its property
+	 */
+	const propertyAt = (at) => {
+		let property = properties[at];
+		if (property === undefined) {
+			const printed = _printedProperty(texts[at], texts[at].indexOf(":"));
+			const id = table.ids.get(printed);
+			if (id === undefined) {
+				property = printed;
+				ids[at] = -1;
+			} else {
+				ids[at] = table.canonical[id];
+				property = table.names[ids[at]];
+			}
+			properties[at] = property;
+		}
+		return property;
+	};
+	/**
+	 * Whether two declarations must keep their order, as `_orderMatters` reads it.
+	 * @param {number} a a declaration's index, its property already read
+	 * @param {number} b another's
+	 * @returns {boolean} true when the two must keep their order
+	 */
+	const orderMattersAt = (a, b) => {
+		const property = propertyAt(b);
+		return ids[a] !== -1 && ids[b] !== -1
+			? _orderMattersById(table, ids[a], ids[b])
+			: _orderMatters(/** @type {string} */ (properties[a]), property);
+	};
 	for (let i = 0; i < items.length; i++) {
 		// A dropped declaration prints nothing, so nothing stands where it stood.
 		if (texts[i].length === 0 || superseded.has(i)) continue;
@@ -13591,7 +14137,16 @@ const _foldFollowingLonghands = (path, items, texts, superseded) => {
 		if (dropsWithPrefix(i)) continue;
 		if (
 			shorthand !== -1 &&
-			_foldIntoEarlier(path, items, texts, superseded, i, dropsWithPrefix)
+			_foldIntoEarlier(
+				path,
+				items,
+				texts,
+				superseded,
+				i,
+				dropsWithPrefix,
+				propertyAt,
+				orderMattersAt
+			)
 		) {
 			superseded.add(i);
 			continue;
@@ -13615,29 +14170,39 @@ let _anyLonghand = null;
  * @param {Set<number>} superseded the indices already dropped
  * @param {number} from the longhand's index
  * @param {(at: number) => boolean} drops whether a declaration is dropped later
+ * @param {(at: number) => string} propertyAt the property a declaration sets, read through `_canonicalProperty`
+ * @param {(a: number, b: number) => boolean} orderMattersAt `_orderMatters` of two declarations' properties, the first already read
  * @returns {boolean} true when it was folded into one before it
  */
-const _foldIntoEarlier = (path, items, texts, superseded, from, drops) => {
+const _foldIntoEarlier = (
+	path,
+	items,
+	texts,
+	superseded,
+	from,
+	drops,
+	propertyAt,
+	orderMattersAt
+) => {
 	if (_anyLonghand === null) {
 		_anyLonghand = new Set();
 		for (const longhands of getShorthandLonghands().values()) {
 			for (const longhand of longhands) _anyLonghand.add(longhand);
 		}
 	}
-	const property = _canonicalProperty(
-		_printedProperty(texts[from], texts[from].indexOf(":"))
-	);
-	if (!_anyLonghand.has(property.replace(_VENDOR_ITEM_PREFIX_RE, ""))) {
+	const property = propertyAt(from);
+	const bare =
+		property.charCodeAt(0) === CC_HYPHEN_MINUS
+			? property.replace(_VENDOR_ITEM_PREFIX_RE, "")
+			: property;
+	if (!_anyLonghand.has(bare)) {
 		return false;
 	}
 	for (let at = from - 1; at >= 0; at--) {
 		if (texts[at].length === 0 || superseded.has(at)) continue;
 		if (path.type(items[at]) !== NodeType.Declaration) return false;
 		if (drops(at)) continue;
-		const other = _canonicalProperty(
-			_printedProperty(texts[at], texts[at].indexOf(":"))
-		);
-		if (_orderMatters(property, other)) {
+		if (orderMattersAt(from, at)) {
 			return _foldInto(path, items, texts, at, from);
 		}
 	}
@@ -14570,9 +15135,9 @@ const _familyValue = (property, longhands, values) => {
  * @returns {boolean} true when no target is left reading the earlier one
  */
 const _valueReadByTarget = (property, value) => {
-	// No selection names no browser to answer for, so nothing is known to read the
-	// later value: the earlier one stands unless asked to assume otherwise.
-	if (_prefixBrowsers === null) return _dropOverriddenDeclarations;
+	// No selection names no browser to answer for, so the earlier one stands
+	// unless the option assumes each engine shipping today, read against below.
+	if (_prefixBrowsers === null && !_dropOverriddenDeclarations) return false;
 	// A selection naming a browser the tables do not cover answers for less than
 	// the whole of it. Naming a browser states a target, which the option that
 	// assumes one does not override, so this stands whatever it says.
@@ -14582,7 +15147,7 @@ const _valueReadByTarget = (property, value) => {
 	const substitutions = _heldSubstitutions(value);
 	if (substitutions !== null) {
 		for (const name of substitutions) {
-			if (!_readsAll(_valueSupportedFrom(name))) return false;
+			if (!_readsOverridingValue(_valueSupportedFrom(name))) return false;
 		}
 		return true;
 	}
@@ -14592,7 +15157,7 @@ const _valueReadByTarget = (property, value) => {
 			const components = _splitPrintedComponents(value);
 			if (components.length > 1) return _textDecorationRead(components);
 		}
-		return _readsAll(
+		return _readsOverridingValue(
 			_valueSupportedFrom(`${property} ${toLowerCaseIfNeeded(value)}`)
 		);
 	}
@@ -14604,9 +15169,10 @@ const _valueReadByTarget = (property, value) => {
 		return false;
 	}
 	const fn = toLowerCaseIfNeeded(value.slice(0, open));
-	if (!_readsAll(_valueSupportedFrom(fn))) return false;
+	if (!_readsOverridingValue(_valueSupportedFrom(fn))) return false;
 	if (fn.endsWith("gradient")) {
-		return _gradientArgumentsRead(value.slice(open + 1, -1));
+		// A one-stop gradient is CSS Images 4's, which not every engine reads yet.
+		return _gradientArgumentsRead(value.slice(open + 1, -1), 2);
 	}
 	const args = value.slice(open + 1, -1).match(_COLOR_ARGUMENT_RE);
 	if (args === null) return false;
@@ -14660,33 +15226,61 @@ const _GRADIENT_AMOUNT_RE = /^[+-]?(?:\d+\.?\d*|\.\d+)([a-z]+|%)?$/i;
  * line, shape or position of keywords and amounts, and stops of a color every
  * engine names. A call inside, or an interpolation space, is not asked here.
  * @param {string} inner the printed arguments
+ * @param {number} stopsNeeded how many color stops the arguments must hold
  * @returns {boolean} true when the target reads every one
  */
-const _gradientArgumentsRead = (inner) => {
-	for (const argument of _splitTopLevelArguments(inner)) {
-		for (const component of _splitPrintedComponents(argument.trim())) {
+const _gradientArgumentsRead = (inner, stopsNeeded) => {
+	const args = _splitTopLevelArguments(inner);
+	let stops = 0;
+	for (let index = 0; index < args.length; index++) {
+		// A line, shape or position opens the list alone; a stop is one color
+		// and its amounts. Anything else, an empty argument too, is invalid.
+		if (args[index].trim() === "") return false;
+		let words = 0;
+		let colors = 0;
+		for (const component of _splitPrintedComponents(args[index].trim())) {
 			const lowered = toLowerCaseIfNeeded(component);
-			if (_GRADIENT_KEYWORDS.has(lowered)) continue;
+			if (_GRADIENT_KEYWORDS.has(lowered)) {
+				if (lowered === "transparent" || lowered === "currentcolor") {
+					colors++;
+				} else {
+					words++;
+				}
+				if (words !== 0 && (index !== 0 || colors !== 0)) return false;
+				if (colors > 1) return false;
+				continue;
+			}
 			const amount = _GRADIENT_AMOUNT_RE.exec(lowered);
 			if (amount !== null) {
 				// A unit some target does not read drops the gradient there.
 				const unit = amount[1];
 				if (unit === undefined || unit === "%") continue;
-				if (_readsAll(_valueSupportedFrom(`unit ${unit}`))) continue;
-				return false;
+				if (!_readsOverridingValue(_valueSupportedFrom(`unit ${unit}`))) {
+					return false;
+				}
+				continue;
 			}
+			let color = false;
 			if (_LONE_HEX_RE.test(component)) {
-				if (component.length === 4 || component.length === 7) continue;
-				if (_S._hexAlphaAllowed) continue;
-				return false;
-			}
-			if (getColorNameToRgb().has(lowered) && !LATER_COLOR_NAMES.has(lowered)) {
-				continue;
+				if (
+					component.length !== 4 &&
+					component.length !== 7 &&
+					!_S._hexAlphaAllowed
+				) {
+					return false;
+				}
+				color = true;
+			} else if (
+				getColorNameToRgb().has(lowered) &&
+				!LATER_COLOR_NAMES.has(lowered)
+			) {
+				color = true;
 			}
-			return false;
+			if (!color || ++colors > 1 || words !== 0) return false;
 		}
+		if (colors !== 0) stops++;
 	}
-	return true;
+	return stops >= stopsNeeded;
 };
 
 /**
@@ -14714,7 +15308,7 @@ const _textDecorationRead = (components) => {
 		);
 		if (keywords.includes(toLowerCaseIfNeeded(written))) continue;
 		// A color or an amount, read as a gradient's stop or length is.
-		if (!_gradientArgumentsRead(written)) return false;
+		if (!_gradientArgumentsRead(written, 0)) return false;
 	}
 	return true;
 };
@@ -14794,6 +15388,17 @@ const _writeIsDead = (path, writer, earlier, later, keyframe) => {
 	);
 };
 
+/**
+ * A property's first word, what an unnamed property of its family starts with:
+ * `margin` for `margin-top`.
+ * @param {string} name a property
+ * @returns {string} the word before its first `-`
+ */
+const _firstPropertyWord = (name) => {
+	const dash = name.indexOf("-");
+	return dash === -1 ? name : name.slice(0, dash);
+};
+
 /**
  * Merge a box family's four longhands into their shorthand, which sets exactly
  * those four (see `BOX_LONGHANDS`) — so the rule computes the same either way.
@@ -14834,7 +15439,22 @@ const _mergeBoxLonghands = (
 	// tail uncovered, dropping its declaration.
 	/** @type {Set<Node> | null} */
 	let claimed = null;
-	for (let e = 0; e < table.length; e++) {
+	// Only an entry whose first longhand the block writes can merge, and blocks
+	// write few properties against a table of dozens of entries.
+	const firsts = _mergeTableFirsts(table);
+	/** @type {number[]} */
+	const candidates = [];
+	for (const property of at.keys()) {
+		const entries = firsts.get(property);
+		if (entries !== undefined) {
+			for (const entry of entries) candidates.push(entry);
+		}
+	}
+	if (candidates.length === 0) return null;
+	// In table order, as the claims between entries are made.
+	if (candidates.length > 1) candidates.sort((a, b) => a - b);
+	for (let c = 0; c < candidates.length; c++) {
+		const e = candidates[c];
 		const shorthand = table[e][0];
 		const longhands = table[e][1];
 		// A plain loop: this runs for every table entry of every rule, where one
@@ -14869,10 +15489,9 @@ const _mergeBoxLonghands = (
 		// merges the same before and after it is reordered. A pair family states no
 		// prefix at all — its longhands are the two names — so a property no dataset
 		// names is read by either one's first segment.
-		const head = (/** @type {string} */ name) =>
-			/** @type {RegExpExecArray} */ (/^[^-]+/.exec(name))[0];
-		const prefix = BOX_FAMILY_PREFIX.get(shorthand) || head(shorthand);
-		const families = [prefix, ...longhands.map(head)];
+		const prefix =
+			BOX_FAMILY_PREFIX.get(shorthand) || _firstPropertyWord(shorthand);
+		const families = [prefix, ...longhands.map(_firstPropertyWord)];
 		let blocked = false;
 		for (
 			let i = ordered[0] + 1;
@@ -14904,15 +15523,14 @@ const _mergeBoxLonghands = (
 		if (indexes.some((i) => _isImportant(decls[i]) !== important)) continue;
 		const values = [];
 		for (const i of indexes) {
-			const components = _valueComponents(path, decls[i], writer);
-			if (components.length !== 1) break;
+			if (!_isSingleValue(path, decls[i], writer)) break;
 			// What the declaration prints, not what its tokens spell: a zero length
 			// loses its unit as a declaration is written, and a token knows no property.
 			const text = writer.get(decls[i]);
 			const colon = text.indexOf(":");
 			values.push(
 				colon === -1
-					? components[0]
+					? _valueComponents(path, decls[i], writer)[0]
 					: text.slice(colon + 1, _printedValueEnd(text, colon))
 			);
 		}
@@ -15027,7 +15645,7 @@ const _mergeBoxLonghands = (
 };
 
 // A `<custom-ident>` as printed; one the printer keeps escaped fails it.
-const _GRID_IDENT_RE = /^(?:--|-?[a-z_\u0080-\uFFFF])[-\w\u0080-\uFFFF]*$/i;
+const _GRID_IDENT_RE = /^(?:--|-?[a-zA-Z_\u0080-\uFFFF])[-\w\u0080-\uFFFF]*$/;
 const _GRID_INTEGER_RE = /^[-+]?\d+$/;
 
 /**
@@ -15324,6 +15942,30 @@ const MERGE_FAMILY = 1;
 const MERGE_SLASH = 2;
 const MERGE_ORDERED = 3;
 
+/** @type {WeakMap<[string, string[]][], Map<string, number[]>>} */
+const _mergeTableFirstsCache = new WeakMap();
+
+/**
+ * A merge table's entries by their first longhand, which a block has to write
+ * for the entry to merge.
+ * @param {[string, string[]][]} table a merge table
+ * @returns {Map<string, number[]>} the indexes of the entries each first longhand leads
+ */
+const _mergeTableFirsts = (table) => {
+	let firsts = _mergeTableFirstsCache.get(table);
+	if (firsts === undefined) {
+		firsts = new Map();
+		for (let e = 0; e < table.length; e++) {
+			const first = table[e][1][0];
+			const entries = firsts.get(first);
+			if (entries === undefined) firsts.set(first, [e]);
+			else entries.push(e);
+		}
+		_mergeTableFirstsCache.set(table, firsts);
+	}
+	return firsts;
+};
+
 // Each table as its entries, read by index: a `for…of` over the map would
 // allocate an entry pair per row of every table for every block merged.
 /** @type {[[string, string[]][], number][]} */
@@ -15358,6 +16000,14 @@ const MERGE_TABLES = [
  * concatenated: its own, or one a child carries. The run that grew it settles
  * it where the run ends (`_settleJoinedSeams`), so a join stays what it costs
  * to append rather than re-reading the list it has
+ * @property {string | null} list its prelude where a join wrote it, so the next
+ * join reads or appends to it rather than cutting it back out of `text`, which
+ * would flatten the whole run so far; null to read it off `text`
+ * @property {string | null} block the text from its `{` on, held beside `list`
+ * for the same reason
+ * @property {PrintedDeclaration[] | null} declarations its block's declarations
+ * where a join of two blocks under one prelude wrote them, so the next join
+ * reads them rather than parsing the whole block again; null to parse `text`
  */
 
 // Each printed rule the merge can join -> its entry, by node id. Emptied per
@@ -15450,7 +16100,10 @@ const _opaqueEntry = (text) => ({
 	listKind: LIST_KIND_SELECTOR,
 	children: null,
 	head: "",
-	unordered: false
+	unordered: false,
+	list: null,
+	block: null,
+	declarations: null
 });
 
 /**
@@ -15462,7 +16115,7 @@ const _opaqueEntry = (text) => ({
 const _entryListable = (entry) => {
 	if (entry.listable === LIST_UNKNOWN) {
 		entry.listable = _isJoinablePrelude(
-			entry.text.slice(0, entry.prelude),
+			_entryPrelude(entry),
 			entry.listKind === LIST_KIND_KEYFRAME,
 			entry.listKind === LIST_KIND_NESTED
 		)
@@ -15501,22 +16154,33 @@ const _STRING = String.raw`"(?:[^"\\]|\\[\s\S])*"|'(?:[^'\\]|\\[\s\S])*'`;
 const _ATTRIBUTE = String.raw`\[(?:${_IDENT}\|)?${_IDENT}(?:[~|^$*]?=(?:${_IDENT}|${_STRING})(?: [iI])?)?\]`;
 // CSS whitespace: U+00A0 is an identifier's character, not a separator.
 const _SPACE = "[ \\t\\n\\f\\r]";
-const _LEGACY_ELEMENT_NAMES = [...LEGACY_PSEUDO_ELEMENTS].join("|");
+/**
+ * A pattern matching the word in any ASCII case, where an `i` flag would make V8
+ * case-fold the whole `\u00A0-\uFFFF` class too, costing milliseconds to compile.
+ * @param {string} word a lowercase word
+ * @returns {string} the pattern
+ */
+const _anyCase = (word) =>
+	word.replace(/[a-z]/g, (letter) => `[${letter}${letter.toUpperCase()}]`);
+const _LEGACY_ELEMENT_NAMES = [...LEGACY_PSEUDO_ELEMENTS]
+	.map(_anyCase)
+	.join("|");
 // A pseudo-class with no selector inside it: argument-less, or the `An+B` of an
 // `:nth-*()`, whose grammar is closed — the one argument a shape may carry.
 const _PSEUDO_CLASS = String.raw`:(?!(?:${_LEGACY_ELEMENT_NAMES})(?![-\w]))(?:(?:${[
 	...NTH_PSEUDO_FUNCTIONS
-].join(
-	"|"
-)})\(${_SPACE}*(?:odd|even|[-+]?(?:\d*n(?:${_SPACE}*[-+]${_SPACE}*\d+)?|\d+))${_SPACE}*\)|[-\w]+(?![-\w(]))`;
+]
+	.map(_anyCase)
+	.join("|")})\(${_SPACE}*(?:${_anyCase("odd")}|${_anyCase(
+	"even"
+)}|[-+]?(?:\d*[nN](?:${_SPACE}*[-+]${_SPACE}*\d+)?|\d+))${_SPACE}*\)|[-\w]+(?![-\w(]))`;
 // A pseudo-element ends the selector it is in: anything after it is no shape
 // an engine parses.
 const _PSEUDO_ELEMENT = String.raw`(?:::[-\w]+|:(?:${_LEGACY_ELEMENT_NAMES}))(?![-\w(])`;
 const _COMPOUND = `(?:\\*|${_IDENT}|[.#]${_IDENT}|${_ATTRIBUTE})(?:[.#]${_IDENT}|${_ATTRIBUTE}|${_PSEUDO_CLASS})*`;
 const _COMBINATOR = `(?:${_SPACE}*[>+~]${_SPACE}*|${_SPACE}+)`;
 const _JOINABLE_SELECTOR_RE = new RegExp(
-	`^(?:${_COMPOUND}${_COMBINATOR})*${_COMPOUND}(?:${_PSEUDO_ELEMENT})?$`,
-	"i"
+	`^(?:${_COMPOUND}${_COMBINATOR})*${_COMPOUND}(?:${_PSEUDO_ELEMENT})?$`
 );
 
 // The same, for a rule nested in another: `&` joins there because an engine that
@@ -15524,8 +16188,7 @@ const _JOINABLE_SELECTOR_RE = new RegExp(
 // dropped together rather than one taking the other down.
 const _NESTED_COMPOUND = `(?:&(?:${_COMPOUND})?|${_COMPOUND})`;
 const _JOINABLE_NESTED_RE = new RegExp(
-	`^(?:${_NESTED_COMPOUND}${_COMBINATOR})*${_NESTED_COMPOUND}(?:${_PSEUDO_ELEMENT})?$`,
-	"i"
+	`^(?:${_NESTED_COMPOUND}${_COMBINATOR})*${_NESTED_COMPOUND}(?:${_PSEUDO_ELEMENT})?$`
 );
 
 // A keyframe selector is a percentage or `to` — `from` is already printed `0%`.
@@ -15717,6 +16380,8 @@ const _blockProperties = (body) => {
 // The `!important` a printed declaration ends in, whatever it was written as.
 const _PRINTED_IMPORTANT_RE = /!\s*important$/i;
 
+/** @typedef {{ property: string, value: string, text: string }} PrintedDeclaration one declaration of a printed block: its lowercased property, its value and its whole text */
+
 /**
  * The declarations one printed block holds, each as the whole of what it is
  * written as. Built on the same walk `_blockProperties` makes, since what a
@@ -15724,10 +16389,10 @@ const _PRINTED_IMPORTANT_RE = /!\s*important$/i;
  * else — a nested rule of its own, whose declarations are read at its place
  * rather than at the block's.
  * @param {string} body the block's printed body, between its braces
- * @returns {{ property: string, value: string, text: string }[] | null} the declarations, in order, or null
+ * @returns {PrintedDeclaration[] | null} the declarations, in order, or null
  */
 const _blockDeclarations = (body) => {
-	/** @type {{ property: string, value: string, text: string }[]} */
+	/** @type {PrintedDeclaration[]} */
 	const out = [];
 	let depth = 0;
 	let quote = 0;
@@ -15807,6 +16472,28 @@ const _rangeEquals = (a, aStart, aEnd, b, bStart, bEnd) => {
 	return true;
 };
 
+/**
+ * A rule's prelude, read from where a join holds it.
+ * @param {RuleEntry} entry the rule
+ * @returns {string} its prelude, as printed
+ */
+const _entryPrelude = (entry) =>
+	entry.list === null ? entry.text.slice(0, entry.prelude) : entry.list;
+
+/**
+ * Whether two rules' blocks say the same, each read from where it is held.
+ * @param {RuleEntry} a one rule
+ * @param {RuleEntry} b another
+ * @returns {boolean} true when the blocks are equal
+ */
+const _blocksEqual = (a, b) => {
+	const aText = a.block === null ? a.text : a.block;
+	const aStart = a.block === null ? a.prelude : 0;
+	const bText = b.block === null ? b.text : b.block;
+	const bStart = b.block === null ? b.prelude : 0;
+	return _rangeEquals(aText, aStart, aText.length, bText, bStart, bText.length);
+};
+
 // A layer with no name: the one at-rule prelude that is not the same rule twice.
 const ANONYMOUS_LAYER_RE = /^@layer[ \t\n\r\f]*$/i;
 
@@ -15902,7 +16589,11 @@ const _joinedHead = (joined) => {
  * @returns {string} the rule the block prints as
  */
 const _joinedBlockText = (prelude, head, joined) => {
-	let lastText = joined[joined.length - 1].text;
+	const last = joined[joined.length - 1];
+	let lastText = last.text;
+	// Read off the block where a join holds one: the text before it is a list a
+	// run of joins is still growing, which reading any of the text flattens.
+	if (last.block !== null) return `${prelude}{${head}${lastText}}`;
 	while (
 		lastText.length !== 0 &&
 		lastText.charCodeAt(lastText.length - 1) === CC_SEMICOLON
@@ -15943,16 +16634,16 @@ const _joinRuleEntries = (before, entry, owned) => {
 	// cutting each one's prelude and block out to answer that is two pieces of
 	// string per meeting for an answer that is usually no.
 	const preludesEqual = _rangeEquals(
-		before.text,
+		before.list === null ? before.text : before.list,
 		0,
 		before.prelude,
-		entry.text,
+		entry.list === null ? entry.text : entry.list,
 		0,
 		entry.prelude
 	);
 	if (before.atRule) {
 		if (!preludesEqual) return null;
-		const beforePrelude = before.text.slice(0, before.prelude);
+		const beforePrelude = _entryPrelude(before);
 		// CSS Cascade 5 §6.4.1: every `@layer {` opens a layer of its own, and a
 		// later layer beats an earlier one whatever the selectors say — so joining
 		// the two hands the block back to specificity.
@@ -16036,17 +16727,13 @@ const _joinRuleEntries = (before, entry, owned) => {
 			listKind: LIST_KIND_SELECTOR,
 			children: joined,
 			head,
-			unordered
+			unordered,
+			list: beforePrelude,
+			block: null,
+			declarations: null
 		};
 	}
-	const blocksEqual = _rangeEquals(
-		before.text,
-		before.prelude,
-		before.text.length,
-		entry.text,
-		entry.prelude,
-		entry.text.length
-	);
+	const blocksEqual = _blocksEqual(before, entry);
 	// The same selector twice is one rule: nothing stands between them, so its
 	// declarations are read in the order they were written either way.
 	if (preludesEqual) {
@@ -16056,12 +16743,14 @@ const _joinRuleEntries = (before, entry, owned) => {
 		// Declarations after a nested rule are the implicit `& {…}` the engine
 		// builds for them, which is a rule the sheet did not have.
 		if (!before.plain) return null;
-		const beforePrelude = before.text.slice(0, before.prelude);
-		const body = before.text.slice(before.prelude + 1, -1);
+		const beforePrelude = _entryPrelude(before);
 		const rest = entry.text.slice(entry.prelude + 1, -1);
 		// One block holds a property once, so two blocks join only where the later
 		// declaration is one the earlier could not have been read behind.
-		const earlier = _blockDeclarations(body);
+		const earlier =
+			before.declarations === null
+				? _blockDeclarations(before.text.slice(before.prelude + 1, -1))
+				: before.declarations;
 		if (earlier === null) return null;
 		// The later block's declarations, and only where it holds nothing else: a
 		// nested rule leaves the properties readable but not their values.
@@ -16109,19 +16798,42 @@ const _joinRuleEntries = (before, entry, owned) => {
 		}
 		const kept =
 			dropped.size === 0
-				? body
-				: earlier
-						.filter((_, at) => !dropped.has(at))
-						.map((one) => one.text)
-						.join(";");
-		// Each block already dropped the `;` its own `}` made redundant, so the one
-		// that is no longer last needs it back.
-		const joined = _orderJoinedBody(
-			kept.length === 0 || rest.length === 0
-				? kept + rest
-				: _mergeJoinedBoxLonghands(`${kept};${rest}`),
-			before.plain && entry.plain
-		);
+				? earlier
+				: earlier.filter((_, at) => !dropped.has(at));
+		const added =
+			later !== null
+				? later
+				: rest.length === 0
+					? []
+					: _blockDeclarations(rest);
+		/** @type {PrintedDeclaration[] | null} */
+		let declarations = null;
+		let joined;
+		// Carried as a list only where reading the joined text back would split it
+		// the same way, which a quote the split reads as left open would not.
+		if (
+			added === null ||
+			!_lastDeclarationCloses(added) ||
+			(before.declarations === null && !_lastDeclarationCloses(earlier))
+		) {
+			const keptText = kept.map((one) => one.text).join(";");
+			joined = _orderJoinedBody(
+				keptText.length === 0 || rest.length === 0
+					? keptText + rest
+					: _mergeJoinedBody(`${keptText};${rest}`),
+				before.plain && entry.plain
+			);
+		} else {
+			declarations = _orderJoinedDeclarations(
+				kept.length === 0 || added.length === 0
+					? [...kept, ...added]
+					: _mergeJoinedBoxLonghands([...kept, ...added]),
+				before.plain && entry.plain
+			);
+			// Each block already dropped the `;` its own `}` made redundant, so the
+			// one that is no longer last needs it back.
+			joined = declarations.map((one) => one.text).join(";");
+		}
 		return {
 			text: `${beforePrelude}{${joined}}`,
 			prelude: before.prelude,
@@ -16136,7 +16848,10 @@ const _joinRuleEntries = (before, entry, owned) => {
 			head: "",
 			// The two preludes are equal, so the list this keeps is the one `before`
 			// already carried — settled or not.
-			unordered: before.unordered
+			unordered: before.unordered,
+			list: beforePrelude,
+			block: null,
+			declarations
 		};
 	}
 	if (!blocksEqual || !_entryListable(before) || !_entryListable(entry)) {
@@ -16145,12 +16860,11 @@ const _joinRuleEntries = (before, entry, owned) => {
 	// Concatenated, never canonicalized here: a run of joins would then re-read
 	// the whole list once per rule. It is noted as a list still to settle, and
 	// the run that grew it orders it once where it ends.
-	const list = `${before.text.slice(0, before.prelude)},${entry.text.slice(
-		0,
-		entry.prelude
-	)}`;
+	const list = `${_entryPrelude(before)},${_entryPrelude(entry)}`;
+	const block =
+		before.block === null ? before.text.slice(before.prelude) : before.block;
 	return {
-		text: list + before.text.slice(before.prelude),
+		text: list + block,
 		prelude: list.length,
 		atRule: false,
 		plain: true,
@@ -16158,13 +16872,30 @@ const _joinRuleEntries = (before, entry, owned) => {
 		listKind: before.listKind,
 		children: null,
 		head: "",
-		unordered: true
+		unordered: true,
+		list,
+		block,
+		declarations: null
 	};
 };
 
 /**
- * A joined style rule's body in the order `_declarationOrder` prints one in,
- * which each half was already in but the two concatenated need not be.
+ * `_mergeJoinedBoxLonghands` over a joined block's text.
+ * @param {string} body the joined block's declarations
+ * @returns {string} the body, each family it could merge merged
+ */
+const _mergeJoinedBody = (body) => {
+	if (!_S._transforms.mergeLonghands) return body;
+	const declarations = _blockDeclarations(body);
+	if (declarations === null) return body;
+	const merged = _mergeJoinedBoxLonghands(declarations);
+	return merged === declarations
+		? body
+		: merged.map((one) => one.text).join(";");
+};
+
+/**
+ * `_orderJoinedDeclarations` over a joined block's text.
  * @param {string} body the joined body, its braces excluded
  * @param {boolean} plain whether it holds declarations and nothing else
  * @returns {string} the body, reordered where that is allowed
@@ -16172,10 +16903,64 @@ const _joinRuleEntries = (before, entry, owned) => {
 const _orderJoinedBody = (body, plain) => {
 	if (!plain || !_S._transforms.reorderDeclarations) return body;
 	const declarations = _blockDeclarations(body);
-	if (declarations === null || declarations.length < 2) return body;
-	const texts = declarations.map((one) => one.text);
-	const order = _declarationOrder(texts);
-	return order === null ? body : order.map((at) => texts[at]).join(";");
+	if (declarations === null) return body;
+	const ordered = _orderJoinedDeclarations(declarations, plain);
+	return ordered === declarations
+		? body
+		: ordered.map((one) => one.text).join(";");
+};
+
+/**
+ * Whether the last of a printed block's declarations leaves the split that read
+ * them where it started: outside a string and every bracket. Only the last can
+ * end elsewhere, since the split parts the others only there.
+ * @param {PrintedDeclaration[]} declarations the declarations, in order
+ * @returns {boolean} true when a text joined after them is read on its own
+ */
+const _lastDeclarationCloses = (declarations) => {
+	if (declarations.length === 0) return true;
+	const text = declarations[declarations.length - 1].text;
+	let depth = 0;
+	let quote = 0;
+	for (let i = 0; i < text.length; i++) {
+		const cc = text.charCodeAt(i);
+		if (quote !== 0) {
+			if (cc === CC_REVERSE_SOLIDUS) {
+				i++;
+			} else if (cc === quote) {
+				quote = 0;
+			}
+		} else if (cc === CC_QUOTATION_MARK || cc === CC_APOSTROPHE) {
+			quote = cc;
+		} else if (
+			cc === CC_LEFT_PARENTHESIS ||
+			cc === CC_LEFT_SQUARE ||
+			cc === CC_LEFT_CURLY
+		) {
+			depth++;
+		} else if (
+			cc === CC_RIGHT_PARENTHESIS ||
+			cc === CC_RIGHT_SQUARE ||
+			cc === CC_RIGHT_CURLY
+		) {
+			depth--;
+		}
+	}
+	return quote === 0 && depth === 0;
+};
+
+/**
+ * A joined style rule's declarations in the order `_declarationOrder` prints
+ * one in, which each half was already in but the two concatenated need not be.
+ * @param {PrintedDeclaration[]} declarations the joined block's declarations
+ * @param {boolean} plain whether it holds declarations and nothing else
+ * @returns {PrintedDeclaration[]} them, reordered where that is allowed
+ */
+const _orderJoinedDeclarations = (declarations, plain) => {
+	if (!plain || !_S._transforms.reorderDeclarations) return declarations;
+	if (declarations.length < 2) return declarations;
+	const order = _declarationOrder(declarations.map((one) => one.text));
+	return order === null ? declarations : order.map((at) => declarations[at]);
 };
 
 // The group rules whose declarations, nested in a style rule, are the implicit
@@ -16237,7 +17022,7 @@ const _noteStreamedLayerClose = (d, opener, at) => {
 	layers.set(opener, {
 		at,
 		subtree: false,
-		taken: { piece: at, text: "}", spans: [], empties: -1 }
+		taken: new TakenPiece(at, "}", -1)
 	});
 };
 
@@ -16500,7 +17285,7 @@ const _nothingBetweenShadows = (items, texts, from, to, declared, subjects) => {
 // selectors and pseudos are gone: what either holds may look like a combinator.
 const _SUBJECT_STRIP_RE = new RegExp(
 	`${_ATTRIBUTE}|${_PSEUDO_CLASS}|${_PSEUDO_ELEMENT}`,
-	"gi"
+	"g"
 );
 const _SUBJECT_TYPE_RE = /(?:^|[\s>+~])([-\w\u00A0-\uFFFF]+)[^\s>+~]*$/;
 
@@ -16532,11 +17317,11 @@ const _subjectTypes = (prelude) => {
  * @returns {Set<string> | null} the type names
  */
 const _entrySubjectTypes = (entry) => {
-	if (!entry.atRule) return _subjectTypes(entry.text.slice(0, entry.prelude));
+	if (!entry.atRule) return _subjectTypes(_entryPrelude(entry));
 	/** @type {Set<string>} */
 	const out = new Set();
 	for (const child of /** @type {RuleEntry[]} */ (entry.children)) {
-		const types = _subjectTypes(child.text.slice(0, child.prelude));
+		const types = _subjectTypes(_entryPrelude(child));
 		if (types === null) return null;
 		for (const type of types) out.add(type);
 	}
@@ -16565,7 +17350,7 @@ const _subjectsDisjoint = (a, b) => {
  * @returns {boolean} true where its block may be read for what it declares
  */
 const _readableCondition = (entry) => {
-	const name = _atRuleName(entry.text.slice(0, entry.prelude));
+	const name = _atRuleName(_entryPrelude(entry));
 	return name !== "layer" && MERGEABLE_AT_RULES.has(name);
 };
 
@@ -16604,7 +17389,7 @@ const _atRuleDeclaredProperties = (entry) => {
  * @returns {void}
  */
 const _mergeDistantAtRule = (items, texts, held, entry, at) => {
-	const prelude = entry.text.slice(0, entry.prelude);
+	const prelude = _entryPrelude(entry);
 	// WHY: a layer's place in the cascade is where its name is first written, not
 	// what its prelude states, so two blocks naming one are not the pair of equal
 	// conditions this joins. `_mergeNamedLayerBlocks` gathers those under the rule
@@ -16712,7 +17497,12 @@ const _dropRulesWrittenAgain = (items, texts) => {
 	/** @type {Map<string, number[]> | null} */
 	let held = null;
 	for (let i = 0; i < items.length; i++) {
-		if (texts[i].length === 0) continue;
+		if (
+			texts[i].length === 0 ||
+			_types[_nodeIndex(items[i])] === NodeType.Declaration
+		) {
+			continue;
+		}
 		const entry = _ruleEntryOf(items[i], texts[i]);
 		// Keyframes of one selector are not one cascade in every engine: an older
 		// one reads only the last block written for it.
@@ -16724,7 +17514,7 @@ const _dropRulesWrittenAgain = (items, texts) => {
 		) {
 			continue;
 		}
-		const prelude = entry.text.slice(0, entry.prelude);
+		const prelude = _entryPrelude(entry);
 		if (held === null) held = new Map();
 		const earlier = held.get(prelude);
 		if (earlier === undefined) {
@@ -17106,17 +17896,19 @@ const _canonicalSelectorList = (prelude) => {
 	if (!prelude.includes(",")) return prelude;
 	const list = _splitSelectorList(prelude);
 	if (list.length < 2) return prelude;
-	// One pass answers both questions the common case turns on — every selector
-	// distinct, and already in order — so the list is walked once rather than
-	// twice before being handed back untouched.
-	const seen = new Set();
-	let sorted = true;
-	for (let i = 0; i < list.length; i++) {
-		seen.add(list[i]);
-		if (i !== 0 && _compareSelectors(list[i - 1], list[i]) > 0) sorted = false;
+	// Strictly increasing answers both questions the common case turns on —
+	// every selector distinct, and already in order — without a set: only two
+	// equal selectors compare as zero.
+	let i = 1;
+	while (i < list.length && _compareSelectors(list[i - 1], list[i]) < 0) i++;
+	if (i === list.length) return prelude;
+	list.sort(_compareSelectors);
+	let kept = 1;
+	for (let j = 1; j < list.length; j++) {
+		if (list[j] !== list[kept - 1]) list[kept++] = list[j];
 	}
-	if (seen.size === list.length && sorted) return prelude;
-	return [...seen].sort(_compareSelectors).join(",");
+	list.length = kept;
+	return list.join(",");
 };
 
 /**
@@ -17155,10 +17947,13 @@ const _settleJoinedSeams = (entry) => {
 	const head = _joinedHead(settled);
 	return {
 		...entry,
-		text: _joinedBlockText(entry.text.slice(0, entry.prelude), head, settled),
+		text: _joinedBlockText(_entryPrelude(entry), head, settled),
 		children: settled,
 		head,
-		unordered: false
+		unordered: false,
+		list: null,
+		block: null,
+		declarations: null
 	};
 };
 
@@ -17173,7 +17968,7 @@ const _settleJoinedSeams = (entry) => {
 const _canonicalizeJoined = (entry) => {
 	if (entry.atRule) return _settleJoinedSeams(entry);
 	if (entry.prelude === -1) return entry;
-	const prelude = entry.text.slice(0, entry.prelude);
+	const prelude = _entryPrelude(entry);
 	const canonical = _canonicalSelectorList(prelude);
 	if (canonical === prelude) {
 		entry.unordered = false;
@@ -17183,7 +17978,10 @@ const _canonicalizeJoined = (entry) => {
 		...entry,
 		text: canonical + entry.text.slice(entry.prelude),
 		prelude: canonical.length,
-		unordered: false
+		unordered: false,
+		list: null,
+		block: null,
+		declarations: null
 	};
 };
 
@@ -17358,8 +18156,9 @@ const _rulePrelude = (path, writer, minify, outParts) => {
 		if (_S._transforms.customSelectors && _customSelectors.size !== 0) {
 			_writeCustomSelector(parts);
 		}
-		_foldPseudoNames(parts);
-		if (_S._transforms.shortenSelectors) _unwrapLoneIs(parts);
+		if (_foldPseudoNames(parts) && _S._transforms.shortenSelectors) {
+			_unwrapLoneIs(parts);
+		}
 		// After the fold, which is what makes the names above match, and before the
 		// class replacement, so a pseudo written as a class is one either way.
 		if (!_S._isSelectorAllowed) {
@@ -17410,9 +18209,7 @@ const _rulePrelude = (path, writer, minify, outParts) => {
 		}
 		const list = _canonicalSelectorList(prelude);
 		if (_readsThroughGoneEngine(list)) {
-			/** @type {Set<Node>} */ (_unusedRules).add(
-				/** @type {Node} */ (_S._currentNode)
-			);
+			/** @type {Set<Node>} */ (_unusedRules).add(_S._currentNode);
 			return list;
 		}
 		if (_unusedSymbols === null) return list;
@@ -17420,9 +18217,7 @@ const _rulePrelude = (path, writer, minify, outParts) => {
 		// Marked rather than dropped here: the rule's own printer takes it out, the
 		// same way it takes out one whose block ends up empty.
 		if (kept !== null) return kept;
-		/** @type {Set<Node>} */ (_unusedRules).add(
-			/** @type {Node} */ (_S._currentNode)
-		);
+		/** @type {Set<Node>} */ (_unusedRules).add(_S._currentNode);
 		return list;
 	}
 	if (
@@ -17435,9 +18230,7 @@ const _rulePrelude = (path, writer, minify, outParts) => {
 			unescapeIdentifier(prelude.slice(_rawName(path.node).length + 1).trim())
 		)
 	) {
-		/** @type {Set<Node>} */ (_unusedRules).add(
-			/** @type {Node} */ (_S._currentNode)
-		);
+		/** @type {Set<Node>} */ (_unusedRules).add(_S._currentNode);
 	}
 	return prelude;
 };
@@ -17904,6 +18697,39 @@ const _canonicalProperty = (property) => {
 const _orderMatters = (a, b) => {
 	if (a === b || a === "all" || b === "all") return true;
 	if (a.startsWith("--") || b.startsWith("--")) return false;
+	let row = _orderMattersMemo.get(a);
+	let matters = row === undefined ? undefined : row.get(b);
+	if (matters !== undefined) return matters;
+	matters = _computeOrderMatters(a, b);
+	// The names are the author's, so a sheet of made-up ones starts again.
+	if (_orderMattersEntries === _ORDER_MATTERS_ENTRIES) {
+		_orderMattersMemo.clear();
+		_orderMattersEntries = 0;
+		row = undefined;
+	}
+	if (row === undefined) {
+		row = new Map();
+		_orderMattersMemo.set(a, row);
+	}
+	row.set(b, matters);
+	_orderMattersEntries++;
+	return matters;
+};
+
+// `_orderMatters` by its first property, then its second: a sheet names few
+// properties, and the walks back over a block ask of the same pairs again.
+/** @type {Map<string, Map<string, boolean>>} */
+const _orderMattersMemo = new Map();
+let _orderMattersEntries = 0;
+const _ORDER_MATTERS_ENTRIES = 1 << 15;
+
+/**
+ * `_orderMatters` without the memo.
+ * @param {string} a a property, read through `_canonicalProperty`
+ * @param {string} b another
+ * @returns {boolean} true when the two must keep their order
+ */
+const _computeOrderMatters = (a, b) => {
 	// A corner's radius is no side's: `border-bottom` sets no `-radius` it starts.
 	if (
 		a.charCodeAt(0) !== CC_HYPHEN_MINUS &&
@@ -17912,7 +18738,7 @@ const _orderMatters = (a, b) => {
 	) {
 		return false;
 	}
-	if (a.startsWith(`${b}-`) || b.startsWith(`${a}-`)) return true;
+	if (_extendsProperty(a, b) || _extendsProperty(b, a)) return true;
 	// A vendor property no standard one aliases says nothing of what it sets
 	// beyond its words: `-webkit-border-before` is a border side.
 	if (
@@ -17938,6 +18764,18 @@ const _orderMatters = (a, b) => {
 	);
 };
 
+/**
+ * Whether a property name is another's followed by more words: `margin-top` of
+ * `margin`. Read in place, as a `${base}-` prefix would be built on every call.
+ * @param {string} name a property
+ * @param {string} base another
+ * @returns {boolean} true when `name` starts with `base` and a `-`
+ */
+const _extendsProperty = (name, base) =>
+	name.length > base.length &&
+	name.charCodeAt(base.length) === CC_HYPHEN_MINUS &&
+	name.startsWith(base);
+
 // A box side, corner or axis a property names, physical or flow-relative.
 const _PHYSICAL_SIDE_RE =
 	/-(?:top|right|bottom|left|x|y)(?=-|$)|^(?:(?:min|max)-)?(?:top|right|bottom|left|width|height)$|-(?:width|height)$/;
@@ -17967,6 +18805,11 @@ const _blocksMerge = (between, later, families) => {
 	);
 };
 
+// The properties `_sideRoot` reads as `inset`'s and as `size`'s sides.
+const _INSET_SIDE_RE = /^(?:top|right|bottom|left)$/;
+const _SIZE_PROPERTY_RE =
+	/^(?:(?:min|max)-)?(?:width|height|inline-size|block-size)$/;
+
 /**
  * The word a property's sides share: `margin` for `margin-left` and
  * `margin-inline-start`, `inset` for `top`, `size` for `width` and `inline-size`.
@@ -17974,11 +18817,12 @@ const _blocksMerge = (between, later, families) => {
  * @returns {string} that word
  */
 const _sideRoot = (property) => {
-	const bare = property.replace(_VENDOR_ITEM_PREFIX_RE, "");
-	if (/^(?:top|right|bottom|left)$/.test(bare)) return "inset";
-	if (/^(?:(?:min|max)-)?(?:width|height|inline-size|block-size)$/.test(bare)) {
-		return "size";
-	}
+	const bare =
+		property.charCodeAt(0) === CC_HYPHEN_MINUS
+			? property.replace(_VENDOR_ITEM_PREFIX_RE, "")
+			: property;
+	if (_INSET_SIDE_RE.test(bare)) return "inset";
+	if (_SIZE_PROPERTY_RE.test(bare)) return "size";
 	const dash = bare.indexOf("-");
 	return dash === -1 ? bare : bare.slice(0, dash);
 };
@@ -18009,8 +18853,8 @@ const _writesOnlyDeclarations = (path, items, texts) => {
  * @returns {number[] | null} where each comes from, or null to keep them as written
  */
 const _declarationOrder = (texts) => {
-	const ranks = getDeclarationRanks();
-	/** @type {string[]} */
+	const table = _declarationTable();
+	/** @type {number[]} */
 	const properties = [];
 	/** @type {number[]} */
 	const rankOf = [];
@@ -18020,20 +18864,38 @@ const _declarationOrder = (texts) => {
 		if (colon <= 0) return null;
 		const property = toLowerCaseIfNeeded(text.slice(0, colon));
 		if (property.startsWith("--")) {
-			properties.push(property);
+			properties.push(-1);
 			rankOf.push(-1);
 			continue;
 		}
-		const rank = ranks.get(property);
-		if (rank === undefined) return null;
+		const id = table.ids.get(property);
+		if (id === undefined) return null;
+		const rank = table.ranks[id];
 		if (rank !== -1) ranked = true;
-		properties.push(_canonicalProperty(property));
+		properties.push(table.canonical[id]);
 		rankOf.push(rank);
 	}
 	if (!ranked) return null;
-	const order = texts
-		.map((_, i) => i)
-		.sort((a, b) => rankOf[a] - rankOf[b] || a - b);
+	// Already in rank order, which half of all blocks are: the stable sort would
+	// hand every index back where it stands.
+	let inOrder = true;
+	for (let i = 1; i < rankOf.length && inOrder; i++) {
+		if (rankOf[i] < rankOf[i - 1]) inOrder = false;
+	}
+	if (inOrder) return null;
+	// A stable insertion sort by rank: blocks are short, and this allocates no
+	// comparator and no copy as `Array#sort` does.
+	/** @type {number[]} */
+	const order = [];
+	for (let i = 0; i < rankOf.length; i++) {
+		let at = order.length;
+		order.push(i);
+		while (at > 0 && rankOf[order[at - 1]] > rankOf[i]) {
+			order[at] = order[at - 1];
+			at--;
+		}
+		order[at] = i;
+	}
 	let moved = false;
 	for (let i = 0; i < order.length; i++) {
 		if (order[i] !== i) moved = true;
@@ -18042,7 +18904,7 @@ const _declarationOrder = (texts) => {
 		for (let j = i + 1; j < order.length; j++) {
 			if (
 				order[j] < order[i] &&
-				_orderMatters(properties[order[i]], properties[order[j]])
+				_orderMattersById(table, properties[order[i]], properties[order[j]])
 			) {
 				return null;
 			}
@@ -18051,6 +18913,73 @@ const _declarationOrder = (texts) => {
 	return moved ? order : null;
 };
 
+/**
+ * Every property `getDeclarationRanks` names by a small number: its rank, the
+ * number of the property `_canonicalProperty` reads it as, and `_orderMatters`
+ * of two such numbers, filled in as pairs are asked of.
+ * @typedef {object} DeclarationTable
+ * @property {Map<string, number>} ids each property's number
+ * @property {Int32Array} ranks the rank of each number
+ * @property {Int32Array} canonical the number of the property each is read as
+ * @property {string[]} names the property each number stands for
+ * @property {number} all the number of `all`
+ * @property {Uint8Array} matters `_orderMatters` by `a * names.length + b`: 0 unknown, 1 no, 2 yes
+ */
+
+/** @type {DeclarationTable | undefined} */
+let _declarationTableValue;
+
+/**
+ * @returns {DeclarationTable} the table, built on first use
+ */
+const _declarationTable = () => {
+	if (_declarationTableValue !== undefined) return _declarationTableValue;
+	const rankMap = getDeclarationRanks();
+	/** @type {Map<string, number>} */
+	const ids = new Map();
+	/** @type {string[]} */
+	const names = [];
+	for (const name of rankMap.keys()) {
+		ids.set(name, names.length);
+		names.push(name);
+	}
+	const ranks = new Int32Array(names.length);
+	const canonical = new Int32Array(names.length);
+	for (let i = 0; i < names.length; i++) {
+		ranks[i] = /** @type {number} */ (rankMap.get(names[i]));
+		const id = ids.get(_canonicalProperty(names[i]));
+		canonical[i] = id === undefined ? i : id;
+	}
+	_declarationTableValue = {
+		ids,
+		ranks,
+		canonical,
+		names,
+		all: /** @type {number} */ (ids.get("all")),
+		matters: new Uint8Array(names.length * names.length)
+	};
+	return _declarationTableValue;
+};
+
+/**
+ * `_orderMatters` of two numbered properties, -1 for a custom one.
+ * @param {DeclarationTable} table the numbering
+ * @param {number} a a property's canonical number
+ * @param {number} b another
+ * @returns {boolean} true when the two must keep their order
+ */
+const _orderMattersById = (table, a, b) => {
+	if (a === b || a === table.all || b === table.all) return true;
+	// Two custom properties are both -1 yet never trade places: they share a rank.
+	if (a === -1 || b === -1) return false;
+	const at = a * table.names.length + b;
+	const known = table.matters[at];
+	if (known !== 0) return known === 2;
+	const matters = _computeOrderMatters(table.names[a], table.names[b]);
+	table.matters[at] = matters ? 2 : 1;
+	return matters;
+};
+
 /**
  * Put one declaration list together: the list-wide transforms (merge a family's
  * longhands into their shorthand, drop what a later declaration supersedes, add
@@ -18227,7 +19156,8 @@ const _composeBlockBody = (
 			for (const node of held) pendingRules.add(node);
 		}
 	}
-	if (minify) {
+	// A block of declarations alone, most of them, holds no rule to join or drop.
+	if (minify && items !== decls) {
 		// Before the joins, so a rule it takes out stands in none of their way;
 		// and again after any join, which can write a rule again in its turn.
 		if (_S._transforms.removeDeadRules) {
@@ -18430,6 +19360,7 @@ const _composeBlockBody = (
 			for (let i = 0; i < properties.length; i++) {
 				if (properties[i].length === 0) continue;
 				present.add(properties[i]);
+				(_isImportant(items[i]) ? importantAt : plainAt).set(properties[i], i);
 				// A value is only ever asked for against its own property, so the
 				// two share one set.
 				if (values[i].length !== 0) {
@@ -18488,7 +19419,32 @@ const _composeBlockBody = (
 						? _prefixedPropertyName(property)
 						: undefined;
 				if (base !== undefined) {
-					if (present.has(base) && _prefixedPropertyRemovable(base, property)) {
+					// An engine still reading the vendor name as an alias cascades the
+					// two as one property, so it is dead only behind a twin that wins.
+					const importantBase = importantAt.get(base);
+					const plainBase = plainAt.get(base);
+					const important = _isImportant(items[i]);
+					const baseWins = important
+						? importantBase !== undefined && importantBase > i
+						: importantBase !== undefined ||
+							(plainBase !== undefined && plainBase > i);
+					// ...or behind one of the same importance saying the same thing.
+					const twinAt = important ? importantBase : plainBase;
+					const sameTwin =
+						twinAt !== undefined &&
+						(important || importantBase === undefined) &&
+						texts[twinAt].slice(
+							base.length + 1,
+							_printedValueEnd(texts[twinAt], base.length)
+						) ===
+							texts[i].slice(
+								property.length + 1,
+								_printedValueEnd(texts[i], property.length)
+							);
+					if (
+						(baseWins || sameTwin) &&
+						_prefixedPropertyRemovable(base, property)
+					) {
 						if (droppedPrefix === null) droppedPrefix = new Set();
 						droppedPrefix.add(i);
 						continue;
@@ -18588,6 +19544,10 @@ const _composeBlockBody = (
 			: null;
 	/** @type {string[]} */
 	const pieceTexts = [];
+	// The body before its last piece, and that piece: the `;` a `}` makes
+	// redundant is cut off the piece, as reading the body's end would flatten it.
+	let prior = "";
+	let last = "";
 	for (let i = 0; i < texts.length; i++) {
 		const isBlock =
 			bodies !== 0 && path.type(items[i]) !== NodeType.Declaration;
@@ -18630,6 +19590,8 @@ const _composeBlockBody = (
 		}
 		body += nl;
 		const at = body.length;
+		prior = body;
+		last = text;
 		body += text;
 		if (minify && isBlock) {
 			if (spans === null) spans = [];
@@ -18639,18 +19601,15 @@ const _composeBlockBody = (
 	if (pieces !== null) {
 		const order = _declarationOrder(pieceTexts);
 		for (let i = 0; i < pieces.length; i++) {
-			body += pieces[order === null ? i : order[i]];
+			prior = body;
+			last = pieces[order === null ? i : order[i]];
+			body += last;
 		}
 	}
 	// Drop the redundant `;` a following `}` — or, at top level, the end of the
 	// input — makes so, when minifying.
-	if (minify) {
-		while (
-			body.length !== 0 &&
-			body.charCodeAt(body.length - 1) === CC_SEMICOLON
-		) {
-			body = body.slice(0, -1);
-		}
+	if (minify && last.charCodeAt(last.length - 1) === CC_SEMICOLON) {
+		body = prior + last.slice(0, -1);
 	}
 
 	return {
@@ -19199,7 +20158,7 @@ const _S = {
 	// The walk's current position (`A.node` / `A.parent` read these; module-level
 	// so the accessor methods' defaults avoid self-referential `this` typing).
 	/** @type {Node} */
-	_currentNode: /** @type {Node} */ (/** @type {unknown} */ (0)),
+	_currentNode: /** @type {Node} */ (/** @type {Node | number} */ (0)),
 	// The declaration `_inKeywordOnlyValue` last answered for, and its answer: one
 	// value's identifiers all ask it, and the read is a pointer compare after the
 	// first. Cleared with the rest of the parse state, so no node outlives it.
@@ -19499,10 +20458,10 @@ const A = {
 	field(i, field, n = _S._currentNode) {
 		const k = _nodeIndex(n);
 		if (i < 0 || i >= A.fieldCount(field, n)) {
-			return /** @type {Node} */ (_nodeRef(0));
+			return _nodeRef(0);
 		}
 		if (_LIST_FIELD[_types[k]] === field) {
-			return /** @type {Node} */ (_nodeRef(_flat[_listStarts[k] + i]));
+			return _nodeRef(_flat[_listStarts[k] + i]);
 		}
 		return (field === Field.declarations ? _declBodies : _ruleBodies)[
 			_bodyIdx[k] - 1
@@ -19519,7 +20478,7 @@ const A = {
 			const item = A.field(i, field, n);
 			if (A.name(item) === name) return item;
 		}
-		return /** @type {Node} */ (_nodeRef(0));
+		return _nodeRef(0);
 	},
 	/**
 	 * `important` is a container's bit, cleared when its id is reused; a token's
@@ -19698,7 +20657,13 @@ const _collectRuleSpans = (spans, item, text, at, path, inner) => {
 	// it — the parent first, so a cut that takes the whole rule is seen before
 	// anything inside it.
 	if (path.type(item) === NodeType.QualifiedRule) {
-		spans.push({ scope: _rootScope(), key: text, at, len: text.length });
+		spans.push({
+			scope: _rootScope(),
+			key: text,
+			at,
+			len: text.length,
+			taken: null
+		});
 	} else if (
 		inner !== undefined &&
 		inner.prelude.charCodeAt(0) === CC_AT_SIGN &&
@@ -19706,7 +20671,13 @@ const _collectRuleSpans = (spans, item, text, at, path, inner) => {
 	) {
 		// Not a rule of its own — a condition its body is read under — so it is
 		// noted only to be cut once the cuts inside it have left it empty.
-		spans.push({ scope: _rootScope(), key: UNKEYED, at, len: text.length });
+		spans.push({
+			scope: _rootScope(),
+			key: UNKEYED,
+			at,
+			len: text.length,
+			taken: null
+		});
 	}
 	if (inner === undefined) return;
 	const base = at + inner.bodyAt;
@@ -19715,7 +20686,8 @@ const _collectRuleSpans = (spans, item, text, at, path, inner) => {
 			scope: _enclosingRuleScope(span.scope, inner.keyPrelude),
 			key: span.key,
 			at: base + span.at,
-			len: span.len
+			len: span.len,
+			taken: null
 		});
 	}
 };
@@ -19764,6 +20736,7 @@ module.exports._NUMERIC_RE = _NUMERIC_RE;
 module.exports._atKeywordOf = _atKeywordOf;
 module.exports._printedSource = _printedSource;
 module.exports._rawName = _rawName;
+module.exports._setVerbatimLeafPrinter = setVerbatimLeafPrinter;
 module.exports._trimCssWhiteSpace = _trimCssWhiteSpace;
 module.exports._declarationsOf = _declarationsOf;
 module.exports._rulesOf = _rulesOf;
@@ -19773,6 +20746,33 @@ module.exports._S = _S;
 module.exports._SEP = _SEP;
 module.exports._keepKeywordComments = _keepKeywordComments;
 module.exports._TRIM_COMBINATORS = _TRIM_COMBINATORS;
+/**
+ * The body a reused block composes to, for the rule being printed.
+ * @param {Node} node the rule
+ * @returns {string | undefined} the body, or undefined to compose it
+ */
+module.exports._memoizedBlockBody = (node) =>
+	_blockMemoNode === node ? _blockMemoBody : undefined;
+/**
+ * Done with the rule the walk looked a block up for: keep the body it composed
+ * where the walk asked for one, and forget the rule — node ids are reused.
+ * @param {Node} node the rule
+ * @param {string | null} body its composed body, null to keep none
+ * @returns {void}
+ */
+module.exports._memoizeBlockBody = (node, body) => {
+	if (
+		_blockMemoNode === node &&
+		body !== null &&
+		_blockMemoKey !== "" &&
+		_blockMemo !== null
+	) {
+		_blockMemoKeyTable.set(_blockMemoKey, body);
+	}
+	_blockMemoNode = null;
+	_blockMemoBody = undefined;
+	_blockMemoKey = "";
+};
 module.exports._TRIM_CONDITIONS = _TRIM_CONDITIONS;
 module.exports._TRIM_MATH = _TRIM_MATH;
 module.exports._TRIM_NOTHING = _TRIM_NOTHING;