@projectwallace/css-parser 0.13.4 → 0.13.6

package/dist/css-node-2ejJUrIw.js

@@ -0,0 +1,645 @@
+import { a as is_whitespace, c as str_starts_with, i as is_vendor_prefixed, t as parse_dimension } from "./parse-dimension-CCn_XRDe.js";
+//#region src/arena.ts
+let BYTES_PER_NODE = 36;
+const STYLESHEET = 1;
+const STYLE_RULE = 2;
+const AT_RULE = 3;
+const DECLARATION = 4;
+const SELECTOR = 5;
+const COMMENT = 6;
+const BLOCK = 7;
+const RAW = 8;
+const IDENTIFIER = 10;
+const NUMBER = 11;
+const DIMENSION = 12;
+const STRING = 13;
+const HASH = 14;
+const FUNCTION = 15;
+const OPERATOR = 16;
+const PARENTHESIS = 17;
+const URL = 18;
+const SELECTOR_LIST = 20;
+const TYPE_SELECTOR = 21;
+const CLASS_SELECTOR = 22;
+const ID_SELECTOR = 23;
+const ATTRIBUTE_SELECTOR = 24;
+const PSEUDO_CLASS_SELECTOR = 25;
+const PSEUDO_ELEMENT_SELECTOR = 26;
+const COMBINATOR = 27;
+const UNIVERSAL_SELECTOR = 28;
+const NESTING_SELECTOR = 29;
+const NTH_SELECTOR = 30;
+const NTH_OF_SELECTOR = 31;
+const LANG_SELECTOR = 56;
+const MEDIA_QUERY = 32;
+const MEDIA_FEATURE = 33;
+const MEDIA_TYPE = 34;
+const CONTAINER_QUERY = 35;
+const SUPPORTS_QUERY = 36;
+const LAYER_NAME = 37;
+const PRELUDE_OPERATOR = 38;
+const FEATURE_RANGE = 39;
+const AT_RULE_PRELUDE = 40;
+const VALUE = 50;
+const FLAG_IMPORTANT = 1;
+const ATTR_OPERATOR_NONE = 0;
+const ATTR_OPERATOR_EQUAL = 1;
+const ATTR_OPERATOR_TILDE_EQUAL = 2;
+const ATTR_OPERATOR_PIPE_EQUAL = 3;
+const ATTR_OPERATOR_CARET_EQUAL = 4;
+const ATTR_OPERATOR_DOLLAR_EQUAL = 5;
+const ATTR_OPERATOR_STAR_EQUAL = 6;
+const ATTR_FLAG_NONE = 0;
+const ATTR_FLAG_CASE_INSENSITIVE = 1;
+const ATTR_FLAG_CASE_SENSITIVE = 2;
+/** @internal */
+var CSSDataArena = class CSSDataArena {
+	buffer;
+	view;
+	capacity;
+	count;
+	growth_count;
+	overflow_lengths;
+	static GROWTH_FACTOR = 1.3;
+	static NODES_PER_KB = 325;
+	static CAPACITY_BUFFER = 1.2;
+	constructor(initial_capacity = 1024) {
+		this.capacity = initial_capacity;
+		this.count = 1;
+		this.growth_count = 0;
+		this.buffer = new ArrayBuffer(initial_capacity * BYTES_PER_NODE);
+		this.view = new DataView(this.buffer);
+		this.overflow_lengths = /* @__PURE__ */ new Map();
+	}
+	static capacity_for_source(source_length) {
+		let size_in_kb = source_length / 1024;
+		let estimated_nodes = Math.ceil(size_in_kb * CSSDataArena.NODES_PER_KB);
+		let capacity = Math.ceil(estimated_nodes * CSSDataArena.CAPACITY_BUFFER);
+		return Math.max(16, capacity);
+	}
+	get_count() {
+		return this.count;
+	}
+	get_capacity() {
+		return this.capacity;
+	}
+	get_growth_count() {
+		return this.growth_count;
+	}
+	node_offset(node_index) {
+		return node_index * BYTES_PER_NODE;
+	}
+	get_type(node_index) {
+		return this.view.getUint8(this.node_offset(node_index));
+	}
+	get_flags(node_index) {
+		return this.view.getUint8(this.node_offset(node_index) + 1);
+	}
+	get_start_offset(node_index) {
+		return this.view.getUint32(this.node_offset(node_index) + 12, true);
+	}
+	get_length(node_index) {
+		if (this.has_flag(node_index, 4)) {
+			const overflow_length = this.overflow_lengths.get(node_index);
+			if (overflow_length !== void 0) return overflow_length;
+		}
+		return this.view.getUint16(this.node_offset(node_index) + 2, true);
+	}
+	get_content_start(node_index) {
+		return this.get_start_offset(node_index) + this.view.getUint16(this.node_offset(node_index) + 16, true);
+	}
+	get_content_length(node_index) {
+		return this.view.getUint16(this.node_offset(node_index) + 20, true);
+	}
+	get_attr_operator(node_index) {
+		return this.view.getUint8(this.node_offset(node_index) + 32);
+	}
+	get_attr_flags(node_index) {
+		return this.view.getUint8(this.node_offset(node_index) + 33);
+	}
+	get_first_child(node_index) {
+		return this.view.getUint32(this.node_offset(node_index) + 4, true);
+	}
+	get_next_sibling(node_index) {
+		return this.view.getUint32(this.node_offset(node_index) + 8, true);
+	}
+	get_start_line(node_index) {
+		return this.view.getUint32(this.node_offset(node_index) + 24, true);
+	}
+	get_start_column(node_index) {
+		return this.view.getUint32(this.node_offset(node_index) + 28, true);
+	}
+	get_value_start(node_index) {
+		return this.get_start_offset(node_index) + this.view.getUint16(this.node_offset(node_index) + 18, true);
+	}
+	get_value_length(node_index) {
+		return this.view.getUint16(this.node_offset(node_index) + 22, true);
+	}
+	set_type(node_index, type) {
+		this.view.setUint8(this.node_offset(node_index), type);
+	}
+	set_flags(node_index, flags) {
+		this.view.setUint8(this.node_offset(node_index) + 1, flags);
+	}
+	set_length(node_index, length) {
+		if (length > 65535) {
+			this.view.setUint16(this.node_offset(node_index) + 2, 65535, true);
+			this.set_flag(node_index, 4);
+			this.overflow_lengths.set(node_index, length);
+		} else this.view.setUint16(this.node_offset(node_index) + 2, length, true);
+	}
+	set_content_start_delta(node_index, delta) {
+		this.view.setUint16(this.node_offset(node_index) + 16, delta, true);
+	}
+	set_content_length(node_index, length) {
+		this.view.setUint16(this.node_offset(node_index) + 20, length, true);
+	}
+	set_attr_operator(node_index, operator) {
+		this.view.setUint8(this.node_offset(node_index) + 32, operator);
+	}
+	set_attr_flags(node_index, flags) {
+		this.view.setUint8(this.node_offset(node_index) + 33, flags);
+	}
+	set_first_child(node_index, childIndex) {
+		this.view.setUint32(this.node_offset(node_index) + 4, childIndex, true);
+	}
+	set_next_sibling(node_index, siblingIndex) {
+		this.view.setUint32(this.node_offset(node_index) + 8, siblingIndex, true);
+	}
+	set_value_start_delta(node_index, delta) {
+		this.view.setUint16(this.node_offset(node_index) + 18, delta, true);
+	}
+	set_value_length(node_index, length) {
+		this.view.setUint16(this.node_offset(node_index) + 22, length, true);
+	}
+	grow() {
+		this.growth_count++;
+		let new_capacity = Math.ceil(this.capacity * CSSDataArena.GROWTH_FACTOR);
+		let new_buffer = new ArrayBuffer(new_capacity * BYTES_PER_NODE);
+		new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));
+		this.buffer = new_buffer;
+		this.view = new DataView(new_buffer);
+		this.capacity = new_capacity;
+	}
+	create_node(type, start_offset, length, start_line, start_column) {
+		if (this.count >= this.capacity) this.grow();
+		const node_index = this.count;
+		this.count++;
+		const offset = node_index * BYTES_PER_NODE;
+		this.view.setUint8(offset, type);
+		this.view.setUint32(offset + 12, start_offset, true);
+		this.view.setUint32(offset + 24, start_line, true);
+		this.view.setUint32(offset + 28, start_column, true);
+		this.set_length(node_index, length);
+		return node_index;
+	}
+	append_children(parent_index, children) {
+		if (children.length === 0) return;
+		const offset = this.node_offset(parent_index);
+		this.view.setUint32(offset + 4, children[0], true);
+		for (let i = 0; i < children.length - 1; i++) this.set_next_sibling(children[i], children[i + 1]);
+	}
+	has_children(node_index) {
+		return this.get_first_child(node_index) !== 0;
+	}
+	has_next_sibling(node_index) {
+		return this.get_next_sibling(node_index) !== 0;
+	}
+	set_flag(node_index, flag) {
+		let current_flags = this.get_flags(node_index);
+		this.set_flags(node_index, current_flags | flag);
+	}
+	clear_flag(node_index, flag) {
+		let current_flags = this.get_flags(node_index);
+		this.set_flags(node_index, current_flags & ~flag);
+	}
+	has_flag(node_index, flag) {
+		return (this.get_flags(node_index) & flag) !== 0;
+	}
+};
+//#endregion
+//#region src/css-node.ts
+const TYPE_NAMES = {
+	[1]: "StyleSheet",
+	[2]: "Rule",
+	[3]: "Atrule",
+	[4]: "Declaration",
+	[5]: "Selector",
+	[6]: "Comment",
+	[7]: "Block",
+	[8]: "Raw",
+	[10]: "Identifier",
+	[11]: "Number",
+	[12]: "Dimension",
+	[13]: "String",
+	[14]: "Hash",
+	[15]: "Function",
+	[16]: "Operator",
+	[17]: "Parentheses",
+	[18]: "Url",
+	[19]: "UnicodeRange",
+	[50]: "Value",
+	[20]: "SelectorList",
+	[21]: "TypeSelector",
+	[22]: "ClassSelector",
+	[23]: "IdSelector",
+	[24]: "AttributeSelector",
+	[25]: "PseudoClassSelector",
+	[26]: "PseudoElementSelector",
+	[27]: "Combinator",
+	[28]: "UniversalSelector",
+	[29]: "NestingSelector",
+	[30]: "Nth",
+	[31]: "NthOf",
+	[56]: "Lang",
+	[32]: "MediaQuery",
+	[33]: "Feature",
+	[34]: "MediaType",
+	[35]: "ContainerQuery",
+	[36]: "SupportsQuery",
+	[37]: "Layer",
+	[38]: "Operator",
+	[39]: "MediaFeatureRange",
+	[40]: "AtrulePrelude"
+};
+const ATTR_OPERATOR_NAMES = {
+	[0]: null,
+	[1]: "=",
+	[2]: "~=",
+	[3]: "|=",
+	[4]: "^=",
+	[5]: "$=",
+	[6]: "*="
+};
+const ATTR_FLAG_NAMES = {
+	[0]: null,
+	[1]: "i",
+	[2]: "s"
+};
+var CSSNode = class CSSNode {
+	arena;
+	source;
+	index;
+	constructor(arena, source, index) {
+		this.arena = arena;
+		this.source = source;
+		this.index = index;
+	}
+	/**
+	* @internal
+	* Get the arena (for internal/advanced use only)
+	*/
+	__get_arena() {
+		return this.arena;
+	}
+	get_content() {
+		let start = this.arena.get_content_start(this.index);
+		let length = this.arena.get_content_length(this.index);
+		if (length === 0) return "";
+		return this.source.substring(start, start + length);
+	}
+	/** Get node type as number (for performance) */
+	get type() {
+		return this.arena.get_type(this.index);
+	}
+	/** Get node type as human-readable string */
+	get type_name() {
+		return TYPE_NAMES[this.type] || "unknown";
+	}
+	/** Get the full text of this node from source */
+	get text() {
+		let start = this.arena.get_start_offset(this.index);
+		let length = this.arena.get_length(this.index);
+		return this.source.substring(start, start + length);
+	}
+	/** Get the "content" text (at-rule name for at-rules, layer name for import layers) */
+	get name() {
+		let { type } = this;
+		if (type === 4 || type === 16 || type === 5) return;
+		return this.get_content();
+	}
+	/**
+	* Alias for name (for declarations: "color" in "color: blue")
+	* More semantic than `name` for declaration nodes
+	*/
+	get property() {
+		let { type } = this;
+		if (type !== 4 && type !== 33) return;
+		return this.get_content();
+	}
+	/**
+	* Get the value text (for declarations: "blue" in "color: blue")
+	* For dimension/number nodes: returns the numeric value as a number
+	* For string nodes: returns the string content without quotes
+	* For URL nodes with quoted string: returns the string with quotes (consistent with STRING node)
+	* For URL nodes with unquoted URL: returns the URL content without quotes
+	*/
+	get value() {
+		let { type, text, first_child } = this;
+		if (type === 4 && first_child) return first_child;
+		if (type === 12) return parse_dimension(text).value;
+		if (type === 11) return Number.parseFloat(text);
+		if (type === 18) {
+			if (first_child?.type === 13) return first_child.text;
+			if (str_starts_with(text, "url(")) {
+				let open_paren = text.indexOf("(");
+				let close_paren = text.lastIndexOf(")");
+				if (open_paren !== -1 && close_paren !== -1 && close_paren > open_paren) return text.substring(open_paren + 1, close_paren).trim();
+			} else if (text.startsWith("\"") || text.startsWith("'")) return text;
+		}
+		if (type === 16) return this.get_content();
+		let start = this.arena.get_value_start(this.index);
+		let length = this.arena.get_value_length(this.index);
+		if (length === 0) return null;
+		return this.source.substring(start, start + length);
+	}
+	/** Get the numeric value for NUMBER and DIMENSION nodes, or null for other node types */
+	get value_as_number() {
+		let { text, type } = this;
+		if (type === 11) return Number.parseFloat(text);
+		if (type === 12) return parse_dimension(text).value;
+		return null;
+	}
+	/**
+	* Get the prelude node:
+	* - For at-rules: AT_RULE_PRELUDE wrapper containing structured prelude children (media queries, layer names, etc.)
+	* - For style rules: SELECTOR_LIST or SELECTOR node
+	* Returns null if no prelude exists
+	*/
+	get prelude() {
+		if (this.type === 3) {
+			let first = this.first_child;
+			if (first?.type === 40 || first?.type === 8) return first;
+			return null;
+		}
+		if (this.type === 2) return this.first_child;
+	}
+	/**
+	* Get the attribute operator (for attribute selectors: =, ~=, |=, ^=, $=, *=)
+	* Returns one of the ATTR_OPERATOR_* constants
+	*/
+	get attr_operator() {
+		if (this.type !== 24) return void 0;
+		return this.arena.get_attr_operator(this.index);
+	}
+	/**
+	* Get the attribute flags (for attribute selectors: i, s)
+	* Returns one of the ATTR_FLAG_* constants
+	*/
+	get attr_flags() {
+		if (this.type !== 24) return void 0;
+		return this.arena.get_attr_flags(this.index);
+	}
+	/** Get the unit for dimension nodes (e.g., "px" from "100px", "%" from "50%") */
+	get unit() {
+		if (this.type !== 12) return void 0;
+		return parse_dimension(this.text).unit;
+	}
+	/** Check if this declaration has !important */
+	get is_important() {
+		if (this.type !== 4) return void 0;
+		return this.arena.has_flag(this.index, 1);
+	}
+	/** Check if this declaration has a browser hack prefix */
+	get is_browserhack() {
+		if (this.type !== 4) return void 0;
+		return this.arena.has_flag(this.index, 128);
+	}
+	/** Check if this has a vendor prefix (computed on-demand) */
+	get is_vendor_prefixed() {
+		switch (this.type) {
+			case 4: return is_vendor_prefixed(this.get_content());
+			case 25:
+			case 26: return is_vendor_prefixed(this.get_content());
+			case 3: return is_vendor_prefixed(this.get_content());
+			case 15: return is_vendor_prefixed(this.get_content());
+			case 10: return is_vendor_prefixed(this.text);
+			default: return false;
+		}
+	}
+	/** Check if this node has an error */
+	get has_error() {
+		return this.arena.has_flag(this.index, 2);
+	}
+	/** Check if this node has a prelude (at-rules and style rules) */
+	get has_prelude() {
+		let { type } = this;
+		if (type === 3) return this.arena.get_value_length(this.index) > 0;
+		if (type === 2) return this.first_child !== null;
+		return false;
+	}
+	/** Check if this rule has a block { } */
+	get has_block() {
+		return this.arena.has_flag(this.index, 8);
+	}
+	/** Check if this style rule has declarations */
+	get has_declarations() {
+		return this.arena.has_flag(this.index, 32);
+	}
+	/** Get the block node (for style rules and at-rules with blocks) */
+	get block() {
+		let { type } = this;
+		if (type === 2) {
+			let first = this.first_child;
+			if (!first) return null;
+			let block_node = first.next_sibling;
+			if (block_node?.type === 7) return block_node;
+			return null;
+		}
+		if (type === 3) {
+			let child = this.first_child;
+			while (child) {
+				if (child.type === 7 && !child.next_sibling) return child;
+				child = child.next_sibling;
+			}
+			return null;
+		}
+		return null;
+	}
+	/** Check if this block is empty (no declarations or rules, only comments allowed) */
+	get is_empty() {
+		if (this.type !== 7) return void 0;
+		let child = this.first_child;
+		while (child) {
+			if (child.type !== 6) return false;
+			child = child.next_sibling;
+		}
+		return true;
+	}
+	/** Get start line number */
+	get line() {
+		return this.arena.get_start_line(this.index);
+	}
+	/** Get start column number */
+	get column() {
+		return this.arena.get_start_column(this.index);
+	}
+	/** Get start offset in source */
+	get start() {
+		return this.arena.get_start_offset(this.index);
+	}
+	/** Get length in source */
+	get length() {
+		return this.arena.get_length(this.index);
+	}
+	/**
+	* Get end offset in source
+	* End is not stored, must be calculated
+	*/
+	get end() {
+		return this.start + this.length;
+	}
+	/** Get first child node */
+	get first_child() {
+		let child_index = this.arena.get_first_child(this.index);
+		if (child_index === 0) return null;
+		return new CSSNode(this.arena, this.source, child_index);
+	}
+	/** Get next sibling node */
+	get next_sibling() {
+		let sibling_index = this.arena.get_next_sibling(this.index);
+		if (sibling_index === 0) return null;
+		return new CSSNode(this.arena, this.source, sibling_index);
+	}
+	/** Check if this node has a next sibling */
+	get has_next() {
+		return this.arena.get_next_sibling(this.index) !== 0;
+	}
+	/**
+	* Check if this node has children
+	* For pseudo-class/pseudo-element functions, returns true if FLAG_HAS_PARENS is set
+	* This allows formatters to distinguish :lang() from :hover
+	*/
+	get has_children() {
+		let { type } = this;
+		if (type === 25 || type === 26) {
+			if (this.arena.has_flag(this.index, 64)) return true;
+		}
+		return this.arena.has_children(this.index);
+	}
+	/** Get all children as an array */
+	get children() {
+		let result = [];
+		let child = this.first_child;
+		while (child) {
+			result.push(child);
+			child = child.next_sibling;
+		}
+		return result;
+	}
+	/** Make CSSNode iterable over its children */
+	*[Symbol.iterator]() {
+		let child = this.first_child;
+		while (child) {
+			yield child;
+			child = child.next_sibling;
+		}
+	}
+	/** Get the 'a' coefficient from An+B expression (e.g., "2n" from "2n+1", "odd" from "odd") */
+	get nth_a() {
+		let { type, arena, index } = this;
+		if (type !== 30 && type !== 31) return void 0;
+		let len = arena.get_content_length(index);
+		if (len === 0) return void 0;
+		let start = arena.get_content_start(index);
+		return this.source.substring(start, start + len);
+	}
+	/** Get the 'b' coefficient from An+B expression (e.g., "+1" from "2n+1") */
+	get nth_b() {
+		let { type, arena, index, source } = this;
+		if (type !== 30 && type !== 31) return void 0;
+		let len = arena.get_value_length(index);
+		if (len === 0) return void 0;
+		let start = arena.get_value_start(index);
+		let value = source.substring(start, start + len);
+		let check_pos = start - 1;
+		while (check_pos >= 0) {
+			let ch = source.charCodeAt(check_pos);
+			if (is_whitespace(ch)) {
+				check_pos--;
+				continue;
+			}
+			if (ch === 45) value = "-" + value;
+			else if (ch === 43) value = "+" + value;
+			break;
+		}
+		return value;
+	}
+	/** Get the An+B formula node from :nth-child(2n+1 of .foo) */
+	get nth() {
+		if (this.type !== 31) return void 0;
+		return this.first_child ?? void 0;
+	}
+	/** Get the selector list from :nth-child(2n+1 of .foo) */
+	get selector() {
+		if (this.type !== 31) return void 0;
+		return this.first_child?.next_sibling ?? void 0;
+	}
+	/**
+	* Get selector list from pseudo-class functions
+	* Works for :is(.a), :not(.b), :has(.c), :where(.d), :nth-child(2n of .e)
+	*/
+	get selector_list() {
+		if (this.type !== 25) return void 0;
+		let child = this.first_child;
+		if (!child) return void 0;
+		if (child.type === 20) return child;
+		if (child.type === 31) return child.selector;
+	}
+	/**
+	* Clone this node as a mutable plain JavaScript object with children as arrays.
+	* See API.md for examples.
+	*
+	* @param options - Cloning configuration
+	* @param options.deep - Recursively clone children (default: true)
+	* @param options.locations - Include line/column/start/length (default: false)
+	*/
+	clone(options = {}) {
+		const { deep = true, locations = false } = options;
+		let { type, name, property, value, unit } = this;
+		let plain = {
+			type,
+			type_name: this.type_name,
+			text: this.text
+		};
+		if (name) plain.name = name;
+		if (property) plain.property = property;
+		if (value) {
+			plain.value = value;
+			if (unit) plain.unit = unit;
+		}
+		if (type === 4) {
+			let { is_important, is_browserhack } = this;
+			if (is_important) plain.is_important = true;
+			if (is_browserhack) plain.is_browserhack = true;
+		}
+		let { is_vendor_prefixed, has_error } = this;
+		if (is_vendor_prefixed) plain.is_vendor_prefixed = true;
+		if (has_error) plain.has_error = true;
+		if (type === 24) {
+			plain.attr_operator = ATTR_OPERATOR_NAMES[this.attr_operator];
+			plain.attr_flags = ATTR_FLAG_NAMES[this.attr_flags];
+		}
+		if (type === 30 || type === 31) {
+			plain.nth_a = this.nth_a;
+			plain.nth_b = this.nth_b;
+		}
+		if (locations) {
+			plain.line = this.line;
+			plain.column = this.column;
+			plain.start = this.start;
+			plain.length = this.length;
+			plain.end = this.end;
+		}
+		if (deep && type !== 4) {
+			plain.children = [];
+			for (let child of this.children) plain.children.push(child.clone({
+				deep: true,
+				locations
+			}));
+		}
+		return plain;
+	}
+};
+//#endregion
+export { TYPE_SELECTOR as $, IDENTIFIER as A, NUMBER as B, CSSDataArena as C, FLAG_IMPORTANT as D, FEATURE_RANGE as E, MEDIA_QUERY as F, PSEUDO_ELEMENT_SELECTOR as G, PARENTHESIS as H, MEDIA_TYPE as I, SELECTOR_LIST as J, RAW as K, NESTING_SELECTOR as L, LANG_SELECTOR as M, LAYER_NAME as N, FUNCTION as O, MEDIA_FEATURE as P, SUPPORTS_QUERY as Q, NTH_OF_SELECTOR as R, CONTAINER_QUERY as S, DIMENSION as T, PRELUDE_OPERATOR as U, OPERATOR as V, PSEUDO_CLASS_SELECTOR as W, STYLESHEET as X, STRING as Y, STYLE_RULE as Z, AT_RULE_PRELUDE as _, ATTRIBUTE_SELECTOR as a, COMBINATOR as b, ATTR_FLAG_NONE as c, ATTR_OPERATOR_EQUAL as d, UNIVERSAL_SELECTOR as et, ATTR_OPERATOR_NONE as f, AT_RULE as g, ATTR_OPERATOR_TILDE_EQUAL as h, TYPE_NAMES as i, ID_SELECTOR as j, HASH as k, ATTR_OPERATOR_CARET_EQUAL as l, ATTR_OPERATOR_STAR_EQUAL as m, ATTR_OPERATOR_NAMES as n, VALUE as nt, ATTR_FLAG_CASE_INSENSITIVE as o, ATTR_OPERATOR_PIPE_EQUAL as p, SELECTOR as q, CSSNode as r, ATTR_FLAG_CASE_SENSITIVE as s, ATTR_FLAG_NAMES as t, URL as tt, ATTR_OPERATOR_DOLLAR_EQUAL as u, BLOCK as v, DECLARATION as w, COMMENT as x, CLASS_SELECTOR as y, NTH_SELECTOR as z };