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

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

@@ -0,0 +1,440 @@
+import { asciiLowercase, isAsciiCase, isWhitespace, trim } from "./text.js";
+import { isNameCodePoint, tokenize } from "./css-syntax.js";
+import { decimalIsFinite, decimalToNumber, parseDecimal } from "./value.js";
+import { decodeNativeContent } from "./class-syntax.js";
+import { naturalCompare } from "./order.js";
+// ../engine-js/src/condition.ts
+const isDelim = (token, value) => token?.kind === 8 && token.value === value;
+const QUERY_KEYWORDS = [
+	"and",
+	"or",
+	"not",
+	"only"
+];
+const isKeyword = (name) => QUERY_KEYWORDS.some((keyword) => isAsciiCase(name, keyword));
+/**
+* A class query names one condition without the native group parentheses: `media(width>=50rem)`,
+* `media(print)`, `supports(display:grid)`, `container(card|width>=40rem)`. The prelude is the
+* native query the engine emits, with those parentheses restored.
+*/
+function parseNativeQuery(token) {
+	const parts = queryParts(token);
+	if (!parts) return;
+	const decoded = decodeNativeContent(parts[1]);
+	const prelude = decoded === void 0 ? void 0 : nativePrelude(parts[0], decoded);
+	return prelude === void 0 ? void 0 : {
+		kind: parts[0],
+		prelude
+	};
+}
+/** A balanced recognized query beyond the class grammar, which belongs in CSS. */
+function queryRequiresCss(token) {
+	const parts = queryParts(token);
+	if (!parts) return false;
+	const decoded = decodeNativeContent(parts[1]);
+	return decoded !== void 0 && nativePrelude(parts[0], decoded) === void 0 && legacyQuery(token) === void 0;
+}
+/** The class form of a query written with its native group parentheses: `media((width>=50rem))` → `media(width>=50rem)`. */
+function legacyQuery(token) {
+	const parts = queryParts(token);
+	if (!parts) return;
+	const [kind, body] = parts;
+	const open = body.indexOf("(");
+	if (open < 0 || !(open === 0 || body.slice(0, open).endsWith("|")) || !body.endsWith(")")) return;
+	let depth = 0;
+	for (let index = open; index < body.length; index++) if (body[index] === "(") depth++;
+	else if (body[index] === ")" && --depth === 0 && index !== body.length - 1) return;
+	const candidate = `${kind}(${body.slice(0, open)}${body.slice(open + 1, -1)})`;
+	return parseNativeQuery(candidate) ? candidate : void 0;
+}
+function queryParts(token) {
+	const open = token.indexOf("(");
+	const kind = token.slice(0, open);
+	if (open < 0 || kind !== "media" && kind !== "supports" && kind !== "container" || !token.endsWith(")")) return;
+	const body = token.slice(open + 1, -1);
+	return trim(body) ? [kind, body] : void 0;
+}
+/** Media Queries Level 4 media types, including the deprecated ones that match nothing. */
+const MEDIA_TYPES = [
+	"all",
+	"print",
+	"screen",
+	"tty",
+	"tv",
+	"projection",
+	"handheld",
+	"braille",
+	"embossed",
+	"aural",
+	"speech"
+];
+function nativePrelude(kind, prelude) {
+	const tokens = tokenize(prelude);
+	const isName = (token) => token?.kind === 0 && !isKeyword(token.value);
+	if (!tokens.length || tokens[0].kind === 0 && isKeyword(tokens[0].value)) return;
+	const start = kind === "container" && isName(tokens[0]) && tokens.length > 1 && tokens[1].kind !== 8 ? 1 : 0;
+	const condition = trim(prelude.slice(tokens[start].start));
+	const containerName = trim(prelude.slice(0, tokens[start].start));
+	const wrap = (text) => containerName ? `${containerName} ${text}` : text;
+	if (kind === "container" && tokens[start].kind === 3 && isAsciiCase(tokens[start].value, "style")) {
+		const end = tokens.length - 1;
+		const inner = tokens.slice(start + 1, end);
+		return tokens[start].close === end && inner[0]?.kind === 0 && inner[0].value.startsWith("--") && (inner.length === 1 || inner.length > 2 && isDelim(inner[1], ":") && simpleValue(tokens, start + 3, end)) ? wrap(condition) : void 0;
+	}
+	if (kind === "media" && tokens.length === 1) {
+		if (tokens[0].kind !== 0) return;
+		return MEDIA_TYPES.some((type) => isAsciiCase(tokens[0].value, type)) ? condition : `(${condition})`;
+	}
+	return simpleCondition(kind, tokens, start) ? wrap(`(${condition})`) : void 0;
+}
+/** One feature, declaration or range from `start` to the end, without its group parentheses. */
+function simpleCondition(kind, tokens, start) {
+	const end = tokens.length;
+	const inner = tokens.slice(start);
+	if (!inner.length) return false;
+	const isName = (token) => token?.kind === 0 && !isKeyword(token.value);
+	const ident = isName(inner[0]);
+	const declaration = ident && inner.length > 2 && isDelim(inner[1], ":") && simpleValue(tokens, start + 2, end);
+	if (kind === "supports") return declaration;
+	if (ident && inner.length === 1) return true;
+	if (ident && inner.length > 2 && isDelim(inner[1], ":")) return declaration;
+	const operands = [];
+	const comparisons = [];
+	let index = start;
+	while (index < end) {
+		const token = tokens[index];
+		const name = isName(token);
+		if (!name && token.kind !== 4 && token.kind !== 5 && token.kind !== 6 && token.kind !== 3) return false;
+		operands.push(name);
+		index = token.close < 0 ? index + 1 : token.close + 1;
+		if (index + 1 < end && isDelim(tokens[index], "/") && tokens[index + 1].kind === 4) index += 2;
+		if (index === end) break;
+		const operator = tokens[index];
+		if (operator.kind !== 8 || !"<>=".includes(operator.value)) return false;
+		index++;
+		if (operator.value !== "=" && index < end && isDelim(tokens[index], "=")) index++;
+		comparisons.push(operator.value);
+		if (index === end) return false;
+	}
+	if (comparisons.length === 1) return operands.length === 2 && operands.filter(Boolean).length === 1;
+	return comparisons.length === 2 && comparisons[0] === comparisons[1] && comparisons[0] !== "=" && operands.length === 3 && !operands[0] && operands[1] && !operands[2];
+}
+/** A feature value without query structure: functions only, no bare groups or separators. */
+function simpleValue(tokens, index, end) {
+	while (index < end) {
+		const token = tokens[index];
+		if (token.kind === 8 && "|;{}".includes(token.value)) return false;
+		if (token.close >= 0) {
+			if (token.kind !== 3) return false;
+			index = token.close + 1;
+		} else index++;
+	}
+	return true;
+}
+function resolveLayerCondition(token) {
+	if (!token.startsWith("layer(") || !token.endsWith(")")) return;
+	const name = token.slice(6, -1);
+	return name === "base" || name === "defaults" || name === "components" || name === "utilities" ? name : void 0;
+}
+/** A condition's wrapper rule and its kind, for conditions that are not custom media or layers. */
+function renderConditionToken(token, program) {
+	if (token === "starting-style") return ["starting-style", "@starting-style"];
+	const query = parseNativeQuery(token);
+	if (!query) return;
+	let prelude = query.prelude;
+	const tokens = tokenize(prelude);
+	const open = tokens.length - 3;
+	const name = tokens[open + 1];
+	if (query.kind === "container" && isDelim(tokens[open], "(") && tokens[open].close === open + 2 && name.kind === 0 && name.value.startsWith("--") && name.value.length > 2) {
+		const condition = program.customContainers.get(name.value);
+		prelude = condition === void 0 ? condition : prelude.slice(0, tokens[open].start) + condition;
+	}
+	return prelude === void 0 ? void 0 : [query.kind, `@${query.kind} ${prelude}`];
+}
+const RANGE_FEATURES = /* @__PURE__ */ new Set([
+	"width",
+	"height",
+	"resolution",
+	"aspect-ratio"
+]);
+function rangeDimension(value) {
+	const end = value.search(/[^0-9.+-]/);
+	const decimal = parseDecimal(end < 0 ? value : value.slice(0, end));
+	const unit = end < 0 ? "" : value.slice(end);
+	if (!decimal || !decimalIsFinite(decimal) || !/^[a-zA-Z%]*$/.test(unit)) return;
+	return [decimalToNumber(decimal), asciiLowercase(unit)];
+}
+function intersectRange(target, source) {
+	const lower = source.lower;
+	if (lower) {
+		if (target.lower && target.lower.value === lower.value) target.lower.inclusive &&= lower.inclusive;
+		else if (!target.lower || !(target.lower.value > lower.value)) target.lower = { ...lower };
+	}
+	const upper = source.upper;
+	if (upper) {
+		if (target.upper && target.upper.value === upper.value) target.upper.inclusive &&= upper.inclusive;
+		else if (!target.upper || !(target.upper.value < upper.value)) target.upper = { ...upper };
+	}
+}
+function addConditionFeature(features, name, operator, value) {
+	const colon = name.indexOf(":");
+	const feature = colon < 0 ? name : name.slice(0, colon);
+	const unit = colon < 0 ? "" : name.slice(colon + 1);
+	const bound = {
+		value,
+		inclusive: operator.includes("=")
+	};
+	const source = {
+		domain: "",
+		feature,
+		unit,
+		lower: null,
+		upper: null
+	};
+	if (operator === ">" || operator === ">=") source.lower = bound;
+	else if (operator === "<" || operator === "<=") source.upper = bound;
+	else if (operator === "=") {
+		source.lower = bound;
+		source.upper = { ...bound };
+	} else return;
+	const target = features.find((item) => item.feature === feature && item.unit === unit);
+	if (target) intersectRange(target, source);
+	else features.push(source);
+}
+const REVERSED = {
+	">": "<",
+	">=": "<=",
+	"<": ">",
+	"<=": ">=",
+	"=": "="
+};
+function addRangeFeatures(features, body) {
+	const colon = body.indexOf(":");
+	if (colon >= 0) {
+		let name = trim(body.slice(0, colon));
+		let operator = "=";
+		if (name.startsWith("min-")) [name, operator] = [name.slice(4), ">="];
+		else if (name.startsWith("max-")) [name, operator] = [name.slice(4), "<="];
+		const dimension = rangeDimension(trim(body.slice(colon + 1)));
+		if (!dimension || !RANGE_FEATURES.has(name)) return false;
+		addConditionFeature(features, `${name}:${dimension[1]}`, operator, dimension[0]);
+		return true;
+	}
+	const operands = [];
+	const operators = [];
+	let remaining = body;
+	for (let index = remaining.search(/[<>=]/); index >= 0; index = remaining.search(/[<>=]/)) {
+		operands.push(trim(remaining.slice(0, index)));
+		remaining = remaining.slice(index);
+		const end = remaining.search(/[^<>=]/);
+		operators.push(end < 0 ? remaining : remaining.slice(0, end));
+		remaining = end < 0 ? "" : remaining.slice(end);
+	}
+	operands.push(trim(remaining));
+	if (!operators.length || operators.length > 2) return false;
+	if (operators.length === 2 && (!RANGE_FEATURES.has(operands[1]) || operators[0][0] === "=" || operators[0][0] !== operators[1][0])) return false;
+	for (const [index, operator] of operators.entries()) {
+		const [left, right] = [operands[index], operands[index + 1]];
+		let name;
+		let value;
+		let direction = operator;
+		if (RANGE_FEATURES.has(left)) [name, value] = [left, right];
+		else if (RANGE_FEATURES.has(right)) [name, value, direction] = [
+			right,
+			left,
+			Object.hasOwn(REVERSED, operator) ? REVERSED[operator] : void 0
+		];
+		else return false;
+		if (direction === void 0 || !Object.hasOwn(REVERSED, direction)) return false;
+		const dimension = rangeDimension(value);
+		if (!dimension) return false;
+		addConditionFeature(features, `${name}:${dimension[1]}`, direction, dimension[0]);
+	}
+	return true;
+}
+const sortFeatures = (features) => features.sort((left, right) => naturalCompare(left.domain, right.domain) || naturalCompare(left.feature, right.feature) || naturalCompare(left.unit, right.unit));
+/** Numeric ranges of a conjunction of simple range features with identical units; empty otherwise. */
+function nativeQueryFeatures(query) {
+	let domain;
+	let body;
+	if (query.startsWith("@media ")) {
+		domain = "media";
+		body = trim(query.slice(7));
+	} else if (query.startsWith("@container ")) {
+		body = trim(query.slice(11));
+		if (body[0] === "(") domain = "container:";
+		else {
+			let space = 0;
+			while (space < body.length && !isWhitespace(body.charCodeAt(space))) space++;
+			if (space === body.length) return [];
+			const name = body.slice(0, space);
+			for (let index = 0; index < name.length; index++) if (!isNameCodePoint(name.charCodeAt(index))) return [];
+			domain = `container:${name}`;
+			body = trim(body.slice(space + 1));
+		}
+	} else return [];
+	const features = [];
+	for (const part of body.split(" and ")) {
+		const trimmed = trim(part);
+		if (trimmed[0] !== "(" || !trimmed.endsWith(")")) return [];
+		const inner = trimmed.slice(1, -1);
+		if (/[()'"]/.test(inner) || !addRangeFeatures(features, trim(inner))) return [];
+	}
+	for (const feature of features) feature.domain = domain;
+	return sortFeatures(features);
+}
+function mergeConditionFeatures(target, source) {
+	for (const feature of source) {
+		const existing = target.find((item) => item.domain === "media" && item.domain === feature.domain && item.feature === feature.feature && item.unit === feature.unit);
+		if (existing) intersectRange(existing, feature);
+		else target.push(feature);
+	}
+	sortFeatures(target);
+}
+/**
+* Ordering evidence of condition wrappers. Only a wholly numeric media conjunction
+* intersects across wrappers; container ancestry and other conditions keep their order.
+*/
+function conditionPriority(wrappers) {
+	const parsed = wrappers.map(([, wrapper]) => nativeQueryFeatures(wrapper));
+	const mediaConjunction = wrappers.every(([kind], index) => kind === "media" && parsed[index].length);
+	const features = [];
+	const conditions = [];
+	for (const [index, [, wrapper]] of wrappers.entries()) {
+		const ranges = parsed[index];
+		if (!ranges.length) conditions.push(`${index}:${trim(wrapper)}`);
+		else if (mediaConjunction) mergeConditionFeatures(features, ranges);
+		else for (const range of ranges) {
+			range.domain = `${index}:${range.domain}`;
+			features.push(range);
+		}
+	}
+	return [features, conditions];
+}
+/** Unwinds the media query parser; never leaves it. */
+const MEDIA_ERROR = /* @__PURE__ */ new Error("Invalid media query");
+const MAX_MEDIA_DEPTH = 128;
+/** Parses a media query that references custom media, resolving `(--name)` through `resolve`. */
+function parseCustomMediaQuery(source, resolve) {
+	const tokens = tokenize(source);
+	if (tokens.length === 1 && tokens[0].kind === 0) {
+		if (isAsciiCase(tokens[0].value, "true")) return { type: "true" };
+		if (isAsciiCase(tokens[0].value, "false")) return { type: "false" };
+	}
+	let depth = 0;
+	for (const token of tokens) {
+		if (token.close >= 0 && ++depth > MAX_MEDIA_DEPTH) return;
+		if (token.kind === 8 && (token.value === ")" || token.value === "]" || token.value === "}") && depth) depth--;
+	}
+	const fail = () => {
+		throw MEDIA_ERROR;
+	};
+	const ident = (index, name) => tokens[index]?.kind === 0 && isAsciiCase(tokens[index].value, name);
+	const top = (start, end) => {
+		const result = [];
+		for (let index = start; index < end;) {
+			result.push(index);
+			const token = tokens[index];
+			if (token.kind === 3 || isDelim(token, "(") || isDelim(token, "[") || isDelim(token, "{")) {
+				if (token.close < 0 || token.close >= end) fail();
+				index = token.close + 1;
+			} else index++;
+		}
+		return result;
+	};
+	const list = (start, end) => {
+		const queries = [];
+		let cursor = start;
+		for (const index of top(start, end)) if (isDelim(tokens[index], ",")) {
+			queries.push(query(cursor, index));
+			cursor = index + 1;
+		}
+		queries.push(query(cursor, end));
+		return queries.length === 1 ? queries[0] : {
+			type: "or",
+			queries
+		};
+	};
+	const query = (start, end) => {
+		if (start >= end) fail();
+		const items = top(start, end);
+		const qualifier = ident(start, "not") || ident(start, "only");
+		const typeIndex = start + (qualifier ? 1 : 0);
+		const typeToken = tokens[typeIndex];
+		if (typeToken?.kind === 0) {
+			const name = typeToken.value;
+			if (isKeyword(name) || name.startsWith("--")) fail();
+			let result = isAsciiCase(name, "all") ? { type: "true" } : {
+				type: "media-type",
+				name: asciiLowercase(name)
+			};
+			if (typeIndex + 1 < end) {
+				if (!ident(typeIndex + 1, "and")) fail();
+				const inner = condition(typeIndex + 2, end);
+				if (top(typeIndex + 2, end).some((index) => ident(index, "or"))) fail();
+				result = {
+					type: "and",
+					queries: [result, inner]
+				};
+			}
+			return ident(start, "not") ? {
+				type: "not",
+				query: result
+			} : result;
+		}
+		if (qualifier && ident(start, "only")) fail();
+		if (!items.length) fail();
+		return condition(start, end);
+	};
+	const condition = (start, end) => {
+		const items = top(start, end);
+		if (!items.length) fail();
+		if (ident(start, "not")) {
+			if (items.length !== 2) fail();
+			return {
+				type: "not",
+				query: atom(items[1], end)
+			};
+		}
+		const queries = [];
+		let operator;
+		for (const [position, index] of items.entries()) {
+			if (position % 2 === 0) {
+				queries.push(atom(index, items[position + 1] ?? end));
+				continue;
+			}
+			const or = ident(index, "or") ? true : ident(index, "and") ? false : fail();
+			if (operator !== void 0 && operator !== or) fail();
+			operator = or;
+		}
+		if (items.length % 2 === 0) fail();
+		return operator === void 0 ? queries[0] : {
+			type: operator ? "or" : "and",
+			queries
+		};
+	};
+	const atom = (start, end) => {
+		const token = tokens[start];
+		if (token.close < 0 || token.close + 1 !== end) fail();
+		const close = token.close;
+		if (isDelim(token, "(")) {
+			const inner = top(start + 1, close);
+			if (inner.length === 1 && tokens[inner[0]].kind === 0 && tokens[inner[0]].value.startsWith("--")) return resolve(tokens[inner[0]].value) ?? fail();
+			const first = tokens[inner[0]];
+			if (first && (isDelim(first, "(") || first.kind === 3 || ident(inner[0], "not"))) return condition(start + 1, close);
+			if (inner.some((index) => tokens[index].kind === 0 && tokens[index].value.startsWith("--"))) fail();
+			if (!inner.length) fail();
+		} else if (token.kind !== 3) fail();
+		return {
+			type: "feature",
+			value: source.slice(token.start, tokens[close].end)
+		};
+	};
+	try {
+		return list(0, tokens.length);
+	} catch (error) {
+		if (error === MEDIA_ERROR) return;
+		throw error;
+	}
+}
+export { conditionPriority, legacyQuery, nativeQueryFeatures, parseCustomMediaQuery, parseNativeQuery, queryRequiresCss, renderConditionToken, resolveLayerCondition };

package/dist/engine-js/src/css-syntax.js

@@ -0,0 +1,247 @@
+import { isAsciiDigit } from "./text.js";
+const isNewline = (unit) => unit === 10 || unit === 13 || unit === 12;
+const isHex = (unit) => isAsciiDigit(unit) || unit >= 97 && unit <= 102 || unit >= 65 && unit <= 70;
+const isLetter = (unit) => unit >= 97 && unit <= 122 || unit >= 65 && unit <= 90;
+const isNameStart = (unit) => isLetter(unit) || unit === 95 || unit >= 128;
+const isCssWhitespace = (unit) => unit === 32 || unit === 9 || unit === 10 || unit === 13 || unit === 12;
+/** A CSS name code point: an ASCII letter or digit, `-`, `_` or any non-ASCII code point. */
+const isNameCodePoint = (unit) => isNameStart(unit) || isAsciiDigit(unit) || unit === 45;
+function startsIdentifier(source, index) {
+	if (index >= source.length) return false;
+	const validEscape = (at) => at < source.length && !isNewline(source.charCodeAt(at));
+	const first = source.charCodeAt(index);
+	if (first === 45) {
+		if (index + 1 >= source.length) return false;
+		const next = source.charCodeAt(index + 1);
+		return next === 92 ? validEscape(index + 2) : isNameStart(next) || next === 45;
+	}
+	return first === 92 ? validEscape(index + 1) : isNameStart(first);
+}
+/** The end of a signed CSS number with an optional fraction and exponent at `index`, or -1. */
+function numberEnd(source, index) {
+	let cursor = index;
+	const sign = source.charCodeAt(cursor);
+	if (sign === 43 || sign === 45) cursor++;
+	const start = cursor;
+	while (isAsciiDigit(source.charCodeAt(cursor))) cursor++;
+	if (source.charCodeAt(cursor) === 46 && isAsciiDigit(source.charCodeAt(cursor + 1))) {
+		cursor += 2;
+		while (isAsciiDigit(source.charCodeAt(cursor))) cursor++;
+	} else if (cursor === start) return -1;
+	const exponent = source.charCodeAt(cursor);
+	if (exponent === 101 || exponent === 69) {
+		let digits = cursor + 1;
+		const exponentSign = source.charCodeAt(digits);
+		if (exponentSign === 43 || exponentSign === 45) digits++;
+		if (isAsciiDigit(source.charCodeAt(digits))) {
+			cursor = digits + 1;
+			while (isAsciiDigit(source.charCodeAt(cursor))) cursor++;
+		}
+	}
+	return cursor;
+}
+let text = "";
+let at = 0;
+/** Consumes the escape whose backslash is at `at`. An escaped newline and the end of input decode to nothing. */
+function escape() {
+	at++;
+	if (at >= text.length) return "";
+	const first = text.charCodeAt(at);
+	if (isNewline(first)) {
+		at++;
+		if (first === 13 && text.charCodeAt(at) === 10) at++;
+		return "";
+	}
+	if (isHex(first)) {
+		const start = at;
+		while (at - start < 6 && isHex(text.charCodeAt(at))) at++;
+		const value = parseInt(text.slice(start, at), 16);
+		const whitespace = text.charCodeAt(at);
+		if (isCssWhitespace(whitespace)) {
+			at++;
+			if (whitespace === 13 && text.charCodeAt(at) === 10) at++;
+		}
+		return value === 0 || value > 1114111 || value >= 55296 && value <= 57343 ? "�" : String.fromCodePoint(value);
+	}
+	const character = String.fromCodePoint(text.codePointAt(at));
+	at += character.length;
+	return character;
+}
+function name() {
+	const start = at;
+	let decoded;
+	while (at < text.length) {
+		const unit = text.charCodeAt(at);
+		if (unit === 92 && at + 1 < text.length && !isNewline(text.charCodeAt(at + 1))) {
+			decoded ??= text.slice(start, at);
+			decoded += escape();
+		} else if (isNameCodePoint(unit)) {
+			at++;
+			if (decoded !== void 0) decoded += text[at - 1];
+		} else break;
+	}
+	return decoded ?? text.slice(start, at);
+}
+/** The end and decoded name of the identifier starting at `index`. */
+function readName(source, index) {
+	text = source;
+	at = index;
+	const value = name();
+	return [at, value];
+}
+function skipComment(source, index) {
+	const end = source.indexOf("*/", index + 2);
+	return end < 0 ? source.length : end + 2;
+}
+/** The name of the leading function token, without tokenizing the rest. */
+function leadingFunctionName(source) {
+	let index = 0;
+	while (index < source.length) {
+		const unit = source.charCodeAt(index);
+		if (isCssWhitespace(unit)) index++;
+		else if (unit === 47 && source.charCodeAt(index + 1) === 42) index = skipComment(source, index);
+		else break;
+	}
+	const unit = source.charCodeAt(index);
+	if (unit === 34 || unit === 39 || numberEnd(source, index) >= 0 || unit === 64 && startsIdentifier(source, index + 1)) return;
+	if (!startsIdentifier(source, index)) return;
+	text = source;
+	at = index;
+	const value = name();
+	return at > index && source.charCodeAt(at) === 40 ? value : void 0;
+}
+function tokenize(source) {
+	const tokens = [];
+	const opens = [];
+	text = source;
+	at = 0;
+	while (at < source.length) {
+		const start = at;
+		const unit = source.charCodeAt(at);
+		if (isCssWhitespace(unit)) {
+			at++;
+			continue;
+		}
+		if (unit === 47 && source.charCodeAt(at + 1) === 42) {
+			at = skipComment(source, at);
+			continue;
+		}
+		let kind;
+		let value = "";
+		let dimension = "";
+		let end;
+		if (unit === 34 || unit === 39) {
+			at++;
+			const contentStart = at;
+			let decoded;
+			let valid = true;
+			while (at < source.length) {
+				const next = source.charCodeAt(at);
+				if (next === unit) break;
+				if (isNewline(next)) {
+					valid = false;
+					break;
+				}
+				if (next === 92) {
+					decoded ??= source.slice(contentStart, at);
+					decoded += escape();
+				} else {
+					at++;
+					if (decoded !== void 0) decoded += source[at - 1];
+				}
+			}
+			value = decoded ?? source.slice(contentStart, at);
+			if (source.charCodeAt(at) === unit) at++;
+			kind = valid ? 1 : 7;
+		} else if ((end = numberEnd(source, at)) >= 0) {
+			at = end;
+			value = source.slice(start, at);
+			if (startsIdentifier(source, at)) {
+				kind = 5;
+				dimension = name();
+			} else if (source.charCodeAt(at) === 37) {
+				at++;
+				kind = 6;
+			} else kind = 4;
+		} else if (unit === 64 && startsIdentifier(source, at + 1)) {
+			at++;
+			value = name();
+			kind = value ? 2 : 8;
+			if (!value) value = "@";
+		} else if (startsIdentifier(source, at)) {
+			value = name();
+			if (at === start) {
+				at++;
+				kind = 7;
+			} else if (source.charCodeAt(at) === 40) {
+				at++;
+				kind = 3;
+			} else kind = 0;
+		} else {
+			at++;
+			kind = 8;
+			value = source[start];
+		}
+		const index = tokens.length;
+		if (kind === 3 || kind === 8 && (value === "(" || value === "[" || value === "{")) opens.push(index);
+		else if (kind === 8 && opens.length && closer(tokens[opens[opens.length - 1]]) === value) tokens[opens.pop()].close = index;
+		tokens.push({
+			kind,
+			value,
+			unit: dimension,
+			start,
+			end: at,
+			close: -1
+		});
+	}
+	return tokens;
+}
+const closer = (token) => token.kind === 3 || token.value === "(" ? ")" : token.value === "[" ? "]" : "}";
+const isDelim = (token, value) => token?.kind === 8 && token.value === value;
+/** Statement and block structure with parent indexes, as `collect_css_syntax_statements` walks it. */
+function collectStatements(tokens) {
+	const result = [];
+	const blocks = [[
+		0,
+		tokens.length,
+		-1
+	]];
+	while (blocks.length) {
+		let [start, end, parent] = blocks.pop();
+		while (start < end) {
+			if (isDelim(tokens[start], ";") || isDelim(tokens[start], "}")) {
+				start++;
+				continue;
+			}
+			const declaration = parent >= 0 && tokens[start].kind === 0 && isDelim(tokens[start + 1], ":");
+			const custom = declaration && tokens[start].value.startsWith("--");
+			let cursor = start;
+			while (cursor < end) {
+				const token = tokens[cursor];
+				if (isDelim(token, ";") || !custom && isDelim(token, "{")) break;
+				if (token.kind === 3 || isDelim(token, "(") || isDelim(token, "[") || isDelim(token, "{")) cursor = token.close < 0 ? end : token.close + 1;
+				else cursor++;
+			}
+			const hasBlock = cursor < end && isDelim(tokens[cursor], "{");
+			const index = result.length;
+			result.push({
+				start,
+				end: cursor,
+				parent,
+				hasBlock,
+				declaration: declaration && !hasBlock
+			});
+			if (hasBlock) {
+				const close = Math.min(tokens[cursor].close < 0 ? end : tokens[cursor].close, end);
+				blocks.push([
+					cursor + 1,
+					close,
+					index
+				]);
+				start = close + 1;
+			} else start = cursor + 1;
+		}
+	}
+	return result;
+}
+export { collectStatements, isCssWhitespace, isNameCodePoint, leadingFunctionName, numberEnd, readName, startsIdentifier, tokenize };