Allow media queries as ruleset children

src/ast.ts

 import { Rule } from './ast/rule';
 import { RuleSet } from './ast/ruleSet';
 
-export type Child = Rule | RuleSet | Application;
+export type Child = Rule | RuleSet | Application | MediaQuery;
 export type Value = Literal | Identifier | Application;
 export type Node
   = Application

src/parser.ts

       selectors.push(selector);
     }
 
-    const children: (AST.Application | AST.Rule | AST.RuleSet)[] = [];
+    const children: (AST.Child)[] = [];
 
     while (
       [TokenTypes.PROPERTY, TokenTypes.LPAREN].includes(
       return new AST.Rule(property, value);
     } else if (this.currentToken().type === TokenTypes.LPAREN) {
       if (this.nextToken().type === TokenTypes.LITERAL) {
-        const ruleSet = this.ruleSet(parents);
-        if (ruleSet instanceof ParserError) return ruleSet;
-        return ruleSet;
+        return this.ruleSet(parents);
       } else if (this.nextToken().type === TokenTypes.FUNCTION_NAME) {
-        const application = this.application();
-        if (application instanceof ParserError) return application;
-        return application;
+        if (this.nextToken().value === 'media') {
+          return this.mediaQuery();
+        }
+        return this.application();
       }
     }
 

src/tests/parser.test.ts

       result.tree[0],
       new AST.RuleSet(
         [new AST.Selector(literalToken('div'))],
-        [
-          new AST.Application(functionName('border'), [
-            literalNode('#000000'),
-          ]),
-        ]
+        [new AST.Application(functionName('border'), [literalNode('#000000')])]
       )
-    )
+    );
   }
 });
 
         [],
         [
           new AST.RuleSet(
-            [
-              new AST.Selector(literalToken('div')),
-            ],
+            [new AST.Selector(literalToken('div'))],
             [new AST.Rule(property('color'), literalNode('blue'))]
-          )
+          ),
         ]
-      ),
-    )
+      )
+    );
+  }
+});
+
+test('media query as child', (t) => {
+  t.plan(2);
+  const result = parse('(div (@media :min-width 1000px (& :color blue)))');
+  t.false(result instanceof ParserError);
+  if (!(result instanceof LexerError) && !(result instanceof ParserError)) {
+    t.deepEqual(
+      result.tree[0],
+      new AST.RuleSet(
+        [new AST.Selector(literalToken('div'))],
+        [
+          new AST.MediaQuery(
+            new AST.MediaQueryPredicate(
+              property('min-width'),
+              literalNode('1000px')
+            ),
+            [
+              new AST.RuleSet(
+                [new AST.Selector(literalToken('&'))],
+                [new AST.Rule(property('color'), literalNode('blue'))]
+              ),
+            ]
+          ),
+        ]
+      )
+    );
   }
 });