Allow defining mixin inside other mixin

src/ast.ts

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

src/parser.ts

 
       return new AST.Rule(property, value);
     } else if (this.currentToken().type === TokenTypes.LPAREN) {
-      if (this.nextToken().type === TokenTypes.LITERAL) {
+      const next = this.nextToken();
+      if (next.type === TokenTypes.LITERAL) {
         return this.ruleSet(parents);
-      } else if (this.nextToken().type === TokenTypes.FUNCTION_NAME) {
-        if (this.nextToken().value === 'media') {
+      } else if (next.type === TokenTypes.FUNCTION_NAME) {
+        if (next.value === 'media') {
           return this.mediaQuery();
+        } else if (next.value === 'mixin') {
+          return this.mixin();
         }
         return this.application();
       }

src/tests/parser.test.ts

     );
   }
 });
+
+test('mixin as child', (t) => {
+  t.plan(2);
+  const result = parse('(div (@mixin m () (div :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.Mixin(
+            literalToken('m'),
+            [],
+            [
+              new AST.RuleSet(
+                [new AST.Selector(literalToken('div'))],
+                [new AST.Rule(property('color'), literalNode('blue'))]
+              ),
+            ]
+          )
+        ]
+      )
+    );
+  }
+});
+
+test('define a mixin inside another mixin', (t) => {
+  t.plan(2);
+  const result = parse('(@mixin outer ($x) (@mixin inner ($y) (div :color $y)))');
+  t.false(result instanceof ParserError);
+  if (!(result instanceof LexerError) && !(result instanceof ParserError)) {
+    t.deepEqual(
+      result.tree[0],
+      new AST.Mixin(
+        literalToken('outer'),
+        [identifierNode('x')],
+        [
+          new AST.Mixin(
+            literalToken('inner'),
+            [identifierNode('y')],
+            [
+              new AST.RuleSet(
+                [new AST.Selector(literalToken('div'))],
+                [new AST.Rule(property('color'), identifierNode('y'))]
+              ),
+            ]
+          ),
+        ]
+      )
+    );
+  }
+});