@pikacss/core 0.0.43 → 0.0.44

package/dist/index.cjs

@@ -1,1197 +0,0 @@
-
-//#region src/internal/constants.ts
-const ATOMIC_STYLE_ID_PLACEHOLDER = "%";
-const ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL = /%/g;
-
-//#endregion
-//#region src/internal/utils.ts
-function createLogger(prefix) {
-	let currentPrefix = prefix;
-	let enabledDebug = false;
-	let _debug = console.log;
-	let _info = console.log;
-	let _warn = console.warn;
-	let _error = console.error;
-	return {
-		debug: (...args) => {
-			if (!enabledDebug) return;
-			_debug(`${currentPrefix}[DEBUG]`, ...args);
-		},
-		info: (...args) => {
-			_info(`${currentPrefix}[INFO]`, ...args);
-		},
-		warn: (...args) => {
-			_warn(`${currentPrefix}[WARN]`, ...args);
-		},
-		error: (...args) => {
-			_error(`${currentPrefix}[ERROR]`, ...args);
-		},
-		toggleDebug() {
-			enabledDebug = !enabledDebug;
-		},
-		setPrefix(newPrefix) {
-			currentPrefix = newPrefix;
-		},
-		setDebugFn(fn) {
-			_debug = fn;
-		},
-		setInfoFn(fn) {
-			_info = fn;
-		},
-		setWarnFn(fn) {
-			_warn = fn;
-		},
-		setErrorFn(fn) {
-			_error = fn;
-		}
-	};
-}
-const log = createLogger("[PikaCSS]");
-const chars = [..."abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"];
-const numOfChars = chars.length;
-function numberToChars(num) {
-	if (num < numOfChars) return chars[num];
-	let result = "";
-	let n = num;
-	while (n >= 0) {
-		result += chars[n % numOfChars];
-		n = Math.floor(n / numOfChars) - 1;
-	}
-	return result;
-}
-const UPPER_CASE = /[A-Z]/g;
-function toKebab(str) {
-	return str.replace(UPPER_CASE, (c) => `-${c.toLowerCase()}`);
-}
-function isNotNullish(value) {
-	return value != null;
-}
-function isNotString(value) {
-	return typeof value !== "string";
-}
-function isPropertyValue(v) {
-	if (Array.isArray(v)) return v.length === 2 && isPropertyValue(v[0]) && Array.isArray(v[1]) && v[1].every(isPropertyValue);
-	if (v == null) return true;
-	if (typeof v === "string" || typeof v === "number") return true;
-	return false;
-}
-function serialize(value) {
-	return JSON.stringify(value);
-}
-function addToSet(set, ...values) {
-	values.forEach((value) => set.add(value));
-}
-function appendAutocompleteSelectors(config, ...selectors$1) {
-	addToSet(config.autocomplete.selectors, ...selectors$1);
-}
-function appendAutocompleteStyleItemStrings(config, ...styleItemStrings) {
-	addToSet(config.autocomplete.styleItemStrings, ...styleItemStrings);
-}
-function appendAutocompleteExtraProperties(config, ...properties) {
-	addToSet(config.autocomplete.extraProperties, ...properties);
-}
-function appendAutocompleteExtraCssProperties(config, ...properties) {
-	addToSet(config.autocomplete.extraCssProperties, ...properties);
-}
-function appendAutocompletePropertyValues(config, property, ...tsTypes) {
-	const current = config.autocomplete.properties.get(property) || [];
-	config.autocomplete.properties.set(property, [...current, ...tsTypes]);
-}
-function appendAutocompleteCssPropertyValues(config, property, ...values) {
-	const current = config.autocomplete.cssProperties.get(property) || [];
-	config.autocomplete.cssProperties.set(property, [...current, ...values]);
-}
-function renderCSSStyleBlocks(blocks, isFormatted, depth = 0) {
-	const blockIndent = isFormatted ? "  ".repeat(depth) : "";
-	const blockBodyIndent = isFormatted ? "  ".repeat(depth + 1) : "";
-	const selectorEnd = isFormatted ? " " : "";
-	const propertySpace = isFormatted ? " " : "";
-	const lineEnd = isFormatted ? "\n" : "";
-	const lines = [];
-	blocks.forEach(({ properties, children }, selector) => {
-		if (properties.length === 0 && (children == null || children.size === 0)) return;
-		lines.push(...[
-			`${blockIndent}${selector}${selectorEnd}{`,
-			...properties.map(({ property, value }) => `${blockBodyIndent}${property}:${propertySpace}${value};`),
-			...children != null && children.size > 0 ? [renderCSSStyleBlocks(children, isFormatted, depth + 1)] : [],
-			`${blockIndent}}`
-		]);
-	});
-	return lines.join(lineEnd);
-}
-
-//#endregion
-//#region src/internal/extractor.ts
-function replaceBySplitAndJoin(str, split, mapFn, join) {
-	let splitted = str.split(split);
-	if (mapFn != null) splitted = splitted.map(mapFn);
-	return splitted.join(join);
-}
-const RE_SPLIT = /\s*,\s*/g;
-const DEFAULT_SELECTOR_PLACEHOLDER_RE_GLOBAL = /\$/g;
-const ATTRIBUTE_SUFFIX_MATCH = "$=";
-const ATTRIBUTE_SUFFIX_MATCH_RE_GLOBAL = /\$=/g;
-function normalizeSelectors({ selectors: selectors$1, defaultSelector }) {
-	return selectors$1.map((s) => replaceBySplitAndJoin(s.replace(RE_SPLIT, ","), ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL, (a) => replaceBySplitAndJoin(a, ATTRIBUTE_SUFFIX_MATCH_RE_GLOBAL, (b) => replaceBySplitAndJoin(b, DEFAULT_SELECTOR_PLACEHOLDER_RE_GLOBAL, null, defaultSelector), ATTRIBUTE_SUFFIX_MATCH), ATOMIC_STYLE_ID_PLACEHOLDER));
-}
-function normalizeValue(value) {
-	if (value == null) return value;
-	return [...new Set([value].flat(2).map((v) => String(v).trim()))];
-}
-async function extract({ styleDefinition, levels = [], result = [], defaultSelector, transformSelectors, transformStyleItems, transformStyleDefinitions }) {
-	for (const definition of await transformStyleDefinitions([styleDefinition])) for (const [k, v] of Object.entries(definition)) if (isPropertyValue(v)) {
-		const selector = normalizeSelectors({
-			selectors: await transformSelectors(levels),
-			defaultSelector
-		});
-		if (selector.length === 0 || selector.every((s) => s.includes(ATOMIC_STYLE_ID_PLACEHOLDER) === false)) selector.push(defaultSelector);
-		result.push({
-			selector,
-			property: toKebab(k),
-			value: normalizeValue(v)
-		});
-	} else if (Array.isArray(v)) for (const styleItem of await transformStyleItems(v)) {
-		if (typeof styleItem === "string") continue;
-		await extract({
-			styleDefinition: styleItem,
-			levels: [...levels, k],
-			result,
-			transformSelectors,
-			transformStyleItems,
-			transformStyleDefinitions,
-			defaultSelector
-		});
-	}
-	else await extract({
-		styleDefinition: v,
-		levels: [...levels, k],
-		result,
-		transformSelectors,
-		transformStyleItems,
-		transformStyleDefinitions,
-		defaultSelector
-	});
-	return result;
-}
-function createExtractFn(options) {
-	return (styleDefinition) => extract({
-		styleDefinition,
-		...options
-	});
-}
-
-//#endregion
-//#region src/internal/plugin.ts
-async function execAsyncHook(plugins, hook, payload) {
-	log.debug(`Executing async hook: ${hook}`);
-	for (const plugin of plugins) {
-		if (plugin[hook] == null) continue;
-		try {
-			log.debug(`  - Plugin "${plugin.name}" executing ${hook}`);
-			const newPayload = await plugin[hook](payload);
-			if (newPayload != null) payload = newPayload;
-			log.debug(`  - Plugin "${plugin.name}" completed ${hook}`);
-		} catch (error) {
-			log.error(`Plugin "${plugin.name}" failed to execute hook "${hook}": ${error.message}`, error);
-		}
-	}
-	log.debug(`Async hook "${hook}" completed`);
-	return payload;
-}
-function execSyncHook(plugins, hook, payload) {
-	log.debug(`Executing sync hook: ${hook}`);
-	for (const plugin of plugins) {
-		if (plugin[hook] == null) continue;
-		try {
-			log.debug(`  - Plugin "${plugin.name}" executing ${hook}`);
-			const newPayload = plugin[hook](payload);
-			if (newPayload != null) payload = newPayload;
-			log.debug(`  - Plugin "${plugin.name}" completed ${hook}`);
-		} catch (error) {
-			log.error(`Plugin "${plugin.name}" failed to execute hook "${hook}": ${error.message}`, error);
-		}
-	}
-	log.debug(`Sync hook "${hook}" completed`);
-	return payload;
-}
-const hooks = {
-	configureRawConfig: (plugins, config) => execAsyncHook(plugins, "configureRawConfig", config),
-	rawConfigConfigured: (plugins, config) => execSyncHook(plugins, "rawConfigConfigured", config),
-	configureResolvedConfig: (plugins, resolvedConfig) => execAsyncHook(plugins, "configureResolvedConfig", resolvedConfig),
-	configureEngine: (plugins, engine) => execAsyncHook(plugins, "configureEngine", engine),
-	transformSelectors: (plugins, selectors$1) => execAsyncHook(plugins, "transformSelectors", selectors$1),
-	transformStyleItems: (plugins, styleItems) => execAsyncHook(plugins, "transformStyleItems", styleItems),
-	transformStyleDefinitions: (plugins, styleDefinitions) => execAsyncHook(plugins, "transformStyleDefinitions", styleDefinitions),
-	preflightUpdated: (plugins) => execSyncHook(plugins, "preflightUpdated", void 0),
-	atomicStyleAdded: (plugins, atomicStyle) => execSyncHook(plugins, "atomicStyleAdded", atomicStyle),
-	autocompleteConfigUpdated: (plugins) => execSyncHook(plugins, "autocompleteConfigUpdated", void 0)
-};
-const orderMap = new Map([
-	[void 0, 1],
-	["pre", 0],
-	["post", 2]
-]);
-function resolvePlugins(plugins) {
-	return plugins.sort((a, b) => orderMap.get(a.order) - orderMap.get(b.order));
-}
-/* c8 ignore start */
-function defineEnginePlugin(plugin) {
-	return plugin;
-}
-/* c8 ignore end */
-
-//#endregion
-//#region src/internal/plugins/important.ts
-function modifyPropertyValue(value) {
-	if (value == null) return null;
-	if (Array.isArray(value)) return [`${value[0]} !important`, value[1].map((i) => `${i} !important`)];
-	return `${value} !important`;
-}
-function important() {
-	let defaultValue;
-	return defineEnginePlugin({
-		name: "core:important",
-		rawConfigConfigured(config) {
-			defaultValue = config.important?.default ?? false;
-		},
-		configureEngine(engine) {
-			engine.appendAutocompleteExtraProperties("__important");
-			engine.appendAutocompletePropertyValues("__important", "boolean");
-		},
-		transformStyleDefinitions(styleDefinitions) {
-			return styleDefinitions.map((styleDefinition) => {
-				const { __important, ...rest } = styleDefinition;
-				const value = __important;
-				if ((value == null ? defaultValue : value) === false) return rest;
-				return Object.fromEntries(Object.entries(rest).map(([k, v]) => {
-					if (isPropertyValue(v)) return [k, modifyPropertyValue(v)];
-					return [k, v];
-				}));
-			});
-		}
-	});
-}
-
-//#endregion
-//#region src/internal/plugins/keyframes.ts
-function keyframes() {
-	let resolveKeyframesConfig;
-	let configList;
-	return defineEnginePlugin({
-		name: "core:keyframes",
-		rawConfigConfigured(config) {
-			resolveKeyframesConfig = createResolveConfigFn({ pruneUnused: config.keyframes?.pruneUnused });
-			configList = config.keyframes?.keyframes ?? [];
-		},
-		configureEngine(engine) {
-			engine.keyframes = {
-				store: /* @__PURE__ */ new Map(),
-				add: (...list) => {
-					list.forEach((config) => {
-						const resolved = resolveKeyframesConfig(config);
-						const { name, frames, autocomplete: autocompleteAnimation } = resolved;
-						if (frames != null) engine.keyframes.store.set(name, resolved);
-						engine.appendAutocompleteCssPropertyValues("animationName", name);
-						engine.appendAutocompleteCssPropertyValues("animation", `${name} `);
-						if (autocompleteAnimation != null) engine.appendAutocompleteCssPropertyValues("animation", ...autocompleteAnimation);
-					});
-					engine.notifyPreflightUpdated();
-				}
-			};
-			engine.keyframes.add(...configList);
-			engine.addPreflight((engine$1) => {
-				const maybeUsedName = /* @__PURE__ */ new Set();
-				engine$1.store.atomicStyles.forEach(({ content: { property, value } }) => {
-					if (property === "animationName") {
-						value.forEach((name) => maybeUsedName.add(name));
-						return;
-					}
-					if (property === "animation") value.forEach((value$1) => {
-						value$1.split(",").map((v) => v.trim()).forEach((animation) => {
-							addToSet(maybeUsedName, ...animation.split(" "));
-						});
-					});
-				});
-				const maybeUsedKeyframes = Array.from(engine$1.keyframes.store.values()).filter(({ name, frames, pruneUnused }) => (pruneUnused === false || maybeUsedName.has(name)) && frames != null);
-				const preflightDefinition = {};
-				maybeUsedKeyframes.forEach(({ name, frames }) => {
-					preflightDefinition[`@keyframes ${name}`] = Object.fromEntries(Object.entries(frames).map(([frame, properties]) => [frame, properties]));
-				});
-				return preflightDefinition;
-			});
-		}
-	});
-}
-function createResolveConfigFn({ pruneUnused: defaultPruneUnused = true } = {}) {
-	return function resolveKeyframesConfig(config) {
-		if (typeof config === "string") return {
-			name: config,
-			frames: null,
-			autocomplete: [],
-			pruneUnused: defaultPruneUnused
-		};
-		if (Array.isArray(config)) {
-			const [name$1, frames$1, autocomplete$1 = [], pruneUnused$1 = defaultPruneUnused] = config;
-			return {
-				name: name$1,
-				frames: frames$1,
-				autocomplete: autocomplete$1,
-				pruneUnused: pruneUnused$1
-			};
-		}
-		const { name, frames, autocomplete = [], pruneUnused = defaultPruneUnused } = config;
-		return {
-			name,
-			frames,
-			autocomplete,
-			pruneUnused
-		};
-	};
-}
-
-//#endregion
-//#region src/internal/resolver.ts
-var AbstractResolver = class {
-	_resolvedResultsMap = /* @__PURE__ */ new Map();
-	staticRulesMap = /* @__PURE__ */ new Map();
-	dynamicRulesMap = /* @__PURE__ */ new Map();
-	onResolved = () => {};
-	get staticRules() {
-		return [...this.staticRulesMap.values()];
-	}
-	get dynamicRules() {
-		return [...this.dynamicRulesMap.values()];
-	}
-	addStaticRule(rule) {
-		log.debug(`Adding static rule: ${rule.key}`);
-		this.staticRulesMap.set(rule.key, rule);
-		return this;
-	}
-	removeStaticRule(key) {
-		const rule = this.staticRulesMap.get(key);
-		if (rule == null) {
-			log.warn(`Static rule not found for removal: ${key}`);
-			return this;
-		}
-		log.debug(`Removing static rule: ${key}`);
-		this.staticRulesMap.delete(key);
-		this._resolvedResultsMap.delete(rule.string);
-		return this;
-	}
-	addDynamicRule(rule) {
-		log.debug(`Adding dynamic rule: ${rule.key}`);
-		this.dynamicRulesMap.set(rule.key, rule);
-		return this;
-	}
-	removeDynamicRule(key) {
-		const rule = this.dynamicRulesMap.get(key);
-		if (rule == null) {
-			log.warn(`Dynamic rule not found for removal: ${key}`);
-			return this;
-		}
-		log.debug(`Removing dynamic rule: ${key}`);
-		const matchedResolvedStringList = Array.from(this._resolvedResultsMap.keys()).filter((string) => rule.stringPattern.test(string));
-		this.dynamicRulesMap.delete(key);
-		matchedResolvedStringList.forEach((string) => this._resolvedResultsMap.delete(string));
-		log.debug(`  - Cleared ${matchedResolvedStringList.length} cached results`);
-		return this;
-	}
-	async _resolve(string) {
-		const existedResult = this._resolvedResultsMap.get(string);
-		if (existedResult != null) {
-			log.debug(`Resolved from cache: ${string}`);
-			return existedResult;
-		}
-		const staticRule = Array.from(this.staticRulesMap.values()).find((rule) => rule.string === string);
-		if (staticRule != null) {
-			log.debug(`Resolved by static rule: ${staticRule.key}`);
-			const resolvedResult = { value: staticRule.resolved };
-			this._resolvedResultsMap.set(string, resolvedResult);
-			this.onResolved(string, "static", resolvedResult);
-			return resolvedResult;
-		}
-		let dynamicRule;
-		let matched;
-		for (const rule of this.dynamicRulesMap.values()) {
-			matched = string.match(rule.stringPattern);
-			if (matched != null) {
-				dynamicRule = rule;
-				break;
-			}
-		}
-		if (dynamicRule != null && matched != null) {
-			log.debug(`Resolved by dynamic rule: ${dynamicRule.key}`);
-			const resolvedResult = { value: await dynamicRule.createResolved(matched) };
-			this._resolvedResultsMap.set(string, resolvedResult);
-			this.onResolved(string, "dynamic", resolvedResult);
-			return resolvedResult;
-		}
-		log.debug(`Resolution failed for: ${string}`);
-	}
-	_setResolvedResult(string, resolved) {
-		const resolvedResult = this._resolvedResultsMap.get(string);
-		if (resolvedResult) {
-			resolvedResult.value = resolved;
-			return;
-		}
-		this._resolvedResultsMap.set(string, { value: resolved });
-	}
-};
-
-//#endregion
-//#region src/internal/plugins/selectors.ts
-function selectors() {
-	let engine;
-	let configList;
-	return defineEnginePlugin({
-		name: "core:selectors",
-		rawConfigConfigured(config) {
-			configList = config.selectors?.selectors ?? [];
-		},
-		configureEngine(_engine) {
-			engine = _engine;
-			engine.selectors = {
-				resolver: new SelectorResolver(),
-				add: (...list) => {
-					list.forEach((config) => {
-						const resolved = resolveSelectorConfig(config);
-						if (resolved == null) return;
-						if (typeof resolved === "string") {
-							engine.appendAutocompleteSelectors(resolved);
-							return;
-						}
-						if (resolved.type === "static") engine.selectors.resolver.addStaticRule(resolved.rule);
-						else if (resolved.type === "dynamic") engine.selectors.resolver.addDynamicRule(resolved.rule);
-						engine.appendAutocompleteSelectors(...resolved.autocomplete);
-					});
-				}
-			};
-			engine.selectors.add(...configList);
-			engine.selectors.resolver.onResolved = (string, type) => {
-				if (type === "dynamic") engine.appendAutocompleteSelectors(string);
-			};
-		},
-		async transformSelectors(selectors$1) {
-			const result = [];
-			for (const selector of selectors$1) result.push(...await engine.selectors.resolver.resolve(selector));
-			return result;
-		}
-	});
-}
-var SelectorResolver = class extends AbstractResolver {
-	async resolve(selector) {
-		const resolved = await this._resolve(selector).catch((error) => {
-			log.warn(`Failed to resolve selector "${selector}": ${error.message}`, error);
-		});
-		if (resolved == null) return [selector];
-		const result = [];
-		for (const s of resolved.value) result.push(...await this.resolve(s));
-		this._setResolvedResult(selector, result);
-		return result;
-	}
-};
-function resolveSelectorConfig(config) {
-	if (typeof config === "string") return config;
-	if (Array.isArray(config)) {
-		if (typeof config[0] === "string" && typeof config[1] !== "function") return {
-			type: "static",
-			rule: {
-				key: config[0],
-				string: config[0],
-				resolved: [config[1]].flat(1)
-			},
-			autocomplete: [config[0]]
-		};
-		if (config[0] instanceof RegExp && typeof config[1] === "function") {
-			const fn = config[1];
-			return {
-				type: "dynamic",
-				rule: {
-					key: config[0].source,
-					stringPattern: config[0],
-					createResolved: async (match) => [await fn(match)].flat(1)
-				},
-				autocomplete: config[2] != null ? [config[2]].flat(1) : []
-			};
-		}
-		return;
-	}
-	if (typeof config.selector === "string" && typeof config.value !== "function") return {
-		type: "static",
-		rule: {
-			key: config.selector,
-			string: config.selector,
-			resolved: [config.value].flat(1)
-		},
-		autocomplete: [config.selector]
-	};
-	if (config.selector instanceof RegExp && typeof config.value === "function") {
-		const fn = config.value;
-		return {
-			type: "dynamic",
-			rule: {
-				key: config.selector.source,
-				stringPattern: config.selector,
-				createResolved: async (match) => [await fn(match)].flat(1)
-			},
-			autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
-		};
-	}
-}
-
-//#endregion
-//#region src/internal/plugins/shortcuts.ts
-function shortcuts() {
-	let engine;
-	let configList;
-	return defineEnginePlugin({
-		name: "core:shortcuts",
-		rawConfigConfigured(config) {
-			configList = config.shortcuts?.shortcuts ?? [];
-		},
-		configureEngine(_engine) {
-			engine = _engine;
-			engine.shortcuts = {
-				resolver: new ShortcutResolver(),
-				add: (...list) => {
-					list.forEach((config) => {
-						const resolved = resolveShortcutConfig(config);
-						if (resolved == null) return;
-						if (typeof resolved === "string") {
-							engine.appendAutocompleteStyleItemStrings(resolved);
-							return;
-						}
-						if (resolved.type === "static") engine.shortcuts.resolver.addStaticRule(resolved.rule);
-						else if (resolved.type === "dynamic") engine.shortcuts.resolver.addDynamicRule(resolved.rule);
-						engine.appendAutocompleteStyleItemStrings(...resolved.autocomplete);
-					});
-				}
-			};
-			engine.shortcuts.add(...configList);
-			engine.shortcuts.resolver.onResolved = (string, type) => {
-				if (type === "dynamic") engine.appendAutocompleteStyleItemStrings(string);
-			};
-			engine.appendAutocompleteExtraProperties("__shortcut");
-			const unionType = ["(string & {})", "Autocomplete['StyleItemString']"].join(" | ");
-			engine.appendAutocompletePropertyValues("__shortcut", unionType, `(${unionType})[]`);
-		},
-		async transformStyleItems(styleItems) {
-			const result = [];
-			for (const styleItem of styleItems) {
-				if (typeof styleItem === "string") {
-					result.push(...await engine.shortcuts.resolver.resolve(styleItem));
-					continue;
-				}
-				result.push(styleItem);
-			}
-			return result;
-		},
-		async transformStyleDefinitions(styleDefinitions) {
-			const result = [];
-			for (const styleDefinition of styleDefinitions) if ("__shortcut" in styleDefinition) {
-				const { __shortcut, ...rest } = styleDefinition;
-				const applied = [];
-				for (const shortcut of __shortcut == null ? [] : [__shortcut].flat(1)) {
-					const resolved = (await engine.shortcuts.resolver.resolve(shortcut)).filter(isNotString);
-					applied.push(...resolved);
-				}
-				result.push(...applied, rest);
-			} else result.push(styleDefinition);
-			return result;
-		}
-	});
-}
-var ShortcutResolver = class extends AbstractResolver {
-	async resolve(shortcut) {
-		const resolved = await this._resolve(shortcut).catch((error) => {
-			log.warn(`Failed to resolve shortcut "${shortcut}": ${error.message}`, error);
-		});
-		if (resolved == null) return [shortcut];
-		const result = [];
-		for (const partial of resolved.value) if (typeof partial === "string") result.push(...await this.resolve(partial));
-		else result.push(partial);
-		this._setResolvedResult(shortcut, result);
-		return result;
-	}
-};
-function resolveShortcutConfig(config) {
-	if (typeof config === "string") return config;
-	else if (Array.isArray(config)) {
-		if (typeof config[0] === "string" && typeof config[1] !== "function") return {
-			type: "static",
-			rule: {
-				key: config[0],
-				string: config[0],
-				resolved: [config[1]].flat(1)
-			},
-			autocomplete: [config[0]]
-		};
-		if (config[0] instanceof RegExp && typeof config[1] === "function") {
-			const fn = config[1];
-			return {
-				type: "dynamic",
-				rule: {
-					key: config[0].source,
-					stringPattern: config[0],
-					createResolved: async (match) => [await fn(match)].flat(1)
-				},
-				autocomplete: config[2] != null ? [config[2]].flat(1) : []
-			};
-		}
-	} else if (typeof config.shortcut === "string" && typeof config.value !== "function") return {
-		type: "static",
-		rule: {
-			key: config.shortcut,
-			string: config.shortcut,
-			resolved: [config.value].flat(1)
-		},
-		autocomplete: [config.shortcut]
-	};
-	else if (config.shortcut instanceof RegExp && typeof config.value === "function") {
-		const fn = config.value;
-		return {
-			type: "dynamic",
-			rule: {
-				key: config.shortcut.source,
-				stringPattern: config.shortcut,
-				createResolved: async (match) => [await fn(match)].flat(1)
-			},
-			autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
-		};
-	}
-}
-
-//#endregion
-//#region src/internal/plugins/variables.ts
-function variables() {
-	let resolveVariables;
-	let rawVariables;
-	let safeSet;
-	return defineEnginePlugin({
-		name: "core:variables",
-		rawConfigConfigured(config) {
-			resolveVariables = createResolveVariablesFn({ pruneUnused: config.variables?.pruneUnused });
-			rawVariables = [config.variables?.variables ?? []].flat();
-			safeSet = new Set(config.variables?.safeList ?? []);
-		},
-		configureEngine(engine) {
-			engine.variables = {
-				store: /* @__PURE__ */ new Map(),
-				add: (variables$1) => {
-					resolveVariables(variables$1).forEach((resolved) => {
-						const { name, value, autocomplete: { asValueOf, asProperty } } = resolved;
-						asValueOf.forEach((p) => {
-							if (p !== "-") engine.appendAutocompleteCssPropertyValues(p, `var(${name})`);
-						});
-						if (asProperty) engine.appendAutocompleteExtraCssProperties(name);
-						if (value != null) {
-							const list = engine.variables.store.get(name) ?? [];
-							list.push(resolved);
-							engine.variables.store.set(name, list);
-						}
-					});
-					engine.notifyPreflightUpdated();
-				}
-			};
-			rawVariables.forEach((variables$1) => engine.variables.add(variables$1));
-			engine.addPreflight(async (engine$1) => {
-				const used = /* @__PURE__ */ new Set();
-				engine$1.store.atomicStyles.forEach(({ content: { value } }) => {
-					value.flatMap(extractUsedVarNames).forEach((name) => used.add(normalizeVariableName(name)));
-				});
-				const usedVariables = Array.from(engine$1.variables.store.values()).flat().filter(({ name, pruneUnused, value }) => (safeSet.has(name) || pruneUnused === false || used.has(name)) && value != null);
-				const preflightDefinition = {};
-				for (const { name, value, selector: _selector } of usedVariables) {
-					const selector = await engine$1.pluginHooks.transformSelectors(engine$1.config.plugins, _selector);
-					let current = preflightDefinition;
-					selector.forEach((s) => {
-						current[s] ||= {};
-						current = current[s];
-					});
-					Object.assign(current, { [name]: value });
-				}
-				return preflightDefinition;
-			});
-		}
-	});
-}
-function createResolveVariablesFn({ pruneUnused: defaultPruneUnused = true } = {}) {
-	function _resolveVariables(variables$1, levels, result) {
-		for (const [key, value] of Object.entries(variables$1)) if (key.startsWith("--")) {
-			const { value: varValue, autocomplete = {}, pruneUnused = defaultPruneUnused } = typeof value === "object" && value !== null && !Array.isArray(value) ? value : { value };
-			result.push({
-				name: key,
-				value: varValue,
-				selector: levels.length > 0 ? levels : [":root"],
-				autocomplete: {
-					asValueOf: autocomplete.asValueOf ? [autocomplete.asValueOf].flat() : ["*"],
-					asProperty: autocomplete.asProperty ?? true
-				},
-				pruneUnused
-			});
-		} else _resolveVariables(value, [...levels, key], result);
-		return result;
-	}
-	return function resolveVariables(variables$1) {
-		return _resolveVariables(variables$1, [], []);
-	};
-}
-const VAR_NAME_RE = /var\((--[\w-]+)/g;
-function extractUsedVarNames(input) {
-	const matched = input.match(VAR_NAME_RE);
-	if (!matched) return [];
-	return matched.map((match) => {
-		const varNameMatch = match.match(/--[^,)]+/);
-		return varNameMatch ? varNameMatch[0] : "";
-	}).filter(Boolean);
-}
-function normalizeVariableName(name) {
-	if (name.startsWith("--")) return name;
-	return `--${name}`;
-}
-
-//#endregion
-//#region src/internal/engine.ts
-const DEFAULT_PREFLIGHTS_LAYER = "preflights";
-const DEFAULT_UTILITIES_LAYER = "utilities";
-const DEFAULT_LAYERS = {
-	[DEFAULT_PREFLIGHTS_LAYER]: 1,
-	[DEFAULT_UTILITIES_LAYER]: 10
-};
-async function createEngine(config = {}) {
-	log.debug("Creating engine with config:", config);
-	const corePlugins = [
-		important(),
-		variables(),
-		keyframes(),
-		selectors(),
-		shortcuts()
-	];
-	log.debug("Core plugins loaded:", corePlugins.length);
-	const plugins = resolvePlugins([...corePlugins, ...config.plugins || []]);
-	config.plugins = plugins;
-	log.debug(`Total plugins resolved: ${plugins.length}`);
-	config = await hooks.configureRawConfig(config.plugins, config);
-	hooks.rawConfigConfigured(resolvePlugins(config.plugins || []), config);
-	let resolvedConfig = await resolveEngineConfig(config);
-	log.debug("Engine config resolved with prefix:", resolvedConfig.prefix);
-	resolvedConfig = await hooks.configureResolvedConfig(resolvedConfig.plugins, resolvedConfig);
-	let engine = new Engine(resolvedConfig);
-	engine.appendAutocompleteExtraProperties("__layer");
-	engine.appendAutocompletePropertyValues("__layer", "Autocomplete['Layer']");
-	log.debug("Engine instance created");
-	engine = await hooks.configureEngine(engine.config.plugins, engine);
-	log.debug("Engine initialized successfully");
-	return engine;
-}
-var Engine = class {
-	config;
-	pluginHooks = hooks;
-	extract;
-	store = {
-		atomicStyleIds: /* @__PURE__ */ new Map(),
-		atomicStyles: /* @__PURE__ */ new Map()
-	};
-	constructor(config) {
-		this.config = config;
-		this.extract = createExtractFn({
-			defaultSelector: this.config.defaultSelector,
-			transformSelectors: (selectors$1) => hooks.transformSelectors(this.config.plugins, selectors$1),
-			transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
-			transformStyleDefinitions: (styleDefinitions) => hooks.transformStyleDefinitions(this.config.plugins, styleDefinitions)
-		});
-	}
-	notifyPreflightUpdated() {
-		hooks.preflightUpdated(this.config.plugins);
-	}
-	notifyAtomicStyleAdded(atomicStyle) {
-		hooks.atomicStyleAdded(this.config.plugins, atomicStyle);
-	}
-	notifyAutocompleteConfigUpdated() {
-		hooks.autocompleteConfigUpdated(this.config.plugins);
-	}
-	appendAutocompleteSelectors(...selectors$1) {
-		appendAutocompleteSelectors(this.config, ...selectors$1);
-		this.notifyAutocompleteConfigUpdated();
-	}
-	appendAutocompleteStyleItemStrings(...styleItemStrings) {
-		appendAutocompleteStyleItemStrings(this.config, ...styleItemStrings);
-		this.notifyAutocompleteConfigUpdated();
-	}
-	appendAutocompleteExtraProperties(...properties) {
-		appendAutocompleteExtraProperties(this.config, ...properties);
-		this.notifyAutocompleteConfigUpdated();
-	}
-	appendAutocompleteExtraCssProperties(...properties) {
-		appendAutocompleteExtraCssProperties(this.config, ...properties);
-		this.notifyAutocompleteConfigUpdated();
-	}
-	appendAutocompletePropertyValues(property, ...tsTypes) {
-		appendAutocompletePropertyValues(this.config, property, ...tsTypes);
-		this.notifyAutocompleteConfigUpdated();
-	}
-	appendAutocompleteCssPropertyValues(property, ...values) {
-		appendAutocompleteCssPropertyValues(this.config, property, ...values);
-		this.notifyAutocompleteConfigUpdated();
-	}
-	addPreflight(preflight) {
-		log.debug("Adding preflight");
-		this.config.preflights.push(resolvePreflight(preflight));
-		log.debug(`Total preflights: ${this.config.preflights.length}`);
-		this.notifyPreflightUpdated();
-	}
-	async use(...itemList) {
-		log.debug(`Processing ${itemList.length} style items`);
-		const { unknown, contents } = await resolveStyleItemList({
-			itemList,
-			transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
-			extractStyleDefinition: (styleDefinition) => this.extract(styleDefinition)
-		});
-		const resolvedIds = [];
-		contents.forEach((content) => {
-			const id = getAtomicStyleId({
-				content,
-				prefix: this.config.prefix,
-				stored: this.store.atomicStyleIds
-			});
-			resolvedIds.push(id);
-			if (!this.store.atomicStyles.has(id)) {
-				const atomicStyle = {
-					id,
-					content
-				};
-				this.store.atomicStyles.set(id, atomicStyle);
-				log.debug(`Atomic style added: ${id}`);
-				this.notifyAtomicStyleAdded(atomicStyle);
-			}
-		});
-		log.debug(`Resolved ${resolvedIds.length} atomic styles, ${unknown.size} unknown items`);
-		return [...unknown, ...resolvedIds];
-	}
-	async renderPreflights(isFormatted) {
-		log.debug("Rendering preflights...");
-		const lineEnd = isFormatted ? "\n" : "";
-		const rendered = await Promise.all(this.config.preflights.map(async ({ layer, fn }) => {
-			const result = await fn(this, isFormatted);
-			return {
-				layer,
-				css: typeof result === "string" ? result : await renderPreflightDefinition({
-					engine: this,
-					preflightDefinition: result,
-					isFormatted
-				})
-			};
-		}));
-		log.debug(`Rendered ${rendered.length} preflights`);
-		const unlayeredParts = [];
-		const layerGroups = /* @__PURE__ */ new Map();
-		for (const { layer, css } of rendered) if (layer == null) unlayeredParts.push(css);
-		else {
-			if (!layerGroups.has(layer)) layerGroups.set(layer, []);
-			layerGroups.get(layer).push(css);
-		}
-		const outputParts = [];
-		if (unlayeredParts.length > 0) {
-			const unlayeredContent = unlayeredParts.join(lineEnd);
-			const { defaultPreflightsLayer } = this.config;
-			if (defaultPreflightsLayer in this.config.layers) outputParts.push(`@layer ${defaultPreflightsLayer} {${lineEnd}${unlayeredContent}${lineEnd}}`);
-			else outputParts.push(unlayeredContent);
-		}
-		const configLayerOrder = sortLayerNames(this.config.layers);
-		const orderedLayerNames = [...configLayerOrder.filter((name) => layerGroups.has(name)), ...[...layerGroups.keys()].filter((name) => !configLayerOrder.includes(name))];
-		for (const layerName of orderedLayerNames) {
-			const content = layerGroups.get(layerName).join(lineEnd);
-			outputParts.push(`@layer ${layerName} {${lineEnd}${content}${lineEnd}}`);
-		}
-		return outputParts.join(lineEnd);
-	}
-	async renderAtomicStyles(isFormatted, options = {}) {
-		log.debug("Rendering atomic styles...");
-		const { atomicStyleIds = null, isPreview = false } = options;
-		const atomicStyles = atomicStyleIds == null ? [...this.store.atomicStyles.values()] : atomicStyleIds.map((id) => this.store.atomicStyles.get(id)).filter(isNotNullish);
-		log.debug(`Rendering ${atomicStyles.length} atomic styles (preview: ${isPreview})`);
-		return renderAtomicStyles({
-			atomicStyles,
-			isPreview,
-			isFormatted,
-			defaultSelector: this.config.defaultSelector,
-			layers: this.config.layers,
-			defaultUtilitiesLayer: this.config.defaultUtilitiesLayer
-		});
-	}
-	renderLayerOrderDeclaration() {
-		const { layers } = this.config;
-		if (Object.keys(layers).length === 0) return "";
-		return `@layer ${sortLayerNames(layers).join(", ")};`;
-	}
-};
-function calcAtomicStyleRenderingWeight(style, defaultSelector) {
-	const { selector } = style.content;
-	return selector.length === 1 && selector[0] === defaultSelector ? 0 : selector.length;
-}
-function sortLayerNames(layers) {
-	return Object.entries(layers).sort((a, b) => a[1] - b[1] || a[0].localeCompare(b[0])).map(([name]) => name);
-}
-function isWithLayer(p) {
-	if (typeof p !== "object" || p === null) return false;
-	const record = p;
-	return typeof record.layer === "string" && "preflight" in record;
-}
-function resolvePreflight(preflight) {
-	if (isWithLayer(preflight)) {
-		const inner = preflight.preflight;
-		const fn = typeof inner === "function" ? inner : () => inner;
-		return {
-			layer: preflight.layer,
-			fn
-		};
-	}
-	return { fn: typeof preflight === "function" ? preflight : () => preflight };
-}
-async function resolveEngineConfig(config) {
-	const { prefix = "", defaultSelector = `.${ATOMIC_STYLE_ID_PLACEHOLDER}`, plugins = [], preflights = [] } = config;
-	const layers = Object.assign({}, DEFAULT_LAYERS, config.layers);
-	const defaultPreflightsLayer = config.defaultPreflightsLayer ?? DEFAULT_PREFLIGHTS_LAYER;
-	const defaultUtilitiesLayer = config.defaultUtilitiesLayer ?? DEFAULT_UTILITIES_LAYER;
-	log.debug(`Resolving engine config with prefix: "${prefix}", plugins: ${plugins.length}, preflights: ${preflights.length}`);
-	const resolvedConfig = {
-		rawConfig: config,
-		plugins: resolvePlugins(plugins),
-		prefix,
-		defaultSelector,
-		preflights: [],
-		layers,
-		defaultPreflightsLayer,
-		defaultUtilitiesLayer,
-		autocomplete: {
-			selectors: /* @__PURE__ */ new Set(),
-			styleItemStrings: /* @__PURE__ */ new Set(),
-			extraProperties: /* @__PURE__ */ new Set(),
-			extraCssProperties: /* @__PURE__ */ new Set(),
-			properties: /* @__PURE__ */ new Map(),
-			cssProperties: /* @__PURE__ */ new Map()
-		}
-	};
-	const resolvedPreflights = preflights.map(resolvePreflight);
-	resolvedConfig.preflights.push(...resolvedPreflights);
-	log.debug(`Engine config resolved: ${resolvedPreflights.length} preflights processed`);
-	return resolvedConfig;
-}
-function getAtomicStyleId({ content, prefix, stored }) {
-	const key = serialize([
-		content.selector,
-		content.property,
-		content.value,
-		content.layer
-	]);
-	const cached = stored.get(key);
-	if (cached != null) {
-		log.debug(`Atomic style cached: ${cached}`);
-		return cached;
-	}
-	const num = stored.size;
-	const id = `${prefix}${numberToChars(num)}`;
-	stored.set(key, id);
-	log.debug(`Generated new atomic style ID: ${id}`);
-	return id;
-}
-function optimizeAtomicStyleContents(list) {
-	const map = /* @__PURE__ */ new Map();
-	list.forEach((content) => {
-		const key = serialize([
-			content.selector,
-			content.property,
-			content.layer
-		]);
-		map.delete(key);
-		if (content.value == null) return;
-		map.set(key, { ...content });
-	});
-	return [...map.values()];
-}
-function extractLayerFromStyleItem(item) {
-	const record = item;
-	const layer = typeof record.__layer === "string" ? record.__layer : void 0;
-	if (layer == null) return {
-		layer: void 0,
-		definition: item
-	};
-	const { __layer: _, ...rest } = record;
-	return {
-		layer,
-		definition: rest
-	};
-}
-async function resolveStyleItemList({ itemList, transformStyleItems, extractStyleDefinition }) {
-	const unknown = /* @__PURE__ */ new Set();
-	const list = [];
-	for (const styleItem of await transformStyleItems(itemList)) if (typeof styleItem === "string") unknown.add(styleItem);
-	else {
-		const { layer, definition } = extractLayerFromStyleItem(styleItem);
-		const extracted = await extractStyleDefinition(definition);
-		if (layer != null) extracted.forEach((c) => c.layer = layer);
-		list.push(...extracted);
-	}
-	return {
-		unknown,
-		contents: optimizeAtomicStyleContents(list)
-	};
-}
-function sortAtomicStyles(styles, defaultSelector) {
-	return [...styles].sort((a, b) => calcAtomicStyleRenderingWeight(a, defaultSelector) - calcAtomicStyleRenderingWeight(b, defaultSelector));
-}
-function renderAtomicStylesCss({ atomicStyles, isPreview, isFormatted }) {
-	const blocks = /* @__PURE__ */ new Map();
-	atomicStyles.forEach(({ id, content: { selector, property, value } }) => {
-		if (selector.some((s) => s.includes(ATOMIC_STYLE_ID_PLACEHOLDER)) === false || value == null) return;
-		const renderObject = {
-			selector: isPreview ? selector : selector.map((s) => s.replace(ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL, id)),
-			properties: value.map((v) => ({
-				property,
-				value: v
-			}))
-		};
-		let currentBlocks = blocks;
-		for (let i = 0; i < renderObject.selector.length; i++) {
-			const s = renderObject.selector[i];
-			const blockBody = currentBlocks.get(s) || { properties: [] };
-			const isLastSelector = i === renderObject.selector.length - 1;
-			if (isLastSelector) blockBody.properties.push(...renderObject.properties);
-			else blockBody.children ||= /* @__PURE__ */ new Map();
-			currentBlocks.set(s, blockBody);
-			if (isLastSelector === false) currentBlocks = blockBody.children;
-		}
-	});
-	return renderCSSStyleBlocks(blocks, isFormatted);
-}
-function renderAtomicStyles(payload) {
-	const { atomicStyles, isPreview, isFormatted, defaultSelector, layers, defaultUtilitiesLayer } = payload;
-	const sortedStyles = sortAtomicStyles(atomicStyles, defaultSelector);
-	if (layers == null) return renderAtomicStylesCss({
-		atomicStyles: sortedStyles,
-		isPreview,
-		isFormatted
-	});
-	const layerOrder = sortLayerNames(layers);
-	const lineEnd = isFormatted ? "\n" : "";
-	const unlayeredStyles = [];
-	const layerGroups = new Map(layerOrder.map((name) => [name, []]));
-	const candidateDefaultLayer = defaultUtilitiesLayer ?? layerOrder[layerOrder.length - 1];
-	const defaultLayer = candidateDefaultLayer != null && layerGroups.has(candidateDefaultLayer) ? candidateDefaultLayer : layerOrder[layerOrder.length - 1];
-	for (const style of sortedStyles) {
-		const layer = style.content.layer;
-		if (layer != null && layerGroups.has(layer)) layerGroups.get(layer).push(style);
-		else if (layer != null) {
-			log.warn(`Unknown layer "${layer}" encountered in atomic style; falling back to unlayered output.`);
-			unlayeredStyles.push(style);
-		} else if (defaultLayer != null) layerGroups.get(defaultLayer).push(style);
-		else unlayeredStyles.push(style);
-	}
-	const parts = [];
-	if (unlayeredStyles.length > 0) parts.push(renderAtomicStylesCss({
-		atomicStyles: unlayeredStyles,
-		isPreview,
-		isFormatted
-	}));
-	for (const layerName of layerOrder) {
-		const styles = layerGroups.get(layerName);
-		if (styles.length === 0) continue;
-		const innerCss = renderAtomicStylesCss({
-			atomicStyles: styles,
-			isPreview,
-			isFormatted
-		});
-		parts.push(`@layer ${layerName} {${lineEnd}${innerCss}${lineEnd}}`);
-	}
-	return parts.join(lineEnd);
-}
-async function _renderPreflightDefinition({ engine, preflightDefinition, blocks = /* @__PURE__ */ new Map() }) {
-	for (const [selector, propertiesOrDefinition] of Object.entries(preflightDefinition)) {
-		if (propertiesOrDefinition == null) continue;
-		const selectors$1 = normalizeSelectors({
-			selectors: await hooks.transformSelectors(engine.config.plugins, [selector]),
-			defaultSelector: ""
-		}).filter(Boolean);
-		let currentBlocks = blocks;
-		let currentBlockBody = null;
-		selectors$1.forEach((s, i) => {
-			const isLast = i === selectors$1.length - 1;
-			currentBlocks.set(s, currentBlocks.get(s) || { properties: [] });
-			if (isLast) {
-				currentBlockBody = currentBlocks.get(s);
-				return;
-			}
-			currentBlocks = currentBlocks.get(s).children ||= /* @__PURE__ */ new Map();
-		});
-		for (const [k, v] of Object.entries(propertiesOrDefinition)) if (isPropertyValue(v)) {
-			const property = toKebab(k);
-			const normalizedValue = normalizeValue(v);
-			if (normalizedValue != null) normalizedValue.forEach((value) => currentBlockBody.properties.push({
-				property,
-				value
-			}));
-		} else {
-			currentBlockBody.children ||= /* @__PURE__ */ new Map();
-			currentBlockBody.children.set(k, currentBlockBody.children.get(k) || { properties: [] });
-			await _renderPreflightDefinition({
-				engine,
-				preflightDefinition: { [k]: v },
-				blocks: currentBlockBody.children
-			});
-		}
-	}
-	return blocks;
-}
-async function renderPreflightDefinition(payload) {
-	const { engine, preflightDefinition, isFormatted } = payload;
-	return renderCSSStyleBlocks(await _renderPreflightDefinition({
-		engine,
-		preflightDefinition
-	}), isFormatted);
-}
-
-//#endregion
-//#region src/index.ts
-function defineEngineConfig(config) {
-	return config;
-}
-function defineStyleDefinition(styleDefinition) {
-	return styleDefinition;
-}
-function definePreflight(preflight) {
-	return preflight;
-}
-function defineKeyframes(keyframes$1) {
-	return keyframes$1;
-}
-function defineSelector(selector) {
-	return selector;
-}
-function defineShortcut(shortcut) {
-	return shortcut;
-}
-function defineVariables(variables$1) {
-	return variables$1;
-}
-/* c8 ignore end */
-
-//#endregion
-exports.appendAutocompleteCssPropertyValues = appendAutocompleteCssPropertyValues;
-exports.appendAutocompleteExtraCssProperties = appendAutocompleteExtraCssProperties;
-exports.appendAutocompleteExtraProperties = appendAutocompleteExtraProperties;
-exports.appendAutocompletePropertyValues = appendAutocompletePropertyValues;
-exports.appendAutocompleteSelectors = appendAutocompleteSelectors;
-exports.appendAutocompleteStyleItemStrings = appendAutocompleteStyleItemStrings;
-exports.createEngine = createEngine;
-exports.createLogger = createLogger;
-exports.defineEngineConfig = defineEngineConfig;
-exports.defineEnginePlugin = defineEnginePlugin;
-exports.defineKeyframes = defineKeyframes;
-exports.definePreflight = definePreflight;
-exports.defineSelector = defineSelector;
-exports.defineShortcut = defineShortcut;
-exports.defineStyleDefinition = defineStyleDefinition;
-exports.defineVariables = defineVariables;
-exports.log = log;
-exports.renderCSSStyleBlocks = renderCSSStyleBlocks;
-exports.sortLayerNames = sortLayerNames;