@projectwallace/css-parser 0.1.0

package/dist/parse.js

@@ -0,0 +1,512 @@
+import { L as Lexer, y as TOKEN_EOF, q as TOKEN_COMMA, h as TOKEN_DELIM, a as TOKEN_FUNCTION, c as TOKEN_HASH, d as TOKEN_STRING, k as TOKEN_DIMENSION, j as TOKEN_PERCENTAGE, i as TOKEN_NUMBER, T as TOKEN_IDENT, t as TOKEN_LEFT_PAREN, u as TOKEN_RIGHT_PAREN, b as TOKEN_AT_KEYWORD, v as TOKEN_LEFT_BRACE, w as TOKEN_RIGHT_BRACE, o as TOKEN_COLON, p as TOKEN_SEMICOLON } from './lexer-DXablYMZ.js';
+import { J as is_whitespace, f as NODE_VALUE_KEYWORD, g as NODE_VALUE_NUMBER, h as NODE_VALUE_DIMENSION, i as NODE_VALUE_STRING, j as NODE_VALUE_COLOR, l as NODE_VALUE_OPERATOR, k as NODE_VALUE_FUNCTION, K as CSSDataArena, e as NODE_STYLESHEET, C as CSSNode, N as NODE_STYLE_RULE, L as FLAG_HAS_BLOCK, d as NODE_SELECTOR, c as NODE_DECLARATION, M as trim_boundaries, I as FLAG_IMPORTANT, a as NODE_AT_RULE } from './string-utils-B-rJII-E.js';
+import { S as SelectorParser } from './selector-parser-2b3tGyri.js';
+import { A as AtRulePreludeParser } from './at-rule-prelude-parser-DlqYQAYH.js';
+
+const CH_PLUS = 43;
+const CH_MINUS = 45;
+const CH_ASTERISK = 42;
+const CH_SLASH = 47;
+class ValueParser {
+  lexer;
+  arena;
+  source;
+  value_end;
+  constructor(arena, source) {
+    this.arena = arena;
+    this.source = source;
+    this.lexer = new Lexer(source, false);
+    this.value_end = 0;
+  }
+  // Parse a declaration value range into value nodes
+  // Returns array of value node indices
+  parse_value(start, end) {
+    this.value_end = end;
+    this.lexer.pos = start;
+    this.lexer.line = 1;
+    let nodes = [];
+    while (this.lexer.pos < this.value_end) {
+      this.lexer.next_token_fast(false);
+      if (this.lexer.token_start >= this.value_end) break;
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_EOF) break;
+      if (this.is_whitespace_token()) {
+        continue;
+      }
+      let node = this.parse_value_node();
+      if (node !== null) {
+        nodes.push(node);
+      }
+    }
+    return nodes;
+  }
+  is_whitespace_token() {
+    let start = this.lexer.token_start;
+    let end = this.lexer.token_end;
+    if (start >= end) return false;
+    for (let i = start; i < end; i++) {
+      let ch = this.source.charCodeAt(i);
+      if (!is_whitespace(ch)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  parse_value_node() {
+    let token_type = this.lexer.token_type;
+    let start = this.lexer.token_start;
+    let end = this.lexer.token_end;
+    switch (token_type) {
+      case TOKEN_IDENT:
+        return this.create_keyword_node(start, end);
+      case TOKEN_NUMBER:
+        return this.create_number_node(start, end);
+      case TOKEN_PERCENTAGE:
+      case TOKEN_DIMENSION:
+        return this.create_dimension_node(start, end);
+      case TOKEN_STRING:
+        return this.create_string_node(start, end);
+      case TOKEN_HASH:
+        return this.create_color_node(start, end);
+      case TOKEN_FUNCTION:
+        return this.parse_function_node(start, end);
+      case TOKEN_DELIM:
+        return this.parse_operator_node(start, end);
+      case TOKEN_COMMA:
+        return this.create_operator_node(start, end);
+      default:
+        return null;
+    }
+  }
+  create_keyword_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_KEYWORD);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_number_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_NUMBER);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_dimension_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_DIMENSION);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_string_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_STRING);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_color_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_COLOR);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_operator_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_OPERATOR);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  parse_operator_node(start, end) {
+    let ch = this.source.charCodeAt(start);
+    if (ch === CH_PLUS || ch === CH_MINUS || ch === CH_ASTERISK || ch === CH_SLASH) {
+      return this.create_operator_node(start, end);
+    }
+    return null;
+  }
+  parse_function_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_FUNCTION);
+    this.arena.set_start_offset(node, start);
+    let name_end = end - 1;
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, name_end - start);
+    let args = [];
+    let paren_depth = 1;
+    let func_end = end;
+    while (this.lexer.pos < this.value_end && paren_depth > 0) {
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_EOF) break;
+      if (this.lexer.token_start >= this.value_end) break;
+      if (token_type === TOKEN_LEFT_PAREN) {
+        paren_depth++;
+      } else if (token_type === TOKEN_RIGHT_PAREN) {
+        paren_depth--;
+        if (paren_depth === 0) {
+          func_end = this.lexer.token_end;
+          break;
+        }
+      }
+      if (this.is_whitespace_token()) continue;
+      let arg_node = this.parse_value_node();
+      if (arg_node !== null) {
+        args.push(arg_node);
+      }
+    }
+    this.arena.set_length(node, func_end - start);
+    if (args.length > 0) {
+      this.arena.set_first_child(node, args[0]);
+      this.arena.set_last_child(node, args[args.length - 1]);
+      for (let i = 0; i < args.length - 1; i++) {
+        this.arena.set_next_sibling(args[i], args[i + 1]);
+      }
+    }
+    return node;
+  }
+}
+
+let DECLARATION_AT_RULES = /* @__PURE__ */ new Set(["font-face", "font-feature-values", "page", "property", "counter-style"]);
+let CONDITIONAL_AT_RULES = /* @__PURE__ */ new Set(["media", "supports", "container", "layer", "nest"]);
+class Parser {
+  source;
+  lexer;
+  arena;
+  value_parser;
+  selector_parser;
+  prelude_parser;
+  parse_values_enabled;
+  parse_selectors_enabled;
+  parse_atrule_preludes_enabled;
+  constructor(source, options) {
+    this.source = source;
+    let opts;
+    if (typeof options === "boolean") {
+      opts = { skip_comments: options };
+    } else {
+      opts = options || {};
+    }
+    let skip_comments = opts.skip_comments ?? true;
+    this.parse_values_enabled = opts.parse_values ?? true;
+    this.parse_selectors_enabled = opts.parse_selectors ?? true;
+    this.parse_atrule_preludes_enabled = opts.parse_atrule_preludes ?? true;
+    this.lexer = new Lexer(source, skip_comments);
+    let capacity = CSSDataArena.capacity_for_source(source.length);
+    this.arena = new CSSDataArena(capacity);
+    this.value_parser = this.parse_values_enabled ? new ValueParser(this.arena, source) : null;
+    this.selector_parser = this.parse_selectors_enabled ? new SelectorParser(this.arena, source) : null;
+    this.prelude_parser = this.parse_atrule_preludes_enabled ? new AtRulePreludeParser(this.arena, source) : null;
+  }
+  // Get the arena (for internal/advanced use only)
+  get_arena() {
+    return this.arena;
+  }
+  // Get the source code
+  get_source() {
+    return this.source;
+  }
+  // Advance to the next token, skipping whitespace
+  next_token() {
+    this.lexer.next_token_fast(true);
+  }
+  // Peek at current token type
+  peek_type() {
+    return this.lexer.token_type;
+  }
+  // Check if we're at the end of input
+  is_eof() {
+    return this.peek_type() === TOKEN_EOF;
+  }
+  // Parse the entire stylesheet and return the root CSSNode
+  parse() {
+    this.next_token();
+    let stylesheet = this.arena.create_node();
+    this.arena.set_type(stylesheet, NODE_STYLESHEET);
+    this.arena.set_start_offset(stylesheet, 0);
+    this.arena.set_length(stylesheet, this.source.length);
+    this.arena.set_start_line(stylesheet, 1);
+    while (!this.is_eof()) {
+      let rule = this.parse_rule();
+      if (rule !== null) {
+        this.arena.append_child(stylesheet, rule);
+      } else {
+        this.next_token();
+      }
+    }
+    return new CSSNode(this.arena, this.source, stylesheet);
+  }
+  // Parse a rule (style rule or at-rule)
+  parse_rule() {
+    if (this.is_eof()) {
+      return null;
+    }
+    if (this.peek_type() === TOKEN_AT_KEYWORD) {
+      return this.parse_atrule();
+    }
+    return this.parse_style_rule();
+  }
+  // Parse a style rule: selector { declarations }
+  parse_style_rule() {
+    if (this.is_eof()) return null;
+    let rule_start = this.lexer.token_start;
+    let rule_line = this.lexer.token_line;
+    let style_rule = this.arena.create_node();
+    this.arena.set_type(style_rule, NODE_STYLE_RULE);
+    this.arena.set_start_line(style_rule, rule_line);
+    let selector = this.parse_selector();
+    if (selector !== null) {
+      this.arena.append_child(style_rule, selector);
+    }
+    if (this.peek_type() !== TOKEN_LEFT_BRACE) {
+      return null;
+    }
+    this.next_token();
+    this.arena.set_flag(style_rule, FLAG_HAS_BLOCK);
+    while (!this.is_eof()) {
+      let token_type = this.peek_type();
+      if (token_type === TOKEN_RIGHT_BRACE) break;
+      if (token_type === TOKEN_AT_KEYWORD) {
+        let nested_at_rule = this.parse_atrule();
+        if (nested_at_rule !== null) {
+          this.arena.append_child(style_rule, nested_at_rule);
+        } else {
+          this.next_token();
+        }
+        continue;
+      }
+      let declaration = this.parse_declaration();
+      if (declaration !== null) {
+        this.arena.append_child(style_rule, declaration);
+        continue;
+      }
+      let nested_rule = this.parse_style_rule();
+      if (nested_rule !== null) {
+        this.arena.append_child(style_rule, nested_rule);
+      } else {
+        this.next_token();
+      }
+    }
+    if (this.peek_type() === TOKEN_RIGHT_BRACE) {
+      this.next_token();
+    }
+    this.arena.set_start_offset(style_rule, rule_start);
+    this.arena.set_length(style_rule, this.lexer.token_end - rule_start);
+    return style_rule;
+  }
+  // Parse a selector (everything before '{')
+  parse_selector() {
+    if (this.is_eof()) return null;
+    let selector_start = this.lexer.token_start;
+    let selector_line = this.lexer.token_line;
+    let last_end = this.lexer.token_end;
+    while (!this.is_eof() && this.peek_type() !== TOKEN_LEFT_BRACE) {
+      last_end = this.lexer.token_end;
+      this.next_token();
+    }
+    if (this.parse_selectors_enabled && this.selector_parser) {
+      let selectorNode = this.selector_parser.parse_selector(selector_start, last_end, selector_line);
+      if (selectorNode !== null) {
+        return selectorNode;
+      }
+    }
+    let selector = this.arena.create_node();
+    this.arena.set_type(selector, NODE_SELECTOR);
+    this.arena.set_start_line(selector, selector_line);
+    this.arena.set_start_offset(selector, selector_start);
+    this.arena.set_length(selector, last_end - selector_start);
+    return selector;
+  }
+  // Parse a declaration: property: value;
+  parse_declaration() {
+    if (this.peek_type() !== TOKEN_IDENT) {
+      return null;
+    }
+    let prop_start = this.lexer.token_start;
+    let prop_end = this.lexer.token_end;
+    let decl_line = this.lexer.token_line;
+    this.next_token();
+    if (this.peek_type() !== TOKEN_COLON) {
+      return null;
+    }
+    this.next_token();
+    let declaration = this.arena.create_node();
+    this.arena.set_type(declaration, NODE_DECLARATION);
+    this.arena.set_start_line(declaration, decl_line);
+    this.arena.set_start_offset(declaration, prop_start);
+    this.arena.set_content_start(declaration, prop_start);
+    this.arena.set_content_length(declaration, prop_end - prop_start);
+    let value_start = this.lexer.token_start;
+    let value_end = value_start;
+    let has_important = false;
+    let last_end = this.lexer.token_end;
+    while (!this.is_eof()) {
+      let token_type = this.peek_type();
+      if (token_type === TOKEN_SEMICOLON || token_type === TOKEN_RIGHT_BRACE) break;
+      if (token_type === TOKEN_DELIM && this.source[this.lexer.token_start] === "!") {
+        value_end = this.lexer.token_start;
+        let next_type = this.lexer.next_token_fast();
+        if (next_type === TOKEN_IDENT) {
+          has_important = true;
+          last_end = this.lexer.token_end;
+          break;
+        }
+      }
+      last_end = this.lexer.token_end;
+      value_end = last_end;
+      this.next_token();
+    }
+    let trimmed = trim_boundaries(this.source, value_start, value_end);
+    if (trimmed) {
+      this.arena.set_value_start(declaration, trimmed[0]);
+      this.arena.set_value_length(declaration, trimmed[1] - trimmed[0]);
+      if (this.parse_values_enabled && this.value_parser) {
+        let valueNodes = this.value_parser.parse_value(trimmed[0], trimmed[1]);
+        if (valueNodes.length > 0) {
+          this.arena.set_first_child(declaration, valueNodes[0]);
+          this.arena.set_last_child(declaration, valueNodes[valueNodes.length - 1]);
+          for (let i = 0; i < valueNodes.length - 1; i++) {
+            this.arena.set_next_sibling(valueNodes[i], valueNodes[i + 1]);
+          }
+        }
+      }
+    }
+    if (has_important) {
+      this.arena.set_flag(declaration, FLAG_IMPORTANT);
+    }
+    if (this.peek_type() === TOKEN_SEMICOLON) {
+      last_end = this.lexer.token_end;
+      this.next_token();
+    }
+    this.arena.set_length(declaration, last_end - prop_start);
+    return declaration;
+  }
+  // Parse an at-rule: @media, @import, @font-face, etc.
+  parse_atrule() {
+    if (this.peek_type() !== TOKEN_AT_KEYWORD) {
+      return null;
+    }
+    let at_rule_start = this.lexer.token_start;
+    let at_rule_line = this.lexer.token_line;
+    let at_rule_name = this.source.substring(this.lexer.token_start + 1, this.lexer.token_end);
+    let name_start = this.lexer.token_start + 1;
+    let name_length = at_rule_name.length;
+    this.next_token();
+    let at_rule = this.arena.create_node();
+    this.arena.set_type(at_rule, NODE_AT_RULE);
+    this.arena.set_start_line(at_rule, at_rule_line);
+    this.arena.set_start_offset(at_rule, at_rule_start);
+    this.arena.set_content_start(at_rule, name_start);
+    this.arena.set_content_length(at_rule, name_length);
+    let prelude_start = this.lexer.token_start;
+    let prelude_end = prelude_start;
+    while (!this.is_eof() && this.peek_type() !== TOKEN_LEFT_BRACE && this.peek_type() !== TOKEN_SEMICOLON) {
+      prelude_end = this.lexer.token_end;
+      this.next_token();
+    }
+    let trimmed = trim_boundaries(this.source, prelude_start, prelude_end);
+    if (trimmed) {
+      this.arena.set_value_start(at_rule, trimmed[0]);
+      this.arena.set_value_length(at_rule, trimmed[1] - trimmed[0]);
+      if (this.prelude_parser) {
+        let prelude_nodes = this.prelude_parser.parse_prelude(at_rule_name, trimmed[0], trimmed[1], at_rule_line);
+        for (let prelude_node of prelude_nodes) {
+          this.arena.append_child(at_rule, prelude_node);
+        }
+      }
+    }
+    let last_end = this.lexer.token_end;
+    if (this.peek_type() === TOKEN_LEFT_BRACE) {
+      this.next_token();
+      this.arena.set_flag(at_rule, FLAG_HAS_BLOCK);
+      let has_declarations = this.atrule_has_declarations(at_rule_name);
+      let is_conditional = this.atrule_is_conditional(at_rule_name);
+      if (has_declarations) {
+        while (!this.is_eof()) {
+          let token_type = this.peek_type();
+          if (token_type === TOKEN_RIGHT_BRACE) break;
+          let declaration = this.parse_declaration();
+          if (declaration !== null) {
+            this.arena.append_child(at_rule, declaration);
+          } else {
+            this.next_token();
+          }
+        }
+      } else if (is_conditional) {
+        while (!this.is_eof()) {
+          let token_type = this.peek_type();
+          if (token_type === TOKEN_RIGHT_BRACE) break;
+          if (token_type === TOKEN_AT_KEYWORD) {
+            let nested_at_rule = this.parse_atrule();
+            if (nested_at_rule !== null) {
+              this.arena.append_child(at_rule, nested_at_rule);
+            } else {
+              this.next_token();
+            }
+            continue;
+          }
+          let declaration = this.parse_declaration();
+          if (declaration !== null) {
+            this.arena.append_child(at_rule, declaration);
+            continue;
+          }
+          let nested_rule = this.parse_style_rule();
+          if (nested_rule !== null) {
+            this.arena.append_child(at_rule, nested_rule);
+          } else {
+            this.next_token();
+          }
+        }
+      } else {
+        while (!this.is_eof()) {
+          let token_type = this.peek_type();
+          if (token_type === TOKEN_RIGHT_BRACE) break;
+          let rule = this.parse_rule();
+          if (rule !== null) {
+            this.arena.append_child(at_rule, rule);
+          } else {
+            this.next_token();
+          }
+        }
+      }
+      if (this.peek_type() === TOKEN_RIGHT_BRACE) {
+        last_end = this.lexer.token_end;
+        this.next_token();
+      }
+    } else if (this.peek_type() === TOKEN_SEMICOLON) {
+      last_end = this.lexer.token_end;
+      this.next_token();
+    }
+    this.arena.set_length(at_rule, last_end - at_rule_start);
+    return at_rule;
+  }
+  // Determine if an at-rule contains declarations or nested rules
+  atrule_has_declarations(name) {
+    return DECLARATION_AT_RULES.has(name.toLowerCase());
+  }
+  // Determine if an at-rule is conditional (can contain both declarations and rules in CSS Nesting)
+  atrule_is_conditional(name) {
+    return CONDITIONAL_AT_RULES.has(name.toLowerCase());
+  }
+}
+
+function parse(source, options) {
+  const parser = new Parser(source, options);
+  return parser.parse();
+}
+
+export { parse };

package/dist/parser.d.ts

@@ -0,0 +1,34 @@
+import { CSSDataArena } from './arena';
+import { CSSNode } from './css-node';
+export interface ParserOptions {
+    skip_comments?: boolean;
+    parse_values?: boolean;
+    parse_selectors?: boolean;
+    parse_atrule_preludes?: boolean;
+}
+export declare class Parser {
+    private source;
+    private lexer;
+    private arena;
+    private value_parser;
+    private selector_parser;
+    private prelude_parser;
+    private parse_values_enabled;
+    private parse_selectors_enabled;
+    private parse_atrule_preludes_enabled;
+    constructor(source: string, options?: ParserOptions | boolean);
+    get_arena(): CSSDataArena;
+    get_source(): string;
+    private next_token;
+    private peek_type;
+    private is_eof;
+    parse(): CSSNode;
+    private parse_rule;
+    private parse_style_rule;
+    private parse_selector;
+    private parse_declaration;
+    private parse_atrule;
+    private atrule_has_declarations;
+    private atrule_is_conditional;
+}
+export { NODE_STYLESHEET, NODE_STYLE_RULE, NODE_AT_RULE, NODE_DECLARATION, NODE_SELECTOR, NODE_COMMENT, 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 './arena';