weapp-tailwindcss 5.0.12 → 5.1.0

package/dist/{bundle-state-BxMNKjBV.mjs → source-candidate-scan-signature-Cvb5z1ha.mjs}

@@ -1,4 +1,6 @@
-import { h as traverse, m as babelParse, o as Parser } from "./precheck-CsFr1q2l.mjs";
+import { a as Parser, h as traverse, m as babelParse } from "./context-Mbzkek1q.mjs";
+import { g as resolveTailwindV4EntriesFromCssCached } from "./tailwindcss-wyUHrfil.mjs";
+import { u as generateCssByGenerator } from "./hmr-timing-BXMLsF4b.mjs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import process from "node:process";
@@ -77,10 +79,14 @@ function slash(p) {
 	return ensurePosix(p);
 }
 const isWindows = process.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 path.posix.normalize(isWindows ? ensurePosix(id) : id);
 }
@@ -116,9 +122,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)} */`;
 }
@@ -147,6 +153,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 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;
@@ -200,6 +225,8 @@ 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 = [];
@@ -223,9 +250,10 @@ 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 = babelParse(source, {
-			cache: true,
+			cache: false,
 			cacheKey: "vite-runtime-affecting:unambiguous",
 			plugins: ["jsx", "typescript"],
 			sourceType: "unambiguous"
@@ -295,8 +323,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";
 }
@@ -331,12 +359,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);
@@ -389,14 +417,156 @@ 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
-export { toAbsoluteOutputPath as S, slash as _, applyLinkedResults as a, normalizeOutputPathKey as b, hasBundlerGeneratedCssMarker as c, resolvePackageDir as d, resolvePluginDisabledState as f, normalizePath as g, isCSSRequest as h, createRuntimeAffectingSourceSignature as i, parseBundlerGeneratedCssMarkerBlocks as l, formatPostcssSourceMap as m, createBundleBuildState as n, createBundleModuleGraphOptions as o, cleanUrl as p, updateBundleBuildState as r, createBundlerGeneratedCssMarker as s, buildBundleSnapshot as t, stripBundlerGeneratedCssMarkers as u, isSourceStyleRequest as v, resolveOutputSpecifier as x, stripRequestQuery as y };
+//#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: path.dirname(path.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 resolveTailwindV4EntriesFromCssCached(rawSource, path.dirname(path.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 resolveTailwindV4EntriesFromCssCached(rawSource, path.dirname(path.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(path.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
+export { isSourceStyleRequest as A, resolvePluginDisabledState as C, isHTMLRequest as D, isCSSRequest as E, normalizeOutputPathKey as M, resolveOutputSpecifier as N, normalizePath as O, toAbsoluteOutputPath as P, resolvePackageDir as S, formatPostcssSourceMap as T, generateTailwindV4Css as _, createJsHashSalt as a, parseBundlerGeneratedCssMarkerBlocks as b, hasRuntimeAffectingSourceChanges as c, classifyBundleEntry as d, createBundleBuildState as f, createBundleModuleGraphOptions as g, applyLinkedResults as h, createCandidateSignature as i, stripRequestQuery as j, slash as k, summarizeStringDiff as l, createRuntimeAffectingSourceSignature as m, createScopedGeneratorCandidateSignature as n, createLinkedImpactSignature as o, updateBundleBuildState as p, createScopedGeneratorRuntime as r, getSnapshotHash as s, createSourceCandidateScanSignature as t, buildBundleSnapshot as u, createBundlerGeneratedCssMarker as v, cleanUrl as w, stripBundlerGeneratedCssMarkers as x, hasBundlerGeneratedCssMarker as y };

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,86 @@
+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>;
+}
+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;

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

@@ -0,0 +1,2 @@
+import type { TailwindCssRuntimeOptions } from '../runtime-types';
+export declare function overrideTailwindcssRuntimeOptionsForBase(options: TailwindCssRuntimeOptions | undefined, baseDir: string, cssEntries: string[]): TailwindCssRuntimeOptions | undefined;

package/dist/tailwindcss/v4-engine/design-system.d.ts

@@ -1 +1 @@
-export { loadTailwindV4DesignSystem, resolveValidTailwindV4Candidates, } from 'tailwindcss-patch';
+export { loadTailwindV4DesignSystem, resolveValidTailwindV4Candidates, } from '@tailwindcss-mangle/engine';

package/dist/tailwindcss/v4-engine/generator/css-compat.d.ts

@@ -1,2 +1,2 @@
 import type { TailwindV4GenerateTarget, TailwindV4ResolvedSource } from '../types';
-export declare function createCompatibleSource(source: TailwindV4ResolvedSource, target: TailwindV4GenerateTarget, tailwindcssV3Compatibility: boolean | undefined): TailwindV4ResolvedSource;
+export declare function createCompatibleSource(source: TailwindV4ResolvedSource, target: TailwindV4GenerateTarget): TailwindV4ResolvedSource;

package/dist/tailwindcss/v4-engine/generator/rpx-candidates.d.ts

@@ -1,6 +1,6 @@
-export declare function normalizeRpxTextCandidates(candidates: Iterable<string>): {
+export declare function normalizeRpxLengthCandidates(candidates: Iterable<string>): {
     candidates: Set<string>;
     restoreCandidates: Map<string, string>;
 };
-export declare function restoreRpxTextCandidates(candidates: Iterable<string>, restoreCandidates: ReadonlyMap<string, string>): Set<string>;
-export declare function restoreRpxTextCssSelectors(css: string, restoreCandidates: ReadonlyMap<string, string>): string;
+export declare function restoreRpxLengthCandidates(candidates: Iterable<string>, restoreCandidates: ReadonlyMap<string, string>): Set<string>;
+export declare function restoreRpxLengthCssSelectors(css: string, restoreCandidates: ReadonlyMap<string, string>): string;

package/dist/tailwindcss/v4-engine/generator/scan-sources.d.ts

@@ -1,2 +1,2 @@
 import type { TailwindV4GenerateOptions, TailwindV4ResolvedSource } from '../types';
-export declare function resolveScanSources(source: TailwindV4ResolvedSource, scanSources: TailwindV4GenerateOptions['scanSources']): Promise<boolean | import("tailwindcss-patch").TailwindV4SourcePattern[] | undefined>;
+export declare function resolveScanSources(source: TailwindV4ResolvedSource, scanSources: TailwindV4GenerateOptions['scanSources']): Promise<boolean | import("@tailwindcss-mangle/engine").TailwindV4SourcePattern[] | undefined>;

package/dist/tailwindcss/v4-engine/generator.d.ts

@@ -8,14 +8,21 @@ export declare function getTailwindV4IncrementalGenerateCacheStats(): {
     taskMax: number;
     taskSize: number;
     entries: {
-        key: string;
         candidates: number;
         classSet: number;
         cssBytes: number;
         rawCssBytes: number;
+        keyHash: string;
+        keyBytes: number;
+    }[];
+    keys: {
+        keyHash: string;
+        keyBytes: number;
+    }[];
+    taskKeys: {
+        keyHash: string;
+        keyBytes: number;
     }[];
-    keys: string[];
-    taskKeys: string[];
 };
 export declare const getTailwindV4IncrementalGenerateCacheStatsForTest: typeof getTailwindV4IncrementalGenerateCacheStats;
 export declare function clearTailwindV4IncrementalGenerateCacheForTest(): void;

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

@@ -1,5 +1,5 @@
 export { loadTailwindV4DesignSystem, resolveValidTailwindV4Candidates, } from './design-system';
 export { clearTailwindV4IncrementalGenerateCacheForTest, createTailwindV4Engine, getTailwindV4IncrementalGenerateCacheStats, getTailwindV4IncrementalGenerateCacheStatsForTest, } from './generator';
 export { transformTailwindV4CssByTarget, transformTailwindV4CssToWeapp } from './miniprogram';
-export { resolveTailwindV4Source, resolveTailwindV4SourceFromPatcher, resolveTailwindV4SourceFromPatchOptions, resolveTailwindV4SourceOptionsFromPatcher, } from './source';
+export { resolveTailwindV4Source, resolveTailwindV4SourceFromRuntime, resolveTailwindV4SourceFromRuntimeOptions, resolveTailwindV4SourceOptionsFromRuntime, } from './source';
 export type { TailwindV4CandidateSource, TailwindV4DesignSystem, TailwindV4Engine, TailwindV4GenerateOptions, TailwindV4GenerateResult, TailwindV4GenerateTarget, TailwindV4ResolvedSource, TailwindV4SourceOptions, } from './types';

package/dist/tailwindcss/v4-engine/miniprogram.d.ts

@@ -1,5 +1,11 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { TailwindV4GenerateTarget } from './types';
+import type { AppType } from '../../types';
+type TailwindV4TargetStyleOptions = Partial<IStyleHandlerOptions> & {
+    appType?: AppType | undefined;
+};
 export declare function normalizeTailwindV4GeneratedUrlValues(css: string): string;
 export declare function transformTailwindV4CssToWeapp(css: string, options?: Partial<IStyleHandlerOptions>): Promise<string>;
-export declare function transformTailwindV4CssByTarget(css: string, target: TailwindV4GenerateTarget, options?: Partial<IStyleHandlerOptions>): Promise<string>;
+export declare function transformTailwindV4WebRpxCss(css: string): string;
+export declare function transformTailwindV4CssByTarget(css: string, target: TailwindV4GenerateTarget, options?: TailwindV4TargetStyleOptions): Promise<string>;
+export {};