weapp-tailwindcss 5.0.13 → 5.1.0

package/dist/tailwindcss/candidates.d.ts

@@ -0,0 +1,7 @@
+import type { IArbitraryValues } from '../types/shared';
+export interface SourceCandidateExtractionOptions {
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
+    extractor?: ((source: string, extension: string) => Promise<Iterable<string>> | Iterable<string>) | undefined;
+}
+export declare function extractCandidatesFromSource(source: string, extension: string, options?: SourceCandidateExtractionOptions): Promise<Set<string>>;
+export declare function extractScriptStringCandidates(source: string, extension: string, options: SourceCandidateExtractionOptions): Promise<never[] | Set<string>>;

package/dist/tailwindcss/index.d.ts

@@ -1,6 +1,6 @@
 import type { PackageResolvingOptions } from 'local-pkg';
 import type { PackageJson } from 'pkg-types';
-import { createTailwindcssPatcher } from './patcher';
+import { createTailwindcssRuntime } from './runtime-factory';
 declare function getTailwindcssPackageInfo(options?: PackageResolvingOptions): {
     name: string;
     version: string | undefined;
@@ -8,4 +8,4 @@ declare function getTailwindcssPackageInfo(options?: PackageResolvingOptions): {
     packageJsonPath: string;
     packageJson: PackageJson;
 } | undefined;
-export { createTailwindcssPatcher, getTailwindcssPackageInfo, };
+export { createTailwindcssRuntime, getTailwindcssPackageInfo, };

package/dist/tailwindcss/runtime/cache.d.ts

@@ -1,12 +1,12 @@
-import type { TailwindcssPatcherLike } from '../../types';
+import type { TailwindcssRuntimeLike } from '../../types';
 interface RuntimeClassSetCacheEntry {
     value?: Set<string> | undefined;
     promise?: Promise<Set<string>> | undefined;
     signature?: string | undefined;
 }
-export declare const runtimeSignaturePatchersSymbol: unique symbol;
-export declare function invalidateRuntimeClassSet(twPatcher?: TailwindcssPatcherLike): void;
-export declare function getRuntimeClassSetCacheEntry(twPatcher: TailwindcssPatcherLike): RuntimeClassSetCacheEntry;
-export declare function getRuntimeClassSetSignature(twPatcher: TailwindcssPatcherLike): string;
-export declare function getRuntimeClassSetSignatureWithSources(twPatcher: TailwindcssPatcherLike): Promise<string>;
+export declare const runtimeSignatureRuntimesSymbol: unique symbol;
+export declare function invalidateRuntimeClassSet(tailwindRuntime?: TailwindcssRuntimeLike): void;
+export declare function getRuntimeClassSetCacheEntry(tailwindRuntime: TailwindcssRuntimeLike): RuntimeClassSetCacheEntry;
+export declare function getRuntimeClassSetSignature(tailwindRuntime: TailwindcssRuntimeLike): string;
+export declare function getRuntimeClassSetSignatureWithSources(tailwindRuntime: TailwindcssRuntimeLike): Promise<string>;
 export {};

package/dist/tailwindcss/runtime-factory.d.ts

@@ -0,0 +1,12 @@
+import type { LengthUnitsRuntimeOptions, TailwindCssRuntimeOptions } from './runtime-types';
+import type { TailwindcssRuntimeLike } from '../types';
+type TailwindUserOptions = NonNullable<TailwindCssRuntimeOptions['tailwindcss']>;
+export interface CreateTailwindcssRuntimeOptions {
+    basedir?: string;
+    cacheDir?: string;
+    supportCustomLengthUnits?: boolean | LengthUnitsRuntimeOptions;
+    tailwindcss?: TailwindUserOptions;
+    tailwindcssRuntimeOptions?: TailwindCssRuntimeOptions;
+}
+export declare function createTailwindcssRuntime(options?: CreateTailwindcssRuntimeOptions): TailwindcssRuntimeLike;
+export {};

package/dist/tailwindcss/runtime-options.d.ts

@@ -0,0 +1,8 @@
+import type { LengthUnitsRuntimeOptions, TailwindCssRuntimeOptions } from './runtime-types';
+type TailwindUserOptions = NonNullable<TailwindCssRuntimeOptions['tailwindcss']>;
+type TailwindApplyOptions = NonNullable<TailwindCssRuntimeOptions['apply']>;
+type TailwindExtendLengthUnitsOption = TailwindApplyOptions['extendLengthUnits'];
+export declare function resolveTailwindcssOptions(options?: TailwindCssRuntimeOptions): TailwindUserOptions | undefined;
+export declare function normalizeExtendLengthUnits(value: boolean | LengthUnitsRuntimeOptions | undefined): TailwindExtendLengthUnitsOption | undefined;
+export declare function normalizeTailwindcssRuntimeOptions(options?: TailwindCssRuntimeOptions): TailwindCssRuntimeOptions | undefined;
+export {};

package/dist/tailwindcss/runtime-types.d.ts

@@ -0,0 +1,86 @@
+import type { PackageResolvingOptions } from 'local-pkg';
+import type { TailwindSourceEntry } from './source-scan';
+import type { TailwindV4SourceOptions } from './v4-engine';
+type TailwindV4CssSource = NonNullable<TailwindV4SourceOptions['cssSources']>[number];
+export interface LengthUnitsRuntimeOptions {
+    units?: string[] | undefined;
+    rem2rpx?: boolean | undefined;
+    [key: string]: unknown;
+}
+export interface ExtendLengthUnitsOptions extends Partial<LengthUnitsRuntimeOptions> {
+    enabled?: boolean | undefined;
+}
+export type CacheStrategy = 'merge' | 'overwrite';
+export type CacheDriver = 'file' | 'memory' | 'noop';
+export interface CacheOptions {
+    enabled?: boolean | undefined;
+    cwd?: string | undefined;
+    dir?: string | undefined;
+    file?: string | undefined;
+    strategy?: CacheStrategy | undefined;
+    driver?: CacheDriver | undefined;
+}
+export interface ExtractOptions {
+    write?: boolean | undefined;
+    file?: string | undefined;
+    format?: 'json' | 'lines' | undefined;
+    pretty?: number | boolean | undefined;
+    removeUniversalSelector?: boolean | undefined;
+}
+export interface ExposeContextOptions {
+    refProperty?: string | undefined;
+}
+export interface ApplyOptions {
+    overwrite?: boolean | undefined;
+    exposeContext?: boolean | ExposeContextOptions | undefined;
+    extendLengthUnits?: false | ExtendLengthUnitsOptions | undefined;
+}
+export interface TailwindRuntimeOptionsBase {
+    config?: string | undefined;
+    cwd?: string | undefined;
+    postcssPlugin?: string | undefined;
+}
+export interface TailwindV4Options {
+    base?: string | undefined;
+    css?: string | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+    cssEntries?: string[] | undefined;
+    sources?: TailwindSourceEntry[] | undefined;
+    bareArbitraryValues?: boolean | {
+        units?: string[] | undefined;
+    } | undefined;
+}
+export interface TailwindCssOptions extends TailwindRuntimeOptionsBase {
+    version?: 4 | undefined;
+    packageName?: string | undefined;
+    resolve?: PackageResolvingOptions | undefined;
+    v4?: TailwindV4Options | undefined;
+}
+export interface TailwindCssRuntimeOptions {
+    projectRoot?: string | undefined;
+    tailwindcss?: TailwindCssOptions | undefined;
+    apply?: ApplyOptions | undefined;
+    extract?: ExtractOptions | undefined;
+    filter?: ((className: string) => boolean) | undefined;
+    cache?: boolean | CacheOptions | undefined;
+}
+export interface TailwindPackageInfo {
+    name: string;
+    version: string | undefined;
+    rootPath: string;
+    packageJsonPath: string;
+    packageJson: Record<string, unknown>;
+}
+export interface TailwindcssExtractOptions extends ExtractOptions {
+}
+export interface TailwindcssExtractResult {
+    classList: string[];
+    classSet: Set<string>;
+}
+export interface TailwindContentTokenReport {
+    entries: unknown[];
+    filesScanned: number;
+    sources: unknown[];
+    skippedFiles: unknown[];
+}
+export {};

package/dist/tailwindcss/runtime.d.ts

@@ -1,6 +1,6 @@
-import type { RefreshTailwindcssPatcherOptions, TailwindcssPatcherLike } from '../types';
+import type { RefreshTailwindcssRuntimeOptions, TailwindcssRuntimeLike } from '../types';
 import { invalidateRuntimeClassSet } from './runtime/cache';
-export declare const refreshTailwindcssPatcherSymbol: unique symbol;
+export declare const refreshTailwindcssRuntimeSymbol: unique symbol;
 export interface CollectRuntimeClassSetOptions {
     force?: boolean | undefined;
     skipRefresh?: boolean | undefined;
@@ -10,11 +10,11 @@ export interface RefreshTailwindRuntimeStateOptions {
     force: boolean;
     clearCache?: boolean | undefined;
 }
-export declare function createTailwindRuntimeReadyPromise(twPatcher: TailwindcssPatcherLike): Promise<void>;
+export declare function createTailwindRuntimeReadyPromise(tailwindRuntime: TailwindcssRuntimeLike): Promise<void>;
 export interface TailwindRuntimeState {
-    twPatcher: TailwindcssPatcherLike;
+    tailwindRuntime: TailwindcssRuntimeLike;
     readyPromise: Promise<void>;
-    refreshTailwindcssPatcher?: ((options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>) | undefined;
+    refreshTailwindcssRuntime?: ((options?: RefreshTailwindcssRuntimeOptions) => Promise<TailwindcssRuntimeLike>) | undefined;
 }
 export declare function refreshTailwindRuntimeState(state: TailwindRuntimeState, forceOrOptions: boolean | RefreshTailwindRuntimeStateOptions): Promise<boolean>;
 export interface EnsureRuntimeClassSetOptions {
@@ -24,5 +24,5 @@ export interface EnsureRuntimeClassSetOptions {
     allowEmpty?: boolean | undefined;
 }
 export declare function ensureRuntimeClassSet(state: TailwindRuntimeState, options?: EnsureRuntimeClassSetOptions): Promise<Set<string>>;
-declare function collectRuntimeClassSet(twPatcher: TailwindcssPatcherLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;
+declare function collectRuntimeClassSet(tailwindRuntime: TailwindcssRuntimeLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;
 export { collectRuntimeClassSet, invalidateRuntimeClassSet };

package/dist/tailwindcss/source-scan.d.ts

@@ -1,5 +1,5 @@
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { Root } from '@weapp-tailwindcss/postcss';
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
 export interface TailwindSourceEntry {
     base: string;
     pattern: string;

package/dist/tailwindcss/targets.d.ts

@@ -1,2 +1,2 @@
-import type { TailwindcssPatcherLike } from '../types';
-export declare function logTailwindcssTarget(patcher: TailwindcssPatcherLike | undefined, baseDir?: string): void;
+import type { TailwindcssRuntimeLike } from '../types';
+export declare function logTailwindcssTarget(tailwindRuntime: TailwindcssRuntimeLike | undefined, baseDir?: string): void;

package/dist/tailwindcss/v4/config.d.ts

@@ -1,5 +1,5 @@
-import type { InternalUserDefinedOptions, TailwindcssPatcherLike } from '../../types';
+import type { InternalUserDefinedOptions, TailwindcssRuntimeLike } from '../../types';
 export declare const DEFAULT_CSS_CALC_CUSTOM_PROPERTIES: (string | RegExp)[];
 export declare function normalizeCssEntriesConfig(entries: unknown): string[] | undefined;
-export declare function warnMissingCssEntries(ctx: InternalUserDefinedOptions, patcher: TailwindcssPatcherLike | undefined): void;
-export declare function applyV4CssCalcDefaults(cssCalc: InternalUserDefinedOptions['cssCalc'], patcher: TailwindcssPatcherLike | undefined): InternalUserDefinedOptions['cssCalc'];
+export declare function warnMissingCssEntries(ctx: InternalUserDefinedOptions, tailwindRuntime: TailwindcssRuntimeLike | undefined): void;
+export declare function applyV4CssCalcDefaults(cssCalc: InternalUserDefinedOptions['cssCalc'], tailwindRuntime: TailwindcssRuntimeLike | undefined): InternalUserDefinedOptions['cssCalc'];

package/dist/tailwindcss/v4/css-entries.d.ts

@@ -1,3 +1,4 @@
+export declare function isTailwindV4CssEntry(entry: string | undefined): entry is string;
 export declare function guessBasedirFromEntries(entries?: string[]): string | undefined;
 export declare function normalizeCssEntries(entries: string[] | undefined, anchor: string): string[] | undefined;
 export interface GroupCssEntriesOptions {

package/dist/tailwindcss/v4/css-sources.d.ts

@@ -1,5 +1,7 @@
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { UserDefinedOptions } from '../../types';
 export declare function hasCssSourcesValue(value: unknown): boolean;
-export declare function hasConfiguredTailwindV4CssRoots(options: Pick<UserDefinedOptions, 'cssEntries' | 'tailwindcss' | 'tailwindcssPatcherOptions'>): boolean;
+export declare function isTailwindV4CssSourceRoot(source: unknown): source is TailwindV4CssSource;
+export declare function filterTailwindV4CssSourceRoots(sources: TailwindV4CssSource[] | undefined): TailwindV4CssSource[] | undefined;
+export declare function hasConfiguredTailwindV4CssRoots(options: Pick<UserDefinedOptions, 'cssEntries' | 'tailwindcss' | 'tailwindcssRuntimeOptions'>): boolean;
 export declare function upsertTailwindV4CssSource(opts: UserDefinedOptions, source: TailwindV4CssSource): boolean;

package/dist/tailwindcss/v4/index.d.ts

@@ -1,2 +1,2 @@
 export * from './config';
-export * from './patcher';
+export * from './runtime-factory';

package/dist/tailwindcss/v4/multi-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { TailwindcssRuntimeLike } from '../../types';
+export declare function createMultiTailwindcssRuntime(runtimes: TailwindcssRuntimeLike[]): TailwindcssRuntimeLike;

package/dist/tailwindcss/v4/runtime-factory.d.ts

@@ -0,0 +1,15 @@
+import type { TailwindCssRuntimeOptions } from '../runtime-types';
+import type { CreateTailwindcssRuntimeOptions } from '../runtime-factory';
+import type { InternalUserDefinedOptions, TailwindcssRuntimeLike } from '../../types';
+export { groupCssEntriesByBase, guessBasedirFromEntries, normalizeCssEntries } from './css-entries';
+export { createMultiTailwindcssRuntime } from './multi-runtime';
+type TailwindUserOptions = NonNullable<TailwindCssRuntimeOptions['tailwindcss']>;
+export interface TailwindcssRuntimeFactoryOptions {
+    tailwindcss?: TailwindUserOptions;
+    tailwindcssRuntimeOptions?: CreateTailwindcssRuntimeOptions['tailwindcssRuntimeOptions'];
+    supportCustomLengthUnits: InternalUserDefinedOptions['supportCustomLengthUnits'];
+    appType: InternalUserDefinedOptions['appType'];
+    bareArbitraryValues?: InternalUserDefinedOptions['arbitraryValues']['bareArbitraryValues'];
+}
+export declare function createTailwindcssRuntimeForBase(baseDir: string, cssEntries: string[] | undefined, options: TailwindcssRuntimeFactoryOptions): TailwindcssRuntimeLike;
+export declare function tryCreateMultiTailwindcssRuntime(groups: Map<string, string[]>, options: TailwindcssRuntimeFactoryOptions): TailwindcssRuntimeLike | undefined;

package/dist/tailwindcss/v4/runtime-options.d.ts

@@ -0,0 +1,2 @@
+import type { TailwindCssRuntimeOptions } from '../runtime-types';
+export declare function overrideTailwindcssRuntimeOptionsForBase(options: TailwindCssRuntimeOptions | undefined, baseDir: string, cssEntries: string[]): TailwindCssRuntimeOptions | undefined;

package/dist/tailwindcss/v4-engine/design-system.d.ts

@@ -1 +1 @@
-export { loadTailwindV4DesignSystem, resolveValidTailwindV4Candidates, } from 'tailwindcss-patch';
+export { loadTailwindV4DesignSystem, resolveValidTailwindV4Candidates, } from '@tailwindcss-mangle/engine';

package/dist/tailwindcss/v4-engine/generator/css-compat.d.ts

@@ -1,2 +1,2 @@
 import type { TailwindV4GenerateTarget, TailwindV4ResolvedSource } from '../types';
-export declare function createCompatibleSource(source: TailwindV4ResolvedSource, target: TailwindV4GenerateTarget, tailwindcssV3Compatibility: boolean | undefined): TailwindV4ResolvedSource;
+export declare function createCompatibleSource(source: TailwindV4ResolvedSource, target: TailwindV4GenerateTarget): TailwindV4ResolvedSource;

package/dist/tailwindcss/v4-engine/generator/rpx-candidates.d.ts

@@ -1,6 +1,6 @@
-export declare function normalizeRpxTextCandidates(candidates: Iterable<string>): {
+export declare function normalizeRpxLengthCandidates(candidates: Iterable<string>): {
     candidates: Set<string>;
     restoreCandidates: Map<string, string>;
 };
-export declare function restoreRpxTextCandidates(candidates: Iterable<string>, restoreCandidates: ReadonlyMap<string, string>): Set<string>;
-export declare function restoreRpxTextCssSelectors(css: string, restoreCandidates: ReadonlyMap<string, string>): string;
+export declare function restoreRpxLengthCandidates(candidates: Iterable<string>, restoreCandidates: ReadonlyMap<string, string>): Set<string>;
+export declare function restoreRpxLengthCssSelectors(css: string, restoreCandidates: ReadonlyMap<string, string>): string;

package/dist/tailwindcss/v4-engine/generator/scan-sources.d.ts

@@ -1,2 +1,2 @@
 import type { TailwindV4GenerateOptions, TailwindV4ResolvedSource } from '../types';
-export declare function resolveScanSources(source: TailwindV4ResolvedSource, scanSources: TailwindV4GenerateOptions['scanSources']): Promise<boolean | import("tailwindcss-patch").TailwindV4SourcePattern[] | undefined>;
+export declare function resolveScanSources(source: TailwindV4ResolvedSource, scanSources: TailwindV4GenerateOptions['scanSources']): Promise<boolean | import("@tailwindcss-mangle/engine").TailwindV4SourcePattern[] | undefined>;

package/dist/tailwindcss/v4-engine/generator.d.ts

@@ -8,14 +8,21 @@ export declare function getTailwindV4IncrementalGenerateCacheStats(): {
     taskMax: number;
     taskSize: number;
     entries: {
-        key: string;
         candidates: number;
         classSet: number;
         cssBytes: number;
         rawCssBytes: number;
+        keyHash: string;
+        keyBytes: number;
+    }[];
+    keys: {
+        keyHash: string;
+        keyBytes: number;
+    }[];
+    taskKeys: {
+        keyHash: string;
+        keyBytes: number;
     }[];
-    keys: string[];
-    taskKeys: string[];
 };
 export declare const getTailwindV4IncrementalGenerateCacheStatsForTest: typeof getTailwindV4IncrementalGenerateCacheStats;
 export declare function clearTailwindV4IncrementalGenerateCacheForTest(): void;

package/dist/tailwindcss/v4-engine/index.d.ts

@@ -1,5 +1,5 @@
 export { loadTailwindV4DesignSystem, resolveValidTailwindV4Candidates, } from './design-system';
 export { clearTailwindV4IncrementalGenerateCacheForTest, createTailwindV4Engine, getTailwindV4IncrementalGenerateCacheStats, getTailwindV4IncrementalGenerateCacheStatsForTest, } from './generator';
 export { transformTailwindV4CssByTarget, transformTailwindV4CssToWeapp } from './miniprogram';
-export { resolveTailwindV4Source, resolveTailwindV4SourceFromPatcher, resolveTailwindV4SourceFromPatchOptions, resolveTailwindV4SourceOptionsFromPatcher, } from './source';
+export { resolveTailwindV4Source, resolveTailwindV4SourceFromRuntime, resolveTailwindV4SourceFromRuntimeOptions, resolveTailwindV4SourceOptionsFromRuntime, } from './source';
 export type { TailwindV4CandidateSource, TailwindV4DesignSystem, TailwindV4Engine, TailwindV4GenerateOptions, TailwindV4GenerateResult, TailwindV4GenerateTarget, TailwindV4ResolvedSource, TailwindV4SourceOptions, } from './types';

package/dist/tailwindcss/v4-engine/miniprogram.d.ts

@@ -1,5 +1,11 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { TailwindV4GenerateTarget } from './types';
+import type { AppType } from '../../types';
+type TailwindV4TargetStyleOptions = Partial<IStyleHandlerOptions> & {
+    appType?: AppType | undefined;
+};
 export declare function normalizeTailwindV4GeneratedUrlValues(css: string): string;
 export declare function transformTailwindV4CssToWeapp(css: string, options?: Partial<IStyleHandlerOptions>): Promise<string>;
-export declare function transformTailwindV4CssByTarget(css: string, target: TailwindV4GenerateTarget, options?: Partial<IStyleHandlerOptions>): Promise<string>;
+export declare function transformTailwindV4WebRpxCss(css: string): string;
+export declare function transformTailwindV4CssByTarget(css: string, target: TailwindV4GenerateTarget, options?: TailwindV4TargetStyleOptions): Promise<string>;
+export {};

package/dist/tailwindcss/v4-engine/source.d.ts

@@ -1,7 +1,24 @@
 import type { TailwindV4SourceOptions, TailwindV4SourceOptionsWithSources } from './types';
-import type { TailwindcssPatcherLike } from '../../types';
-import { resolveTailwindV4SourceFromPatchOptions } from 'tailwindcss-patch';
-export declare function resolveTailwindV4SourceOptionsFromPatcher(patcher: TailwindcssPatcherLike): TailwindV4SourceOptionsWithSources;
-export declare function resolveTailwindV4Source(options?: TailwindV4SourceOptions): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
-export declare function resolveTailwindV4SourceFromPatcher(patcher: TailwindcssPatcherLike): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
-export { resolveTailwindV4SourceFromPatchOptions };
+import type { TailwindcssRuntimeLike } from '../../types';
+export declare function normalizeTailwindV4SourceOptions(options: TailwindV4SourceOptions | undefined): TailwindV4SourceOptions | {
+    cssSources: import("@tailwindcss-mangle/engine").TailwindV4CssSource[] | undefined;
+    cssEntries?: string[];
+    css: string | undefined;
+    projectRoot?: string;
+    cwd?: string;
+    base?: string;
+    baseFallbacks?: string[];
+    packageName?: string;
+} | undefined;
+export declare function resolveTailwindV4SourceOptionsFromRuntime(runtime: TailwindcssRuntimeLike): TailwindV4SourceOptionsWithSources;
+export declare function resolveTailwindV4Source(options?: TailwindV4SourceOptions): Promise<import("@tailwindcss-mangle/engine").TailwindV4ResolvedSource>;
+export declare function resolveTailwindV4SourceFromRuntimeOptions(options?: {
+    projectRoot?: string;
+    tailwindcss?: {
+        cwd?: string;
+        packageName?: string;
+        config?: string;
+        v4?: TailwindV4SourceOptions;
+    };
+}): Promise<import("@tailwindcss-mangle/engine").TailwindV4ResolvedSource>;
+export declare function resolveTailwindV4SourceFromRuntime(runtime: TailwindcssRuntimeLike): Promise<import("@tailwindcss-mangle/engine").TailwindV4ResolvedSource>;

package/dist/tailwindcss/v4-engine/types.d.ts

@@ -1,31 +1,30 @@
+import type { TailwindV4Engine as EngineTailwindV4Engine, TailwindV4GenerateOptions as EngineTailwindV4GenerateOptions, TailwindV4GenerateResult as EngineTailwindV4GenerateResult, TailwindV4CandidateSource, TailwindV4DesignSystem, TailwindV4ResolvedSource, TailwindV4SourceOptions } from '@tailwindcss-mangle/engine';
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
-import type { TailwindV4Engine as PatchTailwindV4Engine, TailwindV4GenerateOptions as PatchTailwindV4GenerateOptions, TailwindV4GenerateResult as PatchTailwindV4GenerateResult, TailwindV4CandidateSource, TailwindV4DesignSystem, TailwindV4ResolvedSource, TailwindV4SourceOptions } from 'tailwindcss-patch';
-export type TailwindV4GenerateTarget = 'weapp' | 'web' | 'tailwind';
+export type TailwindV4GenerateTarget = 'weapp' | 'web';
 export interface TailwindV4SourcePattern {
     base: string;
     pattern: string;
     negated: boolean;
 }
-type TailwindV4PatchGenerateOptions = Omit<PatchTailwindV4GenerateOptions, 'target' | 'styleOptions' | 'tailwindcssV3Compatibility' | 'scanSources' | 'bareArbitraryValues'>;
-export interface TailwindV4GenerateOptions extends TailwindV4PatchGenerateOptions {
+type TailwindV4EngineGenerateOptions = Omit<EngineTailwindV4GenerateOptions, 'target' | 'styleOptions' | 'scanSources' | 'bareArbitraryValues'>;
+export interface TailwindV4GenerateOptions extends TailwindV4EngineGenerateOptions {
     incrementalCache?: boolean | undefined;
-    bareArbitraryValues?: PatchTailwindV4GenerateOptions['bareArbitraryValues'] | undefined;
+    bareArbitraryValues?: EngineTailwindV4GenerateOptions['bareArbitraryValues'] | undefined;
     target?: TailwindV4GenerateTarget | undefined;
     styleOptions?: Partial<IStyleHandlerOptions> | undefined;
-    tailwindcssV3Compatibility?: boolean | undefined;
-    scanSources?: PatchTailwindV4GenerateOptions['scanSources'] | undefined;
+    scanSources?: EngineTailwindV4GenerateOptions['scanSources'] | undefined;
 }
 export interface TailwindV4SourceOptionsWithSources extends TailwindV4SourceOptions {
     sources?: TailwindV4SourcePattern[] | undefined;
 }
-export interface TailwindV4GenerateResult extends Omit<PatchTailwindV4GenerateResult, 'css'> {
+export interface TailwindV4GenerateResult extends Omit<EngineTailwindV4GenerateResult, 'css'> {
     css: string;
     rawCss: string;
     incrementalCss?: string | undefined;
     incrementalRawCss?: string | undefined;
     target: TailwindV4GenerateTarget;
 }
-export interface TailwindV4Engine extends Omit<PatchTailwindV4Engine, 'generate'> {
+export interface TailwindV4Engine extends Omit<EngineTailwindV4Engine, 'generate'> {
     source: TailwindV4ResolvedSource;
     generate: (options?: TailwindV4GenerateOptions) => Promise<TailwindV4GenerateResult>;
 }

package/dist/tailwindcss/version.d.ts

@@ -1,4 +1,4 @@
-export type SupportedTailwindcssMajorVersion = 3 | 4;
+export type SupportedTailwindcssMajorVersion = 4;
 export declare const DEFAULT_TAILWINDCSS_GENERATOR_MAJOR_VERSION: SupportedTailwindcssMajorVersion;
 export declare function normalizeSupportedTailwindcssMajorVersion(version: number | undefined): SupportedTailwindcssMajorVersion | undefined;
 export declare function readInstalledPackageMajorVersion(packageName: string, base: string): SupportedTailwindcssMajorVersion | undefined;