weapp-tailwindcss 4.12.0 → 5.0.0-next.1

package/dist/reset/index.d.ts

@@ -0,0 +1,2 @@
+export { default, reset } from '@weapp-tailwindcss/reset';
+export type { ResetConfig, ResetOptions, ResetPreset } from '@weapp-tailwindcss/reset';

package/dist/reset.d.ts

@@ -1,4 +1 @@
-import _default from '@weapp-tailwindcss/reset';
-// @ts-ignore
-export = _default;
-export { ResetConfig, ResetOptions, ResetPreset, reset } from '@weapp-tailwindcss/reset';
+export * from './reset/index'

package/dist/reset.js

@@ -1,8 +1,19 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }require('./chunk-RKISS72P.js');
-
-// src/reset/index.ts
-var _reset = require('@weapp-tailwindcss/reset'); var _reset2 = _interopRequireDefault(_reset);
-
-
-
-exports.default = _reset2.default; exports.reset = _reset.reset;
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_chunk = require("./chunk-8l464Juk.js");
+let _weapp_tailwindcss_reset = require("@weapp-tailwindcss/reset");
+_weapp_tailwindcss_reset = require_chunk.__toESM(_weapp_tailwindcss_reset);
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return _weapp_tailwindcss_reset.default;
+	}
+});
+Object.defineProperty(exports, "reset", {
+	enumerable: true,
+	get: function() {
+		return _weapp_tailwindcss_reset.reset;
+	}
+});

package/dist/reset.mjs

@@ -1,8 +1,2 @@
-import "./chunk-NNOQDMUP.mjs";
-
-// src/reset/index.ts
-import { default as default2, reset } from "@weapp-tailwindcss/reset";
-export {
-  default2 as default,
-  reset
-};
+import reset_default, { reset } from "@weapp-tailwindcss/reset";
+export { reset_default as default, reset };

package/dist/shared/classname-transform.d.ts

@@ -0,0 +1,14 @@
+import type { IJsHandlerOptions } from '../types';
+export type ClassNameTransformDecision = 'direct' | 'escaped' | 'fallback' | 'skip';
+export interface ClassNameTransformResult {
+    decision: ClassNameTransformDecision;
+    escapedValue?: string;
+}
+interface ResolveClassNameTransformOptions extends Pick<IJsHandlerOptions, 'alwaysEscape' | 'classNameSet' | 'escapeMap' | 'jsArbitraryValueFallback' | 'jsPreserveClass' | 'tailwindcssMajorVersion'> {
+    classContext?: boolean;
+}
+export declare function shouldEnableArbitraryValueFallback({ classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion, }: Pick<ResolveClassNameTransformOptions, 'classNameSet' | 'jsArbitraryValueFallback' | 'tailwindcssMajorVersion'>): boolean;
+export declare function resolveClassNameTransformWithResult(candidate: string, { alwaysEscape, classNameSet, escapeMap, jsArbitraryValueFallback, jsPreserveClass, tailwindcssMajorVersion, classContext, }: ResolveClassNameTransformOptions): ClassNameTransformResult;
+export declare function resolveClassNameTransformDecision(candidate: string, options: ResolveClassNameTransformOptions): ClassNameTransformDecision;
+export declare function shouldTransformClassNameCandidate(candidate: string, options: ResolveClassNameTransformOptions): boolean;
+export {};

package/dist/shared/mpx.d.ts

@@ -0,0 +1,7 @@
+import type { AppType } from '../types';
+export declare function isMpx(appType?: AppType): appType is "mpx";
+export declare function getTailwindcssCssEntry(pkgDir: string): string;
+export declare function ensureMpxTailwindcssAliases(compiler: any, pkgDir: string): string;
+export declare function patchMpxLoaderResolve(loaderContext: any, pkgDir: string, enabled: boolean): void;
+export declare function setupMpxTailwindcssRedirect(pkgDir: string, enabled: boolean): void;
+export declare function injectMpxCssRewritePreRules(compiler: any, loader: string | undefined, loaderOptions: any): void;

package/dist/shared/tailwindcss-css-redirect.d.ts

@@ -0,0 +1 @@
+export declare function installTailwindcssCssRedirect(pkgDir: string): void;

package/dist/tailwindcss/index.d.ts

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

package/dist/tailwindcss/miniprogram.d.ts

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

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

@@ -0,0 +1,56 @@
+import type { PackageResolvingOptions } from 'local-pkg';
+import type { ILengthUnitsPatchOptions, NormalizedTailwindCssPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
+type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
+type ResolvedTailwindUserOptions = TailwindUserOptions | NormalizedTailwindCssPatchOptions['tailwind'];
+type TailwindApplyOptions = NonNullable<TailwindCssPatchOptions['apply']>;
+type TailwindExtractOptions = NonNullable<TailwindCssPatchOptions['extract']>;
+type TailwindExtendLengthUnitsOption = TailwindApplyOptions['extendLengthUnits'];
+export interface LegacyTailwindcssPatcherOptions {
+    cache?: boolean | {
+        enabled?: boolean;
+        cwd?: string;
+        dir?: string;
+        file?: string;
+        strategy?: 'merge' | 'overwrite';
+    };
+    patch?: {
+        overwrite?: boolean;
+        basedir?: string;
+        cwd?: string;
+        filter?: (className: string) => boolean;
+        resolve?: PackageResolvingOptions;
+        tailwindcss?: TailwindUserOptions;
+        applyPatches?: {
+            exportContext?: boolean;
+            extendLengthUnits?: boolean | ILengthUnitsPatchOptions;
+        };
+        output?: {
+            filename?: string;
+            loose?: boolean;
+            removeUniversalSelector?: boolean;
+        };
+    };
+}
+export interface LegacyTailwindcssOutputOptions {
+    enabled?: boolean;
+    file?: string;
+    format?: TailwindExtractOptions['format'];
+    pretty?: TailwindExtractOptions['pretty'];
+    removeUniversalSelector?: boolean;
+}
+export interface LegacyTailwindcssFeatureOptions {
+    exposeContext?: TailwindApplyOptions['exposeContext'];
+    extendLengthUnits?: boolean | ILengthUnitsPatchOptions | TailwindExtendLengthUnitsOption;
+}
+export type CompatTailwindCssPatchOptions = TailwindCssPatchOptions & {
+    cwd?: string;
+    overwrite?: boolean;
+    features?: LegacyTailwindcssFeatureOptions;
+    output?: LegacyTailwindcssOutputOptions;
+    tailwind?: ResolvedTailwindUserOptions;
+};
+export declare function resolveTailwindcssOptions(options?: CompatTailwindCssPatchOptions | LegacyTailwindcssPatcherOptions): ResolvedTailwindUserOptions | undefined;
+export declare function normalizeExtendLengthUnits(value: boolean | ILengthUnitsPatchOptions | undefined): TailwindExtendLengthUnitsOption | undefined;
+export declare function normalizeTailwindcssPatcherOptions(options?: CompatTailwindCssPatchOptions | LegacyTailwindcssPatcherOptions): TailwindCssPatchOptions | undefined;
+export declare function toModernTailwindcssPatchOptions(options?: CompatTailwindCssPatchOptions): TailwindCssPatchOptions | undefined;
+export {};

package/dist/tailwindcss/patcher-resolve.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveModuleFromPaths(specifier: string | undefined, paths: string[]): string | undefined;
+export declare function resolveTailwindConfigFallback(packageName: string | undefined, paths: string[]): string | undefined;
+export declare function findTailwindConfig(searchRoots: Iterable<string>): string | undefined;
+export declare function createDefaultResolvePaths(basedir?: string): string[];

package/dist/tailwindcss/patcher.d.ts

@@ -0,0 +1,13 @@
+import type { ILengthUnitsPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
+import type { LegacyTailwindcssPatcherOptions } from './patcher-options';
+import type { TailwindcssPatcherLike } from '../types';
+type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
+export interface CreateTailwindcssPatcherOptions {
+    basedir?: string;
+    cacheDir?: string;
+    supportCustomLengthUnitsPatch?: boolean | ILengthUnitsPatchOptions;
+    tailwindcss?: TailwindUserOptions;
+    tailwindcssPatcherOptions?: TailwindCssPatchOptions | LegacyTailwindcssPatcherOptions;
+}
+export declare function createTailwindcssPatcher(options?: CreateTailwindcssPatcherOptions): TailwindcssPatcherLike;
+export {};

package/dist/tailwindcss/recorder.d.ts

@@ -0,0 +1,13 @@
+import type { PatchTargetRecorder, PatchTargetRecorderOptions } from './targets';
+import type { TailwindcssPatcherLike } from '../types';
+interface SetupPatchRecorderOptions extends PatchTargetRecorderOptions {
+    logMessage?: boolean;
+    messagePrefix?: string;
+}
+export interface PatchRecorderState {
+    recorder?: PatchTargetRecorder;
+    patchPromise: Promise<void>;
+    onPatchCompleted?: () => Promise<void> | void;
+}
+export declare function setupPatchRecorder(patcher: TailwindcssPatcherLike | undefined, baseDir: string | undefined, options?: SetupPatchRecorderOptions): PatchRecorderState;
+export {};

package/dist/tailwindcss/remove-unsupported-css.d.ts

@@ -0,0 +1,2 @@
+import type postcss from 'postcss';
+export declare function removeUnsupportedCascadeLayers(root: postcss.Root): void;

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

@@ -0,0 +1,11 @@
+import type { TailwindcssPatcherLike } from '../../types';
+interface RuntimeClassSetCacheEntry {
+    value?: Set<string>;
+    promise?: Promise<Set<string>>;
+    signature?: string;
+}
+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 {};

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

@@ -0,0 +1,3 @@
+export declare function logRuntimeTailwindcssTarget(baseDir?: string, rootPath?: string, version?: string): void;
+export declare function logRuntimeTailwindcssVersion(baseDir?: string, rootPath?: string, version?: string): void;
+export declare function __resetRuntimeTailwindcssLogsForTests(): void;

package/dist/tailwindcss/runtime.d.ts

@@ -0,0 +1,29 @@
+import type { RefreshTailwindcssPatcherOptions, TailwindcssPatcherLike } from '../types';
+import { invalidateRuntimeClassSet } from './runtime/cache';
+export declare const refreshTailwindcssPatcherSymbol: unique symbol;
+export interface CollectRuntimeClassSetOptions {
+    force?: boolean;
+    skipRefresh?: boolean;
+    clearCache?: boolean;
+}
+export interface RefreshTailwindRuntimeStateOptions {
+    force: boolean;
+    clearCache?: boolean;
+}
+export declare function createTailwindPatchPromise(twPatcher: TailwindcssPatcherLike, onPatched?: () => Promise<void> | void): Promise<void>;
+export interface TailwindRuntimeState {
+    twPatcher: TailwindcssPatcherLike;
+    patchPromise: Promise<void>;
+    refreshTailwindcssPatcher?: (options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>;
+    onPatchCompleted?: () => Promise<void> | void;
+}
+export declare function refreshTailwindRuntimeState(state: TailwindRuntimeState, forceOrOptions: boolean | RefreshTailwindRuntimeStateOptions): Promise<boolean>;
+export interface EnsureRuntimeClassSetOptions {
+    forceRefresh?: boolean;
+    forceCollect?: boolean;
+    clearCache?: boolean;
+    allowEmpty?: boolean;
+}
+export declare function ensureRuntimeClassSet(state: TailwindRuntimeState, options?: EnsureRuntimeClassSetOptions): Promise<Set<string>>;
+declare function collectRuntimeClassSet(twPatcher: TailwindcssPatcherLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;
+export { collectRuntimeClassSet, invalidateRuntimeClassSet };

package/dist/tailwindcss/targets/paths.d.ts

@@ -0,0 +1,13 @@
+export declare const PATCH_INFO_FILENAME = "tailwindcss-target.json";
+export declare const PATCH_INFO_CACHE_RELATIVE_PATH: string;
+export declare const PATCH_INFO_LEGACY_RELATIVE_PATH: string;
+export declare function formatRelativeToBase(targetPath: string, baseDir?: string): string;
+export declare function resolveRecordLocation(baseDir: string): {
+    normalizedBase: string;
+    packageRoot: string;
+    recordDir: string;
+    recordKey: string;
+    recordPath: string;
+    packageJsonPath: string | undefined;
+};
+export declare function getRecordFileCandidates(baseDir: string): string[];

package/dist/tailwindcss/targets/record-io.d.ts

@@ -0,0 +1,5 @@
+import type { PatchTargetRecordResult, SavePatchTargetRecordOptions } from './types';
+import type { TailwindcssPatcherLike } from '../../types';
+export declare function readPatchTargetRecord(baseDir?: string): PatchTargetRecordResult | undefined;
+export declare function saveCliPatchTargetRecord(baseDir: string | undefined, patcher: TailwindcssPatcherLike | undefined, options?: SavePatchTargetRecordOptions): Promise<string | undefined>;
+export declare function __resetPatchTargetRecordWarningsForTests(): void;

package/dist/tailwindcss/targets/recorder.d.ts

@@ -0,0 +1,3 @@
+import type { PatchTargetRecorder, PatchTargetRecorderOptions } from './types';
+import type { TailwindcssPatcherLike } from '../../types';
+export declare function createPatchTargetRecorder(baseDir: string | undefined, patcher: TailwindcssPatcherLike | undefined, options?: PatchTargetRecorderOptions): PatchTargetRecorder | undefined;

package/dist/tailwindcss/targets/types.d.ts

@@ -0,0 +1,35 @@
+export interface PatchTargetRecord {
+    tailwindPackagePath: string;
+    packageVersion?: string;
+    recordedAt: string;
+    source: 'cli' | 'runtime' | string;
+    tailwindcssBasedir?: string;
+    cwd?: string;
+    patchVersion?: string;
+    packageJsonPath?: string;
+    recordKey?: string;
+}
+export interface PatchTargetRecordResult {
+    baseDir: string;
+    path: string;
+    record: PatchTargetRecord;
+}
+export interface SavePatchTargetRecordOptions {
+    cwd?: string;
+    source?: 'cli' | 'runtime' | string;
+    recordPath?: string;
+    recordKey?: string;
+    packageJsonPath?: string;
+}
+export interface PatchTargetRecorder {
+    recordPath: string;
+    message?: string;
+    reason?: string;
+    onPatched: () => Promise<string | undefined>;
+}
+export interface PatchTargetRecorderOptions {
+    source?: 'cli' | 'runtime' | string;
+    cwd?: string;
+    recordTarget?: boolean;
+    alwaysRecord?: boolean;
+}

package/dist/tailwindcss/targets.d.ts

@@ -0,0 +1,6 @@
+import type { TailwindcssPatcherLike } from '../types';
+import { __resetPatchTargetRecordWarningsForTests, saveCliPatchTargetRecord } from './targets/record-io';
+import { createPatchTargetRecorder } from './targets/recorder';
+export type { PatchTargetRecorder, PatchTargetRecorderOptions, SavePatchTargetRecordOptions } from './targets/types';
+export declare function logTailwindcssTarget(kind: 'cli' | 'runtime', patcher: TailwindcssPatcherLike | undefined, baseDir?: string): void;
+export { __resetPatchTargetRecordWarningsForTests, createPatchTargetRecorder, saveCliPatchTargetRecord, };

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

@@ -0,0 +1,2 @@
+import type { TailwindV3Engine, TailwindV3ResolvedSource } from './types';
+export declare function createTailwindV3Engine(source: TailwindV3ResolvedSource): TailwindV3Engine;

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

@@ -0,0 +1,4 @@
+export { createTailwindV3Engine } from './generator';
+export { transformTailwindV3CssByTarget, transformTailwindV3CssToWeapp } from './miniprogram';
+export { resolveTailwindV3Source, resolveTailwindV3SourceFromPatcher, resolveTailwindV3SourceOptionsFromPatcher, } from './source';
+export type { TailwindV3CandidateSource, TailwindV3Engine, TailwindV3GenerateOptions, TailwindV3GenerateResult, TailwindV3GenerateTarget, TailwindV3ResolvedSource, TailwindV3SourceOptions, } from './types';

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

@@ -0,0 +1,4 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindV3GenerateTarget } from './types';
+export declare function transformTailwindV3CssToWeapp(css: string, options?: Partial<IStyleHandlerOptions>): Promise<string>;
+export declare function transformTailwindV3CssByTarget(css: string, target: TailwindV3GenerateTarget, options?: Partial<IStyleHandlerOptions>): Promise<string>;

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

@@ -0,0 +1,5 @@
+import type { TailwindV3ResolvedSource, TailwindV3SourceOptions } from './types';
+import type { TailwindcssPatcherLike } from '../../types';
+export declare function resolveTailwindV3Source(options?: TailwindV3SourceOptions): Promise<TailwindV3ResolvedSource>;
+export declare function resolveTailwindV3SourceOptionsFromPatcher(patcher: TailwindcssPatcherLike): TailwindV3SourceOptions;
+export declare function resolveTailwindV3SourceFromPatcher(patcher: TailwindcssPatcherLike): Promise<TailwindV3ResolvedSource>;

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

@@ -0,0 +1,55 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { Config } from 'tailwindcss';
+export type TailwindV3GenerateTarget = 'weapp' | 'web' | 'tailwind';
+export interface TailwindV3CandidateSource {
+    content: string;
+    extension?: string;
+}
+export interface TailwindV3SourcePattern {
+    base: string;
+    pattern: string;
+    negated: boolean;
+}
+export interface TailwindV3SourceOptions {
+    projectRoot?: string;
+    cwd?: string;
+    base?: string;
+    css?: string;
+    config?: string;
+    packageName?: string;
+    postcssPlugin?: string;
+}
+export interface TailwindV3ResolvedSource {
+    version: 3;
+    projectRoot: string;
+    cwd: string;
+    base: string;
+    css: string;
+    config?: string;
+    configObject?: Config;
+    dependencies: string[];
+    packageName: string;
+    postcssPlugin: string;
+}
+export interface TailwindV3GenerateOptions {
+    candidates?: Iterable<string>;
+    sources?: TailwindV3CandidateSource[];
+    target?: TailwindV3GenerateTarget;
+    styleOptions?: Partial<IStyleHandlerOptions>;
+}
+export interface TailwindV3GenerateResult {
+    css: string;
+    rawCss: string;
+    classSet: Set<string>;
+    rawCandidates: Set<string>;
+    dependencies: string[];
+    sources: TailwindV3SourcePattern[];
+    root: null;
+    target: TailwindV3GenerateTarget;
+    version: 3;
+}
+export interface TailwindV3Engine {
+    source: TailwindV3ResolvedSource;
+    validateCandidates: (candidates: Iterable<string>) => Promise<Set<string>>;
+    generate: (options?: TailwindV3GenerateOptions) => Promise<TailwindV3GenerateResult>;
+}

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

@@ -0,0 +1,5 @@
+import type { InternalUserDefinedOptions, TailwindcssPatcherLike } 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'];

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

@@ -0,0 +1,7 @@
+export declare function guessBasedirFromEntries(entries?: string[]): string | undefined;
+export declare function normalizeCssEntries(entries: string[] | undefined, anchor: string): string[] | undefined;
+export interface GroupCssEntriesOptions {
+    preferredBaseDir?: string;
+    workspaceRoot?: string;
+}
+export declare function groupCssEntriesByBase(entries: string[], options?: GroupCssEntriesOptions): Map<string, string[]>;

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

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

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

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

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

@@ -0,0 +1,24 @@
+import type { TailwindCssPatchOptions } from 'tailwindcss-patch';
+type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
+export interface LegacyTailwindcssPatcherOptionsLike {
+    patch?: {
+        basedir?: string;
+        cwd?: string;
+        tailwindcss?: TailwindUserOptions & {
+            v4?: {
+                base?: string;
+                cssEntries?: string[];
+                sources?: Array<{
+                    base?: string;
+                    pattern: string;
+                    negated?: boolean;
+                }>;
+            };
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+type TailwindcssPatcherOptionsForBase = TailwindCssPatchOptions | LegacyTailwindcssPatcherOptionsLike | undefined;
+export declare function overrideTailwindcssPatcherOptionsForBase(options: TailwindcssPatcherOptionsForBase, baseDir: string, cssEntries: string[]): TailwindcssPatcherOptionsForBase;
+export {};

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

@@ -0,0 +1,14 @@
+import type { TailwindCssPatchOptions } from 'tailwindcss-patch';
+import type { CreateTailwindcssPatcherOptions } from '../patcher';
+import type { InternalUserDefinedOptions, TailwindcssPatcherLike } from '../../types';
+export { groupCssEntriesByBase, guessBasedirFromEntries, normalizeCssEntries } from './css-entries';
+export { createMultiTailwindcssPatcher } from './multi-patcher';
+type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
+export interface TailwindcssPatcherFactoryOptions {
+    tailwindcss?: TailwindUserOptions;
+    tailwindcssPatcherOptions?: CreateTailwindcssPatcherOptions['tailwindcssPatcherOptions'];
+    supportCustomLengthUnitsPatch: InternalUserDefinedOptions['supportCustomLengthUnitsPatch'];
+    appType: InternalUserDefinedOptions['appType'];
+}
+export declare function createPatcherForBase(baseDir: string, cssEntries: string[] | undefined, options: TailwindcssPatcherFactoryOptions): TailwindcssPatcherLike;
+export declare function tryCreateMultiTailwindcssPatcher(groups: Map<string, string[]>, options: TailwindcssPatcherFactoryOptions): TailwindcssPatcherLike | undefined;

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

@@ -0,0 +1 @@
+export { loadTailwindV4DesignSystem, resolveValidTailwindV4Candidates, } from 'tailwindcss-patch';

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

@@ -0,0 +1,2 @@
+import type { TailwindV4Engine, TailwindV4ResolvedSource } from './types';
+export declare function createTailwindV4Engine(source: TailwindV4ResolvedSource): TailwindV4Engine;

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

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

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

@@ -0,0 +1,4 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindV4GenerateTarget } from './types';
+export declare function transformTailwindV4CssToWeapp(css: string, options?: Partial<IStyleHandlerOptions>): Promise<string>;
+export declare function transformTailwindV4CssByTarget(css: string, target: TailwindV4GenerateTarget, options?: Partial<IStyleHandlerOptions>): Promise<string>;

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

@@ -0,0 +1,7 @@
+import type { TailwindV4SourceOptions } from './types';
+import type { TailwindcssPatcherLike } from '../../types';
+import { resolveTailwindV4SourceFromPatchOptions } from 'tailwindcss-patch';
+export declare function resolveTailwindV4SourceOptionsFromPatcher(patcher: TailwindcssPatcherLike): TailwindV4SourceOptions;
+export declare function resolveTailwindV4Source(options?: TailwindV4SourceOptions): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
+export declare function resolveTailwindV4SourceFromPatcher(patcher: TailwindcssPatcherLike): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
+export { resolveTailwindV4SourceFromPatchOptions };

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

@@ -0,0 +1,17 @@
+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 interface TailwindV4GenerateOptions extends PatchTailwindV4GenerateOptions {
+    target?: TailwindV4GenerateTarget;
+    styleOptions?: Partial<IStyleHandlerOptions>;
+}
+export interface TailwindV4GenerateResult extends Omit<PatchTailwindV4GenerateResult, 'css'> {
+    css: string;
+    rawCss: string;
+    target: TailwindV4GenerateTarget;
+}
+export interface TailwindV4Engine extends Omit<PatchTailwindV4Engine, 'generate'> {
+    source: TailwindV4ResolvedSource;
+    generate: (options?: TailwindV4GenerateOptions) => Promise<TailwindV4GenerateResult>;
+}
+export type { TailwindV4CandidateSource, TailwindV4DesignSystem, TailwindV4ResolvedSource, TailwindV4SourceOptions, };

package/dist/typedoc.export.d.ts

@@ -0,0 +1,5 @@
+export type { WeappTailwindcssGenerateOptions, WeappTailwindcssGenerateResult, WeappTailwindcssGenerator, WeappTailwindcssGeneratorTarget, WeappTailwindcssPostcssPluginOptions, } from './index';
+export type { DisabledOptions } from './types/disabled-options';
+export type { UserDefinedOptions } from './types/user-defined-options';
+export type { ApplyOptions, CacheOptions, ExtractOptions, TailwindCssOptions, TailwindCssPatchOptions, TailwindV2Options, TailwindV3Options, TailwindV4Options, } from 'tailwindcss-patch';
+export type TailwindcssPatchOptions = import('tailwindcss-patch').TailwindCssPatchOptions;

package/dist/types/base.d.ts

@@ -0,0 +1 @@
+export type ItemOrItemArray<T> = T | T[];

package/dist/types/disabled-options.d.ts

@@ -0,0 +1,4 @@
+export interface DisabledOptions {
+    plugin?: boolean;
+    rewriteCssImports?: boolean;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,104 @@
+import type { ParseError, ParserOptions } from '@babel/parser';
+import type { CssPreflightOptions, IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { SourceMap } from 'magic-string';
+import type { Document, Result as PostcssResult, Root } from 'postcss';
+import type { ILengthUnitsPatchOptions, TailwindcssPatcher } from 'tailwindcss-patch';
+import type { ICreateCacheReturnType } from '../cache';
+import type { ItemOrItemArray } from './base';
+import type { DisabledOptions } from './disabled-options';
+import type { AppType, IArbitraryValues, ICustomAttributesEntities } from './shared';
+import type { UniAppXComponentLocalStylesOptions, UniAppXOptions as UniAppXUserDefinedOptions, UserDefinedOptions } from './user-defined-options';
+type AsyncableMethod<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> | Awaited<R> : never;
+export type { DisabledOptions, UniAppXComponentLocalStylesOptions, UniAppXUserDefinedOptions, UserDefinedOptions, };
+export type { CssPreflightOptions, IStyleHandlerOptions, ItemOrItemArray };
+export type { AppType, IArbitraryValues, ICustomAttributes, ICustomAttributesEntities } from './shared';
+export interface LinkedJsModuleResult {
+    code: string;
+}
+export interface JsHandlerResult {
+    code: string;
+    map?: SourceMap;
+    error?: ParseError;
+    linked?: Record<string, LinkedJsModuleResult>;
+}
+export interface TailwindcssPatcherLike {
+    packageInfo: TailwindcssPatcher['packageInfo'];
+    majorVersion?: TailwindcssPatcher['majorVersion'];
+    patch: TailwindcssPatcher['patch'];
+    getClassSet: AsyncableMethod<TailwindcssPatcher['getClassSet']>;
+    getClassSetSync?: TailwindcssPatcher['getClassSetSync'];
+    extract: TailwindcssPatcher['extract'];
+    collectContentTokens?: TailwindcssPatcher['collectContentTokens'];
+    options?: TailwindcssPatcher['options'];
+}
+export interface RefreshTailwindcssPatcherOptions {
+    clearCache?: boolean;
+}
+export interface IJsHandlerOptions {
+    escapeMap?: Record<string, string>;
+    classNameSet?: Set<string>;
+    staleClassNameFallback?: boolean;
+    jsArbitraryValueFallback?: boolean | 'auto';
+    tailwindcssMajorVersion?: number;
+    arbitraryValues?: IArbitraryValues;
+    jsPreserveClass?: (keyword: string) => boolean | undefined;
+    needEscaped?: boolean;
+    generateMap?: boolean;
+    alwaysEscape?: boolean;
+    unescapeUnicode?: boolean;
+    babelParserOptions?: ParserOptions;
+    ignoreTaggedTemplateExpressionIdentifiers?: (string | RegExp)[];
+    ignoreCallExpressionIdentifiers?: (string | RegExp)[];
+    uniAppX?: boolean;
+    moduleSpecifierReplacements?: Record<string, string>;
+    wrapExpression?: boolean;
+    filename?: string;
+    moduleGraph?: JsModuleGraphOptions;
+}
+export interface JsHandler {
+    (rawSource: string, set?: Set<string>, options?: CreateJsHandlerOptions): JsHandlerResult;
+}
+export interface ICommonReplaceOptions {
+    keepEOL?: boolean;
+    escapeMap?: Record<string, string>;
+}
+export interface ITemplateHandlerOptions extends ICommonReplaceOptions {
+    customAttributesEntities?: ICustomAttributesEntities;
+    escapeMap?: Record<string, string>;
+    inlineWxs?: boolean;
+    jsHandler?: JsHandler;
+    runtimeSet?: Set<string>;
+    disabledDefaultTemplateHandler?: boolean;
+    quote?: string | null;
+    ignoreHead?: boolean;
+    wrapExpression?: boolean;
+}
+export type InternalUserDefinedOptions = Required<Omit<UserDefinedOptions, 'supportCustomLengthUnitsPatch' | 'customReplaceDictionary' | 'cache'> & {
+    supportCustomLengthUnitsPatch: ILengthUnitsPatchOptions | boolean;
+    templateHandler: (rawSource: string, options?: ITemplateHandlerOptions) => Promise<string>;
+    styleHandler: (rawSource: string, options?: IStyleHandlerOptions) => Promise<PostcssResult<Root | Document>>;
+    jsHandler: JsHandler;
+    escapeMap: Record<string, string>;
+    customReplaceDictionary: Record<string, string>;
+    cache: ICreateCacheReturnType;
+    twPatcher: TailwindcssPatcherLike;
+    refreshTailwindcssPatcher: (options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>;
+}>;
+export type InternalPostcssOptions = Pick<UserDefinedOptions, 'cssMatcher' | 'mainCssChunkMatcher' | 'cssPreflight' | 'cssPreflightRange' | 'disabled'>;
+export interface IBaseWebpackPlugin {
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    apply: (compiler: any) => void;
+}
+export interface InternalPatchResult {
+    dataTypes?: string;
+    processTailwindFeatures?: string;
+    plugin?: string;
+}
+export type CreateJsHandlerOptions = Omit<IJsHandlerOptions, 'classNameSet'>;
+export interface JsModuleGraphOptions {
+    resolve: (specifier: string, importer: string) => string | undefined;
+    load: (id: string) => string | undefined;
+    filter?: (id: string, specifier: string, importer: string) => boolean;
+    maxDepth?: number;
+}