weapp-tailwindcss 5.1.15 → 5.1.16

package/dist/bundlers/gulp/shared/create-native-framework-plugins/cache-state.d.ts

@@ -0,0 +1,71 @@
+import type { getCompilerContext } from '../../../../context';
+import type { IStyleHandlerOptions } from '../../../../types';
+export declare function touchMapEntry<Key, Value>(map: Map<Key, Value>, key: Key, value: Value): void;
+export declare function pruneGulpRuntimeSourceCaches(sourceHashByFile: Map<string, string>, sourcesByFile: Map<string, {
+    source: string;
+    type: 'html' | 'js';
+}>): void;
+export declare function rememberGulpProcessCacheKey(cacheKeys: Set<string>, key: string): void;
+export declare function pruneGulpProcessCache(cache: ReturnType<typeof getCompilerContext>['cache'], cacheKeys: Set<string>): void;
+export declare function resolveGulpMemoryDebugStats(context: {
+    cache: ReturnType<typeof getCompilerContext>['cache'];
+    defaultStyleHandlerOptionsCache: Map<number | 'unknown', Partial<IStyleHandlerOptions>>;
+    gulpProcessCacheKeys: Set<string>;
+    phase: string;
+    runtimeSet: Set<string>;
+    runtimeSourceHashByFile: Map<string, string>;
+    runtimeSourcesByFile: Map<string, {
+        source: string;
+        type: 'html' | 'js';
+    }>;
+}): {
+    phase: string;
+    process: {
+        rssMb: number;
+        heapTotalMb: number;
+        heapUsedMb: number;
+        externalMb: number;
+        arrayBuffersMb: number;
+    };
+    runtime: {
+        runtimeSet: number;
+        runtimeSourceHashByFile: number;
+        runtimeSourcesByFile: number;
+        maxRuntimeSources: number;
+    };
+    processCache: {
+        instance: number;
+        hashMap: number;
+        activeCacheKeys: number;
+        maxCacheKeys: number;
+    };
+    gulpOptions: {
+        defaultStyleHandlerOptions: number;
+    };
+    tailwind: {
+        v4: {
+            max: number;
+            entryCandidatesMax: number;
+            entryCssBytesMax: number;
+            size: number;
+            taskMax: number;
+            taskSize: number;
+            entries: {
+                candidates: number;
+                classSet: number;
+                cssBytes: number;
+                rawCssBytes: number;
+                keyHash: string;
+                keyBytes: number;
+            }[];
+            keys: {
+                keyHash: string;
+                keyBytes: number;
+            }[];
+            taskKeys: {
+                keyHash: string;
+                keyBytes: number;
+            }[];
+        };
+    };
+} | undefined;

package/dist/bundlers/gulp/shared/create-native-framework-plugins/file-transforms.d.ts

@@ -0,0 +1,43 @@
+import type File from 'vinyl';
+import type { getCompilerContext } from '../../../../context';
+import type { TailwindRuntimeState } from '../../../../tailwindcss/runtime';
+import type { CreateJsHandlerOptions, IStyleHandlerOptions, ITemplateHandlerOptions, JsModuleGraphOptions } from '../../../../types';
+type DebugFunction = (formatter: unknown, ...args: unknown[]) => void;
+type RuntimeRefreshOptions = boolean | {
+    forceRefresh?: boolean;
+    forceCollect?: boolean;
+    clearCache?: boolean;
+};
+export interface GulpFileTransformContext {
+    cache: ReturnType<typeof getCompilerContext>['cache'];
+    createRuntimeSetHash: (rawSource: string, nextRuntimeSet: Set<string>, sourceTraceSignature?: string, sourceCandidateSignature?: string, outputSignature?: string) => string;
+    debug: DebugFunction;
+    generatedCssPreflightModeByFile: Map<string, {
+        inject: boolean;
+        preserve: boolean;
+    }>;
+    getSourceCandidateGetter: () => ((entries?: unknown) => Set<string>) | undefined;
+    getSourceCandidateSourceGetter: () => ((entries?: unknown) => Map<string, Set<string>>) | undefined;
+    getRuntimeSet: () => Set<string>;
+    gulpProcessCacheKeys: Set<string>;
+    opts: ReturnType<typeof getCompilerContext>;
+    refreshGulpV4SourceCandidates: (forceRefresh?: boolean) => Promise<((entries?: unknown) => Set<string>) | undefined>;
+    refreshRuntimeSet: (options?: RuntimeRefreshOptions) => Promise<Set<string>>;
+    refreshRuntimeSetForSource: (file: File, rawSource: string, type: 'html' | 'js') => Promise<Set<string>>;
+    registerAutoCssSource: (file: File, rawSource: string) => Promise<boolean>;
+    resolveGulpStyleOutputExtension: (file: File) => string | undefined;
+    resolveGulpTransformTimingDetails: (phase: string) => unknown;
+    resolveModuleGraphOptions: (moduleGraph?: JsModuleGraphOptions) => JsModuleGraphOptions;
+    resolveWxmlHandlerOptions: (options?: Partial<ITemplateHandlerOptions>) => Partial<ITemplateHandlerOptions>;
+    resolveWxssFileHandlerOptions: (file: File, rawSource: string, options?: Partial<IStyleHandlerOptions>) => Partial<IStyleHandlerOptions>;
+    resolveWxssUserHandlerOptions: (options?: Partial<IStyleHandlerOptions>) => Partial<IStyleHandlerOptions>;
+    runtimeState: TailwindRuntimeState;
+}
+export declare function createGulpFileTransforms(context: GulpFileTransformContext): {
+    adaptWxss: (options?: Partial<IStyleHandlerOptions>) => import("node:stream").Transform;
+    generateWxss: (options?: Partial<IStyleHandlerOptions>) => import("node:stream").Transform;
+    transformWxss: (options?: Partial<IStyleHandlerOptions>) => import("node:stream").Transform;
+    transformWxml: (options?: Partial<ITemplateHandlerOptions>) => import("node:stream").Transform;
+    transformJs: (options?: Partial<CreateJsHandlerOptions>) => import("node:stream").Transform;
+};
+export {};

package/dist/bundlers/gulp/shared/create-native-framework-plugins.d.ts

@@ -1,8 +1,8 @@
-import type { CreateJsHandlerOptions, IStyleHandlerOptions, ITemplateHandlerOptions, UserDefinedOptions } from '../../../types';
+import type { IStyleHandlerOptions, ITemplateHandlerOptions, UserDefinedOptions } from '../../../types';
 export declare function createNativeGulpPlugins(options?: UserDefinedOptions): {
     adaptWxss: (options?: Partial<IStyleHandlerOptions>) => import("node:stream").Transform;
     generateWxss: (options?: Partial<IStyleHandlerOptions>) => import("node:stream").Transform;
     transformWxss: (options?: Partial<IStyleHandlerOptions>) => import("node:stream").Transform;
     transformWxml: (options?: Partial<ITemplateHandlerOptions>) => import("node:stream").Transform;
-    transformJs: (options?: Partial<CreateJsHandlerOptions>) => import("node:stream").Transform;
+    transformJs: (options?: Partial<import("@/types").CreateJsHandlerOptions>) => import("node:stream").Transform;
 };

package/dist/bundlers/shared/framework-postcss.d.ts

@@ -0,0 +1,14 @@
+import type { IStyleHandlerOptions, LoadedPostcssOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GenerateCssByGeneratorResult } from './generator-css';
+import type { InternalUserDefinedOptions } from '../../types';
+export declare function resolveFrameworkPostcssOptions(value: unknown): LoadedPostcssOptions | undefined;
+export declare function collectFrameworkPostcssOptionsFromLoaderEntries(entries: unknown[], loaderContext?: unknown): LoadedPostcssOptions | undefined;
+export declare function captureFrameworkPostcssOptions(owner: InternalUserDefinedOptions, options: unknown): LoadedPostcssOptions | undefined;
+export declare function captureResolvedFrameworkPostcssOptions(owner: InternalUserDefinedOptions, options: LoadedPostcssOptions | undefined): LoadedPostcssOptions | undefined;
+export declare function hasFrameworkPostcssOptions(owner: InternalUserDefinedOptions): boolean;
+export declare function adaptGeneratedCssWithFrameworkPipeline(owner: InternalUserDefinedOptions, generated: GenerateCssByGeneratorResult, options: {
+    cssHandlerOptions: IStyleHandlerOptions;
+    file: string;
+    majorVersion: number;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+}): Promise<string>;

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

@@ -0,0 +1,18 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { InternalUserDefinedOptions } from '../../../../types';
+export declare function hasMiniProgramTailwindV4PreflightReset(css: string): boolean;
+export declare function finalizeMiniProgramGeneratorCss(css: string, target: string, _majorVersion: number | undefined, cssPreflight: InternalUserDefinedOptions['cssPreflight'], options?: {
+    injectPreflight?: boolean;
+    preservePreflight?: boolean;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
+}): string;
+export declare function resolveMiniProgramPreflightModeForGeneratorCss(opts: InternalUserDefinedOptions, options: {
+    cssHandlerOptions: IStyleHandlerOptions;
+    isolateCurrentCssCandidates: boolean;
+    localImports?: string | undefined;
+    primaryCssSource?: boolean | undefined;
+    explicitCssSource?: boolean | undefined;
+}): {
+    inject: boolean;
+    preserve: boolean;
+};

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

@@ -0,0 +1,25 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { createWeappTailwindcssGenerator } from '../../../../generator';
+export declare function shouldFinalizeMarkedUserLayerComponentsCss(file: string): boolean;
+export declare function splitRawSourceByGeneratedCssOrder(rawSource: string, rawTailwindCss: string): {
+    before: string;
+    after: string;
+} | undefined;
+export declare function shouldUseGeneratorForCurrentCss(_majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
+    forceGenerator?: boolean | undefined;
+    hasGeneratedCss: boolean;
+    hasGeneratedMarkers: boolean;
+    hasSourceDirectives: boolean;
+    rawSource: string;
+    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: import("@/generator").WeappTailwindcssGeneratorTarget;
+    rawCss: string;
+}) | undefined;
+type GeneratorResult = Awaited<ReturnType<ReturnType<typeof createWeappTailwindcssGenerator>['generate']>>;
+export {};

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

@@ -0,0 +1,30 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorResolvedSource } from '../source-resolver';
+import type { TailwindSourceEntry } from '../../../../tailwindcss/source-scan';
+import type { InternalUserDefinedOptions } from '../../../../types';
+export declare function mergeScopedRuntimeWithCurrentRuntime(scopedRuntime: Set<string>, runtime: Set<string>, options: {
+    currentCssCandidates?: string[] | undefined;
+    cssHandlerOptions: IStyleHandlerOptions;
+    isolateCssSource: boolean;
+    majorVersion?: number | undefined;
+    matchedCssSourceFile: boolean;
+}): Set<string>;
+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: {
+    hasSourceDirectives: boolean;
+    hasMatchedCssSourceFile: boolean;
+}): target is "web";
+export declare function isEmptyCssSourceOrderParts(parts: {
+    before: string;
+    after: string;
+}): boolean;
+export declare function resolveGeneratorStyleOptions(opts: InternalUserDefinedOptions, cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Partial<IStyleHandlerOptions>;

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

@@ -0,0 +1,2 @@
+export declare function createCssSourceOrderAppend(base: string, extra: string): string;
+export declare function deduplicateGeneratedCssRules(css: string): string;

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

@@ -1,72 +1,4 @@
-import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
-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 hasMiniProgramTailwindV4PreflightReset(css: string): boolean;
-export declare function finalizeMiniProgramGeneratorCss(css: string, target: string, _majorVersion: number | undefined, cssPreflight: InternalUserDefinedOptions['cssPreflight'], options?: {
-    injectPreflight?: boolean;
-    preservePreflight?: boolean;
-    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
-}): string;
-export declare function resolveMiniProgramPreflightModeForGeneratorCss(opts: InternalUserDefinedOptions, options: {
-    cssHandlerOptions: IStyleHandlerOptions;
-    isolateCurrentCssCandidates: boolean;
-    localImports?: string | undefined;
-    primaryCssSource?: boolean | undefined;
-    explicitCssSource?: boolean | undefined;
-}): {
-    inject: boolean;
-    preserve: boolean;
-};
-export declare function mergeScopedRuntimeWithCurrentRuntime(scopedRuntime: Set<string>, runtime: Set<string>, options: {
-    currentCssCandidates?: string[] | undefined;
-    cssHandlerOptions: IStyleHandlerOptions;
-    isolateCssSource: boolean;
-    majorVersion?: number | undefined;
-    matchedCssSourceFile: boolean;
-}): Set<string>;
-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: {
-    hasSourceDirectives: boolean;
-    hasMatchedCssSourceFile: boolean;
-}): target is "web";
-export declare function isEmptyCssSourceOrderParts(parts: {
-    before: string;
-    after: string;
-}): boolean;
-export declare function resolveGeneratorStyleOptions(opts: InternalUserDefinedOptions, cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Partial<IStyleHandlerOptions>;
-export declare function createCssSourceOrderAppend(base: string, extra: string): string;
-export declare function deduplicateGeneratedCssRules(css: string): string;
-export declare function shouldFinalizeMarkedUserLayerComponentsCss(file: string): boolean;
-export declare function splitRawSourceByGeneratedCssOrder(rawSource: string, rawTailwindCss: string): {
-    before: string;
-    after: string;
-} | undefined;
-export declare function shouldUseGeneratorForCurrentCss(_majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
-    forceGenerator?: boolean | undefined;
-    hasGeneratedCss: boolean;
-    hasGeneratedMarkers: boolean;
-    hasSourceDirectives: boolean;
-    rawSource: string;
-    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: import("@/generator").WeappTailwindcssGeneratorTarget;
-    rawCss: string;
-}) | undefined;
-type GeneratorResult = Awaited<ReturnType<ReturnType<typeof createWeappTailwindcssGenerator>['generate']>>;
-export {};
+export { finalizeMiniProgramGeneratorCss, hasMiniProgramTailwindV4PreflightReset, resolveMiniProgramPreflightModeForGeneratorCss } from './generation-helpers/preflight';
+export { createRuntimeWithCurrentCssCandidates, hasGeneratorSourceDirectives, mergeGeneratorResults, shouldFinalizeMarkedUserLayerComponentsCss, shouldUseGeneratorForCurrentCss, splitRawSourceByGeneratedCssOrder } from './generation-helpers/results';
+export { isEmptyCssSourceOrderParts, mergeScopedRuntimeWithCurrentRuntime, resolveGeneratorStyleOptions, shouldAppendWebBundleCssFallback, shouldIsolateCurrentTailwindV4CssCandidates, shouldIsolateScopedCssSource, shouldScanTailwindV4Sources } from './generation-helpers/runtime-isolation';
+export { createCssSourceOrderAppend, deduplicateGeneratedCssRules } from './generation-helpers/source-order';

package/dist/bundlers/shared/generator-css/legacy-compat.d.ts

@@ -3,5 +3,7 @@ import type { TailwindResolvedSource } from '../../../generator';
 import type { InternalUserDefinedOptions } from '../../../types';
 export declare function removeTailwindApplyRules(rawSource: string): string;
 export declare function hasConfiguredContainerCompatSources(sources: TailwindResolvedSource[]): boolean;
-export declare function appendLegacyCompatCss(css: string, rawSource: string, generatorTarget: string, styleHandler: InternalUserDefinedOptions['styleHandler'], cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Promise<string>;
+export declare function appendLegacyCompatCss(css: string, rawSource: string, generatorTarget: string, styleHandler: InternalUserDefinedOptions['styleHandler'], cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined, options?: {
+    preserveSelectorOverrides?: boolean | undefined;
+}): Promise<string>;
 export declare function appendLegacyContainerCompatCss(css: string, rawSource: string, file: string, runtime: Set<string>, configuredContainerCompat: boolean, generatorTarget: string, styleHandler: InternalUserDefinedOptions['styleHandler'], cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Promise<string>;

package/dist/bundlers/shared/generator-css/pipeline/deferred-output.d.ts

@@ -0,0 +1,14 @@
+export declare function finalizeDeferredGeneratorCss(context: any): Promise<{
+    css: string;
+    classSet: Set<string>;
+    target: any;
+    source: string;
+    dependencies: any;
+    incremental: boolean;
+    metadata: {
+        file: any;
+        majorVersion: any;
+        preflightMode: any;
+        rawCss: any;
+    };
+} | undefined>;

package/dist/bundlers/shared/generator-css/pipeline/execution.d.ts

@@ -0,0 +1,12 @@
+export declare function executeGeneratorPipeline(context: any): Promise<{
+    css: any;
+    classSet: Set<string>;
+    target: any;
+    source: string;
+    dependencies: any;
+    metadata: {
+        file: any;
+        majorVersion: any;
+        rawCss: any;
+    };
+} | undefined>;

package/dist/bundlers/shared/generator-css/pipeline/fallback-output.d.ts

@@ -0,0 +1,12 @@
+export declare function finalizeFallbackGeneratorCss(context: any): Promise<{
+    css: any;
+    classSet: Set<string>;
+    target: any;
+    source: string;
+    dependencies: any;
+    metadata: {
+        file: any;
+        majorVersion: any;
+        rawCss: any;
+    };
+}>;

package/dist/bundlers/shared/generator-css/pipeline/ordered-output.d.ts

@@ -0,0 +1,25 @@
+export declare function finalizeOrderedGeneratorCss(context: any): Promise<{
+    css: string;
+    classSet: Set<string>;
+    target: any;
+    source: string;
+    dependencies: any;
+    incremental: boolean;
+    metadata: {
+        file: any;
+        majorVersion: any;
+        rawCss: any;
+    };
+} | {
+    css: any;
+    classSet: Set<string>;
+    target: any;
+    source: string;
+    dependencies: any;
+    metadata: {
+        file: any;
+        majorVersion: any;
+        rawCss: any;
+    };
+    incremental?: never;
+} | undefined>;

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

@@ -0,0 +1,2 @@
+import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './types';
+export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

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

@@ -0,0 +1,6 @@
+import type { normalizeWeappTailwindcssGeneratorOptions } from '../../../generator';
+import { finalizeMiniProgramGeneratorCss } from './generation-helpers';
+export declare function isCssAlreadyRepresentedByMarkers(css: string, source: string): boolean;
+export declare function resolveGeneratedCssClassSet(target: string, classSet: Set<string>, candidates: Iterable<string>, css: string, escapeMap: Record<string, string> | undefined, previousClassSet?: Set<string> | undefined): Set<string>;
+export declare function finalizeWebGeneratorCss(css: string, target: string, webCompat: ReturnType<typeof normalizeWeappTailwindcssGeneratorOptions>['webCompat']): string;
+export declare function finalizeIncrementalGeneratorCss(previousCss: string, incrementalCss: string, target: string, majorVersion: number | undefined, cssPreflight: Parameters<typeof finalizeMiniProgramGeneratorCss>[3], options: Parameters<typeof finalizeMiniProgramGeneratorCss>[4], webCompat: ReturnType<typeof normalizeWeappTailwindcssGeneratorOptions>['webCompat']): string;

package/dist/bundlers/shared/generator-css/scoped-rules.d.ts

@@ -0,0 +1 @@
+export declare function preferScopedGeneratedCssRules(css: string): string;

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

@@ -0,0 +1,33 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorResolvedSource } from './metadata';
+import type { GeneratorSourceRuntimeState, SourceStyleMatchOptions, TailwindV4CssSource, TailwindV4SourceOptions } from './types';
+import type { TailwindResolvedSource } from '../../../../generator';
+export declare function createCssEntrySources(cssEntries: string[] | undefined): {
+    file: string;
+}[] | undefined;
+export declare function mergeCssSources(cssSources: TailwindV4CssSource[] | undefined, cssEntrySources: TailwindV4CssSource[] | undefined): import("@tailwindcss-mangle/engine").TailwindV4CssSource[] | undefined;
+export declare function createSingleTailwindV4SourceOptions(sourceOptions: TailwindV4SourceOptions, options: {
+    base: string;
+    css: string;
+    cssEntries?: string[] | undefined;
+}): Partial<{
+    projectRoot: string;
+    baseFallbacks: string[];
+    packageName: string;
+    base: string;
+    css: string;
+    cssEntries: string[];
+}>;
+export declare function resolveTailwindV4CssEntrySource(cssEntry: string, sourceOptions: TailwindV4SourceOptions, options?: {
+    candidateMatched?: boolean | undefined;
+    includesPreflight?: boolean | undefined;
+    index?: number | undefined;
+}): Promise<GeneratorResolvedSource>;
+export declare function canResolveSourceSideCssEntry(file: string, cssHandlerOptions: IStyleHandlerOptions, sourceOptions?: Pick<SourceStyleMatchOptions, 'sourceFile' | 'cssSources' | 'outputRoot'>): boolean;
+export declare function shouldResolveSourceSideCssEntry(rawSource: string): boolean;
+export declare function normalizeTailwindV4CssSourceConfig(cssSource: TailwindV4CssSource, sourceBase: string): import("@tailwindcss-mangle/engine").TailwindV4CssSource;
+export declare function normalizeResolvedTailwindV4SourceConfig<T extends TailwindResolvedSource>(source: T, file: string | undefined, sourceOptions: TailwindV4SourceOptions | undefined): T;
+export declare function normalizeTailwindV4CssSourceConfigs(sourceOptions: TailwindV4SourceOptions): TailwindV4SourceOptions;
+export declare function tryResolveTailwindV4SourceOptions(runtimeState: GeneratorSourceRuntimeState): TailwindV4SourceOptions | undefined;
+export declare function hasConfiguredTailwindV4CssSource(sourceOptions: TailwindV4SourceOptions | undefined): boolean;
+export declare function isSameTailwindV4CssSource(a: TailwindV4CssSource | undefined, b: TailwindV4CssSource | undefined): boolean;

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

@@ -0,0 +1,4 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './types';
+import type { NormalizedWeappTailwindcssGeneratorOptions } from '../../../../generator';
+export declare function resolveGeneratorSource(_majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("@/generator").TailwindV4ResolvedSource>;

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

@@ -0,0 +1,4 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './types';
+import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../../../generator';
+export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<TailwindResolvedSource[]>;

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

@@ -0,0 +1,16 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { resolveSourceSideCssEntrySource } from '../source-files';
+import type { GeneratorSourceSelectionOptions, TailwindV4CssSource, TailwindV4SourceOptions } from './types';
+import type { NormalizedWeappTailwindcssGeneratorOptions, resolveTailwindV4SourceOptionsFromRuntime } from '../../../../generator';
+export declare function resolveSingleTailwindV4CssSource(cssSource: TailwindV4CssSource, sourceOptions: TailwindV4SourceOptions, options?: {
+    includesPreflight?: boolean | undefined;
+    index?: number | undefined;
+    matched?: boolean;
+    primary?: boolean | undefined;
+}): Promise<import("./metadata").GeneratorResolvedSource>;
+export declare function resolveTailwindV4CssSourceEntries(cssSource: TailwindV4CssSource, sourceOptions: TailwindV4SourceOptions): Promise<import("@/bundlers/vite/source-scan").ResolvedTailwindV4CssEntries | undefined>;
+export declare function resolveCandidateMatchedTailwindV4CssSource(_rawSource: string, _cssHandlerOptions: IStyleHandlerOptions, sourceOptions: TailwindV4SourceOptions, selectionOptions: GeneratorSourceSelectionOptions | undefined): Promise<import("./metadata").GeneratorResolvedSource | undefined>;
+export declare function resolveTailwindV4CssEntryIncludesPreflight(cssEntry: string): Promise<boolean | undefined>;
+export declare function resolveCandidateMatchedTailwindV4CssEntry(sourceOptions: TailwindV4SourceOptions, selectionOptions: GeneratorSourceSelectionOptions | undefined): Promise<import("./metadata").GeneratorResolvedSource | undefined>;
+export declare function createTailwindV4CssSourceResolver(sourceOptions: TailwindV4SourceOptions, generatorOptions: NormalizedWeappTailwindcssGeneratorOptions | undefined): (cssSource: NonNullable<typeof sourceOptions.cssSources>[number], index: number) => Promise<import("./metadata").GeneratorResolvedSource>;
+export declare function resolveTailwindV4SourceSideEntrySource(resolvedEntrySource: ReturnType<typeof resolveSourceSideCssEntrySource>, sourceOptions: ReturnType<typeof resolveTailwindV4SourceOptionsFromRuntime>, generatorOptions: NormalizedWeappTailwindcssGeneratorOptions | undefined, file: string): Promise<import("@/generator").TailwindV4ResolvedSource | undefined>;

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

@@ -0,0 +1,3 @@
+import type { GeneratorSourceRuntimeState } from './types';
+import type { TailwindResolvedSource } from '../../../../generator';
+export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<import("../../../../tailwindcss/source-scan").TailwindSourceEntry[] | undefined>;

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

@@ -0,0 +1,5 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceSelectionOptions, TailwindV4SourceOptions } from './types';
+import type { resolveTailwindV4SourceOptionsFromRuntime } from '../../../../generator';
+export declare function resolveMatchingTailwindV4CssEntry(rawSource: string, file: string, sourceOptions: ReturnType<typeof resolveTailwindV4SourceOptionsFromRuntime>): Promise<import("./metadata").GeneratorResolvedSource | undefined>;
+export declare function resolveMatchingTailwindV4CssSource(rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, sourceOptions: TailwindV4SourceOptions, selectionOptions?: GeneratorSourceSelectionOptions | undefined): Promise<import("./metadata").GeneratorResolvedSource | undefined>;

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

@@ -1,9 +1,6 @@
-import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
-import type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './source-resolver/types';
-import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../../generator';
 export type { GeneratorResolvedSource, GeneratorSourceMetadata } from './source-resolver/metadata';
 export { resolveCssSourceBase } from './source-resolver/postcss-source';
+export { resolveGeneratorSource } from './source-resolver/resolve-source';
+export { resolveGeneratorSources } from './source-resolver/resolve-sources';
+export { resolveGeneratorSourceEntries } from './source-resolver/source-entries';
 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").TailwindV4ResolvedSource>;
-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<import("@/tailwindcss/source-scan").TailwindSourceEntry[] | undefined>;

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

@@ -0,0 +1,9 @@
+export declare function normalizeEmptyTailwindCustomVariants(css: string): string;
+export declare function filterApplyOnlyGeneratedCss(css: string, source: string, options?: {
+    preserveVariables?: boolean | undefined;
+    preferScopedRules?: boolean | undefined;
+}): string;
+export declare function shouldFilterApplyOnlyGeneratedCss(_majorVersion: number | undefined, target: string, source: string, options: {
+    hasGeneratedCss: boolean;
+    hasGeneratedMarkers: boolean;
+}): boolean;

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

@@ -0,0 +1,3 @@
+export declare function removeTailwindSourceMediaBlocks(source: string): string;
+export declare function terminateTailwindSourceAtRulesBeforeNextDirective(source: string): string;
+export declare function removeTailwindApplyAtRules(source: string): string;

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

@@ -0,0 +1,4 @@
+export declare const TAILWIND_V4_GENERATOR_AT_RULES: Set<string>;
+export declare function removeBalancedAtRuleBlock(source: string, atRuleStart: number): string;
+export declare function removeTailwindV4GeneratorAtRulesFallback(source: string): string;
+export declare function removeTailwindV4GeneratedUserCssArtifacts(source: string): string;

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

@@ -0,0 +1,9 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+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 removeProcessedMiniProgramUnsupportedCss(source: string, options: Partial<IStyleHandlerOptions>): string;
+export declare function unwrapMiniProgramCascadeLayers(source: string): string;
+export declare function collectBareSelectorUserCss(source: string): string;
+export declare function stripTailwindSourceMediaFragments(source: string): string;
+export declare function stripUnmatchedTailwindSourceMediaCloseFragments(source: string): string;

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

@@ -0,0 +1,10 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { InternalUserDefinedOptions } from '../../../../types';
+export declare function transformGeneratorUserCss(source: string, options: {
+    generatorTarget: string;
+    generatorStyleOptions: Partial<IStyleHandlerOptions>;
+    cssUserHandlerOptions: IStyleHandlerOptions;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+    importFallback: boolean;
+    processed?: boolean | undefined;
+}): Promise<string>;

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

@@ -0,0 +1,15 @@
+import { postcss } from '@weapp-tailwindcss/postcss';
+export declare function splitUserCssLayerBlocks(source: string): {
+    layer: string;
+    rest: string;
+};
+export declare function hasUserCssLayerBlocks(source: string): boolean;
+export declare function extractGeneratedCssForUserLayerSelectors(css: string, userLayerSource: string): {
+    layer: string;
+    rest: string;
+};
+export declare function normalizeGeneratedSelector(selector: string): string;
+export declare function collectApplyOnlySourceSelectors(source: string): Set<string>;
+export declare function hasOnlyApplyBackedSourceRules(source: string): boolean;
+export declare function removeCssComments(css: string): string;
+export declare function isEmptyCustomVariantBlock(rule: postcss.AtRule): boolean;

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

@@ -1,33 +1,5 @@
-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): {
-    layer: string;
-    rest: string;
-};
-export declare function hasUserCssLayerBlocks(source: string): boolean;
-export declare function extractGeneratedCssForUserLayerSelectors(css: string, userLayerSource: string): {
-    layer: string;
-    rest: string;
-};
-export declare function normalizeEmptyTailwindCustomVariants(css: string): string;
-export declare function filterApplyOnlyGeneratedCss(css: string, source: string, options?: {
-    preserveVariables?: boolean | undefined;
-}): string;
-export declare function shouldFilterApplyOnlyGeneratedCss(_majorVersion: number | undefined, target: string, source: string, options: {
-    hasGeneratedCss: boolean;
-    hasGeneratedMarkers: boolean;
-}): boolean;
-export declare function transformGeneratorUserCss(source: string, options: {
-    generatorTarget: string;
-    generatorStyleOptions: Partial<IStyleHandlerOptions>;
-    cssUserHandlerOptions: IStyleHandlerOptions;
-    styleHandler: InternalUserDefinedOptions['styleHandler'];
-    importFallback: boolean;
-    processed?: boolean | undefined;
-}): Promise<string>;
+export { filterApplyOnlyGeneratedCss, normalizeEmptyTailwindCustomVariants, shouldFilterApplyOnlyGeneratedCss } from './user-css/apply-only';
+export { removeTailwindV4GeneratedUserCssArtifacts } from './user-css/generated-cleanup';
+export { isCommentOnlyCss, removeMiniProgramHoverSelectors, removeTailwindV4GeneratorAtRules, stripTailwindSourceMediaFragments, stripUnmatchedTailwindSourceMediaCloseFragments } from './user-css/source-fragments';
+export { transformGeneratorUserCss } from './user-css/transform';
+export { extractGeneratedCssForUserLayerSelectors, hasUserCssLayerBlocks, splitUserCssLayerBlocks } from './user-css/user-layers';

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

@@ -1,10 +1,9 @@
-import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './generator-css/types';
 export { hasTailwindSourceDirectives, normalizeTailwindSourceForGenerator, removeTailwindSourceDirectives, resolveCssEntrySource, } from './generator-css/directives';
 export { removeTailwindApplyRules, } from './generator-css/legacy-compat';
 export { inheritLegacyUnitConvertedDeclarations, } from './generator-css/legacy-units';
 export { isPureLocalCssImportWrapper, } from './generator-css/local-imports';
 export { createCssAppend, hasTailwindGeneratedCss, hasTailwindGeneratedCssMarkers, removeTailwindGeneratedCssByBanner, splitGeneratorPlaceholderCssBySourceOrder, splitTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, splitTailwindV4GeneratedCssBySourceOrder, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, } from './generator-css/markers';
+export { generateCssByGenerator } from './generator-css/pipeline';
 export { resolveGeneratorSource, } from './generator-css/source-resolver';
 export type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult, } from './generator-css/types';
 export { validateCandidatesByGenerator, } from './generator-css/validate';
-export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

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

@@ -1,5 +1,8 @@
 import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './generator-css';
+import type { InternalUserDefinedOptions } from '../../types';
 export interface TailwindV4GenerationCoreInput extends GenerateCssByGeneratorOptions {
+    frameworkPostcssOwner?: InternalUserDefinedOptions | undefined;
+    frameworkPostcssStage?: 'complete' | 'pending' | undefined;
     outputFile?: string | undefined;
     sourceCandidates?: Set<string> | undefined;
 }