weapp-tailwindcss 5.1.6 → 5.1.8

package/dist/bundlers/framework-selector.d.ts

@@ -0,0 +1,26 @@
+import type { DetectableAppType, DetectAppTypeOptions } from '../framework';
+import type { AppType, UserDefinedOptions } from '../types';
+export interface ResolveBundlerFrameworkOptions extends Pick<DetectAppTypeOptions, 'cwd' | 'env' | 'manifest' | 'packageJson' | 'root' | 'searchUp'> {
+    appType?: AppType | undefined;
+    detectEnv?: boolean | undefined;
+    uniAppX?: UserDefinedOptions['uniAppX'];
+}
+export type ViteFrameworkName = 'generic' | 'taro' | 'uni-app' | 'uni-app-x' | 'weapp-vite';
+export type WebpackFrameworkName = 'generic' | 'mpx' | 'taro' | 'uni-app' | 'weapp-vite';
+export type GulpFrameworkName = 'native';
+export interface BundlerFrameworkProfile<Name extends string> {
+    appType?: AppType | DetectableAppType | undefined;
+    frameworkName: Name;
+}
+export type ViteFrameworkProfile = BundlerFrameworkProfile<ViteFrameworkName>;
+export type WebpackFrameworkProfile = BundlerFrameworkProfile<WebpackFrameworkName>;
+export type GulpFrameworkProfile = BundlerFrameworkProfile<GulpFrameworkName>;
+export interface BundlerFrameworkState<Profile, Options> {
+    current: () => Profile;
+    refresh: (options?: Partial<Options>) => Profile;
+}
+export declare function resolveBundlerAppType(options: ResolveBundlerFrameworkOptions): AppType | DetectableAppType | undefined;
+export declare function resolveViteFrameworkProfile(options: ResolveBundlerFrameworkOptions): ViteFrameworkProfile;
+export declare function resolveWebpackFrameworkProfile(options: ResolveBundlerFrameworkOptions): WebpackFrameworkProfile;
+export declare function resolveGulpFrameworkProfile(options: ResolveBundlerFrameworkOptions): GulpFrameworkProfile;
+export declare function createViteFrameworkProfileState(options: ResolveBundlerFrameworkOptions): BundlerFrameworkState<ViteFrameworkProfile, ResolveBundlerFrameworkOptions>;

package/dist/bundlers/gulp/frameworks/native/index.d.ts

@@ -0,0 +1,6 @@
+import type { UserDefinedOptions } from '../../../../types';
+export declare function createNativeGulpFrameworkPlugins(options?: UserDefinedOptions): {
+    transformWxss: (options?: Partial<import("@weapp-tailwindcss/postcss").IStyleHandlerOptions>) => import("node:stream").Transform;
+    transformWxml: (options?: Partial<import("@/types").ITemplateHandlerOptions>) => import("node:stream").Transform;
+    transformJs: (options?: Partial<import("@/types").CreateJsHandlerOptions>) => import("node:stream").Transform;
+};

package/dist/bundlers/gulp/index.d.ts

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

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

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

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

@@ -1,5 +1,6 @@
 import type { OutputAsset } from 'rollup';
 import type { Plugin, ResolvedConfig } from 'vite';
+import type { ViteFrameworkCssPipelineStrategy } from './shared/framework-strategy';
 import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface RememberedMainCssSource {
@@ -13,6 +14,7 @@ interface CssFinalizerContext {
         readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
     isCssAssetProcessed: (asset: OutputAsset, file?: string) => boolean;
     markCssAssetProcessed: (asset: OutputAsset, file?: string) => void;
     debug: (format: string, ...args: unknown[]) => void;

package/dist/bundlers/vite/frameworks/generic/index.d.ts

@@ -0,0 +1,2 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+export declare function createGenericVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/frameworks/taro/index.d.ts

@@ -0,0 +1,2 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+export declare function createTaroVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): any[];

package/dist/bundlers/vite/frameworks/uni-app/index.d.ts

@@ -0,0 +1,2 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+export declare function createUniAppVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/frameworks/uni-app-x/index.d.ts

@@ -0,0 +1,2 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+export declare function createUniAppXVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/frameworks/weapp-vite/index.d.ts

@@ -0,0 +1,2 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+export declare function createWeappVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;

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

@@ -1,4 +1,5 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
 import type { InternalUserDefinedOptions } from '../../../types';
 export declare function resolveCssBundleOutputFile(options: {
     bundleFiles: string[];
@@ -6,6 +7,8 @@ export declare function resolveCssBundleOutputFile(options: {
     file: string;
     isWebGeneratorTarget: boolean;
     opts: InternalUserDefinedOptions;
+    pipelineContext: ViteFrameworkCssPipelineContext;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
     shouldPreserveAppCssExtension: boolean;
 }): string;
 export declare function shouldSkipRawSourceStyleAsset(outputFile: string, file: string, rawSource: string, assetSourceFile?: string, cssMatcher?: ((file: string) => boolean) | undefined): boolean;
@@ -35,5 +38,6 @@ export declare function applyCssResultToBundle(options: {
     outputFile: string;
     source: string;
     viteProcessedCssAsset: boolean;
-    appType: unknown;
+    pipelineContext: ViteFrameworkCssPipelineContext;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
 }): void;

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

@@ -1,5 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { BundleBuildState, BundleSnapshot } from '../bundle-state';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
 import type { BundleMetrics } from './metrics';
 import type { GenerateBundleContext } from './types';
 interface FinalizeGenerateBundleOptions {
@@ -10,6 +11,8 @@ interface FinalizeGenerateBundleOptions {
     bundleFiles: string[];
     cache: GenerateBundleContext['opts']['cache'];
     cssTaskFactories: Array<() => Promise<void>>;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
     debug: GenerateBundleContext['debug'];
     defaultStyleOutputExtension: string;
     formatIteration: number;
@@ -57,8 +60,9 @@ interface FinalizeGenerateBundleOptions {
     transformWebTargetCss?: ((css: string, file: string) => string) | undefined;
     useIncrementalMode: boolean;
 }
-export declare function normalizeTaroRootImportShellAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<GenerateBundleContext['opts'], 'appType' | 'cssMatcher'> & {
+export declare function normalizeRootMiniProgramImportShellAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<GenerateBundleContext['opts'], 'cssMatcher'> & {
     debug: GenerateBundleContext['debug'];
+    enabled: boolean;
     onUpdate: GenerateBundleContext['opts']['onUpdate'];
     recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
 }): number;

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

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

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

@@ -1,8 +1,16 @@
 import type { OutputChunk } from 'rollup';
 import type { BundleSnapshot } from '../bundle-state';
 import type { RememberedCssSource } from './types';
+export interface SfcStyleBlock {
+    attrs: string;
+    index: number;
+    scoped: boolean;
+    source: string;
+}
+export declare function extractSfcStyleBlocks(source: string): SfcStyleBlock[];
 export declare function extractSfcStyleSources(source: string): string[];
 export declare function hasSfcStyleSources(source: string): boolean;
+export declare function resolveSfcStyleRequestFromKnownSource(sourceFile: string, sfcSource: string | undefined, styleSource: string): string;
 export declare function hasTailwindGenerationSource(source: string, options?: {
     allowRootDirectives?: boolean | undefined;
 }): boolean;

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

@@ -2,6 +2,7 @@ import type { OutputAsset } from 'rollup';
 import type { ResolvedConfig } from 'vite';
 import type { HmrTimingRecorder } from '../../shared/hmr-timing';
 import type { BundleSnapshot } from '../bundle-state';
+import type { ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
 import type { SourceCandidateFilterOptions } from '../source-candidates';
 import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
@@ -58,6 +59,7 @@ export interface GenerateBundleContext {
     }) => void;
     getViteCssCacheStats?: () => Record<string, unknown>;
     hmrTimingRecorder?: HmrTimingRecorder;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
 }
 export interface RememberedCssSource {
     outputFile: string;

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

@@ -1,6 +1,4 @@
+import type { WeappTailwindcssVitePlugin } from './shared/create-framework-plugins';
 import type { UserDefinedOptions } from '../../types';
-export interface WeappTailwindcssVitePlugin {
-    name: string;
-    [hook: string]: any;
-}
+export type { WeappTailwindcssVitePlugin } from './shared/create-framework-plugins';
 export declare function WeappTailwindcss(options?: UserDefinedOptions): WeappTailwindcssVitePlugin[] | undefined;

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

@@ -1,4 +1,5 @@
 import type { OutputAsset, OutputBundle } from 'rollup';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from './shared/framework-strategy';
 import type { InternalUserDefinedOptions } from '../../types';
 interface CssAssetMarkerMatcher {
     (asset: OutputAsset, file?: string): boolean;
@@ -22,6 +23,8 @@ interface CssAssetResultsGetter {
 }
 interface CollectViteProcessedCssAssetOptions {
     opts?: InternalUserDefinedOptions | undefined;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
     isViteProcessedCssAsset?: CssAssetMarkerMatcher | undefined;
     markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
     recordCssAssetResult?: CssAssetResultRecorder | undefined;
@@ -33,6 +36,8 @@ interface CollectViteProcessedCssAssetOptions {
 }
 interface InjectViteProcessedCssAssetOptions {
     opts: InternalUserDefinedOptions;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
     getViteProcessedCssAssetResults?: CssAssetResultsGetter | undefined;
     markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
     recordCssAssetResult?: CssAssetResultRecorder | undefined;

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

@@ -0,0 +1,35 @@
+import type { Plugin, ResolvedConfig } from 'vite';
+import type { ViteFrameworkName } from '../../framework-selector';
+import type { ViteFrameworkCssPipelineStrategy, ViteFrameworkExtraPluginPlatform, ViteFrameworkRuntimeFeatureContext } from './framework-strategy';
+import type { ViteStyleInjectorDelegateFactory } from '../../../style-injector/internal';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
+import { getCompilerContext } from '../../../context';
+import { toCustomAttributesEntities } from '../../../context/custom-attributes';
+import { createViteRuntimeClassSet } from '../runtime-class-set';
+export interface WeappTailwindcssVitePlugin {
+    name: string;
+    [hook: string]: any;
+}
+export interface ViteFrameworkBranchContext {
+    frameworkName: ViteFrameworkName;
+    createExtraPlugins?: (context: ViteFrameworkExtraPluginContext) => Plugin[];
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    getExtraPluginPlatform?: () => ViteFrameworkExtraPluginPlatform;
+    styleInjectorDelegate: ViteStyleInjectorDelegateFactory;
+    isRuntimeClassSetFeatureEnabled?: (context: ViteFrameworkRuntimeFeatureContext) => boolean;
+}
+export interface ViteFrameworkExtraPluginContext {
+    customAttributesEntities: ReturnType<typeof toCustomAttributesEntities>;
+    disabledDefaultTemplateHandler: boolean | undefined;
+    ensureRuntimeClassSet: (...args: any[]) => Promise<Set<string>>;
+    generateCss: (...args: any[]) => Promise<string | undefined>;
+    getResolvedConfig: () => ResolvedConfig | undefined;
+    isEnabled: () => boolean;
+    isIosPlatform: boolean;
+    jsHandler: ReturnType<typeof getCompilerContext>['jsHandler'];
+    mainCssChunkMatcher: ReturnType<typeof getCompilerContext>['mainCssChunkMatcher'];
+    runtimeState: ReturnType<typeof createViteRuntimeClassSet>['runtimeState'];
+    styleHandler: ReturnType<typeof getCompilerContext>['styleHandler'];
+    uniAppX: ReturnType<typeof getCompilerContext>['uniAppX'];
+}
+export declare function createViteFrameworkPlugins(options: (UserDefinedOptions | InternalUserDefinedOptions) | undefined, frameworkBranch: ViteFrameworkBranchContext): WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/shared/framework-strategy.d.ts

@@ -0,0 +1,88 @@
+import type { OutputBundle } from 'rollup';
+import type { ResolvedConfig } from 'vite';
+import type { getCompilerContext } from '../../../context';
+import type { normalizeWeappTailwindcssGeneratorOptions } from '../../../generator';
+import type { resolveGeneratorRuntimeBranch } from '../../../runtime-branch';
+import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types';
+export interface ViteFrameworkExtraPluginPlatform {
+    isIosPlatform?: boolean | undefined;
+}
+export interface ViteFrameworkRuntimeFeatureContext {
+    uniAppX: ReturnType<typeof getCompilerContext>['uniAppX'];
+}
+export interface ViteFrameworkCssPipelineContext {
+    bundle?: OutputBundle | undefined;
+    currentGeneratorBranch: ReturnType<typeof resolveGeneratorRuntimeBranch>;
+    currentGeneratorOptions: ReturnType<typeof normalizeWeappTailwindcssGeneratorOptions>;
+    opts: InternalUserDefinedOptions;
+    resolvedConfig: ResolvedConfig | undefined;
+    resolveStylePlatform: () => string | undefined;
+}
+export interface ViteFrameworkCssPipelineStrategy {
+    getCssHandlerExtraOptions?: (context: ViteFrameworkCssPipelineContext & {
+        file: string;
+    }) => Record<string, unknown>;
+    getServeJsHandlerOptions?: (context: ViteFrameworkCssPipelineContext & {
+        file: string;
+    }) => CreateJsHandlerOptions | undefined;
+    includeTailwindGeneratedCssAssetsInRootCoverage?: (context: ViteFrameworkCssPipelineContext & {
+        bundleFiles: string[];
+        isWebGeneratorTarget: boolean;
+        outDir: string;
+    }) => boolean;
+    isHarmonyAppStyleTarget?: (context: ViteFrameworkCssPipelineContext) => boolean;
+    isNativeAppStyleTarget?: (context: ViteFrameworkCssPipelineContext) => boolean;
+    resolveConfiguredCssEntryRootInjectionTarget?: (context: ViteFrameworkCssPipelineContext & {
+        bundle: OutputBundle;
+        isConfiguredCssEntryFile: (file: string | undefined) => boolean;
+        isMiniProgramStyleOutputFile: (file: string) => boolean;
+        isRootStyleOutputFile: (file: string) => boolean;
+        outputFile: string;
+        sourceFile: string | undefined;
+    }) => string | undefined;
+    shouldApplyFinalWebviewCssCompat?: (context: ViteFrameworkCssPipelineContext & {
+        bundleFiles: string[];
+        isWebGeneratorTarget: boolean;
+        outDir: string;
+    }) => boolean;
+    shouldApplyWebCssCompat?: (context: ViteFrameworkCssPipelineContext) => boolean;
+    shouldDeferEmptyScopedCssSource?: (context: ViteFrameworkCssPipelineContext & {
+        cssHandlerOptions: {
+            isMainChunk?: boolean | undefined;
+        };
+        generatorCode: string;
+    }) => boolean;
+    shouldKeepRootMiniProgramStyleAsImportShell?: (context: ViteFrameworkCssPipelineContext & {
+        css: string;
+        file: string;
+    }) => boolean;
+    shouldMoveRootMiniProgramStyleToImportShellOrigin?: (context: ViteFrameworkCssPipelineContext & {
+        file: string;
+    }) => boolean;
+    shouldNormalizeRootMiniProgramImportShell?: (context: ViteFrameworkCssPipelineContext) => boolean;
+    shouldPreferExplicitWebCssTargets?: (context: ViteFrameworkCssPipelineContext & {
+        explicitRootTargets: string[];
+        explicitWebCssTargets: string[];
+        file: string;
+    }) => boolean;
+    shouldPreferMatchedRootWebOutputTarget?: (context: ViteFrameworkCssPipelineContext & {
+        file: string;
+        matchedRootWebOutputTargets: string[];
+    }) => boolean;
+    shouldPreserveStyleOutputExtension?: (context: ViteFrameworkCssPipelineContext) => boolean;
+    shouldSelectConfiguredCssEntryRootSource?: (context: ViteFrameworkCssPipelineContext & {
+        isRootStyleOutputFile: (file: string) => boolean;
+        outputFile: string;
+    }) => boolean;
+    shouldRemoveDuplicateUnlinkedRootCssAssetsReferencedByHtml?: (context: ViteFrameworkCssPipelineContext & {
+        bundleFiles: string[];
+        isWebGeneratorTarget: boolean;
+        outDir: string;
+    }) => boolean;
+    shouldTransformServeJs?: (context: ViteFrameworkCssPipelineContext) => boolean;
+    transformGeneratedCss?: (css: string, context: ViteFrameworkCssPipelineContext & {
+        defaultWebCssCompat: (css: string) => string;
+        removeScopedPreflight: (css: string) => string;
+        shouldApplyWebCssCompat: boolean;
+    }) => string;
+}

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

@@ -1,7 +1,6 @@
-import type { AppType } from '../../../types';
 export declare function getCacheKey(filename: string): string;
 export declare function stripResourceQuery(resource?: string): string | undefined;
-export declare function isCssLikeModuleResource(resource: string | undefined, cssMatcher: (file: string) => boolean, appType?: AppType): boolean;
+export declare function isCssLikeModuleResource(resource: string | undefined, cssMatcher: (file: string) => boolean): boolean;
 export declare function hasLoaderEntry(entries: Array<{
     loader?: string;
 }>, target?: string): boolean;

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

@@ -28,6 +28,7 @@ export interface WebpackSourceCandidateCache {
 export declare function isRuntimeTransformCandidate(candidate: string): boolean;
 export declare function collectRuntimeTokenSignatureParts(source: string): [] | RegExpMatchArray;
 export declare function hasMissingRuntimeCandidates(classSet: ReadonlySet<string> | undefined, candidates: ReadonlySet<string> | undefined): boolean;
+export declare function hasStaleRuntimeCandidates(classSet: ReadonlySet<string> | undefined, candidates: ReadonlySet<string> | undefined): boolean;
 export declare function resolveGeneratedCssRuntimeCandidates(source: string, fallbackClassSet?: ReadonlySet<string> | undefined): ReadonlySet<string>;
 export declare function getRuntimeClassSetSync(tailwindRuntime: TailwindcssRuntimeLike): Set<string>;
 export declare function toMb(bytes: number): number;
@@ -35,6 +36,13 @@ export declare function pruneMapToMaxSize<Key, Value>(map: Map<Key, Value>, maxS
 export declare function stripTrailingLineWhitespace(source: string): string;
 export declare function pruneWebpackCssHandlerOptionCaches(cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>, cssUserHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>, activeCssFiles: Set<string>): void;
 export declare function resolveWebpackGeneratorRawSource(rawSource: string, cssHandlerOptions: WebpackCssHandlerOptions): string;
+export declare function shouldConsumeWebpackLoaderGeneratedCss(options: {
+    hasBundlerGeneratedCssMarker: boolean;
+    loaderGeneratedClassSet?: Set<string> | undefined;
+    sourceCandidates?: Set<string> | undefined;
+    shouldRegenerateExplicitTailwindV4CssSource: boolean;
+    watchMode?: boolean | undefined;
+}): boolean;
 export interface WebpackGeneratorUserCssSource {
     css: string;
     processed: boolean;
@@ -49,6 +57,7 @@ export declare function shouldUseWebpackAssetAsGeneratorUserCss(rawSource: strin
     processed?: boolean | undefined;
 }): boolean;
 export declare function collectWebpackAssetUserCssMarkers(source: string): Set<string>;
+export declare function collectWebpackBareSelectorUserCss(source: string): string;
 export declare function parseWebpackCssLayerNames(params: string): string[];
 export declare function removeWebpackTailwindGeneratedAssetCss(source: string): string;
 export declare function collectWebpackCssRuleIdentityMarkers(source: string): Set<string>;
@@ -58,6 +67,8 @@ export declare function hasAdditionalWebpackAssetUserCssMarkers(rawSource: strin
 export declare function hasWebpackTailwindSourceDirectives(source: string | undefined): boolean;
 export declare function isWebpackTailwindImportRequest(request: string | undefined): boolean | undefined;
 export declare function removeWebpackGeneratorNonTailwindImports(source: string | undefined): string | undefined;
+export declare function removeWebpackUserCssFallbackImports(source: string): string;
+export declare function normalizeWebpackUserCssFallbackSource(source: string): string;
 export declare function isWebpackCssSourceRepresentedInAsset(rawSource: string, sourceCss: string | undefined): boolean;
 export declare function createWebpackGeneratorCssSource(file: string | undefined, css: string | undefined): {
     file: string;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-loaders.d.ts

@@ -1,6 +1,7 @@
 import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { Compiler } from 'webpack';
 import type { WebpackCssSourceRegistration, WebpackGeneratedCssRegistration } from '../loaders/runtime-registry';
+import type { LoaderAnchorFinders } from '../shared/loader-anchors';
 import type { TailwindRuntimeState } from '../../../tailwindcss/runtime';
 import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5LoadersOptions {
@@ -22,6 +23,8 @@ interface SetupWebpackV5LoadersOptions {
         files: ReadonlySet<string>;
         contexts: ReadonlySet<string>;
     };
+    loaderAnchorFinders?: LoaderAnchorFinders | undefined;
+    mpxCssImportRewrite?: boolean | undefined;
     runtimeRegistryKey?: string | undefined;
     debug: (format: string, ...args: unknown[]) => void;
 }

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

@@ -1,10 +1,9 @@
 import type { Compiler } from 'webpack';
 import type { AppType, IBaseWebpackPlugin, InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
-export declare const weappTailwindcssPackageDir: string;
+export { weappTailwindcssPackageDir } from '../shared/create-framework-plugin';
 export declare class WeappTailwindcss implements IBaseWebpackPlugin {
     options: InternalUserDefinedOptions;
     appType?: AppType;
-    private hasInitialTailwindCssRoots;
     constructor(options?: UserDefinedOptions);
     apply(compiler: Compiler): void;
 }

package/dist/bundlers/webpack/frameworks/generic/index.d.ts

@@ -0,0 +1,5 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import { WebpackFrameworkPlugin } from '../../shared/create-framework-plugin';
+export declare class GenericWebpackPlugin extends WebpackFrameworkPlugin {
+    constructor(options?: UserDefinedOptions | InternalUserDefinedOptions);
+}

package/dist/bundlers/webpack/frameworks/index.d.ts

@@ -0,0 +1,8 @@
+import type { WebpackFrameworkName } from '../../framework-selector';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
+import { GenericWebpackPlugin } from './generic';
+import { MpxWebpackPlugin } from './mpx';
+import { TaroWebpackPlugin } from './taro';
+import { UniAppWebpackPlugin } from './uni-app';
+import { WeappViteWebpackPlugin } from './weapp-vite';
+export declare function createWebpackFrameworkPlugin(frameworkName: WebpackFrameworkName, options?: UserDefinedOptions | InternalUserDefinedOptions): GenericWebpackPlugin | MpxWebpackPlugin | TaroWebpackPlugin | UniAppWebpackPlugin | WeappViteWebpackPlugin;

package/dist/bundlers/webpack/frameworks/mpx/index.d.ts

@@ -0,0 +1,5 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import { WebpackFrameworkPlugin } from '../../shared/create-framework-plugin';
+export declare class MpxWebpackPlugin extends WebpackFrameworkPlugin {
+    constructor(options?: UserDefinedOptions | InternalUserDefinedOptions);
+}

package/dist/bundlers/webpack/frameworks/taro/index.d.ts

@@ -0,0 +1,5 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import { WebpackFrameworkPlugin } from '../../shared/create-framework-plugin';
+export declare class TaroWebpackPlugin extends WebpackFrameworkPlugin {
+    constructor(options?: UserDefinedOptions | InternalUserDefinedOptions);
+}

package/dist/bundlers/webpack/frameworks/uni-app/index.d.ts

@@ -0,0 +1,5 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import { WebpackFrameworkPlugin } from '../../shared/create-framework-plugin';
+export declare class UniAppWebpackPlugin extends WebpackFrameworkPlugin {
+    constructor(options?: UserDefinedOptions | InternalUserDefinedOptions);
+}

package/dist/bundlers/webpack/frameworks/weapp-vite/index.d.ts

@@ -0,0 +1,5 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import { WebpackFrameworkPlugin } from '../../shared/create-framework-plugin';
+export declare class WeappViteWebpackPlugin extends WebpackFrameworkPlugin {
+    constructor(options?: UserDefinedOptions | InternalUserDefinedOptions);
+}

package/dist/bundlers/webpack/shared/create-framework-plugin.d.ts

@@ -0,0 +1,21 @@
+import type { Compiler } from 'webpack';
+import type { WebpackFrameworkName } from '../../framework-selector';
+import type { LoaderAnchorFinders } from '../shared/loader-anchors';
+import type { WebpackStyleInjectorDelegateFactory } from '../../../style-injector/internal';
+import type { AppType, IBaseWebpackPlugin, InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
+export declare const weappTailwindcssPackageDir: string;
+export interface WebpackFrameworkBranchContext {
+    frameworkName: WebpackFrameworkName;
+    loaderAnchorFinders: LoaderAnchorFinders;
+    mpxCssImportRewrite?: boolean | undefined;
+    setupCssImportRewriteRedirect?: ((packageDir: string) => void) | undefined;
+    styleInjectorDelegate: WebpackStyleInjectorDelegateFactory;
+}
+export declare class WebpackFrameworkPlugin implements IBaseWebpackPlugin {
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    private hasInitialTailwindCssRoots;
+    private frameworkBranch;
+    constructor(options: (UserDefinedOptions | InternalUserDefinedOptions) | undefined, frameworkBranch: WebpackFrameworkBranchContext);
+    apply(compiler: Compiler): void;
+}

package/dist/bundlers/webpack/shared/loader-anchors.d.ts

@@ -1,8 +1,9 @@
-import type { AppType } from '../../../types';
 export interface LoaderEntry {
     loader?: string;
 }
-export declare function createLoaderAnchorFinders(appType?: AppType): {
+export interface LoaderAnchorFinders {
     findRewriteAnchor: (entries: LoaderEntry[]) => number;
     findClassSetAnchor: (entries: LoaderEntry[]) => number;
-};
+}
+export declare function createMpxLoaderAnchorFinders(): LoaderAnchorFinders;
+export declare function createDefaultLoaderAnchorFinders(): LoaderAnchorFinders;

package/dist/cli.js

@@ -300,6 +300,13 @@ let lastEscapedCandidateCacheStore;
 function isUrlLikeCandidate(candidate) {
 	return candidate.startsWith("//") || candidate.startsWith("http://") || candidate.startsWith("https://");
 }
+function isPlainSlashPathCandidate(candidate) {
+	const slashIndex = candidate.indexOf("/");
+	if (slashIndex <= 0) return false;
+	if (isUrlLikeCandidate(candidate)) return true;
+	if (candidate.includes("[") || candidate.includes("]") || candidate.includes(":")) return false;
+	return !candidate.slice(0, slashIndex).includes("-");
+}
 function isArbitraryValueCandidate(candidate) {
 	let hasOpenBracket = false;
 	let hasCloseBracket = false;
@@ -355,6 +362,7 @@ function getEscapedCandidate(candidate, escapeMap, store = getEscapedCandidateCa
 function resolveClassNameTransformWithResult(candidate, { alwaysEscape, classNameSet, escapeMap, jsArbitraryValueFallback, jsPreserveClass, tailwindcssMajorVersion, classContext }) {
 	if (alwaysEscape) return DIRECT_RESULT;
 	if (jsPreserveClass?.(candidate)) return SKIP_RESULT;
+	if (!classContext && isPlainSlashPathCandidate(candidate)) return SKIP_RESULT;
 	if (classNameSet?.has(candidate)) return DIRECT_RESULT;
 	if (classNameSet && classNameSet.size > 0) {
 		const escapedCandidate = getEscapedCandidate(candidate, escapeMap);

package/dist/cli.mjs

@@ -271,6 +271,13 @@ let lastEscapedCandidateCacheStore;
 function isUrlLikeCandidate(candidate) {
 	return candidate.startsWith("//") || candidate.startsWith("http://") || candidate.startsWith("https://");
 }
+function isPlainSlashPathCandidate(candidate) {
+	const slashIndex = candidate.indexOf("/");
+	if (slashIndex <= 0) return false;
+	if (isUrlLikeCandidate(candidate)) return true;
+	if (candidate.includes("[") || candidate.includes("]") || candidate.includes(":")) return false;
+	return !candidate.slice(0, slashIndex).includes("-");
+}
 function isArbitraryValueCandidate(candidate) {
 	let hasOpenBracket = false;
 	let hasCloseBracket = false;
@@ -326,6 +333,7 @@ function getEscapedCandidate(candidate, escapeMap, store = getEscapedCandidateCa
 function resolveClassNameTransformWithResult(candidate, { alwaysEscape, classNameSet, escapeMap, jsArbitraryValueFallback, jsPreserveClass, tailwindcssMajorVersion, classContext }) {
 	if (alwaysEscape) return DIRECT_RESULT;
 	if (jsPreserveClass?.(candidate)) return SKIP_RESULT;
+	if (!classContext && isPlainSlashPathCandidate(candidate)) return SKIP_RESULT;
 	if (classNameSet?.has(candidate)) return DIRECT_RESULT;
 	if (classNameSet && classNameSet.size > 0) {
 		const escapedCandidate = getEscapedCandidate(candidate, escapeMap);

package/dist/{context-BCSk_YnL.js → context-CRhUs_5e.js}

@@ -1,10 +1,10 @@
 const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.js");
 const require_framework = require("./framework.js");
-const require_v4_engine = require("./v4-engine-C9cmNlP8.js");
-const require_generator = require("./generator-CqWzj2Z1.js");
+const require_v4_engine = require("./v4-engine-BZP2462H.js");
+const require_generator = require("./generator-DaaFxR5V.js");
 require("./utils-D3h8j7Mk.js");
 const require_defaults = require("./defaults-nsf4VNMX.js");
-const require_tailwindcss = require("./tailwindcss-DYJ3HZD2.js");
+const require_tailwindcss = require("./tailwindcss-BZjZZi60.js");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path);
 let node_process = require("node:process");
@@ -774,6 +774,13 @@ let lastEscapedCandidateCacheStore;
 function isUrlLikeCandidate(candidate) {
 	return candidate.startsWith("//") || candidate.startsWith("http://") || candidate.startsWith("https://");
 }
+function isPlainSlashPathCandidate(candidate) {
+	const slashIndex = candidate.indexOf("/");
+	if (slashIndex <= 0) return false;
+	if (isUrlLikeCandidate(candidate)) return true;
+	if (candidate.includes("[") || candidate.includes("]") || candidate.includes(":")) return false;
+	return !candidate.slice(0, slashIndex).includes("-");
+}
 function isArbitraryValueCandidate(candidate) {
 	let hasOpenBracket = false;
 	let hasCloseBracket = false;
@@ -829,6 +836,7 @@ function getEscapedCandidate(candidate, escapeMap, store = getEscapedCandidateCa
 function resolveClassNameTransformWithResult(candidate, { alwaysEscape, classNameSet, escapeMap, jsArbitraryValueFallback, jsPreserveClass, tailwindcssMajorVersion, classContext }) {
 	if (alwaysEscape) return DIRECT_RESULT;
 	if (jsPreserveClass?.(candidate)) return SKIP_RESULT;
+	if (!classContext && isPlainSlashPathCandidate(candidate)) return SKIP_RESULT;
 	if (classNameSet?.has(candidate)) return DIRECT_RESULT;
 	if (classNameSet && classNameSet.size > 0) {
 		const escapedCandidate = getEscapedCandidate(candidate, escapeMap);
@@ -4945,7 +4953,8 @@ function applyLoggerLevel(logLevel) {
 function resolveContextCssPreflight(opts, ctx, majorVersion) {
 	const userCssPreflight = opts?.cssOptions?.cssPreflight ?? opts?.cssPreflight;
 	const cssPreflight = require_defaults.resolveDefaultCssPreflight(userCssPreflight, majorVersion);
-	if (cssPreflight === false || !require_tailwindcss.resolveUniAppXOptions(ctx.uniAppX).enabled) return cssPreflight;
+	const shouldUseUniAppXPreflight = ctx.appType === "uni-app-x" || require_tailwindcss.resolveUniAppXOptions(ctx.uniAppX).enabled;
+	if (cssPreflight === false || !shouldUseUniAppXPreflight) return cssPreflight;
 	const userCssPreflightObject = userCssPreflight && typeof userCssPreflight === "object" ? userCssPreflight : void 0;
 	return {
 		...cssPreflight,