Parse mixin application

src/ast.ts

 
   export class RuleSet extends Node {
     public selectors: Selector[];
-    public children: (RuleSet | Rule)[];
+    public children: (Application | Rule | RuleSet)[];
 
     public constructor(
       selectors: Selector[],
-      children: (RuleSet | Rule)[] = []
+      children: (Application | Rule | RuleSet)[] = []
     ) {
       super();
       this.selectors = selectors;

src/parser.ts

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

src/tests/parser.test.ts

     );
   }
 });
+
+test('parse mixin application', (t) => {
+  t.plan(2);
+  const result = parse('(div (@border #000000))');
+  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.Application(functionName('border'), [
+            literalNode('#000000'),
+          ]),
+        ]
+      )
+    )
+  }
+});