weapp-tailwindcss 4.12.0 → 5.0.0-next.2

package/dist/recorder-zsgatmkB.mjs

@@ -0,0 +1,2763 @@
+import { i as isMap, n as defuOverrideArray } from "./utils-7DUGTFED.mjs";
+import { getDefaultOptions } from "./defaults.mjs";
+import { a as resolveUniAppXOptions, c as warnMissingCssEntries, d as getRuntimeClassSetSignature, f as invalidateRuntimeClassSet, i as isUniAppXEnabled, l as findNearestPackageRoot, n as createTailwindcssPatcherFromContext, s as applyV4CssCalcDefaults, t as logger$1, u as getRuntimeClassSetCacheEntry } from "./logger-BoVx1Dbt.mjs";
+import { createStyleHandler } from "@weapp-tailwindcss/postcss";
+import path from "node:path";
+import process from "node:process";
+import { Buffer } from "node:buffer";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { logger, pc } from "@weapp-tailwindcss/logger";
+import { LRUCache } from "lru-cache";
+import { md5 as md5Hash } from "@weapp-tailwindcss/shared/node";
+import { MappingChars2String, escape } from "@weapp-core/escape";
+import _createDebug from "debug";
+import _babelTraverse from "@babel/traverse";
+import { parse, parseExpression } from "@babel/parser";
+import { escapeStringRegexp } from "@weapp-core/regex";
+import MagicString from "magic-string";
+import { jsStringEscape } from "@ast-core/escape";
+import { splitCode } from "@weapp-tailwindcss/shared/extractors";
+import * as t from "@babel/types";
+import { Parser } from "htmlparser2";
+//#region src/cache/index.ts
+function isProcessResult(value) {
+	return typeof value === "object" && value !== null && "result" in value;
+}
+function createCache(options) {
+	const disabled = options === false;
+	const hashMap = /* @__PURE__ */ new Map();
+	const instance = new LRUCache({
+		max: 1024,
+		ttl: 0,
+		ttlAutopurge: false
+	});
+	const cache = {
+		hashMap,
+		instance,
+		hasHashKey(key) {
+			return hashMap.has(key);
+		},
+		getHashValue(key) {
+			return hashMap.get(key);
+		},
+		setHashValue(key, value) {
+			return hashMap.set(key, value);
+		},
+		get(key) {
+			return instance.get(key);
+		},
+		set(key, value) {
+			return instance.set(key, value);
+		},
+		computeHash(message) {
+			return md5Hash(message);
+		},
+		calcHashValueChanged(key, hash) {
+			const hit = hashMap.get(key);
+			if (hit) hashMap.set(key, {
+				changed: hash !== hit.hash,
+				hash
+			});
+			else hashMap.set(key, {
+				changed: true,
+				hash
+			});
+			return cache;
+		},
+		has(key) {
+			return instance.has(key);
+		},
+		async process({ key, hashKey, rawSource, hash, resolveCache, transform, onCacheHit }) {
+			if (disabled) {
+				const value = await transform();
+				return isProcessResult(value) ? value.result : value;
+			}
+			const cacheHashKey = hashKey ?? key;
+			let hasChanged = true;
+			if (hash != null || rawSource != null) {
+				const nextHash = hash ?? cache.computeHash(rawSource);
+				cache.calcHashValueChanged(cacheHashKey, nextHash);
+				hasChanged = cache.getHashValue(cacheHashKey)?.changed ?? true;
+			}
+			const readCache = resolveCache ?? (() => cache.get(key));
+			if (!hasChanged) {
+				const cached = readCache();
+				if (cached !== void 0) {
+					await onCacheHit?.(cached);
+					return cached;
+				}
+			}
+			const value = await transform();
+			const normalized = isProcessResult(value) ? value : { result: value };
+			const stored = normalized.cacheValue ?? normalized.result;
+			cache.set(key, stored);
+			return normalized.result;
+		}
+	};
+	return cache;
+}
+function initializeCache(cacheConfig) {
+	if (typeof cacheConfig === "boolean" || cacheConfig === void 0) return createCache(cacheConfig);
+	return cacheConfig;
+}
+//#endregion
+//#region src/debug/index.ts
+const _debug = _createDebug("weapp-tw");
+function createDebug(prefix) {
+	const debug = ((formatter, ...args) => {
+		return _debug((prefix ?? "") + formatter, ...args);
+	});
+	Object.defineProperty(debug, "enabled", {
+		enumerable: false,
+		configurable: false,
+		get() {
+			return _debug.enabled;
+		}
+	});
+	return debug;
+}
+//#endregion
+//#region src/tailwindcss/runtime.ts
+const debug$1 = createDebug("[tailwindcss:runtime] ");
+const refreshTailwindcssPatcherSymbol = Symbol.for("weapp-tailwindcss.refreshTailwindcssPatcher");
+function createTailwindPatchPromise(twPatcher, onPatched) {
+	return Promise.resolve(twPatcher.patch()).then(async () => {
+		invalidateRuntimeClassSet(twPatcher);
+		if (onPatched) try {
+			await onPatched();
+		} catch (error) {
+			debug$1("failed to persist patch target after patch(): %O", error);
+		}
+	});
+}
+const runtimeClassSetStateCache = /* @__PURE__ */ new WeakMap();
+function getRuntimeClassSetStateEntry(state) {
+	let entry = runtimeClassSetStateCache.get(state);
+	if (!entry) {
+		entry = {};
+		runtimeClassSetStateCache.set(state, entry);
+	}
+	return entry;
+}
+async function refreshTailwindRuntimeState(state, forceOrOptions) {
+	const normalizedOptions = typeof forceOrOptions === "boolean" ? { force: forceOrOptions } : forceOrOptions;
+	const force = normalizedOptions.force;
+	const clearCache = normalizedOptions.clearCache === true;
+	if (!force) return false;
+	debug$1("refresh runtime state start, clearCache=%s major=%s", clearCache, state.twPatcher.majorVersion ?? "unknown");
+	await state.patchPromise;
+	let refreshed = false;
+	if (typeof state.refreshTailwindcssPatcher === "function") {
+		const next = await state.refreshTailwindcssPatcher({ clearCache });
+		if (next !== state.twPatcher) state.twPatcher = next;
+		refreshed = true;
+	}
+	if (refreshed) state.patchPromise = createTailwindPatchPromise(state.twPatcher, state.onPatchCompleted);
+	debug$1("refresh runtime state end, refreshed=%s major=%s", refreshed, state.twPatcher.majorVersion ?? "unknown");
+	return refreshed;
+}
+async function ensureRuntimeClassSet(state, options = {}) {
+	const forceRefresh = options.forceRefresh === true;
+	const forceCollect = options.forceCollect === true;
+	const clearCache = options.clearCache === true;
+	const allowEmpty = options.allowEmpty === true;
+	if (forceRefresh) await refreshTailwindRuntimeState(state, {
+		force: true,
+		clearCache
+	});
+	await state.patchPromise;
+	const entry = getRuntimeClassSetStateEntry(state);
+	const signature = getRuntimeClassSetSignature(state.twPatcher);
+	const signatureChanged = entry.signature !== signature;
+	const shouldForceCollect = forceCollect || forceRefresh || signatureChanged;
+	if (!shouldForceCollect) {
+		if (entry.value && (allowEmpty || entry.value.size > 0)) return entry.value;
+		if (entry.promise) return entry.promise;
+	}
+	const task = (async () => {
+		const collected = await collectRuntimeClassSet(state.twPatcher, {
+			force: shouldForceCollect,
+			skipRefresh: true,
+			clearCache
+		});
+		if (allowEmpty || collected.size > 0) return collected;
+		await refreshTailwindRuntimeState(state, {
+			force: true,
+			clearCache: true
+		});
+		await state.patchPromise;
+		return collectRuntimeClassSet(state.twPatcher, {
+			force: true,
+			skipRefresh: true,
+			clearCache: true
+		});
+	})();
+	entry.promise = task;
+	try {
+		const runtimeSet = await task;
+		entry.value = runtimeSet;
+		entry.signature = getRuntimeClassSetSignature(state.twPatcher);
+		return runtimeSet;
+	} finally {
+		if (entry.promise === task) entry.promise = void 0;
+	}
+}
+function shouldPreferSync(majorVersion) {
+	if (majorVersion == null) return true;
+	if (majorVersion === 3) return true;
+	if (majorVersion === 4) return true;
+	return false;
+}
+function tryGetRuntimeClassSetSync(twPatcher) {
+	if (typeof twPatcher.getClassSetSync !== "function") return;
+	if (!shouldPreferSync(twPatcher.majorVersion)) return;
+	try {
+		const set = twPatcher.getClassSetSync();
+		if (set && set.size === 0) return;
+		return set;
+	} catch (error) {
+		if (twPatcher.majorVersion === 4) debug$1("getClassSetSync() unavailable for tailwindcss v4, fallback to async getClassSet(): %O", error);
+		else debug$1("getClassSetSync() failed, fallback to async getClassSet(): %O", error);
+		return;
+	}
+}
+async function collectRuntimeClassSet(twPatcher, options = {}) {
+	let activePatcher = twPatcher;
+	if (options.force && !options.skipRefresh) {
+		const refresh = activePatcher[refreshTailwindcssPatcherSymbol];
+		if (typeof refresh === "function") try {
+			const refreshed = await refresh({ clearCache: options.clearCache === true });
+			if (refreshed) activePatcher = refreshed;
+		} catch (error) {
+			debug$1("refreshTailwindcssPatcher failed, continuing with existing patcher: %O", error);
+		}
+	}
+	const entry = getRuntimeClassSetCacheEntry(activePatcher);
+	const signature = getRuntimeClassSetSignature(activePatcher);
+	if (!options.force) {
+		if (entry.value && entry.signature === signature) return entry.value;
+		if (entry.promise) return entry.promise;
+	} else entry.value = void 0;
+	const task = (async () => {
+		const preExtractSyncSet = options.force ? tryGetRuntimeClassSetSync(activePatcher) : void 0;
+		if (preExtractSyncSet) debug$1("runtime class set snapshot via getClassSetSync() before extract(), size=%d", preExtractSyncSet.size);
+		const preferExtract = options.force === true;
+		try {
+			const result = await activePatcher.extract({ write: false });
+			if (result?.classSet) {
+				if (result.classSet.size > 0) {
+					debug$1("runtime class set resolved via extract(), size=%d", result.classSet.size);
+					return result.classSet;
+				}
+				if (preferExtract) debug$1("runtime class set from extract() is empty on force collect, fallback to sync/async class set");
+				else debug$1("runtime class set from extract() is empty, fallback to sync/async class set");
+			}
+		} catch (error) {
+			debug$1("extract() failed, fallback to getClassSet(): %O", error);
+		}
+		if (preExtractSyncSet) {
+			debug$1("runtime class set fallback to pre-extract sync snapshot, size=%d", preExtractSyncSet.size);
+			return preExtractSyncSet;
+		}
+		const syncSet = tryGetRuntimeClassSetSync(activePatcher);
+		if (syncSet) {
+			debug$1("runtime class set resolved via getClassSetSync(), size=%d", syncSet.size);
+			return syncSet;
+		}
+		try {
+			const fallbackSet = await Promise.resolve(activePatcher.getClassSet());
+			if (fallbackSet) {
+				debug$1("runtime class set resolved via getClassSet(), size=%d", fallbackSet.size);
+				return fallbackSet;
+			}
+		} catch (error) {
+			debug$1("getClassSet() failed, returning empty set: %O", error);
+		}
+		return /* @__PURE__ */ new Set();
+	})();
+	entry.promise = task;
+	entry.signature = signature;
+	try {
+		const resolved = await task;
+		entry.value = resolved;
+		entry.promise = void 0;
+		entry.signature = signature;
+		return resolved;
+	} catch (error) {
+		entry.promise = void 0;
+		throw error;
+	}
+}
+//#endregion
+//#region src/tailwindcss/runtime-logs.ts
+const runtimeLogDedupeHolder = globalThis;
+const runtimeLogDedupe = runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ ?? (runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ = /* @__PURE__ */ new Set());
+function createRuntimeLogKey(category, baseDir, rootPath, version) {
+	return JSON.stringify([
+		category,
+		baseDir ?? process.cwd(),
+		rootPath ?? "",
+		version ?? ""
+	]);
+}
+function markRuntimeLog(category, baseDir, rootPath, version) {
+	const key = createRuntimeLogKey(category, baseDir, rootPath, version);
+	if (runtimeLogDedupe.has(key)) return false;
+	runtimeLogDedupe.add(key);
+	return true;
+}
+function logRuntimeTailwindcssTarget(baseDir, rootPath, version) {
+	if (!markRuntimeLog("target", baseDir, rootPath, version)) return;
+	const versionText = version ? ` (v${version})` : "";
+	logger.info("%s 使用 Tailwind CSS%s", "Weapp-tailwindcss", versionText);
+}
+function logRuntimeTailwindcssVersion(baseDir, rootPath, version) {
+	if (version) {
+		if (!markRuntimeLog("version", baseDir, rootPath, version)) return;
+		logger.success(`当前使用 ${pc.cyanBright("Tailwind CSS")} 版本为: ${pc.underline(pc.bold(pc.green(version)))}`);
+		return;
+	}
+	if (!markRuntimeLog("missing", baseDir, rootPath, version)) return;
+	logger.warn(`${pc.cyanBright("Tailwind CSS")} 未安装，已跳过版本检测与补丁应用。`);
+}
+//#endregion
+//#region src/tailwindcss/targets/paths.ts
+const PATCH_INFO_FILENAME = "tailwindcss-target.json";
+const PATCH_INFO_CACHE_RELATIVE_PATH = path.join("node_modules", ".cache", "weapp-tailwindcss", PATCH_INFO_FILENAME);
+const PATCH_INFO_LEGACY_RELATIVE_PATH = path.join(".tw-patch", PATCH_INFO_FILENAME);
+function toDisplayPath(value) {
+	return path.normalize(value).replace(/\\/g, "/");
+}
+function formatRelativeToBase(targetPath, baseDir) {
+	if (!baseDir) return toDisplayPath(targetPath);
+	const relative = path.relative(baseDir, targetPath);
+	if (!relative || relative === ".") return ".";
+	if (relative.startsWith("..")) return toDisplayPath(targetPath);
+	return toDisplayPath(path.join(".", relative));
+}
+function resolveRecordLocation(baseDir) {
+	const normalizedBase = path.normalize(baseDir);
+	const packageRoot = findNearestPackageRoot(normalizedBase) ?? normalizedBase;
+	const packageJsonPath = path.join(packageRoot, "package.json");
+	const hasPackageJson = existsSync(packageJsonPath);
+	const recordKeySource = hasPackageJson ? packageJsonPath : normalizedBase;
+	const recordKey = md5Hash(path.normalize(recordKeySource));
+	const recordDir = path.join(packageRoot, "node_modules", ".cache", "weapp-tailwindcss", recordKey);
+	return {
+		normalizedBase,
+		packageRoot,
+		recordDir,
+		recordKey,
+		recordPath: path.join(recordDir, PATCH_INFO_FILENAME),
+		packageJsonPath: hasPackageJson ? packageJsonPath : void 0
+	};
+}
+function getRecordFileCandidates(baseDir) {
+	const { normalizedBase, packageRoot, recordPath } = resolveRecordLocation(baseDir);
+	return [...new Set([
+		recordPath,
+		path.join(packageRoot, PATCH_INFO_CACHE_RELATIVE_PATH),
+		path.join(normalizedBase, PATCH_INFO_CACHE_RELATIVE_PATH),
+		path.join(normalizedBase, PATCH_INFO_LEGACY_RELATIVE_PATH)
+	])];
+}
+//#endregion
+//#region package.json
+var version = "5.0.0-next.2";
+//#endregion
+//#region src/constants.ts
+const pluginName = "weapp-tailwindcss-webpack-plugin";
+const vitePluginName = "weapp-tailwindcss:adaptor";
+const WEAPP_TW_VERSION = version;
+const DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS = {
+	"tailwind-merge": "@weapp-tailwindcss/merge",
+	"class-variance-authority": "@weapp-tailwindcss/cva",
+	"tailwind-variants": "@weapp-tailwindcss/variants"
+};
+//#endregion
+//#region src/tailwindcss/targets/record-io.ts
+const loggedInvalidPatchRecords = /* @__PURE__ */ new Set();
+function warnInvalidPatchTargetRecord(baseDir, recordPath, reason) {
+	const normalizedPath = path.normalize(recordPath);
+	if (loggedInvalidPatchRecords.has(normalizedPath)) return;
+	loggedInvalidPatchRecords.add(normalizedPath);
+	const fileDisplay = formatRelativeToBase(normalizedPath, baseDir);
+	const baseDisplay = formatRelativeToBase(path.normalize(baseDir), process.cwd());
+	const reasonMessage = reason ? `：${reason}` : "";
+	logger.warn(`检测到损坏的 Tailwind CSS 目标记录 ${fileDisplay}${reasonMessage}。请在 ${baseDisplay} 重新执行 "weapp-tw patch --record-target" 或删除该文件后再运行。`);
+}
+function readPatchTargetRecord(baseDir) {
+	if (!baseDir) return;
+	const normalizedBase = path.normalize(baseDir);
+	for (const recordPath of getRecordFileCandidates(normalizedBase)) {
+		if (!existsSync(recordPath)) continue;
+		try {
+			const content = readFileSync(recordPath, "utf8");
+			const parsed = JSON.parse(content);
+			if (!parsed || typeof parsed.tailwindPackagePath !== "string") {
+				warnInvalidPatchTargetRecord(normalizedBase, recordPath, "缺少 tailwindPackagePath 字段");
+				continue;
+			}
+			return {
+				baseDir: normalizedBase,
+				path: recordPath,
+				record: parsed
+			};
+		} catch (error) {
+			warnInvalidPatchTargetRecord(normalizedBase, recordPath, error instanceof Error ? error.message : String(error));
+			continue;
+		}
+	}
+}
+async function saveCliPatchTargetRecord(baseDir, patcher, options) {
+	if (!baseDir || !patcher?.packageInfo?.rootPath) return;
+	const normalizedBase = path.normalize(baseDir);
+	const location = resolveRecordLocation(normalizedBase);
+	const recordPath = options?.recordPath ? path.normalize(options.recordPath) : location.recordPath;
+	const record = {
+		tailwindPackagePath: path.normalize(patcher.packageInfo.rootPath),
+		packageVersion: patcher.packageInfo.version,
+		recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source: options?.source ?? "cli",
+		tailwindcssBasedir: normalizedBase,
+		cwd: options?.cwd ? path.normalize(options.cwd) : normalizedBase,
+		patchVersion: WEAPP_TW_VERSION,
+		packageJsonPath: options?.packageJsonPath ?? location.packageJsonPath,
+		recordKey: options?.recordKey ?? location.recordKey
+	};
+	try {
+		await mkdir(path.dirname(recordPath), { recursive: true });
+		await writeFile(recordPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+		return recordPath;
+	} catch (error) {
+		const baseDisplay = formatRelativeToBase(normalizedBase, process.cwd());
+		logger.warn("自动更新 Tailwind CSS 补丁记录失败，请在 %s 运行 \"weapp-tw patch --cwd %s\"。", baseDisplay, normalizedBase);
+		logger.debug("failed to persist patch target record %s: %O", recordPath, error);
+		return;
+	}
+}
+//#endregion
+//#region src/tailwindcss/targets/recorder.ts
+function findPatchTargetRecord(baseDir) {
+	const visited = /* @__PURE__ */ new Set();
+	const fallback = baseDir ?? process.cwd();
+	let current = path.resolve(fallback);
+	while (!visited.has(current)) {
+		const record = readPatchTargetRecord(current);
+		if (record) return record;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		visited.add(current);
+		current = parent;
+	}
+}
+function createPatchTargetRecorder(baseDir, patcher, options) {
+	if (!baseDir || !patcher?.packageInfo?.rootPath || options?.recordTarget === false) return;
+	const normalizedBase = path.normalize(baseDir);
+	const recorded = findPatchTargetRecord(normalizedBase);
+	const location = resolveRecordLocation(normalizedBase);
+	const expectedPath = path.normalize(patcher.packageInfo.rootPath);
+	let reason;
+	if (!recorded) reason = "missing";
+	else if (path.normalize(recorded.record.tailwindPackagePath) !== expectedPath) reason = "mismatch";
+	else if (path.normalize(recorded.path) !== path.normalize(location.recordPath) || !recorded.record.recordKey || recorded.record.recordKey !== location.recordKey) reason = "migrate";
+	else if (!recorded.record.patchVersion || recorded.record.patchVersion !== WEAPP_TW_VERSION) reason = "stale";
+	else if (options?.cwd && recorded.record.cwd && path.normalize(recorded.record.cwd) !== path.normalize(options.cwd)) reason = "metadata";
+	else if (!recorded.record.cwd && options?.cwd) reason = "metadata";
+	if (!(options?.alwaysRecord || !recorded || Boolean(reason))) return;
+	let message;
+	switch (reason) {
+		case "mismatch":
+			message = "检测到 Tailwind CSS 目标记录与当前解析结果不一致，正在自动重新 patch 并刷新缓存。";
+			break;
+		case "migrate":
+		case "stale":
+			message = "正在刷新当前子包的 Tailwind CSS 补丁记录，确保缓存隔离。";
+			break;
+		case "missing":
+			message = "未找到当前子包的 Tailwind CSS 目标记录，正在生成。";
+			break;
+		default: break;
+	}
+	const onPatched = async () => saveCliPatchTargetRecord(normalizedBase, patcher, {
+		cwd: options?.cwd ?? normalizedBase,
+		source: options?.source ?? "cli",
+		recordPath: location.recordPath,
+		recordKey: location.recordKey,
+		packageJsonPath: location.packageJsonPath
+	});
+	return {
+		recordPath: location.recordPath,
+		message,
+		reason,
+		onPatched
+	};
+}
+//#endregion
+//#region src/tailwindcss/targets.ts
+function logTailwindcssTarget(kind, patcher, baseDir) {
+	const packageInfo = patcher?.packageInfo;
+	const label = kind === "cli" ? "weapp-tw patch" : "Weapp-tailwindcss";
+	if (!packageInfo?.rootPath) {
+		logger.warn("%s 未找到 Tailwind CSS 依赖，请检查在 %s 是否已安装 tailwindcss", label, baseDir ?? process.cwd());
+		return;
+	}
+	const displayPath = formatRelativeToBase(packageInfo.rootPath, baseDir);
+	const version = packageInfo.version ? ` (v${packageInfo.version})` : "";
+	if (kind === "runtime") {
+		logRuntimeTailwindcssTarget(baseDir, packageInfo.rootPath, packageInfo.version);
+		return;
+	}
+	logger.info("%s 绑定 Tailwind CSS -> %s%s", label, displayPath, version);
+}
+//#endregion
+//#region src/context/compiler-context-cache.ts
+const PAREN_CONTENT_RE = /\(([^)]+)\)/u;
+const AT_LOCATION_RE = /at\s+(\S.*)$/u;
+const TRAILING_LINE_COL_RE = /:\d+(?::\d+)?$/u;
+const globalCacheHolder = globalThis;
+const compilerContextCache = globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
+const compilerContextKeyCacheByOptions = /* @__PURE__ */ new WeakMap();
+const compilerContextKeyCacheWithoutOptions = /* @__PURE__ */ new Map();
+function withCircularGuard(value, stack, factory) {
+	if (stack.has(value)) throw new TypeError("Cannot serialize circular structure in compiler context options");
+	stack.add(value);
+	try {
+		return factory();
+	} finally {
+		stack.delete(value);
+	}
+}
+function encodeTaggedValue(type, value) {
+	const record = { __type: type };
+	if (value !== void 0) record.value = value;
+	return record;
+}
+function hasExplicitOptionBasedir(opts) {
+	return typeof opts?.tailwindcssBasedir === "string" && opts.tailwindcssBasedir.length > 0;
+}
+function shouldProbeCallerLocation(opts) {
+	if (hasExplicitOptionBasedir(opts)) return false;
+	return !(process.env.WEAPP_TAILWINDCSS_BASEDIR || process.env.WEAPP_TAILWINDCSS_BASE_DIR || process.env.TAILWINDCSS_BASEDIR || process.env.TAILWINDCSS_BASE_DIR);
+}
+function detectCallerLocation() {
+	const stack = (/* @__PURE__ */ new Error("compiler-context-cache stack probe")).stack;
+	if (!stack) return;
+	const lines = stack.split("\n");
+	for (const line of lines) {
+		const location = (line.match(PAREN_CONTENT_RE) ?? line.match(AT_LOCATION_RE))?.[1];
+		if (!location) continue;
+		const candidatePath = location.replace(TRAILING_LINE_COL_RE, "");
+		if (!candidatePath || !path.isAbsolute(candidatePath)) continue;
+		if (candidatePath.includes(`${path.sep}weapp-tailwindcss${path.sep}src${path.sep}`) || candidatePath.includes(`${path.sep}weapp-tailwindcss${path.sep}dist${path.sep}`) || candidatePath.includes(`${path.sep}node_modules${path.sep}weapp-tailwindcss${path.sep}`)) continue;
+		return candidatePath;
+	}
+}
+function getRuntimeCacheScope(opts) {
+	if (hasExplicitOptionBasedir(opts)) return { caller: void 0 };
+	const runtimeScope = {
+		caller: void 0,
+		cwd: process.cwd(),
+		init_cwd: process.env.INIT_CWD,
+		npm_config_local_prefix: process.env.npm_config_local_prefix,
+		npm_package_json: process.env.npm_package_json,
+		pnpm_package_name: process.env.PNPM_PACKAGE_NAME,
+		pwd: process.env.PWD,
+		tailwindcss_base_dir: process.env.TAILWINDCSS_BASE_DIR,
+		tailwindcss_basedir: process.env.TAILWINDCSS_BASEDIR,
+		uni_app_input_dir: process.env.UNI_APP_INPUT_DIR,
+		uni_cli_root: process.env.UNI_CLI_ROOT,
+		uni_input_dir: process.env.UNI_INPUT_DIR,
+		uni_input_root: process.env.UNI_INPUT_ROOT,
+		weapp_tailwindcss_base_dir: process.env.WEAPP_TAILWINDCSS_BASE_DIR,
+		weapp_tailwindcss_basedir: process.env.WEAPP_TAILWINDCSS_BASEDIR
+	};
+	if (shouldProbeCallerLocation(opts)) runtimeScope.caller = detectCallerLocation();
+	return runtimeScope;
+}
+function serializeNormalizedValue(value) {
+	return JSON.stringify(value);
+}
+function createRuntimeCacheScopeKey(opts) {
+	return serializeNormalizedValue(normalizeOptionsValue(getRuntimeCacheScope(opts)));
+}
+function getCompilerContextKeyCacheStore(opts) {
+	if (!opts) return compilerContextKeyCacheWithoutOptions;
+	let store = compilerContextKeyCacheByOptions.get(opts);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		compilerContextKeyCacheByOptions.set(opts, store);
+	}
+	return store;
+}
+function createComparableNormalizedValue(rawValue, stack) {
+	const normalized = normalizeOptionsValue(rawValue, stack);
+	return {
+		normalized,
+		sortKey: serializeNormalizedValue(normalized)
+	};
+}
+function getRuntimeCacheScopeValue(opts) {
+	return {
+		options: opts ?? {},
+		runtime: getRuntimeCacheScope(opts)
+	};
+}
+function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet()) {
+	if (rawValue === null) return null;
+	if (rawValue === void 0) return encodeTaggedValue("Undefined");
+	const type = typeof rawValue;
+	if (type === "string") return rawValue;
+	if (type === "boolean") return rawValue;
+	if (type === "number") {
+		const numericValue = rawValue;
+		if (Number.isNaN(numericValue)) return encodeTaggedValue("Number", "NaN");
+		if (!Number.isFinite(numericValue)) return encodeTaggedValue("Number", numericValue > 0 ? "Infinity" : "-Infinity");
+		if (Object.is(numericValue, -0)) return encodeTaggedValue("Number", "-0");
+		return numericValue;
+	}
+	if (type === "bigint") return encodeTaggedValue("BigInt", rawValue.toString());
+	if (type === "symbol") {
+		const symbolValue = rawValue;
+		return encodeTaggedValue("Symbol", symbolValue.description ?? String(symbolValue));
+	}
+	if (type === "function") return encodeTaggedValue("Function", rawValue.toString());
+	if (Array.isArray(rawValue)) return withCircularGuard(rawValue, stack, () => rawValue.map((item) => normalizeOptionsValue(item, stack)));
+	if (rawValue instanceof Date) return encodeTaggedValue("Date", rawValue.toISOString());
+	if (rawValue instanceof RegExp) return {
+		__type: "RegExp",
+		source: rawValue.source,
+		flags: rawValue.flags
+	};
+	if (typeof Buffer !== "undefined" && Buffer.isBuffer(rawValue)) return encodeTaggedValue("Buffer", rawValue.toString("base64"));
+	if (ArrayBuffer.isView(rawValue)) {
+		const view = rawValue;
+		const buffer = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+		return encodeTaggedValue(view.constructor?.name ?? "ArrayBufferView", buffer.toString("base64"));
+	}
+	if (rawValue instanceof ArrayBuffer) return encodeTaggedValue("ArrayBuffer", Buffer.from(rawValue).toString("base64"));
+	if (rawValue instanceof Set) return withCircularGuard(rawValue, stack, () => {
+		const normalizedEntries = Array.from(rawValue, (element) => createComparableNormalizedValue(element, stack));
+		normalizedEntries.sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+		return {
+			__type: "Set",
+			value: normalizedEntries.map((entry) => entry.normalized)
+		};
+	});
+	if (rawValue instanceof Map) return withCircularGuard(rawValue, stack, () => {
+		const normalizedEntries = Array.from(rawValue.entries(), ([key, entryValue]) => {
+			const normalizedKey = createComparableNormalizedValue(key, stack);
+			return {
+				key: normalizedKey.normalized,
+				sortKey: normalizedKey.sortKey,
+				value: normalizeOptionsValue(entryValue, stack)
+			};
+		});
+		normalizedEntries.sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+		return {
+			__type: "Map",
+			value: normalizedEntries.map((entry) => [entry.key, entry.value])
+		};
+	});
+	if (typeof URL !== "undefined" && rawValue instanceof URL) return encodeTaggedValue("URL", rawValue.toString());
+	if (rawValue instanceof Error) {
+		const errorValue = rawValue;
+		return {
+			__type: "Error",
+			name: errorValue.name,
+			message: errorValue.message,
+			stack: errorValue.stack ?? ""
+		};
+	}
+	if (rawValue instanceof Promise) return encodeTaggedValue("Promise");
+	if (rawValue instanceof WeakMap) return encodeTaggedValue("WeakMap");
+	if (rawValue instanceof WeakSet) return encodeTaggedValue("WeakSet");
+	if (rawValue && typeof rawValue === "object") return withCircularGuard(rawValue, stack, () => {
+		const result = {};
+		const entries = Object.entries(rawValue);
+		entries.sort(([a], [b]) => a.localeCompare(b));
+		for (const [key, entryValue] of entries) result[key] = normalizeOptionsValue(entryValue, stack);
+		return result;
+	});
+	return encodeTaggedValue(typeof rawValue, String(rawValue));
+}
+function createCompilerContextCacheKey(opts) {
+	try {
+		const runtimeCacheScopeKey = createRuntimeCacheScopeKey(opts);
+		const keyStore = getCompilerContextKeyCacheStore(opts);
+		const cached = keyStore.get(runtimeCacheScopeKey);
+		if (cached !== void 0) return cached;
+		const cacheKey = md5Hash(serializeNormalizedValue(normalizeOptionsValue(getRuntimeCacheScopeValue(opts))));
+		keyStore.set(runtimeCacheScopeKey, cacheKey);
+		return cacheKey;
+	} catch (error) {
+		logger.debug("skip compiler context cache: %O", error);
+		return;
+	}
+}
+function withCompilerContextCache(opts, factory) {
+	const cacheKey = createCompilerContextCacheKey(opts);
+	if (cacheKey) {
+		const cached = compilerContextCache.get(cacheKey);
+		if (cached) return cached;
+	}
+	const ctx = factory();
+	if (cacheKey) compilerContextCache.set(cacheKey, ctx);
+	return ctx;
+}
+//#endregion
+//#region src/context/custom-attributes.ts
+function toCustomAttributesEntities(customAttributes) {
+	if (!customAttributes) return [];
+	if (isMap(customAttributes)) return [...customAttributes.entries()];
+	return Object.entries(customAttributes);
+}
+//#endregion
+//#region src/babel/index.ts
+function _interopDefaultCompat(e) {
+	return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+const traverse = _interopDefaultCompat(_babelTraverse);
+//#endregion
+//#region src/utils/nameMatcher.ts
+const NEVER_MATCH_NAME$1 = () => false;
+const GLOBAL_FLAG_REGEXP = /g/g;
+function buildFuzzyMatcher(fuzzyStrings) {
+	if (fuzzyStrings.length === 0) return;
+	if (fuzzyStrings.length === 1) {
+		const [needle] = fuzzyStrings;
+		return (value) => value.includes(needle);
+	}
+	const unique = [...new Set(fuzzyStrings)];
+	const pattern = new RegExp(unique.map(escapeStringRegexp).join("|"));
+	return (value) => pattern.test(value);
+}
+function normaliseRegex(regex) {
+	const { source, flags } = regex;
+	if (!flags.includes("g")) return regex;
+	return new RegExp(source, flags.replace(GLOBAL_FLAG_REGEXP, ""));
+}
+function createNameMatcher(list, { exact = false } = {}) {
+	if (!list || list.length === 0) return NEVER_MATCH_NAME$1;
+	const exactStrings = exact ? /* @__PURE__ */ new Set() : void 0;
+	const fuzzyStrings = [];
+	const regexList = [];
+	for (const item of list) if (typeof item === "string") if (exact) exactStrings.add(item);
+	else fuzzyStrings.push(item);
+	else regexList.push(normaliseRegex(item));
+	if (exact) {
+		const exactStringCount = exactStrings?.size ?? 0;
+		if (exactStringCount === 1 && regexList.length === 0) {
+			const [needle] = exactStrings;
+			return (value) => value === needle;
+		}
+		if (regexList.length === 0) return (value) => exactStrings.has(value);
+		if (exactStringCount === 0 && regexList.length === 1) {
+			const [regex] = regexList;
+			return (value) => regex.test(value);
+		}
+		return (value) => {
+			if (exactStrings?.has(value)) return true;
+			return regexList.some((regex) => regex.test(value));
+		};
+	}
+	const fuzzyMatcher = exact ? void 0 : buildFuzzyMatcher(fuzzyStrings);
+	const hasRegex = regexList.length > 0;
+	if (fuzzyMatcher && !hasRegex) return fuzzyMatcher;
+	if (!fuzzyMatcher && regexList.length === 1) {
+		const [regex] = regexList;
+		return (value) => regex.test(value);
+	}
+	return (value) => {
+		if (fuzzyMatcher?.(value)) return true;
+		if (!hasRegex) return false;
+		return regexList.some((regex) => regex.test(value));
+	};
+}
+//#endregion
+//#region src/js/babel/parse.ts
+const parseCache = new LRUCache({ max: 1024 });
+function genCacheKey(source, options) {
+	if (typeof options === "string") return source + options;
+	return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
+}
+function babelParse(code, opts = {}) {
+	const { cache, cacheKey, ...rest } = opts;
+	const cacheKeyString = genCacheKey(code, cacheKey ?? rest);
+	let result;
+	if (cache) result = parseCache.get(cacheKeyString);
+	if (!result) {
+		const { cache: _cache, cacheKey: _cacheKey, ...parseOptions } = opts;
+		result = parse(code, parseOptions);
+		if (cache) parseCache.set(cacheKeyString, result);
+	}
+	return result;
+}
+//#endregion
+//#region src/wxml/shared.ts
+const NEWLINE_RE = /[\n\r]+/g;
+function replaceWxml(original, options = {
+	keepEOL: false,
+	escapeMap: MappingChars2String
+}) {
+	const { keepEOL, escapeMap, ignoreHead } = options;
+	let res = original;
+	if (!keepEOL) res = res.replaceAll(NEWLINE_RE, "");
+	res = escape(res, {
+		map: escapeMap,
+		ignoreHead
+	});
+	return res;
+}
+//#endregion
+//#region src/shared/classname-transform.ts
+const escapedCandidateCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+const defaultEscapedCandidateCache = /* @__PURE__ */ new Map();
+let lastEscapedCandidateEscapeMap;
+let lastEscapedCandidateCacheStore;
+function isUrlLikeCandidate(candidate) {
+	return candidate.startsWith("//") || candidate.startsWith("http://") || candidate.startsWith("https://");
+}
+function isArbitraryValueCandidate(candidate) {
+	let hasOpenBracket = false;
+	let hasCloseBracket = false;
+	for (let i = 0; i < candidate.length; i++) {
+		const char = candidate[i];
+		if (char === "[") hasOpenBracket = true;
+		else if (char === "]") hasCloseBracket = true;
+		if (hasOpenBracket && hasCloseBracket) break;
+	}
+	if (!hasOpenBracket || !hasCloseBracket) return false;
+	if (isUrlLikeCandidate(candidate.trim())) return false;
+	return true;
+}
+function shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) {
+	if (jsArbitraryValueFallback === true) return true;
+	if (jsArbitraryValueFallback === false) return false;
+	return tailwindcssMajorVersion === 4 && (!classNameSet || classNameSet.size === 0);
+}
+function shouldEnableArbitraryValueFallback({ classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion }) {
+	return shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion);
+}
+const SKIP_RESULT = { decision: "skip" };
+const DIRECT_RESULT = { decision: "direct" };
+const FALLBACK_RESULT = { decision: "fallback" };
+function getEscapedCandidateCacheStore(escapeMap) {
+	if (!escapeMap) return defaultEscapedCandidateCache;
+	if (escapeMap === lastEscapedCandidateEscapeMap && lastEscapedCandidateCacheStore) return lastEscapedCandidateCacheStore;
+	let store = escapedCandidateCacheByEscapeMap.get(escapeMap);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		escapedCandidateCacheByEscapeMap.set(escapeMap, store);
+	}
+	lastEscapedCandidateEscapeMap = escapeMap;
+	lastEscapedCandidateCacheStore = store;
+	return store;
+}
+function getEscapedCandidate(candidate, escapeMap, store = getEscapedCandidateCacheStore(escapeMap)) {
+	let cached = store.get(candidate);
+	if (cached === void 0) {
+		cached = replaceWxml(candidate, { escapeMap });
+		store.set(candidate, cached);
+	}
+	return cached;
+}
+/**
+* JS 转译严格遵循 runtime class set：
+* 1. 直接命中 classNameSet 原始值；
+* 2. 兼容命中 classNameSet 中已转义值；
+* 3. 仅在受控条件下允许 class 语义兜底。
+*
+* 返回结构化结果，附带已计算的 escapedValue 以避免下游重复 escape。
+*/
+function resolveClassNameTransformWithResult(candidate, { alwaysEscape, classNameSet, escapeMap, jsArbitraryValueFallback, jsPreserveClass, tailwindcssMajorVersion, classContext }) {
+	if (alwaysEscape) return DIRECT_RESULT;
+	if (jsPreserveClass?.(candidate)) return SKIP_RESULT;
+	if (classNameSet?.has(candidate)) return DIRECT_RESULT;
+	if (classNameSet && classNameSet.size > 0) {
+		const escapedCandidate = getEscapedCandidate(candidate, escapeMap);
+		if (escapedCandidate !== candidate && classNameSet.has(escapedCandidate)) return {
+			decision: "escaped",
+			escapedValue: escapedCandidate
+		};
+	}
+	if (classContext && shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) && isArbitraryValueCandidate(candidate)) return FALLBACK_RESULT;
+	return SKIP_RESULT;
+}
+//#endregion
+//#region src/utils/decode.ts
+const unicodeEscapeRE = /\\u([\dA-Fa-f]{4})/g;
+const unicodeEscapeTestRE = /\\u[\dA-Fa-f]{4}/;
+function decodeUnicode(value) {
+	if (!unicodeEscapeTestRE.test(value)) return value;
+	return value.replace(unicodeEscapeRE, (_match, hex) => {
+		const codePoint = Number.parseInt(hex, 16);
+		return Number.isNaN(codePoint) ? _match : String.fromCharCode(codePoint);
+	});
+}
+function decodeUnicode2(input) {
+	if (!unicodeEscapeTestRE.test(input)) return input;
+	try {
+		return JSON.parse(`"${input}"`);
+	} catch (_error) {
+		return decodeUnicode(input);
+	}
+}
+//#endregion
+//#region src/js/class-context.ts
+const CLASS_LIKE_KEYWORDS = new Set([
+	"class",
+	"classname",
+	"hoverclass",
+	"virtualhostclass",
+	"rootclass"
+]);
+const CLASS_HELPER_IDENTIFIERS = new Set([
+	"cn",
+	"clsx",
+	"classnames",
+	"twmerge",
+	"cva",
+	"tv",
+	"cx",
+	"r"
+]);
+const DASH_CODE = 45;
+const COLON_CODE = 58;
+const UPPERCASE_A_CODE = 65;
+const UPPERCASE_Z_CODE = 90;
+const UNDERSCORE_CODE = 95;
+const ASCII_MAX_CODE = 127;
+const NORMALIZE_KEYWORD_REGEXP = /[-_:]/g;
+function normalizeKeyword(name) {
+	const length = name.length;
+	let firstNormalizedIndex = -1;
+	for (let i = 0; i < length; i++) {
+		const code = name.charCodeAt(i);
+		if (code === DASH_CODE || code === UNDERSCORE_CODE || code === COLON_CODE || code >= UPPERCASE_A_CODE && code <= UPPERCASE_Z_CODE) {
+			firstNormalizedIndex = i;
+			break;
+		}
+		if (code > ASCII_MAX_CODE) return name.replace(NORMALIZE_KEYWORD_REGEXP, "").toLowerCase();
+	}
+	if (firstNormalizedIndex === -1) return name;
+	let normalized = name.slice(0, firstNormalizedIndex);
+	for (let i = firstNormalizedIndex; i < length; i++) {
+		const code = name.charCodeAt(i);
+		if (code === DASH_CODE || code === UNDERSCORE_CODE || code === COLON_CODE) continue;
+		if (code >= UPPERCASE_A_CODE && code <= UPPERCASE_Z_CODE) {
+			normalized += String.fromCharCode(code + 32);
+			continue;
+		}
+		if (code > ASCII_MAX_CODE) return name.replace(NORMALIZE_KEYWORD_REGEXP, "").toLowerCase();
+		normalized += name[i];
+	}
+	return normalized;
+}
+function readObjectKeyName(path) {
+	if (path.isIdentifier()) return path.node.name;
+	if (path.isStringLiteral()) return path.node.value;
+	if (path.isTemplateLiteral() && path.node.expressions.length === 0) return path.node.quasis[0]?.value.cooked ?? path.node.quasis[0]?.value.raw;
+}
+function isClassLikeObjectProperty(path, valuePath) {
+	if (!path.isObjectProperty()) return false;
+	if (path.get("value") !== valuePath) return false;
+	const keyName = readObjectKeyName(path.get("key"));
+	if (!keyName) return false;
+	return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(keyName));
+}
+function isClassLikeJsxAttribute(path) {
+	if (!path.isJSXAttribute()) return false;
+	const namePath = path.get("name");
+	if (!namePath.isJSXIdentifier()) return false;
+	return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(namePath.node.name));
+}
+function readCallHelperName(calleePath) {
+	if (calleePath.isIdentifier()) return calleePath.node.name;
+	if (calleePath.isMemberExpression()) {
+		const propertyPath = calleePath.get("property");
+		if (propertyPath.isIdentifier()) return propertyPath.node.name;
+		if (propertyPath.isStringLiteral()) return propertyPath.node.value;
+	}
+}
+function isClassLikeCallExpression(path, valuePath) {
+	if (!path.isCallExpression()) return false;
+	const helperName = readCallHelperName(path.get("callee"));
+	if (!helperName || !CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(helperName))) return false;
+	return path.get("arguments").some((argumentPath) => argumentPath.node === valuePath.node);
+}
+/**
+* 判断字符串字面量是否处于 class 语义上下文。
+* 仅用于受控兜底场景，避免将普通业务文本误判为 class。
+*/
+function isClassContextLiteralPath(path) {
+	let current = path;
+	while (current.parentPath) {
+		const parent = current.parentPath;
+		if (isClassLikeObjectProperty(parent, current)) return true;
+		if (isClassLikeJsxAttribute(parent)) return true;
+		if (isClassLikeCallExpression(parent, current)) return true;
+		current = parent;
+	}
+	return false;
+}
+//#endregion
+//#region src/js/handlers.ts
+const debug = createDebug("[js:handlers] ");
+const replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+const defaultReplacementCache = /* @__PURE__ */ new Map();
+const WEAPP_TW_IGNORE_MARKER = "weapp-tw";
+const IGNORE_MARKER = "ignore";
+function getReplacementCacheStore(escapeMap) {
+	if (!escapeMap) return defaultReplacementCache;
+	let store = replacementCacheByEscapeMap.get(escapeMap);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		replacementCacheByEscapeMap.set(escapeMap, store);
+	}
+	return store;
+}
+function getReplacement(candidate, escapeMap, store = getReplacementCacheStore(escapeMap)) {
+	let cached = store.get(candidate);
+	if (cached === void 0) {
+		cached = replaceWxml(candidate, { escapeMap });
+		store.set(candidate, cached);
+	}
+	return cached;
+}
+function hasIgnoreComment(node) {
+	const { leadingComments } = node;
+	if (!Array.isArray(leadingComments) || leadingComments.length === 0) return false;
+	for (const comment of leadingComments) {
+		const { value } = comment;
+		if (value.includes(WEAPP_TW_IGNORE_MARKER) && value.includes(IGNORE_MARKER)) return true;
+	}
+	return false;
+}
+function extractLiteralValue(path, { unescapeUnicode, arbitraryValues }) {
+	const allowDoubleQuotes = arbitraryValues?.allowDoubleQuotes;
+	const { node } = path;
+	let offset = 0;
+	let original;
+	if (node.type === "StringLiteral") {
+		offset = 1;
+		original = node.value;
+	} else if (node.type === "TemplateElement") original = node.value.raw;
+	else original = "";
+	let literal = original;
+	if (unescapeUnicode && original.includes("\\u")) literal = decodeUnicode2(original);
+	return {
+		allowDoubleQuotes,
+		literal,
+		offset,
+		original
+	};
+}
+function createCandidatePlanResolver(options, classContext) {
+	const { escapeMap } = options;
+	const replacementCache = getReplacementCacheStore(escapeMap);
+	const transformOptions = classContext ? {
+		...options,
+		classContext
+	} : options;
+	let firstCandidate = "";
+	let firstPlan;
+	let cache;
+	const buildCandidatePlan = (candidate) => {
+		const result = resolveClassNameTransformWithResult(candidate, transformOptions);
+		if (result.decision === "skip") return { result };
+		let replacement;
+		if (result.decision === "escaped" && result.escapedValue) {
+			replacement = result.escapedValue;
+			replacementCache.set(candidate, replacement);
+		} else replacement = getReplacement(candidate, escapeMap, replacementCache);
+		return {
+			result,
+			replacement
+		};
+	};
+	return (candidate) => {
+		if (cache) {
+			const cached = cache.get(candidate);
+			if (cached) return cached;
+		} else if (firstPlan && candidate === firstCandidate) return firstPlan;
+		const plan = buildCandidatePlan(candidate);
+		if (!firstPlan) {
+			firstCandidate = candidate;
+			firstPlan = plan;
+			return plan;
+		}
+		if (!cache) {
+			cache = /* @__PURE__ */ new Map();
+			cache.set(firstCandidate, firstPlan);
+		}
+		cache.set(candidate, plan);
+		return plan;
+	};
+}
+function replaceHandleValue(path, options) {
+	const { needEscaped = false } = options;
+	const { classNameSet, alwaysEscape } = options;
+	const fallbackEnabled = shouldEnableArbitraryValueFallback(options);
+	if (!alwaysEscape && !fallbackEnabled && (!classNameSet || classNameSet.size === 0)) return;
+	if (hasIgnoreComment(path.node)) return;
+	const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path, options);
+	const candidates = splitCode(literal, allowDoubleQuotes);
+	if (candidates.length === 0) return;
+	const debugEnabled = debug.enabled;
+	const classContext = options.wrapExpression || isClassContextLiteralPath(path);
+	let transformed = literal;
+	let mutated = false;
+	let matchedCandidateCount = 0;
+	let escapedDecisionCount = 0;
+	let fallbackDecisionCount = 0;
+	let escapedSamples;
+	let skippedSamples;
+	const resolveCandidatePlan = createCandidatePlanResolver(options, classContext);
+	for (const candidate of candidates) {
+		const plan = resolveCandidatePlan(candidate);
+		if (plan.result.decision === "skip") {
+			if (debugEnabled) {
+				if (!skippedSamples) skippedSamples = [];
+				if (skippedSamples.length < 6) skippedSamples.push(candidate);
+			}
+			continue;
+		}
+		if (debugEnabled) {
+			matchedCandidateCount += 1;
+			if (plan.result.decision === "escaped") {
+				escapedDecisionCount += 1;
+				if (!escapedSamples) escapedSamples = [];
+				if (escapedSamples.length < 6) escapedSamples.push(candidate);
+			}
+			if (plan.result.decision === "fallback") fallbackDecisionCount += 1;
+		}
+		const replaced = transformed.replace(candidate, plan.replacement);
+		if (replaced !== transformed) {
+			transformed = replaced;
+			mutated = true;
+		}
+	}
+	const node = path.node;
+	if (!mutated || typeof node.start !== "number" || typeof node.end !== "number") return;
+	if (debugEnabled) debug("runtimeSet size=%d fallbackTriggered=%s candidates=%d matched=%d escapedHits=%d skipped=%d file=%s escapedSamples=%s skippedSamples=%s", classNameSet?.size ?? 0, fallbackDecisionCount > 0, candidates.length, matchedCandidateCount, escapedDecisionCount, skippedSamples?.length ?? 0, options.filename ?? "unknown", escapedSamples?.join(",") || "-", skippedSamples?.join(",") || "-");
+	const start = node.start + offset;
+	const end = node.end - offset;
+	if (start >= end || transformed === original) return;
+	return {
+		start,
+		end,
+		value: needEscaped ? jsStringEscape(transformed) : transformed,
+		path
+	};
+}
+//#endregion
+//#region src/js/sourceAnalysis.ts
+function hasReplacementEntries(replacements) {
+	for (const key in replacements) if (Object.hasOwn(replacements, key)) return true;
+	return false;
+}
+function createModuleSpecifierReplacementToken(path, replacement) {
+	const node = path.node;
+	if (node.value === replacement) return;
+	if (typeof node.start !== "number" || typeof node.end !== "number") return;
+	const start = node.start + 1;
+	const end = node.end - 1;
+	if (start >= end) return;
+	return {
+		start,
+		end,
+		value: replacement,
+		path
+	};
+}
+function collectModuleSpecifierReplacementTokens(analysis, replacements) {
+	if (!hasReplacementEntries(replacements)) return [];
+	if (analysis.importDeclarations.size === 0 && analysis.exportDeclarations.size === 0 && analysis.requireCallPaths.length === 0 && analysis.walker.imports.size === 0) return [];
+	const tokens = [];
+	const applyReplacement = (path) => {
+		const replacement = replacements[path.node.value];
+		if (!replacement) return;
+		const token = createModuleSpecifierReplacementToken(path, replacement);
+		if (token) tokens.push(token);
+	};
+	for (const importPath of analysis.importDeclarations) {
+		const source = importPath.get("source");
+		if (source.isStringLiteral()) applyReplacement(source);
+	}
+	for (const exportPath of analysis.exportDeclarations) if (exportPath.isExportNamedDeclaration() || exportPath.isExportAllDeclaration()) {
+		const source = exportPath.get("source");
+		if (source && !Array.isArray(source) && source.isStringLiteral()) applyReplacement(source);
+	}
+	for (const literalPath of analysis.requireCallPaths) applyReplacement(literalPath);
+	for (const token of analysis.walker.imports) {
+		const replacement = replacements[token.source];
+		if (replacement) token.source = replacement;
+	}
+	return tokens;
+}
+//#endregion
+//#region src/js/babel/process.ts
+const optionVariantsCache = /* @__PURE__ */ new WeakMap();
+function getNeedEscapedOptions(options, needEscaped) {
+	if (options.needEscaped === needEscaped) return options;
+	let cached = optionVariantsCache.get(options);
+	if (!cached) {
+		cached = {};
+		optionVariantsCache.set(options, cached);
+	}
+	if (needEscaped) {
+		if (!cached.stringLiteralOptions) cached.stringLiteralOptions = {
+			...options,
+			needEscaped: true
+		};
+		return cached.stringLiteralOptions;
+	}
+	if (!cached.templateLiteralOptions) cached.templateLiteralOptions = {
+		...options,
+		needEscaped: false
+	};
+	return cached.templateLiteralOptions;
+}
+function processUpdatedSource(rawSource, options, analysis) {
+	const { targetPaths, jsTokenUpdater, ignoredPaths } = analysis;
+	if (targetPaths.length === 0 && !options.moduleSpecifierReplacements && jsTokenUpdater.length === 0) return new MagicString(rawSource);
+	const replacementTokens = [];
+	for (const path of targetPaths) {
+		if (ignoredPaths.has(path)) continue;
+		const token = replaceHandleValue(path, path.isStringLiteral() ? getNeedEscapedOptions(options, true) : getNeedEscapedOptions(options, false));
+		if (token) replacementTokens.push(token);
+	}
+	if (options.moduleSpecifierReplacements) replacementTokens.push(...collectModuleSpecifierReplacementTokens(analysis, options.moduleSpecifierReplacements));
+	if (jsTokenUpdater.length + replacementTokens.length === 0) return new MagicString(rawSource);
+	const ms = new MagicString(rawSource);
+	jsTokenUpdater.push(...replacementTokens).filter((token) => !ignoredPaths.has(token.path)).updateMagicString(ms);
+	return ms;
+}
+//#endregion
+//#region src/js/evalTransforms.ts
+const evalHandlerOptionsCache = /* @__PURE__ */ new WeakMap();
+const EVAL_SCOPE_ERROR_REGEXP = /pass a scope and parentPath|traversing a Program\/File/i;
+function isEvalPath(path) {
+	if (path.isCallExpression()) return path.get("callee").isIdentifier({ name: "eval" });
+	return false;
+}
+function createEvalReplacementToken(path, updated) {
+	const node = path.node;
+	let offset = 0;
+	let original;
+	if (path.isStringLiteral()) {
+		offset = 1;
+		original = path.node.value;
+	} else if (path.isTemplateElement()) original = path.node.value.raw;
+	else original = "";
+	if (typeof node.start !== "number" || typeof node.end !== "number") return;
+	const start = node.start + offset;
+	const end = node.end - offset;
+	if (start >= end) return;
+	if (original === updated) return;
+	return {
+		start,
+		end,
+		value: path.isStringLiteral() ? jsStringEscape(updated) : updated,
+		path
+	};
+}
+function handleEvalStringLiteral(path, handlerOptions, updater, handler) {
+	const { code } = handler(path.node.value, handlerOptions);
+	if (!code) return;
+	const token = createEvalReplacementToken(path, code);
+	if (token) updater.addToken(token);
+}
+function handleEvalTemplateElement(path, handlerOptions, updater, handler) {
+	const { code } = handler(path.node.value.raw, handlerOptions);
+	if (!code) return;
+	const token = createEvalReplacementToken(path, code);
+	if (token) updater.addToken(token);
+}
+function getEvalStringHandlerOptions(options) {
+	if (options.needEscaped === false && options.generateMap === false) return options;
+	let cached = evalHandlerOptionsCache.get(options);
+	if (!cached) {
+		cached = {};
+		evalHandlerOptionsCache.set(options, cached);
+	}
+	if (!cached.stringLiteralOptions) cached.stringLiteralOptions = {
+		...options,
+		needEscaped: false,
+		generateMap: false
+	};
+	return cached.stringLiteralOptions;
+}
+function getEvalTemplateHandlerOptions(options) {
+	if (options.generateMap === false) return options;
+	let cached = evalHandlerOptionsCache.get(options);
+	if (!cached) {
+		cached = {};
+		evalHandlerOptionsCache.set(options, cached);
+	}
+	if (!cached.templateLiteralOptions) cached.templateLiteralOptions = {
+		...options,
+		generateMap: false
+	};
+	return cached.templateLiteralOptions;
+}
+function walkEvalExpression(path, options, updater, handler) {
+	const stringHandlerOptions = getEvalStringHandlerOptions(options);
+	const templateHandlerOptions = getEvalTemplateHandlerOptions(options);
+	const maybeTraverse = path?.traverse;
+	if (typeof maybeTraverse === "function") try {
+		return maybeTraverse.call(path, {
+			StringLiteral(innerPath) {
+				handleEvalStringLiteral(innerPath, stringHandlerOptions, updater, handler);
+			},
+			TemplateElement(innerPath) {
+				handleEvalTemplateElement(innerPath, templateHandlerOptions, updater, handler);
+			}
+		});
+	} catch (error) {
+		const msg = error?.message ?? "";
+		if (!EVAL_SCOPE_ERROR_REGEXP.test(msg)) throw error;
+	}
+	const getArgs = path?.get?.("arguments");
+	if (Array.isArray(getArgs)) {
+		for (const arg of getArgs) {
+			if (arg?.isStringLiteral?.()) {
+				handleEvalStringLiteral(arg, stringHandlerOptions, updater, handler);
+				continue;
+			}
+			if (arg?.isTemplateLiteral?.()) for (const quasi of arg.get("quasis")) handleEvalTemplateElement(quasi, templateHandlerOptions, updater, handler);
+		}
+		return;
+	}
+	const nodeArgs = path?.node?.arguments;
+	if (Array.isArray(nodeArgs)) {
+		for (const n of nodeArgs) if (n?.type === "StringLiteral") handleEvalStringLiteral({
+			node: n,
+			isStringLiteral: () => true
+		}, stringHandlerOptions, updater, handler);
+		else if (n?.type === "TemplateLiteral" && Array.isArray(n.quasis)) for (const q of n.quasis) handleEvalTemplateElement({
+			node: q,
+			isStringLiteral: () => false,
+			isTemplateElement: () => true
+		}, templateHandlerOptions, updater, handler);
+	}
+}
+//#endregion
+//#region src/js/JsTokenUpdater.ts
+/**
+* Lightweight helper that batches updates to {@link MagicString}.
+* It keeps the transformation logic out of the traversal code and makes
+* it easier to reason about the order in which tokens are written back.
+*/
+var JsTokenUpdater = class {
+	constructor({ value } = {}) {
+		this.tokens = value ? [...value] : [];
+	}
+	addToken(token) {
+		if (token) this.tokens.push(token);
+	}
+	push(...args) {
+		this.tokens.push(...args);
+		return this;
+	}
+	/**
+	* 待写入的 token 数量。
+	*/
+	get length() {
+		return this.tokens.length;
+	}
+	map(callbackfn) {
+		this.tokens = this.tokens.map(callbackfn);
+		return this;
+	}
+	filter(callbackfn) {
+		this.tokens = this.tokens.filter(callbackfn);
+		return this;
+	}
+	updateMagicString(ms) {
+		for (const { start, end, value } of this.tokens) ms.update(start, end, value);
+		return ms;
+	}
+};
+//#endregion
+//#region src/js/module-graph/ignored-exports.ts
+var IgnoredExportsTracker = class {
+	constructor(options) {
+		this.options = options;
+		this.ignoredExportNames = /* @__PURE__ */ new Map();
+	}
+	addIgnoredExport(filename, exportName) {
+		if (!exportName) return;
+		let pending = this.ignoredExportNames.get(filename);
+		if (!pending) {
+			pending = /* @__PURE__ */ new Set();
+			this.ignoredExportNames.set(filename, pending);
+		}
+		if (pending.has(exportName)) return;
+		pending.add(exportName);
+		const existing = this.options.modules.get(filename);
+		if (existing) this.applyIgnoredExportsToAnalysis(filename, existing.analysis);
+	}
+	registerIgnoredExportsFromTokens(resolved, tokens) {
+		for (const token of tokens) if (token.type === "ImportSpecifier") this.addIgnoredExport(resolved, token.imported);
+		else if (token.type === "ImportDefaultSpecifier") this.addIgnoredExport(resolved, "default");
+	}
+	applyIgnoredExportsToAnalysis(filename, analysis) {
+		const pending = this.ignoredExportNames.get(filename);
+		if (!pending || pending.size === 0) return;
+		const names = new Set(pending);
+		pending.clear();
+		const propagate = [];
+		for (const exportPath of analysis.exportDeclarations) {
+			if (names.size === 0) break;
+			if (exportPath.isExportDefaultDeclaration()) {
+				if (names.has("default")) {
+					analysis.walker.walkExportDefaultDeclaration(exportPath);
+					names.delete("default");
+				}
+				continue;
+			}
+			if (exportPath.isExportNamedDeclaration()) {
+				const source = exportPath.node.source?.value;
+				if (typeof source === "string") {
+					for (const spec of exportPath.get("specifiers")) {
+						if (!spec.isExportSpecifier()) continue;
+						const exported = spec.get("exported");
+						let exportedName;
+						if (exported.isIdentifier()) exportedName = exported.node.name;
+						else if (exported.isStringLiteral()) exportedName = exported.node.value;
+						if (!exportedName || !names.has(exportedName)) continue;
+						const local = spec.get("local");
+						if (local.isIdentifier()) {
+							propagate.push({
+								specifier: source,
+								exportName: local.node.name
+							});
+							names.delete(exportedName);
+						} else if (local.isStringLiteral()) {
+							propagate.push({
+								specifier: source,
+								exportName: local.node.value
+							});
+							names.delete(exportedName);
+						}
+					}
+					continue;
+				}
+				const declaration = exportPath.get("declaration");
+				if (declaration.isVariableDeclaration()) for (const decl of declaration.get("declarations")) {
+					const id = decl.get("id");
+					if (id.isIdentifier()) {
+						const exportName = id.node.name;
+						if (names.has(exportName)) {
+							analysis.walker.walkVariableDeclarator(decl);
+							names.delete(exportName);
+						}
+					}
+				}
+				for (const spec of exportPath.get("specifiers")) {
+					if (!spec.isExportSpecifier()) continue;
+					const exported = spec.get("exported");
+					let exportedName;
+					if (exported.isIdentifier()) exportedName = exported.node.name;
+					else if (exported.isStringLiteral()) exportedName = exported.node.value;
+					if (!exportedName || !names.has(exportedName)) continue;
+					const local = spec.get("local");
+					analysis.walker.walkNode(local);
+					names.delete(exportedName);
+				}
+				continue;
+			}
+			if (exportPath.isExportAllDeclaration()) {
+				const source = exportPath.node.source?.value;
+				if (typeof source === "string") {
+					for (const exportName of names) propagate.push({
+						specifier: source,
+						exportName
+					});
+					names.clear();
+				}
+			}
+		}
+		for (const { specifier, exportName } of propagate) {
+			let resolved;
+			try {
+				resolved = this.options.resolve(specifier, filename);
+			} catch {
+				resolved = void 0;
+			}
+			if (!resolved) {
+				pending.add(exportName);
+				continue;
+			}
+			if (this.options.filter && !this.options.filter(resolved, specifier, filename)) {
+				pending.add(exportName);
+				continue;
+			}
+			this.addIgnoredExport(resolved, exportName);
+		}
+		for (const name of names) pending.add(name);
+	}
+};
+//#endregion
+//#region src/js/ModuleGraph.ts
+var JsModuleGraph = class {
+	constructor(entry, graphOptions) {
+		this.modules = /* @__PURE__ */ new Map();
+		this.queue = [];
+		this.resolve = graphOptions.resolve;
+		this.load = graphOptions.load;
+		this.filter = graphOptions.filter;
+		this.maxDepth = graphOptions.maxDepth ?? Number.POSITIVE_INFINITY;
+		const { moduleGraph: _moduleGraph, filename: _ignoredFilename, ...rest } = entry.handlerOptions;
+		this.baseOptions = {
+			...rest,
+			filename: entry.filename
+		};
+		this.parserOptions = entry.handlerOptions.babelParserOptions;
+		this.rootFilename = entry.filename;
+		this.ignoredExports = new IgnoredExportsTracker({
+			resolve: this.resolve,
+			filter: this.filter,
+			modules: this.modules
+		});
+		this.modules.set(entry.filename, {
+			filename: entry.filename,
+			source: entry.source,
+			analysis: entry.analysis
+		});
+		this.queue.push({
+			filename: entry.filename,
+			depth: 0
+		});
+	}
+	build() {
+		this.collectDependencies();
+		let linked;
+		for (const [filename, state] of this.modules) {
+			if (filename === this.rootFilename) continue;
+			const childOptions = {
+				...this.baseOptions,
+				filename
+			};
+			const code = processUpdatedSource(state.source, childOptions, state.analysis).toString();
+			if (code !== state.source) {
+				if (!linked) linked = {};
+				linked[filename] = { code };
+			}
+		}
+		return linked;
+	}
+	collectDependencies() {
+		while (this.queue.length > 0) {
+			const { filename, depth } = this.queue.shift();
+			if (depth >= this.maxDepth) continue;
+			const state = this.modules.get(filename);
+			if (!state) continue;
+			const dependencySpecifiers = /* @__PURE__ */ new Map();
+			for (const token of state.analysis.walker.imports) {
+				if (!dependencySpecifiers.has(token.source)) dependencySpecifiers.set(token.source, []);
+				dependencySpecifiers.get(token.source).push(token);
+			}
+			for (const exportPath of state.analysis.exportDeclarations) if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
+				const source = exportPath.node.source?.value;
+				if (typeof source === "string" && !dependencySpecifiers.has(source)) dependencySpecifiers.set(source, []);
+			}
+			for (const [specifier, tokens] of dependencySpecifiers) {
+				let resolved;
+				try {
+					resolved = this.resolve(specifier, filename);
+				} catch {
+					continue;
+				}
+				if (!resolved) continue;
+				if (this.filter && !this.filter(resolved, specifier, filename)) continue;
+				if (tokens.length > 0) this.ignoredExports.registerIgnoredExportsFromTokens(resolved, tokens);
+				if (this.modules.has(resolved)) continue;
+				let source;
+				try {
+					source = this.load(resolved);
+				} catch {
+					continue;
+				}
+				if (typeof source !== "string") continue;
+				let analysis;
+				try {
+					analysis = analyzeSource(babelParse(source, {
+						...this.parserOptions,
+						sourceFilename: resolved
+					}), {
+						...this.baseOptions,
+						filename: resolved
+					});
+					this.ignoredExports.applyIgnoredExportsToAnalysis(resolved, analysis);
+				} catch {
+					continue;
+				}
+				this.modules.set(resolved, {
+					filename: resolved,
+					source,
+					analysis
+				});
+				this.queue.push({
+					filename: resolved,
+					depth: depth + 1
+				});
+			}
+		}
+	}
+};
+//#endregion
+//#region src/js/node-path-walker/export-handlers.ts
+function walkExportDeclaration(ctx, path) {
+	if (path.isExportDeclaration()) {
+		if (path.isExportNamedDeclaration()) walkExportNamedDeclaration(ctx, path);
+		else if (path.isExportDefaultDeclaration()) walkExportDefaultDeclaration(ctx, path);
+		else if (path.isExportAllDeclaration()) walkExportAllDeclaration(ctx, path);
+	}
+}
+function walkExportNamedDeclaration(ctx, path) {
+	const declaration = path.get("declaration");
+	if (declaration.isVariableDeclaration()) for (const decl of declaration.get("declarations")) ctx.walkNode(decl);
+	const specifiers = path.get("specifiers");
+	for (const spec of specifiers) if (spec.isExportSpecifier()) {
+		const local = spec.get("local");
+		if (local.isIdentifier()) ctx.walkNode(local);
+	}
+}
+function walkExportDefaultDeclaration(ctx, path) {
+	const decl = path.get("declaration");
+	if (decl.isIdentifier()) ctx.walkNode(decl);
+	else ctx.walkNode(decl);
+}
+function walkExportAllDeclaration(ctx, path) {
+	const source = path.get("source");
+	if (source.isStringLiteral()) ctx.addImportToken({
+		declaration: path,
+		source: source.node.value,
+		type: "ExportAllDeclaration"
+	});
+}
+//#endregion
+//#region src/js/node-path-walker/import-tokens.ts
+function maybeAddImportToken(imports, arg) {
+	if (!(arg.isImportSpecifier() && arg.node.importKind !== "type" || arg.isImportDefaultSpecifier())) return false;
+	const importDeclaration = arg.parentPath;
+	if (!importDeclaration.isImportDeclaration() || importDeclaration.node.importKind === "type") return false;
+	if (arg.isImportSpecifier()) {
+		const imported = arg.get("imported");
+		if (imported.isIdentifier()) imports.add({
+			declaration: importDeclaration,
+			specifier: arg,
+			imported: imported.node.name,
+			local: arg.node.local.name,
+			source: importDeclaration.node.source.value,
+			type: "ImportSpecifier"
+		});
+		return true;
+	}
+	imports.add({
+		declaration: importDeclaration,
+		specifier: arg,
+		local: arg.node.local.name,
+		source: importDeclaration.node.source.value,
+		type: "ImportDefaultSpecifier"
+	});
+	return true;
+}
+//#endregion
+//#region src/js/NodePathWalker.ts
+const EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS = [];
+const EMPTY_IMPORT_TOKENS = /* @__PURE__ */ new Set();
+function NOOP_STRING_PATH_CALLBACK() {}
+const NEVER_MATCH_NAME = () => false;
+/**
+* 遍历我们关注的调用表达式所关联的绑定，收集后续需要转换的字符串节点。
+*/
+var NodePathWalker = class {
+	constructor({ ignoreCallExpressionIdentifiers, callback } = {}) {
+		this.hasIgnoredCallIdentifiers = Boolean(ignoreCallExpressionIdentifiers && ignoreCallExpressionIdentifiers.length > 0);
+		this.ignoreCallExpressionIdentifiers = ignoreCallExpressionIdentifiers ?? EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS;
+		this.callback = callback ?? NOOP_STRING_PATH_CALLBACK;
+		this.isIgnoredCallIdentifier = this.hasIgnoredCallIdentifiers ? createNameMatcher(this.ignoreCallExpressionIdentifiers, { exact: true }) : NEVER_MATCH_NAME;
+	}
+	get imports() {
+		return this.importsStore ?? EMPTY_IMPORT_TOKENS;
+	}
+	getWritableImports() {
+		if (!this.importsStore) this.importsStore = /* @__PURE__ */ new Set();
+		return this.importsStore;
+	}
+	addImportToken(token) {
+		this.getWritableImports().add(token);
+	}
+	getVisited() {
+		if (!this.visitedStore) this.visitedStore = /* @__PURE__ */ new WeakSet();
+		return this.visitedStore;
+	}
+	walkVariableDeclarator(path) {
+		const init = path.get("init");
+		this.walkNode(init);
+	}
+	walkTemplateLiteral(path) {
+		for (const exp of path.get("expressions")) this.walkNode(exp);
+		for (const quasis of path.get("quasis")) this.callback(quasis);
+	}
+	walkStringLiteral(path) {
+		this.callback(path);
+	}
+	walkBinaryExpression(path) {
+		const left = path.get("left");
+		this.walkNode(left);
+		const right = path.get("right");
+		this.walkNode(right);
+	}
+	walkLogicalExpression(path) {
+		const left = path.get("left");
+		this.walkNode(left);
+		const right = path.get("right");
+		this.walkNode(right);
+	}
+	walkObjectExpression(path) {
+		const props = path.get("properties");
+		for (const prop of props) if (prop.isObjectProperty()) {
+			const key = prop.get("key");
+			this.walkNode(key);
+			const value = prop.get("value");
+			this.walkNode(value);
+		}
+	}
+	walkArrayExpression(path) {
+		const elements = path.get("elements");
+		for (const element of elements) this.walkNode(element);
+	}
+	walkNode(arg) {
+		const visited = this.getVisited();
+		if (visited.has(arg)) return;
+		visited.add(arg);
+		if (arg.isIdentifier()) {
+			const binding = arg?.scope?.getBinding?.(arg.node.name);
+			if (binding) this.walkNode(binding.path);
+		} else if (arg.isMemberExpression()) {
+			const objectPath = arg.get("object");
+			if (objectPath.isIdentifier()) {
+				const binding = arg?.scope?.getBinding?.(objectPath.node.name);
+				if (binding) {
+					if (binding.path.isVariableDeclarator()) this.walkVariableDeclarator(binding.path);
+				}
+			}
+		} else if (arg.isTemplateLiteral()) this.walkTemplateLiteral(arg);
+		else if (arg.isStringLiteral()) this.walkStringLiteral(arg);
+		else if (arg.isBinaryExpression()) this.walkBinaryExpression(arg);
+		else if (arg.isLogicalExpression()) this.walkLogicalExpression(arg);
+		else if (arg.isObjectExpression()) this.walkObjectExpression(arg);
+		else if (arg.isArrayExpression()) this.walkArrayExpression(arg);
+		else if (arg.isVariableDeclarator()) this.walkVariableDeclarator(arg);
+		else if (maybeAddImportToken(this.getWritableImports(), arg)) {}
+	}
+	/**
+	* Walk the arguments of a desired call expression so their bindings can be analysed.
+	*/
+	walkCallExpression(path) {
+		if (!this.hasIgnoredCallIdentifiers) return;
+		const calleePath = path.get("callee");
+		if (calleePath.isIdentifier() && this.isIgnoredCallIdentifier(calleePath.node.name)) for (const arg of path.get("arguments")) this.walkNode(arg);
+	}
+	walkExportDeclaration(path) {
+		walkExportDeclaration(this, path);
+	}
+	walkExportNamedDeclaration(path) {
+		walkExportNamedDeclaration(this, path);
+	}
+	walkExportDefaultDeclaration(path) {
+		walkExportDefaultDeclaration(this, path);
+	}
+	walkExportAllDeclaration(path) {
+		walkExportAllDeclaration(this, path);
+	}
+};
+//#endregion
+//#region src/js/taggedTemplateIgnore.ts
+function createTaggedTemplateIgnore({ matcher, names }) {
+	const bindingIgnoreCache = /* @__PURE__ */ new Map();
+	const taggedTemplateIgnoreCache = /* @__PURE__ */ new WeakMap();
+	const seenBindings = /* @__PURE__ */ new Set();
+	let singleCanonicalIgnoreName;
+	let canonicalIgnoreNames;
+	for (const item of names ?? []) {
+		if (typeof item !== "string") continue;
+		if (singleCanonicalIgnoreName === void 0) {
+			singleCanonicalIgnoreName = item;
+			continue;
+		}
+		if (item === singleCanonicalIgnoreName) continue;
+		if (!canonicalIgnoreNames) {
+			canonicalIgnoreNames = new Set([singleCanonicalIgnoreName, item]);
+			continue;
+		}
+		canonicalIgnoreNames.add(item);
+	}
+	const hasCanonicalIgnoreNames = singleCanonicalIgnoreName !== void 0;
+	const matchesIgnoreName = (value) => {
+		if (hasCanonicalIgnoreNames) {
+			if (canonicalIgnoreNames) {
+				if (canonicalIgnoreNames.has(value)) return true;
+			} else if (value === singleCanonicalIgnoreName) return true;
+		}
+		return matcher(value);
+	};
+	const propertyMatches = (propertyPath) => {
+		if (!propertyPath) return false;
+		if (propertyPath.isIdentifier()) return matchesIgnoreName(propertyPath.node.name);
+		if (propertyPath.isStringLiteral()) return matchesIgnoreName(propertyPath.node.value);
+		return false;
+	};
+	const resolvesMemberExpressionToIgnore = (path, seen) => {
+		if (propertyMatches(path.get("property"))) return true;
+		const objectPath = path.get("object");
+		if (objectPath.isIdentifier()) {
+			const binding = (objectPath?.scope)?.getBinding?.(objectPath.node.name);
+			if (binding) return resolvesToWeappTwIgnore(binding, seen);
+		}
+		return false;
+	};
+	const resolvesToWeappTwIgnore = (binding, seen) => {
+		const cached = bindingIgnoreCache.get(binding);
+		if (cached !== void 0) return cached;
+		if (seen.has(binding)) return false;
+		seen.add(binding);
+		let result = false;
+		const bindingPath = binding.path;
+		if (bindingPath.isImportSpecifier()) {
+			const imported = bindingPath.node.imported;
+			if (imported.type === "Identifier" && matchesIgnoreName(imported.name)) result = true;
+			else if (imported.type === "StringLiteral" && matchesIgnoreName(imported.value)) result = true;
+		} else if (bindingPath.isVariableDeclarator()) {
+			const init = bindingPath.get("init");
+			if (init && init.node) {
+				if (init.isIdentifier()) {
+					const target = binding?.scope?.getBinding?.(init.node.name);
+					if (target) result = resolvesToWeappTwIgnore(target, seen);
+				} else if (init.isMemberExpression()) result = resolvesMemberExpressionToIgnore(init, seen);
+			}
+		}
+		bindingIgnoreCache.set(binding, result);
+		seen.delete(binding);
+		return result;
+	};
+	const getEffectiveTagPath = (tagPath) => {
+		let current = tagPath;
+		while (true) {
+			if (current.isParenthesizedExpression?.() || current.node.type === "ParenthesizedExpression") {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isTSAsExpression() || current.isTSTypeAssertion()) {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isTSNonNullExpression()) {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isTypeCastExpression?.()) {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isSequenceExpression()) {
+				const last = current.get("expressions").at(-1);
+				if (last) {
+					current = last;
+					continue;
+				}
+			}
+			if (current.isCallExpression?.() || current.node.type === "CallExpression") {
+				current = current.get("callee");
+				continue;
+			}
+			break;
+		}
+		return current;
+	};
+	const evaluateTagPath = (tagPath, seen) => {
+		if (tagPath.isCallExpression?.() || tagPath.node.type === "CallExpression") return evaluateTagPath(tagPath.get("callee"), seen);
+		if (tagPath.isIdentifier()) {
+			if (matchesIgnoreName(tagPath.node.name)) return true;
+			const binding = tagPath?.scope?.getBinding?.(tagPath.node.name);
+			if (binding) return resolvesToWeappTwIgnore(binding, seen);
+			return false;
+		}
+		if (tagPath.isMemberExpression()) return resolvesMemberExpressionToIgnore(tagPath, seen);
+		return false;
+	};
+	const computeIgnore = (tagPath) => {
+		const cached = taggedTemplateIgnoreCache.get(tagPath.node);
+		if (cached !== void 0) return cached;
+		const effectiveTagPath = getEffectiveTagPath(tagPath);
+		const effectiveCached = taggedTemplateIgnoreCache.get(effectiveTagPath.node);
+		if (effectiveCached !== void 0) {
+			taggedTemplateIgnoreCache.set(tagPath.node, effectiveCached);
+			return effectiveCached;
+		}
+		seenBindings.clear();
+		const result = evaluateTagPath(effectiveTagPath, seenBindings);
+		taggedTemplateIgnoreCache.set(effectiveTagPath.node, result);
+		taggedTemplateIgnoreCache.set(tagPath.node, result);
+		return result;
+	};
+	return {
+		shouldIgnore(tagPath) {
+			return computeIgnore(tagPath);
+		},
+		getEffectiveTagPath
+	};
+}
+//#endregion
+//#region src/js/babel.ts
+const EXPRESSION_WRAPPER_PREFIX = "(\n";
+const EXPRESSION_WRAPPER_SUFFIX = "\n)";
+const EMPTY_IGNORED_PATHS = /* @__PURE__ */ new WeakSet();
+const EMPTY_IMPORT_DECLARATIONS = /* @__PURE__ */ new Set();
+const EMPTY_EXPORT_DECLARATIONS = /* @__PURE__ */ new Set();
+const EMPTY_REQUIRE_CALL_PATHS = [];
+const ignoredTaggedTemplateMatcherCache = /* @__PURE__ */ new WeakMap();
+let defaultEvalHandler;
+function getIgnoredTaggedTemplateMatcher(options) {
+	const cached = ignoredTaggedTemplateMatcherCache.get(options);
+	if (cached) return cached;
+	const created = createNameMatcher(options.ignoreTaggedTemplateExpressionIdentifiers, { exact: true });
+	ignoredTaggedTemplateMatcherCache.set(options, created);
+	return created;
+}
+function getDefaultEvalHandler() {
+	if (!defaultEvalHandler) throw new Error("Default JS eval handler is not initialized.");
+	return defaultEvalHandler;
+}
+function analyzeSource(ast, options, handler, collectModuleMetadata = true) {
+	const jsTokenUpdater = new JsTokenUpdater();
+	const needScope = Boolean(options.ignoreCallExpressionIdentifiers && options.ignoreCallExpressionIdentifiers.length > 0);
+	const ignoredPaths = needScope ? /* @__PURE__ */ new WeakSet() : EMPTY_IGNORED_PATHS;
+	const walker = needScope ? new NodePathWalker({
+		ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
+		callback(path) {
+			ignoredPaths.add(path);
+		}
+	}) : new NodePathWalker();
+	let taggedTemplateIgnore;
+	const hasTaggedTemplateIgnoreIdentifiers = Boolean(options.ignoreTaggedTemplateExpressionIdentifiers && options.ignoreTaggedTemplateExpressionIdentifiers.length > 0);
+	function getTaggedTemplateIgnore() {
+		if (!taggedTemplateIgnore) taggedTemplateIgnore = createTaggedTemplateIgnore({
+			matcher: getIgnoredTaggedTemplateMatcher(options),
+			names: options.ignoreTaggedTemplateExpressionIdentifiers
+		});
+		return taggedTemplateIgnore;
+	}
+	const targetPaths = [];
+	const importDeclarations = collectModuleMetadata ? /* @__PURE__ */ new Set() : EMPTY_IMPORT_DECLARATIONS;
+	const exportDeclarations = collectModuleMetadata ? /* @__PURE__ */ new Set() : EMPTY_EXPORT_DECLARATIONS;
+	const requireCallPaths = collectModuleMetadata ? [] : EMPTY_REQUIRE_CALL_PATHS;
+	const evalHandler = handler ?? getDefaultEvalHandler();
+	traverse(ast, {
+		StringLiteral: { enter(p) {
+			if (isEvalPath(p.parentPath)) return;
+			targetPaths.push(p);
+		} },
+		TemplateElement: { enter: hasTaggedTemplateIgnoreIdentifiers ? (p) => {
+			const pp = p.parentPath;
+			if (pp.isTemplateLiteral()) {
+				const ppp = pp.parentPath;
+				if (isEvalPath(ppp)) return;
+				if (ppp.isTaggedTemplateExpression()) {
+					const tagPath = ppp.get("tag");
+					if (getTaggedTemplateIgnore().shouldIgnore(tagPath)) return;
+				}
+			}
+			targetPaths.push(p);
+		} : (p) => {
+			const pp = p.parentPath;
+			if (pp.isTemplateLiteral()) {
+				const ppp = pp.parentPath;
+				if (isEvalPath(ppp)) return;
+			}
+			targetPaths.push(p);
+		} },
+		CallExpression: { enter: !collectModuleMetadata && !needScope ? (p) => {
+			if (isEvalPath(p)) walkEvalExpression(p, options, jsTokenUpdater, evalHandler);
+		} : (p) => {
+			if (isEvalPath(p)) {
+				walkEvalExpression(p, options, jsTokenUpdater, evalHandler);
+				return;
+			}
+			const calleePath = p.get("callee");
+			if (collectModuleMetadata && calleePath.isIdentifier({ name: "require" }) && !p?.scope?.hasBinding?.("require")) {
+				const args = p.get("arguments");
+				if (Array.isArray(args) && args.length > 0) {
+					const first = args[0];
+					if (first?.isStringLiteral()) requireCallPaths.push(first);
+				}
+			}
+			if (needScope) walker.walkCallExpression(p);
+		} },
+		...collectModuleMetadata ? {
+			ImportDeclaration: { enter(p) {
+				importDeclarations.add(p);
+			} },
+			ExportDeclaration: { enter(p) {
+				exportDeclarations.add(p);
+			} }
+		} : {},
+		noScope: !needScope
+	});
+	return {
+		walker,
+		jsTokenUpdater,
+		ast,
+		targetPaths,
+		importDeclarations,
+		exportDeclarations,
+		requireCallPaths,
+		ignoredPaths
+	};
+}
+function jsHandler(rawSource, options) {
+	const shouldWrapExpression = Boolean(options.wrapExpression);
+	const source = shouldWrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+	let ast;
+	try {
+		ast = babelParse(source, options.babelParserOptions);
+	} catch (error) {
+		return {
+			code: rawSource,
+			error
+		};
+	}
+	const needsModuleMetadata = Boolean(options.moduleSpecifierReplacements || options.moduleGraph && options.filename);
+	const analysis = analyzeSource(ast, options, jsHandler, needsModuleMetadata);
+	const ms = processUpdatedSource(source, options, analysis);
+	if (shouldWrapExpression) {
+		const start = 0;
+		const end = source.length;
+		const prefixLength = 2;
+		const suffixLength = 2;
+		ms.remove(start, start + prefixLength);
+		ms.remove(end - suffixLength, end);
+	}
+	const result = { code: ms.toString() };
+	if (options.generateMap) Object.defineProperty(result, "map", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return ms.generateMap();
+		}
+	});
+	if (options.moduleGraph && options.filename) {
+		const linked = new JsModuleGraph({
+			filename: options.filename,
+			source: rawSource,
+			analysis,
+			handlerOptions: options
+		}, options.moduleGraph).build();
+		if (linked) result.linked = linked;
+	}
+	return result;
+}
+defaultEvalHandler = jsHandler;
+//#endregion
+//#region src/js/index.ts
+/** 默认 LRU 缓存最大条目数 */
+const RESULT_CACHE_MAX = 512;
+/** 仅对短片段做内层结果缓存，避免 bundler 热路径重复 hash 大块 JS。 */
+const CACHEABLE_SOURCE_MAX_LENGTH = 512;
+/** 为每个 ClassNameSet 实例分配递增 ID */
+const classNameSetIds = /* @__PURE__ */ new WeakMap();
+let nextClassNameSetId = 0;
+/**
+* 获取 ClassNameSet 的唯一身份 ID。
+* 每个 Set 引用分配一个递增整数，用于指纹计算。
+*/
+function getClassNameSetId(set) {
+	if (!set) return "none";
+	const existing = classNameSetIds.get(set);
+	if (existing !== void 0) return String(existing);
+	const id = nextClassNameSetId++;
+	classNameSetIds.set(set, id);
+	return String(id);
+}
+/** 缓存 IJsHandlerOptions -> fingerprint 的映射 */
+const fingerprintCache = /* @__PURE__ */ new WeakMap();
+/**
+* 计算选项指纹，包含所有影响转译结果的字段。
+* 不包含 filename、moduleGraph、jsPreserveClass。
+*/
+function getOptionsFingerprint(options) {
+	const cached = fingerprintCache.get(options);
+	if (cached) return cached;
+	const fingerprint = [
+		getClassNameSetId(options.classNameSet),
+		JSON.stringify(options.escapeMap ?? null),
+		options.needEscaped ? "1" : "0",
+		options.alwaysEscape ? "1" : "0",
+		options.unescapeUnicode ? "1" : "0",
+		options.generateMap ? "1" : "0",
+		options.uniAppX ? "1" : "0",
+		options.wrapExpression ? "1" : "0",
+		String(options.tailwindcssMajorVersion ?? ""),
+		String(options.staleClassNameFallback ?? ""),
+		String(options.jsArbitraryValueFallback ?? ""),
+		JSON.stringify(options.arbitraryValues ?? null),
+		JSON.stringify(options.ignoreCallExpressionIdentifiers ?? null),
+		JSON.stringify(options.ignoreTaggedTemplateExpressionIdentifiers?.map((v) => v instanceof RegExp ? v.source : v) ?? null),
+		JSON.stringify(options.moduleSpecifierReplacements ?? null),
+		JSON.stringify(options.babelParserOptions ?? null)
+	].join("|");
+	fingerprintCache.set(options, fingerprint);
+	return fingerprint;
+}
+function hasDefinedOverrides(options) {
+	if (!options) return false;
+	for (const key in options) if (options[key] !== void 0) return true;
+	return false;
+}
+function shouldCacheJsResult(rawSource, options) {
+	if (rawSource.length === 0 || rawSource.length > CACHEABLE_SOURCE_MAX_LENGTH) return false;
+	if (options.moduleGraph || options.filename) return false;
+	return true;
+}
+function createJsHandler(options) {
+	const defaults = {
+		escapeMap: options.escapeMap,
+		staleClassNameFallback: options.staleClassNameFallback,
+		jsArbitraryValueFallback: options.jsArbitraryValueFallback,
+		tailwindcssMajorVersion: options.tailwindcssMajorVersion,
+		arbitraryValues: options.arbitraryValues,
+		jsPreserveClass: options.jsPreserveClass,
+		generateMap: options.generateMap,
+		needEscaped: options.needEscaped,
+		alwaysEscape: options.alwaysEscape,
+		unescapeUnicode: options.unescapeUnicode,
+		babelParserOptions: options.babelParserOptions,
+		ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
+		ignoreTaggedTemplateExpressionIdentifiers: options.ignoreTaggedTemplateExpressionIdentifiers,
+		uniAppX: options.uniAppX,
+		moduleSpecifierReplacements: options.moduleSpecifierReplacements
+	};
+	/** 层1: 无 override 时，classNameSet -> resolvedOptions */
+	const defaultOptionsCache = /* @__PURE__ */ new WeakMap();
+	let resolvedOptionsWithoutClassNameSet;
+	/** 层2: 有 override 时，overrideOptions -> { bySet, noSet } */
+	const overrideOptionsCache = /* @__PURE__ */ new WeakMap();
+	const resultCache = new LRUCache({ max: RESULT_CACHE_MAX });
+	function resolveDefaultOptions(classNameSet) {
+		if (!classNameSet) {
+			if (!resolvedOptionsWithoutClassNameSet) resolvedOptionsWithoutClassNameSet = {
+				...defaults,
+				classNameSet
+			};
+			return resolvedOptionsWithoutClassNameSet;
+		}
+		const cached = defaultOptionsCache.get(classNameSet);
+		if (cached) return cached;
+		const created = {
+			...defaults,
+			classNameSet
+		};
+		defaultOptionsCache.set(classNameSet, created);
+		return created;
+	}
+	function getCachedJsResult(rawSource, resolvedOptions) {
+		if (!shouldCacheJsResult(rawSource, resolvedOptions)) return;
+		const key = `${getOptionsFingerprint(resolvedOptions)}:${md5Hash(rawSource)}`;
+		return resultCache.get(key);
+	}
+	function setCachedJsResult(rawSource, resolvedOptions, result) {
+		if (!shouldCacheJsResult(rawSource, resolvedOptions) || result.error || result.linked) return result;
+		const key = `${getOptionsFingerprint(resolvedOptions)}:${md5Hash(rawSource)}`;
+		resultCache.set(key, result);
+		return result;
+	}
+	function resolveOptions(classNameSet, overrideOptions) {
+		if (!hasDefinedOverrides(overrideOptions)) return resolveDefaultOptions(classNameSet);
+		let entry = overrideOptionsCache.get(overrideOptions);
+		if (!entry) {
+			entry = { bySet: /* @__PURE__ */ new WeakMap() };
+			overrideOptionsCache.set(overrideOptions, entry);
+		}
+		if (!classNameSet) {
+			if (entry.noSet) return entry.noSet;
+			const created = defuOverrideArray({
+				...overrideOptions,
+				classNameSet
+			}, defaults);
+			entry.noSet = created;
+			return created;
+		}
+		const cached = entry.bySet.get(classNameSet);
+		if (cached) return cached;
+		const created = defuOverrideArray({
+			...overrideOptions,
+			classNameSet
+		}, defaults);
+		entry.bySet.set(classNameSet, created);
+		return created;
+	}
+	function handler(rawSource, classNameSet, options) {
+		const resolvedOptions = resolveOptions(classNameSet, options);
+		const cached = getCachedJsResult(rawSource, resolvedOptions);
+		if (cached) return cached;
+		return setCachedJsResult(rawSource, resolvedOptions, jsHandler(rawSource, resolvedOptions));
+	}
+	return handler;
+}
+//#endregion
+//#region src/wxml/custom-attributes.ts
+function regTest(reg, str) {
+	reg.lastIndex = 0;
+	return reg.test(str);
+}
+function isPropsMatch(props, attr) {
+	if (Array.isArray(props)) {
+		let lowerAttr;
+		for (const prop of props) if (typeof prop === "string") {
+			lowerAttr ?? (lowerAttr = attr.toLowerCase());
+			if (prop.toLowerCase() === lowerAttr) return true;
+		} else if (regTest(prop, attr)) return true;
+		return false;
+	} else if (typeof props === "string") return props === attr;
+	else return regTest(props, attr);
+}
+function createAttributeMatcher(entities) {
+	if (!entities || entities.length === 0) return;
+	const wildcardAttributeRules = [];
+	const tagAttributeRuleMap = /* @__PURE__ */ new Map();
+	const regexpAttributeRules = [];
+	for (const [selector, props] of entities) if (selector === "*") wildcardAttributeRules.push(props);
+	else if (typeof selector === "string") {
+		const list = tagAttributeRuleMap.get(selector);
+		if (list) list.push(props);
+		else tagAttributeRuleMap.set(selector, [props]);
+	} else regexpAttributeRules.push([selector, props]);
+	return (tag, attr) => {
+		for (const props of wildcardAttributeRules) if (isPropsMatch(props, attr)) return true;
+		const tagRules = tagAttributeRuleMap.get(tag);
+		if (tagRules) {
+			for (const props of tagRules) if (isPropsMatch(props, attr)) return true;
+		}
+		for (const [selector, props] of regexpAttributeRules) if (regTest(selector, tag) && isPropsMatch(props, attr)) return true;
+		return false;
+	};
+}
+//#endregion
+//#region src/wxml/utils/codegen/legacy-visitor.ts
+function shouldSkipLegacyStringLiteral(path) {
+	if (t.isMemberExpression(path.parent)) return true;
+	return Boolean(t.isBinaryExpression(path.parent) && (t.isConditionalExpression(path.parentPath?.parent) || t.isLogicalExpression(path.parentPath?.parent)));
+}
+function createLegacyTraverseOptions(options, jsTokenUpdater) {
+	const legacyReplaceOptions = {
+		escapeMap: options.escapeMap,
+		classNameSet: options.runtimeSet,
+		needEscaped: true,
+		alwaysEscape: true
+	};
+	return {
+		StringLiteral(path) {
+			if (shouldSkipLegacyStringLiteral(path)) return;
+			jsTokenUpdater.addToken(replaceHandleValue(path, legacyReplaceOptions));
+		},
+		noScope: true
+	};
+}
+//#endregion
+//#region src/wxml/utils/codegen/legacy-rewriter.ts
+function rewriteLegacyExpression(match, options) {
+	const ast = parseExpression(match);
+	const jsTokenUpdater = new JsTokenUpdater();
+	traverse(ast, createLegacyTraverseOptions(options, jsTokenUpdater));
+	if (jsTokenUpdater.length === 0) return match;
+	const ms = new MagicString(match);
+	jsTokenUpdater.updateMagicString(ms);
+	return ms.toString();
+}
+//#endregion
+//#region src/wxml/utils/codegen.ts
+const WRAP_EXPRESSION_HANDLER_OPTIONS = Object.freeze({ wrapExpression: true });
+function generateCode(match, options = {}) {
+	try {
+		const { jsHandler, runtimeSet, wrapExpression } = options;
+		if (jsHandler && runtimeSet) {
+			const initial = jsHandler(match, runtimeSet, wrapExpression ? WRAP_EXPRESSION_HANDLER_OPTIONS : void 0);
+			if (!initial.error || wrapExpression) return initial.code;
+			return jsHandler(match, runtimeSet, WRAP_EXPRESSION_HANDLER_OPTIONS).code;
+		} else
+ /**
+		* @deprecated
+		*/
+		return rewriteLegacyExpression(match, options);
+	} catch {
+		return match;
+	}
+}
+//#endregion
+//#region src/wxml/whitespace.ts
+const WHITESPACE_CODES = new Set([
+	9,
+	10,
+	11,
+	12,
+	13,
+	32,
+	160,
+	65279
+]);
+function isWhitespace(char) {
+	if (char.length === 0) return false;
+	return WHITESPACE_CODES.has(char.charCodeAt(0));
+}
+function isAllWhitespace(value) {
+	for (let i = 0; i < value.length; i++) if (!WHITESPACE_CODES.has(value.charCodeAt(i))) return false;
+	return true;
+}
+//#endregion
+//#region src/wxml/Tokenizer.ts
+var Tokenizer = class {
+	constructor() {
+		this.reset();
+	}
+	processChar(char, index) {
+		switch (this.state) {
+			case 0:
+				if (isWhitespace(char)) {} else if (char === "{") {
+					this.state = 2;
+					this.bufferStartIndex = index;
+					this.buffer += char;
+					this.expressionBuffer = char;
+					this.expressionStartIndex = index;
+				} else {
+					this.state = 1;
+					this.bufferStartIndex = index;
+					this.buffer += char;
+				}
+				break;
+			case 1:
+				if (isWhitespace(char)) {
+					this.tokens.push({
+						start: this.bufferStartIndex,
+						end: index,
+						value: this.buffer,
+						expressions: this.expressions
+					});
+					this.buffer = "";
+					this.expressions = [];
+					this.state = 0;
+				} else if (char === "{") {
+					this.buffer += char;
+					this.expressionBuffer = char;
+					this.expressionStartIndex = index;
+					this.state = 2;
+				} else this.buffer += char;
+				break;
+			case 2:
+				if (char === "}") {
+					this.buffer += char;
+					this.expressionBuffer += char;
+					this.state = 3;
+				} else {
+					this.buffer += char;
+					this.expressionBuffer += char;
+				}
+				break;
+			case 3:
+				if (char === "}") {
+					this.buffer += char;
+					this.expressionBuffer += char;
+					this.expressions.push({
+						start: this.expressionStartIndex,
+						end: index + 1,
+						value: this.expressionBuffer
+					});
+					this.expressionBuffer = "";
+					this.state = 4;
+				} else {
+					this.buffer += char;
+					this.expressionBuffer += char;
+					this.state = 2;
+				}
+				break;
+			case 4:
+				if (isWhitespace(char)) {
+					this.tokens.push({
+						start: this.bufferStartIndex,
+						end: index,
+						value: this.buffer,
+						expressions: this.expressions
+					});
+					this.buffer = "";
+					this.expressions = [];
+					this.state = 0;
+				} else if (char === "{") {
+					this.expressionStartIndex = index;
+					this.expressionBuffer = char;
+					this.buffer += char;
+					this.state = 2;
+				} else {
+					this.buffer += char;
+					this.state = 1;
+				}
+				break;
+			default: throw new Error("Unexpected state");
+		}
+	}
+	run(input) {
+		this.reset();
+		for (let i = 0; i < input.length; i++) {
+			const char = input[i];
+			this.processChar(char, i);
+		}
+		if (this.buffer.length > 0) this.tokens.push({
+			start: this.bufferStartIndex,
+			end: input.length,
+			value: this.buffer,
+			expressions: this.expressions
+		});
+		const tokens = this.tokens;
+		this.reset();
+		return tokens;
+	}
+	reset() {
+		this.state = 0;
+		this.buffer = "";
+		this.tokens = [];
+		this.bufferStartIndex = 0;
+		this.expressionBuffer = "";
+		this.expressionStartIndex = 0;
+		this.expressions = [];
+	}
+};
+//#endregion
+//#region src/wxml/utils/fragment-helpers.ts
+function updateWhitespaceGap(ms, start, end, options) {
+	const gap = ms.slice(start, end);
+	if (isAllWhitespace(gap)) ms.update(start, end, replaceWxml(gap, {
+		keepEOL: false,
+		escapeMap: options.escapeMap,
+		ignoreHead: true
+	}));
+}
+function updateWxmlSegment(ms, start, end, options, keepEOL, ignoreHead) {
+	ms.update(start, end, replaceWxml(ms.slice(start, end), {
+		keepEOL,
+		escapeMap: options.escapeMap,
+		ignoreHead
+	}));
+}
+function updateExpressionSegment(ms, exp, options) {
+	const code = `{{${generateCode(exp.value.slice(2, -2), options)}}}`;
+	ms.update(exp.start, exp.end, code);
+}
+//#endregion
+//#region src/wxml/utils/fragment-updater.ts
+function handleEachClassFragment(ms, tokens, options = {}) {
+	let previousEnd = 0;
+	for (const token of tokens) {
+		if (token.start > previousEnd) updateWhitespaceGap(ms, previousEnd, token.start, options);
+		let p = token.start;
+		if (token.expressions.length > 0) {
+			for (const exp of token.expressions) {
+				if (exp.start > token.start && p < exp.start) updateWxmlSegment(ms, p, exp.start, options, true, p > 0);
+				updateExpressionSegment(ms, exp, options);
+				p = exp.end;
+			}
+			if (token.end > p) updateWxmlSegment(ms, p, token.end, options, false, true);
+		} else updateWxmlSegment(ms, token.start, token.end, options, false, false);
+		previousEnd = token.end;
+	}
+	if (tokens.length > 0) {
+		const lastToken = tokens[tokens.length - 1];
+		if (lastToken.end < ms.original.length) updateWhitespaceGap(ms, lastToken.end, ms.original.length, options);
+	}
+}
+//#endregion
+//#region src/wxml/utils/template-fragments.ts
+/**
+* 模块级共享 Tokenizer 实例，避免每次调用都重新创建。
+* Tokenizer.run() 末尾已调用 reset()，天然支持复用。
+*/
+const sharedTokenizer = new Tokenizer();
+function templateReplacer(original, options = {}, tokenizer) {
+	const ms = new MagicString(original);
+	handleEachClassFragment(ms, (tokenizer ?? sharedTokenizer).run(ms.original), options);
+	return ms.toString();
+}
+//#endregion
+//#region src/wxml/utils/custom-template.ts
+async function customTemplateHandler(rawSource, options, cachedMatcher) {
+	const { customAttributesEntities = [], disabledDefaultTemplateHandler, inlineWxs, runtimeSet, jsHandler } = options ?? {};
+	const matchCustomAttribute = cachedMatcher ?? createAttributeMatcher(customAttributesEntities);
+	const defaultTemplateHandlerEnabled = !disabledDefaultTemplateHandler;
+	let replaceOptions;
+	let cachedQuote;
+	let s;
+	let tag = "";
+	let wxsArray;
+	function getMagicString() {
+		if (!s) s = new MagicString(rawSource);
+		return s;
+	}
+	function getReplaceOptions(quote) {
+		if (!replaceOptions) {
+			replaceOptions = {
+				...options,
+				quote
+			};
+			cachedQuote = quote;
+			return replaceOptions;
+		}
+		if (cachedQuote !== quote) {
+			replaceOptions.quote = quote;
+			cachedQuote = quote;
+		}
+		return replaceOptions;
+	}
+	function isDefaultTemplateAttribute(name) {
+		if (name === "class" || name === "hover-class" || name === "virtualhostclass") return true;
+		const lowerName = name.toLowerCase();
+		return lowerName === "class" || lowerName === "hover-class" || lowerName === "virtualhostclass";
+	}
+	const parser = new Parser({
+		onopentagname(name) {
+			tag = name;
+		},
+		onattribute(name, value, quote) {
+			if (!value) return;
+			const shouldHandleDefault = defaultTemplateHandlerEnabled && isDefaultTemplateAttribute(name);
+			const shouldHandleCustom = matchCustomAttribute?.(tag, name) ?? false;
+			if (!shouldHandleDefault && !shouldHandleCustom) return;
+			getMagicString().update(parser.startIndex + name.length + 2, parser.endIndex - 1, templateReplacer(value, getReplaceOptions(quote)));
+		},
+		ontext(data) {
+			if (inlineWxs && tag === "wxs") (wxsArray ?? (wxsArray = [])).push({
+				data,
+				endIndex: parser.endIndex + 1,
+				startIndex: parser.startIndex
+			});
+		},
+		onclosetag() {
+			tag = "";
+		}
+	}, { xmlMode: true });
+	parser.write(rawSource);
+	parser.end();
+	for (const { data, endIndex, startIndex } of wxsArray ?? []) {
+		const { code } = await jsHandler(data, runtimeSet);
+		if (code !== data) getMagicString().update(startIndex, endIndex, code);
+	}
+	return s?.toString() ?? rawSource;
+}
+//#endregion
+//#region src/wxml/utils.ts
+function createTemplateHandler(options = {}) {
+	const cachedMatcher = createAttributeMatcher(options.customAttributesEntities);
+	const defaultOptions = options;
+	let cachedRuntimeSet;
+	let cachedOptionsWithRuntimeSet;
+	return (rawSource, opt) => {
+		const runtimeSet = opt?.runtimeSet;
+		if (runtimeSet === void 0) return customTemplateHandler(rawSource, defaultOptions, cachedMatcher);
+		if (cachedRuntimeSet !== runtimeSet || !cachedOptionsWithRuntimeSet) {
+			cachedRuntimeSet = runtimeSet;
+			cachedOptionsWithRuntimeSet = {
+				...defaultOptions,
+				runtimeSet
+			};
+		}
+		return customTemplateHandler(rawSource, cachedOptionsWithRuntimeSet, cachedMatcher);
+	};
+}
+//#endregion
+//#region src/context/handlers.ts
+function resolveRuntimePackageReplacements(option) {
+	if (!option) return;
+	const mapping = option === true ? DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS : option;
+	const normalized = {};
+	for (const [from, to] of Object.entries(mapping)) {
+		if (!from || typeof to !== "string" || to.length === 0) continue;
+		normalized[from] = to;
+	}
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions, tailwindcssMajorVersion) {
+	const { cssPreflight, cssPreflightRange, escapeMap, cssChildCombinatorReplaceValue, injectAdditionalCssVarScope, cssSelectorReplacement, rem2rpx, postcssOptions, cssRemoveProperty, cssRemoveHoverPseudoClass, cssPresetEnv, autoprefixer, uniAppX, px2rpx, unitsToPx, arbitraryValues, jsPreserveClass, staleClassNameFallback, jsArbitraryValueFallback, babelParserOptions, ignoreCallExpressionIdentifiers, ignoreTaggedTemplateExpressionIdentifiers, inlineWxs, disabledDefaultTemplateHandler, replaceRuntimePackages } = ctx;
+	const uniAppXEnabled = isUniAppXEnabled(uniAppX);
+	const resolvedUniAppXOptions = resolveUniAppXOptions(uniAppX);
+	const moduleSpecifierReplacements = resolveRuntimePackageReplacements(replaceRuntimePackages);
+	const styleHandler = createStyleHandler({
+		cssPreflight,
+		cssPreflightRange,
+		escapeMap,
+		cssChildCombinatorReplaceValue,
+		injectAdditionalCssVarScope,
+		cssSelectorReplacement,
+		rem2rpx,
+		postcssOptions,
+		cssRemoveProperty,
+		cssRemoveHoverPseudoClass,
+		cssPresetEnv,
+		autoprefixer,
+		uniAppX: uniAppXEnabled,
+		uniAppXUnsupported: resolvedUniAppXOptions.uvueUnsupported,
+		cssCalc: cssCalcOptions,
+		px2rpx,
+		unitsToPx,
+		majorVersion: tailwindcssMajorVersion
+	});
+	const jsHandler = createJsHandler({
+		escapeMap,
+		arbitraryValues,
+		jsPreserveClass,
+		staleClassNameFallback,
+		jsArbitraryValueFallback: jsArbitraryValueFallback ?? "auto",
+		tailwindcssMajorVersion,
+		generateMap: true,
+		babelParserOptions,
+		ignoreCallExpressionIdentifiers,
+		ignoreTaggedTemplateExpressionIdentifiers,
+		uniAppX: uniAppXEnabled,
+		moduleSpecifierReplacements
+	});
+	return {
+		styleHandler,
+		jsHandler,
+		templateHandler: createTemplateHandler({
+			customAttributesEntities,
+			escapeMap,
+			inlineWxs,
+			jsHandler,
+			disabledDefaultTemplateHandler
+		})
+	};
+}
+//#endregion
+//#region src/context/logger.ts
+const loggerLevelMap = {
+	error: 0,
+	warn: 1,
+	info: 3,
+	silent: -999
+};
+function applyLoggerLevel(logLevel) {
+	logger.level = loggerLevelMap[logLevel ?? "info"] ?? loggerLevelMap.info;
+}
+//#endregion
+//#region src/context/index.ts
+async function clearTailwindcssPatcherCache(patcher, options) {
+	if (!patcher) return;
+	const cacheOptions = patcher.options?.cache;
+	if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) return;
+	if (typeof patcher.clearCache === "function") try {
+		await patcher.clearCache({ scope: "all" });
+	} catch (error) {
+		logger.debug("failed to clear tailwindcss patcher cache via clearCache(): %O", error);
+	}
+	if (!options?.removeDirectory) return;
+	const cachePaths = /* @__PURE__ */ new Map();
+	const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
+	if (normalizedCacheOptions?.path) cachePaths.set(normalizedCacheOptions.path, false);
+	const privateCachePath = patcher?.cacheStore?.options?.path;
+	if (privateCachePath) cachePaths.set(privateCachePath, false);
+	if (options?.removeDirectory && normalizedCacheOptions?.dir) cachePaths.set(normalizedCacheOptions.dir, true);
+	if (!cachePaths.size) return;
+	for (const [cachePath, recursive] of cachePaths.entries()) try {
+		await rm(cachePath, {
+			force: true,
+			recursive
+		});
+	} catch (error) {
+		const err = error;
+		if (err?.code === "ENOENT") continue;
+		logger.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
+	}
+}
+function createInternalCompilerContext(opts) {
+	const ctx = defuOverrideArray(opts, getDefaultOptions(), {});
+	ctx.escapeMap = ctx.customReplaceDictionary;
+	applyLoggerLevel(ctx.logLevel);
+	const twPatcher = createTailwindcssPatcherFromContext(ctx);
+	logTailwindcssTarget("runtime", twPatcher, ctx.tailwindcssBasedir);
+	logRuntimeTailwindcssVersion(ctx.tailwindcssBasedir, twPatcher.packageInfo?.rootPath, twPatcher.packageInfo?.version);
+	warnMissingCssEntries(ctx, twPatcher);
+	const cssCalcOptions = applyV4CssCalcDefaults(ctx.cssCalc, twPatcher);
+	ctx.cssCalc = cssCalcOptions;
+	const { styleHandler, jsHandler, templateHandler } = createHandlersFromContext(ctx, toCustomAttributesEntities(ctx.customAttributes), cssCalcOptions, twPatcher.majorVersion);
+	ctx.styleHandler = styleHandler;
+	ctx.jsHandler = jsHandler;
+	ctx.templateHandler = templateHandler;
+	ctx.cache = initializeCache(ctx.cache);
+	ctx.twPatcher = twPatcher;
+	const refreshTailwindcssPatcher = async (options) => {
+		const previousPatcher = ctx.twPatcher;
+		if (options?.clearCache !== false) await clearTailwindcssPatcherCache(previousPatcher);
+		invalidateRuntimeClassSet(previousPatcher);
+		const nextPatcher = createTailwindcssPatcherFromContext(ctx);
+		Object.assign(previousPatcher, nextPatcher);
+		ctx.twPatcher = previousPatcher;
+		return previousPatcher;
+	};
+	ctx.refreshTailwindcssPatcher = refreshTailwindcssPatcher;
+	Object.defineProperty(ctx.twPatcher, refreshTailwindcssPatcherSymbol, {
+		value: refreshTailwindcssPatcher,
+		configurable: true
+	});
+	return ctx;
+}
+/**
+* 获取用户定义选项的内部表示，并初始化相关的处理程序和补丁。
+* @param opts - 用户定义的选项，可选。
+* @returns 返回一个包含内部用户定义选项的对象，包括样式、JS和模板处理程序，以及Tailwind CSS补丁。
+*/
+function getCompilerContext(opts) {
+	return withCompilerContextCache(opts, () => createInternalCompilerContext(opts));
+}
+//#endregion
+//#region src/js/precheck.ts
+/** 用于检测源码中是否包含类名相关模式的正则表达式 */
+const FAST_JS_TRANSFORM_HINT_RE = /className\b|class\s*=|classList\.|\b(?:twMerge|clsx|classnames|cn|cva)\b|\[["'`]class["'`]\]|text-\[|bg-\[|\b(?:[whpm]|px|py|mx|my|rounded|flex|grid|gap)-/;
+/** 用于检测源码中是否包含 import/export/require 语句的正则表达式 */
+const DEPENDENCY_HINT_RE = /\bimport\s*[("'`{*]|\brequire\s*\(|\bexport\s+\*\s+from\s+["'`]|\bexport\s*\{[^}]*\}\s*from\s+["'`]/;
+/**
+* 判断是否可以跳过 JS 转换。
+* 通过正则快速检测源码内容，避免不必要的 Babel AST 解析。
+*
+* @param rawSource - 原始 JS 源码字符串
+* @param options - 可选的 JS 处理器配置选项
+* @returns 如果可以跳过转换返回 `true`，否则返回 `false`
+*/
+function shouldSkipJsTransform(rawSource, options) {
+	if (process.env.WEAPP_TW_DISABLE_JS_PRECHECK === "1") return false;
+	if (!rawSource) return true;
+	if (options?.alwaysEscape) return false;
+	if (options?.moduleSpecifierReplacements && Object.keys(options.moduleSpecifierReplacements).length > 0) return false;
+	if (options?.wrapExpression) return false;
+	if (DEPENDENCY_HINT_RE.test(rawSource)) return false;
+	return !FAST_JS_TRANSFORM_HINT_RE.test(rawSource);
+}
+//#endregion
+//#region src/tailwindcss/recorder.ts
+function setupPatchRecorder(patcher, baseDir, options) {
+	const recorder = createPatchTargetRecorder(baseDir, patcher, options);
+	if (recorder?.message && options?.logMessage !== false) {
+		const prefix = options?.messagePrefix ? `${options.messagePrefix} ` : "";
+		logger$1.info("%s%s", prefix, recorder.message);
+	}
+	const onPatchCompleted = recorder?.onPatched ? async () => {
+		await recorder.onPatched();
+	} : void 0;
+	return {
+		recorder,
+		patchPromise: patcher ? createTailwindPatchPromise(patcher, onPatchCompleted) : Promise.resolve(),
+		onPatchCompleted
+	};
+}
+//#endregion
+export { refreshTailwindRuntimeState as _, createAttributeMatcher as a, isClassContextLiteralPath as c, traverse as d, toCustomAttributesEntities as f, ensureRuntimeClassSet as g, collectRuntimeClassSet as h, generateCode as i, replaceWxml as l, vitePluginName as m, shouldSkipJsTransform as n, analyzeSource as o, pluginName as p, getCompilerContext as r, JsTokenUpdater as s, setupPatchRecorder as t, babelParse as u, createDebug as v };