use biome_css_syntax::{CssSyntaxKind, CssSyntaxKind::*, T, *};
use biome_rowan::{
AstNode, ParsedChildren, RawNodeSlots, RawSyntaxNode, SyntaxFactory, SyntaxKind,
};
#[derive(Debug)]
pub struct CssSyntaxFactory;
impl SyntaxFactory for CssSyntaxFactory {
type Kind = CssSyntaxKind;
#[allow(unused_mut)]
fn make_syntax(
kind: Self::Kind,
children: ParsedChildren<Self::Kind>,
) -> RawSyntaxNode<Self::Kind> {
match kind {
CSS_BOGUS | CSS_BOGUS_BODY | CSS_BOGUS_PATTERN => {
RawSyntaxNode::new(kind, children.into_iter().map(Some))
}
CSS_ANY_FUNCTION => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssSimpleFunction::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ANY_FUNCTION.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ANY_FUNCTION, children)
}
CSS_AT_KEYFRAMES => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<5usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [@] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![keyframes] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssString::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAtKeyframesBody::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_KEYFRAMES.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_KEYFRAMES, children)
}
CSS_AT_KEYFRAMES_BODY => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T!['{'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAtKeyframesItemList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['}'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_KEYFRAMES_BODY.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_KEYFRAMES_BODY, children)
}
CSS_AT_MEDIA => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<6usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [@] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![media] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAtMediaQueryList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['{'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssRule::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['}'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA, children)
}
CSS_AT_MEDIA_QUERY => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<5usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T![not] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![or] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![only] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssAtMediaQueryType::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAtMediaQueryConsequent::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY, children)
}
CSS_AT_MEDIA_QUERY_CONSEQUENT => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T![and] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![not] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssAtMediaQueryType::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY_CONSEQUENT.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY_CONSEQUENT, children)
}
CSS_AT_MEDIA_QUERY_FEATURE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T!['('] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssAtMediaQueryFeatureType::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![')'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY_FEATURE.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY_FEATURE, children)
}
CSS_AT_MEDIA_QUERY_FEATURE_BOOLEAN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY_FEATURE_BOOLEAN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY_FEATURE_BOOLEAN, children)
}
CSS_AT_MEDIA_QUERY_FEATURE_COMPARE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAtMediaQueryRange::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY_FEATURE_COMPARE.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY_FEATURE_COMPARE, children)
}
CSS_AT_MEDIA_QUERY_FEATURE_PLAIN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [:] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY_FEATURE_PLAIN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY_FEATURE_PLAIN, children)
}
CSS_AT_MEDIA_QUERY_FEATURE_RANGE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<5usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if AnyCssValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAtMediaQueryRange::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAtMediaQueryRange::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY_FEATURE_RANGE.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY_FEATURE_RANGE, children)
}
CSS_AT_MEDIA_QUERY_RANGE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [>] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [<] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [>=] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [<=] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_AT_MEDIA_QUERY_RANGE.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_AT_MEDIA_QUERY_RANGE, children)
}
CSS_ATTRIBUTE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T!['['] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAttributeName::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAttributeMeta::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![']'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ATTRIBUTE.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ATTRIBUTE, children)
}
CSS_ATTRIBUTE_MATCHER => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<8usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [~=] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [|=] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [^=] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!["$="] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [*=] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [=] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssString::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ATTRIBUTE_MATCHER.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ATTRIBUTE_MATCHER, children)
}
CSS_ATTRIBUTE_META => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssAttributeMatcher::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAttributeModifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ATTRIBUTE_META.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ATTRIBUTE_META, children)
}
CSS_ATTRIBUTE_MODIFIER => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T![i] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ATTRIBUTE_MODIFIER.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ATTRIBUTE_MODIFIER, children)
}
CSS_ATTRIBUTE_NAME => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssString::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ATTRIBUTE_NAME.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ATTRIBUTE_NAME, children)
}
CSS_ATTRIBUTE_SELECTOR_PATTERN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssAttributeList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ATTRIBUTE_SELECTOR_PATTERN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ATTRIBUTE_SELECTOR_PATTERN, children)
}
CSS_BLOCK => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T!['{'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssDeclarationList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['}'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_BLOCK.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_BLOCK, children)
}
CSS_CLASS_SELECTOR_PATTERN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [.] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_CLASS_SELECTOR_PATTERN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_CLASS_SELECTOR_PATTERN, children)
}
CSS_COMBINATOR_SELECTOR_PATTERN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<6usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if AnyCssSelectorPattern::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [>] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [+] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [~] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == CSS_SPACE_LITERAL {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssSelectorPattern::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_COMBINATOR_SELECTOR_PATTERN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_COMBINATOR_SELECTOR_PATTERN, children)
}
CSS_CUSTOM_PROPERTY => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == CSS_CUSTOM_PROPERTY {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_CUSTOM_PROPERTY.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_CUSTOM_PROPERTY, children)
}
CSS_DECLARATION => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<5usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssCustomProperty::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [:] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssDeclarationImportant::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_DECLARATION.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_DECLARATION, children)
}
CSS_DECLARATION_IMPORTANT => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T![!] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![important] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_DECLARATION_IMPORTANT.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_DECLARATION_IMPORTANT, children)
}
CSS_DIMENSION => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssNumber::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_DIMENSION.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_DIMENSION, children)
}
CSS_ID_SELECTOR_PATTERN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [#] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_ID_SELECTOR_PATTERN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_ID_SELECTOR_PATTERN, children)
}
CSS_IDENTIFIER => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == IDENT {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_IDENTIFIER.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_IDENTIFIER, children)
}
CSS_KEYFRAMES_BLOCK => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssKeyframesSelectorList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['{'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssDeclarationList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['}'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_KEYFRAMES_BLOCK.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_KEYFRAMES_BLOCK, children)
}
CSS_KEYFRAMES_SELECTOR => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T![from] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![to] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssPercentage::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_KEYFRAMES_SELECTOR.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_KEYFRAMES_SELECTOR, children)
}
CSS_NUMBER => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == CSS_NUMBER_LITERAL {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_NUMBER.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_NUMBER, children)
}
CSS_PARAMETER => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if AnyCssValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_PARAMETER.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_PARAMETER, children)
}
CSS_PERCENTAGE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssNumber::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T ! [%] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_PERCENTAGE.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_PERCENTAGE, children)
}
CSS_PSEUDO_CLASS_SELECTOR_PATTERN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [:] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssPseudoClassSelectorPatternParameters::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_PSEUDO_CLASS_SELECTOR_PATTERN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_PSEUDO_CLASS_SELECTOR_PATTERN, children)
}
CSS_PSEUDO_CLASS_SELECTOR_PATTERN_PARAMETERS => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T!['('] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if AnyCssValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![')'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_PSEUDO_CLASS_SELECTOR_PATTERN_PARAMETERS.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_PSEUDO_CLASS_SELECTOR_PATTERN_PARAMETERS, children)
}
CSS_RATIO => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssNumber::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssNumber::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_RATIO.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_RATIO, children)
}
CSS_ROOT => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssRuleList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![EOF] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(CSS_ROOT.to_bogus(), children.into_iter().map(Some));
}
slots.into_node(CSS_ROOT, children)
}
CSS_RULE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssSelectorList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssBlock::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(CSS_RULE.to_bogus(), children.into_iter().map(Some));
}
slots.into_node(CSS_RULE, children)
}
CSS_SIMPLE_FUNCTION => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['('] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssParameterList::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![')'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_SIMPLE_FUNCTION.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_SIMPLE_FUNCTION, children)
}
CSS_STRING => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == CSS_STRING_LITERAL {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_STRING.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_STRING, children)
}
CSS_TYPE_SELECTOR_PATTERN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_TYPE_SELECTOR_PATTERN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_TYPE_SELECTOR_PATTERN, children)
}
CSS_UNIVERSAL_SELECTOR_PATTERN => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [*] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_UNIVERSAL_SELECTOR_PATTERN.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_UNIVERSAL_SELECTOR_PATTERN, children)
}
CSS_VAR_FUNCTION => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<5usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T![var] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T!['('] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssCustomProperty::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssVarFunctionValue::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if element.kind() == T![')'] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_VAR_FUNCTION.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_VAR_FUNCTION, children)
}
CSS_VAR_FUNCTION_VALUE => {
let mut elements = (&children).into_iter();
let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
let mut current_element = elements.next();
if let Some(element) = ¤t_element {
if element.kind() == T ! [,] {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if let Some(element) = ¤t_element {
if CssIdentifier::can_cast(element.kind()) {
slots.mark_present();
current_element = elements.next();
}
}
slots.next_slot();
if current_element.is_some() {
return RawSyntaxNode::new(
CSS_VAR_FUNCTION_VALUE.to_bogus(),
children.into_iter().map(Some),
);
}
slots.into_node(CSS_VAR_FUNCTION_VALUE, children)
}
CSS_AT_KEYFRAMES_ITEM_LIST => {
Self::make_node_list_syntax(kind, children, CssKeyframesBlock::can_cast)
}
CSS_AT_MEDIA_QUERY_LIST => Self::make_separated_list_syntax(
kind,
children,
CssAtMediaQuery::can_cast,
T ! [,],
false,
),
CSS_ATTRIBUTE_LIST => {
Self::make_node_list_syntax(kind, children, CssAttribute::can_cast)
}
CSS_DECLARATION_LIST => {
Self::make_node_list_syntax(kind, children, CssDeclaration::can_cast)
}
CSS_KEYFRAMES_SELECTOR_LIST => Self::make_separated_list_syntax(
kind,
children,
CssKeyframesSelector::can_cast,
T ! [,],
false,
),
CSS_PARAMETER_LIST => {
Self::make_node_list_syntax(kind, children, CssParameter::can_cast)
}
CSS_RULE_LIST => Self::make_node_list_syntax(kind, children, AnyCssRule::can_cast),
CSS_SELECTOR_LIST => Self::make_separated_list_syntax(
kind,
children,
AnyCssSelectorPattern::can_cast,
T ! [,],
false,
),
_ => unreachable!("Is {:?} a token?", kind),
}
}
}