weapp-tailwindcss 5.0.12 → 5.1.0

package/dist/bundlers/vite/generate-bundle/memory-debug.d.ts

@@ -0,0 +1,80 @@
+import type { GenerateBundleContext } from './types';
+export declare function resolveViteMemoryDebugStats(context: {
+    activeProcessCacheKeys: Set<string>;
+    activeProcessHashKeys: Set<string | number>;
+    cache: GenerateBundleContext['opts']['cache'];
+    generatorRuntimeSize: number;
+    getViteCssCacheStats?: (() => Record<string, unknown>) | undefined;
+    hasOmittedKnownFiles: boolean;
+    lastCssResultByFile: Map<string, string>;
+    phase: string;
+    processCachePruned: boolean;
+    processCachePruneSkipReason?: string | undefined;
+    runtimeSize: number;
+    sourceCandidatesSize: number;
+    transformRuntimeSize: number;
+    useIncrementalMode: boolean;
+}): {
+    phase: string;
+    mode: string;
+    bundle: {
+        hasOmittedKnownFiles: boolean;
+    };
+    process: {
+        rssMb: number;
+        heapTotalMb: number;
+        heapUsedMb: number;
+        externalMb: number;
+        arrayBuffersMb: number;
+    };
+    runtime: {
+        sourceCandidates: number;
+        runtime: number;
+        transformRuntime: number;
+        generatorRuntime: number;
+    };
+    processCache: {
+        pruneSkipReason?: string;
+        instance: number;
+        hashMap: number;
+        activeCacheKeys: number;
+        activeHashKeys: number;
+        staleCacheKeys: number;
+        staleHashKeys: number;
+        pruned: boolean;
+        pruneSkipped: boolean;
+    };
+    viteCss: {
+        lastCssResultByFile: {
+            bytes: number;
+            mb: number;
+            size: number;
+        };
+    };
+    tailwind: {
+        v4: {
+            max: number;
+            entryCandidatesMax: number;
+            entryCssBytesMax: number;
+            size: number;
+            taskMax: number;
+            taskSize: number;
+            entries: {
+                candidates: number;
+                classSet: number;
+                cssBytes: number;
+                rawCssBytes: number;
+                keyHash: string;
+                keyBytes: number;
+            }[];
+            keys: {
+                keyHash: string;
+                keyBytes: number;
+            }[];
+            taskKeys: {
+                keyHash: string;
+                keyBytes: number;
+            }[];
+        };
+    };
+} | undefined;

package/dist/bundlers/vite/generate-bundle/remembered-css-replay.d.ts

@@ -0,0 +1,53 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleMetrics } from './metrics';
+import type { GenerateBundleContext, RememberedCssSource } from './types';
+interface ProcessRememberedCssReplayOptions {
+    addWatchFile: (id: string) => void;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    bundleFiles: string[];
+    cache: GenerateBundleContext['opts']['cache'];
+    createScopedGeneratorRuntime: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }, runtime: Set<string>, rawSource?: string | undefined, sourceFile?: string | undefined) => Promise<Set<string>>;
+    createScopedSourceCandidateGetter: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => GenerateBundleContext['getSourceCandidatesForEntries'];
+    createScopedSourceCandidateSourceGetter: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => GenerateBundleContext['getSourceCandidateSourcesForEntries'];
+    cssTaskFactories: Array<() => Promise<void>>;
+    debug: GenerateBundleContext['debug'];
+    defaultStyleOutputExtension: string;
+    emitOrReplayCssAsset: (fileName: string, source: string) => OutputAsset;
+    generatorRuntime: Set<string>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
+    getRememberedCssSignature?: ((file: string) => string | undefined) | undefined;
+    getRememberedCssSources?: (() => Iterable<[string, RememberedCssSource]>) | undefined;
+    isNativeAppStyleTarget: boolean;
+    isWebGeneratorTarget: boolean;
+    lastCssResultByFile: Map<string, string>;
+    lastCssSourceHashByFile: Map<string, string>;
+    markCssAssetProcessed: GenerateBundleContext['markCssAssetProcessed'];
+    metrics: BundleMetrics;
+    normalizeViteCssCacheKey: (file: string) => string;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    opts: GenerateBundleContext['opts'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+    recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
+    refreshRememberedCssSource?: GenerateBundleContext['refreshRememberedCssSource'];
+    rootDir: string;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    setRememberedCssSignature?: ((file: string, cssRuntimeSignature: string) => void) | undefined;
+    shouldInjectCssIntoMainFromOutput: (outputFile: string, sourceFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => boolean;
+    shouldPreserveAppCssExtension: boolean;
+    sourceRoot: string | undefined;
+    styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    timeTask: (name: string, task: () => Promise<void>) => Promise<void>;
+    useIncrementalMode: boolean;
+    activeViteCssCacheFiles: Set<string>;
+}
+export declare function processRememberedCssReplay(options: ProcessRememberedCssReplayOptions): Promise<void>;
+export {};

package/dist/bundlers/vite/generate-bundle/remembered-css.d.ts

@@ -5,7 +5,7 @@ export declare function createRememberedCssRuntimeSignature(cssRuntimeSignature:
 export declare function resolveRememberedCssSourceForTest(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource | undefined;
 export declare function findRememberedCssSources(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource[];
 export declare function mergeRememberedCssSources(sources: RememberedCssSource[], outputFile: string): RememberedCssSource | undefined;
-export declare function collectRememberedCssReplayGroups(sources: Iterable<[string, RememberedCssSource]> | undefined, opts: Pick<InternalUserDefinedOptions, 'cssMatcher'>, rootDir: string, isWebGeneratorTarget: boolean, preserveCssExtension: boolean, sourceRoot?: string | undefined): Map<string, {
+export declare function collectRememberedCssReplayGroups(sources: Iterable<[string, RememberedCssSource]> | undefined, opts: Pick<InternalUserDefinedOptions, 'cssMatcher'>, rootDir: string, isWebGeneratorTarget: boolean, preserveCssExtension: boolean, sourceRoot?: string | undefined, styleOutputExtension?: string | undefined, styleOutputFiles?: Iterable<string> | undefined): Map<string, {
     key: string;
     remembered: RememberedCssSource;
 }[]>;

package/dist/bundlers/vite/generate-bundle/runtime-linked-css.d.ts

@@ -0,0 +1,4 @@
+import type { BundleSnapshot } from '../bundle-state';
+export declare function collectCssExtensionByStem(files: string[], cssMatcher: (file: string) => boolean): Map<string, string>;
+export declare function collectRuntimeLinkedCssFiles(snapshot: BundleSnapshot, extensionByStem: Map<string, string>, fallbackExtension: string): Set<string>;
+export declare function collectJsImportedCssFiles(snapshot: BundleSnapshot): Set<string>;

package/dist/bundlers/vite/generate-bundle/scoped-generator.d.ts

@@ -0,0 +1,21 @@
+import type { SourceCandidateFilterOptions } from '../source-candidates';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+export declare function createScopedGeneratorCandidateSignature(rawSource: string, sourceFile: string, fallbackSignature: string, getSourceCandidatesForEntries: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined, options?: {
+    includeFallbackSignature?: boolean | undefined;
+    majorVersion?: number | undefined;
+}): Promise<string>;
+export declare function createScopedGeneratorRuntime(options: {
+    cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    };
+    fallbackRuntime: Set<string>;
+    getSourceCandidatesForEntries: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined;
+    majorVersion: number | undefined;
+    outputFile: string;
+    rawSource?: string | undefined;
+    shouldExcludeSubpackageSourceCandidates: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => boolean;
+    sourceFile?: string | undefined;
+    scopedSourceCandidateGetter: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined;
+}): Promise<Set<string>>;

package/dist/bundlers/vite/generate-bundle/sfc-style-source.d.ts

@@ -3,7 +3,10 @@ import type { BundleSnapshot } from '../bundle-state';
 import type { RememberedCssSource } from './types';
 export declare function extractSfcStyleSources(source: string): string[];
 export declare function hasSfcStyleSources(source: string): boolean;
-export declare function hasTailwindGenerationSource(source: string): boolean;
-export declare function resolveSfcStyleSourceFromOutputFile(outputFile: string, snapshot: BundleSnapshot, outputRoot: string, sourceRoot: string | undefined, getSfcSource: ((file: string) => string | undefined) | undefined, debug: (format: string, ...args: unknown[]) => void): Promise<RememberedCssSource | undefined>;
+export declare function hasTailwindGenerationSource(source: string, options?: {
+    allowRootDirectives?: boolean | undefined;
+}): boolean;
+export declare function resolveSfcStyleSourceFromOutputFile(outputFile: string, snapshot: BundleSnapshot, outputRoot: string, sourceRoot: string | undefined, cssMatcher: ((file: string) => boolean) | undefined, getSfcSource: ((file: string) => string | undefined) | undefined, debug: (format: string, ...args: unknown[]) => void): Promise<RememberedCssSource | undefined>;
 export declare function normalizeSfcSourceFileForCompare(file: string): string;
 export declare function collectChunkModuleIds(output: OutputChunk): string[];
+export declare function resolveSourceStyleSourceFromOutputFile(outputFile: string, snapshot: BundleSnapshot, outputRoot: string, sourceRoot: string | undefined, getSourceStyleSource: ((file: string) => string | undefined) | undefined, getSourceStyleSources: (() => Iterable<[string, string]>) | undefined, configuredSourceEntries: Iterable<[string, string]> | undefined, debug: (format: string, ...args: unknown[]) => void): RememberedCssSource | undefined;

package/dist/bundlers/vite/generate-bundle/source-candidate-scope.d.ts

@@ -0,0 +1,30 @@
+import type { BundleSnapshot } from '../bundle-state';
+import type { SourceCandidateFilterOptions } from '../source-candidates';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+interface CreateSubpackageSourceCandidateScopeOptions {
+    cssSourceFiles?: Iterable<string> | undefined;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined;
+    getSourceCandidateSourcesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>) | undefined;
+    projectRoot?: string | undefined;
+    rootDir: string;
+    snapshot: BundleSnapshot;
+    sourceRoot?: string | undefined;
+    subpackageRoots?: Set<string> | undefined;
+    tailwindcssBasedir?: string | undefined;
+    useIncrementalMode: boolean;
+}
+export declare function createSubpackageSourceCandidateScope(options: CreateSubpackageSourceCandidateScopeOptions): {
+    createScopedSourceCandidateGetter: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => ((entries: TailwindSourceEntry[] | undefined, filterOptions?: SourceCandidateFilterOptions) => Set<string>) | undefined;
+    createScopedSourceCandidateSourceGetter: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => ((entries: TailwindSourceEntry[] | undefined, filterOptions?: SourceCandidateFilterOptions) => Map<string, Set<string>>) | undefined;
+    shouldExcludeSubpackageSourceCandidates: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => boolean;
+    shouldInjectCssIntoMainFromOutput: (outputFile: string, _sourceFile: string, outputCssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => boolean;
+};
+export {};

package/dist/bundlers/vite/generate-bundle/timing.d.ts

@@ -0,0 +1 @@
+export declare function createBundleTaskTimer(recordTimingDetail: (name: string, startedAt: number) => void): (name: string, task: () => Promise<void>) => Promise<void>;

package/dist/bundlers/vite/generate-bundle/types.d.ts

@@ -8,7 +8,7 @@ import type { InternalUserDefinedOptions } from '../../../types';
 export interface GenerateBundleContext {
     opts: InternalUserDefinedOptions;
     runtimeState: {
-        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
         readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
@@ -38,6 +38,8 @@ export interface GenerateBundleContext {
         outputFile?: string | undefined;
     } | undefined;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidateSource?: (file: string) => string | undefined;
+    getSourceCandidateSources?: () => Iterable<[string, string]>;
     getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined;
     getSourceCandidateSourcesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;

package/dist/bundlers/vite/generate-bundle/uni-app-x-postprocess.d.ts

@@ -0,0 +1,20 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { CssHandlerOptionsCache } from './css-handler-options';
+import type { GenerateBundleContext } from './types';
+interface HandleUniAppXPostCssOptions {
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    debug: GenerateBundleContext['debug'];
+    generatorRuntime: Set<string>;
+    getCssHandlerOptions: CssHandlerOptionsCache['getCssHandlerOptions'];
+    getSourceCandidateSourcesForEntries: GenerateBundleContext['getSourceCandidateSourcesForEntries'];
+    getSourceCandidatesForEntries: GenerateBundleContext['getSourceCandidatesForEntries'];
+    getViteProcessedCssAssetResults: GenerateBundleContext['getViteProcessedCssAssetResults'];
+    isHarmonyAppStyleTarget: boolean;
+    isNativeAppStyleTarget: boolean;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    opts: GenerateBundleContext['opts'];
+    runtimeState: GenerateBundleContext['runtimeState'];
+    styleHandler: GenerateBundleContext['opts']['styleHandler'];
+}
+export declare function handleUniAppXPostCssTasks(options: HandleUniAppXPostCssOptions): Promise<string[]>;
+export {};

package/dist/bundlers/vite/generate-bundle/vite-css-cache.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveViteCssTaskConcurrency(_useIncrementalMode: boolean, _majorVersion?: number | undefined): number;
+export declare function normalizeViteCssCacheKey(file: string): string;
+export declare function rememberLastCssResult(resultByFile: Map<string, string>, sourceHashByFile: Map<string, string>, file: string, css: string, sourceHash: string): void;
+export declare function getLastCssResult(resultByFile: Map<string, string>, ...files: Array<string | undefined>): string | undefined;
+export declare function getLastCssSourceHash(sourceHashByFile: Map<string, string>, file: string): string | undefined;
+export declare function pruneLastCssResults(resultByFile: Map<string, string>, sourceHashByFile: Map<string, string>, activeFiles: Set<string>): void;

package/dist/bundlers/vite/generate-bundle.d.ts

@@ -1,6 +1,9 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { GenerateBundleContext, GenerateBundleThis } from './generate-bundle/types';
-export { resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile } from './generate-bundle/css-output';
+export { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names';
+export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output';
 export { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css';
 export type { GenerateBundleContext, GenerateBundleThis, RememberedCssSource } from './generate-bundle/types';
+export declare function shouldKeepRootMiniProgramStyleAsImportShell(appType: unknown): appType is "uni-app-x" | "taro" | "uni-app-vite";
+export declare function shouldMoveRootMiniProgramStyleToImportShellOrigin(appType: unknown): appType is "taro";
 export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, _opt: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;

package/dist/bundlers/vite/hot-css-modules.d.ts

@@ -0,0 +1,5 @@
+import type { HmrContext, ModuleNode } from 'vite';
+export declare function resolveHotTailwindCssModules(ctx: HmrContext, tailwindRootCssModuleIds: Set<string>): ModuleNode[];
+export declare function hasSelfAcceptingNonStyleHotModule(modules: ModuleNode[]): boolean;
+export declare function sendSupplementalCssHotUpdates(ctx: HmrContext, cssModules: ModuleNode[]): void;
+export declare function sendFullReloadForUnresolvedHotUpdate(ctx: HmrContext): void;

package/dist/bundlers/vite/incremental-runtime-class-set/escaped-candidates.d.ts

@@ -1,2 +1,3 @@
 export declare function createEscapeFragments(escapeMap: Record<string, string>): string[];
 export declare function collectEscapedRuntimeCandidates(source: string, escapeMap: Record<string, string>, escapeFragments: string[]): Set<string>;
+export declare function collectStrictEscapedRuntimeCandidates(source: string, escapeMap: Record<string, string>, escapeFragments: string[]): Set<string>;

package/dist/bundlers/vite/incremental-runtime-class-set.d.ts

@@ -1,7 +1,7 @@
 import type { BundleSnapshot } from './bundle-state';
-import type { TailwindcssPatcherLike } from '../../types';
+import type { TailwindcssRuntimeLike } from '../../types';
 import type { IArbitraryValues } from '../../types/shared';
-import { extractRawCandidatesWithPositions, extractValidCandidates } from 'tailwindcss-patch';
+import { extractRawCandidatesWithPositions, extractValidCandidates } from '@tailwindcss-mangle/engine';
 type ExtractValidCandidatesOptions = Parameters<typeof extractValidCandidates>[0];
 type MemoryExtractValidCandidatesOptions = ExtractValidCandidatesOptions & {
     content?: string;
@@ -13,7 +13,7 @@ type ExtractRawCandidatesFn = (content: string, extension?: string, options?: {
     bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
 }) => Promise<ExtractRawCandidateResult>;
 export interface BundleRuntimeClassSetManager {
-    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
+    sync: (runtime: TailwindcssRuntimeLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
     reset: () => Promise<void>;
 }
 export interface BundleRuntimeClassSetSyncOptions {

package/dist/bundlers/vite/map-cache.d.ts

@@ -0,0 +1,2 @@
+export declare function touchMapEntry<Key, Value>(map: Map<Key, Value>, key: Key, value: Value): void;
+export declare function pruneMapToMaxSize<Key, Value>(map: Map<Key, Value>, maxSize: number, onDelete?: (key: Key) => void): void;

package/dist/bundlers/vite/processed-css-assets.d.ts

@@ -27,6 +27,7 @@ interface CollectViteProcessedCssAssetOptions {
     recordCssAssetResult?: CssAssetResultRecorder | undefined;
     recordViteProcessedCssAssetResult?: CssAssetResultRecorder | undefined;
     resolveViteProcessedCssOutputFile?: ((file: string) => string | undefined) | undefined;
+    subpackageRoots?: Set<string> | undefined;
     debug?: ((format: string, ...args: unknown[]) => void) | undefined;
 }
 interface InjectViteProcessedCssAssetOptions {
@@ -34,9 +35,24 @@ interface InjectViteProcessedCssAssetOptions {
     getViteProcessedCssAssetResults?: CssAssetResultsGetter | undefined;
     markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
     recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    shouldRemoveInjectedSourceAsset?: ((file: string, record: {
+        file: string;
+        css: string;
+        injectIntoMain?: boolean | undefined;
+        outputFile?: string | undefined;
+    }) => boolean) | undefined;
     debug?: ((format: string, ...args: unknown[]) => void) | undefined;
     onUpdate?: ((file: string, original: string, generated: string) => void) | undefined;
 }
+export declare function removeCssCoveredByRootStyleAssets(bundle: OutputBundle, options: {
+    cssMatcher: (file: string) => boolean;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+    isViteProcessedCssAsset?: CssAssetMarkerMatcher | undefined;
+    onUpdate?: ((file: string, original: string, generated: string) => void) | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    subpackageRoots?: Set<string> | undefined;
+}): number;
+export declare function isCssImportOnlyBundleAsset(bundle: OutputBundle, file: string, css: string): boolean;
 export declare function collectViteProcessedCssAssetResults(bundle: OutputBundle, options: CollectViteProcessedCssAssetOptions): number;
 export declare function injectViteProcessedCssIntoMainCssAssets(bundle: OutputBundle, options: InjectViteProcessedCssAssetOptions): number;
 export {};

package/dist/bundlers/vite/resolve-app-type.d.ts

@@ -1,2 +1 @@
-import type { AppType } from '../../types';
-export declare function resolveImplicitAppTypeFromViteRoot(root: string): AppType | undefined;
+export { resolveImplicitAppTypeFromViteRoot } from '../../framework';

package/dist/bundlers/vite/rewrite-css-imports.d.ts

@@ -18,6 +18,7 @@ interface RewriteCssImportsOptions {
     onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;
     onCssSourceTransform?: ((id: string, code: string) => Promise<void> | void) | undefined;
     shouldGenerateCss?: ((id: string, code: string) => boolean) | undefined;
+    shouldDeferGeneration?: ((id: string, code: string) => boolean) | undefined;
 }
 export declare function createRewriteCssImportsPlugins(options: RewriteCssImportsOptions): Plugin[];
 export declare function hasVitePipelineTailwindGenerationDirective(code: string): boolean;

package/dist/bundlers/vite/runtime-class-set.d.ts

@@ -2,8 +2,8 @@ import type { BundleSnapshot } from './bundle-state';
 import type { InternalUserDefinedOptions } from '../../types';
 interface CreateViteRuntimeClassSetOptions {
     opts: InternalUserDefinedOptions;
-    initialTwPatcher: InternalUserDefinedOptions['twPatcher'];
-    refreshTailwindcssPatcher: InternalUserDefinedOptions['refreshTailwindcssPatcher'];
+    initialTailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
+    refreshTailwindcssRuntime: InternalUserDefinedOptions['refreshTailwindcssRuntime'];
     uniAppXEnabled: boolean;
     customAttributesEntities: unknown;
     disabledDefaultTemplateHandler: boolean;
@@ -11,13 +11,13 @@ interface CreateViteRuntimeClassSetOptions {
 }
 export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClassSetOptions): {
     runtimeState: {
-        twPatcher: import("@/types").TailwindcssPatcherLike;
+        tailwindRuntime: import("@/types").TailwindcssRuntimeLike;
         readyPromise: Promise<void>;
-        refreshTailwindcssPatcher: (options?: import("@/types").RefreshTailwindcssPatcherOptions) => Promise<import("@/types").TailwindcssPatcherLike>;
+        refreshTailwindcssRuntime: (options?: import("@/types").RefreshTailwindcssRuntimeOptions) => Promise<import("@/types").TailwindcssRuntimeLike>;
     };
     refreshRuntimeState: (force: boolean) => Promise<void>;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, _options?: {
         allowBaselineOnlyInitialSync?: boolean | undefined;
         baseClassSet?: Set<string> | undefined;
         transformOnly?: boolean | undefined;

package/dist/bundlers/vite/source-candidate-scan-signature.d.ts

@@ -0,0 +1,13 @@
+import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
+export interface SourceCandidateScanRoot {
+    root: string;
+    entries?: TailwindSourceEntry[] | undefined;
+    explicit?: boolean | undefined;
+}
+export interface SourceCandidateScanSignatureInput {
+    inlineCandidates?: TailwindInlineSourceCandidates | undefined;
+    outDir?: string | undefined;
+    roots: SourceCandidateScanRoot[];
+    scanAllSources?: boolean | undefined;
+}
+export declare function createSourceCandidateScanSignature(input: SourceCandidateScanSignatureInput): string;

package/dist/bundlers/vite/source-candidates/script.d.ts

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

package/dist/bundlers/vite/source-candidates.d.ts

@@ -1,7 +1,7 @@
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { IArbitraryValues } from '../../types/shared';
-export { createTailwindV3DefaultExtractor } from './source-candidates/tailwind-v3-default-extractor';
-export interface SourceCandidateCollector {
+export interface SourceCandidateStore {
+    syncSource: (id: string, source: string) => Promise<void>;
     sync: (id: string, source: string) => Promise<void>;
     syncCss: (id: string, source: string) => Promise<void>;
     merge: (id: string, source: string) => Promise<void>;
@@ -11,19 +11,27 @@ export interface SourceCandidateCollector {
     syncInline: (inlineCandidates: TailwindInlineSourceCandidates | undefined) => void;
     remove: (id: string) => void;
     source: (id: string) => string | undefined;
+    sources: () => IterableIterator<[string, string]>;
     values: () => Set<string>;
     valuesForEntries: (entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>;
     sourcesForEntries: (entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>;
     snapshot: () => SourceCandidateCollectorSnapshot;
     restore: (snapshot: SourceCandidateCollectorSnapshot) => void;
+    clearScan: () => void;
+    resetScan: () => void;
     clear: () => void;
 }
+export interface SourceCandidateCollector extends SourceCandidateStore {
+}
 export interface SourceCandidateCollectorSnapshot {
     candidatesById: Array<[string, string[]]>;
     cssCandidatesById?: Array<[string, string[]]> | undefined;
+    cssSourceById?: Array<[string, string]> | undefined;
     scanCandidatesById?: Array<[string, string[]]> | undefined;
+    scanSourceById?: Array<[string, string]> | undefined;
     sourceById?: Array<[string, string]> | undefined;
     transformCandidatesById?: Array<[string, string[]]> | undefined;
+    transformSourceById?: Array<[string, string]> | undefined;
     inlineExcludedCandidates: string[];
     inlineIncludedCandidates: string[];
 }
@@ -41,6 +49,7 @@ export interface SourceCandidateCollectorOptions {
     extractor?: ((source: string, extension: string) => Promise<Iterable<string>> | Iterable<string>) | undefined;
 }
 export declare function isSourceCandidateRequest(id: string): boolean;
+export declare function createSourceCandidateStore(options?: SourceCandidateCollectorOptions): SourceCandidateStore;
 export declare function createSourceCandidateCollector(options?: SourceCandidateCollectorOptions): SourceCandidateCollector;
 export declare function getSourceCandidateContentCacheStatsForTest(): {
     max: number;
@@ -48,3 +57,4 @@ export declare function getSourceCandidateContentCacheStatsForTest(): {
     keys: string[];
 };
 export declare function clearSourceCandidateContentCacheForTest(): void;
+export {};

package/dist/bundlers/vite/source-scan/css-entries.d.ts

@@ -1,6 +1,6 @@
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../../tailwindcss/source-scan';
-import type { TailwindcssPatcherLike, UserDefinedOptions } from '../../../types';
+import type { UserDefinedOptions } from '../../../types';
 export interface ResolvedTailwindV4CssEntries {
     entries: TailwindSourceEntry[];
     explicit: boolean;
@@ -11,10 +11,7 @@ export declare function mergeTailwindInlineSourceCandidates(allInlineCandidates:
 export declare function resolveTailwindV4EntriesFromCss(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
 export declare function resolveViteTailwindV4CssDependencies(css: string, base: string): Promise<string[]>;
 export declare function collectExistingCssEntries(options: UserDefinedOptions): string[];
-export declare function resolveTailwindV3CssEntryScan(options: UserDefinedOptions, patcher: TailwindcssPatcherLike): Promise<{
-    entries: TailwindSourceEntry[];
-    dependencies: Set<string>;
-}>;
 export declare function resolveTailwindV4EntriesFromCssCached(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
+export declare function resolveTailwindConfigEntriesFromCssCached(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
 export declare function discoverTailwindV4CssEntries(root: string, outDir: string | undefined): Promise<string[]>;
 export declare function collectConfiguredCssSources(options: UserDefinedOptions): TailwindV4CssSource[];

package/dist/bundlers/vite/source-scan.d.ts

@@ -1,6 +1,6 @@
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
-import type { TailwindcssPatcherLike, UserDefinedOptions } from '../../types';
-export { discoverTailwindV4CssEntries, resolveTailwindV4EntriesFromCss, resolveTailwindV4EntriesFromCssCached, resolveViteTailwindV4CssDependencies, } from './source-scan/css-entries';
+import type { TailwindcssRuntimeLike, UserDefinedOptions } from '../../types';
+export { discoverTailwindV4CssEntries, resolveTailwindConfigEntriesFromCssCached, resolveTailwindV4EntriesFromCss, resolveTailwindV4EntriesFromCssCached, resolveViteTailwindV4CssDependencies, } from './source-scan/css-entries';
 export type { ResolvedTailwindV4CssEntries } from './source-scan/css-entries';
 export interface ResolvedViteSourceScan {
     dependencies?: string[] | undefined;
@@ -12,5 +12,5 @@ interface ResolveViteSourceScanOptions {
     root?: string | undefined;
     outDir?: string | undefined;
 }
-export declare function resolveViteSourceScanEntries(options: UserDefinedOptions, patcher: TailwindcssPatcherLike, scanOptions?: ResolveViteSourceScanOptions): Promise<ResolvedViteSourceScan | undefined>;
+export declare function resolveViteSourceScanEntries(options: UserDefinedOptions, runtime: TailwindcssRuntimeLike, scanOptions?: ResolveViteSourceScanOptions): Promise<ResolvedViteSourceScan | undefined>;
 export declare function createViteSourceScanMatcher(entries: TailwindSourceEntry[] | undefined): ((file: string) => boolean) | undefined;

package/dist/bundlers/vite/uni-app-x-css-options.d.ts

@@ -1,2 +1,2 @@
 import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../types';
-export declare function resolveUniAppXNativeCssHandlerOptions(opts: Pick<InternalUserDefinedOptions, 'appType' | 'uniAppX'>): Partial<IStyleHandlerOptions>;
+export declare function resolveUniAppXNativeCssHandlerOptions(opts: Pick<InternalUserDefinedOptions, 'appType' | 'generator' | 'platform' | 'cssOptions' | 'uniAppX'>): Partial<IStyleHandlerOptions>;

package/dist/bundlers/vite/utils.d.ts

@@ -4,6 +4,7 @@ export declare function slash(p: string): string;
 export declare const isWindows: boolean;
 export declare const cssLangRE: RegExp;
 export declare function isCSSRequest(request: string): boolean;
+export declare function isHTMLRequest(request: string): boolean;
 export declare function normalizePath(id: string): string;
 export { cleanUrl };
 export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;

package/dist/bundlers/vite/weapp-vite-config.d.ts

@@ -1 +1,3 @@
-export declare function resolveWeappViteSourceRoot(config: unknown): string | undefined;
+import type { OutputBundle } from 'rollup';
+export declare function resolveWeappViteSourceRoot(config: unknown, _appType?: unknown): string | undefined;
+export declare function resolveSourceRootFromBundleGraph(config: unknown, bundle: OutputBundle): string | undefined;

package/dist/bundlers/webpack/BaseUnifiedPlugin/shared.d.ts

@@ -10,6 +10,21 @@ interface ChunkLike {
     name?: string;
     hash?: string | null;
     files?: Iterable<string> | Array<string>;
+    hasRuntime?: () => boolean;
+}
+interface ModuleLike {
+    context?: string;
+    dependencies?: Array<unknown> | Iterable<unknown>;
+    modules?: ModuleLike[] | Iterable<ModuleLike>;
+    request?: string;
+    resource?: string;
+    rootModule?: ModuleLike;
+    userRequest?: string;
+}
+interface ChunkGraphLike {
+    getChunkModulesIterable?: (chunk: ChunkLike) => Iterable<ModuleLike> | undefined;
+    getIssuer?: (module: ModuleLike) => ModuleLike | null | undefined;
+    getModule?: (dependency: unknown) => ModuleLike | null | undefined;
 }
 interface WebpackWatchChangeLike {
     modifiedFiles?: Set<string>;
@@ -19,6 +34,15 @@ interface RuntimeWatchDependenciesLike {
     files?: Iterable<string>;
     contexts?: Iterable<string>;
 }
+export declare function inferWebpackMainCssFiles(chunks: Iterable<ChunkLike>, cssMatcher: (file: string) => boolean, options?: {
+    mainSourceFiles?: ReadonlySet<string> | undefined;
+    resourcesByAsset?: ReadonlyMap<string, ReadonlySet<string>> | undefined;
+}): Set<string>;
+export declare function resolveSingleActiveWebpackCssResource(assetResources: ReadonlySet<string> | undefined, activeWebpackAssetResourceFiles: ReadonlySet<string>): string | undefined;
+export declare function createWebpackCssAssetResourceMap(chunks: Iterable<ChunkLike>, chunkGraph: ChunkGraphLike | undefined, cssMatcher: (file: string) => boolean, normalizeResource: (resource: string, issuer?: {
+    context?: string;
+    resource?: string;
+}) => string | undefined): Map<string, Set<string>>;
 export declare function createAssetHashByChunkMap(chunks: Iterable<ChunkLike>): Map<string, string>;
 export declare function createRuntimeAwareCssHash(assetHash: string | undefined, sourceHash: string, runtimeSetHash: string): string;
 export declare function hasWatchChanges(compiler: WebpackWatchChangeLike): boolean;