@weapp-tailwindcss/postcss 3.3.5 → 3.3.6

package/dist/resolve-EBh65bS8.cjs

@@ -0,0 +1,3556 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_shared = require("./shared-CELzerNo.cjs");
+let _weapp_tailwindcss_postcss_calc = require("@weapp-tailwindcss/postcss-calc");
+_weapp_tailwindcss_postcss_calc = require_rolldown_runtime.__toESM(_weapp_tailwindcss_postcss_calc, 1);
+let postcss = require("postcss");
+postcss = require_rolldown_runtime.__toESM(postcss, 1);
+let postcss_value_parser = require("postcss-value-parser");
+postcss_value_parser = require_rolldown_runtime.__toESM(postcss_value_parser, 1);
+let postcss_selector_parser = require("postcss-selector-parser");
+postcss_selector_parser = require_rolldown_runtime.__toESM(postcss_selector_parser, 1);
+let _csstools_css_color_parser = require("@csstools/css-color-parser");
+let _csstools_css_parser_algorithms = require("@csstools/css-parser-algorithms");
+let _csstools_css_tokenizer = require("@csstools/css-tokenizer");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let postcss_preset_env = require("postcss-preset-env");
+postcss_preset_env = require_rolldown_runtime.__toESM(postcss_preset_env, 1);
+let _weapp_tailwindcss_engine = require("@weapp-tailwindcss/engine");
+let _weapp_tailwindcss_source_scan = require("@weapp-tailwindcss/source-scan");
+let node_module = require("node:module");
+let tailwindcss_config = require("tailwindcss-config");
+//#region src/compat/lynx-css.ts
+const tailwindThemePropertyPatterns = [
+	/^--aspect-/,
+	/^--animate-/,
+	/^--blur-/,
+	/^--breakpoint-/,
+	/^--color-/,
+	/^--container-/,
+	/^--drop-shadow-/,
+	/^--ease-/,
+	/^--default-font-/,
+	/^--font-/,
+	/^--font-weight-/,
+	/^--inset-shadow-/,
+	/^--leading-/,
+	/^--perspective-/,
+	/^--radius-/,
+	/^--shadow-/,
+	/^--text-/,
+	/^--tracking-/,
+	/^--spacing$/
+];
+function isTailwindThemeProperty(property) {
+	return tailwindThemePropertyPatterns.some((pattern) => pattern.test(property));
+}
+function isThemeScopeSelector(selector) {
+	return selector.split(",").some((part) => {
+		const normalized = part.trim();
+		return normalized === ":root" || normalized === ":host";
+	});
+}
+function collectTailwindThemeProperties(root) {
+	const values = /* @__PURE__ */ new Map();
+	root.walkRules((rule) => {
+		if (!isThemeScopeSelector(rule.selector)) return;
+		rule.walkDecls((decl) => {
+			if (isTailwindThemeProperty(decl.prop)) values.set(decl.prop, decl.value.trim());
+		});
+	});
+	return values;
+}
+function resolveThemeValue(value, properties, resolving = /* @__PURE__ */ new Set()) {
+	if (!value.includes("var(")) return value;
+	const parsed = (0, postcss_value_parser.default)(value);
+	parsed.walk((node) => {
+		if (node.type !== "function" || node.value.toLowerCase() !== "var") return;
+		const property = node.nodes.find((child) => child.type === "word" && child.value.startsWith("--"))?.value;
+		if (!property || resolving.has(property)) return;
+		const propertyValue = properties.get(property);
+		if (!propertyValue) return;
+		const nextResolving = new Set(resolving);
+		nextResolving.add(property);
+		const resolved = resolveThemeValue(propertyValue, properties, nextResolving);
+		const mutableNode = node;
+		mutableNode.type = "word";
+		mutableNode.value = resolved;
+		delete mutableNode.nodes;
+	});
+	return parsed.toString();
+}
+function removeConsumedThemeProperties(root) {
+	root.walkRules((rule) => {
+		if (!isThemeScopeSelector(rule.selector)) return;
+		rule.walkDecls((decl) => {
+			if (isTailwindThemeProperty(decl.prop)) decl.remove();
+		});
+		if (rule.nodes.length === 0) rule.remove();
+	});
+}
+/** 将 Lynx 原生无法继承的 Tailwind theme 变量静态化。 */
+function transformLynxCssCompat(css) {
+	try {
+		const root = postcss.default.parse(css);
+		const properties = collectTailwindThemeProperties(root);
+		if (properties.size === 0) return css;
+		root.walkDecls((decl) => {
+			decl.value = resolveThemeValue(decl.value, properties);
+		});
+		removeConsumedThemeProperties(root);
+		(0, postcss.default)([(0, _weapp_tailwindcss_postcss_calc.default)()]).process(root, { from: void 0 }).sync();
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+//#endregion
+//#region src/compat/mini-program-css/cascade-layers.ts
+const LAYER_PATH_SEPARATOR = "
";
+const LAYER_INSERTION_ANCHOR = "__weapp_tailwindcss_layer_anchor__";
+function splitLayerNames(params) {
+	return params.split(",").map((name) => name.trim()).filter(Boolean);
+}
+function splitLayerPath(name) {
+	return name.split(".").map((segment) => segment.trim()).filter(Boolean);
+}
+function createLayerPath(segments) {
+	return {
+		key: segments.join(LAYER_PATH_SEPARATOR),
+		segments
+	};
+}
+function isContainer(node) {
+	return "nodes" in node && Array.isArray(node.nodes);
+}
+function cloneWrapper(node, children) {
+	const wrapper = node.clone({ nodes: [] });
+	wrapper.append(...children);
+	return wrapper;
+}
+function wrapLayerNodes(atRule, nodes, root) {
+	let wrapped = nodes;
+	let parent = atRule.parent;
+	while (parent && parent !== root) {
+		if (parent.type !== "atrule" || parent.name !== "layer") {
+			if (isContainer(parent)) wrapped = [cloneWrapper(parent, wrapped)];
+		}
+		parent = parent.parent;
+	}
+	return wrapped;
+}
+function removeEmptyLayerAncestors(node, root) {
+	let parent = node.parent;
+	node.remove();
+	while (parent && parent !== root && parent.type === "atrule" && parent.nodes?.length === 0) {
+		const nextParent = parent.parent;
+		parent.remove();
+		parent = nextParent;
+	}
+}
+function isLayerDescendant(candidate, parent) {
+	return candidate.length > parent.length && parent.every((segment, index) => candidate[index] === segment);
+}
+function findParentLayerPath(atRule, paths) {
+	let parent = atRule.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name === "layer") return paths.get(parent)?.segments ?? [];
+		parent = parent.parent;
+	}
+	return [];
+}
+function createLayerInsertionAnchor(root, atRule) {
+	let topLevelNode = atRule;
+	while (topLevelNode.parent && topLevelNode.parent !== root) topLevelNode = topLevelNode.parent;
+	const anchor = postcss.default.comment({ text: LAYER_INSERTION_ANCHOR });
+	topLevelNode.before(anchor);
+	return anchor;
+}
+function insertLayeredNodes(root, anchor, nodes) {
+	if (!anchor.parent) {
+		root.append(nodes);
+		return;
+	}
+	if (nodes.length === 0) {
+		anchor.remove();
+		return;
+	}
+	anchor.replaceWith(nodes);
+}
+/**
+* 按 cascade layer 声明顺序重排规则并移除 `@layer` 语法。
+*
+* 该转换只模拟 layer 的顺序语义，不通过提高选择器权重模拟完整 specificity 规则。
+*/
+function consumeCascadeLayers(root) {
+	const layerAtRules = [];
+	const paths = /* @__PURE__ */ new WeakMap();
+	const siblingOrders = /* @__PURE__ */ new Map();
+	const buckets = /* @__PURE__ */ new Map();
+	const topLayerOccurrences = /* @__PURE__ */ new Map();
+	let anonymousLayerIndex = 0;
+	const registerPath = (segments, occurrence) => {
+		let parentKey = "";
+		for (const [index, segment] of segments.entries()) {
+			let siblings = siblingOrders.get(parentKey);
+			if (!siblings) {
+				siblings = /* @__PURE__ */ new Map();
+				siblingOrders.set(parentKey, siblings);
+			}
+			if (!siblings.has(segment)) siblings.set(segment, siblings.size);
+			if (index === 0 && !topLayerOccurrences.has(segment)) topLayerOccurrences.set(segment, occurrence);
+			parentKey = parentKey ? `${parentKey}${LAYER_PATH_SEPARATOR}${segment}` : segment;
+		}
+		const path = createLayerPath(segments);
+		if (!buckets.has(path.key)) buckets.set(path.key, {
+			...path,
+			nodes: []
+		});
+		return path;
+	};
+	root.walkAtRules("layer", (atRule) => {
+		layerAtRules.push(atRule);
+		const parentLayer = findParentLayerPath(atRule, paths);
+		const names = splitLayerNames(atRule.params);
+		if (!atRule.nodes) {
+			for (const name of names) registerPath([...parentLayer, ...splitLayerPath(name)], atRule);
+			return;
+		}
+		const ownSegments = names[0] ? splitLayerPath(names[0]) : [`\u0000anonymous-${anonymousLayerIndex++}`];
+		paths.set(atRule, registerPath([...parentLayer, ...ownSegments], atRule));
+	});
+	if (layerAtRules.length === 0) return;
+	const insertionAnchors = /* @__PURE__ */ new Map();
+	for (const [segment, occurrence] of topLayerOccurrences) insertionAnchors.set(segment, createLayerInsertionAnchor(root, occurrence));
+	for (const atRule of [...layerAtRules].reverse()) {
+		if (!atRule.parent) continue;
+		const path = paths.get(atRule);
+		if (!path || !atRule.nodes) {
+			removeEmptyLayerAncestors(atRule, root);
+			continue;
+		}
+		const nodes = atRule.nodes.map((node) => node.clone());
+		if (nodes.length > 0) buckets.get(path.key)?.nodes.unshift(...wrapLayerNodes(atRule, nodes, root));
+		removeEmptyLayerAncestors(atRule, root);
+	}
+	const compareBuckets = (left, right) => {
+		if (isLayerDescendant(left.segments, right.segments)) return -1;
+		if (isLayerDescendant(right.segments, left.segments)) return 1;
+		const size = Math.min(left.segments.length, right.segments.length);
+		let parentKey = "";
+		for (let index = 0; index < size; index++) {
+			const leftSegment = left.segments[index];
+			const rightSegment = right.segments[index];
+			if (leftSegment !== rightSegment) {
+				const siblings = siblingOrders.get(parentKey);
+				return (siblings?.get(leftSegment) ?? 0) - (siblings?.get(rightSegment) ?? 0);
+			}
+			parentKey = parentKey ? `${parentKey}${LAYER_PATH_SEPARATOR}${leftSegment}` : leftSegment;
+		}
+		return left.segments.length - right.segments.length;
+	};
+	const bucketsByTopLayer = /* @__PURE__ */ new Map();
+	for (const bucket of buckets.values()) {
+		const topLayer = bucket.segments[0];
+		if (!topLayer || bucket.nodes.length === 0) continue;
+		const group = bucketsByTopLayer.get(topLayer) ?? [];
+		group.push(bucket);
+		bucketsByTopLayer.set(topLayer, group);
+	}
+	for (const [segment, anchor] of insertionAnchors) insertLayeredNodes(root, anchor, (bucketsByTopLayer.get(segment) ?? []).sort(compareBuckets).flatMap((bucket) => bucket.nodes));
+}
+//#endregion
+//#region src/compat/mini-program-css/at-rules.ts
+const MINI_PROGRAM_UNSUPPORTED_AT_RULES = /* @__PURE__ */ new Set(["property", "supports"]);
+function removeAtRulesByScan(css, names) {
+	let index = 0;
+	let result = "";
+	const atRulePattern = new RegExp(`@(?:${[...names].join("|")})\\b`, "i");
+	while (index < css.length) {
+		const match = atRulePattern.exec(css.slice(index));
+		if (!match || match.index === void 0) {
+			result += css.slice(index);
+			break;
+		}
+		const start = index + match.index;
+		result += css.slice(index, start);
+		const blockStart = css.indexOf("{", start);
+		if (blockStart === -1) {
+			result += css.slice(start);
+			break;
+		}
+		let depth = 0;
+		let cursor = blockStart;
+		for (; cursor < css.length; cursor++) {
+			const char = css[cursor];
+			if (char === "{") depth++;
+			else if (char === "}") {
+				depth--;
+				if (depth === 0) {
+					cursor++;
+					break;
+				}
+			}
+		}
+		index = cursor;
+	}
+	return result;
+}
+function removeUnsupportedMiniProgramAtRules(css) {
+	try {
+		const root = postcss.default.parse(css);
+		root.walkAtRules((atRule) => {
+			if (MINI_PROGRAM_UNSUPPORTED_AT_RULES.has(atRule.name)) atRule.remove();
+		});
+		root.walkAtRules((atRule) => {
+			if (atRule.nodes && atRule.nodes.length === 0) atRule.remove();
+		});
+		return root.toString();
+	} catch {
+		return removeAtRulesByScan(css, MINI_PROGRAM_UNSUPPORTED_AT_RULES);
+	}
+}
+function removeUnsupportedAtSupports(css) {
+	return removeUnsupportedMiniProgramAtRules(css);
+}
+/**
+* 移除小程序不支持的 cascade layer 语法，同时保留 layer 内的实际规则。
+*/
+function removeUnsupportedCascadeLayers(root) {
+	consumeCascadeLayers(root);
+}
+function unwrapUnsupportedCascadeLayers(css) {
+	if (!css.includes("@layer")) return css;
+	try {
+		const root = postcss.default.parse(css);
+		removeUnsupportedCascadeLayers(root);
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+//#endregion
+//#region src/compat/mini-program-css/selectors.ts
+const MINI_PROGRAM_THEME_SCOPE_SELECTOR = ":host,page,.tw-root,wx-root-portal-content";
+const MINI_PROGRAM_ELEMENT_SCOPE_SELECTOR = "view,text,::after,::before";
+const MINI_PROGRAM_ELEMENT_SCOPE_SELECTORS = /* @__PURE__ */ new Set([
+	"view",
+	"text",
+	":before",
+	":after",
+	"::before",
+	"::after"
+]);
+const MINI_PROGRAM_NATIVE_ELEMENT_SELECTORS = /* @__PURE__ */ new Set([
+	...MINI_PROGRAM_ELEMENT_SCOPE_SELECTORS,
+	"button",
+	"input",
+	"textarea",
+	"canvas",
+	"video",
+	"audio"
+]);
+const MINI_PROGRAM_PREFLIGHT_SELECTORS = /* @__PURE__ */ new Set(["*", ...MINI_PROGRAM_ELEMENT_SCOPE_SELECTORS]);
+const MINI_PROGRAM_THEME_SCOPE_SELECTORS = /* @__PURE__ */ new Set([
+	":host",
+	":root",
+	"page",
+	".tw-root",
+	"wx-root-portal-content"
+]);
+function normalizeMiniProgramThemeScopeSelector(root) {
+	if (root === false) return ":host";
+	if (root === void 0) return MINI_PROGRAM_THEME_SCOPE_SELECTOR;
+	const selectors = Array.isArray(root) ? root.filter(Boolean) : [root];
+	return [.../* @__PURE__ */ new Set([":host", ...selectors])].join(",");
+}
+const SPECIFICITY_PLACEHOLDER_SUFFIXES = [":not(#n)", ":not(#\\#)"];
+const ROOT_SPECIFICITY_PLACEHOLDER_SUFFIXES = [":not(.does-not-exist)"];
+const MINI_PROGRAM_UNSUPPORTED_BROWSER_SELECTORS = /* @__PURE__ */ new Set([
+	":-moz-focusring",
+	":-moz-ui-invalid",
+	"::-webkit-calendar-picker-indicator",
+	"::-webkit-date-and-time-value",
+	"::-webkit-datetime-edit",
+	"::-webkit-datetime-edit-day-field",
+	"::-webkit-datetime-edit-fields-wrapper",
+	"::-webkit-datetime-edit-hour-field",
+	"::-webkit-datetime-edit-meridiem-field",
+	"::-webkit-datetime-edit-millisecond-field",
+	"::-webkit-datetime-edit-minute-field",
+	"::-webkit-datetime-edit-month-field",
+	"::-webkit-datetime-edit-second-field",
+	"::-webkit-datetime-edit-year-field",
+	"::-webkit-inner-spin-button",
+	"::-webkit-input-placeholder",
+	"::-webkit-outer-spin-button",
+	"::-webkit-search-decoration",
+	"::placeholder",
+	"[hidden]:where(:not([hidden='until-found']))"
+]);
+const MINI_PROGRAM_UNSUPPORTED_BROWSER_TAG_SELECTORS = /* @__PURE__ */ new Set([
+	"a",
+	"abbr:where([title])",
+	"audio",
+	"b",
+	"button",
+	"canvas",
+	"code",
+	"embed",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"hr",
+	"html",
+	"iframe",
+	"img",
+	"input",
+	"input:where([type='button'],[type='reset'],[type='submit'])",
+	"kbd",
+	"menu",
+	"object",
+	"ol",
+	"optgroup",
+	"pre",
+	"progress",
+	"samp",
+	"select",
+	"select[multiple]optgroup",
+	"select[multiple]optgroupoption",
+	"select[size]optgroup",
+	"select[size]optgroupoption",
+	"small",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"svg",
+	"table",
+	"textarea",
+	"ul",
+	"video"
+]);
+const MINI_PROGRAM_UNSUPPORTED_BROWSER_PREFLIGHT_SELECTOR_PARTS = /* @__PURE__ */ new Set([...MINI_PROGRAM_UNSUPPORTED_BROWSER_TAG_SELECTORS, "::file-selector-button"]);
+function normalizeSelector(selector) {
+	return selector.trim().replace(/\s+/g, "");
+}
+function normalizePseudoElementSelector(selector) {
+	return normalizeSelector(selector).replace(/^:(before|after)$/, "::$1");
+}
+function getRuleSelectors(rule) {
+	return rule.selector.split(",").map(normalizePseudoElementSelector).filter(Boolean);
+}
+function getSortedRuleSelectorKey(rule) {
+	return getRuleSelectors(rule).sort().join(",");
+}
+function isUnsupportedBrowserSelector(selector) {
+	const normalized = normalizeSelector(selector);
+	return MINI_PROGRAM_UNSUPPORTED_BROWSER_SELECTORS.has(normalized) || MINI_PROGRAM_UNSUPPORTED_BROWSER_TAG_SELECTORS.has(normalized) && !MINI_PROGRAM_NATIVE_ELEMENT_SELECTORS.has(normalized);
+}
+function isUnsupportedBrowserPreflightSelector(selector) {
+	const normalizedParts = selector.split(",").map(normalizeSelector).filter(Boolean);
+	return normalizedParts.length > 1 && normalizedParts.every((part) => MINI_PROGRAM_UNSUPPORTED_BROWSER_PREFLIGHT_SELECTOR_PARTS.has(part));
+}
+function isMiniProgramNativeElementSelector(selector) {
+	return MINI_PROGRAM_NATIVE_ELEMENT_SELECTORS.has(normalizePseudoElementSelector(selector));
+}
+function isMiniProgramPreflightSelector(selectors) {
+	return selectors.length > 0 && selectors.every((selector) => MINI_PROGRAM_PREFLIGHT_SELECTORS.has(selector)) && selectors.some((selector) => selector === "*" || selector === ":before" || selector === ":after" || selector === "::before" || selector === "::after");
+}
+function isMiniProgramThemeScopeSelector(selectors) {
+	return selectors.length > 0 && selectors.every((selector) => MINI_PROGRAM_THEME_SCOPE_SELECTORS.has(selector));
+}
+//#endregion
+//#region src/compat/mini-program-css/predicates.ts
+const PREFLIGHT_RESET_PROPS = /* @__PURE__ */ new Set([
+	"box-sizing",
+	"border",
+	"border-width",
+	"border-style",
+	"border-color",
+	"margin",
+	"padding"
+]);
+const PSEUDO_CONTENT_SELECTOR_RE = /^(?:::before|::after|:before|:after)(?:,(?:::before|::after|:before|:after))*$/;
+const TW_CONTENT_VAR_RE$1 = /var\(\s*--tw-content\b/;
+const BROWSER_PREFLIGHT_SINGLE_ELEMENT_DECLARATIONS = /* @__PURE__ */ new Map([["button", /* @__PURE__ */ new Set(["appearance:button", "-moz-appearance:button"])], ["textarea", /* @__PURE__ */ new Set(["resize:vertical"])]]);
+function hasTailwindPreflightDeclaration(rule) {
+	let hasTailwindVar = false;
+	let hasResetProp = false;
+	rule.walkDecls((decl) => {
+		if (decl.prop.startsWith("--tw-")) hasTailwindVar = true;
+		if (PREFLIGHT_RESET_PROPS.has(decl.prop)) hasResetProp = true;
+	});
+	return hasTailwindVar || hasResetProp;
+}
+function hasTailwindVariableDeclaration(rule) {
+	let hasTailwindVar = false;
+	rule.walkDecls((decl) => {
+		if (decl.prop.startsWith("--tw-")) hasTailwindVar = true;
+	});
+	return hasTailwindVar;
+}
+function isCustomPropertyRule(rule) {
+	let hasDeclaration = false;
+	let allCustomProperties = true;
+	rule.each((node) => {
+		if (node.type !== "decl") return;
+		hasDeclaration = true;
+		if (!node.prop.startsWith("--")) allCustomProperties = false;
+	});
+	return hasDeclaration && allCustomProperties;
+}
+function isEmptyTwContentDeclaration(decl) {
+	return decl.prop === "--tw-content" && (decl.value === "\"\"" || decl.value === "''");
+}
+function isOnlyTwContentDeclarations(rule) {
+	let hasDeclaration = false;
+	let onlyContentVariable = true;
+	rule.walkDecls((decl) => {
+		hasDeclaration = true;
+		if (decl.prop !== "--tw-content") onlyContentVariable = false;
+	});
+	return hasDeclaration && onlyContentVariable;
+}
+function isPseudoContentInitRule(rule) {
+	const selector = rule.selector.replace(/\s+/g, "");
+	return PSEUDO_CONTENT_SELECTOR_RE.test(selector) && isOnlyTwContentDeclarations(rule);
+}
+function usesTwContentVariable(root) {
+	let used = false;
+	root.walkDecls((decl) => {
+		if (TW_CONTENT_VAR_RE$1.test(decl.value)) used = true;
+	});
+	return used;
+}
+function isMiniProgramPreflightRule(node) {
+	if (node.type !== "rule") return false;
+	const selectors = getRuleSelectors(node);
+	if (!isMiniProgramPreflightSelector(selectors)) return false;
+	if (selectors.includes("*")) return hasTailwindPreflightDeclaration(node);
+	if (hasTailwindVariableDeclaration(node)) return true;
+	return selectors.some((selector) => selector === ":before" || selector === ":after" || selector === "::before" || selector === "::after") && selectors.some((selector) => selector === "view" || selector === "text") && hasTailwindPreflightDeclaration(node);
+}
+function isBrowserElementPreflightRule(node) {
+	if (node.type !== "rule") return false;
+	const selectors = getRuleSelectors(node);
+	if (selectors.length !== 1) return false;
+	const declarations = BROWSER_PREFLIGHT_SINGLE_ELEMENT_DECLARATIONS.get(selectors[0]);
+	if (!declarations) return false;
+	let hasDeclaration = false;
+	let allBrowserPreflightDeclarations = true;
+	node.each((child) => {
+		if (child.type !== "decl") return;
+		hasDeclaration = true;
+		const key = `${child.prop.toLowerCase()}:${child.value.trim().toLowerCase()}`;
+		if (!declarations.has(key)) allBrowserPreflightDeclarations = false;
+	});
+	return hasDeclaration && allBrowserPreflightDeclarations;
+}
+function isMiniProgramThemeVariableRule(node) {
+	if (node.type !== "rule") return false;
+	return isMiniProgramThemeScopeSelector(getRuleSelectors(node)) && isCustomPropertyRule(node);
+}
+//#endregion
+//#region src/compat/mini-program-css/directives.ts
+const TAILWIND_V4_BANNER_RE = /\/\*!\s*tailwindcss v4\./;
+const GENERATOR_PLACEHOLDER_COMMENT_RE = /^\s*(?:!\s*)?weapp-tailwindcss generator-placeholder\s*$/i;
+function isCssWhitespace$1(code) {
+	return code === 9 || code === 10 || code === 12 || code === 13 || code === 32;
+}
+function skipCssWhitespace$1(css, start) {
+	let index = start;
+	while (index < css.length && isCssWhitespace$1(css.charCodeAt(index))) index++;
+	return index;
+}
+function findClosingParenthesis(css, openingIndex) {
+	let depth = 0;
+	let quote = 0;
+	for (let index = openingIndex; index < css.length; index++) {
+		const code = css.charCodeAt(index);
+		if (quote !== 0) {
+			if (code === 92) index++;
+			else if (code === quote) quote = 0;
+			continue;
+		}
+		if (code === 34 || code === 39) {
+			quote = code;
+			continue;
+		}
+		if (code === 92) {
+			index++;
+			continue;
+		}
+		if (code === 47 && css.charCodeAt(index + 1) === 42) {
+			const commentEnd = css.indexOf("*/", index + 2);
+			if (commentEnd < 0) return -1;
+			index = commentEnd + 1;
+			continue;
+		}
+		if (code === 40) {
+			depth++;
+			continue;
+		}
+		if (code === 41) {
+			depth--;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+function isCssCodePosition(css, position) {
+	let quote = 0;
+	for (let index = 0; index < position; index++) {
+		const code = css.charCodeAt(index);
+		if (quote !== 0) {
+			if (code === 92) index++;
+			else if (code === quote) quote = 0;
+			continue;
+		}
+		if (code === 34 || code === 39) {
+			quote = code;
+			continue;
+		}
+		if (code === 47 && css.charCodeAt(index + 1) === 42) {
+			const commentEnd = css.indexOf("*/", index + 2);
+			if (commentEnd < 0 || commentEnd >= position) return false;
+			index = commentEnd + 1;
+		}
+	}
+	return quote === 0;
+}
+/**
+* 严格移除文件末尾残留的 Tailwind source media 开始标记。
+* 仅处理可确认属于 Tailwind 的尾部残片，其它非法 CSS 保持原样。
+*/
+function repairTrailingUnclosedTailwindSourceMedia(css) {
+	const sourceMediaPattern = /(?:^|\r?\n)[\t\f ]*@media\s+source\(/g;
+	for (let match = sourceMediaPattern.exec(css); match !== null; match = sourceMediaPattern.exec(css)) {
+		const prefixLength = match[0].startsWith("\n") ? 1 : match[0].startsWith("\r\n") ? 2 : 0;
+		const start = match.index + prefixLength;
+		if (!isCssCodePosition(css, start)) continue;
+		const closingIndex = findClosingParenthesis(css, start + match[0].length - prefixLength - 1);
+		if (closingIndex < 0) continue;
+		const blockStart = skipCssWhitespace$1(css, closingIndex + 1);
+		if (css.charCodeAt(blockStart) !== 123) continue;
+		if (skipCssWhitespace$1(css, blockStart + 1) !== css.length) continue;
+		return css.slice(0, match.index);
+	}
+	return css;
+}
+function hasTailwindcssV4Signal(css) {
+	if (TAILWIND_V4_BANNER_RE.test(css)) return true;
+	const root = postcss.default.parse(css);
+	let hasProperty = false;
+	root.walkAtRules("property", (atRule) => {
+		if (atRule.params.trim().startsWith("--tw-")) {
+			hasProperty = true;
+			return false;
+		}
+	});
+	return hasProperty;
+}
+function unwrapTailwindSourceMedia(root) {
+	root.walkAtRules("media", (atRule) => {
+		if (!atRule.params.startsWith("source(")) return;
+		if (atRule.nodes && atRule.nodes.length > 0) atRule.replaceWith(...atRule.nodes);
+		else atRule.remove();
+	});
+}
+function removeTailwindGenerationDirectives(root) {
+	root.walkComments((comment) => {
+		if (GENERATOR_PLACEHOLDER_COMMENT_RE.test(comment.text)) comment.remove();
+	});
+	root.walkAtRules((atRule) => {
+		if (atRule.name === "config" || atRule.name === "source" || atRule.name === "tailwind" || atRule.name === "reference" || atRule.name === "plugin") atRule.remove();
+	});
+}
+const MODERN_COLOR_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+	"oklch",
+	"oklab",
+	"lch",
+	"lab"
+]);
+const MODERN_COLOR_SYNTAX_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+	"rgb",
+	"rgba",
+	"hsl",
+	"hsla",
+	"hwb"
+]);
+const PLACEHOLDER_PREFIX = "__weapp_tw_color_mix_";
+const DYNAMIC_ALPHA_RE = /\b(?:var|env)\(|--[\w-]+\b/;
+const INTERNAL_TAILWIND_ALPHA_RE = /var\(\s*--tw-[^)]+-alpha\s*\)/;
+const TRANSPARENT_COLOR_RE = /^transparent$/i;
+const CURRENT_COLOR_RE = /^currentcolor$/i;
+const CSS_WIDE_KEYWORD_RE = /^(?:inherit|initial|unset|revert|revert-layer)$/i;
+const CUSTOM_PROPERTY_RE = /^--[\w-]+$/;
+//#endregion
+//#region src/compat/color-mix/modern.ts
+function isDisplayP3ColorFunction(colorSource) {
+	return /^color\(\s*display-p3\b/i.test(colorSource.trim());
+}
+function isModernColorSyntaxFunction(colorSource) {
+	const parsed = (0, postcss_value_parser.default)(colorSource.trim());
+	const node = parsed.nodes.length === 1 ? parsed.nodes[0] : void 0;
+	if (node?.type !== "function") return false;
+	const name = node.value.toLowerCase();
+	if (!MODERN_COLOR_SYNTAX_FUNCTION_NAMES.has(name)) return false;
+	return !node.nodes.some((child) => child.type === "div" && child.value === ",");
+}
+function hasUnsupportedModernColorFunction(value) {
+	const parsed = (0, postcss_value_parser.default)(value);
+	let hasUnsupported = false;
+	parsed.walk((node) => {
+		if (node.type !== "function") return;
+		const name = node.value.toLowerCase();
+		if (name === "color-mix" || MODERN_COLOR_FUNCTION_NAMES.has(name) || name === "color" && isDisplayP3ColorFunction(postcss_value_parser.default.stringify(node)) || isModernColorSyntaxFunction(postcss_value_parser.default.stringify(node))) {
+			hasUnsupported = true;
+			return false;
+		}
+	});
+	return hasUnsupported;
+}
+//#endregion
+//#region src/compat/color-mix/parse.ts
+function splitArguments(nodes) {
+	const args = [];
+	let current = [];
+	for (const node of nodes) {
+		if (node.type === "div" && node.value === ",") {
+			args.push(current);
+			current = [];
+			continue;
+		}
+		current.push(node);
+	}
+	args.push(current);
+	return args;
+}
+function splitStopSegments(nodes) {
+	const segments = [];
+	let current = [];
+	for (const node of nodes) {
+		if (node.type === "space") {
+			if (current.length > 0) {
+				segments.push(current);
+				current = [];
+			}
+			continue;
+		}
+		current.push(node);
+	}
+	if (current.length > 0) segments.push(current);
+	return segments;
+}
+function trimNodes(nodes) {
+	let start = 0;
+	let end = nodes.length;
+	while (start < end && nodes[start]?.type === "space") start += 1;
+	while (end > start && nodes[end - 1]?.type === "space") end -= 1;
+	return nodes.slice(start, end);
+}
+function getParsedColorData(colorSource) {
+	try {
+		const parsed = (0, _csstools_css_parser_algorithms.parseComponentValue)((0, _csstools_css_tokenizer.tokenize)({ css: colorSource }));
+		return (0, _csstools_css_color_parser.color)(parsed);
+	} catch {
+		return false;
+	}
+}
+function parseAlphaValue(alphaSource) {
+	const parsed = Number.parseFloat(alphaSource);
+	if (Number.isFinite(parsed)) return alphaSource.trim().endsWith("%") ? parsed / 100 : parsed;
+}
+function resolveVarColor(colorSource, customPropertyValues, depth = 0) {
+	if (depth > 5) return;
+	const parsed = (0, postcss_value_parser.default)(colorSource.trim());
+	const node = parsed.nodes.length === 1 ? parsed.nodes[0] : void 0;
+	if (node?.type !== "function" || node.value.toLowerCase() !== "var") return;
+	const args = splitArguments(node.nodes);
+	const propertyName = postcss_value_parser.default.stringify(trimNodes(args[0] ?? [])).trim();
+	if (!CUSTOM_PROPERTY_RE.test(propertyName)) return;
+	const resolved = customPropertyValues.get(propertyName);
+	if (!resolved) {
+		const fallback = args[1] ? postcss_value_parser.default.stringify(trimNodes(args[1])).trim() : void 0;
+		return fallback ? resolveColorData(fallback, customPropertyValues, depth + 1) : void 0;
+	}
+	return resolveColorData(resolved, customPropertyValues, depth + 1);
+}
+function resolveColorData(colorSource, customPropertyValues, depth = 0) {
+	if (typeof colorSource !== "string") return;
+	const trimmed = colorSource.trim();
+	if (TRANSPARENT_COLOR_RE.test(trimmed)) return getParsedColorData(trimmed) || void 0;
+	if (CURRENT_COLOR_RE.test(trimmed) || CSS_WIDE_KEYWORD_RE.test(trimmed)) return;
+	const resolvedVar = resolveVarColor(trimmed, customPropertyValues, depth);
+	if (resolvedVar) return resolvedVar;
+	return getParsedColorData(trimmed) || void 0;
+}
+function normalizeColorFunctionName(colorSource, alpha, customPropertyValues) {
+	const resolvedColor = resolveColorData(colorSource, customPropertyValues);
+	if (!resolvedColor) return;
+	resolvedColor.alpha = alpha;
+	return (0, _csstools_css_color_parser.serializeRGB)(resolvedColor).toString();
+}
+function normalizeColorFunctionWithDynamicAlpha(colorSource, alphaSource, customPropertyValues) {
+	const resolvedColor = resolveColorData(colorSource, customPropertyValues);
+	const alphaColor = getParsedColorData(`rgb(0 0 0 / ${alphaSource})`);
+	if (!resolvedColor || !alphaColor || typeof alphaColor.alpha === "number") return;
+	resolvedColor.alpha = alphaColor.alpha;
+	return (0, _csstools_css_color_parser.serializeRGB)(resolvedColor).toString();
+}
+function normalizeStandaloneColorFunction(colorSource) {
+	const resolvedColor = getParsedColorData(colorSource);
+	return resolvedColor ? (0, _csstools_css_color_parser.serializeRGB)(resolvedColor).toString() : void 0;
+}
+//#endregion
+//#region src/compat/color-mix/resolve.ts
+function createRgbaWithAlpha(colorSource, alphaSource, customPropertyValues) {
+	const alpha = alphaSource.trim();
+	return normalizeColorFunctionWithDynamicAlpha(colorSource, CUSTOM_PROPERTY_RE.test(alpha) ? `var(${alpha})` : alpha, customPropertyValues);
+}
+function tryResolveColorMix(node, customPropertyValues) {
+	const args = splitArguments(node.nodes);
+	if (args.length < 3) return;
+	const colorStopNodes = splitStopSegments(args[1] ?? []);
+	if (colorStopNodes.length < 2) return;
+	const colorNodes = trimNodes(colorStopNodes[0] ?? []);
+	const alphaNodes = trimNodes(colorStopNodes[1] ?? []);
+	const trailingNodes = trimNodes(args[2] ?? []);
+	if (!colorNodes.length || !alphaNodes.length || postcss_value_parser.default.stringify(trailingNodes).trim().toLowerCase() !== "transparent") return;
+	const colorSource = postcss_value_parser.default.stringify(colorNodes).trim();
+	const alphaSource = postcss_value_parser.default.stringify(alphaNodes).trim();
+	if (!colorSource || !alphaSource || INTERNAL_TAILWIND_ALPHA_RE.test(alphaSource)) return;
+	if (CURRENT_COLOR_RE.test(colorSource)) return {
+		value: colorSource,
+		deferred: false
+	};
+	if (DYNAMIC_ALPHA_RE.test(alphaSource)) {
+		const normalized = createRgbaWithAlpha(colorSource, alphaSource, customPropertyValues);
+		return normalized ? {
+			value: normalized,
+			deferred: true
+		} : {
+			value: colorSource,
+			deferred: true
+		};
+	}
+	const alpha = parseAlphaValue(alphaSource);
+	if (alpha === void 0) return;
+	const normalized = normalizeColorFunctionName(colorSource, alpha, customPropertyValues);
+	if (normalized) return {
+		value: normalized,
+		deferred: false
+	};
+	return {
+		value: colorSource,
+		deferred: false
+	};
+}
+//#endregion
+//#region src/cssVarsV4.ts
+function property(ident, initialValue, _syntax) {
+	return {
+		prop: ident,
+		value: initialValue || ""
+	};
+}
+const nullShadow = "0 0 #0000";
+const nodes = [
+	property("--tw-border-spacing-x", "0", "<length>"),
+	property("--tw-border-spacing-y", "0", "<length>"),
+	property("--tw-translate-x", "0"),
+	property("--tw-translate-y", "0"),
+	property("--tw-translate-z", "0"),
+	property("--tw-scale-x", "1"),
+	property("--tw-scale-y", "1"),
+	property("--tw-scale-z", "1"),
+	property("--tw-rotate-x"),
+	property("--tw-rotate-y"),
+	property("--tw-rotate-z"),
+	property("--tw-skew-x"),
+	property("--tw-skew-y"),
+	property("--tw-pan-x"),
+	property("--tw-pan-y"),
+	property("--tw-pinch-zoom"),
+	property("--tw-scroll-snap-strictness", "proximity", "*"),
+	property("--tw-space-x-reverse", "0"),
+	property("--tw-space-y-reverse", "0"),
+	property("--tw-scrollbar-thumb", "#0000", "<color>"),
+	property("--tw-scrollbar-track", "#0000", "<color>"),
+	property("--tw-border-style", "solid"),
+	property("--tw-divide-x-reverse", "0"),
+	property("--tw-divide-y-reverse", "0"),
+	property("--tw-gradient-position", "initial"),
+	property("--tw-gradient-from", "#0000", "<color>"),
+	property("--tw-gradient-via", "#0000", "<color>"),
+	property("--tw-gradient-to", "#0000", "<color>"),
+	property("--tw-gradient-stops", "initial"),
+	property("--tw-gradient-via-stops", "initial"),
+	property("--tw-gradient-from-position", "0%", "<length-percentage>"),
+	property("--tw-gradient-via-position", "50%", "<length-percentage>"),
+	property("--tw-gradient-to-position", "100%", "<length-percentage>"),
+	property("--tw-mask-linear", "linear-gradient(#fff, #fff)"),
+	property("--tw-mask-radial", "linear-gradient(#fff, #fff)"),
+	property("--tw-mask-conic", "linear-gradient(#fff, #fff)"),
+	property("--tw-mask-left", "linear-gradient(#fff, #fff)"),
+	property("--tw-mask-right", "linear-gradient(#fff, #fff)"),
+	property("--tw-mask-bottom", "linear-gradient(#fff, #fff)"),
+	property("--tw-mask-top", "linear-gradient(#fff, #fff)"),
+	property("--tw-mask-linear-position", "0deg"),
+	property("--tw-mask-linear-from-position", "0%"),
+	property("--tw-mask-linear-to-position", "100%"),
+	property("--tw-mask-linear-from-color", "black"),
+	property("--tw-mask-linear-to-color", "transparent"),
+	property("--tw-mask-radial-from-position", "0%"),
+	property("--tw-mask-radial-to-position", "100%"),
+	property("--tw-mask-radial-from-color", "black"),
+	property("--tw-mask-radial-to-color", "transparent"),
+	property("--tw-mask-radial-shape", "ellipse"),
+	property("--tw-mask-radial-size", "farthest-corner"),
+	property("--tw-mask-radial-position", "center"),
+	property("--tw-mask-conic-position", "0deg"),
+	property("--tw-mask-conic-from-position", "0%"),
+	property("--tw-mask-conic-to-position", "100%"),
+	property("--tw-mask-conic-from-color", "black"),
+	property("--tw-mask-conic-to-color", "transparent"),
+	property("--tw-font-weight"),
+	property("--tw-blur"),
+	property("--tw-brightness"),
+	property("--tw-contrast"),
+	property("--tw-grayscale"),
+	property("--tw-hue-rotate"),
+	property("--tw-invert"),
+	property("--tw-opacity"),
+	property("--tw-saturate"),
+	property("--tw-sepia"),
+	property("--tw-drop-shadow"),
+	property("--tw-drop-shadow-color"),
+	property("--tw-drop-shadow-alpha", "100%", "<percentage>"),
+	property("--tw-drop-shadow-size"),
+	property("--tw-backdrop-blur"),
+	property("--tw-backdrop-brightness"),
+	property("--tw-backdrop-contrast"),
+	property("--tw-backdrop-grayscale"),
+	property("--tw-backdrop-hue-rotate"),
+	property("--tw-backdrop-invert"),
+	property("--tw-backdrop-opacity"),
+	property("--tw-backdrop-saturate"),
+	property("--tw-backdrop-sepia"),
+	property("--tw-duration", "initial"),
+	property("--tw-ease", "initial"),
+	property("--tw-content", "\"\""),
+	property("--tw-contain-size"),
+	property("--tw-contain-layout"),
+	property("--tw-contain-paint"),
+	property("--tw-contain-style"),
+	property("--tw-leading"),
+	property("--tw-tracking"),
+	property("--tw-ordinal"),
+	property("--tw-slashed-zero"),
+	property("--tw-numeric-figure"),
+	property("--tw-numeric-spacing"),
+	property("--tw-numeric-fraction"),
+	property("--tw-outline-style", "solid"),
+	property("--tw-text-shadow-color", "initial"),
+	property("--tw-text-shadow-alpha", "100%", "<percentage>"),
+	property("--tw-shadow", nullShadow),
+	property("--tw-shadow-color", "initial"),
+	property("--tw-shadow-alpha", "100%", "<percentage>"),
+	property("--tw-inset-shadow", nullShadow),
+	property("--tw-inset-shadow-color", "initial"),
+	property("--tw-inset-shadow-alpha", "100%", "<percentage>"),
+	property("--tw-ring-color"),
+	property("--tw-ring-shadow", nullShadow),
+	property("--tw-inset-ring-color"),
+	property("--tw-inset-ring-shadow", nullShadow),
+	property("--tw-ring-inset"),
+	property("--tw-ring-offset-width", "0px", "<length>"),
+	property("--tw-ring-offset-color", "#fff"),
+	property("--tw-ring-offset-shadow", nullShadow)
+];
+for (const edge of [
+	"top",
+	"right",
+	"bottom",
+	"left"
+]) nodes.push(property(`--tw-mask-${edge}-from-position`, "0%"), property(`--tw-mask-${edge}-to-position`, "100%"), property(`--tw-mask-${edge}-from-color`, "black"), property(`--tw-mask-${edge}-to-color`, "transparent"));
+//#endregion
+//#region src/utils/css-vars.ts
+/**
+* 将 CSS 变量定义转换为可直接插入的 Declaration 节点列表。
+*/
+function createCssVarNodes(definitions) {
+	return definitions.map((def) => new postcss.Declaration({
+		prop: def.prop,
+		value: def.value
+	}));
+}
+const CLAMP_PX = 9999;
+const INFINITY_CALC_VALUE_REGEXP = /^calc\(\s*infinity\s*\*\s*(\d+(?:\.\d*)?|\.\d+)r?px\s*\)$/i;
+const MODERN_CHECK_WEBKIT_HYPHENS_RE = /-webkit-hyphens\s*:\s*none/;
+const MODERN_CHECK_MARGIN_TRIM_RE = /margin-trim\s*:\s*inline/;
+const MODERN_CHECK_MOZ_ORIENT_RE = /-moz-orient\s*:\s*inline/;
+const MODERN_CHECK_COLOR_RGB_RE = /color\s*:\s*rgb\(\s*from\s+red\s+r\s+g\s+b\s*\)/;
+const LINEAR_GRADIENT_LAB_RE = /background-image\s*:\s*linear-gradient\(\s*in\s+lab\s*,\s*red\s*,\s*red\s*\)/;
+const DISPLAY_P3_COLOR_RE = /color\s*:\s*color\(\s*display-p3\s+0\s+0\s+0%\s*\)/;
+const DISPLAY_P3_VALUE_RE$1 = /color\(\s*display-p3\b/i;
+const COLOR_GAMUT_P3_RE$1 = /\(\s*color-gamut\s*:\s*p3\s*\)/i;
+const GRADIENT_BACKGROUND_RE = /^(linear|radial|conic)-gradient\(/i;
+const GRADIENT_STOPS_VAR_RE = /^(?:linear|radial|conic)-gradient\(\s*var\(\s*--tw-gradient-stops\b/i;
+const SIMPLE_CLASS_SELECTOR_RE = /^\.([_a-z\u00A0-\uFFFF\\-][\w\u00A0-\uFFFF\\-]*)$/i;
+const COLOR_VAR_RE = /^var\(\s*(--color-[\w-]+)\s*\)$/i;
+const TAILWIND_THEME_VARIABLE_RE = /^--(?:animate|aspect|blur|breakpoint|color|container|drop-shadow|ease|font|inset-shadow|leading|perspective|radius|shadow|spacing|text|tracking)(?:-|$)/;
+const GRADIENT_DIRECTION_CLASS_RE = /^(?:-?bg-linear|bg-gradient-to-|-?bg-conic|bg-radial)/;
+const RADIUS_VALUE_RE = /\b([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\s*(r?px)\b/gi;
+const SCIENTIFIC_NOTATION_RE = /e/i;
+const TW_VAR_FUNCTION_RE = /var\(\s*(--tw-[\w-]+)\b/g;
+const TW_CONTENT_VAR_RE = /var\(\s*--tw-content\b/;
+const TW_GRADIENT_POSITION_PROPS = /* @__PURE__ */ new Set([
+	"--tw-gradient-from-position",
+	"--tw-gradient-via-position",
+	"--tw-gradient-to-position"
+]);
+const UNSUPPORTED_CUSTOM_PROPERTY_DEFAULT_PROPS = /* @__PURE__ */ new Set(["--tw-gradient-via-stops"]);
+const DEFAULT_VARIABLE_SCOPE_SELECTORS = /* @__PURE__ */ new Set([
+	"*",
+	"view",
+	"text",
+	":before",
+	":after",
+	"::before",
+	"::after",
+	"::backdrop"
+]);
+function isTailwindcssV4(options) {
+	return options?.majorVersion === 4;
+}
+function isTailwindcssV4ThemeVariable(property) {
+	return property.startsWith("--tw-") || TAILWIND_THEME_VARIABLE_RE.test(property);
+}
+function testIfRootHostForV4(node) {
+	return node.type === "rule" && node.selector.includes(":root") && node.selector.includes(":host");
+}
+createCssVarNodes(nodes);
+function collectUsedTailwindcssV4Variables(root) {
+	const props = /* @__PURE__ */ new Set();
+	root.walkDecls((decl) => {
+		if (decl.prop.startsWith("--tw-")) props.add(decl.prop);
+		TW_VAR_FUNCTION_RE.lastIndex = 0;
+		let match = TW_VAR_FUNCTION_RE.exec(decl.value);
+		while (match !== null) {
+			const prop = match[1];
+			if (prop) props.add(prop);
+			match = TW_VAR_FUNCTION_RE.exec(decl.value);
+		}
+	});
+	root.walkAtRules("property", (atRule) => {
+		const prop = atRule.params.trim();
+		if (prop.startsWith("--tw-")) props.add(prop);
+	});
+	return props;
+}
+function usesTailwindcssV4ContentVariable(root) {
+	let used = false;
+	root.walkDecls((decl) => {
+		if (TW_CONTENT_VAR_RE.test(decl.value)) used = true;
+	});
+	return used;
+}
+function createUsedCssVarsV4Nodes(usedProps) {
+	return nodes.filter((def) => usedProps.has(def.prop) && !UNSUPPORTED_CUSTOM_PROPERTY_DEFAULT_PROPS.has(def.prop)).map((def) => new postcss.Declaration({
+		prop: def.prop,
+		value: def.value
+	}));
+}
+function isInsideAtRule(decl, name) {
+	let parent = decl.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name === name) return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+function isDefaultVariableScopeRule(rule) {
+	const selectors = rule.selectors.map((selector) => selector.trim());
+	if (!selectors.every((selector) => DEFAULT_VARIABLE_SCOPE_SELECTORS.has(selector))) return false;
+	if (!selectors.some((selector) => selector === "*" || selector === "view" || selector === "text")) return false;
+	let hasDeclaration = false;
+	let onlyCustomProperties = true;
+	rule.each((node) => {
+		if (node.type !== "decl") return;
+		hasDeclaration = true;
+		if (!node.prop.startsWith("--")) onlyCustomProperties = false;
+	});
+	return hasDeclaration && onlyCustomProperties;
+}
+function collectScopedTailwindcssV4DefaultVariables(root) {
+	const props = /* @__PURE__ */ new Set();
+	root.walkDecls((decl) => {
+		if (!decl.prop.startsWith("--tw-")) return;
+		if (isInsideAtRule(decl, "supports")) return;
+		if (decl.parent?.type === "rule" && isDefaultVariableScopeRule(decl.parent)) props.add(decl.prop);
+	});
+	return props;
+}
+function createMissingCssVarsV4Nodes(root, usedProps) {
+	const scopedProps = collectScopedTailwindcssV4DefaultVariables(root);
+	return nodes.filter((def) => usedProps.has(def.prop) && !scopedProps.has(def.prop) && !UNSUPPORTED_CUSTOM_PROPERTY_DEFAULT_PROPS.has(def.prop)).map((def) => new postcss.Declaration({
+		prop: def.prop,
+		value: def.value
+	}));
+}
+//#endregion
+//#region src/compat/color-mix.ts
+const DYNAMIC_VAR_FALLBACK_PLACEHOLDER_PREFIX = "__weapp_tw_var_fallback_";
+function getStandaloneDynamicVarWithFallback(value) {
+	const nodes = (0, postcss_value_parser.default)(value).nodes.filter((node) => node.type !== "space" && node.type !== "comment");
+	const variable = nodes.length === 1 ? nodes[0] : void 0;
+	const property = variable?.type === "function" ? variable.nodes.find((node) => node.type === "word" && node.value.startsWith("--")) : void 0;
+	if (variable?.type !== "function" || variable.value.toLowerCase() !== "var" || property?.type !== "word" || isTailwindcssV4ThemeVariable(property.value) || !variable.nodes.some((node) => node.type === "div" && node.value === ",")) return;
+	return variable;
+}
+/**
+* 保护带 fallback 的作者 CSS 变量，避免兼容插件把它错误静态化。
+*/
+function protectDynamicVarFallbacks(css) {
+	if (!css.includes("var(") || !css.includes(",")) return {
+		css,
+		restore: (value) => value
+	};
+	const replacements = /* @__PURE__ */ new Map();
+	let root;
+	try {
+		root = postcss.default.parse(css);
+	} catch {
+		return {
+			css,
+			restore: (value) => value
+		};
+	}
+	root.walkDecls((decl) => {
+		if (!getStandaloneDynamicVarWithFallback(decl.value)) return;
+		const placeholder = `${DYNAMIC_VAR_FALLBACK_PLACEHOLDER_PREFIX}${replacements.size}__`;
+		replacements.set(placeholder, decl.value);
+		decl.value = placeholder;
+	});
+	if (replacements.size === 0) return {
+		css,
+		restore: (value) => value
+	};
+	return {
+		css: root.toString(),
+		restore(value) {
+			let restored = value;
+			for (const [placeholder, replacement] of replacements) restored = restored.split(placeholder).join(replacement);
+			return restored;
+		}
+	};
+}
+function normalizeModernColorValue(value, customPropertyValues = /* @__PURE__ */ new Map()) {
+	if (!hasUnsupportedModernColorFunction(value)) return {
+		value,
+		changed: false,
+		hasUnsupported: false
+	};
+	const parsed = (0, postcss_value_parser.default)(value);
+	let changed = false;
+	parsed.walk((node) => {
+		if (node.type !== "function") return;
+		const name = node.value.toLowerCase();
+		const source = postcss_value_parser.default.stringify(node);
+		let normalized;
+		if (MODERN_COLOR_FUNCTION_NAMES.has(name) || name === "color" && isDisplayP3ColorFunction(source) || isModernColorSyntaxFunction(source)) normalized = normalizeStandaloneColorFunction(source);
+		else if (name === "color-mix") normalized = tryResolveColorMix(node, customPropertyValues)?.value;
+		if (!normalized) return;
+		const mutableNode = node;
+		mutableNode.type = "word";
+		mutableNode.value = normalized;
+		delete mutableNode.nodes;
+		changed = true;
+	});
+	const nextValue = changed ? parsed.toString() : value;
+	return {
+		value: nextValue,
+		changed,
+		hasUnsupported: hasUnsupportedModernColorFunction(nextValue)
+	};
+}
+function createPlaceholder(index) {
+	return `${PLACEHOLDER_PREFIX}${index}__`;
+}
+function unwrapProtectedSupports(cssRoot) {
+	cssRoot.walkAtRules("supports", (atRule) => {
+		if (!atRule.nodes || !atRule.toString().includes("__weapp_tw_color_mix_")) return;
+		atRule.replaceWith(atRule.nodes);
+	});
+}
+function protectDynamicColorMixAlpha(css, options = {}) {
+	if (!css.includes("color-mix")) return {
+		css,
+		restore: (value) => value
+	};
+	const replacements = /* @__PURE__ */ new Map();
+	const root = postcss.default.parse(css);
+	const customPropertyValues = new Map(options.customPropertyValues);
+	let changed = false;
+	root.walkDecls((decl) => {
+		if (decl.prop.startsWith("--") && !decl.value.includes("color-mix")) customPropertyValues.set(decl.prop, decl.value.trim());
+	});
+	root.walkDecls((decl) => {
+		if (!decl.value.includes("color-mix")) return;
+		const parsed = (0, postcss_value_parser.default)(decl.value);
+		let mutated = false;
+		parsed.walk((node) => {
+			if (node.type !== "function" || node.value.toLowerCase() !== "color-mix") return;
+			const resolved = tryResolveColorMix(node, customPropertyValues);
+			if (resolved) {
+				if (resolved.deferred) {
+					const placeholder = createPlaceholder(replacements.size);
+					replacements.set(placeholder, resolved.value);
+					const mutableNode = node;
+					mutableNode.type = "word";
+					mutableNode.value = placeholder;
+					delete mutableNode.nodes;
+					mutated = true;
+					return;
+				}
+				const mutableNode = node;
+				mutableNode.type = "word";
+				mutableNode.value = resolved.value;
+				delete mutableNode.nodes;
+				mutated = true;
+			}
+		});
+		if (mutated) {
+			decl.value = parsed.toString();
+			changed = true;
+		}
+	});
+	if (replacements.size > 0) unwrapProtectedSupports(root);
+	return {
+		css: changed ? root.toString() : css,
+		restore(value) {
+			let restored = value;
+			for (const [placeholder, replacement] of replacements) restored = restored.split(placeholder).join(replacement);
+			return restored;
+		}
+	};
+}
+//#endregion
+//#region src/compat/mini-program-css/color-gamut.ts
+const DISPLAY_P3_VALUE_RE = /color\(\s*display-p3\b/i;
+const COLOR_GAMUT_P3_RE = /\(\s*color-gamut\s*:\s*p3\s*\)/i;
+function isDisplayP3MediaRule(atRule) {
+	return atRule.name === "media" && COLOR_GAMUT_P3_RE.test(atRule.params);
+}
+function isDisplayP3Declaration(decl) {
+	return DISPLAY_P3_VALUE_RE.test(decl.value);
+}
+//#endregion
+//#region src/compat/mini-program-css/root-cleanups.ts
+function removeSpecificityPlaceholders(root) {
+	root.walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) return;
+		let changed = false;
+		const selectors = rule.selectors.map((selector) => {
+			let next = selector;
+			for (const suffix of SPECIFICITY_PLACEHOLDER_SUFFIXES) if (next.includes(suffix)) next = next.split(suffix).join("");
+			if (next !== selector) changed = true;
+			return next;
+		});
+		if (changed) rule.selectors = selectors;
+	});
+}
+function hasMiniProgramCssSpecificityPlaceholders(source) {
+	return SPECIFICITY_PLACEHOLDER_SUFFIXES.some((suffix) => source.includes(suffix));
+}
+function stripMiniProgramCssSpecificityPlaceholders(source) {
+	let output = source;
+	for (const suffix of SPECIFICITY_PLACEHOLDER_SUFFIXES) if (output.includes(suffix)) output = output.split(suffix).join("");
+	return output;
+}
+const removeSpecificityPlaceholdersFromSource = stripMiniProgramCssSpecificityPlaceholders;
+function removeRootSpecificityPlaceholders(root) {
+	root.walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) return;
+		let changed = false;
+		const selectors = rule.selectors.map((selector) => {
+			let next = selector;
+			for (const scopeSelector of MINI_PROGRAM_THEME_SCOPE_SELECTORS) for (const suffix of ROOT_SPECIFICITY_PLACEHOLDER_SUFFIXES) {
+				const target = `${scopeSelector}${suffix}`;
+				if (next.includes(target)) next = next.split(target).join(scopeSelector);
+			}
+			if (next !== selector) changed = true;
+			return next;
+		});
+		if (changed) rule.selectors = selectors;
+	});
+}
+function isEffectivelyEmptyContainer(container) {
+	return container.nodes !== void 0 && container.nodes.every((node) => node.type === "comment");
+}
+function isKeyframeStepRule(rule) {
+	return rule.parent?.type === "atrule" && rule.parent.name.toLowerCase().endsWith("keyframes");
+}
+function removeEmptyAtRules$1(root) {
+	let removed = 0;
+	const visit = (container) => {
+		for (const node of [...container.nodes ?? []]) {
+			if (!("nodes" in node) || node.nodes === void 0) continue;
+			visit(node);
+			if (node.type === "atrule" && node.parent && isEffectivelyEmptyContainer(node)) {
+				node.remove();
+				removed++;
+			}
+		}
+	};
+	visit(root);
+	return removed;
+}
+function removeEmptyBlockAtRules(root) {
+	let removed = 0;
+	root.walkAtRules((atRule) => {
+		if (atRule.nodes?.length === 0) {
+			atRule.remove();
+			removed++;
+		}
+	});
+	return removed;
+}
+function removeEmptyAtRuleAncestors(parent) {
+	while (parent?.type === "atrule" && isEffectivelyEmptyContainer(parent)) {
+		const nextParent = parent.parent;
+		parent.remove();
+		parent = nextParent?.type === "atrule" ? nextParent : void 0;
+	}
+}
+function removeEmptyRules(root) {
+	let removed = 0;
+	root.walkRules((rule) => {
+		if (isKeyframeStepRule(rule) || !rule.parent || !isEffectivelyEmptyContainer(rule)) return;
+		const parent = rule.parent;
+		rule.remove();
+		removeEmptyAtRuleAncestors(parent);
+		removed++;
+	});
+	return removed;
+}
+function removeUnsupportedBrowserSelectors(root) {
+	root.walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) return;
+		if (isUnsupportedBrowserPreflightSelector(rule.selector)) {
+			const parent = rule.parent;
+			rule.remove();
+			removeEmptyAtRuleAncestors(parent);
+			return;
+		}
+		if (isBrowserElementPreflightRule(rule)) {
+			const parent = rule.parent;
+			rule.remove();
+			removeEmptyAtRuleAncestors(parent);
+			return;
+		}
+		const selectors = rule.selectors.filter((selector) => !isUnsupportedBrowserSelector(selector));
+		if (selectors.length === rule.selectors.length) return;
+		if (selectors.length === 0) {
+			const parent = rule.parent;
+			rule.remove();
+			removeEmptyAtRuleAncestors(parent);
+			return;
+		}
+		rule.selectors = selectors;
+	});
+}
+function removeDeclarationAndEmptyRule(decl) {
+	const parent = decl.parent;
+	decl.remove();
+	if (parent?.type === "rule" && parent.nodes.length === 0) {
+		const ruleParent = parent.parent;
+		parent.remove();
+		removeEmptyAtRuleAncestors(ruleParent);
+	}
+}
+function removeEmptyStandardDeclarations(root) {
+	root.walkDecls((decl) => {
+		if (!decl.prop.startsWith("--") && decl.value.trim().length === 0 && decl.next()?.type !== "comment") removeDeclarationAndEmptyRule(decl);
+	});
+}
+function removeDisplayP3Declarations(root) {
+	root.walkAtRules((atRule) => {
+		if (isDisplayP3MediaRule(atRule)) {
+			const parent = atRule.parent;
+			atRule.remove();
+			removeEmptyAtRuleAncestors(parent);
+		}
+	});
+}
+const SIMPLE_MIN_WIDTH_MEDIA_RE = /^\(\s*min-width\s*:[^)]+\)$/i;
+const TAILWIND_GENERATED_TOKEN_COMMENT_RE = /^\s*tokens:\s*container\s*<=\s*<tailwind generated>\s*$/i;
+function isContainerMaxWidthOnlyRule(rule) {
+	if (!rule.selectors || rule.selectors.length !== 1 || rule.selectors[0] !== ".container") return false;
+	const declarations = rule.nodes?.filter((node) => node.type === "decl") ?? [];
+	return declarations.length === 1 && declarations[0]?.prop === "max-width" && (rule.nodes ?? []).every((node) => node.type === "decl" || node.type === "comment");
+}
+function removeTailwindContainerMaxWidthMediaRules(root) {
+	root.walkAtRules("media", (atRule) => {
+		if (!SIMPLE_MIN_WIDTH_MEDIA_RE.test(atRule.params.trim())) return;
+		atRule.walkRules((rule) => {
+			if (!isContainerMaxWidthOnlyRule(rule)) return;
+			const parent = rule.parent;
+			rule.remove();
+			removeEmptyAtRuleAncestors(parent);
+		});
+	});
+}
+function isContainerWidthOnlyRule(rule) {
+	if (!rule.selectors || rule.selectors.length !== 1 || rule.selectors[0] !== ".container") return false;
+	const declarations = rule.nodes?.filter((node) => node.type === "decl") ?? [];
+	return declarations.length === 1 && declarations[0]?.prop === "width" && declarations[0].value.trim() === "100%" && (rule.nodes ?? []).every((node) => node.type === "decl" || node.type === "comment");
+}
+function isTailwindGeneratedContainerRule(rule) {
+	const previous = rule.prev();
+	return previous?.type === "comment" && TAILWIND_GENERATED_TOKEN_COMMENT_RE.test(previous.text);
+}
+function removeTailwindContainerWidthRules(root, options = {}) {
+	root.walkRules((rule) => {
+		if (!isContainerWidthOnlyRule(rule)) return;
+		if (options.generatedOnly && !isTailwindGeneratedContainerRule(rule)) return;
+		const parent = rule.parent;
+		if (isTailwindGeneratedContainerRule(rule)) rule.prev()?.remove();
+		rule.remove();
+		removeEmptyAtRuleAncestors(parent);
+	});
+}
+function removeUnsupportedModernColorDeclarations(root) {
+	const customPropertyValues = /* @__PURE__ */ new Map();
+	root.walkDecls((decl) => {
+		if (decl.prop.startsWith("--")) customPropertyValues.set(decl.prop, decl.value.trim());
+	});
+	root.walkDecls((decl) => {
+		const normalized = normalizeModernColorValue(decl.value, customPropertyValues);
+		if (normalized.changed) {
+			decl.value = normalized.value;
+			if (decl.prop.startsWith("--")) customPropertyValues.set(decl.prop, decl.value.trim());
+		}
+		if (normalized.hasUnsupported) removeDeclarationAndEmptyRule(decl);
+	});
+}
+//#endregion
+//#region src/compat/mini-program-prefixes.ts
+const PRESERVED_WEBKIT_DECLARATION_PROPS = /* @__PURE__ */ new Set([
+	"-webkit-box-orient",
+	"-webkit-line-clamp",
+	"-webkit-overflow-scrolling",
+	"-webkit-text-fill-color",
+	"-webkit-text-stroke",
+	"-webkit-text-stroke-color",
+	"-webkit-text-stroke-width"
+]);
+const PRESERVED_WEBKIT_VALUE_DECLARATIONS = /* @__PURE__ */ new Map([["display", /* @__PURE__ */ new Set(["-webkit-box"])], ["-webkit-background-clip", /* @__PURE__ */ new Set(["text"])]]);
+const TRANSITION_PROPS = /* @__PURE__ */ new Set(["transition", "transition-property"]);
+function splitTopLevelCommaList(value) {
+	const parts = [];
+	let start = 0;
+	let depth = 0;
+	let quote;
+	let escaped = false;
+	for (let i = 0; i < value.length; i++) {
+		const char = value[i];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "(") {
+			depth++;
+			continue;
+		}
+		if (char === ")") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (char === "," && depth === 0) {
+			parts.push(value.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(value.slice(start));
+	return parts;
+}
+function isPreservedWebkitDeclaration(decl) {
+	const prop = decl.prop.toLowerCase();
+	if (prop.startsWith("-webkit-mask")) return true;
+	if (PRESERVED_WEBKIT_DECLARATION_PROPS.has(prop)) return true;
+	return PRESERVED_WEBKIT_VALUE_DECLARATIONS.get(prop)?.has(decl.value.trim().toLowerCase()) ?? false;
+}
+function normalizeTransitionValue(value) {
+	return splitTopLevelCommaList(value).map((part) => part.trim()).filter((part) => part.length > 0 && !part.toLowerCase().startsWith("-webkit-")).join(", ");
+}
+function hasUnsupportedWebkitKeywordValue(decl) {
+	const value = decl.value.trim().toLowerCase();
+	if (!value.startsWith("-webkit-")) return false;
+	if (PRESERVED_WEBKIT_VALUE_DECLARATIONS.get(decl.prop.toLowerCase())?.has(value)) return false;
+	return /^-webkit-[\w-]+$/.test(value);
+}
+/**
+* 收敛小程序 CSS 中的 WebKit 前缀，只保留 WXSS 里有实际价值的兼容写法。
+*/
+function normalizeMiniProgramPrefixedDeclaration(decl) {
+	const prop = decl.prop.toLowerCase();
+	if (TRANSITION_PROPS.has(prop) && decl.value.toLowerCase().includes("-webkit-")) {
+		const value = normalizeTransitionValue(decl.value);
+		if (value.length === 0) {
+			decl.remove();
+			return;
+		}
+		decl.value = value;
+	}
+	if (prop.startsWith("-webkit-") && !isPreservedWebkitDeclaration(decl)) {
+		decl.remove();
+		return;
+	}
+	if (hasUnsupportedWebkitKeywordValue(decl)) decl.remove();
+}
+function removeUnsupportedMiniProgramPrefixedAtRule(atRule) {
+	if (atRule.name.toLowerCase() === "-webkit-keyframes") atRule.remove();
+}
+//#endregion
+//#region src/compat/tailwindcss-v4/gradients.ts
+function collectTailwindcssV4ThemeVariables(root) {
+	const variables = /* @__PURE__ */ new Map();
+	root.walkRules((rule) => {
+		if (!testIfRootHostForV4(rule) && !rule.selector.includes("page") && !rule.selector.includes(".tw-root")) return;
+		rule.walkDecls((decl) => {
+			if (decl.prop.startsWith("--color-")) variables.set(decl.prop, decl.value);
+		});
+	});
+	return variables;
+}
+function resolveTailwindcssV4GradientColor(value, themeVariables) {
+	const trimmed = value.trim();
+	const match = COLOR_VAR_RE.exec(trimmed);
+	if (!match) return trimmed;
+	return themeVariables.get(match[1]) ?? trimmed;
+}
+function getSingleClassSelector(selector) {
+	const match = SIMPLE_CLASS_SELECTOR_RE.exec(selector.trim());
+	return match ? match[1] : void 0;
+}
+function normalizeDeclarationValue(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function normalizeTailwindcssV4GradientPosition(value) {
+	return value.replace(/calc\(\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:deg|grad|rad|turn))\s*\*\s*-1\s*\)/gi, "-$1").replace(/^in\s+(?:oklab|oklch|hsl|srgb)(?:\s+(?:longer|shorter|increasing|decreasing)\s+hue)?$/i, "").replace(/\s+in\s+(?:oklab|oklch|hsl|srgb)(?:\s+(?:longer|shorter|increasing|decreasing)\s+hue)?\s*$/i, "").replace(/\s+(?:longer|shorter|increasing|decreasing)\s*$/i, "").trim();
+}
+function normalizeTailwindcssV4InfinityCalcValue(value) {
+	return INFINITY_CALC_VALUE_REGEXP.test(value.trim()) ? `${CLAMP_PX}px` : value;
+}
+const INFINITY_CALC_CSS_RE = /calc\(\s*infinity\s*\*\s*(?:\d+(?:\.\d*)?|\.\d+)r?px\s*\)/gi;
+/** 在预处理器解析前收敛 Tailwind v4 生成的无限圆角，避免 Sass 将 infinity 当作非法表达式。 */
+function normalizeTailwindcssV4InfinityCalcCss(css) {
+	return css.replace(INFINITY_CALC_CSS_RE, `${CLAMP_PX}px`);
+}
+function normalizeTailwindcssV4GradientDirectionDeclaration(rule, decl) {
+	const normalized = normalizeTailwindcssV4GradientPosition(decl.value);
+	if (normalized) return normalized;
+	const backgroundImageDecl = rule.nodes.find((node) => {
+		return node.type === "decl" && node.prop === "background-image";
+	});
+	if (!backgroundImageDecl) return normalized;
+	if (/^radial-gradient\(/i.test(backgroundImageDecl.value)) return "at center";
+	if (/^conic-gradient\(/i.test(backgroundImageDecl.value)) return "from 0deg";
+	return normalized;
+}
+function appendStopPosition(color, position) {
+	const normalizedPosition = position?.trim();
+	return normalizedPosition ? `${color} ${normalizedPosition}` : color;
+}
+function getGradientStopsFallback(value) {
+	if (!value.includes("var(") || !value.includes("--tw-gradient-stops")) return;
+	const parsed = (0, postcss_value_parser.default)(value);
+	let fallback;
+	parsed.walk((node) => {
+		if (fallback || node.type !== "function" || node.value.toLowerCase() !== "var") return;
+		const firstCommaIndex = node.nodes.findIndex((child) => child.type === "div" && child.value === ",");
+		const firstArg = node.nodes.find((child) => child.type !== "space");
+		if (firstArg?.type !== "word" || firstArg.value !== "--tw-gradient-stops" || firstCommaIndex < 0) return;
+		fallback = postcss_value_parser.default.stringify(node.nodes.slice(firstCommaIndex + 1)).trim();
+	});
+	return fallback;
+}
+function isTailwindcssV4GradientDirectionRule(rule) {
+	const classSelector = getSingleClassSelector(rule.selector);
+	if (!classSelector || !GRADIENT_DIRECTION_CLASS_RE.test(classSelector)) return false;
+	return rule.nodes.some((node) => {
+		return node.type === "decl" && (node.prop === "--tw-gradient-position" || node.prop === "background-image" && node.value.includes("linear-gradient("));
+	});
+}
+function reorderTailwindcssV4GradientDirectionRule(rule) {
+	const gradientPositionDecls = [];
+	const gradientBackgroundDecls = [];
+	for (const node of rule.nodes) {
+		if (node.type !== "decl") continue;
+		if (node.prop === "--tw-gradient-position") gradientPositionDecls.push(node);
+		else if (node.prop === "background-image" && node.value.includes("linear-gradient(")) gradientBackgroundDecls.push(node);
+	}
+	if (gradientPositionDecls.length === 0 || gradientBackgroundDecls.length === 0) return;
+	for (const decl of gradientPositionDecls) decl.value = normalizeTailwindcssV4GradientDirectionDeclaration(rule, decl);
+	const anchor = rule.nodes.find((node) => {
+		return node.type === "decl" && (node.prop === "--tw-gradient-position" || node.prop === "background-image" && node.value.includes("linear-gradient("));
+	});
+	if (!anchor) return;
+	const ordered = [...gradientPositionDecls, ...gradientBackgroundDecls];
+	const orderedClones = ordered.map((decl) => decl.clone());
+	anchor.replaceWith(...orderedClones);
+	for (const decl of ordered) if (decl.parent) decl.remove();
+}
+function mergeTailwindcssV4GradientDirectionRules(root) {
+	const seen = /* @__PURE__ */ new Map();
+	root.walkRules((rule) => {
+		if (!isTailwindcssV4GradientDirectionRule(rule)) return;
+		rule.walkDecls("--tw-gradient-position", (decl) => {
+			decl.value = normalizeTailwindcssV4GradientDirectionDeclaration(rule, decl);
+		});
+		const selector = rule.selector.trim();
+		const previous = seen.get(selector);
+		if (!previous || previous.parent !== rule.parent) {
+			seen.set(selector, rule);
+			return;
+		}
+		for (const node of [...rule.nodes]) {
+			if (node.type !== "decl") continue;
+			if (node.prop !== "--tw-gradient-position" && node.prop !== "background-image") continue;
+			previous.append(node.clone());
+		}
+		reorderTailwindcssV4GradientDirectionRule(previous);
+		rule.remove();
+	});
+}
+function createTailwindcssV4MiniProgramGradientValue(gradient, from, to, via) {
+	const stops = [gradient.position, appendStopPosition(from.color, from.position)];
+	if (via) stops.push(appendStopPosition(via.color, via.position));
+	stops.push(appendStopPosition(to.color, to.position));
+	return `${gradient.type}-gradient(${stops.filter(Boolean).join(", ")})`;
+}
+function appendTailwindcssV4MiniProgramGradientRules(root) {
+	const themeVariables = collectTailwindcssV4ThemeVariables(root);
+	const gradients = [];
+	const fromColors = /* @__PURE__ */ new Map();
+	const viaColors = /* @__PURE__ */ new Map();
+	const toColors = /* @__PURE__ */ new Map();
+	const fromPositions = [];
+	const viaPositions = [];
+	const toPositions = [];
+	const directBackgroundImages = [];
+	const existingBackgroundImages = /* @__PURE__ */ new Map();
+	const ruleOrder = /* @__PURE__ */ new Map();
+	let order = 0;
+	root.walkRules((rule) => {
+		const classSelector = getSingleClassSelector(rule.selector);
+		const currentOrder = order++;
+		if (classSelector) ruleOrder.set(classSelector, currentOrder);
+		rule.walkDecls("background-image", (decl) => {
+			const selector = rule.selector.trim();
+			const values = existingBackgroundImages.get(selector);
+			if (values) values.add(normalizeDeclarationValue(decl.value));
+			else existingBackgroundImages.set(selector, /* @__PURE__ */ new Set([normalizeDeclarationValue(decl.value)]));
+		});
+		if (classSelector) {
+			const gradientPositionDecl = rule.nodes.find((node) => {
+				return node.type === "decl" && node.prop === "--tw-gradient-position";
+			});
+			const gradientBackgroundDecl = rule.nodes.find((node) => {
+				return node.type === "decl" && node.prop === "background-image" && GRADIENT_BACKGROUND_RE.test(node.value);
+			});
+			if (gradientPositionDecl && gradientBackgroundDecl) {
+				const gradientType = GRADIENT_BACKGROUND_RE.exec(gradientBackgroundDecl.value)?.[1];
+				if (gradientType) {
+					gradients.push({
+						classSelector,
+						order: currentOrder,
+						position: normalizeTailwindcssV4GradientDirectionDeclaration(rule, gradientPositionDecl),
+						type: gradientType
+					});
+					const fallback = GRADIENT_STOPS_VAR_RE.test(gradientBackgroundDecl.value) ? getGradientStopsFallback(gradientBackgroundDecl.value) : void 0;
+					if (fallback) directBackgroundImages.push({
+						selector: rule.selector.trim(),
+						value: `${gradientType}-gradient(${fallback})`
+					});
+				}
+			}
+			rule.walkDecls((decl) => {
+				if (decl.prop === "--tw-gradient-from") fromColors.set(classSelector, {
+					classSelector,
+					color: resolveTailwindcssV4GradientColor(decl.value, themeVariables),
+					order: currentOrder
+				});
+				else if (decl.prop === "--tw-gradient-from-position") fromPositions.push({
+					classSelector,
+					position: decl.value
+				});
+				else if (decl.prop === "--tw-gradient-via") viaColors.set(classSelector, {
+					classSelector,
+					color: resolveTailwindcssV4GradientColor(decl.value, themeVariables),
+					order: currentOrder
+				});
+				else if (decl.prop === "--tw-gradient-via-position") viaPositions.push({
+					classSelector,
+					position: decl.value
+				});
+				else if (decl.prop === "--tw-gradient-to") toColors.set(classSelector, {
+					classSelector,
+					color: resolveTailwindcssV4GradientColor(decl.value, themeVariables),
+					order: currentOrder
+				});
+				else if (decl.prop === "--tw-gradient-to-position") toPositions.push({
+					classSelector,
+					position: decl.value
+				});
+			});
+		}
+	});
+	const fromVariants = [];
+	const viaVariants = [];
+	const toVariants = [];
+	const positionedFromVariants = [];
+	const positionedViaVariants = [];
+	const positionedToVariants = [];
+	for (const color of fromColors.values()) {
+		fromVariants.push(color);
+		for (const position of fromPositions) positionedFromVariants.push({
+			...color,
+			classSelector: `${color.classSelector}.${position.classSelector}`,
+			order: Math.max(color.order, ruleOrder.get(position.classSelector) ?? color.order),
+			position: position.position
+		});
+	}
+	for (const color of viaColors.values()) {
+		viaVariants.push(color);
+		for (const position of viaPositions) positionedViaVariants.push({
+			...color,
+			classSelector: `${color.classSelector}.${position.classSelector}`,
+			order: Math.max(color.order, ruleOrder.get(position.classSelector) ?? color.order),
+			position: position.position
+		});
+	}
+	for (const color of toColors.values()) {
+		toVariants.push(color);
+		for (const position of toPositions) positionedToVariants.push({
+			...color,
+			classSelector: `${color.classSelector}.${position.classSelector}`,
+			order: Math.max(color.order, ruleOrder.get(position.classSelector) ?? color.order),
+			position: position.position
+		});
+	}
+	function appendGradientRule(selector, value) {
+		const normalizedValue = normalizeDeclarationValue(value);
+		if (existingBackgroundImages.get(selector)?.has(normalizedValue)) return;
+		existingBackgroundImages.set(selector, /* @__PURE__ */ new Set([...existingBackgroundImages.get(selector) ?? [], normalizedValue]));
+		root.append((0, postcss.rule)({
+			selector,
+			nodes: [new postcss.Declaration({
+				prop: "background-image",
+				value
+			})]
+		}));
+	}
+	for (const { selector, value } of directBackgroundImages) appendGradientRule(selector, value);
+	function appendGradientCombinations(gradient, fromRules, viaRules, toRules) {
+		for (const from of fromRules) for (const to of toRules) {
+			appendGradientRule(`.${gradient.classSelector}.${from.classSelector}.${to.classSelector}`, createTailwindcssV4MiniProgramGradientValue(gradient, from, to));
+			for (const via of viaRules) appendGradientRule(`.${gradient.classSelector}.${from.classSelector}.${via.classSelector}.${to.classSelector}`, createTailwindcssV4MiniProgramGradientValue(gradient, from, to, via));
+		}
+	}
+	for (const gradient of gradients) {
+		if (gradient.position.includes(",") || /^var\(/i.test(gradient.position)) continue;
+		appendGradientCombinations(gradient, fromVariants, viaVariants, toVariants);
+		appendGradientCombinations(gradient, positionedFromVariants, positionedViaVariants, positionedToVariants);
+	}
+}
+//#endregion
+//#region src/compat/tailwindcss-v4/declarations.ts
+function normalizeTailwindcssV4EmptyVarFallback(value) {
+	if (!value.includes("var(") || !value.includes("--tw-")) return value;
+	const parsed = (0, postcss_value_parser.default)(value);
+	let changed = false;
+	parsed.walk((node) => {
+		if (node.type !== "function" || node.value.toLowerCase() !== "var") return;
+		const firstArg = node.nodes.find((child) => child.type !== "space");
+		const lastArg = node.nodes.findLast((child) => child.type !== "space");
+		if (firstArg?.type !== "word" || !firstArg.value.startsWith("--tw-") || lastArg?.type !== "div" || lastArg.value !== "," || node.after === " ") return;
+		node.after = " ";
+		changed = true;
+	});
+	return changed ? parsed.toString() : value;
+}
+function normalizeTailwindcssV4GradientStopsFallback(value) {
+	if (!value.includes("var(") || !value.includes("--tw-gradient-via-stops")) return value;
+	const parsed = (0, postcss_value_parser.default)(value);
+	let changed = false;
+	function normalizeNodes(nodes) {
+		for (let index = 0; index < nodes.length; index++) {
+			const node = nodes[index];
+			if (!node) continue;
+			if (node.type === "function" && node.value.toLowerCase() !== "var") {
+				normalizeNodes(node.nodes);
+				continue;
+			}
+			if (node.type !== "function") continue;
+			const firstArg = node.nodes.filter((child) => child.type !== "space")[0];
+			if (firstArg?.type !== "word" || firstArg.value !== "--tw-gradient-via-stops") {
+				normalizeNodes(node.nodes);
+				continue;
+			}
+			const firstCommaIndex = node.nodes.findIndex((child) => child.type === "div" && child.value === ",");
+			if (firstCommaIndex < 0) continue;
+			const fallbackNodes = node.nodes.slice(firstCommaIndex + 1);
+			const splitIndex = fallbackNodes.findIndex((child) => child.type === "div" && child.value === ",");
+			if (splitIndex < 0) continue;
+			const viaFallbackNodes = fallbackNodes.slice(0, splitIndex);
+			const stopNodes = fallbackNodes.slice(splitIndex);
+			const nextVarNode = {
+				...node,
+				nodes: [
+					{
+						type: "word",
+						value: "--tw-gradient-via-stops"
+					},
+					{
+						type: "div",
+						value: ",",
+						before: "",
+						after: " "
+					},
+					...viaFallbackNodes
+				],
+				sourceEndIndex: void 0,
+				sourceIndex: void 0
+			};
+			nodes.splice(index, 1, nextVarNode, ...stopNodes);
+			changed = true;
+			index += stopNodes.length;
+		}
+	}
+	normalizeNodes(parsed.nodes);
+	return changed ? parsed.toString() : value;
+}
+function normalizeTailwindcssV4GradientPositionFallback(value) {
+	if (!value.includes("var(") || !value.includes("--tw-gradient-")) return value;
+	const parsed = (0, postcss_value_parser.default)(value);
+	let changed = false;
+	parsed.walk((node) => {
+		if (node.type !== "function" || node.value.toLowerCase() !== "var") return;
+		const args = node.nodes.filter((child) => child.type !== "space");
+		const firstArg = args[0];
+		if (firstArg?.type !== "word" || !TW_GRADIENT_POSITION_PROPS.has(firstArg.value)) return;
+		const commaIndex = args.findIndex((child) => child.type === "div" && child.value === ",");
+		if (commaIndex === -1 ? void 0 : args[commaIndex]) {
+			if (!args.slice(commaIndex + 1).some((child) => child.type !== "space") && node.after !== " ") {
+				node.after = " ";
+				changed = true;
+			}
+			return;
+		}
+		node.nodes.push({
+			type: "div",
+			value: ",",
+			before: "",
+			after: ""
+		});
+		node.after = " ";
+		changed = true;
+	});
+	return changed ? parsed.toString() : value;
+}
+function normalizeTailwindcssV4Declaration(decl) {
+	let changed = false;
+	if (decl.prop === "--tw-gradient-via-stops" && decl.value.trim() === "initial") {
+		decl.remove();
+		return true;
+	}
+	const normalizedEmptyVarFallback = normalizeTailwindcssV4EmptyVarFallback(decl.value);
+	if (normalizedEmptyVarFallback !== decl.value) {
+		decl.value = normalizedEmptyVarFallback;
+		changed = true;
+	}
+	const normalizedGradientStopsFallback = normalizeTailwindcssV4GradientStopsFallback(decl.value);
+	if (normalizedGradientStopsFallback !== decl.value) {
+		decl.value = normalizedGradientStopsFallback;
+		changed = true;
+	}
+	const normalizedGradientPositionFallback = normalizeTailwindcssV4GradientPositionFallback(decl.value);
+	if (normalizedGradientPositionFallback !== decl.value) {
+		decl.value = normalizedGradientPositionFallback;
+		changed = true;
+	}
+	if (decl.prop === "--tw-gradient-position") {
+		const nextValue = decl.parent?.type === "rule" ? normalizeTailwindcssV4GradientDirectionDeclaration(decl.parent, decl) : normalizeTailwindcssV4GradientPosition(decl.value);
+		if (nextValue !== decl.value) {
+			decl.value = nextValue;
+			return true;
+		}
+	}
+	const normalizedInfinityCalcValue = normalizeTailwindcssV4InfinityCalcValue(decl.value);
+	if (normalizedInfinityCalcValue !== decl.value) {
+		decl.value = normalizedInfinityCalcValue;
+		return true;
+	}
+	if (decl.prop.includes("radius")) {
+		RADIUS_VALUE_RE.lastIndex = 0;
+		const next = decl.value.replace(RADIUS_VALUE_RE, (m, num) => {
+			const n = Number(num);
+			if (!Number.isFinite(n)) return `${CLAMP_PX}px`;
+			if (SCIENTIFIC_NOTATION_RE.test(String(num)) || n > 1e5) return `${CLAMP_PX}px`;
+			return m;
+		});
+		if (next !== decl.value) {
+			decl.value = next;
+			return true;
+		}
+	}
+	return changed;
+}
+//#endregion
+//#region src/syntax/css-import.ts
+function significantTokens(params) {
+	return (0, _csstools_css_tokenizer.tokenize)({ css: params }).filter((token) => token[0] !== _csstools_css_tokenizer.TokenType.Whitespace && token[0] !== _csstools_css_tokenizer.TokenType.Comment);
+}
+function isCssWhitespace(char) {
+	return char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+}
+function skipCssWhitespace(params, index) {
+	while (index < params.length && isCssWhitespace(params[index])) index++;
+	return index;
+}
+function parseSimpleQuotedSpecifier(params, start) {
+	const quote = params[start];
+	if (quote !== "\"" && quote !== "'") return;
+	let index = start + 1;
+	while (index < params.length) {
+		const char = params[index];
+		if (char === "\\" || char === "\n" || char === "\r") return;
+		if (char === quote) return {
+			specifier: params.slice(start + 1, index),
+			raw: params.slice(start, index + 1),
+			quote
+		};
+		index++;
+	}
+}
+function parseSimpleImportSpecifier(params) {
+	let index = skipCssWhitespace(params, 0);
+	const quoted = parseSimpleQuotedSpecifier(params, index);
+	if (quoted) return quoted;
+	if (params.slice(index, index + 4).toLowerCase() !== "url(") return;
+	const urlStart = index;
+	index = skipCssWhitespace(params, index + 4);
+	const inner = parseSimpleQuotedSpecifier(params, index);
+	if (!inner) return;
+	index = skipCssWhitespace(params, index + inner.raw.length);
+	if (params[index] !== ")") return;
+	return {
+		specifier: inner.specifier,
+		raw: params.slice(urlStart, index + 1),
+		quote: inner.quote
+	};
+}
+/**
+* 解析 `@import` / `@use` / `@forward` 参数中的请求串。
+* 无 escape/注释的引号和 `url("...")` 走快路径；复杂输入才使用 CSS tokenizer。
+*/
+function parseCssImportSpecifier(params) {
+	const simple = parseSimpleImportSpecifier(params);
+	if (simple) return simple;
+	const tokens = significantTokens(params);
+	const first = tokens[0];
+	if (!first || first[0] === _csstools_css_tokenizer.TokenType.EOF) return;
+	if (first[0] === _csstools_css_tokenizer.TokenType.String || first[0] === _csstools_css_tokenizer.TokenType.URL || first[0] === _csstools_css_tokenizer.TokenType.Ident) return {
+		specifier: first[4].value,
+		raw: first[1],
+		quote: first[0] === _csstools_css_tokenizer.TokenType.String ? first[1][0] : void 0
+	};
+	if (first[0] === _csstools_css_tokenizer.TokenType.Function && first[4].value.toLowerCase() === "url" && (tokens[1]?.[0] === _csstools_css_tokenizer.TokenType.String || tokens[1]?.[0] === _csstools_css_tokenizer.TokenType.Ident) && tokens[2]?.[0] === _csstools_css_tokenizer.TokenType.CloseParen) return {
+		specifier: tokens[1][4].value,
+		raw: params.slice(first[2], tokens[2][3] + 1),
+		quote: tokens[1][0] === _csstools_css_tokenizer.TokenType.String ? tokens[1][1][0] : void 0
+	};
+}
+/** 把文件系统路径写成 CSS 请求串；缓存和读文件仍使用原始路径。 */
+function quoteCssImportSpecifier(file, quote = "\"") {
+	return `${quote}${(node_path.default.sep === "\\" || /^[a-z]:[\\/]|^\\\\/i.test(file) ? file.replaceAll("\\", "/") : file).replaceAll("\\", "\\\\").replaceAll(quote, `\\${quote}`).replaceAll("\n", "\\a ").replaceAll("\r", "\\d ")}${quote}`;
+}
+/** 判断 import 参数是否指向 Tailwind CSS 包入口。 */
+function isTailwindCssImport(params) {
+	const specifier = parseCssImportSpecifier(params)?.specifier;
+	if (!specifier) return false;
+	if (specifier === "tailwindcss" || specifier.startsWith("tailwindcss/")) return true;
+	const paths = specifier.includes("\\") ? node_path.default.win32 : node_path.default.posix;
+	return paths.basename(specifier) === "index.css" && paths.basename(paths.dirname(specifier)) === "tailwindcss";
+}
+/** 解析 `@import "..." source(...)` 中的 source 参数。 */
+function parseImportSourceParam(params) {
+	const tokens = significantTokens(params);
+	const index = tokens.findIndex((token) => token[0] === _csstools_css_tokenizer.TokenType.Function && token[4].value === "source");
+	const value = tokens[index + 1];
+	if (index < 0 || tokens[index + 2]?.[0] !== _csstools_css_tokenizer.TokenType.CloseParen) return;
+	if (value?.[0] === _csstools_css_tokenizer.TokenType.Ident && value[4].value === "none") return {
+		none: true,
+		sourcePath: void 0
+	};
+	return value?.[0] === _csstools_css_tokenizer.TokenType.String ? {
+		none: false,
+		sourcePath: value[4].value
+	} : void 0;
+}
+//#endregion
+//#region src/compat/mini-program-css/hoist.ts
+const HOIST_ANCHOR_COMMENT = "__weapp_tailwindcss_base_anchor__";
+function getTopDirectiveTail(root) {
+	let tail;
+	for (const node of root.nodes ?? []) {
+		if (node.type === "atrule" && (node.name === "charset" || node.name === "import")) {
+			tail = node;
+			continue;
+		}
+		break;
+	}
+	return tail;
+}
+function reorderPreflightResetDeclarations(rule) {
+	const declarations = (rule.nodes ?? []).filter((node) => node.type === "decl");
+	if (declarations.length <= 1) return;
+	const resetDeclarations = [];
+	const otherDeclarations = [];
+	for (const declaration of declarations) if (PREFLIGHT_RESET_PROPS.has(declaration.prop)) resetDeclarations.push(declaration);
+	else otherDeclarations.push(declaration);
+	if (resetDeclarations.length === 0 || otherDeclarations.length === 0) return;
+	const orderedDeclarations = [...resetDeclarations, ...otherDeclarations];
+	if (orderedDeclarations.every((declaration, index) => declaration === declarations[index])) return;
+	for (const declaration of declarations) declaration.remove();
+	rule.prepend(...orderedDeclarations);
+	rule.raws.semicolon = true;
+}
+function createHoistInsertionAnchor(root) {
+	for (const node of root.nodes ?? []) if (isMiniProgramPreflightRule(node) || isMiniProgramThemeVariableRule(node)) {
+		const anchor = postcss.default.comment({ text: HOIST_ANCHOR_COMMENT });
+		node.before(anchor);
+		return anchor;
+	}
+}
+function insertHoistedRules(root, rules, anchor) {
+	if (anchor && !anchor.parent) anchor = void 0;
+	if (rules.length === 0) {
+		anchor?.remove();
+		return;
+	}
+	const topDirectiveTail = getTopDirectiveTail(root);
+	const firstRule = rules[0];
+	if (!firstRule) return;
+	if (anchor) {
+		if (anchor.raws.before === void 0) delete firstRule.raws.before;
+		else firstRule.raws.before = anchor.raws.before;
+		anchor.replaceWith(rules);
+		return;
+	}
+	firstRule.raws.before = topDirectiveTail ? "\n" : "";
+	if (topDirectiveTail) topDirectiveTail.after(rules);
+	else root.prepend(rules);
+}
+function mergeEquivalentHoistedRules(rules) {
+	const mergedRules = [];
+	const ruleBySelector = /* @__PURE__ */ new Map();
+	const propsBySelector = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		const key = getSortedRuleSelectorKey(rule);
+		const existingRule = ruleBySelector.get(key);
+		if (existingRule) {
+			const existingProps = propsBySelector.get(key) ?? /* @__PURE__ */ new Set();
+			const nextNodes = (rule.nodes ?? []).filter((node) => {
+				if (node.type !== "decl") return true;
+				if (existingProps.has(node.prop)) return false;
+				existingProps.add(node.prop);
+				return true;
+			});
+			existingRule.append(...nextNodes.map((node) => node.clone()));
+			reorderPreflightResetDeclarations(existingRule);
+			propsBySelector.set(key, existingProps);
+			continue;
+		}
+		ruleBySelector.set(key, rule);
+		propsBySelector.set(key, new Set((rule.nodes ?? []).flatMap((node) => node.type === "decl" ? [node.prop] : [])));
+		reorderPreflightResetDeclarations(rule);
+		mergedRules.push(rule);
+	}
+	return mergedRules;
+}
+//#endregion
+//#region src/compat/mini-program-css/preflight.ts
+const MINI_PROGRAM_PSEUDO_CONTENT_SELECTORS = /* @__PURE__ */ new Set(["::before", "::after"]);
+function applyConfiguredPreflightDeclarations(rule, cssPreflight) {
+	if (!cssPreflight || typeof cssPreflight !== "object") return;
+	const configuredNodes = [];
+	const remainingNodes = [];
+	const remainingDeclarations = /* @__PURE__ */ new Map();
+	for (const node of rule.nodes ?? []) {
+		if (node.type !== "decl") {
+			remainingNodes.push(node);
+			continue;
+		}
+		if (Object.hasOwn(cssPreflight, node.prop)) {
+			remainingDeclarations.set(node.prop, node);
+			continue;
+		}
+		remainingNodes.push(node);
+	}
+	for (const [prop, value] of Object.entries(cssPreflight)) {
+		if (value === false) continue;
+		const declaration = remainingDeclarations.get(prop)?.clone() ?? postcss.default.decl({
+			prop,
+			value: value.toString()
+		});
+		declaration.value = value.toString();
+		configuredNodes.push(declaration);
+	}
+	rule.removeAll();
+	rule.append([...configuredNodes, ...remainingNodes]);
+}
+function collectPreflightRules(root, options = {}) {
+	const preflightNodes = [];
+	for (const node of root.nodes ?? []) if (isMiniProgramPreflightRule(node)) preflightNodes.push(node);
+	if (preflightNodes.length === 0) return [];
+	const clonedPreflightRules = preflightNodes.map((node) => {
+		const rule = node.clone();
+		rule.walkDecls("--tw-content", (decl) => {
+			if (isEmptyTwContentDeclaration(decl)) decl.remove();
+		});
+		return rule;
+	});
+	for (const rule of clonedPreflightRules) {
+		const selectors = getRuleSelectors(rule);
+		const hasElementSelector = selectors.some((selector) => selector === "view" || selector === "text");
+		if (selectors.length > 0 && selectors.every((selector) => MINI_PROGRAM_PSEUDO_CONTENT_SELECTORS.has(selector))) rule.remove();
+		else if (hasElementSelector && selectors.every((selector) => MINI_PROGRAM_ELEMENT_SCOPE_SELECTORS.has(selector))) {
+			if (options.cssPreflight === false) {
+				rule.removeAll();
+				continue;
+			}
+			rule.selector = MINI_PROGRAM_ELEMENT_SCOPE_SELECTOR;
+			applyConfiguredPreflightDeclarations(rule, options.cssPreflight);
+		}
+	}
+	const nonEmptyPreflightRules = [...clonedPreflightRules.filter((rule) => (rule.nodes?.length ?? 0) > 0)];
+	for (const node of preflightNodes) node.remove();
+	return nonEmptyPreflightRules;
+}
+function createPreflightResetRule(cssPreflight) {
+	if (!cssPreflight || typeof cssPreflight !== "object") return;
+	const rule = postcss.default.rule({ selector: MINI_PROGRAM_ELEMENT_SCOPE_SELECTOR });
+	for (const [prop, value] of Object.entries(cssPreflight)) {
+		if (value === false) continue;
+		rule.append({
+			prop,
+			value: value.toString()
+		});
+	}
+	return rule.nodes?.length ? rule : void 0;
+}
+//#endregion
+//#region src/compat/mini-program-css/theme.ts
+function collectThemeVariableRule(root, options = {}) {
+	const themeRules = [];
+	const declarations = /* @__PURE__ */ new Map();
+	const shouldPreserveContentInit = usesTwContentVariable(root);
+	for (const node of root.nodes ?? []) {
+		if (!isMiniProgramThemeVariableRule(node)) continue;
+		themeRules.push(node);
+		node.walkDecls((decl) => {
+			if (isDisplayP3Declaration(decl)) return;
+			if (decl.prop.startsWith("--tw-")) return;
+			if (!shouldPreserveContentInit && isEmptyTwContentDeclaration(decl)) return;
+			declarations.set(decl.prop, decl.clone());
+		});
+	}
+	for (const rule of themeRules) rule.remove();
+	if (declarations.size === 0) return;
+	const rule = postcss.default.rule({ selector: normalizeMiniProgramThemeScopeSelector(options.cssSelectorReplacement?.root) });
+	for (const decl of declarations.values()) rule.append(decl);
+	return rule;
+}
+//#endregion
+//#region src/compat/mini-program-css/finalize.ts
+function finalizeMiniProgramCssRoot(root, options = {}) {
+	const shouldInjectTailwindcssV4Defaults = options.isTailwindcssV4 === true;
+	const tailwindcssV4DefaultNodes = shouldInjectTailwindcssV4Defaults ? createMissingCssVarsV4Nodes(root, collectUsedTailwindcssV4Variables(root)) : [];
+	removeUnsupportedCascadeLayers(root);
+	unwrapTailwindSourceMedia(root);
+	removeTailwindGenerationDirectives(root);
+	root.walkAtRules("property", (atRule) => {
+		atRule.remove();
+	});
+	root.walkAtRules("supports", (atRule) => {
+		atRule.remove();
+	});
+	removeSpecificityPlaceholders(root);
+	removeRootSpecificityPlaceholders(root);
+	removeUnsupportedBrowserSelectors(root);
+	removeDisplayP3Declarations(root);
+	removeEmptyStandardDeclarations(root);
+	removeTailwindContainerMaxWidthMediaRules(root);
+	removeTailwindContainerWidthRules(root, { generatedOnly: true });
+	removeUnsupportedModernColorDeclarations(root);
+	root.walkDecls((decl) => {
+		if (shouldInjectTailwindcssV4Defaults) normalizeTailwindcssV4Declaration(decl);
+		normalizeMiniProgramPrefixedDeclaration(decl);
+	});
+	root.walkAtRules((atRule) => {
+		removeUnsupportedMiniProgramPrefixedAtRule(atRule);
+	});
+	if (shouldInjectTailwindcssV4Defaults) {
+		mergeTailwindcssV4GradientDirectionRules(root);
+		if (options.tailwindcssV4GradientFallback === true) appendTailwindcssV4MiniProgramGradientRules(root);
+	}
+	const hoistAnchor = createHoistInsertionAnchor(root);
+	const preflightRules = collectPreflightRules(root, options);
+	if (preflightRules.length === 0) {
+		const resetRule = createPreflightResetRule(options.cssPreflight);
+		if (resetRule) preflightRules.push(resetRule);
+	}
+	if (tailwindcssV4DefaultNodes.length > 0) preflightRules.push(postcss.default.rule({
+		selector: MINI_PROGRAM_ELEMENT_SCOPE_SELECTOR,
+		nodes: tailwindcssV4DefaultNodes
+	}));
+	const themeRule = collectThemeVariableRule(root, options);
+	insertHoistedRules(root, mergeEquivalentHoistedRules(themeRule ? [...preflightRules, themeRule] : preflightRules), hoistAnchor);
+	if (options.removeEmptyAtRuleAncestors !== false) {
+		removeEmptyRules(root);
+		removeEmptyAtRules$1(root);
+	} else root.walkAtRules((atRule) => {
+		if (atRule.nodes?.length === 0) atRule.remove();
+	});
+}
+function hoistTailwindPreflightBase(css) {
+	try {
+		const root = postcss.default.parse(css);
+		insertHoistedRules(root, collectPreflightRules(root));
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+function finalizeMiniProgramCss(css, options = {}) {
+	const repairedCss = repairTrailingUnclosedTailwindSourceMedia(css);
+	let isTailwindcssV4 = options.isTailwindcssV4;
+	if (isTailwindcssV4 === void 0) try {
+		isTailwindcssV4 = hasTailwindcssV4Signal(repairedCss);
+	} catch {
+		isTailwindcssV4 = TAILWIND_V4_BANNER_RE.test(repairedCss);
+	}
+	const cleanedCss = removeUnsupportedMiniProgramAtRules(repairedCss);
+	try {
+		const root = postcss.default.parse(cleanedCss);
+		finalizeMiniProgramCssRoot(root, {
+			...options,
+			isTailwindcssV4
+		});
+		return root.toString();
+	} catch {
+		return removeSpecificityPlaceholdersFromSource(cleanedCss);
+	}
+}
+//#endregion
+//#region src/compat/web-css.ts
+const disabledFeatures = {
+	theme: false,
+	layer: false,
+	property: false,
+	nesting: false,
+	oklch: false,
+	colorFunctions: false,
+	supports: false
+};
+const legacyWebFeatures = {
+	theme: true,
+	layer: true,
+	property: true,
+	nesting: true,
+	oklch: true,
+	colorFunctions: true,
+	supports: true
+};
+function normalizeWebCssCompatOptionsObject(options) {
+	const preset = options.preset ?? "legacy-web";
+	return {
+		preset,
+		features: {
+			...preset === "legacy-web" ? legacyWebFeatures : disabledFeatures,
+			...options.features
+		}
+	};
+}
+function normalizeWebCssCompatOptions(options) {
+	if (options === true) return normalizeWebCssCompatOptionsObject({ preset: "legacy-web" });
+	if (!options) return {
+		preset: "off",
+		features: disabledFeatures
+	};
+	return normalizeWebCssCompatOptionsObject(options);
+}
+function isWebCssCompatEnabled(options) {
+	return Object.values(options.features).some(Boolean);
+}
+function collectCustomPropertyValues(root) {
+	const values = /* @__PURE__ */ new Map();
+	root.walkRules((rule) => {
+		if (!rule.selectors.some((selector) => selector.trim() === ":root" || selector.trim() === ":host")) return;
+		rule.each((node) => {
+			if (node.type === "decl" && node.prop.startsWith("--") && !node.prop.startsWith("--tw-")) {
+				const decl = node;
+				values.set(decl.prop, decl.value.trim());
+			}
+		});
+	});
+	return values;
+}
+function collectRegisteredCustomPropertyFallbacks(root) {
+	const registeredProperties = /* @__PURE__ */ new Map();
+	root.walkAtRules("property", (atRule) => {
+		const propertyName = atRule.params.trim().split(/\s+/, 1)[0];
+		if (propertyName?.startsWith("--")) {
+			const existing = registeredProperties.get(propertyName) ?? {};
+			atRule.walkDecls("initial-value", (decl) => {
+				existing.initialValue = decl.value.trim();
+			});
+			registeredProperties.set(propertyName, existing);
+		}
+		atRule.remove();
+	});
+	return registeredProperties;
+}
+const tailwindUnregisteredInitialFallbackCustomProperties = /* @__PURE__ */ new Set([
+	"--tw-gradient-position",
+	"--tw-gradient-stops",
+	"--tw-gradient-via-stops",
+	"--tw-leading",
+	"--tw-font-weight",
+	"--tw-tracking"
+]);
+function insertRegisteredCustomPropertyFallbackRule(root, registeredProperties) {
+	const declarations = [];
+	for (const [prop, registration] of registeredProperties) {
+		if (!registration.initialValue || registration.initialValue === "initial") continue;
+		declarations.push(postcss.default.decl({
+			prop,
+			value: registration.initialValue
+		}));
+	}
+	if (declarations.length === 0) return;
+	root.prepend(postcss.default.rule({
+		selector: "*, ::before, ::after, ::backdrop",
+		nodes: declarations
+	}));
+}
+function removeInitialFallbackDeclarations(root, registeredProperties) {
+	root.walkDecls((decl) => {
+		if ((registeredProperties.has(decl.prop) && !registeredProperties.get(decl.prop)?.initialValue || tailwindUnregisteredInitialFallbackCustomProperties.has(decl.prop)) && decl.value.trim() === "initial") decl.remove();
+	});
+}
+function unwrapThemeAtRules(root) {
+	root.walkAtRules("theme", (atRule) => {
+		if (atRule.nodes && atRule.nodes.length > 0) {
+			const rootNodes = [];
+			const hoistedNodes = [];
+			for (const node of atRule.nodes) if (node.type === "decl" || node.type === "comment") rootNodes.push(node.clone());
+			else hoistedNodes.push(node.clone());
+			const replacements = [...rootNodes.length > 0 ? [postcss.default.rule({
+				selector: ":root",
+				nodes: rootNodes
+			})] : [], ...hoistedNodes];
+			atRule.replaceWith(...replacements);
+		} else atRule.remove();
+	});
+}
+function resolveCustomPropertyVarValue(value, customPropertyValues) {
+	if (!value.includes("var(")) return value;
+	const parsed = (0, postcss_value_parser.default)(value);
+	let changed = false;
+	parsed.walk((node) => {
+		if (node.type !== "function" || node.value.toLowerCase() !== "var") return;
+		const propertyNode = node.nodes.find((child) => child.type === "word" && child.value.startsWith("--"));
+		if (!propertyNode) return;
+		const customPropertyValue = customPropertyValues.get(propertyNode.value);
+		if (!customPropertyValue) return;
+		const mutableNode = node;
+		mutableNode.type = "word";
+		mutableNode.value = customPropertyValue;
+		delete mutableNode.nodes;
+		changed = true;
+	});
+	return changed ? parsed.toString() : value;
+}
+function usesResolvableTailwindColorVariable(value, customPropertyValues) {
+	if (!value.includes("var(")) return false;
+	const parsed = (0, postcss_value_parser.default)(value);
+	let usesColorVariable = false;
+	parsed.walk((node) => {
+		if (node.type !== "function" || node.value.toLowerCase() !== "var") return;
+		const propertyNode = node.nodes.find((child) => child.type === "word" && child.value.startsWith("--color-"));
+		if (propertyNode && customPropertyValues.has(propertyNode.value)) usesColorVariable = true;
+	});
+	return usesColorVariable;
+}
+function normalizeModernColorDeclarations(root, features) {
+	if (!features.oklch && !features.colorFunctions) return;
+	const customPropertyValues = collectCustomPropertyValues(root);
+	root.walkDecls((decl) => {
+		const value = resolveCustomPropertyVarValue(decl.value, customPropertyValues);
+		const normalized = normalizeModernColorValue(value, customPropertyValues);
+		if (!normalized.changed) {
+			if (value !== decl.value && usesResolvableTailwindColorVariable(decl.value, customPropertyValues)) decl.value = value;
+			return;
+		}
+		if (!features.colorFunctions && !/oklch|oklab/i.test(value)) return;
+		decl.value = normalized.value;
+	});
+}
+function removeModernColorSupports(root) {
+	root.walkAtRules("supports", (atRule) => {
+		if (!/color-mix|oklch|oklab|lab|lch|display-p3/i.test(atRule.params)) return;
+		if (atRule.nodes && atRule.nodes.length > 0) atRule.replaceWith(...atRule.nodes);
+		else atRule.remove();
+	});
+}
+function normalizeTailwindcssV4GradientPositionDeclarations(root) {
+	root.walkDecls("--tw-gradient-position", (decl) => {
+		const normalized = normalizeTailwindcssV4GradientPosition(decl.value);
+		if (normalized) {
+			decl.value = normalized;
+			return;
+		}
+		if (normalized === decl.value.trim()) return;
+		const parent = decl.parent;
+		if (parent?.type !== "rule") {
+			decl.value = "to bottom";
+			return;
+		}
+		const backgroundImageDecl = parent.nodes.find((node) => {
+			return node.type === "decl" && node.prop === "background-image";
+		});
+		if (/^radial-gradient\(/i.test(backgroundImageDecl?.value ?? "")) {
+			decl.value = "at center";
+			return;
+		}
+		if (/^conic-gradient\(/i.test(backgroundImageDecl?.value ?? "")) {
+			decl.value = "from 0deg";
+			return;
+		}
+		decl.value = "to bottom";
+	});
+}
+function normalizeTailwindcssV4InfinityCalcDeclarations(root) {
+	root.walkDecls((decl) => {
+		const normalized = normalizeTailwindcssV4InfinityCalcValue(decl.value);
+		if (normalized !== decl.value) decl.value = normalized;
+	});
+}
+function removeEmptyAtRules(root) {
+	root.walkAtRules((atRule) => {
+		if (atRule.nodes && atRule.nodes.length === 0) atRule.remove();
+	});
+}
+function insertWebkitBackgroundClipText(root) {
+	root.walkDecls("background-clip", (decl) => {
+		if (decl.value.trim().toLowerCase() !== "text") return;
+		const parent = decl.parent;
+		if (!parent || !("nodes" in parent)) return;
+		if (!parent.nodes.some((node) => {
+			return node.type === "decl" && node.prop.toLowerCase() === "-webkit-background-clip" && node.value.trim().toLowerCase() === "text";
+		})) decl.cloneBefore({ prop: "-webkit-background-clip" });
+	});
+}
+function transformCssNesting(root) {
+	(0, postcss.default)([(0, postcss_preset_env.default)({
+		stage: false,
+		autoprefixer: false,
+		features: { "nesting-rules": true }
+	})]).process(root, { from: void 0 }).sync();
+}
+function transformWebCssCompat(css, options) {
+	const normalized = normalizeWebCssCompatOptions(options);
+	if (!isWebCssCompatEnabled(normalized) && normalized.preset !== "legacy-web") return css;
+	try {
+		const root = postcss.default.parse(css);
+		if (normalized.features.theme) unwrapThemeAtRules(root);
+		if (normalized.features.property) {
+			const registeredProperties = collectRegisteredCustomPropertyFallbacks(root);
+			insertRegisteredCustomPropertyFallbackRule(root, registeredProperties);
+			removeInitialFallbackDeclarations(root, registeredProperties);
+		}
+		if (normalized.features.supports) removeModernColorSupports(root);
+		if (normalized.features.nesting) transformCssNesting(root);
+		normalizeTailwindcssV4GradientPositionDeclarations(root);
+		normalizeTailwindcssV4InfinityCalcDeclarations(root);
+		normalizeModernColorDeclarations(root, normalized.features);
+		if (normalized.preset === "legacy-web") insertWebkitBackgroundClipText(root);
+		if (normalized.features.layer) removeUnsupportedCascadeLayers(root);
+		removeEmptyAtRules(root);
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+function transformWebCssSafeSelectors(css, options) {
+	try {
+		const root = postcss.default.parse(css);
+		root.walkRules((rule) => {
+			if (!rule.selector.includes(".")) return;
+			rule.selector = (0, postcss_selector_parser.default)((selectors) => {
+				selectors.walkClasses((node) => {
+					node.value = require_shared.internalCssSelectorReplacer(node.value, options);
+				});
+			}).processSync(rule.selector);
+		});
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+//#endregion
+//#region src/source-scan/params.ts
+function parseConfigParam(params) {
+	const value = params.trim();
+	return /^(['"])(.+)\1$/.exec(value)?.[2];
+}
+function parseSourceFileParam(params) {
+	const value = params.trim();
+	if (!value || value === "none" || value.startsWith("inline(")) return;
+	const negated = value.startsWith("not ");
+	const sourceValue = negated ? value.slice(4).trim() : value;
+	if (sourceValue.startsWith("inline(")) return;
+	const match = /^(['"])(.+)\1$/.exec(sourceValue);
+	return match?.[2] ? {
+		negated,
+		sourcePath: match[2]
+	} : void 0;
+}
+//#endregion
+//#region src/source-scan/inline-source.ts
+const NUMERICAL_RANGE_RE = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+function segmentTopLevel(input, separator, options = {}) {
+	const parts = [];
+	const stack = [];
+	let lastPos = 0;
+	let quote;
+	for (let index = 0; index < input.length; index++) {
+		const char = input[index];
+		if (char === "\\") {
+			index += 1;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "(") {
+			stack.push(")");
+			continue;
+		}
+		if (char === "[") {
+			stack.push("]");
+			continue;
+		}
+		if (char === "{") {
+			stack.push("}");
+			continue;
+		}
+		if (stack.length > 0 && char === stack[stack.length - 1]) {
+			stack.pop();
+			continue;
+		}
+		if (stack.length === 0 && char === separator) {
+			const part = input.slice(lastPos, index);
+			if (part || options.keepEmpty) parts.push(part);
+			lastPos = index + 1;
+		}
+	}
+	const part = input.slice(lastPos);
+	if (part || options.keepEmpty) parts.push(part);
+	return parts;
+}
+function isSequence(value) {
+	return NUMERICAL_RANGE_RE.test(value);
+}
+function expandSequence(value) {
+	const match = value.match(NUMERICAL_RANGE_RE);
+	if (!match) return [value];
+	const [, start, end, stepValue] = match;
+	if (start === void 0 || end === void 0) return [value];
+	let step = stepValue ? Number.parseInt(stepValue, 10) : void 0;
+	const startNumber = Number.parseInt(start, 10);
+	const endNumber = Number.parseInt(end, 10);
+	const increasing = startNumber < endNumber;
+	if (step === void 0) step = increasing ? 1 : -1;
+	if (step === 0) return [];
+	if (increasing && step < 0) step = -step;
+	if (!increasing && step > 0) step = -step;
+	const result = [];
+	for (let value = startNumber; increasing ? value <= endNumber : value >= endNumber; value += step) result.push(String(value));
+	return result;
+}
+function expandInlineSourceCandidatePattern(pattern) {
+	const index = pattern.indexOf("{");
+	if (index === -1) return [pattern];
+	const prefix = pattern.slice(0, index);
+	const rest = pattern.slice(index);
+	let depth = 0;
+	let endIndex = -1;
+	for (let index = 0; index < rest.length; index++) {
+		const char = rest[index];
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				endIndex = index;
+				break;
+			}
+		}
+	}
+	if (endIndex === -1) return [pattern];
+	const inner = rest.slice(1, endIndex);
+	const suffix = rest.slice(endIndex + 1);
+	const parts = (isSequence(inner) ? expandSequence(inner) : segmentTopLevel(inner, ",", { keepEmpty: true })).flatMap((part) => expandInlineSourceCandidatePattern(part));
+	return expandInlineSourceCandidatePattern(suffix).flatMap((suffix) => parts.map((part) => `${prefix}${part}${suffix}`));
+}
+function parseSourceInlineParam(params) {
+	let value = params.trim();
+	const negated = value.startsWith("not ");
+	if (negated) value = value.slice(4).trim();
+	if (!value.startsWith("inline(") || !value.endsWith(")")) return;
+	const inlineValue = value.slice(7, -1).trim();
+	const match = /^(['"])([\s\S]*)\1$/.exec(inlineValue);
+	if (!match) return;
+	const source = match[2];
+	if (source === void 0) return;
+	return {
+		negated,
+		source
+	};
+}
+function collectCssInlineSourceCandidates(root) {
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceInlineParam(rule.params);
+		if (!parsed) return;
+		const target = parsed.negated ? excluded : included;
+		for (const source of segmentTopLevel(parsed.source, " ")) {
+			const trimmed = source.trim();
+			if (!trimmed) continue;
+			for (const candidate of expandInlineSourceCandidatePattern(trimmed)) {
+				const normalized = candidate.trim();
+				if (normalized) target.add(normalized);
+			}
+		}
+	});
+	for (const candidate of excluded) included.delete(candidate);
+	return {
+		included,
+		excluded
+	};
+}
+//#endregion
+//#region src/source-scan.ts
+async function resolveCssSourceEntries(root, base, defaultPattern = (0, _weapp_tailwindcss_source_scan.createSourceScanPattern)()) {
+	const entries = [];
+	const tasks = [];
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceFileParam(rule.params);
+		if (!parsed) return;
+		tasks.push((0, _weapp_tailwindcss_source_scan.resolveTailwindSourceEntry)(parsed.sourcePath, base, parsed.negated, defaultPattern));
+	});
+	entries.push(...await Promise.all(tasks));
+	return entries;
+}
+async function expandTailwindSourceEntries(entries, options = {}) {
+	return (0, _weapp_tailwindcss_source_scan.expandSourceEntries)(entries, ({ cwd, sources }) => (0, _weapp_tailwindcss_engine.resolveProjectSourceFiles)({
+		cwd,
+		sources,
+		...options.ignore ? { ignoredSources: options.ignore.map((pattern) => ({
+			base: cwd,
+			pattern: (0, _weapp_tailwindcss_source_scan.normalizeGlobPattern)(pattern),
+			negated: true
+		})) } : {}
+	}));
+}
+//#endregion
+//#region src/utils/apply-source.ts
+function normalizeGeneratedSelector(selector) {
+	return selector.replace(/:not\(#\\#\)/g, "").trim();
+}
+/** 复用调用方 AST，同时取得 apply 选择器和纯 apply 输入判定。 */
+function analyzeApplyOnlySourceRoot(root) {
+	const selectors = /* @__PURE__ */ new Set();
+	let hasApplyRule = false;
+	let hasNonApplyRule = false;
+	root.walkRules((rule) => {
+		if (!rule.nodes?.some((node) => node.type === "atrule" && node.name === "apply")) {
+			hasNonApplyRule = true;
+			return;
+		}
+		hasApplyRule = true;
+		for (const selector of rule.selectors ?? [rule.selector]) {
+			const normalized = normalizeGeneratedSelector(selector);
+			if (normalized) selectors.add(normalized);
+		}
+	});
+	return {
+		selectors,
+		onlyApply: hasApplyRule && !hasNonApplyRule
+	};
+}
+function analyzeApplyOnlySource(source) {
+	try {
+		return analyzeApplyOnlySourceRoot(postcss.default.parse(source));
+	} catch {
+		return {
+			selectors: /* @__PURE__ */ new Set(),
+			onlyApply: false
+		};
+	}
+}
+//#endregion
+//#region src/generator-plugin/apply-only.ts
+function collectApplyOnlyCssSelectorsRoot(root) {
+	return analyzeApplyOnlySourceRoot(root).selectors;
+}
+function collectApplyOnlyCssSelectors(css) {
+	try {
+		return collectApplyOnlyCssSelectorsRoot(postcss.default.parse(css));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function ruleMatchesApplyOnlySelector(rule, selectors) {
+	return (rule.selectors ?? [rule.selector]).some((selector) => selectors.has(normalizeGeneratedSelector(selector)));
+}
+function filterApplyOnlyGeneratedCssRoot(root, selectors) {
+	if (selectors.size === 0) return false;
+	let changed = false;
+	root.walkRules((rule) => {
+		if (ruleMatchesApplyOnlySelector(rule, selectors) || rule.nodes?.some((node) => node.type === "decl" && node.prop.startsWith("--"))) return;
+		rule.remove();
+		changed = true;
+	});
+	root.walkAtRules((rule) => {
+		if (rule.nodes !== void 0 && rule.nodes.length === 0) {
+			rule.remove();
+			changed = true;
+		}
+	});
+	return changed;
+}
+function filterApplyOnlyGeneratedCss(css, selectors) {
+	if (selectors.size === 0) return css;
+	try {
+		const root = postcss.default.parse(css);
+		return filterApplyOnlyGeneratedCssRoot(root, selectors) ? root.toString() : css;
+	} catch {
+		return css;
+	}
+}
+//#endregion
+//#region src/generator-plugin/config-directive.ts
+function normalizeConfigDirective(css, config) {
+	if (!config || !/@config\s+/.test(css)) return css;
+	return css.replace(/@config\s+(["'])(.+?)\1\s*;?/, `@config "${quoteCssString(toCssPath(config))}";`);
+}
+/** 保留预处理器文本兼容；请求解析与文件定位由调用方提供。 */
+function rewriteCssConfigRequests(source, resolve) {
+	return source.replace(/@config\s+(["'])(.+?)\1\s*;?/g, (full, quote, request) => {
+		const resolved = resolve(request);
+		return resolved === void 0 ? full : `@config ${quote}${resolved}${quote};`;
+	});
+}
+/** 保留 Vite 预处理前的行级清理语义，允许尚未编译的 Sass 等源码。 */
+function stripTailwindConfigDirectives(code) {
+	return code.replace(/^\s*@config\s+(?:"[^"]+"|'[^']+')[^;\n]*;\s*$/gm, "");
+}
+function quoteCssString(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+function toCssPath(value) {
+	return value.replaceAll("\\", "/");
+}
+function prependConfigDirective(css, config) {
+	if (!config || /@config\s+/.test(css)) return css;
+	return `@config "${quoteCssString(toCssPath(config))}";\n${css}`;
+}
+//#endregion
+//#region src/generator-plugin/directives.ts
+const TAILWIND_ROOT_DIRECTIVE_NAMES = /* @__PURE__ */ new Set([
+	"config",
+	"custom-variant",
+	"plugin",
+	"source",
+	"tailwind",
+	"theme",
+	"utility",
+	"variant"
+]);
+function createEmptyDirectiveAnalysis() {
+	return {
+		hasLocalCssImport: false,
+		hasTailwindApplyDirective: false,
+		hasTailwindNonRootGenerationDirectives: false,
+		hasTailwindRootDirectives: false,
+		hasTailwindRootImportDirectives: false,
+		hasTailwindSourceDirectives: false
+	};
+}
+function parseTailwindCssDirectiveRequest(params) {
+	return parseCssImportSpecifier(params)?.specifier;
+}
+function parseTailwindCssConfigRequest(params) {
+	return /^(["'])(.+)\1\s*;?$/.exec(params.trim())?.[2];
+}
+function isTailwindCssPackageJsonImportRequest(request) {
+	return typeof request === "string" && request.startsWith("#");
+}
+function isWeappTailwindcssImportRequest(request) {
+	return request === "weapp-tailwindcss" || request?.startsWith("weapp-tailwindcss/") === true;
+}
+function normalizeTailwindCssImportRequest(request, options = {}) {
+	return options.importFallback && (request === "weapp-tailwindcss" || request?.startsWith("weapp-tailwindcss/")) ? request.replace(/^weapp-tailwindcss/, "tailwindcss") : request;
+}
+function isTailwindCssImportRequest(request, options = {}) {
+	const normalized = normalizeTailwindCssImportRequest(request, options);
+	return normalized === "tailwindcss" || normalized === "tailwindcss4" || normalized?.startsWith("tailwindcss/") === true || normalized?.startsWith("tailwindcss4/") === true;
+}
+function isTailwindCssImportAtRule(node, options = {}) {
+	if (node.name === "tailwind") return true;
+	if (node.name !== "import" && node.name !== "use" && node.name !== "forward") return false;
+	return isTailwindCssImportRequest(parseTailwindCssDirectiveRequest(node.params), options);
+}
+function getTailwindCssDirectiveRequest(node) {
+	return node.name === "import" ? parseTailwindCssDirectiveRequest(node.params) : node.name === "config" || node.name === "plugin" || node.name === "reference" ? parseTailwindCssConfigRequest(node.params) : void 0;
+}
+function isTailwindCssGenerationDirective(node, options = {}) {
+	if (node.type !== "atrule") return false;
+	const atRule = node;
+	const request = getTailwindCssDirectiveRequest(atRule);
+	return isTailwindCssImportAtRule(atRule, options) || isTailwindCssPackageJsonImportRequest(request) || atRule.name === "apply" || !options.ignoreLayer && atRule.name === "layer" || atRule.name === "config" || atRule.name === "source";
+}
+function hasTailwindApplyDirective(css) {
+	return /@apply\b/.test(css);
+}
+function analyzeTailwindCssDirectives(root, options = {}) {
+	const analysis = createEmptyDirectiveAnalysis();
+	root.walk((node) => {
+		if (node.type !== "atrule") return;
+		const atRule = node;
+		if (atRule.name === "import") {
+			const request = parseTailwindCssDirectiveRequest(atRule.params);
+			if (request?.startsWith(".") === true || request?.startsWith("/") === true) analysis.hasLocalCssImport = true;
+		}
+		const isTailwindImport = isTailwindCssImportAtRule(atRule, options);
+		if (isTailwindImport) {
+			analysis.hasTailwindRootImportDirectives = true;
+			analysis.hasTailwindRootDirectives = true;
+		}
+		const request = atRule.name === "import" || atRule.name === "config" || atRule.name === "plugin" ? getTailwindCssDirectiveRequest(atRule) : void 0;
+		if (isTailwindImport || isTailwindCssPackageJsonImportRequest(request) || TAILWIND_ROOT_DIRECTIVE_NAMES.has(atRule.name)) analysis.hasTailwindRootDirectives = true;
+		if (atRule.name === "apply") analysis.hasTailwindApplyDirective = true;
+		if (isTailwindCssGenerationDirective(atRule, options)) {
+			analysis.hasTailwindSourceDirectives = true;
+			if (!isTailwindImport) analysis.hasTailwindNonRootGenerationDirectives = true;
+		}
+	});
+	return analysis;
+}
+function hasTailwindRootDirectives(root, options = {}) {
+	let found = false;
+	root.walkAtRules((rule) => {
+		if (rule.name === "import" && isTailwindCssImportRequest(parseTailwindCssDirectiveRequest(rule.params), options)) {
+			found = true;
+			return false;
+		}
+		if (TAILWIND_ROOT_DIRECTIVE_NAMES.has(rule.name)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+}
+//#endregion
+//#region src/source-scan/description.ts
+/** 只提取来源指令；默认扫描策略与配置加载由调用层决定。 */
+function describeCssSources(root, isSourceImport = isTailwindCssImport) {
+	const imports = [];
+	const sources = [];
+	const configs = [];
+	root.walkAtRules((rule) => {
+		if (rule.name === "import" && isSourceImport(rule.params)) imports.push(parseImportSourceParam(rule.params) ?? {});
+		else if (rule.name === "source") {
+			const source = parseSourceFileParam(rule.params);
+			if (source) sources.push(source);
+		} else if (rule.name === "config") {
+			const config = parseConfigParam(rule.params);
+			if (config) configs.push(config);
+		}
+	});
+	return {
+		imports,
+		sources,
+		configs,
+		inlineCandidates: collectCssInlineSourceCandidates(root)
+	};
+}
+//#endregion
+//#region src/source-scan/resolve.ts
+/** 将 AST 描述与配置 content 合并，再交给共享扫描策略生成执行计划。 */
+async function resolveCssScanSources(definitions, policy) {
+	const entries = [];
+	const configEntries = [];
+	const configGroups = [];
+	const configPaths = /* @__PURE__ */ new Set();
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	let automaticBase;
+	let sourceNone = false;
+	let hasImport = false;
+	for (const { root, base } of definitions) {
+		const descriptor = describeCssSources(root);
+		hasImport ||= descriptor.imports.length > 0;
+		sourceNone ||= descriptor.imports.some((item) => item.none);
+		for (const item of descriptor.imports) if (item.sourcePath) automaticBase = (0, _weapp_tailwindcss_source_scan.sourcePathApi)(base, item.sourcePath).resolve(base, item.sourcePath);
+		for (const source of descriptor.sources) entries.push(await (0, _weapp_tailwindcss_source_scan.resolveTailwindSourceEntry)(source.sourcePath, base, source.negated, policy.pattern));
+		for (const value of descriptor.inlineCandidates.included) included.add(value);
+		for (const value of descriptor.inlineCandidates.excluded) excluded.add(value);
+		for (const request of descriptor.configs) configPaths.add(policy.configResolution === "module" ? (0, node_module.createRequire)(node_path.default.join(base, "package.json")).resolve(request) : (0, _weapp_tailwindcss_source_scan.sourcePathApi)(base, request).resolve(base, request));
+	}
+	if (policy.config) configPaths.add((0, _weapp_tailwindcss_source_scan.sourcePathApi)(policy.base, policy.config).resolve(policy.base, policy.config));
+	for (const config of policy.loadConfigContent === false ? [] : configPaths) {
+		const base = node_path.default.dirname(config);
+		const loaded = await (0, tailwindcss_config.loadConfig)({
+			config,
+			cwd: base
+		});
+		const group = (0, _weapp_tailwindcss_source_scan.normalizeLegacyContentEntries)(loaded?.config.content, base, { relativeBase: base });
+		configGroups.push(group);
+		configEntries.push(...group);
+	}
+	const explicitEntries = policy.sourceEntries ?? entries;
+	const combinedEntries = [...explicitEntries, ...configEntries];
+	let mode = policy.automatic;
+	if (mode !== "disabled") {
+		if (automaticBase) mode = "auto";
+		else if (sourceNone || policy.requireImport && !hasImport && combinedEntries.length === 0) mode = "disabled";
+	}
+	const base = automaticBase ?? (combinedEntries.length > 0 ? policy.base : policy.defaultBase ?? policy.base);
+	return {
+		entries: (0, _weapp_tailwindcss_source_scan.createSourceScanPlan)({
+			base,
+			mode,
+			entries: combinedEntries,
+			pattern: policy.pattern,
+			...policy.ignoredPatterns ? { ignoredPatterns: policy.ignoredPatterns } : {}
+		}),
+		explicitEntries,
+		configEntries,
+		configGroups,
+		configPaths: [...configPaths],
+		inlineCandidates: {
+			included,
+			excluded
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "CLAMP_PX", {
+	enumerable: true,
+	get: function() {
+		return CLAMP_PX;
+	}
+});
+Object.defineProperty(exports, "COLOR_GAMUT_P3_RE", {
+	enumerable: true,
+	get: function() {
+		return COLOR_GAMUT_P3_RE$1;
+	}
+});
+Object.defineProperty(exports, "DISPLAY_P3_COLOR_RE", {
+	enumerable: true,
+	get: function() {
+		return DISPLAY_P3_COLOR_RE;
+	}
+});
+Object.defineProperty(exports, "DISPLAY_P3_VALUE_RE", {
+	enumerable: true,
+	get: function() {
+		return DISPLAY_P3_VALUE_RE$1;
+	}
+});
+Object.defineProperty(exports, "INFINITY_CALC_VALUE_REGEXP", {
+	enumerable: true,
+	get: function() {
+		return INFINITY_CALC_VALUE_REGEXP;
+	}
+});
+Object.defineProperty(exports, "LINEAR_GRADIENT_LAB_RE", {
+	enumerable: true,
+	get: function() {
+		return LINEAR_GRADIENT_LAB_RE;
+	}
+});
+Object.defineProperty(exports, "MINI_PROGRAM_ELEMENT_SCOPE_SELECTOR", {
+	enumerable: true,
+	get: function() {
+		return MINI_PROGRAM_ELEMENT_SCOPE_SELECTOR;
+	}
+});
+Object.defineProperty(exports, "MINI_PROGRAM_ELEMENT_SCOPE_SELECTORS", {
+	enumerable: true,
+	get: function() {
+		return MINI_PROGRAM_ELEMENT_SCOPE_SELECTORS;
+	}
+});
+Object.defineProperty(exports, "MODERN_CHECK_COLOR_RGB_RE", {
+	enumerable: true,
+	get: function() {
+		return MODERN_CHECK_COLOR_RGB_RE;
+	}
+});
+Object.defineProperty(exports, "MODERN_CHECK_MARGIN_TRIM_RE", {
+	enumerable: true,
+	get: function() {
+		return MODERN_CHECK_MARGIN_TRIM_RE;
+	}
+});
+Object.defineProperty(exports, "MODERN_CHECK_MOZ_ORIENT_RE", {
+	enumerable: true,
+	get: function() {
+		return MODERN_CHECK_MOZ_ORIENT_RE;
+	}
+});
+Object.defineProperty(exports, "MODERN_CHECK_WEBKIT_HYPHENS_RE", {
+	enumerable: true,
+	get: function() {
+		return MODERN_CHECK_WEBKIT_HYPHENS_RE;
+	}
+});
+Object.defineProperty(exports, "analyzeApplyOnlySource", {
+	enumerable: true,
+	get: function() {
+		return analyzeApplyOnlySource;
+	}
+});
+Object.defineProperty(exports, "analyzeTailwindCssDirectives", {
+	enumerable: true,
+	get: function() {
+		return analyzeTailwindCssDirectives;
+	}
+});
+Object.defineProperty(exports, "appendTailwindcssV4MiniProgramGradientRules", {
+	enumerable: true,
+	get: function() {
+		return appendTailwindcssV4MiniProgramGradientRules;
+	}
+});
+Object.defineProperty(exports, "collectApplyOnlyCssSelectors", {
+	enumerable: true,
+	get: function() {
+		return collectApplyOnlyCssSelectors;
+	}
+});
+Object.defineProperty(exports, "collectApplyOnlyCssSelectorsRoot", {
+	enumerable: true,
+	get: function() {
+		return collectApplyOnlyCssSelectorsRoot;
+	}
+});
+Object.defineProperty(exports, "collectCssInlineSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return collectCssInlineSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "collectUsedTailwindcssV4Variables", {
+	enumerable: true,
+	get: function() {
+		return collectUsedTailwindcssV4Variables;
+	}
+});
+Object.defineProperty(exports, "consumeCascadeLayers", {
+	enumerable: true,
+	get: function() {
+		return consumeCascadeLayers;
+	}
+});
+Object.defineProperty(exports, "createMissingCssVarsV4Nodes", {
+	enumerable: true,
+	get: function() {
+		return createMissingCssVarsV4Nodes;
+	}
+});
+Object.defineProperty(exports, "createUsedCssVarsV4Nodes", {
+	enumerable: true,
+	get: function() {
+		return createUsedCssVarsV4Nodes;
+	}
+});
+Object.defineProperty(exports, "describeCssSources", {
+	enumerable: true,
+	get: function() {
+		return describeCssSources;
+	}
+});
+Object.defineProperty(exports, "expandInlineSourceCandidatePattern", {
+	enumerable: true,
+	get: function() {
+		return expandInlineSourceCandidatePattern;
+	}
+});
+Object.defineProperty(exports, "expandTailwindSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return expandTailwindSourceEntries;
+	}
+});
+Object.defineProperty(exports, "filterApplyOnlyGeneratedCss", {
+	enumerable: true,
+	get: function() {
+		return filterApplyOnlyGeneratedCss;
+	}
+});
+Object.defineProperty(exports, "filterApplyOnlyGeneratedCssRoot", {
+	enumerable: true,
+	get: function() {
+		return filterApplyOnlyGeneratedCssRoot;
+	}
+});
+Object.defineProperty(exports, "finalizeMiniProgramCss", {
+	enumerable: true,
+	get: function() {
+		return finalizeMiniProgramCss;
+	}
+});
+Object.defineProperty(exports, "finalizeMiniProgramCssRoot", {
+	enumerable: true,
+	get: function() {
+		return finalizeMiniProgramCssRoot;
+	}
+});
+Object.defineProperty(exports, "getRuleSelectors", {
+	enumerable: true,
+	get: function() {
+		return getRuleSelectors;
+	}
+});
+Object.defineProperty(exports, "hasMiniProgramCssSpecificityPlaceholders", {
+	enumerable: true,
+	get: function() {
+		return hasMiniProgramCssSpecificityPlaceholders;
+	}
+});
+Object.defineProperty(exports, "hasTailwindApplyDirective", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindApplyDirective;
+	}
+});
+Object.defineProperty(exports, "hasTailwindRootDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindRootDirectives;
+	}
+});
+Object.defineProperty(exports, "hoistTailwindPreflightBase", {
+	enumerable: true,
+	get: function() {
+		return hoistTailwindPreflightBase;
+	}
+});
+Object.defineProperty(exports, "isBrowserElementPreflightRule", {
+	enumerable: true,
+	get: function() {
+		return isBrowserElementPreflightRule;
+	}
+});
+Object.defineProperty(exports, "isCustomPropertyRule", {
+	enumerable: true,
+	get: function() {
+		return isCustomPropertyRule;
+	}
+});
+Object.defineProperty(exports, "isEmptyTwContentDeclaration", {
+	enumerable: true,
+	get: function() {
+		return isEmptyTwContentDeclaration;
+	}
+});
+Object.defineProperty(exports, "isMiniProgramNativeElementSelector", {
+	enumerable: true,
+	get: function() {
+		return isMiniProgramNativeElementSelector;
+	}
+});
+Object.defineProperty(exports, "isMiniProgramPreflightRule", {
+	enumerable: true,
+	get: function() {
+		return isMiniProgramPreflightRule;
+	}
+});
+Object.defineProperty(exports, "isMiniProgramThemeScopeSelector", {
+	enumerable: true,
+	get: function() {
+		return isMiniProgramThemeScopeSelector;
+	}
+});
+Object.defineProperty(exports, "isMiniProgramThemeVariableRule", {
+	enumerable: true,
+	get: function() {
+		return isMiniProgramThemeVariableRule;
+	}
+});
+Object.defineProperty(exports, "isPseudoContentInitRule", {
+	enumerable: true,
+	get: function() {
+		return isPseudoContentInitRule;
+	}
+});
+Object.defineProperty(exports, "isTailwindCssGenerationDirective", {
+	enumerable: true,
+	get: function() {
+		return isTailwindCssGenerationDirective;
+	}
+});
+Object.defineProperty(exports, "isTailwindCssImport", {
+	enumerable: true,
+	get: function() {
+		return isTailwindCssImport;
+	}
+});
+Object.defineProperty(exports, "isTailwindCssImportAtRule", {
+	enumerable: true,
+	get: function() {
+		return isTailwindCssImportAtRule;
+	}
+});
+Object.defineProperty(exports, "isTailwindCssImportRequest", {
+	enumerable: true,
+	get: function() {
+		return isTailwindCssImportRequest;
+	}
+});
+Object.defineProperty(exports, "isTailwindCssPackageJsonImportRequest", {
+	enumerable: true,
+	get: function() {
+		return isTailwindCssPackageJsonImportRequest;
+	}
+});
+Object.defineProperty(exports, "isTailwindcssV4", {
+	enumerable: true,
+	get: function() {
+		return isTailwindcssV4;
+	}
+});
+Object.defineProperty(exports, "isTailwindcssV4ThemeVariable", {
+	enumerable: true,
+	get: function() {
+		return isTailwindcssV4ThemeVariable;
+	}
+});
+Object.defineProperty(exports, "isUnsupportedBrowserPreflightSelector", {
+	enumerable: true,
+	get: function() {
+		return isUnsupportedBrowserPreflightSelector;
+	}
+});
+Object.defineProperty(exports, "isWeappTailwindcssImportRequest", {
+	enumerable: true,
+	get: function() {
+		return isWeappTailwindcssImportRequest;
+	}
+});
+Object.defineProperty(exports, "mergeTailwindcssV4GradientDirectionRules", {
+	enumerable: true,
+	get: function() {
+		return mergeTailwindcssV4GradientDirectionRules;
+	}
+});
+Object.defineProperty(exports, "normalizeConfigDirective", {
+	enumerable: true,
+	get: function() {
+		return normalizeConfigDirective;
+	}
+});
+Object.defineProperty(exports, "normalizeGeneratedSelector", {
+	enumerable: true,
+	get: function() {
+		return normalizeGeneratedSelector;
+	}
+});
+Object.defineProperty(exports, "normalizeMiniProgramPrefixedDeclaration", {
+	enumerable: true,
+	get: function() {
+		return normalizeMiniProgramPrefixedDeclaration;
+	}
+});
+Object.defineProperty(exports, "normalizeModernColorValue", {
+	enumerable: true,
+	get: function() {
+		return normalizeModernColorValue;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindCssImportRequest", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindCssImportRequest;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindcssV4Declaration", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindcssV4Declaration;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindcssV4InfinityCalcCss", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindcssV4InfinityCalcCss;
+	}
+});
+Object.defineProperty(exports, "normalizeWebCssCompatOptions", {
+	enumerable: true,
+	get: function() {
+		return normalizeWebCssCompatOptions;
+	}
+});
+Object.defineProperty(exports, "parseConfigParam", {
+	enumerable: true,
+	get: function() {
+		return parseConfigParam;
+	}
+});
+Object.defineProperty(exports, "parseCssImportSpecifier", {
+	enumerable: true,
+	get: function() {
+		return parseCssImportSpecifier;
+	}
+});
+Object.defineProperty(exports, "parseImportSourceParam", {
+	enumerable: true,
+	get: function() {
+		return parseImportSourceParam;
+	}
+});
+Object.defineProperty(exports, "parseSourceFileParam", {
+	enumerable: true,
+	get: function() {
+		return parseSourceFileParam;
+	}
+});
+Object.defineProperty(exports, "parseTailwindCssConfigRequest", {
+	enumerable: true,
+	get: function() {
+		return parseTailwindCssConfigRequest;
+	}
+});
+Object.defineProperty(exports, "parseTailwindCssDirectiveRequest", {
+	enumerable: true,
+	get: function() {
+		return parseTailwindCssDirectiveRequest;
+	}
+});
+Object.defineProperty(exports, "prependConfigDirective", {
+	enumerable: true,
+	get: function() {
+		return prependConfigDirective;
+	}
+});
+Object.defineProperty(exports, "protectDynamicColorMixAlpha", {
+	enumerable: true,
+	get: function() {
+		return protectDynamicColorMixAlpha;
+	}
+});
+Object.defineProperty(exports, "protectDynamicVarFallbacks", {
+	enumerable: true,
+	get: function() {
+		return protectDynamicVarFallbacks;
+	}
+});
+Object.defineProperty(exports, "quoteCssImportSpecifier", {
+	enumerable: true,
+	get: function() {
+		return quoteCssImportSpecifier;
+	}
+});
+Object.defineProperty(exports, "removeEmptyAtRules", {
+	enumerable: true,
+	get: function() {
+		return removeEmptyAtRules$1;
+	}
+});
+Object.defineProperty(exports, "removeEmptyBlockAtRules", {
+	enumerable: true,
+	get: function() {
+		return removeEmptyBlockAtRules;
+	}
+});
+Object.defineProperty(exports, "removeEmptyRules", {
+	enumerable: true,
+	get: function() {
+		return removeEmptyRules;
+	}
+});
+Object.defineProperty(exports, "removeEmptyStandardDeclarations", {
+	enumerable: true,
+	get: function() {
+		return removeEmptyStandardDeclarations;
+	}
+});
+Object.defineProperty(exports, "removeSpecificityPlaceholders", {
+	enumerable: true,
+	get: function() {
+		return removeSpecificityPlaceholders;
+	}
+});
+Object.defineProperty(exports, "removeTailwindContainerMaxWidthMediaRules", {
+	enumerable: true,
+	get: function() {
+		return removeTailwindContainerMaxWidthMediaRules;
+	}
+});
+Object.defineProperty(exports, "removeTailwindContainerWidthRules", {
+	enumerable: true,
+	get: function() {
+		return removeTailwindContainerWidthRules;
+	}
+});
+Object.defineProperty(exports, "removeUnsupportedAtSupports", {
+	enumerable: true,
+	get: function() {
+		return removeUnsupportedAtSupports;
+	}
+});
+Object.defineProperty(exports, "removeUnsupportedCascadeLayers", {
+	enumerable: true,
+	get: function() {
+		return removeUnsupportedCascadeLayers;
+	}
+});
+Object.defineProperty(exports, "removeUnsupportedMiniProgramAtRules", {
+	enumerable: true,
+	get: function() {
+		return removeUnsupportedMiniProgramAtRules;
+	}
+});
+Object.defineProperty(exports, "removeUnsupportedMiniProgramPrefixedAtRule", {
+	enumerable: true,
+	get: function() {
+		return removeUnsupportedMiniProgramPrefixedAtRule;
+	}
+});
+Object.defineProperty(exports, "removeUnsupportedModernColorDeclarations", {
+	enumerable: true,
+	get: function() {
+		return removeUnsupportedModernColorDeclarations;
+	}
+});
+Object.defineProperty(exports, "repairTrailingUnclosedTailwindSourceMedia", {
+	enumerable: true,
+	get: function() {
+		return repairTrailingUnclosedTailwindSourceMedia;
+	}
+});
+Object.defineProperty(exports, "resolveCssScanSources", {
+	enumerable: true,
+	get: function() {
+		return resolveCssScanSources;
+	}
+});
+Object.defineProperty(exports, "resolveCssSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return resolveCssSourceEntries;
+	}
+});
+Object.defineProperty(exports, "rewriteCssConfigRequests", {
+	enumerable: true,
+	get: function() {
+		return rewriteCssConfigRequests;
+	}
+});
+Object.defineProperty(exports, "stripMiniProgramCssSpecificityPlaceholders", {
+	enumerable: true,
+	get: function() {
+		return stripMiniProgramCssSpecificityPlaceholders;
+	}
+});
+Object.defineProperty(exports, "stripTailwindConfigDirectives", {
+	enumerable: true,
+	get: function() {
+		return stripTailwindConfigDirectives;
+	}
+});
+Object.defineProperty(exports, "testIfRootHostForV4", {
+	enumerable: true,
+	get: function() {
+		return testIfRootHostForV4;
+	}
+});
+Object.defineProperty(exports, "transformLynxCssCompat", {
+	enumerable: true,
+	get: function() {
+		return transformLynxCssCompat;
+	}
+});
+Object.defineProperty(exports, "transformWebCssCompat", {
+	enumerable: true,
+	get: function() {
+		return transformWebCssCompat;
+	}
+});
+Object.defineProperty(exports, "transformWebCssSafeSelectors", {
+	enumerable: true,
+	get: function() {
+		return transformWebCssSafeSelectors;
+	}
+});
+Object.defineProperty(exports, "unwrapUnsupportedCascadeLayers", {
+	enumerable: true,
+	get: function() {
+		return unwrapUnsupportedCascadeLayers;
+	}
+});
+Object.defineProperty(exports, "usesTailwindcssV4ContentVariable", {
+	enumerable: true,
+	get: function() {
+		return usesTailwindcssV4ContentVariable;
+	}
+});
+Object.defineProperty(exports, "usesTwContentVariable", {
+	enumerable: true,
+	get: function() {
+		return usesTwContentVariable;
+	}
+});