weapp-tailwindcss 5.0.0-next.8 → 5.0.0

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { weappTailwindcssPostcssPlugin } from './postcss';
 export type { WeappTailwindcssPostcssPluginOptions } from './postcss';
 export type * from './types';
 export { WeappTailwindcss } from './vite';
-export { UnifiedWebpackPluginV5, weappTailwindcssPackageDir } from './webpack';
+export { weappTailwindcssPackageDir } from './webpack';
+export { unitConversionComposeRules, unitConversionPresets, } from '@weapp-tailwindcss/postcss';

package/dist/index.js

@@ -1,12 +1,24 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_generator = require("./generator-DKkhJbOg.js");
+const require_generator = require("./generator--0-ekuVO.js");
 const require_gulp = require("./gulp.js");
-const require_postcss = require("./postcss-QIXwT40c.js");
-const require_vite = require("./vite-DyZuiyap.js");
-const require_webpack = require("./webpack-CNV2dx3Q.js");
-exports.UnifiedWebpackPluginV5 = require_webpack.UnifiedWebpackPluginV5;
+const require_postcss = require("./postcss-hYimKoN_.js");
+const require_vite = require("./vite-Ec0uX6kF.js");
+const require_webpack = require("./webpack-Ccohlg3A.js");
+let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
 exports.WeappTailwindcss = require_vite.WeappTailwindcss;
 exports.createPlugins = require_gulp.createPlugins;
 exports.createWeappTailwindcssGenerator = require_generator.createWeappTailwindcssGenerator;
+Object.defineProperty(exports, "unitConversionComposeRules", {
+	enumerable: true,
+	get: function() {
+		return _weapp_tailwindcss_postcss.unitConversionComposeRules;
+	}
+});
+Object.defineProperty(exports, "unitConversionPresets", {
+	enumerable: true,
+	get: function() {
+		return _weapp_tailwindcss_postcss.unitConversionPresets;
+	}
+});
 exports.weappTailwindcssPackageDir = require_webpack.weappTailwindcssPackageDir;
 exports.weappTailwindcssPostcssPlugin = require_postcss.weappTailwindcssPostcssPlugin;

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { t as createWeappTailwindcssGenerator } from "./generator-UBmfduYg.mjs";
+import { t as createWeappTailwindcssGenerator } from "./generator-B76ovqsv.mjs";
 import { WeappTailwindcss as createPlugins } from "./gulp.mjs";
-import { t as weappTailwindcssPostcssPlugin } from "./postcss-w48mGIhe.mjs";
-import { t as WeappTailwindcss } from "./vite-BwgRVgxH.mjs";
-import { n as weappTailwindcssPackageDir, t as UnifiedWebpackPluginV5 } from "./webpack-CT6EEENx.mjs";
-export { UnifiedWebpackPluginV5, WeappTailwindcss, createPlugins, createWeappTailwindcssGenerator, weappTailwindcssPackageDir, weappTailwindcssPostcssPlugin };
+import { t as weappTailwindcssPostcssPlugin } from "./postcss-CR9UCaIK.mjs";
+import { t as WeappTailwindcss } from "./vite-DOprpdH-.mjs";
+import { n as weappTailwindcssPackageDir } from "./webpack-DFlZcqAU.mjs";
+import { unitConversionComposeRules, unitConversionPresets } from "@weapp-tailwindcss/postcss";
+export { WeappTailwindcss, createPlugins, createWeappTailwindcssGenerator, unitConversionComposeRules, unitConversionPresets, weappTailwindcssPackageDir, weappTailwindcssPostcssPlugin };

package/dist/js/babel/cache-options.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_PARSE_CACHE_MAX_ENTRIES = 128;
+export declare const DEFAULT_PARSE_CACHE_MAX_SOURCE_LENGTH = 50000;
+export declare const HARD_PARSE_CACHE_MAX_ENTRIES = 1024;

package/dist/js/babel/parse.d.ts

@@ -1,9 +1,12 @@
 import type { ParseResult, ParserOptions } from '@babel/parser';
 import type { File } from '@babel/types';
 import { LRUCache } from 'lru-cache';
+export type BabelParseOptions = ParserOptions & {
+    cache?: boolean | undefined;
+    cacheKey?: string | undefined;
+    cacheMaxEntries?: number | undefined;
+    cacheMaxSourceLength?: number | undefined;
+};
 export declare const parseCache: LRUCache<string, ParseResult<File>>;
 export declare function genCacheKey(source: string, options: any): string;
-export declare function babelParse(code: string, opts?: (ParserOptions & {
-    cache?: boolean;
-    cacheKey?: string;
-})): ParseResult<File>;
+export declare function babelParse(code: string, opts?: BabelParseOptions): ParseResult<File>;

package/dist/js/precheck.d.ts

@@ -1,2 +1,2 @@
-import type { CreateJsHandlerOptions } from '../types';
-export declare function shouldSkipJsTransform(rawSource: string, options?: CreateJsHandlerOptions): boolean;
+import type { IJsHandlerOptions } from '../types';
+export declare function shouldSkipJsTransform(rawSource: string, options?: IJsHandlerOptions): boolean;

package/dist/js/replacement-cache.d.ts

@@ -0,0 +1,5 @@
+import type { IJsHandlerOptions } from '../types';
+type EscapeMap = NonNullable<IJsHandlerOptions['escapeMap']>;
+export declare function getReplacementCacheStore(escapeMap?: EscapeMap): Map<string, string>;
+export declare function getReplacement(candidate: string, escapeMap: EscapeMap | undefined, store?: Map<string, string>): string;
+export {};

package/dist/postcss-C7BMYpEF.mjs

@@ -0,0 +1,169 @@
+//#region src/css-macro/constants.ts
+const queryKey = "weapp-tw-platform";
+const ifdefAtRule = "weapp-tw-ifdef";
+const ifndefAtRule = "weapp-tw-ifndef";
+function quoteAtRuleParam(value) {
+	return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function createConditionalAtRule(value) {
+	return `@${ifdefAtRule} ${quoteAtRuleParam(value)}{&}`;
+}
+function createNegativeConditionalAtRule(value) {
+	return `@${ifndefAtRule} ${quoteAtRuleParam(value)}{&}`;
+}
+const UNESCAPED_UNDERSCORE_RE = /(?<!\\)_/g;
+const WHITESPACE_RE = /\s+/g;
+const LOGICAL_OPERATOR_RE = /\s*(\|\||&&)\s*/g;
+function normalComment(text) {
+	if (typeof text === "string") {
+		const normalized = text.replaceAll(UNESCAPED_UNDERSCORE_RE, " ").replaceAll(WHITESPACE_RE, " ").trim();
+		if (normalized.includes("\\")) return normalized;
+		return normalized.replaceAll(LOGICAL_OPERATOR_RE, " $1 ").replaceAll(WHITESPACE_RE, " ").trim();
+	}
+	return text;
+}
+function ifdef(text) {
+	return {
+		start: `#ifdef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+function ifndef(text) {
+	return {
+		start: `#ifndef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+const QUERY_KEY_REGEX = new RegExp(`\\(\\s*${queryKey}\\s*:\\s*"([^)]*)"\\)`, "g");
+function matchCustomPropertyFromValue(str, cb) {
+	let index = 0;
+	QUERY_KEY_REGEX.lastIndex = 0;
+	let arr = QUERY_KEY_REGEX.exec(str);
+	while (arr !== null) {
+		cb(arr, index);
+		index++;
+		arr = QUERY_KEY_REGEX.exec(str);
+	}
+}
+function parseConditionalAtRuleParam(params) {
+	const value = params.trim();
+	const quoted = /^(['"])((?:\\.|(?!\1).)*)\1/.exec(value);
+	if (!quoted) return value;
+	return quoted[2]?.replaceAll(/\\(["'\\])/g, "$1") ?? "";
+}
+//#endregion
+//#region src/css-macro/postcss.ts
+const IFDEF_ENDIF_RE = /#(?:ifn?def|endif)/;
+const CONDITIONAL_COMMENT_SPACING = " ";
+const CSS_MACRO_POSTCSS_PLUGIN_NAME = "postcss-weapp-tw-css-macro-plugin";
+const creator = () => {
+	return {
+		postcssPlugin: CSS_MACRO_POSTCSS_PLUGIN_NAME,
+		prepare() {
+			function replaceAtRuleWithConditionalComments(atRule, helper, comment) {
+				const hasPreviousNode = Boolean(atRule.prev());
+				const clonedNodes = (atRule.nodes ?? []).map((node) => node.clone());
+				const startComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.start
+				});
+				const endComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.end
+				});
+				const nextNodes = [
+					startComment,
+					...clonedNodes,
+					endComment
+				];
+				atRule.replaceWith(nextNodes);
+				startComment.raws.before = hasPreviousNode ? "\n" : "";
+				startComment.raws["after"] = "\n";
+				if (clonedNodes[0]) clonedNodes[0].raws.before = "\n";
+				endComment.raws.before = "\n";
+				endComment.raws["after"] = "\n";
+				const nextNode = endComment?.next();
+				if (nextNode) nextNode.raws.before = "\n";
+			}
+			function replaceNestedAtRuleWithConditionalRule(atRule, helper, comment) {
+				if (atRule.parent?.type !== "rule") return false;
+				const parentRule = atRule.parent;
+				const clonedNodes = (atRule.nodes ?? []).map((node) => node.clone());
+				const conditionalRule = parentRule.clone();
+				conditionalRule.removeAll();
+				conditionalRule.append(...clonedNodes);
+				const startComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.start
+				});
+				const endComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.end
+				});
+				const nextNodes = [
+					startComment,
+					conditionalRule,
+					endComment
+				];
+				const hasPreviousNode = Boolean(parentRule.prev());
+				atRule.remove();
+				if ((parentRule.nodes?.length ?? 0) === 0) parentRule.replaceWith(nextNodes);
+				else parentRule.after(nextNodes);
+				startComment.raws.before = hasPreviousNode ? "\n" : "";
+				startComment.raws["after"] = "\n";
+				conditionalRule.raws.before = "\n";
+				endComment.raws.before = "\n";
+				endComment.raws["after"] = "\n";
+				const nextNode = endComment.next();
+				if (nextNode) nextNode.raws.before = "\n";
+				return true;
+			}
+			return {
+				AtRule(atRule, helper) {
+					if (atRule.name === "weapp-tw-ifdef" || atRule.name === "weapp-tw-ifndef") {
+						const text = parseConditionalAtRuleParam(atRule.params);
+						const comment = atRule.name === "weapp-tw-ifndef" ? ifndef(text) : ifdef(text);
+						if (replaceNestedAtRuleWithConditionalRule(atRule, helper, comment)) return;
+						replaceAtRuleWithConditionalComments(atRule, helper, comment);
+						return;
+					}
+					if (atRule.name === "media") {
+						const values = [];
+						matchCustomPropertyFromValue(atRule.params, (arr) => {
+							const value = arr[1];
+							if (value) values.push(value);
+						});
+						if (values.length > 0) {
+							const isNegative = atRule.params.includes("not");
+							const text = values.join(" ");
+							const comment = isNegative ? ifndef(text) : ifdef(text);
+							if (replaceNestedAtRuleWithConditionalRule(atRule, helper, comment)) return;
+							replaceAtRuleWithConditionalComments(atRule, helper, comment);
+						}
+					}
+				},
+				CommentExit(comment) {
+					if (IFDEF_ENDIF_RE.test(comment.text)) {
+						comment.raws.left = CONDITIONAL_COMMENT_SPACING;
+						comment.raws.right = CONDITIONAL_COMMENT_SPACING;
+					}
+				}
+			};
+		}
+	};
+};
+creator.postcss = true;
+//#endregion
+export { createNegativeConditionalAtRule as i, creator as n, createConditionalAtRule as r, CSS_MACRO_POSTCSS_PLUGIN_NAME as t };

package/dist/{postcss-w48mGIhe.mjs → postcss-CR9UCaIK.mjs}

@@ -1,12 +1,11 @@
-import { o as readInstalledPackageMajorVersion } from "./cache-CHs4DXui.mjs";
-import { a as resolveTailwindV4Source$1, i as normalizeWeappTailwindcssGeneratorOptions, p as resolveTailwindV3Source, t as createWeappTailwindcssGenerator } from "./generator-UBmfduYg.mjs";
+import { A as collectCssInlineSourceCandidates, F as parseConfigParam, H as readInstalledPackageMajorVersion, I as resolveCssSourceEntries, M as expandTailwindSourceEntries, O as DEFAULT_SOURCE_SCAN_EXTENSIONS, P as normalizeLegacyContentEntries, j as createSourceScanPattern, t as resolveTailwindV3Source, y as resolveTailwindV4Source$1 } from "./v3-engine-DCxNPBVs.mjs";
+import { i as normalizeWeappTailwindcssGeneratorOptions, t as createWeappTailwindcssGenerator } from "./generator-B76ovqsv.mjs";
 import postcss from "postcss";
-import path from "node:path";
+import { extractRawCandidatesWithPositions, extractValidCandidates } from "tailwindcss-patch";
 import process from "node:process";
-import { extractValidCandidates } from "tailwindcss-patch";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
 import { loadConfig } from "tailwindcss-config";
-import { readFile, stat } from "node:fs/promises";
-import fg from "fast-glob";
 //#region src/postcss/config-directive.ts
 function quoteCssString(value) {
 	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
@@ -61,85 +60,10 @@ function addSourceDependencyMessages(result, files) {
 }
 //#endregion
 //#region src/postcss/source-files.ts
-const POSTCSS_SOURCE_PATTERN = `**/*.{${[
-	"html",
-	"wxml",
-	"axml",
-	"jxml",
-	"ksml",
-	"ttml",
-	"qml",
-	"tyml",
-	"xhsml",
-	"swan",
-	"vue",
-	"mpx",
-	"js",
-	"jsx",
-	"ts",
-	"tsx"
-].join(",")}}`;
-function parseLocalSourceParam(params) {
-	const value = params.trim();
-	if (!value || value === "none" || value.startsWith("not ") || value.startsWith("inline(")) return;
-	return /^(['"])(.+)\1$/.exec(value)?.[2];
-}
-function parseConfigParam(params) {
-	const value = params.trim();
-	return /^(['"])(.+)\1$/.exec(value)?.[2];
-}
-function parseSourceFileParam(params) {
-	const value = params.trim();
-	if (!value || value === "none" || value.startsWith("inline(")) return;
-	const negated = value.startsWith("not ");
-	const sourceValue = negated ? value.slice(4).trim() : value;
-	const match = /^(['"])(.+)\1$/.exec(sourceValue);
-	return match?.[2] ? {
-		negated,
-		sourcePath: match[2]
-	} : void 0;
-}
+const POSTCSS_SOURCE_PATTERN = createSourceScanPattern(DEFAULT_SOURCE_SCAN_EXTENSIONS);
 function getSourceExtension(file) {
 	return path.extname(file).slice(1) || void 0;
 }
-async function pathExistsAsDirectory(file) {
-	try {
-		return (await stat(file)).isDirectory();
-	} catch {
-		return false;
-	}
-}
-async function expandLocalSourceFiles(sourcePath, base) {
-	const absoluteSource = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(base, sourcePath);
-	if (await pathExistsAsDirectory(absoluteSource)) return fg(POSTCSS_SOURCE_PATTERN, {
-		absolute: true,
-		cwd: absoluteSource,
-		onlyFiles: true
-	});
-	return fg(sourcePath, {
-		absolute: true,
-		cwd: base,
-		onlyFiles: true
-	});
-}
-async function resolveTailwindSourceEntry(sourcePath, base, negated) {
-	const absoluteSource = path.isAbsolute(sourcePath) ? path.resolve(sourcePath) : path.resolve(base, sourcePath);
-	if (await pathExistsAsDirectory(absoluteSource)) return {
-		base: absoluteSource,
-		negated,
-		pattern: POSTCSS_SOURCE_PATTERN
-	};
-	if (path.isAbsolute(sourcePath)) return {
-		base: path.dirname(absoluteSource),
-		negated,
-		pattern: path.basename(absoluteSource)
-	};
-	return {
-		base,
-		negated,
-		pattern: sourcePath
-	};
-}
 function collectConfigPaths(root, base) {
 	const configPaths = [];
 	root.walkAtRules("config", (rule) => {
@@ -148,65 +72,81 @@ function collectConfigPaths(root, base) {
 	});
 	return [...new Set(configPaths)];
 }
-function normalizeContentFiles(content) {
-	if (typeof content === "string") return [content];
-	if (Array.isArray(content)) return content.flatMap((item) => normalizeContentFiles(item));
-	if (typeof content === "object" && content !== null && "files" in content) return normalizeContentFiles(content.files);
-	return [];
+function resolveOptionConfigPath(config, base) {
+	if (!config) return;
+	return path.isAbsolute(config) ? config : path.resolve(base, config);
 }
-async function collectConfigContentFiles(root, base) {
-	const configPaths = collectConfigPaths(root, base);
+async function collectConfigContentFiles(root, base, options) {
+	const configPaths = [...new Set([...resolveOptionConfigPath(options.config, base) ? [resolveOptionConfigPath(options.config, base)] : [], ...collectConfigPaths(root, base)])];
 	const files = [];
 	for (const configPath of configPaths) {
-		const contentFiles = normalizeContentFiles((await loadConfig({
+		const contentEntries = normalizeLegacyContentEntries((await loadConfig({
 			config: configPath,
 			cwd: path.dirname(configPath)
-		}))?.config.content);
-		for (const contentFile of contentFiles) files.push(...await expandLocalSourceFiles(contentFile, path.dirname(configPath)));
+		}))?.config.content, path.dirname(configPath));
+		files.push(...await expandTailwindSourceEntries(contentEntries));
 	}
 	return {
 		configPaths,
 		files: [...new Set(files)]
 	};
 }
+async function collectConfiguredContentEntries(root, base, options) {
+	const configPath = resolveOptionConfigPath(options.generator?.config ?? options.config, base) ?? collectConfigPaths(root, base)[0];
+	if (!configPath) return [];
+	const resolvedConfigPath = path.isAbsolute(configPath) ? configPath : path.resolve(base, configPath);
+	return normalizeLegacyContentEntries((await loadConfig({
+		config: resolvedConfigPath,
+		cwd: path.dirname(resolvedConfigPath)
+	}))?.config.content, path.dirname(resolvedConfigPath));
+}
+async function collectRawCandidatesFromSourceEntries(sourceEntries) {
+	const candidates = /* @__PURE__ */ new Set();
+	const files = await expandTailwindSourceEntries(sourceEntries);
+	await Promise.all(files.map(async (file) => {
+		const matches = await extractRawCandidatesWithPositions(await readFile(file, "utf8"), getSourceExtension(file));
+		for (const match of matches) {
+			const candidate = match?.rawCandidate;
+			if (typeof candidate === "string" && candidate.length > 0) candidates.add(candidate);
+		}
+	}));
+	return candidates;
+}
 async function collectAutoTailwindCandidates(root, result, options) {
 	if (options.scanSources === false) return /* @__PURE__ */ new Set();
 	const base = resolvePostcssBase(result, options);
 	const projectRoot = resolvePostcssProjectRoot(result, options);
-	const sourceEntryTasks = [];
-	if (!root.toString().includes("source(none)")) sourceEntryTasks.push(Promise.resolve({
+	const sourceEntries = [];
+	const hasSourceNone = root.toString().includes("source(none)");
+	const inlineCandidates = collectCssInlineSourceCandidates(root);
+	const configuredContentEntries = options.version === 3 ? await collectConfiguredContentEntries(root, base, options) : [];
+	if (configuredContentEntries.length > 0) sourceEntries.push(...configuredContentEntries);
+	else if (!hasSourceNone) sourceEntries.push({
 		base,
 		negated: false,
 		pattern: POSTCSS_SOURCE_PATTERN
-	}));
-	root.walkAtRules("source", (rule) => {
-		const parsed = parseSourceFileParam(rule.params);
-		if (!parsed) return;
-		sourceEntryTasks.push(resolveTailwindSourceEntry(parsed.sourcePath, base, parsed.negated));
 	});
-	const sourceEntries = await Promise.all(sourceEntryTasks);
-	if (sourceEntries.length === 0) return /* @__PURE__ */ new Set();
-	const candidates = await extractValidCandidates({
+	sourceEntries.push(...await resolveCssSourceEntries(root, base, POSTCSS_SOURCE_PATTERN));
+	const candidates = sourceEntries.length === 0 ? [] : options.version === 3 ? await collectRawCandidatesFromSourceEntries(sourceEntries) : await extractValidCandidates({
 		base,
 		css: root.toString(),
 		cwd: projectRoot,
 		sources: sourceEntries
 	});
-	return new Set(candidates);
+	return new Set([...[...candidates].filter((candidate) => !inlineCandidates.excluded.has(candidate)), ...inlineCandidates.included]);
 }
 async function collectPostcssLocalSources(root, result, options) {
 	const base = resolvePostcssBase(result, options);
-	const sourcePaths = [];
-	root.walkAtRules("source", (rule) => {
-		const sourcePath = parseLocalSourceParam(rule.params);
-		if (sourcePath) sourcePaths.push(sourcePath);
-	});
-	const configContentFiles = await collectConfigContentFiles(root, base);
-	const files = [...new Set((await Promise.all(sourcePaths.map((sourcePath) => expandLocalSourceFiles(sourcePath, base)))).flat().concat(configContentFiles.files))];
-	const sources = await Promise.all(files.map(async (file) => ({
-		content: await readFile(file, "utf8"),
-		extension: getSourceExtension(file)
-	})));
+	const sourceEntries = await resolveCssSourceEntries(root, base, POSTCSS_SOURCE_PATTERN);
+	const configContentFiles = await collectConfigContentFiles(root, base, options);
+	const files = [...new Set([...await expandTailwindSourceEntries(sourceEntries), ...configContentFiles.files])];
+	const sources = await Promise.all(files.map(async (file) => {
+		const extension = getSourceExtension(file);
+		return {
+			content: await readFile(file, "utf8"),
+			...extension === void 0 ? {} : { extension }
+		};
+	}));
 	return {
 		files: [...files, ...configContentFiles.configPaths],
 		sources

package/dist/postcss-CiYLsqZn.js

@@ -0,0 +1,192 @@
+//#region src/css-macro/constants.ts
+const queryKey = "weapp-tw-platform";
+const ifdefAtRule = "weapp-tw-ifdef";
+const ifndefAtRule = "weapp-tw-ifndef";
+function quoteAtRuleParam(value) {
+	return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function createConditionalAtRule(value) {
+	return `@${ifdefAtRule} ${quoteAtRuleParam(value)}{&}`;
+}
+function createNegativeConditionalAtRule(value) {
+	return `@${ifndefAtRule} ${quoteAtRuleParam(value)}{&}`;
+}
+const UNESCAPED_UNDERSCORE_RE = /(?<!\\)_/g;
+const WHITESPACE_RE = /\s+/g;
+const LOGICAL_OPERATOR_RE = /\s*(\|\||&&)\s*/g;
+function normalComment(text) {
+	if (typeof text === "string") {
+		const normalized = text.replaceAll(UNESCAPED_UNDERSCORE_RE, " ").replaceAll(WHITESPACE_RE, " ").trim();
+		if (normalized.includes("\\")) return normalized;
+		return normalized.replaceAll(LOGICAL_OPERATOR_RE, " $1 ").replaceAll(WHITESPACE_RE, " ").trim();
+	}
+	return text;
+}
+function ifdef(text) {
+	return {
+		start: `#ifdef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+function ifndef(text) {
+	return {
+		start: `#ifndef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+const QUERY_KEY_REGEX = new RegExp(`\\(\\s*${queryKey}\\s*:\\s*"([^)]*)"\\)`, "g");
+function matchCustomPropertyFromValue(str, cb) {
+	let index = 0;
+	QUERY_KEY_REGEX.lastIndex = 0;
+	let arr = QUERY_KEY_REGEX.exec(str);
+	while (arr !== null) {
+		cb(arr, index);
+		index++;
+		arr = QUERY_KEY_REGEX.exec(str);
+	}
+}
+function parseConditionalAtRuleParam(params) {
+	const value = params.trim();
+	const quoted = /^(['"])((?:\\.|(?!\1).)*)\1/.exec(value);
+	if (!quoted) return value;
+	return quoted[2]?.replaceAll(/\\(["'\\])/g, "$1") ?? "";
+}
+//#endregion
+//#region src/css-macro/postcss.ts
+const IFDEF_ENDIF_RE = /#(?:ifn?def|endif)/;
+const CONDITIONAL_COMMENT_SPACING = " ";
+const CSS_MACRO_POSTCSS_PLUGIN_NAME = "postcss-weapp-tw-css-macro-plugin";
+const creator = () => {
+	return {
+		postcssPlugin: CSS_MACRO_POSTCSS_PLUGIN_NAME,
+		prepare() {
+			function replaceAtRuleWithConditionalComments(atRule, helper, comment) {
+				const hasPreviousNode = Boolean(atRule.prev());
+				const clonedNodes = (atRule.nodes ?? []).map((node) => node.clone());
+				const startComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.start
+				});
+				const endComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.end
+				});
+				const nextNodes = [
+					startComment,
+					...clonedNodes,
+					endComment
+				];
+				atRule.replaceWith(nextNodes);
+				startComment.raws.before = hasPreviousNode ? "\n" : "";
+				startComment.raws["after"] = "\n";
+				if (clonedNodes[0]) clonedNodes[0].raws.before = "\n";
+				endComment.raws.before = "\n";
+				endComment.raws["after"] = "\n";
+				const nextNode = endComment?.next();
+				if (nextNode) nextNode.raws.before = "\n";
+			}
+			function replaceNestedAtRuleWithConditionalRule(atRule, helper, comment) {
+				if (atRule.parent?.type !== "rule") return false;
+				const parentRule = atRule.parent;
+				const clonedNodes = (atRule.nodes ?? []).map((node) => node.clone());
+				const conditionalRule = parentRule.clone();
+				conditionalRule.removeAll();
+				conditionalRule.append(...clonedNodes);
+				const startComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.start
+				});
+				const endComment = helper.comment({
+					raws: {
+						left: CONDITIONAL_COMMENT_SPACING,
+						right: CONDITIONAL_COMMENT_SPACING
+					},
+					text: comment.end
+				});
+				const nextNodes = [
+					startComment,
+					conditionalRule,
+					endComment
+				];
+				const hasPreviousNode = Boolean(parentRule.prev());
+				atRule.remove();
+				if ((parentRule.nodes?.length ?? 0) === 0) parentRule.replaceWith(nextNodes);
+				else parentRule.after(nextNodes);
+				startComment.raws.before = hasPreviousNode ? "\n" : "";
+				startComment.raws["after"] = "\n";
+				conditionalRule.raws.before = "\n";
+				endComment.raws.before = "\n";
+				endComment.raws["after"] = "\n";
+				const nextNode = endComment.next();
+				if (nextNode) nextNode.raws.before = "\n";
+				return true;
+			}
+			return {
+				AtRule(atRule, helper) {
+					if (atRule.name === "weapp-tw-ifdef" || atRule.name === "weapp-tw-ifndef") {
+						const text = parseConditionalAtRuleParam(atRule.params);
+						const comment = atRule.name === "weapp-tw-ifndef" ? ifndef(text) : ifdef(text);
+						if (replaceNestedAtRuleWithConditionalRule(atRule, helper, comment)) return;
+						replaceAtRuleWithConditionalComments(atRule, helper, comment);
+						return;
+					}
+					if (atRule.name === "media") {
+						const values = [];
+						matchCustomPropertyFromValue(atRule.params, (arr) => {
+							const value = arr[1];
+							if (value) values.push(value);
+						});
+						if (values.length > 0) {
+							const isNegative = atRule.params.includes("not");
+							const text = values.join(" ");
+							const comment = isNegative ? ifndef(text) : ifdef(text);
+							if (replaceNestedAtRuleWithConditionalRule(atRule, helper, comment)) return;
+							replaceAtRuleWithConditionalComments(atRule, helper, comment);
+						}
+					}
+				},
+				CommentExit(comment) {
+					if (IFDEF_ENDIF_RE.test(comment.text)) {
+						comment.raws.left = CONDITIONAL_COMMENT_SPACING;
+						comment.raws.right = CONDITIONAL_COMMENT_SPACING;
+					}
+				}
+			};
+		}
+	};
+};
+creator.postcss = true;
+//#endregion
+Object.defineProperty(exports, "CSS_MACRO_POSTCSS_PLUGIN_NAME", {
+	enumerable: true,
+	get: function() {
+		return CSS_MACRO_POSTCSS_PLUGIN_NAME;
+	}
+});
+Object.defineProperty(exports, "createConditionalAtRule", {
+	enumerable: true,
+	get: function() {
+		return createConditionalAtRule;
+	}
+});
+Object.defineProperty(exports, "createNegativeConditionalAtRule", {
+	enumerable: true,
+	get: function() {
+		return createNegativeConditionalAtRule;
+	}
+});
+Object.defineProperty(exports, "creator", {
+	enumerable: true,
+	get: function() {
+		return creator;
+	}
+});