weapp-tailwindcss 5.0.0-next.9 → 5.0.1

package/dist/tailwindcss/runtime.d.ts

@@ -2,26 +2,26 @@ import type { RefreshTailwindcssPatcherOptions, TailwindcssPatcherLike } from '.
 import { invalidateRuntimeClassSet } from './runtime/cache';
 export declare const refreshTailwindcssPatcherSymbol: unique symbol;
 export interface CollectRuntimeClassSetOptions {
-    force?: boolean;
-    skipRefresh?: boolean;
-    clearCache?: boolean;
+    force?: boolean | undefined;
+    skipRefresh?: boolean | undefined;
+    clearCache?: boolean | undefined;
 }
 export interface RefreshTailwindRuntimeStateOptions {
     force: boolean;
-    clearCache?: boolean;
+    clearCache?: boolean | undefined;
 }
 export declare function createTailwindRuntimeReadyPromise(twPatcher: TailwindcssPatcherLike): Promise<void>;
 export interface TailwindRuntimeState {
     twPatcher: TailwindcssPatcherLike;
     readyPromise: Promise<void>;
-    refreshTailwindcssPatcher?: (options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>;
+    refreshTailwindcssPatcher?: ((options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>) | undefined;
 }
 export declare function refreshTailwindRuntimeState(state: TailwindRuntimeState, forceOrOptions: boolean | RefreshTailwindRuntimeStateOptions): Promise<boolean>;
 export interface EnsureRuntimeClassSetOptions {
-    forceRefresh?: boolean;
-    forceCollect?: boolean;
-    clearCache?: boolean;
-    allowEmpty?: boolean;
+    forceRefresh?: boolean | undefined;
+    forceCollect?: boolean | undefined;
+    clearCache?: boolean | undefined;
+    allowEmpty?: boolean | undefined;
 }
 export declare function ensureRuntimeClassSet(state: TailwindRuntimeState, options?: EnsureRuntimeClassSetOptions): Promise<Set<string>>;
 declare function collectRuntimeClassSet(twPatcher: TailwindcssPatcherLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;

package/dist/tailwindcss/source-scan.d.ts

@@ -0,0 +1,35 @@
+import type { Root } from 'postcss';
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
+export interface TailwindSourceEntry {
+    base: string;
+    pattern: string;
+    negated: boolean;
+}
+export interface TailwindInlineSourceCandidates {
+    included: Set<string>;
+    excluded: Set<string>;
+}
+export declare const DEFAULT_SOURCE_SCAN_EXTENSIONS: string[];
+export declare const FULL_SOURCE_SCAN_EXTENSIONS: string[];
+export declare function createSourceScanPattern(extensions?: string[]): string;
+export declare const FULL_SOURCE_SCAN_PATTERN: string;
+export declare const FULL_SOURCE_SCAN_EXTENSION_RE: RegExp;
+export declare function toPosixPath(value: string): string;
+export declare function resolveSourceScanPath(value: string): string;
+export declare function isFileExcludedByTailwindSourceEntries(file: string, entries: TailwindSourceEntry[] | undefined): boolean;
+export declare function isFileMatchedByTailwindSourceEntries(file: string, entries: TailwindSourceEntry[] | undefined): boolean;
+export declare function createTailwindSourceEntryMatcher(entries: TailwindSourceEntry[] | undefined): ((file: string) => boolean) | undefined;
+export declare function resolveTailwindV4CssSourceBase(source: Pick<TailwindV4CssSource, 'base' | 'file'>, fallbackBase: string): string;
+export declare function parseConfigParam(params: string): string | undefined;
+export declare function expandInlineSourceCandidatePattern(pattern: string): string[];
+export declare function collectCssInlineSourceCandidates(root: Root): TailwindInlineSourceCandidates;
+export declare function normalizeLegacyContentEntries(content: unknown, base: string): TailwindSourceEntry[];
+export declare function resolveTailwindSourceEntry(sourcePath: string, base: string, negated: boolean, defaultPattern?: string): Promise<TailwindSourceEntry>;
+export declare function parseSourceFileParam(params: string): {
+    negated: boolean;
+    sourcePath: string;
+} | undefined;
+export declare function resolveCssSourceEntries(root: Root, base: string, defaultPattern?: string): Promise<TailwindSourceEntry[]>;
+export declare function expandTailwindSourceEntries(entries: TailwindSourceEntry[], options?: {
+    ignore?: string[];
+}): Promise<string[]>;

package/dist/tailwindcss/v3-engine/types.d.ts

@@ -1,9 +1,10 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { Config } from 'tailwindcss';
+import type { IArbitraryValues } from '../../types/shared';
 export type TailwindV3GenerateTarget = 'weapp' | 'web' | 'tailwind';
 export interface TailwindV3CandidateSource {
     content: string;
-    extension?: string;
+    extension?: string | undefined;
 }
 export interface TailwindV3SourcePattern {
     base: string;
@@ -11,13 +12,13 @@ export interface TailwindV3SourcePattern {
     negated: boolean;
 }
 export interface TailwindV3SourceOptions {
-    projectRoot?: string;
-    cwd?: string;
-    base?: string;
-    css?: string;
-    config?: string;
-    packageName?: string;
-    postcssPlugin?: string;
+    projectRoot?: string | undefined;
+    cwd?: string | undefined;
+    base?: string | undefined;
+    css?: string | undefined;
+    config?: string | undefined;
+    packageName?: string | undefined;
+    postcssPlugin?: string | undefined;
 }
 export interface TailwindV3ResolvedSource {
     version: 3;
@@ -25,21 +26,25 @@ export interface TailwindV3ResolvedSource {
     cwd: string;
     base: string;
     css: string;
-    config?: string;
-    configObject?: Config;
+    config?: string | undefined;
+    configObject?: Config | undefined;
     dependencies: string[];
     packageName: string;
     postcssPlugin: string;
 }
 export interface TailwindV3GenerateOptions {
-    candidates?: Iterable<string>;
-    sources?: TailwindV3CandidateSource[];
-    target?: TailwindV3GenerateTarget;
-    styleOptions?: Partial<IStyleHandlerOptions>;
+    candidates?: Iterable<string> | undefined;
+    sources?: TailwindV3CandidateSource[] | undefined;
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
+    incrementalCache?: boolean | undefined;
+    target?: TailwindV3GenerateTarget | undefined;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
 }
 export interface TailwindV3GenerateResult {
     css: string;
     rawCss: string;
+    incrementalCss?: string | undefined;
+    incrementalRawCss?: string | undefined;
     classSet: Set<string>;
     rawCandidates: Set<string>;
     dependencies: string[];

package/dist/tailwindcss/v4/css-entries.d.ts

@@ -1,7 +1,7 @@
 export declare function guessBasedirFromEntries(entries?: string[]): string | undefined;
 export declare function normalizeCssEntries(entries: string[] | undefined, anchor: string): string[] | undefined;
 export interface GroupCssEntriesOptions {
-    preferredBaseDir?: string;
-    workspaceRoot?: string;
+    preferredBaseDir?: string | undefined;
+    workspaceRoot?: string | undefined;
 }
 export declare function groupCssEntriesByBase(entries: string[], options?: GroupCssEntriesOptions): Map<string, string[]>;

package/dist/tailwindcss/v4/patcher.d.ts

@@ -11,5 +11,5 @@ export interface TailwindcssPatcherFactoryOptions {
     appType: InternalUserDefinedOptions['appType'];
     bareArbitraryValues?: InternalUserDefinedOptions['arbitraryValues']['bareArbitraryValues'];
 }
-export declare function createPatcherForBase(baseDir: string, cssEntries: string[] | undefined, options: TailwindcssPatcherFactoryOptions): TailwindcssPatcherLike | undefined;
+export declare function createPatcherForBase(baseDir: string, cssEntries: string[] | undefined, options: TailwindcssPatcherFactoryOptions): TailwindcssPatcherLike;
 export declare function tryCreateMultiTailwindcssPatcher(groups: Map<string, string[]>, options: TailwindcssPatcherFactoryOptions): TailwindcssPatcherLike | undefined;

package/dist/tailwindcss/v4-engine/source.d.ts

@@ -1,7 +1,7 @@
-import type { TailwindV4SourceOptions } from './types';
+import type { TailwindV4SourceOptions, TailwindV4SourceOptionsWithSources } from './types';
 import type { TailwindcssPatcherLike } from '../../types';
 import { resolveTailwindV4SourceFromPatchOptions } from 'tailwindcss-patch';
-export declare function resolveTailwindV4SourceOptionsFromPatcher(patcher: TailwindcssPatcherLike): TailwindV4SourceOptions;
+export declare function resolveTailwindV4SourceOptionsFromPatcher(patcher: TailwindcssPatcherLike): TailwindV4SourceOptionsWithSources;
 export declare function resolveTailwindV4Source(options?: TailwindV4SourceOptions): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
 export declare function resolveTailwindV4SourceFromPatcher(patcher: TailwindcssPatcherLike): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
 export { resolveTailwindV4SourceFromPatchOptions };

package/dist/tailwindcss/v4-engine/types.d.ts

@@ -1,15 +1,28 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { TailwindV4Engine as PatchTailwindV4Engine, TailwindV4GenerateOptions as PatchTailwindV4GenerateOptions, TailwindV4GenerateResult as PatchTailwindV4GenerateResult, TailwindV4CandidateSource, TailwindV4DesignSystem, TailwindV4ResolvedSource, TailwindV4SourceOptions } from 'tailwindcss-patch';
 export type TailwindV4GenerateTarget = 'weapp' | 'web' | 'tailwind';
-export interface TailwindV4GenerateOptions extends PatchTailwindV4GenerateOptions {
-    target?: TailwindV4GenerateTarget;
-    styleOptions?: Partial<IStyleHandlerOptions>;
-    tailwindcssV3Compatibility?: boolean;
-    scanSources?: PatchTailwindV4GenerateOptions['scanSources'];
+export interface TailwindV4SourcePattern {
+    base: string;
+    pattern: string;
+    negated: boolean;
+}
+type TailwindV4PatchGenerateOptions = Omit<PatchTailwindV4GenerateOptions, 'target' | 'styleOptions' | 'tailwindcssV3Compatibility' | 'scanSources'>;
+export interface TailwindV4GenerateOptions extends TailwindV4PatchGenerateOptions {
+    incrementalCache?: boolean | undefined;
+    bareArbitraryValues?: PatchTailwindV4GenerateOptions['bareArbitraryValues'] | undefined;
+    target?: TailwindV4GenerateTarget | undefined;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
+    tailwindcssV3Compatibility?: boolean | undefined;
+    scanSources?: PatchTailwindV4GenerateOptions['scanSources'] | undefined;
+}
+export interface TailwindV4SourceOptionsWithSources extends TailwindV4SourceOptions {
+    sources?: TailwindV4SourcePattern[] | undefined;
 }
 export interface TailwindV4GenerateResult extends Omit<PatchTailwindV4GenerateResult, 'css'> {
     css: string;
     rawCss: string;
+    incrementalCss?: string | undefined;
+    incrementalRawCss?: string | undefined;
     target: TailwindV4GenerateTarget;
 }
 export interface TailwindV4Engine extends Omit<PatchTailwindV4Engine, 'generate'> {

package/dist/{tailwindcss-C5IgPlQ0.mjs → tailwindcss-CCZcu0lr.mjs}

@@ -1,10 +1,10 @@
-import { a as createTailwindcssPatcher, d as findWorkspaceRoot, i as runtimeSignaturePatchersSymbol, l as findNearestPackageRoot, o as readInstalledPackageMajorVersion, u as findWorkspacePackageDir } from "./cache-CHs4DXui.mjs";
-import { n as defuOverrideArray } from "./utils-Btw1iOVV.mjs";
+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-DGBhUnjn.mjs";
+import { n as defuOverrideArray } from "./utils-DsaS975I.mjs";
 import { createRequire } from "node:module";
-import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import process from "node:process";
+import path from "node:path";
 import { logger } from "@weapp-tailwindcss/logger";
-import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/tailwindcss/v4/css-sources.ts
 function hasCssEntriesValue(value) {
@@ -23,18 +23,23 @@ 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 && a.base === b.base && normalizeCssSourceFile(a.file) === normalizeCssSourceFile(b.file) && JSON.stringify(normalizeDependencies(a.dependencies)) === JSON.stringify(normalizeDependencies(b.dependencies));
+	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 = {
+	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 ?? []];
@@ -42,6 +47,10 @@ function upsertTailwindV4CssSource(opts, source) {
 	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
@@ -98,14 +107,7 @@ function ensureDefaultsIncluded(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;
+	return normalizeStringListOption(entries);
 }
 function hasConfiguredCssEntries(ctx) {
 	if (normalizeCssEntriesConfig(ctx.cssEntries)) return true;
@@ -132,7 +134,11 @@ function applyV4CssCalcDefaults(cssCalc, patcher) {
 //#endregion
 //#region src/tailwindcss/v4/multi-patcher.ts
 function createMultiTailwindcssPatcher(patchers) {
-	if (patchers.length <= 1) return patchers[0];
+	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;
@@ -163,11 +169,11 @@ function createMultiTailwindcssPatcher(patchers) {
 				}
 				if (result.classSet) for (const className of result.classSet) aggregatedSet.add(className);
 			}
-			return {
+			return omitUndefined({
 				classList: aggregatedList,
 				classSet: aggregatedSet,
 				filename
-			};
+			});
 		}
 	};
 	if (patchers.every((patcher) => typeof patcher.getClassSetSync === "function")) multiPatcher.getClassSetSync = () => {
@@ -259,34 +265,26 @@ function groupCssEntriesByBase(entries, options = {}) {
 }
 //#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 mergedTailwindOptions = defuOverrideArray(tailwindcss ?? {}, {
+	const defaultTailwindcssConfig = {
 		cwd: baseDir,
 		v2: { cwd: baseDir },
 		v3: { cwd: baseDir },
-		v4: hasCssEntries ? { cssEntries } : {
+		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 ?? []
@@ -302,69 +300,48 @@ function createPatcherForBase(baseDir, cssEntries, options) {
 	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 || hasOwnV4Signal(tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwindcss);
-	const packageNameForVersionDetection = configuredPackageName ?? mergedTailwindOptions.packageName ?? "tailwindcss";
-	const installedTailwindVersion = readInstalledPackageMajorVersion(packageNameForVersionDetection, baseDir);
-	const resolvedTailwindVersion = installedTailwindVersion ?? explicitTailwindVersion;
-	const shouldPatchV4PostcssPackage = (resolvedTailwindVersion === 4 && (installedTailwindVersion === 4 || explicitTailwindVersion === 4 || hasExplicitV4Signals && isTailwindcss4Package(packageNameForVersionDetection)) || resolvedTailwindVersion === void 0 && (hasCssEntries || 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 (resolvedTailwindVersion) tailwindOptionsForPackage.version = resolvedTailwindVersion;
-		try {
-			patchers.push(createTailwindcssPatcher({
-				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;
-	return patchers.length === 1 ? patchers[0] : createMultiTailwindcssPatcher(patchers);
+	const resolvedTailwindVersion = readInstalledPackageMajorVersion(configuredPackageName ?? mergedTailwindOptions.packageName ?? "tailwindcss", baseDir) ?? explicitTailwindVersion;
+	const supportedResolvedTailwindVersion = resolvedTailwindVersion === 2 || resolvedTailwindVersion === 3 || resolvedTailwindVersion === 4 ? resolvedTailwindVersion : void 0;
+	const tailwindOptionsForPackage = {
+		...mergedTailwindOptions,
+		packageName: mergedTailwindOptions.packageName ?? configuredPackageName ?? "tailwindcss"
+	};
+	if (supportedResolvedTailwindVersion) tailwindOptionsForPackage.version = supportedResolvedTailwindVersion;
+	return createTailwindcssPatcher(omitUndefined({
+		basedir: baseDir,
+		supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
+		tailwindcss: tailwindOptionsForPackage,
+		tailwindcssPatcherOptions: patchedOptions
+	}));
 }
 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) patchers.push(createPatcherForBase(baseDir, entries, options));
+	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 (option === false) return {
-		enabled: false,
-		onlyWhenStyleIsolationVersion2: true
-	};
-	if (option === true || option === void 0) return {
-		enabled: false,
-		onlyWhenStyleIsolationVersion2: true
-	};
+	if (isBooleanUniAppXShortcut(option)) return DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS;
 	const componentLocalStyles = option.componentLocalStyles;
-	if (componentLocalStyles === false) return {
-		enabled: false,
-		onlyWhenStyleIsolationVersion2: true
-	};
-	if (componentLocalStyles === true || componentLocalStyles === void 0) return {
-		enabled: true,
-		onlyWhenStyleIsolationVersion2: true
-	};
+	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
@@ -410,12 +387,12 @@ function pickEnvBasedir() {
 	}
 }
 function pickPackageEnvBasedir() {
-	const packageJsonPath = process.env.npm_package_json;
+	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;
+	const localPrefix = process.env["npm_config_local_prefix"];
 	if (localPrefix && path.isAbsolute(localPrefix)) return localPrefix;
 }
 const STACK_PAREN_RE = /\(([^)]+)\)/u;
@@ -423,7 +400,7 @@ 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);
+	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];
@@ -434,7 +411,7 @@ function detectCallerBasedir() {
 		} catch {
 			continue;
 		}
-		const [candidate] = filePath.split(":");
+		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;
@@ -455,7 +432,7 @@ function resolveTailwindcssBasedir(basedir, fallback) {
 	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", {
+	if (process.env["WEAPP_TW_DEBUG_STACK"] === "1") logger.debug("resolveTailwindcssBasedir anchor %O", {
 		basedir,
 		envBasedir,
 		envBasedirKey,
@@ -463,7 +440,7 @@ function resolveTailwindcssBasedir(basedir, fallback) {
 		packageEnvBasedir,
 		fallback,
 		callerBasedir,
-		npm_package_json: process.env.npm_package_json,
+		npm_package_json: process.env["npm_package_json"],
 		cwd,
 		anchor
 	});
@@ -476,13 +453,13 @@ function resolveTailwindcssBasedir(basedir, fallback) {
 		const librarySegment = `${path.sep}weapp-tailwindcss${path.sep}`;
 		if (!normalizedCaller.includes(librarySegment)) return normalizedCaller;
 	}
-	const packageName = process.env.PNPM_PACKAGE_NAME;
+	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);
+		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);
+		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);
@@ -501,8 +478,8 @@ function isRaxWorkspace(appType, baseDir) {
 		if (!existsSync(pkgPath)) return false;
 		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
 		const deps = {
-			...pkg.dependencies ?? {},
-			...pkg.devDependencies ?? {}
+			...pkg["dependencies"] ?? {},
+			...pkg["devDependencies"] ?? {}
 		};
 		if (deps["rax-app"] || deps.rax) return true;
 	} catch {
@@ -531,8 +508,8 @@ function detectImplicitCssEntries(appType, baseDir) {
 	baseCandidates.add(path.normalize(baseDir));
 	const envCandidates = [
 		process.cwd(),
-		process.env.INIT_CWD,
-		process.env.PWD
+		process.env["INIT_CWD"],
+		process.env["PWD"]
 	];
 	for (const candidate of envCandidates) if (candidate) baseCandidates.add(path.normalize(candidate));
 	for (const candidateBase of baseCandidates) {
@@ -560,10 +537,10 @@ function createTailwindcssPatcherFromContext(ctx) {
 		bareArbitraryValues: arbitraryValues?.bareArbitraryValues
 	};
 	const workspaceRoot = findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
-	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, {
+	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, omitUndefined({
 		preferredBaseDir: resolvedTailwindcssBasedir,
 		workspaceRoot
-	}) : void 0;
+	})) : void 0;
 	const multiPatcher = groupedCssEntries ? tryCreateMultiTailwindcssPatcher(groupedCssEntries, patcherOptions) : void 0;
 	if (multiPatcher) return multiPatcher;
 	if (groupedCssEntries?.size === 1) {