Compile mixin applications as long as mixins are not nested

src/ast.ts

 import Env, { EnvError } from './env';
 import Token from './token';
 
-
 export namespace AST {
   export type Child = Rule | RuleSet | Application;
 
     public parameters: Identifier[];
     public children: Child[];
 
-    public constructor(name: Token, parameters: Identifier[], children: Child[]) {
+    public constructor(
+      name: Token,
+      parameters: Identifier[],
+      children: Child[]
+    ) {
       super();
       this.name = name;
       this.parameters = parameters;
 
   export class RuleSet extends Node {
     public selectors: Selector[];
-    public children: (Application | Rule | RuleSet)[];
+    public children: Child[];
 
-    public constructor(
-      selectors: Selector[],
-      children: (Application | Rule | RuleSet)[] = []
-    ) {
+    public constructor(selectors: Selector[], children: Child[] = []) {
       super();
       this.selectors = selectors;
       this.children = children;
       const rules: (String | EnvError)[] = [];
       const children: (String | EnvError)[] = [];
 
-      this.children.map((child) => {
+      for (const child of this.children) {
         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 mixin = env.get(child.name.value);
+          if (mixin instanceof EnvError) return mixin;
+          if (mixin instanceof AST.Mixin) {
+            if (mixin.parameters.length !== child.arguments.length) {
+              return new EnvError(
+                child.name.value.line,
+                `Expected ${mixin.parameters.length} arguments but received ${
+                  child.arguments.length
+                }`
+              );
+            }
+            const mixinEnv = new Env(env);
+            mixin.parameters.forEach((param, index) => {
+              mixinEnv.set(param.name.value, child.arguments[index]);
+            });
+            mixin.children.forEach((mixinChild) => {
+              if (mixinChild instanceof Rule) {
+                rules.push(mixinChild.compile(mixinEnv, opts));
+              } else if (mixinChild instanceof RuleSet) {
+                mixinChild.selectors.map((sel) => {
+                  sel.parents = this.selectors;
+                });
+                children.push(mixinChild.compile(mixinEnv, opts));
+              } else {
+                console.log(mixinChild);
+              }
+            });
+          }
         }
-      });
+      }
 
       const rulesError = rules.find((node) => node instanceof EnvError);
       if (rulesError instanceof EnvError) return rulesError;

src/tests/compiler.test.ts

     ]
   ));
 });
+
+test('compiles mixin application', (t) => {
+  t.plan(1);
+  const result = compile('(@mixin centered ($width) :max-width $width :margin auto)(div (@centered 800px))');
+  t.equal(result, 'div{max-width:800px;margin:auto;}');
+});
+
+test('compiles mixin application with children', (t) => {
+  t.plan(1);
+  const result = compile('(@mixin heading-color ($color) (h1 :color $color))(div (@heading-color blue))');
+  t.equal(result, 'div h1{color:blue;}');
+});