webpack 5.112.0 → 5.112.2

package/lib/css/syntax-printer.js

@@ -179,6 +179,8 @@ const {
 	_joinSlots,
 	_keepKeywordComments,
 	_lowercaseConditionParts,
+	_memoizeBlockBody,
+	_memoizedBlockBody,
 	_minifyColorFunction,
 	_minifyPolarColorFunction,
 	_nearByteHalf,
@@ -200,6 +202,7 @@ const {
 	_rulesOf,
 	_setHoistedRuns,
 	_setRuleEntry,
+	_setVerbatimLeafPrinter,
 	_shortestAuthoredFlex,
 	_shortestColor,
 	_shortestFlexValue,
@@ -1342,11 +1345,7 @@ const _prefixQualifiedRule = (ruleText, parts, soft, body, scope, top) => {
 		const removable = bases.every(
 			(base, i) =>
 				selectors[i].at === -1 ||
-				_prefixRemovable(
-					PREFIXED_SELECTORS,
-					base,
-					/** @type {string} */ (listPrefix)
-				)
+				_prefixRemovable(PREFIXED_SELECTORS, base, listPrefix)
 		);
 		// Covered when every selector is: a list of twins says the same as one twin
 		// of the list, and the rules writing them need not be one rule.
@@ -2388,12 +2387,17 @@ const _writeNested = (
 	const taken = [];
 	// A rule written in another names its own parent where its list opens on a
 	// combinator, so that parent stays an `&` the next level out writes in.
-	const against =
-		path.parent !== null && path.type(path.parent) !== NodeType.Stylesheet
-			? _parentNamed(prelude)
-			: prelude;
+	// Read only once a rule written in this one asks.
+	/** @type {string | undefined} */
+	let against;
 	for (let i = _pendingNested.length - 1; i >= 0; i--) {
 		if (_pendingNested[i].owner !== node) continue;
+		if (against === undefined) {
+			against =
+				path.parent !== null && path.type(path.parent) !== NodeType.Stylesheet
+					? _parentNamed(prelude)
+					: prelude;
+		}
 		const one = _pendingNested[i];
 		_pendingNested.splice(i, 1);
 		one.prelude = _resolveNestedPrelude(one.prelude, against);
@@ -2504,7 +2508,10 @@ const _hoistedEntry = (text, prelude) => ({
 	listKind: LIST_KIND_SELECTOR,
 	children: null,
 	head: "",
-	unordered: false
+	unordered: false,
+	list: null,
+	block: null,
+	declarations: null
 });
 
 /**
@@ -2516,7 +2523,7 @@ const _hoistedEntry = (text, prelude) => ({
  * @returns {void}
  */
 const _recordHoistedRule = (text, parent, parentPrelude) => {
-	const node = /** @type {Node} */ (_S._currentNode);
+	const node = _S._currentNode;
 	if (parent === null && _nestedRuns.length === 1) {
 		_setRuleEntry(node, _hoistedEntry(text, _nestedRuns[0].prelude));
 		return;
@@ -3190,8 +3197,11 @@ const _numberAlphaValue = (property, value) => {
 	const parts = _LONE_PERCENTAGE_RE.exec(value);
 	if (parts === null) return value;
 	const digits = `00${parts[2]}`;
-	const shifted = _normalizeNumber(
-		`${parts[1]}${digits.slice(0, -2)}.${digits.slice(-2)}${parts[3] || ""}`
+	// A number rounds to fewer digits than the percentage it was printed as.
+	const shifted = _roundSignificant(
+		_normalizeNumber(
+			`${parts[1]}${digits.slice(0, -2)}.${digits.slice(-2)}${parts[3] || ""}`
+		)
 	);
 	return shifted.length < value.length ? shifted : value;
 };
@@ -3587,6 +3597,18 @@ const _dropDefaultGradientPosition = (fn, inner) => {
 	return match[1] === undefined ? rest : `${match[1]},${rest}`;
 };
 
+// The basic shapes `_dropDefaultShapeParts` reads, so every other call is
+// turned away before its arguments are scanned.
+const _BASIC_SHAPE_FUNCTIONS = new Set([
+	"polygon",
+	"path",
+	"circle",
+	"ellipse",
+	"inset",
+	"rect",
+	"xywh"
+]);
+
 /**
  * Drop what a basic shape (CSS Shapes 1 §3) says with its own defaults: a
  * `closest-side` radius, a zero corner `round`, `nonzero`, and the sides an
@@ -3596,7 +3618,11 @@ const _dropDefaultGradientPosition = (fn, inner) => {
  * @returns {string | null} the arguments without them, or null to keep them
  */
 const _dropDefaultShapeParts = (fn, inner) => {
-	if (!_S._transforms.reduceFunctions || containsSubstitutionFunction(inner)) {
+	if (
+		!_BASIC_SHAPE_FUNCTIONS.has(fn) ||
+		!_S._transforms.reduceFunctions ||
+		containsSubstitutionFunction(inner)
+	) {
 		return null;
 	}
 	if (fn === "polygon" || fn === "path") {
@@ -4285,6 +4311,23 @@ const _standardSpelling = (property) => {
 	return standard === undefined ? property : standard;
 };
 
+/**
+ * What `_composeBlockBody` hands back for a block of declarations alone whose
+ * body was composed before.
+ * @param {string} body the body
+ * @returns {ReturnType<typeof _composeBlockBody>} the composition
+ */
+const _memoizedComposition = (body) => ({
+	body,
+	items: [],
+	texts: [],
+	superseded: null,
+	droppedPrefix: null,
+	addedPrefix: null,
+	deadPrefixed: null,
+	spans: null
+});
+
 /**
  * Shorten a shorthand declaration's value to an equivalent spelling. A prefixed
  * spelling is a different property, and neither table lists one.
@@ -4465,6 +4508,7 @@ const _dropFontNormals = (components) => {
  * @returns {string[] | null} the fragments to join, or `null` to keep the value
  */
 const _shortenIndividualTransform = (property, components) => {
+	if (property !== "translate" && property !== "scale") return null;
 	if (components.length > 3) return null;
 	if (components.some((one) => one.includes("(") || one.includes(","))) {
 		return null;
@@ -4486,7 +4530,7 @@ const _shortenIndividualTransform = (property, components) => {
 		for (let i = 0; i < kept.length; i++) {
 			const percentage = _PERCENTAGE_RE.exec(kept[i]);
 			if (percentage === null) continue;
-			const number = _shiftDecimal(percentage[1], -2);
+			const number = _roundSignificant(_shiftDecimal(percentage[1], -2));
 			if (number.length <= kept[i].length) kept[i] = number;
 		}
 		if (kept.length === 3 && Number(kept[2]) === 1) kept.pop();
@@ -4849,6 +4893,1071 @@ const _printAttributeSelector = (path, children, writer) => {
 	return parts;
 };
 
+/**
+ * The `printer` case for a function.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {PrintContext} writer the print context (children's printed text)
+ * @param {boolean} minify whether minifying
+ * @returns {string} the node's serialized text
+ */
+const _printFunctionNode = (path, writer, minify) => {
+	const written = _rawName(path.node);
+	// An escape spells the same name (§4.3.7): `c\61 lc(` is `calc()`, so
+	// every table below reads what it spells.
+	const name = written.includes("\\") ? unescapeIdentifier(written) : written;
+	// A container style query asks whether a custom property's value is the one
+	// written here, comparing token streams as written (CSS Conditional 5 §5),
+	// so a squeezed whitespace run asks another question. Nothing is rewritten.
+	if (
+		minify &&
+		!path.within(NodeType.Declaration) &&
+		_S._inMediaConditionPrelude &&
+		asciiCaseInsensitiveMatch(name, "style")
+	) {
+		const source = _printedSource(path.node);
+		// Unclosed at EOF, the source carries no `)` for the walk to have
+		// closed — printed as usual so the parenthesis is written back.
+		if (source.endsWith(")")) {
+			// Written whole, comments included, so the queued copies are claimed
+			// here rather than flushed a second time after the rule.
+			writer.takeInserts(path.start(), path.end());
+			return source;
+		}
+	}
+	let inner;
+	if (path.childCount() === 1) {
+		// Half of all functions take one argument, which `_join` would hand
+		// straight back — and a trim only ever parts two of them, so no
+		// universal a compound implies can stand beside anything here either.
+		const only = writer.get(path.child(0));
+		inner = only === _SEP ? "" : only;
+	} else {
+		// A selector function's argument is a selector, so its combinators need
+		// no whitespace, as in the enclosing prelude; an `@import`'s
+		// `supports()` and a container's `scroll-state()` hold conditions.
+		const lower = name.toLowerCase();
+		const trim =
+			_S._mathFunctionDepth !== 0
+				? _TRIM_MATH
+				: path.within(NodeType.Declaration)
+					? _TRIM_NOTHING
+					: SELECTOR_FUNCTIONS.has(lower)
+						? _TRIM_COMBINATORS
+						: (_S._inSupportsPrelude && lower === "supports") ||
+							  (_S._inMediaConditionPrelude && lower === "scroll-state")
+							? _TRIM_CONDITIONS
+							: _TRIM_NOTHING;
+		/** @type {string[]} */
+		const parts = [];
+		_appendChildTexts(path.node, writer, parts);
+		if (minify && trim === _TRIM_CONDITIONS) _keepKeywordComments(parts);
+		// A selector function's argument is a selector like the prelude's, so
+		// the universal a compound implies says nothing there either — except
+		// under test in a `@supports` condition, where only whitespace goes.
+		if (minify && trim === _TRIM_COMBINATORS && !_S._inSupportsPrelude) {
+			if (_foldPseudoNames(parts) && _S._transforms.shortenSelectors) {
+				_unwrapLoneIs(parts);
+			}
+			_dropImpliedUniversalSelector(parts);
+		}
+		inner = _join(parts, !minify, minify ? trim : _TRIM_NOTHING);
+		// A leading `+` in An+B is a sign, not a combinator: `+ n` is no
+		// argument an engine reads, and `+n` would be one.
+		if (minify && NTH_PSEUDO_FUNCTIONS.has(lower)) {
+			const at = parts.findIndex((part) => part.length !== 0 && part !== _SEP);
+			if (parts[at] === "+" && parts[at + 1] === _SEP) {
+				inner = `+ ${inner.slice(1)}`;
+			}
+		}
+		// Chrome throws out `attr( name unit )` where `attr( name unit)`
+		// parses, so the space before the `)` decides whether the declaration
+		// runs — `_join` drops a trailing one like any other.
+		if (
+			minify &&
+			parts[parts.length - 1] === _SEP &&
+			asciiCaseInsensitiveMatch(name, "attr")
+		) {
+			inner += " ";
+		}
+	}
+	if (!minify) return `${written}(${inner})`;
+	// Function names match ASCII case-insensitively, so one lowercase name
+	// is what every table below is keyed by; the eleven transforms spelled
+	// with a capital are printed the way everything else writes them.
+	const fn = asciiLowercaseName(name);
+	// As with a unit: a name already lowercase is its own answer, and only a
+	// shouted one is looked up. The lookup key still folds inside a
+	// substituted value; only the printed spelling stays as written.
+	let out =
+		_S._inSubstitutedValue ||
+		_S._inSupportsSelector ||
+		!_S._transforms.foldCase ||
+		fn.startsWith("--")
+			? name
+			: fn === name
+				? fn
+				: CANONICAL_NAMES.get(fn) || fn;
+	if (written !== name) {
+		out = _S._transforms.rewriteEscapes ? escapeName(out) : written;
+	}
+	// An+B in a selector: `2n+1` is what `odd` names, and shorter written so.
+	if (!path.within(NodeType.Declaration) && NTH_PSEUDO_FUNCTIONS.has(fn)) {
+		return _S._inSupportsSelector
+			? `${out}(${inner})`
+			: _minifyAnPlusB(out, inner);
+	}
+	// Every rewrite below is keyed by a name none of these carry.
+	if (
+		SUBSTITUTION_FUNCTIONS.has(fn) ||
+		(!path.within(NodeType.Declaration) && SELECTOR_FUNCTIONS.has(fn))
+	) {
+		return `${out}(${inner})`;
+	}
+	// WHY: an `rgb()` or `rgba()` collapses to the shortest color and anything
+	// else keeps its `name(args)` form. A color inside a `@supports` condition
+	// is syntax under test — the engines reading `#0000` are not those reading
+	// `rgba(0,0,0,0)` — so rewriting it asks another question, and esbuild,
+	// clean-css and lightningcss leave the condition alone too. A color read as
+	// numbers, in a gradient stop, a `color-mix()` argument or a relative
+	// color's origin, stays as written unless converting it is exact, which the
+	// legacy sRGB forms are where their channels are bytes.
+	let color = _S._inSupportsPrelude
+		? null
+		: _minifyColorFunction(
+				fn,
+				inner,
+				_S._hexAlphaAllowed,
+				_S._inColorOperand
+			) ||
+			(_S._inColorOperand
+				? null
+				: _minifyPolarColorFunction(fn, inner, _S._hexAlphaAllowed));
+	// A mix no byte holds is written back in the space it was computed in,
+	// which can be longer than the call — then the call is the shorter one.
+	if (color !== null && color.length > fn.length + inner.length + 2) {
+		color = null;
+	}
+	if (color !== null && (color !== "transparent" || !_inTapHighlightColor())) {
+		return color === "transparent" && _S._hexAlphaAllowed ? "#0000" : color;
+	}
+	// `light-dark()` names a color per scheme, which the pair above says with
+	// a substitution the scheme itself switches. Two arguments only: the
+	// grammar takes exactly that many, and anything else is no such call.
+	if (
+		_S._loweringLightDark &&
+		fn === "light-dark" &&
+		path.within(NodeType.Declaration) &&
+		!_S._inCustomProperty &&
+		!_S._inSupportsPrelude &&
+		!_S._inSubstitutedValue
+	) {
+		const halves = _splitTopLevelArguments(inner);
+		// A half the target cannot read would substitute into a `var()` and make
+		// the declaration invalid at computed-value time, where nothing before it
+		// is read — so it is left alone rather than lowered.
+		if (halves.length === 2 && !_namesUnreadableColor(inner)) {
+			_S._lightDarkUsed = true;
+			return `var(${LIGHT_PROPERTY},${halves[0].trim()})var(${DARK_PROPERTY},${halves[1].trim()})`;
+		}
+	}
+	// A math function over constants of one unit is that value, written back as
+	// a `calc()`: the parentheses stay, since dropping them turns a clamped
+	// negative into a parse error, and only the declaration printer does.
+	if (!_S._inSupportsPrelude && !_S._inCustomProperty) {
+		const term = _foldMathFunction(fn, inner);
+		if (term !== null) {
+			// A term that means the same bare needs no parentheses anywhere, so
+			// it is written as itself; the rest keep a `calc()` for the
+			// declaration printer to judge against the property.
+			const shape =
+				_S._mathFunctionDepth > 1 || _inNumberArgument(path)
+					? _NESTED_TERM_RE
+					: _BARE_TERM_RE;
+			const folded =
+				(shape.test(term) ||
+					(_S._mathFunctionDepth === 1 &&
+						_NEGATIVE_TERM_RE.test(term) &&
+						_inNegativeAcceptingArgument(path))) &&
+				!_inCalcRejectingProperty() &&
+				!(!/[a-z%]$/i.test(term) && _inNumberOnlyOutsideCalcProperty()) &&
+				!_foldLosesClamp(term) &&
+				!_foldBelowStepCount(term, path)
+					? term
+					: `calc(${term})`;
+			// A division can land on a value needing every digit of a double, which
+			// is longer than the expression producing it. Only the outermost call
+			// is asked, a nested one being a term still to be reduced.
+			if (
+				_S._mathFunctionDepth > 1 ||
+				folded.length < fn.length + inner.length + 2 ||
+				_unwrapsShorter(path, folded, fn.length + inner.length + 2)
+			) {
+				return folded;
+			}
+		}
+		const reduced = _reduceMathArguments(fn, inner);
+		// A `calc()` inside another math function is the parentheses it
+		// stands for (CSS Values 4 §10.1), whatever a substitution expands to.
+		if (
+			fn === "calc" &&
+			_S._mathFunctionDepth > 1 &&
+			path.within(NodeType.Declaration) &&
+			_S._transforms.reduceFunctions
+		) {
+			return `(${reduced === null ? inner : reduced})`;
+		}
+		if (reduced !== null) return `${fn}(${reduced})`;
+	}
+	// An easing function is only ever a value; `url()` is also an at-rule
+	// prelude's (`@import url("a.css")`).
+	const easing =
+		path.within(NodeType.Declaration) && !_S._inCustomProperty
+			? _minifyEasingFunction(fn, inner)
+			: null;
+	if (easing !== null) return easing;
+	// A translation's percentage is of the element's own box, which always
+	// has a size, so a `0%` term beside one length adds nothing to it.
+	if (
+		_S._transforms.reduceFunctions &&
+		path.within(NodeType.Declaration) &&
+		!_S._inSubstitutedValue &&
+		fn.startsWith("translate") &&
+		inner.includes("0%")
+	) {
+		const args = _splitTopLevelArguments(inner);
+		let changed = false;
+		for (let i = 0; i < args.length; i++) {
+			// A z slot takes no percentage, so a `0%` there makes the whole
+			// declaration invalid, which dropping it would revive.
+			if (fn === "translatez" || (fn === "translate3d" && i === 2)) {
+				continue;
+			}
+			const term = _dropZeroPercentTerm(args[i].trim());
+			if (term !== null) {
+				args[i] = term;
+				changed = true;
+			}
+		}
+		// The rewrites below read the arguments as they now stand.
+		if (changed) inner = args.join(",");
+	}
+	// `translateX(v)` is `translate(v)` and `skewX(a)` is `skew(a)`, the second
+	// component defaulting to 0. Only for one plain component: a substitution
+	// could expand to two, reviving a declaration the browser drops.
+	const oneAxis = _S._transforms.reduceFunctions
+		? X_AXIS_TRANSFORMS.get(fn)
+		: undefined;
+	if (
+		oneAxis !== undefined &&
+		path.within(NodeType.Declaration) &&
+		!_S._inSubstitutedValue &&
+		!inner.includes(",") &&
+		!containsSubstitutionFunction(inner)
+	) {
+		return `${oneAxis}(${inner})`;
+	}
+	if (path.within(NodeType.Declaration) && !_S._inSubstitutedValue) {
+		// An argument that is the amount an omitted one means says nothing,
+		// whether or not the zero still carries the unit its grammar drops.
+		const omitted = _S._transforms.reduceFunctions
+			? FILTER_FUNCTION_OMITTED.get(fn)
+			: undefined;
+		if (omitted !== undefined) {
+			const bare = _dropCallZeroUnit(fn, inner);
+			if (bare === omitted || (omitted === "1" && bare === "100%")) {
+				return `${out}()`;
+			}
+		}
+		const reduced = _reduceTransformFunctionDeep(fn, inner);
+		if (reduced !== null) return reduced;
+		// The stops are folded over what dropping the direction leaves, a
+		// gradient carrying both otherwise keeping whichever ran second.
+		const shape = _dropDefaultShapeParts(fn, inner);
+		if (shape !== null) return `${out}(${shape})`;
+		let gradient = _reduceGradientDirection(fn, inner);
+		if (gradient === null) {
+			gradient = _dropDefaultGradientPosition(fn, inner);
+		}
+		let stops = _foldGradientStops(
+			fn,
+			gradient === null ? inner : gradient,
+			_S._doublePositionAllowed
+		);
+		// A double position the target cannot read is written as the two
+		// stops it names, over whatever the folds above left.
+		if (!_S._doublePositionAllowed) {
+			const split = !_S._transforms.lowerUnsupported
+				? null
+				: _splitDoublePositionStops(
+						fn,
+						stops !== null ? stops : gradient !== null ? gradient : inner
+					);
+			if (split !== null) stops = split;
+		}
+		if (stops !== null) return `${out}(${stops})`;
+		if (gradient !== null) return `${out}(${gradient})`;
+	}
+	// A zero angle needs no unit where the grammar names `<zero>` beside
+	// `<angle>` (CSS Transforms 2, Filter Effects 1).
+	if (
+		path.within(NodeType.Declaration) &&
+		!_S._inSubstitutedValue &&
+		_S._transforms.shortenNumbers &&
+		ZERO_ANGLE_FUNCTIONS.has(fn)
+	) {
+		const bare = inner.replace(_ZERO_ANGLE_ARGUMENT_RE, "$10");
+		if (bare !== inner) return `${out}(${bare})`;
+	}
+	// A name kept escaped keeps its call as written: unquoting it rests on the
+	// tokenizer reading `url` through the escape.
+	const url =
+		_S._inSubstitutedValue || (written !== name && out === written)
+			? null
+			: _minifyUrlFunction(fn, inner);
+	if (url !== null) return url;
+	return `${out}(${inner})`;
+};
+
+/**
+ * The `printer` case for a `url()` token.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {boolean} minify whether minifying
+ * @returns {string} the node's serialized text
+ */
+const _printUrlNode = (path, minify) => {
+	const source = _printedSource(path.node);
+	// Closed at EOF: write the `)` back so the url stops where it stopped for
+	// the tokenizer rather than swallowing what the printer emits next. Before
+	// the rest rather than instead of it, or a second pass is what folds it.
+	const unterminated = _isUnterminatedUrl(source);
+	const raw = unterminated ? _terminate(source, ")", "\uFFFD") : source;
+	// The tokenizer already trimmed the url-token's content, so the padding in
+	// `url(  a.png  )` carries nothing.
+	if (!minify) return raw;
+	const open = raw.indexOf("(");
+	// `url` matches ASCII case-insensitively like any function name. Read in
+	// place, since cutting the name out would allocate on every url and all but
+	// a shouted one folds to itself. In a substituted value nothing is read.
+	let head = null;
+	if (!_S._inSubstitutedValue && _S._transforms.foldCase) {
+		for (let i = 0; i < open; i++) {
+			const c = raw.charCodeAt(i);
+			if (c >= CC_UPPER_A && c <= CC_UPPER_Z) {
+				head = asciiLowercaseName(raw.slice(0, open + 1));
+				break;
+			}
+		}
+	}
+	const percent = raw.includes("%");
+	/**
+	 * @returns {string} the url-token as it prints with nothing rendered
+	 */
+	const plainUrl = () => {
+		// Padding only exists when the content is whitespace-bounded; checking
+		// that costs two char reads, reading the content costs a slice.
+		if (
+			!percent &&
+			!isAsciiWhitespace(raw.charCodeAt(open + 1)) &&
+			!isAsciiWhitespace(raw.charCodeAt(raw.length - 2))
+		) {
+			return head === null ? raw : head + raw.slice(open + 1);
+		}
+		const name = head === null ? raw.slice(0, open + 1) : head;
+		const value = _urlValue(path, unterminated);
+		// A url-token already carrying an escape is one this printer did not
+		// write, so its `\%` is not read as the start of a percent-escape.
+		return `${name}${
+			percent && !value.includes("\\")
+				? _decodePercentEscapes(value, true, "")
+				: value
+		})`;
+	};
+	// Ahead of the padding fast path below: a base64 `data:` url is
+	// whitespace-free and `%`-free, so it would take it and never be offered.
+	if (_S._deferEmbeddedSource !== undefined) {
+		const opener = head === null ? raw.slice(0, open + 1) : head;
+		const deferred = _deferDataUrl(
+			_urlValue(path, unterminated),
+			(url) => `${opener}${_serializeUrl(url, '"')})`,
+			plainUrl()
+		);
+		if (deferred !== null) return deferred;
+	}
+	if (_S._renderEmbeddedSource !== undefined) {
+		const renderedUrl = _renderDataUrl(_urlValue(path, unterminated));
+		if (renderedUrl !== null) {
+			const name = head === null ? raw.slice(0, open + 1) : head;
+			return `${name}${_serializeUrl(renderedUrl, '"')})`;
+		}
+	}
+	return plainUrl();
+};
+
+/**
+ * The `printer` case for a string.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {boolean} minify whether minifying
+ * @returns {string} the node's serialized text
+ */
+const _printStringNode = (path, minify) => {
+	const source = _printedSource(path.node);
+	// Closed at EOF: write the quote back, for the same reason as `url()`.
+	// Written here rather than after the transforms below, or they read a
+	// string with no closing quote and decline it, which a second pass undoes.
+	const raw = _isClosedString(source)
+		? source
+		: _terminate(source, source[0], "");
+	// A custom property hands its string back as written, quotes included.
+	if (!minify || _S._inCustomProperty) return raw;
+	// `<family-name>` is `<string> | <custom-ident>+`, so a family whose text
+	// is a run of identifiers means the same unquoted, two bytes shorter.
+	if (
+		!_S._inSupportsPrelude &&
+		!_S._inSubstitutedValue &&
+		((_inFontFamily() && _isLoneFamilyName(path)) || _isLoneFontFamily(path))
+	) {
+		const unquoted = _unquoteFontFamily(raw);
+		if (unquoted !== null) return unquoted;
+	}
+	const written = _minifyString(raw);
+	return (_S._charsetPiece === -1 && !_S._assumeUtf8) ||
+		!_S._transforms.rewriteEscapes
+		? written
+		: _unescapeAstral(written);
+};
+
+/**
+ * The `printer` case for an ident.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {boolean} minify whether minifying
+ * @returns {string} the node's serialized text
+ */
+const _printIdentNode = (path, minify) => {
+	const raw = _printedSource(path.node);
+	if (!minify) return raw;
+	// A keyword is matched by what an escape spells, not by how it is written.
+	const meaning = raw.includes("\\") ? unescapeIdentifier(raw) : raw;
+	// `transparent` is `#0000` where the target reads a hex alpha — the same
+	// color, six bytes shorter. The tap-highlight guard still holds: that
+	// WebKit bug is about the keyword's *value*, whichever way it is spelled.
+	if (
+		path.within(NodeType.Declaration) &&
+		!_S._inSubstitutedValue &&
+		_S._hexAlphaAllowed &&
+		_S._transforms.shortenColors &&
+		asciiCaseInsensitiveMatch(meaning, "transparent") &&
+		!_inTapHighlightColor()
+	) {
+		return "#0000";
+	}
+	// The keyword names each platform's own UI font, which a target that
+	// does not read it reaches only through the platform's own name for it.
+	if (
+		!_S._systemUiAllowed &&
+		_S._transforms.lowerUnsupported &&
+		path.within(NodeType.Declaration) &&
+		!_S._inCustomProperty &&
+		!_S._inSubstitutedValue &&
+		asciiCaseInsensitiveMatch(meaning, "system-ui") &&
+		_inFontFamily()
+	) {
+		return SYSTEM_UI_STACK;
+	}
+	if (
+		path.within(NodeType.Declaration) &&
+		!_S._inCustomProperty &&
+		!_S._inSupportsPrelude &&
+		!_S._inSubstitutedValue
+	) {
+		// One fold for both questions below, handing back the string where nothing
+		// changes. ASCII only: `pin\212A` ends in a Kelvin sign, not a `k`.
+		const lowered = asciiLowercaseName(meaning);
+		// A named color where the property takes nothing else an identifier could
+		// be: `white` is `#fff`, both computing to `rgb(255, 255, 255)`.
+		// Elsewhere an identifier may be the author's own name.
+		if (_S._transforms.shortenColors) {
+			const shorter = getColorNameToShortest().get(lowered);
+			if (
+				shorter !== undefined &&
+				(_inColorOnlyProperty() ||
+					_inGradientArgument(path) ||
+					_atBackgroundTop(path))
+			) {
+				return shorter;
+			}
+		}
+		// A keyword-only or color property names nothing of the author's, so an
+		// ident directly in its value (a call's arguments are their own grammar's)
+		// is a keyword matched ASCII case-insensitively, but a dashed ident (§4.2).
+		if (
+			_S._transforms.foldCase &&
+			lowered !== raw &&
+			path.parent === _S._valueDeclaration &&
+			!meaning.startsWith("--") &&
+			_inKeywordOnlyValue()
+		) {
+			const folded =
+				meaning !== raw && _S._transforms.rewriteEscapes
+					? escapeIdentifier(lowered)
+					: asciiLowercaseName(raw);
+			if (folded !== raw) return folded;
+		}
+	}
+	return _S._transforms.rewriteEscapes ? _minifyIdentEscapes(raw) : raw;
+};
+
+/**
+ * The `printer` case for a simple block.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {PrintContext} writer the print context (children's printed text)
+ * @param {boolean} minify whether minifying
+ * @returns {string} the node's serialized text
+ */
+const _printSimpleBlockNode = (path, writer, minify) => {
+	const open = _blockTokenOf(path.node);
+	const close = open === "(" ? ")" : open === "[" ? "]" : "}";
+	// Outside a declaration value a `[…]` is an attribute selector and a `(…)`
+	// a query condition. Inside one they are a grid line-name list and a
+	// `calc()` sub-expression, where neither of those rewrites holds.
+	const structural = minify && !path.within(NodeType.Declaration);
+	/** @type {string[]} */
+	let parts;
+	if (structural && open === "[") {
+		parts = _printAttributeSelector(path, path.children(), writer);
+	} else {
+		// One array, rather than a child list and a mapped copy of it.
+		parts = [];
+		_appendChildTexts(path.node, writer, parts);
+	}
+	if (structural && open === "(" && _S._inMediaConditionPrelude) {
+		if (_S._transforms.foldCase) _lowercaseConditionParts(parts);
+		if (_S._rangeSpellingAllowed) _useRangeSpelling(parts);
+	}
+	if (
+		minify &&
+		structural &&
+		open === "(" &&
+		(_S._inSupportsPrelude || _S._inMediaConditionPrelude)
+	) {
+		_keepKeywordComments(parts);
+	}
+	let trim = minify && _S._mathFunctionDepth !== 0 ? _TRIM_MATH : _TRIM_NOTHING;
+	if (structural && open === "(") {
+		// `@scope`'s parentheses hold selector lists, so a `:` there starts a
+		// pseudo-class and the whitespace before it is a descendant combinator
+		// — `@scope (div :hover)` is not `@scope (div:hover)`.
+		trim = _inScopePrelude(path) ? _TRIM_COMBINATORS : _TRIM_CONDITIONS;
+		if (trim === _TRIM_COMBINATORS) _foldPseudoNames(parts);
+	}
+	const inner = _join(parts, !minify, trim);
+	return `${open}${inner}${close}`;
+};
+
+/**
+ * The `printer` case for a declaration.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {PrintContext} writer the print context (children's printed text)
+ * @param {boolean} minify whether minifying
+ * @param {string} soft `""` minifying, `" "` beautifying
+ * @returns {string} the node's serialized text
+ */
+const _printDeclarationNode = (path, writer, minify, soft) => {
+	const name = _rawName(path.node);
+	// WHY: a property is matched by what its name means, not by how it was
+	// spelled — §4.3.7 lets any of its letters be written as an escape — so
+	// every lookup below reads the unescaped name while the printed one
+	// keeps the source's. It costs an `indexOf` where nothing is escaped.
+	const meaning = path.name();
+	// Counted rather than listed: a declaration's value is one component 92
+	// times in 100, and the list would be built only to be indexed twice.
+	const count = path.childCount();
+	// `@property`'s `initial-value` is read against the sibling `syntax`
+	// descriptor, so it is as opaque as a custom property's own value.
+	const custom =
+		meaning.startsWith("--") ||
+		(_S._inPropertyRule &&
+			asciiCaseInsensitiveMatch(meaning, "initial-value")) ||
+		// `@function`'s `result` is the token stream the call substitutes, so
+		// it is opaque the same way — and empty when the function returns the
+		// guaranteed-invalid value.
+		(_S._inFunctionRule && asciiCaseInsensitiveMatch(meaning, "result")) ||
+		// A `{}` block standing as the whole value is a token stream the
+		// engine holds as written too — no grammar reads it, so a rewrite of
+		// it builds a different CSSOM from the same document.
+		(count === 1 &&
+			path.type(path.child(0)) === NodeType.SimpleBlock &&
+			_blockTokenOf(path.child(0)) === "{");
+	// A value-less declaration is invalid, so it is already ignored — except
+	// on a custom property, where the empty value is the guaranteed-invalid
+	// one a `var()` fallback reads.
+	if (minify && _S._transforms.removeDeadRules && count === 0 && !custom) {
+		return "";
+	}
+	// The name folded to lowercase, where the value below needed it; `name`
+	// itself where it did not, which is what the printed name reads as
+	// "nothing to fold".
+	let lowered = name;
+	let value = "";
+	if (count !== 0) {
+		// Property names match ASCII case-insensitively and a custom property's
+		// does not, so skipping it skips the lowercasing. One fold serves both
+		// which value rules apply and how the name prints.
+		lowered = custom ? meaning : toLowerCaseIfNeeded(meaning);
+		const property = custom ? meaning : _standardSpelling(lowered);
+		if (custom) {
+			// `getPropertyValue()` hands this text back, so a rewritten token
+			// would be a different CSSOM; only the boundaries between them go.
+			const from = path.start(path.child(0));
+			const to = path.end(path.child(count - 1));
+			if (minify) {
+				value = _customPropertyValue(path, path.node, writer, from, to);
+			} else {
+				// Straight from source, so the kept comments in it are already
+				// there — claim them, or the writer emits them a second time
+				// ahead of the next top-level node.
+				writer.takeInserts(from, to);
+				value = _S._input.slice(from, to);
+				if (to === _S._input.length) value = _closeAtEof(value);
+			}
+			// Closed as printed, since a `}` may still follow; the grammar leaves it
+			// open where nothing does, as the engine keeps it.
+			const last = _S._eofPrinted;
+			if (
+				to === _S._input.length &&
+				last !== "" &&
+				value.endsWith(last) &&
+				last !== _S._eofOpen
+			) {
+				_S._openCustomValue = {
+					printed: value,
+					source: value.slice(0, value.length - last.length) + _S._eofOpen
+				};
+			}
+		} else if (property === "unicode-range") {
+			// `U+…` tokenizes as numbers, so the generic numeric normalization
+			// would corrupt it; each range is shortened as the urange it is.
+			let raw = "";
+			for (let at = 0; at < count; at++) {
+				raw += _printedSource(path.child(at));
+			}
+			value = minify
+				? raw
+						.split(",")
+						.map((one) => _minifyUnicodeRange(one.trim()))
+						.join(",")
+				: raw;
+		} else {
+			// Value hashes were already shortened by the hash printer, printing in a
+			// value context, so this joins the children's text. A shorthand whose
+			// value repeats what the notation implies collapses.
+			const shorthand = minify
+				? _collapseShorthand(path, property, path.node, writer)
+				: null;
+			if (shorthand === null && count === 1) {
+				// What a value is 98 times in 100, and `_join` hands a lone fragment
+				// back, so it is rewritten without an array. §5.4.6 step 7 pops a
+				// trailing whitespace, so that child is never the `""` case.
+				value = _valueFragment(writer.get(path.child(0)), property, minify);
+			} else {
+				/** @type {string[]} */
+				let fragments;
+				if (shorthand === null) {
+					fragments = [];
+					_appendChildTexts(path.node, writer, fragments);
+				} else {
+					fragments = shorthand;
+				}
+				// In place: a `map` per transform would allocate an array each.
+				for (let i = 0; i < fragments.length; i++) {
+					fragments[i] = _valueFragment(fragments[i], property, minify);
+				}
+				// The string transforms below read space-separated components, so
+				// only a value none of them covers loses the separators its tokens
+				// do not need — a substitution's tokens included.
+				const separatorsOnly =
+					minify &&
+					!AUTO_SECOND_VALUE_PROPERTIES.has(property) &&
+					!ALPHA_VALUE_PROPERTIES.has(property) &&
+					!RATIO_PROPERTIES.has(property);
+				value = _join(
+					fragments,
+					!minify,
+					separatorsOnly ? _TRIM_SEPARATORS : _TRIM_NOTHING
+				);
+			}
+			if (minify) {
+				value = _dropDefaultSecondValue(property, value);
+				value = _numberAlphaValue(property, value);
+				value = _dropRatioDenominator(property, value);
+			}
+		}
+	}
+	const important = _isImportant(path.node) ? `${soft}!important` : "";
+	// Property names match ASCII case-insensitively; a custom property's
+	// does not, which is what `custom` already stands for — nor does an
+	// `@font-feature-values` sub-rule's, which names a feature value.
+	const folds =
+		minify && _S._transforms.foldCase && !custom && !_S._inFeatureValuesRule;
+	let printedName = folds && lowered !== name ? asciiLowercaseName(name) : name;
+	// An escape spells the same name, so the name is written the shortest way.
+	if (minify && _S._transforms.rewriteEscapes && meaning !== name) {
+		const spelled = escapeName(folds ? asciiLowercaseName(meaning) : meaning);
+		if (spelled.length <= printedName.length) printedName = spelled;
+	}
+	return `${printedName}:${soft}${value}${important};`;
+};
+
+/**
+ * The `printer` case for an at-rule or a qualified rule.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {PrintContext} writer the print context (children's printed text)
+ * @param {boolean} minify whether minifying
+ * @param {string} soft `""` minifying, `" "` beautifying
+ * @returns {string} the node's serialized text
+ */
+const _printRuleNode = (path, writer, minify, soft) => {
+	// Prefixing reads the prelude's tokens, not its joined text.
+	const preludeParts = _S._prefixingOn
+		? /** @type {string[]} */ ([])
+		: undefined;
+	const prelude = _rulePrelude(path, writer, minify, preludeParts);
+	const decls = _declarationsOf(path.node);
+	// A qualified rule always has a block; an at-rule has one only when its
+	// declaration list is non-null — else it is `@…;`.
+	if (decls === null) {
+		if (minify) _blockSpans.push(_NO_BLOCK_ENTRY);
+		// `@charset` names the encoding the *source* was read in, and what is
+		// written out is UTF-8 whatever it said — so carrying it over is at
+		// best 22 dead bytes and at worst an encoding the output is not in.
+		if (
+			minify &&
+			_S._transforms.removeDeadRules &&
+			asciiCaseInsensitiveMatch(_rawName(path.node), "charset")
+		) {
+			return "";
+		}
+		// The rule only goes where no target reads one: a condition this has
+		// not come to yet still needs it, and so does an engine that reads it.
+		if (
+			minify &&
+			_S._transforms.customMedia &&
+			_atKeywordOf(path.node) === "custom-media" &&
+			_takeCustomMedia(prelude) &&
+			!_S._customMediaAllowed
+		) {
+			return "";
+		}
+		// No engine reads `@custom-selector`, so the rule always goes once its
+		// name is down — but only where `:is()` can carry what it stands for.
+		if (
+			minify &&
+			_S._transforms.customSelectors &&
+			_S._isSelectorAllowed &&
+			_atKeywordOf(path.node) === "custom-selector" &&
+			_takeCustomSelector(prelude)
+		) {
+			return "";
+		}
+		return `${prelude};`;
+	}
+	// Read before the body: composing it is what leaves the block empty, and
+	// the drop below asks the same question again.
+	const unusedRule = _takeUnusedRule(_S._currentNode);
+	const rules = _rulesOf(path.node);
+	// `nl` prefixes each item: nothing minifying, a line break beautifying
+	// (declarations end in `;`, rules don't).
+	const nl = minify ? "" : "\n";
+	const memoized = _memoizedBlockBody(_S._currentNode);
+	const {
+		body,
+		items,
+		texts,
+		superseded,
+		droppedPrefix,
+		addedPrefix,
+		deadPrefixed,
+		spans
+	} =
+		memoized === undefined
+			? _composeBlockBody(
+					path,
+					decls,
+					rules,
+					writer,
+					minify,
+					nl,
+					_S._currentNode,
+					unusedRule
+				)
+			: // A rule its selector made unused writes nothing, whatever its block.
+				_memoizedComposition(unusedRule ? "" : memoized);
+	_memoizeBlockBody(
+		_S._currentNode,
+		memoized === undefined && !unusedRule ? body : null
+	);
+	if (
+		minify &&
+		// An empty rule paints nothing, so dropping it leaves the cascade as it
+		// was — but only where the block means nothing (`_streamClose` agrees).
+		_S._transforms.removeDeadRules &&
+		body.length === 0 &&
+		// See `_streamClose`: a rule taken out while a `@namespace` after it
+		// could still be read would move one up into a live position.
+		!(path.parent === null && _S._namespacePrologueOpen) &&
+		(path.type() === NodeType.QualifiedRule ||
+			DROPPABLE_WHEN_EMPTY_AT_RULES.has(_atKeywordOf(path.node)) ||
+			unusedRule)
+	) {
+		// The rules written in it are not empty for its being so, and what the
+		// hoist writes for them is rules a later copy can take back.
+		_blockSpans.push(
+			path.type() === NodeType.QualifiedRule
+				? _NO_BLOCK_ENTRY_QUALIFIED
+				: _NO_BLOCK_ENTRY
+		);
+		{
+			const written =
+				_writeNested(path, _S._currentNode, prelude, null, true) || "";
+			if (minify && written.length !== 0) {
+				_recordHoistedRule(written, null, 0);
+			}
+			return written;
+		}
+	}
+	// A rule that says which color scheme it is in says it again as the pair
+	// a lowered `light-dark()` reads, and — where it hands the choice to the
+	// user's own preference — once more under the query that asks for it.
+	let scheme = body;
+	let schemeCopy = "";
+	if (
+		_S._loweringLightDark &&
+		_S._sourceNamesLightDark &&
+		path.type() === NodeType.QualifiedRule &&
+		body.includes("color-scheme:") &&
+		// The pair as this writes it, not either name on its own: a
+		// block carrying that is one a lowering pass wrote. An authored
+		// `--webpack-light` is a declaration of the author's.
+		!body.includes(LIGHT_DARK_WRITTEN) &&
+		!body.includes(LIGHT_DARK_WRITTEN_DARK)
+	) {
+		const written = _COLOR_SCHEME_RE.exec(body);
+		const toggle =
+			written === null
+				? null
+				: _lightDarkToggle(written[1].replace(_IMPORTANT, "").trim());
+		if (toggle !== null) {
+			// The body's own closing `;` went with the minified print, and the
+			// toggle's last is the one this block now ends on.
+			scheme = `${body};${toggle.toggle.slice(0, -1)}`;
+			if (toggle.flip) {
+				schemeCopy = `${_PREFERS_DARK}${soft}{${_OWN_PRELUDE}${soft}{${LIGHT_PROPERTY}:;${DARK_PROPERTY}:initial}}`;
+			}
+		}
+	}
+	// The hoist's copy names the prelude as the run settles it, since one
+	// taken out is resolved against its parent and may be joined into a list.
+	const ownRest = `${soft}{${scheme}${nl}}${schemeCopy}`;
+	const rest =
+		schemeCopy === "" ? ownRest : ownRest.replace(_OWN_PRELUDE, () => prelude);
+	const text = `${prelude}${rest}`;
+	// Prefix copies turn one rule into several, so a rewritten rule is not
+	// offered for joining: its text no longer describes a single block. Each
+	// block's rules are their own siblings, pairing within their scope.
+	let out = text;
+	if (_S._prefixingOn) {
+		// Read and clear here, so the lookahead is the one rule the writer
+		// holds — which only a top-level rule ever is — and never a rule
+		// further back.
+		const parent = path.parent;
+		const top = parent === null;
+		const scope = _prefixScope(parent);
+		out =
+			path.type() === NodeType.AtRule
+				? _prefixAtRule(path, text, prelude, scope, top)
+				: _prefixQualifiedRule(
+						text,
+						/** @type {string[]} */ (preludeParts),
+						soft,
+						body,
+						scope,
+						top
+					);
+	}
+	// WHY: pushed whatever it holds, since the parent takes one off per child
+	// with a body, so a block carrying no rule still has to be there. A
+	// rewritten rule records no nesting — those spans name `text` rather than
+	// `out` — but is still the one rule its text says it is. Only a block that
+	// recorded something needs an entry of its own, a leaf rule taking the
+	// shared one, and nothing is pushed while not minifying.
+	if (minify) {
+		_blockSpans.push(
+			spans === null || out !== text
+				? path.type() === NodeType.QualifiedRule
+					? _NO_BLOCK_ENTRY_QUALIFIED
+					: _NO_BLOCK_ENTRY
+				: {
+						bodyAt: prelude.length + soft.length + 1,
+						prelude,
+						keyPrelude: _openerKey(`${prelude}{`),
+						qualified: path.type() === NodeType.QualifiedRule,
+						spans
+					}
+		);
+	}
+	// A rewritten rule is several rules with preludes of their own, and each
+	// carries this rule's block — so the hoist takes them out. Only where
+	// it holds no rule of its own, those naming one prelude of the several.
+	const copies =
+		out === text ||
+		_prefixCopyPreludes.length === 0 ||
+		_holdsNested(_S._currentNode)
+			? undefined
+			: _prefixCopyPreludes;
+	const nested = _writeNested(
+		path,
+		_S._currentNode,
+		prelude,
+		ownRest,
+		out === text || copies !== undefined,
+		copies,
+		`${soft}{${body}}`
+	);
+	if (nested === null) return "";
+	if (out !== text) return out + nested;
+	// The run wrote this rule's selectors into itself, so what it returns is
+	// the whole of both — `text` being this rule's own `prelude` and `rest`.
+	if (nested.length !== 0) {
+		if (_nestedTookParent) {
+			if (minify) _recordHoistedRule(nested, null, 0);
+			return nested;
+		}
+		if (minify) _recordHoistedRule(nested, text, prelude.length);
+		return text + nested;
+	}
+	// Where the block is what a sibling is compared against, remember the rule
+	// so the parent parts it without re-scanning for the `{`. An at-rule
+	// remembers its block's entries too, so a sibling's rules can join them.
+	if (
+		minify &&
+		path.type() === NodeType.AtRule &&
+		MERGEABLE_AT_RULES.has(_atKeywordOf(path.node))
+	) {
+		/** @type {RuleEntry[]} */
+		const children = [];
+		for (let i = 0; i < texts.length; i++) {
+			if (texts[i].length === 0) continue;
+			if (superseded !== null && superseded.has(i)) continue;
+			// The entries have to spell the block this rule printed, prefixes and
+			// all: a join rebuilds the body from them, and one built from the
+			// unprefixed texts would restore what was dropped.
+			if (droppedPrefix !== null && droppedPrefix.has(i)) continue;
+			if (deadPrefixed !== null && deadPrefixed.has(items[i])) continue;
+			const added = addedPrefix === null ? undefined : addedPrefix.get(i);
+			children.push(
+				added === undefined
+					? _ruleEntryOf(items[i], texts[i])
+					: _opaqueEntry(added + texts[i])
+			);
+		}
+		let head = "";
+		for (let i = 0; i < children.length - 1; i++) head += children[i].text;
+		_setRuleEntry(_S._currentNode, {
+			text,
+			prelude: prelude.length,
+			atRule: true,
+			plain: false,
+			listable: LIST_NO,
+			listKind: LIST_KIND_SELECTOR,
+			children,
+			head,
+			// The block's own merges have run and settled what they grew, so the
+			// text above and the children agree; a list one of them still carries
+			// concatenated is one this block says is there to settle.
+			unordered: _anyUnordered(children),
+			list: null,
+			block: null,
+			declarations: null
+		});
+	}
+	if (minify && path.type() === NodeType.QualifiedRule) {
+		// Only a block of declarations lends its selectors to another's list: a
+		// nested rule's `&` stands for the whole list and `:is(…)` takes its most
+		// specific selector, so joining preludes moves what the nested beat.
+		const plain = rules === null || rules.length === 0;
+		const parent = path.parent;
+		// Which shape a join would read the prelude with — the parent is gone by
+		// then. A keyframe selector is a list of its own shape, which
+		// `_rulePrelude` has already rewritten `from` in.
+		let listKind = LIST_KIND_SELECTOR;
+		if (parent !== null) {
+			const parentType = path.type(parent);
+			if (parentType === NodeType.QualifiedRule) {
+				listKind = LIST_KIND_NESTED;
+			} else if (
+				parentType === NodeType.AtRule &&
+				KEYFRAMES_AT_RULE_RE.test(_atKeywordOf(parent))
+			) {
+				listKind = LIST_KIND_KEYFRAME;
+			}
+		}
+		_setRuleEntry(_S._currentNode, {
+			text,
+			prelude: prelude.length,
+			atRule: false,
+			plain,
+			listable: plain ? LIST_UNKNOWN : LIST_NO,
+			listKind,
+			children: null,
+			head: "",
+			unordered: false,
+			list: null,
+			block: null,
+			declarations: null
+		});
+	}
+	return text;
+};
+
+/**
+ * The `printer` case for a hash.
+ * @param {CssPath} path the accessor positioned on the finished node
+ * @param {boolean} minify whether minifying
+ * @returns {string} the node's serialized text
+ */
+const _printHashNode = (path, minify) => {
+	const raw = _printedSource(path.node);
+	if (!minify) return raw;
+	// A hash is a hex color in a value and an id in a selector, and ids are
+	// case-sensitive, so only the former shortens — at any value depth. An id's
+	// escapes still shorten, the `#` held back so its first code point is one.
+	if (!path.within(NodeType.Declaration)) {
+		return _S._transforms.rewriteEscapes
+			? `#${_minifyIdentEscapes(raw.slice(1))}`
+			: raw;
+	}
+	// Inside a function only the known color functions take color hashes, and a
+	// substitution's fallback, being the property's value. `paint()` is the
+	// exception: its arguments reach a worklet rather than a declaration.
+	const parent = path.parent;
+	if (parent !== null && path.type(parent) === NodeType.Function) {
+		const fn = unescapeIdentifier(_rawName(parent)).toLowerCase();
+		if (
+			!COLOR_ARGUMENT_FUNCTIONS.has(fn) &&
+			!(SUBSTITUTION_FUNCTIONS.has(fn) && fn !== "paint")
+		) {
+			return raw;
+		}
+	}
+	const short = _minifyHash(raw);
+	const text = short === null ? raw : short;
+	// A hex alpha the target cannot read is written as the `rgba()` it names.
+	if (_S._hexAlphaAllowed) return text;
+	const lowered = _S._transforms.lowerUnsupported
+		? _hexAlphaFallback(text)
+		: null;
+	return lowered === null ? text : lowered;
+};
+
 /**
  * The default CSS node printer — passed to the `SourceProcessor` and fired once a
  * node's visitors and children are done (a developer could supply their own).
@@ -4895,984 +6004,21 @@ const printer = (path, writer) => {
 				? _normalizeNumericToken(raw, _isRgbChannel(path))
 				: raw;
 		}
-		case NodeType.Function: {
-			const written = _rawName(path.node);
-			// An escape spells the same name (§4.3.7): `c\61 lc(` is `calc()`, so
-			// every table below reads what it spells.
-			const name = written.includes("\\")
-				? unescapeIdentifier(written)
-				: written;
-			// A container style query asks whether a custom property's value is the one
-			// written here, comparing token streams as written (CSS Conditional 5 §5),
-			// so a squeezed whitespace run asks another question. Nothing is rewritten.
-			if (
-				minify &&
-				!path.within(NodeType.Declaration) &&
-				_S._inMediaConditionPrelude &&
-				asciiCaseInsensitiveMatch(name, "style")
-			) {
-				const source = _printedSource(path.node);
-				// Unclosed at EOF, the source carries no `)` for the walk to have
-				// closed — printed as usual so the parenthesis is written back.
-				if (source.endsWith(")")) {
-					// Written whole, comments included, so the queued copies are claimed
-					// here rather than flushed a second time after the rule.
-					writer.takeInserts(path.start(), path.end());
-					return source;
-				}
-			}
-			let inner;
-			if (path.childCount() === 1) {
-				// Half of all functions take one argument, which `_join` would hand
-				// straight back — and a trim only ever parts two of them, so no
-				// universal a compound implies can stand beside anything here either.
-				const only = writer.get(path.child(0));
-				inner = only === _SEP ? "" : only;
-			} else {
-				// A selector function's argument is a selector, so its combinators need
-				// no whitespace, as in the enclosing prelude; an `@import`'s
-				// `supports()` and a container's `scroll-state()` hold conditions.
-				const lower = name.toLowerCase();
-				const trim =
-					_S._mathFunctionDepth !== 0
-						? _TRIM_MATH
-						: path.within(NodeType.Declaration)
-							? _TRIM_NOTHING
-							: SELECTOR_FUNCTIONS.has(lower)
-								? _TRIM_COMBINATORS
-								: (_S._inSupportsPrelude && lower === "supports") ||
-									  (_S._inMediaConditionPrelude && lower === "scroll-state")
-									? _TRIM_CONDITIONS
-									: _TRIM_NOTHING;
-				/** @type {string[]} */
-				const parts = [];
-				_appendChildTexts(path.node, writer, parts);
-				if (minify && trim === _TRIM_CONDITIONS) _keepKeywordComments(parts);
-				// A selector function's argument is a selector like the prelude's, so
-				// the universal a compound implies says nothing there either — except
-				// under test in a `@supports` condition, where only whitespace goes.
-				if (minify && trim === _TRIM_COMBINATORS && !_S._inSupportsPrelude) {
-					_foldPseudoNames(parts);
-					if (_S._transforms.shortenSelectors) _unwrapLoneIs(parts);
-					_dropImpliedUniversalSelector(parts);
-				}
-				inner = _join(parts, !minify, minify ? trim : _TRIM_NOTHING);
-				// A leading `+` in An+B is a sign, not a combinator: `+ n` is no
-				// argument an engine reads, and `+n` would be one.
-				if (minify && NTH_PSEUDO_FUNCTIONS.has(lower)) {
-					const at = parts.findIndex(
-						(part) => part.length !== 0 && part !== _SEP
-					);
-					if (parts[at] === "+" && parts[at + 1] === _SEP) {
-						inner = `+ ${inner.slice(1)}`;
-					}
-				}
-				// Chrome throws out `attr( name unit )` where `attr( name unit)`
-				// parses, so the space before the `)` decides whether the declaration
-				// runs — `_join` drops a trailing one like any other.
-				if (
-					minify &&
-					parts[parts.length - 1] === _SEP &&
-					asciiCaseInsensitiveMatch(name, "attr")
-				) {
-					inner += " ";
-				}
-			}
-			if (!minify) return `${written}(${inner})`;
-			// Function names match ASCII case-insensitively, so one lowercase name
-			// is what every table below is keyed by; the eleven transforms spelled
-			// with a capital are printed the way everything else writes them.
-			const fn = asciiLowercaseName(name);
-			// As with a unit: a name already lowercase is its own answer, and only a
-			// shouted one is looked up. The lookup key still folds inside a
-			// substituted value; only the printed spelling stays as written.
-			let out =
-				_S._inSubstitutedValue ||
-				_S._inSupportsSelector ||
-				!_S._transforms.foldCase ||
-				fn.startsWith("--")
-					? name
-					: fn === name
-						? fn
-						: CANONICAL_NAMES.get(fn) || fn;
-			if (written !== name) {
-				out = _S._transforms.rewriteEscapes ? escapeName(out) : written;
-			}
-			// An+B in a selector: `2n+1` is what `odd` names, and shorter written so.
-			if (!path.within(NodeType.Declaration) && NTH_PSEUDO_FUNCTIONS.has(fn)) {
-				return _S._inSupportsSelector
-					? `${out}(${inner})`
-					: _minifyAnPlusB(out, inner);
-			}
-			// Every rewrite below is keyed by a name none of these carry.
-			if (
-				SUBSTITUTION_FUNCTIONS.has(fn) ||
-				(!path.within(NodeType.Declaration) && SELECTOR_FUNCTIONS.has(fn))
-			) {
-				return `${out}(${inner})`;
-			}
-			// WHY: an `rgb()` or `rgba()` collapses to the shortest color and anything
-			// else keeps its `name(args)` form. A color inside a `@supports` condition
-			// is syntax under test — the engines reading `#0000` are not those reading
-			// `rgba(0,0,0,0)` — so rewriting it asks another question, and esbuild,
-			// clean-css and lightningcss leave the condition alone too. A color read as
-			// numbers, in a gradient stop, a `color-mix()` argument or a relative
-			// color's origin, stays as written unless converting it is exact, which the
-			// legacy sRGB forms are where their channels are bytes.
-			let color = _S._inSupportsPrelude
-				? null
-				: _minifyColorFunction(
-						fn,
-						inner,
-						_S._hexAlphaAllowed,
-						_S._inColorOperand
-					) ||
-					(_S._inColorOperand
-						? null
-						: _minifyPolarColorFunction(fn, inner, _S._hexAlphaAllowed));
-			// A mix no byte holds is written back in the space it was computed in,
-			// which can be longer than the call — then the call is the shorter one.
-			if (color !== null && color.length > fn.length + inner.length + 2) {
-				color = null;
-			}
-			if (
-				color !== null &&
-				(color !== "transparent" || !_inTapHighlightColor())
-			) {
-				return color === "transparent" && _S._hexAlphaAllowed ? "#0000" : color;
-			}
-			// `light-dark()` names a color per scheme, which the pair above says with
-			// a substitution the scheme itself switches. Two arguments only: the
-			// grammar takes exactly that many, and anything else is no such call.
-			if (
-				_S._loweringLightDark &&
-				fn === "light-dark" &&
-				path.within(NodeType.Declaration) &&
-				!_S._inCustomProperty &&
-				!_S._inSupportsPrelude &&
-				!_S._inSubstitutedValue
-			) {
-				const halves = _splitTopLevelArguments(inner);
-				// A half the target cannot read would substitute into a `var()` and make
-				// the declaration invalid at computed-value time, where nothing before it
-				// is read — so it is left alone rather than lowered.
-				if (halves.length === 2 && !_namesUnreadableColor(inner)) {
-					_S._lightDarkUsed = true;
-					return `var(${LIGHT_PROPERTY},${halves[0].trim()})var(${DARK_PROPERTY},${halves[1].trim()})`;
-				}
-			}
-			// A math function over constants of one unit is that value, written back as
-			// a `calc()`: the parentheses stay, since dropping them turns a clamped
-			// negative into a parse error, and only the declaration printer does.
-			if (!_S._inSupportsPrelude && !_S._inCustomProperty) {
-				const term = _foldMathFunction(fn, inner);
-				if (term !== null) {
-					// A term that means the same bare needs no parentheses anywhere, so
-					// it is written as itself; the rest keep a `calc()` for the
-					// declaration printer to judge against the property.
-					const shape =
-						_S._mathFunctionDepth > 1 || _inNumberArgument(path)
-							? _NESTED_TERM_RE
-							: _BARE_TERM_RE;
-					const folded =
-						(shape.test(term) ||
-							(_S._mathFunctionDepth === 1 &&
-								_NEGATIVE_TERM_RE.test(term) &&
-								_inNegativeAcceptingArgument(path))) &&
-						!_inCalcRejectingProperty() &&
-						!(!/[a-z%]$/i.test(term) && _inNumberOnlyOutsideCalcProperty()) &&
-						!_foldLosesClamp(term) &&
-						!_foldBelowStepCount(term, path)
-							? term
-							: `calc(${term})`;
-					// A division can land on a value needing every digit of a double, which
-					// is longer than the expression producing it. Only the outermost call
-					// is asked, a nested one being a term still to be reduced.
-					if (
-						_S._mathFunctionDepth > 1 ||
-						folded.length < fn.length + inner.length + 2 ||
-						_unwrapsShorter(path, folded, fn.length + inner.length + 2)
-					) {
-						return folded;
-					}
-				}
-				const reduced = _reduceMathArguments(fn, inner);
-				// A `calc()` inside another math function is the parentheses it
-				// stands for (CSS Values 4 §10.1), whatever a substitution expands to.
-				if (
-					fn === "calc" &&
-					_S._mathFunctionDepth > 1 &&
-					path.within(NodeType.Declaration) &&
-					_S._transforms.reduceFunctions
-				) {
-					return `(${reduced === null ? inner : reduced})`;
-				}
-				if (reduced !== null) return `${fn}(${reduced})`;
-			}
-			// An easing function is only ever a value; `url()` is also an at-rule
-			// prelude's (`@import url("a.css")`).
-			const easing =
-				path.within(NodeType.Declaration) && !_S._inCustomProperty
-					? _minifyEasingFunction(fn, inner)
-					: null;
-			if (easing !== null) return easing;
-			// A translation's percentage is of the element's own box, which always
-			// has a size, so a `0%` term beside one length adds nothing to it.
-			if (
-				_S._transforms.reduceFunctions &&
-				path.within(NodeType.Declaration) &&
-				!_S._inSubstitutedValue &&
-				fn.startsWith("translate") &&
-				inner.includes("0%")
-			) {
-				const args = _splitTopLevelArguments(inner);
-				let changed = false;
-				for (let i = 0; i < args.length; i++) {
-					// A z slot takes no percentage, so a `0%` there makes the whole
-					// declaration invalid, which dropping it would revive.
-					if (fn === "translatez" || (fn === "translate3d" && i === 2)) {
-						continue;
-					}
-					const term = _dropZeroPercentTerm(args[i].trim());
-					if (term !== null) {
-						args[i] = term;
-						changed = true;
-					}
-				}
-				// The rewrites below read the arguments as they now stand.
-				if (changed) inner = args.join(",");
-			}
-			// `translateX(v)` is `translate(v)` and `skewX(a)` is `skew(a)`, the second
-			// component defaulting to 0. Only for one plain component: a substitution
-			// could expand to two, reviving a declaration the browser drops.
-			const oneAxis = _S._transforms.reduceFunctions
-				? X_AXIS_TRANSFORMS.get(fn)
-				: undefined;
-			if (
-				oneAxis !== undefined &&
-				path.within(NodeType.Declaration) &&
-				!_S._inSubstitutedValue &&
-				!inner.includes(",") &&
-				!containsSubstitutionFunction(inner)
-			) {
-				return `${oneAxis}(${inner})`;
-			}
-			if (path.within(NodeType.Declaration) && !_S._inSubstitutedValue) {
-				// An argument that is the amount an omitted one means says nothing,
-				// whether or not the zero still carries the unit its grammar drops.
-				const omitted = _S._transforms.reduceFunctions
-					? FILTER_FUNCTION_OMITTED.get(fn)
-					: undefined;
-				if (omitted !== undefined) {
-					const bare = _dropCallZeroUnit(fn, inner);
-					if (bare === omitted || (omitted === "1" && bare === "100%")) {
-						return `${out}()`;
-					}
-				}
-				const reduced = _reduceTransformFunctionDeep(fn, inner);
-				if (reduced !== null) return reduced;
-				// The stops are folded over what dropping the direction leaves, a
-				// gradient carrying both otherwise keeping whichever ran second.
-				const shape = _dropDefaultShapeParts(fn, inner);
-				if (shape !== null) return `${out}(${shape})`;
-				let gradient = _reduceGradientDirection(fn, inner);
-				if (gradient === null) {
-					gradient = _dropDefaultGradientPosition(fn, inner);
-				}
-				let stops = _foldGradientStops(
-					fn,
-					gradient === null ? inner : gradient,
-					_S._doublePositionAllowed
-				);
-				// A double position the target cannot read is written as the two
-				// stops it names, over whatever the folds above left.
-				if (!_S._doublePositionAllowed) {
-					const split = !_S._transforms.lowerUnsupported
-						? null
-						: _splitDoublePositionStops(
-								fn,
-								stops !== null ? stops : gradient !== null ? gradient : inner
-							);
-					if (split !== null) stops = split;
-				}
-				if (stops !== null) return `${out}(${stops})`;
-				if (gradient !== null) return `${out}(${gradient})`;
-			}
-			// A zero angle needs no unit where the grammar names `<zero>` beside
-			// `<angle>` (CSS Transforms 2, Filter Effects 1).
-			if (
-				path.within(NodeType.Declaration) &&
-				!_S._inSubstitutedValue &&
-				_S._transforms.shortenNumbers &&
-				ZERO_ANGLE_FUNCTIONS.has(fn)
-			) {
-				const bare = inner.replace(_ZERO_ANGLE_ARGUMENT_RE, "$10");
-				if (bare !== inner) return `${out}(${bare})`;
-			}
-			// A name kept escaped keeps its call as written: unquoting it rests on the
-			// tokenizer reading `url` through the escape.
-			const url =
-				_S._inSubstitutedValue || (written !== name && out === written)
-					? null
-					: _minifyUrlFunction(fn, inner);
-			if (url !== null) return url;
-			return `${out}(${inner})`;
-		}
-		case NodeType.Url: {
-			const source = _printedSource(path.node);
-			// Closed at EOF: write the `)` back so the url stops where it stopped for
-			// the tokenizer rather than swallowing what the printer emits next. Before
-			// the rest rather than instead of it, or a second pass is what folds it.
-			const unterminated = _isUnterminatedUrl(source);
-			const raw = unterminated ? _terminate(source, ")", "\uFFFD") : source;
-			// The tokenizer already trimmed the url-token's content, so the padding in
-			// `url(  a.png  )` carries nothing.
-			if (!minify) return raw;
-			const open = raw.indexOf("(");
-			// `url` matches ASCII case-insensitively like any function name. Read in
-			// place, since cutting the name out would allocate on every url and all but
-			// a shouted one folds to itself. In a substituted value nothing is read.
-			let head = null;
-			if (!_S._inSubstitutedValue && _S._transforms.foldCase) {
-				for (let i = 0; i < open; i++) {
-					const c = raw.charCodeAt(i);
-					if (c >= CC_UPPER_A && c <= CC_UPPER_Z) {
-						head = asciiLowercaseName(raw.slice(0, open + 1));
-						break;
-					}
-				}
-			}
-			const percent = raw.includes("%");
-			/**
-			 * @returns {string} the url-token as it prints with nothing rendered
-			 */
-			const plainUrl = () => {
-				// Padding only exists when the content is whitespace-bounded; checking
-				// that costs two char reads, reading the content costs a slice.
-				if (
-					!percent &&
-					!isAsciiWhitespace(raw.charCodeAt(open + 1)) &&
-					!isAsciiWhitespace(raw.charCodeAt(raw.length - 2))
-				) {
-					return head === null ? raw : head + raw.slice(open + 1);
-				}
-				const name = head === null ? raw.slice(0, open + 1) : head;
-				const value = _urlValue(path, unterminated);
-				// A url-token already carrying an escape is one this printer did not
-				// write, so its `\%` is not read as the start of a percent-escape.
-				return `${name}${
-					percent && !value.includes("\\")
-						? _decodePercentEscapes(value, true, "")
-						: value
-				})`;
-			};
-			// Ahead of the padding fast path below: a base64 `data:` url is
-			// whitespace-free and `%`-free, so it would take it and never be offered.
-			if (_S._deferEmbeddedSource !== undefined) {
-				const opener = head === null ? raw.slice(0, open + 1) : head;
-				const deferred = _deferDataUrl(
-					_urlValue(path, unterminated),
-					(url) => `${opener}${_serializeUrl(url, '"')})`,
-					plainUrl()
-				);
-				if (deferred !== null) return deferred;
-			}
-			if (_S._renderEmbeddedSource !== undefined) {
-				const renderedUrl = _renderDataUrl(_urlValue(path, unterminated));
-				if (renderedUrl !== null) {
-					const name = head === null ? raw.slice(0, open + 1) : head;
-					return `${name}${_serializeUrl(renderedUrl, '"')})`;
-				}
-			}
-			return plainUrl();
-		}
-		case NodeType.String: {
-			const source = _printedSource(path.node);
-			// Closed at EOF: write the quote back, for the same reason as `url()`.
-			// Written here rather than after the transforms below, or they read a
-			// string with no closing quote and decline it, which a second pass undoes.
-			const raw = _isClosedString(source)
-				? source
-				: _terminate(source, source[0], "");
-			// A custom property hands its string back as written, quotes included.
-			if (!minify || _S._inCustomProperty) return raw;
-			// `<family-name>` is `<string> | <custom-ident>+`, so a family whose text
-			// is a run of identifiers means the same unquoted, two bytes shorter.
-			if (
-				!_S._inSupportsPrelude &&
-				!_S._inSubstitutedValue &&
-				((_inFontFamily() && _isLoneFamilyName(path)) ||
-					_isLoneFontFamily(path))
-			) {
-				const unquoted = _unquoteFontFamily(raw);
-				if (unquoted !== null) return unquoted;
-			}
-			const written = _minifyString(raw);
-			return (_S._charsetPiece === -1 && !_S._assumeUtf8) ||
-				!_S._transforms.rewriteEscapes
-				? written
-				: _unescapeAstral(written);
-		}
-		case NodeType.Ident: {
-			const raw = _printedSource(path.node);
-			if (!minify) return raw;
-			// A keyword is matched by what an escape spells, not by how it is written.
-			const meaning = raw.includes("\\") ? unescapeIdentifier(raw) : raw;
-			// `transparent` is `#0000` where the target reads a hex alpha — the same
-			// color, six bytes shorter. The tap-highlight guard still holds: that
-			// WebKit bug is about the keyword's *value*, whichever way it is spelled.
-			if (
-				path.within(NodeType.Declaration) &&
-				!_S._inSubstitutedValue &&
-				_S._hexAlphaAllowed &&
-				_S._transforms.shortenColors &&
-				asciiCaseInsensitiveMatch(meaning, "transparent") &&
-				!_inTapHighlightColor()
-			) {
-				return "#0000";
-			}
-			// The keyword names each platform's own UI font, which a target that
-			// does not read it reaches only through the platform's own name for it.
-			if (
-				!_S._systemUiAllowed &&
-				_S._transforms.lowerUnsupported &&
-				path.within(NodeType.Declaration) &&
-				!_S._inCustomProperty &&
-				!_S._inSubstitutedValue &&
-				asciiCaseInsensitiveMatch(meaning, "system-ui") &&
-				_inFontFamily()
-			) {
-				return SYSTEM_UI_STACK;
-			}
-			if (
-				path.within(NodeType.Declaration) &&
-				!_S._inCustomProperty &&
-				!_S._inSupportsPrelude &&
-				!_S._inSubstitutedValue
-			) {
-				// One fold for both questions below, handing back the string where nothing
-				// changes. ASCII only: `pin\212A` ends in a Kelvin sign, not a `k`.
-				const lowered = asciiLowercaseName(meaning);
-				// A named color where the property takes nothing else an identifier could
-				// be: `white` is `#fff`, both computing to `rgb(255, 255, 255)`.
-				// Elsewhere an identifier may be the author's own name.
-				if (_S._transforms.shortenColors) {
-					const shorter = getColorNameToShortest().get(lowered);
-					if (
-						shorter !== undefined &&
-						(_inColorOnlyProperty() ||
-							_inGradientArgument(path) ||
-							_atBackgroundTop(path))
-					) {
-						return shorter;
-					}
-				}
-				// A keyword-only or color property names nothing of the author's, so an
-				// ident directly in its value (a call's arguments are their own grammar's)
-				// is a keyword matched ASCII case-insensitively, but a dashed ident (§4.2).
-				if (
-					_S._transforms.foldCase &&
-					lowered !== raw &&
-					path.parent === _S._valueDeclaration &&
-					!meaning.startsWith("--") &&
-					_inKeywordOnlyValue()
-				) {
-					const folded =
-						meaning !== raw && _S._transforms.rewriteEscapes
-							? escapeIdentifier(lowered)
-							: asciiLowercaseName(raw);
-					if (folded !== raw) return folded;
-				}
-			}
-			return _S._transforms.rewriteEscapes ? _minifyIdentEscapes(raw) : raw;
-		}
-		case NodeType.SimpleBlock: {
-			const open = _blockTokenOf(path.node);
-			const close = open === "(" ? ")" : open === "[" ? "]" : "}";
-			// Outside a declaration value a `[…]` is an attribute selector and a `(…)`
-			// a query condition. Inside one they are a grid line-name list and a
-			// `calc()` sub-expression, where neither of those rewrites holds.
-			const structural = minify && !path.within(NodeType.Declaration);
-			/** @type {string[]} */
-			let parts;
-			if (structural && open === "[") {
-				parts = _printAttributeSelector(path, path.children(), writer);
-			} else {
-				// One array, rather than a child list and a mapped copy of it.
-				parts = [];
-				_appendChildTexts(path.node, writer, parts);
-			}
-			if (structural && open === "(" && _S._inMediaConditionPrelude) {
-				if (_S._transforms.foldCase) _lowercaseConditionParts(parts);
-				if (_S._rangeSpellingAllowed) _useRangeSpelling(parts);
-			}
-			if (
-				minify &&
-				structural &&
-				open === "(" &&
-				(_S._inSupportsPrelude || _S._inMediaConditionPrelude)
-			) {
-				_keepKeywordComments(parts);
-			}
-			let trim =
-				minify && _S._mathFunctionDepth !== 0 ? _TRIM_MATH : _TRIM_NOTHING;
-			if (structural && open === "(") {
-				// `@scope`'s parentheses hold selector lists, so a `:` there starts a
-				// pseudo-class and the whitespace before it is a descendant combinator
-				// — `@scope (div :hover)` is not `@scope (div:hover)`.
-				trim = _inScopePrelude(path) ? _TRIM_COMBINATORS : _TRIM_CONDITIONS;
-				if (trim === _TRIM_COMBINATORS) _foldPseudoNames(parts);
-			}
-			const inner = _join(parts, !minify, trim);
-			return `${open}${inner}${close}`;
-		}
-		case NodeType.Declaration: {
-			const name = _rawName(path.node);
-			// WHY: a property is matched by what its name means, not by how it was
-			// spelled — §4.3.7 lets any of its letters be written as an escape — so
-			// every lookup below reads the unescaped name while the printed one
-			// keeps the source's. It costs an `indexOf` where nothing is escaped.
-			const meaning = path.name();
-			// Counted rather than listed: a declaration's value is one component 92
-			// times in 100, and the list would be built only to be indexed twice.
-			const count = path.childCount();
-			// `@property`'s `initial-value` is read against the sibling `syntax`
-			// descriptor, so it is as opaque as a custom property's own value.
-			const custom =
-				meaning.startsWith("--") ||
-				(_S._inPropertyRule &&
-					asciiCaseInsensitiveMatch(meaning, "initial-value")) ||
-				// `@function`'s `result` is the token stream the call substitutes, so
-				// it is opaque the same way — and empty when the function returns the
-				// guaranteed-invalid value.
-				(_S._inFunctionRule && asciiCaseInsensitiveMatch(meaning, "result")) ||
-				// A `{}` block standing as the whole value is a token stream the
-				// engine holds as written too — no grammar reads it, so a rewrite of
-				// it builds a different CSSOM from the same document.
-				(count === 1 &&
-					path.type(path.child(0)) === NodeType.SimpleBlock &&
-					_blockTokenOf(path.child(0)) === "{");
-			// A value-less declaration is invalid, so it is already ignored — except
-			// on a custom property, where the empty value is the guaranteed-invalid
-			// one a `var()` fallback reads.
-			if (minify && _S._transforms.removeDeadRules && count === 0 && !custom) {
-				return "";
-			}
-			// The name folded to lowercase, where the value below needed it; `name`
-			// itself where it did not, which is what the printed name reads as
-			// "nothing to fold".
-			let lowered = name;
-			let value = "";
-			if (count !== 0) {
-				// Property names match ASCII case-insensitively and a custom property's
-				// does not, so skipping it skips the lowercasing. One fold serves both
-				// which value rules apply and how the name prints.
-				lowered = custom ? meaning : toLowerCaseIfNeeded(meaning);
-				const property = custom ? meaning : _standardSpelling(lowered);
-				if (custom) {
-					// `getPropertyValue()` hands this text back, so a rewritten token
-					// would be a different CSSOM; only the boundaries between them go.
-					const from = path.start(path.child(0));
-					const to = path.end(path.child(count - 1));
-					if (minify) {
-						value = _customPropertyValue(path, path.node, writer, from, to);
-					} else {
-						// Straight from source, so the kept comments in it are already
-						// there — claim them, or the writer emits them a second time
-						// ahead of the next top-level node.
-						writer.takeInserts(from, to);
-						value = _S._input.slice(from, to);
-						if (to === _S._input.length) value = _closeAtEof(value);
-					}
-					// Closed as printed, since a `}` may still follow; the grammar leaves it
-					// open where nothing does, as the engine keeps it.
-					const last = _S._eofPrinted;
-					if (
-						to === _S._input.length &&
-						last !== "" &&
-						value.endsWith(last) &&
-						last !== _S._eofOpen
-					) {
-						_S._openCustomValue = {
-							printed: value,
-							source: value.slice(0, value.length - last.length) + _S._eofOpen
-						};
-					}
-				} else if (property === "unicode-range") {
-					// `U+…` tokenizes as numbers, so the generic numeric normalization
-					// would corrupt it; each range is shortened as the urange it is.
-					let raw = "";
-					for (let at = 0; at < count; at++) {
-						raw += _printedSource(path.child(at));
-					}
-					value = minify
-						? raw
-								.split(",")
-								.map((one) => _minifyUnicodeRange(one.trim()))
-								.join(",")
-						: raw;
-				} else {
-					// Value hashes were already shortened by the hash printer, printing in a
-					// value context, so this joins the children's text. A shorthand whose
-					// value repeats what the notation implies collapses.
-					const shorthand = minify
-						? _collapseShorthand(path, property, path.node, writer)
-						: null;
-					if (shorthand === null && count === 1) {
-						// What a value is 98 times in 100, and `_join` hands a lone fragment
-						// back, so it is rewritten without an array. §5.4.6 step 7 pops a
-						// trailing whitespace, so that child is never the `""` case.
-						value = _valueFragment(writer.get(path.child(0)), property, minify);
-					} else {
-						/** @type {string[]} */
-						let fragments;
-						if (shorthand === null) {
-							fragments = [];
-							_appendChildTexts(path.node, writer, fragments);
-						} else {
-							fragments = shorthand;
-						}
-						// In place: a `map` per transform would allocate an array each.
-						for (let i = 0; i < fragments.length; i++) {
-							fragments[i] = _valueFragment(fragments[i], property, minify);
-						}
-						// The string transforms below read space-separated components, so
-						// only a value none of them covers loses the separators its tokens
-						// do not need — a substitution's tokens included.
-						const separatorsOnly =
-							minify &&
-							!AUTO_SECOND_VALUE_PROPERTIES.has(property) &&
-							!ALPHA_VALUE_PROPERTIES.has(property) &&
-							!RATIO_PROPERTIES.has(property);
-						value = _join(
-							fragments,
-							!minify,
-							separatorsOnly ? _TRIM_SEPARATORS : _TRIM_NOTHING
-						);
-					}
-					if (minify) {
-						value = _dropDefaultSecondValue(property, value);
-						value = _numberAlphaValue(property, value);
-						value = _dropRatioDenominator(property, value);
-					}
-				}
-			}
-			const important = _isImportant(path.node) ? `${soft}!important` : "";
-			// Property names match ASCII case-insensitively; a custom property's
-			// does not, which is what `custom` already stands for — nor does an
-			// `@font-feature-values` sub-rule's, which names a feature value.
-			const folds =
-				minify &&
-				_S._transforms.foldCase &&
-				!custom &&
-				!_S._inFeatureValuesRule;
-			let printedName =
-				folds && lowered !== name ? asciiLowercaseName(name) : name;
-			// An escape spells the same name, so the name is written the shortest way.
-			if (minify && _S._transforms.rewriteEscapes && meaning !== name) {
-				const spelled = escapeName(
-					folds ? asciiLowercaseName(meaning) : meaning
-				);
-				if (spelled.length <= printedName.length) printedName = spelled;
-			}
-			return `${printedName}:${soft}${value}${important};`;
-		}
+		case NodeType.Function:
+			return _printFunctionNode(path, writer, minify);
+		case NodeType.Url:
+			return _printUrlNode(path, minify);
+		case NodeType.String:
+			return _printStringNode(path, minify);
+		case NodeType.Ident:
+			return _printIdentNode(path, minify);
+		case NodeType.SimpleBlock:
+			return _printSimpleBlockNode(path, writer, minify);
+		case NodeType.Declaration:
+			return _printDeclarationNode(path, writer, minify, soft);
 		case NodeType.AtRule:
-		case NodeType.QualifiedRule: {
-			// Prefixing reads the prelude's tokens, not its joined text.
-			const preludeParts = _S._prefixingOn
-				? /** @type {string[]} */ ([])
-				: undefined;
-			const prelude = _rulePrelude(path, writer, minify, preludeParts);
-			const decls = _declarationsOf(path.node);
-			// A qualified rule always has a block; an at-rule has one only when its
-			// declaration list is non-null — else it is `@…;`.
-			if (decls === null) {
-				if (minify) _blockSpans.push(_NO_BLOCK_ENTRY);
-				// `@charset` names the encoding the *source* was read in, and what is
-				// written out is UTF-8 whatever it said — so carrying it over is at
-				// best 22 dead bytes and at worst an encoding the output is not in.
-				if (
-					minify &&
-					_S._transforms.removeDeadRules &&
-					asciiCaseInsensitiveMatch(_rawName(path.node), "charset")
-				) {
-					return "";
-				}
-				// The rule only goes where no target reads one: a condition this has
-				// not come to yet still needs it, and so does an engine that reads it.
-				if (
-					minify &&
-					_S._transforms.customMedia &&
-					_atKeywordOf(path.node) === "custom-media" &&
-					_takeCustomMedia(prelude) &&
-					!_S._customMediaAllowed
-				) {
-					return "";
-				}
-				// No engine reads `@custom-selector`, so the rule always goes once its
-				// name is down — but only where `:is()` can carry what it stands for.
-				if (
-					minify &&
-					_S._transforms.customSelectors &&
-					_S._isSelectorAllowed &&
-					_atKeywordOf(path.node) === "custom-selector" &&
-					_takeCustomSelector(prelude)
-				) {
-					return "";
-				}
-				return `${prelude};`;
-			}
-			// Read before the body: composing it is what leaves the block empty, and
-			// the drop below asks the same question again.
-			const unusedRule = _takeUnusedRule(/** @type {Node} */ (_S._currentNode));
-			const rules = _rulesOf(path.node);
-			// `nl` prefixes each item: nothing minifying, a line break beautifying
-			// (declarations end in `;`, rules don't).
-			const nl = minify ? "" : "\n";
-			const {
-				body,
-				items,
-				texts,
-				superseded,
-				droppedPrefix,
-				addedPrefix,
-				deadPrefixed,
-				spans
-			} = _composeBlockBody(
-				path,
-				decls,
-				rules,
-				writer,
-				minify,
-				nl,
-				_S._currentNode,
-				unusedRule
-			);
-			if (
-				minify &&
-				// An empty rule paints nothing, so dropping it leaves the cascade as it
-				// was — but only where the block means nothing (`_streamClose` agrees).
-				_S._transforms.removeDeadRules &&
-				body.length === 0 &&
-				// See `_streamClose`: a rule taken out while a `@namespace` after it
-				// could still be read would move one up into a live position.
-				!(path.parent === null && _S._namespacePrologueOpen) &&
-				(path.type() === NodeType.QualifiedRule ||
-					DROPPABLE_WHEN_EMPTY_AT_RULES.has(_atKeywordOf(path.node)) ||
-					unusedRule)
-			) {
-				// The rules written in it are not empty for its being so, and what the
-				// hoist writes for them is rules a later copy can take back.
-				_blockSpans.push(
-					path.type() === NodeType.QualifiedRule
-						? _NO_BLOCK_ENTRY_QUALIFIED
-						: _NO_BLOCK_ENTRY
-				);
-				{
-					const written =
-						_writeNested(
-							path,
-							/** @type {Node} */ (_S._currentNode),
-							prelude,
-							null,
-							true
-						) || "";
-					if (minify && written.length !== 0) {
-						_recordHoistedRule(written, null, 0);
-					}
-					return written;
-				}
-			}
-			// A rule that says which color scheme it is in says it again as the pair
-			// a lowered `light-dark()` reads, and — where it hands the choice to the
-			// user's own preference — once more under the query that asks for it.
-			let scheme = body;
-			let schemeCopy = "";
-			if (
-				_S._loweringLightDark &&
-				_S._sourceNamesLightDark &&
-				path.type() === NodeType.QualifiedRule &&
-				body.includes("color-scheme:") &&
-				// The pair as this writes it, not either name on its own: a
-				// block carrying that is one a lowering pass wrote. An authored
-				// `--webpack-light` is a declaration of the author's.
-				!body.includes(LIGHT_DARK_WRITTEN) &&
-				!body.includes(LIGHT_DARK_WRITTEN_DARK)
-			) {
-				const written = _COLOR_SCHEME_RE.exec(body);
-				const toggle =
-					written === null
-						? null
-						: _lightDarkToggle(written[1].replace(_IMPORTANT, "").trim());
-				if (toggle !== null) {
-					// The body's own closing `;` went with the minified print, and the
-					// toggle's last is the one this block now ends on.
-					scheme = `${body};${toggle.toggle.slice(0, -1)}`;
-					if (toggle.flip) {
-						schemeCopy = `${_PREFERS_DARK}${soft}{${_OWN_PRELUDE}${soft}{${LIGHT_PROPERTY}:;${DARK_PROPERTY}:initial}}`;
-					}
-				}
-			}
-			// The hoist's copy names the prelude as the run settles it, since one
-			// taken out is resolved against its parent and may be joined into a list.
-			const ownRest = `${soft}{${scheme}${nl}}${schemeCopy}`;
-			const rest =
-				schemeCopy === ""
-					? ownRest
-					: ownRest.replace(_OWN_PRELUDE, () => prelude);
-			const text = `${prelude}${rest}`;
-			// Prefix copies turn one rule into several, so a rewritten rule is not
-			// offered for joining: its text no longer describes a single block. Each
-			// block's rules are their own siblings, pairing within their scope.
-			let out = text;
-			if (_S._prefixingOn) {
-				// Read and clear here, so the lookahead is the one rule the writer
-				// holds — which only a top-level rule ever is — and never a rule
-				// further back.
-				const parent = path.parent;
-				const top = parent === null;
-				const scope = _prefixScope(parent);
-				out =
-					path.type() === NodeType.AtRule
-						? _prefixAtRule(path, text, prelude, scope, top)
-						: _prefixQualifiedRule(
-								text,
-								/** @type {string[]} */ (preludeParts),
-								soft,
-								body,
-								scope,
-								top
-							);
-			}
-			// WHY: pushed whatever it holds, since the parent takes one off per child
-			// with a body, so a block carrying no rule still has to be there. A
-			// rewritten rule records no nesting — those spans name `text` rather than
-			// `out` — but is still the one rule its text says it is. Only a block that
-			// recorded something needs an entry of its own, a leaf rule taking the
-			// shared one, and nothing is pushed while not minifying.
-			if (minify) {
-				_blockSpans.push(
-					spans === null || out !== text
-						? path.type() === NodeType.QualifiedRule
-							? _NO_BLOCK_ENTRY_QUALIFIED
-							: _NO_BLOCK_ENTRY
-						: {
-								bodyAt: prelude.length + soft.length + 1,
-								prelude,
-								keyPrelude: _openerKey(`${prelude}{`),
-								qualified: path.type() === NodeType.QualifiedRule,
-								spans
-							}
-				);
-			}
-			// A rewritten rule is several rules with preludes of their own, and each
-			// carries this rule's block — so the hoist takes them out. Only where
-			// it holds no rule of its own, those naming one prelude of the several.
-			const copies =
-				out === text ||
-				_prefixCopyPreludes.length === 0 ||
-				_holdsNested(/** @type {Node} */ (_S._currentNode))
-					? undefined
-					: _prefixCopyPreludes;
-			const nested = _writeNested(
-				path,
-				/** @type {Node} */ (_S._currentNode),
-				prelude,
-				ownRest,
-				out === text || copies !== undefined,
-				copies,
-				`${soft}{${body}}`
-			);
-			if (nested === null) return "";
-			if (out !== text) return out + nested;
-			// The run wrote this rule's selectors into itself, so what it returns is
-			// the whole of both — `text` being this rule's own `prelude` and `rest`.
-			if (nested.length !== 0) {
-				if (_nestedTookParent) {
-					if (minify) _recordHoistedRule(nested, null, 0);
-					return nested;
-				}
-				if (minify) _recordHoistedRule(nested, text, prelude.length);
-				return text + nested;
-			}
-			// Where the block is what a sibling is compared against, remember the rule
-			// so the parent parts it without re-scanning for the `{`. An at-rule
-			// remembers its block's entries too, so a sibling's rules can join them.
-			if (
-				minify &&
-				path.type() === NodeType.AtRule &&
-				MERGEABLE_AT_RULES.has(_atKeywordOf(path.node))
-			) {
-				/** @type {RuleEntry[]} */
-				const children = [];
-				for (let i = 0; i < texts.length; i++) {
-					if (texts[i].length === 0) continue;
-					if (superseded !== null && superseded.has(i)) continue;
-					// The entries have to spell the block this rule printed, prefixes and
-					// all: a join rebuilds the body from them, and one built from the
-					// unprefixed texts would restore what was dropped.
-					if (droppedPrefix !== null && droppedPrefix.has(i)) continue;
-					if (deadPrefixed !== null && deadPrefixed.has(items[i])) continue;
-					const added = addedPrefix === null ? undefined : addedPrefix.get(i);
-					children.push(
-						added === undefined
-							? _ruleEntryOf(items[i], texts[i])
-							: _opaqueEntry(added + texts[i])
-					);
-				}
-				let head = "";
-				for (let i = 0; i < children.length - 1; i++) head += children[i].text;
-				_setRuleEntry(_S._currentNode, {
-					text,
-					prelude: prelude.length,
-					atRule: true,
-					plain: false,
-					listable: LIST_NO,
-					listKind: LIST_KIND_SELECTOR,
-					children,
-					head,
-					// The block's own merges have run and settled what they grew, so the
-					// text above and the children agree; a list one of them still carries
-					// concatenated is one this block says is there to settle.
-					unordered: _anyUnordered(children)
-				});
-			}
-			if (minify && path.type() === NodeType.QualifiedRule) {
-				// Only a block of declarations lends its selectors to another's list: a
-				// nested rule's `&` stands for the whole list and `:is(…)` takes its most
-				// specific selector, so joining preludes moves what the nested beat.
-				const plain = rules === null || rules.length === 0;
-				const parent = path.parent;
-				// Which shape a join would read the prelude with — the parent is gone by
-				// then. A keyframe selector is a list of its own shape, which
-				// `_rulePrelude` has already rewritten `from` in.
-				let listKind = LIST_KIND_SELECTOR;
-				if (parent !== null) {
-					const parentType = path.type(parent);
-					if (parentType === NodeType.QualifiedRule) {
-						listKind = LIST_KIND_NESTED;
-					} else if (
-						parentType === NodeType.AtRule &&
-						KEYFRAMES_AT_RULE_RE.test(_atKeywordOf(parent))
-					) {
-						listKind = LIST_KIND_KEYFRAME;
-					}
-				}
-				_setRuleEntry(_S._currentNode, {
-					text,
-					prelude: prelude.length,
-					atRule: false,
-					plain,
-					listable: plain ? LIST_UNKNOWN : LIST_NO,
-					listKind,
-					children: null,
-					head: "",
-					unordered: false
-				});
-			}
-			return text;
-		}
+		case NodeType.QualifiedRule:
+			return _printRuleNode(path, writer, minify, soft);
 		case NodeType.Raw:
 			// Off-spec passthrough (see `NodeType.Raw`). It sits in a declaration list,
 			// so it carries the `;` parting it from the next item, and leaves an entry
@@ -5891,39 +6037,8 @@ const printer = (path, writer) => {
 				// string, a bracket — would swallow the `;` and `}` written after it.
 				return `${rest === _S._input.length ? _closeAtEof(raw) : raw};`;
 			}
-		case NodeType.Hash: {
-			const raw = _printedSource(path.node);
-			if (!minify) return raw;
-			// A hash is a hex color in a value and an id in a selector, and ids are
-			// case-sensitive, so only the former shortens — at any value depth. An id's
-			// escapes still shorten, the `#` held back so its first code point is one.
-			if (!path.within(NodeType.Declaration)) {
-				return _S._transforms.rewriteEscapes
-					? `#${_minifyIdentEscapes(raw.slice(1))}`
-					: raw;
-			}
-			// Inside a function only the known color functions take color hashes, and a
-			// substitution's fallback, being the property's value. `paint()` is the
-			// exception: its arguments reach a worklet rather than a declaration.
-			const parent = path.parent;
-			if (parent !== null && path.type(parent) === NodeType.Function) {
-				const fn = unescapeIdentifier(_rawName(parent)).toLowerCase();
-				if (
-					!COLOR_ARGUMENT_FUNCTIONS.has(fn) &&
-					!(SUBSTITUTION_FUNCTIONS.has(fn) && fn !== "paint")
-				) {
-					return raw;
-				}
-			}
-			const short = _minifyHash(raw);
-			const text = short === null ? raw : short;
-			// A hex alpha the target cannot read is written as the `rgba()` it names.
-			if (_S._hexAlphaAllowed) return text;
-			const lowered = _S._transforms.lowerUnsupported
-				? _hexAlphaFallback(text)
-				: null;
-			return lowered === null ? text : lowered;
-		}
+		case NodeType.Hash:
+			return _printHashNode(path, minify);
 		default: {
 			// Any remaining leaf token (ident, string, url, delim, …) prints verbatim
 			// from its source slice.
@@ -6034,4 +6149,6 @@ const _renderDataUrl = (url) => {
 	return buildDataURI(read.parsed, rendered);
 };
 
+_setVerbatimLeafPrinter(printer);
+
 module.exports.printer = printer;