@projectwallace/css-parser 0.16.2 → 0.18.0

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

@@ -0,0 +1,395 @@
+import { A as PRELUDE_SELECTORLIST, B as SUPPORTS_QUERY, C as NESTING_SELECTOR, D as OPERATOR, E as NUMBER, F as SELECTOR_LIST, G as VALUE, H as UNICODE_RANGE, 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 UNIVERSAL_SELECTOR, V as TYPE_SELECTOR, W as URL, _ 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_DECLARATION } from "./arena-Bx5vp6Sl.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 57: 'SupportsDeclaration';
+  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 | typeof SUPPORTS_DECLARATION;
+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
+type 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;
+  readonly first_child: CSSNode | null;
+  clone(options?: CloneOptions): PlainCSSNode;
+} & ({
+  readonly has_next: false;
+  readonly next_sibling: null;
+} | {
+  readonly has_next: true;
+  readonly next_sibling: CSSNode;
+});
+/**
+ * A boolean discriminant paired with the value it gates, e.g. `has_prelude` /
+ * `prelude`: `T` when the flag is true, `null` when it's false.
+ */
+type Toggle<HasKey extends string, ValueKey extends string, T> = ({ readonly [K in HasKey]: true; } & { readonly [K in ValueKey]: T; }) | ({ readonly [K in HasKey]: false; } & { readonly [K in ValueKey]: null; });
+/** Adds a `clone()` whose return type is `ToPlain<T>` for this exact T. */
+type WithClone<T extends CSSNode> = T & {
+  clone(options?: CloneOptions): ToPlain<T>;
+};
+/** A node with no children: CSSNode + a literal type tag + any extra fields. */
+type Leaf<Type extends CSSNodeType, Name extends TypeName, Extra = {}> = WithClone<CSSNode & Extra & {
+  readonly type: Type;
+  readonly type_name: Name;
+}>;
+/** Mixin for container node types (StyleSheet, Block, SelectorList, …). Leaf nodes never carry children, so they skip this. */
+interface WithChildren<T = AnyNode> {
+  readonly has_children: boolean;
+  readonly child_count: number;
+  readonly children: T[];
+  readonly first_child: T;
+  [Symbol.iterator](): Iterator<T>;
+}
+/**
+ * Maps a CssNodeCommon subtype to its clone() equivalent: `type` narrowed to
+ * T's literal, subtype-specific fields with CssNodeCommon refs replaced by
+ * PlainCSSNode, and traversal props (first_child, next_sibling, …) dropped
+ * since clone() never serialises them.
+ */
+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]; };
+type StyleSheet = WithClone<CSSNode & WithChildren & {
+  readonly type: typeof STYLESHEET;
+  readonly type_name: 'StyleSheet';
+}>;
+type Rule = WithClone<CSSNode &
+/** SELECTOR_LIST (parse_selectors=true) or RAW (parse_selectors=false) */
+Toggle<'has_prelude', 'prelude', SelectorList | Raw> & Toggle<'has_block', 'block', Block> & {
+  readonly type: typeof STYLE_RULE;
+  readonly type_name: 'Rule';
+  readonly has_declarations: boolean;
+}>;
+type Atrule = WithClone<CSSNode &
+/** AT_RULE_PRELUDE (parse_atrule_preludes=true) or RAW (parse_atrule_preludes=false) */
+Toggle<'has_prelude', 'prelude', AtrulePrelude | Raw> & Toggle<'has_block', 'block', Block> & {
+  readonly type: typeof AT_RULE;
+  readonly type_name: 'Atrule';
+  /** At-rule keyword, e.g. "media", "keyframes" */
+  readonly name: string;
+  readonly has_declarations: boolean;
+}>;
+type Declaration = Leaf<typeof DECLARATION, '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;
+}>;
+type SelectorNode = TypeSelector | IdSelector | ClassSelector | NthSelector | NthOfSelector | LangSelector | NestingSelector | AttributeSelector | UniversalSelector | PseudoClassSelector | PseudoElementSelector;
+type Selector = WithClone<CSSNode & WithChildren<SelectorNode> & {
+  readonly type: typeof SELECTOR;
+  readonly type_name: 'Selector';
+}>;
+type SelectorList = WithClone<CSSNode & WithChildren<Selector> & {
+  readonly type: typeof SELECTOR_LIST;
+  readonly type_name: 'SelectorList';
+}>;
+/**
+ * A direct child of a Block: `Raw | Declaration | Atrule | Rule` with
+ * `next_sibling` narrowed to the same union instead of generic `CSSNode`.
+ * Safe since none of the four use WithChildren, avoiding TS2589.
+ */
+type BlockChild = (Raw | Declaration | Atrule | Rule) & Toggle<'has_next', 'next_sibling', Raw | Declaration | Atrule | Rule>;
+type Block = WithClone<CSSNode & WithChildren<Raw | Declaration | Atrule | Rule> & {
+  readonly type: typeof BLOCK;
+  readonly type_name: 'Block';
+  readonly is_empty: boolean;
+  /** Block children with next_sibling narrowed to the Block child union. */
+  readonly first_child: BlockChild;
+  readonly children: BlockChild[];
+  [Symbol.iterator](): Iterator<BlockChild>;
+}>;
+type Comment = Leaf<typeof COMMENT, 'Comment'>;
+type Raw = Leaf<typeof RAW, 'Raw'>;
+type ValueLike = Function | Identifier | Operator | Parenthesis | Url | UnicodeRange | String | Hash | Dimension | Number;
+type Identifier = Leaf<typeof IDENTIFIER, 'Identifier', {
+  readonly name: string;
+}>;
+type Number = Leaf<typeof NUMBER, 'Number', {
+  readonly value: number;
+}>;
+type Dimension = Leaf<typeof DIMENSION, 'Dimension', {
+  readonly value: number;
+  /** Unit string, e.g. "px", "%" */
+  readonly unit: string;
+}>;
+type String = Leaf<typeof STRING, 'String'>;
+type Hash = Leaf<typeof HASH, 'Hash'>;
+type Function = WithClone<CSSNode & WithChildren<ValueLike> & {
+  readonly type: typeof FUNCTION;
+  readonly type_name: '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;
+}>;
+type Operator = Leaf<typeof OPERATOR, 'Operator', {
+  /** The operator character(s), e.g. ",", "+", "-" */
+  readonly value: string;
+}>;
+type Parenthesis = WithClone<CSSNode & WithChildren & {
+  readonly type: typeof PARENTHESIS;
+  readonly type_name: 'Parentheses';
+}>;
+type Url = Leaf<typeof URL, 'Url', {
+  /** URL content, e.g. '"image.png"' (with quotes) or 'mycursor.cur' (unquoted) */
+  readonly value: string | null;
+}>;
+type UnicodeRange = Leaf<typeof UNICODE_RANGE, 'UnicodeRange'>;
+type Value = WithClone<CSSNode & WithChildren<ValueLike> & {
+  readonly type: typeof VALUE;
+  readonly type_name: 'Value';
+}>;
+type TypeSelector = Leaf<typeof TYPE_SELECTOR, 'TypeSelector', {
+  /** Local element name, e.g. "div" in both "div" and "ns|div" */
+  readonly name: string;
+  /** Namespace prefix: null if no qualifier, '' for |div, 'ns' for ns|div, '*' for *|div */
+  readonly namespace: string | null;
+}>;
+type ClassSelector = Leaf<typeof CLASS_SELECTOR, 'ClassSelector', {
+  /** Class name without dot, e.g. "foo" from ".foo" */
+  readonly name: string;
+}>;
+type IdSelector = Leaf<typeof ID_SELECTOR, 'IdSelector', {
+  /** Id without hash, e.g. "bar" from "#bar" */
+  readonly name: string;
+}>;
+type AttributeSelector = Leaf<typeof ATTRIBUTE_SELECTOR, 'AttributeSelector', {
+  /** 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;
+  /** Attribute value, e.g. "external" from [rel="external"] */
+  readonly value: string | null;
+}>;
+type PseudoClassSelector = WithClone<CSSNode & WithChildren<Selector | NthOfSelector> & {
+  readonly type: typeof PSEUDO_CLASS_SELECTOR;
+  readonly type_name: 'PseudoClassSelector';
+  /** Pseudo-class name without colon, e.g. "hover" */
+  readonly name: string;
+}>;
+type PseudoElementSelector = WithClone<CSSNode & WithChildren<SelectorList> & {
+  readonly type: typeof PSEUDO_ELEMENT_SELECTOR;
+  readonly type_name: 'PseudoElementSelector';
+  /** Pseudo-element name without colons, e.g. "before" */
+  readonly name: string;
+}>;
+type Combinator = Leaf<typeof COMBINATOR, 'Combinator', {
+  /** Combinator character(s), e.g. " ", ">", "~", "+", "||", "/deep/" */
+  readonly name: string;
+}>;
+type UniversalSelector = Leaf<typeof UNIVERSAL_SELECTOR, 'UniversalSelector', {
+  /** Always null — universal selector has no element name */
+  readonly name: null;
+  /** Namespace prefix: null if no qualifier, '' for |*, 'ns' for ns|*, '*' for *|* */
+  readonly namespace: string | null;
+}>;
+type NestingSelector = Leaf<typeof NESTING_SELECTOR, 'NestingSelector'>;
+type NthSelector = Leaf<typeof NTH_SELECTOR, 'Nth', {
+  /** The `An` part of the An+B formula, including keywords `odd`/`even`. Null when only a B value is present (e.g. `:nth-child(3)`). */
+  readonly nth_a: string | null;
+  /** The `+B` part of the An+B formula. Null when only an A value is present (e.g. `:nth-child(2n)` or `:nth-child(odd)`). */
+  readonly nth_b: string | null;
+}>;
+type NthOfSelector = Leaf<typeof NTH_OF_SELECTOR, 'NthOf', {
+  /** The An+B formula node */
+  readonly nth: NthSelector | null;
+  /** The selector list from :nth-child(An+B of <selector>) */
+  readonly selector: SelectorList | null;
+}>;
+type LangSelector = Leaf<typeof LANG_SELECTOR, 'Lang', {
+  /** `"nl"`, `en-US` */
+  readonly name: string | null;
+}>;
+type AtrulePrelude = WithClone<CSSNode & WithChildren<Raw | MediaQuery | MediaType | ContainerQuery | SupportsQuery | LayerName | PreludeOperator | PreludeSelectorList | Parenthesis | Url> & {
+  readonly type: typeof AT_RULE_PRELUDE;
+  readonly type_name: 'AtrulePrelude';
+}>;
+type MediaQuery = WithClone<CSSNode & WithChildren<MediaFeature | PreludeOperator | MediaType | FeatureRange> & {
+  readonly type: typeof MEDIA_QUERY;
+  readonly type_name: 'MediaQuery';
+}>;
+type MediaFeature = Leaf<typeof MEDIA_FEATURE, 'Feature', {
+  /** Feature name, e.g. "min-width" */
+  readonly property: string;
+  /** Feature value node, or null for boolean features like (hover) */
+  readonly value: CSSNode | null;
+}>;
+type MediaType = Leaf<typeof MEDIA_TYPE, 'MediaType', {
+  /** Media type text, e.g. "screen", "print" */
+  readonly value: string;
+}>;
+type ContainerQuery = WithClone<CSSNode & WithChildren<Identifier | MediaFeature | Function> & {
+  readonly type: typeof CONTAINER_QUERY;
+  readonly type_name: 'ContainerQuery';
+}>;
+type SupportsQuery = WithClone<CSSNode & WithChildren<SupportsDeclaration> & {
+  readonly type: typeof SUPPORTS_QUERY;
+  readonly type_name: 'SupportsQuery';
+  /** The supports condition text, e.g. "display: flex" from "supports(display: flex)" */
+  readonly value: string;
+}>;
+type SupportsDeclaration = WithClone<CSSNode & WithChildren<Declaration> & {
+  readonly type: typeof SUPPORTS_DECLARATION;
+  readonly type_name: 'SupportsDeclaration';
+}>;
+type LayerName = Leaf<typeof LAYER_NAME, 'Layer', {
+  readonly name: string;
+  /** Alias for name — the layer name string, e.g. "base" from "layer(base)" */
+  readonly value: string;
+}>;
+/**
+ * A parenthesised selector argument in an at-rule prelude, e.g. `(.parent)`
+ * in `@scope (.parent) to (.child)`. Distinct from SELECTOR_LIST, which
+ * already means "matches elements", so tooling can tell scoping arguments
+ * apart from real selectors. `value` is the trimmed text inside the parens.
+ */
+type PreludeSelectorList = Leaf<typeof PRELUDE_SELECTORLIST, 'PreludeSelectorList', {
+  readonly value: string;
+}>;
+type PreludeOperator = Leaf<typeof PRELUDE_OPERATOR, 'Operator'>;
+type FeatureRange = WithClone<CSSNode & WithChildren<Dimension | Operator> & {
+  readonly type: typeof FEATURE_RANGE;
+  readonly type_name: 'MediaFeatureRange';
+  /** The feature name in a range comparison, e.g. "width" from "(width >= 400px)" */
+  readonly name: string;
+}>;
+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 | SupportsDeclaration | 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_supports_declaration(node: CSSNode): node is SupportsDeclaration;
+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_class_selector as $, PreludeSelectorList as A, is_stylesheet as At, SupportsDeclaration as B, TYPE_NAMES as Bt, NestingSelector as C, is_pseudo_class_selector as Ct, Operator as D, is_selector as Dt, Number as E, is_rule as Et, Selector as F, is_universal_selector as Ft, UniversalSelector as G, ToPlain as H, SelectorList as I, is_url as It, WithChildren as J, Url as K, SelectorNode as L, is_value as Lt, PseudoElementSelector as M, is_supports_query as Mt, Raw as N, is_type_selector as Nt, Parenthesis as O, is_selector_list as Ot, Rule as P, is_unicode_range as Pt, is_block as Q, String as R, CloneOptions as Rt, MediaType as S, is_prelude_selectorlist as St, NthSelector as T, is_raw as Tt, TypeSelector as U, SupportsQuery as V, UnicodeRange as W, is_atrule_prelude as X, is_atrule as Y, is_attribute_selector as Z, Identifier as _, is_nth_selector as _t, Block as a, is_feature_range as at, MediaFeature as b, is_parenthesis as bt, Combinator as c, is_id_selector as ct, Declaration as d, is_layer_name as dt, is_combinator as et, Dimension as f, is_media_feature as ft, IdSelector as g, is_nth_of_selector as gt, Hash as h, is_nesting_selector as ht, AttributeSelector as i, is_dimension as it, PseudoClassSelector as j, is_supports_declaration as jt, PreludeOperator as k, is_string as kt, Comment as l, is_identifier as lt, Function as m, is_media_type as mt, Atrule as n, is_container_query as nt, CSSNode as o, is_function as ot, FeatureRange as p, is_media_query as pt, Value as q, AtrulePrelude as r, is_declaration as rt, ClassSelector as s, is_hash as st, AnyNode as t, is_comment as tt, ContainerQuery as u, is_lang_selector as ut, LangSelector as v, is_number as vt, NthOfSelector as w, is_pseudo_element_selector as wt, MediaQuery as x, is_prelude_operator as xt, LayerName as y, is_operator as yt, StyleSheet as z, PlainCSSNode as zt };

package/dist/parse-anplusb.d.ts

@@ -1,6 +1,5 @@
-import { l as CSSDataArena } from "./arena-DfpuGV9Y.js";
-import { T as NthSelector } from "./node-types-BrZu8T2C.js";
-
+import { l as CSSDataArena } from "./arena-Bx5vp6Sl.js";
+import { T as NthSelector } from "./node-types-BRnQyc9B.js";
 //#region src/parse-anplusb.d.ts
 /** @internal */
 declare class ANplusBParser {

package/dist/parse-anplusb.js

@@ -1,7 +1,7 @@
 import { t as Lexer } from "./tokenize-BiRLfVbm.js";
-import { l as CSSDataArena } from "./arena-CCye9VYE.js";
-import { o as str_equals, s as str_index_of } from "./parse-dimension-B0AZRxxt.js";
-import { t as CSSNode } from "./css-node-TR2T5Q7D.js";
+import { l as CSSDataArena } from "./arena-CFwM4uQs.js";
+import { o as str_equals, s as str_index_of } from "./parse-dimension-ouWXNHdx.js";
+import { t as CSSNode } from "./css-node-B3EzCweR.js";
 //#region src/parse-anplusb.ts
 /** @internal */
 var ANplusBParser = class {

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

@@ -1,6 +1,5 @@
-import { l as CSSDataArena } from "./arena-DfpuGV9Y.js";
-import { t as AnyNode } from "./node-types-BrZu8T2C.js";
-
+import { l as CSSDataArena } from "./arena-Bx5vp6Sl.js";
+import { t as AnyNode } from "./node-types-BRnQyc9B.js";
 //#region src/parse-atrule-prelude.d.ts
 /** @internal */
 declare class AtRulePreludeParser {
@@ -8,6 +7,7 @@ declare class AtRulePreludeParser {
   private arena;
   private source;
   private prelude_end;
+  private value_node_parser;
   constructor(arena: CSSDataArena, source: string);
   parse_prelude(at_rule_name: string, start: number, end: number, line?: number, column?: number): number[];
   private parse_prelude_dispatch;
@@ -31,7 +31,6 @@ declare class AtRulePreludeParser {
   private skip_whitespace;
   private peek_token_type;
   private next_token;
-  private parse_value_token;
   private parse_feature_value;
   private parse_namespace_prelude;
   private parse_scope_prelude;