weapp-tailwindcss 5.1.0 → 5.1.1

package/dist/bundlers/shared/generator-css/class-selectors.d.ts

@@ -0,0 +1,2 @@
+export declare function collectRawSourceClassSelectors(rawSource: string): Set<string>;
+export declare function collectGeneratedRawSourceCandidates(candidates: Iterable<string>, rawSource: string, escapeMap: Record<string, string> | undefined): Set<string>;

package/dist/bundlers/shared/generator-css/generation-helpers.d.ts

@@ -51,23 +51,15 @@ export declare function shouldUseGeneratorForCurrentCss(_majorVersion: number |
     hasGeneratedMarkers: boolean;
     hasSourceDirectives: boolean;
     rawSource: string;
-}): boolean;
+    runtimeCandidateCount?: number | undefined;
+    target?: string | undefined;
+    configuredCssSourceCount?: number | undefined;
+}): boolean | undefined;
 export declare function hasGeneratorSourceDirectives(source: string, importFallback: boolean): boolean;
 export declare function createRuntimeWithCurrentCssCandidates(runtime: Set<string>, currentCssCandidates: string[], isolateCurrentCssCandidates: boolean): Set<string>;
 export declare function mergeGeneratorResults(generatedResults: GeneratorResult[]): (import("@/generator").TailwindV4GenerateResult & {
-    target: WeappTailwindcssGeneratorTarget;
-    rawCss: string;
-}) | {
-    css: string;
+    target: import("@/generator").WeappTailwindcssGeneratorTarget;
     rawCss: string;
-    incrementalCss: string | undefined;
-    incrementalRawCss: string | undefined;
-    classSet: Set<string>;
-    dependencies: string[];
-    sources: import("@tailwindcss-mangle/engine").TailwindV4SourcePattern[];
-    target: any;
-    root: import("@tailwindcss-mangle/engine").TailwindV4CompiledSourceRoot;
-    rawCandidates: Set<string>;
-} | undefined;
+}) | undefined;
 type GeneratorResult = Awaited<ReturnType<ReturnType<typeof createWeappTailwindcssGenerator>['generate']>>;
 export {};

package/dist/bundlers/shared/generator-css/source-resolver/metadata.d.ts

@@ -12,4 +12,4 @@ export type GeneratorResolvedSource = TailwindResolvedSource & {
     __weappTailwindcssMeta?: GeneratorSourceMetadata | undefined;
 };
 export declare function withGeneratorSourceMetadata(source: TailwindResolvedSource, metadata: GeneratorSourceMetadata): GeneratorResolvedSource;
-export declare function withMatchedSourceSideMetadata(source: TailwindResolvedSource, resolvedEntrySource: SourceSideCssEntrySource): import("@tailwindcss-mangle/engine").TailwindV4ResolvedSource;
+export declare function withMatchedSourceSideMetadata(source: TailwindResolvedSource, resolvedEntrySource: SourceSideCssEntrySource): import("@/generator").TailwindV4ResolvedSource;

package/dist/bundlers/shared/generator-css/source-resolver.d.ts

@@ -4,6 +4,6 @@ import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource
 export type { GeneratorResolvedSource, GeneratorSourceMetadata } from './source-resolver/metadata';
 export { resolveCssSourceBase } from './source-resolver/postcss-source';
 export type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './source-resolver/types';
-export declare function resolveGeneratorSource(_majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("@tailwindcss-mangle/engine").TailwindV4ResolvedSource | undefined>;
+export declare function resolveGeneratorSource(_majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("@/generator").TailwindV4ResolvedSource | undefined>;
 export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<TailwindResolvedSource[]>;
-export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<any>;
+export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<import("@/tailwindcss/source-scan").TailwindSourceEntry[] | undefined>;

package/dist/bundlers/shared/generator-css/validate.d.ts

@@ -1,6 +1,7 @@
 import type { GenerateCssByGeneratorOptions } from './types';
 export interface ValidateCandidatesByGeneratorOptions extends Omit<GenerateCssByGeneratorOptions, 'runtime'> {
     candidates: Set<string>;
+    generatedCssSources?: Iterable<string> | undefined;
     skipGenerateFallback?: boolean | undefined;
 }
 export declare function validateCandidatesByGenerator(options: ValidateCandidatesByGeneratorOptions): Promise<Set<string>>;

package/dist/bundlers/vite/css-memory.d.ts

@@ -17,6 +17,12 @@ export declare function createViteCssMemory(options: {
             size: number;
         };
         rememberedCssSignatureByFile: number;
+        knownCssSources: number;
+        knownCssSourcesRaw: {
+            bytes: number;
+            mb: number;
+            size: number;
+        };
         knownSfcSources: number;
         knownSfcSourcesRaw: {
             bytes: number;

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

@@ -1,4 +1,4 @@
 import type { OutputAsset } from 'rollup';
 import type { GenerateBundleThis } from './types';
-export declare function createCssAssetEmitter(context: Pick<GenerateBundleThis, 'emitFile'>): (fileName: string, source: string) => OutputAsset;
+export declare function createCssAssetEmitter(context: Pick<GenerateBundleThis, 'emitFile'>): (fileName: string, source: string) => OutputAsset | undefined;
 export declare function resolveAssetSourceFile(asset: OutputAsset, fallbackFile: string): string;

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

@@ -5,7 +5,7 @@ type CssHandlerOptions = IStyleHandlerOptions & {
             from: string;
         };
     };
-    majorVersion: number | undefined;
+    majorVersion?: 4 | undefined;
     sourceOptions?: {
         outputRoot?: string | undefined;
     } | undefined;

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

@@ -0,0 +1,39 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { InternalUserDefinedOptions } from '../../../types';
+export declare function resolveCssBundleOutputFile(options: {
+    bundleFiles: string[];
+    defaultStyleOutputExtension: string;
+    file: string;
+    isWebGeneratorTarget: boolean;
+    opts: InternalUserDefinedOptions;
+    shouldPreserveAppCssExtension: boolean;
+}): string;
+export declare function shouldSkipRawSourceStyleAsset(outputFile: string, file: string, rawSource: string): boolean;
+export declare function resolveOutputFileFromMatchedCssSource(options: {
+    bundleFiles: string[];
+    defaultStyleOutputExtension: string;
+    isWebGeneratorTarget: boolean;
+    opts: Pick<InternalUserDefinedOptions, 'cssMatcher' | 'platform'>;
+    rootDir: string;
+    shouldPreserveAppCssExtension: boolean;
+    sourceFile: string | undefined;
+    sourceRoot?: string | undefined;
+}): string | undefined;
+export declare function createMatchedCssSourceOutputResolver(options: {
+    assetSourceFile: string;
+    file: string;
+    originalFileNames?: string[] | undefined;
+    resolveOutputFileFromMatchedCssSource: (sourceFile: string | undefined) => string | undefined;
+}): (sourceFile: string | undefined) => string | undefined;
+export declare function hasViteProcessedCssResultForSource(sourceFile: string, getViteProcessedCssAssetResults?: (() => Iterable<[string, unknown]> | undefined) | undefined): boolean;
+export declare function applyCssResultToBundle(options: {
+    assetSourceFile: string;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    emitOrReplayCssAsset: (file: string, source: string) => OutputAsset | undefined;
+    file: string;
+    originalSource: OutputAsset;
+    outputFile: string;
+    source: string;
+    viteProcessedCssAsset: boolean;
+    appType: unknown;
+}): void;

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

@@ -3,4 +3,5 @@ export declare function resolveGenerateBundleEnvFlags(): {
     disableDirtyOptimization: boolean;
     disableJsPrecheck: boolean;
     debugCssDiff: boolean;
+    slowJsAstWarnMs: number;
 };

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

@@ -1,8 +1,9 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { GenerateBundleContext } from './types';
+import type { IStyleHandlerOptions } from '../../../types';
 export declare function finalizeMiniProgramCssAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: {
     cssMatcher: GenerateBundleContext['opts']['cssMatcher'];
-    getCssHandlerOptions: GenerateBundleContext['getCssHandlerOptions'];
+    getCssHandlerOptions: (file: string) => IStyleHandlerOptions;
     isWebGeneratorTarget: boolean;
     lastCssResultByFile?: Map<string, string> | undefined;
     onUpdate: GenerateBundleContext['opts']['onUpdate'];

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

@@ -26,6 +26,8 @@ interface FinalizeGenerateBundleOptions {
     isNativeAppStyleTarget: boolean;
     isViteProcessedCssAsset: GenerateBundleContext['isViteProcessedCssAsset'];
     isWebGeneratorTarget: boolean;
+    jsAfterCss: boolean;
+    jsTaskFactories: Array<() => Promise<void>>;
     lastCssResultByFile: Map<string, string>;
     lastCssSourceHashByFile: Map<string, string>;
     linkedByEntry: Map<string, Set<string>> | undefined;

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

@@ -0,0 +1,26 @@
+import type { OutputAsset } from 'rollup';
+import type { createEmptyMetrics } from './metrics';
+import { processCachedTask } from '../../shared/cache';
+export interface ProcessHtmlBundleEntryOptions {
+    cache: Parameters<typeof processCachedTask<string>>[0]['cache'];
+    context: {
+        ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
+    };
+    debug: (message: string, ...args: unknown[]) => void;
+    dynamicRetryCandidates: Set<string>;
+    file: string;
+    metrics: ReturnType<typeof createEmptyMetrics>;
+    onUpdate: (file: string, oldVal: string, newVal: string) => void;
+    originalEntrySource: string;
+    originalSource: OutputAsset;
+    rememberProcessCacheKey: (cacheKey: string, hashKey?: string | number) => void;
+    resolveCurrentSourceCandidateSource: (file: string) => string | undefined;
+    tasks: Promise<void>[];
+    templateHandler: (source: string, options: {
+        runtimeSet: Set<string>;
+    }) => string | Promise<string>;
+    timeTask: (name: string, task: () => Promise<void>) => Promise<void>;
+    transformRuntime: Set<string>;
+    transformRuntimeSignature: string;
+}
+export declare function processHtmlBundleEntry(options: ProcessHtmlBundleEntryOptions): void;

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

@@ -22,8 +22,12 @@ interface ProcessJsBundleEntryOptions {
     rememberProcessCacheKey: (cacheKey: string, hashKey?: string | number) => void;
     runtimeSignature: string;
     snapshot: BundleSnapshot;
+    shouldSkipAstTransform: ((chunk: OutputChunk) => boolean) | undefined;
+    slowJsAstWarnMs: number;
     timeTask: (name: string, task: () => Promise<void>) => Promise<void>;
     transformRuntime: Set<string>;
+    transformRuntimeSignature: string;
+    transformFilterSignature: string;
     uniAppX: GenerateBundleContext['opts']['uniAppX'];
     useIncrementalMode: boolean;
 }

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

@@ -18,7 +18,7 @@ interface ProcessRememberedCssReplayOptions {
     cssTaskFactories: Array<() => Promise<void>>;
     debug: GenerateBundleContext['debug'];
     defaultStyleOutputExtension: string;
-    emitOrReplayCssAsset: (fileName: string, source: string) => OutputAsset;
+    emitOrReplayCssAsset: (fileName: string, source: string) => OutputAsset | undefined;
     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']>;

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, styleOutputExtension?: string | undefined, styleOutputFiles?: Iterable<string> | undefined): Map<string, {
+export declare function collectRememberedCssReplayGroups(sources: Iterable<[string, RememberedCssSource]> | undefined, opts: Pick<InternalUserDefinedOptions, 'cssMatcher' | 'platform'>, 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/root-style-output.d.ts

@@ -0,0 +1,6 @@
+export declare function isRootMiniProgramStyleOutputFile(file: string): boolean;
+export declare function createRelativeCssImportRequest(targetFile: string, importedFile: string): string;
+export declare function createCssImportShell(targetFile: string, importedFile: string): string;
+export declare function createRootMiniProgramOriginStyleOutputFile(file: string): string;
+export declare function shouldKeepRootMiniProgramStyleAsImportShell(appType: unknown): appType is "uni-app-x" | "taro" | "uni-app-vite";
+export declare function shouldMoveRootMiniProgramStyleToImportShellOrigin(appType: unknown): appType is "taro";

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

@@ -0,0 +1,25 @@
+import type { BundleSnapshot } from '../bundle-state';
+import type { RememberedCssSource } from './types';
+import type { InternalUserDefinedOptions } from '../../../types';
+export interface RememberRuntimeLinkedCssSourcesOptions {
+    bundleFiles: string[];
+    defaultStyleOutputExtension: string;
+    debug: (message: string, ...args: unknown[]) => void;
+    getConfiguredTailwindV4CssSourceEntries: () => Array<{
+        file: string;
+        source: string;
+    }>;
+    getSourceCandidateSource?: ((file: string) => string | undefined) | undefined;
+    getSourceCandidateSources?: (() => Iterable<[string, string]>) | undefined;
+    isWebGeneratorTarget: boolean;
+    jsImportedCssFiles: Set<string>;
+    opts: Pick<InternalUserDefinedOptions, 'cssMatcher' | 'platform'>;
+    outDir: string;
+    rememberCssSource?: ((source: RememberedCssSource) => void) | undefined;
+    rootDir: string;
+    runtimeLinkedCssFiles: Set<string>;
+    shouldPreserveAppCssExtension: boolean;
+    snapshot: BundleSnapshot;
+    sourceRoot?: string | undefined;
+}
+export declare function rememberRuntimeLinkedCssSources(options: RememberRuntimeLinkedCssSourcesOptions): void;

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

@@ -0,0 +1,9 @@
+export interface ResolveCurrentSourceCandidateSourceOptions {
+    file: string;
+    getSourceCandidateSource?: ((file: string) => string | undefined) | undefined;
+    getSourceCandidateSources?: (() => Iterable<[string, string]> | undefined) | undefined;
+    outDir: string;
+    rootDir: string;
+    sourceRoot?: string | undefined;
+}
+export declare function resolveCurrentSourceCandidateSource(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;

package/dist/bundlers/vite/generate-bundle/tailwind-v4-css-source.d.ts

@@ -0,0 +1,9 @@
+export interface TailwindV4GenerationCssSourceEntry {
+    file: string;
+    source: string;
+}
+export declare function collectTailwindV4SourceFingerprint(source: string): Set<string>;
+export declare function scoreConfiguredTailwindV4SourceForRawSource(rawSource: string | undefined, entrySource: string): number;
+export declare function resolveSubpackageRootForFile(file: string | undefined, subpackageRoots: Set<string> | undefined): string | undefined;
+export declare function isSameSubpackageScope(outputFile: string, sourceFile: string | undefined, subpackageRoots: Set<string> | undefined): boolean;
+export declare function selectTailwindV4GenerationCssSourceForOutput<T extends TailwindV4GenerationCssSourceEntry>(outputFile: string, entries: T[], rawSource?: string, subpackageRoots?: Set<string> | undefined): T | undefined;

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

@@ -0,0 +1,15 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { InternalUserDefinedOptions } from '../../../types';
+type TransformMatcher = (id: string) => boolean;
+interface TransformFilter {
+    include?: TransformMatcher | undefined;
+    exclude?: TransformMatcher | undefined;
+}
+export declare function createTransformFilter(options: InternalUserDefinedOptions['transform'], rootDir: string): {
+    include: ((id: string) => boolean) | undefined;
+    exclude: ((id: string) => boolean) | undefined;
+} | undefined;
+export declare function shouldSkipViteJsChunkTransform(chunk: OutputChunk, filter: TransformFilter | undefined): boolean;
+export declare function shouldSkipViteAssetTransform(asset: OutputAsset, file: string, rootDir: string, filter: TransformFilter | undefined): boolean;
+export declare function createTransformFilterSignature(options: InternalUserDefinedOptions['transform']): string;
+export {};

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

@@ -15,6 +15,7 @@ export interface GenerateBundleContext {
     ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
         allowBaselineOnlyInitialSync?: boolean | undefined;
         baseClassSet?: Set<string> | undefined;
+        refreshBySource?: boolean | undefined;
         transformOnly?: boolean | undefined;
     }) => Promise<Set<string>>;
     debug: (format: string, ...args: unknown[]) => void;

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

@@ -3,7 +3,6 @@ import type { GenerateBundleContext, GenerateBundleThis } from './generate-bundl
 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 { shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin } from './generate-bundle/root-style-output';
 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/plugin-cache.d.ts

@@ -0,0 +1,15 @@
+export declare function isMissingInternalCssSource(file: string, packageDir: string): boolean;
+export declare function normalizeVitePersistentCacheKey(file: string): string;
+export declare function toMb(bytes: number): number;
+export declare function summarizeStringCache(map: Map<string, string>): {
+    bytes: number;
+    mb: number;
+    size: number;
+};
+export declare function summarizeViteProcessedCssResults(map: Map<string, {
+    css: string;
+}>): {
+    bytes: number;
+    mb: number;
+    size: number;
+};

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

@@ -17,9 +17,10 @@ export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClas
     };
     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;
+        refreshBySource?: boolean | undefined;
         transformOnly?: boolean | undefined;
     }) => Promise<Set<string>>;
 };

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

@@ -7,10 +7,10 @@ export declare function hasLoaderEntry(entries: Array<{
 }>, target?: string): boolean;
 interface ChunkLike {
     id?: string | number | null;
-    name?: string;
+    name?: string | undefined;
     hash?: string | null;
-    files?: Iterable<string> | Array<string>;
-    hasRuntime?: () => boolean;
+    files?: Iterable<string> | Array<string> | undefined;
+    hasRuntime?: (() => boolean) | undefined;
 }
 interface ModuleLike {
     context?: string;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/css-source-resolvers.d.ts

@@ -0,0 +1,34 @@
+import type { SetupWebpackV5ProcessAssetsHookOptions } from './helpers';
+import type { WebpackCssHandlerOptions } from './pipeline-helpers';
+export declare function createWebpackCssSourceResolvers(options: {
+    activeWebpackAssetResourceFiles: ReadonlySet<string>;
+    appType: SetupWebpackV5ProcessAssetsHookOptions['appType'];
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    compilation: {
+        chunks: Iterable<{
+            files?: Iterable<string> | string[] | undefined;
+            hasRuntime?: () => boolean;
+            name?: string | undefined;
+        }>;
+    };
+    cssAssetResources: ReadonlyMap<string, ReadonlySet<string>>;
+    cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    cssSources: Map<string, {
+        css: string | undefined;
+        processed?: boolean | undefined;
+    }>;
+    cssUserHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    groupedCssEntriesLength: number;
+    singleCssAssetFile?: string | undefined;
+    isWebGeneratorTarget: boolean;
+    outputDir: string;
+    runtimeState: SetupWebpackV5ProcessAssetsHookOptions['runtimeState'];
+}): {
+    activeWebpackCssSourceFiles: Set<string>;
+    configuredMainCssEntryFiles: string[];
+    getCssHandlerOptions: (file: string, rawSource?: string | undefined) => WebpackCssHandlerOptions;
+    getCssUserHandlerOptions: (file: string) => WebpackCssHandlerOptions;
+    hasConfiguredTailwindV4SourceRoots: () => boolean;
+    isSameWebpackSourceScope: (outputFile: string, candidateSourceFile: string, currentSourceFile?: string | undefined) => boolean;
+    resolveWebpackCssSourceFile: (file: string, rawSource?: string | undefined) => string | undefined;
+};

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/js-module-graph.d.ts

@@ -0,0 +1,37 @@
+import type { sources as WebpackSources } from 'webpack';
+import type { SetupWebpackV5ProcessAssetsHookOptions } from './helpers';
+import type { LinkedJsModuleResult } from '../../../../types';
+export declare function createWebpackJsAssetModuleGraph(options: {
+    compilation: {
+        getAsset: (file: string) => {
+            source: {
+                source: () => unknown;
+            };
+        } | undefined;
+    };
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    entries: Array<[string, unknown]>;
+    outputDir: string;
+}): {
+    jsAssets: Map<string, string>;
+    moduleGraphOptions: {
+        resolve(specifier: string, importer: string): string | undefined;
+        load: (id: string) => string | undefined;
+        filter(id: string): boolean;
+    };
+};
+export declare function applyWebpackLinkedJsResults(options: {
+    ConcatSource: new (code: string) => WebpackSources.Source;
+    compilation: {
+        getAsset: (file: string) => {
+            source: {
+                source: () => unknown;
+            };
+        } | undefined;
+        updateAsset: (file: string, source: WebpackSources.Source) => void;
+    };
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    debug: SetupWebpackV5ProcessAssetsHookOptions['debug'];
+    jsAssets: ReadonlyMap<string, string>;
+    linked: Record<string, LinkedJsModuleResult> | undefined;
+}): void;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers.d.ts

@@ -0,0 +1,199 @@
+import type { TailwindV4CssSource } from '../../../shared/generator-css/source-resolver/types';
+import type { createEscapeFragments } from '../../../vite/incremental-runtime-class-set/escaped-candidates';
+import type { SourceCandidateStore } from '../../../vite/source-candidates';
+import type { SetupWebpackV5ProcessAssetsHookOptions, WebpackSourceLike } from './helpers';
+import type { WebpackSourceCandidateScanMemoryStats } from './source-candidate-cache';
+import type { TailwindcssRuntimeLike } from '../../../../types';
+export interface WebpackCssHandlerOptions {
+    isMainChunk: boolean;
+    postcssOptions: {
+        options: {
+            from: string;
+        };
+    };
+    majorVersion?: 4 | undefined;
+    sourceOptions?: {
+        cssSources?: TailwindV4CssSource[] | undefined;
+        outputRoot?: string | undefined;
+        sourceCss?: string | undefined;
+        sourceFile?: string | undefined;
+    } | undefined;
+}
+export declare function removeTailwindV4StandaloneHostPreflightRule(source: string): string;
+export interface WebpackSourceCandidateCache {
+    getSourceCandidatesForEntries: SourceCandidateStore['valuesForEntries'];
+    signatureHash: string;
+    tokenSources: ReturnType<SourceCandidateStore['sourcesForEntries']>;
+}
+export declare function isRuntimeTransformCandidate(candidate: string): boolean;
+export declare function collectRuntimeTokenSignatureParts(source: string): [] | RegExpMatchArray;
+export declare function hasMissingRuntimeCandidates(classSet: ReadonlySet<string> | undefined, candidates: ReadonlySet<string> | undefined): boolean;
+export declare function resolveGeneratedCssRuntimeCandidates(source: string, fallbackClassSet?: ReadonlySet<string> | undefined): ReadonlySet<string>;
+export declare function getRuntimeClassSetSync(tailwindRuntime: TailwindcssRuntimeLike): Set<string>;
+export declare function toMb(bytes: number): number;
+export declare function pruneMapToMaxSize<Key, Value>(map: Map<Key, Value>, maxSize: number): void;
+export declare function stripTrailingLineWhitespace(source: string): string;
+export declare function pruneWebpackCssHandlerOptionCaches(cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>, cssUserHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>, activeCssFiles: Set<string>): void;
+export declare function resolveWebpackGeneratorRawSource(rawSource: string, cssHandlerOptions: WebpackCssHandlerOptions): string;
+export interface WebpackGeneratorUserCssSource {
+    css: string;
+    processed: boolean;
+}
+export declare function hasUsableWebpackGeneratorCssSources(cssSources: TailwindV4CssSource[] | undefined): cssSources is TailwindV4CssSource[];
+export declare function normalizeWebpackGeneratorCssSources(cssSources: TailwindV4CssSource[] | undefined): import("@tailwindcss-mangle/engine").TailwindV4CssSource[] | undefined;
+export declare function hasProcessedCssAssetUrl(css: string): boolean;
+export declare function shouldUseWebpackAssetAsGeneratorUserCss(rawSource: string, generatorRawSource: string, options?: {
+    processed?: boolean | undefined;
+}): boolean;
+export declare function collectWebpackAssetUserCssMarkers(source: string): Set<string>;
+export declare function parseWebpackCssLayerNames(params: string): string[];
+export declare function removeWebpackTailwindGeneratedAssetCss(source: string): string;
+export declare function collectWebpackCssRuleIdentityMarkers(source: string): Set<string>;
+export declare function unescapeCssIdentifier(value: string): string;
+export declare function collectGeneratedCssRuntimeCandidates(source: string): Set<string>;
+export declare function hasAdditionalWebpackAssetUserCssMarkers(rawSource: string, generatorRawSource: string): boolean;
+export declare function hasWebpackTailwindSourceDirectives(source: string | undefined): boolean;
+export declare function isWebpackTailwindImportRequest(request: string | undefined): boolean | undefined;
+export declare function removeWebpackGeneratorNonTailwindImports(source: string | undefined): string | undefined;
+export declare function isWebpackCssSourceRepresentedInAsset(rawSource: string, sourceCss: string | undefined): boolean;
+export declare function createWebpackGeneratorCssSource(file: string | undefined, css: string | undefined): {
+    file: string;
+    base: string;
+    css: string;
+    dependencies: string[];
+} | undefined;
+export declare function createWebpackUserCssSourceAppend(sources: Iterable<{
+    css: string | undefined;
+    file: string;
+    processed?: boolean | undefined;
+}>, generatorRawSource: string, currentSourceFile?: string | undefined, shouldIncludeSource?: ((file: string) => boolean) | undefined): {
+    css: string;
+    processed: boolean;
+} | undefined;
+export declare function createWebpackGeneratorUserCssSourceAppend(...sources: Array<WebpackGeneratorUserCssSource | undefined>): WebpackGeneratorUserCssSource | undefined;
+export declare function resolveWebpackMemoryDebugStats(context: {
+    activeAssetFiles: number;
+    activeCssFiles: number;
+    activeProcessCacheKeys: Set<string>;
+    activeProcessHashKeys: Set<string | number>;
+    cache: SetupWebpackV5ProcessAssetsHookOptions['options']['cache'];
+    cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    cssUserHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    phase: string;
+    sourceCandidateScan: WebpackSourceCandidateScanMemoryStats;
+}): {
+    phase: string;
+    process: {
+        rssMb: number;
+        heapTotalMb: number;
+        heapUsedMb: number;
+        externalMb: number;
+        arrayBuffersMb: number;
+    };
+    assets: {
+        active: number;
+        activeCss: number;
+    };
+    processCache: {
+        instance: number;
+        hashMap: number;
+        activeCacheKeys: number;
+        activeHashKeys: number;
+        staleCacheKeys: number;
+        staleHashKeys: number;
+        pruned: boolean;
+        pruneSkipped: boolean;
+    };
+    webpackCss: {
+        handlerOptions: number;
+        userHandlerOptions: number;
+        maxHandlerOptions: number;
+    };
+    sourceCandidateScan: WebpackSourceCandidateScanMemoryStats;
+    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;
+export declare function shouldInjectWebpackCssTracePreflight(appType: SetupWebpackV5ProcessAssetsHookOptions['appType'], cssHandlerOptions: Pick<WebpackCssHandlerOptions, 'isMainChunk'>): boolean;
+export declare function finalizeMiniProgramUserCssAssetSource(source: string, compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], isWebGeneratorTarget: boolean, options?: {
+    cssPreflight?: boolean | undefined;
+}): string;
+export declare function shouldFallbackToWebpackUserCssOnGeneratorError(options: {
+    configuredMainCssEntryFilesLength: number;
+    generatorRawSource: string;
+    hasExplicitTailwindV4SourceCss: boolean;
+}): boolean;
+export declare function resolveWebpackCssAssetModuleResource(resource: string, issuer: {
+    context?: string;
+    resource?: string;
+} | undefined, options: {
+    appType?: SetupWebpackV5ProcessAssetsHookOptions['appType'] | undefined;
+    cssMatcher: (file: string) => boolean;
+}): string | undefined;
+export declare function isSameWebpackCssSourceScope(options: {
+    candidateSourceFile: string;
+    currentSourceFile?: string | undefined;
+    outputFile: string;
+    resourcesByAsset: ReadonlyMap<string, ReadonlySet<string>>;
+}): boolean;
+export declare function shouldAppendCurrentWebpackAssetUserCss(options: {
+    currentAssetHasBundlerGeneratedMarker: boolean;
+    currentAssetHasUserCss: boolean;
+    currentAssetLooksGenerated: boolean;
+    registeredUserRawSource: WebpackGeneratorUserCssSource | undefined;
+    shouldPreserveGeneratedWebAssetUserCss: boolean;
+    sourceCssProcessed: boolean;
+}): boolean;
+export declare function createWebpackCurrentAssetUserRawSource(options: {
+    currentAssetHasUserCss: boolean;
+    currentAssetLooksGenerated: boolean;
+    currentAssetUserCssSource: string;
+    shouldAppendCurrentAssetUserCss: boolean;
+    sourceCssProcessed: boolean;
+}): WebpackGeneratorUserCssSource | undefined;
+export declare function finalizeTracedWebpackCssAsset(css: string, cssHandlerOptions: WebpackCssHandlerOptions, options: {
+    annotateCss: (css: string) => string;
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    isWebGeneratorTarget: boolean;
+}): string;
+export declare function finalizeWebpackCssAssetSource(source: string, compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], isWebGeneratorTarget: boolean, options?: {
+    generatedCss?: boolean;
+}): string;
+export declare function collectWebpackJsRuntimeCandidatesFromAssets(options: {
+    escapeFragments: ReturnType<typeof createEscapeFragments>;
+    getAssetSource: (file: string) => WebpackSourceLike | undefined;
+    isWebGeneratorTarget: boolean;
+    jsAssets: Iterable<string>;
+}): Set<string> | undefined;
+export declare function collectWebpackJsRuntimeTokenSignature(options: {
+    getAssetSource: (file: string) => WebpackSourceLike | undefined;
+    isWebGeneratorTarget: boolean;
+    jsAssets: Iterable<string>;
+}): string;
+export declare function addRuntimeTransformCandidates(target: Set<string>, candidates: ReadonlySet<string> | undefined): void;
+export declare function createWebpackCssSourceTraceTokenSources(compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], webpackSourceCandidates: WebpackSourceCandidateCache | undefined): import("../../../shared/css-source-trace").CssTokenSourceMap | undefined;
+export declare function stringifyOptionalWebpackSourceValue(value: unknown): string;
+export declare function stringifyWebpackSourceLike(source: WebpackSourceLike): string;