weapp-tailwindcss 4.12.0 → 5.0.0-next.2

package/dist/logger-BZ45DZJT.js

@@ -0,0 +1,1003 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_patcher_options = require("./patcher-options-6gJN2EXy.js");
+require("./utils-DmC9_In3.js");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let tailwindcss_patch = require("tailwindcss-patch");
+let node_fs = require("node:fs");
+let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+let node_url = require("node:url");
+//#region src/tailwindcss/runtime/cache.ts
+const runtimeClassSetCache = /* @__PURE__ */ new WeakMap();
+const runtimeFileSignatureCache = /* @__PURE__ */ new Map();
+let runtimeFileSignatureCacheClearTimer;
+const runtimeSignaturePatchersSymbol = Symbol.for("weapp-tailwindcss.runtimeSignaturePatchers");
+function getCacheEntry(twPatcher) {
+	let entry = runtimeClassSetCache.get(twPatcher);
+	if (!entry) {
+		entry = {};
+		runtimeClassSetCache.set(twPatcher, entry);
+	}
+	return entry;
+}
+function scheduleRuntimeConfigSignatureCacheClear() {
+	if (runtimeFileSignatureCacheClearTimer) return;
+	runtimeFileSignatureCacheClearTimer = setTimeout(() => {
+		runtimeFileSignatureCache.clear();
+		runtimeFileSignatureCacheClearTimer = void 0;
+	}, 0);
+	runtimeFileSignatureCacheClearTimer.unref?.();
+}
+function getFileSignature(filePath) {
+	const cached = runtimeFileSignatureCache.get(filePath);
+	if (cached !== void 0) return cached;
+	let signature;
+	try {
+		const stats = (0, node_fs.statSync)(filePath);
+		signature = `${filePath}:${stats.size}:${stats.mtimeMs}`;
+	} catch {
+		signature = `${filePath}:missing`;
+	}
+	runtimeFileSignatureCache.set(filePath, signature);
+	scheduleRuntimeConfigSignatureCacheClear();
+	return signature;
+}
+function getTailwindTrackedFiles(twPatcher) {
+	const tailwindOptions = require_patcher_options.resolveTailwindcssOptions(twPatcher.options);
+	const tracked = /* @__PURE__ */ new Set();
+	const configPath = tailwindOptions?.config;
+	if (typeof configPath === "string" && configPath.length > 0) tracked.add(configPath);
+	for (const entry of tailwindOptions?.v4?.cssEntries ?? []) if (typeof entry === "string" && entry.length > 0) tracked.add(entry);
+	return tracked;
+}
+function normalizeSignatureValue(value) {
+	if (value == null) return "null";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return `[${value.map((item) => normalizeSignatureValue(item)).join(",")}]`;
+	if (typeof value === "object") return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${key}:${normalizeSignatureValue(item)}`).join(",")}}`;
+	return String(value);
+}
+function readOptionalProperty(value, key) {
+	if (typeof value !== "object" || value === null || !(key in value)) return;
+	return value[key];
+}
+function getTailwindOptionsSignature(twPatcher) {
+	const options = twPatcher.options;
+	const tailwindOptions = require_patcher_options.resolveTailwindcssOptions(options);
+	return normalizeSignatureValue({
+		projectRoot: options?.projectRoot,
+		packageName: tailwindOptions?.packageName,
+		versionHint: readOptionalProperty(tailwindOptions, "versionHint"),
+		cwd: tailwindOptions?.cwd,
+		config: tailwindOptions?.config,
+		v2: tailwindOptions?.v2,
+		v3: tailwindOptions?.v3,
+		v4: {
+			base: tailwindOptions?.v4?.base,
+			configuredBase: readOptionalProperty(tailwindOptions?.v4, "configuredBase"),
+			css: tailwindOptions?.v4?.css,
+			cssEntries: tailwindOptions?.v4?.cssEntries,
+			hasUserDefinedSources: readOptionalProperty(tailwindOptions?.v4, "hasUserDefinedSources"),
+			sources: tailwindOptions?.v4?.sources
+		}
+	});
+}
+function getPatchTargetSignature(twPatcher) {
+	const packageInfo = twPatcher.packageInfo;
+	return [
+		packageInfo?.name ?? "missing",
+		packageInfo?.rootPath ?? "missing",
+		packageInfo?.version ?? "unknown",
+		twPatcher.majorVersion ?? "unknown",
+		getTailwindOptionsSignature(twPatcher)
+	].join(":");
+}
+function getNestedPatchers(twPatcher) {
+	const nested = twPatcher[runtimeSignaturePatchersSymbol];
+	return Array.isArray(nested) && nested.length > 0 ? nested : void 0;
+}
+function getOwnRuntimeClassSetSignature(twPatcher) {
+	const trackedFiles = [...getTailwindTrackedFiles(twPatcher)].sort((a, b) => a.localeCompare(b)).map(getFileSignature);
+	return `${trackedFiles.length > 0 ? trackedFiles.join("|") : "files:missing"}|patch:${getPatchTargetSignature(twPatcher)}`;
+}
+function invalidateRuntimeClassSet(twPatcher) {
+	if (!twPatcher) return;
+	const nestedPatchers = getNestedPatchers(twPatcher);
+	if (nestedPatchers) for (const patcher of nestedPatchers) invalidateRuntimeClassSet(patcher);
+	for (const trackedFile of getTailwindTrackedFiles(twPatcher)) runtimeFileSignatureCache.delete(trackedFile);
+	runtimeClassSetCache.delete(twPatcher);
+}
+function getRuntimeClassSetCacheEntry(twPatcher) {
+	return getCacheEntry(twPatcher);
+}
+function getRuntimeClassSetSignature(twPatcher) {
+	const nestedPatchers = getNestedPatchers(twPatcher);
+	if (nestedPatchers) return nestedPatchers.map(getOwnRuntimeClassSetSignature).sort((a, b) => a.localeCompare(b)).join("||");
+	return getOwnRuntimeClassSetSignature(twPatcher);
+}
+//#endregion
+//#region src/context/workspace.ts
+const IGNORED_WORKSPACE_DIRS = new Set([
+	"node_modules",
+	".git",
+	".hg",
+	".svn",
+	".turbo",
+	".output",
+	".next",
+	"dist",
+	"build"
+]);
+function findWorkspaceRoot(startDir) {
+	if (!startDir) return;
+	let current = node_path.default.resolve(startDir);
+	while (true) {
+		if ((0, node_fs.existsSync)(node_path.default.join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findNearestPackageRoot(startDir) {
+	if (!startDir) return;
+	let current = node_path.default.resolve(startDir);
+	while (true) {
+		if ((0, node_fs.existsSync)(node_path.default.join(current, "package.json"))) return current;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findWorkspacePackageDir(rootDir, packageName) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [node_path.default.resolve(rootDir)];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const normalized = node_path.default.normalize(current);
+		if (visited.has(normalized)) continue;
+		visited.add(normalized);
+		try {
+			const pkgPath = node_path.default.join(normalized, "package.json");
+			if ((0, node_fs.existsSync)(pkgPath)) {
+				if (JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf8"))?.name === packageName) return normalized;
+			}
+		} catch {}
+		let entries;
+		try {
+			entries = (0, node_fs.readdirSync)(normalized, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || IGNORED_WORKSPACE_DIRS.has(entry.name) || entry.isSymbolicLink?.()) continue;
+			queue.push(node_path.default.join(normalized, entry.name));
+		}
+	}
+}
+//#endregion
+//#region src/tailwindcss/v4/config.ts
+const DEFAULT_CSS_CALC_CUSTOM_PROPERTIES = [];
+function includesToken(list, token) {
+	return list.some((candidate) => {
+		if (typeof token === "string") {
+			if (typeof candidate === "string") return candidate === token;
+			candidate.lastIndex = 0;
+			return candidate.test(token);
+		}
+		if (typeof candidate === "string") {
+			token.lastIndex = 0;
+			return token.test(candidate);
+		}
+		return candidate.source === token.source && candidate.flags === token.flags;
+	});
+}
+function ensureDefaultsIncluded(value) {
+	if (value === true) return { includeCustomProperties: [...DEFAULT_CSS_CALC_CUSTOM_PROPERTIES] };
+	if (Array.isArray(value)) {
+		if (!DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.length) return value;
+		const missing = DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.filter((token) => !includesToken(value, token));
+		return missing.length > 0 ? [...value, ...missing] : value;
+	}
+	if (value && typeof value === "object") {
+		const include = value.includeCustomProperties;
+		if (!Array.isArray(include)) return {
+			...value,
+			includeCustomProperties: [...DEFAULT_CSS_CALC_CUSTOM_PROPERTIES]
+		};
+		if (!DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.length) return value;
+		const missing = DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.filter((token) => !includesToken(include, token));
+		return missing.length > 0 ? {
+			...value,
+			includeCustomProperties: [...include, ...missing]
+		} : value;
+	}
+	return value;
+}
+function normalizeCssEntriesConfig(entries) {
+	if (!entries) return;
+	if (typeof entries === "string") {
+		const trimmed = entries.trim();
+		return trimmed ? [trimmed] : void 0;
+	}
+	if (!Array.isArray(entries)) return;
+	const normalized = entries.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+	return normalized.length > 0 ? normalized : void 0;
+}
+function hasConfiguredCssEntries(ctx) {
+	if (normalizeCssEntriesConfig(ctx.cssEntries)) return true;
+	if (normalizeCssEntriesConfig(ctx.tailwindcss?.v4?.cssEntries)) return true;
+	const patcherOptions = ctx.tailwindcssPatcherOptions;
+	if (patcherOptions) {
+		if (normalizeCssEntriesConfig(patcherOptions.tailwindcss?.v4?.cssEntries)) return true;
+		if (normalizeCssEntriesConfig(patcherOptions.tailwind?.v4?.cssEntries)) return true;
+		if (normalizeCssEntriesConfig(patcherOptions.patch?.tailwindcss?.v4?.cssEntries)) return true;
+	}
+	return false;
+}
+let hasWarnedMissingCssEntries = false;
+function warnMissingCssEntries(ctx, patcher) {
+	if (hasWarnedMissingCssEntries) return;
+	if (patcher?.majorVersion !== 4) return;
+	if (hasConfiguredCssEntries(ctx)) return;
+	hasWarnedMissingCssEntries = true;
+	_weapp_tailwindcss_logger.logger.warn("[tailwindcss@4] 未检测到 cssEntries 配置。请传入包含 tailwindcss 引用的 CSS 绝对路径，例如 cssEntries: [\"/absolute/path/to/src/app.css\"]，否则 tailwindcss 生成的类名不会参与转译。");
+}
+function applyV4CssCalcDefaults(cssCalc, patcher) {
+	const cssCalcOptions = cssCalc ?? patcher?.majorVersion === 4;
+	if (patcher?.majorVersion === 4 && cssCalcOptions) return ensureDefaultsIncluded(cssCalcOptions);
+	return cssCalcOptions;
+}
+//#endregion
+//#region src/tailwindcss/patcher-resolve.ts
+const GENERIC_RELATIVE_SPECIFIERS = [".", ".."];
+const DEFAULT_TAILWIND_CONFIG_SPECIFIERS = ["stubs/config.full.js", "defaultConfig.js"];
+const TAILWIND_CONFIG_FILES = [
+	"tailwind.config.js",
+	"tailwind.config.cjs",
+	"tailwind.config.mjs",
+	"tailwind.config.ts",
+	"tailwind.config.cts",
+	"tailwind.config.mts"
+];
+function isPathSpecifier(specifier) {
+	if (!specifier) return false;
+	if (specifier.startsWith("file://")) return true;
+	if (node_path.default.isAbsolute(specifier)) return true;
+	return GENERIC_RELATIVE_SPECIFIERS.some((prefix) => specifier.startsWith(`${prefix}/`) || specifier.startsWith(`${prefix}\\`));
+}
+function resolveModuleFromPaths(specifier, paths) {
+	if (!specifier || isPathSpecifier(specifier) || paths.length === 0) return;
+	try {
+		return (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve(specifier, { paths });
+	} catch {
+		return;
+	}
+}
+function resolveTailwindConfigFallback(packageName, paths) {
+	if (!packageName) return;
+	for (const suffix of DEFAULT_TAILWIND_CONFIG_SPECIFIERS) {
+		const resolved = resolveModuleFromPaths(`${packageName}/${suffix}`, paths);
+		if (resolved) return resolved;
+	}
+}
+function appendNodeModules(paths, dir) {
+	if (!dir) return;
+	const nodeModulesDir = node_path.default.join(dir, "node_modules");
+	if ((0, node_fs.existsSync)(nodeModulesDir)) paths.add(nodeModulesDir);
+}
+function findTailwindConfig(searchRoots) {
+	for (const root of searchRoots) for (const file of TAILWIND_CONFIG_FILES) {
+		const candidate = node_path.default.resolve(root, file);
+		if ((0, node_fs.existsSync)(candidate)) return candidate;
+	}
+}
+function createDefaultResolvePaths(basedir) {
+	const paths = /* @__PURE__ */ new Set();
+	let fallbackCandidates = [];
+	if (basedir) {
+		const resolvedBase = node_path.default.resolve(basedir);
+		appendNodeModules(paths, resolvedBase);
+		fallbackCandidates.push(resolvedBase);
+		const packageRoot = findNearestPackageRoot(resolvedBase);
+		if (packageRoot) {
+			appendNodeModules(paths, packageRoot);
+			fallbackCandidates.push(packageRoot);
+		}
+	}
+	const cwd = node_process.default.cwd();
+	appendNodeModules(paths, cwd);
+	try {
+		const modulePath = (0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+		const candidate = (0, node_fs.existsSync)(modulePath) && !node_path.default.extname(modulePath) ? modulePath : node_path.default.dirname(modulePath);
+		paths.add(candidate);
+	} catch {
+		paths.add(require("url").pathToFileURL(__filename).href);
+	}
+	if (paths.size === 0) {
+		fallbackCandidates = fallbackCandidates.filter(Boolean);
+		if (fallbackCandidates.length === 0) fallbackCandidates.push(cwd);
+		for (const candidate of fallbackCandidates) paths.add(candidate);
+	}
+	return [...paths];
+}
+//#endregion
+//#region src/tailwindcss/patcher.ts
+function createFallbackTailwindcssPatcher() {
+	return {
+		packageInfo: {
+			name: "tailwindcss",
+			version: void 0,
+			rootPath: "",
+			packageJsonPath: "",
+			packageJson: {}
+		},
+		async patch() {
+			return {
+				exposeContext: void 0,
+				extendLengthUnits: void 0
+			};
+		},
+		async getClassSet() {
+			return /* @__PURE__ */ new Set();
+		},
+		async extract(_options) {
+			return {
+				classList: [],
+				classSet: /* @__PURE__ */ new Set()
+			};
+		},
+		async collectContentTokens() {
+			return {
+				entries: [],
+				filesScanned: 0,
+				sources: [],
+				skippedFiles: []
+			};
+		}
+	};
+}
+let hasLoggedMissingTailwind = false;
+const TAILWINDCSS_NOT_FOUND_RE = /tailwindcss not found/i;
+const UNABLE_TO_LOCATE_TAILWINDCSS_RE = /unable to locate tailwind css package/i;
+function isTailwindcssV4PackageName(packageName) {
+	return packageName === "@tailwindcss/postcss" || packageName === "tailwindcss4" || Boolean(packageName && packageName.includes("tailwindcss4"));
+}
+function createTailwindcssPatcher(options) {
+	const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
+	const cache = { driver: "memory" };
+	const normalizedBasedir = basedir ? node_path.default.resolve(basedir) : void 0;
+	const cacheRoot = findNearestPackageRoot(normalizedBasedir) ?? normalizedBasedir ?? node_process.default.cwd();
+	if (cacheDir) if (node_path.default.isAbsolute(cacheDir)) cache.dir = cacheDir;
+	else if (normalizedBasedir) cache.dir = node_path.default.resolve(normalizedBasedir, cacheDir);
+	else cache.dir = node_path.default.resolve(node_process.default.cwd(), cacheDir);
+	else cache.dir = node_path.default.join(cacheRoot, "node_modules", ".cache", "tailwindcss-patch");
+	if (normalizedBasedir) cache.cwd = normalizedBasedir;
+	const resolvePaths = createDefaultResolvePaths(cache.cwd ?? normalizedBasedir ?? node_process.default.cwd());
+	const normalizedUserOptions = require_patcher_options.normalizeTailwindcssPatcherOptions(tailwindcssPatcherOptions);
+	const extendLengthUnits = require_patcher_options.normalizeExtendLengthUnits(supportCustomLengthUnitsPatch ?? true);
+	const baseTailwindOptions = (0, _weapp_tailwindcss_shared.defuOverrideArray)(tailwindcss ?? {}, {
+		cwd: normalizedBasedir,
+		resolve: { paths: resolvePaths }
+	});
+	if (baseTailwindOptions.version === 2) {
+		if (!baseTailwindOptions.packageName) baseTailwindOptions.packageName = "@tailwindcss/postcss7-compat";
+		if (!baseTailwindOptions.postcssPlugin) baseTailwindOptions.postcssPlugin = "@tailwindcss/postcss7-compat";
+	} else if (!baseTailwindOptions.packageName) baseTailwindOptions.packageName = "tailwindcss";
+	if (!baseTailwindOptions.postcssPlugin) baseTailwindOptions.postcssPlugin = baseTailwindOptions.version === 4 || isTailwindcssV4PackageName(baseTailwindOptions.packageName) ? "@tailwindcss/postcss" : "tailwindcss";
+	if (typeof baseTailwindOptions.postcssPlugin === "string") {
+		const resolvedPlugin = resolveModuleFromPaths(baseTailwindOptions.postcssPlugin, resolvePaths);
+		if (resolvedPlugin) baseTailwindOptions.postcssPlugin = resolvedPlugin;
+	}
+	const resolvedOptions = require_patcher_options.toModernTailwindcssPatchOptions((0, _weapp_tailwindcss_shared.defuOverrideArray)(normalizedUserOptions ?? {}, {
+		projectRoot: normalizedBasedir,
+		cache,
+		tailwindcss: baseTailwindOptions,
+		apply: {
+			exposeContext: true,
+			extendLengthUnits
+		}
+	})) ?? {};
+	const resolvedTailwindOptions = resolvedOptions.tailwindcss;
+	if (resolvedTailwindOptions) {
+		const existingResolve = resolvedTailwindOptions.resolve ?? {};
+		const sourcePaths = Array.isArray(existingResolve.paths) && existingResolve.paths.length > 0 ? existingResolve.paths : resolvePaths;
+		resolvedTailwindOptions.resolve = {
+			...existingResolve,
+			paths: [...new Set(sourcePaths)]
+		};
+		_weapp_tailwindcss_logger.logger.debug("Tailwind resolve config %O", {
+			packageName: resolvedTailwindOptions.packageName,
+			version: resolvedTailwindOptions.version,
+			resolve: resolvedTailwindOptions.resolve,
+			cwd: resolvedTailwindOptions.cwd
+		});
+		if (typeof resolvedTailwindOptions.postcssPlugin === "string") {
+			const resolvedPlugin = resolveModuleFromPaths(resolvedTailwindOptions.postcssPlugin, resolvedTailwindOptions.resolve?.paths ?? resolvePaths);
+			if (resolvedPlugin) resolvedTailwindOptions.postcssPlugin = resolvedPlugin;
+		}
+		const searchRoots = /* @__PURE__ */ new Set();
+		if (resolvedTailwindOptions.cwd) searchRoots.add(resolvedTailwindOptions.cwd);
+		for (const resolvePath of resolvedTailwindOptions.resolve?.paths ?? []) {
+			const parentDir = node_path.default.dirname(resolvePath);
+			searchRoots.add(parentDir);
+		}
+		const configPath = findTailwindConfig(searchRoots);
+		if (!resolvedTailwindOptions.config) if (configPath) resolvedTailwindOptions.config = configPath;
+		else {
+			const fallbackConfig = resolveTailwindConfigFallback(resolvedTailwindOptions.packageName, resolvedTailwindOptions.resolve.paths ?? resolvePaths);
+			if (fallbackConfig) resolvedTailwindOptions.config = fallbackConfig;
+		}
+		if (!resolvedTailwindOptions.cwd && configPath) resolvedTailwindOptions.cwd = node_path.default.dirname(configPath);
+		resolvedOptions.tailwindcss = resolvedTailwindOptions;
+	}
+	try {
+		return new tailwindcss_patch.TailwindcssPatcher(resolvedOptions);
+	} catch (error) {
+		const searchPaths = resolvedOptions.tailwindcss?.resolve?.paths;
+		if (error instanceof Error && TAILWINDCSS_NOT_FOUND_RE.test(error.message)) {
+			if (!hasLoggedMissingTailwind) {
+				_weapp_tailwindcss_logger.logger.warn("Tailwind CSS 未安装，已跳过 Tailwind 相关补丁。若需使用 Tailwind 能力，请安装 tailwindcss。");
+				hasLoggedMissingTailwind = true;
+			}
+			return createFallbackTailwindcssPatcher();
+		}
+		if (error instanceof Error && UNABLE_TO_LOCATE_TAILWINDCSS_RE.test(error.message)) _weapp_tailwindcss_logger.logger.error("无法定位 Tailwind CSS 包 \"%s\"，已尝试路径: %O", resolvedOptions.tailwindcss?.packageName, searchPaths);
+		throw error;
+	}
+}
+//#endregion
+//#region src/tailwindcss/v4/multi-patcher.ts
+function createMultiTailwindcssPatcher(patchers) {
+	if (patchers.length <= 1) return patchers[0];
+	const [first] = patchers;
+	const multiPatcher = {
+		...first,
+		packageInfo: first?.packageInfo,
+		majorVersion: first?.majorVersion,
+		options: first?.options,
+		async patch() {
+			let exposeContext;
+			let extendLengthUnits;
+			for (const patcher of patchers) {
+				const result = await patcher.patch();
+				if (result?.exposeContext && exposeContext == null) exposeContext = result.exposeContext;
+				if (result?.extendLengthUnits && extendLengthUnits == null) extendLengthUnits = result.extendLengthUnits;
+			}
+			return {
+				exposeContext,
+				extendLengthUnits
+			};
+		},
+		async getClassSet() {
+			const aggregated = /* @__PURE__ */ new Set();
+			for (const patcher of patchers) {
+				const current = await patcher.getClassSet();
+				for (const className of current) aggregated.add(className);
+			}
+			return aggregated;
+		},
+		async extract(options) {
+			const aggregatedSet = /* @__PURE__ */ new Set();
+			const aggregatedList = [];
+			let filename;
+			for (const patcher of patchers) {
+				const result = await patcher.extract(options);
+				if (!result) continue;
+				if (filename === void 0 && result.filename) filename = result.filename;
+				if (result.classList) for (const className of result.classList) {
+					if (!aggregatedSet.has(className)) aggregatedList.push(className);
+					aggregatedSet.add(className);
+				}
+				if (result.classSet) for (const className of result.classSet) aggregatedSet.add(className);
+			}
+			return {
+				classList: aggregatedList,
+				classSet: aggregatedSet,
+				filename
+			};
+		}
+	};
+	if (patchers.every((patcher) => typeof patcher.getClassSetSync === "function")) multiPatcher.getClassSetSync = () => {
+		const aggregated = /* @__PURE__ */ new Set();
+		for (const patcher of patchers) {
+			const current = patcher.getClassSetSync?.();
+			if (!current) continue;
+			for (const className of current) aggregated.add(className);
+		}
+		return aggregated;
+	};
+	Object.defineProperty(multiPatcher, runtimeSignaturePatchersSymbol, {
+		value: [...patchers],
+		configurable: true
+	});
+	return multiPatcher;
+}
+//#endregion
+//#region src/tailwindcss/v4/patcher-options.ts
+function isLegacyTailwindcssPatcherOptions(options) {
+	return typeof options === "object" && options !== null && "patch" in options;
+}
+function isModernTailwindcssPatchOptions(options) {
+	return typeof options === "object" && options !== null && !("patch" in options);
+}
+function overrideTailwindcssPatcherOptionsForBase(options, baseDir, cssEntries) {
+	const hasCssEntries = cssEntries.length > 0;
+	if (!options) return options;
+	if (isLegacyTailwindcssPatcherOptions(options)) {
+		const patchOptions = options.patch;
+		if (!patchOptions) return options;
+		const nextPatch = {
+			...patchOptions,
+			basedir: baseDir,
+			cwd: patchOptions.cwd ?? baseDir
+		};
+		if (patchOptions.tailwindcss) {
+			const nextV4 = { ...patchOptions.tailwindcss.v4 ?? {} };
+			if (hasCssEntries) nextV4.cssEntries = cssEntries;
+			else {
+				nextV4.cssEntries = nextV4.cssEntries ?? cssEntries;
+				if (nextV4.base === void 0) nextV4.base = baseDir;
+			}
+			nextPatch.tailwindcss = {
+				...patchOptions.tailwindcss,
+				v4: nextV4
+			};
+		}
+		return {
+			...options,
+			patch: nextPatch
+		};
+	}
+	if (!isModernTailwindcssPatchOptions(options)) return options;
+	const modernTailwind = options.tailwindcss ?? options.tailwind;
+	if (!modernTailwind) return options;
+	const { tailwind: _legacyTailwind, ...rest } = options;
+	return {
+		...rest,
+		tailwindcss: {
+			...modernTailwind,
+			v4: {
+				...modernTailwind.v4 ?? {},
+				...hasCssEntries ? {} : { base: modernTailwind.v4?.base ?? baseDir },
+				cssEntries: hasCssEntries ? cssEntries : modernTailwind.v4?.cssEntries ?? cssEntries
+			}
+		}
+	};
+}
+//#endregion
+//#region src/tailwindcss/v4/css-entries.ts
+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;
+		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;
+		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/patcher.ts
+const CONFIGURED_TAILWIND_VERSION_RE = /Configured tailwindcss\.version=\d+/u;
+const RESOLVED_TAILWIND_VERSION_RE = /resolved package ".+" is version /u;
+function isTailwindcss4Package(packageName) {
+	return Boolean(packageName && (packageName === "tailwindcss4" || packageName === "@tailwindcss/postcss" || packageName.includes("tailwindcss4")));
+}
+function resolveExplicitTailwindVersion(configuredVersion, configuredPackageName) {
+	if (typeof configuredVersion === "number") return configuredVersion;
+	if (configuredPackageName === "tailwindcss") return 3;
+	if (isTailwindcss4Package(configuredPackageName)) return 4;
+}
+function hasOwnV4Signal(value) {
+	return typeof value === "object" && value !== null && "v4" in value;
+}
+function isTailwindVersionMismatchError(error) {
+	return error instanceof Error && CONFIGURED_TAILWIND_VERSION_RE.test(error.message) && RESOLVED_TAILWIND_VERSION_RE.test(error.message);
+}
+function createPatcherForBase(baseDir, cssEntries, options) {
+	const { tailwindcss, tailwindcssPatcherOptions, supportCustomLengthUnitsPatch } = options;
+	const hasCssEntries = Boolean(cssEntries?.length);
+	const mergedTailwindOptions = (0, _weapp_tailwindcss_shared.defuOverrideArray)(tailwindcss ?? {}, {
+		cwd: baseDir,
+		v2: { cwd: baseDir },
+		v3: { cwd: baseDir },
+		v4: hasCssEntries ? { cssEntries } : {
+			base: baseDir,
+			cssEntries
+		}
+	});
+	if (!mergedTailwindOptions.v4) mergedTailwindOptions.v4 = hasCssEntries ? { cssEntries: cssEntries ?? [] } : {
+		base: baseDir,
+		cssEntries: cssEntries ?? []
+	};
+	else {
+		if (!hasCssEntries && !mergedTailwindOptions.v4.base) mergedTailwindOptions.v4.base = baseDir;
+		if (hasCssEntries) {
+			if (cssEntries?.length) mergedTailwindOptions.v4.cssEntries = cssEntries;
+			else if (!mergedTailwindOptions.v4.cssEntries) mergedTailwindOptions.v4.cssEntries = [];
+		} else if (!mergedTailwindOptions.v4.cssEntries) mergedTailwindOptions.v4.cssEntries = cssEntries ?? [];
+	}
+	const patchedOptions = overrideTailwindcssPatcherOptionsForBase(tailwindcssPatcherOptions, baseDir, cssEntries ?? []);
+	const configuredPackageName = tailwindcss?.packageName || tailwindcssPatcherOptions?.tailwindcss?.packageName || tailwindcssPatcherOptions?.tailwind?.packageName || tailwindcssPatcherOptions?.patch?.tailwindcss?.packageName;
+	const explicitTailwindVersion = resolveExplicitTailwindVersion(tailwindcss?.version || tailwindcssPatcherOptions?.tailwindcss?.version || tailwindcssPatcherOptions?.tailwind?.version || tailwindcssPatcherOptions?.patch?.tailwindcss?.version || mergedTailwindOptions.version, configuredPackageName);
+	const hasExplicitV4Signals = hasCssEntries || hasOwnV4Signal(tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwind) || hasOwnV4Signal(tailwindcssPatcherOptions?.patch?.tailwindcss);
+	const shouldPatchV4PostcssPackage = (explicitTailwindVersion === 3 ? false : explicitTailwindVersion === 4 || explicitTailwindVersion === void 0 && (mergedTailwindOptions.version === 4 || isTailwindcss4Package(configuredPackageName ?? mergedTailwindOptions.packageName) || hasExplicitV4Signals)) && !Boolean(configuredPackageName);
+	const packageCandidates = /* @__PURE__ */ new Set();
+	if (shouldPatchV4PostcssPackage) packageCandidates.add("@tailwindcss/postcss");
+	packageCandidates.add(mergedTailwindOptions.packageName ?? configuredPackageName ?? "tailwindcss");
+	const patchers = [];
+	const packageCandidateList = [...packageCandidates];
+	let firstVersionMismatchError;
+	for (const packageName of packageCandidateList) {
+		const tailwindOptionsForPackage = {
+			...mergedTailwindOptions,
+			packageName
+		};
+		try {
+			patchers.push(createTailwindcssPatcher({
+				basedir: baseDir,
+				supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
+				tailwindcss: tailwindOptionsForPackage,
+				tailwindcssPatcherOptions: patchedOptions
+			}));
+		} catch (error) {
+			if (packageCandidateList.length > 1 && isTailwindVersionMismatchError(error)) {
+				firstVersionMismatchError ?? (firstVersionMismatchError = error);
+				_weapp_tailwindcss_logger.logger.warn("skip incompatible Tailwind package candidate \"%s\" for v4 patcher: %s", packageName, error.message);
+				continue;
+			}
+			throw error;
+		}
+	}
+	if (patchers.length === 0 && firstVersionMismatchError) throw firstVersionMismatchError;
+	return patchers.length === 1 ? patchers[0] : createMultiTailwindcssPatcher(patchers);
+}
+function tryCreateMultiTailwindcssPatcher(groups, options) {
+	if (groups.size <= 1) return;
+	_weapp_tailwindcss_logger.logger.debug("detected multiple Tailwind CSS entry bases: %O", [...groups.keys()]);
+	const patchers = [];
+	for (const [baseDir, entries] of groups) patchers.push(createPatcherForBase(baseDir, entries, options));
+	return createMultiTailwindcssPatcher(patchers);
+}
+//#endregion
+//#region src/uni-app-x/options.ts
+function resolveComponentLocalStyles(option) {
+	if (option === false) return {
+		enabled: false,
+		onlyWhenStyleIsolationVersion2: true
+	};
+	if (option === true || option === void 0) return {
+		enabled: false,
+		onlyWhenStyleIsolationVersion2: true
+	};
+	const componentLocalStyles = option.componentLocalStyles;
+	if (componentLocalStyles === false) return {
+		enabled: false,
+		onlyWhenStyleIsolationVersion2: true
+	};
+	if (componentLocalStyles === true || componentLocalStyles === void 0) return {
+		enabled: true,
+		onlyWhenStyleIsolationVersion2: true
+	};
+	return {
+		enabled: componentLocalStyles.enabled !== false,
+		onlyWhenStyleIsolationVersion2: componentLocalStyles.onlyWhenStyleIsolationVersion2 !== false
+	};
+}
+function resolveUniAppXOptions(option) {
+	if (typeof option === "object" && option) return {
+		enabled: option.enabled !== false,
+		componentLocalStyles: resolveComponentLocalStyles(option),
+		uvueUnsupported: option.uvueUnsupported ?? "warn"
+	};
+	return {
+		enabled: Boolean(option),
+		componentLocalStyles: resolveComponentLocalStyles(option),
+		uvueUnsupported: "warn"
+	};
+}
+function isUniAppXEnabled(option) {
+	return resolveUniAppXOptions(option).enabled;
+}
+//#endregion
+//#region src/context/tailwindcss/basedir.ts
+const ENV_BASEDIR_KEYS = [
+	"WEAPP_TAILWINDCSS_BASEDIR",
+	"WEAPP_TAILWINDCSS_BASE_DIR",
+	"TAILWINDCSS_BASEDIR",
+	"TAILWINDCSS_BASE_DIR",
+	"UNI_INPUT_DIR",
+	"UNI_INPUT_ROOT",
+	"UNI_CLI_ROOT",
+	"UNI_APP_INPUT_DIR",
+	"INIT_CWD",
+	"PWD"
+];
+const GENERIC_ENV_BASEDIR_KEYS = new Set(["INIT_CWD", "PWD"]);
+function pickEnvBasedir() {
+	for (const key of ENV_BASEDIR_KEYS) {
+		const value = node_process.default.env[key];
+		if (value && node_path.default.isAbsolute(value)) return {
+			key,
+			value
+		};
+	}
+}
+function pickPackageEnvBasedir() {
+	const packageJsonPath = node_process.default.env.npm_package_json;
+	if (packageJsonPath) {
+		const packageDir = node_path.default.dirname(packageJsonPath);
+		if (packageDir && node_path.default.isAbsolute(packageDir)) return packageDir;
+	}
+	const localPrefix = node_process.default.env.npm_config_local_prefix;
+	if (localPrefix && node_path.default.isAbsolute(localPrefix)) return localPrefix;
+}
+const STACK_PAREN_RE = /\(([^)]+)\)/u;
+const STACK_AT_RE = /at\s+(\S.*)$/u;
+function detectCallerBasedir() {
+	const stack = (/* @__PURE__ */ new Error("resolveTailwindcssBasedir stack probe")).stack;
+	if (!stack) return;
+	if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("caller stack: %s", stack);
+	const lines = stack.split("\n");
+	for (const line of lines) {
+		const location = (line.match(STACK_PAREN_RE) ?? line.match(STACK_AT_RE))?.[1];
+		if (!location) continue;
+		let filePath = location;
+		if (filePath.startsWith("file://")) try {
+			filePath = (0, node_url.fileURLToPath)(filePath);
+		} catch {
+			continue;
+		}
+		const [candidate] = filePath.split(":");
+		const resolvedPath = node_path.default.isAbsolute(filePath) ? filePath : candidate;
+		if (!node_path.default.isAbsolute(resolvedPath)) continue;
+		if (resolvedPath.includes("node_modules") && resolvedPath.includes("weapp-tailwindcss")) continue;
+		try {
+			return node_path.default.dirname(resolvedPath);
+		} catch {
+			continue;
+		}
+	}
+}
+function resolveTailwindcssBasedir(basedir, fallback) {
+	const envBasedirResult = pickEnvBasedir();
+	const envBasedir = envBasedirResult?.value;
+	const envBasedirKey = envBasedirResult?.key;
+	const envBasedirIsGeneric = envBasedirKey ? GENERIC_ENV_BASEDIR_KEYS.has(envBasedirKey) : false;
+	const packageEnvBasedir = pickPackageEnvBasedir();
+	const callerBasedir = !envBasedir || envBasedirIsGeneric ? detectCallerBasedir() : void 0;
+	const cwd = node_process.default.cwd();
+	const anchor = envBasedir ?? packageEnvBasedir ?? fallback ?? callerBasedir ?? cwd;
+	const resolveRelative = (value) => node_path.default.isAbsolute(value) ? node_path.default.normalize(value) : node_path.default.normalize(node_path.default.resolve(anchor, value));
+	if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("resolveTailwindcssBasedir anchor %O", {
+		basedir,
+		envBasedir,
+		envBasedirKey,
+		envBasedirIsGeneric,
+		packageEnvBasedir,
+		fallback,
+		callerBasedir,
+		npm_package_json: node_process.default.env.npm_package_json,
+		cwd,
+		anchor
+	});
+	if (basedir && basedir.trim().length > 0) return resolveRelative(basedir);
+	if (envBasedir && !envBasedirIsGeneric) return node_path.default.normalize(envBasedir);
+	if (fallback && fallback.trim().length > 0) return resolveRelative(fallback);
+	if (packageEnvBasedir) return node_path.default.normalize(packageEnvBasedir);
+	if (callerBasedir) {
+		const normalizedCaller = node_path.default.normalize(callerBasedir);
+		const librarySegment = `${node_path.default.sep}weapp-tailwindcss${node_path.default.sep}`;
+		if (!normalizedCaller.includes(librarySegment)) return normalizedCaller;
+	}
+	const packageName = node_process.default.env.PNPM_PACKAGE_NAME;
+	if (packageName) try {
+		const packageJsonPath = (0, node_module.createRequire)(node_path.default.join(anchor, "__resolve_tailwindcss_basedir__.cjs")).resolve(`${packageName}/package.json`);
+		if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("package basedir resolved from PNPM_PACKAGE_NAME: %s", packageJsonPath);
+		return node_path.default.normalize(node_path.default.dirname(packageJsonPath));
+	} catch {
+		if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("failed to resolve package json for %s", packageName);
+		const workspaceRoot = findWorkspaceRoot(anchor);
+		if (workspaceRoot) {
+			const packageDir = findWorkspacePackageDir(workspaceRoot, packageName);
+			if (packageDir) return packageDir;
+		}
+	}
+	if (envBasedir) return node_path.default.normalize(envBasedir);
+	return node_path.default.normalize(cwd);
+}
+//#endregion
+//#region src/context/tailwindcss/rax.ts
+function isRaxWorkspace(appType, baseDir) {
+	if (appType === "rax") return true;
+	try {
+		const pkgPath = node_path.default.join(baseDir, "package.json");
+		if (!(0, node_fs.existsSync)(pkgPath)) return false;
+		const pkg = JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf8"));
+		const deps = {
+			...pkg.dependencies ?? {},
+			...pkg.devDependencies ?? {}
+		};
+		if (deps["rax-app"] || deps.rax) return true;
+	} catch {
+		return false;
+	}
+	return false;
+}
+function collectRaxStyleEntries(baseDir) {
+	const STYLE_CANDIDATES = [
+		"src/global.css",
+		"src/global.scss",
+		"src/global.less",
+		"src/global.sass",
+		"src/global.styl",
+		"src/global.stylus"
+	];
+	const discovered = [];
+	for (const relative of STYLE_CANDIDATES) {
+		const candidate = node_path.default.resolve(baseDir, relative);
+		if ((0, node_fs.existsSync)(candidate)) discovered.push(node_path.default.normalize(candidate));
+	}
+	return discovered;
+}
+function detectImplicitCssEntries(appType, baseDir) {
+	const baseCandidates = /* @__PURE__ */ new Set();
+	baseCandidates.add(node_path.default.normalize(baseDir));
+	const envCandidates = [
+		node_process.default.cwd(),
+		node_process.default.env.INIT_CWD,
+		node_process.default.env.PWD
+	];
+	for (const candidate of envCandidates) if (candidate) baseCandidates.add(node_path.default.normalize(candidate));
+	for (const candidateBase of baseCandidates) {
+		if (!isRaxWorkspace(appType, candidateBase)) continue;
+		const entries = collectRaxStyleEntries(candidateBase);
+		if (entries.length) return entries;
+	}
+}
+//#endregion
+//#region src/context/tailwindcss.ts
+function createTailwindcssPatcherFromContext(ctx) {
+	const { tailwindcssBasedir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions, cssEntries: rawCssEntries, appType } = ctx;
+	const absoluteCssEntryBasedir = guessBasedirFromEntries(rawCssEntries);
+	const resolvedTailwindcssBasedir = resolveTailwindcssBasedir(tailwindcssBasedir, absoluteCssEntryBasedir);
+	ctx.tailwindcssBasedir = resolvedTailwindcssBasedir;
+	_weapp_tailwindcss_logger.logger.debug("tailwindcss basedir resolved: %s", resolvedTailwindcssBasedir);
+	let normalizedCssEntries = normalizeCssEntries(rawCssEntries, resolvedTailwindcssBasedir);
+	if (!normalizedCssEntries) normalizedCssEntries = detectImplicitCssEntries(ctx.appType, resolvedTailwindcssBasedir);
+	if (normalizedCssEntries) ctx.cssEntries = normalizedCssEntries;
+	const patcherOptions = {
+		tailwindcss,
+		tailwindcssPatcherOptions,
+		supportCustomLengthUnitsPatch,
+		appType
+	};
+	const workspaceRoot = findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
+	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, {
+		preferredBaseDir: resolvedTailwindcssBasedir,
+		workspaceRoot
+	}) : void 0;
+	const multiPatcher = groupedCssEntries ? tryCreateMultiTailwindcssPatcher(groupedCssEntries, patcherOptions) : void 0;
+	if (multiPatcher) return multiPatcher;
+	if (groupedCssEntries?.size === 1) {
+		const firstGroup = groupedCssEntries.entries().next().value;
+		if (firstGroup) {
+			const [baseDir, entries] = firstGroup;
+			return createPatcherForBase(baseDir, entries, patcherOptions);
+		}
+	}
+	return createPatcherForBase(resolvedTailwindcssBasedir, normalizedCssEntries ?? rawCssEntries, patcherOptions);
+}
+//#endregion
+Object.defineProperty(exports, "applyV4CssCalcDefaults", {
+	enumerable: true,
+	get: function() {
+		return applyV4CssCalcDefaults;
+	}
+});
+Object.defineProperty(exports, "createTailwindcssPatcherFromContext", {
+	enumerable: true,
+	get: function() {
+		return createTailwindcssPatcherFromContext;
+	}
+});
+Object.defineProperty(exports, "findNearestPackageRoot", {
+	enumerable: true,
+	get: function() {
+		return findNearestPackageRoot;
+	}
+});
+Object.defineProperty(exports, "findTailwindConfig", {
+	enumerable: true,
+	get: function() {
+		return findTailwindConfig;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetCacheEntry", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetCacheEntry;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetSignature", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetSignature;
+	}
+});
+Object.defineProperty(exports, "invalidateRuntimeClassSet", {
+	enumerable: true,
+	get: function() {
+		return invalidateRuntimeClassSet;
+	}
+});
+Object.defineProperty(exports, "isUniAppXEnabled", {
+	enumerable: true,
+	get: function() {
+		return isUniAppXEnabled;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindcssBasedir", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindcssBasedir;
+	}
+});
+Object.defineProperty(exports, "resolveUniAppXOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveUniAppXOptions;
+	}
+});
+Object.defineProperty(exports, "warnMissingCssEntries", {
+	enumerable: true,
+	get: function() {
+		return warnMissingCssEntries;
+	}
+});