@projectwallace/css-parser 0.6.7 → 0.7.0

package/dist/css-node.js

@@ -0,0 +1,455 @@
+import { DIMENSION, NUMBER, DECLARATION, FLAG_IMPORTANT, FLAG_VENDOR_PREFIXED, FLAG_HAS_ERROR, FLAG_HAS_BLOCK, FLAG_HAS_DECLARATIONS, STYLE_RULE, BLOCK, AT_RULE, COMMENT, PSEUDO_CLASS_SELECTOR, PSEUDO_ELEMENT_SELECTOR, FLAG_HAS_PARENS, NTH_SELECTOR, NTH_OF_SELECTOR, SELECTOR_LIST, SELECTOR, COMBINATOR, ATTRIBUTE_SELECTOR, PRELUDE_OPERATOR, LAYER_NAME, SUPPORTS_QUERY, CONTAINER_QUERY, MEDIA_TYPE, MEDIA_FEATURE, MEDIA_QUERY, LANG_SELECTOR, NESTING_SELECTOR, UNIVERSAL_SELECTOR, ID_SELECTOR, CLASS_SELECTOR, TYPE_SELECTOR, URL, PARENTHESIS, OPERATOR, FUNCTION, HASH, STRING, IDENTIFIER, STYLESHEET } from './arena.js';
+import { is_whitespace, CHAR_MINUS_HYPHEN, CHAR_PLUS } from './string-utils.js';
+import { parse_dimension } from './parse-utils.js';
+
+const TYPE_NAMES = {
+  [STYLESHEET]: "StyleSheet",
+  [STYLE_RULE]: "Rule",
+  [AT_RULE]: "Atrule",
+  [DECLARATION]: "Declaration",
+  [SELECTOR]: "Selector",
+  [COMMENT]: "Comment",
+  [BLOCK]: "Block",
+  [IDENTIFIER]: "Identifier",
+  [NUMBER]: "Number",
+  [DIMENSION]: "Dimension",
+  [STRING]: "String",
+  [HASH]: "Hash",
+  [FUNCTION]: "Function",
+  [OPERATOR]: "Operator",
+  [PARENTHESIS]: "Parentheses",
+  [URL]: "Url",
+  [SELECTOR_LIST]: "SelectorList",
+  [TYPE_SELECTOR]: "TypeSelector",
+  [CLASS_SELECTOR]: "ClassSelector",
+  [ID_SELECTOR]: "IdSelector",
+  [ATTRIBUTE_SELECTOR]: "AttributeSelector",
+  [PSEUDO_CLASS_SELECTOR]: "PseudoClassSelector",
+  [PSEUDO_ELEMENT_SELECTOR]: "PseudoElementSelector",
+  [COMBINATOR]: "Combinator",
+  [UNIVERSAL_SELECTOR]: "UniversalSelector",
+  [NESTING_SELECTOR]: "NestingSelector",
+  [NTH_SELECTOR]: "Nth",
+  [NTH_OF_SELECTOR]: "NthOf",
+  [LANG_SELECTOR]: "Lang",
+  [MEDIA_QUERY]: "MediaQuery",
+  [MEDIA_FEATURE]: "Feature",
+  [MEDIA_TYPE]: "MediaType",
+  [CONTAINER_QUERY]: "ContainerQuery",
+  [SUPPORTS_QUERY]: "SupportsQuery",
+  [LAYER_NAME]: "Layer",
+  [PRELUDE_OPERATOR]: "Operator"
+};
+class CSSNode {
+  arena;
+  source;
+  index;
+  constructor(arena, source, index) {
+    this.arena = arena;
+    this.source = source;
+    this.index = index;
+  }
+  // Get the node index (for internal use)
+  get_index() {
+    return this.index;
+  }
+  // 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 (property name for declarations, at-rule name for at-rules, layer name for import layers)
+  get name() {
+    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);
+  }
+  // Alias for name (for declarations: "color" in "color: blue")
+  // More semantic than `name` for declaration nodes
+  get property() {
+    return this.name;
+  }
+  // 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
+  get value() {
+    if (this.type === DIMENSION || this.type === NUMBER) {
+      return parse_dimension(this.text).value;
+    }
+    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 prelude text (for at-rules: "(min-width: 768px)" in "@media (min-width: 768px)")
+  // This is an alias for `value` to make at-rule usage more semantic
+  get prelude() {
+    let val = this.value;
+    return typeof val === "string" ? val : null;
+  }
+  // Get the attribute operator (for attribute selectors: =, ~=, |=, ^=, $=, *=)
+  // Returns one of the ATTR_OPERATOR_* constants
+  get attr_operator() {
+    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() {
+    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 !== DIMENSION) return null;
+    return parse_dimension(this.text).unit;
+  }
+  // Check if this declaration has !important
+  get is_important() {
+    if (this.type !== DECLARATION) return null;
+    return this.arena.has_flag(this.index, FLAG_IMPORTANT);
+  }
+  // Check if this has a vendor prefix (flag-based for performance)
+  get is_vendor_prefixed() {
+    return this.arena.has_flag(this.index, FLAG_VENDOR_PREFIXED);
+  }
+  // Check if this node has an error
+  get has_error() {
+    return this.arena.has_flag(this.index, FLAG_HAS_ERROR);
+  }
+  // Check if this at-rule has a prelude
+  get has_prelude() {
+    return this.arena.get_value_length(this.index) > 0;
+  }
+  // Check if this rule has a block { }
+  get has_block() {
+    return this.arena.has_flag(this.index, FLAG_HAS_BLOCK);
+  }
+  // Check if this style rule has declarations
+  get has_declarations() {
+    return this.arena.has_flag(this.index, FLAG_HAS_DECLARATIONS);
+  }
+  // Get the block node (for style rules and at-rules with blocks)
+  get block() {
+    if (this.type === STYLE_RULE) {
+      let first = this.first_child;
+      if (!first) return null;
+      let blockNode = first.next_sibling;
+      if (blockNode && blockNode.type === BLOCK) {
+        return blockNode;
+      }
+      return null;
+    }
+    if (this.type === AT_RULE) {
+      let child = this.first_child;
+      while (child) {
+        if (child.type === BLOCK && !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 !== BLOCK) return false;
+    let child = this.first_child;
+    while (child) {
+      if (child.type !== COMMENT) {
+        return false;
+      }
+      child = child.next_sibling;
+    }
+    return true;
+  }
+  // --- Value Node Access (for declarations) ---
+  // Get array of parsed value nodes (for declarations only)
+  get values() {
+    let result = [];
+    let child = this.first_child;
+    while (child) {
+      result.push(child);
+      child = child.next_sibling;
+    }
+    return result;
+  }
+  // Get count of value nodes
+  get value_count() {
+    let count = 0;
+    let child = this.first_child;
+    while (child) {
+      count++;
+      child = child.next_sibling;
+    }
+    return count;
+  }
+  // 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 offset() {
+    return this.arena.get_start_offset(this.index);
+  }
+  // Get length in source
+  get length() {
+    return this.arena.get_length(this.index);
+  }
+  // --- Tree Traversal ---
+  // 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);
+  }
+  get has_next() {
+    let sibling_index = this.arena.get_next_sibling(this.index);
+    return sibling_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() {
+    if (this.type === PSEUDO_CLASS_SELECTOR || this.type === PSEUDO_ELEMENT_SELECTOR) {
+      if (this.arena.has_flag(this.index, FLAG_HAS_PARENS)) {
+        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;
+    }
+  }
+  // --- An+B Expression Helpers (for NODE_SELECTOR_NTH) ---
+  // Get the 'a' coefficient from An+B expression (e.g., "2n" from "2n+1", "odd" from "odd")
+  get nth_a() {
+    if (this.type !== NTH_SELECTOR) return null;
+    let len = this.arena.get_content_length(this.index);
+    if (len === 0) return null;
+    let start = this.arena.get_content_start(this.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() {
+    if (this.type !== NTH_SELECTOR) return null;
+    let len = this.arena.get_value_length(this.index);
+    if (len === 0) return null;
+    let start = this.arena.get_value_start(this.index);
+    let value = this.source.substring(start, start + len);
+    let check_pos = start - 1;
+    while (check_pos >= 0) {
+      let ch = this.source.charCodeAt(check_pos);
+      if (is_whitespace(ch)) {
+        check_pos--;
+        continue;
+      }
+      if (ch === CHAR_MINUS_HYPHEN) {
+        value = "-" + value;
+      } else if (ch === CHAR_PLUS) {
+        value = "+" + value;
+      }
+      break;
+    }
+    return value;
+  }
+  // --- Pseudo-Class Nth-Of Helpers (for NODE_SELECTOR_NTH_OF) ---
+  // Get the An+B formula node from :nth-child(2n+1 of .foo)
+  get nth() {
+    if (this.type !== NTH_OF_SELECTOR) return null;
+    return this.first_child;
+  }
+  // Get the selector list from :nth-child(2n+1 of .foo)
+  get selector() {
+    if (this.type !== NTH_OF_SELECTOR) return null;
+    let first = this.first_child;
+    return first ? first.next_sibling : null;
+  }
+  // --- Pseudo-Class Selector List Helper ---
+  // 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 !== PSEUDO_CLASS_SELECTOR) return null;
+    let child = this.first_child;
+    if (!child) return null;
+    if (child.type === SELECTOR_LIST) {
+      return child;
+    }
+    if (child.type === NTH_OF_SELECTOR) {
+      return child.selector;
+    }
+    return null;
+  }
+  // --- Compound Selector Helpers (for NODE_SELECTOR) ---
+  // Iterator over first compound selector parts (zero allocation)
+  // Yields parts before the first combinator
+  *compound_parts() {
+    if (this.type !== SELECTOR) return;
+    let child = this.first_child;
+    while (child) {
+      if (child.type === COMBINATOR) break;
+      yield child;
+      child = child.next_sibling;
+    }
+  }
+  // Get first compound selector as array
+  // Returns array of parts before first combinator
+  get first_compound() {
+    if (this.type !== SELECTOR) return [];
+    let result = [];
+    let child = this.first_child;
+    while (child) {
+      if (child.type === COMBINATOR) break;
+      result.push(child);
+      child = child.next_sibling;
+    }
+    return result;
+  }
+  // Split selector into compound selectors
+  // Returns array of compound arrays split by combinators
+  get all_compounds() {
+    if (this.type !== SELECTOR) return [];
+    let compounds = [];
+    let current_compound = [];
+    let child = this.first_child;
+    while (child) {
+      if (child.type === COMBINATOR) {
+        if (current_compound.length > 0) {
+          compounds.push(current_compound);
+          current_compound = [];
+        }
+      } else {
+        current_compound.push(child);
+      }
+      child = child.next_sibling;
+    }
+    if (current_compound.length > 0) {
+      compounds.push(current_compound);
+    }
+    return compounds;
+  }
+  // Check if selector is compound (no combinators)
+  get is_compound() {
+    if (this.type !== SELECTOR) return false;
+    let child = this.first_child;
+    while (child) {
+      if (child.type === COMBINATOR) return false;
+      child = child.next_sibling;
+    }
+    return true;
+  }
+  // Get text of first compound selector (no node allocation)
+  get first_compound_text() {
+    if (this.type !== SELECTOR) return "";
+    let start = -1;
+    let end = -1;
+    let child = this.first_child;
+    while (child) {
+      if (child.type === COMBINATOR) break;
+      if (start === -1) start = child.offset;
+      end = child.offset + child.length;
+      child = child.next_sibling;
+    }
+    if (start === -1) return "";
+    return this.source.substring(start, end);
+  }
+  // --- Node Cloning ---
+  /**
+   * Clone this node as a mutable plain JavaScript object
+   *
+   * Extracts all properties from the arena into a plain object with children as an array.
+   * The resulting object can be freely modified.
+   *
+   * @param options - Cloning configuration
+   * @param options.deep - Recursively clone children (default: true)
+   * @param options.locations - Include line/column/offset/length (default: false)
+   * @returns Plain object with children as array
+   *
+   * @example
+   * const ast = parse('div { color: red; }')
+   * const decl = ast.first_child.block.first_child
+   * const plain = decl.clone()
+   *
+   * // Access children as array
+   * plain.children.length
+   * plain.children[0]
+   * plain.children.push(newChild)
+   */
+  clone(options = {}) {
+    const { deep = true, locations = false } = options;
+    let plain = {
+      type: this.type,
+      type_name: this.type_name,
+      text: this.text,
+      children: []
+    };
+    if (this.name) plain.name = this.name;
+    if (this.type === DECLARATION) plain.property = this.name;
+    if (this.value !== void 0 && this.value !== null) {
+      plain.value = this.value;
+      if (this.unit) plain.unit = this.unit;
+    }
+    if (this.type === AT_RULE && this.prelude) {
+      plain.prelude = this.prelude;
+    }
+    if (this.type === DECLARATION) plain.is_important = this.is_important;
+    plain.is_vendor_prefixed = this.is_vendor_prefixed;
+    plain.has_error = this.has_error;
+    if (this.type === ATTRIBUTE_SELECTOR) {
+      plain.attr_operator = this.attr_operator;
+      plain.attr_flags = this.attr_flags;
+    }
+    if (this.type === NTH_SELECTOR || this.type === NTH_OF_SELECTOR) {
+      plain.nth_a = this.nth_a;
+      plain.nth_b = this.nth_b;
+    }
+    if (locations) {
+      plain.line = this.line;
+      plain.column = this.column;
+      plain.offset = this.offset;
+      plain.length = this.length;
+    }
+    if (deep) {
+      for (let child of this.children) {
+        plain.children.push(child.clone({ deep: true, locations }));
+      }
+    }
+    return plain;
+  }
+}
+
+export { CSSNode, TYPE_NAMES };

package/dist/index.d.ts

@@ -8,5 +8,5 @@ export { type ParserOptions } from './parse';
 export { CSSNode, type CSSNodeType, TYPE_NAMES, type CloneOptions, type PlainCSSNode } from './css-node';
 export type { LexerPosition } from './lexer';
 export { ATTR_OPERATOR_NONE, ATTR_OPERATOR_EQUAL, ATTR_OPERATOR_TILDE_EQUAL, ATTR_OPERATOR_PIPE_EQUAL, ATTR_OPERATOR_CARET_EQUAL, ATTR_OPERATOR_DOLLAR_EQUAL, ATTR_OPERATOR_STAR_EQUAL, ATTR_FLAG_NONE, ATTR_FLAG_CASE_INSENSITIVE, ATTR_FLAG_CASE_SENSITIVE, } from './arena';
-export { NODE_STYLE_RULE, NODE_AT_RULE, NODE_COMMENT, NODE_DECLARATION, NODE_SELECTOR, NODE_STYLESHEET, NODE_VALUE_KEYWORD, NODE_VALUE_NUMBER, NODE_VALUE_DIMENSION, NODE_VALUE_STRING, NODE_VALUE_COLOR, NODE_VALUE_FUNCTION, NODE_VALUE_OPERATOR, NODE_VALUE_PARENTHESIS, NODE_SELECTOR_LIST, NODE_SELECTOR_TYPE, NODE_SELECTOR_CLASS, NODE_SELECTOR_ID, NODE_SELECTOR_ATTRIBUTE, NODE_SELECTOR_PSEUDO_CLASS, NODE_SELECTOR_PSEUDO_ELEMENT, NODE_SELECTOR_COMBINATOR, NODE_SELECTOR_UNIVERSAL, NODE_SELECTOR_NESTING, NODE_SELECTOR_NTH, NODE_SELECTOR_NTH_OF, NODE_SELECTOR_LANG, NODE_PRELUDE_MEDIA_QUERY, NODE_PRELUDE_MEDIA_FEATURE, NODE_PRELUDE_MEDIA_TYPE, NODE_PRELUDE_CONTAINER_QUERY, NODE_PRELUDE_SUPPORTS_QUERY, NODE_PRELUDE_LAYER_NAME, NODE_PRELUDE_IDENTIFIER, NODE_PRELUDE_OPERATOR, NODE_PRELUDE_IMPORT_URL, NODE_PRELUDE_IMPORT_LAYER, NODE_PRELUDE_IMPORT_SUPPORTS, FLAG_IMPORTANT, } from './parse';
-export { TOKEN_IDENT, TOKEN_FUNCTION, TOKEN_AT_KEYWORD, TOKEN_HASH, TOKEN_STRING, TOKEN_BAD_STRING, TOKEN_URL, TOKEN_BAD_URL, TOKEN_DELIM, TOKEN_NUMBER, TOKEN_PERCENTAGE, TOKEN_DIMENSION, TOKEN_WHITESPACE, TOKEN_CDO, TOKEN_CDC, TOKEN_COLON, TOKEN_SEMICOLON, TOKEN_COMMA, TOKEN_LEFT_BRACKET, TOKEN_RIGHT_BRACKET, TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_COMMENT, TOKEN_EOF, type Token, type TokenType, } from './token-types';
+export * from './constants';
+export * from './token-types';

package/dist/index.js

@@ -3,27 +3,7 @@ export { parse_selector } from './parse-selector.js';
 export { parse_atrule_prelude } from './parse-atrule-prelude.js';
 export { parse_value } from './parse-value.js';
 export { tokenize } from './tokenize.js';
-export { h as ATTR_FLAG_CASE_INSENSITIVE, i as ATTR_FLAG_CASE_SENSITIVE, g as ATTR_FLAG_NONE, d as ATTR_OPERATOR_CARET_EQUAL, e as ATTR_OPERATOR_DOLLAR_EQUAL, a as ATTR_OPERATOR_EQUAL, A as ATTR_OPERATOR_NONE, c as ATTR_OPERATOR_PIPE_EQUAL, f as ATTR_OPERATOR_STAR_EQUAL, b as ATTR_OPERATOR_TILDE_EQUAL, C as CSSNode, Y as FLAG_IMPORTANT, j as NODE_AT_RULE, k as NODE_COMMENT, l as NODE_DECLARATION, P as NODE_PRELUDE_CONTAINER_QUERY, S as NODE_PRELUDE_IDENTIFIER, W as NODE_PRELUDE_IMPORT_LAYER, X as NODE_PRELUDE_IMPORT_SUPPORTS, V as NODE_PRELUDE_IMPORT_URL, R as NODE_PRELUDE_LAYER_NAME, M as NODE_PRELUDE_MEDIA_FEATURE, L as NODE_PRELUDE_MEDIA_QUERY, O as NODE_PRELUDE_MEDIA_TYPE, U as NODE_PRELUDE_OPERATOR, Q as NODE_PRELUDE_SUPPORTS_QUERY, m as NODE_SELECTOR, B as NODE_SELECTOR_ATTRIBUTE, y as NODE_SELECTOR_CLASS, F as NODE_SELECTOR_COMBINATOR, z as NODE_SELECTOR_ID, K as NODE_SELECTOR_LANG, w as NODE_SELECTOR_LIST, H as NODE_SELECTOR_NESTING, I as NODE_SELECTOR_NTH, J as NODE_SELECTOR_NTH_OF, D as NODE_SELECTOR_PSEUDO_CLASS, E as NODE_SELECTOR_PSEUDO_ELEMENT, x as NODE_SELECTOR_TYPE, G as NODE_SELECTOR_UNIVERSAL, n as NODE_STYLESHEET, N as NODE_STYLE_RULE, s as NODE_VALUE_COLOR, q as NODE_VALUE_DIMENSION, t as NODE_VALUE_FUNCTION, o as NODE_VALUE_KEYWORD, p as NODE_VALUE_NUMBER, u as NODE_VALUE_OPERATOR, v as NODE_VALUE_PARENTHESIS, r as NODE_VALUE_STRING, T as TYPE_NAMES } from './css-node-GOEvp2OO.js';
-export { b as TOKEN_AT_KEYWORD, e as TOKEN_BAD_STRING, g as TOKEN_BAD_URL, n as TOKEN_CDC, m as TOKEN_CDO, o as TOKEN_COLON, q as TOKEN_COMMA, x as TOKEN_COMMENT, h as TOKEN_DELIM, k as TOKEN_DIMENSION, y as TOKEN_EOF, a as TOKEN_FUNCTION, c as TOKEN_HASH, T as TOKEN_IDENT, v as TOKEN_LEFT_BRACE, r as TOKEN_LEFT_BRACKET, t as TOKEN_LEFT_PAREN, i as TOKEN_NUMBER, j as TOKEN_PERCENTAGE, w as TOKEN_RIGHT_BRACE, s as TOKEN_RIGHT_BRACKET, u as TOKEN_RIGHT_PAREN, p as TOKEN_SEMICOLON, d as TOKEN_STRING, f as TOKEN_URL, l as TOKEN_WHITESPACE } from './lexer-CtBKgfVv.js';
-
-function walk(node, callback, depth = 0) {
-  callback(node, depth);
-  let child = node.first_child;
-  while (child) {
-    walk(child, callback, depth + 1);
-    child = child.next_sibling;
-  }
-}
-const NOOP = function() {
-};
-function traverse(node, { enter = NOOP, leave = NOOP } = {}) {
-  enter(node);
-  let child = node.first_child;
-  while (child) {
-    traverse(child, { enter, leave });
-    child = child.next_sibling;
-  }
-  leave(node);
-}
-
-export { traverse, walk };
+export { traverse, walk } from './walk.js';
+export { CSSNode, TYPE_NAMES } from './css-node.js';
+export { ATTRIBUTE_SELECTOR, ATTR_FLAG_CASE_INSENSITIVE, ATTR_FLAG_CASE_SENSITIVE, ATTR_FLAG_NONE, ATTR_OPERATOR_CARET_EQUAL, ATTR_OPERATOR_DOLLAR_EQUAL, ATTR_OPERATOR_EQUAL, ATTR_OPERATOR_NONE, ATTR_OPERATOR_PIPE_EQUAL, ATTR_OPERATOR_STAR_EQUAL, ATTR_OPERATOR_TILDE_EQUAL, AT_RULE, BLOCK, CLASS_SELECTOR, COMBINATOR, COMMENT, CONTAINER_QUERY, DECLARATION, DIMENSION, FLAG_IMPORTANT, FUNCTION, HASH, IDENTIFIER, ID_SELECTOR, LANG_SELECTOR, LAYER_NAME, MEDIA_FEATURE, MEDIA_QUERY, MEDIA_TYPE, NESTING_SELECTOR, NTH_OF_SELECTOR, NTH_SELECTOR, NUMBER, OPERATOR, PARENTHESIS, PRELUDE_OPERATOR, PSEUDO_CLASS_SELECTOR, PSEUDO_ELEMENT_SELECTOR, SELECTOR, SELECTOR_LIST, STRING, STYLESHEET, STYLE_RULE, SUPPORTS_QUERY, TYPE_SELECTOR, UNIVERSAL_SELECTOR, URL } from './arena.js';
+export { TOKEN_AT_KEYWORD, TOKEN_BAD_STRING, TOKEN_BAD_URL, TOKEN_CDC, TOKEN_CDO, TOKEN_COLON, TOKEN_COMMA, TOKEN_COMMENT, TOKEN_DELIM, TOKEN_DIMENSION, TOKEN_EOF, TOKEN_FUNCTION, TOKEN_HASH, TOKEN_IDENT, TOKEN_LEFT_BRACE, TOKEN_LEFT_BRACKET, TOKEN_LEFT_PAREN, TOKEN_NUMBER, TOKEN_PERCENTAGE, TOKEN_RIGHT_BRACE, TOKEN_RIGHT_BRACKET, TOKEN_RIGHT_PAREN, TOKEN_SEMICOLON, TOKEN_STRING, TOKEN_URL, TOKEN_WHITESPACE } from './token-types.js';

package/dist/lexer.d.ts

@@ -1,4 +1,4 @@
-import { type Token, type TokenType } from './token-types';
+import { type TokenType } from './token-types';
 export interface LexerPosition {
     pos: number;
     line: number;
@@ -9,39 +9,3 @@ export interface LexerPosition {
     token_line: number;
     token_column: number;
 }
-export declare class Lexer {
-    source: string;
-    pos: number;
-    line: number;
-    column: number;
-    skip_comments: boolean;
-    token_type: TokenType;
-    token_start: number;
-    token_end: number;
-    token_line: number;
-    token_column: number;
-    constructor(source: string, skip_comments?: boolean);
-    next_token_fast(skip_whitespace?: boolean): TokenType;
-    consume_whitespace(start_line: number, start_column: number): TokenType;
-    consume_comment(start_line: number, start_column: number): TokenType;
-    consume_string(quote: number, start_line: number, start_column: number): TokenType;
-    consume_hex_escape(): void;
-    consume_number(start_line: number, start_column: number): TokenType;
-    consume_ident_or_function(start_line: number, start_column: number): TokenType;
-    consume_at_keyword(start_line: number, start_column: number): TokenType;
-    consume_hash(start_line: number, start_column: number): TokenType;
-    advance(count?: number): void;
-    peek(offset?: number): number;
-    make_token(type: TokenType, start: number, end: number, line?: number, column?: number): TokenType;
-    next_token(skip_whitespace?: boolean): Token | null;
-    /**
-     * Save complete lexer state for backtracking
-     * @returns Object containing all lexer state
-     */
-    save_position(): LexerPosition;
-    /**
-     * Restore lexer state from saved position
-     * @param saved The saved position to restore
-     */
-    restore_position(saved: LexerPosition): void;
-}

package/dist/{lexer-CtBKgfVv.js → lexer.js}

@@ -1,83 +1,5 @@
-let CHAR_ALPHA = 1 << 0;
-let CHAR_DIGIT = 1 << 1;
-let CHAR_HEX = 1 << 2;
-let CHAR_WHITESPACE = 1 << 3;
-let CHAR_NEWLINE = 1 << 4;
-let char_types = new Uint8Array(128);
-for (let i = 48; i <= 57; i++) {
-  char_types[i] = CHAR_DIGIT;
-}
-for (let i = 48; i <= 57; i++) {
-  char_types[i] |= CHAR_HEX;
-}
-for (let i = 65; i <= 70; i++) {
-  char_types[i] = CHAR_HEX;
-}
-for (let i = 97; i <= 102; i++) {
-  char_types[i] = CHAR_HEX;
-}
-for (let i = 65; i <= 90; i++) {
-  char_types[i] |= CHAR_ALPHA;
-}
-for (let i = 97; i <= 122; i++) {
-  char_types[i] |= CHAR_ALPHA;
-}
-char_types[32] = CHAR_WHITESPACE;
-char_types[9] = CHAR_WHITESPACE;
-char_types[10] = CHAR_NEWLINE;
-char_types[13] = CHAR_NEWLINE;
-char_types[12] = CHAR_NEWLINE;
-function is_digit(ch) {
-  return ch < 128 && (char_types[ch] & CHAR_DIGIT) !== 0;
-}
-function is_hex_digit(ch) {
-  return ch < 128 && (char_types[ch] & CHAR_HEX) !== 0;
-}
-function is_alpha(ch) {
-  return ch < 128 && (char_types[ch] & CHAR_ALPHA) !== 0;
-}
-function is_whitespace(ch) {
-  return ch < 128 && (char_types[ch] & CHAR_WHITESPACE) !== 0;
-}
-function is_newline(ch) {
-  return ch < 128 && (char_types[ch] & CHAR_NEWLINE) !== 0;
-}
-function is_ident_start(ch) {
-  if (ch >= 128) return true;
-  if (ch === 95) return true;
-  return is_alpha(ch);
-}
-function is_ident_char(ch) {
-  if (ch === 45) return true;
-  return is_ident_start(ch) || is_digit(ch);
-}
-
-const TOKEN_IDENT = 1;
-const TOKEN_FUNCTION = 2;
-const TOKEN_AT_KEYWORD = 3;
-const TOKEN_HASH = 4;
-const TOKEN_STRING = 5;
-const TOKEN_BAD_STRING = 6;
-const TOKEN_URL = 7;
-const TOKEN_BAD_URL = 8;
-const TOKEN_DELIM = 9;
-const TOKEN_NUMBER = 10;
-const TOKEN_PERCENTAGE = 11;
-const TOKEN_DIMENSION = 12;
-const TOKEN_WHITESPACE = 13;
-const TOKEN_CDO = 14;
-const TOKEN_CDC = 15;
-const TOKEN_COLON = 16;
-const TOKEN_SEMICOLON = 17;
-const TOKEN_COMMA = 18;
-const TOKEN_LEFT_BRACKET = 19;
-const TOKEN_RIGHT_BRACKET = 20;
-const TOKEN_LEFT_PAREN = 21;
-const TOKEN_RIGHT_PAREN = 22;
-const TOKEN_LEFT_BRACE = 23;
-const TOKEN_RIGHT_BRACE = 24;
-const TOKEN_COMMENT = 25;
-const TOKEN_EOF = 26;
+import { is_whitespace, is_newline, is_digit, is_ident_start, is_hex_digit, is_ident_char } from './char-types.js';
+import { TOKEN_EOF, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_COLON, TOKEN_SEMICOLON, TOKEN_COMMA, TOKEN_LEFT_BRACKET, TOKEN_RIGHT_BRACKET, TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN, TOKEN_CDO, TOKEN_CDC, TOKEN_DELIM, TOKEN_WHITESPACE, TOKEN_COMMENT, TOKEN_STRING, TOKEN_BAD_STRING, TOKEN_PERCENTAGE, TOKEN_DIMENSION, TOKEN_NUMBER, TOKEN_FUNCTION, TOKEN_IDENT, TOKEN_AT_KEYWORD, TOKEN_HASH } from './token-types.js';
 
 const CHAR_LEFT_BRACE = 123;
 const CHAR_RIGHT_BRACE = 125;
@@ -506,4 +428,4 @@ class Lexer {
   }
 }
 
-export { Lexer as L, TOKEN_IDENT as T, TOKEN_FUNCTION as a, TOKEN_AT_KEYWORD as b, TOKEN_HASH as c, TOKEN_STRING as d, TOKEN_BAD_STRING as e, TOKEN_URL as f, TOKEN_BAD_URL as g, TOKEN_DELIM as h, TOKEN_NUMBER as i, TOKEN_PERCENTAGE as j, TOKEN_DIMENSION as k, TOKEN_WHITESPACE as l, TOKEN_CDO as m, TOKEN_CDC as n, TOKEN_COLON as o, TOKEN_SEMICOLON as p, TOKEN_COMMA as q, TOKEN_LEFT_BRACKET as r, TOKEN_RIGHT_BRACKET as s, TOKEN_LEFT_PAREN as t, TOKEN_RIGHT_PAREN as u, TOKEN_LEFT_BRACE as v, TOKEN_RIGHT_BRACE as w, TOKEN_COMMENT as x, TOKEN_EOF as y };
+export { Lexer };

package/dist/parse-anplusb.d.ts

@@ -1,22 +1,2 @@
-import { CSSDataArena } from './arena';
 import { CSSNode } from './css-node';
-export declare class ANplusBParser {
-    private lexer;
-    private arena;
-    private source;
-    private expr_end;
-    constructor(arena: CSSDataArena, source: string);
-    /**
-     * Parse An+B expression
-     * Examples: odd, even, 3, n, -n, 2n, 2n+1, -3n-5
-     */
-    parse_anplusb(start: number, end: number, line?: number): number | null;
-    /**
-     * Parse the b part after 'n'
-     * Handles: +5, -3, whitespace variations
-     */
-    private parse_b_part;
-    private skip_whitespace;
-    private create_anplusb_node;
-}
 export declare function parse_anplusb(expr: string): CSSNode | null;