@animus-ui/layergate 0.0.0-stage → 0.1.35

package/dist/sheet-BUnyt5Jt.cjs

@@ -0,0 +1,576 @@
+//#region src/tokenize.ts
+const isNewline = (c) => c === "\n" || c === "\r" || c === "\f";
+const isWhitespace = (c) => c === " " || c === "	" || isNewline(c);
+const isDigit = (c) => c !== void 0 && c >= "0" && c <= "9";
+const isHex = (c) => c !== void 0 && (c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F");
+const isNameStart = (c) => c !== void 0 && (c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_" || c.charCodeAt(0) >= 128);
+const isName = (c) => isNameStart(c) || isDigit(c) || c === "-";
+const isNonPrintable = (c) => {
+	if (c === void 0) return false;
+	const code = c.charCodeAt(0);
+	return code <= 8 || code === 11 || code >= 14 && code <= 31 || code === 127;
+};
+/** Whether the two code points at `at` start a valid escape. */
+function validEscape(css, at) {
+	return css[at] === "\\" && !isNewline(css[at + 1]) && at + 1 < css.length;
+}
+/** Whether the three code points at `at` would start an identifier. */
+function startsIdent(css, at) {
+	const c = css[at];
+	if (c === "-") return isNameStart(css[at + 1]) || css[at + 1] === "-" || validEscape(css, at + 1);
+	if (isNameStart(c)) return true;
+	return validEscape(css, at);
+}
+/** Whether the three code points at `at` would start a number. */
+function startsNumber(css, at) {
+	const c = css[at];
+	if (c === "+" || c === "-") return isDigit(css[at + 1]) || css[at + 1] === "." && isDigit(css[at + 2]);
+	if (c === ".") return isDigit(css[at + 1]);
+	return isDigit(c);
+}
+function tokenize(css) {
+	const tokens = [];
+	let at = 0;
+	/** Consumes an escape after its `\`, returning the code point. */
+	const escape = () => {
+		let hex = "";
+		while (hex.length < 6 && isHex(css[at])) hex += css[at++];
+		if (hex) {
+			if (css[at] === "\r" && css[at + 1] === "\n") at += 2;
+			else if (isWhitespace(css[at])) at += 1;
+			const code = Number.parseInt(hex, 16);
+			return code === 0 || code >= 55296 && code <= 57343 || code > 1114111 ? "�" : String.fromCodePoint(code);
+		}
+		if (at >= css.length) return "�";
+		const char = String.fromCodePoint(css.codePointAt(at));
+		at += char.length;
+		return char;
+	};
+	const name = () => {
+		let result = "";
+		for (;;) if (isName(css[at])) result += css[at++];
+		else if (validEscape(css, at)) {
+			at += 1;
+			result += escape();
+		} else return result;
+	};
+	const numeric = (start) => {
+		if (css[at] === "+" || css[at] === "-") at += 1;
+		while (isDigit(css[at])) at += 1;
+		if (css[at] === "." && isDigit(css[at + 1])) {
+			at += 1;
+			while (isDigit(css[at])) at += 1;
+		}
+		if ((css[at] === "e" || css[at] === "E") && (isDigit(css[at + 1]) || (css[at + 1] === "+" || css[at + 1] === "-") && isDigit(css[at + 2]))) {
+			at += 2;
+			while (isDigit(css[at])) at += 1;
+		}
+		const number = css.slice(start, at);
+		if (startsIdent(css, at)) {
+			const unit = name();
+			tokens.push({
+				type: "dimension",
+				start,
+				end: at,
+				value: number + unit
+			});
+		} else if (css[at] === "%") {
+			at += 1;
+			tokens.push({
+				type: "percentage",
+				start,
+				end: at,
+				value: number
+			});
+		} else tokens.push({
+			type: "number",
+			start,
+			end: at,
+			value: number
+		});
+	};
+	const string = (start, quote) => {
+		let value = "";
+		for (;;) {
+			const c = css[at];
+			if (c === void 0) break;
+			if (c === quote) {
+				at += 1;
+				break;
+			}
+			if (isNewline(c)) {
+				tokens.push({
+					type: "bad-string",
+					start,
+					end: at,
+					value
+				});
+				return;
+			}
+			if (c === "\\") {
+				if (at + 1 >= css.length) {
+					at += 1;
+					continue;
+				}
+				if (isNewline(css[at + 1])) {
+					at += css[at + 1] === "\r" && css[at + 2] === "\n" ? 3 : 2;
+					continue;
+				}
+				at += 1;
+				value += escape();
+				continue;
+			}
+			value += c;
+			at += 1;
+		}
+		tokens.push({
+			type: "string",
+			start,
+			end: at,
+			value
+		});
+	};
+	const badUrlRemnant = () => {
+		while (at < css.length) {
+			if (css[at] === ")") {
+				at += 1;
+				return;
+			}
+			if (validEscape(css, at)) {
+				at += 1;
+				escape();
+			} else at += 1;
+		}
+	};
+	const url = (start) => {
+		while (isWhitespace(css[at])) at += 1;
+		let value = "";
+		for (;;) {
+			const c = css[at];
+			if (c === void 0) break;
+			if (c === ")") {
+				at += 1;
+				break;
+			}
+			if (isWhitespace(c)) {
+				while (isWhitespace(css[at])) at += 1;
+				if (css[at] === ")" || css[at] === void 0) {
+					if (css[at] === ")") at += 1;
+					break;
+				}
+				badUrlRemnant();
+				tokens.push({
+					type: "bad-url",
+					start,
+					end: at,
+					value
+				});
+				return;
+			}
+			if (c === "\"" || c === "'" || c === "(" || isNonPrintable(c)) {
+				badUrlRemnant();
+				tokens.push({
+					type: "bad-url",
+					start,
+					end: at,
+					value
+				});
+				return;
+			}
+			if (c === "\\") {
+				if (validEscape(css, at)) {
+					at += 1;
+					value += escape();
+					continue;
+				}
+				badUrlRemnant();
+				tokens.push({
+					type: "bad-url",
+					start,
+					end: at,
+					value
+				});
+				return;
+			}
+			value += c;
+			at += 1;
+		}
+		tokens.push({
+			type: "url",
+			start,
+			end: at,
+			value
+		});
+	};
+	const identLike = (start) => {
+		const value = name();
+		if (value.toLowerCase() === "url" && css[at] === "(") {
+			at += 1;
+			let peek = at;
+			while (isWhitespace(css[peek]) && isWhitespace(css[peek + 1])) peek += 1;
+			const next = isWhitespace(css[peek]) ? css[peek + 1] : css[peek];
+			if (next === "\"" || next === "'") {
+				tokens.push({
+					type: "function",
+					start,
+					end: at,
+					value
+				});
+				return;
+			}
+			url(start);
+			return;
+		}
+		if (css[at] === "(") {
+			at += 1;
+			tokens.push({
+				type: "function",
+				start,
+				end: at,
+				value
+			});
+			return;
+		}
+		tokens.push({
+			type: "ident",
+			start,
+			end: at,
+			value
+		});
+	};
+	if (css.charCodeAt(0) === 65279) {
+		at = 1;
+		tokens.push({
+			type: "whitespace",
+			start: 0,
+			end: 1,
+			value: ""
+		});
+	}
+	while (at < css.length) {
+		const start = at;
+		const c = css[at];
+		if (c === "/" && css[at + 1] === "*") {
+			const close = css.indexOf("*/", at + 2);
+			at = close === -1 ? css.length : close + 2;
+			tokens.push({
+				type: "comment",
+				start,
+				end: at,
+				value: ""
+			});
+		} else if (isWhitespace(c)) {
+			while (isWhitespace(css[at])) at += 1;
+			tokens.push({
+				type: "whitespace",
+				start,
+				end: at,
+				value: ""
+			});
+		} else if (c === "\"" || c === "'") {
+			at += 1;
+			string(start, c);
+		} else if (c === "#") {
+			if (isName(css[at + 1]) || validEscape(css, at + 1)) {
+				at += 1;
+				const value = name();
+				tokens.push({
+					type: "hash",
+					start,
+					end: at,
+					value
+				});
+			} else {
+				at += 1;
+				tokens.push({
+					type: "delim",
+					start,
+					end: at,
+					value: c
+				});
+			}
+		} else if (c === "(" || c === ")" || c === "[" || c === "]" || c === "{" || c === "}" || c === "," || c === ":" || c === ";") {
+			at += 1;
+			tokens.push({
+				type: c,
+				start,
+				end: at,
+				value: ""
+			});
+		} else if (c === "+" || c === ".") {
+			if (startsNumber(css, at)) numeric(start);
+			else {
+				at += 1;
+				tokens.push({
+					type: "delim",
+					start,
+					end: at,
+					value: c
+				});
+			}
+		} else if (c === "-") {
+			if (startsNumber(css, at)) numeric(start);
+			else if (css[at + 1] === "-" && css[at + 2] === ">") {
+				at += 3;
+				tokens.push({
+					type: "cdc",
+					start,
+					end: at,
+					value: ""
+				});
+			} else if (startsIdent(css, at)) identLike(start);
+			else {
+				at += 1;
+				tokens.push({
+					type: "delim",
+					start,
+					end: at,
+					value: c
+				});
+			}
+		} else if (c === "<" && css.startsWith("!--", at + 1)) {
+			at += 4;
+			tokens.push({
+				type: "cdo",
+				start,
+				end: at,
+				value: ""
+			});
+		} else if (c === "@") {
+			at += 1;
+			if (startsIdent(css, at)) {
+				const value = name();
+				tokens.push({
+					type: "at-keyword",
+					start,
+					end: at,
+					value
+				});
+			} else tokens.push({
+				type: "delim",
+				start,
+				end: at,
+				value: c
+			});
+		} else if (c === "\\") {
+			if (validEscape(css, at)) identLike(start);
+			else {
+				at += 1;
+				tokens.push({
+					type: "delim",
+					start,
+					end: at,
+					value: c
+				});
+			}
+		} else if (isDigit(c)) numeric(start);
+		else if (isNameStart(c)) identLike(start);
+		else {
+			const char = String.fromCodePoint(css.codePointAt(at));
+			at += char.length;
+			tokens.push({
+				type: "delim",
+				start,
+				end: at,
+				value: char
+			});
+		}
+	}
+	return tokens;
+}
+//#endregion
+//#region src/sheet.ts
+/**
+* One stylesheet's structure, read from its tokens: the leading statements
+* (`@charset`, `@import`, `@namespace`, `@layer` statements), the URLs it
+* references and the effects a layer cannot hold back.
+*/
+const skippable = (token) => token.type === "whitespace" || token.type === "comment" || token.type === "cdo" || token.type === "cdc";
+/** The index of the first significant token at or after `at`, before `to`. */
+function significant(tokens, at, to = tokens.length) {
+	while (at < to && skippable(tokens[at])) at += 1;
+	return at;
+}
+function statementEnd(tokens, index) {
+	let depth = 0;
+	for (let at = index; at < tokens.length; at++) {
+		const type = tokens[at].type;
+		if (type === "(" || type === "[" || type === "function") depth += 1;
+		else if ((type === ")" || type === "]") && depth > 0) depth -= 1;
+		else if (depth === 0 && type === ";") return {
+			end: at + 1,
+			block: false
+		};
+		else if (depth === 0 && type === "{") return {
+			end: tokens.length,
+			block: true
+		};
+	}
+	return {
+		end: tokens.length,
+		block: false
+	};
+}
+/** The index of the token closing the function or `(` at `index`. */
+function closing(tokens, index) {
+	let depth = 0;
+	for (let at = index; at < tokens.length; at++) {
+		const type = tokens[at].type;
+		if (type === "(" || type === "function") depth += 1;
+		else if (type === ")" && --depth === 0) return at;
+	}
+	return tokens.length - 1;
+}
+/** An `@import`'s URL, layer, supports and media, from the tokens after
+*  its at-keyword (`from`) through its `;` (`to`, exclusive). */
+function readImport(css, tokens, from, to) {
+	const start = tokens[from - 1].start;
+	const last = tokens[to - 1];
+	const end = last.end;
+	let at = significant(tokens, from, to);
+	const target = tokens[at];
+	if (!target || at >= to) return null;
+	let url;
+	if (target.type === "string" || target.type === "url") {
+		url = target.value;
+		at += 1;
+	} else if (target.type === "function" && target.value.toLowerCase() === "url") {
+		const close = closing(tokens, at);
+		const inner = tokens[significant(tokens, at + 1, close)];
+		if (inner?.type !== "string") return null;
+		url = inner.value;
+		at = close + 1;
+	} else return null;
+	let layer = { kind: "none" };
+	at = significant(tokens, at, to);
+	let token = tokens[at];
+	if (token?.type === "ident" && token.value.toLowerCase() === "layer") {
+		layer = { kind: "anonymous" };
+		at += 1;
+	} else if (token?.type === "function" && token.value.toLowerCase() === "layer") {
+		const close = closing(tokens, at);
+		layer = {
+			kind: "named",
+			name: css.slice(token.end, tokens[close].start).trim()
+		};
+		at = close + 1;
+	}
+	let supports = null;
+	at = significant(tokens, at, to);
+	token = tokens[at];
+	if (token?.type === "function" && token.value.toLowerCase() === "supports") {
+		const close = closing(tokens, at);
+		supports = css.slice(token.end, tokens[close].start).trim();
+		at = close + 1;
+	}
+	at = significant(tokens, at, to);
+	token = tokens[at];
+	const mediaEnd = last.type === ";" ? last.start : end;
+	const media = token && at < to && token.type !== ";" ? css.slice(token.start, mediaEnd).trim() : "";
+	return {
+		start,
+		end,
+		url,
+		layer,
+		supports,
+		media
+	};
+}
+function readSheet(css) {
+	const tokens = tokenize(css);
+	const sheet = {
+		imports: [],
+		removed: [],
+		namespaces: [],
+		urls: [],
+		important: [],
+		keyframes: [],
+		animations: [],
+		ignoredImports: [],
+		layers: []
+	};
+	if (css.charCodeAt(0) === 65279) sheet.removed.push([0, 1]);
+	let index = significant(tokens, 0);
+	let leading = 0;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		const name = token.type === "at-keyword" ? token.value.toLowerCase() : "";
+		if (name !== "charset" && name !== "import" && name !== "namespace" && name !== "layer") break;
+		const { end, block } = statementEnd(tokens, index);
+		if (block) break;
+		const span = [token.start, tokens[end - 1].end];
+		if (name === "charset") sheet.removed.push(span);
+		else if (name === "import") {
+			const statement = readImport(css, tokens, index + 1, end);
+			if (statement) sheet.imports.push(statement);
+			sheet.removed.push(span);
+		} else if (name === "namespace") sheet.namespaces.push(token.start);
+		index = significant(tokens, end);
+		leading = index;
+	}
+	let previous;
+	let depth = 0;
+	for (let at = 0; at < tokens.length; at++) {
+		const token = tokens[at];
+		if (token.type === "{") depth += 1;
+		else if (token.type === "}" && depth > 0) depth -= 1;
+		else if (depth === 0 && token.type === "at-keyword") {
+			const name = token.value.toLowerCase();
+			if (name === "layer") {
+				let to = at + 1;
+				while (to < tokens.length && tokens[to].type !== "{" && tokens[to].type !== ";") to += 1;
+				const names = css.slice(token.end, tokens[to]?.start ?? css.length).split(",").map((part) => part.trim()).filter(Boolean);
+				sheet.layers.push({
+					at: token.start,
+					names
+				});
+			} else if (name === "import" && at >= leading) sheet.ignoredImports.push(token.start);
+		}
+		if (at < leading && sheet.removed.some(([from, to]) => token.start >= from && token.start < to)) continue;
+		if (token.type === "url") sheet.urls.push({
+			start: token.start,
+			end: token.end,
+			url: token.value,
+			kind: "token"
+		});
+		else if (token.type === "function") {
+			const fn = token.value.toLowerCase();
+			if (fn === "url" || fn === "src") {
+				const inner = tokens[significant(tokens, at + 1, closing(tokens, at))];
+				if (inner?.type === "string") sheet.urls.push({
+					start: inner.start,
+					end: inner.end,
+					url: inner.value,
+					kind: "string"
+				});
+			} else if (fn === "image-set" || fn === "-webkit-image-set") {
+				const close = closing(tokens, at);
+				let nesting = 0;
+				for (let inner = at + 1; inner < close; inner++) {
+					const candidate = tokens[inner];
+					if (candidate.type === "(" || candidate.type === "function") nesting += 1;
+					else if (candidate.type === ")") nesting -= 1;
+					else if (nesting === 0 && candidate.type === "string") sheet.urls.push({
+						start: candidate.start,
+						end: candidate.end,
+						url: candidate.value,
+						kind: "string"
+					});
+				}
+			}
+		} else if (token.type === "delim" && token.value === "!") {
+			const next = tokens[significant(tokens, at + 1)];
+			if (next?.type === "ident" && next.value.toLowerCase() === "important") sheet.important.push(token.start);
+		} else if (token.type === "at-keyword" && /^(-[a-z]+-)?keyframes$/i.test(token.value)) sheet.keyframes.push(token.start);
+		else if (token.type === "ident" && /^(-[a-z]+-)?animation(-name)?$/i.test(token.value) && (previous?.type === "{" || previous?.type === ";") && tokens[significant(tokens, at + 1)]?.type === ":") sheet.animations.push(token.start);
+		if (!skippable(token)) previous = token;
+	}
+	return sheet;
+}
+//#endregion
+Object.defineProperty(exports, "readSheet", {
+	enumerable: true,
+	get: function() {
+		return readSheet;
+	}
+});