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

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

@@ -0,0 +1,195 @@
+import { isAsciiCase, isAsciiWhitespace, trim } from "./text.js";
+import { tokenize } from "./css-syntax.js";
+import { nativeContent, splitTopLevel } from "./class-syntax.js";
+// ../engine-js/src/selector.ts
+/** Top-level selector list branches, each trimmed. */
+function splitSelectorList(source) {
+	const tokens = tokenize(source);
+	const branches = [];
+	let cursor = 0;
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.close >= 0) index = token.close;
+		else if (token.kind === 8 && token.value === ",") {
+			branches.push(trim(source.slice(cursor, token.start)));
+			cursor = token.end;
+		}
+	}
+	branches.push(trim(source.slice(cursor)));
+	return branches;
+}
+/** Replaces each nesting `&` outside attribute selectors; undefined when there is none. */
+function replaceNestingSelector(source, parent) {
+	const replacement = splitSelectorList(parent).length > 1 ? `:is(${parent})` : parent;
+	let result = "";
+	let cursor = 0;
+	let attributes = 0;
+	for (const token of tokenize(source)) {
+		if (token.kind !== 8) continue;
+		if (token.value === "[") attributes++;
+		else if (token.value === "]") attributes && attributes--;
+		else if (token.value === "&" && !attributes) {
+			result += source.slice(cursor, token.start) + replacement;
+			cursor = token.end;
+		}
+	}
+	return cursor ? result + source.slice(cursor) : void 0;
+}
+/** Rejects definite token structure errors, without a browser capability allowlist. */
+function validSelectorStructure(source) {
+	if (nativeContent(source) === void 0 || splitSelectorList(source).includes("")) return false;
+	const tokens = tokenize(source);
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.kind !== 8) continue;
+		if (token.value === "[") {
+			if (token.close < 0) return false;
+			index = token.close;
+		} else if (token.value === "." || token.value === "#") {
+			if (tokens[index + 1]?.kind !== 0) return false;
+		} else if ("<;{}@".includes(token.value)) return false;
+		else if (token.value === ":") {
+			const previous = tokens[index - 1];
+			const element = previous?.kind === 8 && previous.value === ":" && previous.end === token.start;
+			const next = tokens[index + 1];
+			if (!(next !== void 0 && next.start === token.end && (next.kind === 0 || next.kind === 3 || next.kind === 8 && next.value === ":" && !element))) return false;
+		}
+	}
+	return true;
+}
+const SELECTOR_LIST_FUNCTIONS = [
+	"is",
+	"where",
+	"not",
+	"has",
+	"host",
+	"host-context",
+	"slotted"
+];
+const NTH_FUNCTIONS = ["nth-child", "nth-last-child"];
+/** Turns descendant `_` into spaces, except inside attributes, strings, escapes and non-selector arguments. */
+function replaceSelectorUnderscores(source) {
+	const tokens = tokenize(source);
+	const protectedRanges = /* @__PURE__ */ new Map();
+	const protect = (start, end) => protectedRanges.has(start) || protectedRanges.set(start, end);
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.kind === 8 && token.value === "[" && token.close >= 0) {
+			protect(token.start, tokens[token.close].end);
+			index = token.close;
+			continue;
+		}
+		if (token.kind === 3 && token.close >= 0 && !SELECTOR_LIST_FUNCTIONS.some((name) => isAsciiCase(token.value, name))) {
+			const closeStart = tokens[token.close].start;
+			let start = closeStart;
+			if (NTH_FUNCTIONS.some((name) => isAsciiCase(token.value, name))) {
+				const of = tokens.slice(index + 1, token.close).find((item) => item.kind === 0 && isAsciiCase(item.value, "of"));
+				if (of) start = of.start;
+			}
+			if (start > token.end) protect(token.end, start);
+			if (start === closeStart) {
+				index = token.close;
+				continue;
+			}
+		}
+		if (token.kind === 1) protect(token.start, token.end);
+	}
+	let output = "";
+	let cursor = 0;
+	while (cursor < source.length) {
+		const end = protectedRanges.get(cursor);
+		if (end !== void 0) {
+			output += source.slice(cursor, end);
+			cursor = end;
+			continue;
+		}
+		if (source.startsWith("/*", cursor)) {
+			const close = source.indexOf("*/", cursor + 2);
+			const commentEnd = close < 0 ? source.length : close + 2;
+			output += source.slice(cursor, commentEnd);
+			cursor = commentEnd;
+			continue;
+		}
+		const unit = source.charCodeAt(cursor);
+		if (unit === 92) {
+			const start = cursor++;
+			let digits = 0;
+			while (digits < 6 && /[0-9a-fA-F]/.test(source[cursor] ?? "")) {
+				digits++;
+				cursor++;
+			}
+			if (!digits) cursor += cursor < source.length ? String.fromCodePoint(source.codePointAt(cursor)).length : 0;
+			else if (isAsciiWhitespace(source.charCodeAt(cursor))) cursor++;
+			output += source.slice(start, cursor);
+			continue;
+		}
+		output += unit === 95 && isDescendantUnderscore(source, tokens, cursor) ? " " : source[cursor];
+		cursor++;
+	}
+	return output;
+}
+function isDescendantUnderscore(source, tokens, cursor) {
+	if (source[cursor - 1] === "_" || source[cursor + 1] === "_") return false;
+	let before;
+	for (let index = tokens.length - 1; index >= 0; index--) if (tokens[index].start < cursor) {
+		before = source[Math.min(tokens[index].end, cursor) - 1];
+		break;
+	}
+	if (before !== void 0 && "(,.:#>+~|".includes(before)) return false;
+	const next = tokens.find((token) => token.end > cursor + 1);
+	if (!next) return false;
+	const after = source[Math.max(next.start, cursor + 1)];
+	return after !== void 0 && !")+,>~|".includes(after);
+}
+/** The template of a selector suffix, `&` before each top-level branch. */
+function selectorTokenToTemplate(selectorToken) {
+	return splitTopLevel(replaceSelectorUnderscores(selectorToken), ",").map((group) => `&${group}`).join(",");
+}
+const STATE_PRIORITIES = {
+	hover: 1,
+	focus: 2,
+	"focus-visible": 2,
+	active: 3,
+	disabled: 4
+};
+const statePriority = (name) => Object.hasOwn(STATE_PRIORITIES, name) ? STATE_PRIORITIES[name] : 0;
+const isIdentifierCharacter = (unit) => unit >= 48 && unit <= 57 || unit >= 65 && unit <= 90 || unit >= 97 && unit <= 122 || unit === 45 || unit === 95;
+/** Interaction states in a selector, so hover precedes focus, active and disabled. */
+function selectorPriority(selector) {
+	if (selector === void 0) return 0;
+	let total = 0;
+	let quote = "";
+	let index = 0;
+	while (index < selector.length) {
+		const character = selector[index];
+		if (quote) {
+			index++;
+			if (character === "\\") {
+				if (index < selector.length) index++;
+			} else if (character === quote) quote = "";
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			index++;
+			continue;
+		}
+		if (character === "[") {
+			const close = selector.indexOf("]", index + 1);
+			if (close >= 0) {
+				total += statePriority(trim(selector.slice(index + 1, close)));
+				index = close + 1;
+				continue;
+			}
+		}
+		if (isIdentifierCharacter(selector.charCodeAt(index))) {
+			const start = index++;
+			while (isIdentifierCharacter(selector.charCodeAt(index))) index++;
+			total += statePriority(selector.slice(start, index));
+			continue;
+		}
+		index++;
+	}
+	return total;
+}
+export { replaceNestingSelector, selectorPriority, selectorTokenToTemplate, splitSelectorList, validSelectorStructure };