weapp-tailwindcss 5.3.6 → 5.4.0

package/dist/{context-4ittVpgt.js → compiler-qDa3phIv.js}

@@ -1,8 +1,9 @@
 import { resolveMpxPlatform } from "./framework.js";
-import { It as shouldUseUniAppWebRpxCompatibility, Lt as loadTailwindV4DesignSystem, Nt as resolveCssMacroTailwindV4Source, Rt as resolveValidTailwindV4Candidates$1, a as resolveGeneratorRuntimeBranch, d as resolveTailwindV4SourceFromRuntime, i as normalizeWeappTailwindcssGeneratorOptions, k as resolveBooleanObjectOption, yt as createTailwindV4Engine$1 } from "./generator-EnTXLBlK.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-ChnpCv25.js";
+import { It as shouldUseUniAppWebRpxCompatibility, Lt as loadTailwindV4DesignSystem, Nt as resolveCssMacroTailwindV4Source, Rt as resolveValidTailwindV4Candidates$1, a as resolveGeneratorRuntimeBranch, d as resolveTailwindV4SourceFromRuntime, i as normalizeWeappTailwindcssGeneratorOptions, k as resolveBooleanObjectOption, t as createWeappTailwindcssGenerator, u as resolveTailwindV4Source$1, yt as createTailwindV4Engine$1 } from "./generator-C0m2S4WI.js";
+import { n as _defineProperty } from "./object-B-8IHefx.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-BSKl0FTD.js";
 import { i as isMap, n as defuOverrideArray } from "./utils-MVwpU07P.js";
-import { _ as md5Hash, a as jsHandler, c as getReplacementCacheStore, d as decodeUnicode2, f as resolveClassNameTransformWithResult, l as jsStringEscape, m as createDebug, s as getReplacement, t as createTemplateHandler } from "./wxml-B7OAVpXJ.js";
+import { _ as md5Hash, a as jsHandler, c as getReplacementCacheStore, d as decodeUnicode2, f as resolveClassNameTransformWithResult, l as jsStringEscape, m as createDebug, s as getReplacement, t as createTemplateHandler } from "./wxml-CvKyV69S.js";
 import { getDefaultOptions, resolveDefaultCssPreflight } from "./defaults.js";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -12,9 +13,531 @@ import { createStyleHandler } from "@weapp-tailwindcss/postcss";
 import { LRUCache } from "lru-cache";
 import { rm } from "node:fs/promises";
 import MagicString from "magic-string";
-import { logger, pc } from "@weapp-tailwindcss/logger";
 import { Buffer } from "node:buffer";
+import { logger, pc } from "@weapp-tailwindcss/logger";
 import { walk } from "oxc-walker";
+//#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/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/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) {
+		this.maxRoots = maxRoots;
+		_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);
+		}
+		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
+		};
+		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);
+		}
+	}
+	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);
+		}
+		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);
+		}
+	}
+	remove(id) {
+		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;
+		}).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();
+	}
+};
+//#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;
@@ -1239,4 +1762,240 @@ function getCompilerContext(opts) {
 	return withCompilerContextCache(opts, () => createInternalCompilerContext(opts));
 }
 //#endregion
-export { vitePluginName as a, collectRuntimeClassSet as c, refreshTailwindRuntimeState as d, normalizeFrameworkStylePlatform as f, pluginName as i, createTailwindRuntimeReadyPromise as l, normalizeStyleHandlerMajorVersion as n, shouldSkipJsTransform as o, resolveStyleOptionsFromContext as r, toCustomAttributesEntities as s, getCompilerContext as t, ensureRuntimeClassSet as u };
+//#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 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);
+		return track(styleHandler(css, resolveStyleOptions(options)).then(clonePostcssResult));
+	}
+	function transformCssRoot(root, snapshot, options) {
+		ensureActive();
+		getInternalCompilerSnapshot(snapshot);
+		return track(styleHandler.transformRoot(root, resolveStyleOptions(options)));
+	}
+	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)));
+	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);
+			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 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,
+		generate,
+		invalidate,
+		mergeSnapshots,
+		remove,
+		...transforms
+	};
+}
+//#endregion
+export { pluginName as a, toCustomAttributesEntities as c, ensureRuntimeClassSet as d, refreshTailwindRuntimeState as f, resolveStyleOptionsFromContext as i, collectRuntimeClassSet as l, DefaultCompilationSession as m, getCompilerContext as n, vitePluginName as o, normalizeFrameworkStylePlatform as p, normalizeStyleHandlerMajorVersion as r, shouldSkipJsTransform as s, createCompiler as t, createTailwindRuntimeReadyPromise as u };