@master/css-compiler 2.0.0-rc.72 → 2.0.0-rc.74

package/dist/master-css-manifest.d.ts

@@ -1,14 +1,20 @@
-import type { CSSDirectiveManifestInput as SharedCSSDirectiveManifestInput, CSSDirectiveVariableDefinition } from '@master/css-schema/css-directives';
-import type { MasterCSSManifest } from '@master/css-schema/manifest';
-export type CSSDirectiveManifestInput = SharedCSSDirectiveManifestInput;
-export interface CreateMasterCSSManifestOptions {
-    baseManifest?: MasterCSSManifest;
+import { CSSDirectiveManifestInput as CSSDirectiveManifestInput$1, CSSDirectiveVariableDefinition } from "@master/css-schema/css-directives";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { CompilerDiagnosticRecorder } from "./diagnostics.js";
+
+//#region src/master-css-manifest.d.ts
+type CSSDirectiveManifestInput = CSSDirectiveManifestInput$1;
+interface CreateMasterCSSManifestOptions {
+  baseManifest?: MasterCSSManifest;
+  diagnostics?: CompilerDiagnosticRecorder;
 }
-export interface ResolvedCSSDirectiveVariableName {
-    name: string;
-    key: string;
-    namespace?: string;
+interface ResolvedCSSDirectiveVariableName {
+  name: string;
+  key: string;
+  namespace?: string;
 }
-export type CSSDirectiveVariableNameResolver = (variable: CSSDirectiveVariableDefinition) => ResolvedCSSDirectiveVariableName;
-export declare function createVariableNameResolver(input?: CSSDirectiveManifestInput, options?: CreateMasterCSSManifestOptions): CSSDirectiveVariableNameResolver;
-export declare function createMasterCSSManifest(input?: CSSDirectiveManifestInput, options?: CreateMasterCSSManifestOptions): MasterCSSManifest;
+type CSSDirectiveVariableNameResolver = (variable: CSSDirectiveVariableDefinition) => ResolvedCSSDirectiveVariableName;
+declare function createVariableNameResolver(input?: CSSDirectiveManifestInput, options?: CreateMasterCSSManifestOptions): CSSDirectiveVariableNameResolver;
+declare function createMasterCSSManifest(input?: CSSDirectiveManifestInput, options?: CreateMasterCSSManifestOptions): MasterCSSManifest;
+//#endregion
+export { CSSDirectiveManifestInput, CSSDirectiveVariableNameResolver, CreateMasterCSSManifestOptions, ResolvedCSSDirectiveVariableName, createMasterCSSManifest, createVariableNameResolver };

package/dist/master-css-manifest.js

@@ -0,0 +1,546 @@
+import { addCompilerDiagnosticCount, setCompilerDiagnosticCount, timeCompilerDiagnostic } from "./diagnostics.js";
+import { createCompilerCSS, parseAt, parseSelector } from "@master/css-engine/compiler";
+import UtilityType from "@master/css-schema/utility-type";
+import { flattenMasterCSSManifestVariables, groupMasterCSSManifestVariables } from "@master/css-schema/manifest";
+import { builtinNamespaces } from "@master/css-engine";
+import { isNativeCSSShorthandProperty } from "@master/css-schema/native-css-shorthand";
+//#region src/master-css-manifest.ts
+const NUMERIC_THEME_NAMESPACES = /* @__PURE__ */ new Set([
+	"font-size",
+	"radius",
+	"spacing",
+	"breakpoint",
+	"container"
+]);
+const UNITFUL_NUMERIC_TOKEN = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(px|rem)?$/;
+function clone(value) {
+	if (Array.isArray(value)) return value.map((item) => clone(item));
+	if (value && typeof value === "object") {
+		const result = {};
+		for (const key in value) result[key] = clone(value[key]);
+		return result;
+	}
+	return value;
+}
+function normalizeZero(value) {
+	return Object.is(value, -0) ? 0 : value;
+}
+function addVariableNamespace(namespaces, namespace) {
+	if (typeof namespace === "string" && namespace) namespaces.add(namespace);
+}
+function addVariableAliasRefNamespace(namespaces, ref) {
+	if (typeof ref === "string" && (ref[0] === "=" || ref[0] === "~")) addVariableNamespace(namespaces, ref.slice(1));
+}
+function addImplicitUtilityNamespace(namespaces, value) {
+	if (typeof value !== "string" || !value || value[0] === "." || value.includes("()")) return;
+	addVariableNamespace(namespaces, value);
+}
+function addUtilityVariableNamespaces(namespaces, utilities) {
+	for (const utility of utilities || []) {
+		for (const namespace of utility.namespaces || []) addVariableNamespace(namespaces, namespace);
+		for (const ref of utility.variableAliasRefs || []) addVariableAliasRefNamespace(namespaces, ref);
+		if (utility.implicitNamespace !== false && utility.emit?.type === "property") {
+			addImplicitUtilityNamespace(namespaces, utility.id);
+			addImplicitUtilityNamespace(namespaces, utility.name);
+		}
+	}
+}
+function collectVariableNamespaces(input = {}, options = {}) {
+	const namespaces = new Set(builtinNamespaces);
+	for (const variable of flattenMasterCSSManifestVariables(options.baseManifest?.variables)) addVariableNamespace(namespaces, variable.namespace);
+	for (const variable of input.variables || []) addVariableNamespace(namespaces, variable.namespace);
+	addUtilityVariableNamespaces(namespaces, options.baseManifest?.utilities);
+	addUtilityVariableNamespaces(namespaces, input.utilities);
+	return [...namespaces].sort((a, b) => b.length - a.length || a.localeCompare(b));
+}
+function resolveVariableName(variable, namespaces) {
+	const explicitName = variable.name?.replace(/^--/, "");
+	if (variable.namespace || variable.key !== void 0) {
+		const key = variable.key ?? explicitName ?? "";
+		return {
+			name: variable.namespace ? `${variable.namespace}${key ? "-" + key : ""}` : key,
+			key,
+			...variable.namespace ? { namespace: variable.namespace } : {}
+		};
+	}
+	const name = explicitName || "";
+	const namespace = namespaces.find((eachNamespace) => name.startsWith(eachNamespace + "-"));
+	return namespace ? {
+		name,
+		namespace,
+		key: name.slice(namespace.length + 1)
+	} : {
+		name,
+		key: name
+	};
+}
+function createVariableNameResolver(input = {}, options = {}) {
+	const namespaces = collectVariableNamespaces(input, options);
+	return (variable) => resolveVariableName(variable, namespaces);
+}
+function getVariableType(value) {
+	return typeof value === "number" ? "number" : "string";
+}
+function getVariableNumericValue(value, namespace) {
+	if (!namespace || !NUMERIC_THEME_NAMESPACES.has(namespace)) return;
+	if (typeof value === "number") return { value };
+	if (typeof value !== "string") return;
+	const match = UNITFUL_NUMERIC_TOKEN.exec(value.trim());
+	if (!match) return;
+	return {
+		value: Number(match[1]),
+		...match[2] ? { unit: match[2] } : {}
+	};
+}
+function collectVariableDependencies(value, dependencies = /* @__PURE__ */ new Set()) {
+	if (typeof value !== "string") return dependencies;
+	for (const match of value.matchAll(/\$(-?[_a-zA-Z0-9-]+)/g)) dependencies.add(match[1]);
+	for (const match of value.matchAll(/var\(\s*--(-?[_a-zA-Z0-9-]+)/g)) dependencies.add(match[1]);
+	return dependencies;
+}
+function variableSlot(variable) {
+	return variable.name || `${variable.namespace || ""}\0${variable.key}`;
+}
+function pushVariable(target, variable) {
+	const slot = variableSlot(variable);
+	const existing = target.find((eachVariable) => variableSlot(eachVariable) === slot);
+	if (existing) Object.assign(existing, variable);
+	else target.push(variable);
+}
+function compileVariables(input, resolveVariableName) {
+	if (!input?.length) return;
+	const variables = [];
+	const byName = /* @__PURE__ */ new Map();
+	for (const definition of input) {
+		const resolved = resolveVariableName(definition);
+		if (!resolved.name) continue;
+		const value = normalizeZero(definition.value);
+		const numeric = getVariableNumericValue(value, resolved.namespace);
+		const type = numeric ? "number" : getVariableType(value);
+		const dependencies = collectVariableDependencies(value);
+		if (definition.mode) {
+			let target = byName.get(resolved.name);
+			if (!target) {
+				target = {
+					name: resolved.name,
+					key: resolved.key,
+					...resolved.namespace ? { namespace: resolved.namespace } : {},
+					type,
+					modes: {},
+					...definition.static ? { static: true } : {}
+				};
+				byName.set(resolved.name, target);
+				pushVariable(variables, target);
+			}
+			if (definition.static) target.static = true;
+			target.modes ??= {};
+			target.modes[definition.mode] = {
+				type,
+				value,
+				...numeric ? { numeric } : {}
+			};
+			if (dependencies.size) {
+				const next = /* @__PURE__ */ new Set([...target.dependencies || [], ...dependencies]);
+				target.dependencies = [...next];
+			}
+			continue;
+		}
+		const variable = {
+			name: resolved.name,
+			key: resolved.key,
+			...resolved.namespace ? { namespace: resolved.namespace } : {},
+			type,
+			value,
+			...numeric ? { numeric } : {},
+			...dependencies.size ? { dependencies: [...dependencies] } : {},
+			...definition.inline ? { inline: true } : {},
+			...definition.static ? { static: true } : {}
+		};
+		byName.set(resolved.name, variable);
+		pushVariable(variables, variable);
+	}
+	return variables.length ? variables : void 0;
+}
+function normalizeNumericAtRuleValue(variable, rootSize) {
+	if (variable.key.startsWith("-")) return;
+	const numeric = variable.numeric || (typeof variable.value === "number" ? { value: variable.value } : void 0);
+	if (!numeric) return;
+	switch (numeric.unit) {
+		case void 0:
+		case "":
+		case "px": return numeric.value / rootSize;
+		case "rem": return numeric.value;
+		default: return;
+	}
+}
+function createVariableAtRule(variable, id, rootSize) {
+	const value = normalizeNumericAtRuleValue(variable, rootSize);
+	if (value === void 0) return;
+	return {
+		id,
+		nodes: [{
+			type: "number",
+			value,
+			unit: "rem"
+		}]
+	};
+}
+function compileAtRules(variables, rootSize) {
+	const atRules = {};
+	const breakpointAtRules = {};
+	const containerAtRules = {};
+	for (const variable of variables || []) if (variable.namespace === "breakpoint") {
+		const atRule = createVariableAtRule(variable, "media", rootSize);
+		if (atRule) {
+			atRules[variable.key] = atRule;
+			breakpointAtRules[variable.key] = atRule;
+		}
+	} else if (variable.namespace === "container") {
+		const atRule = createVariableAtRule(variable, "container", rootSize);
+		if (atRule) containerAtRules[variable.key] = atRule;
+	}
+	return {
+		atRules: Object.keys(atRules).length ? atRules : void 0,
+		breakpointAtRules: Object.keys(breakpointAtRules).length ? breakpointAtRules : void 0,
+		containerAtRules: Object.keys(containerAtRules).length ? containerAtRules : void 0
+	};
+}
+function cloneAtRuleNode(node) {
+	return "children" in node ? {
+		...node,
+		children: node.children.map(cloneAtRuleNode)
+	} : { ...node };
+}
+function cloneAtRule(atRule) {
+	return {
+		id: atRule.id,
+		nodes: atRule.nodes.map(cloneAtRuleNode)
+	};
+}
+function cloneSelectorNode(node) {
+	return "children" in node && node.children?.length ? {
+		...node,
+		children: node.children.map(cloneSelectorNode)
+	} : { ...node };
+}
+function compileVariantBranch(branch, css) {
+	const selector = branch.selector?.trim();
+	const bodylessSelector = selector ? selector.includes("&") ? selector.replace(/&/g, "") : selector : void 0;
+	const selectorNodes = branch.selectorNodes?.length ? branch.selectorNodes.map(cloneSelectorNode) : bodylessSelector ? parseSelector(bodylessSelector, css, false).map((node) => cloneSelectorNode(node)) : void 0;
+	const atRuleNodes = branch.atRuleNodes?.length ? branch.atRuleNodes.map(cloneAtRule) : branch.atRules?.length ? branch.atRules.map((atRule) => cloneAtRule(parseAt(atRule, css, false))) : void 0;
+	return {
+		...branch,
+		...selectorNodes?.length ? { selectorNodes } : {},
+		...branch.atRules?.length ? { atRules: [...branch.atRules] } : {},
+		...atRuleNodes?.length ? { atRuleNodes } : {}
+	};
+}
+function compileVariants(input, baseManifest) {
+	if (!input?.length) return {};
+	const css = createCompilerCSS(baseManifest);
+	const variants = [];
+	const selectors = {};
+	const atRules = {};
+	for (const variant of input) {
+		const branches = variant.branches.map((branch) => compileVariantBranch(branch, css));
+		variants.push({
+			token: variant.token,
+			branches
+		});
+		if (variant.token.startsWith(":")) {
+			const firstSelectorNodes = branches.find((branch) => branch.selectorNodes?.length)?.selectorNodes;
+			if (firstSelectorNodes?.length) selectors[variant.token] = firstSelectorNodes.map(cloneSelectorNode);
+		}
+		if (variant.token.startsWith("@")) {
+			const firstAtRule = branches.find((branch) => branch.atRuleNodes?.length)?.atRuleNodes?.[0];
+			if (firstAtRule) atRules[variant.token.slice(1)] = cloneAtRule(firstAtRule);
+			else {
+				const firstLayer = branches.find((branch) => branch.layer)?.layer;
+				if (firstLayer) atRules[variant.token.slice(1)] = {
+					id: "layer",
+					nodes: [{
+						type: "string",
+						value: firstLayer
+					}]
+				};
+			}
+		}
+	}
+	return {
+		variants,
+		...Object.keys(selectors).length ? { selectors } : {},
+		...Object.keys(atRules).length ? { atRules } : {}
+	};
+}
+function cloneDeclarations(declarations) {
+	return Array.isArray(declarations) ? [...declarations] : { ...declarations };
+}
+function assertNoValuePlaceholder(declarations) {
+	for (const property in declarations) if (declarations[property].includes("--value")) throw new Error("--value() is only supported inside managed pattern declarations");
+}
+function compileUtilityRule(rule) {
+	assertNoValuePlaceholder(rule.declarations);
+	return {
+		declarations: cloneDeclarations(rule.declarations),
+		...rule.atRules?.length ? { atRules: [...rule.atRules] } : {},
+		...rule.selector && rule.selector !== "&" ? { selector: rule.selector } : {}
+	};
+}
+const VALUE_PLACEHOLDER_FUNCTION = "--value()";
+const VALUE_PLACEHOLDER_CALL = /--value\s*\(([^)]*)\)/g;
+function compilePatternDeclarationValue(value) {
+	if (!value.includes("--value")) return value;
+	const parts = [];
+	let lastIndex = 0;
+	let matched = false;
+	VALUE_PLACEHOLDER_CALL.lastIndex = 0;
+	for (const match of value.matchAll(VALUE_PLACEHOLDER_CALL)) {
+		matched = true;
+		if (match[1].trim()) throw new Error("--value() does not accept arguments");
+		if (match.index > lastIndex) parts.push(value.slice(lastIndex, match.index));
+		parts.push(null);
+		lastIndex = match.index + match[0].length;
+	}
+	if (!matched || value.slice(lastIndex).includes("--value")) throw new Error("--value() must be called as --value()");
+	if (lastIndex < value.length) parts.push(value.slice(lastIndex));
+	return value === VALUE_PLACEHOLDER_FUNCTION ? null : parts;
+}
+function compilePatternDeclarations(declarations) {
+	const compiled = {};
+	for (const property in declarations) compiled[property] = compilePatternDeclarationValue(declarations[property]);
+	return compiled;
+}
+function compilePatternUtilityRule(rule) {
+	return {
+		declarations: compilePatternDeclarations(rule.declarations),
+		...rule.atRules?.length ? { atRules: [...rule.atRules] } : {},
+		...rule.selector && rule.selector !== "&" ? { selector: rule.selector } : {}
+	};
+}
+function declarationValueUsesPlaceholder(value) {
+	return value === null || Array.isArray(value) && value.includes(null);
+}
+function countValuePlaceholderProperties(declarations) {
+	let count = 0;
+	const declarationMap = declarations;
+	for (const property in declarationMap) if (declarationValueUsesPlaceholder(declarationMap[property])) count++;
+	return count;
+}
+function utilityTypeFromRules(rules) {
+	return rules.some(({ declarations }) => {
+		return Object.keys(declarations).some((property) => isNativeCSSShorthandProperty(property)) || countValuePlaceholderProperties(declarations) > 1;
+	}) ? UtilityType.Shorthand : UtilityType.Normal;
+}
+function getPatternMatcher(pattern) {
+	return {
+		type: "pattern",
+		prefix: pattern.prefix,
+		values: [...pattern.values]
+	};
+}
+function getDynamicMatchers(dynamic) {
+	const matchers = [];
+	if (dynamic.variableAliasRefs?.length) matchers.push({
+		type: "variable",
+		keys: [dynamic.key]
+	});
+	if (dynamic.kind) matchers.push({
+		type: "value",
+		keys: [dynamic.key]
+	});
+	if (dynamic.arbitrary) matchers.push({
+		type: "key",
+		keys: [dynamic.key]
+	});
+	if (dynamic.values?.length) matchers.push({
+		type: "pattern",
+		prefix: dynamic.key + ":",
+		values: [...dynamic.values]
+	});
+	if (!matchers.length) throw new Error("Managed dynamic utility definition must include at least one value source");
+	return matchers;
+}
+function compileUtility(definition, order) {
+	if (definition.type === "pattern") {
+		if (!definition.pattern) throw new Error("Managed enum pattern definition is missing a pattern");
+		const rules = [];
+		if (definition.declarations) rules.push({
+			declarations: compilePatternDeclarations(definition.declarations),
+			...definition.atRules?.length ? { atRules: [...definition.atRules] } : {}
+		});
+		if (definition.rules?.length) rules.push(...definition.rules.map(compilePatternUtilityRule));
+		return {
+			id: definition.name,
+			name: definition.name,
+			type: UtilityType.Semantic,
+			order,
+			layer: definition.layer || "utilities",
+			emit: {
+				type: "static",
+				rules
+			},
+			matchers: [getPatternMatcher(definition.pattern)]
+		};
+	}
+	if (definition.type === "dynamic") {
+		if (!definition.dynamic) throw new Error("Managed dynamic utility definition is missing a dynamic source");
+		const rules = [];
+		if (definition.declarations) rules.push({
+			declarations: compilePatternDeclarations(definition.declarations),
+			...definition.atRules?.length ? { atRules: [...definition.atRules] } : {}
+		});
+		if (definition.rules?.length) rules.push(...definition.rules.map(compilePatternUtilityRule));
+		return {
+			id: definition.name,
+			name: definition.name,
+			type: utilityTypeFromRules(rules),
+			order,
+			layer: definition.layer || "utilities",
+			...definition.dynamic.kind ? { kind: definition.dynamic.kind } : {},
+			...definition.dynamic.variableAliasRefs?.length ? { variableAliasRefs: [...definition.dynamic.variableAliasRefs] } : {},
+			emit: {
+				type: "static",
+				rules
+			},
+			matchers: getDynamicMatchers(definition.dynamic)
+		};
+	}
+	const name = definition.name.startsWith(".") ? definition.name.slice(1) : definition.name;
+	const rules = [];
+	if (definition.declarations) {
+		assertNoValuePlaceholder(definition.declarations);
+		rules.push({
+			declarations: cloneDeclarations(definition.declarations),
+			...definition.atRules?.length ? { atRules: [...definition.atRules] } : {}
+		});
+	}
+	if (definition.rules?.length) rules.push(...definition.rules.map(compileUtilityRule));
+	return {
+		id: "." + name,
+		name,
+		type: UtilityType.Semantic,
+		order,
+		layer: definition.layer || "utilities",
+		emit: {
+			type: "static",
+			rules
+		},
+		matchers: [{
+			type: "static",
+			name
+		}]
+	};
+}
+function compileUtilities(input) {
+	if (!input?.length) return;
+	return input.map((definition, index) => compileUtility(definition, index));
+}
+function compileAnimations(input) {
+	return input ? clone(input) : void 0;
+}
+function compileAnimationOptions(input) {
+	return input ? clone(input) : void 0;
+}
+function mergeBy(base, next, getKey) {
+	const merged = [...(base || []).map((value) => clone(value))];
+	for (const value of next || []) {
+		const key = getKey(value);
+		const index = key === void 0 ? -1 : merged.findIndex((existing) => getKey(existing) === key);
+		if (index === -1) merged.push(clone(value));
+		else merged[index] = clone(value);
+	}
+	return merged.length ? merged : void 0;
+}
+function mergeVariables(base, next) {
+	return groupMasterCSSManifestVariables(mergeBy(flattenMasterCSSManifestVariables(base), flattenMasterCSSManifestVariables(next), (variable) => variable.name));
+}
+function mergeRecords(base, next) {
+	return Object.keys(base || {}).length || Object.keys(next || {}).length ? {
+		...base ? clone(base) : {},
+		...next ? clone(next) : {}
+	} : void 0;
+}
+function mergeAnimationOptions(base, next, animations) {
+	const merged = mergeRecords(base, next);
+	if (!merged) return;
+	for (const animationName of Object.keys(animations || {})) if (!next?.[animationName]) delete merged[animationName];
+	return Object.keys(merged).length ? merged : void 0;
+}
+function mergeManifest(baseManifest, fragment) {
+	if (!baseManifest) return clone(fragment);
+	const manifest = {
+		version: 1,
+		settings: {
+			...baseManifest.settings || {},
+			...fragment.settings || {}
+		},
+		variables: mergeVariables(baseManifest.variables, fragment.variables),
+		animations: mergeRecords(baseManifest.animations, fragment.animations),
+		animationOptions: mergeAnimationOptions(baseManifest.animationOptions, fragment.animationOptions, fragment.animations),
+		variants: mergeBy(baseManifest.variants, fragment.variants, (variant) => variant.token),
+		atRules: mergeRecords(baseManifest.atRules, fragment.atRules),
+		breakpointAtRules: mergeRecords(baseManifest.breakpointAtRules, fragment.breakpointAtRules),
+		containerAtRules: mergeRecords(baseManifest.containerAtRules, fragment.containerAtRules),
+		selectors: mergeRecords(baseManifest.selectors, fragment.selectors),
+		utilities: mergeBy(baseManifest.utilities, fragment.utilities, (utility) => `${utility.id}\0${utility.layer || ""}`),
+		debug: mergeRecords(baseManifest.debug, fragment.debug)
+	};
+	return Object.fromEntries(Object.entries(manifest).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length) && (typeof value !== "object" || Array.isArray(value) || Object.keys(value).length)));
+}
+function createMasterCSSManifest(input = {}, options = {}) {
+	const diagnostics = options.diagnostics;
+	addCompilerDiagnosticCount(diagnostics, "manifest-create-count");
+	setCompilerDiagnosticCount(diagnostics, "manifest-input-variable-count", input.variables?.length || 0);
+	setCompilerDiagnosticCount(diagnostics, "manifest-input-utility-count", input.utilities?.length || 0);
+	setCompilerDiagnosticCount(diagnostics, "manifest-input-variant-count", input.variants?.length || 0);
+	setCompilerDiagnosticCount(diagnostics, "manifest-input-animation-count", Object.keys(input.animations || {}).length);
+	const rootSize = input.rootSize ?? options.baseManifest?.settings?.rootSize ?? 16;
+	const resolveVariableName = timeCompilerDiagnostic(diagnostics, "manifest-variable-name-resolver-ms", () => createVariableNameResolver(input, options));
+	const variableDefinitions = timeCompilerDiagnostic(diagnostics, "manifest-compile-variables-ms", () => compileVariables(input.variables, resolveVariableName));
+	const variables = timeCompilerDiagnostic(diagnostics, "manifest-group-variables-ms", () => groupMasterCSSManifestVariables(variableDefinitions));
+	const { atRules, breakpointAtRules, containerAtRules } = timeCompilerDiagnostic(diagnostics, "manifest-compile-at-rules-ms", () => compileAtRules(variableDefinitions, rootSize));
+	const settings = {
+		...input.rootSize !== void 0 ? { rootSize: input.rootSize } : {},
+		...input.baseUnit !== void 0 ? { baseUnit: input.baseUnit } : {},
+		...input.defaultMode !== void 0 ? { defaultMode: input.defaultMode } : {},
+		...input.scope !== void 0 ? { scope: input.scope } : {},
+		...input.important !== void 0 ? { important: input.important } : {},
+		...input.modeTrigger !== void 0 ? { modeTrigger: input.modeTrigger } : {},
+		...input.modes?.length ? { modes: [...input.modes] } : {}
+	};
+	const variantBaseManifest = timeCompilerDiagnostic(diagnostics, "manifest-variant-base-merge-ms", () => mergeManifest(options.baseManifest, {
+		version: 1,
+		...Object.keys(settings).length ? { settings } : {},
+		...variables ? { variables } : {},
+		...atRules ? { atRules } : {},
+		...breakpointAtRules ? { breakpointAtRules } : {},
+		...containerAtRules ? { containerAtRules } : {}
+	}));
+	const { variants, selectors, atRules: variantAtRules } = timeCompilerDiagnostic(diagnostics, "manifest-compile-variants-ms", () => compileVariants(input.variants, variantBaseManifest));
+	const utilities = timeCompilerDiagnostic(diagnostics, "manifest-compile-utilities-ms", () => compileUtilities(input.utilities));
+	const animations = timeCompilerDiagnostic(diagnostics, "manifest-compile-animations-ms", () => compileAnimations(input.animations));
+	const animationOptions = timeCompilerDiagnostic(diagnostics, "manifest-compile-animation-options-ms", () => compileAnimationOptions(input.animationOptions));
+	const fragment = {
+		version: 1,
+		...Object.keys(settings).length ? { settings } : {},
+		...variables ? { variables } : {},
+		...animations ? { animations } : {},
+		...animationOptions ? { animationOptions } : {},
+		...variants?.length ? { variants } : {},
+		...atRules || variantAtRules ? { atRules: mergeRecords(atRules, variantAtRules) } : {},
+		...breakpointAtRules ? { breakpointAtRules } : {},
+		...containerAtRules ? { containerAtRules } : {},
+		...selectors ? { selectors } : {},
+		...utilities?.length ? { utilities } : {}
+	};
+	const manifest = timeCompilerDiagnostic(diagnostics, "manifest-final-merge-ms", () => mergeManifest(options.baseManifest, fragment));
+	setCompilerDiagnosticCount(diagnostics, "manifest-output-variable-count", Object.keys(manifest.variables || {}).length);
+	setCompilerDiagnosticCount(diagnostics, "manifest-output-utility-count", manifest.utilities?.length || 0);
+	setCompilerDiagnosticCount(diagnostics, "manifest-output-variant-count", manifest.variants?.length || 0);
+	setCompilerDiagnosticCount(diagnostics, "manifest-output-selector-count", Object.keys(manifest.selectors || {}).length);
+	setCompilerDiagnosticCount(diagnostics, "manifest-output-at-rule-count", Object.keys(manifest.atRules || {}).length);
+	setCompilerDiagnosticCount(diagnostics, "manifest-output-animation-count", Object.keys(manifest.animations || {}).length);
+	return manifest;
+}
+//#endregion
+export { createMasterCSSManifest, createVariableNameResolver };

package/dist/native-declaration.d.ts

@@ -1,2 +1,6 @@
-import type { NativeCSSDeclarationMatcher } from '@master/css-engine';
-export declare const cssTreeNativeDeclarationMatcher: NativeCSSDeclarationMatcher;
+import { NativeCSSDeclarationMatcher } from "@master/css-engine";
+
+//#region src/native-declaration.d.ts
+declare const cssTreeNativeDeclarationMatcher: NativeCSSDeclarationMatcher;
+//#endregion
+export { cssTreeNativeDeclarationMatcher };

package/dist/native-declaration.js

@@ -0,0 +1,23 @@
+import { lexer, parse, property } from "css-tree";
+//#region src/native-declaration.ts
+const matches = /* @__PURE__ */ new Map();
+function isTargetError(error) {
+	return error && typeof error === "object" && "name" in error && (error.name === "SyntaxError" || error.name === "SyntaxMatchError" || error.name === "SyntaxReferenceError");
+}
+const cssTreeNativeDeclarationMatcher = ({ property: property$1, value }) => {
+	if (property(property$1).custom) return true;
+	const cacheKey = property$1 + "\0" + value;
+	const cached = matches.get(cacheKey);
+	if (cached !== void 0) return cached;
+	let matched = false;
+	try {
+		const ast = parse(value, { context: "value" });
+		matched = !isTargetError(lexer.checkPropertyName(property$1)) && !isTargetError(lexer.matchProperty(property$1, ast).error);
+	} catch {
+		matched = false;
+	}
+	matches.set(cacheKey, matched);
+	return matched;
+};
+//#endregion
+export { cssTreeNativeDeclarationMatcher };

package/dist/utils/selectors.d.ts

@@ -1,3 +1,6 @@
-export declare function splitSelectorList(selectorText: string): string[];
-export declare function combineSelectorLists(parentSelectors: string[], childSelectors: string[]): string[];
-export declare function combineStyleSelectors(parentSelector: string, childSelector: string): string;
+//#region src/utils/selectors.d.ts
+declare function splitSelectorList(selectorText: string): string[];
+declare function combineSelectorLists(parentSelectors: string[], childSelectors: string[]): string[];
+declare function combineStyleSelectors(parentSelector: string, childSelector: string): string;
+//#endregion
+export { combineSelectorLists, combineStyleSelectors, splitSelectorList };

package/dist/utils/selectors.js

@@ -0,0 +1,49 @@
+//#region src/utils/selectors.ts
+function splitSelectorList(selectorText) {
+	const selectors = [];
+	let current = "";
+	let depth = 0;
+	let quote = "";
+	for (let index = 0; index < selectorText.length; index++) {
+		const char = selectorText[index];
+		if (quote) {
+			current += char;
+			if (char === "\\") current += selectorText[++index] || "";
+			else if (char === quote) quote = "";
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			current += char;
+			continue;
+		}
+		if (char === "(" || char === "[") {
+			depth++;
+			current += char;
+			continue;
+		}
+		if (char === ")" || char === "]") {
+			depth--;
+			current += char;
+			continue;
+		}
+		if (char === "," && depth === 0) {
+			selectors.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current.trim()) selectors.push(current.trim());
+	return selectors;
+}
+function combineSelectorLists(parentSelectors, childSelectors) {
+	const selectors = [];
+	for (const child of childSelectors) for (const parent of parentSelectors) selectors.push(child.includes("&") ? child.replace(/&/g, parent) : `${parent} ${child}`);
+	return selectors;
+}
+function combineStyleSelectors(parentSelector, childSelector) {
+	return combineSelectorLists(splitSelectorList(parentSelector), splitSelectorList(childSelector)).join(",");
+}
+//#endregion
+export { combineSelectorLists, combineStyleSelectors, splitSelectorList };

package/dist/utils/unquote.d.ts

@@ -1 +1,4 @@
-export default function unquote(value: string): string;
+//#region src/utils/unquote.d.ts
+declare function unquote(value: string): string;
+//#endregion
+export { unquote as default };