weapp-tailwindcss 5.0.0-next.11 → 5.0.0-next.14

package/dist/source-candidates-CK70jGo7.mjs

@@ -0,0 +1,259 @@
+import { j as expandTailwindSourceEntries } from "./v3-engine-D61eilBl.mjs";
+import path from "node:path";
+import { extractSourceCandidates } from "tailwindcss-patch";
+import { readFile } from "node:fs/promises";
+import fg from "fast-glob";
+import micromatch from "micromatch";
+//#region src/bundlers/vite/source-candidates.ts
+const CLEAN_URL_RE = /[?#].*$/;
+const SOURCE_CANDIDATE_EXTENSIONS = [
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts",
+	"vue",
+	"uvue",
+	"nvue",
+	"svelte",
+	"mpx",
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"css",
+	"wxss",
+	"acss",
+	"jxss",
+	"ttss",
+	"qss",
+	"tyss",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+];
+const SOURCE_CANDIDATE_EXTENSION_RE = /\.(?:[cm]?[jt]sx?|vue|uvue|nvue|svelte|mpx|html|wxml|axml|jxml|ksml|ttml|qml|tyml|xhsml|swan|css|wxss|acss|jxss|ttss|qss|tyss|scss|sass|less|stylus?)$/;
+const SOURCE_CANDIDATE_GLOB = `**/*.{${SOURCE_CANDIDATE_EXTENSIONS.join(",")}}`;
+const DEFAULT_SCAN_IGNORE = ["**/node_modules/**", "**/.git/**"];
+const sourceCandidateContentCache = /* @__PURE__ */ new Map();
+function cleanUrl(id) {
+	return path.resolve(id.replace(CLEAN_URL_RE, ""));
+}
+function toPosixPath(value) {
+	return value.split(path.sep).join("/");
+}
+function resolveOutDirIgnorePattern(root, outDir) {
+	if (!outDir) return;
+	const relative = path.relative(root, path.resolve(root, outDir));
+	if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return;
+	return `${toPosixPath(relative)}/**`;
+}
+function resolveSourceCandidateExtension(id) {
+	const normalized = cleanUrl(id);
+	return /\.([^.\\/]+)$/.exec(normalized)?.[1] ?? "html";
+}
+function createSourceCandidateContentCacheKey(extension, source) {
+	return `${extension}\0${source}`;
+}
+function isSourceCandidateRequest(id) {
+	return SOURCE_CANDIDATE_EXTENSION_RE.test(cleanUrl(id));
+}
+function removeCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) {
+		const count = candidateCount.get(candidate);
+		if (count == null) continue;
+		if (count <= 1) {
+			candidateCount.delete(candidate);
+			continue;
+		}
+		candidateCount.set(candidate, count - 1);
+	}
+}
+function addCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) candidateCount.set(candidate, (candidateCount.get(candidate) ?? 0) + 1);
+}
+function isFileMatchedByEntries(file, entries) {
+	if (!entries?.length) return true;
+	const positiveEntries = entries.filter((entry) => !entry.negated);
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	if (positiveEntries.length === 0) return false;
+	const resolvedFile = path.resolve(file);
+	if (!positiveEntries.some((entry) => {
+		const relative = toPosixPath(path.relative(path.resolve(entry.base), resolvedFile));
+		const pattern = path.isAbsolute(entry.pattern) ? toPosixPath(path.relative(path.resolve(entry.base), entry.pattern)) : entry.pattern;
+		return relative && !relative.startsWith("../") && !path.isAbsolute(relative) && micromatch.isMatch(relative, pattern);
+	})) return false;
+	return !negativeEntries.some((entry) => {
+		const relative = toPosixPath(path.relative(path.resolve(entry.base), resolvedFile));
+		const pattern = path.isAbsolute(entry.pattern) ? toPosixPath(path.relative(path.resolve(entry.base), entry.pattern)) : entry.pattern;
+		return relative && !relative.startsWith("../") && !path.isAbsolute(relative) && micromatch.isMatch(relative, pattern);
+	});
+}
+function createSourceCandidateCollector() {
+	const candidatesById = /* @__PURE__ */ new Map();
+	const scanCandidatesById = /* @__PURE__ */ new Map();
+	const transformCandidatesById = /* @__PURE__ */ new Map();
+	const candidateCount = /* @__PURE__ */ new Map();
+	let inlineIncludedCandidates = /* @__PURE__ */ new Set();
+	let inlineExcludedCandidates = /* @__PURE__ */ new Set();
+	async function sync(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		if (cachedCandidates) {
+			replaceScanLayer(normalizedId, new Set(cachedCandidates));
+			return;
+		}
+		const nextCandidates = new Set(await extractSourceCandidates(source, extension));
+		sourceCandidateContentCache.set(contentCacheKey, [...nextCandidates]);
+		replaceScanLayer(normalizedId, nextCandidates);
+	}
+	async function merge(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		const extractedCandidates = cachedCandidates ? new Set(cachedCandidates) : new Set(await extractSourceCandidates(source, extension));
+		if (!cachedCandidates) sourceCandidateContentCache.set(contentCacheKey, [...extractedCandidates]);
+		replaceTransformLayer(normalizedId, extractedCandidates);
+	}
+	async function syncFile(id) {
+		const normalizedId = cleanUrl(id);
+		await sync(normalizedId, await readFile(normalizedId, "utf8"));
+	}
+	async function scanRoot({ entries, root, outDir }) {
+		const resolvedRoot = path.resolve(root);
+		const outDirIgnore = resolveOutDirIgnorePattern(resolvedRoot, outDir);
+		const ignore = outDirIgnore ? [...DEFAULT_SCAN_IGNORE, outDirIgnore] : DEFAULT_SCAN_IGNORE;
+		const files = entries ? await expandTailwindSourceEntries(entries, { ignore }) : await fg(SOURCE_CANDIDATE_GLOB, {
+			absolute: true,
+			cwd: resolvedRoot,
+			ignore,
+			onlyFiles: true,
+			unique: true
+		});
+		await Promise.all(files.map((file) => syncFile(file)));
+	}
+	function replaceFinal(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (previousCandidates) {
+			removeCandidateSet(candidateCount, previousCandidates);
+			candidatesById.delete(normalizedId);
+		}
+		if (nextCandidates.size === 0) return;
+		candidatesById.set(normalizedId, nextCandidates);
+		addCandidateSet(candidateCount, nextCandidates);
+	}
+	function replaceScanLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) scanCandidatesById.delete(normalizedId);
+		else scanCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function replaceTransformLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) transformCandidatesById.delete(normalizedId);
+		else transformCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function recompute(id) {
+		const normalizedId = cleanUrl(id);
+		replaceFinal(normalizedId, new Set([...scanCandidatesById.get(normalizedId) ?? [], ...transformCandidatesById.get(normalizedId) ?? []]));
+	}
+	function syncInline(inlineCandidates) {
+		inlineIncludedCandidates = new Set(inlineCandidates?.included ?? []);
+		inlineExcludedCandidates = new Set(inlineCandidates?.excluded ?? []);
+	}
+	function remove(id) {
+		const normalizedId = cleanUrl(id);
+		scanCandidatesById.delete(normalizedId);
+		transformCandidatesById.delete(normalizedId);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (!previousCandidates) return;
+		removeCandidateSet(candidateCount, previousCandidates);
+		candidatesById.delete(normalizedId);
+	}
+	function values() {
+		const values = new Set([...candidateCount.keys(), ...inlineIncludedCandidates]);
+		for (const candidate of inlineExcludedCandidates) values.delete(candidate);
+		return values;
+	}
+	function valuesForEntries(entries) {
+		if (entries === void 0) return values();
+		const filtered = /* @__PURE__ */ new Set();
+		for (const [id, candidates] of candidatesById) {
+			if (!isFileMatchedByEntries(id, entries)) continue;
+			for (const candidate of candidates) filtered.add(candidate);
+		}
+		for (const candidate of inlineIncludedCandidates) filtered.add(candidate);
+		for (const candidate of inlineExcludedCandidates) filtered.delete(candidate);
+		return filtered;
+	}
+	function clear() {
+		candidatesById.clear();
+		scanCandidatesById.clear();
+		transformCandidatesById.clear();
+		candidateCount.clear();
+		inlineIncludedCandidates.clear();
+		inlineExcludedCandidates.clear();
+	}
+	function snapshot() {
+		return {
+			candidatesById: [...candidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			scanCandidatesById: [...scanCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			transformCandidatesById: [...transformCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			inlineExcludedCandidates: [...inlineExcludedCandidates],
+			inlineIncludedCandidates: [...inlineIncludedCandidates]
+		};
+	}
+	function restore(snapshot) {
+		clear();
+		inlineExcludedCandidates = new Set(snapshot.inlineExcludedCandidates);
+		inlineIncludedCandidates = new Set(snapshot.inlineIncludedCandidates);
+		const scanEntries = snapshot.scanCandidatesById ?? snapshot.candidatesById;
+		for (const [id, candidates] of scanEntries) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			scanCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.transformCandidatesById ?? []) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			transformCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.candidatesById) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			candidatesById.set(id, candidateSet);
+			addCandidateSet(candidateCount, candidateSet);
+		}
+	}
+	return {
+		sync,
+		merge,
+		syncFile,
+		scanRoot,
+		syncInline,
+		remove,
+		values,
+		valuesForEntries,
+		snapshot,
+		restore,
+		clear
+	};
+}
+//#endregion
+export { isSourceCandidateRequest as n, createSourceCandidateCollector as t };

package/dist/tailwindcss/runtime/cache.d.ts

@@ -8,4 +8,5 @@ export declare const runtimeSignaturePatchersSymbol: unique symbol;
 export declare function invalidateRuntimeClassSet(twPatcher?: TailwindcssPatcherLike): void;
 export declare function getRuntimeClassSetCacheEntry(twPatcher: TailwindcssPatcherLike): RuntimeClassSetCacheEntry;
 export declare function getRuntimeClassSetSignature(twPatcher: TailwindcssPatcherLike): string;
+export declare function getRuntimeClassSetSignatureWithSources(twPatcher: TailwindcssPatcherLike): Promise<string>;
 export {};

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

@@ -34,12 +34,15 @@ export interface TailwindV3ResolvedSource {
 export interface TailwindV3GenerateOptions {
     candidates?: Iterable<string> | undefined;
     sources?: TailwindV3CandidateSource[] | 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-engine/types.d.ts

@@ -1,8 +1,14 @@
 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 TailwindV4SourcePattern {
+    base: string;
+    pattern: string;
+    negated: boolean;
+}
 type TailwindV4PatchGenerateOptions = Omit<PatchTailwindV4GenerateOptions, 'target' | 'styleOptions' | 'tailwindcssV3Compatibility' | 'scanSources'>;
 export interface TailwindV4GenerateOptions extends TailwindV4PatchGenerateOptions {
+    incrementalCache?: boolean | undefined;
     target?: TailwindV4GenerateTarget | undefined;
     styleOptions?: Partial<IStyleHandlerOptions> | undefined;
     tailwindcssV3Compatibility?: boolean | undefined;
@@ -11,6 +17,8 @@ export interface TailwindV4GenerateOptions extends TailwindV4PatchGenerateOption
 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-DGM8lHUj.mjs → tailwindcss-7k0LFa12.mjs}

@@ -1,10 +1,10 @@
-import { a as createTailwindcssPatcher, d as findWorkspacePackageDir, f as findWorkspaceRoot, i as runtimeSignaturePatchersSymbol, l as omitUndefined, o as readInstalledPackageMajorVersion, u as findNearestPackageRoot } from "./cache-DEDxBMIw.mjs";
+import { B as omitUndefined, H as findWorkspacePackageDir, I as createTailwindcssPatcher, L as readInstalledPackageMajorVersion, U as findWorkspaceRoot, V as findNearestPackageRoot, f as runtimeSignaturePatchersSymbol } from "./v3-engine-D61eilBl.mjs";
 import { n as defuOverrideArray } from "./utils-CGBVVNm6.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 { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/tailwindcss/v4/css-sources.ts
 function hasCssEntriesValue(value) {
@@ -23,15 +23,20 @@ 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 = 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) }
 	});

package/dist/{tailwindcss-B78nj6n7.js → tailwindcss-CN0K7G-l.js}

@@ -1,13 +1,13 @@
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_cache = require("./cache-B_9E7FxF.js");
+const require_v3_engine = require("./v3-engine-DwV1E6rX.js");
 require("./utils-4ODFyoqD.js");
+let node_fs = require("node:fs");
 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 _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
-let node_fs = require("node:fs");
 let node_url = require("node:url");
 let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
 //#region src/tailwindcss/v4/css-sources.ts
@@ -27,15 +27,20 @@ function normalizeCssSourceFile(file) {
 	if (!file) return;
 	return node_path.default.isAbsolute(file) ? node_path.default.normalize(file) : file;
 }
+function normalizeCssSourceBase(base) {
+	if (!base) return;
+	return node_path.default.resolve(base);
+}
 function normalizeDependencies(dependencies) {
 	return dependencies?.map(normalizeCssSourceFile).filter((dependency) => typeof dependency === "string" && dependency.length > 0);
 }
 function isSameCssSource(a, b) {
-	return a.css === b.css && 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 = require_cache.omitUndefined({
+	const normalizedSource = require_v3_engine.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) }
 	});
@@ -175,7 +180,7 @@ function createMultiTailwindcssPatcher(patchers) {
 				}
 				if (result.classSet) for (const className of result.classSet) aggregatedSet.add(className);
 			}
-			return require_cache.omitUndefined({
+			return require_v3_engine.omitUndefined({
 				classList: aggregatedList,
 				classSet: aggregatedSet,
 				filename
@@ -191,7 +196,7 @@ function createMultiTailwindcssPatcher(patchers) {
 		}
 		return aggregated;
 	};
-	Object.defineProperty(multiPatcher, require_cache.runtimeSignaturePatchersSymbol, {
+	Object.defineProperty(multiPatcher, require_v3_engine.runtimeSignaturePatchersSymbol, {
 		value: [...patchers],
 		configurable: true
 	});
@@ -225,7 +230,7 @@ function guessBasedirFromEntries(entries) {
 		const trimmed = entry.trim();
 		if (!trimmed || !node_path.default.isAbsolute(trimmed)) continue;
 		const entryDir = node_path.default.dirname(trimmed);
-		const resolved = require_cache.findNearestPackageRoot(entryDir) ?? entryDir;
+		const resolved = require_v3_engine.findNearestPackageRoot(entryDir) ?? entryDir;
 		if (resolved) return resolved;
 	}
 }
@@ -251,7 +256,7 @@ function resolveCssEntryBase(entryDir, options) {
 	const { preferredBaseDir, workspaceRoot } = options;
 	if (preferredBaseDir && isSubPath(preferredBaseDir, normalizedDir)) return preferredBaseDir;
 	if (workspaceRoot && isSubPath(workspaceRoot, normalizedDir)) return workspaceRoot;
-	const packageRoot = require_cache.findNearestPackageRoot(normalizedDir);
+	const packageRoot = require_v3_engine.findNearestPackageRoot(normalizedDir);
 	if (packageRoot) return node_path.default.normalize(packageRoot);
 	return normalizedDir;
 }
@@ -294,7 +299,7 @@ function createPatcherForBase(baseDir, cssEntries, options) {
 		cwd: baseDir,
 		v2: { cwd: baseDir },
 		v3: { cwd: baseDir },
-		v4: hasCssEntries ? require_cache.omitUndefined({ cssEntries }) : require_cache.omitUndefined({
+		v4: hasCssEntries ? require_v3_engine.omitUndefined({ cssEntries }) : require_v3_engine.omitUndefined({
 			base: baseDir,
 			cssEntries
 		})
@@ -317,7 +322,7 @@ function createPatcherForBase(baseDir, cssEntries, options) {
 	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 = require_cache.readInstalledPackageMajorVersion(packageNameForVersionDetection, baseDir);
+	const installedTailwindVersion = require_v3_engine.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 || hasOwnV4Signal(tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwindcss))) && !Boolean(configuredPackageName);
@@ -334,7 +339,7 @@ function createPatcherForBase(baseDir, cssEntries, options) {
 		};
 		if (supportedResolvedTailwindVersion) tailwindOptionsForPackage.version = supportedResolvedTailwindVersion;
 		try {
-			patchers.push(require_cache.createTailwindcssPatcher(require_cache.omitUndefined({
+			patchers.push(require_v3_engine.createTailwindcssPatcher(require_v3_engine.omitUndefined({
 				basedir: baseDir,
 				supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
 				tailwindcss: tailwindOptionsForPackage,
@@ -501,9 +506,9 @@ function resolveTailwindcssBasedir(basedir, fallback) {
 		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 = require_cache.findWorkspaceRoot(anchor);
+		const workspaceRoot = require_v3_engine.findWorkspaceRoot(anchor);
 		if (workspaceRoot) {
-			const packageDir = require_cache.findWorkspacePackageDir(workspaceRoot, packageName);
+			const packageDir = require_v3_engine.findWorkspacePackageDir(workspaceRoot, packageName);
 			if (packageDir) return packageDir;
 		}
 	}
@@ -577,8 +582,8 @@ function createTailwindcssPatcherFromContext(ctx) {
 		appType,
 		bareArbitraryValues: arbitraryValues?.bareArbitraryValues
 	};
-	const workspaceRoot = require_cache.findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? require_cache.findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
-	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, require_cache.omitUndefined({
+	const workspaceRoot = require_v3_engine.findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? require_v3_engine.findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
+	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, require_v3_engine.omitUndefined({
 		preferredBaseDir: resolvedTailwindcssBasedir,
 		workspaceRoot
 	})) : void 0;

package/dist/types/index.d.ts

@@ -34,6 +34,12 @@ export interface TailwindcssPatcherLike {
     collectContentTokens?: TailwindcssPatcher['collectContentTokens'] | undefined;
     options?: TailwindcssPatcher['options'] | undefined;
 }
+export type BabelParserOptions = ParserOptions & {
+    cache?: boolean | undefined;
+    cacheKey?: string | undefined;
+    cacheMaxEntries?: number | undefined;
+    cacheMaxSourceLength?: number | undefined;
+};
 export interface RefreshTailwindcssPatcherOptions {
     clearCache?: boolean | undefined;
 }
@@ -48,7 +54,7 @@ export interface IJsHandlerOptions {
     generateMap?: boolean | undefined;
     alwaysEscape?: boolean | undefined;
     unescapeUnicode?: boolean | undefined;
-    babelParserOptions?: ParserOptions | undefined;
+    babelParserOptions?: BabelParserOptions | undefined;
     ignoreTaggedTemplateExpressionIdentifiers?: (string | RegExp)[] | undefined;
     ignoreCallExpressionIdentifiers?: (string | RegExp)[] | undefined;
     uniAppX?: boolean | undefined;

package/dist/types/user-defined-options/general.d.ts

@@ -19,6 +19,8 @@ export interface UserDefinedOptionsGeneralPart {
     babelParserOptions?: (ParserOptions & {
         cache?: boolean | undefined;
         cacheKey?: string | undefined;
+        cacheMaxEntries?: number | undefined;
+        cacheMaxSourceLength?: number | undefined;
     }) | undefined;
     cssChildCombinatorReplaceValue?: string | string[] | undefined;
     postcssOptions?: LoadedPostcssOptions | undefined;