weapp-tailwindcss 5.0.0-next.3 → 5.0.0-next.31

package/dist/tailwindcss-C7dJHZ0G.mjs

@@ -0,0 +1,591 @@
+import { G as normalizeStringListOption, H as readInstalledPackageMajorVersion, J as findNearestPackageRoot, V as createTailwindcssPatcher, X as findWorkspaceRoot, Y as findWorkspacePackageDir, f as runtimeSignaturePatchersSymbol, q as omitUndefined } from "./v3-engine-DcvCCHfs.mjs";
+import { n as defuOverrideArray } from "./utils-DsaS975I.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { logger } from "@weapp-tailwindcss/logger";
+import { fileURLToPath } from "node:url";
+//#region src/tailwindcss/v4/css-sources.ts
+function hasCssEntriesValue(value) {
+	if (typeof value === "string") return value.trim().length > 0;
+	return Array.isArray(value) && value.some((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function hasCssSourcesValue(value) {
+	return Array.isArray(value) && value.some((source) => {
+		return typeof source === "object" && source !== null && typeof source.css === "string" && source.css.trim().length > 0;
+	});
+}
+function hasConfiguredTailwindV4CssRoots(options) {
+	return hasCssEntriesValue(options.cssEntries) || hasCssEntriesValue(options.tailwindcss?.v4?.cssEntries) || hasCssEntriesValue(options.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssEntries) || hasCssSourcesValue(options.tailwindcss?.v4?.cssSources) || hasCssSourcesValue(options.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssSources);
+}
+function normalizeCssSourceFile(file) {
+	if (!file) return;
+	return path.isAbsolute(file) ? path.normalize(file) : file;
+}
+function normalizeCssSourceBase(base) {
+	if (!base) return;
+	return path.resolve(base);
+}
+function normalizeDependencies(dependencies) {
+	return dependencies?.map(normalizeCssSourceFile).filter((dependency) => typeof dependency === "string" && dependency.length > 0);
+}
+function isSameCssSource(a, b) {
+	return a.css === b.css && normalizeCssSourceBase(a.base) === normalizeCssSourceBase(b.base) && normalizeCssSourceFile(a.file) === normalizeCssSourceFile(b.file) && JSON.stringify(normalizeDependencies(a.dependencies)) === JSON.stringify(normalizeDependencies(b.dependencies));
+}
+function upsertTailwindV4CssSource(opts, source) {
+	const normalizedSource = omitUndefined({
+		...source,
+		...source.base === void 0 ? {} : { base: normalizeCssSourceBase(source.base) },
+		...source.file === void 0 ? {} : { file: normalizeCssSourceFile(source.file) },
+		...source.dependencies === void 0 ? {} : { dependencies: normalizeDependencies(source.dependencies) }
+	});
+	const tailwindcss = opts.tailwindcss ?? {};
+	const v4 = tailwindcss.v4 ?? {};
+	const cssSources = [...v4.cssSources ?? []];
+	const sourceFile = normalizeCssSourceFile(normalizedSource.file);
+	const existingIndex = cssSources.findIndex((candidate) => normalizeCssSourceFile(candidate.file) === sourceFile);
+	if (existingIndex >= 0) {
+		const existing = cssSources[existingIndex];
+		if (!existing) {
+			cssSources[existingIndex] = normalizedSource;
+			return true;
+		}
+		const nextSource = {
+			...existing,
+			...normalizedSource
+		};
+		if (isSameCssSource(existing, nextSource)) return false;
+		cssSources[existingIndex] = nextSource;
+	} else cssSources.push(normalizedSource);
+	opts.tailwindcss = {
+		...tailwindcss,
+		v4: {
+			...v4,
+			cssSources
+		}
+	};
+	return true;
+}
+//#endregion
+//#region src/tailwindcss/v4/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) {
+	return normalizeStringListOption(entries);
+}
+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;
+	}
+	return false;
+}
+let hasWarnedMissingCssEntries = false;
+function warnMissingCssEntries(ctx, patcher) {
+	if (hasWarnedMissingCssEntries) return;
+	if (patcher?.majorVersion !== 4) return;
+	if (hasConfiguredCssEntries(ctx) || hasConfiguredTailwindV4CssRoots(ctx)) return;
+	hasWarnedMissingCssEntries = true;
+	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/v4/multi-patcher.ts
+function createMultiTailwindcssPatcher(patchers) {
+	if (patchers.length <= 1) {
+		const [patcher] = patchers;
+		if (!patcher) throw new Error("createMultiTailwindcssPatcher requires at least one patcher.");
+		return patcher;
+	}
+	const first = patchers[0];
+	const firstWithoutPatch = { ...first };
+	delete firstWithoutPatch.patch;
+	const multiPatcher = {
+		...firstWithoutPatch,
+		packageInfo: first?.packageInfo,
+		majorVersion: first?.majorVersion,
+		options: first?.options,
+		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 omitUndefined({
+				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 overrideTailwindcssPatcherOptionsForBase(options, baseDir, cssEntries) {
+	const hasCssEntries = cssEntries.length > 0;
+	if (!options) return options;
+	const modernTailwind = options.tailwindcss;
+	if (!modernTailwind) return options;
+	return {
+		...options,
+		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 || !path.isAbsolute(trimmed)) continue;
+		const entryDir = path.dirname(trimmed);
+		const resolved = findNearestPackageRoot(entryDir) ?? entryDir;
+		if (resolved) return resolved;
+	}
+}
+function normalizeCssEntries(entries, anchor) {
+	if (!entries || entries.length === 0) return;
+	const normalized = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (typeof entry !== "string") continue;
+		const trimmed = entry.trim();
+		if (trimmed.length === 0) continue;
+		const resolved = path.isAbsolute(trimmed) ? path.normalize(trimmed) : path.normalize(path.resolve(anchor, trimmed));
+		normalized.add(resolved);
+	}
+	return normalized.size > 0 ? [...normalized] : void 0;
+}
+function isSubPath(parent, child) {
+	if (!parent || !child) return false;
+	const relative = path.relative(parent, child);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function resolveCssEntryBase(entryDir, options) {
+	const normalizedDir = path.normalize(entryDir);
+	const { preferredBaseDir, workspaceRoot } = options;
+	if (preferredBaseDir && isSubPath(preferredBaseDir, normalizedDir)) return preferredBaseDir;
+	if (workspaceRoot && isSubPath(workspaceRoot, normalizedDir)) return workspaceRoot;
+	const packageRoot = findNearestPackageRoot(normalizedDir);
+	if (packageRoot) return path.normalize(packageRoot);
+	return normalizedDir;
+}
+function groupCssEntriesByBase(entries, options = {}) {
+	const normalizedOptions = {
+		preferredBaseDir: options.preferredBaseDir ? path.normalize(options.preferredBaseDir) : void 0,
+		workspaceRoot: options.workspaceRoot ? path.normalize(options.workspaceRoot) : void 0
+	};
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const baseDir = resolveCssEntryBase(path.dirname(entry), normalizedOptions);
+		const bucket = groups.get(baseDir);
+		if (bucket) bucket.push(entry);
+		else groups.set(baseDir, [entry]);
+	}
+	return groups;
+}
+//#endregion
+//#region src/tailwindcss/v4/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, bareArbitraryValues } = options;
+	const hasCssEntries = Boolean(cssEntries?.length);
+	const configuredV4Options = tailwindcss?.v4 ?? tailwindcssPatcherOptions?.tailwindcss?.v4;
+	const hasCssSources = Boolean(configuredV4Options?.cssSources?.length);
+	const defaultTailwindcssConfig = {
+		cwd: baseDir,
+		v2: { cwd: baseDir },
+		v3: { cwd: baseDir },
+		v4: hasCssEntries ? omitUndefined({ cssEntries }) : omitUndefined({
+			base: baseDir,
+			cssEntries
+		})
+	};
+	const mergedTailwindOptions = defuOverrideArray(tailwindcss ?? {}, defaultTailwindcssConfig);
+	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 ?? [];
+	}
+	if (bareArbitraryValues !== void 0 && bareArbitraryValues !== false) mergedTailwindOptions.v4.bareArbitraryValues = bareArbitraryValues;
+	const patchedOptions = overrideTailwindcssPatcherOptionsForBase(tailwindcssPatcherOptions, baseDir, cssEntries ?? []);
+	const configuredPackageName = tailwindcss?.packageName || tailwindcssPatcherOptions?.tailwindcss?.packageName;
+	const explicitTailwindVersion = resolveExplicitTailwindVersion(tailwindcss?.version || tailwindcssPatcherOptions?.tailwindcss?.version || mergedTailwindOptions.version, configuredPackageName);
+	const hasExplicitV4Signals = hasCssEntries || hasCssSources || hasOwnV4Signal(tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwindcss);
+	const packageNameForVersionDetection = configuredPackageName ?? mergedTailwindOptions.packageName ?? "tailwindcss";
+	const installedTailwindVersion = readInstalledPackageMajorVersion(packageNameForVersionDetection, baseDir);
+	const resolvedTailwindVersion = installedTailwindVersion ?? explicitTailwindVersion;
+	const supportedResolvedTailwindVersion = resolvedTailwindVersion === 2 || resolvedTailwindVersion === 3 || resolvedTailwindVersion === 4 ? resolvedTailwindVersion : void 0;
+	const shouldPatchV4PostcssPackage = (resolvedTailwindVersion === 4 && (installedTailwindVersion === 4 || explicitTailwindVersion === 4 || hasExplicitV4Signals && isTailwindcss4Package(packageNameForVersionDetection)) || resolvedTailwindVersion === void 0 && (hasCssEntries || hasCssSources || hasOwnV4Signal(tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwindcss))) && !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
+		};
+		if (supportedResolvedTailwindVersion) tailwindOptionsForPackage.version = supportedResolvedTailwindVersion;
+		try {
+			patchers.push(createTailwindcssPatcher(omitUndefined({
+				basedir: baseDir,
+				supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
+				tailwindcss: tailwindOptionsForPackage,
+				tailwindcssPatcherOptions: patchedOptions
+			})));
+		} catch (error) {
+			if (packageCandidateList.length > 1 && isTailwindVersionMismatchError(error)) {
+				firstVersionMismatchError ?? (firstVersionMismatchError = error);
+				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;
+	const [singlePatcher] = patchers;
+	return patchers.length === 1 && singlePatcher ? singlePatcher : createMultiTailwindcssPatcher(patchers);
+}
+function tryCreateMultiTailwindcssPatcher(groups, options) {
+	if (groups.size <= 1) return;
+	logger.debug("detected multiple Tailwind CSS entry bases: %O", [...groups.keys()]);
+	const patchers = [];
+	for (const [baseDir, entries] of groups) {
+		const patcher = createPatcherForBase(baseDir, entries, options);
+		if (patcher) patchers.push(patcher);
+	}
+	return createMultiTailwindcssPatcher(patchers);
+}
+//#endregion
+//#region src/uni-app-x/options.ts
+const DEFAULT_COMPONENT_LOCAL_STYLES_OPTIONS = {
+	enabled: true,
+	onlyWhenStyleIsolationVersion2: true
+};
+const DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS = {
+	enabled: false,
+	onlyWhenStyleIsolationVersion2: true
+};
+function isBooleanUniAppXShortcut(option) {
+	return option === true || option === false || option === void 0;
+}
+function resolveComponentLocalStyles(option) {
+	if (isBooleanUniAppXShortcut(option)) return DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS;
+	const componentLocalStyles = option.componentLocalStyles;
+	if (componentLocalStyles === false) return DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS;
+	if (componentLocalStyles === true || componentLocalStyles === void 0) return DEFAULT_COMPONENT_LOCAL_STYLES_OPTIONS;
+	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 = process.env[key];
+		if (value && path.isAbsolute(value)) return {
+			key,
+			value
+		};
+	}
+}
+function pickPackageEnvBasedir() {
+	const packageJsonPath = process.env["npm_package_json"];
+	if (packageJsonPath) {
+		const packageDir = path.dirname(packageJsonPath);
+		if (packageDir && path.isAbsolute(packageDir)) return packageDir;
+	}
+	const localPrefix = process.env["npm_config_local_prefix"];
+	if (localPrefix && path.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 (process.env["WEAPP_TW_DEBUG_STACK"] === "1") 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 = fileURLToPath(filePath);
+		} catch {
+			continue;
+		}
+		const [candidate = ""] = filePath.split(":");
+		const resolvedPath = path.isAbsolute(filePath) ? filePath : candidate;
+		if (!path.isAbsolute(resolvedPath)) continue;
+		if (resolvedPath.includes("node_modules") && resolvedPath.includes("weapp-tailwindcss")) continue;
+		try {
+			return path.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 = process.cwd();
+	const anchor = envBasedir ?? packageEnvBasedir ?? fallback ?? callerBasedir ?? cwd;
+	const resolveRelative = (value) => path.isAbsolute(value) ? path.normalize(value) : path.normalize(path.resolve(anchor, value));
+	if (process.env["WEAPP_TW_DEBUG_STACK"] === "1") logger.debug("resolveTailwindcssBasedir anchor %O", {
+		basedir,
+		envBasedir,
+		envBasedirKey,
+		envBasedirIsGeneric,
+		packageEnvBasedir,
+		fallback,
+		callerBasedir,
+		npm_package_json: process.env["npm_package_json"],
+		cwd,
+		anchor
+	});
+	if (basedir && basedir.trim().length > 0) return resolveRelative(basedir);
+	if (envBasedir && !envBasedirIsGeneric) return path.normalize(envBasedir);
+	if (fallback && fallback.trim().length > 0) return resolveRelative(fallback);
+	if (packageEnvBasedir) return path.normalize(packageEnvBasedir);
+	if (callerBasedir) {
+		const normalizedCaller = path.normalize(callerBasedir);
+		const librarySegment = `${path.sep}weapp-tailwindcss${path.sep}`;
+		if (!normalizedCaller.includes(librarySegment)) return normalizedCaller;
+	}
+	const packageName = process.env["PNPM_PACKAGE_NAME"];
+	if (packageName) try {
+		const packageJsonPath = createRequire(path.join(anchor, "__resolve_tailwindcss_basedir__.cjs")).resolve(`${packageName}/package.json`);
+		if (process.env["WEAPP_TW_DEBUG_STACK"] === "1") logger.debug("package basedir resolved from PNPM_PACKAGE_NAME: %s", packageJsonPath);
+		return path.normalize(path.dirname(packageJsonPath));
+	} catch {
+		if (process.env["WEAPP_TW_DEBUG_STACK"] === "1") 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 path.normalize(envBasedir);
+	return path.normalize(cwd);
+}
+//#endregion
+//#region src/context/tailwindcss/rax.ts
+function isRaxWorkspace(appType, baseDir) {
+	if (appType === "rax") return true;
+	try {
+		const pkgPath = path.join(baseDir, "package.json");
+		if (!existsSync(pkgPath)) return false;
+		const pkg = JSON.parse(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 = path.resolve(baseDir, relative);
+		if (existsSync(candidate)) discovered.push(path.normalize(candidate));
+	}
+	return discovered;
+}
+function detectImplicitCssEntries(appType, baseDir) {
+	const baseCandidates = /* @__PURE__ */ new Set();
+	baseCandidates.add(path.normalize(baseDir));
+	const envCandidates = [
+		process.cwd(),
+		process.env["INIT_CWD"],
+		process.env["PWD"]
+	];
+	for (const candidate of envCandidates) if (candidate) baseCandidates.add(path.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, arbitraryValues } = ctx;
+	const absoluteCssEntryBasedir = guessBasedirFromEntries(rawCssEntries);
+	const resolvedTailwindcssBasedir = resolveTailwindcssBasedir(tailwindcssBasedir, absoluteCssEntryBasedir);
+	ctx.tailwindcssBasedir = resolvedTailwindcssBasedir;
+	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,
+		bareArbitraryValues: arbitraryValues?.bareArbitraryValues
+	};
+	const workspaceRoot = findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
+	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, omitUndefined({
+		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
+export { applyV4CssCalcDefaults as a, upsertTailwindV4CssSource as c, resolveUniAppXOptions as i, resolveTailwindcssBasedir as n, warnMissingCssEntries as o, isUniAppXEnabled as r, hasConfiguredTailwindV4CssRoots as s, createTailwindcssPatcherFromContext as t };

package/dist/typedoc.export.d.ts

@@ -1,5 +1,3 @@
 export type { WeappTailwindcssGenerateOptions, WeappTailwindcssGenerateResult, WeappTailwindcssGenerator, WeappTailwindcssGeneratorTarget, WeappTailwindcssPostcssPluginOptions, } from './index';
-export type { DisabledOptions } from './types/disabled-options';
 export type { UserDefinedOptions } from './types/user-defined-options';
 export type { ApplyOptions, CacheOptions, ExtractOptions, TailwindCssOptions, TailwindCssPatchOptions, TailwindV2Options, TailwindV3Options, TailwindV4Options, } from 'tailwindcss-patch';
-export type TailwindcssPatchOptions = import('tailwindcss-patch').TailwindCssPatchOptions;