weapp-tailwindcss 5.0.13 → 5.1.1

package/dist/{bundle-state-CKWeTEhv.js → source-candidate-scan-signature-BKYb9jxa.js}

@@ -1,5 +1,7 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_precheck = require("./precheck-B0Z8yW7E.js");
+const require_context = require("./context-B6hVF7dr.js");
+const require_tailwindcss = require("./tailwindcss-dbrbY4cd.js");
+const require_hmr_timing = require("./hmr-timing-CegXR9O4.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
@@ -80,10 +82,14 @@ function slash(p) {
 	return (0, _weapp_tailwindcss_shared.ensurePosix)(p);
 }
 const isWindows = node_process.default.platform === "win32";
-const cssLangRE = new RegExp(`\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`);
+const cssLangRE = new RegExp(`\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)`);
+const htmlLangRE = /\.html?(?:$|\?)/;
 function isCSSRequest(request) {
 	return cssLangRE.test(request) || isSourceStyleRequest(request);
 }
+function isHTMLRequest(request) {
+	return htmlLangRE.test(request);
+}
 function normalizePath(id) {
 	return node_path.default.posix.normalize(isWindows ? (0, _weapp_tailwindcss_shared.ensurePosix)(id) : id);
 }
@@ -119,9 +125,9 @@ function resolvePackageDir(name) {
 }
 //#endregion
 //#region src/bundlers/shared/generated-css-marker.ts
-const BUNDLER_GENERATED_CSS_MARKER_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/i;
-const BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/gi;
-const BUNDLER_GENERATED_CSS_MARKER_CAPTURE_RE = /\/\*!\s*weapp-tailwindcss (vite|webpack)-generated-css(?::([^\s*]+))?\s*\*\/\s*/gi;
+const BUNDLER_GENERATED_CSS_MARKER_RE = /\/\*!?\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?:\s*:\s*[^\s*]+)?\s*\*\/\s*/i;
+const BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE = /\/\*!?\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?:\s*:\s*[^\s*]+)?\s*\*\/\s*/gi;
+const BUNDLER_GENERATED_CSS_MARKER_CAPTURE_RE = /\/\*!?\s*weapp-tailwindcss (vite|webpack)-generated-css(?:\s*:\s*([^\s*]+))?\s*\*\/\s*/gi;
 function createBundlerGeneratedCssMarker(bundler, file) {
 	return `/*! weapp-tailwindcss ${bundler}-generated-css:${encodeURIComponent(file)} */`;
 }
@@ -150,6 +156,25 @@ function parseBundlerGeneratedCssMarkerBlocks(source) {
 	return blocks;
 }
 //#endregion
+//#region src/bundlers/shared/v4-generation-core.ts
+async function generateTailwindV4Css(options) {
+	const majorVersion = options.runtimeState.tailwindRuntime.majorVersion;
+	if (majorVersion !== 4) throw new Error("weapp-tailwindcss 生成管线仅支持 Tailwind CSS v4。");
+	const generated = await require_hmr_timing.generateCssByGenerator(options);
+	if (!generated) return;
+	return {
+		...generated,
+		classSet: generated.classSet,
+		dependencies: generated.dependencies,
+		metadata: {
+			file: options.file,
+			majorVersion,
+			outputFile: options.outputFile,
+			...generated.metadata ?? {}
+		}
+	};
+}
+//#endregion
 //#region src/bundlers/vite/bundle-entries.ts
 function readOutputEntry(entry) {
 	if (entry.output.type === "chunk") return entry.output.code;
@@ -203,10 +228,12 @@ 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*$/;
 function createHtmlRuntimeAffectingSignature(source) {
 	try {
 		const parts = [];
-		const parser = new require_precheck.Parser({
+		const parser = new require_context.Parser({
 			onattribute(name, value) {
 				parts.push(`a:${name}=${value}`);
 			},
@@ -226,15 +253,16 @@ function createHtmlRuntimeAffectingSignature(source) {
 	}
 }
 function createJsRuntimeAffectingSignature(source) {
+	if (!JS_RUNTIME_AFFECTING_TEXT_HINT_RE.test(source) && !JS_INCOMPLETE_TRAILING_OPERATOR_RE.test(source)) return "";
 	try {
-		const ast = require_precheck.babelParse(source, {
-			cache: true,
+		const ast = require_context.babelParse(source, {
+			cache: false,
 			cacheKey: "vite-runtime-affecting:unambiguous",
 			plugins: ["jsx", "typescript"],
 			sourceType: "unambiguous"
 		});
 		const parts = [];
-		require_precheck.traverse(ast, {
+		require_context.traverse(ast, {
 			noScope: true,
 			StringLiteral(path) {
 				parts.push(`s:${path.node.value}`);
@@ -298,8 +326,8 @@ function readEntrySource(output) {
 	return output.source.toString();
 }
 function classifyBundleEntry(file, opts) {
+	if (opts.htmlMatcher(file) || isHTMLRequest(file)) return "html";
 	if (opts.cssMatcher(file) || isCSSRequest(file)) return "css";
-	if (opts.htmlMatcher(file)) return "html";
 	if (opts.jsMatcher(file) || opts.wxsMatcher(file)) return "js";
 	return "other";
 }
@@ -334,12 +362,12 @@ function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false, opti
 		sourceHashByFile.set(file, hash);
 		const previousHash = state.sourceHashByFile.get(file);
 		const changed = previousHash == null || previousHash !== hash;
-		const previousRuntimeAffectingSignature = state.runtimeAffectingSignatureByFile.get(file);
 		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
-		const canReuseRuntimeAffectingSignature = !changed && previousRuntimeAffectingSignature != null && previousRuntimeAffectingHash != null;
-		const runtimeAffectingSignature = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingSignature : createRuntimeAffectingSourceSignature(source, type);
-		const runtimeAffectingHash = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingHash : opts.cache.computeHash(runtimeAffectingSignature);
-		runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+		const runtimeAffectingHash = !changed && previousRuntimeAffectingHash != null ? previousRuntimeAffectingHash : (() => {
+			const runtimeAffectingSignature = createRuntimeAffectingSourceSignature(source, type);
+			runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+			return opts.cache.computeHash(runtimeAffectingSignature);
+		})();
 		runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
 		if (changed) changedByType[type].add(file);
 		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) runtimeAffectingChangedByType[type].add(file);
@@ -392,16 +420,158 @@ function invertLinkedByEntry(linkedByEntry) {
 	}
 	return dependentsByLinkedFile;
 }
+function replaceMapEntries(target, source) {
+	target.clear();
+	for (const [key, value] of source) target.set(key, value);
+	return target;
+}
+function mergeMapEntries(target, source) {
+	for (const [key, value] of source) target.set(key, value);
+	return target;
+}
 function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
 	const incremental = options.incremental === true;
 	state.iteration += 1;
-	state.sourceHashByFile = incremental ? new Map([...state.sourceHashByFile, ...snapshot.sourceHashByFile]) : snapshot.sourceHashByFile;
-	state.runtimeAffectingSignatureByFile = incremental ? new Map([...state.runtimeAffectingSignatureByFile, ...snapshot.runtimeAffectingSignatureByFile]) : snapshot.runtimeAffectingSignatureByFile;
-	state.runtimeAffectingHashByFile = incremental ? new Map([...state.runtimeAffectingHashByFile, ...snapshot.runtimeAffectingHashByFile]) : snapshot.runtimeAffectingHashByFile;
-	state.linkedByEntry = incremental ? new Map([...state.linkedByEntry, ...linkedByEntry]) : linkedByEntry;
+	state.sourceHashByFile = incremental ? mergeMapEntries(state.sourceHashByFile, snapshot.sourceHashByFile) : replaceMapEntries(state.sourceHashByFile, snapshot.sourceHashByFile);
+	state.runtimeAffectingSignatureByFile.clear();
+	state.runtimeAffectingHashByFile = incremental ? mergeMapEntries(state.runtimeAffectingHashByFile, snapshot.runtimeAffectingHashByFile) : replaceMapEntries(state.runtimeAffectingHashByFile, snapshot.runtimeAffectingHashByFile);
+	state.linkedByEntry = incremental ? mergeMapEntries(state.linkedByEntry, linkedByEntry) : replaceMapEntries(state.linkedByEntry, linkedByEntry);
 	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
 }
 //#endregion
+//#region src/bundlers/vite/generate-bundle/signatures.ts
+function summarizeStringDiff(previous, next) {
+	if (previous === next) return "same";
+	const previousLength = previous.length;
+	const nextLength = next.length;
+	const minLength = Math.min(previousLength, nextLength);
+	let prefixLength = 0;
+	while (prefixLength < minLength && previous.charCodeAt(prefixLength) === next.charCodeAt(prefixLength)) prefixLength += 1;
+	let previousSuffixCursor = previousLength - 1;
+	let nextSuffixCursor = nextLength - 1;
+	while (previousSuffixCursor >= prefixLength && nextSuffixCursor >= prefixLength && previous.charCodeAt(previousSuffixCursor) === next.charCodeAt(nextSuffixCursor)) {
+		previousSuffixCursor -= 1;
+		nextSuffixCursor -= 1;
+	}
+	const previousChangedLength = previousSuffixCursor >= prefixLength ? previousSuffixCursor - prefixLength + 1 : 0;
+	const nextChangedLength = nextSuffixCursor >= prefixLength ? nextSuffixCursor - prefixLength + 1 : 0;
+	return `changed@${prefixLength} old=${previousChangedLength} new=${nextChangedLength} len=${previousLength}->${nextLength}`;
+}
+function createLinkedImpactSignature(entry, linkedImpactsByEntry, sourceHashByFile) {
+	const changedLinkedFiles = linkedImpactsByEntry.get(entry);
+	if (!changedLinkedFiles || changedLinkedFiles.size === 0) return;
+	return [...changedLinkedFiles].sort().map((file) => {
+		return `${file}:${sourceHashByFile.get(file) ?? "missing"}`;
+	}).join(",");
+}
+function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
+	if (!linkedImpactSignature) return runtimeSignature;
+	return `${runtimeSignature}:linked:${linkedImpactSignature}`;
+}
+function createStableTextSignature(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function createCandidateSignature(candidates) {
+	if (candidates.size === 0) return "empty";
+	return createStableTextSignature([...candidates].sort().join("\n"));
+}
+function getSnapshotHash(snapshotMap, file, fallback) {
+	return snapshotMap.get(file) ?? fallback;
+}
+function hasRuntimeAffectingSourceChanges(changedByType) {
+	return changedByType.html.size > 0 || changedByType.js.size > 0;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/scoped-generator.ts
+function hasOwnSourceDirectives(rawSource) {
+	return rawSource.includes("@source") || rawSource.includes("@config");
+}
+function createLocalSourceEntries(sourceFile) {
+	return [{
+		base: node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, ""))),
+		negated: false,
+		pattern: "**/*"
+	}];
+}
+function intersectCandidates(first, second) {
+	const scoped = /* @__PURE__ */ new Set();
+	const [small, large] = first.size <= second.size ? [first, second] : [second, first];
+	for (const candidate of small) if (large.has(candidate)) scoped.add(candidate);
+	return scoped;
+}
+function resolveScopedSourceEntries(rawSource, sourceFile, resolvedEntries) {
+	if (!hasOwnSourceDirectives(rawSource)) return {
+		entries: resolvedEntries,
+		localEntries: void 0
+	};
+	const localEntries = createLocalSourceEntries(sourceFile);
+	if (!resolvedEntries || resolvedEntries.length === 0) return {
+		entries: localEntries,
+		localEntries: void 0
+	};
+	return {
+		entries: resolvedEntries,
+		localEntries
+	};
+}
+async function createScopedGeneratorCandidateSignature(rawSource, sourceFile, fallbackSignature, getSourceCandidatesForEntries, options = {}) {
+	if (!getSourceCandidatesForEntries || !hasOwnSourceDirectives(rawSource)) return fallbackSignature;
+	const { entries, localEntries } = resolveScopedSourceEntries(rawSource, sourceFile, (await require_tailwindcss.resolveTailwindV4EntriesFromCssCached(rawSource, node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, "")))))?.entries);
+	if (entries === void 0) return fallbackSignature;
+	const scopedCandidates = getSourceCandidatesForEntries(entries);
+	const scopedSignature = createCandidateSignature(localEntries ? intersectCandidates(scopedCandidates, getSourceCandidatesForEntries(localEntries)) : scopedCandidates);
+	return options.includeFallbackSignature === true ? `${scopedSignature}:${fallbackSignature}` : scopedSignature;
+}
+async function createScopedGeneratorRuntime(options) {
+	const { cssHandlerOptions, fallbackRuntime, getSourceCandidatesForEntries, outputFile, rawSource, shouldExcludeSubpackageSourceCandidates, sourceFile, scopedSourceCandidateGetter } = options;
+	if (getSourceCandidatesForEntries && rawSource && sourceFile) {
+		const { entries, localEntries } = resolveScopedSourceEntries(rawSource, sourceFile, (await require_tailwindcss.resolveTailwindV4EntriesFromCssCached(rawSource, node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, "")))))?.entries);
+		if (entries !== void 0 && (entries.length > 0 || hasOwnSourceDirectives(rawSource))) {
+			const scopedCandidates = scopedSourceCandidateGetter?.(entries) ?? getSourceCandidatesForEntries(entries);
+			if (!localEntries) return scopedCandidates;
+			return intersectCandidates(scopedCandidates, scopedSourceCandidateGetter?.(localEntries) ?? getSourceCandidatesForEntries(localEntries));
+		}
+	}
+	const scopedCandidates = scopedSourceCandidateGetter?.(void 0);
+	if (scopedCandidates && (scopedCandidates.size > 0 || shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions))) return scopedCandidates;
+	if (!shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions)) return fallbackRuntime;
+	return fallbackRuntime;
+}
+//#endregion
+//#region src/bundlers/vite/source-candidate-scan-signature.ts
+function normalizeSignaturePath(value) {
+	return slash(node_path.default.resolve(value));
+}
+function serializeInlineCandidates(inlineCandidates) {
+	return {
+		excluded: [...inlineCandidates?.excluded ?? []].sort(),
+		included: [...inlineCandidates?.included ?? []].sort()
+	};
+}
+function serializeSourceEntries(entries) {
+	return (entries ?? []).map((entry) => ({
+		base: normalizeSignaturePath(entry.base),
+		negated: entry.negated,
+		pattern: entry.pattern
+	})).sort((a, b) => `${a.base}\0${a.pattern}\0${a.negated}`.localeCompare(`${b.base}\0${b.pattern}\0${b.negated}`));
+}
+function createSourceCandidateScanSignature(input) {
+	return JSON.stringify({
+		inlineCandidates: serializeInlineCandidates(input.inlineCandidates),
+		outDir: input.outDir ? normalizeSignaturePath(input.outDir) : void 0,
+		roots: input.roots.map((root) => ({
+			entries: serializeSourceEntries(root.entries),
+			root: normalizeSignaturePath(root.root)
+		})),
+		scanAllSources: input.scanAllSources ?? false
+	});
+}
+//#endregion
 Object.defineProperty(exports, "applyLinkedResults", {
 	enumerable: true,
 	get: function() {
@@ -414,6 +584,12 @@ Object.defineProperty(exports, "buildBundleSnapshot", {
 		return buildBundleSnapshot;
 	}
 });
+Object.defineProperty(exports, "classifyBundleEntry", {
+	enumerable: true,
+	get: function() {
+		return classifyBundleEntry;
+	}
+});
 Object.defineProperty(exports, "createBundleBuildState", {
 	enumerable: true,
 	get: function() {
@@ -432,30 +608,90 @@ Object.defineProperty(exports, "createBundlerGeneratedCssMarker", {
 		return createBundlerGeneratedCssMarker;
 	}
 });
+Object.defineProperty(exports, "createCandidateSignature", {
+	enumerable: true,
+	get: function() {
+		return createCandidateSignature;
+	}
+});
+Object.defineProperty(exports, "createJsHashSalt", {
+	enumerable: true,
+	get: function() {
+		return createJsHashSalt;
+	}
+});
+Object.defineProperty(exports, "createLinkedImpactSignature", {
+	enumerable: true,
+	get: function() {
+		return createLinkedImpactSignature;
+	}
+});
 Object.defineProperty(exports, "createRuntimeAffectingSourceSignature", {
 	enumerable: true,
 	get: function() {
 		return createRuntimeAffectingSourceSignature;
 	}
 });
+Object.defineProperty(exports, "createScopedGeneratorCandidateSignature", {
+	enumerable: true,
+	get: function() {
+		return createScopedGeneratorCandidateSignature;
+	}
+});
+Object.defineProperty(exports, "createScopedGeneratorRuntime", {
+	enumerable: true,
+	get: function() {
+		return createScopedGeneratorRuntime;
+	}
+});
+Object.defineProperty(exports, "createSourceCandidateScanSignature", {
+	enumerable: true,
+	get: function() {
+		return createSourceCandidateScanSignature;
+	}
+});
 Object.defineProperty(exports, "formatPostcssSourceMap", {
 	enumerable: true,
 	get: function() {
 		return formatPostcssSourceMap;
 	}
 });
+Object.defineProperty(exports, "generateTailwindV4Css", {
+	enumerable: true,
+	get: function() {
+		return generateTailwindV4Css;
+	}
+});
+Object.defineProperty(exports, "getSnapshotHash", {
+	enumerable: true,
+	get: function() {
+		return getSnapshotHash;
+	}
+});
 Object.defineProperty(exports, "hasBundlerGeneratedCssMarker", {
 	enumerable: true,
 	get: function() {
 		return hasBundlerGeneratedCssMarker;
 	}
 });
+Object.defineProperty(exports, "hasRuntimeAffectingSourceChanges", {
+	enumerable: true,
+	get: function() {
+		return hasRuntimeAffectingSourceChanges;
+	}
+});
 Object.defineProperty(exports, "isCSSRequest", {
 	enumerable: true,
 	get: function() {
 		return isCSSRequest;
 	}
 });
+Object.defineProperty(exports, "isHTMLRequest", {
+	enumerable: true,
+	get: function() {
+		return isHTMLRequest;
+	}
+});
 Object.defineProperty(exports, "isSourceStyleRequest", {
 	enumerable: true,
 	get: function() {
@@ -516,6 +752,12 @@ Object.defineProperty(exports, "stripRequestQuery", {
 		return stripRequestQuery;
 	}
 });
+Object.defineProperty(exports, "summarizeStringDiff", {
+	enumerable: true,
+	get: function() {
+		return summarizeStringDiff;
+	}
+});
 Object.defineProperty(exports, "toAbsoluteOutputPath", {
 	enumerable: true,
 	get: function() {

package/dist/tailwindcss/candidates.d.ts

@@ -0,0 +1,7 @@
+import type { IArbitraryValues } from '../types/shared';
+export interface SourceCandidateExtractionOptions {
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
+    extractor?: ((source: string, extension: string) => Promise<Iterable<string>> | Iterable<string>) | undefined;
+}
+export declare function extractCandidatesFromSource(source: string, extension: string, options?: SourceCandidateExtractionOptions): Promise<Set<string>>;
+export declare function extractScriptStringCandidates(source: string, extension: string, options: SourceCandidateExtractionOptions): Promise<never[] | Set<string>>;

package/dist/tailwindcss/index.d.ts

@@ -1,6 +1,6 @@
 import type { PackageResolvingOptions } from 'local-pkg';
 import type { PackageJson } from 'pkg-types';
-import { createTailwindcssPatcher } from './patcher';
+import { createTailwindcssRuntime } from './runtime-factory';
 declare function getTailwindcssPackageInfo(options?: PackageResolvingOptions): {
     name: string;
     version: string | undefined;
@@ -8,4 +8,4 @@ declare function getTailwindcssPackageInfo(options?: PackageResolvingOptions): {
     packageJsonPath: string;
     packageJson: PackageJson;
 } | undefined;
-export { createTailwindcssPatcher, getTailwindcssPackageInfo, };
+export { createTailwindcssRuntime, getTailwindcssPackageInfo, };

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

@@ -1,12 +1,12 @@
-import type { TailwindcssPatcherLike } from '../../types';
+import type { TailwindcssRuntimeLike } from '../../types';
 interface RuntimeClassSetCacheEntry {
     value?: Set<string> | undefined;
     promise?: Promise<Set<string>> | undefined;
     signature?: string | undefined;
 }
-export declare const runtimeSignaturePatchersSymbol: unique symbol;
-export declare function invalidateRuntimeClassSet(twPatcher?: TailwindcssPatcherLike): void;
-export declare function getRuntimeClassSetCacheEntry(twPatcher: TailwindcssPatcherLike): RuntimeClassSetCacheEntry;
-export declare function getRuntimeClassSetSignature(twPatcher: TailwindcssPatcherLike): string;
-export declare function getRuntimeClassSetSignatureWithSources(twPatcher: TailwindcssPatcherLike): Promise<string>;
+export declare const runtimeSignatureRuntimesSymbol: unique symbol;
+export declare function invalidateRuntimeClassSet(tailwindRuntime?: TailwindcssRuntimeLike): void;
+export declare function getRuntimeClassSetCacheEntry(tailwindRuntime: TailwindcssRuntimeLike): RuntimeClassSetCacheEntry;
+export declare function getRuntimeClassSetSignature(tailwindRuntime: TailwindcssRuntimeLike): string;
+export declare function getRuntimeClassSetSignatureWithSources(tailwindRuntime: TailwindcssRuntimeLike): Promise<string>;
 export {};

package/dist/tailwindcss/runtime-factory.d.ts

@@ -0,0 +1,12 @@
+import type { LengthUnitsRuntimeOptions, TailwindCssRuntimeOptions } from './runtime-types';
+import type { TailwindcssRuntimeLike } from '../types';
+type TailwindUserOptions = NonNullable<TailwindCssRuntimeOptions['tailwindcss']>;
+export interface CreateTailwindcssRuntimeOptions {
+    basedir?: string;
+    cacheDir?: string;
+    supportCustomLengthUnits?: boolean | LengthUnitsRuntimeOptions;
+    tailwindcss?: TailwindUserOptions;
+    tailwindcssRuntimeOptions?: TailwindCssRuntimeOptions;
+}
+export declare function createTailwindcssRuntime(options?: CreateTailwindcssRuntimeOptions): TailwindcssRuntimeLike;
+export {};

package/dist/tailwindcss/runtime-options.d.ts

@@ -0,0 +1,8 @@
+import type { LengthUnitsRuntimeOptions, TailwindCssRuntimeOptions } from './runtime-types';
+type TailwindUserOptions = NonNullable<TailwindCssRuntimeOptions['tailwindcss']>;
+type TailwindApplyOptions = NonNullable<TailwindCssRuntimeOptions['apply']>;
+type TailwindExtendLengthUnitsOption = TailwindApplyOptions['extendLengthUnits'];
+export declare function resolveTailwindcssOptions(options?: TailwindCssRuntimeOptions): TailwindUserOptions | undefined;
+export declare function normalizeExtendLengthUnits(value: boolean | LengthUnitsRuntimeOptions | undefined): TailwindExtendLengthUnitsOption | undefined;
+export declare function normalizeTailwindcssRuntimeOptions(options?: TailwindCssRuntimeOptions): TailwindCssRuntimeOptions | undefined;
+export {};

package/dist/tailwindcss/runtime-types.d.ts

@@ -0,0 +1,87 @@
+import type { PackageResolvingOptions } from 'local-pkg';
+import type { TailwindSourceEntry } from './source-scan';
+import type { TailwindV4SourceOptions } from './v4-engine';
+type TailwindV4CssSource = NonNullable<TailwindV4SourceOptions['cssSources']>[number];
+export interface LengthUnitsRuntimeOptions {
+    units?: string[] | undefined;
+    rem2rpx?: boolean | undefined;
+    [key: string]: unknown;
+}
+export interface ExtendLengthUnitsOptions extends Partial<LengthUnitsRuntimeOptions> {
+    enabled?: boolean | undefined;
+}
+export type CacheStrategy = 'merge' | 'overwrite';
+export type CacheDriver = 'file' | 'memory' | 'noop';
+export interface CacheOptions {
+    enabled?: boolean | undefined;
+    cwd?: string | undefined;
+    dir?: string | undefined;
+    file?: string | undefined;
+    strategy?: CacheStrategy | undefined;
+    driver?: CacheDriver | undefined;
+}
+export interface ExtractOptions {
+    write?: boolean | undefined;
+    file?: string | undefined;
+    format?: 'json' | 'lines' | undefined;
+    pretty?: number | boolean | undefined;
+    removeUniversalSelector?: boolean | undefined;
+}
+export interface ExposeContextOptions {
+    refProperty?: string | undefined;
+}
+export interface ApplyOptions {
+    overwrite?: boolean | undefined;
+    exposeContext?: boolean | ExposeContextOptions | undefined;
+    extendLengthUnits?: false | ExtendLengthUnitsOptions | undefined;
+}
+export interface TailwindRuntimeOptionsBase {
+    config?: string | undefined;
+    cwd?: string | undefined;
+    postcssPlugin?: string | undefined;
+}
+export interface TailwindV4Options {
+    base?: string | undefined;
+    css?: string | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+    cssEntries?: string[] | undefined;
+    sources?: TailwindSourceEntry[] | undefined;
+    bareArbitraryValues?: boolean | {
+        units?: string[] | undefined;
+    } | undefined;
+}
+export interface TailwindCssOptions extends TailwindRuntimeOptionsBase {
+    version?: 4 | undefined;
+    packageName?: string | undefined;
+    resolve?: PackageResolvingOptions | undefined;
+    v4?: TailwindV4Options | undefined;
+}
+export interface TailwindCssRuntimeOptions {
+    projectRoot?: string | undefined;
+    tailwindcss?: TailwindCssOptions | undefined;
+    apply?: ApplyOptions | undefined;
+    extract?: ExtractOptions | undefined;
+    filter?: ((className: string) => boolean) | undefined;
+    cache?: boolean | CacheOptions | undefined;
+}
+export interface TailwindPackageInfo {
+    name: string;
+    version: string | undefined;
+    rootPath: string;
+    packageJsonPath: string;
+    packageJson: Record<string, unknown>;
+}
+export interface TailwindcssExtractOptions extends ExtractOptions {
+}
+export interface TailwindcssExtractResult {
+    classList: string[];
+    classSet: Set<string>;
+    filename?: string | undefined;
+}
+export interface TailwindContentTokenReport {
+    entries: unknown[];
+    filesScanned: number;
+    sources: unknown[];
+    skippedFiles: unknown[];
+}
+export {};

package/dist/tailwindcss/runtime.d.ts

@@ -1,6 +1,6 @@
-import type { RefreshTailwindcssPatcherOptions, TailwindcssPatcherLike } from '../types';
+import type { RefreshTailwindcssRuntimeOptions, TailwindcssRuntimeLike } from '../types';
 import { invalidateRuntimeClassSet } from './runtime/cache';
-export declare const refreshTailwindcssPatcherSymbol: unique symbol;
+export declare const refreshTailwindcssRuntimeSymbol: unique symbol;
 export interface CollectRuntimeClassSetOptions {
     force?: boolean | undefined;
     skipRefresh?: boolean | undefined;
@@ -10,11 +10,11 @@ export interface RefreshTailwindRuntimeStateOptions {
     force: boolean;
     clearCache?: boolean | undefined;
 }
-export declare function createTailwindRuntimeReadyPromise(twPatcher: TailwindcssPatcherLike): Promise<void>;
+export declare function createTailwindRuntimeReadyPromise(tailwindRuntime: TailwindcssRuntimeLike): Promise<void>;
 export interface TailwindRuntimeState {
-    twPatcher: TailwindcssPatcherLike;
+    tailwindRuntime: TailwindcssRuntimeLike;
     readyPromise: Promise<void>;
-    refreshTailwindcssPatcher?: ((options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>) | undefined;
+    refreshTailwindcssRuntime?: ((options?: RefreshTailwindcssRuntimeOptions) => Promise<TailwindcssRuntimeLike>) | undefined;
 }
 export declare function refreshTailwindRuntimeState(state: TailwindRuntimeState, forceOrOptions: boolean | RefreshTailwindRuntimeStateOptions): Promise<boolean>;
 export interface EnsureRuntimeClassSetOptions {
@@ -24,5 +24,5 @@ export interface EnsureRuntimeClassSetOptions {
     allowEmpty?: boolean | undefined;
 }
 export declare function ensureRuntimeClassSet(state: TailwindRuntimeState, options?: EnsureRuntimeClassSetOptions): Promise<Set<string>>;
-declare function collectRuntimeClassSet(twPatcher: TailwindcssPatcherLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;
+declare function collectRuntimeClassSet(tailwindRuntime: TailwindcssRuntimeLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;
 export { collectRuntimeClassSet, invalidateRuntimeClassSet };

package/dist/tailwindcss/source-scan.d.ts

@@ -1,5 +1,5 @@
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { Root } from '@weapp-tailwindcss/postcss';
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
 export interface TailwindSourceEntry {
     base: string;
     pattern: string;

package/dist/tailwindcss/targets.d.ts

@@ -1,2 +1,2 @@
-import type { TailwindcssPatcherLike } from '../types';
-export declare function logTailwindcssTarget(patcher: TailwindcssPatcherLike | undefined, baseDir?: string): void;
+import type { TailwindcssRuntimeLike } from '../types';
+export declare function logTailwindcssTarget(tailwindRuntime: TailwindcssRuntimeLike | undefined, baseDir?: string): void;

package/dist/tailwindcss/v4/config.d.ts

@@ -1,5 +1,5 @@
-import type { InternalUserDefinedOptions, TailwindcssPatcherLike } from '../../types';
+import type { InternalUserDefinedOptions, TailwindcssRuntimeLike } from '../../types';
 export declare const DEFAULT_CSS_CALC_CUSTOM_PROPERTIES: (string | RegExp)[];
 export declare function normalizeCssEntriesConfig(entries: unknown): string[] | undefined;
-export declare function warnMissingCssEntries(ctx: InternalUserDefinedOptions, patcher: TailwindcssPatcherLike | undefined): void;
-export declare function applyV4CssCalcDefaults(cssCalc: InternalUserDefinedOptions['cssCalc'], patcher: TailwindcssPatcherLike | undefined): InternalUserDefinedOptions['cssCalc'];
+export declare function warnMissingCssEntries(ctx: InternalUserDefinedOptions, tailwindRuntime: TailwindcssRuntimeLike | undefined): void;
+export declare function applyV4CssCalcDefaults(cssCalc: InternalUserDefinedOptions['cssCalc'], tailwindRuntime: TailwindcssRuntimeLike | undefined): InternalUserDefinedOptions['cssCalc'];

package/dist/tailwindcss/v4/css-entries.d.ts

@@ -1,3 +1,4 @@
+export declare function isTailwindV4CssEntry(entry: string | undefined): entry is string;
 export declare function guessBasedirFromEntries(entries?: string[]): string | undefined;
 export declare function normalizeCssEntries(entries: string[] | undefined, anchor: string): string[] | undefined;
 export interface GroupCssEntriesOptions {

package/dist/tailwindcss/v4/css-sources.d.ts

@@ -1,5 +1,7 @@
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { UserDefinedOptions } from '../../types';
 export declare function hasCssSourcesValue(value: unknown): boolean;
-export declare function hasConfiguredTailwindV4CssRoots(options: Pick<UserDefinedOptions, 'cssEntries' | 'tailwindcss' | 'tailwindcssPatcherOptions'>): boolean;
+export declare function isTailwindV4CssSourceRoot(source: unknown): source is TailwindV4CssSource;
+export declare function filterTailwindV4CssSourceRoots(sources: TailwindV4CssSource[] | undefined): TailwindV4CssSource[] | undefined;
+export declare function hasConfiguredTailwindV4CssRoots(options: Pick<UserDefinedOptions, 'cssEntries' | 'tailwindcss' | 'tailwindcssRuntimeOptions'>): boolean;
 export declare function upsertTailwindV4CssSource(opts: UserDefinedOptions, source: TailwindV4CssSource): boolean;

package/dist/tailwindcss/v4/index.d.ts

@@ -1,2 +1,2 @@
 export * from './config';
-export * from './patcher';
+export * from './runtime-factory';

package/dist/tailwindcss/v4/multi-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { TailwindcssRuntimeLike } from '../../types';
+export declare function createMultiTailwindcssRuntime(runtimes: TailwindcssRuntimeLike[]): TailwindcssRuntimeLike;

package/dist/tailwindcss/v4/runtime-factory.d.ts

@@ -0,0 +1,15 @@
+import type { TailwindCssRuntimeOptions } from '../runtime-types';
+import type { CreateTailwindcssRuntimeOptions } from '../runtime-factory';
+import type { InternalUserDefinedOptions, TailwindcssRuntimeLike } from '../../types';
+export { groupCssEntriesByBase, guessBasedirFromEntries, normalizeCssEntries } from './css-entries';
+export { createMultiTailwindcssRuntime } from './multi-runtime';
+type TailwindUserOptions = NonNullable<TailwindCssRuntimeOptions['tailwindcss']>;
+export interface TailwindcssRuntimeFactoryOptions {
+    tailwindcss?: TailwindUserOptions;
+    tailwindcssRuntimeOptions?: CreateTailwindcssRuntimeOptions['tailwindcssRuntimeOptions'];
+    supportCustomLengthUnits: InternalUserDefinedOptions['supportCustomLengthUnits'];
+    appType: InternalUserDefinedOptions['appType'];
+    bareArbitraryValues?: InternalUserDefinedOptions['arbitraryValues']['bareArbitraryValues'];
+}
+export declare function createTailwindcssRuntimeForBase(baseDir: string, cssEntries: string[] | undefined, options: TailwindcssRuntimeFactoryOptions): TailwindcssRuntimeLike;
+export declare function tryCreateMultiTailwindcssRuntime(groups: Map<string, string[]>, options: TailwindcssRuntimeFactoryOptions): TailwindcssRuntimeLike | undefined;