@master/css-binding 0.0.0-site.1793659883.g69c9aebcf628

package/dist/engine-binding-node.js

@@ -0,0 +1,38 @@
+import { normalizeBindingError } from "./normalize-error.js";
+import { bindEngineBindingSession, bindRenderBindingSession } from "./engine-binding-adapter.js";
+import { compileNativeRuntimeProgram, createNativeEngineSession, createNativeRenderSession } from "./engine.js";
+// src/engine-binding-node.ts
+function createEngineBindingSessionSync(options, loadOptions = {}) {
+	try {
+		const session = createNativeEngineSession(options, {
+			...loadOptions,
+			required: true
+		});
+		return bindEngineBindingSession("native", session);
+	} catch (cause) {
+		throw normalizeBindingError(cause, "engine");
+	}
+}
+function createRenderBindingSessionSync(options, loadOptions = {}) {
+	try {
+		const session = createNativeRenderSession(options, {
+			...loadOptions,
+			required: true
+		});
+		return bindRenderBindingSession("native", session);
+	} catch (cause) {
+		throw normalizeBindingError(cause, "server");
+	}
+}
+/** Compiles a manifest into the runtime program that browsers execute. */
+function compileRuntimeProgramSync(manifest, loadOptions = {}) {
+	try {
+		return compileNativeRuntimeProgram(manifest, {
+			...loadOptions,
+			required: true
+		});
+	} catch (cause) {
+		throw normalizeBindingError(cause, "engine");
+	}
+}
+export { compileRuntimeProgramSync, createEngineBindingSessionSync, createRenderBindingSessionSync };

package/dist/engine-binding-wasm.js

@@ -0,0 +1,64 @@
+import { assertMasterCSSBindingInfo } from "./binding.js";
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+// src/engine-binding-wasm.ts
+async function loadDefaultWasmProvider(options) {
+	const { createMasterCSSEngineWasmProvider } = await import("@master/css-binding-wasm-engine");
+	return await createMasterCSSEngineWasmProvider(options);
+}
+async function createWasmProvider(feature, options, factory = loadDefaultWasmProvider) {
+	const provider = await factory(options);
+	assertMasterCSSBindingInfo(provider.info, {
+		surface: "runtime",
+		features: [feature]
+	});
+	return provider;
+}
+function lifecycle(session) {
+	let disposed = false;
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		session.dispose();
+	};
+	return {
+		binding: "wasm",
+		dispose,
+		[Symbol.dispose]: dispose
+	};
+}
+function wasmSource(source) {
+	return ArrayBuffer.isView(source) ? source : serializeMasterCSSManifest(source);
+}
+async function createWasmEngineBindingSession(options, loadOptions, providerFactory) {
+	const session = await (await createWasmProvider("engine", loadOptions, providerFactory)).createEngineSession(wasmSource(options.program ?? options.manifest), options.emittedGlobals);
+	const bound = {
+		...lifecycle(session),
+		ensureClassRules: (classNames) => session.ensureClassRules([...classNames]),
+		deleteClassRules: (classNames) => session.deleteClassRules([...classNames]),
+		registerEmittedGlobals: (emittedGlobals) => session.registerEmittedGlobals(emittedGlobals),
+		replaceEmittedGlobals: (emittedGlobals) => session.replaceEmittedGlobals(emittedGlobals),
+		refresh: (source, emittedGlobals) => session.refresh(wasmSource(source), emittedGlobals),
+		keyframeDefinitions: () => session.keyframeDefinitions(),
+		executionState: (classNames) => session.executionState([...classNames]),
+		inspect: (className) => session.inspect(className),
+		snapshot: () => session.snapshot()
+	};
+	return Object.freeze(bound);
+}
+async function createWasmRenderBindingSession(options, loadOptions, providerFactory) {
+	const session = await (await createWasmProvider("render", loadOptions, providerFactory)).createRenderSession(serializeMasterCSSManifest(options.manifest), options.emittedGlobals ? JSON.stringify(options.emittedGlobals) : void 0);
+	const bound = {
+		...lifecycle(session),
+		nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates(classNames),
+		ensureClassRules: (classNames) => session.ensureClassRules(classNames),
+		ensureStylesheetResources: (nativeCSS) => session.ensureStylesheetResources(nativeCSS),
+		emittedGlobals: () => session.emittedGlobals(),
+		snapshot: () => session.snapshot(),
+		snapshotForClassNames: (classNames) => session.snapshotForClassNames(classNames)
+	};
+	return Object.freeze(bound);
+}
+async function compileWasmRuntimeProgram(manifest, loadOptions, providerFactory) {
+	return await (await createWasmProvider("engine", loadOptions, providerFactory)).compileRuntimeProgram(serializeMasterCSSManifest(manifest));
+}
+export { compileWasmRuntimeProgram, createWasmEngineBindingSession, createWasmRenderBindingSession };

package/dist/engine-binding.d.ts

@@ -0,0 +1,40 @@
+import { MasterCSSEngineExecutionState, MasterCSSEngineInspection, MasterCSSEngineResolvedBinding, MasterCSSEngineSnapshot, MasterCSSEngineTransition, MasterCSSNativeDeclarationCandidate, MasterCSSResolvedBinding, MasterCSSServerRender } from "./protocol.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSEngineSource } from "./engine-contract.js";
+import { MasterCSSKeyframeDefinition, MasterCSSManifest } from "@master/css-schema/manifest";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+type MasterCSSEngineBindingSessionOptions = MasterCSSEngineSource & {
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
+};
+interface MasterCSSRenderBindingSessionOptions {
+  readonly manifest: MasterCSSManifest;
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
+}
+interface MasterCSSEngineBindingSession extends Disposable {
+  readonly binding: MasterCSSEngineResolvedBinding;
+  ensureClassRules(classNames: readonly string[]): MasterCSSEngineTransition;
+  deleteClassRules(classNames: readonly string[]): MasterCSSEngineTransition;
+  registerEmittedGlobals(emittedGlobals: MasterCSSEmittedGlobals): MasterCSSEngineTransition;
+  replaceEmittedGlobals(emittedGlobals: MasterCSSEmittedGlobals): MasterCSSEngineTransition;
+  refresh(source: MasterCSSManifest | Uint8Array, emittedGlobals?: MasterCSSEmittedGlobals): MasterCSSEngineTransition;
+  keyframeDefinitions(): readonly MasterCSSKeyframeDefinition[];
+  executionState(classNames: readonly string[]): MasterCSSEngineExecutionState;
+  inspect(className: string): MasterCSSEngineInspection;
+  snapshot(): MasterCSSEngineSnapshot;
+  dispose(): void;
+}
+interface MasterCSSRenderBindingSession extends Disposable {
+  readonly binding: MasterCSSResolvedBinding;
+  nativeDeclarationCandidates(classNames: readonly string[]): readonly MasterCSSNativeDeclarationCandidate[];
+  ensureClassRules(classNames: readonly string[]): void;
+  ensureStylesheetResources(nativeCSS: string): void;
+  emittedGlobals(): MasterCSSEmittedGlobals;
+  snapshot(): MasterCSSServerRender;
+  snapshotForClassNames(classNames: readonly string[]): MasterCSSServerRender;
+  dispose(): void;
+}
+declare function createEngineBindingSession(options: MasterCSSEngineBindingSessionOptions, loadOptions?: MasterCSSBindingLoadOptions): Promise<MasterCSSEngineBindingSession>;
+declare function createRenderBindingSession(options: MasterCSSRenderBindingSessionOptions, loadOptions?: MasterCSSBindingLoadOptions): Promise<MasterCSSRenderBindingSession>;
+/** Compiles a manifest into the runtime program that browsers execute. */
+declare function compileRuntimeProgram(manifest: MasterCSSManifest, loadOptions?: MasterCSSBindingLoadOptions): Promise<Uint8Array>;
+export { type MasterCSSBindingLoadOptions, MasterCSSEngineBindingSession, MasterCSSEngineBindingSessionOptions, type MasterCSSEngineSource, type MasterCSSNativeBindingLoadOptions, MasterCSSRenderBindingSession, MasterCSSRenderBindingSessionOptions, type MasterCSSWasmBindingLoadOptions, compileRuntimeProgram, createEngineBindingSession, createRenderBindingSession };

package/dist/engine-binding.js

@@ -0,0 +1,57 @@
+import { normalizeBindingError } from "./normalize-error.js";
+import { hasMasterCSSNodeRuntime, shouldLoadMasterCSSNativeBinding } from "./binding-options.js";
+import { compileWasmRuntimeProgram, createWasmEngineBindingSession, createWasmRenderBindingSession } from "./engine-binding-wasm.js";
+import { bindEngineBindingSession, bindRenderBindingSession } from "./engine-binding-adapter.js";
+import { createJavaScriptEngineBindingSession } from "./engine-binding-js.js";
+// src/engine-binding.ts
+async function loadNativeEngineFactories() {
+	return await (import.meta.url.endsWith(".ts") ? import("./engine.js") : import("./engine.js"));
+}
+async function createEngineBindingSession(options, loadOptions = {}) {
+	try {
+		if (shouldLoadMasterCSSNativeBinding(loadOptions.binding)) {
+			const { createNativeEngineSession } = await loadNativeEngineFactories();
+			const native = createNativeEngineSession(options, {
+				...loadOptions.native,
+				required: loadOptions.binding === "native"
+			});
+			if (native) return bindEngineBindingSession("native", native);
+		}
+		if (loadOptions.binding !== "wasm" && options.program && !hasMasterCSSNodeRuntime()) return createJavaScriptEngineBindingSession(options);
+		return bindEngineBindingSession("wasm", await createWasmEngineBindingSession(options, loadOptions.wasm));
+	} catch (cause) {
+		throw normalizeBindingError(cause, "engine");
+	}
+}
+async function createRenderBindingSession(options, loadOptions = {}) {
+	try {
+		if (shouldLoadMasterCSSNativeBinding(loadOptions.binding)) {
+			const { createNativeRenderSession } = await loadNativeEngineFactories();
+			const native = createNativeRenderSession(options, {
+				...loadOptions.native,
+				required: loadOptions.binding === "native"
+			});
+			if (native) return bindRenderBindingSession("native", native);
+		}
+		return bindRenderBindingSession("wasm", await createWasmRenderBindingSession(options, loadOptions.wasm));
+	} catch (cause) {
+		throw normalizeBindingError(cause, "server");
+	}
+}
+/** Compiles a manifest into the runtime program that browsers execute. */
+async function compileRuntimeProgram(manifest, loadOptions = {}) {
+	try {
+		if (shouldLoadMasterCSSNativeBinding(loadOptions.binding)) {
+			const { compileNativeRuntimeProgram } = await loadNativeEngineFactories();
+			const program = compileNativeRuntimeProgram(manifest, {
+				...loadOptions.native,
+				required: loadOptions.binding === "native"
+			});
+			if (program) return program;
+		}
+		return await compileWasmRuntimeProgram(manifest, loadOptions.wasm);
+	} catch (cause) {
+		throw normalizeBindingError(cause, "engine");
+	}
+}
+export { compileRuntimeProgram, createEngineBindingSession, createRenderBindingSession };

package/dist/engine-contract.d.ts

@@ -0,0 +1,14 @@
+import { MasterCSSKeyframeDefinition, MasterCSSManifest } from "@master/css-schema/manifest";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+/**
+ * What an engine session executes: a manifest, which only Node hosts compile, or a
+ * runtime program that `compileRuntimeProgram()` encoded.
+ */
+type MasterCSSEngineSource = {
+  readonly manifest: MasterCSSManifest;
+  readonly program?: never;
+} | {
+  readonly program: Uint8Array;
+  readonly manifest?: never;
+};
+export { MasterCSSEngineSource };

package/dist/engine-js/src/animation.js

@@ -0,0 +1,154 @@
+import { asciiLowercase, isAsciiCase } from "./text.js";
+import { collectStatements, tokenize } from "./css-syntax.js";
+// ../engine-js/src/animation.ts
+/** Authored declarations, without those inside keyframes, which CSS ignores. */
+function stylesheetDeclarations(source) {
+	const tokens = tokenize(source);
+	const statements = collectStatements(tokens);
+	const declarations = [];
+	for (const statement of statements) {
+		if (!statement.declaration || statement.end - statement.start < 3) continue;
+		let inKeyframes = false;
+		for (let parent = statement.parent; parent >= 0; parent = statements[parent].parent) {
+			const head = tokens[statements[parent].start];
+			if (head.kind === 2 && (isAsciiCase(head.value, "keyframes") || isAsciiCase(head.value, "-webkit-keyframes"))) {
+				inKeyframes = true;
+				break;
+			}
+		}
+		const property = tokens[statement.start];
+		if (inKeyframes || property.kind !== 0) continue;
+		declarations.push([property.value, source.slice(tokens[statement.start + 2].start, tokens[statement.end - 1].end)]);
+	}
+	return declarations;
+}
+function analyzeAnimations(declarations, program) {
+	const result = {
+		names: [],
+		retainAll: false
+	};
+	if (!program.keyframes.length) return result;
+	const variables = /* @__PURE__ */ new Map();
+	for (const [name, value] of declarations) {
+		if (!name.startsWith("--")) continue;
+		const values = variables.get(name.slice(2));
+		if (values) values.push(value);
+		else variables.set(name.slice(2), [value]);
+	}
+	for (const [name, value] of declarations) {
+		let property = asciiLowercase(name);
+		if (property.startsWith("-webkit-")) property = property.slice(8);
+		if (property !== "animation" && property !== "animation-name") continue;
+		const values = resolve(value, program, variables, /* @__PURE__ */ new Set(), { remaining: 256 });
+		if (values) for (const option of values) parseNames(option, property === "animation-name", result);
+		else result.retainAll = true;
+	}
+	result.names = result.names.filter((name) => program.keyframes.some((definition) => definition.name === name));
+	return result;
+}
+/** Every value a `var()` chain may substitute, or undefined when any is unknown. */
+function resolve(value, program, variables, stack, budget) {
+	if (!budget.remaining || stack.size > 64) return;
+	budget.remaining--;
+	const tokens = tokenize(value);
+	const index = tokens.findIndex((token) => token.kind === 3 && isAsciiCase(token.value, "var"));
+	if (index < 0) return [value];
+	const token = tokens[index];
+	if (token.close < 0) return;
+	const nameToken = tokens[index + 1];
+	if (nameToken?.kind !== 0 || !nameToken.value.startsWith("--")) return;
+	const name = nameToken.value.slice(2);
+	if (stack.has(name)) return;
+	stack.add(name);
+	const options = (program.variables.get(name)?.values ?? []).map((entry) => entry.value);
+	options.push(...program.animationVariables.get(name) ?? [], ...variables.get(name) ?? []);
+	if (!options.length) {
+		stack.delete(name);
+		return;
+	}
+	const comma = tokens[index + 2];
+	if (comma?.kind === 8 && comma.value === ",") options.push(value.slice(comma.end, tokens[token.close].start));
+	const output = [];
+	for (const option of options) {
+		const optionTokens = tokenize(option);
+		const bang = optionTokens[optionTokens.length - 2];
+		const last = optionTokens[optionTokens.length - 1];
+		const replacements = resolve(bang?.kind === 8 && bang.value === "!" && last.kind === 0 && isAsciiCase(last.value, "important") ? option.slice(0, bang.start) : option, program, variables, stack, budget);
+		if (!replacements) return;
+		for (const replacement of replacements) {
+			const expanded = value.slice(0, token.start) + replacement + value.slice(tokens[token.close].end);
+			stack.delete(name);
+			const resolved = resolve(expanded, program, variables, stack, budget);
+			if (!resolved) return;
+			output.push(...resolved);
+			stack.add(name);
+		}
+	}
+	stack.delete(name);
+	return output;
+}
+const KEYWORD_CATEGORIES = {
+	ease: "timing",
+	linear: "timing",
+	"ease-in": "timing",
+	"ease-out": "timing",
+	"ease-in-out": "timing",
+	"step-start": "timing",
+	"step-end": "timing",
+	infinite: "iteration",
+	normal: "direction",
+	reverse: "direction",
+	alternate: "direction",
+	"alternate-reverse": "direction",
+	none: "fill",
+	forwards: "fill",
+	backwards: "fill",
+	both: "fill",
+	running: "play",
+	paused: "play",
+	auto: "duration"
+};
+const MATH = /* @__PURE__ */ new Set([
+	"calc",
+	"min",
+	"max",
+	"clamp",
+	"round",
+	"mod",
+	"rem",
+	"abs",
+	"sign"
+]);
+function parseNames(value, namesOnly, result) {
+	const tokens = tokenize(value);
+	const used = /* @__PURE__ */ new Set();
+	for (let cursor = 0; cursor < tokens.length; cursor++) {
+		const token = tokens[cursor];
+		let name;
+		if (token.kind === 8 && token.value === ",") used.clear();
+		else if (token.kind === 8 && token.value === "!") break;
+		else if (token.kind === 1) name = token.value;
+		else if (token.kind === 0) {
+			const keyword = asciiLowercase(token.value);
+			if (keyword === "initial" || keyword === "inherit" || keyword === "unset" || keyword === "revert" || keyword === "revert-layer") {
+				if (keyword === "inherit" || keyword.startsWith("revert")) result.retainAll = true;
+			} else if (namesOnly) {
+				if (keyword !== "none") name = token.value;
+			} else {
+				const category = Object.hasOwn(KEYWORD_CATEGORIES, keyword) ? KEYWORD_CATEGORIES[keyword] : void 0;
+				const fresh = category !== void 0 && !used.has(category);
+				if (category !== void 0) used.add(category);
+				if (!fresh && keyword !== "none") name = token.value;
+			}
+		} else if (token.kind === 3) {
+			const fn = asciiLowercase(token.value);
+			if (fn === "steps" || fn === "cubic-bezier" || fn === "linear") used.add("timing");
+			else if (!MATH.has(fn)) result.retainAll = true;
+			if (token.close >= 0) cursor = token.close;
+			else result.retainAll = true;
+		} else if (token.kind === 4) used.add("iteration");
+		else if (token.kind !== 5 && token.kind !== 6) result.retainAll = true;
+		if (name !== void 0 && !result.names.includes(name)) result.names.push(name);
+	}
+}
+export { analyzeAnimations, stylesheetDeclarations };

package/dist/engine-js/src/apply.js

@@ -0,0 +1,207 @@
+import { trim } from "./text.js";
+import { tokenize } from "./css-syntax.js";
+import { collectCssVariableReferences, substituteInlineTokens } from "./value.js";
+import { cssEscape } from "./program.js";
+import { decodeNativeContent, parseFunctionalClass, parseNativeDeclaration, splitStateToken } from "./class-syntax.js";
+import { atomicShape } from "./order.js";
+import { conditionPriority, parseCustomMediaQuery, parseNativeQuery, queryRequiresCss, renderConditionToken, resolveLayerCondition } from "./condition.js";
+import { replaceNestingSelector, selectorPriority, selectorTokenToTemplate, validSelectorStructure } from "./selector.js";
+import { expandBody, expandMixin, expandUtility } from "./mixin.js";
+import { resolveStateBranches } from "./state.js";
+import { functionInvocation, matchingUtilities, tokenPrefix } from "./utility.js";
+import { addAnimationReferences, compositionRules, formatDeclaration, nativeDeclaration, rulePriority, wrapRawConditions } from "./generate.js";
+// ../engine-js/src/apply.ts
+/** The CSS mixin call inside an `@apply(…)` suffix: a complete dashed call or name. */
+function parseMixinCall(source) {
+	const head = parseFunctionalClass(source);
+	if (head !== void 0) {
+		if (typeof head === "string" || !head.name.startsWith("--") || head.suffix) return;
+		return [head.name, head.arguments.map(trim)];
+	}
+	const tokens = tokenize(source);
+	if (tokens.length === 1 && tokens[0].kind === 0 && tokens[0].value.startsWith("--")) return [tokens[0].value, []];
+}
+/** The mixin call of an `apply(…)` condition token; null when it is malformed, undefined for other tokens. */
+function applyInvocation(token) {
+	if (!token.startsWith("apply(")) return;
+	const body = token.endsWith(")") ? decodeNativeContent(token.slice(6, -1)) : void 0;
+	return (body === void 0 ? void 0 : parseMixinCall(body)) ?? null;
+}
+/** Whether a function class or a matched recipe fails to expand. */
+function hasExpansionError(source, program) {
+	const invocation = functionInvocation(source, program);
+	if (invocation !== void 0) return !invocation || !expandUtility(program, invocation[1], invocation[2]);
+	return matchingUtilities(source, program).some(([index, matched]) => {
+		const { emit } = program.utilities[index];
+		return emit.type === "recipe" && !expandUtility(program, program.utilityDefinitions[emit.definition], matched.arguments);
+	});
+}
+/** Whether the Rust engine reports any error diagnostic for a class. */
+function hasDiagnostics(className, program) {
+	const source = className.endsWith("!") ? className.slice(0, -1) : className;
+	const declaration = parseNativeDeclaration(source);
+	if (declaration === null) return true;
+	const stateSource = declaration ? source.slice(declaration.suffixStart) : source;
+	if (!declaration && hasExpansionError(source, program)) return true;
+	if (decodeNativeContent(stateSource) === void 0) return true;
+	const matches = declaration ? [] : matchingUtilities(source, program);
+	const states = declaration ? [stateSource] : matches.map(([, matched]) => matched.stateToken);
+	for (const state of states) {
+		const [selector] = splitStateToken(state[0] === "!" ? state.slice(1) : state);
+		if (selector && !validSelectorStructure(selectorTokenToTemplate(selector))) return true;
+	}
+	let layer;
+	for (const token of splitStateToken(stateSource)[1]) {
+		const call = applyInvocation(token);
+		if (call !== void 0) {
+			if (!call || !expandMixin(program, call[0], call[1], [])) return true;
+			continue;
+		}
+		const next = resolveLayerCondition(token);
+		if (next) {
+			if (layer && layer !== next) return true;
+			layer = next;
+			continue;
+		}
+		if (queryRequiresCss(token)) return true;
+		const query = parseNativeQuery(token);
+		if (query?.kind === "media" && query.prelude.includes("--") && !parseCustomMediaQuery(query.prelude, (name) => program.customMedia.get(name))) return true;
+		if (!program.customMedia.has(`--${token}`) && !renderConditionToken(token, program)) return true;
+	}
+	return !declaration && !matches.length && tokenPrefix(source, program) !== void 0;
+}
+const textValue = (value) => [{
+	type: "text",
+	value
+}];
+function expandApplication(className, head, suffixes, program) {
+	if (hasDiagnostics(className, program)) return;
+	const important = className.endsWith("!");
+	const native = !!parseNativeDeclaration(head);
+	const [first] = matchingUtilities(head, program);
+	const state = first ? first[1].stateToken : nativeDeclaration(head)?.[1].stateToken ?? "";
+	const base = head.endsWith(state) ? head.slice(0, head.length - state.length) : head;
+	if (hasDiagnostics(base, program)) return;
+	const originals = compositionRules(base, program);
+	if (!originals.length) return;
+	let layer;
+	const setLayer = (next) => {
+		if (layer && layer !== next) return false;
+		layer = next;
+		return true;
+	};
+	const body = [];
+	for (const rule of originals) {
+		if (rule.explicitLayer && !setLayer(rule.explicitLayer)) return;
+		let nodes = rule.declarations.map(([property, value]) => ({
+			type: "declaration",
+			property,
+			value: textValue(value)
+		}));
+		if (rule.selector !== "&") nodes = [{
+			type: "rule",
+			selector: rule.selector,
+			body: nodes
+		}];
+		for (let index = rule.conditions.length - 1; index >= 0; index--) nodes = [{
+			type: "condition",
+			condition: rule.conditions[index],
+			body: nodes
+		}];
+		body.push(...nodes);
+	}
+	const options = [];
+	for (const suffix of suffixes) {
+		const call = applyInvocation(suffix);
+		const next = call === void 0 ? resolveLayerCondition(suffix) : void 0;
+		if (call === null || next && !setLayer(next)) return;
+		const branches = call === void 0 && !next ? resolveStateBranches(`@${suffix}`, false, program) : void 0;
+		if (branches && !branches.length && !program.customMedia.has(`--${suffix}`)) return;
+		options.push(branches);
+	}
+	const template = state ? selectorTokenToTemplate(state) : void 0;
+	let combinations = [[]];
+	for (const branches of options) if (branches) combinations = combinations.flatMap((chosen) => branches.map((branch) => [...chosen, branch]));
+	const primary = originals[0];
+	const anchor = `.${cssEscape(className)}`;
+	const stored = [];
+	for (const [group, chosen] of combinations.entries()) {
+		let nodes = body;
+		let at = chosen.length;
+		for (let index = suffixes.length - 1; index >= 0; index--) {
+			const call = applyInvocation(suffixes[index]);
+			if (call) nodes = [{
+				type: "apply",
+				name: call[0],
+				arguments: call[1].map(textValue),
+				contents: nodes
+			}];
+			else if (options[index]) nodes = chosen[--at].conditionWrappers.reduceRight((contents, [, condition]) => [{
+				type: "condition",
+				condition,
+				body: contents
+			}], nodes);
+		}
+		if (template !== void 0) nodes = [{
+			type: "rule",
+			selector: template,
+			body: nodes
+		}];
+		const expanded = expandBody(program, nodes);
+		if (!expanded) return;
+		if (!expanded.length) continue;
+		const outer = chosen.flatMap((branch) => branch.conditionWrappers);
+		const texts = [];
+		const selectors = [];
+		const declarations = expanded.map((rule) => {
+			const text = rule.declarations.map(([property, raw]) => {
+				const value = substituteInlineTokens(raw, program);
+				if (!important) return `${property}:${value}`;
+				const declaration = formatDeclaration(property, value, true);
+				return `${property}:${declaration.slice(declaration.indexOf(":") + 1)}`;
+			}).join(";");
+			const selector = replaceNestingSelector(rule.selector, anchor) ?? rule.selector;
+			texts.push(wrapRawConditions(`${selector}{${text}}`, rule.conditions));
+			selectors.push(selector);
+			return text;
+		}).join(";");
+		const [only] = expanded;
+		const shape = expanded.length === 1 && only.selector === (template ?? "&") && only.conditions.length === outer.length && only.declarations.length === 1 ? native ? { category: 2 } : atomicShape(...only.declarations[0]) : { category: 0 };
+		const [features, conditions] = conditionPriority(outer);
+		const ir = {
+			className,
+			key: group ? `${className}\0${group}` : className,
+			layer: layer ?? primary.layer,
+			type: primary.type,
+			sortTier: outer.length ? 3 : template === void 0 ? 0 : 1,
+			priority: rulePriority(features, selectorPriority(template), conditions, primary.valuePriority, declarations, shape),
+			text: texts.join("")
+		};
+		if (texts.length > 1) ir.nodes = texts.map((text) => ({ text }));
+		if (selectors.length === 1) ir.selectorText = selectors[0];
+		const variableNames = collectCssVariableReferences(declarations).filter((name) => program.variables.has(name));
+		if (variableNames.length) ir.variableNames = variableNames;
+		addAnimationReferences(ir, declarations, program);
+		stored.push({
+			ir,
+			features
+		});
+	}
+	return stored;
+}
+/** The rule of an `@apply` class, or undefined when the class has no `@apply` suffix. */
+function applicationRules(className, program) {
+	if (!className.includes("@apply(")) return;
+	const source = className.endsWith("!") ? className.slice(0, -1) : className;
+	const declaration = parseNativeDeclaration(source);
+	let head;
+	let suffixes;
+	if (declaration) {
+		const [selector, conditions] = splitStateToken(source.slice(declaration.suffixStart));
+		head = source.slice(0, declaration.suffixStart) + selector;
+		suffixes = conditions;
+	} else [head, suffixes] = splitStateToken(source);
+	if (!suffixes.some((suffix) => suffix.startsWith("apply("))) return;
+	return expandApplication(className, head, suffixes, program) ?? [];
+}
+export { applicationRules };