@projectwallace/css-parser 0.13.10 → 0.14.0

package/dist/node-types-Dt096ytO.d.ts

@@ -0,0 +1,456 @@
+import { A as PRELUDE_SELECTORLIST, B as TYPE_SELECTOR, C as NESTING_SELECTOR, D as OPERATOR, E as NUMBER, F as SELECTOR_LIST, H as UNIVERSAL_SELECTOR, I as STRING, L as STYLESHEET, M as PSEUDO_ELEMENT_SELECTOR, N as RAW, O as PARENTHESIS, P as SELECTOR, R as STYLE_RULE, S as MEDIA_TYPE, T as NTH_SELECTOR, U as URL, V as UNICODE_RANGE, W as VALUE, _ as ID_SELECTOR, a as CLASS_SELECTOR, b as MEDIA_FEATURE, c as CONTAINER_QUERY, d as DIMENSION, f as FEATURE_RANGE, g as IDENTIFIER, h as HASH, i as BLOCK, j as PSEUDO_CLASS_SELECTOR, k as PRELUDE_OPERATOR, m as FUNCTION, n as AT_RULE, o as COMBINATOR, r as AT_RULE_PRELUDE, s as COMMENT, t as ATTRIBUTE_SELECTOR, u as DECLARATION, v as LANG_SELECTOR, w as NTH_OF_SELECTOR, x as MEDIA_QUERY, y as LAYER_NAME, z as SUPPORTS_QUERY } from "./arena-D6TANE5e.js";
+
+//#region src/css-node.d.ts
+declare const TYPE_NAMES: {
+  readonly 1: "StyleSheet";
+  readonly 2: "Rule";
+  readonly 3: "Atrule";
+  readonly 4: "Declaration";
+  readonly 5: "Selector";
+  readonly 6: "Comment";
+  readonly 7: "Block";
+  readonly 8: "Raw";
+  readonly 10: "Identifier";
+  readonly 11: "Number";
+  readonly 12: "Dimension";
+  readonly 13: "String";
+  readonly 14: "Hash";
+  readonly 15: "Function";
+  readonly 16: "Operator";
+  readonly 17: "Parentheses";
+  readonly 18: "Url";
+  readonly 19: "UnicodeRange";
+  readonly 50: "Value";
+  readonly 20: "SelectorList";
+  readonly 21: "TypeSelector";
+  readonly 22: "ClassSelector";
+  readonly 23: "IdSelector";
+  readonly 24: "AttributeSelector";
+  readonly 25: "PseudoClassSelector";
+  readonly 26: "PseudoElementSelector";
+  readonly 27: "Combinator";
+  readonly 28: "UniversalSelector";
+  readonly 29: "NestingSelector";
+  readonly 30: "Nth";
+  readonly 31: "NthOf";
+  readonly 56: "Lang";
+  readonly 32: "MediaQuery";
+  readonly 33: "Feature";
+  readonly 34: "MediaType";
+  readonly 35: "ContainerQuery";
+  readonly 36: "SupportsQuery";
+  readonly 37: "Layer";
+  readonly 38: "Operator";
+  readonly 39: "MediaFeatureRange";
+  readonly 40: "AtrulePrelude";
+  readonly 41: "PreludeSelectorList";
+};
+type TypeName = (typeof TYPE_NAMES)[keyof typeof TYPE_NAMES] | 'unknown';
+type CSSNodeType = typeof STYLESHEET | typeof STYLE_RULE | typeof AT_RULE | typeof DECLARATION | typeof SELECTOR | typeof COMMENT | typeof BLOCK | typeof RAW | typeof IDENTIFIER | typeof NUMBER | typeof DIMENSION | typeof STRING | typeof HASH | typeof FUNCTION | typeof OPERATOR | typeof PARENTHESIS | typeof URL | typeof UNICODE_RANGE | typeof VALUE | typeof SELECTOR_LIST | typeof TYPE_SELECTOR | typeof CLASS_SELECTOR | typeof ID_SELECTOR | typeof ATTRIBUTE_SELECTOR | typeof PSEUDO_CLASS_SELECTOR | typeof PSEUDO_ELEMENT_SELECTOR | typeof COMBINATOR | typeof UNIVERSAL_SELECTOR | typeof NESTING_SELECTOR | typeof NTH_SELECTOR | typeof NTH_OF_SELECTOR | typeof LANG_SELECTOR | typeof MEDIA_QUERY | typeof MEDIA_FEATURE | typeof MEDIA_TYPE | typeof CONTAINER_QUERY | typeof SUPPORTS_QUERY | typeof LAYER_NAME | typeof PRELUDE_OPERATOR | typeof FEATURE_RANGE | typeof AT_RULE_PRELUDE | typeof PRELUDE_SELECTORLIST;
+interface CloneOptions {
+  /**
+   * Recursively clone all children
+   * @default true
+   */
+  deep?: boolean;
+  /**
+   * Include location information (line, column, start, length)
+   * @default false
+   */
+  locations?: boolean;
+}
+type PlainCSSNode = {
+  type: number;
+  type_name: TypeName;
+  text: string;
+  children?: PlainCSSNode[];
+  child_count?: number;
+  has_children?: boolean;
+  name?: string;
+  property?: string;
+  value?: PlainCSSNode | string | number | null;
+  unit?: string;
+  prelude?: PlainCSSNode | null;
+  is_important?: boolean;
+  is_vendor_prefixed?: boolean;
+  is_browserhack?: boolean;
+  has_error?: boolean;
+  attr_operator?: string | null;
+  attr_flags?: string | null;
+  nth_a?: string | null;
+  nth_b?: string | null;
+  line?: number;
+  column?: number;
+  start?: number;
+  length?: number;
+  end?: number;
+};
+//#endregion
+//#region src/node-types.d.ts
+interface CSSNode {
+  readonly type: CSSNodeType;
+  readonly type_name: TypeName;
+  readonly text: string;
+  readonly has_error: boolean;
+  readonly is_vendor_prefixed: boolean;
+  readonly line: number;
+  readonly column: number;
+  readonly start: number;
+  readonly length: number;
+  readonly end: number;
+  /** Low-level linked-list pointer used by walk()/traverse(). Prefer .children on nodes that have it. */
+  readonly first_child: CSSNode | null;
+  /** Low-level linked-list pointer used by walk()/traverse(). */
+  readonly next_sibling: CSSNode | null;
+  readonly has_next: boolean;
+  clone(options?: CloneOptions): PlainCSSNode;
+}
+/**
+ * Mixin for node types that have child nodes.
+ *
+ * Only a subset of node types expose children — structural and container nodes
+ * like StyleSheet, Block, SelectorList, Value, Function, etc. Leaf nodes
+ * (Identifier, Number, Dimension, …) do not extend WithChildren, reflecting
+ * that they never carry child nodes in a well-formed tree.
+ */
+interface WithChildren {
+  readonly has_children: boolean;
+  readonly child_count: number;
+  readonly children: AnyNode[];
+  [Symbol.iterator](): Iterator<AnyNode>;
+}
+/**
+ * Maps a CssNodeCommon subtype interface to its plain-object equivalent,
+ * as returned by clone().
+ *
+ * The result is always a subtype of PlainCSSNode (the intersection starts
+ * with PlainCSSNode), with two additions:
+ *  - `type` is narrowed to T's specific literal (enables discriminated unions)
+ *  - subtype-specific properties (those not on CssNodeCommon) are added with
+ *    CssNodeCommon references replaced by PlainCSSNode
+ *
+ * Traversal properties (first_child, next_sibling, etc.) are excluded since
+ * they live on CssNodeCommon and are never serialised by clone().
+ *
+ *   const rule = root.first_child as Rule
+ *   rule.clone().prelude   // PlainCSSNode | null  — not PlainCSSNode | undefined
+ *   rule.clone().block     // PlainCSSNode | null
+ */
+type ToPlain<T extends CSSNode> = PlainCSSNode & {
+  type: T['type'];
+} & { [K in Exclude<keyof T, keyof CSSNode | symbol | 'attr_operator' | 'attr_flags' | 'has_children' | 'child_count' | 'children'> as T[K] extends ((...args: any[]) => any) ? never : K]: T[K] extends CSSNode | null | undefined ? PlainCSSNode | Exclude<T[K], CSSNode> : T[K] extends CSSNode[] ? PlainCSSNode[] : T[K] };
+interface StyleSheet extends CSSNode, WithChildren {
+  readonly type: typeof STYLESHEET;
+  clone(options?: CloneOptions): ToPlain<StyleSheet>;
+}
+type Rule = CSSNode & {
+  readonly type: typeof STYLE_RULE;
+  readonly name: string;
+  readonly has_declarations: boolean;
+  clone(options?: CloneOptions): ToPlain<Rule>;
+} & /** SELECTOR_LIST (parse_selectors=true) or RAW (parse_selectors=false) */({
+  readonly has_prelude: true;
+  readonly prelude: SelectorList | Raw;
+} | {
+  readonly has_prelude: false;
+  readonly prelude: null;
+}) & ({
+  readonly has_block: true;
+  readonly block: Block;
+} | {
+  readonly has_block: false;
+  readonly block: null;
+});
+type Atrule = CSSNode & {
+  readonly type: typeof AT_RULE; /** At-rule keyword, e.g. "media", "keyframes" */
+  readonly name: string;
+  readonly has_declarations: boolean;
+  clone(options?: CloneOptions): ToPlain<Atrule>;
+} & /** AT_RULE_PRELUDE (parse_atrule_preludes=true) or RAW (parse_atrule_preludes=false) */({
+  readonly has_prelude: true;
+  readonly prelude: AtrulePrelude | Raw;
+} | {
+  readonly has_prelude: false;
+  readonly prelude: null;
+}) & ({
+  readonly has_block: true;
+  readonly block: Block;
+} | {
+  readonly has_block: false;
+  readonly block: null;
+});
+interface Declaration extends CSSNode {
+  readonly type: typeof DECLARATION;
+  /** Property name, e.g. "color" */
+  readonly property: string;
+  /** VALUE node (parse_values=true), RAW node (parse_values=false), or null */
+  readonly value: Value | Raw | null;
+  readonly is_important: boolean;
+  readonly is_browserhack: boolean;
+  clone(options?: CloneOptions): ToPlain<Declaration>;
+}
+interface Selector extends CSSNode, WithChildren {
+  readonly type: typeof SELECTOR;
+  clone(options?: CloneOptions): ToPlain<Selector>;
+}
+interface SelectorList extends CSSNode, WithChildren {
+  readonly type: typeof SELECTOR_LIST;
+  clone(options?: CloneOptions): ToPlain<SelectorList>;
+}
+interface Block extends CSSNode, WithChildren {
+  readonly type: typeof BLOCK;
+  readonly is_empty: boolean;
+  clone(options?: CloneOptions): ToPlain<Block>;
+}
+interface Comment extends CSSNode {
+  readonly type: typeof COMMENT;
+  clone(options?: CloneOptions): ToPlain<Comment>;
+}
+interface Raw extends CSSNode {
+  readonly type: typeof RAW;
+  clone(options?: CloneOptions): ToPlain<Raw>;
+}
+interface Identifier extends CSSNode {
+  readonly type: typeof IDENTIFIER;
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<Identifier>;
+}
+interface Number extends CSSNode {
+  readonly type: typeof NUMBER;
+  readonly value: number;
+  clone(options?: CloneOptions): ToPlain<Number>;
+}
+interface Dimension extends CSSNode {
+  readonly type: typeof DIMENSION;
+  readonly value: number;
+  /** Unit string, e.g. "px", "%" */
+  readonly unit: string;
+  clone(options?: CloneOptions): ToPlain<Dimension>;
+}
+interface String extends CSSNode {
+  readonly type: typeof STRING;
+  clone(options?: CloneOptions): ToPlain<String>;
+}
+interface Hash extends CSSNode {
+  readonly type: typeof HASH;
+  clone(options?: CloneOptions): ToPlain<Hash>;
+}
+interface Function extends CSSNode, WithChildren {
+  readonly type: typeof FUNCTION;
+  /** Function name, e.g. "rgb", "calc" */
+  readonly name: string;
+  /** Function arguments as raw text, e.g. "255, 0, 0" for rgb(255, 0, 0) */
+  readonly value: string | null;
+  clone(options?: CloneOptions): ToPlain<Function>;
+}
+interface Operator extends CSSNode {
+  readonly type: typeof OPERATOR;
+  /** The operator character(s), e.g. ",", "+", "-" */
+  readonly value: string;
+  clone(options?: CloneOptions): ToPlain<Operator>;
+}
+interface Parenthesis extends CSSNode, WithChildren {
+  readonly type: typeof PARENTHESIS;
+  clone(options?: CloneOptions): ToPlain<Parenthesis>;
+}
+interface Url extends CSSNode {
+  readonly type: typeof URL;
+  /** URL content, e.g. '"image.png"' (with quotes) or 'mycursor.cur' (unquoted) */
+  readonly value: string | null;
+  clone(options?: CloneOptions): ToPlain<Url>;
+}
+interface UnicodeRange extends CSSNode {
+  readonly type: typeof UNICODE_RANGE;
+  clone(options?: CloneOptions): ToPlain<UnicodeRange>;
+}
+interface Value extends CSSNode, WithChildren {
+  readonly type: typeof VALUE;
+  clone(options?: CloneOptions): ToPlain<Value>;
+}
+interface TypeSelector extends CSSNode {
+  readonly type: typeof TYPE_SELECTOR;
+  /** Element type, e.g. "div", "span" */
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<TypeSelector>;
+}
+interface ClassSelector extends CSSNode {
+  readonly type: typeof CLASS_SELECTOR;
+  /** Class name without dot, e.g. "foo" from ".foo" */
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<ClassSelector>;
+}
+interface IdSelector extends CSSNode {
+  readonly type: typeof ID_SELECTOR;
+  /** Id without hash, e.g. "bar" from "#bar" */
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<IdSelector>;
+}
+interface AttributeSelector extends CSSNode {
+  readonly type: typeof ATTRIBUTE_SELECTOR;
+  /** Attribute name, e.g. "href" from "[href]" */
+  readonly name: string;
+  /** Operator string, e.g. "=", "~=", "|="; null if no operator ([attr] form) */
+  readonly attr_operator: string | null;
+  /** Flag character, e.g. "i", "s"; null if no flag */
+  readonly attr_flags: string | null;
+  clone(options?: CloneOptions): ToPlain<AttributeSelector>;
+}
+interface PseudoClassSelector extends CSSNode, WithChildren {
+  readonly type: typeof PSEUDO_CLASS_SELECTOR;
+  /** Pseudo-class name without colon, e.g. "hover" */
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<PseudoClassSelector>;
+}
+interface PseudoElementSelector extends CSSNode, WithChildren {
+  readonly type: typeof PSEUDO_ELEMENT_SELECTOR;
+  /** Pseudo-element name without colons, e.g. "before" */
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<PseudoElementSelector>;
+}
+interface Combinator extends CSSNode {
+  readonly type: typeof COMBINATOR;
+  /** Combinator character(s), e.g. " ", ">", "~", "+", "||", "/deep/" */
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<Combinator>;
+}
+interface UniversalSelector extends CSSNode {
+  readonly type: typeof UNIVERSAL_SELECTOR;
+  /** Namespace qualifier (e.g. 'ns' in 'ns|*'), undefined if no namespace */
+  readonly name: string | undefined;
+  clone(options?: CloneOptions): ToPlain<UniversalSelector>;
+}
+interface NestingSelector extends CSSNode {
+  readonly type: typeof NESTING_SELECTOR;
+  clone(options?: CloneOptions): ToPlain<NestingSelector>;
+}
+interface NthSelector extends CSSNode {
+  readonly type: typeof NTH_SELECTOR;
+  readonly nth_a: string | undefined;
+  readonly nth_b: string | undefined;
+  clone(options?: CloneOptions): ToPlain<NthSelector>;
+}
+interface NthOfSelector extends CSSNode {
+  readonly type: typeof NTH_OF_SELECTOR;
+  /** The An+B formula node */
+  readonly nth: NthSelector | null;
+  /** The selector list from :nth-child(An+B of <selector>) */
+  readonly selector: SelectorList | null;
+  clone(options?: CloneOptions): ToPlain<NthOfSelector>;
+}
+interface LangSelector extends CSSNode {
+  readonly type: typeof LANG_SELECTOR;
+  clone(options?: CloneOptions): ToPlain<LangSelector>;
+}
+interface AtrulePrelude extends CSSNode, WithChildren {
+  readonly type: typeof AT_RULE_PRELUDE;
+  clone(options?: CloneOptions): ToPlain<AtrulePrelude>;
+}
+interface MediaQuery extends CSSNode, WithChildren {
+  readonly type: typeof MEDIA_QUERY;
+  clone(options?: CloneOptions): ToPlain<MediaQuery>;
+}
+interface MediaFeature extends CSSNode, WithChildren {
+  readonly type: typeof MEDIA_FEATURE;
+  /** Feature name, e.g. "min-width" */
+  readonly property: string;
+  clone(options?: CloneOptions): ToPlain<MediaFeature>;
+}
+interface MediaType extends CSSNode {
+  readonly type: typeof MEDIA_TYPE;
+  /** Media type text, e.g. "screen", "print" */
+  readonly value: string;
+  clone(options?: CloneOptions): ToPlain<MediaType>;
+}
+interface ContainerQuery extends CSSNode, WithChildren {
+  readonly type: typeof CONTAINER_QUERY;
+  clone(options?: CloneOptions): ToPlain<ContainerQuery>;
+}
+interface SupportsQuery extends CSSNode {
+  readonly type: typeof SUPPORTS_QUERY;
+  /** The supports condition text, e.g. "display: flex" from "supports(display: flex)" */
+  readonly value: string;
+  clone(options?: CloneOptions): ToPlain<SupportsQuery>;
+}
+interface LayerName extends CSSNode {
+  readonly type: typeof LAYER_NAME;
+  readonly name: string;
+  /** Alias for name — the layer name string, e.g. "base" from "layer(base)" */
+  readonly value: string;
+  clone(options?: CloneOptions): ToPlain<LayerName>;
+}
+/**
+ * A parenthesised selector argument in an at-rule prelude.
+ *
+ * This node type exists because at-rule preludes that contain selectors (like
+ * @scope) cannot reuse SELECTOR_LIST: that type already appears inside the
+ * rule's block, and mixing the two would make traversal ambiguous. A distinct
+ * type lets walkers and tooling distinguish "this is a selector used as a
+ * scoping argument" from "this is a selector that matches elements".
+ *
+ * Currently produced only by @scope:
+ *   @scope (.parent) to (.child) { }
+ *          ^^^^^^^^^    ^^^^^^^^  — each parenthesised group is a PRELUDE_SELECTORLIST
+ *
+ * `value` is the raw selector text inside the parentheses, trimmed of
+ * whitespace: ".parent" from "(.parent)".
+ */
+interface PreludeSelectorList extends CSSNode {
+  readonly type: typeof PRELUDE_SELECTORLIST;
+  readonly value: string;
+  clone(options?: CloneOptions): ToPlain<PreludeSelectorList>;
+}
+interface PreludeOperator extends CSSNode {
+  readonly type: typeof PRELUDE_OPERATOR;
+  clone(options?: CloneOptions): ToPlain<PreludeOperator>;
+}
+interface FeatureRange extends CSSNode, WithChildren {
+  readonly type: typeof FEATURE_RANGE;
+  /** The feature name in a range comparison, e.g. "width" from "(width >= 400px)" */
+  readonly name: string;
+  clone(options?: CloneOptions): ToPlain<FeatureRange>;
+}
+type AnyNode = StyleSheet | Rule | Atrule | Declaration | Selector | SelectorList | Block | Comment | Raw | Identifier | Number | Dimension | String | Hash | Function | Operator | Parenthesis | Url | UnicodeRange | Value | TypeSelector | ClassSelector | IdSelector | AttributeSelector | PseudoClassSelector | PseudoElementSelector | Combinator | UniversalSelector | NestingSelector | NthSelector | NthOfSelector | LangSelector | AtrulePrelude | MediaQuery | MediaFeature | MediaType | ContainerQuery | SupportsQuery | LayerName | PreludeOperator | FeatureRange | PreludeSelectorList;
+declare function is_stylesheet(node: CSSNode): node is StyleSheet;
+declare function is_rule(node: CSSNode): node is Rule;
+declare function is_atrule(node: CSSNode): node is Atrule;
+declare function is_declaration(node: CSSNode): node is Declaration;
+declare function is_selector(node: CSSNode): node is Selector;
+declare function is_selector_list(node: CSSNode): node is SelectorList;
+declare function is_block(node: CSSNode): node is Block;
+declare function is_comment(node: CSSNode): node is Comment;
+declare function is_raw(node: CSSNode): node is Raw;
+declare function is_identifier(node: CSSNode): node is Identifier;
+declare function is_number(node: CSSNode): node is Number;
+declare function is_dimension(node: CSSNode): node is Dimension;
+declare function is_string(node: CSSNode): node is String;
+declare function is_hash(node: CSSNode): node is Hash;
+declare function is_function(node: CSSNode): node is Function;
+declare function is_operator(node: CSSNode): node is Operator;
+declare function is_parenthesis(node: CSSNode): node is Parenthesis;
+declare function is_url(node: CSSNode): node is Url;
+declare function is_unicode_range(node: CSSNode): node is UnicodeRange;
+declare function is_value(node: CSSNode): node is Value;
+declare function is_type_selector(node: CSSNode): node is TypeSelector;
+declare function is_class_selector(node: CSSNode): node is ClassSelector;
+declare function is_id_selector(node: CSSNode): node is IdSelector;
+declare function is_attribute_selector(node: CSSNode): node is AttributeSelector;
+declare function is_pseudo_class_selector(node: CSSNode): node is PseudoClassSelector;
+declare function is_pseudo_element_selector(node: CSSNode): node is PseudoElementSelector;
+declare function is_combinator(node: CSSNode): node is Combinator;
+declare function is_universal_selector(node: CSSNode): node is UniversalSelector;
+declare function is_nesting_selector(node: CSSNode): node is NestingSelector;
+declare function is_nth_selector(node: CSSNode): node is NthSelector;
+declare function is_nth_of_selector(node: CSSNode): node is NthOfSelector;
+declare function is_lang_selector(node: CSSNode): node is LangSelector;
+declare function is_atrule_prelude(node: CSSNode): node is AtrulePrelude;
+declare function is_media_query(node: CSSNode): node is MediaQuery;
+declare function is_media_feature(node: CSSNode): node is MediaFeature;
+declare function is_media_type(node: CSSNode): node is MediaType;
+declare function is_container_query(node: CSSNode): node is ContainerQuery;
+declare function is_supports_query(node: CSSNode): node is SupportsQuery;
+declare function is_layer_name(node: CSSNode): node is LayerName;
+declare function is_prelude_operator(node: CSSNode): node is PreludeOperator;
+declare function is_feature_range(node: CSSNode): node is FeatureRange;
+declare function is_prelude_selectorlist(node: CSSNode): node is PreludeSelectorList;
+//#endregion
+export { is_comment as $, PreludeSelectorList as A, is_type_selector as At, ToPlain as B, NestingSelector as C, is_raw as Ct, Operator as D, is_string as Dt, Number as E, is_selector_list as Et, Selector as F, CloneOptions as Ft, Value as G, UnicodeRange as H, SelectorList as I, TYPE_NAMES as It, is_atrule_prelude as J, WithChildren as K, String as L, PseudoElementSelector as M, is_universal_selector as Mt, Raw as N, is_url as Nt, Parenthesis as O, is_stylesheet as Ot, Rule as P, is_value as Pt, is_combinator as Q, StyleSheet as R, MediaType as S, is_pseudo_element_selector as St, NthSelector as T, is_selector as Tt, UniversalSelector as U, TypeSelector as V, Url as W, is_block as X, is_attribute_selector as Y, is_class_selector as Z, Identifier as _, is_operator as _t, Block as a, is_hash as at, MediaFeature as b, is_prelude_selectorlist as bt, Combinator as c, is_lang_selector as ct, Declaration as d, is_media_query as dt, is_container_query as et, Dimension as f, is_media_type as ft, IdSelector as g, is_number as gt, Hash as h, is_nth_selector as ht, AttributeSelector as i, is_function as it, PseudoClassSelector as j, is_unicode_range as jt, PreludeOperator as k, is_supports_query as kt, Comment as l, is_layer_name as lt, Function as m, is_nth_of_selector as mt, Atrule as n, is_dimension as nt, CSSNode as o, is_id_selector as ot, FeatureRange as p, is_nesting_selector as pt, is_atrule as q, AtrulePrelude as r, is_feature_range as rt, ClassSelector as s, is_identifier as st, AnyNode as t, is_declaration as tt, ContainerQuery as u, is_media_feature as ut, LangSelector as v, is_parenthesis as vt, NthOfSelector as w, is_rule as wt, MediaQuery as x, is_pseudo_class_selector as xt, LayerName as y, is_prelude_operator as yt, SupportsQuery as z };

package/dist/parse-anplusb.d.ts

@@ -1,5 +1,5 @@
-import { y as CSSDataArena } from "./arena-BtlVZlkG.js";
-import { r as CSSNode } from "./css-node-B9tSb6YD.js";
+import { l as CSSDataArena } from "./arena-D6TANE5e.js";
+import { T as NthSelector } from "./node-types-Dt096ytO.js";
 
 //#region src/parse-anplusb.d.ts
 /** @internal */
@@ -22,6 +22,6 @@ declare class ANplusBParser {
   private skip_whitespace;
   private create_anplusb_node;
 }
-declare function parse_anplusb(expr: string): CSSNode | null;
+declare function parse_anplusb(expr: string): NthSelector | null;
 //#endregion
 export { ANplusBParser, parse_anplusb };

package/dist/parse-anplusb.js

@@ -1,7 +1,7 @@
 import { t as Lexer } from "./tokenize-BSycRGm0.js";
-import { y as CSSDataArena } from "./arena-CDAx4eAB.js";
+import { l as CSSDataArena } from "./arena-CveFYH2l.js";
 import { o as str_equals, s as str_index_of } from "./parse-dimension-CCn_XRDe.js";
-import { r as CSSNode } from "./css-node-CZf-PvCf.js";
+import { t as CSSNode } from "./css-node-CbNQbD4P.js";
 //#region src/parse-anplusb.ts
 /** @internal */
 var ANplusBParser = class {

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

@@ -1,5 +1,5 @@
-import { y as CSSDataArena } from "./arena-BtlVZlkG.js";
-import { r as CSSNode } from "./css-node-B9tSb6YD.js";
+import { l as CSSDataArena } from "./arena-D6TANE5e.js";
+import { t as AnyNode } from "./node-types-Dt096ytO.js";
 
 //#region src/parse-atrule-prelude.d.ts
 /** @internal */
@@ -42,6 +42,6 @@ declare class AtRulePreludeParser {
  * @param prelude - The at-rule prelude to parse (e.g., "(min-width: 768px)", "utilities")
  * @returns An array of CSSNode objects representing the parsed prelude
  */
-declare function parse_atrule_prelude(at_rule_name: string, prelude: string): CSSNode[];
+declare function parse_atrule_prelude(at_rule_name: string, prelude: string): AnyNode[];
 //#endregion
 export { AtRulePreludeParser, parse_atrule_prelude };

package/dist/parse-atrule-prelude.js

@@ -1,7 +1,7 @@
 import { t as Lexer } from "./tokenize-BSycRGm0.js";
-import { y as CSSDataArena } from "./arena-CDAx4eAB.js";
+import { l as CSSDataArena } from "./arena-CveFYH2l.js";
 import { a as is_whitespace, l as strip_vendor_prefix, o as str_equals } from "./parse-dimension-CCn_XRDe.js";
-import { r as CSSNode } from "./css-node-CZf-PvCf.js";
+import { t as CSSNode } from "./css-node-CbNQbD4P.js";
 import { i as trim_boundaries, n as skip_whitespace_and_comments_forward } from "./parse-utils-BxrmqJxI.js";
 //#region src/parse-atrule-prelude.ts
 /** @internal */
@@ -259,8 +259,8 @@ var AtRulePreludeParser = class {
 			let token_type = this.lexer.token_type;
 			if (token_type === 1) {
 				let layer = this.create_node(37, this.lexer.token_start, this.lexer.token_end);
-				this.arena.set_value_start_delta(layer, 0);
-				this.arena.set_value_length(layer, this.lexer.token_end - this.lexer.token_start);
+				this.arena.set_content_start_delta(layer, 0);
+				this.arena.set_content_length(layer, this.lexer.token_end - this.lexer.token_start);
 				nodes.push(layer);
 			} else if (token_type === 18) continue;
 			else if (token_type === 13) continue;
@@ -361,8 +361,6 @@ var AtRulePreludeParser = class {
 					if (trimmed) {
 						this.arena.set_content_start_delta(layer_node, trimmed[0] - layer_start);
 						this.arena.set_content_length(layer_node, trimmed[1] - trimmed[0]);
-						this.arena.set_value_start_delta(layer_node, trimmed[0] - layer_start);
-						this.arena.set_value_length(layer_node, trimmed[1] - trimmed[0]);
 					}
 				}
 				return layer_node;

package/dist/parse-declaration.d.ts

@@ -1,6 +1,6 @@
-import { y as CSSDataArena } from "./arena-BtlVZlkG.js";
+import { l as CSSDataArena } from "./arena-D6TANE5e.js";
 import { n as Lexer } from "./tokenize-CyiJelQC.js";
-import { r as CSSNode } from "./css-node-B9tSb6YD.js";
+import { d as Declaration } from "./node-types-Dt096ytO.js";
 
 //#region src/parse-declaration.d.ts
 /** @internal */
@@ -17,6 +17,6 @@ declare class DeclarationParser {
  * @param source - The CSS declaration to parse (e.g., "color: red", "margin: 10px !important")
  * @returns The DECLARATION CSSNode
  */
-declare function parse_declaration(source: string): CSSNode;
+declare function parse_declaration(source: string): Declaration;
 //#endregion
 export { DeclarationParser, parse_declaration };

package/dist/parse-declaration.js

@@ -1,7 +1,7 @@
 import { t as Lexer } from "./tokenize-BSycRGm0.js";
-import { y as CSSDataArena } from "./arena-CDAx4eAB.js";
+import { l as CSSDataArena } from "./arena-CveFYH2l.js";
 import { i as is_vendor_prefixed } from "./parse-dimension-CCn_XRDe.js";
-import { r as CSSNode } from "./css-node-CZf-PvCf.js";
+import { t as CSSNode } from "./css-node-CbNQbD4P.js";
 import { i as trim_boundaries } from "./parse-utils-BxrmqJxI.js";
 import { ValueParser } from "./parse-value.js";
 //#region src/parse-declaration.ts

package/dist/parse-selector.d.ts

@@ -1,5 +1,5 @@
-import { y as CSSDataArena } from "./arena-BtlVZlkG.js";
-import { r as CSSNode } from "./css-node-B9tSb6YD.js";
+import { l as CSSDataArena } from "./arena-D6TANE5e.js";
+import { I as SelectorList } from "./node-types-Dt096ytO.js";
 
 //#region src/parse-selector.d.ts
 /** @internal */
@@ -38,6 +38,6 @@ declare class SelectorParser {
  * @param source - The CSS selector to parse (e.g., "div.class > p#id")
  * @returns The root CSSNode of the selector AST
  */
-declare function parse_selector(source: string): CSSNode;
+declare function parse_selector(source: string): SelectorList;
 //#endregion
 export { SelectorParser, parse_selector };

package/dist/parse-selector.js

@@ -1,7 +1,7 @@
 import { t as Lexer } from "./tokenize-BSycRGm0.js";
-import { y as CSSDataArena } from "./arena-CDAx4eAB.js";
+import { l as CSSDataArena } from "./arena-CveFYH2l.js";
 import { a as is_whitespace, n as is_combinator, o as str_equals } from "./parse-dimension-CCn_XRDe.js";
-import { r as CSSNode } from "./css-node-CZf-PvCf.js";
+import { t as CSSNode } from "./css-node-CbNQbD4P.js";
 import { n as skip_whitespace_and_comments_forward, r as skip_whitespace_forward, t as skip_whitespace_and_comments_backward } from "./parse-utils-BxrmqJxI.js";
 import { ANplusBParser } from "./parse-anplusb.js";
 //#region src/parse-selector.ts
@@ -260,41 +260,18 @@ var SelectorParser = class {
 			this.arena.set_content_length(node, name_end - name_start);
 		}
 		let pos = skip_whitespace_and_comments_forward(this.source, name_end, end);
-		if (pos >= end) {
-			this.arena.set_attr_operator(node, 0);
-			this.arena.set_attr_flags(node, 0);
-			return;
-		}
+		if (pos >= end) return;
 		let ch1 = this.source.charCodeAt(pos);
 		let ch2 = pos + 1 < end ? this.source.charCodeAt(pos + 1) : 0;
-		if (ch1 === 61) {
-			operator_end = pos + 1;
-			this.arena.set_attr_operator(node, 1);
-		} else if (ch1 === 126 && ch2 === 61) {
-			operator_end = pos + 2;
-			this.arena.set_attr_operator(node, 2);
-		} else if (ch1 === 124 && ch2 === 61) {
-			operator_end = pos + 2;
-			this.arena.set_attr_operator(node, 3);
-		} else if (ch1 === 94 && ch2 === 61) {
-			operator_end = pos + 2;
-			this.arena.set_attr_operator(node, 4);
-		} else if (ch1 === 36 && ch2 === 61) {
-			operator_end = pos + 2;
-			this.arena.set_attr_operator(node, 5);
-		} else if (ch1 === 42 && ch2 === 61) {
-			operator_end = pos + 2;
-			this.arena.set_attr_operator(node, 6);
-		} else {
-			this.arena.set_attr_operator(node, 0);
-			this.arena.set_attr_flags(node, 0);
-			return;
-		}
+		if (ch1 === 61) operator_end = pos + 1;
+		else if (ch1 === 126 && ch2 === 61) operator_end = pos + 2;
+		else if (ch1 === 124 && ch2 === 61) operator_end = pos + 2;
+		else if (ch1 === 94 && ch2 === 61) operator_end = pos + 2;
+		else if (ch1 === 36 && ch2 === 61) operator_end = pos + 2;
+		else if (ch1 === 42 && ch2 === 61) operator_end = pos + 2;
+		else return;
 		pos = skip_whitespace_and_comments_forward(this.source, operator_end, end);
-		if (pos >= end) {
-			this.arena.set_attr_flags(node, 0);
-			return;
-		}
+		if (pos >= end) return;
 		value_start = pos;
 		let ch = this.source.charCodeAt(pos);
 		if (ch === 39 || ch === 34) {
@@ -322,13 +299,6 @@ var SelectorParser = class {
 			this.arena.set_value_start_delta(node, value_start - this.arena.get_start_offset(node));
 			this.arena.set_value_length(node, value_end - value_start);
 		}
-		pos = skip_whitespace_and_comments_forward(this.source, value_end, end);
-		if (pos < end) {
-			let flag_ch = this.source.charCodeAt(pos);
-			if (flag_ch === 105 || flag_ch === 73) this.arena.set_attr_flags(node, 1);
-			else if (flag_ch === 115 || flag_ch === 83) this.arena.set_attr_flags(node, 2);
-			else this.arena.set_attr_flags(node, 0);
-		} else this.arena.set_attr_flags(node, 0);
 	}
 	parse_pseudo(start) {
 		const saved = this.lexer.save_position();

package/dist/parse-value.d.ts

@@ -1,5 +1,5 @@
-import { y as CSSDataArena } from "./arena-BtlVZlkG.js";
-import { r as CSSNode } from "./css-node-B9tSb6YD.js";
+import { l as CSSDataArena } from "./arena-D6TANE5e.js";
+import { G as Value } from "./node-types-Dt096ytO.js";
 
 //#region src/parse-value.d.ts
 /** @internal */
@@ -24,6 +24,6 @@ declare class ValueParser {
  * @param value_string - The CSS value to parse (e.g., "1px solid red")
  * @returns A CSSNode VALUE wrapper containing the parsed value tokens as children
  */
-declare function parse_value(value_string: string): CSSNode;
+declare function parse_value(value_string: string): Value;
 //#endregion
 export { ValueParser, parse_value };