weapp-tailwindcss 5.0.12 → 5.0.13

package/dist/{bundle-state-DU2ATDhw.js → bundle-state-CKWeTEhv.js}

@@ -1,10 +1,10 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_precheck = require("./precheck-30zNPRlI.js");
-let node_module = require("node:module");
+const require_precheck = require("./precheck-B0Z8yW7E.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
+let node_module = require("node:module");
 let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
 let node_buffer = require("node:buffer");
 //#region src/bundlers/shared/module-graph.ts

package/dist/{bundle-state-BxMNKjBV.mjs → bundle-state-zQ2MrDdi.mjs}

@@ -1,4 +1,4 @@
-import { h as traverse, m as babelParse, o as Parser } from "./precheck-CsFr1q2l.mjs";
+import { h as traverse, m as babelParse, o as Parser } from "./precheck-CRI90iL1.mjs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import process from "node:process";

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

@@ -5,6 +5,7 @@ import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 export declare function finalizeMiniProgramGeneratorCss(css: string, target: string, majorVersion: number | undefined, cssPreflight: InternalUserDefinedOptions['cssPreflight'], options?: {
     injectPreflight?: boolean;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
 }): string;
 export declare function shouldInjectMiniProgramPreflightForGeneratorCss(opts: InternalUserDefinedOptions, options: {
     cssHandlerOptions: IStyleHandlerOptions;
@@ -15,9 +16,13 @@ export declare function mergeScopedRuntimeWithCurrentRuntime(scopedRuntime: Set<
     currentCssCandidates?: string[] | undefined;
     cssHandlerOptions: IStyleHandlerOptions;
     isolateCssSource: boolean;
+    majorVersion?: number | undefined;
     matchedCssSourceFile: boolean;
 }): Set<string>;
-export declare function shouldIsolateScopedCssSource(source: GeneratorResolvedSource, sourceEntries: TailwindSourceEntry[] | undefined): boolean;
+export declare function shouldIsolateScopedCssSource(majorVersion: number | undefined, source: GeneratorResolvedSource, sourceEntries: TailwindSourceEntry[] | undefined, options: {
+    cssHandlerOptions?: IStyleHandlerOptions | undefined;
+    target: string;
+}): boolean;
 export declare function shouldIsolateCurrentTailwindV4CssCandidates(majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
     hasGeneratedCss: boolean;
     hasGeneratedMarkers: boolean;
@@ -39,7 +44,7 @@ export declare function splitRawSourceByGeneratedCssOrder(rawSource: string, raw
     before: string;
     after: string;
 } | undefined;
-export declare function shouldUseGeneratorForCurrentCss(majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
+export declare function shouldUseGeneratorForCurrentCss(_majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
     hasGeneratedCss: boolean;
     hasGeneratedMarkers: boolean;
     hasSourceDirectives: boolean;

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

@@ -3,6 +3,7 @@ export interface SourceSideCssEntryOptions {
     cwd?: string | undefined;
     outputRoot?: string | undefined;
     sourceFile?: string | undefined;
+    sourceCss?: string | undefined;
     cssSources?: Array<{
         file?: string | undefined;
     }> | undefined;

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

@@ -0,0 +1,3 @@
+export declare function createTailwindV4ApplyReferenceSource(css: string, sourceOptions: {
+    packageName?: string;
+}): string;

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

@@ -0,0 +1,7 @@
+export declare function resolveExistingConfigPath(config: string | undefined, configRequest: string | undefined, file: string, sourceOptions: {
+    projectRoot?: string | undefined;
+    cwd?: string | undefined;
+    config?: string | undefined;
+    sourceFile?: string | undefined;
+    outputRoot?: string | undefined;
+}): string | undefined;

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

@@ -0,0 +1,4 @@
+import type { SourceStyleMatchOptions } from './types';
+export declare function normalizeCssSourceForCompare(css: string): string;
+export declare function getOutputFileStem(file: string): string;
+export declare function scoreTailwindV4CssSourceFileMatch(file: string, cssSourceFile: string, sourceOptions: SourceStyleMatchOptions): number;

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

@@ -0,0 +1,15 @@
+import type { SourceSideCssEntrySource } from '../source-files';
+import type { TailwindResolvedSource } from '../../../../generator';
+import type { TailwindSourceEntry } from '../../../../tailwindcss/source-scan';
+export interface GeneratorSourceMetadata {
+    isolateCssSource?: boolean | undefined;
+    matchedCssSourceFile?: string | undefined;
+    sourceEntries?: TailwindSourceEntry[] | undefined;
+    sourceBase?: string | undefined;
+    sourceCss?: string | undefined;
+}
+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("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource;

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

@@ -0,0 +1,12 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindV4CssSource } from './types';
+export declare function resolvePostcssFromOption(cssHandlerOptions: IStyleHandlerOptions): string | undefined;
+export declare function resolvePostcssSourceFile(cssHandlerOptions: IStyleHandlerOptions): string | undefined;
+export declare function resolveCssHandlerSourceOptions(cssHandlerOptions: IStyleHandlerOptions): {
+    outputRoot?: string | undefined;
+    sourceFile?: string | undefined;
+    sourceCss?: string | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+    cssEntries?: string[] | undefined;
+} | undefined;
+export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;

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

@@ -0,0 +1,22 @@
+import type { SourceSideCssEntryOptions } from '../source-files';
+import type { resolveTailwindV4SourceOptionsFromPatcher } from '../../../../generator';
+import type { TailwindSourceEntry } from '../../../../tailwindcss/source-scan';
+import type { InternalUserDefinedOptions } from '../../../../types';
+export interface GeneratorSourceRuntimeState {
+    twPatcher: InternalUserDefinedOptions['twPatcher'];
+}
+export interface GeneratorSourceSelectionOptions {
+    runtime?: Set<string> | undefined;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+    cssEntries?: string[] | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+}
+export type TailwindV4SourceOptions = ReturnType<typeof resolveTailwindV4SourceOptionsFromPatcher> & {
+    config?: string | undefined;
+    outputRoot?: string | undefined;
+    sourceFile?: string | undefined;
+};
+export type TailwindV4CssSource = NonNullable<TailwindV4SourceOptions['cssSources']>[number];
+export type TailwindV4CssSourceRef = Pick<TailwindV4CssSource, 'file'>;
+export interface SourceStyleMatchOptions extends SourceSideCssEntryOptions {
+}

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

@@ -1,26 +1,9 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './source-resolver/types';
 import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../../generator';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
-import type { InternalUserDefinedOptions } from '../../../types';
-interface GeneratorSourceRuntimeState {
-    twPatcher: InternalUserDefinedOptions['twPatcher'];
-}
-interface GeneratorSourceSelectionOptions {
-    runtime?: Set<string> | undefined;
-    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
-    cssEntries?: string[] | undefined;
-}
-export interface GeneratorSourceMetadata {
-    matchedCssSourceFile?: string | undefined;
-    sourceEntries?: TailwindSourceEntry[] | undefined;
-    sourceBase?: string | undefined;
-    sourceCss?: string | undefined;
-}
-export type GeneratorResolvedSource = TailwindResolvedSource & {
-    __weappTailwindcssMeta?: GeneratorSourceMetadata | undefined;
-};
-export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;
+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("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").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<TailwindSourceEntry[] | undefined>;
-export {};
+export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<any>;

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

@@ -1,4 +1,5 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindV4CssSource } from './source-resolver/types';
 import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 export interface GenerateCssByGeneratorOptions {
@@ -12,6 +13,7 @@ export interface GenerateCssByGeneratorOptions {
     file: string;
     cssHandlerOptions: IStyleHandlerOptions;
     cssUserHandlerOptions: IStyleHandlerOptions;
+    cssSources?: TailwindV4CssSource[] | undefined;
     getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     debug: (format: string, ...args: unknown[]) => void;

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

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

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

@@ -0,0 +1,27 @@
+import type { RememberedCssSource } from './generate-bundle';
+export declare function normalizeCssSourceIdentity(sourceFile: string): string;
+export declare function shouldCollectTransformedSourceCandidates(id: string): boolean;
+export declare function createViteCssMemory(options: {
+    debug: (format: string, ...args: unknown[]) => void;
+    getSourceCandidateSource: (file: string) => string | undefined;
+}): {
+    getKnownSfcSource: (file: string) => string | undefined;
+    getRememberedCssSignature: (file: string) => string | undefined;
+    getRememberedCssSourceEntry: (file: string) => RememberedCssSource | undefined;
+    getRememberedCssSources: () => Map<string, RememberedCssSource>;
+    getStats: () => {
+        rememberedCssSources: number;
+        rememberedCssSignatureByFile: number;
+        knownSfcSources: number;
+    };
+    rememberCssSource: (entry: RememberedCssSource, cssRuntimeSignature?: string) => void;
+    rememberKnownSfcSource: (id: string, code: string) => void;
+    refreshRememberedCssSource: (remembered: RememberedCssSource) => Promise<RememberedCssSource | undefined>;
+    refreshRememberedCssSourceByCurrentFile: (sourceFile: string) => Promise<void>;
+    refreshRememberedCssSourceBySourceFile: (sourceFile: string, rawSource: string) => void;
+    setRememberedCssSignature: (file: string, cssRuntimeSignature: string) => void;
+    prune: (pruneOptions: {
+        activeFiles: Set<string>;
+        activeKnownSfcFiles?: Set<string> | undefined;
+    }) => void;
+};

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

@@ -0,0 +1,2 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+export declare function normalizeBundleFileNameKeysForTest(bundle: Record<string, OutputAsset | OutputChunk>): void;

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

@@ -0,0 +1,8 @@
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { InternalUserDefinedOptions } from '../../../types';
+export interface ConfiguredCssSourceEntry {
+    file: string;
+    source: string;
+}
+export declare function collectConfiguredTailwindV4CssSources(opts: InternalUserDefinedOptions): TailwindV4CssSource[];
+export declare function collectConfiguredTailwindV4CssSourceEntries(opts: InternalUserDefinedOptions, fallbackBase: string): ConfiguredCssSourceEntry[];

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

@@ -0,0 +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 resolveAssetSourceFile(asset: OutputAsset, fallbackFile: string): string;

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

@@ -21,5 +21,10 @@ export interface CssHandlerOptionsCache {
     getCssHandlerOptions: (file: string) => CssHandlerOptions;
     getCssUserHandlerOptions: (file: string) => CssHandlerOptions;
 }
+export declare function resolveViteCssHandlerExtraOptions(file: string): {
+    isMainChunk: boolean;
+} | {
+    isMainChunk?: never;
+};
 export declare function createCssHandlerOptionsCache(options: CssHandlerOptionsCacheOptions): CssHandlerOptionsCache;
 export {};

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

@@ -1,15 +1,16 @@
 import type { InternalUserDefinedOptions } from '../../../types';
 export declare const SOURCE_STYLE_OUTPUT_EXT_RE: RegExp;
 export declare const CSS_SOURCE_OUTPUT_EXT_RE: RegExp;
-export declare const MINI_PROGRAM_STYLE_OUTPUT_EXT_RE: RegExp;
+export declare function resolveMiniProgramStyleOutputExtension(options?: {
+    cssMatcher?: ((file: string) => boolean) | undefined;
+    fallback?: string | undefined;
+    files?: Iterable<string> | undefined;
+    stem?: string | undefined;
+}): string;
 export declare function resolveReplayCssOutputFile(rootDir: string, file: string): string;
 export declare function resolveReplayCssOutputFileFromSourceRoot(rootDir: string, file: string, sourceRoot: string | undefined): string;
-export declare function resolveViteCssOutputFile(file: string, opts: InternalUserDefinedOptions, isWebGeneratorTarget: boolean, preserveCssExtension?: boolean): string;
-export declare function resolveViteCssPipelineOutputFile(file: string, _opts: Pick<InternalUserDefinedOptions, 'cssMatcher'>, rootDir: string, isWebGeneratorTarget?: boolean, preserveCssExtension?: boolean, sourceRoot?: string | undefined): string;
+export declare function resolveViteCssOutputFile(file: string, opts: InternalUserDefinedOptions, isWebGeneratorTarget: boolean, preserveCssExtension?: boolean, styleOutputExtension?: string | undefined, styleOutputFiles?: Iterable<string> | undefined): string;
+export declare function resolveViteCssPipelineOutputFile(file: string, opts: Pick<InternalUserDefinedOptions, 'cssMatcher' | 'platform'>, rootDir: string, isWebGeneratorTarget?: boolean, preserveCssExtension?: boolean, sourceRoot?: string | undefined, styleOutputExtension?: string | undefined, styleOutputFiles?: Iterable<string> | undefined): string;
 export declare function canProcessViteSourceStyleAsCss(source: string, file: string): boolean;
 export declare function normalizeCssSourceForCompare(css: string): string;
 export declare function stripStyleFileExtension(file: string): string;
-export declare function isAppOriginCssFile(file: string): boolean;
-export declare function isMainAppCssFile(file: string): boolean;
-export declare function isMainStyleEntryCssFile(file: string): boolean;
-export declare function isTailwindEntryCssFile(file: string): boolean;

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

@@ -0,0 +1,7 @@
+export declare function resolveGenerateBundleEnvFlags(): {
+    forceRuntimeRefreshByEnv: boolean;
+    disableDirtyOptimization: boolean;
+    disableJsPrecheck: boolean;
+    debugCssDiff: boolean;
+    disableV3OxideSourceRuntime: boolean;
+};

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

@@ -0,0 +1,58 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleBuildState, BundleSnapshot } from '../bundle-state';
+import type { BundleMetrics } from './metrics';
+import type { GenerateBundleContext } from './types';
+interface FinalizeGenerateBundleOptions {
+    activeProcessCacheKeys: Set<string>;
+    activeProcessHashKeys: Set<string | number>;
+    activeViteCssCacheFiles: Set<string>;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    bundleFiles: string[];
+    cache: GenerateBundleContext['opts']['cache'];
+    cssTaskFactories: Array<() => Promise<void>>;
+    debug: GenerateBundleContext['debug'];
+    defaultStyleOutputExtension: string;
+    formatIteration: number;
+    generatorCandidateSignature: string;
+    generatorRuntime: Set<string>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getSourceCandidateSourcesForEntries: GenerateBundleContext['getSourceCandidateSourcesForEntries'];
+    getSourceCandidatesForEntries: GenerateBundleContext['getSourceCandidatesForEntries'];
+    getViteCssCacheStats: GenerateBundleContext['getViteCssCacheStats'];
+    getViteProcessedCssAssetResults: GenerateBundleContext['getViteProcessedCssAssetResults'];
+    hmrTimingRecorder: GenerateBundleContext['hmrTimingRecorder'];
+    hmrTimingStartedAt: number;
+    isHarmonyAppStyleTarget: boolean;
+    isNativeAppStyleTarget: boolean;
+    isViteProcessedCssAsset: GenerateBundleContext['isViteProcessedCssAsset'];
+    isWebGeneratorTarget: boolean;
+    lastCssResultByFile: Map<string, string>;
+    lastCssSourceHashByFile: Map<string, string>;
+    linkedByEntry: Map<string, Set<string>> | undefined;
+    markCssAssetProcessed: GenerateBundleContext['markCssAssetProcessed'];
+    metrics: BundleMetrics;
+    onEnd: GenerateBundleContext['opts']['onEnd'];
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    opts: GenerateBundleContext['opts'];
+    outDir: string;
+    pendingLinkedUpdates: Array<() => void>;
+    pruneViteCssCaches: GenerateBundleContext['pruneViteCssCaches'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+    recordTimingDetail: (name: string, startedAt: number) => void;
+    recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
+    rootDir: string;
+    runtime: Set<string>;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    shouldPreserveAppCssExtension: boolean;
+    snapshot: BundleSnapshot;
+    sourceCandidates: Set<string>;
+    sourceRoot: string | undefined;
+    state: BundleBuildState;
+    styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    tasks: Promise<void>[];
+    timingDetails: Record<string, number>;
+    transformRuntime: Set<string>;
+    useIncrementalMode: boolean;
+}
+export declare function finalizeGenerateBundle(options: FinalizeGenerateBundleOptions): Promise<void>;
+export {};

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

@@ -0,0 +1,31 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleSnapshot, BundleStateEntry } from '../bundle-state';
+import type { BundleMetrics } from './metrics';
+import type { GenerateBundleContext } from './types';
+import type { CreateJsHandlerOptions, LinkedJsModuleResult } from '../../../types';
+interface ProcessJsBundleEntryOptions {
+    applyLinkedUpdates: (linked?: Record<string, LinkedJsModuleResult>) => void;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    cache: GenerateBundleContext['opts']['cache'];
+    createHandlerOptions: (absoluteFilename: string, extra?: CreateJsHandlerOptions) => CreateJsHandlerOptions;
+    debug: GenerateBundleContext['debug'];
+    disableJsPrecheck: boolean;
+    entry: BundleStateEntry;
+    getJsEntry: ReturnType<typeof import('./js-entries').createJsEntryResolver>;
+    jsHandler: GenerateBundleContext['opts']['jsHandler'];
+    jsTaskFactories: Array<() => Promise<void>>;
+    linkedByEntry: Map<string, Set<string>> | undefined;
+    metrics: BundleMetrics;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    outDir: string;
+    processFiles: BundleSnapshot['processFiles'];
+    rememberProcessCacheKey: (cacheKey: string, hashKey?: string | number) => void;
+    runtimeSignature: string;
+    snapshot: BundleSnapshot;
+    timeTask: (name: string, task: () => Promise<void>) => Promise<void>;
+    transformRuntime: Set<string>;
+    uniAppX: GenerateBundleContext['opts']['uniAppX'];
+    useIncrementalMode: boolean;
+}
+export declare function processJsBundleEntry(options: ProcessJsBundleEntryOptions): void;
+export {};

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

@@ -0,0 +1,77 @@
+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;
+    lastCssResultByFile: Map<string, string>;
+    phase: string;
+    runtimeSize: number;
+    sourceCandidatesSize: number;
+    transformRuntimeSize: number;
+    useIncrementalMode: boolean;
+}): {
+    phase: string;
+    mode: string;
+    process: {
+        rssMb: number;
+        heapTotalMb: number;
+        heapUsedMb: number;
+        externalMb: number;
+        arrayBuffersMb: number;
+    };
+    runtime: {
+        sourceCandidates: number;
+        runtime: number;
+        transformRuntime: number;
+        generatorRuntime: number;
+    };
+    processCache: {
+        instance: number;
+        hashMap: number;
+        activeCacheKeys: number;
+        activeHashKeys: number;
+    };
+    viteCss: {
+        lastCssResultByFile: {
+            bytes: number;
+            mb: number;
+            size: number;
+        };
+    };
+    tailwind: {
+        v3: {
+            max: number;
+            entryCandidatesMax: number;
+            entryCssBytesMax: number;
+            size: number;
+            entries: {
+                key: string;
+                candidates: number;
+                classSet: number;
+                cssBytes: number;
+                rawCssBytes: number;
+                exactResults: number;
+            }[];
+            keys: string[];
+        };
+        v4: {
+            max: number;
+            entryCandidatesMax: number;
+            entryCssBytesMax: number;
+            size: number;
+            taskMax: number;
+            taskSize: number;
+            entries: {
+                key: string;
+                candidates: number;
+                classSet: number;
+                cssBytes: number;
+                rawCssBytes: number;
+            }[];
+            keys: string[];
+            taskKeys: string[];
+        };
+    };
+} | 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

@@ -4,6 +4,7 @@ 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 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,29 @@
+import type { BundleSnapshot } from '../bundle-state';
+import type { SourceCandidateFilterOptions } from '../source-candidates';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+interface CreateSubpackageSourceCandidateScopeOptions {
+    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

@@ -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 {};