weapp-tailwindcss 5.0.0-next.1 → 5.0.0-next.11

package/dist/presets.js

@@ -1,7 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_utils = require("./utils-DmC9_In3.js");
-const require_logger = require("./logger-BZ45DZJT.js");
+const require_cache = require("./cache-B_9E7FxF.js");
+const require_utils = require("./utils-4ODFyoqD.js");
+const require_tailwindcss = require("./tailwindcss-B78nj6n7.js");
+require("./logger-EVNB9z7i.js");
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 let local_pkg = require("local-pkg");
@@ -15,15 +17,15 @@ function normalizeCssEntries(entries) {
 }
 function createBasePreset(options = {}) {
 	const { base, cssEntries, resolve, rawOptions, ...userOptions } = options;
-	const baseDir = require_logger.resolveTailwindcssBasedir(base);
+	const baseDir = require_tailwindcss.resolveTailwindcssBasedir(base);
 	const normalizedCssEntries = normalizeCssEntries(cssEntries);
 	const tailwindConfig = {
 		v2: { cwd: baseDir },
 		v3: { cwd: baseDir },
-		v4: {
+		v4: require_cache.omitUndefined({
 			base: baseDir,
 			cssEntries: normalizedCssEntries
-		}
+		})
 	};
 	if (normalizedCssEntries && normalizedCssEntries.length > 0) tailwindConfig.version = 4;
 	const preset = {
@@ -42,7 +44,7 @@ function createBasePreset(options = {}) {
 //#endregion
 //#region src/presets/uni-app.ts
 function uniApp(options = {}) {
-	const uniPlatform = node_process.default.env.UNI_PLATFORM;
+	const uniPlatform = node_process.default.env["UNI_PLATFORM"];
 	return createBasePreset({
 		disabled: uniPlatform === "h5" || uniPlatform === "app" || uniPlatform === "app-plus" ? true : void 0,
 		...options
@@ -79,15 +81,15 @@ function resolveInstalledTailwindDefaults(resolve) {
 	};
 }
 function uniAppX(options) {
-	_weapp_tailwindcss_logger.logger.info(`UNI_PLATFORM: ${node_process.default.env.UNI_PLATFORM}`);
+	_weapp_tailwindcss_logger.logger.info(`UNI_PLATFORM: ${node_process.default.env["UNI_PLATFORM"]}`);
 	const utsPlatform = require_utils.resolveUniUtsPlatform();
-	const uniPlatform = require_utils.resolveUniUtsPlatform(node_process.default.env.UNI_PLATFORM);
+	const uniPlatform = require_utils.resolveUniUtsPlatform(node_process.default.env["UNI_PLATFORM"]);
 	_weapp_tailwindcss_logger.logger.info(`UNI_UTS_PLATFORM: ${utsPlatform.raw ?? "undefined"}`);
 	const isApp = utsPlatform.isApp || uniPlatform.isApp;
 	const cssEntries = normalizeCssEntries(options.cssEntries);
 	const resolvedResolve = resolveTailwindResolveOptions(options.base, options.resolve);
 	const installedTailwindDefaults = resolveInstalledTailwindDefaults(resolvedResolve);
-	const resolvedUniAppX = require_logger.resolveUniAppXOptions({
+	const resolvedUniAppX = require_tailwindcss.resolveUniAppXOptions({
 		enabled: isApp,
 		componentLocalStyles: options.componentLocalStyles ?? true,
 		uvueUnsupported: options.uvueUnsupported,
@@ -107,10 +109,10 @@ function uniAppX(options) {
 				cwd: options.base,
 				resolve: resolvedResolve,
 				v3: { cwd: options.base },
-				v4: {
+				v4: require_cache.omitUndefined({
 					base: options.base,
 					cssEntries
-				}
+				})
 			}
 		},
 		tailwindcss: {

package/dist/presets.mjs

@@ -1,5 +1,7 @@
-import { n as defuOverrideArray, o as resolveUniUtsPlatform } from "./utils-7DUGTFED.mjs";
-import { a as resolveUniAppXOptions, r as resolveTailwindcssBasedir, t as logger } from "./logger-BoVx1Dbt.mjs";
+import { l as omitUndefined } from "./cache-DEDxBMIw.mjs";
+import { n as defuOverrideArray, o as resolveUniUtsPlatform } from "./utils-CGBVVNm6.mjs";
+import { i as resolveUniAppXOptions, n as resolveTailwindcssBasedir } from "./tailwindcss-DGM8lHUj.mjs";
+import { t as logger } from "./logger-CZUxvJJD.mjs";
 import process from "node:process";
 import { getPackageInfoSync } from "local-pkg";
 //#region src/presets/shared.ts
@@ -15,10 +17,10 @@ function createBasePreset(options = {}) {
 	const tailwindConfig = {
 		v2: { cwd: baseDir },
 		v3: { cwd: baseDir },
-		v4: {
+		v4: omitUndefined({
 			base: baseDir,
 			cssEntries: normalizedCssEntries
-		}
+		})
 	};
 	if (normalizedCssEntries && normalizedCssEntries.length > 0) tailwindConfig.version = 4;
 	const preset = {
@@ -37,7 +39,7 @@ function createBasePreset(options = {}) {
 //#endregion
 //#region src/presets/uni-app.ts
 function uniApp(options = {}) {
-	const uniPlatform = process.env.UNI_PLATFORM;
+	const uniPlatform = process.env["UNI_PLATFORM"];
 	return createBasePreset({
 		disabled: uniPlatform === "h5" || uniPlatform === "app" || uniPlatform === "app-plus" ? true : void 0,
 		...options
@@ -74,9 +76,9 @@ function resolveInstalledTailwindDefaults(resolve) {
 	};
 }
 function uniAppX(options) {
-	logger.info(`UNI_PLATFORM: ${process.env.UNI_PLATFORM}`);
+	logger.info(`UNI_PLATFORM: ${process.env["UNI_PLATFORM"]}`);
 	const utsPlatform = resolveUniUtsPlatform();
-	const uniPlatform = resolveUniUtsPlatform(process.env.UNI_PLATFORM);
+	const uniPlatform = resolveUniUtsPlatform(process.env["UNI_PLATFORM"]);
 	logger.info(`UNI_UTS_PLATFORM: ${utsPlatform.raw ?? "undefined"}`);
 	const isApp = utsPlatform.isApp || uniPlatform.isApp;
 	const cssEntries = normalizeCssEntries(options.cssEntries);
@@ -102,10 +104,10 @@ function uniAppX(options) {
 				cwd: options.base,
 				resolve: resolvedResolve,
 				v3: { cwd: options.base },
-				v4: {
+				v4: omitUndefined({
 					base: options.base,
 					cssEntries
-				}
+				})
 			}
 		},
 		tailwindcss: {

package/dist/reset.d.ts

@@ -1 +1,2 @@
+export { default } from './reset/index'
 export * from './reset/index'

package/dist/runtime-patch-CqB-A4zA.js

@@ -0,0 +1,85 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_cache = require("./cache-B_9E7FxF.js");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let debug = require("debug");
+debug = require_chunk.__toESM(debug);
+//#region src/debug/index.ts
+const _debug = (0, debug.default)("weapp-tw");
+function createDebug(prefix) {
+	const debug$2 = ((formatter, ...args) => {
+		return _debug((prefix ?? "") + formatter, ...args);
+	});
+	Object.defineProperty(debug$2, "enabled", {
+		enumerable: false,
+		configurable: false,
+		get() {
+			return _debug.enabled;
+		}
+	});
+	return debug$2;
+}
+//#endregion
+//#region src/tailwindcss/runtime-patch.ts
+const debug$1 = createDebug("[tailwindcss:runtime-patch] ");
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const runtimePatchPromiseCache = /* @__PURE__ */ new WeakMap();
+function getNestedPatchers(twPatcher) {
+	const nested = twPatcher[require_cache.runtimeSignaturePatchersSymbol];
+	return Array.isArray(nested) && nested.length > 0 ? nested : void 0;
+}
+function shouldApplyRuntimePatch(twPatcher) {
+	return twPatcher.majorVersion === 3 && typeof twPatcher.patch === "function";
+}
+function clearTailwindcssRequireCache(twPatcher) {
+	const rootPath = twPatcher.packageInfo?.rootPath;
+	if (!rootPath) return;
+	const normalizedRoot = node_path.default.resolve(rootPath);
+	let count = 0;
+	for (const id of Object.keys(require$1.cache)) {
+		const normalizedId = node_path.default.resolve(id);
+		if (normalizedId === normalizedRoot || normalizedId.startsWith(`${normalizedRoot}${node_path.default.sep}`)) {
+			delete require$1.cache[id];
+			count += 1;
+		}
+	}
+	if (count > 0) debug$1("clear tailwindcss require cache after runtime patch, count=%d root=%s", count, normalizedRoot);
+}
+async function ensureTailwindcssRuntimePatch(twPatcher, options = {}) {
+	const nestedPatchers = getNestedPatchers(twPatcher);
+	if (nestedPatchers) {
+		await Promise.all(nestedPatchers.map((patcher) => ensureTailwindcssRuntimePatch(patcher)));
+		return;
+	}
+	if (!shouldApplyRuntimePatch(twPatcher)) return;
+	const cached = runtimePatchPromiseCache.get(twPatcher);
+	if (cached) {
+		await cached;
+		if (options.clearRequireCache) clearTailwindcssRequireCache(twPatcher);
+		return;
+	}
+	const task = Promise.resolve().then(async () => {
+		debug$1("apply tailwindcss runtime patch, package=%s version=%s root=%s", twPatcher.packageInfo?.name ?? "tailwindcss", twPatcher.packageInfo?.version ?? "unknown", twPatcher.packageInfo?.rootPath ?? "unknown");
+		await twPatcher.patch?.();
+		if (options.clearRequireCache) clearTailwindcssRequireCache(twPatcher);
+	}).catch((error) => {
+		runtimePatchPromiseCache.delete(twPatcher);
+		throw error;
+	});
+	runtimePatchPromiseCache.set(twPatcher, task);
+	return task;
+}
+//#endregion
+Object.defineProperty(exports, "createDebug", {
+	enumerable: true,
+	get: function() {
+		return createDebug;
+	}
+});
+Object.defineProperty(exports, "ensureTailwindcssRuntimePatch", {
+	enumerable: true,
+	get: function() {
+		return ensureTailwindcssRuntimePatch;
+	}
+});

package/dist/runtime-patch-DGKsVkiG.mjs

@@ -0,0 +1,71 @@
+import { i as runtimeSignaturePatchersSymbol } from "./cache-DEDxBMIw.mjs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import _createDebug from "debug";
+//#region src/debug/index.ts
+const _debug = _createDebug("weapp-tw");
+function createDebug(prefix) {
+	const debug = ((formatter, ...args) => {
+		return _debug((prefix ?? "") + formatter, ...args);
+	});
+	Object.defineProperty(debug, "enabled", {
+		enumerable: false,
+		configurable: false,
+		get() {
+			return _debug.enabled;
+		}
+	});
+	return debug;
+}
+//#endregion
+//#region src/tailwindcss/runtime-patch.ts
+const debug = createDebug("[tailwindcss:runtime-patch] ");
+const require = createRequire(import.meta.url);
+const runtimePatchPromiseCache = /* @__PURE__ */ new WeakMap();
+function getNestedPatchers(twPatcher) {
+	const nested = twPatcher[runtimeSignaturePatchersSymbol];
+	return Array.isArray(nested) && nested.length > 0 ? nested : void 0;
+}
+function shouldApplyRuntimePatch(twPatcher) {
+	return twPatcher.majorVersion === 3 && typeof twPatcher.patch === "function";
+}
+function clearTailwindcssRequireCache(twPatcher) {
+	const rootPath = twPatcher.packageInfo?.rootPath;
+	if (!rootPath) return;
+	const normalizedRoot = path.resolve(rootPath);
+	let count = 0;
+	for (const id of Object.keys(require.cache)) {
+		const normalizedId = path.resolve(id);
+		if (normalizedId === normalizedRoot || normalizedId.startsWith(`${normalizedRoot}${path.sep}`)) {
+			delete require.cache[id];
+			count += 1;
+		}
+	}
+	if (count > 0) debug("clear tailwindcss require cache after runtime patch, count=%d root=%s", count, normalizedRoot);
+}
+async function ensureTailwindcssRuntimePatch(twPatcher, options = {}) {
+	const nestedPatchers = getNestedPatchers(twPatcher);
+	if (nestedPatchers) {
+		await Promise.all(nestedPatchers.map((patcher) => ensureTailwindcssRuntimePatch(patcher)));
+		return;
+	}
+	if (!shouldApplyRuntimePatch(twPatcher)) return;
+	const cached = runtimePatchPromiseCache.get(twPatcher);
+	if (cached) {
+		await cached;
+		if (options.clearRequireCache) clearTailwindcssRequireCache(twPatcher);
+		return;
+	}
+	const task = Promise.resolve().then(async () => {
+		debug("apply tailwindcss runtime patch, package=%s version=%s root=%s", twPatcher.packageInfo?.name ?? "tailwindcss", twPatcher.packageInfo?.version ?? "unknown", twPatcher.packageInfo?.rootPath ?? "unknown");
+		await twPatcher.patch?.();
+		if (options.clearRequireCache) clearTailwindcssRequireCache(twPatcher);
+	}).catch((error) => {
+		runtimePatchPromiseCache.delete(twPatcher);
+		throw error;
+	});
+	runtimePatchPromiseCache.set(twPatcher, task);
+	return task;
+}
+//#endregion
+export { createDebug as n, ensureTailwindcssRuntimePatch as t };

package/dist/shared/mpx.d.ts

@@ -1,6 +1,7 @@
 import type { AppType } from '../types';
 export declare function isMpx(appType?: AppType): appType is "mpx";
 export declare function getTailwindcssCssEntry(pkgDir: string): string;
+export declare function patchMpxWebpackPluginNormalizeLib(compiler: any, mpxWebpackPluginDir: string | undefined): boolean;
 export declare function ensureMpxTailwindcssAliases(compiler: any, pkgDir: string): string;
 export declare function patchMpxLoaderResolve(loaderContext: any, pkgDir: string, enabled: boolean): void;
 export declare function setupMpxTailwindcssRedirect(pkgDir: string, enabled: boolean): void;

package/dist/source-scan-CIVTa3Cj.js

@@ -0,0 +1,297 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+let fast_glob = require("fast-glob");
+fast_glob = require_chunk.__toESM(fast_glob);
+let micromatch = require("micromatch");
+micromatch = require_chunk.__toESM(micromatch);
+//#region src/tailwindcss/source-scan.ts
+const DEFAULT_SOURCE_SCAN_EXTENSIONS = [
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"vue",
+	"mpx",
+	"js",
+	"jsx",
+	"ts",
+	"tsx"
+];
+function createSourceScanPattern(extensions = DEFAULT_SOURCE_SCAN_EXTENSIONS) {
+	return `**/*.{${extensions.join(",")}}`;
+}
+const NUMERICAL_RANGE_RE = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+function parseConfigParam(params) {
+	const value = params.trim();
+	return /^(['"])(.+)\1$/.exec(value)?.[2];
+}
+function isLegacyContentObject(value) {
+	return typeof value === "object" && value !== null && "files" in value;
+}
+function normalizeGlobPattern(pattern) {
+	return pattern.startsWith("./") ? pattern.slice(2) : pattern;
+}
+function segmentTopLevel(input, separator) {
+	const parts = [];
+	const stack = [];
+	let lastPos = 0;
+	let quote;
+	for (let index = 0; index < input.length; index++) {
+		const char = input[index];
+		if (char === "\\") {
+			index += 1;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "(") {
+			stack.push(")");
+			continue;
+		}
+		if (char === "[") {
+			stack.push("]");
+			continue;
+		}
+		if (char === "{") {
+			stack.push("}");
+			continue;
+		}
+		if (stack.length > 0 && char === stack[stack.length - 1]) {
+			stack.pop();
+			continue;
+		}
+		if (stack.length === 0 && char === separator) {
+			parts.push(input.slice(lastPos, index));
+			lastPos = index + 1;
+		}
+	}
+	parts.push(input.slice(lastPos));
+	return parts;
+}
+function isSequence(value) {
+	return NUMERICAL_RANGE_RE.test(value);
+}
+function expandSequence(value) {
+	const match = value.match(NUMERICAL_RANGE_RE);
+	if (!match) return [value];
+	const [, start, end, stepValue] = match;
+	if (start === void 0 || end === void 0) return [value];
+	let step = stepValue ? Number.parseInt(stepValue, 10) : void 0;
+	const startNumber = Number.parseInt(start, 10);
+	const endNumber = Number.parseInt(end, 10);
+	const increasing = startNumber < endNumber;
+	if (step === void 0) step = increasing ? 1 : -1;
+	if (step === 0) return [];
+	if (increasing && step < 0) step = -step;
+	if (!increasing && step > 0) step = -step;
+	const result = [];
+	for (let value = startNumber; increasing ? value <= endNumber : value >= endNumber; value += step) result.push(String(value));
+	return result;
+}
+function expandInlineSourceCandidatePattern(pattern) {
+	const index = pattern.indexOf("{");
+	if (index === -1) return [pattern];
+	const prefix = pattern.slice(0, index);
+	const rest = pattern.slice(index);
+	let depth = 0;
+	let endIndex = -1;
+	for (let index = 0; index < rest.length; index++) {
+		const char = rest[index];
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				endIndex = index;
+				break;
+			}
+		}
+	}
+	if (endIndex === -1) return [pattern];
+	const inner = rest.slice(1, endIndex);
+	const suffix = rest.slice(endIndex + 1);
+	const parts = (isSequence(inner) ? expandSequence(inner) : segmentTopLevel(inner, ",")).flatMap((part) => expandInlineSourceCandidatePattern(part));
+	return expandInlineSourceCandidatePattern(suffix).flatMap((suffix) => parts.map((part) => `${prefix}${part}${suffix}`));
+}
+function parseSourceInlineParam(params) {
+	let value = params.trim();
+	const negated = value.startsWith("not ");
+	if (negated) value = value.slice(4).trim();
+	if (!value.startsWith("inline(") || !value.endsWith(")")) return;
+	const inlineValue = value.slice(7, -1).trim();
+	const match = /^(['"])([\s\S]*)\1$/.exec(inlineValue);
+	if (!match) return;
+	const source = match[2];
+	if (source === void 0) return;
+	return {
+		negated,
+		source
+	};
+}
+function collectCssInlineSourceCandidates(root) {
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceInlineParam(rule.params);
+		if (!parsed) return;
+		const target = parsed.negated ? excluded : included;
+		for (const source of segmentTopLevel(parsed.source, " ")) {
+			const trimmed = source.trim();
+			if (!trimmed) continue;
+			for (const candidate of expandInlineSourceCandidatePattern(trimmed)) {
+				const normalized = candidate.trim();
+				if (normalized) target.add(normalized);
+			}
+		}
+	});
+	for (const candidate of excluded) included.delete(candidate);
+	return {
+		included,
+		excluded
+	};
+}
+function normalizeLegacyContentEntries(content, base) {
+	if (typeof content === "string") {
+		const negated = content.startsWith("!");
+		return [{
+			base,
+			negated,
+			pattern: normalizeGlobPattern(negated ? content.slice(1) : content)
+		}];
+	}
+	if (Array.isArray(content)) return content.flatMap((item) => normalizeLegacyContentEntries(item, base));
+	if (isLegacyContentObject(content)) return normalizeLegacyContentEntries(content.files, base);
+	return [];
+}
+async function pathExistsAsDirectory(file) {
+	try {
+		return (await (0, node_fs_promises.stat)(file)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindSourceEntry(sourcePath, base, negated, defaultPattern = createSourceScanPattern()) {
+	const absoluteSource = node_path.default.isAbsolute(sourcePath) ? node_path.default.resolve(sourcePath) : node_path.default.resolve(base, sourcePath);
+	if (await pathExistsAsDirectory(absoluteSource)) return {
+		base: absoluteSource,
+		negated,
+		pattern: normalizeGlobPattern(defaultPattern)
+	};
+	if (node_path.default.isAbsolute(sourcePath)) return {
+		base: node_path.default.dirname(absoluteSource),
+		negated,
+		pattern: normalizeGlobPattern(node_path.default.basename(absoluteSource))
+	};
+	return {
+		base,
+		negated,
+		pattern: normalizeGlobPattern(sourcePath)
+	};
+}
+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;
+	if (sourceValue.startsWith("inline(")) return;
+	const match = /^(['"])(.+)\1$/.exec(sourceValue);
+	return match?.[2] ? {
+		negated,
+		sourcePath: match[2]
+	} : void 0;
+}
+async function resolveCssSourceEntries(root, base, defaultPattern = createSourceScanPattern()) {
+	const entries = [];
+	const tasks = [];
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceFileParam(rule.params);
+		if (!parsed) return;
+		tasks.push(resolveTailwindSourceEntry(parsed.sourcePath, base, parsed.negated, defaultPattern));
+	});
+	entries.push(...await Promise.all(tasks));
+	return entries;
+}
+async function expandTailwindSourceEntries(entries, options = {}) {
+	const files = /* @__PURE__ */ new Set();
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	const entriesByBase = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const base = node_path.default.resolve(entry.base);
+		const group = entriesByBase.get(base) ?? [];
+		group.push({
+			...entry,
+			base
+		});
+		entriesByBase.set(base, group);
+	}
+	await Promise.all([...entriesByBase.entries()].map(async ([base, group]) => {
+		const patterns = group.map((entry) => {
+			const pattern = normalizeGlobPattern(entry.pattern);
+			return entry.negated ? `!${pattern}` : pattern;
+		});
+		if (!patterns.some((pattern) => !pattern.startsWith("!"))) return;
+		const ignore = options.ignore;
+		const matched = await (0, fast_glob.default)(patterns, {
+			absolute: true,
+			cwd: base,
+			...ignore === void 0 ? {} : { ignore },
+			onlyFiles: true,
+			unique: true
+		});
+		for (const file of matched) files.add(node_path.default.resolve(file));
+	}));
+	return [...files].filter((file) => !negativeEntries.some((entry) => {
+		const relative = node_path.default.relative(node_path.default.resolve(entry.base), file).split(node_path.default.sep).join("/");
+		return relative && !relative.startsWith("../") && !node_path.default.isAbsolute(relative) && micromatch.default.isMatch(relative, normalizeGlobPattern(entry.pattern));
+	}));
+}
+//#endregion
+Object.defineProperty(exports, "collectCssInlineSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return collectCssInlineSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "createSourceScanPattern", {
+	enumerable: true,
+	get: function() {
+		return createSourceScanPattern;
+	}
+});
+Object.defineProperty(exports, "expandTailwindSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return expandTailwindSourceEntries;
+	}
+});
+Object.defineProperty(exports, "normalizeLegacyContentEntries", {
+	enumerable: true,
+	get: function() {
+		return normalizeLegacyContentEntries;
+	}
+});
+Object.defineProperty(exports, "parseConfigParam", {
+	enumerable: true,
+	get: function() {
+		return parseConfigParam;
+	}
+});
+Object.defineProperty(exports, "resolveCssSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return resolveCssSourceEntries;
+	}
+});