weapp-tailwindcss 5.0.0-next.3 → 5.0.0-next.30

package/dist/bundle-state-Ct_8GcSR.js

@@ -0,0 +1,529 @@
+const require_chunk = require("./chunk-C5U5_Hdc.js");
+const require_precheck = require("./precheck-D7gJSmJz.js");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+let node_buffer = require("node:buffer");
+//#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/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/bundlers/vite/utils.ts
+function slash(p) {
+	return (0, _weapp_tailwindcss_shared.ensurePosix)(p);
+}
+const isWindows = node_process.default.platform === "win32";
+const cssLangRE = new RegExp(`\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`);
+function isCSSRequest(request) {
+	return cssLangRE.test(request) || isSourceStyleRequest(request);
+}
+function normalizePath(id) {
+	return node_path.default.posix.normalize(isWindows ? (0, _weapp_tailwindcss_shared.ensurePosix)(id) : id);
+}
+async function formatPostcssSourceMap(rawMap, file) {
+	const inputFileDir = node_path.default.dirname(file);
+	const sources = rawMap.sources.map((source) => {
+		const cleanSource = (0, _weapp_tailwindcss_shared.cleanUrl)(decodeURIComponent(source));
+		if (cleanSource[0] === "<" && cleanSource.endsWith(">")) return `\0${cleanSource}`;
+		return normalizePath(node_path.default.resolve(inputFileDir, cleanSource));
+	});
+	return {
+		file,
+		mappings: rawMap.mappings,
+		names: rawMap.names,
+		sources,
+		sourcesContent: rawMap.sourcesContent,
+		version: rawMap.version
+	};
+}
+//#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/generated-css-marker.ts
+const BUNDLER_GENERATED_CSS_MARKER_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/i;
+const BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/gi;
+function createBundlerGeneratedCssMarker(bundler, file) {
+	return `/*! weapp-tailwindcss ${bundler}-generated-css:${encodeURIComponent(file)} */`;
+}
+function hasBundlerGeneratedCssMarker(source) {
+	return typeof source === "string" && BUNDLER_GENERATED_CSS_MARKER_RE.test(source);
+}
+function stripBundlerGeneratedCssMarkers(source) {
+	return source.replace(BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE, "");
+}
+//#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 factory = factories[currentIndex];
+		if (!factory) return;
+		const wrapped = Promise.resolve(factory()).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 require_precheck.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(),
+		generatorCandidateSignature: void 0
+	};
+}
+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) || isCSSRequest(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, "createBundlerGeneratedCssMarker", {
+	enumerable: true,
+	get: function() {
+		return createBundlerGeneratedCssMarker;
+	}
+});
+Object.defineProperty(exports, "formatPostcssSourceMap", {
+	enumerable: true,
+	get: function() {
+		return formatPostcssSourceMap;
+	}
+});
+Object.defineProperty(exports, "hasBundlerGeneratedCssMarker", {
+	enumerable: true,
+	get: function() {
+		return hasBundlerGeneratedCssMarker;
+	}
+});
+Object.defineProperty(exports, "isCSSRequest", {
+	enumerable: true,
+	get: function() {
+		return isCSSRequest;
+	}
+});
+Object.defineProperty(exports, "isSourceStyleRequest", {
+	enumerable: true,
+	get: function() {
+		return isSourceStyleRequest;
+	}
+});
+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, "slash", {
+	enumerable: true,
+	get: function() {
+		return slash;
+	}
+});
+Object.defineProperty(exports, "stripBundlerGeneratedCssMarkers", {
+	enumerable: true,
+	get: function() {
+		return stripBundlerGeneratedCssMarkers;
+	}
+});
+Object.defineProperty(exports, "stripRequestQuery", {
+	enumerable: true,
+	get: function() {
+		return stripRequestQuery;
+	}
+});
+Object.defineProperty(exports, "toAbsoluteOutputPath", {
+	enumerable: true,
+	get: function() {
+		return toAbsoluteOutputPath;
+	}
+});
+Object.defineProperty(exports, "updateBundleBuildState", {
+	enumerable: true,
+	get: function() {
+		return updateBundleBuildState;
+	}
+});

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

@@ -0,0 +1 @@
+export { removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules, } from '@weapp-tailwindcss/postcss';

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

@@ -1,4 +1 @@
-export declare function removeUnsupportedMiniProgramAtRules(css: string): string;
-export declare function removeUnsupportedAtSupports(css: string): string;
-export declare function hoistTailwindPreflightBase(css: string): string;
-export declare function finalizeMiniProgramCss(css: string): string;
+export { finalizeMiniProgramCss, hoistTailwindPreflightBase, removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules, } from '@weapp-tailwindcss/postcss';

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/generated-css-marker.d.ts

@@ -0,0 +1,3 @@
+export declare function createBundlerGeneratedCssMarker(bundler: 'vite' | 'webpack', file: string): string;
+export declare function hasBundlerGeneratedCssMarker(source: unknown): boolean;
+export declare function stripBundlerGeneratedCssMarkers(source: string): string;

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,20 @@
+interface TailwindDirectiveOptions {
+    importFallback?: boolean | undefined;
+}
+export declare function parseImportRequest(params: string): string | undefined;
+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/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,28 @@
+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 splitTailwindV4GeneratedCssBySourceOrder(rawSource: string, rawTailwindCss: string): {
+    before: string;
+    after: string;
+} | undefined;
+export declare function splitGeneratorPlaceholderCssBySourceOrder(rawSource: string, rawTailwindCss?: string): {
+    before: string;
+    after: string;
+} | undefined;
+export declare function removeTailwindGeneratedCssByBanner(rawSource: string): string | undefined;
+export declare function splitTailwindGeneratedCssByBanner(rawSource: string, start?: number): {
+    before: string;
+    after: 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,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;
+}): SourceSideCssEntrySource | undefined;