weapp-tailwindcss 4.12.0 → 5.0.0-next.1

package/dist/generator-css-CnYjiMrD.js

@@ -0,0 +1,1084 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_generator = require("./generator-CZ-JXw6T.js");
+const require_recorder = require("./recorder-rn_2v_nd.js");
+let postcss = require("postcss");
+postcss = require_chunk.__toESM(postcss);
+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 node_fs = require("node:fs");
+//#region src/bundlers/shared/cache.ts
+async function processCachedTask({ cache, cacheKey, hashKey = cacheKey, rawSource, hash, readCache, applyResult, transform, onCacheHit }) {
+	let cacheHit = false;
+	const result = await cache.process({
+		key: cacheKey,
+		hashKey,
+		rawSource,
+		hash,
+		resolveCache: readCache,
+		async onCacheHit(value) {
+			cacheHit = true;
+			await applyResult(value);
+			onCacheHit?.();
+		},
+		transform
+	});
+	if (!cacheHit) await applyResult(result);
+}
+//#endregion
+//#region src/bundlers/shared/css-cleanup.ts
+const MINI_PROGRAM_PREFLIGHT_SELECTORS = new Set([
+	"*",
+	"view",
+	"text",
+	":before",
+	":after",
+	"::before",
+	"::after"
+]);
+const MINI_PROGRAM_THEME_SCOPE_SELECTOR = ":host,page,.tw-root,wx-root-portal-content";
+const MINI_PROGRAM_THEME_SCOPE_SELECTORS$1 = new Set([
+	":host",
+	":root",
+	"page",
+	".tw-root",
+	"wx-root-portal-content"
+]);
+const SPECIFICITY_PLACEHOLDER_SUFFIXES = [":not(#n)", ":not(#\\#)"];
+const MINI_PROGRAM_UNSUPPORTED_BROWSER_SELECTORS = new Set([
+	":-moz-focusring",
+	":-moz-ui-invalid",
+	"::-webkit-calendar-picker-indicator",
+	"::-webkit-date-and-time-value",
+	"::-webkit-datetime-edit",
+	"::-webkit-datetime-edit-day-field",
+	"::-webkit-datetime-edit-fields-wrapper",
+	"::-webkit-datetime-edit-hour-field",
+	"::-webkit-datetime-edit-meridiem-field",
+	"::-webkit-datetime-edit-millisecond-field",
+	"::-webkit-datetime-edit-minute-field",
+	"::-webkit-datetime-edit-month-field",
+	"::-webkit-datetime-edit-second-field",
+	"::-webkit-datetime-edit-year-field",
+	"::-webkit-inner-spin-button",
+	"::-webkit-input-placeholder",
+	"::-webkit-outer-spin-button",
+	"::-webkit-search-decoration",
+	"::placeholder",
+	"[hidden]:where(:not([hidden='until-found']))"
+]);
+const MINI_PROGRAM_UNSUPPORTED_BROWSER_TAG_SELECTORS = new Set([
+	"a",
+	"abbr:where([title])",
+	"audio",
+	"b",
+	"button",
+	"canvas",
+	"code",
+	"embed",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"hr",
+	"html",
+	"iframe",
+	"img",
+	"input",
+	"input:where([type='button'],[type='reset'],[type='submit'])",
+	"kbd",
+	"menu",
+	"object",
+	"ol",
+	"optgroup",
+	"pre",
+	"progress",
+	"samp",
+	"select",
+	"select[multiple]optgroup",
+	"select[multiple]optgroupoption",
+	"select[size]optgroup",
+	"select[size]optgroupoption",
+	"small",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"svg",
+	"table",
+	"textarea",
+	"ul",
+	"video"
+]);
+const PREFLIGHT_RESET_PROPS = new Set([
+	"box-sizing",
+	"border",
+	"border-width",
+	"border-style",
+	"border-color",
+	"margin",
+	"padding"
+]);
+const DISPLAY_P3_VALUE_RE = /color\(\s*display-p3\b/i;
+const COLOR_GAMUT_P3_RE = /\(\s*color-gamut\s*:\s*p3\s*\)/i;
+function removeAtRulesByScan(css, names) {
+	let index = 0;
+	let result = "";
+	const atRulePattern = new RegExp(`@(?:${[...names].join("|")})\\b`, "i");
+	while (index < css.length) {
+		const match = atRulePattern.exec(css.slice(index));
+		if (!match || match.index === void 0) {
+			result += css.slice(index);
+			break;
+		}
+		const start = index + match.index;
+		result += css.slice(index, start);
+		const blockStart = css.indexOf("{", start);
+		if (blockStart === -1) {
+			result += css.slice(start);
+			break;
+		}
+		let depth = 0;
+		let cursor = blockStart;
+		for (; cursor < css.length; cursor++) {
+			const char = css[cursor];
+			if (char === "{") depth++;
+			else if (char === "}") {
+				depth--;
+				if (depth === 0) {
+					cursor++;
+					break;
+				}
+			}
+		}
+		index = cursor;
+	}
+	return result;
+}
+const MINI_PROGRAM_UNSUPPORTED_AT_RULES = new Set(["property", "supports"]);
+function removeUnsupportedMiniProgramAtRules(css) {
+	try {
+		const root = postcss.default.parse(css);
+		root.walkAtRules((atRule) => {
+			if (MINI_PROGRAM_UNSUPPORTED_AT_RULES.has(atRule.name)) atRule.remove();
+		});
+		root.walkAtRules((atRule) => {
+			if (!atRule.nodes || atRule.nodes.length === 0) atRule.remove();
+		});
+		return root.toString();
+	} catch {
+		return removeAtRulesByScan(css, MINI_PROGRAM_UNSUPPORTED_AT_RULES);
+	}
+}
+function normalizeSelector(selector) {
+	return selector.trim().replace(/\s+/g, "");
+}
+function getRuleSelectors(rule) {
+	return rule.selector.split(",").map(normalizeSelector).filter(Boolean);
+}
+function isMiniProgramThemeScopeSelector$1(selectors) {
+	return selectors.length > 0 && selectors.every((selector) => MINI_PROGRAM_THEME_SCOPE_SELECTORS$1.has(selector));
+}
+function isMiniProgramPreflightSelector(selectors) {
+	return selectors.length > 0 && selectors.every((selector) => MINI_PROGRAM_PREFLIGHT_SELECTORS.has(selector)) && selectors.some((selector) => selector === "*" || selector === ":before" || selector === ":after" || selector === "::before" || selector === "::after");
+}
+function hasTailwindPreflightDeclaration(rule) {
+	let hasTailwindVar = false;
+	let hasResetProp = false;
+	rule.walkDecls((decl) => {
+		if (decl.prop.startsWith("--tw-")) hasTailwindVar = true;
+		if (PREFLIGHT_RESET_PROPS.has(decl.prop)) hasResetProp = true;
+	});
+	return hasTailwindVar || hasResetProp;
+}
+function isCustomPropertyOnlyRule$1(rule) {
+	let hasDeclaration = false;
+	let allCustomProperties = true;
+	rule.each((node) => {
+		if (node.type !== "decl") return;
+		hasDeclaration = true;
+		if (!node.prop.startsWith("--")) allCustomProperties = false;
+	});
+	return hasDeclaration && allCustomProperties;
+}
+function hasContentInitDeclaration(rule) {
+	let hasContentInit = false;
+	rule.walkDecls("--tw-content", () => {
+		hasContentInit = true;
+	});
+	return hasContentInit;
+}
+function isTailwindPreflightRule(node) {
+	if (node.type !== "rule" || node.parent?.type !== "root") return false;
+	return isMiniProgramPreflightSelector(getRuleSelectors(node)) && hasTailwindPreflightDeclaration(node);
+}
+function isMiniProgramThemeVariableRule(node) {
+	if (node.type !== "rule" || node.parent?.type !== "root") return false;
+	return isMiniProgramThemeScopeSelector$1(getRuleSelectors(node)) && isCustomPropertyOnlyRule$1(node);
+}
+function createPseudoContentInitRule() {
+	const rule = postcss.default.rule({ selector: "::before,\n::after" });
+	rule.append({
+		prop: "--tw-content",
+		value: "''"
+	});
+	return rule;
+}
+function isDisplayP3MediaRule(atRule) {
+	return atRule.name === "media" && COLOR_GAMUT_P3_RE.test(atRule.params);
+}
+function isDisplayP3Declaration(decl) {
+	return DISPLAY_P3_VALUE_RE.test(decl.value);
+}
+function removeSpecificityPlaceholders(root) {
+	root.walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) return;
+		let changed = false;
+		const selectors = rule.selectors.map((selector) => {
+			let next = selector;
+			for (const suffix of SPECIFICITY_PLACEHOLDER_SUFFIXES) if (next.includes(suffix)) next = next.split(suffix).join("");
+			if (next !== selector) changed = true;
+			return next;
+		});
+		if (changed) rule.selectors = selectors;
+	});
+}
+function isUnsupportedBrowserSelector(selector) {
+	const normalized = normalizeSelector(selector);
+	return MINI_PROGRAM_UNSUPPORTED_BROWSER_SELECTORS.has(normalized) || MINI_PROGRAM_UNSUPPORTED_BROWSER_TAG_SELECTORS.has(normalized);
+}
+function removeUnsupportedBrowserSelectors(root) {
+	root.walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) return;
+		const selectors = rule.selectors.filter((selector) => !isUnsupportedBrowserSelector(selector));
+		if (selectors.length === rule.selectors.length) return;
+		if (selectors.length === 0) {
+			const parent = rule.parent;
+			rule.remove();
+			removeEmptyAtRuleAncestors(parent);
+			return;
+		}
+		rule.selectors = selectors;
+	});
+}
+function removeEmptyAtRuleAncestors(parent) {
+	while (parent?.type === "atrule" && (!parent.nodes || parent.nodes.length === 0)) {
+		const nextParent = parent.parent;
+		parent.remove();
+		parent = nextParent;
+	}
+}
+function removeDeclarationAndEmptyRule(decl) {
+	const parent = decl.parent;
+	decl.remove();
+	if (parent?.type === "rule" && parent.nodes.length === 0) {
+		const ruleParent = parent.parent;
+		parent.remove();
+		removeEmptyAtRuleAncestors(ruleParent);
+	}
+}
+function removeDisplayP3Declarations(root) {
+	root.walkAtRules((atRule) => {
+		if (isDisplayP3MediaRule(atRule)) {
+			const parent = atRule.parent;
+			atRule.remove();
+			removeEmptyAtRuleAncestors(parent);
+		}
+	});
+	root.walkDecls((decl) => {
+		if (isDisplayP3Declaration(decl)) removeDeclarationAndEmptyRule(decl);
+	});
+}
+function collectPreflightRules(root) {
+	const preflightNodes = [];
+	let hasContentInit = false;
+	for (const node of root.nodes ?? []) if (isTailwindPreflightRule(node)) {
+		preflightNodes.push(node);
+		if (hasContentInitDeclaration(node)) hasContentInit = true;
+	}
+	if (preflightNodes.length === 0) return [];
+	const clonedPreflightRules = preflightNodes.map((node) => node.clone());
+	const contentInitRules = clonedPreflightRules.filter((rule) => hasContentInitDeclaration(rule));
+	const otherPreflightRules = clonedPreflightRules.filter((rule) => !hasContentInitDeclaration(rule));
+	const preflightRules = hasContentInit ? [...contentInitRules, ...otherPreflightRules] : [createPseudoContentInitRule(), ...otherPreflightRules];
+	for (const node of preflightNodes) node.remove();
+	return preflightRules;
+}
+function collectThemeVariableRule(root) {
+	const themeRules = [];
+	const declarations = /* @__PURE__ */ new Map();
+	for (const node of root.nodes ?? []) {
+		if (!isMiniProgramThemeVariableRule(node)) continue;
+		themeRules.push(node);
+		node.walkDecls((decl) => {
+			if (isDisplayP3Declaration(decl)) return;
+			declarations.set(decl.prop, decl.clone());
+		});
+	}
+	for (const rule of themeRules) rule.remove();
+	if (declarations.size === 0) return;
+	const rule = postcss.default.rule({ selector: MINI_PROGRAM_THEME_SCOPE_SELECTOR });
+	for (const decl of declarations.values()) rule.append(decl);
+	return rule;
+}
+function getTopDirectiveTail(root) {
+	let tail;
+	for (const node of root.nodes ?? []) {
+		if (node.type === "atrule" && (node.name === "charset" || node.name === "import")) {
+			tail = node;
+			continue;
+		}
+		break;
+	}
+	return tail;
+}
+function insertHoistedRules(root, rules) {
+	if (rules.length === 0) return;
+	const topDirectiveTail = getTopDirectiveTail(root);
+	rules[0].raws.before = topDirectiveTail ? "\n" : "";
+	if (topDirectiveTail) topDirectiveTail.after(...rules);
+	else root.prepend(...rules);
+}
+function finalizeMiniProgramCssRoot(root) {
+	require_generator.removeUnsupportedCascadeLayers(root);
+	root.walkAtRules("property", (atRule) => {
+		atRule.remove();
+	});
+	removeSpecificityPlaceholders(root);
+	removeUnsupportedBrowserSelectors(root);
+	removeDisplayP3Declarations(root);
+	const preflightRules = collectPreflightRules(root);
+	const themeRule = collectThemeVariableRule(root);
+	insertHoistedRules(root, themeRule ? [...preflightRules, themeRule] : preflightRules);
+}
+function finalizeMiniProgramCss(css) {
+	const cleanedCss = removeUnsupportedMiniProgramAtRules(css);
+	try {
+		const root = postcss.default.parse(cleanedCss);
+		finalizeMiniProgramCssRoot(root);
+		return root.toString();
+	} catch {
+		return cleanedCss;
+	}
+}
+//#endregion
+//#region src/bundlers/shared/generator-css.ts
+const TAILWIND_V4_BANNER_RE = /\/\*!\s*tailwindcss v4\./;
+const TAILWIND_GENERATED_CSS_MARKER_RE = /\/\*!\s*tailwindcss v|@property\s+--tw-|--tw-|:not\(#\\#\)|\.[^,{]*(?:\\:|\\\[|\\#)|(?::host|page|\.tw-root|wx-root-portal-content)[^{]*\{[^}]*--(?:color|spacing|text|font-weight|radius)-/;
+const GENERATOR_PLACEHOLDER_MARKER_RE = /\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\//i;
+const GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE = /\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\/\s*/gi;
+const TAILWIND_BANNER_PREFIX_RE = /^\/\*!\s*tailwindcss v[^*]*\*\/\s*/i;
+const TAILWIND_BANNER_GLOBAL_RE = /\/\*!\s*tailwindcss v[^*]*\*\/\s*/gi;
+const VITE_MARKER_RE = /\/\*\$vite\$:[^*]*\*\//g;
+const CLASS_SELECTOR_RE = /(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i;
+const MINI_PROGRAM_THEME_SCOPE_SELECTORS = new Set([
+	":host",
+	"page",
+	".tw-root",
+	"wx-root-portal-content"
+]);
+const SUPPORTED_GENERATOR_MAJOR_VERSIONS = new Set([3, 4]);
+const REMOTE_IMPORT_RE = /^(?:https?:)?\/\//i;
+const SPECIFICITY_PLACEHOLDER_RE = /:not\(#(?:\\#|n)\)/g;
+const CSS_LENGTH_UNIT_RE = /(?:^|[\s(,])[-+]?(?:\d+|\d*\.\d+)(?:px|rem)\b/i;
+const RPX_UNIT_RE = /(?:^|[\s(,])[-+]?(?:\d+|\d*\.\d+)rpx\b/i;
+const TAILWIND_REMOVABLE_SOURCE_DIRECTIVE_NAMES = new Set([
+	"config",
+	"custom-variant",
+	"layer",
+	"plugin",
+	"reference",
+	"source",
+	"tailwind",
+	"theme",
+	"utility",
+	"variant"
+]);
+const LEGACY_CONTAINER_COMPAT_CSS = [
+	".container {",
+	"  width: 100%;",
+	"}",
+	"@media (min-width: 40rem) {",
+	"  .container {",
+	"    max-width: 40rem;",
+	"  }",
+	"}",
+	"@media (min-width: 48rem) {",
+	"  .container {",
+	"    max-width: 48rem;",
+	"  }",
+	"}",
+	"@media (min-width: 64rem) {",
+	"  .container {",
+	"    max-width: 64rem;",
+	"  }",
+	"}",
+	"@media (min-width: 80rem) {",
+	"  .container {",
+	"    max-width: 80rem;",
+	"  }",
+	"}",
+	"@media (min-width: 96rem) {",
+	"  .container {",
+	"    max-width: 96rem;",
+	"  }",
+	"}"
+].join("\n");
+const SOURCE_STYLE_EXTENSIONS = [
+	".vue",
+	".uvue",
+	".nvue",
+	".css",
+	".scss",
+	".sass",
+	".less",
+	".styl",
+	".stylus",
+	".wxss",
+	".acss",
+	".jxss",
+	".ttss",
+	".qss"
+];
+const SFC_STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+function createCssAppend(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	return `${base}\n${extra}`;
+}
+function splitTailwindV4GeneratedCss(rawSource, rawTailwindCss) {
+	const trimmedRaw = rawSource.trim();
+	const trimmedTailwind = rawTailwindCss.trim();
+	if (trimmedRaw === trimmedTailwind) return "";
+	if (trimmedTailwind.startsWith(trimmedRaw)) return "";
+	const start = rawSource.indexOf(rawTailwindCss);
+	if (start === -1) return;
+	return createCssAppend(rawSource.slice(0, start), rawSource.slice(start + rawTailwindCss.length));
+}
+function stripTailwindBanner(css) {
+	return css.replace(TAILWIND_BANNER_PREFIX_RE, "");
+}
+function stripTailwindBanners(css) {
+	return css.replace(TAILWIND_BANNER_GLOBAL_RE, "");
+}
+function stripGeneratorPlaceholderMarkers(css) {
+	return css.replace(GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE, "");
+}
+function hasTailwindGeneratedCss(rawSource) {
+	return TAILWIND_V4_BANNER_RE.test(rawSource);
+}
+function hasTailwindGeneratedCssMarkers(rawSource) {
+	return TAILWIND_GENERATED_CSS_MARKER_RE.test(rawSource) || GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource);
+}
+function finalizeMiniProgramGeneratorCss(css, target) {
+	if (target !== "weapp") return css;
+	return finalizeMiniProgramCss(css);
+}
+function normalizeCompatSelector(selector) {
+	return selector.replace(SPECIFICITY_PLACEHOLDER_RE, "").replace(/\s+/g, " ").trim();
+}
+function isClassSelectorTerminator(char) {
+	return /[\s>+~#,.:()[\]]/.test(char);
+}
+function unescapeSimpleCssIdent(value) {
+	return value.replaceAll(/\\(.)/g, "$1");
+}
+function escapeCompatSelectorClasses(selector) {
+	let result = "";
+	let index = 0;
+	let changed = false;
+	while (index < selector.length) {
+		const char = selector[index];
+		if (char !== ".") {
+			result += char;
+			index += 1;
+			continue;
+		}
+		let end = index + 1;
+		let className = "";
+		while (end < selector.length) {
+			const current = selector[end];
+			if (current === "\\" && end + 1 < selector.length) {
+				className += current + selector[end + 1];
+				end += 2;
+				continue;
+			}
+			if (isClassSelectorTerminator(current)) break;
+			className += current;
+			end += 1;
+		}
+		if (className.includes("\\")) {
+			result += `.${require_recorder.replaceWxml(unescapeSimpleCssIdent(className))}`;
+			changed = true;
+		} else result += `.${className}`;
+		index = end;
+	}
+	return changed ? result : selector;
+}
+function normalizeCompatSelectors(selector) {
+	const normalized = normalizeCompatSelector(selector);
+	if (!normalized) return [];
+	const selectors = new Set([normalized]);
+	const escaped = normalizeCompatSelector(escapeCompatSelectorClasses(normalized));
+	if (escaped) selectors.add(escaped);
+	return [...selectors];
+}
+function createLegacyDeclarationValueMap(css) {
+	const values = /* @__PURE__ */ new Map();
+	postcss.default.parse(css).walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) return;
+		for (const selector of rule.selectors) {
+			const normalizedSelectors = normalizeCompatSelectors(selector);
+			rule.walkDecls((decl) => {
+				if (RPX_UNIT_RE.test(decl.value)) for (const normalizedSelector of normalizedSelectors) values.set(`${normalizedSelector}\n${decl.prop}`, decl.value);
+			});
+		}
+	});
+	return values;
+}
+function inheritLegacyUnitConvertedDeclarations(css, legacyCss) {
+	try {
+		const legacyValues = createLegacyDeclarationValueMap(legacyCss);
+		if (legacyValues.size === 0) return css;
+		const root = postcss.default.parse(css);
+		let changed = false;
+		root.walkRules((rule) => {
+			if (!rule.selectors || rule.selectors.length === 0) return;
+			const selectors = rule.selectors.flatMap((selector) => normalizeCompatSelectors(selector));
+			if (selectors.length === 0) return;
+			rule.walkDecls((decl) => {
+				if (!CSS_LENGTH_UNIT_RE.test(decl.value)) return;
+				for (const selector of selectors) {
+					const legacyValue = legacyValues.get(`${selector}\n${decl.prop}`);
+					if (legacyValue && legacyValue !== decl.value) {
+						decl.value = legacyValue;
+						changed = true;
+						return;
+					}
+				}
+			});
+		});
+		return changed ? root.toString() : css;
+	} catch {
+		return css;
+	}
+}
+function resolveGeneratorStyleOptions(opts, cssHandlerOptions, generatorStyleOptions) {
+	return {
+		cssChildCombinatorReplaceValue: opts.cssChildCombinatorReplaceValue,
+		cssSelectorReplacement: opts.cssSelectorReplacement,
+		rem2rpx: opts.rem2rpx,
+		px2rpx: opts.px2rpx,
+		unitsToPx: opts.unitsToPx,
+		cssRemoveProperty: opts.cssRemoveProperty,
+		cssRemoveHoverPseudoClass: opts.cssRemoveHoverPseudoClass,
+		cssPresetEnv: opts.cssPresetEnv,
+		autoprefixer: opts.autoprefixer,
+		cssCalc: opts.cssCalc,
+		atRules: opts.atRules,
+		uniAppX: opts.uniAppX,
+		uniAppXCssTarget: opts.uniAppXCssTarget,
+		uniAppXUnsupported: opts.uniAppXUnsupported,
+		...cssHandlerOptions,
+		...generatorStyleOptions
+	};
+}
+function parseImportRequest(params) {
+	return /^(?:url\(\s*)?(["']?)([^"')\s]+)\1\s*\)?/.exec(params.trim())?.[2];
+}
+function parseConfigRequest(params) {
+	return /^(["'])(.+)\1\s*;?$/.exec(params.trim())?.[2];
+}
+function resolvePostcssFromOption(cssHandlerOptions) {
+	const from = cssHandlerOptions.postcssOptions?.options?.from;
+	return typeof from === "string" && from.length > 0 ? from : void 0;
+}
+function resolveCssSourceBase(file, cssHandlerOptions) {
+	const normalized = (resolvePostcssFromOption(cssHandlerOptions) ?? file).replace(/[?#].*$/, "");
+	return node_path.default.dirname(node_path.default.resolve(normalized));
+}
+function isTailwindImportAtRule(node) {
+	if (node.name === "tailwind") return true;
+	if (node.name !== "import") return false;
+	const request = parseImportRequest(node.params);
+	return request === "tailwindcss" || request === "tailwindcss4" || request?.startsWith("tailwindcss/") || request?.startsWith("tailwindcss4/");
+}
+function isTailwindSourceDirective(node) {
+	if (node.type !== "atrule") return false;
+	if (isTailwindImportAtRule(node)) return true;
+	return TAILWIND_REMOVABLE_SOURCE_DIRECTIVE_NAMES.has(node.name);
+}
+function isTailwindGenerationDirective(node) {
+	if (node.type !== "atrule") return false;
+	return isTailwindImportAtRule(node) || node.name === "layer" || node.name === "config";
+}
+function removeTailwindSourceDirectives(rawSource) {
+	try {
+		const source = stripGeneratorPlaceholderMarkers(rawSource);
+		const root = postcss.default.parse(source);
+		let removed = false;
+		root.walk((node) => {
+			if (isTailwindSourceDirective(node)) {
+				node.remove();
+				removed = true;
+			}
+		});
+		return removed ? root.toString() : source;
+	} catch {
+		return stripGeneratorPlaceholderMarkers(rawSource);
+	}
+}
+function hasTailwindSourceDirectives(rawSource) {
+	try {
+		if (GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource)) return true;
+		const root = postcss.default.parse(rawSource);
+		let found = false;
+		root.walk((node) => {
+			if (isTailwindGenerationDirective(node)) {
+				found = true;
+				return false;
+			}
+		});
+		return found;
+	} catch {
+		return false;
+	}
+}
+function resolveCssEntrySource(rawSource, base) {
+	try {
+		const root = postcss.default.parse(rawSource);
+		let found = false;
+		let config;
+		let configRequest;
+		let removedConfig = false;
+		root.walk((node) => {
+			if (isTailwindGenerationDirective(node)) found = true;
+			if (node.type === "atrule" && node.name === "config") {
+				const configPath = parseConfigRequest(node.params);
+				if (configPath && !config) {
+					configRequest = configPath;
+					config = node_path.default.isAbsolute(configPath) ? configPath : node_path.default.resolve(base, configPath);
+				}
+				node.remove();
+				removedConfig = true;
+			}
+		});
+		if (!found) return;
+		return {
+			css: removedConfig ? root.toString() : rawSource,
+			config,
+			configRequest,
+			base
+		};
+	} catch {
+		return;
+	}
+}
+function resolveExistingConfigPath(config, configRequest, file, sourceOptions) {
+	if (config && (0, node_fs.existsSync)(config)) return config;
+	if (!configRequest || node_path.default.isAbsolute(configRequest)) return sourceOptions.config;
+	const outputDir = node_path.default.dirname(file.replace(/[?#].*$/, ""));
+	const baseCandidates = [
+		sourceOptions.projectRoot,
+		sourceOptions.cwd,
+		node_process.default.cwd()
+	].filter((item) => typeof item === "string" && item.length > 0);
+	for (const base of baseCandidates) {
+		const candidates = [
+			node_path.default.resolve(base, configRequest),
+			node_path.default.resolve(base, "src", configRequest),
+			node_path.default.resolve(base, outputDir, configRequest),
+			node_path.default.resolve(base, "src", outputDir, configRequest)
+		];
+		for (const candidate of candidates) if ((0, node_fs.existsSync)(candidate)) return candidate;
+	}
+	return sourceOptions.config;
+}
+function stripStyleExtension(file) {
+	return file.replace(/[?#].*$/, "").replace(/\.(?:wx|ac|jx|tt|q|c|ty)?ss$/i, "");
+}
+function createSourceStylePathCandidates(file, sourceOptions) {
+	const relativeFile = stripStyleExtension(file);
+	if (node_path.default.isAbsolute(relativeFile)) return [];
+	const bases = [
+		sourceOptions.projectRoot,
+		sourceOptions.cwd,
+		node_process.default.cwd()
+	].filter((item) => typeof item === "string" && item.length > 0);
+	const candidates = /* @__PURE__ */ new Set();
+	for (const base of bases) for (const sourceRoot of ["", "src"]) {
+		const prefix = sourceRoot ? node_path.default.resolve(base, sourceRoot, relativeFile) : node_path.default.resolve(base, relativeFile);
+		for (const extension of SOURCE_STYLE_EXTENSIONS) candidates.add(`${prefix}${extension}`);
+	}
+	return [...candidates];
+}
+function extractStyleDirectiveSources(source) {
+	const styleSources = [];
+	SFC_STYLE_BLOCK_RE.lastIndex = 0;
+	let match = SFC_STYLE_BLOCK_RE.exec(source);
+	while (match !== null) {
+		const styleSource = match[1] ?? "";
+		if (hasTailwindSourceDirectives(styleSource)) styleSources.push(styleSource);
+		match = SFC_STYLE_BLOCK_RE.exec(source);
+	}
+	if (styleSources.length > 0) return styleSources;
+	return hasTailwindSourceDirectives(source) ? [source] : [];
+}
+function resolveSourceSideCssEntrySource(file, sourceOptions) {
+	for (const sourceFile of createSourceStylePathCandidates(file, sourceOptions)) {
+		if (!(0, node_fs.existsSync)(sourceFile)) continue;
+		try {
+			const source = (0, node_fs.readFileSync)(sourceFile, "utf8");
+			for (const styleSource of extractStyleDirectiveSources(source)) {
+				const cssEntrySource = resolveCssEntrySource(styleSource, node_path.default.dirname(sourceFile));
+				if (cssEntrySource) return cssEntrySource;
+			}
+		} catch {
+			continue;
+		}
+	}
+}
+async function resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions) {
+	const cssEntrySource = resolveCssEntrySource(rawSource, resolveCssSourceBase(file, cssHandlerOptions));
+	if (majorVersion === 3) {
+		const sourceOptions = require_generator.resolveTailwindV3SourceOptionsFromPatcher(runtimeState.twPatcher);
+		const sourceSideEntrySource = resolveSourceSideCssEntrySource(file, sourceOptions);
+		const resolvedEntrySource = cssEntrySource ?? sourceSideEntrySource;
+		if (!resolvedEntrySource) return require_generator.resolveTailwindV3SourceFromPatcher(runtimeState.twPatcher);
+		const config = resolveExistingConfigPath(resolvedEntrySource.config, resolvedEntrySource.configRequest, file, sourceOptions);
+		return require_generator.resolveTailwindV3Source({
+			...sourceOptions,
+			base: resolvedEntrySource.base,
+			css: resolvedEntrySource.css,
+			...config ? { config } : {}
+		});
+	}
+	if (!cssEntrySource) return require_generator.resolveTailwindV4SourceFromPatcher(runtimeState.twPatcher);
+	return require_generator.resolveTailwindV4Source({
+		...require_generator.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher),
+		base: cssEntrySource.base,
+		css: cssEntrySource.css
+	});
+}
+async function resolveGeneratorSources(majorVersion, runtimeState, rawSource, file, cssHandlerOptions) {
+	const cssEntrySource = resolveCssEntrySource(rawSource, resolveCssSourceBase(file, cssHandlerOptions));
+	if (majorVersion !== 4 || cssEntrySource && !cssHandlerOptions.isMainChunk) return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions)];
+	let sourceOptions;
+	try {
+		sourceOptions = require_generator.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher);
+	} catch {
+		return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions)];
+	}
+	if (!sourceOptions.cssEntries || sourceOptions.cssEntries.length <= 1) return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions)];
+	return await Promise.all(sourceOptions.cssEntries.map((cssEntry) => require_generator.resolveTailwindV4Source({
+		...sourceOptions,
+		css: void 0,
+		cssEntries: [cssEntry]
+	})));
+}
+function isLocalImportRequest(request) {
+	return request.length > 0 && !request.startsWith("tailwindcss") && !request.startsWith("weapp-tailwindcss") && !request.startsWith("data:") && !REMOTE_IMPORT_RE.test(request);
+}
+function isPureLocalCssImportWrapper(css) {
+	let hasImport = false;
+	try {
+		const root = postcss.default.parse(css);
+		for (const node of root.nodes) {
+			if (node.type === "comment") continue;
+			if (node.type !== "atrule" || node.name !== "import") return false;
+			const request = parseImportRequest(node.params);
+			if (!request || !isLocalImportRequest(request)) return false;
+			hasImport = true;
+		}
+	} catch {
+		return false;
+	}
+	return hasImport;
+}
+function resolveLegacyCompatCssSource(rawSource) {
+	return removeUnsupportedMiniProgramAtRules(removeTailwindSourceDirectives(stripTailwindBanners(rawSource)));
+}
+function hasContainerConfigToken(rawSource) {
+	return rawSource.includes("@config") && /\bcontainer\b/.test(rawSource);
+}
+function hasConfiguredContainerCompat(rawSource, file, cssHandlerOptions) {
+	if (hasContainerConfigToken(rawSource)) return true;
+	const cssEntrySource = resolveCssEntrySource(rawSource, resolveCssSourceBase(file, cssHandlerOptions));
+	if (!cssEntrySource?.config) return false;
+	try {
+		return /\bcontainer\b/.test((0, node_fs.readFileSync)(cssEntrySource.config, "utf8"));
+	} catch {
+		return false;
+	}
+}
+function hasConfiguredContainerCompatSource(source) {
+	if (hasContainerConfigToken(source.css)) return true;
+	const cssEntrySource = resolveCssEntrySource(source.css, source.base);
+	if (cssEntrySource?.config) try {
+		if (/\bcontainer\b/.test((0, node_fs.readFileSync)(cssEntrySource.config, "utf8"))) return true;
+	} catch {}
+	if ("config" in source && source.config) try {
+		if (/\bcontainer\b/.test((0, node_fs.readFileSync)(source.config, "utf8"))) return true;
+	} catch {}
+	return false;
+}
+function hasConfiguredContainerCompatSources(sources) {
+	return sources.some((source) => hasConfiguredContainerCompatSource(source));
+}
+function removeDuplicatedViteMarkers(css, baseCss) {
+	if (!VITE_MARKER_RE.test(baseCss)) return css;
+	VITE_MARKER_RE.lastIndex = 0;
+	return css.replace(VITE_MARKER_RE, "");
+}
+function normalizeCssSelector(selector) {
+	return selector.trim().replace(/\s+/g, "");
+}
+function getCompatSelectorKeys(selector) {
+	return normalizeCompatSelectors(selector).map(normalizeCssSelector);
+}
+function getRuleCompatSelectorKeys(rule) {
+	return (rule.selectors?.length ? rule.selectors : [rule.selector]).flatMap((selector) => getCompatSelectorKeys(selector));
+}
+function hasClassSelector(selector) {
+	return CLASS_SELECTOR_RE.test(selector);
+}
+function getNormalizedSelectorList(selector) {
+	return selector.split(",").map(normalizeCssSelector).filter(Boolean);
+}
+function isMiniProgramThemeScopeSelector(selector) {
+	const selectors = getNormalizedSelectorList(selector);
+	return selectors.length > 0 && selectors.every((item) => MINI_PROGRAM_THEME_SCOPE_SELECTORS.has(item));
+}
+function hasUtilityClassSelector(selector) {
+	return hasClassSelector(selector) && !isMiniProgramThemeScopeSelector(selector);
+}
+function isCustomPropertyOnlyRule(rule) {
+	let hasDeclaration = false;
+	let allCustomProperties = true;
+	rule.each((node) => {
+		if (node.type !== "decl") return;
+		hasDeclaration = true;
+		if (!node.prop.startsWith("--")) allCustomProperties = false;
+	});
+	return hasDeclaration && allCustomProperties;
+}
+function isPseudoContentInitRule(rule) {
+	let hasDeclaration = false;
+	let onlyContentVariable = true;
+	rule.each((node) => {
+		if (node.type !== "decl") return;
+		hasDeclaration = true;
+		if (node.prop !== "--tw-content") onlyContentVariable = false;
+	});
+	return hasDeclaration && onlyContentVariable;
+}
+function collectGeneratedSelectors(css) {
+	const selectors = /* @__PURE__ */ new Set();
+	try {
+		postcss.default.parse(css).walkRules((rule) => {
+			if (isCustomPropertyOnlyRule(rule) && !isPseudoContentInitRule(rule) && !hasUtilityClassSelector(rule.selector)) return;
+			for (const selector of getRuleCompatSelectorKeys(rule)) selectors.add(selector);
+		});
+	} catch {
+		return selectors;
+	}
+	return selectors;
+}
+function removeGeneratedSelectorCompatCss(css, generatedCss) {
+	const generatedSelectors = collectGeneratedSelectors(generatedCss);
+	if (generatedSelectors.size === 0) return css;
+	try {
+		const root = postcss.default.parse(css);
+		let removed = false;
+		root.walkRules((rule) => {
+			if (isPseudoContentInitRule(rule)) {
+				rule.remove();
+				removed = true;
+				return;
+			}
+			if (isCustomPropertyOnlyRule(rule) && !isPseudoContentInitRule(rule) && !hasUtilityClassSelector(rule.selector)) return;
+			if (getRuleCompatSelectorKeys(rule).some((selector) => generatedSelectors.has(selector))) {
+				rule.remove();
+				removed = true;
+			}
+		});
+		root.walkAtRules((atRule) => {
+			if (!atRule.nodes || atRule.nodes.length === 0) atRule.remove();
+		});
+		return removed ? root.toString() : css;
+	} catch {
+		return css;
+	}
+}
+function collectDedupedPostTransformCompatCss(css, generatedCss) {
+	const generatedSelectors = collectGeneratedSelectors(generatedCss);
+	if (generatedSelectors.size === 0) return css;
+	const preservedNodes = [];
+	try {
+		const root = postcss.default.parse(css);
+		root.each((node) => {
+			if (node.type === "rule" && getRuleCompatSelectorKeys(node).some((selector) => generatedSelectors.has(selector))) {
+				if (isCustomPropertyOnlyRule(node) && !isPseudoContentInitRule(node) && !hasUtilityClassSelector(node.selector)) {
+					const declarationProps = /* @__PURE__ */ new Set();
+					node.walkDecls((decl) => {
+						declarationProps.add(decl.prop);
+					});
+					postcss.default.parse(generatedCss).walkRules((rule) => {
+						const nodeSelectors = new Set(getRuleCompatSelectorKeys(node));
+						if (!getRuleCompatSelectorKeys(rule).some((selector) => nodeSelectors.has(selector))) return;
+						rule.walkDecls((decl) => {
+							declarationProps.delete(decl.prop);
+						});
+					});
+					const nextRule = node.clone();
+					nextRule.walkDecls((decl) => {
+						if (!declarationProps.has(decl.prop)) decl.remove();
+					});
+					if (nextRule.nodes.length > 0) preservedNodes.push(nextRule);
+				}
+				return;
+			}
+			preservedNodes.push(node.clone());
+		});
+		if (preservedNodes.length === root.nodes.length) return css;
+		const nextRoot = postcss.default.root();
+		nextRoot.append(preservedNodes);
+		return nextRoot.toString();
+	} catch {
+		return css;
+	}
+}
+async function appendLegacyCompatCss(css, rawSource, generatorTarget, styleHandler, cssHandlerOptions, generatorStyleOptions) {
+	const compatSource = removeGeneratedSelectorCompatCss(resolveLegacyCompatCssSource(rawSource), css);
+	if (compatSource.trim().length === 0) return css;
+	if (generatorTarget !== "weapp") return createCssAppend(css, compatSource);
+	const { css: compatCss } = await styleHandler(compatSource, {
+		...cssHandlerOptions,
+		...generatorStyleOptions
+	});
+	const cleanedCompatCss = collectDedupedPostTransformCompatCss(removeDuplicatedViteMarkers(removeUnsupportedMiniProgramAtRules(compatCss), css), css);
+	if (cleanedCompatCss.trim().length === 0) return css;
+	return createCssAppend(css, cleanedCompatCss);
+}
+async function appendLegacyContainerCompatCss(css, rawSource, file, runtime, configuredContainerCompat, generatorTarget, styleHandler, cssHandlerOptions, generatorStyleOptions) {
+	const compatSource = resolveLegacyCompatCssSource(rawSource);
+	const shouldAppendContainer = runtime.has("container") || hasConfiguredContainerCompat(rawSource, file, cssHandlerOptions) || configuredContainerCompat || collectGeneratedSelectors(compatSource).has(".container");
+	if (generatorTarget !== "weapp" || !shouldAppendContainer || collectGeneratedSelectors(css).has(".container")) return css;
+	const { css: compatCss } = await styleHandler(LEGACY_CONTAINER_COMPAT_CSS, {
+		...cssHandlerOptions,
+		...generatorStyleOptions
+	});
+	const cleanedCompatCss = collectDedupedPostTransformCompatCss(removeUnsupportedMiniProgramAtRules(compatCss), css);
+	if (cleanedCompatCss.trim().length === 0) return css;
+	return createCssAppend(css, cleanedCompatCss);
+}
+async function generateCssByGenerator(options) {
+	const { opts, runtimeState, runtime, rawSource, file, cssHandlerOptions, cssUserHandlerOptions, styleHandler, debug } = options;
+	const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+	const majorVersion = runtimeState.twPatcher.majorVersion;
+	if (isPureLocalCssImportWrapper(rawSource)) return;
+	const hasGeneratedCss = hasTailwindGeneratedCss(rawSource);
+	const hasSourceDirectives = hasTailwindSourceDirectives(rawSource);
+	const hasGeneratedMarkers = hasTailwindGeneratedCssMarkers(rawSource);
+	const shouldForceGenerateCurrentCss = hasGeneratedCss || hasGeneratedMarkers || hasSourceDirectives || cssHandlerOptions.isMainChunk;
+	if (generatorOptions.mode === "off" || !SUPPORTED_GENERATOR_MAJOR_VERSIONS.has(majorVersion ?? 0) || generatorOptions.mode === "force" && (!shouldForceGenerateCurrentCss || majorVersion === 3 && !hasSourceDirectives && !hasGeneratedCss && !hasGeneratedMarkers) || generatorOptions.mode !== "force" && majorVersion !== 3 && !hasGeneratedCss || !cssHandlerOptions.isMainChunk && majorVersion !== 3 && generatorOptions.mode !== "force" && !hasGeneratedCss) return;
+	try {
+		await runtimeState.patchPromise;
+		const sources = await resolveGeneratorSources(majorVersion, runtimeState, rawSource, file, cssHandlerOptions);
+		const generatorStyleOptions = resolveGeneratorStyleOptions(opts, cssHandlerOptions, generatorOptions.styleOptions);
+		const configuredContainerCompat = hasConfiguredContainerCompatSources(sources);
+		const generatedResults = await Promise.all(sources.map(async (source) => {
+			return require_generator.createWeappTailwindcssGenerator(source).generate({
+				candidates: runtime,
+				styleOptions: generatorStyleOptions,
+				target: generatorOptions.target
+			});
+		}));
+		const firstGenerated = generatedResults[0];
+		if (!firstGenerated) return;
+		const generated = generatedResults.length === 1 ? firstGenerated : {
+			...firstGenerated,
+			css: generatedResults.map((item) => item.css).join("\n"),
+			rawCss: generatedResults.map((item) => item.rawCss).join("\n"),
+			classSet: new Set(generatedResults.flatMap((item) => [...item.classSet])),
+			dependencies: [...new Set(generatedResults.flatMap((item) => item.dependencies))],
+			sources: generatedResults.flatMap((item) => item.sources)
+		};
+		debug("tailwind generator result: %s rawBytes=%d cssBytes=%d candidates=%d", file, generated.rawCss.length, generated.css.length, generated.classSet.size);
+		const extraCss = splitTailwindV4GeneratedCss(rawSource, generated.rawCss);
+		if (typeof extraCss === "string") {
+			let css = stripTailwindBanner(generated.css);
+			if (generated.target === "weapp") css = inheritLegacyUnitConvertedDeclarations(css, rawSource);
+			if (extraCss.trim().length > 0) {
+				const cleanedExtraCss = removeTailwindSourceDirectives(extraCss);
+				if (cleanedExtraCss.trim().length > 0) {
+					const extraSource = generated.target === "weapp" ? removeUnsupportedMiniProgramAtRules(cleanedExtraCss) : cleanedExtraCss;
+					if (extraSource.trim().length === 0) return {
+						css: finalizeMiniProgramGeneratorCss(css, generated.target),
+						target: generated.target,
+						source: "generator"
+					};
+					if (generated.target === "weapp") {
+						const { css: userCss } = await styleHandler(extraSource, {
+							...generatorStyleOptions,
+							...cssUserHandlerOptions
+						});
+						css = createCssAppend(css, removeUnsupportedMiniProgramAtRules(userCss));
+					} else css = createCssAppend(css, extraSource);
+				}
+			}
+			if (generated.target === "weapp" && generatorOptions.mode === "force") {
+				css = await appendLegacyCompatCss(css, rawSource, generated.target, styleHandler, cssHandlerOptions, generatorStyleOptions);
+				css = await appendLegacyContainerCompatCss(css, rawSource, file, runtime, configuredContainerCompat, generated.target, styleHandler, cssHandlerOptions, generatorStyleOptions);
+			}
+			return {
+				css: finalizeMiniProgramGeneratorCss(css, generated.target),
+				target: generated.target,
+				source: "generator"
+			};
+		}
+		if (generatorOptions.mode === "force") {
+			debug("tailwind direct css generation prefix mismatch, append transformed bundle css %s", file);
+			let css = stripTailwindBanner(generated.css);
+			if (generated.target === "weapp") css = inheritLegacyUnitConvertedDeclarations(css, rawSource);
+			css = await appendLegacyCompatCss(css, rawSource, generated.target, styleHandler, cssHandlerOptions, generatorStyleOptions);
+			css = await appendLegacyContainerCompatCss(css, rawSource, file, runtime, configuredContainerCompat, generated.target, styleHandler, cssHandlerOptions, generatorStyleOptions);
+			return {
+				css: finalizeMiniProgramGeneratorCss(css, generated.target),
+				target: generated.target,
+				source: "generator-forced"
+			};
+		}
+	} catch (error) {
+		if (generatorOptions.mode === "force") throw error;
+		debug("tailwind direct css generation failed, fallback to styleHandler: %s %O", file, error);
+	}
+}
+//#endregion
+Object.defineProperty(exports, "generateCssByGenerator", {
+	enumerable: true,
+	get: function() {
+		return generateCssByGenerator;
+	}
+});
+Object.defineProperty(exports, "hasTailwindGeneratedCssMarkers", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindGeneratedCssMarkers;
+	}
+});
+Object.defineProperty(exports, "hasTailwindSourceDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindSourceDirectives;
+	}
+});
+Object.defineProperty(exports, "processCachedTask", {
+	enumerable: true,
+	get: function() {
+		return processCachedTask;
+	}
+});