weapp-tailwindcss 5.0.12 → 5.1.0

package/README.en.md

@@ -2,7 +2,7 @@
 
 > English | [简体中文](./README.md)
 
-This is the core package that brings Tailwind CSS to mini program ecosystems, handling class transformation, CSS compatibility, framework build adapters, and Tailwind v3/v4 support.
+This is the core package that brings Tailwind CSS to mini program ecosystems, handling class transformation, CSS compatibility, framework build adapters, and Tailwind v4 support.
 
 ## Website
 

package/README.md

@@ -2,7 +2,7 @@
 
 > 简体中文 | [English](./README.en.md)
 
-这个包是把 Tailwind CSS 带到小程序生态的核心入口，负责类名转译、CSS 兼容、框架构建适配和 Tailwind v3/v4 支持。
+这个包是把 Tailwind CSS 带到小程序生态的核心入口，负责类名转译、CSS 兼容、框架构建适配和 Tailwind v4 支持。
 
 ## 官网
 

package/dist/auto-Ba6hDrse.mjs

@@ -0,0 +1,13 @@
+import { hasCssMacroStyleOptions, hasCssMacroTailwindV4Directive, transformCssMacroCss, withCssMacroStyleOptions } from "@weapp-tailwindcss/postcss";
+//#region src/css-macro/auto.ts
+const CSS_MACRO_PLUGIN_MARKER = "__weappTailwindcssCssMacro";
+function markCssMacroPlugin(value) {
+	Object.defineProperty(value, CSS_MACRO_PLUGIN_MARKER, {
+		configurable: false,
+		enumerable: false,
+		value: true
+	});
+	return value;
+}
+//#endregion
+export { withCssMacroStyleOptions as a, transformCssMacroCss as i, hasCssMacroTailwindV4Directive as n, markCssMacroPlugin as r, hasCssMacroStyleOptions as t };

package/dist/auto-DtU6f3X6.js

@@ -0,0 +1,18 @@
+require("@weapp-tailwindcss/postcss");
+//#region src/css-macro/auto.ts
+const CSS_MACRO_PLUGIN_MARKER = "__weappTailwindcssCssMacro";
+function markCssMacroPlugin(value) {
+	Object.defineProperty(value, CSS_MACRO_PLUGIN_MARKER, {
+		configurable: false,
+		enumerable: false,
+		value: true
+	});
+	return value;
+}
+//#endregion
+Object.defineProperty(exports, "markCssMacroPlugin", {
+	enumerable: true,
+	get: function() {
+		return markCssMacroPlugin;
+	}
+});

package/dist/bundlers/shared/css-cleanup.d.ts

@@ -1 +1 @@
-export { finalizeMiniProgramCss, hoistTailwindPreflightBase, pruneMiniProgramGeneratedCss, removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules, } from '@weapp-tailwindcss/postcss';
+export { finalizeMiniProgramCss, hasMiniProgramCssSpecificityPlaceholders, hoistTailwindPreflightBase, pruneMiniProgramGeneratedCss, removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules, stripMiniProgramCssSpecificityPlaceholders, } from '@weapp-tailwindcss/postcss';

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

@@ -5,10 +5,11 @@ export declare function parseImportRequest(params: string): string | undefined;
 export declare function hasLocalCssImport(rawSource: string): boolean;
 export declare function normalizeTailwindConfigDirectives(rawSource: string, base: string): string;
 export declare function normalizeTailwindSourceForGenerator(rawSource: string, options?: TailwindDirectiveOptions): string;
-export declare function normalizeTailwindV3CssEntrySource(rawSource: string): string;
 export declare function normalizeTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): string;
 export declare function removeTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): string;
 export declare function hasTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
+export declare function hasTailwindNonRootGenerationDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
+export declare function hasTailwindRootImportDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
 export declare function hasTailwindRootDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
 export declare function hasTailwindApplyDirective(rawSource: string): boolean;
 export declare function resolveCssEntrySource(rawSource: string, base: string, options?: {

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

@@ -3,8 +3,10 @@ import type { GeneratorResolvedSource } from './source-resolver';
 import type { createWeappTailwindcssGenerator } from '../../../generator';
 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?: {
+export declare function hasMiniProgramTailwindV4PreflightReset(css: string): boolean;
+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,19 +17,23 @@ 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 shouldIsolateCurrentTailwindV4CssCandidates(majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
+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;
     rawSource: string;
 }): boolean;
 export declare function shouldScanTailwindV4Sources(majorVersion: number | undefined, target: string, generatorRuntime: Set<string>, isolateCssSource: boolean): boolean;
-export declare function shouldAppendWebBundleCssFallback(target: string, options: {
+export declare function shouldAppendWebBundleCssFallback(target: string, _options: {
     hasSourceDirectives: boolean;
     hasMatchedCssSourceFile: boolean;
-}): boolean;
+}): target is "web";
 export declare function isEmptyCssSourceOrderParts(parts: {
     before: string;
     after: string;
@@ -39,18 +45,29 @@ 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: {
+    forceGenerator?: boolean | undefined;
     hasGeneratedCss: boolean;
     hasGeneratedMarkers: boolean;
     hasSourceDirectives: boolean;
     rawSource: string;
-}): boolean | undefined;
+}): boolean;
 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: import("@/generator").WeappTailwindcssGeneratorTarget;
+    target: WeappTailwindcssGeneratorTarget;
     rawCss: string;
-}) | undefined;
+}) | {
+    css: string;
+    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;
 type GeneratorResult = Awaited<ReturnType<ReturnType<typeof createWeappTailwindcssGenerator>['generate']>>;
-export declare function isSupportedGeneratorMajorVersion(majorVersion: number | undefined): boolean;
 export {};

package/dist/bundlers/shared/generator-css/local-imports.d.ts

@@ -5,3 +5,6 @@ export declare function splitLocalCssImports(source: string): {
     source: string;
 } | undefined;
 export declare function restoreLocalCssImports(css: string, imports: string | undefined): string;
+export declare function rewriteLocalCssImportRequestsForOutput(css: string, options?: {
+    styleOutputExtension?: string | undefined;
+}): string;

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,6 @@
+export declare function createTailwindV4ApplyReferenceSource(css: string, sourceOptions: {
+    packageName?: string;
+}): string;
+export declare function createTailwindV4SourceReferenceSource(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,3 @@
+import type { SourceStyleMatchOptions } from './types';
+export declare function normalizeCssSourceForCompare(css: 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("@tailwindcss-mangle/engine").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 { resolveTailwindV4SourceOptionsFromRuntime } from '../../../../generator';
+import type { TailwindSourceEntry } from '../../../../tailwindcss/source-scan';
+import type { InternalUserDefinedOptions } from '../../../../types';
+export interface GeneratorSourceRuntimeState {
+    tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
+}
+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 resolveTailwindV4SourceOptionsFromRuntime> & {
+    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 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 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 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,10 +1,11 @@
 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 {
     opts: InternalUserDefinedOptions;
     runtimeState: {
-        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
         readyPromise: Promise<void>;
     };
     runtime: Set<string>;
@@ -12,16 +13,29 @@ export interface GenerateCssByGeneratorOptions {
     file: string;
     cssHandlerOptions: IStyleHandlerOptions;
     cssUserHandlerOptions: IStyleHandlerOptions;
+    cssSources?: TailwindV4CssSource[] | undefined;
     getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+    sourceCandidates?: Set<string> | undefined;
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     debug: (format: string, ...args: unknown[]) => void;
+    userRawSource?: string | undefined;
+    userRawSourceProcessed?: boolean | undefined;
+    forceGenerator?: boolean | undefined;
     previousCss?: string | undefined;
     deferEmptyScopedCssSource?: boolean | undefined;
+    restoreLocalCssImports?: boolean | undefined;
 }
 export interface GenerateCssByGeneratorResult {
     css: string;
+    classSet: Set<string>;
     target: string;
     source: 'generator';
     dependencies: string[];
     incremental?: boolean | undefined;
+    metadata?: {
+        file: string;
+        majorVersion?: number | undefined;
+        outputFile?: string | undefined;
+        rawCss?: string | undefined;
+    } | undefined;
 }

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

@@ -1,6 +1,9 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { InternalUserDefinedOptions } from '../../../types';
+export declare function removeTailwindV4GeneratedUserCssArtifacts(source: string): string;
 export declare function removeTailwindV4GeneratorAtRules(source: string): string;
+export declare function isCommentOnlyCss(source: string): boolean;
+export declare function removeMiniProgramHoverSelectors(source: string, enabled?: boolean | undefined): string;
 export declare function stripTailwindSourceMediaFragments(source: string): string;
 export declare function stripUnmatchedTailwindSourceMediaCloseFragments(source: string): string;
 export declare function splitUserCssLayerBlocks(source: string): {
@@ -13,7 +16,7 @@ export declare function extractGeneratedCssForUserLayerSelectors(css: string, us
     rest: string;
 };
 export declare function filterApplyOnlyGeneratedCss(css: string, source: string): string;
-export declare function shouldFilterApplyOnlyGeneratedCss(majorVersion: number | undefined, target: string, source: string, options: {
+export declare function shouldFilterApplyOnlyGeneratedCss(_majorVersion: number | undefined, target: string, source: string, options: {
     hasGeneratedCss: boolean;
     hasGeneratedMarkers: boolean;
 }): boolean;
@@ -23,4 +26,5 @@ export declare function transformGeneratorUserCss(source: string, options: {
     cssUserHandlerOptions: IStyleHandlerOptions;
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     importFallback: boolean;
+    processed?: boolean | undefined;
 }): Promise<string>;

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/shared/run-tasks.d.ts

@@ -1,2 +1,3 @@
 export declare function runWithConcurrency<T>(factories: Array<() => Promise<T>>, limit?: number): Promise<T[]>;
+export declare function resolveTaskConcurrency(defaultLimit?: number): number;
 export declare function pushConcurrentTaskFactories(queue: Array<Promise<void>>, factories: Array<() => Promise<unknown>>, limit?: number): void;

package/dist/bundlers/shared/v4-generation-core.d.ts

@@ -0,0 +1,11 @@
+import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './generator-css';
+export interface TailwindV4GenerationCoreInput extends GenerateCssByGeneratorOptions {
+    outputFile?: string | undefined;
+    sourceCandidates?: Set<string> | undefined;
+}
+export interface TailwindV4GenerationCoreResult extends GenerateCssByGeneratorResult {
+    classSet: Set<string>;
+    dependencies: string[];
+    metadata: NonNullable<GenerateCssByGeneratorResult['metadata']>;
+}
+export declare function generateTailwindV4Css(options: TailwindV4GenerationCoreInput): Promise<TailwindV4GenerationCoreResult | undefined>;

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

@@ -9,7 +9,7 @@ interface RememberedMainCssSource {
 interface CssFinalizerContext {
     opts: InternalUserDefinedOptions;
     runtimeState: {
-        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
         readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;

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

@@ -0,0 +1,37 @@
+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;
+        rememberedCssSourcesRaw: {
+            bytes: number;
+            mb: number;
+            size: number;
+        };
+        rememberedCssSignatureByFile: number;
+        knownSfcSources: number;
+        knownSfcSourcesRaw: {
+            bytes: number;
+            mb: number;
+            size: 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/candidates.d.ts

@@ -1,2 +1 @@
 export declare function collectUnescapedDynamicCandidates(source: string, allowedCandidates?: Set<string>): string[];
-export declare function collectLegacyContainerCompatCandidates(sourceCandidates: Set<string>, candidates: Set<string>): Set<string>;

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

@@ -0,0 +1,8 @@
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
+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,17 @@
 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 resolveViteCssPipelineOutputFileFromSourceFile(sourceFile: 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,6 @@
+export declare function resolveGenerateBundleEnvFlags(): {
+    forceRuntimeRefreshByEnv: boolean;
+    disableDirtyOptimization: boolean;
+    disableJsPrecheck: boolean;
+    debugCssDiff: boolean;
+};

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

@@ -0,0 +1,12 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { GenerateBundleContext } from './types';
+export declare function finalizeMiniProgramCssAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: {
+    cssMatcher: GenerateBundleContext['opts']['cssMatcher'];
+    getCssHandlerOptions: GenerateBundleContext['getCssHandlerOptions'];
+    isWebGeneratorTarget: boolean;
+    lastCssResultByFile?: Map<string, string> | undefined;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+    styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    debug?: GenerateBundleContext['debug'];
+}): Promise<number>;

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

@@ -0,0 +1,63 @@
+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 normalizeTaroRootImportShellAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<GenerateBundleContext['opts'], 'appType' | 'cssMatcher'> & {
+    debug: GenerateBundleContext['debug'];
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+}): number;
+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 {};