weapp-tailwindcss 5.4.2 → 5.5.1

package/dist/compiler-B0YSc0DY.js

@@ -0,0 +1,4877 @@
+import { resolveMpxPlatform } from "./framework.js";
+import { A as resolveBooleanObjectOption, Bt as resolveValidTailwindV4Candidates$1, Ft as resolveCssMacroTailwindV4Source, Mt as _defineProperty, Rt as shouldUseUniAppWebRpxCompatibility, T as omitUndefined, Tt as isFileMatchedByTailwindSourceEntries, a as resolveGeneratorRuntimeBranch, bt as createTailwindV4Engine$1, d as resolveTailwindV4SourceFromRuntime, i as normalizeWeappTailwindcssGeneratorOptions, t as createWeappTailwindcssGenerator, u as resolveTailwindV4Source$1, zt as loadTailwindV4DesignSystem } from "./generator-DyXTBPmE.js";
+import { c as getRuntimeClassSetCacheEntry, d as invalidateRuntimeClassSet, i as resolveUniAppXOptions, o as applyV4CssCalcDefaults, s as warnMissingCssEntries, t as createTailwindcssRuntimeFromContext, u as getRuntimeClassSetSignatureWithSources } from "./tailwindcss-BK9S7zuq.js";
+import { i as isMap, n as defuOverrideArray$1 } from "./utils-MVwpU07P.js";
+import { a as DEFAULT_PARSE_CACHE_MAX_SOURCE_LENGTH, i as resolveDefaultCssPreflight, o as HARD_PARSE_CACHE_MAX_ENTRIES, r as getDefaultOptions } from "./defaults-B5ep0ojb.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { splitCandidateTokens } from "@tailwindcss-mangle/engine";
+import { createStyleHandler, finalizeMiniProgramCss, finalizeMiniProgramCssRoot, postcss } from "@weapp-tailwindcss/postcss";
+import { LRUCache } from "lru-cache";
+import { rm } from "node:fs/promises";
+import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+import { md5 as md5Hash } from "@weapp-tailwindcss/shared/node";
+import { Parser } from "htmlparser2";
+import _babelTraverse from "@babel/traverse";
+import { parse, parseExpression } from "@babel/parser";
+import MagicString from "magic-string";
+import _createDebug from "debug";
+import { MappingChars2String, escape } from "@weapp-core/escape";
+import { Buffer } from "node:buffer";
+import { logger, pc } from "@weapp-tailwindcss/logger";
+import { walk } from "oxc-walker";
+import * as t from "@babel/types";
+//#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/regex.ts
+function escapeStringRegexp(str) {
+	if (typeof str !== "string") throw new TypeError("Expected a string");
+	return str.replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&").replaceAll("-", "\\x2d");
+}
+//#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;
+		if (needle === void 0) return;
+		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;
+			if (needle === void 0) return NEVER_MATCH_NAME$1;
+			return (value) => value === needle;
+		}
+		if (regexList.length === 0) return (value) => exactStrings.has(value);
+		if (exactStringCount === 0 && regexList.length === 1) {
+			const [regex] = regexList;
+			if (!regex) return NEVER_MATCH_NAME$1;
+			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;
+		if (!regex) return NEVER_MATCH_NAME$1;
+		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: HARD_PARSE_CACHE_MAX_ENTRIES });
+function genCacheKey(source, options) {
+	if (typeof options === "string") return `${md5Hash(source)}:${options}`;
+	return `${md5Hash(source)}:${JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val)}`;
+}
+function normalizeCacheMaxEntries(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 128;
+	return Math.min(Math.max(Math.floor(value), 0), HARD_PARSE_CACHE_MAX_ENTRIES);
+}
+function normalizeCacheMaxSourceLength(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_PARSE_CACHE_MAX_SOURCE_LENGTH;
+	return Math.max(Math.floor(value), 0);
+}
+function trimParseCache(maxEntries) {
+	while (parseCache.size > maxEntries) parseCache.pop();
+}
+function babelParse(code, opts = {}) {
+	const { cache, cacheKey, cacheMaxEntries, cacheMaxSourceLength, ...rest } = opts;
+	const maxEntries = normalizeCacheMaxEntries(cacheMaxEntries);
+	const maxSourceLength = normalizeCacheMaxSourceLength(cacheMaxSourceLength);
+	const shouldCache = cache === true && maxEntries > 0 && code.length <= maxSourceLength;
+	const cacheKeyString = shouldCache ? genCacheKey(code, cacheKey ?? rest) : void 0;
+	let result;
+	if (shouldCache) {
+		trimParseCache(maxEntries);
+		result = parseCache.get(cacheKeyString);
+	}
+	if (!result) {
+		const { cache: _cache, cacheKey: _cacheKey, cacheMaxEntries: _cacheMaxEntries, cacheMaxSourceLength: _cacheMaxSourceLength, ...parseOptions } = opts;
+		result = parse(code, parseOptions);
+		if (shouldCache) {
+			parseCache.set(cacheKeyString, result);
+			trimParseCache(maxEntries);
+		}
+	}
+	return result;
+}
+//#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/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, omitUndefined({
+		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 isPlainSlashPathCandidate(candidate) {
+	const slashIndex = candidate.indexOf("/");
+	if (slashIndex <= 0) return false;
+	if (isUrlLikeCandidate(candidate)) return true;
+	if (candidate.includes("[") || candidate.includes("]") || candidate.includes(":")) return false;
+	return !candidate.slice(0, slashIndex).includes("-");
+}
+const SKIP_RESULT = { decision: "skip" };
+const DIRECT_RESULT = { decision: "direct" };
+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. 除显式 alwaysEscape 外，不允许绕过 classNameSet。
+*
+* 返回结构化结果，附带已计算的 escapedValue 以避免下游重复 escape。
+*/
+function resolveClassNameTransformWithResult(candidate, { alwaysEscape, classNameSet, escapeMap, jsPreserveClass, classContext }) {
+	if (jsPreserveClass?.(candidate)) return SKIP_RESULT;
+	if (alwaysEscape) return DIRECT_RESULT;
+	if (!classContext && isPlainSlashPathCandidate(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
+		};
+	}
+	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 = /* @__PURE__ */ new Set([
+	"class",
+	"classname",
+	"hoverclass",
+	"virtualhostclass",
+	"rootclass"
+]);
+const CLASS_HELPER_IDENTIFIERS = /* @__PURE__ */ 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/js-string-escape.ts
+function jsStringEscape(value) {
+	return String(value).replaceAll(/[\n\r"'\\\u2028\u2029]/g, (character) => {
+		switch (character) {
+			case "\"":
+			case "'":
+			case "\\": return `\\${character}`;
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return character;
+		}
+	});
+}
+//#endregion
+//#region src/js/replacement-cache.ts
+const replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+const defaultReplacementCache = /* @__PURE__ */ new Map();
+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;
+}
+//#endregion
+//#region src/js/handlers.ts
+const debug$1 = createDebug("[js:handlers] ");
+const WEAPP_TW_IGNORE_MARKER = "weapp-tw";
+const IGNORE_MARKER = "ignore";
+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 isConditionTestLiteral(path) {
+	let current = path;
+	while (current?.parentPath) {
+		const parent = current.parentPath;
+		if (parent.isConditionalExpression()) return parent.node.test === current.node;
+		if (parent.isBinaryExpression() || parent.isCallExpression() || parent.isLogicalExpression() || parent.isMemberExpression() || parent.isUnaryExpression()) {
+			current = parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+}
+function extractLiteralValue(path, { unescapeUnicode }) {
+	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 {
+		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;
+	if (!alwaysEscape && (!classNameSet || classNameSet.size === 0)) return;
+	if (hasIgnoreComment(path.node)) return;
+	if (isConditionTestLiteral(path)) return;
+	const { literal, original, offset } = extractLiteralValue(path, options);
+	const candidates = splitCandidateTokens(literal);
+	if (candidates.length === 0) return;
+	const debugEnabled = debug$1.enabled;
+	const classContext = options.wrapExpression || isClassContextLiteralPath(path);
+	let transformed = literal;
+	let mutated = false;
+	let matchedCandidateCount = 0;
+	let escapedDecisionCount = 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);
+			}
+		}
+		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$1("runtimeSet size=%d candidates=%d matched=%d escapedHits=%d skipped=%d file=%s escapedSamples=%s skippedSamples=%s", classNameSet?.size ?? 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 } = {}) {
+		_defineProperty(this, "tokens", void 0);
+		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;
+		_defineProperty(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) {
+		_defineProperty(this, "modules", /* @__PURE__ */ new Map());
+		_defineProperty(this, "queue", []);
+		_defineProperty(this, "resolve", void 0);
+		_defineProperty(this, "load", void 0);
+		_defineProperty(this, "filter", void 0);
+		_defineProperty(this, "maxDepth", void 0);
+		_defineProperty(this, "baseOptions", void 0);
+		_defineProperty(this, "parserOptions", void 0);
+		_defineProperty(this, "rootFilename", void 0);
+		_defineProperty(this, "ignoredExports", void 0);
+		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 } = {}) {
+		_defineProperty(this, "ignoreCallExpressionIdentifiers", void 0);
+		_defineProperty(this, "callback", void 0);
+		_defineProperty(this, "isIgnoredCallIdentifier", void 0);
+		_defineProperty(this, "hasIgnoredCallIdentifiers", void 0);
+		_defineProperty(this, "importsStore", void 0);
+		_defineProperty(this, "visitedStore", void 0);
+		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 = /* @__PURE__ */ 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) => {
+		const propertyPath = path.get("property");
+		if (propertyMatches(propertyPath)) 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") {
+			const calleePath = tagPath.get("callee");
+			return evaluateTagPath(calleePath, 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({
+		...options.ignoreCallExpressionIdentifiers === void 0 ? {} : { 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),
+			...options.ignoreTaggedTemplateExpressionIdentifiers === void 0 ? {} : { 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();
+	const traverseOptions = {
+		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);
+			} }
+		} : {}
+	};
+	traverse(ast, {
+		...traverseOptions,
+		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 suffixLength = 2;
+		ms.remove(start, 2);
+		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/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/compiler/artifact.ts
+function createCssFragment(options) {
+	return {
+		id: options.id,
+		kind: options.kind,
+		root: postcss.parse(options.css, { from: options.sourceId }),
+		sourceId: options.sourceId,
+		scope: options.scope,
+		order: options.order ?? 0,
+		stage: options.stage ?? "raw"
+	};
+}
+function cloneCssFragment(fragment) {
+	return {
+		...fragment,
+		root: fragment.root.clone(),
+		scope: { ...fragment.scope }
+	};
+}
+function cloneGenerationArtifact(artifact) {
+	return {
+		fragments: artifact.fragments.map(cloneCssFragment),
+		classSet: new Set(artifact.classSet),
+		rawCandidates: new Set(artifact.rawCandidates),
+		dependencies: [...artifact.dependencies],
+		sourceEntries: [...artifact.sourceEntries],
+		...artifact.revision === void 0 ? {} : { revision: artifact.revision }
+	};
+}
+function createGenerationArtifact(fragments, options) {
+	return cloneGenerationArtifact({
+		fragments,
+		...options
+	});
+}
+//#endregion
+//#region src/compiler/candidate-index.ts
+var CandidateIndex = class {
+	constructor() {
+		_defineProperty(this, "candidatesBySource", /* @__PURE__ */ new Map());
+	}
+	sync(sourceId, candidates) {
+		const previous = this.candidatesBySource.get(sourceId) ?? /* @__PURE__ */ new Set();
+		const next = new Set(candidates);
+		const addedCandidates = new Set([...next].filter((candidate) => !previous.has(candidate)));
+		const removedCandidates = new Set([...previous].filter((candidate) => !next.has(candidate)));
+		this.candidatesBySource.set(sourceId, next);
+		return {
+			sourceId,
+			addedCandidates,
+			removedCandidates
+		};
+	}
+	remove(sourceId) {
+		const previous = this.candidatesBySource.get(sourceId) ?? /* @__PURE__ */ new Set();
+		this.candidatesBySource.delete(sourceId);
+		return {
+			sourceId,
+			addedCandidates: /* @__PURE__ */ new Set(),
+			removedCandidates: new Set(previous)
+		};
+	}
+	values() {
+		const values = /* @__PURE__ */ new Set();
+		for (const candidates of this.candidatesBySource.values()) for (const candidate of candidates) values.add(candidate);
+		return values;
+	}
+	get(sourceId) {
+		return new Set(this.candidatesBySource.get(sourceId) ?? []);
+	}
+	entries() {
+		return new Map([...this.candidatesBySource].map(([sourceId, candidates]) => [sourceId, new Set(candidates)]));
+	}
+	clear() {
+		this.candidatesBySource.clear();
+	}
+};
+//#endregion
+//#region src/compiler/compilation-scope-graph.ts
+function sourceNodeId(sourceId) {
+	return `source:${sourceId}`;
+}
+function dependencyNodeId(dependencyId) {
+	return `dependency:${dependencyId}`;
+}
+function createCompilationDependencyChanges(dependencyIds, type = "dependency-changed") {
+	return [...new Set(dependencyIds)].map((id) => ({
+		id,
+		type
+	}));
+}
+function mergeCompilationDependencyChanges(...groups) {
+	const changes = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const change of group ?? []) {
+		const previous = changes.get(change.id);
+		changes.set(change.id, {
+			id: change.id,
+			type: previous?.type === "config-changed" ? previous.type : change.type
+		});
+	}
+	return [...changes.values()];
+}
+function mergeCompilationScopeDependencies(...groups) {
+	const dependencies = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const dependency of group ?? []) {
+		const previous = dependencies.get(dependency.id);
+		if (previous && previous.kind !== dependency.kind) throw new Error(`同一个依赖不能对应不同类型：${dependency.id}`);
+		dependencies.set(dependency.id, { ...dependency });
+	}
+	return [...dependencies.values()];
+}
+function dependencySignature(source) {
+	return mergeCompilationScopeDependencies(source.dependencies).map((dependency) => `${dependency.kind}\0${dependency.id}`).sort().join("\0");
+}
+function createCompilationScopeGraph(scope, outputId, sources) {
+	const normalizedSources = [...sources].map((source) => ({
+		...source,
+		dependencies: mergeCompilationScopeDependencies(source.dependencies)
+	}));
+	const dependencies = mergeCompilationScopeDependencies(...normalizedSources.map((source) => source.dependencies));
+	const outputNodeId = `asset:${outputId}`;
+	return {
+		nodes: [
+			...normalizedSources.map((source) => ({
+				id: sourceNodeId(source.id),
+				kind: source.kind,
+				scope: { ...scope },
+				...source.content === void 0 ? {} : { content: source.content }
+			})),
+			...dependencies.map((dependency) => ({
+				id: dependencyNodeId(dependency.id),
+				kind: dependency.kind,
+				scope: { ...scope }
+			})),
+			{
+				id: outputNodeId,
+				kind: "asset",
+				scope: { ...scope }
+			}
+		],
+		edges: normalizedSources.flatMap((source) => [{
+			from: sourceNodeId(source.id),
+			to: outputNodeId,
+			kind: "emits-to"
+		}, ...source.dependencies.map((dependency) => ({
+			from: sourceNodeId(source.id),
+			to: dependencyNodeId(dependency.id),
+			kind: "depends-on"
+		}))])
+	};
+}
+function createCompilationScopeSnapshot(scope, outputId, sources, options = {}) {
+	const normalizedSources = [...sources];
+	return {
+		...createCompilationScopeGraph(scope, outputId, normalizedSources),
+		candidatesBySource: normalizedSources.map((source) => [sourceNodeId(source.id), source.candidates]),
+		...options.changes === void 0 ? {} : { changes: options.changes },
+		...options.preserveDeletedCss === void 0 ? {} : { preserveDeletedCss: options.preserveDeletedCss },
+		...options.validatedClassSet === void 0 ? {} : { validatedClassSet: options.validatedClassSet }
+	};
+}
+//#endregion
+//#region src/compiler/compilation-dependency-state.ts
+var CompilationDependencyState = class {
+	constructor() {
+		_defineProperty(this, "revisions", /* @__PURE__ */ new Map());
+	}
+	getAffectedScopes(entries, changes) {
+		return new Set(this.getAffectedScopeChanges(entries, changes).keys());
+	}
+	getAffectedScopeChanges(entries, changes) {
+		const changesByNodeId = new Map([...changes].map((change) => [dependencyNodeId(change.id), change]));
+		const affectedScopeChanges = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const scopeChanges = entry.latest?.graphNodes.map((node) => changesByNodeId.get(node.id)).filter((change) => change !== void 0);
+			if (scopeChanges && scopeChanges.length > 0) affectedScopeChanges.set(entry.scope.id, scopeChanges.map((change) => ({ ...change })));
+		}
+		return affectedScopeChanges;
+	}
+	record(entries, changes) {
+		const affectedScopes = this.getAffectedScopes(entries, changes);
+		this.recordScopes(affectedScopes);
+		return affectedScopes;
+	}
+	recordScopes(scopeIds) {
+		for (const scopeId of scopeIds) this.revisions.set(scopeId, (this.revisions.get(scopeId) ?? 0) + 1);
+	}
+	getRevision(scopeId) {
+		return this.revisions.get(scopeId) ?? 0;
+	}
+	delete(scopeId) {
+		this.revisions.delete(scopeId);
+	}
+	clear() {
+		this.revisions.clear();
+	}
+};
+//#endregion
+//#region src/compiler/compiler-owner-state.ts
+const compilerOwnerDisposals = /* @__PURE__ */ new WeakMap();
+const compilerOwnerActivities = /* @__PURE__ */ new WeakMap();
+function ensureCompilerOwnerActive(owner) {
+	if (compilerOwnerDisposals.has(owner)) throw new Error("Compiler owner 正在释放，不能创建新的编译状态。");
+}
+function acquireCompilerOwnerActivity(owner) {
+	const currentDisposal = compilerOwnerDisposals.get(owner);
+	if (currentDisposal) return currentDisposal.then(() => acquireCompilerOwnerActivity(owner));
+	let state = compilerOwnerActivities.get(owner);
+	if (!state) {
+		state = {
+			active: 0,
+			idleWaiters: /* @__PURE__ */ new Set()
+		};
+		compilerOwnerActivities.set(owner, state);
+	}
+	state.active += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		state.active -= 1;
+		if (state.active > 0) return;
+		compilerOwnerActivities.delete(owner);
+		for (const resolve of state.idleWaiters) resolve();
+		state.idleWaiters.clear();
+	};
+}
+function waitForCompilerOwnerIdle(owner) {
+	const state = compilerOwnerActivities.get(owner);
+	if (!state || state.active === 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		state.idleWaiters.add(resolve);
+	});
+}
+function runCompilerOwnerActivity(owner, activity) {
+	const acquired = acquireCompilerOwnerActivity(owner);
+	if (typeof acquired !== "function") return acquired.then((release) => runCompilerOwnerActivityWithRelease(activity, release));
+	return runCompilerOwnerActivityWithRelease(activity, acquired);
+}
+function runCompilerOwnerActivityWithRelease(activity, release) {
+	try {
+		return Promise.resolve(activity()).finally(release);
+	} catch (error) {
+		release();
+		return Promise.reject(error);
+	}
+}
+function runCompilerOwnerDisposal(owner, dispose) {
+	const currentDisposal = compilerOwnerDisposals.get(owner);
+	if (currentDisposal) return currentDisposal;
+	const disposal = Promise.resolve().then(async () => {
+		await waitForCompilerOwnerIdle(owner);
+		await dispose();
+	}).finally(() => {
+		if (compilerOwnerDisposals.get(owner) === disposal) compilerOwnerDisposals.delete(owner);
+	});
+	compilerOwnerDisposals.set(owner, disposal);
+	return disposal;
+}
+//#endregion
+//#region src/compiler/invalidation.ts
+function resolveInvalidatedScopes(graph, changes) {
+	const invalidatedScopes = /* @__PURE__ */ new Set();
+	const visit = (sourceId, visited) => {
+		if (visited.has(sourceId)) return;
+		visited.add(sourceId);
+		const node = graph.getNode(sourceId);
+		if (node) invalidatedScopes.add(node.scope.id);
+		for (const dependent of graph.getDependents(sourceId)) visit(dependent, visited);
+	};
+	for (const change of changes) visit(change.sourceId, /* @__PURE__ */ new Set());
+	return invalidatedScopes;
+}
+//#endregion
+//#region src/compiler/source-graph.ts
+var SourceGraph = class {
+	constructor() {
+		_defineProperty(this, "edges", /* @__PURE__ */ new Map());
+		_defineProperty(this, "nodes", /* @__PURE__ */ new Map());
+	}
+	replace(nodes, edges) {
+		this.clear();
+		for (const node of nodes) this.nodes.set(node.id, {
+			...node,
+			scope: { ...node.scope }
+		});
+		for (const edge of edges) {
+			if (!this.nodes.has(edge.from) || !this.nodes.has(edge.to)) throw new Error(`编译图边引用了不存在的节点：${edge.from} -> ${edge.to}`);
+			this.edges.set(this.edgeKey(edge), { ...edge });
+		}
+	}
+	getNode(id) {
+		const node = this.nodes.get(id);
+		return node ? {
+			...node,
+			scope: { ...node.scope }
+		} : void 0;
+	}
+	getNodes() {
+		return [...this.nodes.values()].map((node) => ({
+			...node,
+			scope: { ...node.scope }
+		}));
+	}
+	getEdges() {
+		return [...this.edges.values()].map((edge) => ({ ...edge }));
+	}
+	getDependents(id) {
+		return this.getEdges().filter((edge) => edge.to === id).map((edge) => edge.from);
+	}
+	clear() {
+		this.edges.clear();
+		this.nodes.clear();
+	}
+	edgeKey(edge) {
+		return `${edge.kind}\0${edge.from}\0${edge.to}`;
+	}
+};
+//#endregion
+//#region src/compiler/session.ts
+var DefaultCompilationSession = class {
+	constructor() {
+		_defineProperty(this, "candidateIndex", new CandidateIndex());
+		_defineProperty(this, "graph", new SourceGraph());
+		_defineProperty(this, "retainedCandidates", /* @__PURE__ */ new Set());
+		_defineProperty(this, "validatedClassSet", /* @__PURE__ */ new Set());
+		_defineProperty(this, "invalidatedScopes", /* @__PURE__ */ new Set());
+		_defineProperty(this, "revision", 0);
+	}
+	update(snapshot) {
+		const changes = [...snapshot.changes ?? []];
+		const invalidatedScopes = resolveInvalidatedScopes(this.graph, changes);
+		this.graph.replace(snapshot.nodes, snapshot.edges);
+		for (const [sourceId, candidates] of snapshot.candidatesBySource ?? []) {
+			const change = this.candidateIndex.sync(sourceId, candidates);
+			if (change.addedCandidates.size > 0 || change.removedCandidates.size > 0) changes.push(change);
+		}
+		for (const change of changes) if ("type" in change && change.type === "source-removed") this.candidateIndex.remove(change.sourceId);
+		const currentCandidates = this.candidateIndex.values();
+		if (snapshot.preserveDeletedCss) for (const candidate of currentCandidates) this.retainedCandidates.add(candidate);
+		else {
+			this.retainedCandidates.clear();
+			for (const candidate of currentCandidates) this.retainedCandidates.add(candidate);
+		}
+		if (snapshot.validatedClassSet !== void 0) this.validatedClassSet = new Set(snapshot.validatedClassSet);
+		else if (!snapshot.preserveDeletedCss) this.validatedClassSet = new Set([...this.validatedClassSet].filter((candidate) => this.retainedCandidates.has(candidate)));
+		this.revision += 1;
+		for (const scopeId of resolveInvalidatedScopes(this.graph, changes)) invalidatedScopes.add(scopeId);
+		this.invalidatedScopes = invalidatedScopes;
+		return this.createResult();
+	}
+	commitValidation(revision, validatedClassSet, graph) {
+		if (revision !== this.revision) throw new Error(`不能向编译 revision ${this.revision} 提交 revision ${revision} 的 classSet。`);
+		if (graph) this.graph.replace(graph.nodes, graph.edges);
+		this.validatedClassSet = new Set(validatedClassSet);
+		return this.createResult();
+	}
+	createResult() {
+		return {
+			revision: this.revision,
+			candidates: new Set(this.retainedCandidates),
+			candidatesBySource: this.candidateIndex.entries(),
+			validatedClassSet: new Set(this.validatedClassSet),
+			invalidatedScopes: new Set(this.invalidatedScopes),
+			graphEdges: this.graph.getEdges(),
+			graphNodes: this.graph.getNodes()
+		};
+	}
+	dispose() {
+		this.candidateIndex.clear();
+		this.graph.clear();
+		this.retainedCandidates.clear();
+		this.validatedClassSet.clear();
+		this.invalidatedScopes.clear();
+		this.revision = 0;
+	}
+};
+//#endregion
+//#region src/compiler/compilation-session-pool.ts
+const COMPILATION_SCOPE_CACHE_MAX = 128;
+function cloneScopeSource(source) {
+	return {
+		...source,
+		candidates: new Set(source.candidates),
+		dependencies: source.dependencies?.map((dependency) => ({ ...dependency }))
+	};
+}
+var CompilationSessionPool = class {
+	constructor() {
+		_defineProperty(this, "dependencyState", new CompilationDependencyState());
+		_defineProperty(this, "entries", /* @__PURE__ */ new Map());
+		_defineProperty(this, "disposed", false);
+	}
+	run(request, compile) {
+		const entry = this.getEntry(request.scope);
+		const execution = this.runEntry(entry, request, compile);
+		entry.executions.add(execution);
+		execution.then(() => entry.executions.delete(execution), () => entry.executions.delete(execution));
+		return execution;
+	}
+	invalidateScope(scopeId) {
+		const entry = this.entries.get(scopeId);
+		if (!entry) return;
+		entry.active = false;
+		this.disposeEntry(entry);
+		this.entries.delete(scopeId);
+		this.dependencyState.delete(scopeId);
+	}
+	dispose() {
+		if (this.disposed) return Promise.resolve();
+		this.disposed = true;
+		const entries = [...this.entries.values()];
+		for (const entry of entries) entry.active = false;
+		this.entries.clear();
+		this.dependencyState.clear();
+		return Promise.all(entries.map((entry) => this.disposeEntry(entry))).then(() => void 0);
+	}
+	get size() {
+		return this.entries.size;
+	}
+	getAffectedScopes(changes) {
+		return this.dependencyState.getAffectedScopes(this.entries.values(), changes);
+	}
+	getAffectedScopeChanges(changes) {
+		return this.dependencyState.getAffectedScopeChanges(this.entries.values(), changes);
+	}
+	recordDependencyChanges(changes) {
+		return this.dependencyState.record(this.entries.values(), changes);
+	}
+	recordAffectedScopes(scopeIds) {
+		this.dependencyState.recordScopes(scopeIds);
+	}
+	getScopeDependencyRevision(scopeId) {
+		return this.dependencyState.getRevision(scopeId);
+	}
+	getEntry(scope) {
+		if (this.disposed) throw new Error("CompilationSessionPool 已释放。");
+		const cached = this.entries.get(scope.id);
+		if (cached) {
+			if (cached.scope.kind !== scope.kind) throw new Error(`同一个 scope id 不能对应不同类型：${scope.id}`);
+			this.entries.delete(scope.id);
+			this.entries.set(scope.id, cached);
+			return cached;
+		}
+		const entry = {
+			active: true,
+			executions: /* @__PURE__ */ new Set(),
+			pending: Promise.resolve(),
+			scope: { ...scope },
+			session: new DefaultCompilationSession(),
+			generatedDependencies: /* @__PURE__ */ new Map(),
+			sources: /* @__PURE__ */ new Map()
+		};
+		this.entries.set(scope.id, entry);
+		while (this.entries.size > COMPILATION_SCOPE_CACHE_MAX) {
+			const oldestScopeId = this.entries.keys().next().value;
+			if (oldestScopeId === void 0 || oldestScopeId === scope.id) break;
+			this.invalidateScope(oldestScopeId);
+		}
+		return entry;
+	}
+	async disposeEntry(entry) {
+		await Promise.allSettled([...entry.executions]);
+		await entry.pending;
+		entry.session.dispose();
+	}
+	async runEntry(entry, request, compile) {
+		const prepared = await this.enqueue(entry, () => this.prepareEntry(entry, request));
+		const value = await compile(prepared.compilation);
+		const validatedClassSet = request.preserveDeletedCss ? /* @__PURE__ */ new Set([...prepared.compilation.validatedClassSet, ...value?.classSet ?? []]) : new Set(value?.classSet ?? []);
+		const generatedDependencies = value?.dependenciesBySource === void 0 ? void 0 : this.normalizeGeneratedDependencies(value.dependenciesBySource, prepared.sources);
+		let committed = false;
+		let committedCompilation;
+		await this.enqueue(entry, () => {
+			if (!entry.active || entry.latest?.revision !== prepared.compilation.revision) return;
+			if (generatedDependencies) entry.generatedDependencies = generatedDependencies;
+			entry.latest = entry.session.commitValidation(prepared.compilation.revision, validatedClassSet, createCompilationScopeGraph(request.scope, request.outputId, this.createGraphSources(prepared.sources, entry.generatedDependencies)));
+			committedCompilation = this.toScopeState(entry.latest, prepared.sources);
+			committed = true;
+		});
+		const compilation = committedCompilation ?? {
+			...prepared.compilation,
+			validatedClassSet
+		};
+		return committed ? {
+			committed,
+			compilation,
+			value
+		} : {
+			committed,
+			compilation
+		};
+	}
+	prepareEntry(entry, request) {
+		const nextSources = new Map(request.sources.map((source) => [source.id, cloneScopeSource(source)]));
+		const changes = [...request.changes ?? []].map((change) => ({
+			sourceId: dependencyNodeId(change.id),
+			type: change.type
+		}));
+		for (const sourceId of entry.sources.keys()) if (!nextSources.has(sourceId)) changes.push({
+			sourceId: sourceNodeId(sourceId),
+			type: "source-removed"
+		});
+		for (const [sourceId, source] of nextSources) {
+			const previous = entry.sources.get(sourceId);
+			if (previous && (previous.content !== source.content || dependencySignature(previous) !== dependencySignature(source))) changes.push({
+				sourceId: sourceNodeId(sourceId),
+				type: "dependency-changed"
+			});
+		}
+		entry.sources = nextSources;
+		entry.generatedDependencies = new Map([...entry.generatedDependencies].filter(([sourceId]) => nextSources.has(sourceId)));
+		entry.latest = entry.session.update(createCompilationScopeSnapshot(request.scope, request.outputId, this.createGraphSources(nextSources, entry.generatedDependencies), {
+			changes,
+			preserveDeletedCss: request.preserveDeletedCss
+		}));
+		return {
+			compilation: this.toScopeState(entry.latest, nextSources),
+			sources: nextSources
+		};
+	}
+	createGraphSources(sources, generatedDependencies) {
+		return [...sources.values()].map((source) => ({
+			...source,
+			dependencies: mergeCompilationScopeDependencies(source.dependencies, generatedDependencies.get(source.id))
+		}));
+	}
+	normalizeGeneratedDependencies(dependenciesBySource, sources) {
+		const normalized = /* @__PURE__ */ new Map();
+		for (const [sourceId, dependencies] of dependenciesBySource) {
+			if (!sources.has(sourceId)) throw new Error(`生成结果引用了未知 source：${sourceId}`);
+			normalized.set(sourceId, mergeCompilationScopeDependencies(normalized.get(sourceId), dependencies));
+		}
+		return normalized;
+	}
+	enqueue(entry, task) {
+		const execution = entry.pending.then(task);
+		entry.pending = execution.then(() => void 0, () => void 0);
+		return execution;
+	}
+	toScopeState(compilation, sources) {
+		return {
+			...compilation,
+			candidatesBySource: new Map([...sources.keys()].map((sourceId) => [sourceId, compilation.candidatesBySource.get(sourceNodeId(sourceId)) ?? /* @__PURE__ */ new Set()]))
+		};
+	}
+};
+const compilationSessionPools = /* @__PURE__ */ new WeakMap();
+function getCompilationSessionPool(owner) {
+	ensureCompilerOwnerActive(owner);
+	let pool = compilationSessionPools.get(owner);
+	if (!pool) {
+		pool = new CompilationSessionPool();
+		compilationSessionPools.set(owner, pool);
+	}
+	return pool;
+}
+function disposeCompilationSessionPool(owner) {
+	const pool = compilationSessionPools.get(owner);
+	if (!pool) return Promise.resolve();
+	compilationSessionPools.delete(owner);
+	return pool.dispose();
+}
+//#endregion
+//#region src/compiler/tailwind-generation-session-pool.ts
+const SESSION_ENGINE_CACHE_MAX = 32;
+function createSourceKey(source) {
+	return md5Hash([
+		source.projectRoot,
+		source.base,
+		source.baseFallbacks.join("\0"),
+		source.css,
+		source.dependencies.join("\0")
+	].join("\0"));
+}
+function disposeGenerator$1(generator) {
+	generator?.dispose?.();
+}
+var TailwindGenerationSessionPool = class {
+	constructor() {
+		_defineProperty(this, "generators", /* @__PURE__ */ new Map());
+		_defineProperty(this, "disposed", false);
+	}
+	async generate(source, options) {
+		return this.getGenerator(source).generate(options);
+	}
+	async validateCandidates(source, candidates) {
+		return this.getGenerator(source).validateCandidates(candidates);
+	}
+	invalidate(change) {
+		if (change.type === "all" || change.type === "dependencies") {
+			for (const generator of this.generators.values()) disposeGenerator$1(generator);
+			this.generators.clear();
+			return;
+		}
+		const key = createSourceKey(change.source);
+		disposeGenerator$1(this.generators.get(key));
+		this.generators.delete(key);
+	}
+	dispose() {
+		for (const generator of this.generators.values()) disposeGenerator$1(generator);
+		this.generators.clear();
+		this.disposed = true;
+	}
+	get size() {
+		return this.generators.size;
+	}
+	getGenerator(source) {
+		if (this.disposed) throw new Error("TailwindGenerationSessionPool 已释放。");
+		const key = createSourceKey(source);
+		const cached = this.generators.get(key);
+		if (cached) {
+			this.generators.delete(key);
+			this.generators.set(key, cached);
+			return cached;
+		}
+		const generator = createWeappTailwindcssGenerator(source);
+		this.generators.set(key, generator);
+		while (this.generators.size > SESSION_ENGINE_CACHE_MAX) {
+			const oldest = this.generators.keys().next().value;
+			if (oldest === void 0) break;
+			disposeGenerator$1(this.generators.get(oldest));
+			this.generators.delete(oldest);
+		}
+		return generator;
+	}
+};
+const sessionPools = /* @__PURE__ */ new WeakMap();
+function getTailwindGenerationSessionPool(owner) {
+	ensureCompilerOwnerActive(owner);
+	let pool = sessionPools.get(owner);
+	if (!pool) {
+		pool = new TailwindGenerationSessionPool();
+		sessionPools.set(owner, pool);
+	}
+	return pool;
+}
+function disposeTailwindGenerationSessionPool(owner) {
+	const pool = sessionPools.get(owner);
+	if (!pool) return;
+	sessionPools.delete(owner);
+	pool.dispose();
+}
+//#endregion
+//#region src/compiler/compilation-change-coordinator.ts
+var CompilationChangeCoordinator = class {
+	constructor(compilationPool, generationPool) {
+		this.compilationPool = compilationPool;
+		this.generationPool = generationPool;
+		_defineProperty(this, "pendingChangesByScope", /* @__PURE__ */ new Map());
+		_defineProperty(this, "disposed", false);
+	}
+	record(changes) {
+		this.ensureActive();
+		const normalizedChanges = mergeCompilationDependencyChanges(changes);
+		if (normalizedChanges.length === 0) return /* @__PURE__ */ new Set();
+		const affectedScopeChanges = this.compilationPool.getAffectedScopeChanges(normalizedChanges);
+		const affectedScopes = new Set(affectedScopeChanges.keys());
+		const newlyPendingScopes = /* @__PURE__ */ new Set();
+		const invalidatedPaths = /* @__PURE__ */ new Set();
+		for (const [scopeId, scopeChanges] of affectedScopeChanges) {
+			let pendingChanges = this.pendingChangesByScope.get(scopeId);
+			if (!pendingChanges) {
+				pendingChanges = /* @__PURE__ */ new Map();
+				this.pendingChangesByScope.set(scopeId, pendingChanges);
+				newlyPendingScopes.add(scopeId);
+			}
+			for (const change of scopeChanges) {
+				const previous = pendingChanges.get(change.id);
+				const mergedChange = mergeCompilationDependencyChanges(previous ? [previous] : void 0, [change])[0];
+				if (!previous || previous.type !== mergedChange.type) {
+					pendingChanges.set(change.id, mergedChange);
+					invalidatedPaths.add(change.id);
+				}
+			}
+		}
+		if (newlyPendingScopes.size > 0) this.compilationPool.recordAffectedScopes(newlyPendingScopes);
+		if (invalidatedPaths.size > 0) this.generationPool.invalidate({
+			type: "dependencies",
+			paths: invalidatedPaths
+		});
+		return affectedScopes;
+	}
+	consume(scopeId) {
+		this.ensureActive();
+		const pendingChanges = this.pendingChangesByScope.get(scopeId);
+		if (!pendingChanges) return;
+		this.pendingChangesByScope.delete(scopeId);
+		return [...pendingChanges.values()].map((change) => ({ ...change }));
+	}
+	invalidateScope(scopeId) {
+		this.ensureActive();
+		this.pendingChangesByScope.delete(scopeId);
+		this.compilationPool.invalidateScope(scopeId);
+	}
+	getScopeDependencyRevision(scopeId) {
+		this.ensureActive();
+		return this.compilationPool.getScopeDependencyRevision(scopeId);
+	}
+	dispose() {
+		this.pendingChangesByScope.clear();
+		this.disposed = true;
+	}
+	ensureActive() {
+		if (this.disposed) throw new Error("CompilationChangeCoordinator 已释放。");
+	}
+};
+const compilationChangeCoordinators = /* @__PURE__ */ new WeakMap();
+function getCompilationChangeCoordinator(owner) {
+	ensureCompilerOwnerActive(owner);
+	let coordinator = compilationChangeCoordinators.get(owner);
+	if (!coordinator) {
+		coordinator = new CompilationChangeCoordinator(getCompilationSessionPool(owner), getTailwindGenerationSessionPool(owner));
+		compilationChangeCoordinators.set(owner, coordinator);
+	}
+	return coordinator;
+}
+function recordCompilationDependencyChanges(owner, changes) {
+	return getCompilationChangeCoordinator(owner).record(changes);
+}
+function consumeCompilationScopeChanges(owner, scopeId) {
+	return getCompilationChangeCoordinator(owner).consume(scopeId);
+}
+function getCompilationScopeDependencyRevision(owner, scopeId) {
+	return getCompilationChangeCoordinator(owner).getScopeDependencyRevision(scopeId);
+}
+function invalidateCompilationScope(owner, scopeId) {
+	getCompilationChangeCoordinator(owner).invalidateScope(scopeId);
+}
+function disposeCompilationChangeCoordinator(owner) {
+	const coordinator = compilationChangeCoordinators.get(owner);
+	if (!coordinator) return;
+	compilationChangeCoordinators.delete(owner);
+	coordinator.dispose();
+}
+//#endregion
+//#region src/compiler/composition.ts
+function orderCssFragments(fragments) {
+	return [...fragments].sort((left, right) => left.order - right.order || left.id.localeCompare(right.id));
+}
+function composeGenerationArtifact(artifact) {
+	const cloned = cloneGenerationArtifact(artifact);
+	const root = postcss.root();
+	for (const fragment of orderCssFragments(cloned.fragments)) root.append(fragment.root.nodes.map((node) => node.clone()));
+	return {
+		artifact: cloned,
+		root,
+		css: root.toString()
+	};
+}
+//#endregion
+//#region src/compiler/emission-plan.ts
+var AssetEmissionPlan = class {
+	constructor() {
+		_defineProperty(this, "emissions", /* @__PURE__ */ new Map());
+		_defineProperty(this, "assetOperations", []);
+	}
+	upsert(assetId, artifact) {
+		this.emissions.set(assetId, cloneGenerationArtifact(artifact));
+	}
+	get(assetId) {
+		const artifact = this.emissions.get(assetId);
+		return artifact ? cloneGenerationArtifact(artifact) : void 0;
+	}
+	entries() {
+		return [...this.emissions].map(([assetId, artifact]) => ({
+			assetId,
+			artifact: cloneGenerationArtifact(artifact)
+		}));
+	}
+	write(assetId, source) {
+		this.assetOperations.push({
+			assetId,
+			kind: "write",
+			source
+		});
+	}
+	remove(assetId) {
+		this.assetOperations.push({
+			assetId,
+			kind: "delete"
+		});
+	}
+	operations() {
+		return this.assetOperations.map((operation) => ({ ...operation }));
+	}
+	clear() {
+		this.emissions.clear();
+		this.assetOperations.length = 0;
+	}
+};
+//#endregion
+//#region src/compiler/events.ts
+/** 创建跨 bundler 共用的生命周期事件总线。 */
+function createCompilationEventBus() {
+	const listeners = /* @__PURE__ */ new Set();
+	let revision = 0;
+	return {
+		get revision() {
+			return revision;
+		},
+		async emit(event) {
+			revision += 1;
+			for (const listener of [...listeners]) await listener(event);
+			return revision;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		clear() {
+			listeners.clear();
+		}
+	};
+}
+//#endregion
+//#region src/core/compiler/source-fingerprint.ts
+function stableSerialize(value, stack = /* @__PURE__ */ new WeakSet()) {
+	if (value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "function") return `[Function:${value.name}]`;
+	if (typeof value !== "object") return String(value);
+	if (stack.has(value)) return "[Circular]";
+	stack.add(value);
+	const serialized = Array.isArray(value) ? `[${value.map((item) => stableSerialize(item, stack)).join(",")}]` : `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize(value[key], stack)}`).join(",")}}`;
+	stack.delete(value);
+	return serialized;
+}
+function createSourceFingerprint(source) {
+	return createCompilerValueFingerprint(source);
+}
+function createCompilerValueFingerprint(value) {
+	return md5Hash(stableSerialize(value));
+}
+//#endregion
+//#region src/core/compiler/generation-cache.ts
+function createCompilerGenerationCacheKey(request, candidates, target) {
+	return {
+		bareArbitraryValues: request.bareArbitraryValues,
+		candidateSignature: [...candidates].sort().join("\0"),
+		incrementalCache: request.incrementalCache,
+		scanSources: request.scanSources,
+		sourcesFingerprint: request.sources === void 0 ? void 0 : createCompilerValueFingerprint(request.sources),
+		styleOptionsFingerprint: request.styleOptions === void 0 ? void 0 : createCompilerValueFingerprint(request.styleOptions),
+		target
+	};
+}
+function isSameCompilerGenerationCacheKey(left, right) {
+	return left.bareArbitraryValues === right.bareArbitraryValues && left.candidateSignature === right.candidateSignature && left.incrementalCache === right.incrementalCache && left.scanSources === right.scanSources && left.sourcesFingerprint === right.sourcesFingerprint && left.styleOptionsFingerprint === right.styleOptionsFingerprint && left.target === right.target;
+}
+function reuseCompilerGenerationResult(result) {
+	return {
+		...result,
+		incrementalCss: "",
+		incrementalRawCss: ""
+	};
+}
+//#endregion
+//#region src/core/compiler/generation-state.ts
+function createGenerationGraph(rootId, source, dependencies) {
+	const scope = {
+		id: rootId,
+		kind: "global"
+	};
+	const dependencyIds = [...new Set(dependencies)].filter((id) => id !== rootId).sort();
+	const nodes = [{
+		content: source.css,
+		id: rootId,
+		kind: "css",
+		scope
+	}, ...dependencyIds.map((id) => ({
+		id,
+		kind: "config",
+		scope
+	}))];
+	return {
+		edges: dependencyIds.map((id) => ({
+			from: rootId,
+			kind: "depends-on",
+			to: id
+		})),
+		nodes
+	};
+}
+function prepareCompilerGeneration(entry, request, source, sourceChanged) {
+	const explicitCandidates = request.candidates !== void 0;
+	const candidates = explicitCandidates ? [...request.candidates] : [];
+	const candidateSignature = [...candidates].sort().join("\0");
+	if (!sourceChanged && entry.compilationCache?.candidateSignature === candidateSignature && entry.compilationCache.compilation.revision === entry.compilationRevision) return {
+		...entry.compilationCache,
+		explicitCandidates
+	};
+	const graph = createGenerationGraph(entry.id, source, source.dependencies);
+	const compilation = entry.compilation.update({
+		...graph,
+		candidatesBySource: [[entry.id, candidates]],
+		changes: sourceChanged ? [{
+			sourceId: entry.id,
+			type: "dependency-changed"
+		}] : void 0
+	});
+	entry.compilationRevision = compilation.revision;
+	return {
+		candidateSignature,
+		compilation,
+		explicitCandidates,
+		graph
+	};
+}
+function commitCompilerGeneration(entry, prepared, source, dependencies, classSet) {
+	const graph = createGenerationGraph(entry.id, source, dependencies);
+	const compilation = entry.compilation.commitValidation(prepared.compilation.revision, classSet, graph);
+	entry.compilationCache = {
+		candidateSignature: prepared.candidateSignature,
+		compilation,
+		graph
+	};
+}
+//#endregion
+//#region src/core/compiler/root-store.ts
+function disposeGenerator(generator) {
+	generator?.dispose?.();
+}
+var CompilerRootStore = class {
+	constructor(maxRoots, onRootEvicted) {
+		this.maxRoots = maxRoots;
+		this.onRootEvicted = onRootEvicted;
+		_defineProperty(this, "dependencyRoots", /* @__PURE__ */ new Map());
+		_defineProperty(this, "releasing", /* @__PURE__ */ new Map());
+		_defineProperty(this, "roots", /* @__PURE__ */ new Map());
+	}
+	get(id) {
+		if (!id) throw new Error("Compiler root id 不能为空。");
+		if (this.releasing.has(id)) throw new Error(`Compiler root 正在移除：${id}`);
+		const cached = this.roots.get(id);
+		if (cached) {
+			if (!cached.accepting) throw new Error(`Compiler root 正在移除：${id}`);
+			this.roots.delete(id);
+			this.roots.set(id, cached);
+			return cached;
+		}
+		if (this.roots.size >= this.maxRoots) {
+			const oldest = [...this.roots.values()].find((entry) => entry.pendingCount === 0);
+			if (oldest) this.remove(oldest.id, true);
+		}
+		const entry = {
+			accepting: true,
+			active: true,
+			appliedInvalidation: 0,
+			compilation: new DefaultCompilationSession(),
+			compilationRevision: 0,
+			dependencies: /* @__PURE__ */ new Set(),
+			id,
+			invalidation: 0,
+			pending: Promise.resolve(),
+			pendingCount: 0,
+			sources: []
+		};
+		this.roots.set(id, entry);
+		return entry;
+	}
+	attachDependencies(entry, dependencies) {
+		this.detachDependencies(entry);
+		if (!entry.accepting) return;
+		for (const dependency of dependencies) {
+			entry.dependencies.add(dependency);
+			let owners = this.dependencyRoots.get(dependency);
+			if (!owners) {
+				owners = /* @__PURE__ */ new Set();
+				this.dependencyRoots.set(dependency, owners);
+			}
+			owners.add(entry.id);
+		}
+	}
+	attachSources(entry, sources) {
+		entry.sources = [...sources];
+	}
+	invalidate(ids) {
+		const affected = /* @__PURE__ */ new Set();
+		for (const id of ids) {
+			const root = this.roots.get(id);
+			if (root?.accepting) affected.add(root.id);
+			for (const rootId of this.dependencyRoots.get(id) ?? []) affected.add(rootId);
+			const sourcePath = stripSourceQuery(id);
+			for (const sourceRoot of this.roots.values()) if (sourceRoot.accepting && sourceRoot.sources.length > 0 && isFileMatchedByTailwindSourceEntries(sourcePath, sourceRoot.sources)) affected.add(sourceRoot.id);
+		}
+		for (const rootId of affected) {
+			const entry = this.roots.get(rootId);
+			if (entry?.accepting) entry.invalidation += 1;
+		}
+		return Object.freeze([...affected].sort());
+	}
+	trim() {
+		while (this.roots.size > this.maxRoots) {
+			const oldest = [...this.roots.values()].find((entry) => entry.pendingCount === 0);
+			if (!oldest) return;
+			this.remove(oldest.id, true);
+		}
+	}
+	remove(id, notifyEvicted = false) {
+		const pendingRelease = this.releasing.get(id);
+		if (pendingRelease) return pendingRelease;
+		const entry = this.roots.get(id);
+		if (!entry) return Promise.resolve();
+		entry.accepting = false;
+		this.roots.delete(id);
+		this.detachDependencies(entry);
+		const release = entry.pending.then(() => {
+			entry.active = false;
+			entry.compilation.dispose();
+			entry.compilationCache = void 0;
+			disposeGenerator(entry.generator);
+			entry.generator = void 0;
+			entry.generationCache = void 0;
+			entry.latestSnapshot = void 0;
+			entry.source = void 0;
+			entry.sourceInput = void 0;
+			entry.sourceFingerprint = void 0;
+			entry.sources = [];
+			if (notifyEvicted) this.onRootEvicted?.(id);
+		}).finally(() => {
+			this.releasing.delete(id);
+		});
+		this.releasing.set(id, release);
+		return release;
+	}
+	async dispose() {
+		await Promise.all([...[...this.roots.keys()].map((id) => this.remove(id)), ...this.releasing.values()]);
+		this.dependencyRoots.clear();
+	}
+	detachDependencies(entry) {
+		for (const dependency of entry.dependencies) {
+			const owners = this.dependencyRoots.get(dependency);
+			owners?.delete(entry.id);
+			if (owners?.size === 0) this.dependencyRoots.delete(dependency);
+		}
+		entry.dependencies.clear();
+	}
+};
+function stripSourceQuery(id) {
+	return id.replace(/[?#].*$/, "");
+}
+//#endregion
+//#region src/core/compiler/snapshot.ts
+const readonlySetValues = /* @__PURE__ */ new WeakMap();
+const snapshotRegistry = /* @__PURE__ */ new WeakMap();
+var ImmutableSetView = class {
+	constructor(values) {
+		readonlySetValues.set(this, new Set(values));
+		Object.freeze(this);
+	}
+	get size() {
+		return this.valuesSet.size;
+	}
+	get [Symbol.toStringTag]() {
+		return "Set";
+	}
+	has(value) {
+		return this.valuesSet.has(value);
+	}
+	entries() {
+		return this.valuesSet.entries();
+	}
+	keys() {
+		return this.valuesSet.keys();
+	}
+	values() {
+		return this.valuesSet.values();
+	}
+	forEach(callbackfn, thisArg) {
+		for (const value of this.valuesSet) callbackfn.call(thisArg, value, value, this);
+	}
+	[Symbol.iterator]() {
+		return this.values();
+	}
+	get valuesSet() {
+		return readonlySetValues.get(this);
+	}
+};
+function uniqueSorted(values) {
+	return Object.freeze([...new Set(values)].sort());
+}
+function sourceKey(source) {
+	return `${source.base}\0${source.pattern}\0${source.negated ? "1" : "0"}`;
+}
+function uniqueSortedSources(sources) {
+	const values = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const cloned = Object.freeze({ ...source });
+		values.set(sourceKey(cloned), cloned);
+	}
+	return Object.freeze([...values.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, value]) => value));
+}
+function createRootFingerprint(root, target, classSet, dependencies, sources) {
+	return [
+		root.id,
+		String(root.revision),
+		target,
+		...[...classSet].sort(),
+		...dependencies,
+		...[...sources].map(sourceKey)
+	].join("\0");
+}
+function createSnapshotFromState(state, reusableClassSet, reusableClassSetView) {
+	const roots = Object.freeze([...state.roots.values()].sort((left, right) => left.id.localeCompare(right.id)).map(({ id, revision }) => Object.freeze({
+		id,
+		revision
+	})));
+	const classSet = reusableClassSet ?? new Set(state.classSet);
+	const fingerprint = [
+		state.target,
+		...[...state.roots.values()].map((root) => `${root.id}\0${root.revision}\0${root.fingerprint}`).sort(),
+		...[...classSet].sort(),
+		...state.dependencies,
+		...state.sources.map(sourceKey)
+	].join("\0");
+	const snapshot = Object.freeze({
+		classSet: reusableClassSetView ?? new ImmutableSetView(classSet),
+		dependencies: state.dependencies,
+		roots,
+		sources: state.sources,
+		target: state.target
+	});
+	snapshotRegistry.set(snapshot, {
+		...state,
+		classSet,
+		fingerprint
+	});
+	return snapshot;
+}
+function createRegisteredCompilerSnapshot(request, reusableClassSet, reusableClassSetView) {
+	if (!request.id) throw new Error("Compiler snapshot 的 root id 不能为空。");
+	const revision = request.revision ?? 0;
+	if (!Number.isSafeInteger(revision) || revision < 0) throw new Error(`Compiler snapshot revision 必须是非负安全整数：${revision}`);
+	const target = request.target ?? "weapp";
+	const classSet = new Set(request.classSet);
+	const dependencies = uniqueSorted(request.dependencies ?? []);
+	const sources = uniqueSortedSources(request.sources ?? []);
+	const root = {
+		id: request.id,
+		revision
+	};
+	const internalRoot = {
+		...root,
+		fingerprint: createRootFingerprint(root, target, classSet, dependencies, sources)
+	};
+	return createSnapshotFromState({
+		classSet,
+		dependencies,
+		roots: /* @__PURE__ */ new Map([[root.id, internalRoot]]),
+		sources,
+		target
+	}, reusableClassSet, reusableClassSetView);
+}
+function getInternalCompilerSnapshot(snapshot) {
+	const state = snapshotRegistry.get(snapshot);
+	if (!state) throw new Error("Compiler snapshot 必须由 createSnapshot()、generate() 或 mergeSnapshots() 创建。");
+	return state;
+}
+function mergeRegisteredCompilerSnapshots(snapshots) {
+	const states = [...snapshots].map(getInternalCompilerSnapshot);
+	if (states.length === 0) throw new Error("mergeSnapshots() 至少需要一个 snapshot。");
+	const target = states[0].target;
+	const roots = /* @__PURE__ */ new Map();
+	const classSet = /* @__PURE__ */ new Set();
+	const dependencies = [];
+	const sources = [];
+	for (const state of states) {
+		if (state.target !== target) throw new Error(`不能合并不同 target 的 snapshot：${target} 与 ${state.target}`);
+		for (const root of state.roots.values()) {
+			const current = roots.get(root.id);
+			if (current && current.revision !== root.revision) throw new Error(`同一 root 不能合并不同 revision：${root.id} (${current.revision} / ${root.revision})`);
+			if (current && current.fingerprint !== root.fingerprint) throw new Error(`同一 root revision 的 snapshot 内容冲突：${root.id}@${root.revision}`);
+			roots.set(root.id, root);
+		}
+		for (const candidate of state.classSet) classSet.add(candidate);
+		dependencies.push(...state.dependencies);
+		sources.push(...state.sources);
+	}
+	return createSnapshotFromState({
+		classSet: new Set([...classSet].sort()),
+		dependencies: uniqueSorted(dependencies),
+		roots,
+		sources: uniqueSortedSources(sources),
+		target
+	});
+}
+function createImmutableSet(values) {
+	return new ImmutableSetView(values);
+}
+//#endregion
+//#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;
+		},
+		pruneHashKeys(hashKeys) {
+			const activeHashKeys = new Set(hashKeys);
+			for (const key of hashMap.keys()) if (!activeHashKeys.has(key)) hashMap.delete(key);
+		},
+		prune(options) {
+			if (options.cacheKeys) {
+				const cacheKeys = new Set(options.cacheKeys);
+				for (const key of instance.keys()) if (!cacheKeys.has(key)) instance.delete(key);
+			}
+			if (options.hashKeys) cache.pruneHashKeys?.(options.hashKeys);
+		},
+		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/framework/platform.ts
+const MPX_TO_UNI_PLATFORM = {
+	ali: "mp-alipay",
+	dd: "mp-dingtalk",
+	jd: "mp-jd",
+	qq: "mp-qq",
+	swan: "mp-baidu",
+	tt: "mp-toutiao",
+	wx: "mp-weixin"
+};
+function normalizeFrameworkStylePlatform(platform, appType) {
+	const normalized = platform?.trim().toLowerCase();
+	if (!normalized) return;
+	if (appType === "mpx") return MPX_TO_UNI_PLATFORM[normalized] ?? normalized;
+	return normalized;
+}
+//#endregion
+//#region src/tailwindcss/runtime.ts
+const debug = createDebug("[tailwindcss:runtime] ");
+const refreshTailwindcssRuntimeSymbol = Symbol.for("weapp-tailwindcss.refreshTailwindcssRuntime");
+function createTailwindRuntimeReadyPromise(tailwindRuntime) {
+	return Promise.resolve().then(async () => {
+		invalidateRuntimeClassSet(tailwindRuntime);
+	});
+}
+const runtimeClassSetStateCache = /* @__PURE__ */ new WeakMap();
+function getRuntimeClassSetStateEntry(state) {
+	let entry = runtimeClassSetStateCache.get(state);
+	if (!entry) {
+		entry = {};
+		runtimeClassSetStateCache.set(state, entry);
+	}
+	return entry;
+}
+function getTailwindRuntime(state) {
+	return state.tailwindRuntime;
+}
+function setTailwindRuntime(state, runtime) {
+	state.tailwindRuntime = runtime;
+}
+function getRefreshTailwindRuntime(state) {
+	return state.refreshTailwindcssRuntime;
+}
+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;
+	const currentRuntime = getTailwindRuntime(state);
+	debug("refresh runtime state start, clearCache=%s major=%s", clearCache, currentRuntime.majorVersion ?? "unknown");
+	await state.readyPromise;
+	let refreshed = false;
+	const refreshTailwindRuntime = getRefreshTailwindRuntime(state);
+	if (typeof refreshTailwindRuntime === "function") {
+		const next = await refreshTailwindRuntime({ clearCache });
+		if (next !== getTailwindRuntime(state)) setTailwindRuntime(state, next);
+		refreshed = true;
+	}
+	if (refreshed) state.readyPromise = createTailwindRuntimeReadyPromise(getTailwindRuntime(state));
+	debug("refresh runtime state end, refreshed=%s major=%s", refreshed, getTailwindRuntime(state).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.readyPromise;
+	const entry = getRuntimeClassSetStateEntry(state);
+	const signature = await getRuntimeClassSetSignatureWithSources(getTailwindRuntime(state));
+	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(getTailwindRuntime(state), {
+			force: shouldForceCollect,
+			skipRefresh: true,
+			clearCache
+		});
+		if (allowEmpty || collected.size > 0) return collected;
+		await refreshTailwindRuntimeState(state, {
+			force: true,
+			clearCache: true
+		});
+		await state.readyPromise;
+		return collectRuntimeClassSet(getTailwindRuntime(state), {
+			force: true,
+			skipRefresh: true,
+			clearCache: true
+		});
+	})();
+	entry.promise = task;
+	try {
+		const runtimeSet = await task;
+		entry.value = runtimeSet;
+		entry.signature = await getRuntimeClassSetSignatureWithSources(getTailwindRuntime(state));
+		return runtimeSet;
+	} finally {
+		if (entry.promise === task) entry.promise = void 0;
+	}
+}
+function tryGetRuntimeClassSetSync(tailwindRuntime) {
+	if (typeof tailwindRuntime.getClassSetSync !== "function") return;
+	try {
+		const set = tailwindRuntime.getClassSetSync();
+		if (set && set.size === 0) return;
+		return set;
+	} catch (error) {
+		debug("getClassSetSync() unavailable for tailwindcss v4, fallback to async getClassSet(): %O", error);
+		return;
+	}
+}
+async function collectTailwindV4GeneratorClassSet(tailwindRuntime) {
+	if (typeof tailwindRuntime.collectContentTokens !== "function") return;
+	try {
+		const source = resolveCssMacroTailwindV4Source(await resolveTailwindV4SourceFromRuntime(tailwindRuntime));
+		const generated = await createTailwindV4Engine$1(source).generate({
+			scanSources: true,
+			target: "web"
+		});
+		const designSystem = await loadTailwindV4DesignSystem(source);
+		const classSet = resolveValidTailwindV4Candidates$1(designSystem, generated.classSet, { ...source.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: source.bareArbitraryValues } });
+		debug("runtime class set resolved via tailwindcss v4 generator source scan, raw=%d valid=%d", generated.classSet.size, classSet.size);
+		return classSet;
+	} catch (error) {
+		debug("tailwindcss v4 generator source scan failed, continuing fallback chain: %O", error);
+		return;
+	}
+}
+async function mergeTailwindV4GeneratorClassSet(tailwindRuntime, classSet) {
+	const generatorClassSet = await collectTailwindV4GeneratorClassSet(tailwindRuntime).catch(() => void 0);
+	if (!generatorClassSet || generatorClassSet.size === 0) return classSet;
+	return /* @__PURE__ */ new Set([...classSet, ...generatorClassSet]);
+}
+async function collectRuntimeClassSet(tailwindRuntime, options = {}) {
+	let activeRuntime = tailwindRuntime;
+	if (options.force && !options.skipRefresh) {
+		const refresh = activeRuntime[refreshTailwindcssRuntimeSymbol];
+		if (typeof refresh === "function") try {
+			const refreshed = await refresh({ clearCache: options.clearCache === true });
+			if (refreshed) activeRuntime = refreshed;
+		} catch (error) {
+			debug("refreshTailwindcssRuntime failed, continuing with existing runtime: %O", error);
+		}
+	}
+	const entry = getRuntimeClassSetCacheEntry(activeRuntime);
+	const signature = await getRuntimeClassSetSignatureWithSources(activeRuntime);
+	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 preferExtract = options.force === true;
+		try {
+			const result = await activeRuntime.extract({ write: false });
+			if (result?.classSet) {
+				if (result.classSet.size > 0) {
+					const merged = await mergeTailwindV4GeneratorClassSet(activeRuntime, result.classSet);
+					debug("runtime class set resolved via extract() + tailwindcss v4 source scan, extract=%d merged=%d", result.classSet.size, merged.size);
+					return merged;
+				}
+				if (preferExtract) debug("runtime class set from extract() is empty on force collect, fallback to generator/sync/async class set");
+				else debug("runtime class set from extract() is empty, fallback to sync/async class set");
+			}
+		} catch (error) {
+			debug("extract() failed, fallback to getClassSet(): %O", error);
+		}
+		const generatorClassSet = await collectTailwindV4GeneratorClassSet(activeRuntime);
+		if (generatorClassSet && generatorClassSet.size > 0) return generatorClassSet;
+		const syncSet = tryGetRuntimeClassSetSync(activeRuntime);
+		if (syncSet) {
+			debug("runtime class set resolved via getClassSetSync(), size=%d", syncSet.size);
+			return syncSet;
+		}
+		try {
+			const fallbackSet = await Promise.resolve(activeRuntime.getClassSet());
+			if (fallbackSet) {
+				debug("runtime class set resolved via getClassSet(), size=%d", fallbackSet.size);
+				return fallbackSet;
+			}
+		} catch (error) {
+			debug("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.ts
+function formatRelativeToBase(targetPath, baseDir) {
+	const normalized = path.normalize(targetPath);
+	if (!baseDir) return normalized.replace(/\\/g, "/");
+	const relative = path.relative(baseDir, normalized);
+	if (!relative || relative === ".") return ".";
+	if (relative.startsWith("..")) return normalized.replace(/\\/g, "/");
+	return path.join(".", relative).replace(/\\/g, "/");
+}
+function logTailwindcssTarget(tailwindRuntime, baseDir) {
+	const packageInfo = tailwindRuntime?.packageInfo;
+	const label = "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})` : "";
+	logRuntimeTailwindcssTarget(baseDir, packageInfo.rootPath, packageInfo.version);
+	logger.debug("%s 解析 Tailwind CSS -> %s%s", label, displayPath, version);
+}
+//#endregion
+//#region src/unocss/index.ts
+function normalizeUnocssOptions(unocss) {
+	return resolveBooleanObjectOption(unocss, {});
+}
+function resolveUnocssBareArbitraryValues(arbitraryValues, unocss) {
+	const baseArbitraryValues = arbitraryValues ?? {};
+	const options = normalizeUnocssOptions(unocss);
+	if (!options) return baseArbitraryValues;
+	if (baseArbitraryValues.bareArbitraryValues !== void 0 && baseArbitraryValues.bareArbitraryValues !== false) return baseArbitraryValues;
+	const bareArbitraryValues = options.bareArbitraryValues ?? true;
+	if (bareArbitraryValues === false) return baseArbitraryValues;
+	return {
+		...baseArbitraryValues,
+		bareArbitraryValues
+	};
+}
+//#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 DEFAULT_COMPILER_CONTEXT_CACHE_MAX = 32;
+const DEFAULT_COMPILER_CONTEXT_KEY_CACHE_MAX = 64;
+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 resolveCompilerContextCacheMax(defaultValue) {
+	const raw = Number.parseInt(process.env["WEAPP_TW_COMPILER_CONTEXT_CACHE_MAX"] ?? "", 10);
+	if (!Number.isFinite(raw) || raw <= 0) return defaultValue;
+	return Math.floor(raw);
+}
+function touchMapValue(map, key, value) {
+	map.delete(key);
+	map.set(key, value);
+}
+function pruneMapToMaxSize(map, maxSize) {
+	while (map.size > maxSize) {
+		const firstKey = map.keys().next().value;
+		if (firstKey === void 0) break;
+		map.delete(firstKey);
+	}
+}
+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 normalized = normalizeOptionsValue(getRuntimeCacheScopeValue(opts));
+		const cacheKey = md5Hash(serializeNormalizedValue(normalized));
+		touchMapValue(keyStore, runtimeCacheScopeKey, cacheKey);
+		pruneMapToMaxSize(keyStore, resolveCompilerContextCacheMax(DEFAULT_COMPILER_CONTEXT_KEY_CACHE_MAX));
+		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) {
+			touchMapValue(compilerContextCache, cacheKey, cached);
+			return cached;
+		}
+	}
+	const ctx = factory();
+	if (cacheKey) {
+		touchMapValue(compilerContextCache, cacheKey, ctx);
+		pruneMapToMaxSize(compilerContextCache, resolveCompilerContextCacheMax(DEFAULT_COMPILER_CONTEXT_CACHE_MAX));
+	}
+	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/js/literal-transform.ts
+function transformLiteralText(literal, options, classContext = true) {
+	if (!options.alwaysEscape && (!options.classNameSet || options.classNameSet.size === 0)) return;
+	const source = options.unescapeUnicode && literal.includes("\\u") ? decodeUnicode2(literal) : literal;
+	const candidates = splitCandidateTokens(source);
+	if (candidates.length === 0) return;
+	const transformOptions = {
+		...options,
+		classContext
+	};
+	const replacementCache = getReplacementCacheStore(options.escapeMap);
+	let transformed = source;
+	let mutated = false;
+	for (const candidate of candidates) {
+		const result = resolveClassNameTransformWithResult(candidate, transformOptions);
+		if (result.decision === "skip" || !transformed.includes(candidate)) continue;
+		const replacement = result.decision === "escaped" && result.escapedValue ? result.escapedValue : getReplacement(candidate, options.escapeMap, replacementCache);
+		const replaced = transformed.replace(candidate, replacement);
+		if (replaced !== transformed) {
+			transformed = replaced;
+			mutated = true;
+		}
+	}
+	return mutated ? transformed : void 0;
+}
+//#endregion
+//#region src/js/fast-path/oxc.ts
+const require = createRequire(import.meta.url);
+let oxcParser;
+function isOxcParserRuntimeSupported(version = process.versions.node) {
+	const match = /^(\d+)\.(\d+)(?:\.|$)/.exec(version);
+	if (!match) return false;
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	if (major === 20) return minor >= 19;
+	if (major === 21) return false;
+	if (major === 22) return minor >= 12;
+	return major > 22;
+}
+function loadOxcParser() {
+	if (!isOxcParserRuntimeSupported()) return;
+	if (oxcParser === false) return;
+	if (oxcParser) return oxcParser;
+	try {
+		oxcParser = require("oxc-parser");
+	} catch {
+		oxcParser = false;
+		return;
+	}
+	return oxcParser;
+}
+function hasValues(values) {
+	return Array.isArray(values) && values.length > 0;
+}
+function hasUnsupportedSourceMarker(rawSource) {
+	return rawSource.includes("eval(") || rawSource.includes("weapp-tw") && rawSource.includes("ignore");
+}
+function hasSupportedClassMatchSource(options) {
+	return options.alwaysEscape === true || Boolean(options.classNameSet && options.classNameSet.size > 0);
+}
+function canAttemptOxcJsFastPath(options) {
+	if (options.experimentalJsFastPath !== true && options.experimentalJsFastPath !== "oxc") return false;
+	return !options.generateMap && !options.wrapExpression && !options.moduleGraph && !options.moduleSpecifierReplacements && hasSupportedClassMatchSource(options) && !hasValues(options.ignoreCallExpressionIdentifiers);
+}
+function getParserLang(filename) {
+	if (filename?.endsWith(".ts") || filename?.endsWith(".mts") || filename?.endsWith(".cts")) return "ts";
+	if (filename?.endsWith(".tsx")) return "tsx";
+	if (filename?.endsWith(".jsx")) return "jsx";
+	return "js";
+}
+function getParserSourceType(sourceType) {
+	return sourceType === "script" || sourceType === "module" ? sourceType : "module";
+}
+function isRangeValid(start, end) {
+	return typeof start === "number" && typeof end === "number" && start < end;
+}
+function getMagicString(rawSource, context) {
+	if (!context.ms) context.ms = new MagicString(rawSource);
+	return context.ms;
+}
+function addStringLiteralReplacement(rawSource, node, transformOptions, context) {
+	if (typeof node.value !== "string" || typeof node.raw !== "string" || !isRangeValid(node.start, node.end)) return false;
+	const transformed = transformLiteralText(node.value, transformOptions, false);
+	if (!transformed) return false;
+	const start = node.start + 1;
+	const end = node.end - 1;
+	if (start >= end || transformed === rawSource.slice(start, end)) return false;
+	getMagicString(rawSource, context).update(start, end, jsStringEscape(transformed));
+	return true;
+}
+function addTemplateElementReplacement(rawSource, node, transformOptions, context) {
+	const raw = node.value?.raw;
+	if (typeof raw !== "string" || !isRangeValid(node.start, node.end)) return false;
+	const transformed = transformLiteralText(raw, transformOptions, false);
+	if (!transformed || transformed === raw) return false;
+	const first = rawSource[node.start];
+	const last = rawSource[node.end - 1];
+	const start = node.start + (first === "`" || first === "}" ? 1 : 0);
+	const end = node.end - (last === "`" ? 1 : last === "{" ? 2 : 0);
+	if (start >= end) return false;
+	getMagicString(rawSource, context).update(start, end, transformed);
+	return true;
+}
+function applyReplacements(rawSource, program, stringLiteralOptions, templateLiteralOptions, context) {
+	let changed = false;
+	walk(program, { enter(node) {
+		if (node.type === "Literal") {
+			changed = addStringLiteralReplacement(rawSource, node, stringLiteralOptions, context) || changed;
+			return;
+		}
+		if (node.type === "TemplateElement") {
+			changed = addTemplateElementReplacement(rawSource, node, templateLiteralOptions, context) || changed;
+			this.skip();
+		}
+	} });
+	return changed;
+}
+function hasTaggedTemplateExpression(program) {
+	let found = false;
+	walk(program, { enter(node) {
+		if (node.type === "TaggedTemplateExpression") {
+			found = true;
+			this.skip();
+		}
+	} });
+	return found;
+}
+function oxcJsHandler(rawSource, options) {
+	if (!canAttemptOxcJsFastPath(options)) return;
+	if (hasUnsupportedSourceMarker(rawSource)) return;
+	const parser = loadOxcParser();
+	if (!parser) return;
+	let result;
+	try {
+		result = parser.parseSync(options.filename ?? "weapp-tailwindcss.js", rawSource, {
+			sourceType: getParserSourceType(options.babelParserOptions?.sourceType),
+			lang: getParserLang(options.filename)
+		});
+	} catch {
+		return;
+	}
+	if (!result.program || Array.isArray(result.errors) && result.errors.length > 0) return;
+	if (hasValues(options.ignoreTaggedTemplateExpressionIdentifiers) && hasTaggedTemplateExpression(result.program)) return;
+	const stringLiteralOptions = options.needEscaped === true ? options : {
+		...options,
+		needEscaped: true
+	};
+	const templateLiteralOptions = options.needEscaped === false ? options : {
+		...options,
+		needEscaped: false
+	};
+	const replacementContext = {};
+	if (!applyReplacements(rawSource, result.program, stringLiteralOptions, templateLiteralOptions, replacementContext)) return { code: rawSource };
+	return { code: replacementContext.ms.toString() };
+}
+//#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*(?:["'`{]|\*\s+as\b)|\brequire\s*\(|\bexport\s+\*\s+from\s+["'`]|\bexport\s*\{[^}]*\}\s*from\s+["'`]/;
+/**
+* 判断源码是否可能声明跨模块依赖。
+*
+* 该检查只作为性能预筛：返回 `true` 时必须保守走 AST 模块图分析；
+* 返回 `false` 时源码中没有可被当前模块图消费的静态 import/export/require 形态。
+*/
+function hasDependencyHint(rawSource) {
+	return DEPENDENCY_HINT_RE.test(rawSource);
+}
+/**
+* 判断是否可以跳过 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 (hasDependencyHint(rawSource)) return false;
+	return !FAST_JS_TRANSFORM_HINT_RE.test(rawSource);
+}
+//#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",
+		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),
+		String(options.experimentalJsFastPath ?? ""),
+		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 resolveFastPathOptions(rawSource, options) {
+	if (!options.moduleGraph) return options;
+	if (options.moduleSpecifierReplacements && Object.keys(options.moduleSpecifierReplacements).length > 0) return options;
+	if (hasDependencyHint(rawSource)) return options;
+	const { moduleGraph: _moduleGraph, ...fastPathOptions } = options;
+	return fastPathOptions;
+}
+function createJsHandler(options) {
+	const defaults = {
+		escapeMap: options.escapeMap,
+		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,
+		experimentalJsFastPath: options.experimentalJsFastPath,
+		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$1({
+				...overrideOptions,
+				classNameSet
+			}, defaults);
+			entry.noSet = created;
+			return created;
+		}
+		const cached = entry.bySet.get(classNameSet);
+		if (cached) return cached;
+		const created = defuOverrideArray$1({
+			...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, oxcJsHandler(rawSource, resolveFastPathOptions(rawSource, resolvedOptions)) ?? jsHandler(rawSource, resolvedOptions));
+	}
+	return handler;
+}
+//#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 return rewriteLegacyExpression(match, options);
+	} catch {
+		return match;
+	}
+}
+//#endregion
+//#region src/wxml/whitespace.ts
+const WHITESPACE_CODES = /* @__PURE__ */ 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() {
+		_defineProperty(this, "state", void 0);
+		_defineProperty(this, "buffer", void 0);
+		_defineProperty(this, "tokens", void 0);
+		_defineProperty(this, "bufferStartIndex", void 0);
+		_defineProperty(this, "expressionStartIndex", void 0);
+		_defineProperty(this, "expressionBuffer", void 0);
+		_defineProperty(this, "expressions", void 0);
+		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];
+			if (char === void 0) continue;
+			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) {
+	const value = ms.slice(start, end);
+	const replaceOptions = {
+		keepEOL,
+		escapeMap: options.escapeMap,
+		ignoreHead
+	};
+	if (options.classSetMode === "exact" && options.runtimeSet) {
+		ms.update(start, end, value.replace(/\S+/g, (candidate) => options.runtimeSet.has(candidate) ? replaceWxml(candidate, replaceOptions) : candidate));
+		return;
+	}
+	ms.update(start, end, replaceWxml(value, replaceOptions));
+}
+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) return;
+		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();
+	if (jsHandler) 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 (opt && Object.keys(opt).some((key) => key !== "runtimeSet")) return customTemplateHandler(rawSource, defuOverrideArray(opt, defaultOptions), opt.customAttributesEntities === void 0 ? cachedMatcher : void 0);
+		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/constants.ts
+const pluginName = "weapp-tailwindcss";
+const vitePluginName = "weapp-tailwindcss:adaptor";
+const DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS = {
+	"tailwind-merge": "@weapp-tailwindcss/merge",
+	"class-variance-authority": "@weapp-tailwindcss/cva",
+	"tailwind-variants": "@weapp-tailwindcss/variants"
+};
+//#endregion
+//#region src/context/runtime-package-replacements.ts
+function resolveRuntimePackageReplacements(option) {
+	const mapping = resolveBooleanObjectOption(option, DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS);
+	if (!mapping) return;
+	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;
+}
+//#endregion
+//#region src/context/style-options.ts
+function normalizeStyleHandlerMajorVersion(majorVersion) {
+	return majorVersion === 4 ? 4 : void 0;
+}
+function resolveStyleOptionsFromContext(ctx, tailwindcssMajorVersion) {
+	const resolvedUniAppXOptions = resolveUniAppXOptions(ctx.uniAppX);
+	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(ctx.generator, {
+		appType: ctx.appType,
+		platform: ctx.cssOptions?.platform ?? ctx.platform,
+		tailwindcssMajorVersion,
+		uniAppX: resolvedUniAppXOptions
+	});
+	const branch = resolveGeneratorRuntimeBranch(generatorOptions, {
+		appType: ctx.appType,
+		platform: ctx.cssOptions?.platform ?? ctx.platform,
+		tailwindcssMajorVersion,
+		uniAppX: resolvedUniAppXOptions
+	});
+	const hasCssOptions = ctx.cssOptions !== void 0;
+	const configuredRem2rpx = ctx.cssOptions?.rem2rpx ?? ctx.rem2rpx;
+	const rem2rpx = branch.isWeb && shouldUseUniAppWebRpxCompatibility(ctx.appType) ? false : configuredRem2rpx;
+	const cssOptions = {
+		cssPreflight: ctx.cssOptions?.cssPreflight ?? ctx.cssPreflight,
+		cssPreflightRange: ctx.cssOptions?.cssPreflightRange ?? ctx.cssPreflightRange,
+		cssChildCombinatorReplaceValue: ctx.cssOptions?.cssChildCombinatorReplaceValue ?? ctx.cssChildCombinatorReplaceValue,
+		cssSelectorReplacement: ctx.cssOptions?.cssSelectorReplacement ?? ctx.cssSelectorReplacement,
+		rem2rpx,
+		cssRemoveProperty: ctx.cssOptions?.cssRemoveProperty ?? ctx.cssRemoveProperty,
+		cssRemoveActivePseudoClass: ctx.cssOptions?.cssRemoveActivePseudoClass ?? ctx.cssRemoveActivePseudoClass,
+		cssRemoveHoverPseudoClass: ctx.cssOptions?.cssRemoveHoverPseudoClass ?? ctx.cssRemoveHoverPseudoClass,
+		cssRemoveFocusPseudoClass: ctx.cssOptions?.cssRemoveFocusPseudoClass ?? ctx.cssRemoveFocusPseudoClass,
+		tailwindcssV4GradientFallback: ctx.cssOptions?.tailwindcssV4GradientFallback ?? ctx.tailwindcssV4GradientFallback,
+		cssPresetEnv: ctx.cssOptions?.cssPresetEnv ?? ctx.cssPresetEnv,
+		atRules: ctx.cssOptions?.atRules ?? ctx.atRules,
+		autoprefixer: ctx.cssOptions?.autoprefixer ?? ctx.autoprefixer,
+		cssCalc: ctx.cssOptions?.cssCalc ?? ctx.cssCalc,
+		platform: branch.platform ?? ctx.cssOptions?.platform ?? ctx.platform,
+		px2rpx: ctx.cssOptions?.px2rpx ?? ctx.px2rpx,
+		unitsToPx: ctx.cssOptions?.unitsToPx ?? ctx.unitsToPx,
+		unitConversion: ctx.cssOptions?.unitConversion ?? ctx.unitConversion,
+		injectAdditionalCssVarScope: ctx.cssOptions?.injectAdditionalCssVarScope ?? ctx.injectAdditionalCssVarScope
+	};
+	return {
+		appType: ctx.appType,
+		postcssOptions: ctx.postcssOptions,
+		cssPreflight: cssOptions.cssPreflight,
+		cssPreflightRange: cssOptions.cssPreflightRange,
+		cssChildCombinatorReplaceValue: cssOptions.cssChildCombinatorReplaceValue,
+		cssSelectorReplacement: cssOptions.cssSelectorReplacement,
+		rem2rpx: cssOptions.rem2rpx,
+		...hasCssOptions ? { cssOptions } : {},
+		cssRemoveProperty: cssOptions.cssRemoveProperty,
+		cssRemoveActivePseudoClass: cssOptions.cssRemoveActivePseudoClass,
+		cssRemoveHoverPseudoClass: cssOptions.cssRemoveHoverPseudoClass,
+		cssRemoveFocusPseudoClass: cssOptions.cssRemoveFocusPseudoClass,
+		tailwindcssV4GradientFallback: cssOptions.tailwindcssV4GradientFallback,
+		cssPresetEnv: cssOptions.cssPresetEnv,
+		atRules: cssOptions.atRules,
+		autoprefixer: cssOptions.autoprefixer,
+		cssCalc: cssOptions.cssCalc,
+		uniAppX: branch.isNativeApp,
+		platform: cssOptions.platform,
+		px2rpx: cssOptions.px2rpx,
+		unitsToPx: cssOptions.unitsToPx,
+		unitConversion: cssOptions.unitConversion
+	};
+}
+//#endregion
+//#region src/context/handlers.ts
+function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions, tailwindcssMajorVersion) {
+	const { escapeMap, injectAdditionalCssVarScope, postcssOptions, uniAppX, arbitraryValues, jsPreserveClass, babelParserOptions, experimentalJsFastPath, ignoreCallExpressionIdentifiers, ignoreTaggedTemplateExpressionIdentifiers, inlineWxs, disabledDefaultTemplateHandler, replaceRuntimePackages } = ctx;
+	const resolvedUniAppXOptions = resolveUniAppXOptions(uniAppX);
+	const styleOptions = resolveStyleOptionsFromContext(ctx, tailwindcssMajorVersion);
+	const resolvedInjectAdditionalCssVarScope = styleOptions.cssOptions?.injectAdditionalCssVarScope ?? injectAdditionalCssVarScope;
+	const uniAppXEnabled = styleOptions.uniAppX === true;
+	const moduleSpecifierReplacements = resolveRuntimePackageReplacements(replaceRuntimePackages);
+	const styleHandler = createStyleHandler({
+		...styleOptions,
+		escapeMap,
+		injectAdditionalCssVarScope: resolvedInjectAdditionalCssVarScope,
+		postcssOptions,
+		uniAppXUnsupported: resolvedUniAppXOptions.uvueUnsupported,
+		cssCalc: cssCalcOptions,
+		majorVersion: normalizeStyleHandlerMajorVersion(tailwindcssMajorVersion)
+	});
+	const jsHandler = createJsHandler({
+		escapeMap,
+		arbitraryValues,
+		jsPreserveClass,
+		generateMap: true,
+		babelParserOptions,
+		experimentalJsFastPath,
+		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
+function resolveContextCssPreflight(opts, ctx, majorVersion) {
+	const userCssPreflight = opts?.cssOptions?.cssPreflight ?? opts?.cssPreflight;
+	const cssPreflight = resolveDefaultCssPreflight(userCssPreflight, majorVersion);
+	const shouldUseUniAppXPreflight = ctx.appType === "uni-app-x" || resolveUniAppXOptions(ctx.uniAppX).enabled;
+	if (cssPreflight === false || !shouldUseUniAppXPreflight) return cssPreflight;
+	const userCssPreflightObject = userCssPreflight && typeof userCssPreflight === "object" ? userCssPreflight : void 0;
+	return {
+		...cssPreflight,
+		"border-width": userCssPreflightObject && "border-width" in userCssPreflightObject ? cssPreflight["border-width"] ?? false : "0",
+		"border-style": userCssPreflightObject && "border-style" in userCssPreflightObject ? cssPreflight["border-style"] ?? false : false,
+		"border": userCssPreflightObject && "border" in userCssPreflightObject ? cssPreflight["border"] ?? false : false
+	};
+}
+function syncCssOptionsToLegacyFields(ctx) {
+	if (!ctx.cssOptions) return;
+	const cssOptions = ctx.cssOptions;
+	ctx.cssPreflight = cssOptions.cssPreflight ?? ctx.cssPreflight;
+	ctx.cssPreflightRange = cssOptions.cssPreflightRange ?? ctx.cssPreflightRange;
+	ctx.cssChildCombinatorReplaceValue = cssOptions.cssChildCombinatorReplaceValue ?? ctx.cssChildCombinatorReplaceValue;
+	ctx.cssSelectorReplacement = cssOptions.cssSelectorReplacement ?? ctx.cssSelectorReplacement;
+	ctx.rem2rpx = cssOptions.rem2rpx ?? ctx.rem2rpx;
+	ctx.cssRemoveProperty = cssOptions.cssRemoveProperty ?? ctx.cssRemoveProperty;
+	ctx.cssRemoveActivePseudoClass = cssOptions.cssRemoveActivePseudoClass ?? ctx.cssRemoveActivePseudoClass;
+	ctx.cssRemoveHoverPseudoClass = cssOptions.cssRemoveHoverPseudoClass ?? ctx.cssRemoveHoverPseudoClass;
+	ctx.cssRemoveFocusPseudoClass = cssOptions.cssRemoveFocusPseudoClass ?? ctx.cssRemoveFocusPseudoClass;
+	ctx.tailwindcssV4GradientFallback = cssOptions.tailwindcssV4GradientFallback ?? ctx.tailwindcssV4GradientFallback;
+	ctx.cssPresetEnv = cssOptions.cssPresetEnv ?? ctx.cssPresetEnv;
+	ctx.atRules = cssOptions.atRules ?? ctx.atRules;
+	ctx.autoprefixer = cssOptions.autoprefixer ?? ctx.autoprefixer;
+	ctx.cssCalc = cssOptions.cssCalc ?? ctx.cssCalc;
+	ctx.platform = cssOptions.platform ?? ctx.platform;
+	ctx.px2rpx = cssOptions.px2rpx ?? ctx.px2rpx;
+	ctx.unitsToPx = cssOptions.unitsToPx ?? ctx.unitsToPx;
+	ctx.unitConversion = cssOptions.unitConversion ?? ctx.unitConversion;
+	ctx.injectAdditionalCssVarScope = cssOptions.injectAdditionalCssVarScope ?? ctx.injectAdditionalCssVarScope;
+}
+function syncLegacyFieldsToCssOptions(ctx) {
+	if (!ctx.cssOptions) return;
+	ctx.cssOptions = {
+		...ctx.cssOptions ?? {},
+		cssPreflight: ctx.cssPreflight,
+		cssPreflightRange: ctx.cssPreflightRange,
+		cssChildCombinatorReplaceValue: ctx.cssChildCombinatorReplaceValue,
+		cssSelectorReplacement: ctx.cssSelectorReplacement,
+		rem2rpx: ctx.rem2rpx,
+		cssRemoveProperty: ctx.cssRemoveProperty,
+		cssRemoveActivePseudoClass: ctx.cssRemoveActivePseudoClass,
+		cssRemoveHoverPseudoClass: ctx.cssRemoveHoverPseudoClass,
+		cssRemoveFocusPseudoClass: ctx.cssRemoveFocusPseudoClass,
+		tailwindcssV4GradientFallback: ctx.tailwindcssV4GradientFallback,
+		cssPresetEnv: ctx.cssPresetEnv,
+		atRules: ctx.atRules,
+		autoprefixer: ctx.autoprefixer,
+		cssCalc: ctx.cssCalc,
+		platform: ctx.platform,
+		px2rpx: ctx.px2rpx,
+		unitsToPx: ctx.unitsToPx,
+		unitConversion: ctx.unitConversion,
+		injectAdditionalCssVarScope: ctx.injectAdditionalCssVarScope
+	};
+}
+function applyFrameworkPlatformDefaults(ctx) {
+	if (ctx.cssOptions?.platform || ctx.platform) {
+		ctx.platform = normalizeFrameworkStylePlatform(ctx.cssOptions?.platform ?? ctx.platform, ctx.appType);
+		return;
+	}
+	if (ctx.appType === "mpx") ctx.platform = normalizeFrameworkStylePlatform(resolveMpxPlatform().normalized, ctx.appType);
+}
+async function clearTailwindcssRuntimeCache(tailwindRuntime, options) {
+	if (!tailwindRuntime) return;
+	const cacheOptions = tailwindRuntime.options?.cache;
+	if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) return;
+	if (typeof tailwindRuntime.clearCache === "function") try {
+		await tailwindRuntime.clearCache({ scope: "all" });
+	} catch (error) {
+		logger.debug("failed to clear tailwindcss runtime cache via clearCache(): %O", error);
+	}
+	if (!options?.removeDirectory) return;
+	const cachePaths = /* @__PURE__ */ new Map();
+	const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
+	const privateCachePath = tailwindRuntime?.cacheStore?.options?.path;
+	if (privateCachePath) cachePaths.set(privateCachePath, false);
+	if (normalizedCacheOptions?.path) cachePaths.set(normalizedCacheOptions.path, 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 runtime cache: %s %O", cachePath, err);
+	}
+}
+function createInternalCompilerContext(opts) {
+	const ctx = defuOverrideArray$1(opts, getDefaultOptions(), {});
+	ctx.arbitraryValues = resolveUnocssBareArbitraryValues(ctx.arbitraryValues, ctx.unocss);
+	ctx.escapeMap = ctx.customReplaceDictionary;
+	syncCssOptionsToLegacyFields(ctx);
+	applyFrameworkPlatformDefaults(ctx);
+	applyLoggerLevel(ctx.logLevel);
+	const tailwindRuntime = createTailwindcssRuntimeFromContext(ctx);
+	if (opts?.__internalViteDeferRuntimeLogs !== true) {
+		logTailwindcssTarget(tailwindRuntime, ctx.tailwindcssBasedir);
+		logRuntimeTailwindcssVersion(ctx.tailwindcssBasedir, tailwindRuntime.packageInfo?.rootPath, tailwindRuntime.packageInfo?.version);
+	}
+	if (opts?.__internalDeferMissingCssEntriesWarning !== true) warnMissingCssEntries(ctx, tailwindRuntime);
+	ctx.cssPreflight = resolveContextCssPreflight(opts, ctx, tailwindRuntime.majorVersion);
+	const cssCalcOptions = applyV4CssCalcDefaults(ctx.cssCalc, tailwindRuntime);
+	ctx.cssCalc = cssCalcOptions;
+	syncLegacyFieldsToCssOptions(ctx);
+	const customAttributesEntities = toCustomAttributesEntities(ctx.customAttributes);
+	ctx.customAttributesEntities = customAttributesEntities;
+	const { styleHandler, jsHandler, templateHandler } = createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions, tailwindRuntime.majorVersion);
+	ctx.styleHandler = styleHandler;
+	ctx.jsHandler = jsHandler;
+	ctx.templateHandler = templateHandler;
+	ctx.cache = initializeCache(ctx.cache);
+	ctx.tailwindRuntime = tailwindRuntime;
+	const refreshTailwindcssRuntime = async (options) => {
+		const previousRuntime = ctx.tailwindRuntime;
+		if (options?.clearCache !== false) await clearTailwindcssRuntimeCache(previousRuntime);
+		invalidateRuntimeClassSet(previousRuntime);
+		const nextRuntime = createTailwindcssRuntimeFromContext(ctx);
+		Object.assign(previousRuntime, nextRuntime);
+		ctx.tailwindRuntime = previousRuntime;
+		return previousRuntime;
+	};
+	ctx.refreshTailwindcssRuntime = refreshTailwindcssRuntime;
+	Object.defineProperty(ctx.tailwindRuntime, refreshTailwindcssRuntimeSymbol, {
+		value: refreshTailwindcssRuntime,
+		configurable: true
+	});
+	return ctx;
+}
+/**
+* 获取用户定义选项的内部表示，并初始化相关的处理程序和 Tailwind 运行时。
+* @param opts - 用户定义的选项，可选。
+* @returns 返回一个包含内部用户定义选项的对象，包括样式、JS 和模板处理程序，以及 Tailwind CSS 运行时。
+*/
+function getCompilerContext(opts) {
+	return withCompilerContextCache(opts, () => createInternalCompilerContext(opts));
+}
+//#endregion
+//#region src/core/compiler/transforms.ts
+const DEFAULT_JS_OPTIONS = Object.freeze({ tailwindcssMajorVersion: 4 });
+const DEFAULT_STYLE_OPTIONS = Object.freeze({ isMainChunk: true });
+function clonePostcssResult(result) {
+	return Object.assign(Object.create(Object.getPrototypeOf(result)), result, {
+		messages: [...result.messages],
+		root: result.root.clone()
+	});
+}
+function resolveStyleOptions(options) {
+	if (!options) return DEFAULT_STYLE_OPTIONS;
+	return options?.isMainChunk === void 0 ? {
+		...options,
+		isMainChunk: true
+	} : options;
+}
+function resolveCssTransformOptions(options) {
+	const { finalize: _finalize, ...styleOptions } = options ?? {};
+	return {
+		finalize: _finalize,
+		styleOptions: resolveStyleOptions(styleOptions)
+	};
+}
+function finalizeResultRoot(result, snapshot, shouldFinalize) {
+	if (!shouldFinalize || result.root.type !== "root") return;
+	finalizeMiniProgramCssRoot(result.root, { isTailwindcssV4: snapshot.target === "weapp" });
+	result.css = result.root.toString();
+}
+function createCompilerTransforms({ ensureActive, track, userOptions }) {
+	const context = getCompilerContext({
+		...userOptions,
+		__internalDeferMissingCssEntriesWarning: true
+	});
+	const styleHandler = context.styleHandler;
+	let cachedTemplateClassSet;
+	let cachedTemplateOptions;
+	function clearCache() {
+		cachedTemplateClassSet = void 0;
+		cachedTemplateOptions = void 0;
+	}
+	function createTemplateOptions(classSet, options) {
+		const isDefault = !options || Object.keys(options).length === 0;
+		if (isDefault && cachedTemplateClassSet === classSet && cachedTemplateOptions) return cachedTemplateOptions;
+		const resolved = {
+			...options,
+			classSetMode: "exact",
+			jsHandler: (jsSource, _runtimeSet, jsOptions) => context.jsHandler(jsSource, classSet, {
+				...jsOptions,
+				tailwindcssMajorVersion: jsOptions?.tailwindcssMajorVersion ?? 4
+			}),
+			runtimeSet: classSet
+		};
+		if (isDefault) {
+			cachedTemplateClassSet = classSet;
+			cachedTemplateOptions = resolved;
+		}
+		return resolved;
+	}
+	function transformCss(css, snapshot, options) {
+		ensureActive();
+		getInternalCompilerSnapshot(snapshot);
+		const resolved = resolveCssTransformOptions(options);
+		const shouldFinalize = resolved.finalize ?? snapshot.target === "weapp";
+		return track(styleHandler(css, resolved.styleOptions).then((result) => {
+			const cloned = clonePostcssResult(result);
+			finalizeResultRoot(cloned, snapshot, shouldFinalize);
+			return cloned;
+		}));
+	}
+	function transformCssRoot(root, snapshot, options) {
+		ensureActive();
+		getInternalCompilerSnapshot(snapshot);
+		const resolved = resolveCssTransformOptions(options);
+		const shouldFinalize = resolved.finalize ?? snapshot.target === "weapp";
+		return track(styleHandler.transformRoot(root, resolved.styleOptions).then((result) => {
+			finalizeResultRoot(result, snapshot, shouldFinalize);
+			return result;
+		}));
+	}
+	function transformJavaScript(source, snapshot, options) {
+		ensureActive();
+		const classSet = getInternalCompilerSnapshot(snapshot).classSet;
+		const resolvedOptions = options?.tailwindcssMajorVersion === void 0 ? options ? {
+			...options,
+			tailwindcssMajorVersion: 4
+		} : DEFAULT_JS_OPTIONS : options;
+		return track(Promise.resolve(shouldSkipJsTransform(source, resolvedOptions) ? { code: source } : context.jsHandler(source, classSet, resolvedOptions)));
+	}
+	function transformTemplate(source, snapshot, options) {
+		ensureActive();
+		const classSet = getInternalCompilerSnapshot(snapshot).classSet;
+		return track(context.templateHandler(source, createTemplateOptions(classSet, options)));
+	}
+	return {
+		clearCache,
+		transformCss,
+		transformCssRoot,
+		transformJavaScript,
+		transformTemplate
+	};
+}
+//#endregion
+//#region src/core/compiler/compiler.ts
+const DEFAULT_MAX_ROOTS = 128;
+function createCompiler(options = {}) {
+	const { compiler: compilerOptions, ...userOptions } = options;
+	const rootStore = new CompilerRootStore(Math.max(1, Math.floor(compilerOptions?.maxRoots ?? DEFAULT_MAX_ROOTS)), compilerOptions?.onRootEvicted);
+	const activeTasks = /* @__PURE__ */ new Set();
+	let lifecycle = "active";
+	let disposePromise;
+	function ensureActive() {
+		if (lifecycle !== "active") throw new Error(lifecycle === "disposing" ? "Compiler 正在释放，不能接受新任务。" : "Compiler 已释放。");
+	}
+	function track(task) {
+		activeTasks.add(task);
+		task.then(() => activeTasks.delete(task), () => activeTasks.delete(task));
+		return task;
+	}
+	const { clearCache: clearTransformCache, ...transforms } = createCompilerTransforms({
+		ensureActive,
+		track,
+		userOptions
+	});
+	async function resolveRequestSource(entry, request) {
+		if (request.source && request.sourceOptions) throw new Error("generate() 的 source 与 sourceOptions 互斥。");
+		if (!request.source && !request.sourceOptions) throw new Error("generate() 必须提供 source 或 sourceOptions。");
+		const sourceInput = request.source ?? request.sourceOptions;
+		return {
+			source: entry.source !== void 0 && entry.sourceInput === sourceInput && entry.appliedInvalidation === entry.invalidation ? entry.source : request.source ?? await resolveTailwindV4Source$1(request.sourceOptions),
+			sourceInput
+		};
+	}
+	async function runGenerate(entry, request) {
+		if (!entry.active) throw new Error(`Compiler root 已被移除：${entry.id}`);
+		const invalidation = entry.invalidation;
+		const { source, sourceInput } = await resolveRequestSource(entry, request);
+		const sourceFingerprint = entry.sourceInput === sourceInput && entry.sourceFingerprint !== void 0 && entry.appliedInvalidation === invalidation ? entry.sourceFingerprint : createSourceFingerprint(source);
+		const sourceReused = entry.sourceFingerprint === sourceFingerprint;
+		const engineReused = sourceReused && entry.generator !== void 0 && entry.appliedInvalidation === invalidation;
+		const generator = engineReused ? entry.generator : createWeappTailwindcssGenerator(source);
+		const target = request.target ?? "weapp";
+		const { id: _id, source: _source, sourceOptions: _sourceOptions, target: _target, ...generateOptions } = request;
+		const prepared = prepareCompilerGeneration(entry, request, source, !sourceReused || entry.appliedInvalidation !== invalidation);
+		const generationCacheKey = createCompilerGenerationCacheKey(request, prepared.compilation.candidates, target);
+		const reusableGeneration = engineReused && entry.generationCache && isSameCompilerGenerationCacheKey(entry.generationCache.key, generationCacheKey) ? entry.generationCache.result : void 0;
+		try {
+			const generated = reusableGeneration ? reuseCompilerGenerationResult(reusableGeneration) : await generator.generate({
+				...generateOptions,
+				candidates: prepared.explicitCandidates ? prepared.compilation.candidates : void 0,
+				incrementalCache: generateOptions.incrementalCache ?? true,
+				target: target === "tailwind" ? "web" : target
+			});
+			if (!entry.active) throw new Error(`Compiler root 已被移除：${entry.id}`);
+			const revision = (getLatestRevision(entry) ?? 0) + 1;
+			const dependencies = [.../* @__PURE__ */ new Set([...source.dependencies, ...generated.dependencies])].sort();
+			const sources = generated.sources ?? source.sources ?? [];
+			const previousSnapshotState = entry.latestSnapshot ? getInternalCompilerSnapshot(entry.latestSnapshot) : void 0;
+			const reusableClassSet = engineReused && generated.incrementalCss === "" && previousSnapshotState && previousSnapshotState.classSet.size === generated.classSet.size && [...generated.classSet].every((candidate) => previousSnapshotState.classSet.has(candidate)) ? previousSnapshotState.classSet : void 0;
+			const reusableClassSetView = reusableClassSet ? entry.latestSnapshot?.classSet : void 0;
+			const snapshot = createRegisteredCompilerSnapshot({
+				classSet: generated.classSet,
+				dependencies,
+				id: entry.id,
+				revision,
+				sources,
+				target
+			}, reusableClassSet, reusableClassSetView);
+			const internalSnapshot = getInternalCompilerSnapshot(snapshot);
+			const previousGenerator = entry.generator;
+			commitCompilerGeneration(entry, prepared, source, dependencies, generated.classSet);
+			entry.generator = generator;
+			entry.generationCache = {
+				key: generationCacheKey,
+				result: generated
+			};
+			entry.source = source;
+			entry.sourceFingerprint = sourceFingerprint;
+			entry.sourceInput = sourceInput;
+			entry.appliedInvalidation = invalidation;
+			entry.latestSnapshot = snapshot;
+			rootStore.attachDependencies(entry, dependencies);
+			rootStore.attachSources(entry, sources);
+			if (!engineReused && previousGenerator !== generator) previousGenerator?.dispose?.();
+			const css = target === "tailwind" ? generated.rawCss : generated.css;
+			const incrementalCss = target === "tailwind" ? generated.incrementalRawCss : generated.incrementalCss;
+			return {
+				...generated,
+				cache: Object.freeze({
+					engine: engineReused,
+					output: reusableGeneration !== void 0 || engineReused && incrementalCss === "",
+					source: sourceReused
+				}),
+				classSet: snapshot.classSet,
+				css,
+				dependencies: snapshot.dependencies,
+				incrementalCss,
+				rawCandidates: createImmutableSet(generated.rawCandidates),
+				revision,
+				snapshot,
+				sources: internalSnapshot.sources,
+				target
+			};
+		} catch (error) {
+			if (!engineReused) generator.dispose?.();
+			throw error;
+		}
+	}
+	function getLatestRevision(entry) {
+		return entry.latestSnapshot?.roots[0]?.revision;
+	}
+	function generate(request) {
+		ensureActive();
+		const entry = rootStore.get(request.id);
+		entry.pendingCount += 1;
+		const execution = entry.pending.then(() => runGenerate(entry, request));
+		entry.pending = execution.finally(() => {
+			entry.pendingCount -= 1;
+			rootStore.trim();
+		}).then(() => void 0, () => void 0);
+		return track(execution);
+	}
+	function createSnapshot(request) {
+		ensureActive();
+		return createRegisteredCompilerSnapshot(request);
+	}
+	function finalizeCss(css, options) {
+		ensureActive();
+		return finalizeMiniProgramCss(css, options);
+	}
+	function finalizeCssRoot(root, options) {
+		ensureActive();
+		const cloned = root.clone();
+		finalizeMiniProgramCssRoot(cloned, options);
+		return cloned;
+	}
+	function mergeSnapshots(snapshots) {
+		ensureActive();
+		return mergeRegisteredCompilerSnapshots(snapshots);
+	}
+	function invalidate(ids) {
+		ensureActive();
+		return rootStore.invalidate(ids);
+	}
+	async function remove(id) {
+		if (lifecycle === "disposed") return;
+		clearTransformCache();
+		await rootStore.remove(id);
+	}
+	function dispose() {
+		if (disposePromise) return disposePromise;
+		lifecycle = "disposing";
+		disposePromise = (async () => {
+			await Promise.allSettled([...activeTasks]);
+			clearTransformCache();
+			await rootStore.dispose();
+			lifecycle = "disposed";
+		})();
+		return disposePromise;
+	}
+	return {
+		createSnapshot,
+		dispose,
+		finalizeCss,
+		finalizeCssRoot,
+		generate,
+		invalidate,
+		mergeSnapshots,
+		remove,
+		...transforms
+	};
+}
+//#endregion
+//#region src/compiler/framework-compiler-session.ts
+/**
+* 官方 bundler 共享的 compiler 生命周期边界。
+*
+* bundler 继续拥有模块图和 scope 投影；本层只负责把逻辑 source root
+* 映射到一个长期复用的 compiler，并保证 root 删除与 owner 释放可等待。
+*/
+var FrameworkCompilerSession = class {
+	constructor(options) {
+		_defineProperty(this, "compiler", void 0);
+		_defineProperty(this, "scopeRoots", /* @__PURE__ */ new Map());
+		_defineProperty(this, "activeRoots", /* @__PURE__ */ new Set());
+		_defineProperty(this, "transactionId", 0);
+		_defineProperty(this, "disposed", false);
+		this.compiler = createCompiler(options);
+	}
+	rootId(scopeId, sourceId) {
+		return `framework:${this.encode(scopeId)}:${this.encode(sourceId)}`;
+	}
+	async generate(scopeId, sourceId, source, request) {
+		if (this.disposed) throw new Error("FrameworkCompilerSession 已释放。");
+		const stableId = this.rootId(scopeId, sourceId);
+		const id = this.activeRoots.has(stableId) ? `${stableId}:transaction-${++this.transactionId}` : stableId;
+		let roots = this.scopeRoots.get(scopeId);
+		if (!roots) {
+			roots = /* @__PURE__ */ new Set();
+			this.scopeRoots.set(scopeId, roots);
+		}
+		roots.add(stableId);
+		this.activeRoots.add(stableId);
+		try {
+			return await this.compiler.generate({
+				...request,
+				id,
+				source: {
+					...source,
+					dependencies: source.dependencies ?? []
+				}
+			});
+		} finally {
+			this.activeRoots.delete(stableId);
+			if (id !== stableId) await this.compiler.remove(id);
+		}
+	}
+	async syncScope(scopeId, sourceIds) {
+		if (this.disposed) return;
+		const roots = this.scopeRoots.get(scopeId);
+		if (!roots) return;
+		const active = new Set([...sourceIds].map((sourceId) => this.rootId(scopeId, sourceId)));
+		const removed = [...roots].filter((rootId) => !active.has(rootId));
+		await Promise.all(removed.map((rootId) => this.compiler.remove(rootId)));
+		for (const rootId of removed) roots.delete(rootId);
+		if (roots.size === 0) this.scopeRoots.delete(scopeId);
+	}
+	async removeScope(scopeId) {
+		const roots = this.scopeRoots.get(scopeId);
+		if (!roots) return;
+		this.scopeRoots.delete(scopeId);
+		await Promise.all([...roots].map((rootId) => this.compiler.remove(rootId)));
+	}
+	invalidate(ids) {
+		return this.compiler.invalidate(ids);
+	}
+	mergeSnapshots(snapshots) {
+		return this.compiler.mergeSnapshots(snapshots);
+	}
+	dispose() {
+		if (this.disposed) return Promise.resolve();
+		this.disposed = true;
+		this.scopeRoots.clear();
+		return this.compiler.dispose();
+	}
+	encode(value) {
+		return Buffer.from(value, "utf8").toString("base64url");
+	}
+};
+const frameworkCompilerSessions = /* @__PURE__ */ new WeakMap();
+function getFrameworkCompilerSession(owner, options) {
+	let session = frameworkCompilerSessions.get(owner);
+	if (!session) {
+		session = new FrameworkCompilerSession(options);
+		frameworkCompilerSessions.set(owner, session);
+	}
+	return session;
+}
+function disposeFrameworkCompilerSession(owner) {
+	const session = frameworkCompilerSessions.get(owner);
+	if (!session) return Promise.resolve();
+	frameworkCompilerSessions.delete(owner);
+	return session.dispose();
+}
+//#endregion
+//#region src/compiler/shadow-report-session.ts
+const COMPILER_SHADOW_REPORT_CACHE_MAX = 512;
+function cloneSemanticValue(value) {
+	if (Array.isArray(value)) return value.map(cloneSemanticValue);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneSemanticValue(entry)]));
+	return value;
+}
+function cloneCompilerShadowReport(report) {
+	return {
+		file: report.file,
+		scopeId: report.scopeId,
+		equal: report.equal,
+		differences: report.differences.map((difference) => ({
+			kind: difference.kind,
+			path: difference.path,
+			..."left" in difference ? { left: cloneSemanticValue(difference.left) } : {},
+			..."right" in difference ? { right: cloneSemanticValue(difference.right) } : {}
+		})),
+		truncated: report.truncated,
+		legacy: { ...report.legacy },
+		graph: { ...report.graph }
+	};
+}
+var CompilerShadowReportSession = class {
+	constructor(maxReports = COMPILER_SHADOW_REPORT_CACHE_MAX) {
+		this.maxReports = maxReports;
+		_defineProperty(this, "reportsByScope", /* @__PURE__ */ new Map());
+		_defineProperty(this, "revision", 0);
+		_defineProperty(this, "dropped", 0);
+		_defineProperty(this, "completed", false);
+		_defineProperty(this, "disposed", false);
+		if (!Number.isInteger(maxReports) || maxReports <= 0) throw new Error("CompilerShadowReportSession 的 maxReports 必须是正整数。");
+	}
+	beginRun() {
+		this.ensureActive();
+		this.revision += 1;
+		this.reportsByScope.clear();
+		this.dropped = 0;
+		this.completed = false;
+		return this.revision;
+	}
+	record(report, revision = this.revision) {
+		this.ensureActive();
+		if (revision !== this.revision || this.completed) return false;
+		const cloned = cloneCompilerShadowReport(report);
+		this.reportsByScope.delete(cloned.scopeId);
+		this.reportsByScope.set(cloned.scopeId, cloned);
+		while (this.reportsByScope.size > this.maxReports) {
+			const oldestScopeId = this.reportsByScope.keys().next().value;
+			if (oldestScopeId === void 0) break;
+			this.reportsByScope.delete(oldestScopeId);
+			this.dropped += 1;
+		}
+		return true;
+	}
+	getRevision() {
+		this.ensureActive();
+		return this.revision;
+	}
+	completeRun(revision = this.revision) {
+		this.ensureActive();
+		if (revision !== this.revision) return;
+		this.completed = true;
+		return this.snapshot();
+	}
+	snapshot() {
+		this.ensureActive();
+		const reports = [...this.reportsByScope.values()].sort((left, right) => left.scopeId.localeCompare(right.scopeId)).map(cloneCompilerShadowReport);
+		return {
+			revision: this.revision,
+			completed: this.completed,
+			reports,
+			summary: {
+				total: reports.length,
+				matched: reports.filter((report) => report.equal).length,
+				mismatched: reports.filter((report) => !report.equal).length,
+				truncated: reports.filter((report) => report.truncated).length,
+				dropped: this.dropped
+			}
+		};
+	}
+	dispose() {
+		this.reportsByScope.clear();
+		this.dropped = 0;
+		this.completed = true;
+		this.disposed = true;
+	}
+	ensureActive() {
+		if (this.disposed) throw new Error("CompilerShadowReportSession 已释放。");
+	}
+};
+const compilerShadowReportSessions = /* @__PURE__ */ new WeakMap();
+function getCompilerShadowReportSession(owner) {
+	ensureCompilerOwnerActive(owner);
+	let session = compilerShadowReportSessions.get(owner);
+	if (!session) {
+		session = new CompilerShadowReportSession();
+		compilerShadowReportSessions.set(owner, session);
+	}
+	return session;
+}
+function beginCompilerShadowRun(owner) {
+	return getCompilerShadowReportSession(owner).beginRun();
+}
+function getCompilerShadowRunRevision(owner) {
+	return getCompilerShadowReportSession(owner).getRevision();
+}
+function recordCompilerShadowReport(owner, report, revision) {
+	return getCompilerShadowReportSession(owner).record(report, revision);
+}
+function getCompilerShadowRunSnapshot(owner) {
+	return getCompilerShadowReportSession(owner).snapshot();
+}
+function completeCompilerShadowReportRun(owner, revision) {
+	return getCompilerShadowReportSession(owner).completeRun(revision);
+}
+function disposeCompilerShadowReportSession(owner) {
+	const session = compilerShadowReportSessions.get(owner);
+	if (!session) return;
+	compilerShadowReportSessions.delete(owner);
+	session.dispose();
+}
+//#endregion
+//#region src/compiler/owner-lifecycle.ts
+async function disposeCompilerOwnerResources(owner) {
+	disposeCompilationChangeCoordinator(owner);
+	await disposeCompilationSessionPool(owner);
+	await disposeFrameworkCompilerSession(owner);
+	disposeTailwindGenerationSessionPool(owner);
+	disposeCompilerShadowReportSession(owner);
+}
+function disposeCompilerOwner(owner) {
+	return runCompilerOwnerDisposal(owner, () => disposeCompilerOwnerResources(owner));
+}
+//#endregion
+//#region src/compiler/platform-adapter.ts
+function createStylePlatformAdapter(options) {
+	return {
+		id: options.id,
+		prepare(request) {
+			return {
+				...request,
+				candidates: new Set(request.candidates),
+				scope: { ...request.scope }
+			};
+		},
+		async transform(artifact, context) {
+			const transformed = cloneGenerationArtifact(artifact);
+			for (const fragment of transformed.fragments) {
+				fragment.root = (await options.styleHandler.transformRoot(fragment.root, options.styleOptions)).root.clone();
+				fragment.stage = context.stage;
+			}
+			return transformed;
+		}
+	};
+}
+//#endregion
+//#region src/compiler/runtime-affecting-signature.ts
+const CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+const CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
+const CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
+const CSS_WHITESPACE_RE = /\s+/g;
+const JS_RUNTIME_AFFECTING_TEXT_HINT_RE = /["'`/]/;
+const JS_INCOMPLETE_TRAILING_OPERATOR_RE = /(?:=>|[=+\-*%&|^!~?:,.({[\]])\s*$/;
+const JS_AST_IGNORED_KEYS = /* @__PURE__ */ new Set([
+	"comments",
+	"errors",
+	"extra",
+	"innerComments",
+	"leadingComments",
+	"loc",
+	"tokens",
+	"trailingComments"
+]);
+function isAstNode(value) {
+	return Boolean(value && typeof value === "object" && typeof value.type === "string");
+}
+function createHtmlRuntimeAffectingSignature(source) {
+	try {
+		const parts = [];
+		const parser = new Parser({
+			onattribute(name, value) {
+				parts.push(`a:${name}=${value}`);
+			},
+			oncomment(data) {
+				parts.push(`c:${data}`);
+			},
+			ontext(data) {
+				const value = data.trim();
+				if (value.length > 0) parts.push(`t:${value}`);
+			}
+		}, { xmlMode: true });
+		parser.write(source);
+		parser.end();
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createJsRuntimeAffectingSignature(source) {
+	if (!JS_RUNTIME_AFFECTING_TEXT_HINT_RE.test(source) && !JS_INCOMPLETE_TRAILING_OPERATOR_RE.test(source)) return "";
+	try {
+		const ast = babelParse(source, {
+			cache: true,
+			cacheKey: "st:unambiguous",
+			plugins: ["jsx", "typescript"],
+			sourceType: "unambiguous"
+		});
+		const parts = [];
+		const stack = [ast];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (node.type === "StringLiteral" && typeof node.value === "string") parts.push(`s:${node.value}`);
+			else if (node.type === "TemplateElement" && node.value && typeof node.value === "object" && "raw" in node.value && typeof node.value.raw === "string") parts.push(`t:${node.value.raw}`);
+			else if (node.type === "JSXText" && typeof node.value === "string") {
+				const value = node.value.trim();
+				if (value.length > 0) parts.push(`x:${value}`);
+			}
+			const children = [];
+			for (const [key, value] of Object.entries(node)) {
+				if (JS_AST_IGNORED_KEYS.has(key)) continue;
+				if (Array.isArray(value)) {
+					for (const item of value) if (isAstNode(item)) children.push(item);
+				} else if (isAstNode(value)) children.push(value);
+			}
+			for (let index = children.length - 1; index >= 0; index--) stack.push(children[index]);
+		}
+		const comments = ast.comments;
+		if (Array.isArray(comments)) {
+			for (const comment of comments) if (typeof comment?.value === "string" && comment.value.length > 0) parts.push(`c:${comment.value}`);
+		}
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createCssRuntimeAffectingSignature(source) {
+	return source.replace(CSS_BLOCK_COMMENT_RE, "").replace(CSS_AROUND_PUNCTUATION_RE, "$1").replace(CSS_TRAILING_DECLARATION_SEMICOLON_RE, "}").replace(CSS_WHITESPACE_RE, " ").trim();
+}
+function createRuntimeAffectingSourceSignature(source, type) {
+	if (type === "html") return createHtmlRuntimeAffectingSignature(source);
+	if (type === "js") return createJsRuntimeAffectingSignature(source);
+	if (type === "css") return createCssRuntimeAffectingSignature(source);
+	return source;
+}
+//#endregion
+//#region src/compiler/runtime-state.ts
+/** 创建构建器无关的 runtime state，并保留旧字段供现有插件继续使用。 */
+function createCompilerRuntimeState(options) {
+	const events = options.events ?? createCompilationEventBus();
+	return {
+		tailwindRuntime: options.tailwindRuntime,
+		readyPromise: options.readyPromise ?? Promise.resolve(),
+		refreshTailwindcssRuntime: options.refreshTailwindcssRuntime,
+		events,
+		get revision() {
+			return events.revision;
+		},
+		dispose() {
+			events.clear();
+		}
+	};
+}
+//#endregion
+export { consumeCompilationScopeChanges as A, createGenerationArtifact as B, createTailwindRuntimeReadyPromise as C, createCompilationEventBus as D, normalizeFrameworkStylePlatform as E, getCompilationSessionPool as F, replaceWxml as G, analyzeSource as H, runCompilerOwnerActivity as I, traverse as J, createDebug as K, createCompilationDependencyChanges as L, invalidateCompilationScope as M, recordCompilationDependencyChanges as N, AssetEmissionPlan as O, getTailwindGenerationSessionPool as P, mergeCompilationDependencyChanges as R, collectRuntimeClassSet as S, refreshTailwindRuntimeState as T, JsTokenUpdater as U, createAttributeMatcher as V, isClassContextLiteralPath as W, md5Hash as Y, generateCode as _, beginCompilerShadowRun as a, logTailwindcssTarget as b, getCompilerShadowRunSnapshot as c, createCompiler as d, getCompilerContext as f, vitePluginName as g, pluginName as h, disposeCompilerOwner as i, getCompilationScopeDependencyRevision as j, composeGenerationArtifact as k, recordCompilerShadowReport as l, resolveStyleOptionsFromContext as m, createRuntimeAffectingSourceSignature as n, completeCompilerShadowReportRun as o, normalizeStyleHandlerMajorVersion as p, babelParse as q, createStylePlatformAdapter as r, getCompilerShadowRunRevision as s, createCompilerRuntimeState as t, getFrameworkCompilerSession as u, shouldSkipJsTransform as v, ensureRuntimeClassSet as w, logRuntimeTailwindcssVersion as x, toCustomAttributesEntities as y, createCssFragment as z };