weapp-tailwindcss 5.0.13 → 5.1.0

package/dist/v4-engine-CF9zt4Cw.mjs

@@ -0,0 +1,2396 @@
+import { a as withCssMacroStyleOptions, i as transformCssMacroCss, n as hasCssMacroTailwindV4Directive, t as hasCssMacroStyleOptions } from "./auto-Ba6hDrse.mjs";
+import { createRequire } from "node:module";
+import fs, { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { createTailwindV4Engine, extractRawCandidates, loadTailwindV4DesignSystem, resolveProjectSourceFiles, resolveTailwindV4Source } from "@tailwindcss-mangle/engine";
+import { createStyleHandler, normalizeTailwindcssWebRpxDeclarations, postcss, protectDynamicColorMixAlpha, pruneMiniProgramGeneratedCss } from "@weapp-tailwindcss/postcss";
+import { LRUCache } from "lru-cache";
+import { stat } from "node:fs/promises";
+import micromatch from "micromatch";
+//#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 process === "undefined" ? void 0 : process.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 = 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 = 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(path.sep).join("/");
+}
+function resolveSourceScanPath(value) {
+	const resolved = path.resolve(value);
+	try {
+		return realpathSync.native(resolved);
+	} catch {
+		return resolved;
+	}
+}
+function normalizeEntryPattern(entry) {
+	return path.isAbsolute(entry.pattern) ? toPosixPath(path.relative(resolveSourceScanPath(entry.base), entry.pattern)) : entry.pattern;
+}
+function isFileMatchedByTailwindSourceEntry(file, entry) {
+	const relative = toPosixPath(path.relative(resolveSourceScanPath(entry.base), file));
+	return relative && !relative.startsWith("../") && !path.isAbsolute(relative) && micromatch.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 path.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 stat(file)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindSourceEntry(sourcePath, base, negated, defaultPattern = createSourceScanPattern()) {
+	const absoluteSource = path.isAbsolute(sourcePath) ? path.resolve(sourcePath) : path.resolve(base, sourcePath);
+	if (await pathExistsAsDirectory(absoluteSource)) return {
+		base: absoluteSource,
+		negated,
+		pattern: normalizeGlobPattern(defaultPattern)
+	};
+	if (path.isAbsolute(sourcePath) && hasGlobMagic(sourcePath)) {
+		const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+		const root = path.parse(sourcePath).root;
+		const normalizedPrefix = prefix[0] === "" ? prefix.slice(1) : prefix;
+		if (rest.length > 0) return {
+			base: path.resolve(root, ...normalizedPrefix),
+			negated,
+			pattern: normalizeGlobPattern(rest.join("/"))
+		};
+	}
+	if (path.isAbsolute(sourcePath)) return {
+		base: path.dirname(absoluteSource),
+		negated,
+		pattern: normalizeGlobPattern(path.basename(absoluteSource))
+	};
+	const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+	if (prefix.length > 0 && rest.length > 0) return {
+		base: path.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 = path.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 resolveProjectSourceFiles({
+			cwd: base,
+			sources: group,
+			...ignoredSources === void 0 ? {} : { ignoredSources }
+		});
+		for (const file of matched) files.add(path.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 path.isAbsolute(sourcePath) ? sourcePath : path.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 = 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 = 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 = protectDynamicColorMixAlpha(normalizeTailwindV4GeneratedUrlValues(hasCssMacroStyleOptions(options) ? await 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: hasCssMacroStyleOptions(options)
+	};
+	return pruneMiniProgramGeneratedCss(protectedCss.restore(result.css), pruneOptions);
+}
+function transformTailwindV4WebRpxCss(css) {
+	if (!css.includes("rpx")) return css;
+	try {
+		const root = postcss.parse(css);
+		return 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 (hasCssMacroStyleOptions(options) ? 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 LRUCache({ max: INCREMENTAL_GENERATE_CACHE_MAX });
+const incrementalGenerateTaskCache = new 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 = fs.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 = 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 hasCssMacroTailwindV4Directive(source.css) ? withCssMacroStyleOptions(options) : options;
+}
+function collectCustomPropertyValues(css) {
+	const values = /* @__PURE__ */ new Map();
+	try {
+		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$1(source) {
+	async function generateOnce(generateSource, options = {}) {
+		const { scanSources = true, styleOptions, target = "weapp", ...patchOptions } = options;
+		const resolvedStyleOptions = resolveStyleOptions(generateSource, styleOptions);
+		const 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 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: createTailwindV4Engine(source).loadDesignSystem,
+		validateCandidates: 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 {
+		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 (path.isAbsolute(configPath) || isPackageJsonImportRequest(configPath)) return path.isAbsolute(configPath) ? configPath : void 0;
+	return path.resolve(base, configPath);
+}
+function normalizeTailwindConfigDirectives(rawSource, base) {
+	return rawSource.replace(/@config\s+(["'])(.+?)\1\s*;?/g, (full, quote, request) => {
+		if (path.isAbsolute(request) || isPackageJsonImportRequest(request)) return full;
+		return `@config ${quote}${path.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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findNearestPackageRoot(startDir) {
+	if (!startDir) return;
+	let current = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "package.json"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findWorkspacePackageDir(rootDir, packageName) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [path.resolve(rootDir)];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const normalized = path.normalize(current);
+		if (visited.has(normalized)) continue;
+		visited.add(normalized);
+		try {
+			const pkgPath = path.join(normalized, "package.json");
+			if (existsSync(pkgPath)) {
+				if (JSON.parse(readFileSync(pkgPath, "utf8"))?.name === packageName) return normalized;
+			}
+		} catch {}
+		let entries;
+		try {
+			entries = 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(path.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 || !path.isAbsolute(trimmed)) continue;
+		if (!isTailwindV4CssEntry(trimmed)) continue;
+		const entryDir = path.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 = path.isAbsolute(trimmed) ? path.normalize(trimmed) : path.normalize(path.resolve(anchor, trimmed));
+		normalized.add(resolved);
+	}
+	return normalized.size > 0 ? [...normalized] : void 0;
+}
+function isSubPath(parent, child) {
+	if (!parent || !child) return false;
+	const relative = path.relative(parent, child);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function resolveCssEntryBase(entryDir, options) {
+	const normalizedDir = path.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 path.normalize(packageRoot);
+	return normalizedDir;
+}
+function groupCssEntriesByBase(entries, options = {}) {
+	const normalizedOptions = {
+		preferredBaseDir: options.preferredBaseDir ? path.normalize(options.preferredBaseDir) : void 0,
+		workspaceRoot: options.workspaceRoot ? path.normalize(options.workspaceRoot) : void 0
+	};
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const baseDir = resolveCssEntryBase(path.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 path.isAbsolute(file) ? path.normalize(file) : file;
+}
+function normalizeCssSourceBase(base) {
+	if (!base) return;
+	return path.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 = createRequire(import.meta.url);
+function isCssEntryPoint(file) {
+	return typeof file === "string" && path.basename(file) === "index.css" && existsSync(file);
+}
+function resolvePackageCssEntryPoint(specifier) {
+	try {
+		const resolved = require.resolve(specifier);
+		if (isCssEntryPoint(resolved)) return resolved;
+	} catch {}
+	const packageName = specifier.replace(/\/index\.css$/, "");
+	if (packageName !== "tailwindcss") return;
+	try {
+		const packageJson = require.resolve(`${packageName}/package.json`);
+		const cssEntry = path.resolve(path.dirname(packageJson), "index.css");
+		if (isCssEntryPoint(cssEntry)) return cssEntry;
+	} catch {}
+	try {
+		let current = path.dirname(require.resolve("@tailwindcss-mangle/engine"));
+		while (true) {
+			const cssEntry = path.resolve(current, "..", "tailwindcss", "index.css");
+			if (isCssEntryPoint(cssEntry)) return cssEntry;
+			const parent = path.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 ?? process.cwd();
+}
+function resolveBase(value, fallback) {
+	return value === void 0 ? fallback : path.isAbsolute(value) ? path.resolve(value) : path.resolve(fallback, value);
+}
+function resolveConfigDir(config, projectRoot) {
+	if (!config) return;
+	const configPath = path.isAbsolute(config) ? config : path.resolve(projectRoot, config);
+	return path.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 = 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 ? path.isAbsolute(cssSource.file) ? path.resolve(cssSource.file) : path.resolve(projectRoot ?? process.cwd(), cssSource.file) : void 0;
+		const base = typeof cssSource.base === "string" && cssSource.base.length > 0 ? path.isAbsolute(cssSource.base) ? path.resolve(cssSource.base) : path.resolve(projectRoot ?? process.cwd(), cssSource.base) : file ? path.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 ?? process.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 = path.resolve(cssEntry);
+		if (!existsSync(file)) {
+			remainingCssEntries.push(cssEntry);
+			continue;
+		}
+		const base = path.dirname(file);
+		const rawCss = readFileSync(file, "utf8");
+		const entrySource = resolveCssEntrySource(rawCss, base, { removeConfig: false });
+		const css = normalizeTailwindV4CssPackageImports(normalizeConfigDirective(rawCss, entrySource?.config && existsSync(entrySource.config) ? entrySource.config : entrySource?.configRequest && !path.isAbsolute(entrySource.configRequest) && !isPackageJsonImportSpecifier(entrySource.configRequest) ? path.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 ?? process.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$1(options) {
+	return resolveTailwindV4Source(normalizeTailwindV4SourceOptions(options));
+}
+function resolveTailwindV4SourceFromRuntimeOptions(options) {
+	const projectRoot = options?.projectRoot ?? process.cwd();
+	const tailwindOptions = options?.tailwindcss;
+	const v4Options = tailwindOptions?.v4;
+	return resolveTailwindV4Source$1({
+		projectRoot,
+		cwd: resolveBase(tailwindOptions?.cwd, projectRoot),
+		packageName: tailwindOptions?.packageName ?? "tailwindcss",
+		...v4Options ?? {}
+	});
+}
+async function resolveTailwindV4SourceFromRuntime(runtime) {
+	return resolveTailwindV4Source$1(resolveTailwindV4SourceOptionsFromRuntime(runtime));
+}
+//#endregion
+export { isFileMatchedByTailwindSourceEntries as $, removeTailwindSourceDirectives as A, stripGeneratorPlaceholderMarkers as B, hasTailwindRootDirectives as C, normalizeTailwindSourceDirectives as D, normalizeTailwindConfigDirectives as E, hasTailwindGeneratedCss as F, createTailwindV4Engine$1 as G, stripTailwindBanners as H, hasTailwindGeneratedCssMarkers as I, transformTailwindV4CssToWeapp as J, getTailwindV4IncrementalGenerateCacheStats as K, splitGeneratorPlaceholderCssBySourceOrder as L, GENERATOR_PLACEHOLDER_MARKER_RE as M, VITE_MARKER_RE as N, normalizeTailwindSourceForGenerator as O, createCssAppend as P, expandTailwindSourceEntries as Q, splitTailwindGeneratedCssByBanner as R, hasTailwindNonRootGenerationDirectives as S, hasTailwindSourceDirectives as T, normalizeConfigDirective as U, stripTailwindBanner as V, prependConfigDirective as W, FULL_SOURCE_SCAN_PATTERN as X, FULL_SOURCE_SCAN_EXTENSION_RE as Y, createTailwindSourceEntryMatcher as Z, resolveTailwindcssOptions as _, filterTailwindV4CssSourceRoots as a, toPosixPath as at, hasLocalCssImport as b, groupCssEntriesByBase as c, omitUndefined as ct, normalizeCssEntries as d, normalizeLegacyContentEntries as et, findNearestPackageRoot as f, normalizeTailwindcssRuntimeOptions as g, normalizeExtendLengthUnits as h, resolveTailwindV4SourceOptionsFromRuntime as i, resolveTailwindV4CssSourceBase as it, resolveCssEntrySource as j, parseImportRequest as k, guessBasedirFromEntries as l, inferGeneratorTargetFromEnv as lt, findWorkspaceRoot as m, resolveTailwindV4SourceFromRuntime as n, resolveCssSourceEntries as nt, hasConfiguredTailwindV4CssRoots as o, collectCssInlineSourceCandidates as ot, findWorkspacePackageDir as p, transformTailwindV4CssByTarget as q, resolveTailwindV4SourceFromRuntimeOptions as r, resolveSourceScanPath as rt, upsertTailwindV4CssSource as s, filterUnsupportedMiniProgramTailwindV4Candidates as st, resolveTailwindV4Source$1 as t, parseConfigParam as tt, isTailwindV4CssEntry as u, loadTailwindV4DesignSystem as ut, normalizeStringListOption as v, hasTailwindRootImportDirectives as w, hasTailwindApplyDirective as x, resolveBooleanObjectOption as y, splitTailwindV4GeneratedCssBySourceOrder as z };