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

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

@@ -0,0 +1,97 @@
+import { asciiLowercase, compareText, isAsciiDigit } from "./text.js";
+// ../engine-js/src/order.ts
+const sign = (value) => value < 0 ? -1 : value > 0 ? 1 : 0;
+/** Rust `f64::total_cmp`; condition bounds are never NaN. */
+const compareNumber = (left, right) => left < right ? -1 : left > right ? 1 : Object.is(left, right) ? 0 : Object.is(left, -0) ? -1 : Object.is(right, -0) ? 1 : 0;
+/** Text order that compares runs of ASCII digits by value, then by spelling. */
+function naturalCompare(left, right) {
+	let i = 0;
+	const length = Math.min(left.length, right.length);
+	while (i < length && left.charCodeAt(i) === right.charCodeAt(i)) i++;
+	if (i === left.length && i === right.length) return 0;
+	while (i > 0 && isAsciiDigit(left.charCodeAt(i - 1))) i--;
+	let j = i;
+	for (;;) {
+		if (i >= left.length) return j >= right.length ? 0 : -1;
+		if (j >= right.length) return 1;
+		if (isAsciiDigit(left.charCodeAt(i)) && isAsciiDigit(right.charCodeAt(j))) {
+			const leftStart = i;
+			const rightStart = j;
+			while (isAsciiDigit(left.charCodeAt(i))) i++;
+			while (isAsciiDigit(right.charCodeAt(j))) j++;
+			const leftDigits = left.slice(leftStart, i);
+			const rightDigits = right.slice(rightStart, j);
+			const order = sign(leftDigits.replace(/^0+/, "").length - rightDigits.replace(/^0+/, "").length) || compareText(leftDigits, rightDigits);
+			if (order) return order;
+			continue;
+		}
+		const leftPoint = left.codePointAt(i);
+		const rightPoint = right.codePointAt(j);
+		if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
+		i += leftPoint > 65535 ? 2 : 1;
+		j += rightPoint > 65535 ? 2 : 1;
+	}
+}
+const lower = (range) => range.lower ? range.lower.value : -Infinity;
+const upper = (range) => range.upper ? range.upper.value : Infinity;
+/** Rust `Option<bool>` order: `None` before `false` before `true`. */
+const inclusiveRank = (bound) => bound ? bound.inclusive ? 2 : 1 : 0;
+function compareConditionFeatures(left, right) {
+	for (let index = 0; index < Math.max(left.length, right.length); index++) {
+		if (index >= left.length) return -1;
+		if (index >= right.length) return 1;
+		const a = left[index];
+		const b = right[index];
+		const identity = naturalCompare(a.domain, b.domain) || naturalCompare(a.feature, b.feature) || naturalCompare(a.unit, b.unit);
+		if (identity) return identity;
+		const order = (!a.upper && !b.upper ? compareNumber(lower(a), lower(b)) : !a.lower && !b.lower ? compareNumber(upper(b), upper(a)) : 0) || compareNumber(upper(b) - lower(b), upper(a) - lower(a)) || compareNumber(lower(b), lower(a)) || compareNumber(upper(b), upper(a)) || sign(inclusiveRank(b.lower) - inclusiveRank(a.lower)) || sign(inclusiveRank(b.upper) - inclusiveRank(a.upper));
+		if (order) return order;
+	}
+	return 0;
+}
+function compareConditions(left = [], right = []) {
+	for (let index = 0; index < Math.min(left.length, right.length); index++) {
+		const order = compareText(left[index], right[index]);
+		if (order) return order;
+	}
+	return sign(left.length - right.length);
+}
+function compareStoredRules(left, right) {
+	const a = left.ir;
+	const b = right.ir;
+	const p = a.priority;
+	const q = b.priority;
+	return sign(a.sortTier - b.sortTier) || compareConditionFeatures(left.features, right.features) || compareConditions(p.conditions, q.conditions) || sign(p.selector - q.selector) || sign(p.category - q.category) || compareText(p.family ?? "", q.family ?? "") || sign((p.coverage ?? 0) - (q.coverage ?? 0)) || p.category !== 1 && sign(a.type - b.type) || sign((p.valuePriority ?? 0) - (q.valuePriority ?? 0)) || compareText(p.property ?? "", q.property ?? "") || naturalCompare(p.sortKey ?? "", q.sortKey ?? "") || naturalCompare(a.key, b.key);
+}
+const atomicShape = (property, value) => {
+	const [family, coverage] = propertyFamily(property);
+	return {
+		category: 1,
+		family,
+		coverage,
+		property,
+		content: `${property}:${value}`
+	};
+};
+const BOX = /^(margin|padding|scroll-margin|scroll-padding|inset)(-(inline|block)(-start|-end)?|-(top|right|bottom|left))?$/;
+const BORDER = /^border(-(inline|block)(-start|-end)?|-(top|right|bottom|left))?-(width|style|color)$/;
+const AXIS = /^(?:(row|column)-gap|overflow-(?:x|y|inline|block))$/;
+const CORNER = /^border-(?:(?:top|bottom)-(?:left|right)|(?:start|end)-(?:start|end))-radius$/;
+const coverage = (side, axis, end) => side || end ? 2 : axis ? 1 : 0;
+/**
+* The family a property belongs to and its coverage in it, as `property_family` in the
+* engine's ordering.rs: 0 sets the whole family, 1 an axis and 2 one side or corner.
+* Custom properties are case-sensitive families of their own; other unlisted
+* properties, shorthands included, are their own family.
+*/
+function propertyFamily(property) {
+	if (property.startsWith("--")) return [property, 0];
+	property = asciiLowercase(property);
+	let match = BOX.exec(property);
+	if (match) return [match[1], coverage(match[5], match[3], match[4])];
+	if (/^(top|right|bottom|left)$/.test(property)) return ["inset", 2];
+	if (match = BORDER.exec(property)) return [`border-${match[5]}`, coverage(match[4], match[2], match[3])];
+	if (match = AXIS.exec(property)) return [match[1] ? "gap" : "overflow", 1];
+	return CORNER.test(property) ? ["border-radius", 2] : [property, 0];
+}
+export { atomicShape, compareConditionFeatures, compareStoredRules, naturalCompare, propertyFamily };

package/dist/engine-js/src/program-model.js

@@ -0,0 +1,19 @@
+// ../engine-js/src/program-model.ts
+const MIXIN_PARAMETER_SYNTAXES = [
+	"integer",
+	"number",
+	"string",
+	"custom-ident"
+];
+const UTILITY_KINDS = [
+	"static",
+	"token",
+	"function"
+];
+const UTILITY_LAYERS = [
+	"base",
+	"defaults",
+	"components",
+	"utilities"
+];
+export { MIXIN_PARAMETER_SYNTAXES, UTILITY_KINDS, UTILITY_LAYERS };

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

@@ -0,0 +1,434 @@
+import { MIXIN_PARAMETER_SYNTAXES, UTILITY_KINDS } from "./program-model.js";
+import { selectedInlineValue } from "./value.js";
+const MAGIC = [
+	77,
+	67,
+	83,
+	80
+];
+const MAX_DEPTH = 512;
+const MAX_U32 = 4294967295;
+var Malformed = class {
+	code;
+	message;
+	constructor(code, message) {
+		this.code = code;
+		this.message = message;
+	}
+};
+const invalid = (message) => {
+	throw new Malformed("INVALID_PROGRAM", message);
+};
+let bytes;
+let view;
+let position;
+let strings;
+let used;
+let depth;
+function byte() {
+	if (position >= bytes.length) invalid("truncated");
+	return bytes[position++];
+}
+/** An unsigned LEB128 varint. Values past 2^53 lose precision, but every use rejects them anyway. */
+function uint() {
+	let value = 0;
+	for (let shift = 0; shift < 64; shift += 7) {
+		const current = byte();
+		const bits = current & 127;
+		if (shift === 63 && bits > 1) invalid("integer overflow");
+		value += bits * 2 ** shift;
+		if (!(current & 128)) return value;
+	}
+	return invalid("integer overflow");
+}
+function u32() {
+	const value = uint();
+	return value > MAX_U32 ? invalid("integer overflow") : value;
+}
+function i32() {
+	const value = uint();
+	const decoded = value % 2 ? -(value + 1) / 2 : value / 2;
+	return decoded > 2147483647 || decoded < -2147483648 ? invalid("integer overflow") : decoded;
+}
+function length() {
+	const value = uint();
+	return value > bytes.length - position ? invalid("length exceeds input") : value;
+}
+function tag(variants) {
+	const value = byte();
+	return value >= variants ? invalid("unknown variant") : value;
+}
+function string() {
+	const reference = uint();
+	let index;
+	if (reference === 0) index = used++;
+	else if (reference - 1 < used) index = reference - 1;
+	else return invalid("unknown string");
+	return index < strings.length ? strings[index] : invalid("unknown string");
+}
+const bool = () => tag(2) === 1;
+const f64 = () => {
+	if (position + 8 > bytes.length) invalid("truncated");
+	const value = view.getFloat64(position, true);
+	position += 8;
+	return value;
+};
+const option = (decode) => tag(2) === 1 ? decode() : void 0;
+function vec(decode) {
+	const count = length();
+	const items = [];
+	for (let index = 0; index < count; index++) items.push(decode());
+	return items;
+}
+function nested(decode) {
+	if (++depth > MAX_DEPTH) invalid("nesting too deep");
+	const value = decode();
+	depth--;
+	return value;
+}
+const stringList = () => vec(string);
+const position32 = () => ({
+	line: u32(),
+	column: u32()
+});
+const sourceReference = () => {
+	return {
+		file: option(string),
+		range: {
+			start: u32(),
+			end: u32()
+		},
+		loc: option(() => ({
+			start: position32(),
+			end: position32()
+		}))
+	};
+};
+const source = () => option(sourceReference);
+function themeNode() {
+	return nested(() => tag(2) === 0 ? {
+		type: "rule",
+		prelude: string(),
+		children: vec(themeNode)
+	} : {
+		type: "declaration",
+		name: string(),
+		value: string(),
+		inline: bool(),
+		isStatic: bool()
+	});
+}
+function keyframe() {
+	return {
+		id: string(),
+		name: string(),
+		text: string(),
+		containers: vec(() => ({
+			id: string(),
+			prelude: string()
+		})),
+		native: bool(),
+		safelisted: bool(),
+		dependencies: stringList(),
+		source: source()
+	};
+}
+function mediaQuery() {
+	return nested(() => {
+		switch (tag(7)) {
+			case 0: return { type: "true" };
+			case 1: return { type: "false" };
+			case 2: return {
+				type: "feature",
+				value: string()
+			};
+			case 3: return {
+				type: "media-type",
+				name: string()
+			};
+			case 4: return {
+				type: "not",
+				query: mediaQuery()
+			};
+			case 5: return {
+				type: "and",
+				queries: vec(mediaQuery)
+			};
+			default: return {
+				type: "or",
+				queries: vec(mediaQuery)
+			};
+		}
+	});
+}
+function valuePart() {
+	return nested(() => tag(2) === 0 ? {
+		type: "text",
+		value: string()
+	} : {
+		type: "function",
+		name: string(),
+		value: vec(valuePart)
+	});
+}
+const mixinValue = () => vec(valuePart);
+function mixinNode() {
+	return nested(() => {
+		switch (tag(5)) {
+			case 0: return {
+				type: "declaration",
+				property: string(),
+				value: mixinValue(),
+				source: source()
+			};
+			case 1: return {
+				type: "rule",
+				selector: string(),
+				body: vec(mixinNode)
+			};
+			case 2: return {
+				type: "condition",
+				condition: string(),
+				body: vec(mixinNode)
+			};
+			case 3: return {
+				type: "apply",
+				name: string(),
+				arguments: vec(mixinValue),
+				contents: option(() => vec(mixinNode)),
+				source: source()
+			};
+			default: return {
+				type: "contents",
+				fallback: vec(mixinNode)
+			};
+		}
+	});
+}
+const mixinDefinition = () => ({
+	name: string(),
+	parameters: vec(() => ({
+		name: string(),
+		syntax: option(() => MIXIN_PARAMETER_SYNTAXES[tag(4)]),
+		default: option(string),
+		source: source()
+	})),
+	body: vec(mixinNode),
+	source: source()
+});
+const tokenFamily = () => ({
+	utility: string(),
+	prefix: string(),
+	namespace: string(),
+	argument: tag(2) === 0 ? "value" : "key",
+	properties: stringList()
+});
+function variable() {
+	const key = string();
+	const namespace = string();
+	const name = option(string) ?? (!namespace ? key : !key ? namespace : `${namespace}-${key}`);
+	const values = vec(() => ({
+		path: stringList(),
+		value: string(),
+		inline: bool(),
+		isStatic: bool()
+	}));
+	return {
+		name,
+		key,
+		namespace,
+		values,
+		numeric: option(() => ({
+			value: f64(),
+			unit: string()
+		})),
+		variableType: string(),
+		dependencies: stringList(),
+		inlineValue: selectedInlineValue(values),
+		isStatic: values.some((value) => value.isStatic)
+	};
+}
+function matcher() {
+	switch (tag(3)) {
+		case 0: return {
+			type: "static",
+			name: string()
+		};
+		case 1: return {
+			type: "token",
+			prefix: string()
+		};
+		default: return {
+			type: "function",
+			name: string()
+		};
+	}
+}
+const utility = () => ({
+	id: string(),
+	name: option(string),
+	utilityType: i32(),
+	variableAliasRefs: stringList(),
+	nativeFallback: false,
+	emit: tag(2) === 0 ? {
+		type: "recipe",
+		definition: u32(),
+		key: bool()
+	} : {
+		type: "property",
+		property: string()
+	},
+	matchers: vec(matcher)
+});
+/** `CSS.escape` as `mastercss_lexer::css_escape` implements it, code unit by code unit. */
+function cssEscape(value) {
+	if (value === "-") return "\\-";
+	let result = "";
+	for (let index = 0; index < value.length; index++) {
+		const unit = value.charCodeAt(index);
+		const digit = unit >= 48 && unit <= 57;
+		if (unit === 0) result += "�";
+		else if (unit <= 31 || unit === 127 || index === 0 && digit || index === 1 && digit && value.charCodeAt(0) === 45) result += `\\${unit.toString(16)} `;
+		else if (unit >= 128) result += unit >= 55296 && unit <= 57343 ? "�" : value[index];
+		else if (unit === 45 || unit === 95 || digit || unit >= 65 && unit <= 90 || unit >= 97 && unit <= 122) result += value[index];
+		else result += `\\${value[index]}`;
+	}
+	return result;
+}
+/** Disjunction of conjunctions of native media queries, as `custom_media_branches` builds it. */
+function customMediaBranches(query) {
+	let remaining = 32768;
+	const branches = (query, negate, level) => {
+		if (remaining === 0 || level > 128) return;
+		remaining--;
+		switch (query.type) {
+			case "true": return negate ? [] : [[]];
+			case "false": return negate ? [[]] : [];
+			case "feature": return [[negate ? `not ${query.value}` : query.value]];
+			case "media-type": {
+				const name = cssEscape(query.name);
+				return [[negate ? `not ${name}` : name]];
+			}
+			case "not": return branches(query.query, !negate, level + 1);
+			default: {
+				const and = query.type === "and" !== negate;
+				let result = and ? [[]] : [];
+				for (const item of query.queries) {
+					const next = branches(item, negate, level + 1);
+					if (!next) return;
+					if ((and ? result.length * next.length : result.length + next.length) > 4096) return;
+					result = and ? result.flatMap((prefix) => next.map((suffix) => [...prefix, ...suffix])) : [...result, ...next];
+				}
+				return result;
+			}
+		}
+	};
+	return branches(query, false, 0);
+}
+function push(map, key, value) {
+	const values = map.get(key);
+	if (values) values.push(value);
+	else map.set(key, [value]);
+}
+/** What `finish_program` derives: defaults, match order and indexes. */
+function finish(program, encoded) {
+	const utilities = encoded.map((entry) => ({
+		...entry,
+		name: entry.name ?? entry.id
+	}));
+	const isStatic = (entry) => entry.matchers.some((item) => item.type === "static");
+	program.utilities = [...utilities.filter(isStatic), ...utilities.filter((entry) => !isStatic(entry))];
+	for (const [index, entry] of program.utilities.entries()) for (const item of entry.matchers) if (item.type === "token") push(program.tokenUtilities, item.prefix, index);
+	else if (item.type === "function") program.functionUtilities.set(item.name, index);
+	else push(program.staticUtilities, item.name, index);
+	for (const prefix of program.tokenUtilities.keys()) push(program.tokenPrefixes, prefix[0] ?? "", prefix);
+	for (const prefixes of program.tokenPrefixes.values()) prefixes.sort((left, right) => right.length - left.length);
+}
+function decodeProgram(input) {
+	bytes = input;
+	view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+	position = 0;
+	strings = [];
+	used = 0;
+	depth = 0;
+	try {
+		if (MAGIC.some((value, index) => input[index] !== value)) invalid("not a Master CSS program");
+		position = MAGIC.length;
+		if (uint() !== 3 || uint() !== 18) throw new Malformed("UNSUPPORTED_PROGRAM_VERSION", "unsupported program version");
+		const decoder = new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		});
+		const count = length();
+		for (let index = 0; index < count; index++) {
+			const size = length();
+			try {
+				strings.push(decoder.decode(input.subarray(position, position + size)));
+			} catch {
+				invalid("invalid UTF-8");
+			}
+			position += size;
+		}
+		const program = {
+			theme: vec(themeNode),
+			keyframes: vec(keyframe),
+			animationVariables: new Map(vec(() => [string(), stringList()])),
+			customMedia: new Map(vec(() => [string(), mediaQuery()])),
+			customMediaPaths: /* @__PURE__ */ new Map(),
+			customContainers: new Map(vec(() => [string(), string()])),
+			mixins: vec(mixinDefinition),
+			utilityDefinitions: vec(() => ({
+				kind: UTILITY_KINDS[tag(3)],
+				recipe: mixinDefinition()
+			})),
+			tokenFamilies: vec(tokenFamily),
+			variables: /* @__PURE__ */ new Map(),
+			variableOrder: [],
+			hasInlineTokens: false,
+			utilities: [],
+			staticUtilities: /* @__PURE__ */ new Map(),
+			tokenUtilities: /* @__PURE__ */ new Map(),
+			functionUtilities: /* @__PURE__ */ new Map(),
+			tokenPrefixes: /* @__PURE__ */ new Map()
+		};
+		const variables = vec(variable);
+		const encoded = vec(utility);
+		if (position !== input.length || used !== strings.length) invalid("trailing bytes");
+		for (const entry of variables) {
+			program.variables.set(entry.name, entry);
+			program.variableOrder.push(entry.name);
+			if (entry.inlineValue !== void 0) program.hasInlineTokens = true;
+		}
+		if (program.variables.size !== variables.length) invalid("duplicate variable");
+		for (const entry of encoded) if (entry.emit.type === "recipe" && entry.emit.definition >= program.utilityDefinitions.length) invalid("unknown recipe");
+		for (const [name, query] of program.customMedia) {
+			const paths = customMediaBranches(query);
+			if (!paths) invalid("invalid custom media");
+			program.customMediaPaths.set(name, paths);
+		}
+		finish(program, encoded);
+		return {
+			ok: true,
+			program
+		};
+	} catch (error) {
+		if (error instanceof Malformed) return {
+			ok: false,
+			error: {
+				code: error.code,
+				message: error.message
+			}
+		};
+		if (error instanceof RangeError) return {
+			ok: false,
+			error: {
+				code: "INVALID_PROGRAM",
+				message: "nesting too deep"
+			}
+		};
+		throw error;
+	} finally {
+		bytes = view = strings = void 0;
+	}
+}
+export { cssEscape, customMediaBranches, decodeProgram };