@weapp-tailwindcss/postcss 2.2.1-next.5 → 3.0.0-next.7

package/dist/index.js

@@ -22,6 +22,8 @@ let postcss_pxtrans = require("postcss-pxtrans");
 postcss_pxtrans = require_html_transform.__toESM(postcss_pxtrans);
 let postcss_rem_to_responsive_pixel = require("postcss-rem-to-responsive-pixel");
 postcss_rem_to_responsive_pixel = require_html_transform.__toESM(postcss_rem_to_responsive_pixel);
+let node_process = require("node:process");
+node_process = require_html_transform.__toESM(node_process);
 let postcss_rule_unit_converter = require("postcss-rule-unit-converter");
 postcss_rule_unit_converter = require_html_transform.__toESM(postcss_rule_unit_converter);
 let _weapp_core_escape = require("@weapp-core/escape");
@@ -274,6 +276,72 @@ function protectDynamicColorMixAlpha(css, options = {}) {
 	};
 }
 //#endregion
+//#region src/compat/mini-program-css/at-rules.ts
+const MINI_PROGRAM_UNSUPPORTED_AT_RULES = 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) {
+	root.walkAtRules("layer", (atRule) => {
+		if (!atRule.nodes || atRule.nodes.length === 0) {
+			atRule.remove();
+			return;
+		}
+		atRule.replaceWith(...atRule.nodes);
+	});
+}
+//#endregion
 //#region src/compat/mini-program-prefixes.ts
 const PRESERVED_WEBKIT_DECLARATION_PROPS = new Set([
 	"-webkit-box-orient",
@@ -286,7 +354,7 @@ const PRESERVED_WEBKIT_DECLARATION_PROPS = new Set([
 ]);
 const PRESERVED_WEBKIT_VALUE_DECLARATIONS = new Map([["display", new Set(["-webkit-box"])], ["-webkit-background-clip", new Set(["text"])]]);
 const TRANSITION_PROPS = new Set(["transition", "transition-property"]);
-function splitTopLevelCommaList(value) {
+function splitTopLevelCommaList$1(value) {
 	const parts = [];
 	let start = 0;
 	let depth = 0;
@@ -333,7 +401,7 @@ function isPreservedWebkitDeclaration(decl) {
 	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(", ");
+	return splitTopLevelCommaList$1(value).map((part) => part.trim()).filter((part) => part.length > 0 && !part.toLowerCase().startsWith("-webkit-")).join(", ");
 }
 function hasUnsupportedWebkitKeywordValue(decl) {
 	const value = decl.value.trim().toLowerCase();
@@ -364,6 +432,506 @@ function removeUnsupportedMiniProgramPrefixedAtRule(atRule) {
 	if (atRule.name.toLowerCase() === "-webkit-keyframes") atRule.remove();
 }
 //#endregion
+//#region src/compat/mini-program-css/color-gamut.ts
+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;
+function isDisplayP3MediaRule(atRule) {
+	return atRule.name === "media" && COLOR_GAMUT_P3_RE$1.test(atRule.params);
+}
+function isDisplayP3Declaration(decl) {
+	return DISPLAY_P3_VALUE_RE$1.test(decl.value);
+}
+//#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_PREFLIGHT_SELECTORS = new Set([
+	"*",
+	"view",
+	"text",
+	":before",
+	":after",
+	"::before",
+	"::after"
+]);
+const MINI_PROGRAM_THEME_SCOPE_SELECTORS = new Set([
+	":host",
+	":root",
+	"page",
+	".tw-root",
+	"wx-root-portal-content"
+]);
+const SPECIFICITY_PLACEHOLDER_SUFFIXES = [":not(#n)", ":not(#\\#)"];
+const MINI_PROGRAM_UNSUPPORTED_BROWSER_SELECTORS = 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 = 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"
+]);
+function normalizeSelector$1(selector) {
+	return selector.trim().replace(/\s+/g, "");
+}
+function getRuleSelectors(rule) {
+	return rule.selector.split(",").map(normalizeSelector$1).filter(Boolean);
+}
+function isUnsupportedBrowserSelector(selector) {
+	const normalized = normalizeSelector$1(selector);
+	return MINI_PROGRAM_UNSUPPORTED_BROWSER_SELECTORS.has(normalized) || MINI_PROGRAM_UNSUPPORTED_BROWSER_TAG_SELECTORS.has(normalized);
+}
+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 = 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/;
+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 hasTwContentDeclaration(rule) {
+	let hasContentInit = false;
+	rule.walkDecls("--tw-content", () => {
+		hasContentInit = true;
+	});
+	return hasContentInit;
+}
+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;
+	return isMiniProgramPreflightSelector(getRuleSelectors(node)) && hasTailwindPreflightDeclaration(node);
+}
+function isMiniProgramThemeVariableRule(node) {
+	if (node.type !== "rule") return false;
+	return isMiniProgramThemeScopeSelector(getRuleSelectors(node)) && isCustomPropertyRule(node);
+}
+//#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 removeEmptyAtRuleAncestors(parent) {
+	while (parent?.type === "atrule" && (!parent.nodes || parent.nodes.length === 0)) {
+		const nextParent = parent.parent;
+		parent.remove();
+		parent = nextParent?.type === "atrule" ? nextParent : void 0;
+	}
+}
+function removeUnsupportedBrowserSelectors(root) {
+	root.walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) 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$1(decl) {
+	const parent = decl.parent;
+	decl.remove();
+	if (parent?.type === "rule" && parent.nodes.length === 0) {
+		const ruleParent = parent.parent;
+		parent.remove();
+		removeEmptyAtRuleAncestors(ruleParent);
+	}
+}
+function removeDisplayP3Declarations(root) {
+	root.walkAtRules((atRule) => {
+		if (isDisplayP3MediaRule(atRule)) {
+			const parent = atRule.parent;
+			atRule.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$1(decl);
+	});
+}
+//#endregion
+//#region src/compat/mini-program-css/finalize.ts
+const HOIST_ANCHOR_COMMENT = "__weapp_tailwindcss_base_anchor__";
+function createPseudoContentInitRule() {
+	const rule = postcss.default.rule({ selector: "::before,\n::after" });
+	rule.append({
+		prop: "--tw-content",
+		value: "''"
+	});
+	return rule;
+}
+function collectPreflightRules(root, options = {}) {
+	const preflightNodes = [];
+	let hasContentInit = false;
+	for (const node of root.nodes ?? []) if (isMiniProgramPreflightRule(node)) {
+		preflightNodes.push(node);
+		if (hasTwContentDeclaration(node)) hasContentInit = true;
+	}
+	if (preflightNodes.length === 0) return [];
+	const clonedPreflightRules = preflightNodes.map((node) => node.clone());
+	const contentInitRules = options.preservePseudoContentInit ? clonedPreflightRules.filter((rule) => hasTwContentDeclaration(rule)) : [];
+	const otherPreflightRules = clonedPreflightRules.filter((rule) => !hasTwContentDeclaration(rule));
+	const preflightRules = hasContentInit ? [...contentInitRules, ...otherPreflightRules] : [...options.preservePseudoContentInit ? [createPseudoContentInitRule()] : [], ...otherPreflightRules];
+	for (const node of preflightNodes) node.remove();
+	return preflightRules;
+}
+function createPreflightResetRule(cssPreflight) {
+	if (!cssPreflight || typeof cssPreflight !== "object") return;
+	const rule = postcss.default.rule({ selector: "view,text,:after,:before" });
+	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;
+}
+function collectThemeVariableRule(root, options = {}) {
+	const themeRules = [];
+	const declarations = /* @__PURE__ */ new Map();
+	const shouldPreserveContentInit = options.preservePseudoContentInit || usesTwContentVariable(root);
+	for (const node of root.nodes ?? []) {
+		if (!isMiniProgramThemeVariableRule(node)) continue;
+		themeRules.push(node);
+		node.walkDecls((decl) => {
+			if (isDisplayP3Declaration(decl)) 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: MINI_PROGRAM_THEME_SCOPE_SELECTOR });
+	for (const decl of declarations.values()) rule.append(decl);
+	return rule;
+}
+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 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 unwrapTailwindSourceMedia(root) {
+	root.walkAtRules("media", (atRule) => {
+		if (atRule.params.startsWith("source(") && atRule.nodes && atRule.nodes.length > 0) atRule.replaceWith(...atRule.nodes);
+	});
+}
+function finalizeMiniProgramCssRoot(root, options = {}) {
+	removeUnsupportedCascadeLayers(root);
+	unwrapTailwindSourceMedia(root);
+	root.walkAtRules("property", (atRule) => {
+		atRule.remove();
+	});
+	removeSpecificityPlaceholders(root);
+	removeUnsupportedBrowserSelectors(root);
+	removeDisplayP3Declarations(root);
+	removeUnsupportedModernColorDeclarations(root);
+	root.walkDecls((decl) => {
+		normalizeMiniProgramPrefixedDeclaration(decl);
+	});
+	root.walkAtRules((atRule) => {
+		removeUnsupportedMiniProgramPrefixedAtRule(atRule);
+	});
+	const hoistAnchor = createHoistInsertionAnchor(root);
+	const preflightRules = collectPreflightRules(root, options);
+	if (preflightRules.length === 0) {
+		const resetRule = createPreflightResetRule(options.cssPreflight);
+		if (resetRule) preflightRules.push(resetRule);
+	}
+	const themeRule = collectThemeVariableRule(root, options);
+	insertHoistedRules(root, themeRule ? [...preflightRules, themeRule] : preflightRules, hoistAnchor);
+}
+function hoistTailwindPreflightBase(css) {
+	try {
+		const root = postcss.default.parse(css);
+		insertHoistedRules(root, collectPreflightRules(root, { preservePseudoContentInit: true }));
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+function finalizeMiniProgramCss(css, options = {}) {
+	const cleanedCss = removeUnsupportedMiniProgramAtRules(css);
+	try {
+		const root = postcss.default.parse(cleanedCss);
+		finalizeMiniProgramCssRoot(root, options);
+		return root.toString();
+	} catch {
+		return cleanedCss;
+	}
+}
+//#endregion
+//#region src/compat/mini-program-css/prune-generated.ts
+const DEFAULT_WEAPP_VARIABLE_SCOPE = "page,.tw-root,wx-root-portal-content,:host";
+const DEFAULT_WEAPP_ELEMENT_VARIABLE_SCOPE = "view,text,:before,:after";
+const CLASS_SELECTOR_RE$1 = /(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i;
+const MINI_PROGRAM_ELEMENT_VARIABLE_SCOPE_SELECTORS = new Set([
+	"view",
+	"text",
+	":before",
+	":after",
+	"::before",
+	"::after"
+]);
+function isConditionalCompilationComment(text) {
+	return /#(?:ifn?def|endif)\b/.test(text);
+}
+function hasClassSelector$2(selector) {
+	return CLASS_SELECTOR_RE$1.test(selector);
+}
+function removeEmptyContentInitDeclarations(rule) {
+	rule.walkDecls((decl) => {
+		if (isEmptyTwContentDeclaration(decl)) decl.remove();
+	});
+}
+function isMiniProgramElementVariableScopeRule(rule) {
+	const selectors = getRuleSelectors(rule);
+	return selectors.length > 0 && selectors.every((selector) => MINI_PROGRAM_ELEMENT_VARIABLE_SCOPE_SELECTORS.has(selector));
+}
+function isTailwindV4GradientRuntimeDeclaration(decl) {
+	return decl.prop.startsWith("--tw-gradient-");
+}
+function moveTailwindV4GradientRuntimeDeclarations(rule) {
+	const gradientDeclarations = [];
+	rule.walkDecls((decl) => {
+		if (isTailwindV4GradientRuntimeDeclaration(decl)) {
+			gradientDeclarations.push(decl.clone());
+			decl.remove();
+		}
+	});
+	if (gradientDeclarations.length > 0) rule.before(new postcss.default.Rule({
+		selector: DEFAULT_WEAPP_ELEMENT_VARIABLE_SCOPE,
+		nodes: gradientDeclarations
+	}));
+	if (rule.nodes.length === 0) rule.remove();
+}
+function isKeyframesRule(rule) {
+	let parent = rule.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name.endsWith("keyframes")) return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+/**
+* 裁剪 Tailwind 生成 CSS 中面向浏览器的 classless 规则。
+*/
+function pruneMiniProgramGeneratedCss(css, options = {}) {
+	const root = postcss.default.parse(css);
+	const shouldPreserveContentInit = options.preservePreflight || usesTwContentVariable(root);
+	root.walkComments((comment) => {
+		if (options.preserveConditionalComments && isConditionalCompilationComment(comment.text)) return;
+		comment.remove();
+	});
+	removeUnsupportedCascadeLayers(root);
+	removeUnsupportedModernColorDeclarations(root);
+	root.walkAtRules("supports", (atRule) => {
+		atRule.remove();
+	});
+	root.walkAtRules((atRule) => {
+		removeUnsupportedMiniProgramPrefixedAtRule(atRule);
+	});
+	root.walkDecls((decl) => {
+		normalizeMiniProgramPrefixedDeclaration(decl);
+	});
+	root.walkRules((rule) => {
+		if (isKeyframesRule(rule)) return;
+		if (isCustomPropertyRule(rule) && isMiniProgramElementVariableScopeRule(rule)) {
+			rule.selector = DEFAULT_WEAPP_ELEMENT_VARIABLE_SCOPE;
+			return;
+		}
+		if (isMiniProgramThemeVariableRule(rule)) {
+			moveTailwindV4GradientRuntimeDeclarations(rule);
+			if (!rule.parent) return;
+			rule.selector = DEFAULT_WEAPP_VARIABLE_SCOPE;
+			return;
+		}
+		if (hasClassSelector$2(rule.selector)) return;
+		if (!shouldPreserveContentInit) removeEmptyContentInitDeclarations(rule);
+		if (isPseudoContentInitRule(rule)) {
+			if (!shouldPreserveContentInit) rule.remove();
+			return;
+		}
+		if (options.preservePreflight && isMiniProgramPreflightRule(rule)) return;
+		if (isCustomPropertyRule(rule)) {
+			moveTailwindV4GradientRuntimeDeclarations(rule);
+			if (!rule.parent) return;
+			rule.selector = DEFAULT_WEAPP_VARIABLE_SCOPE;
+			return;
+		}
+		rule.remove();
+	});
+	root.walkAtRules((atRule) => {
+		if (!atRule.nodes || atRule.nodes.length === 0) atRule.remove();
+	});
+	return root.toString();
+}
+//#endregion
 //#region src/compat/uni-app-x.ts
 const UNI_APP_X_BASE_CARRIER_SELECTORS = new Set([
 	"*",
@@ -640,6 +1208,8 @@ function getSimpleOverrideCacheKey(options) {
 	let rem2rpx = SIMPLE_OVERRIDE_UNSET;
 	let px2rpx = SIMPLE_OVERRIDE_UNSET;
 	let unitsToPx = SIMPLE_OVERRIDE_UNSET;
+	let unitConversion = SIMPLE_OVERRIDE_UNSET;
+	let platform = SIMPLE_OVERRIDE_UNSET;
 	let cssCalc = SIMPLE_OVERRIDE_UNSET;
 	let cssChildCombinatorReplaceValue = SIMPLE_OVERRIDE_UNSET;
 	let cssPreflight = SIMPLE_OVERRIDE_UNSET;
@@ -687,6 +1257,14 @@ function getSimpleOverrideCacheKey(options) {
 				if (typeof value !== "boolean") return;
 				unitsToPx = value ? "1" : "0";
 				break;
+			case "unitConversion":
+				if (value !== false) return;
+				unitConversion = "0";
+				break;
+			case "platform":
+				if (typeof value !== "string") return;
+				platform = value;
+				break;
 			case "cssCalc":
 				if (typeof value !== "boolean") return;
 				cssCalc = value ? "1" : "0";
@@ -718,6 +1296,8 @@ function getSimpleOverrideCacheKey(options) {
 		rem2rpx,
 		px2rpx,
 		unitsToPx,
+		unitConversion,
+		platform,
 		cssCalc,
 		cssChildCombinatorReplaceValue,
 		cssPreflight,
@@ -906,7 +1486,24 @@ function getCalcDuplicateCleaner(options) {
 	return calcDuplicateCleanerPlugin;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/object/omit.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/object/omit.mjs
+/**
+* Creates a new object with specified keys omitted.
+*
+* This function takes an object and an array of keys, and returns a new object that
+* excludes the properties corresponding to the specified keys.
+*
+* @template T - The type of object.
+* @template K - The type of keys in object.
+* @param {T} obj - The object to omit keys from.
+* @param {K[]} keys - An array of keys to be omitted from the object.
+* @returns {Omit<T, K>} A new object with the specified keys omitted.
+*
+* @example
+* const obj = { a: 1, b: 2, c: 3 };
+* const result = omit(obj, ['b', 'c']);
+* // result will be { a: 1 }
+*/
 function omit(obj, keys) {
 	const result = { ...obj };
 	for (let i = 0; i < keys.length; i++) {
@@ -995,6 +1592,110 @@ function getRemTransformPlugin(options) {
 	return (0, postcss_rem_to_responsive_pixel.default)((0, _weapp_tailwindcss_shared.defuOverrideArray)(options.rem2rpx, defaultStage));
 }
 //#endregion
+//#region src/plugins/getUnitConversionPlugin.ts
+const DEFAULT_PLATFORM_KEYS = ["default", "*"];
+const PLATFORM_ENV_KEYS = [
+	"WEAPP_TW_TARGET",
+	"WEAPP_TAILWINDCSS_TARGET",
+	"UNI_PLATFORM",
+	"UNI_UTS_PLATFORM",
+	"TARO_ENV",
+	"MPX_CLI_MODE",
+	"MPX_CURRENT_TARGET_MODE"
+];
+const PLATFORM_ALIASES = {
+	"weapp": [
+		"mp-weixin",
+		"weixin",
+		"wechat",
+		"wx",
+		"mp"
+	],
+	"mp-weixin": [
+		"weapp",
+		"weixin",
+		"wechat",
+		"wx",
+		"mp"
+	],
+	"wx": [
+		"weapp",
+		"mp-weixin",
+		"weixin",
+		"wechat",
+		"mp"
+	],
+	"h5": ["web"],
+	"web": ["h5"],
+	"app": [
+		"app-plus",
+		"app-android",
+		"app-ios",
+		"android",
+		"ios"
+	],
+	"app-plus": ["app"],
+	"app-android": ["app", "android"],
+	"app-ios": ["app", "ios"],
+	"android": ["app", "app-android"],
+	"ios": ["app", "app-ios"]
+};
+function normalizePlatform(value) {
+	return value?.trim().toLowerCase() || void 0;
+}
+function readEnvValue(key) {
+	return typeof node_process.default === "undefined" ? void 0 : node_process.default.env[key];
+}
+function resolveUnitConversionPlatform(options) {
+	const explicit = normalizePlatform(options.platform);
+	if (explicit) return explicit;
+	for (const key of PLATFORM_ENV_KEYS) {
+		const value = normalizePlatform(readEnvValue(key));
+		if (value) return value;
+	}
+}
+function isPlatformUnitConversionOptions(options) {
+	return Boolean(options && typeof options === "object" && "platforms" in options);
+}
+function hasRules(config) {
+	return Array.isArray(config.rules) && config.rules.length > 0;
+}
+function getPlatformCandidateKeys(platform) {
+	if (!platform) return [];
+	const normalized = normalizePlatform(platform);
+	if (!normalized) return [];
+	return [normalized, ...PLATFORM_ALIASES[normalized] ?? []];
+}
+function getPlatformConfig(platforms, key) {
+	if (Object.hasOwn(platforms, key)) return platforms[key];
+	for (const [platform, config] of Object.entries(platforms)) if (normalizePlatform(platform) === key) return config;
+}
+function resolvePlatformConfig(options, platform) {
+	if (!isPlatformUnitConversionOptions(options)) return options;
+	const platforms = options.platforms;
+	for (const key of getPlatformCandidateKeys(platform)) {
+		const config = getPlatformConfig(platforms, key);
+		if (config !== void 0) return config;
+	}
+	if (options.default !== void 0) return options.default;
+	for (const key of DEFAULT_PLATFORM_KEYS) {
+		const config = getPlatformConfig(platforms, key);
+		if (config !== void 0) return config;
+	}
+}
+function resolveUnitConversionConfig(options) {
+	const unitConversion = options.unitConversion;
+	if (!unitConversion || unitConversion === false) return;
+	const config = resolvePlatformConfig(unitConversion, resolveUnitConversionPlatform(options));
+	if (!config || config === false || config.disabled || !hasRules(config)) return;
+	return config;
+}
+function getUnitConversionPlugin(options) {
+	const config = resolveUnitConversionConfig(options);
+	if (!config) return null;
+	return (0, postcss_rule_unit_converter.default)(config);
+}
+//#endregion
 //#region src/plugins/getUnitsToPxPlugin.ts
 function getUnitsToPxPlugin(options) {
 	if (!options.unitsToPx) return null;
@@ -1935,6 +2636,78 @@ function normalizeCalcValue(value) {
 function hasVariableReference(value) {
 	return value.includes("var(");
 }
+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 getTransitionPropertySet(value) {
+	const items = splitTopLevelCommaList(value).map((item) => item.trim().toLowerCase()).filter(Boolean);
+	return items.length > 0 ? new Set(items) : void 0;
+}
+function isSubsetOfSet(subset, superset) {
+	for (const item of subset) if (!superset.has(item)) return false;
+	return true;
+}
+function removeRedundantTransitionPropertyFallbacks(rule) {
+	const entries = rule.nodes.filter((node) => node.type === "decl" && node.prop.toLowerCase() === "transition-property").map((decl) => ({
+		decl,
+		items: getTransitionPropertySet(decl.value)
+	}));
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (!entry?.items) continue;
+		for (let j = i + 1; j < entries.length; j++) {
+			const next = entries[j];
+			if (!next?.items) continue;
+			if (next.items.size === entry.items.size && isSubsetOfSet(entry.items, next.items)) {
+				next.decl.remove();
+				entries.splice(j, 1);
+				j--;
+				continue;
+			}
+			if (next.items.size > entry.items.size && isSubsetOfSet(entry.items, next.items)) {
+				entry.decl.remove();
+				break;
+			}
+		}
+	}
+}
 function dedupeDeclarations(rule) {
 	const entries = [];
 	for (const node of [...rule.nodes]) {
@@ -1986,6 +2759,7 @@ function dedupeDeclarations(rule) {
 		if (literalSeen.get(canonical)) node.remove();
 		else literalSeen.set(canonical, node);
 	}
+	removeRedundantTransitionPropertyFallbacks(rule);
 }
 //#endregion
 //#region src/plugins/post/specificity-cleaner.ts
@@ -2135,6 +2909,9 @@ const postcssWeappTailwindcssPostPlugin = (options) => {
 			root.walkDecls((decl) => {
 				normalizeMiniProgramPrefixedDeclaration(decl);
 			});
+			root.walkRules((rule) => {
+				removeRedundantTransitionPropertyFallbacks(rule);
+			});
 			root.walkAtRules((atRule) => {
 				removeUnsupportedMiniProgramPrefixedAtRule(atRule);
 			});
@@ -2615,6 +3392,8 @@ function createPreparedNodes(options, signal) {
 	if (pxTransformPlugin) preparedNodes.push(createPreparedNode("normal:px-transform", "normal", () => pxTransformPlugin));
 	const remTransformPlugin = getRemTransformPlugin(options);
 	if (remTransformPlugin) preparedNodes.push(createPreparedNode("normal:rem-transform", "normal", () => remTransformPlugin));
+	const unitConversionPlugin = getUnitConversionPlugin(options);
+	if (unitConversionPlugin) preparedNodes.push(createPreparedNode("normal:unit-conversion", "normal", () => unitConversionPlugin));
 	const calcPlugin = getCalcPlugin(options);
 	if (calcPlugin) preparedNodes.push(createPreparedNode("normal:calc", "normal", () => calcPlugin));
 	const calcDuplicateCleaner = getCalcDuplicateCleaner(options);
@@ -2864,9 +3643,27 @@ exports.createFallbackPlaceholderReplacer = createFallbackPlaceholderReplacer;
 exports.createInjectPreflight = createInjectPreflight;
 exports.createStyleHandler = createStyleHandler;
 exports.createStylePipeline = createStylePipeline;
+exports.finalizeMiniProgramCss = finalizeMiniProgramCss;
+exports.hoistTailwindPreflightBase = hoistTailwindPreflightBase;
 exports.internalCssSelectorReplacer = internalCssSelectorReplacer;
 exports.normalizeMiniProgramPrefixedDeclaration = normalizeMiniProgramPrefixedDeclaration;
 exports.normalizeModernColorValue = normalizeModernColorValue;
 exports.postcssHtmlTransform = require_html_transform.postcssHtmlTransform;
 exports.protectDynamicColorMixAlpha = protectDynamicColorMixAlpha;
+exports.pruneMiniProgramGeneratedCss = pruneMiniProgramGeneratedCss;
+exports.removeUnsupportedAtSupports = removeUnsupportedAtSupports;
+exports.removeUnsupportedCascadeLayers = removeUnsupportedCascadeLayers;
+exports.removeUnsupportedMiniProgramAtRules = removeUnsupportedMiniProgramAtRules;
 exports.removeUnsupportedMiniProgramPrefixedAtRule = removeUnsupportedMiniProgramPrefixedAtRule;
+Object.defineProperty(exports, "unitConversionComposeRules", {
+	enumerable: true,
+	get: function() {
+		return postcss_rule_unit_converter.composeRules;
+	}
+});
+Object.defineProperty(exports, "unitConversionPresets", {
+	enumerable: true,
+	get: function() {
+		return postcss_rule_unit_converter.presets;
+	}
+});