weapp-tailwindcss 5.0.0-next.2 → 5.0.0-next.21

package/dist/shared/mpx.d.ts

@@ -1,6 +1,7 @@
 import type { AppType } from '../types';
 export declare function isMpx(appType?: AppType): appType is "mpx";
 export declare function getTailwindcssCssEntry(pkgDir: string): string;
+export declare function patchMpxWebpackPluginNormalizeLib(compiler: any, mpxWebpackPluginDir: string | undefined): boolean;
 export declare function ensureMpxTailwindcssAliases(compiler: any, pkgDir: string): string;
 export declare function patchMpxLoaderResolve(loaderContext: any, pkgDir: string, enabled: boolean): void;
 export declare function setupMpxTailwindcssRedirect(pkgDir: string, enabled: boolean): void;

package/dist/source-candidates-CUTNdsiz.js

@@ -0,0 +1,222 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_v3_engine = require("./v3-engine-CCwvhRrQ.js");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let tailwindcss_patch = require("tailwindcss-patch");
+let node_fs_promises = require("node:fs/promises");
+//#region src/bundlers/vite/source-candidates.ts
+const CLEAN_URL_RE = /[?#].*$/;
+const sourceCandidateContentCache = /* @__PURE__ */ new Map();
+function cleanUrl(id) {
+	return require_v3_engine.resolveSourceScanPath(id.replace(CLEAN_URL_RE, ""));
+}
+function resolveOutDirIgnorePattern(root, outDir) {
+	if (!outDir) return;
+	const relative = node_path.default.relative(root, node_path.default.resolve(root, outDir));
+	if (!relative || relative.startsWith("..") || node_path.default.isAbsolute(relative)) return;
+	return `${require_v3_engine.toPosixPath(relative)}/**`;
+}
+function resolveSourceCandidateExtension(id) {
+	const normalized = cleanUrl(id);
+	return /\.([^.\\/]+)$/.exec(normalized)?.[1] ?? "html";
+}
+function createSourceCandidateContentCacheKey(extension, source) {
+	return `${extension}\0${source}`;
+}
+function isSourceCandidateRequest(id) {
+	return require_v3_engine.FULL_SOURCE_SCAN_EXTENSION_RE.test(cleanUrl(id));
+}
+function removeCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) {
+		const count = candidateCount.get(candidate);
+		if (count == null) continue;
+		if (count <= 1) {
+			candidateCount.delete(candidate);
+			continue;
+		}
+		candidateCount.set(candidate, count - 1);
+	}
+}
+function addCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) candidateCount.set(candidate, (candidateCount.get(candidate) ?? 0) + 1);
+}
+function createSourceCandidateCollector() {
+	const candidatesById = /* @__PURE__ */ new Map();
+	const scanCandidatesById = /* @__PURE__ */ new Map();
+	const transformCandidatesById = /* @__PURE__ */ new Map();
+	const candidateCount = /* @__PURE__ */ new Map();
+	let inlineIncludedCandidates = /* @__PURE__ */ new Set();
+	let inlineExcludedCandidates = /* @__PURE__ */ new Set();
+	async function sync(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		if (cachedCandidates) {
+			replaceScanLayer(normalizedId, new Set(cachedCandidates));
+			return;
+		}
+		const nextCandidates = new Set(await (0, tailwindcss_patch.extractSourceCandidates)(source, extension));
+		sourceCandidateContentCache.set(contentCacheKey, [...nextCandidates]);
+		replaceScanLayer(normalizedId, nextCandidates);
+	}
+	async function merge(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		const extractedCandidates = cachedCandidates ? new Set(cachedCandidates) : new Set(await (0, tailwindcss_patch.extractSourceCandidates)(source, extension));
+		if (!cachedCandidates) sourceCandidateContentCache.set(contentCacheKey, [...extractedCandidates]);
+		replaceTransformLayer(normalizedId, extractedCandidates);
+	}
+	async function syncFile(id) {
+		const normalizedId = cleanUrl(id);
+		await sync(normalizedId, await (0, node_fs_promises.readFile)(normalizedId, "utf8"));
+	}
+	async function syncCurrentFile(id) {
+		const normalizedId = cleanUrl(id);
+		transformCandidatesById.delete(normalizedId);
+		await syncFile(normalizedId);
+	}
+	async function scanRoot({ entries, root, outDir }) {
+		const resolvedRoot = node_path.default.resolve(root);
+		const outDirIgnore = resolveOutDirIgnorePattern(resolvedRoot, outDir);
+		const scanEntries = outDirIgnore ? [...entries?.length ? entries : [{
+			base: resolvedRoot,
+			pattern: "**/*",
+			negated: false
+		}], {
+			base: resolvedRoot,
+			pattern: outDirIgnore,
+			negated: true
+		}] : entries;
+		const files = await (0, tailwindcss_patch.resolveProjectSourceFiles)({
+			cwd: resolvedRoot,
+			...scanEntries === void 0 ? {} : { sources: scanEntries },
+			filter: isSourceCandidateRequest
+		});
+		await Promise.all(files.map((file) => syncFile(file)));
+	}
+	function replaceFinal(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (previousCandidates) {
+			removeCandidateSet(candidateCount, previousCandidates);
+			candidatesById.delete(normalizedId);
+		}
+		if (nextCandidates.size === 0) return;
+		candidatesById.set(normalizedId, nextCandidates);
+		addCandidateSet(candidateCount, nextCandidates);
+	}
+	function replaceScanLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) scanCandidatesById.delete(normalizedId);
+		else scanCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function replaceTransformLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) transformCandidatesById.delete(normalizedId);
+		else transformCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function recompute(id) {
+		const normalizedId = cleanUrl(id);
+		replaceFinal(normalizedId, new Set([...scanCandidatesById.get(normalizedId) ?? [], ...transformCandidatesById.get(normalizedId) ?? []]));
+	}
+	function syncInline(inlineCandidates) {
+		inlineIncludedCandidates = new Set(inlineCandidates?.included ?? []);
+		inlineExcludedCandidates = new Set(inlineCandidates?.excluded ?? []);
+	}
+	function remove(id) {
+		const normalizedId = cleanUrl(id);
+		scanCandidatesById.delete(normalizedId);
+		transformCandidatesById.delete(normalizedId);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (!previousCandidates) return;
+		removeCandidateSet(candidateCount, previousCandidates);
+		candidatesById.delete(normalizedId);
+	}
+	function values() {
+		const values = new Set([...candidateCount.keys(), ...inlineIncludedCandidates]);
+		for (const candidate of inlineExcludedCandidates) values.delete(candidate);
+		return values;
+	}
+	function valuesForEntries(entries) {
+		if (entries === void 0) return values();
+		const filtered = /* @__PURE__ */ new Set();
+		for (const [id, candidates] of candidatesById) {
+			if (!require_v3_engine.isFileMatchedByTailwindSourceEntries(id, entries)) continue;
+			for (const candidate of candidates) filtered.add(candidate);
+		}
+		for (const candidate of inlineIncludedCandidates) filtered.add(candidate);
+		for (const candidate of inlineExcludedCandidates) filtered.delete(candidate);
+		return filtered;
+	}
+	function clear() {
+		candidatesById.clear();
+		scanCandidatesById.clear();
+		transformCandidatesById.clear();
+		candidateCount.clear();
+		inlineIncludedCandidates.clear();
+		inlineExcludedCandidates.clear();
+	}
+	function snapshot() {
+		return {
+			candidatesById: [...candidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			scanCandidatesById: [...scanCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			transformCandidatesById: [...transformCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			inlineExcludedCandidates: [...inlineExcludedCandidates],
+			inlineIncludedCandidates: [...inlineIncludedCandidates]
+		};
+	}
+	function restore(snapshot) {
+		clear();
+		inlineExcludedCandidates = new Set(snapshot.inlineExcludedCandidates);
+		inlineIncludedCandidates = new Set(snapshot.inlineIncludedCandidates);
+		const scanEntries = snapshot.scanCandidatesById ?? snapshot.candidatesById;
+		for (const [id, candidates] of scanEntries) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			scanCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.transformCandidatesById ?? []) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			transformCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.candidatesById) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			candidatesById.set(id, candidateSet);
+			addCandidateSet(candidateCount, candidateSet);
+		}
+	}
+	return {
+		sync,
+		merge,
+		syncFile,
+		syncCurrentFile,
+		scanRoot,
+		syncInline,
+		remove,
+		values,
+		valuesForEntries,
+		snapshot,
+		restore,
+		clear
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createSourceCandidateCollector", {
+	enumerable: true,
+	get: function() {
+		return createSourceCandidateCollector;
+	}
+});
+Object.defineProperty(exports, "isSourceCandidateRequest", {
+	enumerable: true,
+	get: function() {
+		return isSourceCandidateRequest;
+	}
+});

package/dist/source-candidates-CnD4vyic.mjs

@@ -0,0 +1,209 @@
+import { L as resolveSourceScanPath, N as isFileMatchedByTailwindSourceEntries, k as FULL_SOURCE_SCAN_EXTENSION_RE, z as toPosixPath } from "./v3-engine-DyIcbpZm.mjs";
+import path from "node:path";
+import { extractSourceCandidates, resolveProjectSourceFiles } from "tailwindcss-patch";
+import { readFile } from "node:fs/promises";
+//#region src/bundlers/vite/source-candidates.ts
+const CLEAN_URL_RE = /[?#].*$/;
+const sourceCandidateContentCache = /* @__PURE__ */ new Map();
+function cleanUrl(id) {
+	return resolveSourceScanPath(id.replace(CLEAN_URL_RE, ""));
+}
+function resolveOutDirIgnorePattern(root, outDir) {
+	if (!outDir) return;
+	const relative = path.relative(root, path.resolve(root, outDir));
+	if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return;
+	return `${toPosixPath(relative)}/**`;
+}
+function resolveSourceCandidateExtension(id) {
+	const normalized = cleanUrl(id);
+	return /\.([^.\\/]+)$/.exec(normalized)?.[1] ?? "html";
+}
+function createSourceCandidateContentCacheKey(extension, source) {
+	return `${extension}\0${source}`;
+}
+function isSourceCandidateRequest(id) {
+	return FULL_SOURCE_SCAN_EXTENSION_RE.test(cleanUrl(id));
+}
+function removeCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) {
+		const count = candidateCount.get(candidate);
+		if (count == null) continue;
+		if (count <= 1) {
+			candidateCount.delete(candidate);
+			continue;
+		}
+		candidateCount.set(candidate, count - 1);
+	}
+}
+function addCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) candidateCount.set(candidate, (candidateCount.get(candidate) ?? 0) + 1);
+}
+function createSourceCandidateCollector() {
+	const candidatesById = /* @__PURE__ */ new Map();
+	const scanCandidatesById = /* @__PURE__ */ new Map();
+	const transformCandidatesById = /* @__PURE__ */ new Map();
+	const candidateCount = /* @__PURE__ */ new Map();
+	let inlineIncludedCandidates = /* @__PURE__ */ new Set();
+	let inlineExcludedCandidates = /* @__PURE__ */ new Set();
+	async function sync(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		if (cachedCandidates) {
+			replaceScanLayer(normalizedId, new Set(cachedCandidates));
+			return;
+		}
+		const nextCandidates = new Set(await extractSourceCandidates(source, extension));
+		sourceCandidateContentCache.set(contentCacheKey, [...nextCandidates]);
+		replaceScanLayer(normalizedId, nextCandidates);
+	}
+	async function merge(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		const extractedCandidates = cachedCandidates ? new Set(cachedCandidates) : new Set(await extractSourceCandidates(source, extension));
+		if (!cachedCandidates) sourceCandidateContentCache.set(contentCacheKey, [...extractedCandidates]);
+		replaceTransformLayer(normalizedId, extractedCandidates);
+	}
+	async function syncFile(id) {
+		const normalizedId = cleanUrl(id);
+		await sync(normalizedId, await readFile(normalizedId, "utf8"));
+	}
+	async function syncCurrentFile(id) {
+		const normalizedId = cleanUrl(id);
+		transformCandidatesById.delete(normalizedId);
+		await syncFile(normalizedId);
+	}
+	async function scanRoot({ entries, root, outDir }) {
+		const resolvedRoot = path.resolve(root);
+		const outDirIgnore = resolveOutDirIgnorePattern(resolvedRoot, outDir);
+		const scanEntries = outDirIgnore ? [...entries?.length ? entries : [{
+			base: resolvedRoot,
+			pattern: "**/*",
+			negated: false
+		}], {
+			base: resolvedRoot,
+			pattern: outDirIgnore,
+			negated: true
+		}] : entries;
+		const files = await resolveProjectSourceFiles({
+			cwd: resolvedRoot,
+			...scanEntries === void 0 ? {} : { sources: scanEntries },
+			filter: isSourceCandidateRequest
+		});
+		await Promise.all(files.map((file) => syncFile(file)));
+	}
+	function replaceFinal(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (previousCandidates) {
+			removeCandidateSet(candidateCount, previousCandidates);
+			candidatesById.delete(normalizedId);
+		}
+		if (nextCandidates.size === 0) return;
+		candidatesById.set(normalizedId, nextCandidates);
+		addCandidateSet(candidateCount, nextCandidates);
+	}
+	function replaceScanLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) scanCandidatesById.delete(normalizedId);
+		else scanCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function replaceTransformLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) transformCandidatesById.delete(normalizedId);
+		else transformCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function recompute(id) {
+		const normalizedId = cleanUrl(id);
+		replaceFinal(normalizedId, new Set([...scanCandidatesById.get(normalizedId) ?? [], ...transformCandidatesById.get(normalizedId) ?? []]));
+	}
+	function syncInline(inlineCandidates) {
+		inlineIncludedCandidates = new Set(inlineCandidates?.included ?? []);
+		inlineExcludedCandidates = new Set(inlineCandidates?.excluded ?? []);
+	}
+	function remove(id) {
+		const normalizedId = cleanUrl(id);
+		scanCandidatesById.delete(normalizedId);
+		transformCandidatesById.delete(normalizedId);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (!previousCandidates) return;
+		removeCandidateSet(candidateCount, previousCandidates);
+		candidatesById.delete(normalizedId);
+	}
+	function values() {
+		const values = new Set([...candidateCount.keys(), ...inlineIncludedCandidates]);
+		for (const candidate of inlineExcludedCandidates) values.delete(candidate);
+		return values;
+	}
+	function valuesForEntries(entries) {
+		if (entries === void 0) return values();
+		const filtered = /* @__PURE__ */ new Set();
+		for (const [id, candidates] of candidatesById) {
+			if (!isFileMatchedByTailwindSourceEntries(id, entries)) continue;
+			for (const candidate of candidates) filtered.add(candidate);
+		}
+		for (const candidate of inlineIncludedCandidates) filtered.add(candidate);
+		for (const candidate of inlineExcludedCandidates) filtered.delete(candidate);
+		return filtered;
+	}
+	function clear() {
+		candidatesById.clear();
+		scanCandidatesById.clear();
+		transformCandidatesById.clear();
+		candidateCount.clear();
+		inlineIncludedCandidates.clear();
+		inlineExcludedCandidates.clear();
+	}
+	function snapshot() {
+		return {
+			candidatesById: [...candidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			scanCandidatesById: [...scanCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			transformCandidatesById: [...transformCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			inlineExcludedCandidates: [...inlineExcludedCandidates],
+			inlineIncludedCandidates: [...inlineIncludedCandidates]
+		};
+	}
+	function restore(snapshot) {
+		clear();
+		inlineExcludedCandidates = new Set(snapshot.inlineExcludedCandidates);
+		inlineIncludedCandidates = new Set(snapshot.inlineIncludedCandidates);
+		const scanEntries = snapshot.scanCandidatesById ?? snapshot.candidatesById;
+		for (const [id, candidates] of scanEntries) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			scanCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.transformCandidatesById ?? []) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			transformCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.candidatesById) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			candidatesById.set(id, candidateSet);
+			addCandidateSet(candidateCount, candidateSet);
+		}
+	}
+	return {
+		sync,
+		merge,
+		syncFile,
+		syncCurrentFile,
+		scanRoot,
+		syncInline,
+		remove,
+		values,
+		valuesForEntries,
+		snapshot,
+		restore,
+		clear
+	};
+}
+//#endregion
+export { isSourceCandidateRequest as n, createSourceCandidateCollector as t };

package/dist/tailwindcss/miniprogram.d.ts

@@ -1 +1 @@
-export declare function pruneMiniProgramGeneratedCss(css: string): string;
+export { pruneMiniProgramGeneratedCss } from '@weapp-tailwindcss/postcss';

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

@@ -1,56 +1,8 @@
-import type { PackageResolvingOptions } from 'local-pkg';
-import type { ILengthUnitsPatchOptions, NormalizedTailwindCssPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
+import type { ILengthUnitsPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
 type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
-type ResolvedTailwindUserOptions = TailwindUserOptions | NormalizedTailwindCssPatchOptions['tailwind'];
 type TailwindApplyOptions = NonNullable<TailwindCssPatchOptions['apply']>;
-type TailwindExtractOptions = NonNullable<TailwindCssPatchOptions['extract']>;
 type TailwindExtendLengthUnitsOption = TailwindApplyOptions['extendLengthUnits'];
-export interface LegacyTailwindcssPatcherOptions {
-    cache?: boolean | {
-        enabled?: boolean;
-        cwd?: string;
-        dir?: string;
-        file?: string;
-        strategy?: 'merge' | 'overwrite';
-    };
-    patch?: {
-        overwrite?: boolean;
-        basedir?: string;
-        cwd?: string;
-        filter?: (className: string) => boolean;
-        resolve?: PackageResolvingOptions;
-        tailwindcss?: TailwindUserOptions;
-        applyPatches?: {
-            exportContext?: boolean;
-            extendLengthUnits?: boolean | ILengthUnitsPatchOptions;
-        };
-        output?: {
-            filename?: string;
-            loose?: boolean;
-            removeUniversalSelector?: boolean;
-        };
-    };
-}
-export interface LegacyTailwindcssOutputOptions {
-    enabled?: boolean;
-    file?: string;
-    format?: TailwindExtractOptions['format'];
-    pretty?: TailwindExtractOptions['pretty'];
-    removeUniversalSelector?: boolean;
-}
-export interface LegacyTailwindcssFeatureOptions {
-    exposeContext?: TailwindApplyOptions['exposeContext'];
-    extendLengthUnits?: boolean | ILengthUnitsPatchOptions | TailwindExtendLengthUnitsOption;
-}
-export type CompatTailwindCssPatchOptions = TailwindCssPatchOptions & {
-    cwd?: string;
-    overwrite?: boolean;
-    features?: LegacyTailwindcssFeatureOptions;
-    output?: LegacyTailwindcssOutputOptions;
-    tailwind?: ResolvedTailwindUserOptions;
-};
-export declare function resolveTailwindcssOptions(options?: CompatTailwindCssPatchOptions | LegacyTailwindcssPatcherOptions): ResolvedTailwindUserOptions | undefined;
+export declare function resolveTailwindcssOptions(options?: TailwindCssPatchOptions): TailwindUserOptions | undefined;
 export declare function normalizeExtendLengthUnits(value: boolean | ILengthUnitsPatchOptions | undefined): TailwindExtendLengthUnitsOption | undefined;
-export declare function normalizeTailwindcssPatcherOptions(options?: CompatTailwindCssPatchOptions | LegacyTailwindcssPatcherOptions): TailwindCssPatchOptions | undefined;
-export declare function toModernTailwindcssPatchOptions(options?: CompatTailwindCssPatchOptions): TailwindCssPatchOptions | undefined;
+export declare function normalizeTailwindcssPatcherOptions(options?: TailwindCssPatchOptions): TailwindCssPatchOptions | undefined;
 export {};

package/dist/tailwindcss/patcher.d.ts

@@ -1,5 +1,4 @@
 import type { ILengthUnitsPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
-import type { LegacyTailwindcssPatcherOptions } from './patcher-options';
 import type { TailwindcssPatcherLike } from '../types';
 type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
 export interface CreateTailwindcssPatcherOptions {
@@ -7,7 +6,7 @@ export interface CreateTailwindcssPatcherOptions {
     cacheDir?: string;
     supportCustomLengthUnitsPatch?: boolean | ILengthUnitsPatchOptions;
     tailwindcss?: TailwindUserOptions;
-    tailwindcssPatcherOptions?: TailwindCssPatchOptions | LegacyTailwindcssPatcherOptions;
+    tailwindcssPatcherOptions?: TailwindCssPatchOptions;
 }
 export declare function createTailwindcssPatcher(options?: CreateTailwindcssPatcherOptions): TailwindcssPatcherLike;
 export {};

package/dist/tailwindcss/remove-unsupported-css.d.ts

@@ -1,2 +1 @@
-import type postcss from 'postcss';
-export declare function removeUnsupportedCascadeLayers(root: postcss.Root): void;
+export { removeUnsupportedCascadeLayers, } from '@weapp-tailwindcss/postcss';

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

@@ -1,11 +1,12 @@
 import type { TailwindcssPatcherLike } from '../../types';
 interface RuntimeClassSetCacheEntry {
-    value?: Set<string>;
-    promise?: Promise<Set<string>>;
-    signature?: string;
+    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 {};

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

@@ -0,0 +1,5 @@
+import type { TailwindcssPatcherLike } from '../types';
+export interface EnsureTailwindcssRuntimePatchOptions {
+    clearRequireCache?: boolean;
+}
+export declare function ensureTailwindcssRuntimePatch(twPatcher: TailwindcssPatcherLike, options?: EnsureTailwindcssRuntimePatchOptions): Promise<void>;

package/dist/tailwindcss/runtime.d.ts

@@ -2,27 +2,26 @@ import type { RefreshTailwindcssPatcherOptions, TailwindcssPatcherLike } from '.
 import { invalidateRuntimeClassSet } from './runtime/cache';
 export declare const refreshTailwindcssPatcherSymbol: unique symbol;
 export interface CollectRuntimeClassSetOptions {
-    force?: boolean;
-    skipRefresh?: boolean;
-    clearCache?: boolean;
+    force?: boolean | undefined;
+    skipRefresh?: boolean | undefined;
+    clearCache?: boolean | undefined;
 }
 export interface RefreshTailwindRuntimeStateOptions {
     force: boolean;
-    clearCache?: boolean;
+    clearCache?: boolean | undefined;
 }
-export declare function createTailwindPatchPromise(twPatcher: TailwindcssPatcherLike, onPatched?: () => Promise<void> | void): Promise<void>;
+export declare function createTailwindRuntimeReadyPromise(twPatcher: TailwindcssPatcherLike): Promise<void>;
 export interface TailwindRuntimeState {
     twPatcher: TailwindcssPatcherLike;
-    patchPromise: Promise<void>;
-    refreshTailwindcssPatcher?: (options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>;
-    onPatchCompleted?: () => Promise<void> | void;
+    readyPromise: Promise<void>;
+    refreshTailwindcssPatcher?: ((options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>) | undefined;
 }
 export declare function refreshTailwindRuntimeState(state: TailwindRuntimeState, forceOrOptions: boolean | RefreshTailwindRuntimeStateOptions): Promise<boolean>;
 export interface EnsureRuntimeClassSetOptions {
-    forceRefresh?: boolean;
-    forceCollect?: boolean;
-    clearCache?: boolean;
-    allowEmpty?: boolean;
+    forceRefresh?: boolean | undefined;
+    forceCollect?: boolean | undefined;
+    clearCache?: boolean | undefined;
+    allowEmpty?: boolean | undefined;
 }
 export declare function ensureRuntimeClassSet(state: TailwindRuntimeState, options?: EnsureRuntimeClassSetOptions): Promise<Set<string>>;
 declare function collectRuntimeClassSet(twPatcher: TailwindcssPatcherLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;

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

@@ -0,0 +1,35 @@
+import type { Root } from 'postcss';
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
+export interface TailwindSourceEntry {
+    base: string;
+    pattern: string;
+    negated: boolean;
+}
+export interface TailwindInlineSourceCandidates {
+    included: Set<string>;
+    excluded: Set<string>;
+}
+export declare const DEFAULT_SOURCE_SCAN_EXTENSIONS: string[];
+export declare const FULL_SOURCE_SCAN_EXTENSIONS: string[];
+export declare function createSourceScanPattern(extensions?: string[]): string;
+export declare const FULL_SOURCE_SCAN_PATTERN: string;
+export declare const FULL_SOURCE_SCAN_EXTENSION_RE: RegExp;
+export declare function toPosixPath(value: string): string;
+export declare function resolveSourceScanPath(value: string): string;
+export declare function isFileExcludedByTailwindSourceEntries(file: string, entries: TailwindSourceEntry[] | undefined): boolean;
+export declare function isFileMatchedByTailwindSourceEntries(file: string, entries: TailwindSourceEntry[] | undefined): boolean;
+export declare function createTailwindSourceEntryMatcher(entries: TailwindSourceEntry[] | undefined): ((file: string) => boolean) | undefined;
+export declare function resolveTailwindV4CssSourceBase(source: Pick<TailwindV4CssSource, 'base' | 'file'>, fallbackBase: string): string;
+export declare function parseConfigParam(params: string): string | undefined;
+export declare function expandInlineSourceCandidatePattern(pattern: string): string[];
+export declare function collectCssInlineSourceCandidates(root: Root): TailwindInlineSourceCandidates;
+export declare function normalizeLegacyContentEntries(content: unknown, base: string): TailwindSourceEntry[];
+export declare function resolveTailwindSourceEntry(sourcePath: string, base: string, negated: boolean, defaultPattern?: string): Promise<TailwindSourceEntry>;
+export declare function parseSourceFileParam(params: string): {
+    negated: boolean;
+    sourcePath: string;
+} | undefined;
+export declare function resolveCssSourceEntries(root: Root, base: string, defaultPattern?: string): Promise<TailwindSourceEntry[]>;
+export declare function expandTailwindSourceEntries(entries: TailwindSourceEntry[], options?: {
+    ignore?: string[];
+}): Promise<string[]>;

package/dist/tailwindcss/targets.d.ts

@@ -1,6 +1,2 @@
 import type { TailwindcssPatcherLike } from '../types';
-import { __resetPatchTargetRecordWarningsForTests, saveCliPatchTargetRecord } from './targets/record-io';
-import { createPatchTargetRecorder } from './targets/recorder';
-export type { PatchTargetRecorder, PatchTargetRecorderOptions, SavePatchTargetRecordOptions } from './targets/types';
-export declare function logTailwindcssTarget(kind: 'cli' | 'runtime', patcher: TailwindcssPatcherLike | undefined, baseDir?: string): void;
-export { __resetPatchTargetRecordWarningsForTests, createPatchTargetRecorder, saveCliPatchTargetRecord, };
+export declare function logTailwindcssTarget(patcher: TailwindcssPatcherLike | undefined, baseDir?: string): void;