weapp-tailwindcss 5.0.0-next.10 → 5.0.0-next.13

package/dist/{bundle-state-EUbcdKqo.js → bundle-state-Bz8vLnCf.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_precheck = require("./precheck-B32p-gLI.js");
+const require_precheck = require("./precheck-CRX-pMKJ.js");
 let node_module = require("node:module");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
@@ -49,6 +49,30 @@ function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
 	return matchWithExtensions(candidate, hasOutput);
 }
 //#endregion
+//#region src/bundlers/shared/style-requests.ts
+const SOURCE_STYLE_EXT_RE = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
+const STYLE_QUERY_RE = /(?:^|&)type=styles?(?:&|$)/;
+const STYLE_LANG_QUERY_RE = /(?:^|&)lang(?:[.=](?:css|scss|sass|less|styl|stylus|pcss|postcss))?(?:&|$)/;
+function stripHash(request) {
+	const hashIndex = request.indexOf("#");
+	return hashIndex === -1 ? request : request.slice(0, hashIndex);
+}
+function stripRequestQuery(request) {
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	return queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+}
+function isSourceStyleRequest(request) {
+	if (typeof request !== "string" || request.length === 0) return false;
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	const pathname = queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+	if (SOURCE_STYLE_EXT_RE.test(pathname)) return true;
+	if (queryIndex === -1) return false;
+	const query = normalized.slice(queryIndex + 1);
+	return STYLE_QUERY_RE.test(query) || STYLE_LANG_QUERY_RE.test(query);
+}
+//#endregion
 //#region src/utils/disabled.ts
 function resolvePluginDisabledState(disabled) {
 	if (disabled === true) return { plugin: true };
@@ -73,7 +97,9 @@ async function runWithConcurrency(factories, limit = Math.min(4, Math.max(1, fac
 	const scheduleNext = () => {
 		if (cursor >= factories.length) return;
 		const currentIndex = cursor++;
-		const wrapped = Promise.resolve(factories[currentIndex]()).then((value) => {
+		const factory = factories[currentIndex];
+		if (!factory) return;
+		const wrapped = Promise.resolve(factory()).then((value) => {
 			results[currentIndex] = value;
 		}).finally(() => {
 			executing.delete(wrapped);
@@ -217,7 +243,8 @@ function createBundleBuildState() {
 		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
 		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
 		linkedByEntry: /* @__PURE__ */ new Map(),
-		dependentsByLinkedFile: /* @__PURE__ */ new Map()
+		dependentsByLinkedFile: /* @__PURE__ */ new Map(),
+		generatorCandidateSignature: void 0
 	};
 }
 function createChangedByType() {
@@ -366,6 +393,12 @@ Object.defineProperty(exports, "createBundleModuleGraphOptions", {
 		return createBundleModuleGraphOptions;
 	}
 });
+Object.defineProperty(exports, "isSourceStyleRequest", {
+	enumerable: true,
+	get: function() {
+		return isSourceStyleRequest;
+	}
+});
 Object.defineProperty(exports, "normalizeOutputPathKey", {
 	enumerable: true,
 	get: function() {
@@ -396,6 +429,12 @@ Object.defineProperty(exports, "resolvePluginDisabledState", {
 		return resolvePluginDisabledState;
 	}
 });
+Object.defineProperty(exports, "stripRequestQuery", {
+	enumerable: true,
+	get: function() {
+		return stripRequestQuery;
+	}
+});
 Object.defineProperty(exports, "toAbsoluteOutputPath", {
 	enumerable: true,
 	get: function() {

package/dist/{bundle-state-BWqi5ZyX.mjs → bundle-state-CP2XS3Uj.mjs}

@@ -1,4 +1,4 @@
-import { d as traverse, u as babelParse } from "./precheck-B4RH6ZNN.mjs";
+import { d as traverse, u as babelParse } from "./precheck-SG48aLG2.mjs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { Buffer } from "node:buffer";
@@ -47,6 +47,30 @@ function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
 	return matchWithExtensions(candidate, hasOutput);
 }
 //#endregion
+//#region src/bundlers/shared/style-requests.ts
+const SOURCE_STYLE_EXT_RE = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
+const STYLE_QUERY_RE = /(?:^|&)type=styles?(?:&|$)/;
+const STYLE_LANG_QUERY_RE = /(?:^|&)lang(?:[.=](?:css|scss|sass|less|styl|stylus|pcss|postcss))?(?:&|$)/;
+function stripHash(request) {
+	const hashIndex = request.indexOf("#");
+	return hashIndex === -1 ? request : request.slice(0, hashIndex);
+}
+function stripRequestQuery(request) {
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	return queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+}
+function isSourceStyleRequest(request) {
+	if (typeof request !== "string" || request.length === 0) return false;
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	const pathname = queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+	if (SOURCE_STYLE_EXT_RE.test(pathname)) return true;
+	if (queryIndex === -1) return false;
+	const query = normalized.slice(queryIndex + 1);
+	return STYLE_QUERY_RE.test(query) || STYLE_LANG_QUERY_RE.test(query);
+}
+//#endregion
 //#region src/utils/disabled.ts
 function resolvePluginDisabledState(disabled) {
 	if (disabled === true) return { plugin: true };
@@ -71,7 +95,9 @@ async function runWithConcurrency(factories, limit = Math.min(4, Math.max(1, fac
 	const scheduleNext = () => {
 		if (cursor >= factories.length) return;
 		const currentIndex = cursor++;
-		const wrapped = Promise.resolve(factories[currentIndex]()).then((value) => {
+		const factory = factories[currentIndex];
+		if (!factory) return;
+		const wrapped = Promise.resolve(factory()).then((value) => {
 			results[currentIndex] = value;
 		}).finally(() => {
 			executing.delete(wrapped);
@@ -215,7 +241,8 @@ function createBundleBuildState() {
 		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
 		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
 		linkedByEntry: /* @__PURE__ */ new Map(),
-		dependentsByLinkedFile: /* @__PURE__ */ new Map()
+		dependentsByLinkedFile: /* @__PURE__ */ new Map(),
+		generatorCandidateSignature: void 0
 	};
 }
 function createChangedByType() {
@@ -340,4 +367,4 @@ function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
 	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
 }
 //#endregion
-export { createBundleModuleGraphOptions as a, resolvePluginDisabledState as c, toAbsoluteOutputPath as d, applyLinkedResults as i, normalizeOutputPathKey as l, createBundleBuildState as n, pushConcurrentTaskFactories as o, updateBundleBuildState as r, resolvePackageDir as s, buildBundleSnapshot as t, resolveOutputSpecifier as u };
+export { createBundleModuleGraphOptions as a, resolvePluginDisabledState as c, normalizeOutputPathKey as d, resolveOutputSpecifier as f, applyLinkedResults as i, isSourceStyleRequest as l, createBundleBuildState as n, pushConcurrentTaskFactories as o, toAbsoluteOutputPath as p, updateBundleBuildState as r, resolvePackageDir as s, buildBundleSnapshot as t, stripRequestQuery as u };

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

@@ -2,15 +2,15 @@ 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;
+    hashKey?: HashMapKey | undefined;
+    rawSource?: string | undefined;
+    hash?: string | undefined;
+    readCache?: (() => TValue | undefined) | undefined;
     applyResult: (value: TValue) => void | Promise<void>;
     transform: () => Promise<{
         result: TValue;
-        cacheValue?: CacheValue;
+        cacheValue?: CacheValue | undefined;
     }>;
-    onCacheHit?: () => void;
+    onCacheHit?: (() => void) | undefined;
 }
 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

@@ -1,3 +1,8 @@
+import type { CssPreflightOptions } from '../../types';
 export { removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules } from './css-cleanup/at-rules';
+interface FinalizeMiniProgramCssOptions {
+    cssPreflight?: CssPreflightOptions | undefined;
+    preservePseudoContentInit?: boolean;
+}
 export declare function hoistTailwindPreflightBase(css: string): string;
-export declare function finalizeMiniProgramCss(css: string): string;
+export declare function finalizeMiniProgramCss(css: string, options?: FinalizeMiniProgramCssOptions): string;

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

@@ -1,8 +1,8 @@
 import type { AppType } from '../../types';
 export interface ResolveTailwindcssImportOptions {
-    join?: (base: string, subpath: string) => string;
-    appType?: AppType;
-    rootImport?: string;
+    join?: ((base: string, subpath: string) => string) | undefined;
+    appType?: AppType | undefined;
+    rootImport?: string | undefined;
 }
 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-css/directives.d.ts

@@ -1,13 +1,20 @@
+interface TailwindDirectiveOptions {
+    importFallback?: boolean | undefined;
+}
 export declare function parseImportRequest(params: string): string | undefined;
-export declare function removeTailwindSourceDirectives(rawSource: string): string;
-export declare function hasTailwindSourceDirectives(rawSource: string): boolean;
-export declare function hasTailwindRootDirectives(rawSource: string): boolean;
+export declare function normalizeTailwindSourceForGenerator(rawSource: string, options?: TailwindDirectiveOptions): string;
+export declare function normalizeTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): string;
+export declare function removeTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): string;
+export declare function hasTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
+export declare function hasTailwindRootDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
 export declare function hasTailwindApplyDirective(rawSource: string): boolean;
 export declare function resolveCssEntrySource(rawSource: string, base: string, options?: {
     removeConfig?: boolean;
+    importFallback?: boolean;
 }): {
     css: string;
     config: string | undefined;
     configRequest: string | undefined;
     base: string;
 } | undefined;
+export {};

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

@@ -1,11 +1,14 @@
+export interface SourceSideCssEntrySource {
+    css: string;
+    config?: string | undefined;
+    configRequest?: string | undefined;
+    base: string;
+    file: string;
+}
 export declare function resolveSourceSideCssEntrySource(file: string, sourceOptions: {
     projectRoot?: string;
     cwd?: string;
+    outputRoot?: string;
 }, resolveOptions?: {
     removeConfig?: boolean;
-}): {
-    css: string;
-    config: string | undefined;
-    configRequest: string | undefined;
-    base: string;
-} | undefined;
+}): SourceSideCssEntrySource | undefined;

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

@@ -1,10 +1,24 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../../generator';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 interface GeneratorSourceRuntimeState {
     twPatcher: InternalUserDefinedOptions['twPatcher'];
 }
+interface GeneratorSourceSelectionOptions {
+    runtime?: Set<string> | undefined;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+}
+export interface GeneratorSourceMetadata {
+    matchedCssSourceFile?: string | undefined;
+    sourceBase?: string | undefined;
+    sourceCss?: string | undefined;
+}
+export type GeneratorResolvedSource = TailwindResolvedSource & {
+    __weappTailwindcssMeta?: GeneratorSourceMetadata | undefined;
+};
 export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;
-export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions): Promise<import("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource>;
-export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions): Promise<TailwindResolvedSource[]>;
+export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource | import("@/generator").TailwindV3ResolvedSource | undefined>;
+export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<TailwindResolvedSource[]>;
+export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<TailwindSourceEntry[] | undefined>;
 export {};

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

@@ -1,6 +1,7 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
-export { hasTailwindSourceDirectives, removeTailwindSourceDirectives, resolveCssEntrySource, } from './generator-css/directives';
+export { hasTailwindSourceDirectives, normalizeTailwindSourceForGenerator, removeTailwindSourceDirectives, resolveCssEntrySource, } from './generator-css/directives';
 export { removeTailwindApplyRules, } from './generator-css/legacy-compat';
 export { inheritLegacyUnitConvertedDeclarations, } from './generator-css/legacy-units';
 export { createCssAppend, hasTailwindGeneratedCss, hasTailwindGeneratedCssMarkers, removeTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, } from './generator-css/markers';
@@ -16,14 +17,17 @@ export interface GenerateCssByGeneratorOptions {
     file: string;
     cssHandlerOptions: IStyleHandlerOptions;
     cssUserHandlerOptions: IStyleHandlerOptions;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     debug: (format: string, ...args: unknown[]) => void;
+    previousCss?: string | undefined;
 }
 export interface GenerateCssByGeneratorResult {
     css: string;
     target: string;
     source: 'generator';
     dependencies: string[];
+    incremental?: boolean | undefined;
 }
 export declare function isPureLocalCssImportWrapper(css: string): boolean;
 export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/bundlers/shared/hmr-timing.d.ts

@@ -0,0 +1,22 @@
+export interface HmrTimingDetails {
+    emit?: boolean;
+    file?: string;
+    hooks?: Record<string, HmrTimingHookSummary>;
+    metric?: 'hook' | 'total';
+    wallMs?: number;
+}
+export interface HmrTimingHookSummary {
+    count: number;
+    durationMs: number;
+    maxMs: number;
+}
+type HmrTimingBundler = 'vite' | 'webpack' | 'gulp';
+export interface HmrTimingRecorder {
+    emitTotal: (phase?: string) => void;
+    measure: <T>(phase: string, task: () => T | Promise<T>, details?: HmrTimingDetails) => Promise<T>;
+    record: (phase: string, durationMs: number, details?: HmrTimingDetails) => void;
+}
+export declare function shouldEmitHmrTiming(): boolean;
+export declare function emitHmrTiming(bundler: HmrTimingBundler, phase: string, durationMs: number, details?: HmrTimingDetails): void;
+export declare function createHmrTimingRecorder(bundler: HmrTimingBundler): HmrTimingRecorder;
+export {};

package/dist/bundlers/shared/style-requests.d.ts

@@ -0,0 +1,2 @@
+export declare function stripRequestQuery(request: string): string;
+export declare function isSourceStyleRequest(request: string | undefined): boolean;

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

@@ -31,6 +31,7 @@ export interface BundleBuildState {
     runtimeAffectingHashByFile: Map<string, string>;
     linkedByEntry: Map<string, Set<string>>;
     dependentsByLinkedFile: Map<string, Set<string>>;
+    generatorCandidateSignature?: string | undefined;
 }
 interface UpdateBundleBuildStateOptions {
     incremental?: boolean;

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 { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface CssFinalizerContext {
     opts: InternalUserDefinedOptions;
@@ -15,6 +16,7 @@ interface CssFinalizerContext {
     recordCssAssetResult?: (file: string, css: string) => void;
     getRecordedGeneratorCandidates?: () => Set<string> | undefined;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string) => void;
 }

package/dist/bundlers/vite/generate-bundle/css-handler-options.d.ts

@@ -6,11 +6,15 @@ type CssHandlerOptions = IStyleHandlerOptions & {
         };
     };
     majorVersion: number | undefined;
+    sourceOptions?: {
+        outputRoot?: string | undefined;
+    } | undefined;
 };
 interface CssHandlerOptionsCacheOptions {
-    appType: InternalUserDefinedOptions['appType'];
+    getAppType: () => InternalUserDefinedOptions['appType'];
     mainCssChunkMatcher: InternalUserDefinedOptions['mainCssChunkMatcher'];
     getMajorVersion: () => number | undefined;
+    getOutputRoot?: (() => string | undefined) | undefined;
 }
 export interface CssHandlerOptionsCache {
     getCssHandlerOptions: (file: string) => CssHandlerOptions;

package/dist/bundlers/vite/generate-bundle/css-share-scope.d.ts

@@ -1,3 +1,4 @@
 import type { InternalUserDefinedOptions } from '../../../types';
+export declare function createCssTransformShareScope(file: string, rawSource: string): string;
 export declare function createCssTransformShareScopeKey(opts: InternalUserDefinedOptions, file: string, rawSource: string): string;
 export declare function createCssRuntimeSignature(runtimeSignature: string, generatorCandidateSignature: string): string;

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

@@ -1,6 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { ResolvedConfig } from 'vite';
+import type { HmrTimingRecorder } from '../shared/hmr-timing';
 import type { BundleSnapshot } from './bundle-state';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface GenerateBundleContext {
     opts: InternalUserDefinedOptions;
@@ -9,18 +11,23 @@ interface GenerateBundleContext {
         readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+    }) => Promise<Set<string>>;
     debug: (format: string, ...args: unknown[]) => void;
     getResolvedConfig: () => ResolvedConfig | undefined;
     markCssAssetProcessed?: (asset: OutputAsset, file?: string) => void;
     recordCssAssetResult?: (file: string, css: string) => void;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string, cssRuntimeSignature: string) => void;
     getRememberedMainCssSources?: () => Map<string, string>;
     getRememberedMainCssSignature?: (file: string) => string | undefined;
     setRememberedMainCssSignature?: (file: string, cssRuntimeSignature: string) => void;
     recordGeneratorCandidates?: (candidates: Set<string>) => void;
+    hmrTimingRecorder?: HmrTimingRecorder;
 }
 interface GenerateBundleThis {
     addWatchFile?: (id: string) => void;

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

@@ -10,9 +10,13 @@ type ExtractValidCandidatesFn = (options?: MemoryExtractValidCandidatesOptions)
 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>>;
+    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
     reset: () => Promise<void>;
 }
+export interface BundleRuntimeClassSetSyncOptions {
+    baseClassSet?: Set<string> | undefined;
+    skipInitialFullScanWithBase?: boolean | undefined;
+}
 interface CreateBundleRuntimeClassSetManagerOptions {
     extractCandidates?: ExtractValidCandidatesFn;
     extractRawCandidates?: ExtractRawCandidatesFn;

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

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

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

@@ -17,6 +17,9 @@ export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClas
     };
     refreshRuntimeState: (force: boolean) => Promise<void>;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+    }) => Promise<Set<string>>;
 };
 export {};

package/dist/bundlers/vite/source-candidates.d.ts

@@ -1,17 +1,28 @@
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
 export interface SourceCandidateCollector {
     sync: (id: string, source: string) => Promise<void>;
+    merge: (id: string, source: string) => Promise<void>;
     syncFile: (id: string) => Promise<void>;
     scanRoot: (options: ScanSourceCandidateRootOptions) => Promise<void>;
     syncInline: (inlineCandidates: TailwindInlineSourceCandidates | undefined) => void;
     remove: (id: string) => void;
     values: () => Set<string>;
+    valuesForEntries: (entries: TailwindSourceEntry[] | undefined) => Set<string>;
+    snapshot: () => SourceCandidateCollectorSnapshot;
+    restore: (snapshot: SourceCandidateCollectorSnapshot) => void;
     clear: () => void;
 }
+export interface SourceCandidateCollectorSnapshot {
+    candidatesById: Array<[string, string[]]>;
+    scanCandidatesById?: Array<[string, string[]]> | undefined;
+    transformCandidatesById?: Array<[string, string[]]> | undefined;
+    inlineExcludedCandidates: string[];
+    inlineIncludedCandidates: string[];
+}
 interface ScanSourceCandidateRootOptions {
     root: string;
-    outDir?: string;
-    entries?: TailwindSourceEntry[];
+    outDir?: string | undefined;
+    entries?: TailwindSourceEntry[] | undefined;
 }
 export declare function isSourceCandidateRequest(id: string): boolean;
 export declare function createSourceCandidateCollector(): SourceCandidateCollector;

package/dist/bundlers/vite/source-scan.d.ts

@@ -1,8 +1,26 @@
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { TailwindcssPatcherLike, UserDefinedOptions } from '../../types';
+export interface ResolvedTailwindV4CssEntries {
+    entries: TailwindSourceEntry[];
+    explicit: boolean;
+    inlineCandidates: TailwindInlineSourceCandidates;
+    dependencies: string[];
+}
 export interface ResolvedViteSourceScan {
-    entries?: TailwindSourceEntry[];
-    inlineCandidates?: TailwindInlineSourceCandidates;
+    dependencies?: string[] | undefined;
+    entries?: TailwindSourceEntry[] | undefined;
+    explicit?: boolean | undefined;
+    inlineCandidates?: TailwindInlineSourceCandidates | undefined;
+}
+interface ResolveViteSourceScanOptions {
+    root?: string | undefined;
+    outDir?: string | undefined;
 }
-export declare function resolveViteSourceScanEntries(options: UserDefinedOptions, patcher: TailwindcssPatcherLike): Promise<ResolvedViteSourceScan | undefined>;
+export declare function mergeTailwindInlineSourceCandidates(allInlineCandidates: Array<TailwindInlineSourceCandidates | undefined>): TailwindInlineSourceCandidates | undefined;
+export declare function resolveTailwindV4EntriesFromCss(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
+export declare function resolveViteTailwindV4CssDependencies(css: string, base: string): Promise<string[]>;
+export declare function resolveTailwindV4EntriesFromCssCached(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
+export declare function discoverTailwindV4CssEntries(root: string, outDir: string | undefined): Promise<string[]>;
+export declare function resolveViteSourceScanEntries(options: UserDefinedOptions, patcher: TailwindcssPatcherLike, scanOptions?: ResolveViteSourceScanOptions): Promise<ResolvedViteSourceScan | undefined>;
 export declare function createViteSourceScanMatcher(entries: TailwindSourceEntry[] | undefined): ((file: string) => boolean) | undefined;
+export {};

package/dist/bundlers/vite/static-config-content.d.ts

@@ -0,0 +1,5 @@
+type StaticContentValue = string | StaticContentValue[] | {
+    files: StaticContentValue;
+};
+export declare function readStaticConfigContent(configPath: string): StaticContentValue | undefined;
+export {};

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

@@ -15,7 +15,12 @@ interface WebpackWatchChangeLike {
     modifiedFiles?: Set<string>;
     removedFiles?: Set<string>;
 }
+interface RuntimeWatchDependenciesLike {
+    files?: Iterable<string>;
+    contexts?: Iterable<string>;
+}
 export declare function createAssetHashByChunkMap(chunks: Iterable<ChunkLike>): Map<string, string>;
 export declare function createRuntimeAwareCssHash(assetHash: string | undefined, sourceHash: string, runtimeSetHash: string): string;
 export declare function hasWatchChanges(compiler: WebpackWatchChangeLike): boolean;
+export declare function isWatchFileInRuntimeDependencies(file: string, dependencies: RuntimeWatchDependenciesLike): boolean;
 export {};

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

@@ -4,7 +4,7 @@ import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5ProcessAssetsHookOptions {
     compiler: Compiler;
     options: InternalUserDefinedOptions;
-    appType?: AppType;
+    appType?: AppType | undefined;
     runtimeState: {
         twPatcher: InternalUserDefinedOptions['twPatcher'];
         readyPromise: Promise<void>;
@@ -12,8 +12,8 @@ interface SetupWebpackV5ProcessAssetsHookOptions {
     getRuntimeRefreshRequirement: () => boolean;
     refreshRuntimeMetadata: (force: boolean) => Promise<void>;
     consumeRuntimeRefreshRequirement: () => void;
-    isWatchMode?: () => boolean;
-    runtimeClassSetManager?: BundleRuntimeClassSetManager;
+    isWatchMode?: (() => boolean) | undefined;
+    runtimeClassSetManager?: BundleRuntimeClassSetManager | undefined;
     debug: (format: string, ...args: unknown[]) => void;
 }
 export declare function setupWebpackV5ProcessAssetsHook(options: SetupWebpackV5ProcessAssetsHookOptions): void;

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

@@ -4,11 +4,11 @@ import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5LoadersOptions {
     compiler: Compiler;
     options: InternalUserDefinedOptions;
-    appType?: AppType;
+    appType?: AppType | undefined;
     weappTailwindcssPackageDir: string;
     shouldRewriteCssImports: boolean;
-    runtimeLoaderPath?: string;
-    registerAutoCssSource?: (source: TailwindV4CssSource) => Promise<void> | void;
+    runtimeLoaderPath?: string | undefined;
+    registerAutoCssSource?: ((source: TailwindV4CssSource) => Promise<void> | void) | undefined;
     getClassSetInLoader: () => Promise<void>;
     getRuntimeWatchDependencies: () => {
         files: ReadonlySet<string>;

package/dist/cache/index.d.ts

@@ -9,16 +9,16 @@ export type HashMapKey = string | number;
 export type CacheValue = sources.Source | string;
 export interface CacheProcessResult<T extends CacheValue> {
     result: T;
-    cacheValue?: CacheValue;
+    cacheValue?: CacheValue | undefined;
 }
 export interface CacheProcessOptions<T extends CacheValue> {
     key: string;
-    hashKey?: HashMapKey;
-    rawSource?: string | Buffer;
-    hash?: string;
-    resolveCache?: () => T | undefined;
+    hashKey?: HashMapKey | undefined;
+    rawSource?: string | Buffer | undefined;
+    hash?: string | undefined;
+    resolveCache?: (() => T | undefined) | undefined;
     transform: () => Promise<CacheProcessResult<T> | T>;
-    onCacheHit?: (value: T) => void | Promise<void>;
+    onCacheHit?: ((value: T) => void | Promise<void>) | undefined;
 }
 export interface ICreateCacheReturnType {
     readonly hashMap: Map<HashMapKey, HashMapValue>;

package/dist/cli/context.d.ts

@@ -1,13 +1,3 @@
 import type { UserDefinedOptions } from '../types';
-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 createCliContext(overrides: Partial<UserDefinedOptions> | undefined, resolvedCwd: string | undefined): import("@/types").InternalUserDefinedOptions;
 export declare function formatOutputPath(target: string, baseDir?: string): string;