Allow rulesets inside mixins

src/ast.ts

 import Env, { EnvError } from './env';
 import Token from './token';
 
+
 export namespace AST {
+  export type Child = Rule | RuleSet | Application;
+
   export interface Opts {
     depth: number;
     prettyPrint: boolean;
   export class Mixin extends Node {
     public name: Token;
     public parameters: Identifier[];
-    public rules: Rule[];
+    public children: Child[];
 
-    public constructor(name: Token, parameters: Identifier[], rules: Rule[]) {
+    public constructor(name: Token, parameters: Identifier[], children: Child[]) {
       super();
       this.name = name;
       this.parameters = parameters;
-      this.rules = rules;
+      this.children = children;
     }
     public compile(env: Env, _opts: Opts) {
       env.set(this.name.value, this);
         ...this.selectors.map((sel) => sel.getLineages())
       );
 
-      const rules: Array<string | EnvError> = this.children
-        .filter((child) => child instanceof Rule)
-        .map(
-          (child): string | EnvError => {
-            return child.compile(env, opts);
-          }
-        );
-      const rulesError = rules.find((child) => child instanceof EnvError);
-      if (rulesError !== undefined) return rulesError;
-
-      const compiledRules = rules.join(lineSpacer);
+      const rules: (String | EnvError)[] = [];
+      const children: (String | EnvError)[] = [];
+
+      this.children.map((child) => {
+        if (child instanceof Rule) {
+          rules.push(child.compile(env, opts));
+        } else if (child instanceof RuleSet) {
+          children.push(child.compile(env, opts));
+        } else if (child instanceof Application) {
+          console.log(child.compile(env, opts));
+        }
+      });
 
-      const children: Array<string | EnvError> = this.children
-        .filter((child) => child instanceof RuleSet)
-        .map(
-          (child): string | EnvError => {
-            return child.compile(env, opts);
-          }
-        );
-      const childrenError = children.find((child) => child instanceof EnvError);
-      if (childrenError !== undefined) return childrenError;
+      const rulesError = rules.find((node) => node instanceof EnvError);
+      if (rulesError instanceof EnvError) return rulesError;
+      const childrenError = children.find((node) => node instanceof EnvError);
+      if (childrenError instanceof EnvError) return childrenError;
 
+      const compiledRules = rules.join(lineSpacer);
       const compiledChildren = children.join(lineSpacer);
 
       const lineage = lineages.join(`,${wordSpacer}`);

src/parser.ts

     const name = this.eat(TokenTypes.LITERAL);
     if (name instanceof ParserError) return name;
 
-    const rules: AST.Rule[] = [];
-
     const openParen = this.eat(TokenTypes.LPAREN);
     if (openParen instanceof ParserError) return openParen;
 
     const closeParen = this.eat(TokenTypes.RPAREN);
     if (closeParen instanceof ParserError) return closeParen;
 
-    while (this.currentToken().type === TokenTypes.PROPERTY) {
-      const property = this.property();
-      if (property instanceof ParserError) return property;
-      const value = this.value();
-      if (value instanceof ParserError) return value;
-      rules.push(new AST.Rule(property, value));
+    const children: AST.Child[] = [];
+    while (
+      [TokenTypes.PROPERTY, TokenTypes.LPAREN].includes(
+        this.currentToken().type
+      )
+    ) {
+      const child = this.child();
+      if (child instanceof ParserError) return child;
+      children.push(child);
     }
 
     const rParen = this.eat(TokenTypes.RPAREN);
     if (rParen instanceof ParserError) return rParen;
 
-    return new AST.Mixin(name, parameters, rules);
+    return new AST.Mixin(name, parameters, children);
   }
 
   private application(): AST.Application | ParserError {
         this.currentToken().type
       )
     ) {
-      if (this.currentToken().type === TokenTypes.PROPERTY) {
-        const propertyToken = this.eat(TokenTypes.PROPERTY);
-        if (propertyToken instanceof ParserError) return propertyToken;
-
-        const property = new AST.Property(propertyToken);
-
-        const value = this.value();
-        if (value instanceof ParserError) return value;
-
-        children.push(new AST.Rule(property, value));
-      } else if (this.currentToken().type === TokenTypes.LPAREN) {
-        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);
-        }
-      }
+      const child = this.child(selectors);
+      if (child instanceof ParserError) return child;
+      children.push(child);
     }
 
     const rParen = this.eat(TokenTypes.RPAREN);
     return new AST.Selector(literal.value, parents);
   }
 
+  private child(parents: AST.Selector[] = []): AST.Child | ParserError {
+    if (this.currentToken().type === TokenTypes.PROPERTY) {
+      const property = this.property();
+      if (property instanceof ParserError) return property;
+
+      const value = this.value();
+      if (value instanceof ParserError) return value;
+
+      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;
+      } else if (this.nextToken().type === TokenTypes.FUNCTION_NAME) {
+        const application = this.application();
+        if (application instanceof ParserError) return application;
+        return application;
+      }
+    }
+
+    return this.error(
+      `Unexpected ${
+        this.nextToken().type
+      }; expected literal or function/macro application`,
+      this.nextToken()
+    );
+  }
+
   private eat(type: TokenTypes): Token | ParserError {
     const token = this.currentToken();
     if (type === token.type) {

src/tests/parser.test.ts

     )
   }
 });
+
+test('parse mixin with children', (t) => {
+  t.plan(2);
+  const result = parse('(@mixin m () (div :color blue))');
+  t.false(result instanceof ParserError);
+  if (!(result instanceof LexerError) && !(result instanceof ParserError)) {
+    t.deepEqual(
+      result.tree[0],
+      new AST.Mixin(
+        literalToken('m'),
+        [],
+        [
+          new AST.RuleSet(
+            [
+              new AST.Selector(literalToken('div')),
+            ],
+            [new AST.Rule(property('color'), literalNode('blue'))]
+          )
+        ]
+      ),
+    )
+  }
+});