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

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

@@ -0,0 +1,236 @@
+import { trim } from "./text.js";
+import { leadingFunctionName } from "./css-syntax.js";
+import { alphaPercentage } from "./value.js";
+import { cssEscape } from "./program.js";
+import { hasTopLevelValueSeparator, isClassSuffixStart, isMatchStateBoundary, isQuote, parseFunctionalClass, splitDynamicValueState } from "./class-syntax.js";
+import { expandUtility } from "./mixin.js";
+// ../engine-js/src/utility.ts
+/** Token keys are non-empty and neither start nor end with `-`. */
+const isVariableKey = (key) => key !== "" && key[0] !== "-" && key[key.length - 1] !== "-";
+/** A `_` begins a descendant selector in classes, so such a token has no bare utility. */
+const isUtilityKey = (key) => isVariableKey(key) && !key.includes("_");
+/** Recipe keys that are CSS strings never take a custom property as their key. */
+const excludesKey = (utility, key) => utility.emit.type === "recipe" && utility.emit.key && key.includes("--");
+/** The variable a token `key` of a utility names: an explicit alias, then the first `~namespace` that declares `namespace-key`. */
+function utilityVariable(utility, key, program) {
+	const { variables } = program;
+	if (excludesKey(utility, key) || !isUtilityKey(key)) return;
+	for (const reference of utility.variableAliasRefs) {
+		const name = `${reference[0] === "~" ? reference.slice(1) : reference}-${key}`;
+		if (variables.has(name)) return name;
+	}
+}
+const NEGATIVE_PROPERTIES = /* @__PURE__ */ new Set([
+	"outline-offset",
+	"text-underline-offset",
+	"mask-position",
+	"perspective-origin",
+	"transform-origin",
+	"cx",
+	"cy",
+	"x",
+	"y",
+	"stroke-dashoffset",
+	"top",
+	"right",
+	"bottom",
+	"left",
+	"translate",
+	"rotate",
+	"letter-spacing",
+	"word-spacing",
+	"text-indent",
+	"background-position",
+	"object-position",
+	"animation-delay",
+	"transition-delay",
+	"order",
+	"z-index"
+]);
+function allowsNegativeToken(utility) {
+	if (utility.emit.type !== "property") return false;
+	const { property } = utility.emit;
+	return property.startsWith("margin") || property.startsWith("scroll-margin") || property.startsWith("inset") || NEGATIVE_PROPERTIES.has(property);
+}
+const variableReference = (name) => `var(${cssEscape(`--${name}`)})`;
+function resolveUtilityValue(value, utility, program) {
+	const slash = value.indexOf("/");
+	if (slash >= 0) {
+		const name = utilityVariable(utility, value.slice(0, slash), program);
+		const variable = name === void 0 ? void 0 : program.variables.get(name);
+		if (!variable?.namespace.startsWith("color")) return;
+		const percentage = alphaPercentage(value.slice(slash + 1));
+		if (percentage === void 0) return;
+		return [`color-mix(in oklab,${variableReference(variable.name)} ${percentage}%,transparent)`, [variable.name]];
+	}
+	const negative = value[0] === "-";
+	const name = utilityVariable(utility, negative ? value.slice(1) : value, program);
+	const variable = name === void 0 ? void 0 : program.variables.get(name);
+	if (!variable || negative && variable.variableType !== "number") return;
+	const reference = variableReference(variable.name);
+	return [negative ? `calc(${reference} * -1)` : reference, [variable.name]];
+}
+function resolveUtilityAliasValue(value, utility, program) {
+	const slash = value.indexOf("/");
+	const key = slash < 0 ? value : value.slice(0, slash);
+	if (utilityVariable(utility, key[0] === "-" ? key.slice(1) : key, program) === void 0) return;
+	return resolveUtilityValue(value, utility, program);
+}
+/** The recipe arguments of a token key: the variable, or the key as a CSS string for string parameters. */
+function namedArguments(key, utility, program) {
+	const keyArgument = utility.emit.type === "recipe" && utility.emit.key;
+	if (keyArgument && key.includes("--")) return;
+	const variable = utilityVariable(utility, key, program);
+	if (variable === void 0) return;
+	if (!keyArgument) return [[`var(--${variable})`], [variable]];
+	return [[`"${key.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`], [variable]];
+}
+function matchUtility(className, utility, program, type) {
+	for (const matcher of utility.matchers) {
+		if (matcher.type !== type) continue;
+		if (matcher.type === "static") {
+			const rest = className.slice(matcher.name.length);
+			if (className.startsWith(matcher.name) && isMatchStateBoundary(rest)) return {
+				arguments: [],
+				stateToken: rest,
+				variableNames: [],
+				matcherType: "static"
+			};
+		} else if (matcher.type === "token") {
+			const { prefix } = matcher;
+			let negative = false;
+			let raw;
+			if (className.startsWith(prefix)) raw = className.slice(prefix.length);
+			else if (className[0] === "-" && className.startsWith(prefix, 1)) {
+				negative = true;
+				raw = className.slice(prefix.length + 1);
+			} else continue;
+			const [value, stateToken] = splitDynamicValueState(raw);
+			if (!value || hasTopLevelValueSeparator(value) || value[0] === "-") continue;
+			if (negative && !allowsNegativeToken(utility)) continue;
+			const token = negative ? `-${value}` : value;
+			if (utility.emit.type === "recipe") {
+				const named = namedArguments(token, utility, program);
+				if (named) return {
+					arguments: named[0],
+					stateToken,
+					variableNames: named[1],
+					matcherType: "token"
+				};
+			} else {
+				const resolved = resolveUtilityAliasValue(token, utility, program);
+				if (resolved) return {
+					value: resolved[0],
+					arguments: [],
+					stateToken,
+					variableNames: resolved[1],
+					matcherType: "token"
+				};
+			}
+		}
+	}
+}
+/** Master `|` separators outside strings become spaces; nothing else changes. */
+function normalizeUnmanagedValue(value) {
+	let output = "";
+	let copied = 0;
+	let quote = 0;
+	let escaped = false;
+	for (let index = 0; index < value.length; index++) {
+		const unit = value.charCodeAt(index);
+		if (escaped) escaped = false;
+		else if (unit === 92) escaped = true;
+		else if (quote) {
+			if (unit === quote) quote = 0;
+		} else if (isQuote(unit)) quote = unit;
+		else if (unit === 124) {
+			output += `${value.slice(copied, index)} `;
+			copied = index + 1;
+		}
+	}
+	return output + value.slice(copied);
+}
+/**
+* The registered recipe, arguments and state token a function class calls; null when
+* the class starts with a function no registered recipe takes, undefined otherwise.
+*/
+function functionInvocation(source, program) {
+	if (leadingFunctionName(source) === void 0) return;
+	const head = parseFunctionalClass(source);
+	if (typeof head !== "object") return null;
+	const index = program.functionUtilities.get(head.name);
+	const emit = index === void 0 ? void 0 : program.utilities[index].emit;
+	if (emit?.type !== "recipe") return null;
+	return [
+		index,
+		program.utilityDefinitions[emit.definition],
+		head.arguments.map((argument) => normalizeUnmanagedValue(trim(argument))),
+		head.suffix
+	];
+}
+/** The longest registered token prefix of a class, with or without its negative sign. */
+function tokenPrefix(source, program) {
+	if (source[0] === "(") return;
+	let longest;
+	for (const candidate of source[0] === "-" ? [source, source.slice(1)] : [source]) for (const prefix of program.tokenPrefixes.get(candidate[0]) ?? []) {
+		if (prefix[prefix.length - 1] !== "-" || !candidate.startsWith(prefix)) continue;
+		if (!longest || prefix.length >= longest.length) longest = prefix;
+		break;
+	}
+	return longest;
+}
+/** Utilities whose namespace owns the token key, before any sign or opacity applies. */
+function tokenOwners(source, prefix, program) {
+	const indexes = program.tokenUtilities.get(prefix);
+	if (!indexes) return [];
+	let raw;
+	if (source.startsWith(prefix)) raw = source.slice(prefix.length);
+	else if (source[0] === "-" && source.startsWith(prefix, 1)) raw = source.slice(prefix.length + 1);
+	else return [];
+	const [value] = splitDynamicValueState(raw);
+	if (!value || value[0] === "-" || hasTopLevelValueSeparator(value)) return [];
+	const slash = value.indexOf("/");
+	const key = slash < 0 ? value : value.slice(0, slash);
+	return indexes.filter((index) => utilityVariable(program.utilities[index], key, program) !== void 0);
+}
+/** The match of a token class whose key exactly one utility owns. */
+function tokenCandidates(source, prefix, program) {
+	const owners = tokenOwners(source, prefix, program);
+	if (owners.length !== 1) return [];
+	const matched = matchUtility(source, program.utilities[owners[0]], program, "token");
+	return matched ? [[owners[0], matched]] : [];
+}
+/**
+* The utilities a class (without `!`) matches, in priority order. A family is selected
+* before its token is looked up, so a missing qualified token never falls back to a
+* shorter prefix, and static names reserve their spelling. Native declaration heads
+* are never utilities.
+*/
+function matchingUtilities(source, program) {
+	const matches = [];
+	if (source[0] === "(") return matches;
+	const invocation = functionInvocation(source, program);
+	if (invocation !== void 0) {
+		if (!invocation) return matches;
+		const [index, recipe, args, stateToken] = invocation;
+		const expansion = expandUtility(program, recipe, args);
+		if (expansion) matches.push([index, {
+			arguments: args,
+			expansion,
+			stateToken,
+			variableNames: [],
+			matcherType: "function"
+		}]);
+		return matches;
+	}
+	let end = 0;
+	while (end < source.length && !isClassSuffixStart(source[end])) end++;
+	for (const index of program.staticUtilities.get(source.slice(0, end)) ?? []) {
+		const matched = matchUtility(source, program.utilities[index], program, "static");
+		if (matched) matches.push([index, matched]);
+	}
+	if (matches.length) return matches;
+	const prefix = tokenPrefix(source, program);
+	return prefix === void 0 ? matches : tokenCandidates(source, prefix, program);
+}
+export { functionInvocation, isVariableKey, matchingUtilities, tokenCandidates, tokenPrefix, utilityVariable };

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

@@ -0,0 +1,254 @@
+import { isAsciiCase, isAsciiDigit, isAsciiWhitespace, trimEnd } from "./text.js";
+import { tokenize } from "./css-syntax.js";
+// ../engine-js/src/value.ts
+const MATH_FUNCTIONS = [
+	"calc",
+	"min",
+	"max",
+	"clamp"
+];
+const isNumeric = (token) => token !== void 0 && (token.kind === 4 || token.kind === 5 || token.kind === 6);
+/** Normalizes the math functions of a value, leaving strings, comments and URLs opaque. */
+function normalizeCssMathFunctions(source) {
+	if (!source.includes("(")) return source;
+	const tokens = tokenize(source);
+	let output = "";
+	let copied = 0;
+	let index = 0;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		if (token.kind !== 3 || token.close < 0) {
+			index++;
+			continue;
+		}
+		const close = token.close;
+		index = close + 1;
+		if (isAsciiCase(token.value, "url")) continue;
+		const start = token.end;
+		const end = tokens[close].start;
+		let inner = normalizeCssMathFunctions(source.slice(start, end));
+		if (MATH_FUNCTIONS.some((name) => isAsciiCase(token.value, name))) inner = normalizeMathExpression(inner);
+		output += source.slice(copied, start) + inner;
+		copied = end;
+	}
+	return output + source.slice(copied);
+}
+/**
+* Spaces binary operators and commas. Token boundaries protect exponent signs and
+* escaped or quoted identifiers; signed adjacent numbers and numeric subtraction
+* inside compact dimensions are Master's two extensions to CSS tokenization.
+*/
+function normalizeMathExpression(source) {
+	const tokens = tokenize(source);
+	const edits = [];
+	let operand = false;
+	let index = 0;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		const raw = source.slice(token.start, token.end);
+		if (token.close >= 0) {
+			if (token.kind === 8 && token.value === "(") {
+				const start = token.end;
+				const end = tokens[token.close].start;
+				edits.push([
+					start,
+					end,
+					normalizeMathExpression(source.slice(start, end))
+				]);
+			}
+			operand = true;
+			index = token.close + 1;
+			continue;
+		}
+		if (isNumeric(token)) {
+			if (operand && (raw[0] === "+" || raw[0] === "-")) edits.push([
+				token.start,
+				token.start + 1,
+				` ${raw[0]} `
+			]);
+			if (token.kind === 5 && !raw.includes("\\")) for (let minus = raw.indexOf("-", token.value.length); minus >= 0; minus = raw.indexOf("-", minus + 1)) {
+				const next = raw.charCodeAt(minus + 1);
+				if (minus + 1 === raw.length && tokens[index + 1]?.start === token.end && isNumeric(tokens[index + 1]) || isAsciiDigit(next) || next === 46 && isAsciiDigit(raw.charCodeAt(minus + 2))) {
+					edits.push([
+						token.start + minus,
+						token.end,
+						` - ${normalizeMathExpression(raw.slice(minus + 1))}`
+					]);
+					break;
+				}
+			}
+			operand = true;
+		} else if (token.kind === 8 && operand && "+-*/".includes(token.value)) {
+			edits.push([
+				token.start,
+				token.end,
+				` ${token.value} `
+			]);
+			operand = false;
+		} else if (token.kind === 8 && token.value === ",") {
+			edits.push([
+				token.start,
+				token.end,
+				", "
+			]);
+			operand = false;
+		} else operand = token.kind === 0;
+		index++;
+	}
+	for (const edit of edits) {
+		const replacement = edit[2];
+		if (replacement[0] !== " " && replacement[0] !== ",") continue;
+		if (replacement[0] === " ") while (edit[0] > 0 && isAsciiWhitespace(source.charCodeAt(edit[0] - 1))) edit[0]--;
+		while (edit[1] < source.length && isAsciiWhitespace(source.charCodeAt(edit[1]))) edit[1]++;
+	}
+	let output = "";
+	let copied = 0;
+	for (const [start, end, replacement] of edits) {
+		if (start < copied) continue;
+		output += source.slice(copied, start) + replacement;
+		copied = end;
+	}
+	return output + source.slice(copied);
+}
+const isVarReference = (tokens, index, end) => {
+	const name = tokens[index + 1];
+	return name?.kind === 0 && name.value.length > 2 && name.value.startsWith("--") && (index + 2 === end || tokens[index + 2]?.kind === 8 && tokens[index + 2].value === ",");
+};
+/** The custom properties a value references with `var()`, in source order, outside strings, comments and URLs. */
+function collectCssVariableReferences(source) {
+	const names = [];
+	if (!source.includes("(")) return names;
+	const tokens = tokenize(source);
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.kind !== 3) continue;
+		const end = token.close < 0 ? tokens.length : token.close;
+		if (isAsciiCase(token.value, "url")) {
+			index = Math.min(end + 1, tokens.length) - 1;
+			continue;
+		}
+		if (isAsciiCase(token.value, "var") && isVarReference(tokens, index, end)) {
+			const name = tokens[index + 1].value.slice(2);
+			if (!names.includes(name)) names.push(name);
+		}
+	}
+	return names;
+}
+/** Replaces `var()` references to inline theme tokens with their values. */
+function substituteInlineTokens(source, program) {
+	if (!program.hasInlineTokens || !source.includes("(")) return source;
+	const tokens = tokenize(source);
+	let result = "";
+	let copied = 0;
+	let index = 0;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		if (token.kind === 3 && token.close >= 0) {
+			const close = token.close;
+			if (isAsciiCase(token.value, "url")) {
+				index = close + 1;
+				continue;
+			}
+			const name = tokens[index + 1];
+			const value = isAsciiCase(token.value, "var") && name?.kind === 0 && name.value.startsWith("--") && (index + 2 === close || tokens[index + 2].kind === 8 && tokens[index + 2].value === ",") ? program.variables.get(name.value.slice(2))?.inlineValue : void 0;
+			if (value !== void 0) {
+				result += source.slice(copied, token.start) + value;
+				copied = tokens[close].end;
+				index = close + 1;
+				continue;
+			}
+		}
+		index++;
+	}
+	return result + source.slice(copied);
+}
+/** A value without its trailing `!important`, and whether it had one. */
+function valueWithoutImportance(value) {
+	const tokens = tokenize(value);
+	const bang = tokens[tokens.length - 2];
+	const keyword = tokens[tokens.length - 1];
+	if (bang?.kind === 8 && bang.value === "!" && keyword.kind === 0 && isAsciiCase(keyword.value, "important")) return [trimEnd(value.slice(0, bang.start)), true];
+	return [value, false];
+}
+/**
+* The value an inlined variable reference becomes: the last declared value, unless an
+* earlier `!important` one outranks it; only when that value is an inline one.
+*/
+function selectedInlineValue(values) {
+	if (!values.some((entry) => entry.inline)) return;
+	let selected;
+	let selectedImportant = false;
+	for (const entry of values) {
+		const [value, important] = valueWithoutImportance(entry.value);
+		if (selectedImportant && !important) continue;
+		selected = [entry.inline, value];
+		selectedImportant = important;
+	}
+	return selected?.[0] ? selected[1] : void 0;
+}
+const DIGITS = /^\d*$/;
+function parseDecimal(text) {
+	const negative = text[0] === "-";
+	const unsigned = negative || text[0] === "+" ? text.slice(1) : text;
+	let mantissa = unsigned;
+	let exponent = 0;
+	const e = unsigned.search(/[eE]/);
+	if (e >= 0) {
+		const raw = unsigned.slice(e + 1);
+		const digits = raw[0] === "+" || raw[0] === "-" ? raw.slice(1) : raw;
+		if (!digits || !DIGITS.test(digits)) return;
+		const magnitude = Math.min(digits.replace(/^0+/, "").length > 7 ? Infinity : Number(digits), 1 << 20);
+		exponent = raw[0] === "-" ? -magnitude : magnitude;
+		mantissa = unsigned.slice(0, e);
+	}
+	const dot = mantissa.indexOf(".");
+	const integer = dot < 0 ? mantissa : mantissa.slice(0, dot);
+	const fraction = dot < 0 ? "" : mantissa.slice(dot + 1);
+	if (!integer && !fraction || !DIGITS.test(integer) || !DIGITS.test(fraction)) return;
+	const all = integer + fraction;
+	const leading = all.length - all.replace(/^0+/, "").length;
+	return {
+		negative,
+		digits: all.slice(leading).replace(/0+$/, ""),
+		point: integer.length - leading + exponent
+	};
+}
+/** `2^1024 − 2^970`, the least magnitude that `f64::from_str` rounds to infinity. */
+const F64_OVERFLOW = "179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792";
+/** Whether `f64::from_str` parses the number to a finite value. */
+function decimalIsFinite({ digits, point }) {
+	if (!digits || point !== 309) return !digits || point < 309;
+	for (let index = 0; index < 309; index++) {
+		const digit = digits[index] ?? "0";
+		if (digit !== F64_OVERFLOW[index]) return digit < F64_OVERFLOW[index];
+	}
+	return false;
+}
+/** Whether a digit string without leading zeros is below 2^53. */
+const belowTwo53 = (digits) => digits.length < 16 || digits.length === 16 && digits < "9007199254740992";
+/**
+* The number as Rust's `Decimal::to_f64` computes it: exact for at most 15 significant
+* digits within the exactly representable powers of ten, close to it otherwise.
+*/
+function decimalToNumber({ negative, digits, point }) {
+	const significant = digits.slice(0, 19);
+	const exponent = point - significant.length;
+	let value = Number(significant || "0");
+	if (belowTwo53(significant) && exponent >= -22 && exponent <= 22) value = exponent < 0 ? value / Number(`1e${-exponent}`) : value * Number(`1e${exponent}`);
+	else if (exponent > 22 && exponent - 22 <= 19 && belowTwo53(significant + "0".repeat(exponent - 22))) value = Number(significant + "0".repeat(exponent - 22)) * 1e22;
+	else for (let step = Math.min(Math.abs(exponent), 400); step > 0; step--) value = exponent < 0 ? value / 10 : value * 10;
+	return negative ? -value : value;
+}
+/** An opacity from 0 to 1 as a percentage, computed on its digits so `.07` is `7`, not `7.000000000000001`. */
+function alphaPercentage(alpha) {
+	const decimal = parseDecimal(alpha);
+	if (!decimal) return;
+	const { negative, digits } = decimal;
+	if (!digits) return "0";
+	if (negative || decimal.point > 1 || decimal.point === 1 && digits !== "1") return;
+	const point = decimal.point + 2;
+	if (point <= 0) return `0.${"0".repeat(-point)}${digits}`;
+	if (point >= digits.length) return digits + "0".repeat(point - digits.length);
+	return `${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+export { alphaPercentage, collectCssVariableReferences, decimalIsFinite, decimalToNumber, normalizeCssMathFunctions, parseDecimal, selectedInlineValue, substituteInlineTokens, valueWithoutImportance };

package/dist/engine.js

@@ -0,0 +1,86 @@
+import { MASTER_CSS_ENGINE_TRANSITION_VERSION } from "./protocol.js";
+import { NativeBindingError } from "./errors.js";
+import { loadNativeBinding } from "./native-loader.js";
+import { MasterCSSError } from "@master/css-schema";
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+// src/engine.ts
+function parse(value) {
+	return JSON.parse(value);
+}
+function globalsJSON(emittedGlobals) {
+	return emittedGlobals ? JSON.stringify(emittedGlobals) : void 0;
+}
+function bindingError(cause) {
+	if (cause instanceof MasterCSSError) return cause;
+	if (!(cause instanceof NativeBindingError)) throw cause;
+	return new MasterCSSError({
+		code: cause.code,
+		domain: "binding",
+		message: cause.message
+	}, { cause });
+}
+function createNativeEngineSession(options, moduleOptions = {}) {
+	try {
+		const loaded = loadNativeBinding(moduleOptions);
+		if (!loaded) return;
+		const { EngineSession } = loaded.binding;
+		const session = options.program ? EngineSession.fromProgram(options.program, globalsJSON(options.emittedGlobals)) : new EngineSession(serializeMasterCSSManifest(options.manifest), globalsJSON(options.emittedGlobals));
+		let disposed = false;
+		const dispose = () => {
+			if (disposed) return;
+			disposed = true;
+			session.dispose();
+		};
+		return {
+			ensureClassRules: (classNames) => parse(session.ensureClassRules([...classNames])),
+			deleteClassRules: (classNames) => parse(session.deleteClassRules([...classNames])),
+			registerEmittedGlobals: (emittedGlobals) => parse(session.registerEmittedGlobals(JSON.stringify(emittedGlobals))),
+			replaceEmittedGlobals: (emittedGlobals) => parse(session.replaceEmittedGlobals(JSON.stringify(emittedGlobals))),
+			refresh: (source, emittedGlobals) => parse(ArrayBuffer.isView(source) ? session.refreshProgram(source, globalsJSON(emittedGlobals)) : session.refresh(serializeMasterCSSManifest(source), globalsJSON(emittedGlobals))),
+			keyframeDefinitions: () => parse(session.keyframeDefinitions()),
+			executionState: (classNames) => parse(session.executionState([...classNames])),
+			inspect: (className) => parse(session.inspect(className)),
+			snapshot: () => parse(session.snapshot()),
+			dispose,
+			[Symbol.dispose]: dispose
+		};
+	} catch (cause) {
+		throw bindingError(cause);
+	}
+}
+function createNativeRenderSession(options, moduleOptions = {}) {
+	try {
+		const loaded = loadNativeBinding(moduleOptions);
+		if (!loaded) return;
+		const session = new loaded.binding.RenderSession(serializeMasterCSSManifest(options.manifest), globalsJSON(options.emittedGlobals));
+		let disposed = false;
+		const dispose = () => {
+			if (disposed) return;
+			disposed = true;
+			session.dispose();
+		};
+		return {
+			nativeDeclarationCandidates: (classNames) => parse(session.nativeDeclarationCandidates([...classNames])),
+			ensureClassRules: (classNames) => session.ensureClasses([...classNames]),
+			ensureStylesheetResources: (nativeCSS) => session.ensureStylesheetResources(nativeCSS),
+			emittedGlobals: () => parse(session.emittedGlobals()),
+			snapshot: () => parse(session.snapshot()),
+			snapshotForClassNames: (classNames) => parse(session.snapshotForClasses([...classNames])),
+			dispose,
+			[Symbol.dispose]: dispose
+		};
+	} catch (cause) {
+		throw bindingError(cause);
+	}
+}
+/** Compiles a manifest into the runtime program that browsers execute. */
+function compileNativeRuntimeProgram(manifest, moduleOptions = {}) {
+	try {
+		const loaded = loadNativeBinding(moduleOptions);
+		if (!loaded) return;
+		return new Uint8Array(loaded.binding.compileRuntimeProgram(serializeMasterCSSManifest(manifest)));
+	} catch (cause) {
+		throw bindingError(cause);
+	}
+}
+export { MASTER_CSS_ENGINE_TRANSITION_VERSION, compileNativeRuntimeProgram, createNativeEngineSession, createNativeRenderSession };

package/dist/errors.js

@@ -0,0 +1,10 @@
+// src/errors.ts
+var NativeBindingError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+		this.name = "NativeBindingError";
+	}
+};
+export { NativeBindingError };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION, MASTER_CSS_PROGRAM_VERSION, MasterCSSBinding, MasterCSSBindingFeature, MasterCSSBindingInfo, MasterCSSBindingSurface, MasterCSSEngineResolvedBinding, MasterCSSResolvedBinding } from "./protocol.js";
+import { MasterCSSBindingContractError, MasterCSSBindingRequirements, assertMasterCSSBindingInfo } from "./binding.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+export { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION, MASTER_CSS_PROGRAM_VERSION, type MasterCSSBinding, MasterCSSBindingContractError, type MasterCSSBindingFeature, type MasterCSSBindingInfo, type MasterCSSBindingLoadOptions, type MasterCSSBindingRequirements, type MasterCSSBindingSurface, type MasterCSSEngineResolvedBinding, type MasterCSSNativeBindingLoadOptions, type MasterCSSResolvedBinding, type MasterCSSWasmBindingLoadOptions, assertMasterCSSBindingInfo };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION, MASTER_CSS_PROGRAM_VERSION } from "./protocol.js";
+import { MasterCSSBindingContractError, assertMasterCSSBindingInfo } from "./binding.js";
+export { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION, MASTER_CSS_PROGRAM_VERSION, MasterCSSBindingContractError, assertMasterCSSBindingInfo };