weapp-tailwindcss 5.3.6 → 5.4.1

package/dist/{context-DTLRADfE.cjs → compiler-CDAz4SwJ.cjs}

@@ -1,13 +1,11 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Ctb5zv51.cjs");
 const require_framework = require("./framework.cjs");
-const require_generator = require("./generator-DKiYbTFR.cjs");
+const require_generator = require("./generator-WlhrtNa3.cjs");
 const require_object = require("./object-DbHtAXRk.cjs");
-const require_options = require("./options-BJrtIQbH.cjs");
+const require_tailwindcss = require("./tailwindcss-D3jltF7M.cjs");
 require("./utils-CuKLf1Zv.cjs");
-const require_wxml = require("./wxml-PrK-8ARX.cjs");
+const require_wxml = require("./wxml-o-CUulAM.cjs");
 const require_defaults = require("./defaults.cjs");
-const require_tailwindcss = require("./tailwindcss-CexDJBhx.cjs");
-const require_style_options = require("./style-options-DW30H5PV.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_process = require("node:process");
@@ -17,10 +15,544 @@ let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
 let lru_cache = require("lru-cache");
 let node_module = require("node:module");
 let node_fs_promises = require("node:fs/promises");
-let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
 let node_buffer = require("node:buffer");
+let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
 let _weapp_tailwindcss_shared_node = require("@weapp-tailwindcss/shared/node");
 let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+//#region src/compiler/candidate-index.ts
+var CandidateIndex = class {
+	constructor() {
+		require_object._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() {
+		require_object._defineProperty(this, "edges", /* @__PURE__ */ new Map());
+		require_object._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() {
+		require_object._defineProperty(this, "candidateIndex", new CandidateIndex());
+		require_object._defineProperty(this, "graph", new SourceGraph());
+		require_object._defineProperty(this, "retainedCandidates", /* @__PURE__ */ new Set());
+		require_object._defineProperty(this, "validatedClassSet", /* @__PURE__ */ new Set());
+		require_object._defineProperty(this, "invalidatedScopes", /* @__PURE__ */ new Set());
+		require_object._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 (0, _weapp_tailwindcss_shared_node.md5)(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;
+		require_object._defineProperty(this, "dependencyRoots", /* @__PURE__ */ new Map());
+		require_object._defineProperty(this, "releasing", /* @__PURE__ */ new Map());
+		require_object._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 && require_generator.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;
@@ -619,7 +1151,7 @@ function toCustomAttributesEntities(customAttributes) {
 	return Object.entries(customAttributes);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/oxc-walker@1.1.1_@oxc-project+types@0.146.0_oxc-parser@0.146.0_rolldown@1.2.3/node_modules/oxc-walker/dist/index.mjs
+//#region ../../node_modules/.pnpm/oxc-walker@1.1.1_@oxc-project+types@0.147.0_oxc-parser@0.147.0_rolldown@1.2.3/node_modules/oxc-walker/dist/index.mjs
 function isNode(v) {
 	return v !== null && typeof v === "object" && typeof v.type === "string";
 }
@@ -1146,11 +1678,79 @@ function resolveRuntimePackageReplacements(option) {
 	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 = require_tailwindcss.resolveUniAppXOptions(ctx.uniAppX);
+	const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(ctx.generator, {
+		appType: ctx.appType,
+		platform: ctx.cssOptions?.platform ?? ctx.platform,
+		tailwindcssMajorVersion,
+		uniAppX: resolvedUniAppXOptions
+	});
+	const branch = require_generator.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 && require_generator.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 = require_options.resolveUniAppXOptions(uniAppX);
-	const styleOptions = require_style_options.resolveStyleOptionsFromContext(ctx, tailwindcssMajorVersion);
+	const resolvedUniAppXOptions = require_tailwindcss.resolveUniAppXOptions(uniAppX);
+	const styleOptions = resolveStyleOptionsFromContext(ctx, tailwindcssMajorVersion);
 	const resolvedInjectAdditionalCssVarScope = styleOptions.cssOptions?.injectAdditionalCssVarScope ?? injectAdditionalCssVarScope;
 	const uniAppXEnabled = styleOptions.uniAppX === true;
 	const moduleSpecifierReplacements = resolveRuntimePackageReplacements(replaceRuntimePackages);
@@ -1161,7 +1761,7 @@ function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions
 		postcssOptions,
 		uniAppXUnsupported: resolvedUniAppXOptions.uvueUnsupported,
 		cssCalc: cssCalcOptions,
-		majorVersion: require_style_options.normalizeStyleHandlerMajorVersion(tailwindcssMajorVersion)
+		majorVersion: normalizeStyleHandlerMajorVersion(tailwindcssMajorVersion)
 	});
 	const jsHandler = createJsHandler({
 		escapeMap,
@@ -1203,7 +1803,7 @@ function applyLoggerLevel(logLevel) {
 function resolveContextCssPreflight(opts, ctx, majorVersion) {
 	const userCssPreflight = opts?.cssOptions?.cssPreflight ?? opts?.cssPreflight;
 	const cssPreflight = require_defaults.resolveDefaultCssPreflight(userCssPreflight, majorVersion);
-	const shouldUseUniAppXPreflight = ctx.appType === "uni-app-x" || require_options.resolveUniAppXOptions(ctx.uniAppX).enabled;
+	const shouldUseUniAppXPreflight = ctx.appType === "uni-app-x" || require_tailwindcss.resolveUniAppXOptions(ctx.uniAppX).enabled;
 	if (cssPreflight === false || !shouldUseUniAppXPreflight) return cssPreflight;
 	const userCssPreflightObject = userCssPreflight && typeof userCssPreflight === "object" ? userCssPreflight : void 0;
 	return {
@@ -1344,12 +1944,296 @@ 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;
+	(0, _weapp_tailwindcss_postcss.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 require_generator.resolveTailwindV4Source(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 : require_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 (0, _weapp_tailwindcss_postcss.finalizeMiniProgramCss)(css, options);
+	}
+	function finalizeCssRoot(root, options) {
+		ensureActive();
+		const cloned = root.clone();
+		(0, _weapp_tailwindcss_postcss.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
+Object.defineProperty(exports, "DefaultCompilationSession", {
+	enumerable: true,
+	get: function() {
+		return DefaultCompilationSession;
+	}
+});
 Object.defineProperty(exports, "collectRuntimeClassSet", {
 	enumerable: true,
 	get: function() {
 		return collectRuntimeClassSet;
 	}
 });
+Object.defineProperty(exports, "createCompiler", {
+	enumerable: true,
+	get: function() {
+		return createCompiler;
+	}
+});
 Object.defineProperty(exports, "createTailwindRuntimeReadyPromise", {
 	enumerable: true,
 	get: function() {
@@ -1374,6 +2258,12 @@ Object.defineProperty(exports, "normalizeFrameworkStylePlatform", {
 		return normalizeFrameworkStylePlatform;
 	}
 });
+Object.defineProperty(exports, "normalizeStyleHandlerMajorVersion", {
+	enumerable: true,
+	get: function() {
+		return normalizeStyleHandlerMajorVersion;
+	}
+});
 Object.defineProperty(exports, "pluginName", {
 	enumerable: true,
 	get: function() {
@@ -1386,6 +2276,12 @@ Object.defineProperty(exports, "refreshTailwindRuntimeState", {
 		return refreshTailwindRuntimeState;
 	}
 });
+Object.defineProperty(exports, "resolveStyleOptionsFromContext", {
+	enumerable: true,
+	get: function() {
+		return resolveStyleOptionsFromContext;
+	}
+});
 Object.defineProperty(exports, "shouldSkipJsTransform", {
 	enumerable: true,
 	get: function() {