@projectwallace/css-parser 0.1.0

package/dist/string-utils-B-rJII-E.js

@@ -0,0 +1,440 @@
+let BYTES_PER_NODE = 44;
+const NODE_STYLESHEET = 1;
+const NODE_STYLE_RULE = 2;
+const NODE_AT_RULE = 3;
+const NODE_DECLARATION = 4;
+const NODE_SELECTOR = 5;
+const NODE_COMMENT = 6;
+const NODE_VALUE_KEYWORD = 10;
+const NODE_VALUE_NUMBER = 11;
+const NODE_VALUE_DIMENSION = 12;
+const NODE_VALUE_STRING = 13;
+const NODE_VALUE_COLOR = 14;
+const NODE_VALUE_FUNCTION = 15;
+const NODE_VALUE_OPERATOR = 16;
+const NODE_SELECTOR_LIST = 20;
+const NODE_SELECTOR_TYPE = 21;
+const NODE_SELECTOR_CLASS = 22;
+const NODE_SELECTOR_ID = 23;
+const NODE_SELECTOR_ATTRIBUTE = 24;
+const NODE_SELECTOR_PSEUDO_CLASS = 25;
+const NODE_SELECTOR_PSEUDO_ELEMENT = 26;
+const NODE_SELECTOR_COMBINATOR = 27;
+const NODE_SELECTOR_UNIVERSAL = 28;
+const NODE_SELECTOR_NESTING = 29;
+const NODE_PRELUDE_MEDIA_QUERY = 30;
+const NODE_PRELUDE_MEDIA_FEATURE = 31;
+const NODE_PRELUDE_MEDIA_TYPE = 32;
+const NODE_PRELUDE_CONTAINER_QUERY = 33;
+const NODE_PRELUDE_SUPPORTS_QUERY = 34;
+const NODE_PRELUDE_LAYER_NAME = 35;
+const NODE_PRELUDE_IDENTIFIER = 36;
+const NODE_PRELUDE_OPERATOR = 37;
+const NODE_PRELUDE_IMPORT_URL = 38;
+const NODE_PRELUDE_IMPORT_LAYER = 39;
+const NODE_PRELUDE_IMPORT_SUPPORTS = 40;
+const FLAG_IMPORTANT = 1 << 0;
+const FLAG_HAS_ERROR = 1 << 1;
+const FLAG_HAS_BLOCK = 1 << 3;
+class CSSDataArena {
+  buffer;
+  view;
+  capacity;
+  // Number of nodes that can fit
+  count;
+  // Number of nodes currently allocated
+  // Growth multiplier when capacity is exceeded
+  static GROWTH_FACTOR = 1.3;
+  // Estimated nodes per KB of CSS (based on real-world data)
+  static NODES_PER_KB = 60;
+  // Buffer to avoid frequent growth (15%)
+  static CAPACITY_BUFFER = 1.15;
+  constructor(initial_capacity = 1024) {
+    this.capacity = initial_capacity;
+    this.count = 1;
+    this.buffer = new ArrayBuffer(initial_capacity * BYTES_PER_NODE);
+    this.view = new DataView(this.buffer);
+  }
+  // Calculate recommended initial capacity based on CSS source size
+  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 the number of nodes currently in the arena
+  get_count() {
+    return this.count;
+  }
+  // Get the capacity (max nodes without reallocation)
+  get_capacity() {
+    return this.capacity;
+  }
+  // Calculate byte offset for a node
+  node_offset(node_index) {
+    return node_index * BYTES_PER_NODE;
+  }
+  // Read node type
+  get_type(node_index) {
+    return this.view.getUint8(this.node_offset(node_index));
+  }
+  // Read node flags
+  get_flags(node_index) {
+    return this.view.getUint8(this.node_offset(node_index) + 1);
+  }
+  // Read start offset in source
+  get_start_offset(node_index) {
+    return this.view.getUint32(this.node_offset(node_index) + 4, true);
+  }
+  // Read length in source
+  get_length(node_index) {
+    return this.view.getUint16(this.node_offset(node_index) + 8, true);
+  }
+  // Read content start offset
+  get_content_start(node_index) {
+    return this.view.getUint32(this.node_offset(node_index) + 12, true);
+  }
+  // Read content length
+  get_content_length(node_index) {
+    return this.view.getUint16(this.node_offset(node_index) + 16, true);
+  }
+  // Read first child index (0 = no children)
+  get_first_child(node_index) {
+    return this.view.getUint32(this.node_offset(node_index) + 20, true);
+  }
+  // Read last child index (0 = no children)
+  get_last_child(node_index) {
+    return this.view.getUint32(this.node_offset(node_index) + 24, true);
+  }
+  // Read next sibling index (0 = no sibling)
+  get_next_sibling(node_index) {
+    return this.view.getUint32(this.node_offset(node_index) + 28, true);
+  }
+  // Read start line
+  get_start_line(node_index) {
+    return this.view.getUint32(this.node_offset(node_index) + 32, true);
+  }
+  // Read value start offset (declaration value / at-rule prelude)
+  get_value_start(node_index) {
+    return this.view.getUint32(this.node_offset(node_index) + 36, true);
+  }
+  // Read value length
+  get_value_length(node_index) {
+    return this.view.getUint16(this.node_offset(node_index) + 40, true);
+  }
+  // --- Write Methods ---
+  // Write node type
+  set_type(node_index, type) {
+    this.view.setUint8(this.node_offset(node_index), type);
+  }
+  // Write node flags
+  set_flags(node_index, flags) {
+    this.view.setUint8(this.node_offset(node_index) + 1, flags);
+  }
+  // Write start offset in source
+  set_start_offset(node_index, offset) {
+    this.view.setUint32(this.node_offset(node_index) + 4, offset, true);
+  }
+  // Write length in source
+  set_length(node_index, length) {
+    this.view.setUint16(this.node_offset(node_index) + 8, length, true);
+  }
+  // Write content start offset
+  set_content_start(node_index, offset) {
+    this.view.setUint32(this.node_offset(node_index) + 12, offset, true);
+  }
+  // Write content length
+  set_content_length(node_index, length) {
+    this.view.setUint16(this.node_offset(node_index) + 16, length, true);
+  }
+  // Write first child index
+  set_first_child(node_index, childIndex) {
+    this.view.setUint32(this.node_offset(node_index) + 20, childIndex, true);
+  }
+  // Write last child index
+  set_last_child(node_index, childIndex) {
+    this.view.setUint32(this.node_offset(node_index) + 24, childIndex, true);
+  }
+  // Write next sibling index
+  set_next_sibling(node_index, siblingIndex) {
+    this.view.setUint32(this.node_offset(node_index) + 28, siblingIndex, true);
+  }
+  // Write start line
+  set_start_line(node_index, line) {
+    this.view.setUint32(this.node_offset(node_index) + 32, line, true);
+  }
+  // Write value start offset (declaration value / at-rule prelude)
+  set_value_start(node_index, offset) {
+    this.view.setUint32(this.node_offset(node_index) + 36, offset, true);
+  }
+  // Write value length
+  set_value_length(node_index, length) {
+    this.view.setUint16(this.node_offset(node_index) + 40, length, true);
+  }
+  // --- Node Creation ---
+  // Grow the arena by 1.3x when capacity is exceeded
+  grow() {
+    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;
+  }
+  // Allocate a new node and return its index
+  // The node is zero-initialized by default (ArrayBuffer guarantees this)
+  // Automatically grows the arena if capacity is exceeded
+  create_node() {
+    if (this.count >= this.capacity) {
+      this.grow();
+    }
+    let node_index = this.count;
+    this.count++;
+    return node_index;
+  }
+  // --- Tree Building Helpers ---
+  // Add a child node to a parent node
+  // This appends to the end of the child list using the sibling chain
+  // O(1) operation using lastChild pointer
+  append_child(parentIndex, childIndex) {
+    let last_child = this.get_last_child(parentIndex);
+    if (last_child === 0) {
+      this.set_first_child(parentIndex, childIndex);
+      this.set_last_child(parentIndex, childIndex);
+    } else {
+      this.set_next_sibling(last_child, childIndex);
+      this.set_last_child(parentIndex, childIndex);
+    }
+  }
+  // Check if a node has any children
+  has_children(node_index) {
+    return this.get_first_child(node_index) !== 0;
+  }
+  // Check if a node has a next sibling
+  has_next_sibling(node_index) {
+    return this.get_next_sibling(node_index) !== 0;
+  }
+  // --- Flag Management Helpers ---
+  // Set a specific flag bit (doesn't clear other flags)
+  set_flag(node_index, flag) {
+    let current_flags = this.get_flags(node_index);
+    this.set_flags(node_index, current_flags | flag);
+  }
+  // Clear a specific flag bit (doesn't affect other flags)
+  clear_flag(node_index, flag) {
+    let current_flags = this.get_flags(node_index);
+    this.set_flags(node_index, current_flags & ~flag);
+  }
+  // Check if a specific flag is set
+  has_flag(node_index, flag) {
+    return (this.get_flags(node_index) & flag) !== 0;
+  }
+}
+
+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 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")
+  get 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() {
+    return this.value;
+  }
+  // Check if this declaration has !important
+  get is_important() {
+    return this.arena.has_flag(this.index, FLAG_IMPORTANT);
+  }
+  // Check if this has a vendor prefix (lazy computation for performance)
+  get is_vendor_prefixed() {
+    const name = this.name;
+    if (!name) return false;
+    return name.startsWith("-webkit-") || name.startsWith("-moz-") || name.startsWith("-ms-") || name.startsWith("-o-");
+  }
+  // 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);
+  }
+  // --- 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 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);
+  }
+  // Check if this node has children
+  get has_children() {
+    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;
+    }
+  }
+}
+
+const CHAR_SPACE = 32;
+const CHAR_TAB = 9;
+const CHAR_NEWLINE = 10;
+const CHAR_CARRIAGE_RETURN = 13;
+const CHAR_FORM_FEED = 12;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_ASTERISK = 42;
+function is_whitespace(ch) {
+  return ch === CHAR_SPACE || ch === CHAR_TAB || ch === CHAR_NEWLINE || ch === CHAR_CARRIAGE_RETURN || ch === CHAR_FORM_FEED;
+}
+function trim_boundaries(source, start, end) {
+  while (start < end) {
+    let ch = source.charCodeAt(start);
+    if (is_whitespace(ch)) {
+      start++;
+      continue;
+    }
+    if (ch === CHAR_FORWARD_SLASH && start + 1 < end && source.charCodeAt(start + 1) === CHAR_ASTERISK) {
+      start += 2;
+      while (start < end) {
+        if (source.charCodeAt(start) === CHAR_ASTERISK && start + 1 < end && source.charCodeAt(start + 1) === CHAR_FORWARD_SLASH) {
+          start += 2;
+          break;
+        }
+        start++;
+      }
+      continue;
+    }
+    break;
+  }
+  while (end > start) {
+    let ch = source.charCodeAt(end - 1);
+    if (is_whitespace(ch)) {
+      end--;
+      continue;
+    }
+    if (end >= 2 && ch === CHAR_FORWARD_SLASH && source.charCodeAt(end - 2) === CHAR_ASTERISK) {
+      end -= 2;
+      while (end > start) {
+        if (end >= 2 && source.charCodeAt(end - 2) === CHAR_FORWARD_SLASH && source.charCodeAt(end - 1) === CHAR_ASTERISK) {
+          end -= 2;
+          break;
+        }
+        end--;
+      }
+      continue;
+    }
+    break;
+  }
+  if (start >= end) return null;
+  return [start, end];
+}
+function str_equals(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    let ca = a.charCodeAt(i);
+    let cb = b.charCodeAt(i);
+    if (cb >= 65 && cb <= 90) cb |= 32;
+    if (ca !== cb) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { NODE_PRELUDE_SUPPORTS_QUERY as A, NODE_PRELUDE_LAYER_NAME as B, CSSNode as C, NODE_PRELUDE_IDENTIFIER as D, NODE_PRELUDE_OPERATOR as E, NODE_PRELUDE_IMPORT_URL as F, NODE_PRELUDE_IMPORT_LAYER as G, NODE_PRELUDE_IMPORT_SUPPORTS as H, FLAG_IMPORTANT as I, is_whitespace as J, CSSDataArena as K, FLAG_HAS_BLOCK as L, trim_boundaries as M, NODE_STYLE_RULE as N, str_equals as O, CHAR_SPACE as P, CHAR_TAB as Q, CHAR_NEWLINE as R, CHAR_CARRIAGE_RETURN as S, CHAR_FORM_FEED as T, NODE_AT_RULE as a, NODE_COMMENT as b, NODE_DECLARATION as c, NODE_SELECTOR as d, NODE_STYLESHEET as e, NODE_VALUE_KEYWORD as f, NODE_VALUE_NUMBER as g, NODE_VALUE_DIMENSION as h, NODE_VALUE_STRING as i, NODE_VALUE_COLOR as j, NODE_VALUE_FUNCTION as k, NODE_VALUE_OPERATOR as l, NODE_SELECTOR_LIST as m, NODE_SELECTOR_TYPE as n, NODE_SELECTOR_CLASS as o, NODE_SELECTOR_ID as p, NODE_SELECTOR_ATTRIBUTE as q, NODE_SELECTOR_PSEUDO_CLASS as r, NODE_SELECTOR_PSEUDO_ELEMENT as s, NODE_SELECTOR_COMBINATOR as t, NODE_SELECTOR_UNIVERSAL as u, NODE_SELECTOR_NESTING as v, NODE_PRELUDE_MEDIA_QUERY as w, NODE_PRELUDE_MEDIA_FEATURE as x, NODE_PRELUDE_MEDIA_TYPE as y, NODE_PRELUDE_CONTAINER_QUERY as z };

package/dist/string-utils.d.ts

@@ -0,0 +1,29 @@
+export declare const CHAR_SPACE = 32;
+export declare const CHAR_TAB = 9;
+export declare const CHAR_NEWLINE = 10;
+export declare const CHAR_CARRIAGE_RETURN = 13;
+export declare const CHAR_FORM_FEED = 12;
+export declare const CHAR_FORWARD_SLASH = 47;
+export declare const CHAR_ASTERISK = 42;
+/**
+ * Check if a character code is whitespace (space, tab, newline, CR, or FF)
+ */
+export declare function is_whitespace(ch: number): boolean;
+/**
+ * Trim whitespace and comments from both ends of a string range
+ *
+ * @param source - The source string
+ * @param start - Start offset in source
+ * @param end - End offset in source
+ * @returns [trimmed_start, trimmed_end] or null if all whitespace/comments
+ *
+ * Skips whitespace (space, tab, newline, CR, FF) and CSS comments from both ends
+ * of the specified range. Returns the trimmed boundaries or null if the range
+ * contains only whitespace and comments.
+ */
+export declare function trim_boundaries(source: string, start: number, end: number): [number, number] | null;
+/**
+ * @param a Base string, MUST be lowercase!
+ * @param b Compare string
+ */
+export declare function str_equals(a: string, b: string): boolean;

package/dist/token-types.d.ts

@@ -0,0 +1,34 @@
+export declare const TOKEN_IDENT = 1;
+export declare const TOKEN_FUNCTION = 2;
+export declare const TOKEN_AT_KEYWORD = 3;
+export declare const TOKEN_HASH = 4;
+export declare const TOKEN_STRING = 5;
+export declare const TOKEN_BAD_STRING = 6;
+export declare const TOKEN_URL = 7;
+export declare const TOKEN_BAD_URL = 8;
+export declare const TOKEN_DELIM = 9;
+export declare const TOKEN_NUMBER = 10;
+export declare const TOKEN_PERCENTAGE = 11;
+export declare const TOKEN_DIMENSION = 12;
+export declare const TOKEN_WHITESPACE = 13;
+export declare const TOKEN_CDO = 14;
+export declare const TOKEN_CDC = 15;
+export declare const TOKEN_COLON = 16;
+export declare const TOKEN_SEMICOLON = 17;
+export declare const TOKEN_COMMA = 18;
+export declare const TOKEN_LEFT_BRACKET = 19;
+export declare const TOKEN_RIGHT_BRACKET = 20;
+export declare const TOKEN_LEFT_PAREN = 21;
+export declare const TOKEN_RIGHT_PAREN = 22;
+export declare const TOKEN_LEFT_BRACE = 23;
+export declare const TOKEN_RIGHT_BRACE = 24;
+export declare const TOKEN_COMMENT = 25;
+export declare const TOKEN_EOF = 26;
+export type TokenType = typeof TOKEN_IDENT | typeof TOKEN_FUNCTION | typeof TOKEN_AT_KEYWORD | typeof TOKEN_HASH | typeof TOKEN_STRING | typeof TOKEN_BAD_STRING | typeof TOKEN_URL | typeof TOKEN_BAD_URL | typeof TOKEN_DELIM | typeof TOKEN_NUMBER | typeof TOKEN_PERCENTAGE | typeof TOKEN_DIMENSION | typeof TOKEN_WHITESPACE | typeof TOKEN_CDO | typeof TOKEN_CDC | typeof TOKEN_COLON | typeof TOKEN_SEMICOLON | typeof TOKEN_COMMA | typeof TOKEN_LEFT_BRACKET | typeof TOKEN_RIGHT_BRACKET | typeof TOKEN_LEFT_PAREN | typeof TOKEN_RIGHT_PAREN | typeof TOKEN_LEFT_BRACE | typeof TOKEN_RIGHT_BRACE | typeof TOKEN_COMMENT | typeof TOKEN_EOF;
+export type Token = {
+    type: TokenType;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+};

package/dist/tokenize.d.ts

@@ -0,0 +1,8 @@
+import type { Token } from './token-types';
+/**
+ * Tokenize CSS source code
+ * @param source - The CSS source code to tokenize
+ * @param skip_comments - Whether to skip comment tokens (default: true)
+ * @yields CSS tokens
+ */
+export declare function tokenize(source: string, skip_comments?: boolean): Generator<Token, void, undefined>;

package/dist/tokenize.js

@@ -0,0 +1,14 @@
+import { L as Lexer, y as TOKEN_EOF } from './lexer-DXablYMZ.js';
+
+function* tokenize(source, skip_comments = true) {
+  const lexer = new Lexer(source, skip_comments);
+  while (true) {
+    const token = lexer.next_token();
+    if (!token || token.type === TOKEN_EOF) {
+      break;
+    }
+    yield token;
+  }
+}
+
+export { tokenize };

package/dist/value-parser.d.ts

@@ -0,0 +1,19 @@
+import type { CSSDataArena } from './arena';
+export declare class ValueParser {
+    private lexer;
+    private arena;
+    private source;
+    private value_end;
+    constructor(arena: CSSDataArena, source: string);
+    parse_value(start: number, end: number): number[];
+    private is_whitespace_token;
+    private parse_value_node;
+    private create_keyword_node;
+    private create_number_node;
+    private create_dimension_node;
+    private create_string_node;
+    private create_color_node;
+    private create_operator_node;
+    private parse_operator_node;
+    private parse_function_node;
+}

package/dist/walk.d.ts

@@ -0,0 +1,20 @@
+import type { CSSNode } from './css-node';
+type WalkCallback = (node: CSSNode, depth: number) => void;
+/**
+ * Walk the AST in depth-first order, calling the callback for each node
+ * @param node - The root node to start walking from
+ * @param callback - Function to call for each node visited. Receives the node and its depth (0 for root)
+ */
+export declare function walk(node: CSSNode, callback: WalkCallback, depth?: number): void;
+type WalkEnterLeaveCallback = (node: CSSNode) => void;
+interface WalkEnterLeaveOptions {
+    enter?: WalkEnterLeaveCallback;
+    leave?: WalkEnterLeaveCallback;
+}
+/**
+ * Walk the AST in depth-first order, calling enter before visiting children and leave after
+ * @param node - The root node to start walking from
+ * @param options - Object with optional enter and leave callback functions
+ */
+export declare function walk_enter_leave(node: CSSNode, { enter, leave }?: WalkEnterLeaveOptions): void;
+export {};

package/package.json

@@ -0,0 +1,78 @@
+{
+	"name": "@projectwallace/css-parser",
+	"version": "0.1.0",
+	"description": "High-performance CSS lexer and parser, optimized for CSS inspection and analysis",
+	"author": "Bart Veneman <bat@projectwallace.com>",
+	"license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/projectwallace/css-parser.git"
+  },
+  "issues": "https://github.com/projectwallace/css-parser/issues",
+  "homepage": "https://github.com/projectwallace/css-parser",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./tokenizer": {
+			"types": "./dist/tokenize.d.ts",
+			"import": "./dist/tokenize.js"
+		},
+		"./parse": {
+			"types": "./dist/parse.d.ts",
+			"import": "./dist/parse.js"
+		},
+		"./parse-selector": {
+			"types": "./dist/parse-selector.d.ts",
+			"import": "./dist/parse-selector.js"
+		},
+		"./parse-atrule-prelude": {
+			"types": "./dist/parse-atrule-prelude.d.ts",
+			"import": "./dist/parse-atrule-prelude.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"test": "vitest",
+		"test-coverage": "vitest --coverage",
+		"test-build": "npm run build && vitest run --config vitest.config.build.ts",
+		"build": "vite build && tsc --project tsconfig.build.json",
+		"benchmark": "npm run build && node benchmark/index.ts",
+		"benchmark:memory": "npm run build && node --expose-gc benchmark/memory.ts",
+		"lint": "oxlint --config .oxlintrc.json",
+		"lint-package": "publint",
+		"check": "tsc --noEmit",
+		"knip": "knip"
+	},
+	"keywords": [
+		"css",
+		"parser",
+		"lexer",
+		"tokenizer",
+		"ast"
+	],
+	"devDependencies": {
+		"@projectwallace/preset-oxlint": "^0.0.7",
+		"@types/node": "^24.10.1",
+		"@vitest/coverage-v8": "^4.0.8",
+		"bootstrap": "^5.3.8",
+		"css-tree": "^3.1.0",
+		"knip": "^5.69.1",
+		"oxlint": "^1.28.0",
+		"postcss": "^8.5.6",
+		"prettier": "^3.6.2",
+		"publint": "^0.3.15",
+		"tailwindcss": "^2.2.8",
+		"tinybench": "^2.9.0",
+		"typescript": "^5.9.3",
+		"vite": "^7.2.2",
+		"vitest": "^4.0.8"
+	}
+}