weapp-tailwindcss 5.5.6 → 5.5.8

package/dist/generator-CxauQbx3.cjs

@@ -0,0 +1,1868 @@
+const require_rolldown_runtime = require("./rolldown-runtime-fg3euq-1.cjs");
+const require_framework = require("./framework.cjs");
+require("./auto-B1OyRrE8.cjs");
+require("./utils-CuKLf1Zv.cjs");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_process = require("node:process");
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
+let _weapp_tailwindcss_engine = require("@weapp-tailwindcss/engine");
+let _weapp_tailwindcss_postcss_transform = require("@weapp-tailwindcss/postcss/transform");
+let lru_cache = require("lru-cache");
+let node_module = require("node:module");
+let _weapp_tailwindcss_source_scan = require("@weapp-tailwindcss/source-scan");
+//#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 shouldUseUniAppWebRpxCompatibility(appType) {
+	return appType === "uni-app-vite" || appType === "uni-app-x" || shouldUseWebGeneratorTargetFromEnv();
+}
+function shouldUseUniAppViteWebViewGeneratorTarget(appType, platform = getEnvValue("UNI_PLATFORM")) {
+	return appType === "uni-app-vite" && isUniAppWebViewPlatform(platform);
+}
+function inferGeneratorTargetFromEnv() {
+	return inferGeneratorTargetFromExplicitEnv() ?? (shouldUseWebGeneratorTargetFromEnv() ? "web" : "weapp");
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/candidates.ts
+const UNSUPPORTED_MINI_PROGRAM_TAILWIND_V4_CANDIDATE_RE = /(?:^|:)(?:has-)?(?:group|peer|in|not-in)-[^\s:]*\/|(?:^|:)(?:has-)?(?: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)));
+}
+const INCREMENTAL_GENERATE_ENTRY_CANDIDATES_MAX = 12e3;
+const INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX = 2097152;
+const incrementalGenerateCache = new lru_cache.LRUCache({ max: 8 });
+const incrementalGenerateTaskCache = new lru_cache.LRUCache({ max: 32 });
+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 createTailwindV4SourceCacheKey(source) {
+	return [
+		source.projectRoot,
+		source.base,
+		createStableJson(source.baseFallbacks),
+		source.css,
+		createDependencyFingerprint(source.dependencies)
+	].join("\0");
+}
+function createIncrementalGenerateCacheKey(source, target, styleOptions) {
+	return [
+		createTailwindV4SourceCacheKey(source),
+		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, _weapp_tailwindcss_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) {
+	return new Set(generated.classSet);
+}
+function createIncrementalStyleOptions(styleOptions) {
+	return {
+		...styleOptions,
+		isMainChunk: false
+	};
+}
+function resolveStyleOptions(source, options) {
+	return (0, _weapp_tailwindcss_postcss_transform.hasCssMacroTailwindV4Source)(source.css) ? (0, _weapp_tailwindcss_postcss_transform.withCssMacroStyleOptions)(options) : options;
+}
+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 > 12e3 || cached.css.length > 2097152 || cached.rawCss.length > 2097152 || requestedCandidates.size > 12e3;
+}
+function shouldAdmitIncrementalEntry(requestedCandidates, generated) {
+	return requestedCandidates.size <= 12e3 && generated.css.length <= 2097152 && generated.rawCss.length <= 2097152;
+}
+function seedIncrementalGenerateCache(options) {
+	if (!shouldAdmitIncrementalEntry(options.requestedCandidates, options.generated)) return false;
+	const cacheKey = createIncrementalGenerateCacheKey(options.compatibleSource, options.target, options.styleOptions);
+	const customPropertyValues = (0, _weapp_tailwindcss_postcss_transform.collectCustomPropertyValues)(options.compatibleSource.css);
+	(0, _weapp_tailwindcss_postcss_transform.mergeCustomPropertyValues)(customPropertyValues, options.generated.css);
+	incrementalGenerateCache.set(cacheKey, {
+		seenCandidates: collectSeenCandidates(options.generated),
+		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 shouldUseUniAppWebRpxCompatibility(styleOptions?.appType);
+}
+function normalizeTargetRpxLengthCandidates(candidates, target, styleOptions) {
+	return shouldNormalizeRpxLengthCandidatesForTarget(target, styleOptions) ? (0, _weapp_tailwindcss_postcss_transform.normalizeRpxLengthCandidates)(candidates) : {
+		candidates: new Set(candidates),
+		restoreCandidates: /* @__PURE__ */ new Map()
+	};
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/cache-stats.ts
+function getTailwindV4IncrementalGenerateCacheStats() {
+	return {
+		max: 8,
+		entryCandidatesMax: INCREMENTAL_GENERATE_ENTRY_CANDIDATES_MAX,
+		entryCssBytesMax: INCREMENTAL_GENERATE_ENTRY_CSS_BYTES_MAX,
+		size: incrementalGenerateCache.size,
+		taskMax: 32,
+		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/tailwindcss/v4-engine/css-macro-source.ts
+function resolveCssMacroTailwindV4Source(source) {
+	const css = (0, _weapp_tailwindcss_postcss_transform.transformCssMacroTailwindV4Source)(source.css);
+	return css === source.css ? source : {
+		...source,
+		css
+	};
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/miniprogram.ts
+function transformTailwindV4CssByTarget(css, target, options) {
+	return (0, _weapp_tailwindcss_postcss_transform.transformTailwindV4GeneratedCss)(css, target, options, shouldUseUniAppWebRpxCompatibility(options?.appType));
+}
+//#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
+const require$2 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const tailwindThemeCssCache = /* @__PURE__ */ new Map();
+function readCachedCss(file) {
+	const cached = tailwindThemeCssCache.get(file);
+	if (cached !== void 0) return cached;
+	const css = (0, node_fs.readFileSync)(file, "utf8");
+	tailwindThemeCssCache.set(file, css);
+	return css;
+}
+function resolveTailwindV4ThemeCssFromImport(css) {
+	const root = _weapp_tailwindcss_postcss_transform.postcss.parse(css);
+	let resolved;
+	root.walkAtRules("import", (rule) => {
+		if (resolved) return;
+		const specifier = (0, _weapp_tailwindcss_postcss_transform.parseCssImportSpecifier)(rule.params)?.specifier;
+		if (!specifier || !node_path.default.isAbsolute(specifier) || node_path.default.basename(specifier) !== "index.css") return;
+		const themeCss = node_path.default.join(node_path.default.dirname(specifier), "theme.css");
+		if ((0, node_fs.existsSync)(themeCss)) resolved = themeCss;
+	});
+	return resolved;
+}
+function resolveTailwindV4ThemeCssFromBase(base) {
+	try {
+		return (0, node_module.createRequire)(node_path.default.join(base, "package.json")).resolve("tailwindcss/theme.css");
+	} catch {
+		try {
+			return require$2.resolve("tailwindcss/theme.css");
+		} catch {
+			return;
+		}
+	}
+}
+function resolveTailwindV4DefaultThemeCss(source) {
+	try {
+		const themeCss = resolveTailwindV4ThemeCssFromImport(source.css) ?? resolveTailwindV4ThemeCssFromBase(source.base);
+		return themeCss ? readCachedCss(themeCss) : createTailwindV4DefaultColorThemeCss();
+	} catch {
+		return createTailwindV4DefaultColorThemeCss();
+	}
+}
+function applyMiniProgramTailwindV4DefaultColorCss(css, source) {
+	const themeCss = resolveTailwindV4DefaultThemeCss(source);
+	return (0, _weapp_tailwindcss_postcss_transform.insertTailwindThemeCss)(css, themeCss);
+}
+function createCompatibleSource(source, target) {
+	const filteredSourceCss = target === "weapp" ? (0, _weapp_tailwindcss_postcss_transform.removeTailwindV4PreflightImports)(source.css) : source.css;
+	const sourceCss = target === "weapp" ? applyMiniProgramTailwindV4DefaultColorCss(filteredSourceCss, source) : filteredSourceCss;
+	const compatibleSourceCss = (0, _weapp_tailwindcss_postcss_transform.removeUnsupportedThemeVendorKeyframes)(sourceCss);
+	return compatibleSourceCss === source.css ? source : {
+		...source,
+		css: compatibleSourceCss
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/native-session.ts
+var TailwindV4NativeSessionPool = class {
+	constructor(createSession = _weapp_tailwindcss_engine.createTailwindGenerationSession) {
+		this.createSession = createSession;
+		_defineProperty(this, "sessions", /* @__PURE__ */ new Map());
+		_defineProperty(this, "disposed", false);
+	}
+	generate(target, sourceKey, source, request) {
+		const entry = this.getSession(target, sourceKey, source);
+		const generated = entry.pending.then(() => entry.session.generate(request));
+		entry.pending = generated.then(() => void 0, () => void 0);
+		return generated;
+	}
+	dispose() {
+		for (const entry of this.sessions.values()) this.disposeEntry(entry);
+		this.sessions.clear();
+		this.disposed = true;
+	}
+	get size() {
+		return this.sessions.size;
+	}
+	getSession(target, sourceKey, source) {
+		if (this.disposed) throw new Error("TailwindV4NativeSessionPool 已释放。");
+		const cached = this.sessions.get(target);
+		if (cached?.sourceKey === sourceKey) return cached;
+		if (cached) this.disposeEntry(cached);
+		const session = this.createSession(source);
+		const entry = {
+			pending: Promise.resolve(),
+			session,
+			sourceKey
+		};
+		this.sessions.set(target, entry);
+		return entry;
+	}
+	disposeEntry(entry) {
+		entry.pending.then(() => entry.session.dispose());
+	}
+};
+function createEngineSourceEntries(sources, sourceId) {
+	return sources.map((source, index) => ({
+		id: `${sourceId}:candidate-source:${index}`,
+		...source
+	}));
+}
+function serializeTailwindGenerationArtifact(artifact) {
+	return [...artifact.fragments].sort((left, right) => left.order - right.order).map((fragment) => fragment.root.toString()).join("\n");
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/scan-sources.ts
+async function resolveScanSources(source, scanSources) {
+	if (scanSources !== true) return scanSources;
+	const definitions = [];
+	const append = (css, base, from) => {
+		try {
+			definitions.push({
+				root: _weapp_tailwindcss_postcss_transform.postcss.parse(css, { from }),
+				base
+			});
+		} catch {}
+	};
+	append(source.css, source.base, source.dependencies[0]);
+	for (const file of source.dependencies.slice(1)) try {
+		append((0, node_fs.readFileSync)(file, "utf8"), node_path.default.dirname(file), file);
+	} catch {}
+	const scan = await (0, _weapp_tailwindcss_postcss_transform.resolveCssScanSources)(definitions, {
+		base: source.base,
+		defaultBase: source.projectRoot ?? source.cwd ?? source.base,
+		automatic: "fallback",
+		requireImport: true,
+		pattern: "**/*",
+		configResolution: "module",
+		ignoredPatterns: _weapp_tailwindcss_source_scan.LEGACY_SOURCE_IGNORED_PATTERNS
+	});
+	return scan.entries.some((entry) => !entry.negated) || scan.explicitEntries.length + scan.configEntries.length > 0 ? scan.entries : false;
+}
+function resolveCompiledSourceRoot(source) {
+	try {
+		const descriptor = (0, _weapp_tailwindcss_postcss_transform.describeCssSources)(_weapp_tailwindcss_postcss_transform.postcss.parse(source.css));
+		for (const item of descriptor.imports) {
+			if (item.none) return "none";
+			if (item.sourcePath) return {
+				base: source.base,
+				pattern: item.sourcePath
+			};
+		}
+	} catch {}
+	return null;
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/style-context.ts
+function resolveGenerationStyleContext(sourceCss, generatedCss, options) {
+	const calc = options?.cssOptions?.cssCalc ?? options?.cssCalc;
+	const include = Array.isArray(calc) ? calc : calc && typeof calc === "object" ? calc.includeCustomProperties : void 0;
+	if (calc !== true && !include?.length) return options;
+	const customPropertyValues = (0, _weapp_tailwindcss_postcss_transform.collectCustomPropertyValues)(sourceCss);
+	(0, _weapp_tailwindcss_postcss_transform.mergeCustomPropertyValues)(customPropertyValues, generatedCss);
+	for (const [name, value] of options?.customPropertyValues ?? []) customPropertyValues.set(name, value);
+	return {
+		...options,
+		customPropertyValues
+	};
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator/engine.ts
+function isCssSyntaxError(error) {
+	return error instanceof Error && error.name === "CssSyntaxError";
+}
+function createTailwindV4Engine(source) {
+	const generationSessions = new TailwindV4NativeSessionPool();
+	const incrementalCacheKeys = /* @__PURE__ */ new Set();
+	const validationEngine = (0, _weapp_tailwindcss_engine.createTailwindV4Engine)(source);
+	async function generateOnce(generateSource, options = {}) {
+		const { scanSources = true, styleOptions, target = "weapp", ...patchOptions } = options;
+		const resolvedStyleOptions = resolveStyleOptions(generateSource, styleOptions);
+		const compatibleSource = createCompatibleSource(resolveCssMacroTailwindV4Source(generateSource), target);
+		const compiledScan = options.scanMode === "compiled";
+		const resolvedScanSources = compiledScan ? void 0 : await resolveScanSources(generateSource, scanSources);
+		const filesystemCandidates = Array.isArray(resolvedScanSources) ? new Set(await (0, _weapp_tailwindcss_engine.extractRawCandidates)(resolvedScanSources, { ...patchOptions.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: patchOptions.bareArbitraryValues } })) : void 0;
+		const resolvedCandidates = resolveTargetCandidates(/* @__PURE__ */ new Set([...collectCandidates(patchOptions.candidates), ...filesystemCandidates ?? []]), target);
+		let normalizedCandidates = normalizeTargetRpxLengthCandidates(resolvedCandidates, target, resolvedStyleOptions);
+		const sourceId = compatibleSource.dependencies[0] ?? compatibleSource.base;
+		const generationRequest = {
+			...compiledScan ? {
+				scanSources,
+				excludeFiles: options.excludeFiles ?? [],
+				prepareCandidates: (candidates) => {
+					normalizedCandidates = normalizeTargetRpxLengthCandidates(resolveTargetCandidates(candidates, target), target, resolvedStyleOptions);
+					return normalizedCandidates.candidates;
+				}
+			} : {},
+			...patchOptions.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: patchOptions.bareArbitraryValues },
+			...patchOptions.sources === void 0 ? {} : { sourceEntries: createEngineSourceEntries(patchOptions.sources, sourceId) },
+			candidates: compiledScan ? resolvedCandidates : normalizedCandidates.candidates
+		};
+		let generatedCss;
+		let classSet;
+		let rawCandidates;
+		let dependencies;
+		try {
+			const artifact = await generationSessions.generate(target, createTailwindV4SourceCacheKey(compatibleSource), compatibleSource, generationRequest);
+			generatedCss = serializeTailwindGenerationArtifact(artifact);
+			classSet = artifact.classSet;
+			rawCandidates = artifact.rawCandidates;
+			dependencies = artifact.dependencies;
+		} catch (error) {
+			if (compiledScan || !isCssSyntaxError(error)) throw error;
+			const legacyEngine = (0, _weapp_tailwindcss_engine.createTailwindV4Engine)(compatibleSource);
+			try {
+				const legacyResult = await legacyEngine.generate({
+					...patchOptions.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: patchOptions.bareArbitraryValues },
+					...patchOptions.sources === void 0 ? {} : { sources: patchOptions.sources },
+					candidates: normalizedCandidates.candidates,
+					scanSources: false
+				});
+				generatedCss = legacyResult.css;
+				classSet = legacyResult.classSet;
+				rawCandidates = legacyResult.rawCandidates;
+				dependencies = legacyResult.dependencies;
+			} finally {
+				legacyEngine.dispose?.();
+			}
+		}
+		const sources = Array.isArray(resolvedScanSources) ? resolvedScanSources : [];
+		const rawCss = (0, _weapp_tailwindcss_postcss_transform.restoreRpxLengthCssSelectors)(generatedCss, normalizedCandidates.restoreCandidates);
+		const css = await transformTailwindV4CssByTarget(rawCss, target, resolveGenerationStyleContext(compatibleSource.css, rawCss, resolvedStyleOptions));
+		return {
+			classSet: (0, _weapp_tailwindcss_postcss_transform.restoreRpxLengthCandidates)(classSet, normalizedCandidates.restoreCandidates),
+			rawCandidates: (0, _weapp_tailwindcss_postcss_transform.restoreRpxLengthCandidates)(rawCandidates, normalizedCandidates.restoreCandidates),
+			dependencies,
+			root: resolveCompiledSourceRoot(compatibleSource),
+			sources,
+			css,
+			rawCss,
+			target
+		};
+	}
+	async function generateWithIncrementalCache(options = {}) {
+		const target = options.target ?? "weapp";
+		const cssMacroSource = resolveCssMacroTailwindV4Source(source);
+		const compatibleSource = createCompatibleSource(cssMacroSource, 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(cssMacroSource, options);
+		const cacheKey = createIncrementalGenerateCacheKey(compatibleSource, target, styleOptions);
+		incrementalCacheKeys.add(cacheKey);
+		if (options.scanSources === true) return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+			const generated = await generateOnce(cssMacroSource, options);
+			if (!seedIncrementalGenerateCache({
+				compatibleSource,
+				generated,
+				requestedCandidates,
+				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(cssMacroSource, 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(cssMacroSource, 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((0, _weapp_tailwindcss_postcss_transform.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");
+				(0, _weapp_tailwindcss_postcss_transform.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(cssMacroSource, options);
+			seedIncrementalGenerateCache({
+				compatibleSource,
+				generated,
+				requestedCandidates,
+				styleOptions,
+				target
+			});
+			return generated;
+		});
+	}
+	async function generate(options = {}) {
+		return options.incrementalCache && options.scanMode !== "compiled" ? generateWithIncrementalCache(options) : generateOnce(source, options);
+	}
+	return {
+		source,
+		loadDesignSystem: validationEngine.loadDesignSystem,
+		validateCandidates: validationEngine.validateCandidates,
+		generate,
+		dispose() {
+			validationEngine.dispose?.();
+			generationSessions.dispose();
+			for (const cacheKey of incrementalCacheKeys) incrementalGenerateCache.delete(cacheKey);
+			incrementalCacheKeys.clear();
+		}
+	};
+}
+//#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;
+}
+/** 清除可选字段中的 undefined，再交给引擎候选校验与生成契约。 */
+function resolveRuntimeBareArbitraryValues(options) {
+	const value = resolveTailwindcssOptions(options)?.v4?.bareArbitraryValues;
+	return value && typeof value === "object" ? value.units === void 0 ? {} : { units: value.units } : value;
+}
+//#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/context/workspace.ts
+const IGNORED_WORKSPACE_DIRS = /* @__PURE__ */ 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) {
+		const workspaceFile = node_path.default.join(current, "pnpm-workspace.yaml");
+		if ((0, node_fs.existsSync)(workspaceFile)) 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) {
+		const pkgPath = node_path.default.join(current, "package.json");
+		if ((0, node_fs.existsSync)(pkgPath)) 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;
+}
+function removeTailwindV4CssSource(opts, file) {
+	const tailwindcss = opts.tailwindcss;
+	const v4 = tailwindcss?.v4;
+	const cssSources = v4?.cssSources;
+	if (!cssSources || cssSources.length === 0) return false;
+	const sourceFile = normalizeCssSourceFile(file);
+	const nextCssSources = cssSources.filter((source) => normalizeCssSourceFile(source.file) !== sourceFile);
+	if (nextCssSources.length === cssSources.length) return false;
+	opts.tailwindcss = {
+		...tailwindcss,
+		v4: {
+			...v4,
+			cssSources: nextCssSources
+		}
+	};
+	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 {
+		const packageJson = (0, node_module.createRequire)(require$1.resolve("@weapp-tailwindcss/engine")).resolve("tailwindcss/package.json");
+		const cssEntry = node_path.default.resolve(node_path.default.dirname(packageJson), "index.css");
+		if (isCssEntryPoint(cssEntry)) return cssEntry;
+	} 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 resolveCssImportFile(base, specifier) {
+	const normalizedSpecifier = node_path.default.sep === "\\" ? specifier.replaceAll("/", "\\") : specifier.replaceAll("\\", "/");
+	return node_path.default.resolve(base, normalizedSpecifier);
+}
+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 createTailwindV4CssImportSpecifierSet(packageName) {
+	const specifiers = /* @__PURE__ */ new Set(["tailwindcss"]);
+	if (packageName && isBarePackageSpecifier(packageName)) specifiers.add(packageName);
+	return specifiers;
+}
+function normalizeTailwindV4CssPackageImports(css, packageName) {
+	if (!css.includes("tailwindcss")) return css;
+	const importSpecifiers = createTailwindV4CssImportSpecifierSet(packageName);
+	return (0, _weapp_tailwindcss_postcss_transform.rewriteCssImportSpecifiers)(css, (specifier) => {
+		return importSpecifiers.has(specifier) ? resolvePackageCssEntryPoint(`${specifier}/index.css`) : void 0;
+	}, {
+		atRuleNames: ["import", "reference"],
+		tolerateInvalidCss: true
+	});
+}
+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((0, _weapp_tailwindcss_postcss_transform.normalizeEmptyTailwindCustomVariants)((0, _weapp_tailwindcss_postcss_transform.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 = [];
+	const graphs = /* @__PURE__ */ new Map();
+	const themeVariables = /* @__PURE__ */ new Map();
+	const collectCssGraph = (file, visiting = /* @__PURE__ */ new Set()) => {
+		const normalizedFile = node_path.default.resolve(file);
+		const cached = graphs.get(normalizedFile);
+		if (cached) return cached;
+		const graph = /* @__PURE__ */ new Set([normalizedFile]);
+		graphs.set(normalizedFile, graph);
+		if (visiting.has(normalizedFile) || !(0, node_fs.existsSync)(normalizedFile)) return graph;
+		const nextVisiting = new Set(visiting).add(normalizedFile);
+		let root;
+		try {
+			root = _weapp_tailwindcss_postcss_transform.postcss.parse((0, node_fs.readFileSync)(normalizedFile, "utf8"));
+		} catch {
+			return graph;
+		}
+		themeVariables.set(normalizedFile, (0, _weapp_tailwindcss_postcss_transform.collectRpxThemeVariables)(root));
+		const base = node_path.default.dirname(normalizedFile);
+		root.walkAtRules("import", (rule) => {
+			const parsed = (0, _weapp_tailwindcss_postcss_transform.parseCssImportSpecifier)(rule.params);
+			if (!parsed || !parsed.specifier.startsWith(".")) return;
+			const importedFile = resolveCssImportFile(base, parsed.specifier);
+			const resolved = (node_path.default.extname(importedFile) ? [importedFile] : [
+				importedFile,
+				`${importedFile}.css`,
+				`${importedFile}.pcss`,
+				`${importedFile}.scss`,
+				`${importedFile}.sass`
+			]).find((candidate) => (0, node_fs.existsSync)(candidate));
+			if (!resolved) return;
+			for (const dependency of collectCssGraph(resolved, nextVisiting)) graph.add(dependency);
+		});
+		return graph;
+	};
+	const createCssSource = (file, dependencies) => {
+		const normalizedFile = node_path.default.resolve(file);
+		const base = node_path.default.dirname(normalizedFile);
+		const rawCss = (0, node_fs.readFileSync)(normalizedFile, "utf8");
+		const entrySource = (0, _weapp_tailwindcss_postcss_transform.resolveCssEntrySource)(rawCss, base, { removeConfig: false });
+		const config = 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;
+		return {
+			file: normalizedFile,
+			base,
+			css: normalizeTailwindV4CssPackageImports((0, _weapp_tailwindcss_postcss_transform.normalizeEmptyTailwindCustomVariants)((0, _weapp_tailwindcss_postcss_transform.normalizeConfigDirective)(rawCss, config)), packageName),
+			dependencies: [...dependencies],
+			rpxThemeVariables: [...new Set([...dependencies].flatMap((dependency) => themeVariables.get(dependency) ?? []))]
+		};
+	};
+	const rootEntries = [];
+	for (const cssEntry of cssEntries) {
+		const normalizedCssEntry = cssEntry.replace(/[?#].*$/, "");
+		const file = node_path.default.resolve(normalizedCssEntry);
+		if (!(0, node_fs.existsSync)(file)) {
+			remainingCssEntries.push(normalizedCssEntry);
+			continue;
+		}
+		rootEntries.push(file);
+	}
+	const entryGraphs = rootEntries.map((entry) => [entry, collectCssGraph(entry)]);
+	const nestedEntries = /* @__PURE__ */ new Set();
+	for (const [entry] of entryGraphs) for (const [otherEntry, otherGraph] of entryGraphs) if (entry !== otherEntry && otherGraph.has(entry)) {
+		nestedEntries.add(entry);
+		break;
+	}
+	const selectedEntries = entryGraphs.filter(([entry]) => !nestedEntries.has(entry));
+	const roots = selectedEntries.length > 0 ? selectedEntries : entryGraphs.slice(0, 1);
+	for (const [rootEntry, dependencies] of roots) cssSources.push(createCssSource(rootEntry, dependencies));
+	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((0, _weapp_tailwindcss_postcss_transform.normalizeEmptyTailwindCustomVariants)((0, _weapp_tailwindcss_postcss_transform.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 === void 0 ? {} : { css },
+		...cssEntries === void 0 ? {} : { cssEntries },
+		...cssSources === void 0 ? {} : { 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
+	}));
+}
+async function resolveTailwindV4Source(options) {
+	const normalizedOptions = normalizeTailwindV4SourceOptions(options);
+	const source = await (0, _weapp_tailwindcss_engine.resolveTailwindV4Source)(normalizedOptions);
+	const variables = normalizedOptions?.cssSources?.flatMap((cssSource) => cssSource.rpxThemeVariables ?? []) ?? [];
+	if (variables.length) source.rpxThemeVariables = [...new Set(variables)];
+	return source;
+}
+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
+//#region src/runtime-branch/create-branch.ts
+function createRuntimeBranch(base, platformFamily, options) {
+	const { context, tailwindcssVersion } = base;
+	return {
+		tailwindcssVersion,
+		generatorTarget: context.generatorTarget,
+		platformFamily,
+		platform: options.platform,
+		nativeAppPlatform: options.nativeAppPlatform,
+		isTailwindV4: tailwindcssVersion === 4,
+		isWeb: platformFamily === "web",
+		isMiniProgram: platformFamily === "mini-program",
+		isNativeApp: platformFamily === "native-app"
+	};
+}
+//#endregion
+//#region src/runtime-branch/mini-program.ts
+function createMiniProgramRuntimeBranch(base) {
+	const { context, uniUtsPlatform } = base;
+	return createRuntimeBranch(base, "mini-program", { platform: typeof context.platform === "string" && context.platform.length > 0 ? context.platform : uniUtsPlatform.isMp ? uniUtsPlatform.normalized : context.platform });
+}
+//#endregion
+//#region src/utils/uni-platform.ts
+function resolveUniUtsPlatform(value = node_process.default.env["UNI_UTS_PLATFORM"]) {
+	return require_framework.resolveUniUtsPlatform(value);
+}
+//#endregion
+//#region src/runtime-branch/platform.ts
+function isRuntimeUniAppXEnabled(value) {
+	return value === true || typeof value === "object" && value?.enabled !== false;
+}
+function normalizeRuntimeUniUtsPlatform(value) {
+	return typeof value === "object" && value !== null ? value : resolveUniUtsPlatform(value);
+}
+function resolveNativeAppPlatform(platform) {
+	if (platform.isAppAndroid) return "android";
+	if (platform.isAppIos) return "ios";
+	if (platform.isAppHarmony) return "harmony";
+	return "unknown";
+}
+function resolveExplicitOrEnvPlatform(context, uniUtsPlatform) {
+	if (typeof context.platform === "string" && context.platform.length > 0) return context.platform;
+	return uniUtsPlatform.normalized;
+}
+//#endregion
+//#region src/runtime-branch/native-app.ts
+function createNativeAppRuntimeBranch(base) {
+	return createRuntimeBranch(base, "native-app", {
+		platform: resolveExplicitOrEnvPlatform(base.context, base.uniUtsPlatform),
+		nativeAppPlatform: resolveNativeAppPlatform(base.uniUtsPlatform)
+	});
+}
+//#endregion
+//#region src/runtime-branch/tailwind-version.ts
+function resolveTailwindcssBranchVersion(_majorVersion) {
+	return 4;
+}
+//#endregion
+//#region src/runtime-branch/web.ts
+function createWebRuntimeBranch(base) {
+	return createRuntimeBranch(base, "web", { platform: resolveExplicitOrEnvPlatform(base.context, base.uniUtsPlatform) });
+}
+//#endregion
+//#region src/runtime-branch/index.ts
+function shouldUseNativeAppBranch(base, uniUtsPlatform) {
+	return base.appType === "uni-app-x" && isRuntimeUniAppXEnabled(base.uniAppX) && uniUtsPlatform.isApp;
+}
+function resolveRuntimeBranch(context) {
+	const uniUtsPlatform = normalizeRuntimeUniUtsPlatform(context.uniUtsPlatform);
+	const base = {
+		context,
+		tailwindcssVersion: resolveTailwindcssBranchVersion(context.tailwindcssMajorVersion),
+		uniUtsPlatform
+	};
+	if (context.generatorTarget === "web") return createWebRuntimeBranch(base);
+	if (shouldUseNativeAppBranch(context, uniUtsPlatform)) return createNativeAppRuntimeBranch(base);
+	return createMiniProgramRuntimeBranch(base);
+}
+function resolveGeneratorRuntimeBranch(options, context = {}) {
+	return options.branch ?? resolveRuntimeBranch({
+		...context,
+		generatorTarget: options.target
+	});
+}
+function shouldUseMiniProgramCssBranch(branch) {
+	return branch.platformFamily === "mini-program" || branch.platformFamily === "native-app";
+}
+function shouldUseNativeAppCssBranch(branch) {
+	return branch.platformFamily === "native-app";
+}
+//#endregion
+//#region src/generator/options.ts
+function normalizeWeappTailwindcssGeneratorOptions(options, context = {}) {
+	const enabled = options !== false;
+	const objectOptions = enabled ? options : void 0;
+	const target = objectOptions?.target ?? (shouldUseUniAppViteWebViewGeneratorTarget(context.appType, context.platform) ? "web" : inferGeneratorTargetFromEnv());
+	const branch = resolveRuntimeBranch({
+		...context,
+		generatorTarget: target
+	});
+	const hasExplicitTarget = objectOptions !== void 0 && Object.hasOwn(objectOptions, "target");
+	const webCompat = objectOptions?.webCompat ?? (!hasExplicitTarget && branch.isWeb ? true : void 0);
+	if (objectOptions == null) return {
+		enabled,
+		target,
+		branch,
+		webCompat,
+		hmr: { preserveDeletedCss: true },
+		importFallback: false,
+		bareArbitraryValues: void 0
+	};
+	return {
+		enabled,
+		target,
+		branch,
+		config: objectOptions.config,
+		styleOptions: objectOptions.styleOptions,
+		webCompat,
+		hmr: { preserveDeletedCss: objectOptions.hmr?.preserveDeletedCss ?? true },
+		importFallback: objectOptions.importFallback ?? false,
+		bareArbitraryValues: objectOptions.bareArbitraryValues
+	};
+}
+//#endregion
+//#region src/generator/index.ts
+function createWeappTailwindcssGenerator(source) {
+	return createTailwindV4Engine(source);
+}
+async function resolveTailwindSourceFromRuntime(tailwindRuntime) {
+	return resolveTailwindV4SourceFromRuntime(tailwindRuntime);
+}
+async function createWeappTailwindcssGeneratorFromRuntime(tailwindRuntime) {
+	return createWeappTailwindcssGenerator(await resolveTailwindSourceFromRuntime(tailwindRuntime));
+}
+//#endregion
+Object.defineProperty(exports, "_defineProperty", {
+	enumerable: true,
+	get: function() {
+		return _defineProperty;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4Engine", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4Engine;
+	}
+});
+Object.defineProperty(exports, "createWeappTailwindcssGenerator", {
+	enumerable: true,
+	get: function() {
+		return createWeappTailwindcssGenerator;
+	}
+});
+Object.defineProperty(exports, "createWeappTailwindcssGeneratorFromRuntime", {
+	enumerable: true,
+	get: function() {
+		return createWeappTailwindcssGeneratorFromRuntime;
+	}
+});
+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, "isTailwindV4CssEntry", {
+	enumerable: true,
+	get: function() {
+		return isTailwindV4CssEntry;
+	}
+});
+Object.defineProperty(exports, "normalizeCssEntries", {
+	enumerable: true,
+	get: function() {
+		return normalizeCssEntries;
+	}
+});
+Object.defineProperty(exports, "normalizeExtendLengthUnits", {
+	enumerable: true,
+	get: function() {
+		return normalizeExtendLengthUnits;
+	}
+});
+Object.defineProperty(exports, "normalizeStringListOption", {
+	enumerable: true,
+	get: function() {
+		return normalizeStringListOption;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindcssRuntimeOptions", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindcssRuntimeOptions;
+	}
+});
+Object.defineProperty(exports, "normalizeWeappTailwindcssGeneratorOptions", {
+	enumerable: true,
+	get: function() {
+		return normalizeWeappTailwindcssGeneratorOptions;
+	}
+});
+Object.defineProperty(exports, "omitUndefined", {
+	enumerable: true,
+	get: function() {
+		return omitUndefined;
+	}
+});
+Object.defineProperty(exports, "removeTailwindV4CssSource", {
+	enumerable: true,
+	get: function() {
+		return removeTailwindV4CssSource;
+	}
+});
+Object.defineProperty(exports, "resolveBooleanObjectOption", {
+	enumerable: true,
+	get: function() {
+		return resolveBooleanObjectOption;
+	}
+});
+Object.defineProperty(exports, "resolveCssMacroTailwindV4Source", {
+	enumerable: true,
+	get: function() {
+		return resolveCssMacroTailwindV4Source;
+	}
+});
+Object.defineProperty(exports, "resolveGeneratorRuntimeBranch", {
+	enumerable: true,
+	get: function() {
+		return resolveGeneratorRuntimeBranch;
+	}
+});
+Object.defineProperty(exports, "resolveRuntimeBareArbitraryValues", {
+	enumerable: true,
+	get: function() {
+		return resolveRuntimeBareArbitraryValues;
+	}
+});
+Object.defineProperty(exports, "resolveRuntimeBranch", {
+	enumerable: true,
+	get: function() {
+		return resolveRuntimeBranch;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindSourceFromRuntime", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindSourceFromRuntime;
+	}
+});
+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, "resolveUniUtsPlatform", {
+	enumerable: true,
+	get: function() {
+		return resolveUniUtsPlatform;
+	}
+});
+Object.defineProperty(exports, "shouldUseMiniProgramCssBranch", {
+	enumerable: true,
+	get: function() {
+		return shouldUseMiniProgramCssBranch;
+	}
+});
+Object.defineProperty(exports, "shouldUseNativeAppCssBranch", {
+	enumerable: true,
+	get: function() {
+		return shouldUseNativeAppCssBranch;
+	}
+});
+Object.defineProperty(exports, "shouldUseUniAppWebRpxCompatibility", {
+	enumerable: true,
+	get: function() {
+		return shouldUseUniAppWebRpxCompatibility;
+	}
+});
+Object.defineProperty(exports, "transformTailwindV4CssByTarget", {
+	enumerable: true,
+	get: function() {
+		return transformTailwindV4CssByTarget;
+	}
+});
+Object.defineProperty(exports, "upsertTailwindV4CssSource", {
+	enumerable: true,
+	get: function() {
+		return upsertTailwindV4CssSource;
+	}
+});