weapp-tailwindcss 5.3.5 → 5.4.0

package/dist/context/handlers.d.ts

@@ -2,5 +2,5 @@ import type { ICustomAttributesEntities, InternalUserDefinedOptions } from '../t
 export declare function createHandlersFromContext(ctx: InternalUserDefinedOptions, customAttributesEntities: ICustomAttributesEntities, cssCalcOptions: InternalUserDefinedOptions['cssCalc'], tailwindcssMajorVersion?: number): {
     styleHandler: import("@weapp-tailwindcss/postcss").StyleHandler;
     jsHandler: import("../types/index.js").JsHandler;
-    templateHandler: (rawSource: string, opt?: Pick<import("../types/index.js").ITemplateHandlerOptions, "runtimeSet">) => Promise<string>;
+    templateHandler: (rawSource: string, opt?: import("../types/index.js").ITemplateHandlerOptions) => Promise<string>;
 };

package/dist/core/compiler/compiler.d.ts

@@ -0,0 +1,2 @@
+import type { Compiler, CreateCompilerOptions } from './types.js';
+export declare function createCompiler(options?: CreateCompilerOptions): Compiler;

package/dist/core/compiler/generation-cache.d.ts

@@ -0,0 +1,30 @@
+import type { CompilerGenerateRequest, CompilerTarget } from './types.js';
+import type { WeappTailwindcssGenerateResult } from '../../generator/index.js';
+export interface CompilerGenerationCacheEntry {
+    key: CompilerGenerationCacheKey;
+    result: WeappTailwindcssGenerateResult;
+}
+interface CompilerGenerationCacheKey {
+    bareArbitraryValues: CompilerGenerateRequest['bareArbitraryValues'];
+    candidateSignature: string;
+    incrementalCache: CompilerGenerateRequest['incrementalCache'];
+    scanSources: CompilerGenerateRequest['scanSources'];
+    sourcesFingerprint: string | undefined;
+    styleOptionsFingerprint: string | undefined;
+    target: CompilerTarget;
+}
+export declare function createCompilerGenerationCacheKey(request: CompilerGenerateRequest, candidates: Iterable<string>, target: CompilerTarget): CompilerGenerationCacheKey;
+export declare function isSameCompilerGenerationCacheKey(left: CompilerGenerationCacheKey, right: CompilerGenerationCacheKey): boolean;
+export declare function reuseCompilerGenerationResult(result: WeappTailwindcssGenerateResult): {
+    incrementalCss: string;
+    incrementalRawCss: string;
+    css: string;
+    rawCss: string;
+    target: "weapp" | "web";
+    root: import("@tailwindcss-mangle/engine").TailwindV4CompiledSourceRoot;
+    sources: import("@tailwindcss-mangle/engine").TailwindV4SourcePattern[];
+    classSet: Set<string>;
+    rawCandidates: Set<string>;
+    dependencies: string[];
+};
+export {};

package/dist/core/compiler/generation-state.d.ts

@@ -0,0 +1,17 @@
+import type { CompilerRootSession } from './root-store.js';
+import type { CompilerGenerateRequest } from './types.js';
+import type { CompilationGraphSnapshot, CompilationResult } from '../../compiler/types.js';
+import type { TailwindV4ResolvedSource } from '../../generator/index.js';
+export interface CompilerCompilationCacheEntry {
+    candidateSignature: string;
+    compilation: CompilationResult;
+    graph: CompilationGraphSnapshot;
+}
+interface PreparedCompilerGeneration extends CompilerCompilationCacheEntry {
+    compilation: CompilationResult;
+    explicitCandidates: boolean;
+    graph: CompilationGraphSnapshot;
+}
+export declare function prepareCompilerGeneration(entry: CompilerRootSession, request: CompilerGenerateRequest, source: TailwindV4ResolvedSource, sourceChanged: boolean): PreparedCompilerGeneration;
+export declare function commitCompilerGeneration(entry: CompilerRootSession, prepared: PreparedCompilerGeneration, source: TailwindV4ResolvedSource, dependencies: Iterable<string>, classSet: Iterable<string>): void;
+export {};

package/dist/core/compiler/index.d.ts

@@ -0,0 +1,2 @@
+export { createCompiler } from './compiler.js';
+export type { Compiler, CompilerCacheReuseState, CompilerGenerateRequest, CompilerGenerateResult, CompilerSnapshot, CompilerSnapshotRoot, CompilerSourcePattern, CompilerTarget, CompilerTemplateTransformOptions, CreateCompilerOptions, CreateCompilerSnapshotRequest, } from './types.js';

package/dist/core/compiler/root-store.d.ts

@@ -0,0 +1,38 @@
+import type { CompilerGenerationCacheEntry } from './generation-cache.js';
+import type { CompilerCompilationCacheEntry } from './generation-state.js';
+import type { CompilerSnapshot } from './types.js';
+import type { TailwindV4ResolvedSource, WeappTailwindcssGenerator } from '../../generator/index.js';
+import { DefaultCompilationSession } from '../../compiler/session.js';
+export interface CompilerRootSession {
+    accepting: boolean;
+    active: boolean;
+    appliedInvalidation: number;
+    compilation: DefaultCompilationSession;
+    compilationCache?: CompilerCompilationCacheEntry | undefined;
+    compilationRevision: number;
+    dependencies: Set<string>;
+    generator?: WeappTailwindcssGenerator | undefined;
+    generationCache?: CompilerGenerationCacheEntry | undefined;
+    id: string;
+    invalidation: number;
+    latestSnapshot?: CompilerSnapshot | undefined;
+    pending: Promise<void>;
+    pendingCount: number;
+    source?: TailwindV4ResolvedSource | undefined;
+    sourceFingerprint?: string | undefined;
+    sourceInput?: object | undefined;
+}
+export declare class CompilerRootStore {
+    private readonly maxRoots;
+    private readonly dependencyRoots;
+    private readonly releasing;
+    private readonly roots;
+    constructor(maxRoots: number);
+    get(id: string): CompilerRootSession;
+    attachDependencies(entry: CompilerRootSession, dependencies: Iterable<string>): void;
+    invalidate(ids: Iterable<string>): readonly string[];
+    trim(): void;
+    remove(id: string): Promise<void>;
+    dispose(): Promise<void>;
+    private detachDependencies;
+}

package/dist/core/compiler/snapshot.d.ts

@@ -0,0 +1,35 @@
+import type { CompilerSnapshot, CompilerSnapshotRoot, CompilerSourcePattern, CompilerTarget, CreateCompilerSnapshotRequest } from './types.js';
+interface InternalSnapshotRoot extends CompilerSnapshotRoot {
+    fingerprint: string;
+}
+export interface InternalCompilerSnapshot {
+    classSet: Set<string>;
+    dependencies: readonly string[];
+    fingerprint: string;
+    roots: ReadonlyMap<string, InternalSnapshotRoot>;
+    sources: readonly CompilerSourcePattern[];
+    target: CompilerTarget;
+}
+export declare function createRegisteredCompilerSnapshot(request: CreateCompilerSnapshotRequest, reusableClassSet?: Set<string>, reusableClassSetView?: ReadonlySet<string>): Readonly<{
+    classSet: ReadonlySet<string>;
+    dependencies: readonly string[];
+    roots: readonly Readonly<{
+        id: string;
+        revision: number;
+    }>[];
+    sources: readonly import("../../tailwindcss/v4-engine/types.js").TailwindV4SourcePattern[];
+    target: CompilerTarget;
+}>;
+export declare function getInternalCompilerSnapshot(snapshot: CompilerSnapshot): InternalCompilerSnapshot;
+export declare function mergeRegisteredCompilerSnapshots(snapshots: Iterable<CompilerSnapshot>): Readonly<{
+    classSet: ReadonlySet<string>;
+    dependencies: readonly string[];
+    roots: readonly Readonly<{
+        id: string;
+        revision: number;
+    }>[];
+    sources: readonly import("../../tailwindcss/v4-engine/types.js").TailwindV4SourcePattern[];
+    target: CompilerTarget;
+}>;
+export declare function createImmutableSet<T>(values: Iterable<T>): ReadonlySet<T>;
+export {};

package/dist/core/compiler/source-fingerprint.d.ts

@@ -0,0 +1,3 @@
+import type { TailwindV4ResolvedSource } from '../../generator/index.js';
+export declare function createSourceFingerprint(source: TailwindV4ResolvedSource): string;
+export declare function createCompilerValueFingerprint(value: unknown): string;

package/dist/core/compiler/transforms.d.ts

@@ -0,0 +1,15 @@
+import type { Compiler, CompilerSnapshot } from './types.js';
+import type { UserDefinedOptions } from '../../types/index.js';
+interface CreateCompilerTransformsOptions {
+    ensureActive: () => void;
+    track: <T>(task: Promise<T>) => Promise<T>;
+    userOptions: UserDefinedOptions;
+}
+export declare function createCompilerTransforms({ ensureActive, track, userOptions }: CreateCompilerTransformsOptions): {
+    clearCache: () => void;
+    transformCss: (css: string, snapshot: CompilerSnapshot, options?: Parameters<Compiler["transformCss"]>[2]) => Promise<import("postcss").Result<import("postcss").Document | import("postcss").Root>>;
+    transformCssRoot: (root: Parameters<Compiler["transformCssRoot"]>[0], snapshot: CompilerSnapshot, options?: Parameters<Compiler["transformCssRoot"]>[2]) => Promise<import("postcss").Result<import("postcss").Document | import("postcss").Root>>;
+    transformJavaScript: (source: string, snapshot: CompilerSnapshot, options?: Parameters<Compiler["transformJavaScript"]>[2]) => Promise<import("../../types/index.js").JsHandlerResult>;
+    transformTemplate: (source: string, snapshot: CompilerSnapshot, options?: Parameters<Compiler["transformTemplate"]>[2]) => Promise<string>;
+};
+export {};

package/dist/core/compiler/types.d.ts

@@ -0,0 +1,69 @@
+import type { Document, IStyleHandlerOptions, Result as PostcssResult, Root } from '@weapp-tailwindcss/postcss';
+import type { TailwindV4ResolvedSource, TailwindV4SourceOptions, WeappTailwindcssGenerateOptions, WeappTailwindcssGenerateResult } from '../../generator/index.js';
+import type { CreateJsHandlerOptions, ITemplateHandlerOptions, JsHandlerResult, UserDefinedOptions } from '../../types/index.js';
+export type CompilerTarget = 'tailwind' | 'weapp' | 'web';
+export type CompilerSourcePattern = NonNullable<TailwindV4ResolvedSource['sources']>[number];
+export interface CompilerSnapshotRoot {
+    id: string;
+    revision: number;
+}
+export interface CompilerSnapshot {
+    readonly classSet: ReadonlySet<string>;
+    readonly dependencies: readonly string[];
+    readonly roots: readonly CompilerSnapshotRoot[];
+    readonly sources: readonly CompilerSourcePattern[];
+    readonly target: CompilerTarget;
+}
+interface CompilerGenerateRequestBase extends Omit<WeappTailwindcssGenerateOptions, 'target'> {
+    id: string;
+    target?: CompilerTarget | undefined;
+}
+export type CompilerGenerateRequest = CompilerGenerateRequestBase & {
+    source: TailwindV4ResolvedSource;
+    sourceOptions?: never;
+} | CompilerGenerateRequestBase & {
+    source?: never;
+    sourceOptions: TailwindV4SourceOptions;
+};
+export interface CompilerCacheReuseState {
+    source: boolean;
+    engine: boolean;
+    output: boolean;
+}
+export interface CompilerGenerateResult extends Omit<WeappTailwindcssGenerateResult, 'classSet' | 'dependencies' | 'rawCandidates' | 'sources' | 'target'> {
+    cache: Readonly<CompilerCacheReuseState>;
+    classSet: ReadonlySet<string>;
+    dependencies: readonly string[];
+    rawCandidates: ReadonlySet<string>;
+    revision: number;
+    snapshot: CompilerSnapshot;
+    sources: readonly CompilerSourcePattern[];
+    target: CompilerTarget;
+}
+export interface CreateCompilerSnapshotRequest {
+    classSet: Iterable<string>;
+    dependencies?: Iterable<string> | undefined;
+    id: string;
+    revision?: number | undefined;
+    sources?: Iterable<CompilerSourcePattern> | undefined;
+    target?: CompilerTarget | undefined;
+}
+export type CompilerTemplateTransformOptions = Omit<ITemplateHandlerOptions, 'classSetMode' | 'runtimeSet'>;
+export type CreateCompilerOptions = UserDefinedOptions & {
+    compiler?: {
+        maxRoots?: number | undefined;
+    } | undefined;
+};
+export interface Compiler {
+    createSnapshot: (request: CreateCompilerSnapshotRequest) => CompilerSnapshot;
+    dispose: () => Promise<void>;
+    generate: (request: CompilerGenerateRequest) => Promise<CompilerGenerateResult>;
+    invalidate: (ids: Iterable<string>) => readonly string[];
+    mergeSnapshots: (snapshots: Iterable<CompilerSnapshot>) => CompilerSnapshot;
+    remove: (id: string) => Promise<void>;
+    transformCss: (css: string, snapshot: CompilerSnapshot, options?: Partial<IStyleHandlerOptions>) => Promise<PostcssResult<Root | Document>>;
+    transformCssRoot: (root: Root, snapshot: CompilerSnapshot, options?: Partial<IStyleHandlerOptions>) => Promise<PostcssResult<Root>>;
+    transformJavaScript: (source: string, snapshot: CompilerSnapshot, options?: CreateJsHandlerOptions) => Promise<JsHandlerResult>;
+    transformTemplate: (source: string, snapshot: CompilerSnapshot, options?: CompilerTemplateTransformOptions) => Promise<string>;
+}
+export {};

package/dist/core.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_context = require("./context-DTLRADfE.cjs");
+const require_compiler = require("./compiler-C93NfxSe.cjs");
 let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
 //#region src/core.ts
 const DEFAULT_MAIN_CHUNK_STYLE_OPTIONS = Object.freeze({ isMainChunk: true });
@@ -14,11 +14,11 @@ function resolveTransformWxssOptions(options) {
 * @returns 返回一个包含 transformWxss、transformWxml 和 transformJs 方法的对象
 */
 function createContext(options = {}) {
-	const opts = require_context.getCompilerContext(options);
+	const opts = require_compiler.getCompilerContext(options);
 	const { templateHandler, styleHandler, jsHandler } = opts;
 	const initialTailwindRuntime = opts.tailwindRuntime;
 	const refreshTailwindcssRuntime = opts.refreshTailwindcssRuntime;
-	const readyPromise = require_context.createTailwindRuntimeReadyPromise(initialTailwindRuntime);
+	const readyPromise = require_compiler.createTailwindRuntimeReadyPromise(initialTailwindRuntime);
 	let runtimeSet = /* @__PURE__ */ new Set();
 	const runtimeState = {
 		tailwindRuntime: initialTailwindRuntime,
@@ -109,25 +109,25 @@ function createContext(options = {}) {
 	async function transformWxss(rawCss, options) {
 		await runtimeState.readyPromise;
 		const result = await styleHandler(rawCss, resolveTransformWxssOptions(options));
-		runtimeSet = await require_context.ensureRuntimeClassSet(runtimeState);
+		runtimeSet = await require_compiler.ensureRuntimeClassSet(runtimeState);
 		return result;
 	}
 	async function getRuntimeSet(options) {
 		await runtimeState.readyPromise;
-		runtimeSet = await require_context.ensureRuntimeClassSet(runtimeState, options);
+		runtimeSet = await require_compiler.ensureRuntimeClassSet(runtimeState, options);
 		return runtimeSet;
 	}
 	async function transformJs(rawJs, options) {
 		await runtimeState.readyPromise;
 		if (options?.runtimeSet) runtimeSet = options.runtimeSet;
-		else if (runtimeSet.size === 0) runtimeSet = await require_context.ensureRuntimeClassSet(runtimeState, { forceCollect: true });
+		else if (runtimeSet.size === 0) runtimeSet = await require_compiler.ensureRuntimeClassSet(runtimeState, { forceCollect: true });
 		const resolvedOptions = resolveTransformJsOptions(options);
-		if (require_context.shouldSkipJsTransform(rawJs, resolvedOptions)) return { code: rawJs };
+		if (require_compiler.shouldSkipJsTransform(rawJs, resolvedOptions)) return { code: rawJs };
 		return await jsHandler(rawJs, runtimeSet, resolvedOptions);
 	}
 	async function transformWxml(rawWxml, options) {
 		await runtimeState.readyPromise;
-		if (!options?.runtimeSet && runtimeSet.size === 0) runtimeSet = await require_context.ensureRuntimeClassSet(runtimeState, { forceCollect: true });
+		if (!options?.runtimeSet && runtimeSet.size === 0) runtimeSet = await require_compiler.ensureRuntimeClassSet(runtimeState, { forceCollect: true });
 		return templateHandler(rawWxml, resolveTransformWxmlOptions(options));
 	}
 	return {
@@ -138,4 +138,5 @@ function createContext(options = {}) {
 	};
 }
 //#endregion
+exports.createCompiler = require_compiler.createCompiler;
 exports.createContext = createContext;

package/dist/core.d.ts

@@ -1,4 +1,6 @@
 import type { CreateJsHandlerOptions, IStyleHandlerOptions, ITemplateHandlerOptions, UserDefinedOptions } from './types/index.js';
+export { createCompiler } from './core/compiler/index.js';
+export type { Compiler, CompilerCacheReuseState, CompilerGenerateRequest, CompilerGenerateResult, CompilerSnapshot, CompilerSnapshotRoot, CompilerSourcePattern, CompilerTarget, CompilerTemplateTransformOptions, CreateCompilerOptions, CreateCompilerSnapshotRequest, } from './core/compiler/index.js';
 type RuntimeJsTransformOptions = {
     runtimeSet?: Set<string>;
 } & CreateJsHandlerOptions;
@@ -14,4 +16,3 @@ export declare function createContext(options?: UserDefinedOptions): {
     transformWxml: (rawWxml: string, options?: ITemplateHandlerOptions) => Promise<string>;
     transformJs: (rawJs: string, options?: RuntimeJsTransformOptions) => Promise<import("./types/index.js").JsHandlerResult>;
 };
-export {};

package/dist/core.js

@@ -1,4 +1,4 @@
-import { l as createTailwindRuntimeReadyPromise, o as shouldSkipJsTransform, t as getCompilerContext, u as ensureRuntimeClassSet } from "./context-4ittVpgt.js";
+import { d as ensureRuntimeClassSet, n as getCompilerContext, s as shouldSkipJsTransform, t as createCompiler, u as createTailwindRuntimeReadyPromise } from "./compiler-qDa3phIv.js";
 import { defuOverrideArray } from "@weapp-tailwindcss/shared";
 //#region src/core.ts
 const DEFAULT_MAIN_CHUNK_STYLE_OPTIONS = Object.freeze({ isMainChunk: true });
@@ -137,4 +137,4 @@ function createContext(options = {}) {
 	};
 }
 //#endregion
-export { createContext };
+export { createCompiler, createContext };

package/dist/framework/index.d.ts

@@ -61,4 +61,6 @@ export declare function isUniAppPackage(pkg: PackageJsonLike): boolean;
 export declare function isUniAppXManifest(manifest: UniAppManifestLike | undefined): boolean;
 export declare function detectAppTypeFromPackageJson(pkg: PackageJsonLike): DetectableAppType | undefined;
 export declare function detectAppType(options?: DetectAppTypeOptions): DetectableAppType | undefined;
-export declare const resolveImplicitAppTypeFromViteRoot: (root: string) => DetectableAppType | undefined;
+export declare function resolveImplicitAppTypeFromViteRoot(root: string, options?: {
+    searchUp?: boolean;
+}): DetectableAppType | undefined;

package/dist/framework.cjs

@@ -206,7 +206,12 @@ function detectAppType(options = {}) {
 		hbuilderxVite: options.hbuilderxVite
 	});
 }
-const resolveImplicitAppTypeFromViteRoot = (root) => detectAppType({ root });
+function resolveImplicitAppTypeFromViteRoot(root, options = {}) {
+	return detectAppType({
+		root,
+		searchUp: options.searchUp
+	});
+}
 //#endregion
 exports.detectAppType = detectAppType;
 exports.detectAppTypeFromEnv = detectAppTypeFromEnv;

package/dist/framework.js

@@ -202,6 +202,11 @@ function detectAppType(options = {}) {
 		hbuilderxVite: options.hbuilderxVite
 	});
 }
-const resolveImplicitAppTypeFromViteRoot = (root) => detectAppType({ root });
+function resolveImplicitAppTypeFromViteRoot(root, options = {}) {
+	return detectAppType({
+		root,
+		searchUp: options.searchUp
+	});
+}
 //#endregion
 export { detectAppType, detectAppTypeFromEnv, detectAppTypeFromPackageJson, isMpxPackage, isRunningInHBuilderX, isTaroPackage, isUniAppPackage, isUniAppVitePackage, isUniAppXManifest, isUniAppXPackage, isWeappVitePackage, resolveImplicitAppTypeFromViteRoot, resolveMpxPlatform, resolvePlatform, resolveTaroPlatform, resolveUniAppXPlatform, resolveUniPlatform, resolveUniPlatformsFromEnv, resolveUniUtsPlatform };

package/dist/{generator-EnTXLBlK.js → generator-C0m2S4WI.js}

@@ -2981,9 +2981,10 @@ function normalizeTailwindV4CssEntrySources(cssEntries, packageName) {
 	const remainingCssEntries = [];
 	const cssSources = [];
 	for (const cssEntry of cssEntries) {
-		const file = path.resolve(cssEntry);
+		const normalizedCssEntry = cssEntry.replace(/[?#].*$/, "");
+		const file = path.resolve(normalizedCssEntry);
 		if (!existsSync(file)) {
-			remainingCssEntries.push(cssEntry);
+			remainingCssEntries.push(normalizedCssEntry);
 			continue;
 		}
 		const base = path.dirname(file);

package/dist/{generator-DKiYbTFR.cjs → generator-CKJ6sj1f.cjs}

@@ -2990,9 +2990,10 @@ function normalizeTailwindV4CssEntrySources(cssEntries, packageName) {
 	const remainingCssEntries = [];
 	const cssSources = [];
 	for (const cssEntry of cssEntries) {
-		const file = node_path.default.resolve(cssEntry);
+		const normalizedCssEntry = cssEntry.replace(/[?#].*$/, "");
+		const file = node_path.default.resolve(normalizedCssEntry);
 		if (!(0, node_fs.existsSync)(file)) {
-			remainingCssEntries.push(cssEntry);
+			remainingCssEntries.push(normalizedCssEntry);
 			continue;
 		}
 		const base = node_path.default.dirname(file);

package/dist/generator.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_generator = require("./generator-DKiYbTFR.cjs");
+const require_generator = require("./generator-CKJ6sj1f.cjs");
 let _tailwindcss_mangle_engine = require("@tailwindcss-mangle/engine");
 exports.createWeappTailwindcssGenerator = require_generator.createWeappTailwindcssGenerator;
 exports.createWeappTailwindcssGeneratorFromRuntime = require_generator.createWeappTailwindcssGeneratorFromRuntime;

package/dist/generator.js

@@ -1,2 +1,2 @@
-import { Lt as loadTailwindV4DesignSystem, Mt as transformTailwindV4CssToWeapp, d as resolveTailwindV4SourceFromRuntime, f as resolveTailwindV4SourceFromRuntimeOptions, i as normalizeWeappTailwindcssGeneratorOptions, jt as transformTailwindV4CssByTarget, n as createWeappTailwindcssGeneratorFromRuntime, p as resolveTailwindV4SourceOptionsFromRuntime, r as resolveTailwindSourceFromRuntime, t as createWeappTailwindcssGenerator, u as resolveTailwindV4Source } from "./generator-EnTXLBlK.js";
+import { Lt as loadTailwindV4DesignSystem, Mt as transformTailwindV4CssToWeapp, d as resolveTailwindV4SourceFromRuntime, f as resolveTailwindV4SourceFromRuntimeOptions, i as normalizeWeappTailwindcssGeneratorOptions, jt as transformTailwindV4CssByTarget, n as createWeappTailwindcssGeneratorFromRuntime, p as resolveTailwindV4SourceOptionsFromRuntime, r as resolveTailwindSourceFromRuntime, t as createWeappTailwindcssGenerator, u as resolveTailwindV4Source } from "./generator-C0m2S4WI.js";
 export { createWeappTailwindcssGenerator, createWeappTailwindcssGeneratorFromRuntime, loadTailwindV4DesignSystem, normalizeWeappTailwindcssGeneratorOptions, resolveTailwindSourceFromRuntime, resolveTailwindV4Source, resolveTailwindV4SourceFromRuntime, resolveTailwindV4SourceFromRuntimeOptions, resolveTailwindV4SourceOptionsFromRuntime, transformTailwindV4CssByTarget, transformTailwindV4CssToWeapp };

package/dist/{gulp-CUysZjW3.cjs → gulp-CW6JGqVn.cjs}

@@ -1,12 +1,10 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Ctb5zv51.cjs");
-const require_generator = require("./generator-DKiYbTFR.cjs");
-const require_options = require("./options-BJrtIQbH.cjs");
-const require_v4_generation_core = require("./v4-generation-core-Dhsu9Deu.cjs");
-const require_wxml = require("./wxml-PrK-8ARX.cjs");
-const require_hmr_timing = require("./hmr-timing-Cvh5UgnM.cjs");
-const require_context = require("./context-DTLRADfE.cjs");
-const require_tailwindcss = require("./tailwindcss-CexDJBhx.cjs");
-const require_style_options = require("./style-options-DW30H5PV.cjs");
+const require_generator = require("./generator-CKJ6sj1f.cjs");
+const require_tailwindcss = require("./tailwindcss-BGlJ1m1l.cjs");
+const require_v4_generation_core = require("./v4-generation-core-B2sUkkgq.cjs");
+const require_wxml = require("./wxml-o-CUulAM.cjs");
+const require_compiler = require("./compiler-C93NfxSe.cjs");
+const require_hmr_timing = require("./hmr-timing-n7QQKFp7.cjs");
 let node_fs = require("node:fs");
 node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -320,7 +318,7 @@ function createGulpFileTransforms(context) {
 			async transform() {
 				await runtimeState.readyPromise;
 				const currentSource = file.contents?.toString() ?? rawSource;
-				if (require_context.shouldSkipJsTransform(currentSource, {
+				if (require_compiler.shouldSkipJsTransform(currentSource, {
 					...handlerOptions,
 					classNameSet: getRuntimeSet()
 				})) return { result: currentSource };
@@ -372,18 +370,18 @@ const GULP_COMPILATION_SCOPE_CACHE_MAX = 512;
 /**
 * @name weapp-tw-gulp
 * @description native framework 的插件组合实现
-* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+* @link https://tw.weapp.dev/docs/quick-start/frameworks/native
 */
 function createNativeGulpPlugins(options = {}) {
 	const hasInitialTailwindCssRoots = require_generator.hasConfiguredTailwindV4CssRoots(options);
-	const opts = require_context.getCompilerContext({
+	const opts = require_compiler.getCompilerContext({
 		...options,
 		__internalDeferMissingCssEntriesWarning: true
 	});
 	const { cache } = opts;
 	const initialTailwindRuntime = opts.tailwindRuntime;
 	const refreshTailwindcssRuntime = opts.refreshTailwindcssRuntime;
-	const readyPromise = require_context.createTailwindRuntimeReadyPromise(initialTailwindRuntime);
+	const readyPromise = require_compiler.createTailwindRuntimeReadyPromise(initialTailwindRuntime);
 	let runtimeSet = /* @__PURE__ */ new Set();
 	const runtimeState = {
 		tailwindRuntime: initialTailwindRuntime,
@@ -420,7 +418,7 @@ function createNativeGulpPlugins(options = {}) {
 		const shouldForceCollect = normalizedOptions.forceCollect === true || runtimeSetDirty;
 		const clearCache = normalizedOptions.clearCache === true || runtimeSetDirty;
 		if (!forceRefresh && !shouldForceCollect && runtimeSetInitialized) return runtimeSet;
-		runtimeSet = await require_context.ensureRuntimeClassSet(runtimeState, {
+		runtimeSet = await require_compiler.ensureRuntimeClassSet(runtimeState, {
 			forceRefresh,
 			forceCollect: shouldForceCollect,
 			clearCache,
@@ -454,7 +452,7 @@ function createNativeGulpPlugins(options = {}) {
 	}
 	async function refreshGulpV4SourceCandidates(forceRefresh = false) {
 		const root = opts.tailwindcssBasedir ?? node_process.default.cwd();
-		const sourceScan = await require_options.resolveSourceScanEntries(opts, runtimeState.tailwindRuntime, { root });
+		const sourceScan = await require_tailwindcss.resolveSourceScanEntries(opts, runtimeState.tailwindRuntime, { root });
 		const nextSignature = cache.computeHash(JSON.stringify({
 			root,
 			entries: sourceScan?.entries,
@@ -515,7 +513,7 @@ function createNativeGulpPlugins(options = {}) {
 		return cachedDefaultModuleGraphOptions;
 	}
 	function resolveWxssHandlerOptions(options) {
-		const styleHandlerMajorVersion = require_style_options.normalizeStyleHandlerMajorVersion(runtimeState.tailwindRuntime.majorVersion);
+		const styleHandlerMajorVersion = require_compiler.normalizeStyleHandlerMajorVersion(runtimeState.tailwindRuntime.majorVersion);
 		const majorVersion = styleHandlerMajorVersion ?? "unknown";
 		if (!options || Object.keys(options).length === 0) {
 			let cached = defaultStyleHandlerOptionsCache.get(majorVersion);
@@ -678,7 +676,7 @@ function createNativeGulpFrameworkPlugins(options = {}) {
 /**
 * @name weapp-tw-gulp
 * @description Gulp 入口直接创建 native framework，具体 stream 组合由 frameworks/native 拥有。
-* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+* @link https://tw.weapp.dev/docs/quick-start/frameworks/native
 */
 function createPlugins(options = {}) {
 	return createNativeGulpFrameworkPlugins(options);

package/dist/{gulp-DwtrU4V1.js → gulp-e2iWsmEK.js}

@@ -1,8 +1,8 @@
-import { Pt as getTailwindV4IncrementalGenerateCacheStats, Q as hasTailwindRootDirectives, _ as upsertTailwindV4CssSource, et as normalizeTailwindConfigDirectives, g as removeTailwindV4CssSource, h as hasConfiguredTailwindV4CssRoots, nt as normalizeTailwindSourceForGenerator, vt as prependConfigDirective } from "./generator-EnTXLBlK.js";
-import { f as resolveSourceScanEntries, l as getRuntimeClassSetSignature } from "./tailwindcss-ChnpCv25.js";
-import { $ as AssetEmissionPlan, B as rewriteLocalCssImportRequestsForOutput, E as hasBundlerGeneratedCssMarker, F as processCachedTask, G as createRuntimeCompilationBuildState, H as finalizeCompilerShadowRun, I as createRuntimeClassSetManager, J as updateRuntimeCompilationBuildState, K as removeRuntimeCompilationBuildStateFiles, M as createCssSourceTraceCacheSignature, N as createCssTokenSourceMap, O as stripBundlerGeneratedCssMarkers, Q as getCompilerShadowRunSnapshot, T as createBundlerGeneratedCssMarker, U as buildRuntimeCompilationSnapshot, V as splitLocalCssImports, X as disposeCompilerOwner, Y as createRuntimeAffectingSourceSignature, Z as beginCompilerShadowRun, b as finalizeMiniProgramGeneratorCss, et as getCompilationScopeDependencyRevision, it as createSourceCandidateCollector, j as annotateCssSourceTrace, k as finalizeMiniProgramCssStructure, n as emitHmrTiming, nt as recordCompilationDependencyChanges, r as generateTailwindV4Css, rt as createCompilationDependencyChanges, tt as invalidateCompilationScope } from "./hmr-timing-utmOgn6p.js";
-import { m as createDebug } from "./wxml-B7OAVpXJ.js";
-import { l as createTailwindRuntimeReadyPromise, n as normalizeStyleHandlerMajorVersion, o as shouldSkipJsTransform, t as getCompilerContext, u as ensureRuntimeClassSet } from "./context-4ittVpgt.js";
+import { Pt as getTailwindV4IncrementalGenerateCacheStats, Q as hasTailwindRootDirectives, _ as upsertTailwindV4CssSource, et as normalizeTailwindConfigDirectives, g as removeTailwindV4CssSource, h as hasConfiguredTailwindV4CssRoots, nt as normalizeTailwindSourceForGenerator, vt as prependConfigDirective } from "./generator-C0m2S4WI.js";
+import { f as resolveSourceScanEntries, l as getRuntimeClassSetSignature } from "./tailwindcss-BSKl0FTD.js";
+import { $ as AssetEmissionPlan, B as rewriteLocalCssImportRequestsForOutput, E as hasBundlerGeneratedCssMarker, F as processCachedTask, G as createRuntimeCompilationBuildState, H as finalizeCompilerShadowRun, I as createRuntimeClassSetManager, J as updateRuntimeCompilationBuildState, K as removeRuntimeCompilationBuildStateFiles, M as createCssSourceTraceCacheSignature, N as createCssTokenSourceMap, O as stripBundlerGeneratedCssMarkers, Q as getCompilerShadowRunSnapshot, T as createBundlerGeneratedCssMarker, U as buildRuntimeCompilationSnapshot, V as splitLocalCssImports, X as disposeCompilerOwner, Y as createRuntimeAffectingSourceSignature, Z as beginCompilerShadowRun, b as finalizeMiniProgramGeneratorCss, et as getCompilationScopeDependencyRevision, it as createSourceCandidateCollector, j as annotateCssSourceTrace, k as finalizeMiniProgramCssStructure, n as emitHmrTiming, nt as recordCompilationDependencyChanges, r as generateTailwindV4Css, rt as createCompilationDependencyChanges, tt as invalidateCompilationScope } from "./hmr-timing-DgMgwSce.js";
+import { m as createDebug } from "./wxml-CvKyV69S.js";
+import { d as ensureRuntimeClassSet, n as getCompilerContext, r as normalizeStyleHandlerMajorVersion, s as shouldSkipJsTransform, u as createTailwindRuntimeReadyPromise } from "./compiler-qDa3phIv.js";
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
@@ -363,7 +363,7 @@ const GULP_COMPILATION_SCOPE_CACHE_MAX = 512;
 /**
 * @name weapp-tw-gulp
 * @description native framework 的插件组合实现
-* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+* @link https://tw.weapp.dev/docs/quick-start/frameworks/native
 */
 function createNativeGulpPlugins(options = {}) {
 	const hasInitialTailwindCssRoots = hasConfiguredTailwindV4CssRoots(options);
@@ -669,7 +669,7 @@ function createNativeGulpFrameworkPlugins(options = {}) {
 /**
 * @name weapp-tw-gulp
 * @description Gulp 入口直接创建 native framework，具体 stream 组合由 frameworks/native 拥有。
-* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+* @link https://tw.weapp.dev/docs/quick-start/frameworks/native
 */
 function createPlugins(options = {}) {
 	return createNativeGulpFrameworkPlugins(options);

package/dist/gulp.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_gulp = require("./gulp-CUysZjW3.cjs");
+const require_gulp = require("./gulp-CW6JGqVn.cjs");
 exports.WeappTailwindcss = require_gulp.createPlugins;
 exports.createPlugins = require_gulp.createPlugins;
 exports.weappTailwindcss = require_gulp.createPlugins;

package/dist/gulp.js

@@ -1,2 +1,2 @@
-import { t as createPlugins } from "./gulp-DwtrU4V1.js";
+import { t as createPlugins } from "./gulp-e2iWsmEK.js";
 export { createPlugins as WeappTailwindcss, createPlugins, createPlugins as weappTailwindcss };