, ) and to keep
				// the tag-boundary regex off script bodies. <style> and
				// <script> were grouped in with them, so protection became a
				// permanent exemption: on builder sites where most CSS is
				// inline, a page with minify ON shipped fully indented. Minify
				// the BODY here, before it's stashed, so the outer passes
				// still never see it. (#2)
				$placeholders[ $key ] = self::minify_inline_block( $m[0], strtolower( $m[1] ) );
				return $key;
			},
			$html
		);

		$html = preg_replace( '/<!--(?!\[if).*?-->/s', '', $html );
		$html = preg_replace( '/\s+/', ' ', $html );

		/*
		 * Collapse whitespace BETWEEN TAGS — but never where it is visible.
		 *
		 * Whitespace separating two INLINE elements is a real, rendered space:
		 * WooCommerce emits `</del> <ins>` for a sale price, and that single
		 * character is the gap between "$32.50" and "$29.50". Stripping it
		 * printed "$32.50$29.50" run together, and only with cache on — the
		 * un-minified page was fine. (FBS-84090)
		 *
		 * So the strip only applies when at least one side is a BLOCK-level
		 * (or non-rendered) tag, where the whitespace collapses away anyway.
		 * Inline-to-inline boundaries keep their single space.
		 */
		$html = preg_replace_callback(
			// left tag name (may be a closing tag) … whitespace … right tag name
			'#</?([a-zA-Z][a-zA-Z0-9-]*)\b[^>]*>\s+<(/?)([a-zA-Z][a-zA-Z0-9-]*)#',
			static function ( $m ) {
				// Keep the space only when BOTH sides are inline elements —
				// that is the one case where it is actually rendered.
				$keep = self::is_inline( $m[1] ) && self::is_inline( $m[3] );
				$open = substr( $m[0], 0, strrpos( $m[0], '<' ) ); // through the left tag's '>'
				return rtrim( $open ) . ( $keep ? ' ' : '' ) . '<' . $m[2] . $m[3];
			},
			$html
		);
		$html = trim( $html );

		foreach ( $placeholders as $key => $original ) {
			$html = str_replace( $key, $original, $html );
		}

		return $html;
	}

	public static function rewrite_style( $src, $handle ) {
		unset( $handle );
		return self::rewrite_asset( $src, 'css' );
	}

	public static function rewrite_script( $src, $handle ) {
		$rewritten = self::rewrite_asset( $src, 'js' );

		// Remember the pre-minify URL for this handle. script_loader_tag
		// runs later and only ever sees the rewritten src (a hashed
		// /cache/xspeed/min/<key>.js path), so a user's URL-substring
		// delay/exclusion target would never match once minification is
		// on. Minify_Filters::original_src() gives those checks the URL
		// the user actually wrote their target against. (FBS field report)
		if ( is_string( $handle ) && '' !== $handle && is_string( $src ) && $src !== $rewritten ) {
			Minify_Filters::remember_original_src( $handle, $src );
		}

		return $rewritten;
	}

	/**
	 * Replace a local CSS/JS URL with a cached, minified equivalent.
	 *
	 * @param string $src      Original asset URL.
	 * @param string $type     'css' or 'js'.
	 * @return string          Possibly rewritten URL.
	 */
	private static function rewrite_asset( $src, $type ) {
		if ( ! is_string( $src ) || '' === $src ) {
			return $src;
		}

		// Skip already-minified files.
		if ( false !== strpos( $src, '.min.' ) ) {
			return $src;
		}

		// Skip anything we already produced. The Asset_Combiner minifies the
		// combined body itself before writing combined-<hash>.css under
		// min/combined/ (issue #331 — that used to be asserted here but was
		// not actually true, so the artifact shipped unminified), and enqueues it
		// as `xspeed-combined-css`; the per-file minifier used to re-minify
		// that combined output into a SECOND file (min/<hash2>.css) with its
		// own mtime-derived hash. The served HTML then pinned that second
		// hash, so a purge/regeneration (which changes the combined file's
		// mtime -> a new hash2) left the cached page pointing at a file that
		// no longer existed -> 404 -> unstyled/broken frontend. Leaving our
		// own cache output untouched keeps a single, stable URL end-to-end.
		if ( false !== strpos( $src, '/cache/xspeed/' ) ) {
			return $src;
		}

		// Resolve to a local path; bail if external or unresolvable.
		$path = self::url_to_path( $src );
		if ( ! $path || ! is_readable( $path ) ) {
			return $src;
		}

		// Build a cache filename keyed on path + mtime so edits invalidate.
		$mtime = filemtime( $path );
		$key   = md5( $path . '|' . $mtime );
		$cache = self::cache_path( $key, $type );

		if ( ! file_exists( $cache ) ) {
			$ok = self::minify_file( $path, $cache, $type );
			if ( ! $ok ) {
				return $src;
			}
		}

		// Return a URL to the cached file. Built from known constants — never
		// from str_replace on a filesystem path (which would assume the FS
		// layout mirrors the URL layout).
		return self::min_url() . '/' . $key . '.' . $type;
	}

	private static function minify_file( $source_path, $target_path, $type ) {
		if ( ! class_exists( '\\MatthiasMullie\\Minify\\CSS' ) ) {
			return false;
		}

		// Path-traversal guard: refuse to write anywhere outside our cache
		// dir, even if a malicious filter ever produced a poisoned key.
		$cache_root = self::min_dir();
		self::ensure_dir( $cache_root );
		$real_root  = realpath( $cache_root );
		$real_dir   = realpath( dirname( $target_path ) );
		if ( ! $real_root || ! $real_dir || 0 !== strpos( $real_dir, $real_root ) ) {
			return false;
		}

		try {
			if ( 'css' === $type ) {
				// Passing the TARGET path makes matthiasmullie/minify rebase every
				// relative url(...) / @import against the minified file's location.
				// Without it, a stylesheet moved from e.g.
				// .../font-awesome/css/all.css to cache/xspeed/min/<key>.css keeps
				// its original url(../webfonts/…) — which then resolves against the
				// cache dir and 404s (missing FontAwesome/eicons/WooCommerce fonts).
				$minifier = new \MatthiasMullie\Minify\CSS( $source_path );
				$minified = $minifier->minify( $target_path );
				return '' !== $minified && file_exists( $target_path );
			}

			$minifier = new \MatthiasMullie\Minify\JS( $source_path );
			$minified = $minifier->minify();

			// Sanity check: paren/brace/bracket/backtick balance must be preserved.
			// matthiasmullie/minify can silently truncate mid-template-literal on
			// complex modern JS — bail rather than ship a broken file.
			// phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents -- WP_Filesystem requires admin context; minification runs on frontend page renders. Source already validated as readable on line 121.
			$source = file_get_contents( $source_path );
			if ( false === $source || ! self::balanced( $source, $minified ) ) {
				return false;
			}

			// phpcs:ignore WordPress.WP.AlternativeFunctions.file_put_contents_file_put_contents -- WP_Filesystem requires admin context; minification runs on frontend page renders.
			$bytes = file_put_contents( $target_path, $minified );
			return false !== $bytes && file_exists( $target_path );
		} catch ( \Throwable $e ) {
			return false;
		}
	}

	/**
	 * Cheap structural sanity check between source + minified bodies.
	 *
	 * Counts paired-delimiter tokens (parens, braces, brackets, backticks)
	 * in each and bails when the counts disagree — matthiasmullie/minify
	 * has been observed to silently truncate inside template literals on
	 * complex modern JS (see commit history), shipping a body that LOOKS
	 * minified but is structurally broken and crashes the page at parse.
	 *
	 * Backticks are paired (open + close = same token), so the count
	 * itself must match exactly. Strings inside the source can contain
	 * literal `{` / `}` / `[` / `]` that throw off the count by the same
	 * amount in both bodies (since they survive minification as-is), so
	 * the equality check is robust to that noise.
	 */
	/**
	 * Minify the body of one captured inline block, or return it untouched.
	 *
	 * Only `<style>` and JavaScript `<script>` bodies are eligible:
	 *
	 *  - `<pre>` / `<textarea>` — whitespace is rendered, never touch it.
	 *  - `<script>` with a non-JS `type` — `application/ld+json`,
	 *    `text/template`, `text/x-handlebars` and anything unrecognised are
	 *    data or markup, not code. Minifying JSON-LD would corrupt structured
	 *    data; minifying a template would eat the markup it holds. An unknown
	 *    type is treated as non-JS on purpose: guessing wrong breaks the page,
	 *    while skipping only forgoes a few bytes.
	 *  - `<script src="...">` — the body is empty; the file path already goes
	 *    through minify_file().
	 *
	 * Every result is checked with balanced(), the same structural guard the
	 * file path uses, so a body the library truncates is shipped as-is rather
	 * than broken. (#2)
	 *
	 * @param string $block Full matched tag, opening tag through closing tag.
	 * @param string $tag   Lowercased tag name.
	 * @return string Minified block, or $block unchanged.
	 */
	private static function minify_inline_block( string $block, string $tag ): string {
		if ( 'style' !== $tag && 'script' !== $tag ) {
			return $block; // pre / textarea — significant whitespace.
		}
		if ( ! class_exists( '\\MatthiasMullie\\Minify\\CSS' ) ) {
			return $block;
		}

		// Split into opening tag / body / closing tag. Anything that doesn't
		// match this shape isn't something we should be rewriting.
		if ( ! preg_match( '#^(<' . $tag . '\b[^>]*>)(.*)(</' . $tag . '\s*>)$#is', $block, $parts ) ) {
			return $block;
		}
		list( , $open, $body, $close ) = $parts;

		if ( '' === trim( $body ) ) {
			return $block;
		}

		// The tag asked to be left alone (data-no-optimize / data-no-minify —
		// the convention consent managers print on their config scripts). (#456)
		if ( Minify_Filters::tag_opts_out( $open ) ) {
			return $block;
		}

		// Refuse a body that is already structurally broken. balanced() only
		// compares source against minified, so it passes when BOTH are equally
		// unbalanced — `function x( {` minifies to `function x({`, same counts,
		// guard satisfied, broken code reformatted. Rewriting a body we can't
		// parse risks turning a page that happens to work into one that does
		// not, for no gain. (#2 AC: a syntactically broken block is left
		// untouched.)
		if ( ! self::self_consistent( $body ) ) {
			return $block;
		}

		if ( 'script' === $tag ) {
			// An external script has no body worth minifying.
			if ( preg_match( '#\bsrc\s*=#i', $open ) ) {
				return $block;
			}
			// No type, or an explicitly JavaScript type, is code. Everything
			// else is data/markup — see the docblock.
			$js_types = array(
				'text/javascript',
				'application/javascript',
				'application/ecmascript',
				'text/ecmascript',
				'module',
			);
			if ( preg_match( '#\btype\s*=\s*["\']?([^"\'\s>]+)#i', $open, $type_match ) ) {
				if ( ! in_array( strtolower( trim( $type_match[1] ) ), $js_types, true ) ) {
					return $block;
				}
			}
		}

		try {
			$minifier = 'style' === $tag
				? new \MatthiasMullie\Minify\CSS()
				: new \MatthiasMullie\Minify\JS();
			$minifier->add( $body );
			$minified = $minifier->minify();
		} catch ( \Throwable $e ) {
			return $block;
		}

		// A minifier that returns nothing for a non-empty body has failed, not
		// succeeded — shipping '' would silently delete the rule set.
		if ( ! is_string( $minified ) || '' === trim( $minified ) ) {
			return $block;
		}
		if ( ! self::balanced( $body, $minified ) ) {
			return $block;
		}

		return $open . $minified . $close;
	}

	/**
	 * Does a body's own paired delimiters balance?
	 *
	 * balanced() is a RELATIVE check — source against minified — so it cannot
	 * see input that was already broken: an unbalanced body minifies to an
	 * equally unbalanced one and the counts still agree. This is the absolute
	 * check, applied to the source alone before we touch it.
	 *
	 * Deliberately naive: it counts tokens without parsing, so a brace inside
	 * a string or comment skews it. That only ever makes it MORE conservative —
	 * a false negative skips minification, which costs bytes, while a false
	 * positive would ship broken code. (#2)
	 *
	 * @param string $body Inline block body.
	 */
	private static function self_consistent( string $body ): bool {
		$pairs = array(
			'{' => '}',
			'(' => ')',
			'[' => ']',
		);
		foreach ( $pairs as $open => $close ) {
			if ( substr_count( $body, $open ) !== substr_count( $body, $close ) ) {
				return false;
			}
		}
		// Backticks and quotes pair with themselves, so an odd count means an
		// unterminated literal.
		foreach ( array( '`' ) as $token ) {
			if ( 0 !== substr_count( $body, $token ) % 2 ) {
				return false;
			}
		}
		return true;
	}

	private static function balanced( string $source, string $minified ): bool {
		unset( $source );

		// Judge the OUTPUT, not the difference between input and output.
		//
		// This used to compare token counts across the pair, on the stated
		// assumption that "literal braces inside strings survive minification
		// unchanged, so they cancel out". Comments do not: stripping them is
		// the minifier's whole job, and every brace, bracket and backtick
		// inside one disappears with it. So any file whose comments contain a
		// delimiter — a commented-out block, a URL in a docblock, an SVG in a
		// note — failed the check and silently shipped unminified.
		//
		// It is not a rare shape. EmbedPress's front.js counts 372 braces
		// against 368, 61 brackets against 58 and 110 backticks against 102
		// purely from comment removal, so 67 KB shipped raw where 46 KB was
		// correct — and `node --check` confirms that rejected output parses
		// fine. A guard that refuses valid work is not conservative, it is
		// broken: it costs bytes on every request and reports nothing.
		//
		// What the guard is FOR still stands (#2): matthiasmullie/minify can
		// truncate inside a template literal on complex modern JS and return a
		// body that looks minified but is structurally broken. That failure is
		// visible in the output alone — an unterminated literal leaves an odd
		// backtick count and unmatched braces — which is exactly what
		// self_consistent() measures, without the false positives.
		return self::self_consistent( $minified );
	}

	/**
	 * Resolve a local asset URL to a filesystem path using a strict allowlist
	 * of "URL prefix → filesystem prefix" pairs registered with WordPress.
	 *
	 * We never assume `site_url()` maps to `ABSPATH` (the WordPress root can
	 * live above the document root in Bedrock-style installs, behind a proxy,
	 * or on multisite with mapped domains). Each branch resolves through a
	 * known WP API (plugins, themes, content, includes) and validates that
	 * `realpath()` of the result still lives under the expected base — so a
	 * crafted `..`-laden URL cannot escape into the filesystem.
	 *
	 * @param string $url Asset URL (may be protocol-relative or absolute).
	 * @return string|false Absolute filesystem path on success, false otherwise.
	 */
	private static function url_to_path( $url ) {
		if ( ! is_string( $url ) || '' === $url ) {
			return false;
		}

		// Drop query string + fragment.
		$clean = strtok( $url, '?#' );

		// Normalise protocol-relative + scheme variants of the host so we
		// match regardless of whether the asset URL came in over http/https.
		$site_host = wp_parse_url( home_url(), PHP_URL_HOST );
		if ( 0 === strpos( $clean, '//' ) ) {
			$clean = 'https:' . $clean;
		}
		if ( $site_host ) {
			$asset_host = wp_parse_url( $clean, PHP_URL_HOST );
			if ( $asset_host && $asset_host !== $site_host ) {
				return false; // External asset — never touch.
			}
		}

		$candidates = array(
			array( plugins_url(),                  WP_PLUGIN_DIR ),
			array( get_stylesheet_directory_uri(), get_stylesheet_directory() ),
			array( get_template_directory_uri(),   get_template_directory() ),
			array( content_url(),                  WP_CONTENT_DIR ),
			array( includes_url(),                 ABSPATH . WPINC ),
		);

		// The host check above normalised the HOST but not the SCHEME, and the
		// prefix match below is a plain string compare — so an https asset URL
		// never matched an http base and the file silently shipped unminified.
		// That is not a corner case: WP_CONTENT_URL is derived from a stored
		// option, `plugins_url()` from another, and a site moved to https
		// without rewriting every row (or one behind a TLS-terminating proxy
		// where `is_ssl()` reads false) serves https pages off http-rooted
		// bases all day. Comparing scheme-less is the whole fix; the host
		// equality test already did the security work of refusing anything
		// off-site, and this runs after it.
		$strip_scheme = static function ( string $value ): string {
			return (string) preg_replace( '#^https?://#i', '//', $value );
		};
		$clean_match  = $strip_scheme( $clean );

		foreach ( $candidates as $pair ) {
			list( $url_base, $path_base ) = $pair;
			if ( ! $url_base || ! $path_base ) {
				continue;
			}
			$url_base  = rtrim( $url_base, '/' );
			$base_match = $strip_scheme( $url_base );
			if ( 0 !== strpos( $clean_match, $base_match . '/' ) && $clean_match !== $base_match ) {
				continue;
			}

			// Slice the scheme-less pair, not the original. `https://…` and
			// `http://…` differ by one byte, so an offset taken from the base
			// as written would cut one character short of (or past) the path
			// when the two schemes disagree — which is the case this fix
			// exists for.
			$relative  = ltrim( substr( $clean_match, strlen( $base_match ) ), '/' );
			$candidate = trailingslashit( $path_base ) . $relative;

			$real_base = realpath( $path_base );
			$real      = realpath( $candidate );
			if ( ! $real_base || ! $real ) {
				return false;
			}
			// Guard against `..`-traversal: resolved path must stay inside
			// the registered base.
			if ( 0 !== strpos( $real, $real_base ) ) {
				return false;
			}
			return $real;
		}

		return false;
	}

	private static function cache_path( $key, $type ) {
		return self::min_dir() . '/' . $key . '.' . $type;
	}

	private static function ensure_dir( $dir ) {
		if ( ! file_exists( $dir ) ) {
			wp_mkdir_p( $dir );
			Cache::write_silence( $dir );
		}
	}

	/**
	 * Clear every minified / combined asset.
	 *
	 * @return int Files removed. Most callers are `add_action` callbacks and
	 *             ignore it; `wp xspeed purge` reports it as a line item.
	 */
	public static function purge_minified() {
		return self::rmtree_files( self::min_dir() );
	}

	/**
	 * Recursively delete every file under $dir (and the emptied
	 * subdirectories), keeping $dir itself. The previous glob('$dir/*')
	 * was non-recursive and no-ops on directories, so combined assets in
	 * min/combined/ were never cleared — a purge left a stale
	 * combined-<hash>.css the regenerated page no longer referenced.
	 * (FBS-83114 / FBS-83116)
	 */
	private static function rmtree_files( string $dir ): int {
		if ( ! is_dir( $dir ) ) {
			return 0;
		}
		$removed = 0;
		foreach ( (array) glob( $dir . '/*' ) as $path ) {
			if ( is_dir( $path ) ) {
				$removed += self::rmtree_files( $path );
				@rmdir( $path ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_rmdir, WordPress.PHP.NoSilencedErrors.Discouraged -- best-effort cleanup of our own cache subdir; WP_Filesystem is unavailable on the frontend purge path.
				continue;
			}
			wp_delete_file( $path );
			++$removed;
		}
		return $removed;
	}
}