weapp-tailwindcss 4.12.0-next.0 → 5.0.0-next.1

package/bin/weapp-tailwindcss.js

@@ -1,8 +1,28 @@
 #!/usr/bin/env node
 const fs = require('node:fs')
 const path = require('node:path')
+const process = require('node:process')
+
+function isInstallLifecycle() {
+  return process.env.npm_lifecycle_event === 'postinstall' || process.env.npm_lifecycle_event === 'prepare'
+}
+
+function isMissingRuntimeModuleError(error) {
+  return error && error.code === 'MODULE_NOT_FOUND'
+}
 
 const cliPath = path.resolve(__dirname, '../dist/cli.js')
 if (fs.existsSync(cliPath)) {
-  require(cliPath)
+  try {
+    require(cliPath)
+  }
+  catch (error) {
+    if (isInstallLifecycle() && isMissingRuntimeModuleError(error)) {
+      console.error('[weapp-tailwindcss] install lifecycle patch skipped because a runtime module is missing.')
+      console.error('Run `pnpm --filter weapp-tailwindcss build` before strict CLI validation.')
+    }
+    else {
+      throw error
+    }
+  }
 }

package/dist/babel/index.d.ts

@@ -0,0 +1,3 @@
+import _babelTraverse from '@babel/traverse';
+export { parse, parseExpression } from '@babel/parser';
+export declare const traverse: typeof _babelTraverse;

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

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

package/dist/bundlers/shared/cache.d.ts

@@ -0,0 +1,16 @@
+import type { CacheValue, HashMapKey, ICreateCacheReturnType } from '../../cache';
+export interface ProcessCachedTaskOptions<TValue extends CacheValue> {
+    cache: ICreateCacheReturnType;
+    cacheKey: string;
+    hashKey?: HashMapKey;
+    rawSource?: string;
+    hash?: string;
+    readCache?: () => TValue | undefined;
+    applyResult: (value: TValue) => void | Promise<void>;
+    transform: () => Promise<{
+        result: TValue;
+        cacheValue?: CacheValue;
+    }>;
+    onCacheHit?: () => void;
+}
+export declare function processCachedTask<TValue extends CacheValue>({ cache, cacheKey, hashKey, rawSource, hash, readCache, applyResult, transform, onCacheHit, }: ProcessCachedTaskOptions<TValue>): Promise<void>;

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

@@ -0,0 +1,4 @@
+export declare function removeUnsupportedMiniProgramAtRules(css: string): string;
+export declare function removeUnsupportedAtSupports(css: string): string;
+export declare function hoistTailwindPreflightBase(css: string): string;
+export declare function finalizeMiniProgramCss(css: string): string;

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

@@ -0,0 +1,8 @@
+import type { AppType } from '../../types';
+export interface ResolveTailwindcssImportOptions {
+    join?: (base: string, subpath: string) => string;
+    appType?: AppType;
+    rootImport?: string;
+}
+export declare function resolveTailwindcssImport(specifier: string, pkgDir: string, options?: ResolveTailwindcssImportOptions): string | null;
+export declare function rewriteTailwindcssImportsInCode(code: string, pkgDir: string, options?: ResolveTailwindcssImportOptions): string | undefined;

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

@@ -0,0 +1,5 @@
+export interface GeneratorCandidateSource {
+    content: string;
+    extension?: string;
+}
+export declare function collectGeneratorCandidatesFromSources(sources: GeneratorCandidateSource[], baseCandidates?: Iterable<string>): Promise<Set<string>>;

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

@@ -0,0 +1,41 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { InternalUserDefinedOptions } from '../../types';
+export interface GenerateCssByGeneratorOptions {
+    opts: InternalUserDefinedOptions;
+    runtimeState: {
+        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        patchPromise: Promise<void>;
+    };
+    runtime: Set<string>;
+    rawSource: string;
+    file: string;
+    cssHandlerOptions: IStyleHandlerOptions;
+    cssUserHandlerOptions: IStyleHandlerOptions;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+    debug: (format: string, ...args: unknown[]) => void;
+}
+export interface GenerateCssByGeneratorResult {
+    css: string;
+    target: string;
+    source: 'generator' | 'generator-forced';
+}
+export declare function createCssAppend(base: string, extra: string): string;
+export declare function splitTailwindV4GeneratedCss(rawSource: string, rawTailwindCss: string): string | undefined;
+export declare function removeTailwindGeneratedCssByBanner(rawSource: string): string | undefined;
+export declare function stripTailwindBanner(css: string): string;
+export declare function stripTailwindBanners(css: string): string;
+export declare function stripGeneratorPlaceholderMarkers(css: string): string;
+export declare function hasTailwindGeneratedCss(rawSource: string): boolean;
+export declare function hasTailwindGeneratedCssMarkers(rawSource: string): boolean;
+export declare function inheritLegacyUnitConvertedDeclarations(css: string, legacyCss: string): string;
+export declare function removeTailwindSourceDirectives(rawSource: string): string;
+export declare function hasTailwindSourceDirectives(rawSource: string): boolean;
+export declare function resolveCssEntrySource(rawSource: string, base: string): {
+    css: string;
+    config: string | undefined;
+    configRequest: string | undefined;
+    base: string;
+} | undefined;
+export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GenerateCssByGeneratorOptions['runtimeState'], rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions): Promise<import("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource>;
+export declare function isPureLocalCssImportWrapper(css: string): boolean;
+export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/bundlers/shared/module-graph.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeOutputPathKey(value: string): string;
+export declare function stripQueryAndHash(specifier: string): string;
+export declare function isResolvableSpecifier(specifier: string): boolean;
+export declare function toAbsoluteOutputPath(fileName: string, outDir: string): string;
+export declare function resolveOutputSpecifier(specifier: string, importer: string, outDir: string, hasOutput: (value: string) => boolean): string | undefined;

package/dist/bundlers/shared/run-tasks.d.ts

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

package/dist/bundlers/vite/bundle-entries.d.ts

@@ -0,0 +1,14 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { LinkedJsModuleResult } from '../../types';
+export interface OutputEntry {
+    fileName: string;
+    output: OutputAsset | OutputChunk;
+}
+export declare function readOutputEntry(entry: OutputEntry): string | undefined;
+export declare function isJavaScriptEntry(entry: OutputEntry): boolean;
+export declare function createBundleModuleGraphOptions(outputDir: string, entries: Map<string, OutputEntry>): {
+    resolve(specifier: string, importer: string): string | undefined;
+    load(id: string): string | undefined;
+    filter(id: string): boolean;
+};
+export declare function applyLinkedResults(linked: Record<string, LinkedJsModuleResult> | undefined, entries: Map<string, OutputEntry>, onLinkedUpdate: (fileName: string, previous: string, next: string) => void, onApplied?: (entry: OutputEntry, code: string) => void): void;

package/dist/bundlers/vite/bundle-state.d.ts

@@ -0,0 +1,43 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { OutputEntry } from './bundle-entries';
+import type { InternalUserDefinedOptions } from '../../types';
+export type EntryType = 'html' | 'js' | 'css' | 'other';
+export interface BundleStateEntry {
+    file: string;
+    output: OutputAsset | OutputChunk;
+    source: string;
+    type: EntryType;
+}
+export interface ProcessFileSets {
+    html: Set<string>;
+    js: Set<string>;
+    css: Set<string>;
+}
+export interface BundleSnapshot {
+    entries: BundleStateEntry[];
+    jsEntries: Map<string, OutputEntry>;
+    sourceHashByFile: Map<string, string>;
+    runtimeAffectingSignatureByFile: Map<string, string>;
+    runtimeAffectingHashByFile: Map<string, string>;
+    changedByType: Record<EntryType, Set<string>>;
+    runtimeAffectingChangedByType: Record<EntryType, Set<string>>;
+    processFiles: ProcessFileSets;
+    linkedImpactsByEntry: Map<string, Set<string>>;
+}
+export interface BundleBuildState {
+    iteration: number;
+    sourceHashByFile: Map<string, string>;
+    runtimeAffectingSignatureByFile: Map<string, string>;
+    runtimeAffectingHashByFile: Map<string, string>;
+    linkedByEntry: Map<string, Set<string>>;
+    dependentsByLinkedFile: Map<string, Set<string>>;
+}
+interface UpdateBundleBuildStateOptions {
+    incremental?: boolean;
+}
+export declare function createBundleBuildState(): BundleBuildState;
+export declare function classifyBundleEntry(file: string, opts: InternalUserDefinedOptions): EntryType;
+export declare function buildBundleSnapshot(bundle: Record<string, OutputAsset | OutputChunk>, opts: InternalUserDefinedOptions, outDir: string, state: BundleBuildState, forceAll?: boolean): BundleSnapshot;
+export declare function buildBundleSnapshotForBuild(bundle: Record<string, OutputAsset | OutputChunk>, opts: InternalUserDefinedOptions, outDir: string): BundleSnapshot;
+export declare function updateBundleBuildState(state: BundleBuildState, snapshot: BundleSnapshot, linkedByEntry: Map<string, Set<string>>, options?: UpdateBundleBuildStateOptions): void;
+export {};

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

@@ -0,0 +1,19 @@
+import type { OutputAsset } from 'rollup';
+import type { Plugin, ResolvedConfig } from 'vite';
+import type { InternalUserDefinedOptions } from '../../types';
+interface CssFinalizerContext {
+    opts: InternalUserDefinedOptions;
+    runtimeState: {
+        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        patchPromise: Promise<void>;
+    };
+    ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
+    isCssAssetProcessed: (asset: OutputAsset, file?: string) => boolean;
+    markCssAssetProcessed: (asset: OutputAsset, file?: string) => void;
+    debug: (format: string, ...args: unknown[]) => void;
+    getResolvedConfig: () => ResolvedConfig | undefined;
+    recordCssAssetResult?: (file: string, css: string) => void;
+    getRecordedGeneratorCandidates?: () => Set<string> | undefined;
+}
+export declare function createViteCssFinalizerOutputPlugin(context: CssFinalizerContext): Plugin;
+export {};

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

@@ -0,0 +1,20 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { ResolvedConfig } from 'vite';
+import type { BundleSnapshot } from './bundle-state';
+import type { InternalUserDefinedOptions } from '../../types';
+interface GenerateBundleContext {
+    opts: InternalUserDefinedOptions;
+    runtimeState: {
+        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        patchPromise: Promise<void>;
+    };
+    ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    debug: (format: string, ...args: unknown[]) => void;
+    getResolvedConfig: () => ResolvedConfig | undefined;
+    markCssAssetProcessed?: (asset: OutputAsset, file?: string) => void;
+    recordCssAssetResult?: (file: string, css: string) => void;
+    recordGeneratorCandidates?: (candidates: Set<string>) => void;
+}
+export declare function createGenerateBundleHook(context: GenerateBundleContext): (_opt: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;
+export {};

package/dist/bundlers/vite/incremental-runtime-class-set.d.ts

@@ -0,0 +1,21 @@
+import type { BundleSnapshot } from './bundle-state';
+import type { TailwindcssPatcherLike } from '../../types';
+import { extractRawCandidatesWithPositions, extractValidCandidates } from 'tailwindcss-patch';
+type ExtractValidCandidatesOptions = Parameters<typeof extractValidCandidates>[0];
+type MemoryExtractValidCandidatesOptions = ExtractValidCandidatesOptions & {
+    content?: string;
+    extension?: string;
+};
+type ExtractValidCandidatesFn = (options?: MemoryExtractValidCandidatesOptions) => Promise<string[]>;
+type ExtractRawCandidateResult = Awaited<ReturnType<typeof extractRawCandidatesWithPositions>>;
+type ExtractRawCandidatesFn = (content: string, extension?: string) => Promise<ExtractRawCandidateResult>;
+export interface BundleRuntimeClassSetManager {
+    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot) => Promise<Set<string>>;
+    reset: () => Promise<void>;
+}
+interface CreateBundleRuntimeClassSetManagerOptions {
+    extractCandidates?: ExtractValidCandidatesFn;
+    extractRawCandidates?: ExtractRawCandidatesFn;
+}
+export declare function createBundleRuntimeClassSetManager(options?: CreateBundleRuntimeClassSetManagerOptions): BundleRuntimeClassSetManager;
+export {};

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

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { UserDefinedOptions } from '../../types';
+export declare function UnifiedViteWeappTailwindcssPlugin(options?: UserDefinedOptions): Plugin[] | undefined;

package/dist/bundlers/vite/js-precheck.d.ts

@@ -0,0 +1 @@
+export { shouldSkipJsTransform as shouldSkipViteJsTransform } from '../../js/precheck';

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

@@ -0,0 +1,15 @@
+export interface VueQuery {
+    vue?: boolean;
+    src?: string;
+    type?: 'script' | 'template' | 'style' | 'custom';
+    index?: number;
+    lang?: string;
+    raw?: boolean;
+    url?: boolean;
+    scoped?: boolean;
+    id?: string;
+}
+export declare function parseVueRequest(id: string): {
+    filename: string;
+    query: VueQuery;
+};

package/dist/bundlers/vite/resolve-app-type.d.ts

@@ -0,0 +1,2 @@
+import type { AppType } from '../../types';
+export declare function resolveImplicitAppTypeFromViteRoot(root: string): AppType | undefined;

package/dist/bundlers/vite/rewrite-css-imports.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+import type { AppType } from '../../types';
+interface RewriteCssImportsOptions {
+    appType?: AppType;
+    getAppType?: () => AppType | undefined;
+    shouldRewrite: boolean;
+    rootImport?: string;
+    weappTailwindcssDirPosix: string;
+}
+export declare function createRewriteCssImportsPlugins(options: RewriteCssImportsOptions): Plugin[];
+export {};

package/dist/bundlers/vite/runtime-affecting-signature.d.ts

@@ -0,0 +1,2 @@
+import type { EntryType } from './bundle-state';
+export declare function createRuntimeAffectingSourceSignature(source: string, type: EntryType): string;

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

@@ -0,0 +1,9 @@
+import type { ExistingRawSourceMap } from 'rollup';
+import { cleanUrl } from '@weapp-tailwindcss/shared';
+export declare function slash(p: string): string;
+export declare const isWindows: boolean;
+export declare const cssLangRE: RegExp;
+export declare function isCSSRequest(request: string): boolean;
+export declare function normalizePath(id: string): string;
+export { cleanUrl };
+export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;

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

@@ -0,0 +1,20 @@
+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 hasLoaderEntry(entries: Array<{
+    loader?: string;
+}>, target?: string): boolean;
+interface ChunkLike {
+    id?: string | number | null;
+    name?: string;
+    hash?: string | null;
+    files?: Iterable<string> | Array<string>;
+}
+interface WebpackWatchChangeLike {
+    modifiedFiles?: Set<string>;
+    removedFiles?: Set<string>;
+}
+export declare function createAssetHashByChunkMap(chunks: Iterable<ChunkLike>): Map<string, string>;
+export declare function hasWatchChanges(compiler: WebpackWatchChangeLike): boolean;
+export {};

package/dist/bundlers/webpack/BaseUnifiedPlugin/v4-assets.d.ts

@@ -0,0 +1,14 @@
+import type { Compiler } from 'webpack4';
+import type { AppType, InternalUserDefinedOptions } from '../../../types';
+interface SetupWebpackV4EmitHookOptions {
+    compiler: Compiler;
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    runtimeState: {
+        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        patchPromise: Promise<void>;
+    };
+    debug: (format: string, ...args: unknown[]) => void;
+}
+export declare function setupWebpackV4EmitHook(options: SetupWebpackV4EmitHookOptions): void;
+export {};

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

@@ -0,0 +1,15 @@
+import type { Compiler } from 'webpack4';
+import type { AppType, InternalUserDefinedOptions } from '../../../types';
+interface SetupWebpackV4LoadersOptions {
+    compiler: Compiler;
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    weappTailwindcssPackageDir: string;
+    shouldRewriteCssImports: boolean;
+    runtimeLoaderPath?: string;
+    runtimeCssImportRewriteLoaderPath?: string;
+    getClassSetInLoader: () => Promise<void>;
+    debug: (format: string, ...args: unknown[]) => void;
+}
+export declare function setupWebpackV4Loaders(options: SetupWebpackV4LoadersOptions): void;
+export {};

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

@@ -0,0 +1,9 @@
+import type { Compiler } from 'webpack4';
+import type { AppType, IBaseWebpackPlugin, InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
+export declare const weappTailwindcssPackageDir: string;
+export declare class UnifiedWebpackPluginV4 implements IBaseWebpackPlugin {
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    constructor(options?: UserDefinedOptions);
+    apply(compiler: Compiler): void;
+}

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

@@ -0,0 +1,17 @@
+import type { Compiler } from 'webpack';
+import type { AppType, InternalUserDefinedOptions } from '../../../types';
+interface SetupWebpackV5ProcessAssetsHookOptions {
+    compiler: Compiler;
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    runtimeState: {
+        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        patchPromise: Promise<void>;
+    };
+    getRuntimeRefreshRequirement: () => boolean;
+    refreshRuntimeMetadata: (force: boolean) => Promise<void>;
+    consumeRuntimeRefreshRequirement: () => void;
+    debug: (format: string, ...args: unknown[]) => void;
+}
+export declare function setupWebpackV5ProcessAssetsHook(options: SetupWebpackV5ProcessAssetsHookOptions): void;
+export {};

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

@@ -0,0 +1,19 @@
+import type { Compiler } from 'webpack';
+import type { AppType, InternalUserDefinedOptions } from '../../../types';
+interface SetupWebpackV5LoadersOptions {
+    compiler: Compiler;
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    weappTailwindcssPackageDir: string;
+    shouldRewriteCssImports: boolean;
+    runtimeLoaderPath?: string;
+    runtimeCssImportRewriteLoaderPath?: string;
+    getClassSetInLoader: () => Promise<void>;
+    getRuntimeWatchDependencies: () => {
+        files: ReadonlySet<string>;
+        contexts: ReadonlySet<string>;
+    };
+    debug: (format: string, ...args: unknown[]) => void;
+}
+export declare function setupWebpackV5Loaders(options: SetupWebpackV5LoadersOptions): void;
+export {};

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

@@ -0,0 +1,9 @@
+import type { Compiler } from 'webpack';
+import type { AppType, IBaseWebpackPlugin, InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
+export declare const weappTailwindcssPackageDir: string;
+export declare class UnifiedWebpackPluginV5 implements IBaseWebpackPlugin {
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    constructor(options?: UserDefinedOptions);
+    apply(compiler: Compiler): void;
+}

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

@@ -0,0 +1 @@
+export * from './BaseUnifiedPlugin/v5';

package/dist/bundlers/webpack/loaders/weapp-tw-css-import-rewrite-loader.d.ts

@@ -0,0 +1,12 @@
+import type webpack from 'webpack';
+import type { AppType } from '../../../types';
+import { Buffer } from 'node:buffer';
+interface CssImportRewriteLoaderOptions {
+    rewriteCssImports?: {
+        pkgDir: string;
+        appType?: AppType;
+    };
+}
+export declare function transformCssImportRewriteSource(source: string | Buffer, options: CssImportRewriteLoaderOptions | undefined): string | Buffer<ArrayBufferLike>;
+declare const WeappTwCssImportRewriteLoader: webpack.LoaderDefinitionFunction<CssImportRewriteLoaderOptions>;
+export default WeappTwCssImportRewriteLoader;

package/dist/bundlers/webpack/loaders/weapp-tw-runtime-classset-loader.d.ts

@@ -0,0 +1,11 @@
+import type webpack from 'webpack';
+interface RuntimeClassSetLoaderOptions {
+    getClassSet?: () => void | Promise<void>;
+    getWatchDependencies?: () => RuntimeLoaderWatchDependencies | Promise<RuntimeLoaderWatchDependencies | void> | void;
+}
+interface RuntimeLoaderWatchDependencies {
+    files?: Iterable<string>;
+    contexts?: Iterable<string>;
+}
+declare const WeappTwRuntimeClassSetLoader: webpack.LoaderDefinitionFunction<RuntimeClassSetLoaderOptions>;
+export default WeappTwRuntimeClassSetLoader;

package/dist/bundlers/webpack/shared/css-imports.d.ts

@@ -0,0 +1,6 @@
+import type { AppType } from '../../../types';
+export declare function applyTailwindcssCssImportRewrite(compiler: any, options: {
+    pkgDir: string;
+    enabled: boolean;
+    appType?: AppType;
+}): void;

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

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

package/dist/cache/index.d.ts

@@ -0,0 +1,38 @@
+import type { Buffer } from 'node:buffer';
+import type { sources } from 'webpack';
+import { LRUCache } from 'lru-cache';
+export interface HashMapValue {
+    hash: string;
+    changed: boolean;
+}
+export type HashMapKey = string | number;
+export type CacheValue = sources.Source | string;
+export interface CacheProcessResult<T extends CacheValue> {
+    result: T;
+    cacheValue?: CacheValue;
+}
+export interface CacheProcessOptions<T extends CacheValue> {
+    key: string;
+    hashKey?: HashMapKey;
+    rawSource?: string | Buffer;
+    hash?: string;
+    resolveCache?: () => T | undefined;
+    transform: () => Promise<CacheProcessResult<T> | T>;
+    onCacheHit?: (value: T) => void | Promise<void>;
+}
+export interface ICreateCacheReturnType {
+    readonly hashMap: Map<HashMapKey, HashMapValue>;
+    readonly instance: LRUCache<string, CacheValue>;
+    hasHashKey: (key: HashMapKey) => boolean;
+    getHashValue: (key: HashMapKey) => HashMapValue | undefined;
+    setHashValue: (key: HashMapKey, value: HashMapValue) => Map<HashMapKey, HashMapValue>;
+    computeHash: (message: string | Buffer) => string;
+    get: <V extends CacheValue = sources.Source>(key: string) => V | undefined;
+    set: <V extends CacheValue = sources.Source>(key: string, value: V) => LRUCache<string, CacheValue>;
+    has: (key: string) => boolean;
+    calcHashValueChanged: (key: HashMapKey, hash: string) => ICreateCacheReturnType;
+    process: <T extends CacheValue>(options: CacheProcessOptions<T>) => Promise<T>;
+}
+declare function createCache(options?: boolean): ICreateCacheReturnType;
+declare function initializeCache(cacheConfig?: boolean | ICreateCacheReturnType): ICreateCacheReturnType;
+export { createCache, initializeCache };

package/dist/cache/md5.d.ts

@@ -0,0 +1 @@
+export { md5 as md5Hash } from '@weapp-tailwindcss/shared/node';

package/dist/chunk-8l464Juk.js

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/cli/config.d.ts

@@ -0,0 +1,5 @@
+export interface TailwindcssMangleConfigModule {
+    initConfig: (cwd: string) => Promise<void>;
+    CONFIG_NAME: string;
+}
+export declare function loadTailwindcssMangleConfig(): Promise<TailwindcssMangleConfigModule | undefined>;

package/dist/cli/context.d.ts

@@ -0,0 +1,16 @@
+import type { CompatTailwindCssPatchOptions } from '../tailwindcss/patcher-options';
+import type { UserDefinedOptions } from '../types';
+export declare function resolveEntry(entry: string, cwd: string | undefined): string;
+export declare function buildTailwindcssPatcherOptions(overrides: Partial<CompatTailwindCssPatchOptions> | undefined): CompatTailwindCssPatchOptions | undefined;
+export declare function createCliContext(overrides: Partial<UserDefinedOptions> | undefined, resolvedCwd: string | undefined): Required<Omit<UserDefinedOptions, "supportCustomLengthUnitsPatch" | "customReplaceDictionary" | "cache"> & {
+    supportCustomLengthUnitsPatch: import("tailwindcss-patch").ILengthUnitsPatchOptions | boolean;
+    templateHandler: (rawSource: string, options?: import("@/types").ITemplateHandlerOptions) => Promise<string>;
+    styleHandler: (rawSource: string, options?: import("@weapp-tailwindcss/postcss").IStyleHandlerOptions) => Promise<import("postcss").Result<import("postcss").Root | import("postcss").Document>>;
+    jsHandler: import("@/types").JsHandler;
+    escapeMap: Record<string, string>;
+    customReplaceDictionary: Record<string, string>;
+    cache: import("../cache").ICreateCacheReturnType;
+    twPatcher: import("@/types").TailwindcssPatcherLike;
+    refreshTailwindcssPatcher: (options?: import("@/types").RefreshTailwindcssPatcherOptions) => Promise<import("@/types").TailwindcssPatcherLike>;
+}>;
+export declare function formatOutputPath(target: string, baseDir?: string): string;

package/dist/cli/doctor/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const CONFIG_FILES: {
+    tailwind: string[];
+    postcss: string[];
+    vite: string[];
+    webpack: string[];
+};
+export declare const FRAMEWORK_DEPS: Array<[string, string]>;

package/dist/cli/doctor/types.d.ts

@@ -0,0 +1,31 @@
+export type DoctorCheckStatus = 'ok' | 'warn' | 'error' | 'info';
+export interface DoctorCheck {
+    id: string;
+    title: string;
+    status: DoctorCheckStatus;
+    message: string;
+    suggestion?: string;
+}
+export interface DoctorReport {
+    cwd: string;
+    nodeVersion: string;
+    detected: {
+        packageManager?: string;
+        frameworks: string[];
+        tailwindcssVersion?: string;
+        weappTailwindcssVersion?: string;
+    };
+    summary: Record<DoctorCheckStatus, number>;
+    checks: DoctorCheck[];
+}
+export interface DoctorOptions {
+    cwd?: string;
+    nodeVersion?: string;
+}
+export interface PackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    packageManager?: string;
+}

package/dist/cli/doctor.d.ts

@@ -0,0 +1,4 @@
+import type { DoctorOptions, DoctorReport } from './doctor/types';
+export declare function createDoctorReport(options?: DoctorOptions): DoctorReport;
+export declare function hasDoctorFailure(report: DoctorReport, strict?: boolean): boolean;
+export declare function formatDoctorReport(report: DoctorReport): string;

package/dist/cli/helpers/options/format.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeTokenFormat(format: string): "json" | "lines" | "grouped-json";
+export declare function normalizeExtractFormat(format: string | undefined): 'json' | 'lines' | undefined;

package/dist/cli/helpers/options/parse.d.ts

@@ -0,0 +1,3 @@
+export declare function readStringOption(flag: string, value: unknown): string | undefined;
+export declare function readStringArrayOption(flag: string, value: unknown): string[] | undefined;
+export declare function toBoolean(value: unknown, fallback: boolean): boolean;