x Stylesheet
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:1:1]
  1 | ,-> @unknown;
  2 | |   @unknown x y;
  3 | |   @unknown "blah";
  4 | |   @unknown \"blah\";
  5 | |   /*@unknown!*test*!;*/
  6 | |   /*@unknown!*test*!x!*test*! y;*/
  7 | |   @unknown  ;
  8 | |   @unknown  x  y;
  9 | |   
 10 | |   @unknown {}
 11 | |   @\unknown {}
 12 | |   @unknown a b {}
 13 | |   @unknown {p:v}
 14 | |   @unknown x y {p:v}
 15 | |   @unknown x, y x(1) {p:v}
 16 | |   @unknown x, y x(1+2) {p:v}
 17 | |   @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
 18 | |   /*@unknown!*test*!x!*test*! y!*test*!{!*test*!p!*test*!:!*test*!v!*test*!}*/
 19 | |   /*@unknown!*test*!x!*test*!,!*test*!y!*test*! x(!*test*!1!*test*!+!*test*!2!*test*!)!*test*!{!*test*!p!*test*!:!*test*!v!*test*!}*/
 20 | |   @unknown  {  p  :  v  }
 21 | |   @unknown  x  y  {  p  :  v  }
 22 | |   /*@unknown  x  ,  y  x(  1  +  2  )  {  p  :  v  }*/
 23 | |   
 24 | |   @unknown {s{p:v}}
 25 | |   @unknown x y {s{p:v}}
 26 | |   @unknown x, y f(1) {s{p:v}}
 27 | |   @unknown x, y f(1+2) {s{p:v}}
 28 | |   @unknown { .a { p: v; } .b { p: v } }
 29 | |   @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
 30 | |   /*@unknown!*test*!x!*test*! y!*test*!{!*test*!s!*test*!{!*test*!p!*test*!:!*test*!v!*test*!}!*test*!}*/
 31 | |   /*@unknown!*test*!x!*test*!,!*test*!y!*test*! f(!*test*!1!*test*!+!*test*!2!*test*!)!*test*!{!*test*!s!*test*!{!*test*!p!*test*!:!*test*!v!*test*!}!*test*!}*/
 32 | |   @unknown  {  s  {  p  :  v  }  }
 33 | |   @unknown  x  y  {  s  {  p  :  v  }  }
 34 | |   @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
 35 | |   @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
 36 | |   
 37 | |   @unknown {
 38 | |       --> {}
 39 | |       <!-- {}
 40 | |   }
 41 | |   
 42 | |   @unknown {
 43 | |       @unknown {s{p:v}}
 44 | |   }
 45 | |   
 46 | |   @unknown {
 47 | |       @unknown {s{p:v}}
 48 | |       
 49 | |       color: red;
 50 | |   }
 51 | |   
 52 | |   .foo {
 53 | |       @unknown {s{p:v}}
 54 | |   
 55 | |       color: red;
 56 | |   }
 57 | |   
 58 | |   @unknown x ( a , b ) ;
 59 | |   @unknown x ( a , b ) { foo: bar }
 60 | |   @unknown x( a, b ) { foo: bar }
 61 | |   @unknown x ( a + b ) ;
 62 | |   @unknown x ( a - b ) ;
 63 | |   @unknown x ( a * b ) ;
 64 | |   @unknown x ( a / b ) ;
 65 | `-> @unknown{}
    `----

  x Rule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:1:1]
 1 | @unknown;
   : ^^^^^^^^^
   `----

  x AtRule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:1:1]
 1 | @unknown;
   : ^^^^^^^^^
   `----

  x AtRuleName
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:1:1]
 1 | @unknown;
   :  ^^^^^^^
   `----

  x Ident
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:1:1]
 1 | @unknown;
   :  ^^^^^^^
   `----

  x Rule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   : ^^^^^^^^^^^^^
   `----

  x AtRule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   : ^^^^^^^^^^^^^
   `----

  x AtRuleName
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :  ^^^^^^^
   `----

  x Ident
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :  ^^^^^^^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :         ^
   `----

  x WhiteSpace { value: Atom(' ' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :         ^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :          ^
   `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :          ^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :           ^
   `----

  x WhiteSpace { value: Atom(' ' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :           ^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :            ^
   `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:2:1]
 2 | @unknown x y;
   :            ^
   `----

  x Rule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   : ^^^^^^^^^^^^^^^^
   `----

  x AtRule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   : ^^^^^^^^^^^^^^^^
   `----

  x AtRuleName
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   :  ^^^^^^^
   `----

  x Ident
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   :  ^^^^^^^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   :         ^
   `----

  x WhiteSpace { value: Atom(' ' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   :         ^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   :          ^^^^^^
   `----

  x String { value: Atom('blah' type=inline), raw: Atom('"blah"' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:3:1]
 3 | @unknown "blah";
   :          ^^^^^^
   `----

  x Rule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   : ^^^^^^^^^^^^^^^^^^
   `----

  x AtRule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   : ^^^^^^^^^^^^^^^^^^
   `----

  x AtRuleName
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   :  ^^^^^^^
   `----

  x Ident
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   :  ^^^^^^^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   :         ^
   `----

  x WhiteSpace { value: Atom(' ' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   :         ^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   :          ^^^^^^^^
   `----

  x Ident { value: Atom('"blah"' type=inline), raw: Atom('\"blah\"' type=dynamic) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:4:1]
 4 | @unknown \"blah\";
   :          ^^^^^^^^
   `----

  x Rule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:7:1]
 7 | @unknown  ;
   : ^^^^^^^^^^^
   `----

  x AtRule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:7:1]
 7 | @unknown  ;
   : ^^^^^^^^^^^
   `----

  x AtRuleName
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:7:1]
 7 | @unknown  ;
   :  ^^^^^^^
   `----

  x Ident
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:7:1]
 7 | @unknown  ;
   :  ^^^^^^^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:7:1]
 7 | @unknown  ;
   :         ^^
   `----

  x WhiteSpace { value: Atom('  ' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:7:1]
 7 | @unknown  ;
   :         ^^
   `----

  x Rule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   : ^^^^^^^^^^^^^^^
   `----

  x AtRule
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   : ^^^^^^^^^^^^^^^
   `----

  x AtRuleName
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :  ^^^^^^^
   `----

  x Ident
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :  ^^^^^^^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :         ^^
   `----

  x WhiteSpace { value: Atom('  ' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :         ^^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :           ^
   `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :           ^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :            ^^
   `----

  x WhiteSpace { value: Atom('  ' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :            ^^
   `----

  x ComponentValue
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :              ^
   `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
   ,-[$DIR/tests/fixture/at-rule/unknown/input.css:8:1]
 8 | @unknown  x  y;
   :              ^
   `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:10:1]
 10 | @unknown {}
    : ^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:10:1]
 10 | @unknown {}
    : ^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:10:1]
 10 | @unknown {}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:10:1]
 10 | @unknown {}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:10:1]
 10 | @unknown {}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:10:1]
 10 | @unknown {}
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:10:1]
 10 | @unknown {}
    :          ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:11:1]
 11 | @\unknown {}
    : ^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:11:1]
 11 | @\unknown {}
    : ^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:11:1]
 11 | @\unknown {}
    :  ^^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:11:1]
 11 | @\unknown {}
    :  ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:11:1]
 11 | @\unknown {}
    :          ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:11:1]
 11 | @\unknown {}
    :          ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:11:1]
 11 | @\unknown {}
    :           ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    : ^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    : ^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :          ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :            ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :             ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:12:1]
 12 | @unknown a b {}
    :              ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    : ^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    : ^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :          ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :           ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :            ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :             ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:13:1]
 13 | @unknown {p:v}
    :             ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    : ^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    : ^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :            ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :             ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :              ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :               ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :                ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :                 ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:14:1]
 14 | @unknown x y {p:v}
    :                 ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    : ^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    : ^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :           ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :            ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :             ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :              ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :               ^^^^
    `----

  x Function
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :               ^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                 ^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                   ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                    ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                     ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                     ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                      ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                      ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                       ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:15:1]
 15 | @unknown x, y x(1) {p:v}
    :                       ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :           ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :            ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :             ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :              ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :               ^^^^^^
    `----

  x Function
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :               ^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                 ^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                  ^^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                     ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                      ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                       ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                        ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                        ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                         ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:16:1]
 16 | @unknown x, y x(1+2) {p:v}
    :                         ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :  ^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :                          ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :                                   ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :                                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :                                            ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:17:1]
 17 | @unknown/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}
    :                                            ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    : ^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    : ^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :         ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :         ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :           ^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :            ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :            ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :              ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :               ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :               ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                 ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                  ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                    ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                     ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:20:1]
 20 | @unknown  {  p  :  v  }
    :                     ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :         ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :         ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :           ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :            ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :            ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :              ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :               ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :               ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                 ^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                  ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                    ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                     ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                     ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                       ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                        ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                        ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                          ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                           ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:21:1]
 21 | @unknown  x  y  {  p  :  v  }
    :                           ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    : ^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    : ^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :          ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :           ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :             ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :              ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :               ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:24:1]
 24 | @unknown {s{p:v}}
    :               ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    : ^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    : ^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :            ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :             ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :              ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :               ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                ^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                 ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                  ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                   ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:25:1]
 25 | @unknown x y {s{p:v}}
    :                   ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :           ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :            ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :             ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :              ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :               ^^^^
    `----

  x Function
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :               ^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                 ^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                   ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                    ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                     ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                     ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                      ^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                      ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                       ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                        ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                        ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                         ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:26:1]
 26 | @unknown x, y f(1) {s{p:v}}
    :                         ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :           ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :            ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :             ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :              ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :               ^^^^^^
    `----

  x Function
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :               ^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                 ^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                  ^^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                     ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                      ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                       ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                        ^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                        ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                         ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                          ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                           ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:27:1]
 27 | @unknown x, y f(1+2) {s{p:v}}
    :                           ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :            ^
    `----

  x Delim { value: '.' }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :             ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :              ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :               ^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :               ^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                 ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                  ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                    ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                     ^
    `----

  x Semi
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                     ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                      ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                      ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                        ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                        ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                         ^
    `----

  x Delim { value: '.' }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                          ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                            ^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                            ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                              ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                               ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                 ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                  ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                    ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:28:1]
 28 | @unknown { .a { p: v; } .b { p: v } }
    :                                    ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :  ^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                          ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                            ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                                     ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                                     ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                                              ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:29:1]
 29 | @unknown/*test*/{/*test*/s/*test*/{/*test*/p/*test*/:/*test*/v/*test*/}/*test*/}
    :                                                              ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :           ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :              ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                 ^^^^^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                 ^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                    ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                     ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                     ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                       ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                        ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                        ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                          ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                           ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                           ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                              ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:32:1]
 32 | @unknown  {  s  {  p  :  v  }  }
    :                              ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :           ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :              ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                 ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                    ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                     ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                     ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                       ^^^^^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                       ^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                        ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                        ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                          ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                           ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                           ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                             ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                              ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                              ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                                ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                                 ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                                 ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                                    ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:33:1]
 33 | @unknown  x  y  {  s  {  p  :  v  }  }
    :                                    ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :           ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :              ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                 ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                    ^^^^^^^^
    `----

  x Function
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                    ^^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                        ^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                        ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                            ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                            ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                              ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                               ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                               ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                 ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                  ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                    ^^^^^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                    ^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                     ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                     ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                       ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                        ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                        ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                          ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                           ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                           ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                             ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                              ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                              ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                                 ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:34:1]
 34 | @unknown  x  ,  y  f(  1  )  {  s  {  p  :  v  }  }
    :                                                 ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :         ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :           ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :            ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :              ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :               ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                 ^
    `----

  x Ident { value: Atom('y' type=inline), raw: Atom('y' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                  ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                    ^^^^^^^^^^^^^
    `----

  x Function
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                    ^^^^^^^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                        ^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                        ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                             ^
    `----

  x Integer
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                 ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                 ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                   ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                    ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                    ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                      ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                      ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                       ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                       ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                         ^^^^^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                         ^^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                          ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                          ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                            ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                             ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                             ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                               ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                  ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                   ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                   ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                      ^^
    `----

  x WhiteSpace { value: Atom('  ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:35:1]
 35 | @unknown  x  ,  y  f(  1    2  )  {  s  {  p  :  v  }  }
    :                                                      ^^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | ,-> @unknown {
 38 | |       --> {}
 39 | |       <!-- {}
 40 | `-> }
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | ,-> @unknown {
 38 | |       --> {}
 39 | |       <!-- {}
 40 | `-> }
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | @unknown {
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | @unknown {
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | @unknown {
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | @unknown {
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | ,-> @unknown {
 38 | |       --> {}
 39 | |       <!-- {}
 40 | `-> }
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | ,-> @unknown {
 38 | `->     --> {}
    `----

  x WhiteSpace { value: Atom('
  |     ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:37:1]
 37 | ,-> @unknown {
 38 | `->     --> {}
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | --> {}
    : ^^^
    `----

  x CDC
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | --> {}
    : ^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | --> {}
    :    ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | --> {}
    :    ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | --> {}
    :     ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | --> {}
    :     ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | ,-> --> {}
 39 | `->     <!-- {}
    `----

  x WhiteSpace { value: Atom('
  |     ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:38:5]
 38 | ,-> --> {}
 39 | `->     <!-- {}
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    : ^^^^
    `----

  x CDO
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    : ^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    :     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    :     ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    :      ^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    :      ^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    :        ^
 40 | }
    `----

  x WhiteSpace { value: Atom('
  | ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:39:5]
 39 | <!-- {}
    :        ^
 40 | }
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | ,-> @unknown {
 43 | |       @unknown {s{p:v}}
 44 | `-> }
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | ,-> @unknown {
 43 | |       @unknown {s{p:v}}
 44 | `-> }
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | @unknown {
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | @unknown {
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | @unknown {
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | @unknown {
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | ,-> @unknown {
 43 | |       @unknown {s{p:v}}
 44 | `-> }
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | ,-> @unknown {
 43 | `->     @unknown {s{p:v}}
    `----

  x WhiteSpace { value: Atom('
  |     ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:42:1]
 42 | ,-> @unknown {
 43 | `->     @unknown {s{p:v}}
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    : ^^^^^^^^
    `----

  x AtKeyword { value: Atom('unknown' type=static), raw: Atom('unknown' type=static) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    : ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :          ^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :          ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :           ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :             ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :              ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :               ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :                  ^
 44 | }
    `----

  x WhiteSpace { value: Atom('
  | ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:43:5]
 43 | @unknown {s{p:v}}
    :                  ^
 44 | }
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | ,-> @unknown {
 47 | |       @unknown {s{p:v}}
 48 | |       
 49 | |       color: red;
 50 | `-> }
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | ,-> @unknown {
 47 | |       @unknown {s{p:v}}
 48 | |       
 49 | |       color: red;
 50 | `-> }
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | @unknown {
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | @unknown {
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | @unknown {
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | @unknown {
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | ,-> @unknown {
 47 | |       @unknown {s{p:v}}
 48 | |       
 49 | |       color: red;
 50 | `-> }
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | ,-> @unknown {
 47 | `->     @unknown {s{p:v}}
    `----

  x WhiteSpace { value: Atom('
  |     ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:46:1]
 46 | ,-> @unknown {
 47 | `->     @unknown {s{p:v}}
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    : ^^^^^^^^
    `----

  x AtKeyword { value: Atom('unknown' type=static), raw: Atom('unknown' type=static) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    : ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :          ^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :          ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :           ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :             ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :              ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :               ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | @unknown {s{p:v}}
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | ,-> @unknown {s{p:v}}
 48 | |       
 49 | `->     color: red;
    `----

  x WhiteSpace { value: Atom('
  | 
  |     ' type=dynamic) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:47:5]
 47 | ,-> @unknown {s{p:v}}
 48 | |       
 49 | `->     color: red;
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    : ^^^^^
    `----

  x Ident { value: Atom('color' type=inline), raw: Atom('color' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    : ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :      ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :      ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :       ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :        ^^^
    `----

  x Ident { value: Atom('red' type=inline), raw: Atom('red' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :        ^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :           ^
    `----

  x Semi
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :            ^
 50 | }
    `----

  x WhiteSpace { value: Atom('
  | ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:49:5]
 49 | color: red;
    :            ^
 50 | }
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | ,-> .foo {
 53 | |       @unknown {s{p:v}}
 54 | |   
 55 | |       color: red;
 56 | `-> }
    `----

  x QualifiedRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | ,-> .foo {
 53 | |       @unknown {s{p:v}}
 54 | |   
 55 | |       color: red;
 56 | `-> }
    `----

  x SelectorList
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | .foo {
    : ^^^^
    `----

  x ComplexSelector
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | .foo {
    : ^^^^
    `----

  x CompoundSelector
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | .foo {
    : ^^^^
    `----

  x SubclassSelector
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | .foo {
    : ^^^^
    `----

  x ClassSelector
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | .foo {
    : ^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | .foo {
    :  ^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:52:1]
 52 | ,-> .foo {
 53 | |       @unknown {s{p:v}}
 54 | |   
 55 | |       color: red;
 56 | `-> }
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:55:5]
 55 | color: red;
    : ^^^^^^^^^^
    `----

  x StyleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:55:5]
 55 | color: red;
    : ^^^^^^^^^^
    `----

  x Declaration
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:55:5]
 55 | color: red;
    : ^^^^^^^^^^
    `----

  x DeclarationName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:55:5]
 55 | color: red;
    : ^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:55:5]
 55 | color: red;
    : ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:55:5]
 55 | color: red;
    :        ^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:55:5]
 55 | color: red;
    :        ^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    : ^^^^^^^^^^^^^^^^^
    `----

  x StyleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    : ^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    : ^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :         ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :          ^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :           ^
    `----

  x Ident { value: Atom('s' type=inline), raw: Atom('s' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :            ^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :             ^
    `----

  x Ident { value: Atom('p' type=inline), raw: Atom('p' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :              ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :               ^
    `----

  x Ident { value: Atom('v' type=inline), raw: Atom('v' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:53:5]
 53 | @unknown {s{p:v}}
    :               ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :            ^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :            ^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :              ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :               ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                 ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                  ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:58:1]
 58 | @unknown x ( a , b ) ;
    :                     ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :            ^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :            ^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :              ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :               ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                ^
    `----

  x Comma
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                 ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                  ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                     ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                      ^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                       ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                       ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                        ^^^
    `----

  x Ident { value: Atom('foo' type=inline), raw: Atom('foo' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                        ^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                           ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                            ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                            ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                             ^^^
    `----

  x Ident { value: Atom('bar' type=inline), raw: Atom('bar' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                             ^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                                ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:59:1]
 59 | @unknown x ( a , b ) { foo: bar }
    :                                ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :          ^^^^^^^^^
    `----

  x Function
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :          ^^^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :             ^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :              ^
    `----

  x Delimiter
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                ^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                   ^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                    ^^^^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                     ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                      ^^^
    `----

  x Ident { value: Atom('foo' type=inline), raw: Atom('foo' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                      ^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                         ^
    `----

  x Colon
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                          ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                           ^^^
    `----

  x Ident { value: Atom('bar' type=inline), raw: Atom('bar' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                           ^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                              ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:60:1]
 60 | @unknown x( a, b ) { foo: bar }
    :                              ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :            ^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :            ^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :              ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :               ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                ^
    `----

  x Delim { value: '+' }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                 ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                  ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:61:1]
 61 | @unknown x ( a + b ) ;
    :                     ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :            ^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :            ^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :              ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :               ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                ^
    `----

  x Delim { value: '-' }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                 ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                  ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:62:1]
 62 | @unknown x ( a - b ) ;
    :                     ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :            ^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :            ^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :              ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :               ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                ^
    `----

  x Delim { value: '*' }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                 ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                  ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:63:1]
 63 | @unknown x ( a * b ) ;
    :                     ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    : ^^^^^^^^^^^^^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :  ^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :         ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :         ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :          ^
    `----

  x Ident { value: Atom('x' type=inline), raw: Atom('x' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :          ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :           ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :           ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :            ^^^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :            ^^^^^^^^^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :             ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :             ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :              ^
    `----

  x Ident { value: Atom('a' type=inline), raw: Atom('a' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :              ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :               ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :               ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                ^
    `----

  x Delim { value: '/' }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                 ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                 ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                  ^
    `----

  x Ident { value: Atom('b' type=inline), raw: Atom('b' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                  ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                   ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                   ^
    `----

  x ComponentValue
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                     ^
    `----

  x WhiteSpace { value: Atom(' ' type=inline) }
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:64:1]
 64 | @unknown x ( a / b ) ;
    :                     ^
    `----

  x Rule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:65:1]
 65 | @unknown{}
    : ^^^^^^^^^^
    `----

  x AtRule
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:65:1]
 65 | @unknown{}
    : ^^^^^^^^^^
    `----

  x AtRuleName
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:65:1]
 65 | @unknown{}
    :  ^^^^^^^
    `----

  x Ident
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:65:1]
 65 | @unknown{}
    :  ^^^^^^^
    `----

  x SimpleBlock
    ,-[$DIR/tests/fixture/at-rule/unknown/input.css:65:1]
 65 | @unknown{}
    :         ^^
    `----