@projectwallace/css-parser 0.4.0 → 0.6.0

package/dist/lexer.d.ts

@@ -1,4 +1,14 @@
 import { type Token, type TokenType } from './token-types';
+export interface LexerPosition {
+    pos: number;
+    line: number;
+    column: number;
+    token_type: TokenType;
+    token_start: number;
+    token_end: number;
+    token_line: number;
+    token_column: number;
+}
 export declare class Lexer {
     source: string;
     pos: number;
@@ -24,4 +34,14 @@ export declare class Lexer {
     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/parse-anplusb.d.ts

@@ -0,0 +1,22 @@
+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;

package/dist/parse-anplusb.js

@@ -0,0 +1,220 @@
+import { L as Lexer, T as TOKEN_IDENT, h as TOKEN_DELIM, k as TOKEN_DIMENSION, i as TOKEN_NUMBER } from './lexer-CtBKgfVv.js';
+import { ai as CHAR_MINUS_HYPHEN, a0 as CHAR_PLUS, ag as skip_whitespace_forward, E as NODE_SELECTOR_NTH, C as CSSNode, T as CSSDataArena } from './css-node-BzCSxoLM.js';
+
+class ANplusBParser {
+  lexer;
+  arena;
+  source;
+  expr_end;
+  constructor(arena, source) {
+    this.arena = arena;
+    this.source = source;
+    this.lexer = new Lexer(source, true);
+    this.expr_end = 0;
+  }
+  /**
+   * Parse An+B expression
+   * Examples: odd, even, 3, n, -n, 2n, 2n+1, -3n-5
+   */
+  parse_anplusb(start, end, line = 1) {
+    this.expr_end = end;
+    this.lexer.pos = start;
+    this.lexer.line = line;
+    let a = null;
+    let b = null;
+    let a_start = start;
+    let a_end = start;
+    let b_start = start;
+    let b_end = start;
+    const node_start = start;
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.expr_end) {
+      return null;
+    }
+    this.lexer.next_token_fast(true);
+    if (this.lexer.token_type === TOKEN_IDENT) {
+      const text = this.source.substring(this.lexer.token_start, this.lexer.token_end).toLowerCase();
+      if (text === "odd" || text === "even") {
+        a = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+        a_start = this.lexer.token_start;
+        a_end = this.lexer.token_end;
+        return this.create_anplusb_node(node_start, a, null, a_start, a_end, 0, 0);
+      }
+      const first_char = this.source.charCodeAt(this.lexer.token_start);
+      const second_char = this.lexer.token_end > this.lexer.token_start + 1 ? this.source.charCodeAt(this.lexer.token_start + 1) : 0;
+      if (first_char === CHAR_MINUS_HYPHEN && second_char === 110) {
+        if (this.lexer.token_end > this.lexer.token_start + 2) {
+          const third_char = this.source.charCodeAt(this.lexer.token_start + 2);
+          if (third_char === CHAR_MINUS_HYPHEN) {
+            a = "-n";
+            a_start = this.lexer.token_start;
+            a_end = this.lexer.token_start + 2;
+            b = this.source.substring(this.lexer.token_start + 2, this.lexer.token_end);
+            b_start = this.lexer.token_start + 2;
+            b_end = this.lexer.token_end;
+            return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+          }
+        }
+        a = "-n";
+        a_start = this.lexer.token_start;
+        a_end = this.lexer.token_start + 2;
+        b = this.parse_b_part();
+        if (b !== null) {
+          b_start = this.lexer.token_start;
+          b_end = this.lexer.token_end;
+        }
+        return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+      }
+      if (first_char === 110) {
+        if (this.lexer.token_end > this.lexer.token_start + 1) {
+          const second_char2 = this.source.charCodeAt(this.lexer.token_start + 1);
+          if (second_char2 === CHAR_MINUS_HYPHEN) {
+            a = "n";
+            a_start = this.lexer.token_start;
+            a_end = this.lexer.token_start + 1;
+            b = this.source.substring(this.lexer.token_start + 1, this.lexer.token_end);
+            b_start = this.lexer.token_start + 1;
+            b_end = this.lexer.token_end;
+            return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+          }
+        }
+        a = "n";
+        a_start = this.lexer.token_start;
+        a_end = this.lexer.token_start + 1;
+        b = this.parse_b_part();
+        if (b !== null) {
+          b_start = this.lexer.token_start;
+          b_end = this.lexer.token_end;
+        }
+        return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+      }
+      return null;
+    }
+    if (this.lexer.token_type === TOKEN_DELIM && this.source.charCodeAt(this.lexer.token_start) === CHAR_PLUS) {
+      const saved = this.lexer.save_position();
+      this.lexer.next_token_fast(true);
+      if (this.lexer.token_type === TOKEN_IDENT) {
+        const text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+        const first_char = text.charCodeAt(0);
+        if (first_char === 110) {
+          a = "+n";
+          a_start = saved.pos - 1;
+          a_end = this.lexer.token_start + 1;
+          if (this.lexer.token_end > this.lexer.token_start + 1) {
+            const second_char = this.source.charCodeAt(this.lexer.token_start + 1);
+            if (second_char === CHAR_MINUS_HYPHEN) {
+              b = this.source.substring(this.lexer.token_start + 1, this.lexer.token_end);
+              b_start = this.lexer.token_start + 1;
+              b_end = this.lexer.token_end;
+              return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+            }
+          }
+          b = this.parse_b_part();
+          if (b !== null) {
+            b_start = this.lexer.token_start;
+            b_end = this.lexer.token_end;
+          }
+          return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+        }
+      }
+      this.lexer.restore_position(saved);
+    }
+    if (this.lexer.token_type === TOKEN_DIMENSION) {
+      const token_text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      const n_index = token_text.toLowerCase().indexOf("n");
+      if (n_index !== -1) {
+        a = token_text.substring(0, n_index + 1);
+        a_start = this.lexer.token_start;
+        a_end = this.lexer.token_start + n_index + 1;
+        if (n_index + 1 < token_text.length) {
+          const remainder = token_text.substring(n_index + 1);
+          if (remainder.charCodeAt(0) === CHAR_MINUS_HYPHEN) {
+            b = remainder;
+            b_start = this.lexer.token_start + n_index + 1;
+            b_end = this.lexer.token_end;
+            return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+          }
+        }
+        b = this.parse_b_part();
+        if (b !== null) {
+          b_start = this.lexer.token_start;
+          b_end = this.lexer.token_end;
+        }
+        return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+      }
+    }
+    if (this.lexer.token_type === TOKEN_NUMBER) {
+      let num_text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      b = num_text;
+      b_start = this.lexer.token_start;
+      b_end = this.lexer.token_end;
+      return this.create_anplusb_node(node_start, a, b, a_start, a_end, b_start, b_end);
+    }
+    return null;
+  }
+  /**
+   * Parse the b part after 'n'
+   * Handles: +5, -3, whitespace variations
+   */
+  parse_b_part() {
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.expr_end) {
+      return null;
+    }
+    this.lexer.next_token_fast(true);
+    if (this.lexer.token_type === TOKEN_DELIM) {
+      const ch = this.source.charCodeAt(this.lexer.token_start);
+      if (ch === CHAR_PLUS || ch === CHAR_MINUS_HYPHEN) {
+        const sign = ch === CHAR_MINUS_HYPHEN ? "-" : "";
+        this.skip_whitespace();
+        this.lexer.next_token_fast(true);
+        if (this.lexer.token_type === TOKEN_NUMBER) {
+          let num_text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+          if (num_text.charCodeAt(0) === CHAR_PLUS) {
+            num_text = num_text.substring(1);
+          }
+          return sign === "-" ? sign + num_text : num_text;
+        }
+      }
+    }
+    if (this.lexer.token_type === TOKEN_NUMBER) {
+      let num_text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      const first_char = num_text.charCodeAt(0);
+      if (first_char === CHAR_PLUS || first_char === CHAR_MINUS_HYPHEN) {
+        if (first_char === CHAR_PLUS) {
+          num_text = num_text.substring(1);
+        }
+        return num_text;
+      }
+    }
+    return null;
+  }
+  skip_whitespace() {
+    this.lexer.pos = skip_whitespace_forward(this.source, this.lexer.pos, this.expr_end);
+  }
+  create_anplusb_node(start, a, b, a_start, a_end, b_start, b_end) {
+    const node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_NTH);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, this.lexer.pos - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    if (a !== null) {
+      this.arena.set_content_start(node, a_start);
+      this.arena.set_content_length(node, a_end - a_start);
+    }
+    if (b !== null) {
+      this.arena.set_value_start(node, b_start);
+      this.arena.set_value_length(node, b_end - b_start);
+    }
+    return node;
+  }
+}
+function parse_anplusb(expr) {
+  const arena = new CSSDataArena(64);
+  const parser = new ANplusBParser(arena, expr);
+  const nodeIndex = parser.parse_anplusb(0, expr.length);
+  if (nodeIndex === null) return null;
+  return new CSSNode(arena, expr, nodeIndex);
+}
+
+export { ANplusBParser, parse_anplusb };

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

@@ -1,4 +1,28 @@
+import { CSSDataArena } from './arena';
 import { CSSNode } from './css-node';
+export declare class AtRulePreludeParser {
+    private lexer;
+    private arena;
+    private source;
+    private prelude_end;
+    constructor(arena: CSSDataArena, source: string);
+    parse_prelude(at_rule_name: string, start: number, end: number, line?: number, column?: number): number[];
+    private parse_media_query_list;
+    private is_and_or_not;
+    private parse_single_media_query;
+    private parse_media_feature;
+    private parse_container_query;
+    private parse_supports_query;
+    private parse_layer_names;
+    private parse_identifier;
+    private parse_import_prelude;
+    private parse_import_url;
+    private parse_import_layer;
+    private parse_import_supports;
+    private skip_whitespace;
+    private peek_token_type;
+    private next_token;
+}
 /**
  * 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")