weapp-tailwindcss 4.12.0 → 5.0.0-next.10

package/dist/bundle-state-EUbcdKqo.js

@@ -0,0 +1,410 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_precheck = require("./precheck-B32p-gLI.js");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_buffer = require("node:buffer");
+let htmlparser2 = require("htmlparser2");
+//#region src/bundlers/shared/module-graph.ts
+const QUERY_HASH_RE = /[?#].*$/u;
+const PROTOCOL_RE = /^[a-z][a-z+.-]*:/iu;
+const WINDOWS_ABSOLUTE_RE = /^[a-z]:[\\/]/iu;
+const VIRTUAL_PREFIX = "\0";
+const JS_EXTENSIONS = [
+	".js",
+	".mjs",
+	".cjs"
+];
+function normalizeOutputPathKey(value) {
+	return node_path.default.normalize(value).replace(/\\/g, "/");
+}
+function stripQueryAndHash(specifier) {
+	return specifier.replace(QUERY_HASH_RE, "");
+}
+function isResolvableSpecifier(specifier) {
+	if (!specifier) return false;
+	const normalized = stripQueryAndHash(specifier);
+	if (normalized.startsWith(VIRTUAL_PREFIX)) return false;
+	if (node_path.default.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) return true;
+	return !PROTOCOL_RE.test(normalized);
+}
+function toAbsoluteOutputPath(fileName, outDir) {
+	if (node_path.default.isAbsolute(fileName) || WINDOWS_ABSOLUTE_RE.test(fileName)) return node_path.default.normalize(fileName);
+	return node_path.default.resolve(outDir, fileName);
+}
+function matchWithExtensions(candidate, hasOutput) {
+	if (hasOutput(candidate)) return candidate;
+	if (!node_path.default.extname(candidate)) for (const ext of JS_EXTENSIONS) {
+		const extended = `${candidate}${ext}`;
+		if (hasOutput(extended)) return extended;
+	}
+}
+function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
+	if (!isResolvableSpecifier(specifier)) return;
+	const normalized = stripQueryAndHash(specifier);
+	let candidate;
+	if (node_path.default.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) candidate = node_path.default.normalize(normalized);
+	else if (normalized.startsWith("/")) candidate = node_path.default.resolve(outDir, normalized.slice(1));
+	else candidate = node_path.default.resolve(node_path.default.dirname(importer), normalized);
+	return matchWithExtensions(candidate, hasOutput);
+}
+//#endregion
+//#region src/utils/disabled.ts
+function resolvePluginDisabledState(disabled) {
+	if (disabled === true) return { plugin: true };
+	if (disabled === false || disabled == null) return { plugin: false };
+	return { plugin: disabled.plugin ?? false };
+}
+//#endregion
+//#region src/utils/resolve-package.ts
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function resolvePackageDir(name) {
+	const pkgPath = require$1.resolve(`${name}/package.json`);
+	return node_path.default.dirname(pkgPath);
+}
+//#endregion
+//#region src/bundlers/shared/run-tasks.ts
+async function runWithConcurrency(factories, limit = Math.min(4, Math.max(1, factories.length))) {
+	if (factories.length === 0) return [];
+	const results = Array.from({ length: factories.length });
+	const executing = /* @__PURE__ */ new Set();
+	let cursor = 0;
+	const effectiveLimit = Math.max(1, limit);
+	const scheduleNext = () => {
+		if (cursor >= factories.length) return;
+		const currentIndex = cursor++;
+		const wrapped = Promise.resolve(factories[currentIndex]()).then((value) => {
+			results[currentIndex] = value;
+		}).finally(() => {
+			executing.delete(wrapped);
+		});
+		executing.add(wrapped);
+	};
+	while (cursor < factories.length && executing.size < effectiveLimit) scheduleNext();
+	while (cursor < factories.length) {
+		await Promise.race(executing);
+		scheduleNext();
+	}
+	await Promise.all(executing);
+	return results;
+}
+function pushConcurrentTaskFactories(queue, factories, limit) {
+	if (factories.length === 0) return;
+	queue.push(runWithConcurrency(factories, limit).then(() => void 0));
+}
+//#endregion
+//#region src/bundlers/vite/bundle-entries.ts
+function readOutputEntry(entry) {
+	if (entry.output.type === "chunk") return entry.output.code;
+	const source = entry.output.source;
+	if (typeof source === "string") return source;
+	if (source instanceof Uint8Array) return node_buffer.Buffer.from(source).toString();
+	const fallbackSource = source;
+	if (fallbackSource == null) return;
+	if (typeof fallbackSource.toString === "function") return fallbackSource.toString();
+}
+function isJavaScriptEntry(entry) {
+	if (entry.output.type === "chunk") return true;
+	return entry.fileName.endsWith(".js");
+}
+function createBundleModuleGraphOptions(outputDir, entries) {
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [id, entry] of entries) normalizedEntries.set(normalizeOutputPathKey(id), entry);
+	const getEntry = (id) => entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(id));
+	return {
+		resolve(specifier, importer) {
+			return resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => Boolean(getEntry(candidate)));
+		},
+		load(id) {
+			const entry = getEntry(id);
+			if (!entry) return;
+			return readOutputEntry(entry);
+		},
+		filter(id) {
+			return Boolean(getEntry(id));
+		}
+	};
+}
+function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
+	if (!linked) return;
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [entryId, entry] of entries) normalizedEntries.set(normalizeOutputPathKey(entryId), entry);
+	for (const [id, { code }] of Object.entries(linked)) {
+		const entry = entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(id));
+		if (!entry) continue;
+		const previous = readOutputEntry(entry);
+		if (previous == null || previous === code) continue;
+		if (entry.output.type === "chunk") entry.output.code = code;
+		else entry.output.source = code;
+		onApplied?.(entry, code);
+		onLinkedUpdate(entry.fileName, previous, code);
+	}
+}
+//#endregion
+//#region src/bundlers/vite/runtime-affecting-signature.ts
+const CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+const CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
+const CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
+const CSS_WHITESPACE_RE = /\s+/g;
+function createHtmlRuntimeAffectingSignature(source) {
+	try {
+		const parts = [];
+		const parser = new htmlparser2.Parser({
+			onattribute(name, value) {
+				parts.push(`a:${name}=${value}`);
+			},
+			oncomment(data) {
+				parts.push(`c:${data}`);
+			},
+			ontext(data) {
+				const value = data.trim();
+				if (value.length > 0) parts.push(`t:${value}`);
+			}
+		}, { xmlMode: true });
+		parser.write(source);
+		parser.end();
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createJsRuntimeAffectingSignature(source) {
+	try {
+		const ast = require_precheck.babelParse(source, {
+			cache: true,
+			cacheKey: "vite-runtime-affecting:unambiguous",
+			plugins: ["jsx", "typescript"],
+			sourceType: "unambiguous"
+		});
+		const parts = [];
+		require_precheck.traverse(ast, {
+			noScope: true,
+			StringLiteral(path) {
+				parts.push(`s:${path.node.value}`);
+			},
+			TemplateElement(path) {
+				parts.push(`t:${path.node.value.raw}`);
+			},
+			JSXText(path) {
+				const value = path.node.value.trim();
+				if (value.length > 0) parts.push(`x:${value}`);
+			}
+		});
+		const comments = ast.comments;
+		if (Array.isArray(comments)) {
+			for (const comment of comments) if (typeof comment?.value === "string" && comment.value.length > 0) parts.push(`c:${comment.value}`);
+		}
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createCssRuntimeAffectingSignature(source) {
+	return source.replace(CSS_BLOCK_COMMENT_RE, "").replace(CSS_AROUND_PUNCTUATION_RE, "$1").replace(CSS_TRAILING_DECLARATION_SEMICOLON_RE, "}").replace(CSS_WHITESPACE_RE, " ").trim();
+}
+function createRuntimeAffectingSourceSignature(source, type) {
+	if (type === "html") return createHtmlRuntimeAffectingSignature(source);
+	if (type === "js") return createJsRuntimeAffectingSignature(source);
+	if (type === "css") return createCssRuntimeAffectingSignature(source);
+	return source;
+}
+//#endregion
+//#region src/bundlers/vite/bundle-state.ts
+function createBundleBuildState() {
+	return {
+		iteration: 0,
+		sourceHashByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+		linkedByEntry: /* @__PURE__ */ new Map(),
+		dependentsByLinkedFile: /* @__PURE__ */ new Map()
+	};
+}
+function createChangedByType() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set(),
+		other: /* @__PURE__ */ new Set()
+	};
+}
+function createProcessFiles() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set()
+	};
+}
+function readEntrySource(output) {
+	if (output.type === "chunk") return output.code;
+	return output.source.toString();
+}
+function classifyBundleEntry(file, opts) {
+	if (opts.cssMatcher(file)) return "css";
+	if (opts.htmlMatcher(file)) return "html";
+	if (opts.jsMatcher(file) || opts.wxsMatcher(file)) return "js";
+	return "other";
+}
+function collectJsEntries(fileName, output, outDir, store) {
+	const entry = {
+		fileName,
+		output
+	};
+	if (!isJavaScriptEntry(entry)) return;
+	const absolute = toAbsoluteOutputPath(fileName, outDir);
+	store.set(absolute, entry);
+}
+function markProcessFile(type, file, processFiles) {
+	if (type === "html" || type === "js" || type === "css") processFiles[type].add(file);
+}
+function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
+	const sourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingSignatureByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingHashByFile = /* @__PURE__ */ new Map();
+	const changedByType = createChangedByType();
+	const runtimeAffectingChangedByType = createChangedByType();
+	const processFiles = createProcessFiles();
+	const linkedImpactsByEntry = /* @__PURE__ */ new Map();
+	const jsEntries = /* @__PURE__ */ new Map();
+	const entries = [];
+	const firstRun = state.linkedByEntry.size === 0;
+	for (const [file, output] of Object.entries(bundle)) {
+		const type = classifyBundleEntry(file, opts);
+		const source = readEntrySource(output);
+		const hash = opts.cache.computeHash(source);
+		sourceHashByFile.set(file, hash);
+		const previousHash = state.sourceHashByFile.get(file);
+		const changed = previousHash == null || previousHash !== hash;
+		const previousRuntimeAffectingSignature = state.runtimeAffectingSignatureByFile.get(file);
+		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+		const canReuseRuntimeAffectingSignature = !changed && previousRuntimeAffectingSignature != null && previousRuntimeAffectingHash != null;
+		const runtimeAffectingSignature = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingSignature : createRuntimeAffectingSourceSignature(source, type);
+		const runtimeAffectingHash = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingHash : opts.cache.computeHash(runtimeAffectingSignature);
+		runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+		runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+		if (changed) changedByType[type].add(file);
+		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) runtimeAffectingChangedByType[type].add(file);
+		if (forceAll || firstRun) markProcessFile(type, file, processFiles);
+		else if (type === "html") processFiles.html.add(file);
+		else if (changed && (type === "js" || type === "css")) processFiles[type].add(file);
+		collectJsEntries(file, output, outDir, jsEntries);
+		entries.push({
+			file,
+			output,
+			source,
+			type
+		});
+	}
+	if (!forceAll && !firstRun) for (const changedFile of changedByType.js) {
+		const dependents = state.dependentsByLinkedFile.get(changedFile);
+		if (!dependents) continue;
+		for (const entryFile of dependents) {
+			processFiles.js.add(entryFile);
+			let impacts = linkedImpactsByEntry.get(entryFile);
+			if (!impacts) {
+				impacts = /* @__PURE__ */ new Set();
+				linkedImpactsByEntry.set(entryFile, impacts);
+			}
+			impacts.add(changedFile);
+		}
+	}
+	return {
+		entries,
+		jsEntries,
+		sourceHashByFile,
+		runtimeAffectingSignatureByFile,
+		runtimeAffectingHashByFile,
+		changedByType,
+		runtimeAffectingChangedByType,
+		processFiles,
+		linkedImpactsByEntry
+	};
+}
+function invertLinkedByEntry(linkedByEntry) {
+	const dependentsByLinkedFile = /* @__PURE__ */ new Map();
+	for (const [entryFile, linkedFiles] of linkedByEntry.entries()) for (const linkedFile of linkedFiles) {
+		let dependents = dependentsByLinkedFile.get(linkedFile);
+		if (!dependents) {
+			dependents = /* @__PURE__ */ new Set();
+			dependentsByLinkedFile.set(linkedFile, dependents);
+		}
+		dependents.add(entryFile);
+	}
+	return dependentsByLinkedFile;
+}
+function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
+	const incremental = options.incremental === true;
+	state.iteration += 1;
+	state.sourceHashByFile = incremental ? new Map([...state.sourceHashByFile, ...snapshot.sourceHashByFile]) : snapshot.sourceHashByFile;
+	state.runtimeAffectingSignatureByFile = incremental ? new Map([...state.runtimeAffectingSignatureByFile, ...snapshot.runtimeAffectingSignatureByFile]) : snapshot.runtimeAffectingSignatureByFile;
+	state.runtimeAffectingHashByFile = incremental ? new Map([...state.runtimeAffectingHashByFile, ...snapshot.runtimeAffectingHashByFile]) : snapshot.runtimeAffectingHashByFile;
+	state.linkedByEntry = incremental ? new Map([...state.linkedByEntry, ...linkedByEntry]) : linkedByEntry;
+	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
+}
+//#endregion
+Object.defineProperty(exports, "applyLinkedResults", {
+	enumerable: true,
+	get: function() {
+		return applyLinkedResults;
+	}
+});
+Object.defineProperty(exports, "buildBundleSnapshot", {
+	enumerable: true,
+	get: function() {
+		return buildBundleSnapshot;
+	}
+});
+Object.defineProperty(exports, "createBundleBuildState", {
+	enumerable: true,
+	get: function() {
+		return createBundleBuildState;
+	}
+});
+Object.defineProperty(exports, "createBundleModuleGraphOptions", {
+	enumerable: true,
+	get: function() {
+		return createBundleModuleGraphOptions;
+	}
+});
+Object.defineProperty(exports, "normalizeOutputPathKey", {
+	enumerable: true,
+	get: function() {
+		return normalizeOutputPathKey;
+	}
+});
+Object.defineProperty(exports, "pushConcurrentTaskFactories", {
+	enumerable: true,
+	get: function() {
+		return pushConcurrentTaskFactories;
+	}
+});
+Object.defineProperty(exports, "resolveOutputSpecifier", {
+	enumerable: true,
+	get: function() {
+		return resolveOutputSpecifier;
+	}
+});
+Object.defineProperty(exports, "resolvePackageDir", {
+	enumerable: true,
+	get: function() {
+		return resolvePackageDir;
+	}
+});
+Object.defineProperty(exports, "resolvePluginDisabledState", {
+	enumerable: true,
+	get: function() {
+		return resolvePluginDisabledState;
+	}
+});
+Object.defineProperty(exports, "toAbsoluteOutputPath", {
+	enumerable: true,
+	get: function() {
+		return toAbsoluteOutputPath;
+	}
+});
+Object.defineProperty(exports, "updateBundleBuildState", {
+	enumerable: true,
+	get: function() {
+		return updateBundleBuildState;
+	}
+});

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/at-rules.d.ts

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

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

@@ -0,0 +1,3 @@
+import type postcss from 'postcss';
+export declare function isDisplayP3MediaRule(atRule: postcss.AtRule): boolean;
+export declare function isDisplayP3Declaration(decl: postcss.Declaration): boolean;

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

@@ -0,0 +1,4 @@
+import type postcss from 'postcss';
+export declare function removeSpecificityPlaceholders(root: postcss.Root): void;
+export declare function removeUnsupportedBrowserSelectors(root: postcss.Root): void;
+export declare function removeDisplayP3Declarations(root: postcss.Root): void;

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

@@ -0,0 +1,8 @@
+import type postcss from 'postcss';
+export declare const MINI_PROGRAM_THEME_SCOPE_SELECTOR = ":host,page,.tw-root,wx-root-portal-content";
+export declare const MINI_PROGRAM_PREFLIGHT_SELECTORS: Set<string>;
+export declare const MINI_PROGRAM_THEME_SCOPE_SELECTORS: Set<string>;
+export declare const SPECIFICITY_PLACEHOLDER_SUFFIXES: string[];
+export declare function normalizeSelector(selector: string): string;
+export declare function getRuleSelectors(rule: postcss.Rule): string[];
+export declare function isUnsupportedBrowserSelector(selector: string): boolean;

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

@@ -0,0 +1,3 @@
+export { removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules } from './css-cleanup/at-rules';
+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-css/config-directive.d.ts

@@ -0,0 +1,2 @@
+export declare function prependConfigDirective(css: string, config: string | undefined): string;
+export declare function normalizeConfigDirective(css: string, config: string | undefined): string;

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

@@ -0,0 +1,13 @@
+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 hasTailwindApplyDirective(rawSource: string): boolean;
+export declare function resolveCssEntrySource(rawSource: string, base: string, options?: {
+    removeConfig?: boolean;
+}): {
+    css: string;
+    config: string | undefined;
+    configRequest: string | undefined;
+    base: string;
+} | undefined;

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

@@ -0,0 +1,7 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindResolvedSource } from '../../../generator';
+import type { InternalUserDefinedOptions } from '../../../types';
+export declare function removeTailwindApplyRules(rawSource: string): string;
+export declare function hasConfiguredContainerCompatSources(sources: TailwindResolvedSource[]): boolean;
+export declare function appendLegacyCompatCss(css: string, rawSource: string, generatorTarget: string, styleHandler: InternalUserDefinedOptions['styleHandler'], cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Promise<string>;
+export declare function appendLegacyContainerCompatCss(css: string, rawSource: string, file: string, runtime: Set<string>, configuredContainerCompat: boolean, generatorTarget: string, styleHandler: InternalUserDefinedOptions['styleHandler'], cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Promise<string>;

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

@@ -0,0 +1,5 @@
+export declare function normalizeCompatSelectors(selector: string): string[];
+export declare function collectGeneratedSelectors(css: string): Set<string>;
+export declare function removeGeneratedSelectorCompatCss(css: string, generatedCss: string): string;
+export declare function collectDedupedPostTransformCompatCss(css: string, generatedCss: string): string;
+export declare function removeDuplicatedViteMarkers(css: string, baseCss: string): string;

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

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

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

@@ -0,0 +1,16 @@
+export declare const TAILWIND_V4_BANNER_RE: RegExp;
+export declare const TAILWIND_GENERATED_CSS_MARKER_RE: RegExp;
+export declare const GENERATOR_PLACEHOLDER_MARKER_RE: RegExp;
+export declare const GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE: RegExp;
+export declare const TAILWIND_BANNER_PREFIX_RE: RegExp;
+export declare const TAILWIND_BANNER_RE: RegExp;
+export declare const TAILWIND_BANNER_GLOBAL_RE: RegExp;
+export declare const VITE_MARKER_RE: RegExp;
+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;

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

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

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

@@ -0,0 +1,10 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../../generator';
+import type { InternalUserDefinedOptions } from '../../../types';
+interface GeneratorSourceRuntimeState {
+    twPatcher: InternalUserDefinedOptions['twPatcher'];
+}
+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 {};

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

@@ -0,0 +1,33 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { InternalUserDefinedOptions } from '../../types';
+export { hasTailwindSourceDirectives, 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';
+export { resolveGeneratorSource, } from './generator-css/source-resolver';
+export interface GenerateCssByGeneratorOptions {
+    opts: InternalUserDefinedOptions;
+    runtimeState: {
+        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        readyPromise: 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';
+    dependencies: string[];
+}
+export declare function isPureLocalCssImportWrapper(css: string): boolean;
+export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;
+export interface ValidateCandidatesByGeneratorOptions extends Omit<GenerateCssByGeneratorOptions, 'runtime'> {
+    candidates: Set<string>;
+}
+export declare function validateCandidatesByGenerator(options: ValidateCandidatesByGeneratorOptions): Promise<Set<string>>;

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 {};