@projectwallace/css-parser 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { parse } from './parse';
+export { parse_selector } from './parse-selector';
+export { parse_atrule_prelude } from './parse-atrule-prelude';
+export { tokenize } from './tokenize';
+export { walk, walk_enter_leave } from './walk';
+export { type ParserOptions } from './parser';
+export { CSSNode, type CSSNodeType } from './css-node';
+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_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_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 './parser';
+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';

package/dist/index.js

@@ -0,0 +1,28 @@
+export { parse } from './parse.js';
+export { parse_selector } from './parse-selector.js';
+export { parse_atrule_prelude } from './parse-atrule-prelude.js';
+export { tokenize } from './tokenize.js';
+export { C as CSSNode, I as FLAG_IMPORTANT, a as NODE_AT_RULE, b as NODE_COMMENT, c as NODE_DECLARATION, z as NODE_PRELUDE_CONTAINER_QUERY, D as NODE_PRELUDE_IDENTIFIER, G as NODE_PRELUDE_IMPORT_LAYER, H as NODE_PRELUDE_IMPORT_SUPPORTS, F as NODE_PRELUDE_IMPORT_URL, B as NODE_PRELUDE_LAYER_NAME, x as NODE_PRELUDE_MEDIA_FEATURE, w as NODE_PRELUDE_MEDIA_QUERY, y as NODE_PRELUDE_MEDIA_TYPE, E as NODE_PRELUDE_OPERATOR, A as NODE_PRELUDE_SUPPORTS_QUERY, d as NODE_SELECTOR, q as NODE_SELECTOR_ATTRIBUTE, o as NODE_SELECTOR_CLASS, t as NODE_SELECTOR_COMBINATOR, p as NODE_SELECTOR_ID, m as NODE_SELECTOR_LIST, v as NODE_SELECTOR_NESTING, r as NODE_SELECTOR_PSEUDO_CLASS, s as NODE_SELECTOR_PSEUDO_ELEMENT, n as NODE_SELECTOR_TYPE, u as NODE_SELECTOR_UNIVERSAL, e as NODE_STYLESHEET, N as NODE_STYLE_RULE, j as NODE_VALUE_COLOR, h as NODE_VALUE_DIMENSION, k as NODE_VALUE_FUNCTION, f as NODE_VALUE_KEYWORD, g as NODE_VALUE_NUMBER, l as NODE_VALUE_OPERATOR, i as NODE_VALUE_STRING } from './string-utils-B-rJII-E.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-DXablYMZ.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 walk_enter_leave(node, { enter = NOOP, leave = NOOP } = {}) {
+  enter(node);
+  let child = node.first_child;
+  while (child) {
+    walk_enter_leave(child, { enter, leave });
+    child = child.next_sibling;
+  }
+  leave(node);
+}
+
+export { walk, walk_enter_leave };

package/dist/lexer-DXablYMZ.js

@@ -0,0 +1,479 @@
+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;
+
+const CHAR_LEFT_BRACE = 123;
+const CHAR_RIGHT_BRACE = 125;
+const CHAR_COLON = 58;
+const CHAR_SEMICOLON = 59;
+const CHAR_COMMA = 44;
+const CHAR_LEFT_BRACKET = 91;
+const CHAR_RIGHT_BRACKET = 93;
+const CHAR_LEFT_PAREN = 40;
+const CHAR_RIGHT_PAREN = 41;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_ASTERISK = 42;
+const CHAR_DOUBLE_QUOTE = 34;
+const CHAR_SINGLE_QUOTE = 39;
+const CHAR_DOT = 46;
+const CHAR_LESS_THAN = 60;
+const CHAR_EXCLAMATION = 33;
+const CHAR_HYPHEN = 45;
+const CHAR_GREATER_THAN = 62;
+const CHAR_AT_SIGN = 64;
+const CHAR_HASH = 35;
+const CHAR_BACKSLASH = 92;
+const CHAR_PLUS = 43;
+const CHAR_PERCENT = 37;
+const CHAR_LOWERCASE_E = 101;
+const CHAR_UPPERCASE_E = 69;
+const CHAR_CARRIAGE_RETURN = 13;
+const CHAR_LINE_FEED = 10;
+class Lexer {
+  source;
+  pos;
+  line;
+  column;
+  skip_comments;
+  // Current token properties (avoiding object allocation)
+  token_type;
+  token_start;
+  token_end;
+  token_line;
+  token_column;
+  constructor(source, skip_comments = false) {
+    this.source = source;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+    this.skip_comments = skip_comments;
+    this.token_type = TOKEN_EOF;
+    this.token_start = 0;
+    this.token_end = 0;
+    this.token_line = 1;
+    this.token_column = 1;
+  }
+  // Fast token advancing without object allocation (for internal parser use)
+  next_token_fast(skip_whitespace = false) {
+    if (skip_whitespace) {
+      while (this.pos < this.source.length) {
+        let ch2 = this.source.charCodeAt(this.pos);
+        if (!is_whitespace(ch2) && !is_newline(ch2)) break;
+        this.advance();
+      }
+    }
+    if (this.pos >= this.source.length) {
+      return this.make_token(TOKEN_EOF, this.pos, this.pos);
+    }
+    let ch = this.source.charCodeAt(this.pos);
+    let start = this.pos;
+    let start_line = this.line;
+    let start_column = this.column;
+    if (ch === CHAR_LEFT_BRACE) {
+      this.advance();
+      return this.make_token(TOKEN_LEFT_BRACE, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_RIGHT_BRACE) {
+      this.advance();
+      return this.make_token(TOKEN_RIGHT_BRACE, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_COLON) {
+      this.advance();
+      return this.make_token(TOKEN_COLON, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_SEMICOLON) {
+      this.advance();
+      return this.make_token(TOKEN_SEMICOLON, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_COMMA) {
+      this.advance();
+      return this.make_token(TOKEN_COMMA, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_LEFT_BRACKET) {
+      this.advance();
+      return this.make_token(TOKEN_LEFT_BRACKET, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_RIGHT_BRACKET) {
+      this.advance();
+      return this.make_token(TOKEN_RIGHT_BRACKET, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_LEFT_PAREN) {
+      this.advance();
+      return this.make_token(TOKEN_LEFT_PAREN, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_RIGHT_PAREN) {
+      this.advance();
+      return this.make_token(TOKEN_RIGHT_PAREN, start, this.pos, start_line, start_column);
+    }
+    if (is_whitespace(ch) || is_newline(ch)) {
+      return this.consume_whitespace(start_line, start_column);
+    }
+    if (ch === CHAR_FORWARD_SLASH && this.peek() === CHAR_ASTERISK) {
+      if (this.skip_comments) {
+        this.advance(2);
+        while (this.pos < this.source.length - 1) {
+          let ch2 = this.source.charCodeAt(this.pos);
+          if (ch2 === CHAR_ASTERISK && this.source.charCodeAt(this.pos + 1) === CHAR_FORWARD_SLASH) {
+            this.advance(2);
+            break;
+          }
+          this.advance();
+        }
+        return this.next_token_fast(skip_whitespace);
+      }
+      return this.consume_comment(start_line, start_column);
+    }
+    if (ch === CHAR_DOUBLE_QUOTE || ch === CHAR_SINGLE_QUOTE) {
+      return this.consume_string(ch, start_line, start_column);
+    }
+    if (is_digit(ch)) {
+      return this.consume_number(start_line, start_column);
+    }
+    if (ch === CHAR_DOT && is_digit(this.peek())) {
+      return this.consume_number(start_line, start_column);
+    }
+    if (ch === CHAR_LESS_THAN && this.pos + 3 < this.source.length) {
+      if (this.source.charCodeAt(this.pos + 1) === CHAR_EXCLAMATION && this.source.charCodeAt(this.pos + 2) === CHAR_HYPHEN && this.source.charCodeAt(this.pos + 3) === CHAR_HYPHEN) {
+        this.advance(4);
+        return this.make_token(TOKEN_CDO, start, this.pos, start_line, start_column);
+      }
+    }
+    if (ch === CHAR_HYPHEN && this.pos + 2 < this.source.length) {
+      if (this.source.charCodeAt(this.pos + 1) === CHAR_HYPHEN && this.source.charCodeAt(this.pos + 2) === CHAR_GREATER_THAN) {
+        this.advance(3);
+        return this.make_token(TOKEN_CDC, start, this.pos, start_line, start_column);
+      }
+    }
+    if (ch === CHAR_AT_SIGN) {
+      return this.consume_at_keyword(start_line, start_column);
+    }
+    if (ch === CHAR_HASH) {
+      return this.consume_hash(start_line, start_column);
+    }
+    if (is_ident_start(ch)) {
+      return this.consume_ident_or_function(start_line, start_column);
+    }
+    if (ch === CHAR_HYPHEN) {
+      let next = this.peek();
+      if (is_ident_start(next) || next === CHAR_HYPHEN) {
+        return this.consume_ident_or_function(start_line, start_column);
+      }
+    }
+    if (ch === CHAR_BACKSLASH) {
+      let next = this.peek();
+      if (next !== 0 && !is_newline(next)) {
+        return this.consume_ident_or_function(start_line, start_column);
+      }
+    }
+    if (ch === CHAR_HYPHEN || ch === CHAR_PLUS) {
+      let next = this.peek();
+      if (is_digit(next) || next === CHAR_DOT && is_digit(this.peek(2))) {
+        return this.consume_number(start_line, start_column);
+      }
+    }
+    this.advance();
+    return this.make_token(TOKEN_DELIM, start, this.pos, start_line, start_column);
+  }
+  consume_whitespace(start_line, start_column) {
+    let start = this.pos;
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (!is_whitespace(ch) && !is_newline(ch)) break;
+      this.advance();
+    }
+    return this.make_token(TOKEN_WHITESPACE, start, this.pos, start_line, start_column);
+  }
+  consume_comment(start_line, start_column) {
+    let start = this.pos;
+    this.advance(2);
+    while (this.pos < this.source.length - 1) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch === CHAR_ASTERISK && this.source.charCodeAt(this.pos + 1) === CHAR_FORWARD_SLASH) {
+        this.advance(2);
+        break;
+      }
+      this.advance();
+    }
+    return this.make_token(TOKEN_COMMENT, start, this.pos, start_line, start_column);
+  }
+  consume_string(quote, start_line, start_column) {
+    let start = this.pos;
+    this.advance();
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch === quote) {
+        this.advance();
+        return this.make_token(TOKEN_STRING, start, this.pos, start_line, start_column);
+      }
+      if (is_newline(ch)) {
+        return this.make_token(TOKEN_BAD_STRING, start, this.pos, start_line, start_column);
+      }
+      if (ch === CHAR_BACKSLASH) {
+        this.advance();
+        if (this.pos < this.source.length) {
+          let next = this.source.charCodeAt(this.pos);
+          if (is_hex_digit(next)) {
+            this.consume_hex_escape();
+          } else if (!is_newline(next)) {
+            this.advance();
+          } else {
+            this.advance();
+          }
+        }
+        continue;
+      }
+      this.advance();
+    }
+    return this.make_token(TOKEN_BAD_STRING, start, this.pos, start_line, start_column);
+  }
+  consume_hex_escape() {
+    let count = 0;
+    while (count < 6 && this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (!is_hex_digit(ch)) break;
+      this.advance();
+      count++;
+    }
+    if (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (is_whitespace(ch) || is_newline(ch)) {
+        this.advance();
+      }
+    }
+  }
+  consume_number(start_line, start_column) {
+    let start = this.pos;
+    let ch = this.source.charCodeAt(this.pos);
+    if (ch === CHAR_PLUS || ch === CHAR_HYPHEN) {
+      this.advance();
+    }
+    while (this.pos < this.source.length && is_digit(this.source.charCodeAt(this.pos))) {
+      this.advance();
+    }
+    if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_DOT && this.pos + 1 < this.source.length && is_digit(this.source.charCodeAt(this.pos + 1))) {
+      this.advance();
+      while (this.pos < this.source.length && is_digit(this.source.charCodeAt(this.pos))) {
+        this.advance();
+      }
+    }
+    if (this.pos < this.source.length) {
+      let ch2 = this.source.charCodeAt(this.pos);
+      if (ch2 === CHAR_LOWERCASE_E || ch2 === CHAR_UPPERCASE_E) {
+        let next = this.peek();
+        if (is_digit(next) || (next === CHAR_PLUS || next === CHAR_HYPHEN) && is_digit(this.peek(2))) {
+          this.advance();
+          if (this.pos < this.source.length) {
+            let sign = this.source.charCodeAt(this.pos);
+            if (sign === CHAR_PLUS || sign === CHAR_HYPHEN) {
+              this.advance();
+            }
+          }
+          while (this.pos < this.source.length && is_digit(this.source.charCodeAt(this.pos))) {
+            this.advance();
+          }
+        }
+      }
+    }
+    if (this.pos < this.source.length) {
+      let ch2 = this.source.charCodeAt(this.pos);
+      if (ch2 === CHAR_PERCENT) {
+        this.advance();
+        return this.make_token(TOKEN_PERCENTAGE, start, this.pos, start_line, start_column);
+      }
+      if (is_ident_start(ch2) || ch2 === CHAR_HYPHEN && is_ident_start(this.peek())) {
+        while (this.pos < this.source.length && is_ident_char(this.source.charCodeAt(this.pos))) {
+          this.advance();
+        }
+        return this.make_token(TOKEN_DIMENSION, start, this.pos, start_line, start_column);
+      }
+    }
+    return this.make_token(TOKEN_NUMBER, start, this.pos, start_line, start_column);
+  }
+  consume_ident_or_function(start_line, start_column) {
+    let start = this.pos;
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch === CHAR_BACKSLASH) {
+        if (this.pos + 1 >= this.source.length) break;
+        let next = this.source.charCodeAt(this.pos + 1);
+        if (is_newline(next)) break;
+        this.advance();
+        if (is_hex_digit(next)) {
+          this.advance();
+          for (let i = 0; i < 5 && this.pos < this.source.length; i++) {
+            if (!is_hex_digit(this.source.charCodeAt(this.pos))) break;
+            this.advance();
+          }
+          if (this.pos < this.source.length) {
+            let ws = this.source.charCodeAt(this.pos);
+            if (is_whitespace(ws) || is_newline(ws)) {
+              this.advance();
+            }
+          }
+        } else {
+          this.advance();
+        }
+      } else if (is_ident_char(ch)) {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+    if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LEFT_PAREN) {
+      this.advance();
+      return this.make_token(TOKEN_FUNCTION, start, this.pos, start_line, start_column);
+    }
+    return this.make_token(TOKEN_IDENT, start, this.pos, start_line, start_column);
+  }
+  consume_at_keyword(start_line, start_column) {
+    let start = this.pos;
+    this.advance();
+    while (this.pos < this.source.length && is_ident_char(this.source.charCodeAt(this.pos))) {
+      this.advance();
+    }
+    return this.make_token(TOKEN_AT_KEYWORD, start, this.pos, start_line, start_column);
+  }
+  consume_hash(start_line, start_column) {
+    let start = this.pos;
+    this.advance();
+    while (this.pos < this.source.length && is_ident_char(this.source.charCodeAt(this.pos))) {
+      this.advance();
+    }
+    return this.make_token(TOKEN_HASH, start, this.pos, start_line, start_column);
+  }
+  advance(count = 1) {
+    if (count === 1) {
+      if (this.pos >= this.source.length) return;
+      let ch = this.source.charCodeAt(this.pos);
+      this.pos++;
+      if (is_newline(ch)) {
+        if (ch === CHAR_CARRIAGE_RETURN && this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LINE_FEED) {
+          this.pos++;
+        }
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+      return;
+    }
+    for (let i = 0; i < count; i++) {
+      if (this.pos >= this.source.length) break;
+      let ch = this.source.charCodeAt(this.pos);
+      this.pos++;
+      if (is_newline(ch)) {
+        if (ch === CHAR_CARRIAGE_RETURN && this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LINE_FEED) {
+          this.pos++;
+          i++;
+        }
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+    }
+  }
+  peek(offset = 1) {
+    let index = this.pos + offset;
+    if (index >= this.source.length) return 0;
+    return this.source.charCodeAt(index);
+  }
+  make_token(type, start, end, line = this.line, column = this.column) {
+    this.token_type = type;
+    this.token_start = start;
+    this.token_end = end;
+    this.token_line = line;
+    this.token_column = column;
+    return type;
+  }
+  // Public API: returns Token object for backwards compatibility
+  next_token(skip_whitespace = false) {
+    this.next_token_fast(skip_whitespace);
+    return {
+      type: this.token_type,
+      start: this.token_start,
+      end: this.token_end,
+      line: this.token_line,
+      column: this.token_column
+    };
+  }
+}
+
+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 };

package/dist/lexer.d.ts

@@ -0,0 +1,27 @@
+import { type Token, type TokenType } from './token-types';
+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;
+}

package/dist/parse-atrule-prelude.d.ts

@@ -0,0 +1,8 @@
+import { CSSNode } from './css-node';
+/**
+ * Parse an at-rule prelude string and return an array of AST nodes
+ * @param at_rule_name - The name of the at-rule (e.g., "media", "supports", "layer")
+ * @param prelude - The at-rule prelude to parse (e.g., "(min-width: 768px)", "utilities")
+ * @returns An array of CSSNode objects representing the parsed prelude
+ */
+export declare function parse_atrule_prelude(at_rule_name: string, prelude: string): CSSNode[];

package/dist/parse-atrule-prelude.js

@@ -0,0 +1,11 @@
+import { K as CSSDataArena, C as CSSNode } from './string-utils-B-rJII-E.js';
+import { A as AtRulePreludeParser } from './at-rule-prelude-parser-DlqYQAYH.js';
+
+function parse_atrule_prelude(at_rule_name, prelude) {
+  const arena = new CSSDataArena(CSSDataArena.capacity_for_source(prelude.length));
+  const prelude_parser = new AtRulePreludeParser(arena, prelude);
+  const node_indices = prelude_parser.parse_prelude(at_rule_name, 0, prelude.length);
+  return node_indices.map((index) => new CSSNode(arena, prelude, index));
+}
+
+export { parse_atrule_prelude };

package/dist/parse-selector.d.ts

@@ -0,0 +1,7 @@
+import { CSSNode } from './css-node';
+/**
+ * Parse a CSS selector string and return an AST
+ * @param source - The CSS selector to parse (e.g., "div.class > p#id")
+ * @returns The root CSSNode of the selector AST
+ */
+export declare function parse_selector(source: string): CSSNode;

package/dist/parse-selector.js

@@ -0,0 +1,19 @@
+import { K as CSSDataArena, d as NODE_SELECTOR, C as CSSNode } from './string-utils-B-rJII-E.js';
+import { S as SelectorParser } from './selector-parser-2b3tGyri.js';
+
+function parse_selector(source) {
+  const arena = new CSSDataArena(CSSDataArena.capacity_for_source(source.length));
+  const selector_parser = new SelectorParser(arena, source);
+  const selector_index = selector_parser.parse_selector(0, source.length);
+  if (selector_index === null) {
+    const empty = arena.create_node();
+    arena.set_type(empty, NODE_SELECTOR);
+    arena.set_start_offset(empty, 0);
+    arena.set_length(empty, 0);
+    arena.set_start_line(empty, 1);
+    return new CSSNode(arena, source, empty);
+  }
+  return new CSSNode(arena, source, selector_index);
+}
+
+export { parse_selector };

package/dist/parse.d.ts

@@ -0,0 +1,9 @@
+import type { ParserOptions } from './parser';
+import type { CSSNode } from './css-node';
+/**
+ * Parse CSS and return an AST
+ * @param source - The CSS source code to parse
+ * @param options - Parser options
+ * @returns The root CSSNode of the AST
+ */
+export declare function parse(source: string, options?: ParserOptions): CSSNode;