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

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

@@ -0,0 +1,333 @@
+import { isAsciiCase, isAsciiDigit, isAsciiWhitespace, trim } from "./text.js";
+import { readName, startsIdentifier, tokenize } from "./css-syntax.js";
+// ../engine-js/src/class-syntax.ts
+const isOpen = (unit) => unit === 40 || unit === 91 || unit === 123;
+const isClose = (unit) => unit === 41 || unit === 93 || unit === 125;
+const isQuote = (unit) => unit === 34 || unit === 39;
+/**
+* Balanced native content outside strings, escapes and comments, or undefined. With
+* `decode`, Master's `|` separators become spaces.
+*/
+function content(source, decode) {
+	let result = "";
+	let copied = 0;
+	const stack = [];
+	let quote = 0;
+	let escaped = false;
+	let comment = false;
+	for (let index = 0; index < source.length; index++) {
+		const unit = source.charCodeAt(index);
+		if (comment) {
+			if (unit === 42 && source.charCodeAt(index + 1) === 47) {
+				index++;
+				comment = false;
+			}
+		} else if (escaped) escaped = false;
+		else if (unit === 92) escaped = true;
+		else if (quote) {
+			if (unit === quote) quote = 0;
+		} else if (unit === 47 && source.charCodeAt(index + 1) === 42) {
+			index++;
+			comment = true;
+		} else if (isQuote(unit)) quote = unit;
+		else if (unit === 40 || unit === 91) stack.push(unit);
+		else if (unit === 41) {
+			if (stack.pop() !== 40) return;
+		} else if (unit === 93) {
+			if (stack.pop() !== 91) return;
+		} else if ((unit === 123 || unit === 125 || unit === 59) && !stack.length) return;
+		else if (decode && unit === 124) {
+			result += `${source.slice(copied, index)} `;
+			copied = index + 1;
+		}
+	}
+	return !stack.length && !quote && !escaped && !comment ? result + source.slice(copied) : void 0;
+}
+const nativeContent = (source) => content(source, false);
+const decodeNativeContent = (source) => content(source, true);
+/** The characters that may begin a class suffix after a complete head. */
+const isClassSuffixStart = (character) => "!*>+~:[@_.#".includes(character);
+/** Whether a matched name may end here: the rest is empty or starts a state. */
+function isMatchStateBoundary(rest) {
+	return !rest.length || isClassSuffixStart(rest[0]);
+}
+/** The property range of a `(property:` prefix, the value start once its colon exists and whether the decoded property is custom. */
+function nativeDeclarationPrefix(source) {
+	if (source.charCodeAt(0) !== 40 || !startsIdentifier(source, 1)) return;
+	const [end, property] = readName(source, 1);
+	if (property === "--") return;
+	return [
+		[1, end],
+		source.charCodeAt(end) === 58 ? end + 1 : void 0,
+		property.startsWith("--")
+	];
+}
+/** The end of the string whose quote is at `start`, or undefined when it is unclosed or broken by a newline. */
+function skipString(source, start) {
+	const quote = source.charCodeAt(start);
+	for (let cursor = start + 1; cursor < source.length; cursor++) {
+		const unit = source.charCodeAt(cursor);
+		if (unit === 92) {
+			cursor++;
+			if (cursor >= source.length) return;
+		} else if (unit === 10 || unit === 13 || unit === 12) return;
+		else if (unit === quote) return cursor + 1;
+	}
+}
+/**
+* The end of an unquoted `url(` token whose contents start at `start`; brackets, braces
+* and pipes are URL text. Only CSS whitespace before `)` and non-printable code points
+* end it badly; other Unicode, including U+00A0 and U+0085, is URL text.
+*/
+function skipUrl(source, start) {
+	for (let cursor = start; cursor < source.length; cursor++) {
+		const unit = source.charCodeAt(cursor);
+		if (unit === 41) return cursor + 1;
+		if (unit === 92 && startsIdentifier(source, cursor)) cursor++;
+		else if (isAsciiWhitespace(unit)) {
+			while (cursor < source.length && isAsciiWhitespace(source.charCodeAt(cursor))) cursor++;
+			return source.charCodeAt(cursor) === 41 ? cursor + 1 : void 0;
+		} else if (isQuote(unit) || unit === 40 || unit === 92 || unit < 32 || unit === 127) return;
+	}
+}
+const OTHER_ITEM = -1;
+const IMPORTANT_ITEM = -2;
+/**
+* The closing parenthesis and top-level items of a declaration value. A bang is the end
+* of the last component before it, so a trailing `!important` never trims into an escape.
+*/
+function scanValue(source, start, custom) {
+	const stack = [];
+	const items = [];
+	let componentEnd = start;
+	let cursor = start;
+	while (cursor < source.length) {
+		const unit = source.charCodeAt(cursor);
+		const top = !stack.length;
+		if (isQuote(unit)) {
+			const end = skipString(source, cursor);
+			if (end === void 0) return;
+			cursor = componentEnd = end;
+			if (top) items.push(OTHER_ITEM);
+			continue;
+		}
+		if (unit === 47 && source.charCodeAt(cursor + 1) === 42) {
+			const end = source.indexOf("*/", cursor + 2);
+			if (end < 0) return;
+			cursor = componentEnd = end + 2;
+			continue;
+		}
+		if (startsIdentifier(source, cursor)) {
+			const [end, ident] = readName(source, cursor);
+			cursor = end;
+			if (source.charCodeAt(cursor) === 40) {
+				cursor++;
+				if (isAsciiCase(ident, "url") && !isQuote(source.charCodeAt(cursor))) {
+					const url = skipUrl(source, cursor);
+					if (url === void 0) return;
+					cursor = url;
+				} else stack.push(41);
+				if (top) items.push(OTHER_ITEM);
+			} else if (top) items.push(isAsciiCase(ident, "important") ? IMPORTANT_ITEM : OTHER_ITEM);
+			componentEnd = cursor;
+			continue;
+		}
+		if (unit === 124 || isAsciiWhitespace(unit)) {
+			cursor++;
+			continue;
+		}
+		if (unit === 92) return;
+		if (isOpen(unit)) {
+			if (unit === 123 && top && !custom) return;
+			stack.push(unit === 40 ? 41 : unit === 91 ? 93 : 125);
+			if (top) items.push(OTHER_ITEM);
+		} else if (unit === 41 && top) return [cursor, items];
+		else if (isClose(unit)) {
+			if (stack.pop() !== unit) return;
+		} else if (unit === 59 && top) return;
+		else if (unit === 33 && top) items.push(componentEnd);
+		else if (top) items.push(OTHER_ITEM);
+		cursor++;
+		componentEnd = cursor;
+	}
+}
+/**
+* Parses a class that starts with `(` as exactly one native declaration: undefined for
+* other classes, null for a malformed declaration, which never becomes another head.
+*/
+function parseNativeDeclaration(source) {
+	if (source.charCodeAt(0) !== 40) return;
+	const prefix = nativeDeclarationPrefix(source);
+	if (!prefix || prefix[1] === void 0) return null;
+	const [property, start, custom] = prefix;
+	const scan = scanValue(source, start, custom);
+	if (!scan) return null;
+	const [close, items] = scan;
+	const bang = items.length >= 2 && items[items.length - 1] === IMPORTANT_ITEM ? items[items.length - 2] : -1;
+	const important = bang >= 0;
+	const valueEnd = important ? Math.max(bang, start) : close;
+	if (!custom && items.length === (important ? 2 : 0)) return null;
+	const suffixStart = close + 1;
+	if (suffixStart < source.length && !isClassSuffixStart(source[suffixStart])) return null;
+	return {
+		property,
+		value: [start, valueEnd],
+		important,
+		suffixStart
+	};
+}
+/** Decodes Master's `|` value spaces outside strings, comments, escapes and URL tokens. */
+function decodeNativeValue(value) {
+	let output = "";
+	let cursor = 0;
+	while (cursor < value.length) {
+		const start = cursor;
+		const unit = value.charCodeAt(cursor);
+		if (isQuote(unit)) cursor = skipString(value, cursor) ?? value.length;
+		else if (unit === 47 && value.charCodeAt(cursor + 1) === 42) {
+			const end = value.indexOf("*/", cursor + 2);
+			cursor = end < 0 ? value.length : end + 2;
+		} else if (startsIdentifier(value, cursor)) {
+			const [end, ident] = readName(value, cursor);
+			cursor = end;
+			if (isAsciiCase(ident, "url") && value.charCodeAt(cursor) === 40 && !isQuote(value.charCodeAt(cursor + 1))) cursor = skipUrl(value, cursor + 1) ?? value.length;
+		} else if (unit === 124) {
+			output += " ";
+			cursor++;
+			continue;
+		} else cursor++;
+		output += value.slice(start, cursor);
+	}
+	return output;
+}
+/** Whether a class has a complete head and a structurally balanced suffix. */
+function validClassStructure(className) {
+	const source = className.endsWith("!") ? className.slice(0, -1) : className;
+	const head = parseNativeDeclaration(source);
+	if (head === null) return false;
+	return decodeNativeContent(head ? source.slice(head.suffixStart) : className) !== void 0;
+}
+/** Splits a dynamic value from the state that follows it at the first top-level state character. */
+function splitDynamicValueState(value) {
+	let quote = 0;
+	let escaped = false;
+	let depth = 0;
+	for (let index = 0; index < value.length; index++) {
+		const unit = value.charCodeAt(index);
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (unit === 92) {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (unit === quote) quote = 0;
+			continue;
+		}
+		if (isQuote(unit)) {
+			quote = unit;
+			continue;
+		}
+		if (unit === 91 && !depth) return [value.slice(0, index), value.slice(index)];
+		if (isOpen(unit)) {
+			depth++;
+			continue;
+		}
+		if (isClose(unit)) {
+			if (depth) depth--;
+			continue;
+		}
+		if (depth) continue;
+		let startsState;
+		if (unit === 46) startsState = !isAsciiDigit(value.charCodeAt(index + 1));
+		else if (unit === 35) {
+			const previous = value.charCodeAt(index - 1);
+			startsState = index > 0 && previous !== 124 && previous !== 32;
+		} else startsState = "!*>+~:@_".includes(value[index]);
+		if (startsState) return [value.slice(0, index), value.slice(index)];
+	}
+	return [value, ""];
+}
+function hasTopLevelValueSeparator(value) {
+	let quote = 0;
+	let escaped = false;
+	let depth = 0;
+	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 (isOpen(unit)) depth++;
+		else if (isClose(unit)) {
+			if (depth) depth--;
+		} else if (unit === 124 && !depth) return true;
+	}
+	return false;
+}
+/** Splits `source` at each top-level `delimiter`. */
+function splitTopLevel(source, delimiter) {
+	const result = [];
+	const separator = delimiter.charCodeAt(0);
+	let start = 0;
+	let depth = 0;
+	let quote = 0;
+	let escaped = false;
+	for (let index = 0; index < source.length; index++) {
+		const unit = source.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 (isOpen(unit)) depth++;
+		else if (isClose(unit)) {
+			if (depth) depth--;
+		} else if (unit === separator && !depth) {
+			result.push(source.slice(start, index));
+			start = index + 1;
+		}
+	}
+	result.push(source.slice(start));
+	return result;
+}
+/** Splits a state token into its selector and the conditions after each top-level `@`. */
+function splitStateToken(stateToken) {
+	const parts = splitTopLevel(stateToken, "@");
+	return [parts[0], parts.slice(1).filter((condition, index) => condition || index < parts.length - 2)];
+}
+/** A functional class head, `name(arguments)` before its suffix; undefined when the class does not start with a function. */
+function parseFunctionalClass(source) {
+	const tokens = tokenize(source);
+	const first = tokens[0];
+	if (first?.kind !== 3) return;
+	if (first.close < 0) return "Unclosed mixin argument list";
+	const close = first.close;
+	const suffixStart = tokens[close].end;
+	const suffix = source.slice(suffixStart);
+	if (suffix && !isClassSuffixStart(suffix[0])) return "Invalid suffix after mixin arguments";
+	const argumentsStart = first.end;
+	const argumentsEnd = tokens[close].start;
+	const ranges = [];
+	if (trim(source.slice(argumentsStart, argumentsEnd))) {
+		let start = argumentsStart;
+		for (let index = 1; index < close; index++) {
+			const token = tokens[index];
+			if (token.kind === 8 && token.value === ",") {
+				ranges.push([start, token.start]);
+				start = token.end;
+			} else if (token.close >= 0) index = token.close;
+		}
+		ranges.push([start, argumentsEnd]);
+		if (ranges.some(([start, end]) => !trim(source.slice(start, end)))) return "Empty mixin argument";
+	}
+	return {
+		name: first.value,
+		arguments: ranges.map(([start, end]) => source.slice(start, end)),
+		suffix
+	};
+}
+export { decodeNativeContent, decodeNativeValue, hasTopLevelValueSeparator, isClassSuffixStart, isMatchStateBoundary, isQuote, nativeContent, parseFunctionalClass, parseNativeDeclaration, splitDynamicValueState, splitStateToken, splitTopLevel, validClassStructure };