weapp-tailwindcss 5.0.12 → 5.1.0

package/dist/v4-engine-D4ubP7N5.js

@@ -0,0 +1,2778 @@
+const require_chunk = require("./chunk-emK7D4bc.js");
+require("./auto-DtU6f3X6.js");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let _tailwindcss_mangle_engine = require("@tailwindcss-mangle/engine");
+let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
+let lru_cache = require("lru-cache");
+let node_fs_promises = require("node:fs/promises");
+let micromatch = require("micromatch");
+micromatch = require_chunk.__toESM(micromatch);
+let node_module = require("node:module");
+//#region src/runtime-branch/generator-target-env.ts
+const explicitGeneratorTargetEnvKeys = ["WEAPP_TW_TARGET", "WEAPP_TAILWINDCSS_TARGET"];
+const uniWebPlatformEnvKeys = ["UNI_PLATFORM", "UNI_UTS_PLATFORM"];
+const mpxWebPlatformEnvKeys = ["MPX_CLI_MODE", "MPX_CURRENT_TARGET_MODE"];
+function getEnvValue(key) {
+	return typeof node_process.default === "undefined" ? void 0 : node_process.default.env[key];
+}
+function normalizeGeneratorTargetValue(value) {
+	return value === "weapp" || value === "web" ? value : void 0;
+}
+function isUniWebPlatform(value) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized === "h5" || normalized?.startsWith("web") === true;
+}
+function isUniAppWebViewPlatform(value) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized === "app" || normalized === "app-plus";
+}
+function isUniNativeAppPlatform(value) {
+	return (value?.trim().toLowerCase())?.startsWith("app-") === true;
+}
+function isMpxWebPlatform(value) {
+	return value?.trim().toLowerCase() === "web";
+}
+function inferGeneratorTargetFromExplicitEnv() {
+	for (const key of explicitGeneratorTargetEnvKeys) {
+		const target = normalizeGeneratorTargetValue(getEnvValue(key));
+		if (target !== void 0) return target;
+	}
+}
+function shouldUseWebGeneratorTargetFromEnv() {
+	return uniWebPlatformEnvKeys.some((key) => isUniWebPlatform(getEnvValue(key))) || isUniAppWebViewPlatform(getEnvValue("UNI_PLATFORM")) && !isUniNativeAppPlatform(getEnvValue("UNI_UTS_PLATFORM")) || mpxWebPlatformEnvKeys.some((key) => isMpxWebPlatform(getEnvValue(key))) || getEnvValue("TARO_ENV") === "h5";
+}
+function inferGeneratorTargetFromEnv() {
+	return inferGeneratorTargetFromExplicitEnv() ?? (shouldUseWebGeneratorTargetFromEnv() ? "web" : "weapp");
+}
+//#endregion
+//#region src/utils/object.ts
+function definedEntries(value) {
+	return Object.entries(value).filter(([, item]) => item !== void 0);
+}
+function omitUndefined(value) {
+	return Object.fromEntries(definedEntries(value));
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/candidates.ts
+const UNSUPPORTED_MINI_PROGRAM_TAILWIND_V4_CANDIDATE_RE = /(?:^|:)(?:group|peer|in|not-in)-[^\s:]*\/|(?:^|:)(?:in|not-in)-\[/;
+function isUnsupportedMiniProgramTailwindV4Candidate(candidate) {
+	return UNSUPPORTED_MINI_PROGRAM_TAILWIND_V4_CANDIDATE_RE.test(candidate);
+}
+function filterUnsupportedMiniProgramTailwindV4Candidates(candidates) {
+	if (!candidates) return;
+	return new Set([...candidates].filter((candidate) => !isUnsupportedMiniProgramTailwindV4Candidate(candidate)));
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/tailwind-v4-default-colors.ts
+const TAILWIND_V4_COLOR_STEPS = [
+	"50",
+	"100",
+	"200",
+	"300",
+	"400",
+	"500",
+	"600",
+	"700",
+	"800",
+	"900",
+	"950"
+];
+const TAILWIND_V4_COLOR_PALETTE = {
+	slate: [
+		"#f8fafc",
+		"#f1f5f9",
+		"#e2e8f0",
+		"#cad5e2",
+		"#90a1b9",
+		"#62748e",
+		"#45556c",
+		"#314158",
+		"#1d293d",
+		"#0f172b",
+		"#020618"
+	],
+	gray: [
+		"#f9fafb",
+		"#f3f4f6",
+		"#e5e7eb",
+		"#d1d5dc",
+		"#99a1af",
+		"#6a7282",
+		"#4a5565",
+		"#364153",
+		"#1e2939",
+		"#101828",
+		"#030712"
+	],
+	zinc: [
+		"#fafafa",
+		"#f4f4f5",
+		"#e4e4e7",
+		"#d4d4d8",
+		"#9f9fa9",
+		"#71717b",
+		"#52525c",
+		"#3f3f46",
+		"#27272a",
+		"#18181b",
+		"#09090b"
+	],
+	neutral: [
+		"#fafafa",
+		"#f5f5f5",
+		"#e5e5e5",
+		"#d4d4d4",
+		"#a1a1a1",
+		"#737373",
+		"#525252",
+		"#404040",
+		"#262626",
+		"#171717",
+		"#0a0a0a"
+	],
+	stone: [
+		"#fafaf9",
+		"#f5f5f4",
+		"#e7e5e4",
+		"#d6d3d1",
+		"#a6a09b",
+		"#79716b",
+		"#57534d",
+		"#44403b",
+		"#292524",
+		"#1c1917",
+		"#0c0a09"
+	],
+	mauve: [
+		"#fafafa",
+		"#f3f1f3",
+		"#e7e4e7",
+		"#d7d0d7",
+		"#a89ea9",
+		"#79697b",
+		"#594c5b",
+		"#463947",
+		"#2a212c",
+		"#1d161e",
+		"#0c090c"
+	],
+	olive: [
+		"#fbfbf9",
+		"#f4f4f0",
+		"#e8e8e3",
+		"#d8d8d0",
+		"#abab9c",
+		"#7c7c67",
+		"#5b5b4b",
+		"#474739",
+		"#2b2b22",
+		"#1d1d16",
+		"#0c0c09"
+	],
+	mist: [
+		"#f9fbfb",
+		"#f1f3f3",
+		"#e3e7e8",
+		"#d0d6d8",
+		"#9ca8ab",
+		"#67787c",
+		"#4b585b",
+		"#394447",
+		"#22292b",
+		"#161b1d",
+		"#090b0c"
+	],
+	taupe: [
+		"#fbfaf9",
+		"#f3f1f1",
+		"#e8e4e3",
+		"#d8d2d0",
+		"#aba09c",
+		"#7c6d67",
+		"#5b4f4b",
+		"#473c39",
+		"#2b2422",
+		"#1d1816",
+		"#0c0a09"
+	],
+	red: [
+		"#fef2f2",
+		"#ffe2e2",
+		"#ffc9c9",
+		"#ffa2a2",
+		"#ff6467",
+		"#fb2c36",
+		"#e7000b",
+		"#c10007",
+		"#9f0712",
+		"#82181a",
+		"#460809"
+	],
+	orange: [
+		"#fff7ed",
+		"#ffedd4",
+		"#ffd6a7",
+		"#ffb86a",
+		"#ff8904",
+		"#ff6900",
+		"#f54900",
+		"#ca3500",
+		"#9f2d00",
+		"#7e2a0c",
+		"#441306"
+	],
+	amber: [
+		"#fffbeb",
+		"#fef3c6",
+		"#fee685",
+		"#ffd230",
+		"#ffb900",
+		"#fe9a00",
+		"#e17100",
+		"#bb4d00",
+		"#973c00",
+		"#7b3306",
+		"#461901"
+	],
+	yellow: [
+		"#fefce8",
+		"#fef9c2",
+		"#fff085",
+		"#ffdf20",
+		"#fdc700",
+		"#f0b100",
+		"#d08700",
+		"#a65f00",
+		"#894b00",
+		"#733e0a",
+		"#432004"
+	],
+	lime: [
+		"#f7fee7",
+		"#ecfcca",
+		"#d8f999",
+		"#bbf451",
+		"#9ae600",
+		"#7ccf00",
+		"#5ea500",
+		"#497d00",
+		"#3c6300",
+		"#35530e",
+		"#192e03"
+	],
+	green: [
+		"#f0fdf4",
+		"#dcfce7",
+		"#b9f8cf",
+		"#7bf1a8",
+		"#05df72",
+		"#00c950",
+		"#00a63e",
+		"#008236",
+		"#016630",
+		"#0d542b",
+		"#032e15"
+	],
+	emerald: [
+		"#ecfdf5",
+		"#d0fae5",
+		"#a4f4cf",
+		"#5ee9b5",
+		"#00d492",
+		"#00bc7d",
+		"#009966",
+		"#007a55",
+		"#006045",
+		"#004f3b",
+		"#002c22"
+	],
+	teal: [
+		"#f0fdfa",
+		"#cbfbf1",
+		"#96f7e4",
+		"#46ecd5",
+		"#00d5be",
+		"#00bba7",
+		"#009689",
+		"#00786f",
+		"#005f5a",
+		"#0b4f4a",
+		"#022f2e"
+	],
+	cyan: [
+		"#ecfeff",
+		"#cefafe",
+		"#a2f4fd",
+		"#53eafd",
+		"#00d3f2",
+		"#00b8db",
+		"#0092b8",
+		"#007595",
+		"#005f78",
+		"#104e64",
+		"#053345"
+	],
+	sky: [
+		"#f0f9ff",
+		"#dff2fe",
+		"#b8e6fe",
+		"#74d4ff",
+		"#00bcff",
+		"#00a6f4",
+		"#0084d1",
+		"#0069a8",
+		"#00598a",
+		"#024a70",
+		"#052f4a"
+	],
+	blue: [
+		"#eff6ff",
+		"#dbeafe",
+		"#bedbff",
+		"#8ec5ff",
+		"#51a2ff",
+		"#2b7fff",
+		"#155dfc",
+		"#1447e6",
+		"#193cb8",
+		"#1c398e",
+		"#162456"
+	],
+	indigo: [
+		"#eef2ff",
+		"#e0e7ff",
+		"#c6d2ff",
+		"#a3b3ff",
+		"#7c86ff",
+		"#615fff",
+		"#4f39f6",
+		"#432dd7",
+		"#372aac",
+		"#312c85",
+		"#1e1a4d"
+	],
+	violet: [
+		"#f5f3ff",
+		"#ede9fe",
+		"#ddd6ff",
+		"#c4b4ff",
+		"#a684ff",
+		"#8e51ff",
+		"#7f22fe",
+		"#7008e7",
+		"#5d0ec0",
+		"#4d179a",
+		"#2f0d68"
+	],
+	purple: [
+		"#faf5ff",
+		"#f3e8ff",
+		"#e9d4ff",
+		"#dab2ff",
+		"#c27aff",
+		"#ad46ff",
+		"#9810fa",
+		"#8200db",
+		"#6e11b0",
+		"#59168b",
+		"#3c0366"
+	],
+	fuchsia: [
+		"#fdf4ff",
+		"#fae8ff",
+		"#f6cfff",
+		"#f4a8ff",
+		"#ed6aff",
+		"#e12afb",
+		"#c800de",
+		"#a800b7",
+		"#8a0194",
+		"#721378",
+		"#4b004f"
+	],
+	pink: [
+		"#fdf2f8",
+		"#fce7f3",
+		"#fccee8",
+		"#fda5d5",
+		"#fb64b6",
+		"#f6339a",
+		"#e60076",
+		"#c6005c",
+		"#a3004c",
+		"#861043",
+		"#510424"
+	],
+	rose: [
+		"#fff1f2",
+		"#ffe4e6",
+		"#ffccd3",
+		"#ffa1ad",
+		"#ff637e",
+		"#ff2056",
+		"#ec003f",
+		"#c70036",
+		"#a50036",
+		"#8b0836",
+		"#4d0218"
+	]
+};
+function createTailwindV4DefaultColorThemeCss() {
+	const declarations = ["  --color-black: #000;", "  --color-white: #fff;"];
+	for (const [color, values] of Object.entries(TAILWIND_V4_COLOR_PALETTE)) for (let index = 0; index < TAILWIND_V4_COLOR_STEPS.length; index++) declarations.push(`  --color-${color}-${TAILWIND_V4_COLOR_STEPS[index]}: ${values[index]};`);
+	return [
+		"@theme {",
+		...declarations,
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/css-compat.ts
+function findLeadingImportInsertionIndex(css) {
+	const importPattern = /(?:^|\n)\s*@import\b[^;]*;/g;
+	let insertionIndex = 0;
+	let match = importPattern.exec(css);
+	while (match !== null) {
+		insertionIndex = match.index + match[0].length;
+		match = importPattern.exec(css);
+	}
+	return insertionIndex;
+}
+function applyMiniProgramTailwindV4DefaultColorCss(css) {
+	const themeCss = createTailwindV4DefaultColorThemeCss();
+	const insertionIndex = findLeadingImportInsertionIndex(css);
+	if (insertionIndex === 0) return `${themeCss}\n${css}`;
+	return `${css.slice(0, insertionIndex)}\n${themeCss}\n${css.slice(insertionIndex)}`;
+}
+function parseCssImportSpecifier$2(params) {
+	const value = params.trim();
+	const quoted = /^(['"])(.*?)\1/.exec(value);
+	if (quoted) return quoted[2];
+	const url = /^url\(\s*(?:(['"])(.*?)\1|([^'")\s]+))\s*\)/.exec(value);
+	return url?.[2] ?? url?.[3];
+}
+function isTailwindCssPreflightImport(params) {
+	const specifier = parseCssImportSpecifier$2(params);
+	return specifier === "tailwindcss/preflight.css" || specifier === "tailwindcss/preflight";
+}
+function removeTailwindV4PreflightImports(css) {
+	if (!css.includes("preflight")) return css;
+	let root;
+	try {
+		root = _weapp_tailwindcss_postcss.postcss.parse(css);
+	} catch {
+		return css;
+	}
+	let changed = false;
+	root.walkAtRules("import", (rule) => {
+		if (isTailwindCssPreflightImport(rule.params)) {
+			rule.remove();
+			changed = true;
+		}
+	});
+	return changed ? root.toString() : css;
+}
+function hasThemeParent(rule) {
+	let parent = rule.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name === "theme") return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+function isVendorPrefixedKeyframes(rule) {
+	return rule.name.startsWith("-") && rule.name.endsWith("keyframes");
+}
+function removeUnsupportedThemeVendorKeyframes(css) {
+	if (!css.includes("@theme") || !css.includes("@-")) return css;
+	let root;
+	try {
+		root = _weapp_tailwindcss_postcss.postcss.parse(css);
+	} catch {
+		return css;
+	}
+	let changed = false;
+	root.walkAtRules((rule) => {
+		if (isVendorPrefixedKeyframes(rule) && hasThemeParent(rule)) {
+			rule.remove();
+			changed = true;
+		}
+	});
+	return changed ? root.toString() : css;
+}
+function createCompatibleSource(source, target) {
+	const filteredSourceCss = target === "weapp" ? removeTailwindV4PreflightImports(source.css) : source.css;
+	const compatibleSourceCss = removeUnsupportedThemeVendorKeyframes(target === "weapp" ? applyMiniProgramTailwindV4DefaultColorCss(filteredSourceCss) : filteredSourceCss);
+	return compatibleSourceCss === source.css ? source : {
+		...source,
+		css: compatibleSourceCss
+	};
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/rpx-candidates.ts
+const RPX_LENGTH_UTILITY_PATTERN = String.raw`text|border(?:-[trblxyse])?|bg|outline|ring`;
+const BARE_RPX_LENGTH_CANDIDATE_RE = new RegExp(String.raw`(^|:)(!?)(${RPX_LENGTH_UTILITY_PATTERN})-\[([-+]?(?:\d+|\d*\.\d+)rpx)\](.*)$`, "u");
+const BARE_RPX_LENGTH_HINT_CANDIDATE_RE = new RegExp(String.raw`(?:^|:)!?(${RPX_LENGTH_UTILITY_PATTERN})-\[length:([-+]?(?:\d+|\d*\.\d+)rpx)\].*$`, "u");
+const RPX_LENGTH_SELECTOR_RE = new RegExp(String.raw`(${RPX_LENGTH_UTILITY_PATTERN})-\\\[length\\:((?:\\[.+-]|[+\-.\d])+rpx)\\\]`, "g");
+function normalizeRpxLengthCandidate(candidate) {
+	return candidate.replace(BARE_RPX_LENGTH_CANDIDATE_RE, (_match, prefix, important, utility, value, suffix) => {
+		return `${prefix}${important}${utility}-[length:${value}]${suffix}`;
+	});
+}
+function normalizeRpxLengthCandidates(candidates) {
+	const normalized = /* @__PURE__ */ new Set();
+	const restoreCandidates = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const normalizedCandidate = normalizeRpxLengthCandidate(candidate);
+		normalized.add(normalizedCandidate);
+		if (normalizedCandidate !== candidate) restoreCandidates.set(normalizedCandidate, candidate);
+	}
+	return {
+		candidates: normalized,
+		restoreCandidates
+	};
+}
+function restoreRpxLengthCandidates(candidates, restoreCandidates) {
+	if (restoreCandidates.size === 0) return new Set(candidates);
+	return new Set([...candidates].map((candidate) => restoreCandidates.get(candidate) ?? candidate));
+}
+function normalizeCssEscapedRpxSelectorValue(value) {
+	return value.replace(/\\([.+-])/g, "$1");
+}
+function restoreRpxLengthCssSelectors(css, restoreCandidates) {
+	if (restoreCandidates.size === 0 || !css.includes("\\[length\\:")) return css;
+	const restoredUtilities = new Set([...restoreCandidates.keys()].map((candidate) => {
+		const match = BARE_RPX_LENGTH_HINT_CANDIDATE_RE.exec(candidate);
+		return match ? `${match[1]}:${match[2]}` : void 0;
+	}).filter((value) => Boolean(value)));
+	return css.replace(RPX_LENGTH_SELECTOR_RE, (match, utility, value) => {
+		return restoredUtilities.has(`${utility}:${normalizeCssEscapedRpxSelectorValue(value)}`) ? `${utility}-\\[${value}\\]` : match;
+	});
+}
+//#endregion
+//#region src/tailwindcss/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/tailwindcss/source-scan.ts
+const DEFAULT_SOURCE_SCAN_EXTENSIONS = [
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"vue",
+	"mpx",
+	"js",
+	"jsx",
+	"ts",
+	"tsx"
+];
+const FULL_SOURCE_SCAN_EXTENSIONS = [
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts",
+	"vue",
+	"uvue",
+	"nvue",
+	"svelte",
+	"mpx",
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"css",
+	"wxss",
+	"acss",
+	"jxss",
+	"ttss",
+	"qss",
+	"tyss",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+];
+function createSourceScanPattern(extensions = DEFAULT_SOURCE_SCAN_EXTENSIONS) {
+	return `**/*.{${extensions.join(",")}}`;
+}
+const FULL_SOURCE_SCAN_PATTERN = createSourceScanPattern(FULL_SOURCE_SCAN_EXTENSIONS);
+const FULL_SOURCE_SCAN_EXTENSION_RE = new RegExp(`\\.(?:${FULL_SOURCE_SCAN_EXTENSIONS.map((extension) => extension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`);
+function toPosixPath(value) {
+	return value.split(node_path.default.sep).join("/");
+}
+function resolveSourceScanPath(value) {
+	const resolved = node_path.default.resolve(value);
+	try {
+		return node_fs.realpathSync.native(resolved);
+	} catch {
+		return resolved;
+	}
+}
+function normalizeEntryPattern(entry) {
+	return node_path.default.isAbsolute(entry.pattern) ? toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), entry.pattern)) : entry.pattern;
+}
+function isFileMatchedByTailwindSourceEntry(file, entry) {
+	const relative = toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), file));
+	return relative && !relative.startsWith("../") && !node_path.default.isAbsolute(relative) && micromatch.default.isMatch(relative, normalizeEntryPattern(entry));
+}
+function isFileExcludedByTailwindSourceEntries(file, entries) {
+	if (!entries?.length) return false;
+	const resolvedFile = resolveSourceScanPath(file);
+	return entries.some((entry) => entry.negated && isFileMatchedByTailwindSourceEntry(resolvedFile, entry));
+}
+function isFileMatchedByTailwindSourceEntries(file, entries) {
+	if (!entries?.length) return true;
+	const positiveEntries = entries.filter((entry) => !entry.negated);
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	const resolvedFile = resolveSourceScanPath(file);
+	if (positiveEntries.length === 0) return !negativeEntries.some((entry) => isFileMatchedByTailwindSourceEntry(resolvedFile, entry));
+	if (!positiveEntries.some((entry) => isFileMatchedByTailwindSourceEntry(resolvedFile, entry))) return false;
+	return !negativeEntries.some((entry) => isFileMatchedByTailwindSourceEntry(resolvedFile, entry));
+}
+function createTailwindSourceEntryMatcher(entries) {
+	if (!entries?.length) return;
+	return (file) => isFileMatchedByTailwindSourceEntries(file, entries);
+}
+function resolveTailwindV4CssSourceBase(source, fallbackBase) {
+	if (typeof source.base === "string" && source.base.length > 0) return source.base;
+	if (typeof source.file === "string" && source.file.length > 0) return node_path.default.dirname(source.file);
+	return fallbackBase;
+}
+function parseConfigParam(params) {
+	const value = params.trim();
+	return /^(['"])(.+)\1$/.exec(value)?.[2];
+}
+function isLegacyContentObject(value) {
+	return typeof value === "object" && value !== null && "files" in value;
+}
+function normalizeGlobPattern(pattern) {
+	return pattern.startsWith("./") ? pattern.slice(2) : pattern;
+}
+function hasGlobMagic(value) {
+	return /[*?[\]{}()!+@]/.test(value);
+}
+function splitStaticGlobPrefix(pattern) {
+	const segments = normalizeGlobPattern(pattern).split(/[\\/]+/);
+	const prefix = [];
+	const rest = [];
+	let reachedGlob = false;
+	for (const segment of segments) {
+		if (!reachedGlob && segment && !hasGlobMagic(segment)) {
+			prefix.push(segment);
+			continue;
+		}
+		reachedGlob = true;
+		rest.push(segment);
+	}
+	return {
+		prefix,
+		rest
+	};
+}
+function normalizeLegacyContentEntries(content, base, options = {}) {
+	if (typeof content === "string") {
+		const negated = content.startsWith("!");
+		return [{
+			base,
+			negated,
+			pattern: normalizeGlobPattern(negated ? content.slice(1) : content)
+		}];
+	}
+	if (Array.isArray(content)) return content.flatMap((item) => normalizeLegacyContentEntries(item, base, options));
+	if (isLegacyContentObject(content)) return normalizeLegacyContentEntries(content.files, content.relative && options.relativeBase ? options.relativeBase : base, options);
+	return [];
+}
+async function pathExistsAsDirectory(file) {
+	try {
+		return (await (0, node_fs_promises.stat)(file)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindSourceEntry(sourcePath, base, negated, defaultPattern = createSourceScanPattern()) {
+	const absoluteSource = node_path.default.isAbsolute(sourcePath) ? node_path.default.resolve(sourcePath) : node_path.default.resolve(base, sourcePath);
+	if (await pathExistsAsDirectory(absoluteSource)) return {
+		base: absoluteSource,
+		negated,
+		pattern: normalizeGlobPattern(defaultPattern)
+	};
+	if (node_path.default.isAbsolute(sourcePath) && hasGlobMagic(sourcePath)) {
+		const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+		const root = node_path.default.parse(sourcePath).root;
+		const normalizedPrefix = prefix[0] === "" ? prefix.slice(1) : prefix;
+		if (rest.length > 0) return {
+			base: node_path.default.resolve(root, ...normalizedPrefix),
+			negated,
+			pattern: normalizeGlobPattern(rest.join("/"))
+		};
+	}
+	if (node_path.default.isAbsolute(sourcePath)) return {
+		base: node_path.default.dirname(absoluteSource),
+		negated,
+		pattern: normalizeGlobPattern(node_path.default.basename(absoluteSource))
+	};
+	const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+	if (prefix.length > 0 && rest.length > 0) return {
+		base: node_path.default.resolve(base, ...prefix),
+		negated,
+		pattern: normalizeGlobPattern(rest.join("/"))
+	};
+	return {
+		base,
+		negated,
+		pattern: normalizeGlobPattern(sourcePath)
+	};
+}
+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;
+}
+async function resolveCssSourceEntries(root, base, defaultPattern = createSourceScanPattern()) {
+	const entries = [];
+	const tasks = [];
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceFileParam(rule.params);
+		if (!parsed) return;
+		tasks.push(resolveTailwindSourceEntry(parsed.sourcePath, base, parsed.negated, defaultPattern));
+	});
+	entries.push(...await Promise.all(tasks));
+	return entries;
+}
+async function expandTailwindSourceEntries(entries, options = {}) {
+	if (entries.length === 0) return [];
+	const files = /* @__PURE__ */ new Set();
+	const entriesByBase = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const base = node_path.default.resolve(entry.base);
+		const group = entriesByBase.get(base) ?? [];
+		group.push({
+			...entry,
+			base
+		});
+		entriesByBase.set(base, group);
+	}
+	await Promise.all([...entriesByBase.entries()].map(async ([base, group]) => {
+		const ignoredSources = options.ignore?.map((pattern) => ({
+			base,
+			pattern: normalizeGlobPattern(pattern),
+			negated: true
+		}));
+		const matched = await (0, _tailwindcss_mangle_engine.resolveProjectSourceFiles)({
+			cwd: base,
+			sources: group,
+			...ignoredSources === void 0 ? {} : { ignoredSources }
+		});
+		for (const file of matched) files.add(node_path.default.resolve(file));
+	}));
+	return [...files].filter((file) => !isFileExcludedByTailwindSourceEntries(file, entries));
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/scan-sources.ts
+const TAILWIND_V4_DEFAULT_IGNORED_SOURCE_PATTERNS = [
+	"**/.git/**",
+	"**/.hg/**",
+	"**/.jj/**",
+	"**/.next/**",
+	"**/.parcel-cache/**",
+	"**/.pnpm-store/**",
+	"**/.svelte-kit/**",
+	"**/.svn/**",
+	"**/.turbo/**",
+	"**/.venv/**",
+	"**/.vercel/**",
+	"**/.yarn/**",
+	"**/__pycache__/**",
+	"**/node_modules/**",
+	"**/venv/**",
+	"**/*.less",
+	"**/*.lock",
+	"**/*.sass",
+	"**/*.scss",
+	"**/*.styl",
+	"**/*.log",
+	"**/package-lock.json",
+	"**/pnpm-lock.yaml",
+	"**/bun.lockb",
+	"**/.gitignore",
+	"**/.env",
+	"**/.env.*"
+];
+function parseImportSourceParam(params) {
+	const match = /\bsource\(\s*(none|(['"])(.*?)\2)\s*\)/.exec(params);
+	if (!match) return;
+	return {
+		none: match[1] === "none",
+		sourcePath: match[3]
+	};
+}
+function parseCssImportSpecifier$1(params) {
+	const value = params.trim();
+	const quoted = /^(['"])(.*?)\1/.exec(value);
+	if (quoted) return quoted[2];
+	const url = /^url\(\s*(?:(['"])(.*?)\1|([^'")\s]+))\s*\)/.exec(value);
+	return url?.[2] ?? url?.[3];
+}
+function isTailwindCssImport(params) {
+	const specifier = parseCssImportSpecifier$1(params);
+	return specifier === "tailwindcss" || specifier?.startsWith("tailwindcss/") || specifier?.replaceAll("\\", "/").endsWith("/tailwindcss/index.css");
+}
+function resolveSourceBase(base, sourcePath) {
+	return node_path.default.isAbsolute(sourcePath) ? sourcePath : node_path.default.resolve(base, sourcePath);
+}
+function createDefaultIgnoredScanSources(base) {
+	return TAILWIND_V4_DEFAULT_IGNORED_SOURCE_PATTERNS.map((pattern) => ({
+		base,
+		pattern,
+		negated: true
+	}));
+}
+function normalizeCssDefinedScanSources(base, entries) {
+	return entries.length > 0 && entries.every((entry) => entry.negated) ? [{
+		base,
+		pattern: "**/*",
+		negated: false
+	}, ...entries] : entries;
+}
+function resolveDefaultSourceBase(source) {
+	return source.projectRoot ?? source.cwd ?? source.base;
+}
+async function resolveCssDefinedScanSources(source) {
+	let importSourceBase;
+	let hasSourceNone = false;
+	let hasTailwindImport = false;
+	const from = source.dependencies[0];
+	let root;
+	try {
+		root = _weapp_tailwindcss_postcss.postcss.parse(source.css, { from });
+	} catch {
+		return;
+	}
+	root.walkAtRules((rule) => {
+		if (rule.name === "import") {
+			if (!isTailwindCssImport(rule.params)) return;
+			hasTailwindImport = true;
+			const sourceParam = parseImportSourceParam(rule.params);
+			if (sourceParam?.none) hasSourceNone = true;
+			if (sourceParam?.sourcePath) importSourceBase = resolveSourceBase(source.base, sourceParam.sourcePath);
+		}
+	});
+	const sourcePatterns = await resolveCssSourceEntries(root, source.base, "**/*");
+	if (!importSourceBase) {
+		if (sourcePatterns.length > 0) return [...normalizeCssDefinedScanSources(source.base, sourcePatterns), ...createDefaultIgnoredScanSources(source.base)];
+		if (hasSourceNone) return false;
+		if (hasTailwindImport) {
+			const defaultBase = resolveDefaultSourceBase(source);
+			return [await resolveTailwindSourceEntry(".", defaultBase, false, "**/*"), ...createDefaultIgnoredScanSources(defaultBase)];
+		}
+		return;
+	}
+	return [
+		await resolveTailwindSourceEntry(".", importSourceBase, false, "**/*"),
+		...sourcePatterns,
+		...createDefaultIgnoredScanSources(importSourceBase)
+	];
+}
+async function resolveScanSources(source, scanSources) {
+	if (scanSources !== true) return scanSources;
+	return await resolveCssDefinedScanSources(source) ?? false;
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/miniprogram.ts
+const defaultStyleHandler = (0, _weapp_tailwindcss_postcss.createStyleHandler)({
+	cssChildCombinatorReplaceValue: ["view", "text"],
+	cssRemoveHoverPseudoClass: true,
+	isMainChunk: true,
+	majorVersion: 4
+});
+const CSS_DECLARATION_URL_RE = /(:\s*)url\(([^\n\r"';[\]{}]*[[\]{}][^\n\r;]*)\)(?=\s*;)/g;
+function normalizeTailwindV4GeneratedUrlValues(css) {
+	return css.replace(CSS_DECLARATION_URL_RE, (match, prefix, urlValue) => {
+		try {
+			return `${prefix}url("${urlValue.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}")`;
+		} catch {
+			return match;
+		}
+	});
+}
+async function transformTailwindV4CssToWeapp(css, options) {
+	const protectedCss = (0, _weapp_tailwindcss_postcss.protectDynamicColorMixAlpha)(normalizeTailwindV4GeneratedUrlValues((0, _weapp_tailwindcss_postcss.hasCssMacroStyleOptions)(options) ? await (0, _weapp_tailwindcss_postcss.transformCssMacroCss)(css, options) : css), { customPropertyValues: options && "customPropertyValues" in options ? options.customPropertyValues : void 0 });
+	const result = await defaultStyleHandler(protectedCss.css, {
+		cssChildCombinatorReplaceValue: ["view", "text"],
+		cssRemoveHoverPseudoClass: true,
+		isMainChunk: true,
+		majorVersion: 4,
+		...options
+	});
+	const pruneOptions = {
+		preservePreflight: true,
+		preserveConditionalComments: (0, _weapp_tailwindcss_postcss.hasCssMacroStyleOptions)(options)
+	};
+	return (0, _weapp_tailwindcss_postcss.pruneMiniProgramGeneratedCss)(protectedCss.restore(result.css), pruneOptions);
+}
+function transformTailwindV4WebRpxCss(css) {
+	if (!css.includes("rpx")) return css;
+	try {
+		const root = _weapp_tailwindcss_postcss.postcss.parse(css);
+		return (0, _weapp_tailwindcss_postcss.normalizeTailwindcssWebRpxDeclarations)(root, { majorVersion: 4 }) ? root.toString() : css;
+	} catch {
+		return css;
+	}
+}
+function shouldTransformWebRpxCss(options) {
+	return options?.appType === "uni-app-vite" || shouldUseWebGeneratorTargetFromEnv();
+}
+async function transformTailwindV4CssByTarget(css, target, options) {
+	if (target === "weapp") return transformTailwindV4CssToWeapp(css, options);
+	const resolvedWebCss = await ((0, _weapp_tailwindcss_postcss.hasCssMacroStyleOptions)(options) ? (0, _weapp_tailwindcss_postcss.transformCssMacroCss)(css, options) : css);
+	return shouldTransformWebRpxCss(options) ? transformTailwindV4WebRpxCss(resolvedWebCss) : resolvedWebCss;
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator.ts
+const INCREMENTAL_GENERATE_CACHE_MAX = 8;
+const INCREMENTAL_GENERATE_TASK_CACHE_MAX = 32;
+const INCREMENTAL_GENERATE_ENTRY_CANDIDATES_MAX = 128;
+const INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX = 256 * 1024;
+const incrementalGenerateCache = new lru_cache.LRUCache({ max: INCREMENTAL_GENERATE_CACHE_MAX });
+const incrementalGenerateTaskCache = new lru_cache.LRUCache({ max: INCREMENTAL_GENERATE_TASK_CACHE_MAX });
+function collectCandidates(candidates) {
+	return new Set(candidates ?? []);
+}
+function hasRemovedCandidates(previousCandidates, nextCandidates) {
+	for (const candidate of previousCandidates) if (!nextCandidates.has(candidate)) return true;
+	return false;
+}
+function createStableJson(value) {
+	if (value === void 0) return "undefined";
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => createStableJson(item)).join(",")}]`;
+	return `{${Object.keys(value).sort().map((key) => {
+		const record = value;
+		return `${JSON.stringify(key)}:${createStableJson(record[key])}`;
+	}).join(",")}}`;
+}
+function createDependencyFingerprint(files) {
+	return files.map((file) => {
+		try {
+			const stat = node_fs.default.statSync(file);
+			return `${file}:${stat.size}:${stat.mtimeMs}`;
+		} catch {
+			return `${file}:missing`;
+		}
+	}).join("|");
+}
+function createIncrementalGenerateCacheKey(source, target, styleOptions) {
+	return [
+		source.projectRoot,
+		source.base,
+		createStableJson(source.baseFallbacks),
+		source.css,
+		createDependencyFingerprint(source.dependencies),
+		target,
+		createStableJson(styleOptions)
+	].join("\0");
+}
+function createIncrementalGenerateTaskCacheKey(cacheKey, requestedCandidates, scanSources) {
+	return [
+		cacheKey,
+		scanSources === true ? "scan:1" : "scan:0",
+		[...requestedCandidates].sort().join("\n")
+	].join("\0");
+}
+function runIncrementalGenerateTask(cacheKey, requestedCandidates, scanSources, task) {
+	const taskKey = createIncrementalGenerateTaskCacheKey(cacheKey, requestedCandidates, scanSources);
+	const cachedTask = incrementalGenerateTaskCache.get(taskKey);
+	if (cachedTask) return cachedTask;
+	const promise = task();
+	incrementalGenerateTaskCache.set(taskKey, promise);
+	promise.finally(() => {
+		if (incrementalGenerateTaskCache.get(taskKey) === promise) incrementalGenerateTaskCache.delete(taskKey);
+	});
+	return promise;
+}
+function createIncrementalDesignSystemPromise(source, cacheKey) {
+	const promise = (0, _tailwindcss_mangle_engine.loadTailwindV4DesignSystem)(source);
+	promise.catch(() => {
+		if (incrementalGenerateCache.get(cacheKey)?.designSystemPromise === promise) incrementalGenerateCache.delete(cacheKey);
+	});
+	return promise;
+}
+function resolveTargetCandidates(candidates, target) {
+	const collected = collectCandidates(candidates);
+	return target === "weapp" ? filterUnsupportedMiniProgramTailwindV4Candidates(collected) : collected;
+}
+function collectSeenCandidates(generated, requestedCandidates) {
+	return new Set([
+		...requestedCandidates,
+		...generated.rawCandidates,
+		...generated.classSet
+	]);
+}
+function shouldDelegateWebSourceScanToTailwind(target, scanSources) {
+	return target === "web" && scanSources !== false;
+}
+function createIncrementalStyleOptions(styleOptions) {
+	return {
+		...styleOptions,
+		isMainChunk: false
+	};
+}
+function resolveStyleOptions(source, options) {
+	return (0, _weapp_tailwindcss_postcss.hasCssMacroTailwindV4Directive)(source.css) ? (0, _weapp_tailwindcss_postcss.withCssMacroStyleOptions)(options) : options;
+}
+function collectCustomPropertyValues(css) {
+	const values = /* @__PURE__ */ new Map();
+	try {
+		_weapp_tailwindcss_postcss.postcss.parse(css).walkDecls((decl) => {
+			if (decl.prop.startsWith("--")) values.set(decl.prop, decl.value.trim());
+		});
+	} catch {}
+	return values;
+}
+function mergeCustomPropertyValues(target, css) {
+	for (const [prop, value] of collectCustomPropertyValues(css)) target.set(prop, value);
+}
+function createStableTextSignature(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function summarizeIncrementalCacheKey(key) {
+	return {
+		keyHash: createStableTextSignature(key),
+		keyBytes: key.length
+	};
+}
+function shouldRebuildIncrementalEntry(cached, requestedCandidates, missingCandidates) {
+	return cached.seenCandidates.size + missingCandidates.length > INCREMENTAL_GENERATE_ENTRY_CANDIDATES_MAX || cached.css.length > INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX || cached.rawCss.length > INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX || requestedCandidates.size > INCREMENTAL_GENERATE_ENTRY_CANDIDATES_MAX;
+}
+function shouldAdmitIncrementalEntry(requestedCandidates, generated) {
+	return requestedCandidates.size <= INCREMENTAL_GENERATE_ENTRY_CANDIDATES_MAX && generated.css.length <= INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX && generated.rawCss.length <= INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX;
+}
+function seedIncrementalGenerateCache(options) {
+	if (!shouldAdmitIncrementalEntry(options.requestedCandidates, options.generated)) return false;
+	const cacheKey = createIncrementalGenerateCacheKey(options.compatibleSource, options.target, options.styleOptions);
+	const customPropertyValues = collectCustomPropertyValues(options.compatibleSource.css);
+	mergeCustomPropertyValues(customPropertyValues, options.generated.css);
+	incrementalGenerateCache.set(cacheKey, {
+		seenCandidates: collectSeenCandidates(options.generated, options.requestedCandidates),
+		classSet: new Set(options.generated.classSet),
+		css: options.generated.css,
+		rawCss: options.generated.rawCss,
+		customPropertyValues,
+		designSystemPromise: createIncrementalDesignSystemPromise(options.compatibleSource, cacheKey),
+		dependencies: options.generated.dependencies,
+		sources: options.generated.sources,
+		root: options.generated.root,
+		target: options.generated.target
+	});
+	return true;
+}
+function shouldNormalizeRpxLengthCandidatesForTarget(target, styleOptions) {
+	if (target !== "web") return true;
+	return styleOptions?.appType === "uni-app-vite" || shouldUseWebGeneratorTargetFromEnv();
+}
+function normalizeTargetRpxLengthCandidates(candidates, target, styleOptions) {
+	return shouldNormalizeRpxLengthCandidatesForTarget(target, styleOptions) ? normalizeRpxLengthCandidates(candidates) : {
+		candidates: new Set(candidates),
+		restoreCandidates: /* @__PURE__ */ new Map()
+	};
+}
+function createTailwindV4Engine(source) {
+	async function generateOnce(generateSource, options = {}) {
+		const { scanSources = true, styleOptions, target = "weapp", ...patchOptions } = options;
+		const resolvedStyleOptions = resolveStyleOptions(generateSource, styleOptions);
+		const engine = (0, _tailwindcss_mangle_engine.createTailwindV4Engine)(createCompatibleSource(generateSource, target));
+		const resolvedScanSources = await resolveScanSources(generateSource, scanSources);
+		const delegateSourceScan = shouldDelegateWebSourceScanToTailwind(target, resolvedScanSources);
+		const filesystemCandidates = !delegateSourceScan && Array.isArray(resolvedScanSources) ? new Set(await (0, _tailwindcss_mangle_engine.extractRawCandidates)(resolvedScanSources, { ...patchOptions.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: patchOptions.bareArbitraryValues } })) : void 0;
+		const normalizedCandidates = normalizeTargetRpxLengthCandidates(resolveTargetCandidates(new Set([...collectCandidates(patchOptions.candidates), ...filesystemCandidates ?? []]), target), target, resolvedStyleOptions);
+		const result = await engine.generate(omitUndefined({
+			scanSources: delegateSourceScan ? resolvedScanSources : false,
+			...patchOptions,
+			candidates: normalizedCandidates.candidates
+		}));
+		const rawCss = restoreRpxLengthCssSelectors(result.css, normalizedCandidates.restoreCandidates);
+		const css = await transformTailwindV4CssByTarget(rawCss, target, resolvedStyleOptions);
+		return {
+			...result,
+			classSet: restoreRpxLengthCandidates(result.classSet, normalizedCandidates.restoreCandidates),
+			rawCandidates: restoreRpxLengthCandidates(result.rawCandidates, normalizedCandidates.restoreCandidates),
+			css,
+			rawCss,
+			target
+		};
+	}
+	async function generateWithIncrementalCache(options = {}) {
+		const target = options.target ?? "weapp";
+		const compatibleSource = createCompatibleSource(source, target);
+		const requestedCandidates = resolveTargetCandidates(options.candidates, target);
+		const styleOptions = resolveStyleOptions(source, options.styleOptions);
+		if ((options.sources?.length ?? 0) > 0 || options.bareArbitraryValues !== void 0 || Array.isArray(options.scanSources)) return generateOnce(source, options);
+		const cacheKey = createIncrementalGenerateCacheKey(compatibleSource, target, styleOptions);
+		if (options.scanSources === true) return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+			const generated = await generateOnce(source, options);
+			if (!seedIncrementalGenerateCache({
+				compatibleSource,
+				generated,
+				requestedCandidates,
+				styleOptions: options.styleOptions,
+				target
+			})) incrementalGenerateCache.delete(cacheKey);
+			return generated;
+		});
+		const cached = incrementalGenerateCache.get(cacheKey);
+		if (cached) {
+			if (hasRemovedCandidates(cached.seenCandidates, requestedCandidates)) return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+				const generated = await generateOnce(source, options);
+				if (!seedIncrementalGenerateCache({
+					compatibleSource,
+					generated,
+					requestedCandidates,
+					styleOptions,
+					target
+				})) incrementalGenerateCache.delete(cacheKey);
+				return generated;
+			});
+			const missingCandidates = [...requestedCandidates].filter((candidate) => !cached.seenCandidates.has(candidate));
+			if (missingCandidates.length === 0) return {
+				css: cached.css,
+				rawCss: cached.rawCss,
+				incrementalCss: "",
+				incrementalRawCss: "",
+				classSet: new Set(cached.classSet),
+				rawCandidates: new Set(cached.seenCandidates),
+				dependencies: cached.dependencies,
+				sources: cached.sources,
+				root: cached.root,
+				target: cached.target
+			};
+			if (shouldRebuildIncrementalEntry(cached, requestedCandidates, missingCandidates)) return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+				const generated = await generateOnce(source, options);
+				if (!seedIncrementalGenerateCache({
+					compatibleSource,
+					generated,
+					requestedCandidates,
+					styleOptions,
+					target
+				})) incrementalGenerateCache.delete(cacheKey);
+				return generated;
+			});
+			return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+				const designSystem = await cached.designSystemPromise;
+				const normalizedMissing = normalizeTargetRpxLengthCandidates(missingCandidates, target, styleOptions);
+				const normalizedMissingCandidates = [...normalizedMissing.candidates];
+				const cssByCandidate = designSystem.candidatesToCss(normalizedMissingCandidates);
+				const rawCssParts = [];
+				const classSet = /* @__PURE__ */ new Set();
+				for (let index = 0; index < normalizedMissingCandidates.length; index += 1) {
+					const candidate = normalizedMissingCandidates[index];
+					const css = cssByCandidate[index];
+					if (candidate && typeof css === "string" && css.trim().length > 0) {
+						rawCssParts.push(restoreRpxLengthCssSelectors(css, normalizedMissing.restoreCandidates));
+						classSet.add(normalizedMissing.restoreCandidates.get(candidate) ?? candidate);
+					}
+				}
+				const rawCss = rawCssParts.join("\n");
+				const incrementalCss = rawCss.length > 0 ? await transformTailwindV4CssByTarget(rawCss, target, {
+					...createIncrementalStyleOptions(styleOptions),
+					customPropertyValues: cached.customPropertyValues
+				}) : "";
+				for (const candidate of missingCandidates) cached.seenCandidates.add(candidate);
+				for (const className of classSet) cached.classSet.add(className);
+				cached.css = [cached.css, incrementalCss].filter(Boolean).join("\n");
+				cached.rawCss = [cached.rawCss, rawCss].filter(Boolean).join("\n");
+				mergeCustomPropertyValues(cached.customPropertyValues, incrementalCss);
+				return {
+					css: cached.css,
+					rawCss: cached.rawCss,
+					incrementalCss,
+					incrementalRawCss: rawCss,
+					classSet: new Set(cached.classSet),
+					rawCandidates: new Set(cached.seenCandidates),
+					dependencies: cached.dependencies,
+					sources: cached.sources,
+					root: cached.root,
+					target: cached.target
+				};
+			});
+		}
+		return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+			const generated = await generateOnce(source, options);
+			seedIncrementalGenerateCache({
+				compatibleSource,
+				generated,
+				requestedCandidates,
+				styleOptions,
+				target
+			});
+			return generated;
+		});
+	}
+	async function generate(options = {}) {
+		return options.incrementalCache ? generateWithIncrementalCache(options) : generateOnce(source, options);
+	}
+	return {
+		source,
+		loadDesignSystem: (0, _tailwindcss_mangle_engine.createTailwindV4Engine)(source).loadDesignSystem,
+		validateCandidates: (0, _tailwindcss_mangle_engine.createTailwindV4Engine)(source).validateCandidates,
+		generate
+	};
+}
+function getTailwindV4IncrementalGenerateCacheStats() {
+	return {
+		max: INCREMENTAL_GENERATE_CACHE_MAX,
+		entryCandidatesMax: INCREMENTAL_GENERATE_ENTRY_CANDIDATES_MAX,
+		entryCssBytesMax: INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX,
+		size: incrementalGenerateCache.size,
+		taskMax: INCREMENTAL_GENERATE_TASK_CACHE_MAX,
+		taskSize: incrementalGenerateTaskCache.size,
+		entries: [...incrementalGenerateCache.entries()].map(([key, entry]) => ({
+			...summarizeIncrementalCacheKey(key),
+			candidates: entry.seenCandidates.size,
+			classSet: entry.classSet.size,
+			cssBytes: entry.css.length,
+			rawCssBytes: entry.rawCss.length
+		})),
+		keys: [...incrementalGenerateCache.keys()].map(summarizeIncrementalCacheKey),
+		taskKeys: [...incrementalGenerateTaskCache.keys()].map(summarizeIncrementalCacheKey)
+	};
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/config-directive.ts
+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}`;
+}
+function normalizeConfigDirective(css, config) {
+	if (!config || !/@config\s+/.test(css)) return css;
+	return css.replace(/@config\s+(["'])(.+?)\1\s*;?/, `@config "${quoteCssString(toCssPath(config))}";`);
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/markers.ts
+const TAILWIND_V4_BANNER_RE = /\/\*!\s*tailwindcss v4\./;
+const TAILWIND_ESCAPED_UTILITY_MARKER_RE = /\.[^,{]{0,512}(?:\\:|\\\[|\\#)/;
+const TAILWIND_ROOT_THEME_MARKER_RE = /(?::host|page|\.tw-root|wx-root-portal-content)[^{]{0,256}\{[^}]{0,4096}--(?:color|spacing|text|font-weight|radius)-/;
+const GENERATOR_PLACEHOLDER_MARKER_RE = /\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\//i;
+const GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE = /\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\/\s*/gi;
+const TAILWIND_BANNER_PREFIX_RE = /^\/\*!\s*tailwindcss v[^*]*\*\/\s*/i;
+const TAILWIND_BANNER_RE = /\/\*!\s*tailwindcss v[^*]*\*\//i;
+const TAILWIND_BANNER_GLOBAL_RE = /\/\*!\s*tailwindcss v[^*]*\*\/\s*/gi;
+const VITE_MARKER_RE = /\/\*\$vite\$:[^*]*\*\//g;
+function createCssAppend(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	return `${base}\n${extra}`;
+}
+function splitTailwindV4GeneratedCssBySourceOrder(rawSource, rawTailwindCss) {
+	const trimmedRaw = rawSource.trim();
+	const trimmedTailwind = rawTailwindCss.trim();
+	if (trimmedRaw === trimmedTailwind) return {
+		before: "",
+		after: ""
+	};
+	if (trimmedTailwind.startsWith(trimmedRaw)) return {
+		before: "",
+		after: ""
+	};
+	const start = rawSource.indexOf(rawTailwindCss);
+	if (start === -1) return;
+	return {
+		before: rawSource.slice(0, start),
+		after: rawSource.slice(start + rawTailwindCss.length)
+	};
+}
+function splitGeneratorPlaceholderCssBySourceOrder(rawSource, rawTailwindCss) {
+	const match = GENERATOR_PLACEHOLDER_MARKER_RE.exec(rawSource);
+	if (!match || match.index === void 0) return;
+	let afterStart = match.index + match[0].length;
+	while (/\s/.test(rawSource[afterStart] ?? "")) afterStart++;
+	if (rawTailwindCss && rawSource.slice(afterStart).startsWith(rawTailwindCss)) {
+		afterStart += rawTailwindCss.length;
+		while (/\s/.test(rawSource[afterStart] ?? "")) afterStart++;
+	}
+	return {
+		before: rawSource.slice(0, match.index),
+		after: rawSource.slice(afterStart)
+	};
+}
+function splitTailwindGeneratedCssByBanner(rawSource, start) {
+	const match = start === void 0 ? TAILWIND_BANNER_RE.exec(rawSource) : { index: start };
+	if (!match || match.index === void 0) return;
+	return {
+		before: rawSource.slice(0, match.index),
+		after: [...rawSource.slice(match.index).matchAll(VITE_MARKER_RE)].map((item) => item[0]).join("\n")
+	};
+}
+function stripTailwindBanner(css) {
+	return css.replace(TAILWIND_BANNER_PREFIX_RE, "");
+}
+function stripTailwindBanners(css) {
+	return css.replace(TAILWIND_BANNER_GLOBAL_RE, "");
+}
+function stripGeneratorPlaceholderMarkers(css) {
+	return css.replace(GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE, "");
+}
+function hasTailwindGeneratedCss(rawSource) {
+	return TAILWIND_V4_BANNER_RE.test(rawSource);
+}
+function hasTailwindGeneratedCssMarkers(rawSource) {
+	if (rawSource.includes("--tw-") || rawSource.includes("tailwindcss v") || rawSource.includes(":not(#\\#)") || GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource)) return true;
+	if (!rawSource.includes("\\:") && !rawSource.includes("\\[") && !rawSource.includes("\\#") && !rawSource.includes("--color-") && !rawSource.includes("--spacing-") && !rawSource.includes("--text-") && !rawSource.includes("--font-weight-") && !rawSource.includes("--radius-")) return false;
+	return TAILWIND_ESCAPED_UTILITY_MARKER_RE.test(rawSource) || TAILWIND_ROOT_THEME_MARKER_RE.test(rawSource);
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/directives/fallback.ts
+const TAILWIND_EXTRACTABLE_DIRECTIVE_RE = /^\s*@(?:import|use|forward|tailwind|config|source|reference|plugin)\b[\s\S]*?(?:;|$)/;
+const TAILWIND_EXTRACTABLE_LAYER_STATEMENT_RE = /^\s*@layer\s[^;{]+;\s*$/;
+const TAILWIND_EXTRACTABLE_BLOCK_START_RE = /^\s*@(?:layer|theme|utility|variant|custom-variant|plugin)\b[\s\S]*\{/;
+function parseImportRequest$1(params) {
+	return /^(?:url\(\s*)?(["']?)([^"')\s]+)\1\s*\)?/.exec(params.trim())?.[2];
+}
+function parseConfigRequest$1(params) {
+	return /^(["'])(.+)\1\s*;?$/.exec(params.trim())?.[2];
+}
+function isPackageJsonImportRequest$1(request) {
+	return typeof request === "string" && request.startsWith("#");
+}
+function isWeappTailwindcssImportRequest$1(request) {
+	return request === "weapp-tailwindcss" || request?.startsWith("weapp-tailwindcss/");
+}
+function isTailwindImportRequest$1(request) {
+	return request === "tailwindcss" || request === "tailwindcss4" || request?.startsWith("tailwindcss/") || request?.startsWith("tailwindcss4/");
+}
+function normalizeTailwindImportRequest$1(request, options = {}) {
+	if (options.importFallback && isWeappTailwindcssImportRequest$1(request)) return request.replace(/^weapp-tailwindcss/, "tailwindcss");
+	return request;
+}
+function replaceImportRequest$1(params, request, replacement) {
+	const index = params.indexOf(request);
+	if (index === -1) return params;
+	return `${params.slice(0, index)}${replacement}${params.slice(index + request.length)}`;
+}
+function normalizeTailwindDirectiveLine(line, options = {}) {
+	const trimmed = line.trimStart();
+	if (/^@(?:use|forward)\b/.test(trimmed)) {
+		const request = parseImportRequest$1(trimmed.replace(/^@(?:use|forward)\b/, ""));
+		if (isTailwindImportRequest$1(request) || options.importFallback && isWeappTailwindcssImportRequest$1(request)) {
+			const normalizedRequest = normalizeTailwindImportRequest$1(request, options);
+			return replaceImportRequest$1(line.replace(/^(\s*)@(?:use|forward)\b/, "$1@import"), request, normalizedRequest);
+		}
+		return line;
+	}
+	if (!options.importFallback || !trimmed.startsWith("@import")) return line;
+	const request = parseImportRequest$1(trimmed.replace(/^@import\b/, ""));
+	if (!request || !isWeappTailwindcssImportRequest$1(request)) return line;
+	return replaceImportRequest$1(line, request, request.replace(/^weapp-tailwindcss/, "tailwindcss"));
+}
+function extractTailwindDirectiveLines(rawSource, options = {}) {
+	const directives = [];
+	const seenImports = /* @__PURE__ */ new Set();
+	for (const line of stripGeneratorPlaceholderMarkers(rawSource).split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("//")) continue;
+		const directive = TAILWIND_EXTRACTABLE_DIRECTIVE_RE.exec(line)?.[0] ?? TAILWIND_EXTRACTABLE_LAYER_STATEMENT_RE.exec(line)?.[0];
+		if (!directive) continue;
+		if (TAILWIND_EXTRACTABLE_BLOCK_START_RE.test(directive)) continue;
+		const normalized = normalizeTailwindDirectiveLine(directive.trimEnd(), options);
+		const normalizedTrimmed = normalized.trim();
+		if (options.removeConfig && normalizedTrimmed.startsWith("@config")) continue;
+		const request = /^@(?:import|use|forward)\b/.test(normalizedTrimmed) ? parseImportRequest$1(normalizedTrimmed.replace(/^@(?:import|use|forward)\b/, "")) : void 0;
+		if (request && !isTailwindImportRequest$1(request) && !isPackageJsonImportRequest$1(request)) continue;
+		if (/^@(?:import|use|forward)\b/.test(normalizedTrimmed) && !request) continue;
+		if (request && isTailwindImportRequest$1(request)) {
+			const key = normalizedTrimmed;
+			if (seenImports.has(key)) continue;
+			seenImports.add(key);
+		}
+		directives.push(normalized);
+	}
+	return directives;
+}
+function stripPreprocessorLineComment(line) {
+	let quote;
+	let escaped = false;
+	for (let index = 0; index < line.length; index++) {
+		const char = line[index];
+		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 === "/" && line[index + 1] === "/" && (index === 0 || /\s/.test(line[index - 1]))) return line.slice(0, index).trimEnd();
+	}
+	return line;
+}
+function countBlockBraceDelta(line) {
+	let quote;
+	let escaped = false;
+	let delta = 0;
+	for (let index = 0; index < line.length; index++) {
+		const char = line[index];
+		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 === "{") delta++;
+		else if (char === "}") delta--;
+	}
+	return delta;
+}
+function extractTailwindFallbackBlocks(rawSource) {
+	const blocks = [];
+	let current;
+	let depth = 0;
+	for (const rawLine of stripGeneratorPlaceholderMarkers(rawSource).split(/\r?\n/)) {
+		const line = stripPreprocessorLineComment(rawLine);
+		if (!line.trim()) continue;
+		if (!current) {
+			if (!TAILWIND_EXTRACTABLE_BLOCK_START_RE.test(line)) continue;
+			current = [line];
+			depth = countBlockBraceDelta(line);
+			if (depth <= 0) {
+				blocks.push(current.join("\n"));
+				current = void 0;
+				depth = 0;
+			}
+			continue;
+		}
+		current.push(line);
+		depth += countBlockBraceDelta(line);
+		if (depth <= 0) {
+			blocks.push(current.join("\n"));
+			current = void 0;
+			depth = 0;
+		}
+	}
+	return blocks;
+}
+function extractTailwindSourceForPostcssFallback(rawSource, options = {}) {
+	const directives = [...extractTailwindDirectiveLines(rawSource, options), ...extractTailwindFallbackBlocks(rawSource)];
+	return directives.length > 0 ? directives.join("\n") : void 0;
+}
+function extractConfigRequestFromSource(rawSource) {
+	for (const line of rawSource.split(/\r?\n/)) {
+		const match = /^\s*@config\b([\s\S]*?)(?:;|$)/.exec(line);
+		const request = match ? parseConfigRequest$1(match[1] ?? "") : void 0;
+		if (request) return request;
+	}
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/directives.ts
+const TAILWIND_REMOVABLE_SOURCE_DIRECTIVE_NAMES = new Set([
+	"config",
+	"custom-variant",
+	"layer",
+	"plugin",
+	"reference",
+	"source",
+	"tailwind",
+	"theme",
+	"utility",
+	"variant"
+]);
+const TAILWIND_ROOT_DIRECTIVE_NAMES = new Set([
+	"config",
+	"custom-variant",
+	"plugin",
+	"source",
+	"tailwind",
+	"theme",
+	"utility",
+	"variant"
+]);
+const TAILWIND_ROOT_DIRECTIVE_RE = /@(?:import\s+(?:url\(\s*)?["']?tailwindcss4?(?:\/[^"')\s]*)?|(?:use|forward)\s+(?:url\(\s*)?["']?tailwindcss4?(?:\/[^"')\s]*)?|tailwind|config|custom-variant|plugin|source|theme|utility|variant)\b/;
+function parseImportRequest(params) {
+	return /^(?:url\(\s*)?(["']?)([^"')\s]+)\1\s*\)?/.exec(params.trim())?.[2];
+}
+function hasLocalCssImport(rawSource) {
+	let found = false;
+	try {
+		_weapp_tailwindcss_postcss.postcss.parse(rawSource).walkAtRules("import", (rule) => {
+			const request = parseImportRequest(rule.params);
+			if (request?.startsWith(".") === true || request?.startsWith("/") === true) {
+				found = true;
+				return false;
+			}
+		});
+	} catch {}
+	return found;
+}
+function parseConfigRequest(params) {
+	return /^(["'])(.+)\1\s*;?$/.exec(params.trim())?.[2];
+}
+function isPackageJsonImportRequest(request) {
+	return typeof request === "string" && request.startsWith("#");
+}
+function isWeappTailwindcssImportRequest(request) {
+	return request === "weapp-tailwindcss" || request?.startsWith("weapp-tailwindcss/");
+}
+function normalizeTailwindImportRequest(request, options = {}) {
+	if (options.importFallback && isWeappTailwindcssImportRequest(request)) return request.replace(/^weapp-tailwindcss/, "tailwindcss");
+	return request;
+}
+function replaceImportRequest(params, request, replacement) {
+	const index = params.indexOf(request);
+	if (index === -1) return params;
+	return `${params.slice(0, index)}${replacement}${params.slice(index + request.length)}`;
+}
+function normalizeTailwindImportAtRules(root, options = {}) {
+	if (!options.importFallback) return false;
+	let changed = false;
+	const seenCanonicalImports = /* @__PURE__ */ new Set();
+	root.walkAtRules("import", (node) => {
+		const request = parseImportRequest(node.params);
+		const normalizedRequest = normalizeTailwindImportRequest(request, options);
+		if (!normalizedRequest || !isTailwindImportRequest(normalizedRequest)) return;
+		const normalizedParams = request && normalizedRequest !== request ? replaceImportRequest(node.params, request, normalizedRequest) : node.params;
+		const normalizedKey = normalizedParams.trim();
+		if (seenCanonicalImports.has(normalizedKey)) {
+			node.remove();
+			changed = true;
+			return;
+		}
+		seenCanonicalImports.add(normalizedKey);
+		if (normalizedParams !== node.params) {
+			node.params = normalizedParams;
+			changed = true;
+		}
+	});
+	return changed;
+}
+function resolveConfigPath(base, configPath) {
+	if (node_path.default.isAbsolute(configPath) || isPackageJsonImportRequest(configPath)) return node_path.default.isAbsolute(configPath) ? configPath : void 0;
+	return node_path.default.resolve(base, configPath);
+}
+function normalizeTailwindConfigDirectives(rawSource, base) {
+	return rawSource.replace(/@config\s+(["'])(.+?)\1\s*;?/g, (full, quote, request) => {
+		if (node_path.default.isAbsolute(request) || isPackageJsonImportRequest(request)) return full;
+		return `@config ${quote}${node_path.default.resolve(base, request).replace(/\\/g, "/")}${quote};`;
+	});
+}
+function hasPreprocessorOnlySyntax(rawSource) {
+	return /(?:^|\n)\s*(?:\/\/|\$[\w-]+\s*:|@[\w-]+\s*:|@(?:mixin|include|function|use|forward)\b)/.test(rawSource);
+}
+function normalizeTailwindSourceForGenerator(rawSource, options = {}) {
+	return hasPreprocessorOnlySyntax(rawSource) ? extractTailwindSourceForPostcssFallback(rawSource, options) ?? rawSource : rawSource;
+}
+function normalizeTailwindSourceDirectives(rawSource, options = {}) {
+	if (!options.importFallback) return rawSource;
+	try {
+		const root = _weapp_tailwindcss_postcss.postcss.parse(rawSource);
+		return normalizeTailwindImportAtRules(root, options) ? root.toString() : rawSource;
+	} catch {
+		return extractTailwindSourceForPostcssFallback(rawSource, options) ?? rawSource;
+	}
+}
+function isTailwindImportRequest(request) {
+	return request === "tailwindcss" || request === "tailwindcss4" || request?.startsWith("tailwindcss/") || request?.startsWith("tailwindcss4/");
+}
+function isTailwindImportAtRule(node, options = {}) {
+	if (node.name === "tailwind") return true;
+	if (node.name !== "import" && node.name !== "use" && node.name !== "forward") return false;
+	return isTailwindImportRequest(normalizeTailwindImportRequest(parseImportRequest(node.params), options));
+}
+function isTailwindSourceDirective(node, options = {}) {
+	if (node.type !== "atrule") return false;
+	const atRule = node;
+	if (isTailwindImportAtRule(atRule, options)) return true;
+	if (atRule.name === "import" && isPackageJsonImportRequest(parseImportRequest(atRule.params))) return true;
+	if (atRule.name === "layer") return !atRule.nodes || atRule.nodes.length === 0;
+	return TAILWIND_REMOVABLE_SOURCE_DIRECTIVE_NAMES.has(atRule.name);
+}
+function hasGeneratedCssArtifacts(rawSource) {
+	return hasTailwindGeneratedCssMarkers(rawSource) && !GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource);
+}
+function isTailwindGenerationDirective(node, options = {}) {
+	if (node.type !== "atrule") return false;
+	const atRule = node;
+	const request = atRule.name === "import" ? parseImportRequest(atRule.params) : atRule.name === "config" || atRule.name === "plugin" || atRule.name === "reference" ? parseConfigRequest(atRule.params) : void 0;
+	return isTailwindImportAtRule(atRule, options) || isPackageJsonImportRequest(request) || atRule.name === "apply" || !options.ignoreLayer && atRule.name === "layer" || atRule.name === "config" || atRule.name === "source";
+}
+function removeTailwindSourceDirectives(rawSource, options = {}) {
+	try {
+		const source = hasPreprocessorOnlySyntax(rawSource) ? extractTailwindSourceForPostcssFallback(rawSource, options) : stripGeneratorPlaceholderMarkers(rawSource);
+		if (!source) return "";
+		const root = _weapp_tailwindcss_postcss.postcss.parse(source);
+		let removed = false;
+		root.walk((node) => {
+			if (isTailwindSourceDirective(node, options)) {
+				node.remove();
+				removed = true;
+			}
+		});
+		return removed ? root.toString() : source;
+	} catch {
+		return stripGeneratorPlaceholderMarkers(rawSource);
+	}
+}
+function hasTailwindSourceDirectives(rawSource, options = {}) {
+	try {
+		if (GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource)) return true;
+		const root = _weapp_tailwindcss_postcss.postcss.parse(rawSource);
+		let found = false;
+		const ignoreLayer = hasGeneratedCssArtifacts(rawSource);
+		root.walk((node) => {
+			if (isTailwindGenerationDirective(node, {
+				...options,
+				ignoreLayer
+			})) {
+				found = true;
+				return false;
+			}
+		});
+		return found;
+	} catch {
+		return extractTailwindDirectiveLines(rawSource, options).length > 0;
+	}
+}
+function hasTailwindNonRootGenerationDirectives(rawSource, options = {}) {
+	try {
+		if (GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource)) return true;
+		const root = _weapp_tailwindcss_postcss.postcss.parse(rawSource);
+		let found = false;
+		const ignoreLayer = hasGeneratedCssArtifacts(rawSource);
+		root.walk((node) => {
+			if (isTailwindGenerationDirective(node, {
+				...options,
+				ignoreLayer
+			}) && !(node.type === "atrule" && isTailwindImportAtRule(node, options))) {
+				found = true;
+				return false;
+			}
+		});
+		return found;
+	} catch {
+		return GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource) || /@(?:apply|config|custom-variant|plugin|source|theme|utility|variant)\b/.test(rawSource);
+	}
+}
+function hasTailwindRootImportDirectives(rawSource, options = {}) {
+	if (!TAILWIND_ROOT_DIRECTIVE_RE.test(rawSource) && !(options.importFallback && rawSource.includes("weapp-tailwindcss"))) return false;
+	try {
+		const root = _weapp_tailwindcss_postcss.postcss.parse(rawSource);
+		let found = false;
+		root.walkAtRules((node) => {
+			if (isTailwindImportAtRule(node, options)) {
+				found = true;
+				return false;
+			}
+		});
+		return found;
+	} catch {
+		return extractTailwindDirectiveLines(rawSource, options).some((line) => /@(?:import|use|forward)\b/.test(line));
+	}
+}
+function hasTailwindRootDirectives(rawSource, options = {}) {
+	if (!TAILWIND_ROOT_DIRECTIVE_RE.test(rawSource) && !(options.importFallback && rawSource.includes("weapp-tailwindcss"))) return false;
+	try {
+		const root = _weapp_tailwindcss_postcss.postcss.parse(rawSource);
+		let found = false;
+		root.walkAtRules((node) => {
+			const request = node.name === "import" ? parseImportRequest(node.params) : node.name === "config" || node.name === "plugin" ? parseConfigRequest(node.params) : void 0;
+			if (isTailwindImportAtRule(node, options) || isPackageJsonImportRequest(request) || TAILWIND_ROOT_DIRECTIVE_NAMES.has(node.name)) {
+				found = true;
+				return false;
+			}
+		});
+		return found;
+	} catch {
+		return extractTailwindDirectiveLines(rawSource, options).length > 0;
+	}
+}
+function hasTailwindApplyDirective(rawSource) {
+	if (!rawSource.includes("@apply")) return false;
+	try {
+		const root = _weapp_tailwindcss_postcss.postcss.parse(rawSource);
+		let found = false;
+		root.walkAtRules("apply", () => {
+			found = true;
+			return false;
+		});
+		return found;
+	} catch {
+		const fallback = extractTailwindSourceForPostcssFallback(rawSource);
+		return typeof fallback === "string" && /@apply\s[^;{}]+;/.test(fallback);
+	}
+}
+function resolveCssEntrySource(rawSource, base, options = {}) {
+	try {
+		const root = _weapp_tailwindcss_postcss.postcss.parse(rawSource);
+		const normalizedImports = normalizeTailwindImportAtRules(root, options);
+		let found = false;
+		let config;
+		let configRequest;
+		let removedConfig = false;
+		const removeConfig = options.removeConfig ?? true;
+		const ignoreLayer = hasGeneratedCssArtifacts(rawSource);
+		root.walk((node) => {
+			if (isTailwindGenerationDirective(node, {
+				...options,
+				ignoreLayer
+			})) found = true;
+			if (node.type === "atrule" && node.name === "config") {
+				const configPath = parseConfigRequest(node.params);
+				if (configPath && !config) {
+					configRequest = configPath;
+					config = resolveConfigPath(base, configPath);
+				}
+				if (removeConfig) {
+					node.remove();
+					removedConfig = true;
+				}
+			}
+		});
+		if (!found) return;
+		if (hasPreprocessorOnlySyntax(rawSource)) {
+			const css = extractTailwindSourceForPostcssFallback(rawSource, {
+				...options,
+				removeConfig
+			});
+			if (css) return {
+				css,
+				config,
+				configRequest,
+				base
+			};
+		}
+		return {
+			css: removedConfig || normalizedImports ? root.toString() : rawSource,
+			config,
+			configRequest,
+			base
+		};
+	} catch {
+		const css = extractTailwindSourceForPostcssFallback(rawSource, options);
+		const configRequest = extractConfigRequestFromSource(rawSource);
+		const config = configRequest ? resolveConfigPath(base, configRequest) : void 0;
+		return css ? {
+			css,
+			config,
+			configRequest,
+			base
+		} : void 0;
+	}
+}
+//#endregion
+//#region src/utils/options.ts
+function resolveBooleanObjectOption(value, enabledValue) {
+	if (!value) return false;
+	if (value === true) return enabledValue;
+	return value;
+}
+function normalizeStringListOption(value) {
+	if (!value) return;
+	const values = typeof value === "string" ? [value] : Array.isArray(value) ? value : void 0;
+	if (!values) return;
+	const normalized = values.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+	return normalized.length > 0 ? normalized : void 0;
+}
+//#endregion
+//#region src/tailwindcss/runtime-options.ts
+function resolveTailwindcssOptions(options) {
+	return options?.tailwindcss ?? options?.tailwind;
+}
+function normalizeExtendLengthUnits(value) {
+	if (value === void 0) return;
+	const resolved = resolveBooleanObjectOption(value, { enabled: true });
+	return resolved && typeof resolved === "object" ? {
+		enabled: true,
+		...resolved
+	} : resolved;
+}
+function normalizeTailwindcssRuntimeOptions(options) {
+	return options;
+}
+//#endregion
+//#region src/context/workspace.ts
+const IGNORED_WORKSPACE_DIRS = new Set([
+	"node_modules",
+	".git",
+	".hg",
+	".svn",
+	".turbo",
+	".output",
+	".next",
+	"dist",
+	"build"
+]);
+function findWorkspaceRoot(startDir) {
+	if (!startDir) return;
+	let current = node_path.default.resolve(startDir);
+	while (true) {
+		if ((0, node_fs.existsSync)(node_path.default.join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findNearestPackageRoot(startDir) {
+	if (!startDir) return;
+	let current = node_path.default.resolve(startDir);
+	while (true) {
+		if ((0, node_fs.existsSync)(node_path.default.join(current, "package.json"))) return current;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findWorkspacePackageDir(rootDir, packageName) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [node_path.default.resolve(rootDir)];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const normalized = node_path.default.normalize(current);
+		if (visited.has(normalized)) continue;
+		visited.add(normalized);
+		try {
+			const pkgPath = node_path.default.join(normalized, "package.json");
+			if ((0, node_fs.existsSync)(pkgPath)) {
+				if (JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf8"))?.name === packageName) return normalized;
+			}
+		} catch {}
+		let entries;
+		try {
+			entries = (0, node_fs.readdirSync)(normalized, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || IGNORED_WORKSPACE_DIRS.has(entry.name) || entry.isSymbolicLink?.()) continue;
+			queue.push(node_path.default.join(normalized, entry.name));
+		}
+	}
+}
+//#endregion
+//#region src/tailwindcss/v4/css-entries.ts
+const TAILWIND_V4_CSS_ENTRY_RE = /\.css(?:[?#].*)?$/i;
+function isTailwindV4CssEntry(entry) {
+	return typeof entry === "string" && TAILWIND_V4_CSS_ENTRY_RE.test(entry.trim());
+}
+function guessBasedirFromEntries(entries) {
+	if (!entries) return;
+	for (const entry of entries) {
+		if (typeof entry !== "string") continue;
+		const trimmed = entry.trim();
+		if (!trimmed || !node_path.default.isAbsolute(trimmed)) continue;
+		if (!isTailwindV4CssEntry(trimmed)) continue;
+		const entryDir = node_path.default.dirname(trimmed);
+		const resolved = findNearestPackageRoot(entryDir) ?? entryDir;
+		if (resolved) return resolved;
+	}
+}
+function normalizeCssEntries(entries, anchor) {
+	if (!entries || entries.length === 0) return;
+	const normalized = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (typeof entry !== "string") continue;
+		const trimmed = entry.trim();
+		if (trimmed.length === 0) continue;
+		if (!isTailwindV4CssEntry(trimmed)) continue;
+		const resolved = node_path.default.isAbsolute(trimmed) ? node_path.default.normalize(trimmed) : node_path.default.normalize(node_path.default.resolve(anchor, trimmed));
+		normalized.add(resolved);
+	}
+	return normalized.size > 0 ? [...normalized] : void 0;
+}
+function isSubPath(parent, child) {
+	if (!parent || !child) return false;
+	const relative = node_path.default.relative(parent, child);
+	return relative === "" || !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+}
+function resolveCssEntryBase(entryDir, options) {
+	const normalizedDir = node_path.default.normalize(entryDir);
+	const { preferredBaseDir, workspaceRoot } = options;
+	if (preferredBaseDir && isSubPath(preferredBaseDir, normalizedDir)) return preferredBaseDir;
+	if (workspaceRoot && isSubPath(workspaceRoot, normalizedDir)) return workspaceRoot;
+	const packageRoot = findNearestPackageRoot(normalizedDir);
+	if (packageRoot) return node_path.default.normalize(packageRoot);
+	return normalizedDir;
+}
+function groupCssEntriesByBase(entries, options = {}) {
+	const normalizedOptions = {
+		preferredBaseDir: options.preferredBaseDir ? node_path.default.normalize(options.preferredBaseDir) : void 0,
+		workspaceRoot: options.workspaceRoot ? node_path.default.normalize(options.workspaceRoot) : void 0
+	};
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const baseDir = resolveCssEntryBase(node_path.default.dirname(entry), normalizedOptions);
+		const bucket = groups.get(baseDir);
+		if (bucket) bucket.push(entry);
+		else groups.set(baseDir, [entry]);
+	}
+	return groups;
+}
+//#endregion
+//#region src/tailwindcss/v4/css-sources.ts
+function hasCssEntriesValue(value) {
+	if (typeof value === "string") return isTailwindV4CssEntry(value);
+	return Array.isArray(value) && value.some(isTailwindV4CssEntry);
+}
+function hasCssSourcesValue(value) {
+	return Array.isArray(value) && value.some((source) => {
+		const file = source?.file;
+		return typeof source === "object" && source !== null && typeof file === "string" && isTailwindV4CssEntry(file) && typeof source.css === "string" && source.css.trim().length > 0;
+	});
+}
+function isTailwindV4CssSourceRoot(source) {
+	return typeof source === "object" && source !== null && typeof source.file === "string" && isTailwindV4CssEntry(source.file);
+}
+function filterTailwindV4CssSourceRoots(sources) {
+	const filtered = sources?.filter(isTailwindV4CssSourceRoot);
+	return filtered && filtered.length > 0 ? filtered : void 0;
+}
+function hasConfiguredTailwindV4CssRoots(options) {
+	return hasCssEntriesValue(options.cssEntries) || hasCssEntriesValue(options.tailwindcss?.v4?.cssEntries) || hasCssEntriesValue(options.tailwindcssRuntimeOptions?.tailwindcss?.v4?.cssEntries) || hasCssSourcesValue(options.tailwindcss?.v4?.cssSources) || hasCssSourcesValue(options.tailwindcssRuntimeOptions?.tailwindcss?.v4?.cssSources);
+}
+function normalizeCssSourceFile(file) {
+	if (!file) return;
+	return node_path.default.isAbsolute(file) ? node_path.default.normalize(file) : file;
+}
+function normalizeCssSourceBase(base) {
+	if (!base) return;
+	return node_path.default.resolve(base);
+}
+function normalizeDependencies(dependencies) {
+	return dependencies?.map(normalizeCssSourceFile).filter((dependency) => typeof dependency === "string" && dependency.length > 0);
+}
+function isSameCssSource(a, b) {
+	return a.css === b.css && normalizeCssSourceBase(a.base) === normalizeCssSourceBase(b.base) && normalizeCssSourceFile(a.file) === normalizeCssSourceFile(b.file) && JSON.stringify(normalizeDependencies(a.dependencies)) === JSON.stringify(normalizeDependencies(b.dependencies));
+}
+function upsertTailwindV4CssSource(opts, source) {
+	if (!isTailwindV4CssEntry(source.file)) return false;
+	const normalizedSource = omitUndefined({
+		...source,
+		...source.base === void 0 ? {} : { base: normalizeCssSourceBase(source.base) },
+		...source.file === void 0 ? {} : { file: normalizeCssSourceFile(source.file) },
+		...source.dependencies === void 0 ? {} : { dependencies: normalizeDependencies(source.dependencies) }
+	});
+	const tailwindcss = opts.tailwindcss ?? {};
+	const v4 = tailwindcss.v4 ?? {};
+	const cssSources = [...v4.cssSources ?? []];
+	const sourceFile = normalizeCssSourceFile(normalizedSource.file);
+	const existingIndex = cssSources.findIndex((candidate) => normalizeCssSourceFile(candidate.file) === sourceFile);
+	if (existingIndex >= 0) {
+		const existing = cssSources[existingIndex];
+		if (!existing) {
+			cssSources[existingIndex] = normalizedSource;
+			return true;
+		}
+		const nextSource = {
+			...existing,
+			...normalizedSource
+		};
+		if (isSameCssSource(existing, nextSource)) return false;
+		cssSources[existingIndex] = nextSource;
+	} else cssSources.push(normalizedSource);
+	opts.tailwindcss = {
+		...tailwindcss,
+		v4: {
+			...v4,
+			cssSources
+		}
+	};
+	return true;
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/source.ts
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function isCssEntryPoint(file) {
+	return typeof file === "string" && node_path.default.basename(file) === "index.css" && (0, node_fs.existsSync)(file);
+}
+function resolvePackageCssEntryPoint(specifier) {
+	try {
+		const resolved = require$1.resolve(specifier);
+		if (isCssEntryPoint(resolved)) return resolved;
+	} catch {}
+	const packageName = specifier.replace(/\/index\.css$/, "");
+	if (packageName !== "tailwindcss") return;
+	try {
+		const packageJson = require$1.resolve(`${packageName}/package.json`);
+		const cssEntry = node_path.default.resolve(node_path.default.dirname(packageJson), "index.css");
+		if (isCssEntryPoint(cssEntry)) return cssEntry;
+	} catch {}
+	try {
+		let current = node_path.default.dirname(require$1.resolve("@tailwindcss-mangle/engine"));
+		while (true) {
+			const cssEntry = node_path.default.resolve(current, "..", "tailwindcss", "index.css");
+			if (isCssEntryPoint(cssEntry)) return cssEntry;
+			const parent = node_path.default.dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	} catch {}
+}
+function isPostcssPluginImportTarget(value) {
+	if (!value) return false;
+	return value === "@tailwindcss/postcss" || value.includes("/postcss");
+}
+function uniqueDefined(values) {
+	return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function getProjectRoot(runtime) {
+	return runtime.options?.projectRoot ?? node_process.default.cwd();
+}
+function resolveBase(value, fallback) {
+	return value === void 0 ? fallback : node_path.default.isAbsolute(value) ? node_path.default.resolve(value) : node_path.default.resolve(fallback, value);
+}
+function resolveConfigDir(config, projectRoot) {
+	if (!config) return;
+	const configPath = node_path.default.isAbsolute(config) ? config : node_path.default.resolve(projectRoot, config);
+	return node_path.default.dirname(configPath);
+}
+function isBarePackageSpecifier(specifier) {
+	return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("#") && !specifier.includes("\\") && !/^[a-z][a-z\d+.-]*:/i.test(specifier);
+}
+function isPackageJsonImportSpecifier(specifier) {
+	return typeof specifier === "string" && specifier.startsWith("#");
+}
+function parseCssImportSpecifier(params) {
+	const value = params.trim();
+	const quoted = /^(['"])(.*?)\1/.exec(value);
+	if (quoted) {
+		const specifier = quoted[2];
+		if (specifier === void 0) return;
+		return {
+			quote: quoted[1],
+			raw: quoted[0],
+			specifier
+		};
+	}
+	const url = /^url\(\s*(?:(['"])(.*?)\1|([^'")\s]+))\s*\)/.exec(value);
+	if (!url) return;
+	const specifier = url[2] ?? url[3];
+	if (specifier === void 0) return;
+	return {
+		quote: url[1],
+		raw: url[0],
+		specifier
+	};
+}
+function quoteCssImportSpecifier(specifier, quote = "\"") {
+	return `${quote}${specifier.replaceAll("\\", "\\\\").replaceAll(quote, `\\${quote}`)}${quote}`;
+}
+function createTailwindV4CssImportSpecifierSet(packageName) {
+	const specifiers = new Set(["tailwindcss"]);
+	if (packageName && isBarePackageSpecifier(packageName)) specifiers.add(packageName);
+	return specifiers;
+}
+function normalizeTailwindV4CssPackageImports(css, packageName) {
+	if (!css.includes("tailwindcss")) return css;
+	let root;
+	try {
+		root = _weapp_tailwindcss_postcss.postcss.parse(css);
+	} catch {
+		return css;
+	}
+	const importSpecifiers = createTailwindV4CssImportSpecifierSet(packageName);
+	let changed = false;
+	root.walkAtRules((rule) => {
+		if (rule.name !== "import" && rule.name !== "reference") return;
+		const parsed = parseCssImportSpecifier(rule.params);
+		if (!parsed || !importSpecifiers.has(parsed.specifier)) return;
+		const cssEntryPoint = resolvePackageCssEntryPoint(`${parsed.specifier}/index.css`);
+		if (!cssEntryPoint) return;
+		rule.params = rule.params.replace(parsed.raw, quoteCssImportSpecifier(cssEntryPoint, parsed.quote));
+		changed = true;
+	});
+	return changed ? root.toString() : css;
+}
+function normalizeTailwindV4CssSources(cssSources, packageName, projectRoot) {
+	if (!cssSources?.length) return cssSources;
+	let changed = false;
+	const normalizedCssSources = cssSources.map((cssSource) => {
+		const file = typeof cssSource.file === "string" && cssSource.file.length > 0 ? node_path.default.isAbsolute(cssSource.file) ? node_path.default.resolve(cssSource.file) : node_path.default.resolve(projectRoot ?? node_process.default.cwd(), cssSource.file) : void 0;
+		const base = typeof cssSource.base === "string" && cssSource.base.length > 0 ? node_path.default.isAbsolute(cssSource.base) ? node_path.default.resolve(cssSource.base) : node_path.default.resolve(projectRoot ?? node_process.default.cwd(), cssSource.base) : file ? node_path.default.dirname(file) : void 0;
+		if (typeof cssSource.css !== "string") {
+			if (file === cssSource.file && base === cssSource.base) return cssSource;
+			changed = true;
+			return {
+				...cssSource,
+				...base === void 0 ? {} : { base },
+				...file === void 0 ? {} : { file }
+			};
+		}
+		const configBase = base ?? projectRoot ?? node_process.default.cwd();
+		const css = normalizeTailwindV4CssPackageImports(normalizeTailwindConfigDirectives(cssSource.css, configBase), packageName);
+		if (css === cssSource.css && file === cssSource.file && base === cssSource.base) return cssSource;
+		changed = true;
+		return {
+			...cssSource,
+			css,
+			...base === void 0 ? {} : { base },
+			...file === void 0 ? {} : { file }
+		};
+	});
+	return changed ? normalizedCssSources : cssSources;
+}
+function normalizeTailwindV4CssEntrySources(cssEntries, packageName) {
+	if (!cssEntries?.length) return;
+	const remainingCssEntries = [];
+	const cssSources = [];
+	for (const cssEntry of cssEntries) {
+		const file = node_path.default.resolve(cssEntry);
+		if (!(0, node_fs.existsSync)(file)) {
+			remainingCssEntries.push(cssEntry);
+			continue;
+		}
+		const base = node_path.default.dirname(file);
+		const rawCss = (0, node_fs.readFileSync)(file, "utf8");
+		const entrySource = resolveCssEntrySource(rawCss, base, { removeConfig: false });
+		const css = normalizeTailwindV4CssPackageImports(normalizeConfigDirective(rawCss, entrySource?.config && (0, node_fs.existsSync)(entrySource.config) ? entrySource.config : entrySource?.configRequest && !node_path.default.isAbsolute(entrySource.configRequest) && !isPackageJsonImportSpecifier(entrySource.configRequest) ? node_path.default.resolve(base, entrySource.configRequest) : entrySource?.config), packageName);
+		cssSources.push({
+			file,
+			base,
+			css,
+			dependencies: [file]
+		});
+	}
+	return {
+		cssEntries: remainingCssEntries,
+		cssSources
+	};
+}
+function normalizeTailwindV4SourceOptions(options) {
+	if (!options) return options;
+	const cssBase = resolveBase(options.base, options.projectRoot ?? options.cwd ?? node_process.default.cwd());
+	const css = options.css === void 0 ? void 0 : normalizeTailwindV4CssPackageImports(normalizeTailwindConfigDirectives(options.css, cssBase), options.packageName);
+	const entrySources = normalizeTailwindV4CssEntrySources(options.cssEntries, options.packageName);
+	const configuredCssSources = filterTailwindV4CssSourceRoots(options.cssSources);
+	const cssSources = normalizeTailwindV4CssSources(configuredCssSources || entrySources?.cssSources ? [...configuredCssSources ?? [], ...entrySources?.cssSources ?? []] : void 0, options.packageName, options.projectRoot);
+	const cssEntries = entrySources?.cssEntries ?? options.cssEntries;
+	if (css === options.css && cssSources === options.cssSources && cssEntries === options.cssEntries) return options;
+	return {
+		...options,
+		css,
+		...cssEntries === void 0 ? {} : { cssEntries },
+		cssSources
+	};
+}
+function resolveTailwindCssImportTarget(runtime) {
+	const configuredPackageName = resolveTailwindcssOptions(runtime.options)?.packageName;
+	if (typeof configuredPackageName === "string" && configuredPackageName.length > 0 && !isPostcssPluginImportTarget(configuredPackageName)) return configuredPackageName;
+	const packageName = runtime.packageInfo?.name;
+	if (typeof packageName === "string" && packageName.length > 0 && !isPostcssPluginImportTarget(packageName)) return packageName;
+	return "tailwindcss";
+}
+function readTailwindV4Options(runtime) {
+	return resolveTailwindcssOptions(runtime.options)?.v4 ?? runtime.options?.tailwind?.v4;
+}
+function isRawTailwindcssPatchOptions(options) {
+	return Boolean(options && "tailwindcss" in options);
+}
+function resolveEngineTailwindV4SourceOptions(runtime) {
+	if (runtime.options) {
+		const projectRoot = getProjectRoot(runtime);
+		const tailwindOptions = resolveTailwindcssOptions(runtime.options);
+		const tailwindV4Options = readTailwindV4Options(runtime);
+		const cwd = resolveBase(tailwindOptions?.cwd, projectRoot);
+		const configuredBase = tailwindV4Options?.configuredBase ?? (isRawTailwindcssPatchOptions(runtime.options) ? tailwindV4Options?.base : void 0);
+		const baseFallbacks = uniqueDefined([
+			configuredBase,
+			cwd,
+			projectRoot,
+			resolveConfigDir(tailwindOptions?.config, projectRoot)
+		]);
+		return {
+			projectRoot,
+			cwd,
+			...configuredBase === void 0 ? {} : { base: configuredBase },
+			baseFallbacks,
+			...tailwindV4Options?.cssSources === void 0 ? {} : { cssSources: tailwindV4Options.cssSources },
+			...tailwindV4Options?.cssEntries === void 0 ? {} : { cssEntries: tailwindV4Options.cssEntries },
+			packageName: resolveTailwindCssImportTarget(runtime)
+		};
+	}
+	return {
+		projectRoot: getProjectRoot(runtime),
+		packageName: resolveTailwindCssImportTarget(runtime)
+	};
+}
+function resolveTailwindV4SourceOptionsFromRuntime(runtime) {
+	const tailwindV4Options = readTailwindV4Options(runtime);
+	return normalizeTailwindV4SourceOptions(omitUndefined({
+		...resolveEngineTailwindV4SourceOptions(runtime),
+		sources: tailwindV4Options?.sources
+	}));
+}
+function resolveTailwindV4Source(options) {
+	return (0, _tailwindcss_mangle_engine.resolveTailwindV4Source)(normalizeTailwindV4SourceOptions(options));
+}
+function resolveTailwindV4SourceFromRuntimeOptions(options) {
+	const projectRoot = options?.projectRoot ?? node_process.default.cwd();
+	const tailwindOptions = options?.tailwindcss;
+	const v4Options = tailwindOptions?.v4;
+	return resolveTailwindV4Source({
+		projectRoot,
+		cwd: resolveBase(tailwindOptions?.cwd, projectRoot),
+		packageName: tailwindOptions?.packageName ?? "tailwindcss",
+		...v4Options ?? {}
+	});
+}
+async function resolveTailwindV4SourceFromRuntime(runtime) {
+	return resolveTailwindV4Source(resolveTailwindV4SourceOptionsFromRuntime(runtime));
+}
+//#endregion
+Object.defineProperty(exports, "FULL_SOURCE_SCAN_EXTENSION_RE", {
+	enumerable: true,
+	get: function() {
+		return FULL_SOURCE_SCAN_EXTENSION_RE;
+	}
+});
+Object.defineProperty(exports, "FULL_SOURCE_SCAN_PATTERN", {
+	enumerable: true,
+	get: function() {
+		return FULL_SOURCE_SCAN_PATTERN;
+	}
+});
+Object.defineProperty(exports, "GENERATOR_PLACEHOLDER_MARKER_RE", {
+	enumerable: true,
+	get: function() {
+		return GENERATOR_PLACEHOLDER_MARKER_RE;
+	}
+});
+Object.defineProperty(exports, "VITE_MARKER_RE", {
+	enumerable: true,
+	get: function() {
+		return VITE_MARKER_RE;
+	}
+});
+Object.defineProperty(exports, "collectCssInlineSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return collectCssInlineSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "createCssAppend", {
+	enumerable: true,
+	get: function() {
+		return createCssAppend;
+	}
+});
+Object.defineProperty(exports, "createTailwindSourceEntryMatcher", {
+	enumerable: true,
+	get: function() {
+		return createTailwindSourceEntryMatcher;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4Engine", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4Engine;
+	}
+});
+Object.defineProperty(exports, "expandTailwindSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return expandTailwindSourceEntries;
+	}
+});
+Object.defineProperty(exports, "filterTailwindV4CssSourceRoots", {
+	enumerable: true,
+	get: function() {
+		return filterTailwindV4CssSourceRoots;
+	}
+});
+Object.defineProperty(exports, "filterUnsupportedMiniProgramTailwindV4Candidates", {
+	enumerable: true,
+	get: function() {
+		return filterUnsupportedMiniProgramTailwindV4Candidates;
+	}
+});
+Object.defineProperty(exports, "findNearestPackageRoot", {
+	enumerable: true,
+	get: function() {
+		return findNearestPackageRoot;
+	}
+});
+Object.defineProperty(exports, "findWorkspacePackageDir", {
+	enumerable: true,
+	get: function() {
+		return findWorkspacePackageDir;
+	}
+});
+Object.defineProperty(exports, "findWorkspaceRoot", {
+	enumerable: true,
+	get: function() {
+		return findWorkspaceRoot;
+	}
+});
+Object.defineProperty(exports, "getTailwindV4IncrementalGenerateCacheStats", {
+	enumerable: true,
+	get: function() {
+		return getTailwindV4IncrementalGenerateCacheStats;
+	}
+});
+Object.defineProperty(exports, "groupCssEntriesByBase", {
+	enumerable: true,
+	get: function() {
+		return groupCssEntriesByBase;
+	}
+});
+Object.defineProperty(exports, "guessBasedirFromEntries", {
+	enumerable: true,
+	get: function() {
+		return guessBasedirFromEntries;
+	}
+});
+Object.defineProperty(exports, "hasConfiguredTailwindV4CssRoots", {
+	enumerable: true,
+	get: function() {
+		return hasConfiguredTailwindV4CssRoots;
+	}
+});
+Object.defineProperty(exports, "hasLocalCssImport", {
+	enumerable: true,
+	get: function() {
+		return hasLocalCssImport;
+	}
+});
+Object.defineProperty(exports, "hasTailwindApplyDirective", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindApplyDirective;
+	}
+});
+Object.defineProperty(exports, "hasTailwindGeneratedCss", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindGeneratedCss;
+	}
+});
+Object.defineProperty(exports, "hasTailwindGeneratedCssMarkers", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindGeneratedCssMarkers;
+	}
+});
+Object.defineProperty(exports, "hasTailwindNonRootGenerationDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindNonRootGenerationDirectives;
+	}
+});
+Object.defineProperty(exports, "hasTailwindRootDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindRootDirectives;
+	}
+});
+Object.defineProperty(exports, "hasTailwindRootImportDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindRootImportDirectives;
+	}
+});
+Object.defineProperty(exports, "hasTailwindSourceDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindSourceDirectives;
+	}
+});
+Object.defineProperty(exports, "inferGeneratorTargetFromEnv", {
+	enumerable: true,
+	get: function() {
+		return inferGeneratorTargetFromEnv;
+	}
+});
+Object.defineProperty(exports, "isFileMatchedByTailwindSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return isFileMatchedByTailwindSourceEntries;
+	}
+});
+Object.defineProperty(exports, "isTailwindV4CssEntry", {
+	enumerable: true,
+	get: function() {
+		return isTailwindV4CssEntry;
+	}
+});
+Object.defineProperty(exports, "normalizeConfigDirective", {
+	enumerable: true,
+	get: function() {
+		return normalizeConfigDirective;
+	}
+});
+Object.defineProperty(exports, "normalizeCssEntries", {
+	enumerable: true,
+	get: function() {
+		return normalizeCssEntries;
+	}
+});
+Object.defineProperty(exports, "normalizeExtendLengthUnits", {
+	enumerable: true,
+	get: function() {
+		return normalizeExtendLengthUnits;
+	}
+});
+Object.defineProperty(exports, "normalizeLegacyContentEntries", {
+	enumerable: true,
+	get: function() {
+		return normalizeLegacyContentEntries;
+	}
+});
+Object.defineProperty(exports, "normalizeStringListOption", {
+	enumerable: true,
+	get: function() {
+		return normalizeStringListOption;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindConfigDirectives", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindConfigDirectives;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindSourceDirectives", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindSourceDirectives;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindSourceForGenerator", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindSourceForGenerator;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindcssRuntimeOptions", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindcssRuntimeOptions;
+	}
+});
+Object.defineProperty(exports, "omitUndefined", {
+	enumerable: true,
+	get: function() {
+		return omitUndefined;
+	}
+});
+Object.defineProperty(exports, "parseConfigParam", {
+	enumerable: true,
+	get: function() {
+		return parseConfigParam;
+	}
+});
+Object.defineProperty(exports, "parseImportRequest", {
+	enumerable: true,
+	get: function() {
+		return parseImportRequest;
+	}
+});
+Object.defineProperty(exports, "prependConfigDirective", {
+	enumerable: true,
+	get: function() {
+		return prependConfigDirective;
+	}
+});
+Object.defineProperty(exports, "removeTailwindSourceDirectives", {
+	enumerable: true,
+	get: function() {
+		return removeTailwindSourceDirectives;
+	}
+});
+Object.defineProperty(exports, "resolveBooleanObjectOption", {
+	enumerable: true,
+	get: function() {
+		return resolveBooleanObjectOption;
+	}
+});
+Object.defineProperty(exports, "resolveCssEntrySource", {
+	enumerable: true,
+	get: function() {
+		return resolveCssEntrySource;
+	}
+});
+Object.defineProperty(exports, "resolveCssSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return resolveCssSourceEntries;
+	}
+});
+Object.defineProperty(exports, "resolveSourceScanPath", {
+	enumerable: true,
+	get: function() {
+		return resolveSourceScanPath;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4CssSourceBase", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4CssSourceBase;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4Source", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4Source;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4SourceFromRuntime", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4SourceFromRuntime;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4SourceFromRuntimeOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4SourceFromRuntimeOptions;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4SourceOptionsFromRuntime", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4SourceOptionsFromRuntime;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindcssOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindcssOptions;
+	}
+});
+Object.defineProperty(exports, "splitGeneratorPlaceholderCssBySourceOrder", {
+	enumerable: true,
+	get: function() {
+		return splitGeneratorPlaceholderCssBySourceOrder;
+	}
+});
+Object.defineProperty(exports, "splitTailwindGeneratedCssByBanner", {
+	enumerable: true,
+	get: function() {
+		return splitTailwindGeneratedCssByBanner;
+	}
+});
+Object.defineProperty(exports, "splitTailwindV4GeneratedCssBySourceOrder", {
+	enumerable: true,
+	get: function() {
+		return splitTailwindV4GeneratedCssBySourceOrder;
+	}
+});
+Object.defineProperty(exports, "stripGeneratorPlaceholderMarkers", {
+	enumerable: true,
+	get: function() {
+		return stripGeneratorPlaceholderMarkers;
+	}
+});
+Object.defineProperty(exports, "stripTailwindBanner", {
+	enumerable: true,
+	get: function() {
+		return stripTailwindBanner;
+	}
+});
+Object.defineProperty(exports, "stripTailwindBanners", {
+	enumerable: true,
+	get: function() {
+		return stripTailwindBanners;
+	}
+});
+Object.defineProperty(exports, "toPosixPath", {
+	enumerable: true,
+	get: function() {
+		return toPosixPath;
+	}
+});
+Object.defineProperty(exports, "transformTailwindV4CssByTarget", {
+	enumerable: true,
+	get: function() {
+		return transformTailwindV4CssByTarget;
+	}
+});
+Object.defineProperty(exports, "transformTailwindV4CssToWeapp", {
+	enumerable: true,
+	get: function() {
+		return transformTailwindV4CssToWeapp;
+	}
+});
+Object.defineProperty(exports, "upsertTailwindV4CssSource", {
+	enumerable: true,
+	get: function() {
+		return upsertTailwindV4CssSource;
+	}
+});