/***********************************************************************

  AST-Tree translator, ColaScript -> JavaScript.

  Distributed under the BSD license:

    Copyright 2014 (c) TrigenSoftware <danon0404@gmail.com>

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

        * Redistributions of source code must retain the above
          copyright notice, this list of conditions and the following
          disclaimer.

        * Redistributions in binary form must reproduce the above
          copyright notice, this list of conditions and the following
          disclaimer in the documentation and/or other materials
          provided with the distribution.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    SUCH DAMAGE.

 ***********************************************************************/

"use strict";
!this.Cola && (this.Cola = {});

Cola.Constructions = {};

Cola.Constructions.setPos = function(node, ext){
    if(!ext) return node;
    if(ext.start) node.start = ext.start;
    if(ext.end) node.end = ext.end;
    return node;
};

/*
    ({{left}} === {{right}} || {{right}}.prototype && ({{left}} instanceof {{right}} || typeof {{left}} === typeof {{right}}()))

*/
Cola.Constructions.Is = function(left, right, ext){
    return this.setPos(new Cola.AST_Binary({
        left     : new Cola.AST_Binary({
            left     : left,
            operator : "===",
            right    : right
        }),
        operator : "||",
        right    : new Cola.AST_Binary({
            left     : new Cola.AST_Dot({
                expression : right,
                property   : "prototype"
            }),
            operator : "&&",
            right    : new Cola.AST_Binary({
                left     : new Cola.AST_Binary({
                    left     : left,
                    operator : "instanceof",
                    right    : right
                }),
                operator : "||",
                right    : new Cola.AST_Binary({
                    left     : new Cola.AST_UnaryPrefix({
                        operator   : "typeof",
                        expression : left
                    }),
                    operator : "===",
                    right    : new Cola.AST_UnaryPrefix({
                        operator   : "typeof",
                        expression : new Cola.AST_Call({
                            expression : right,
                            args       : []
                        })
                    })  
                })
            })
        })
    }), ext);
};

/*
    !({{left}} === {{right}} || {{right}}.prototype && ({{left}} instanceof {{right}} || typeof {{left}} === typeof {{right}}()))

*/
Cola.Constructions.Isnt = function(left, right, ext){
    return this.setPos(new Cola.AST_UnaryPrefix({
        operator   : "!",
        expression : new Cola.AST_Binary({
            left     : new Cola.AST_Binary({
                left     : left,
                operator : "===",
                right    : right
            }),
            operator : "||",
            right    : new Cola.AST_Binary({
                left     : new Cola.AST_Dot({
                    expression : right,
                    property   : "prototype"
                }),
                operator : "&&",
                right    : new Cola.AST_Binary({
                    left     : new Cola.AST_Binary({
                        left     : left,
                        operator : "instanceof",
                        right    : right
                    }),
                    operator : "||",
                    right    : new Cola.AST_Binary({
                        left     : new Cola.AST_UnaryPrefix({
                            operator   : "typeof",
                            expression : left
                        }),
                        operator : "===",
                        right    : new Cola.AST_UnaryPrefix({
                            operator   : "typeof",
                            expression : new Cola.AST_Call({
                                expression : right,
                                args       : []
                            })
                        })  
                    })
                })
            })
        })
    }), ext);
};

/*
    !(typeof {{node}} === "undefined" || {{node}} === null)

*/
Cola.Constructions.IsSet = function(node, ext){
    return this.setPos(new Cola.AST_UnaryPrefix({
        expression : new Cola.AST_Binary({
            right    : new Cola.AST_Binary({
                right    : new Cola.AST_Null,
                operator : "===",
                left     : node
            }),
            operator : "||",
            left     : new Cola.AST_Binary({
                right    : new Cola.AST_String({ value: "undefined" }),
                operator : "===",
                left     : new Cola.AST_UnaryPrefix({
                    expression : node,
                    operator   : "typeof"
                })
            })
        }),
        operator   : "!"
    }), ext);
};

/*
    (typeof {{node}} === "undefined" || {{node}} === null)

*/
Cola.Constructions.IsntSet = function(node, ext){
    return this.setPos(new Cola.AST_Binary({
        right    : new Cola.AST_Binary({
            right    : new Cola.AST_Null,
            operator : "===",
            left     : node
        }),
        operator : "||",
        left     : new Cola.AST_Binary({
            right    : new Cola.AST_String({ value: "undefined" }),
            operator : "===",
            left     : new Cola.AST_UnaryPrefix({
                expression : node,
                operator   : "typeof"
            })
        })
    }), ext);
};

/*
    {{length}} <= {{name}}.length ? [].slice.call({{name}}, {{pos}}, $_cola{{uid}}i = {{name}}.length - {{after}}) : ($_cola{{uid}}i = {{pos}}, [])

*/
Cola.Constructions.SplatedConditional = function(name, uid, pos, after, length){
    if(Cola._ColaRuntime$$is(name, String)) name = new Cola.AST_SymbolRef({ name : name });
    return new Cola.AST_Conditional({
        condition   : new Cola.AST_Binary({
            operator  : "<=",
            left      : new Cola.AST_Number({ value : length }), // length
            right     : new Cola.AST_Dot({
                expression : name, // name
                property   : "length"
            })
        }),
        consequent  : new Cola.AST_Call({
            expression  : new Cola.AST_Dot({ 
                property   : "call",
                expression : new Cola.AST_Dot({
                    property   : "slice",
                    expression : new Cola.AST_Array({ elements : [] })
                })
            }),
            args        : [
                name, // name
                new Cola.AST_Number({ value : pos }), // pos
                new Cola.AST_Assign({
                    operator : '=',
                    left     : new Cola.AST_SymbolRef({ name :  "$_cola" + uid + "i" }),
                    right    : new Cola.AST_Binary({
                        operator : '-',
                        left     : new Cola.AST_Dot({
                            property   : "length",
                            expression : name // name
                        }),
                        right    : new Cola.AST_Number({ value : after }) // after
                    })
                })
            ]
        }),
        alternative : new Cola.AST_Seq({
            car : new Cola.AST_Assign({
                operator : '=',
                left     : new Cola.AST_SymbolRef({ name :  "$_cola" + uid + "i" }),
                right    : new Cola.AST_Number({ value : pos }) // pos
            }),
            cdr : new Cola.AST_Array({ elements : [] })
        })
    });
};

/*
    {{name}}[{{pos}}]

    or

    {{name}}[$_cola{{uid}}i + {{after}}]

*/
Cola.Constructions.ValueWithOffset = function(name, uid, cond, pos, after){
    if(Cola._ColaRuntime$$is(name, String)) name = new Cola.AST_SymbolRef({ name : name });
    return new Cola.AST_Sub({ 
        expression : name, 
        property   : cond 
            ? new Cola.AST_Number({ value : pos }) 
            : new Cola.AST_Binary({
                operator : "+",
                left     : new Cola.AST_SymbolRef({ name : "$_cola" + uid + "i" }),
                right    : new Cola.AST_Number({ value : after })
            })
    });
};

/*
    {{name}}.{{key}}

    or

    {{name}}["{{key}}"]

*/
Cola.Constructions.ValueWithKey = function(cond, name, key){
    return cond
        ? new Cola.AST_Dot({ 
            expression : name, 
            property   : key
        })
        : new Cola.AST_Sub({
            expression : name,
            property   : new Cola.AST_String({ value : key })
        });
};

/*
    {{name}} = {{length}} <= arguments.length ? [].slice.call(arguments, {{pos}}, _ColaRuntime$$i = arguments.length - {{after}}) : (_ColaRuntime$$i = {{pos}}, [])

*/
Cola.Constructions.SplatedVarDef = function(name, pos, after, length){
    if(Cola._ColaRuntime$$is(name, String)) name = { name : name };
    return new Cola.AST_VarDef({
        type  : "Array",
        name  : new Cola.AST_SymbolVar(name), // name
        value : Cola.Constructions.SplatedConditional('arguments', '_', pos, after, length)
    });
};

/*
    {{name}} = arguments[{{pos}}]

    or

    {{name}} = arguments[_ColaRuntime$$i + {{aftersplated}}]

*/
Cola.Constructions.PosedVarDef = function(name, type, pos, aftersplated){
    if(Cola._ColaRuntime$$is(name, String)) name = { name : name };
    return new Cola.AST_VarDef({
        type  : type,
        name  : new Cola.AST_SymbolVar(name),
        value : Cola.Constructions.ValueWithOffset('arguments', '_', aftersplated == -1, pos, aftersplated)
    });
};

/*
    {{name}} = arguments[{{pos}}] !== undefined ? arguments[{{pos}}] : {{defval}}

    or

    {{name}} = arguments[_ColaRuntime$$i + {{aftersplated}}] !== undefined ? arguments[_ColaRuntime$$i + {{aftersplated}}] : {{defval}}

*/
Cola.Constructions.PosedWithDefsVarDef = function(name, type, defval, pos, aftersplated){
    if(Cola._ColaRuntime$$is(name, String)) name = { name : name };
    return new Cola.AST_VarDef({
        type  : type,
        name  : new Cola.AST_SymbolVar(name),
        value : new Cola.AST_Conditional({
            condition   : new Cola.AST_Binary({
                operator : "!==",
                left     : Cola.Constructions.ValueWithOffset('arguments', '_', aftersplated == -1, pos, aftersplated),
                right    : new Cola.AST_SymbolRef({ name : 'undefined' })
            }),
            consequent  : Cola.Constructions.ValueWithOffset('arguments', '_', aftersplated == -1, pos, aftersplated),
            alternative : defval
        })
    });
};

/*
    {{name}} = arguments.{{key}} !== undefined ? arguments.{{key}} : {{defval}}

*/
Cola.Constructions.NamedVarDef = function(name, type, defval, key){
    if(Cola._ColaRuntime$$is(name, String)) name = { name : name };
    return new Cola.AST_VarDef({
        type  : type,
        name  : new Cola.AST_SymbolVar(name),
        value : new Cola.AST_Conditional({
            condition   : new Cola.AST_Binary({
                operator : "!==",
                left     : new Cola.AST_Dot({
                    expression : new Cola.AST_SymbolRef({ name : 'arguments' }),
                    property   : key
                }),
                right    : new Cola.AST_SymbolRef({ name : 'undefined' })
            }),
            consequent  : new Cola.AST_Dot({
                expression : new Cola.AST_SymbolRef({ name : 'arguments' }),
                property   : key
            }),
            alternative : defval
        })
    });
};

Cola.ContainCondAccess = function(node){
    if(!(node instanceof Cola.AST_Call || node instanceof Cola.AST_PropAccess)) return false;
    if(node instanceof Cola.AST_CondAccess) return node.expression;

    var expr = node;
    while(expr.expression instanceof Cola.AST_Call || expr.expression instanceof Cola.AST_PropAccess){
        expr = expr.expression;
        if(expr instanceof Cola.AST_CondAccess) return expr.expression;
    }

    return false;
};

Cola.DefPropWithMods = function(def, mods){
    if(mods.length == 0) return new Cola.AST_Assign({
        start    : def.start,
        end      : def.end,
        operator : '=',
        left     : def.name,
        right    : def.value
    });

    if(mods.indexOf("static") != -1)
        Cola.Parser.prototype.token_error.call(Cola.Parser.prototype, def.start, "Prop definition outside of class can't contain `static` modifer");

    if(mods.indexOf("const") != -1 && !def.value)
        Cola.Parser.prototype.token_error.call(Cola.Parser.prototype, def.start, "`const` prop can't have `undefined` value");

    var dp = { properties : [
        new Cola.AST_ObjectKeyVal({
            key   : "value",
            value : def.value
        })
    ] };

    if(!(def.name.expression instanceof Cola.AST_Symbol && def.name.expression.name == "this" || def.name instanceof Cola.AST_Proto))
        dp.properties.push(new Cola.AST_ObjectKeyVal({
            key   : "configurable",
            value : new Cola.AST_True
        }));

    if(mods.indexOf("const") == -1)
        dp.properties.push(new Cola.AST_ObjectKeyVal({
            key   : "writable",
            value : new Cola.AST_True
        }));

    if(mods.indexOf("covert") == -1)
        dp.properties.push(new Cola.AST_ObjectKeyVal({
            key   : "enumerable",
            value : new Cola.AST_True
        }));
    
    return new Cola.AST_Call({
        args       : [
            def.name.expression, 
            def.name instanceof Cola.AST_Sub
                ? def.name.property 
                : new Cola.AST_String({ value: def.name.property }), 
            new Cola.AST_Object(dp)],
        expression : new Cola.AST_Dot({
            expression : new Cola.AST_SymbolRef({ name: "Object" }),
            property   : "defineProperty"
        })
    });
};

Cola.DefFunWithMods = function(func, mods){
    if(!mods || mods.length == 0){ 
        if(func instanceof Cola.AST_Defun || func instanceof Cola.AST_Function)
            return new Cola.AST_Assign({
                start    : func.start,
                end      : func.end,
                operator : '=',
                left     : func.name,
                right    : (function(node){
                    node.name = new Cola.AST_SymbolLambda({
                        start : node.name.start,
                        end   : node.name.end,
                        name  : node.name.property
                    });
                    return new Cola.AST_Function(node);
                })(func)
            });
        else if(func instanceof Cola.AST_Getter)
            return new Cola.AST_Call({
                expression : new Cola.AST_Dot({
                    expression : func.name instanceof Cola.AST_Proto
                        ? new Cola.AST_Dot({ expression: func.name.expression, property: "prototype" })
                        : func.name.expression,
                    property   : "__defineGetter__"
                }),
                args       : [
                    new Cola.AST_String({ value: func.name.property}),
                    (function(node){
                        node.name = new Cola.AST_SymbolLambda({
                            start : node.name.start,
                            end   : node.name.end,
                            name  : node.name.property
                        });
                        return new Cola.AST_Function(node);
                    })(func)
                ],
            });
        else if(func instanceof Cola.AST_Setter)
            return new Cola.AST_Call({
                expression : new Cola.AST_Dot({
                    expression : func.name instanceof Cola.AST_Proto
                        ? new Cola.AST_Dot({ expression: func.name.expression, property: "prototype" })
                        : func.name.expression,
                    property   : "__defineSetter__"
                }),
                args       : [
                    new Cola.AST_String({ value: func.name.property}),
                    (function(node){
                        node.name = new Cola.AST_SymbolLambda({
                            start : node.name.start,
                            end   : node.name.end,
                            name  : node.name.property
                        });
                        return new Cola.AST_Function(node);
                    })(func)
                ],
            });
    }

    if(mods.indexOf("static") != -1)
        Cola.Parser.prototype.token_error.call(Cola.Parser.prototype, func.start, "Function definition outside of class can't contain `static` modifer");

    var sname = func.name, dp = { properties : [
        new Cola.AST_ObjectKeyVal({
            key   : (function(node){
                if(node instanceof Cola.AST_Getter) return "get";
                if(node instanceof Cola.AST_Setter) return "set";
                return "value";
            })(func),
            value : (function(node){
                node.name = new Cola.AST_SymbolLambda({
                    start : node.name.start,
                    end   : node.name.end,
                    name  : node.name.property
                });
                return new Cola.AST_Function(node);
            })(func)
        })
    ] };

    if(!(sname.expression instanceof Cola.AST_Symbol && sname.expression.name == "this" || sname instanceof Cola.AST_Proto))
        dp.properties.push(new Cola.AST_ObjectKeyVal({
            key   : "configurable",
            value : new Cola.AST_True
        }));

    if(!(func instanceof Cola.AST_Getter || func instanceof Cola.AST_Setter))
        dp.properties.push(new Cola.AST_ObjectKeyVal({
            key   : "writable",
            value : new Cola.AST_True
        }));

    if(mods.indexOf("covert") == -1)
        dp.properties.push(new Cola.AST_ObjectKeyVal({
            key   : "enumerable",
            value : new Cola.AST_True
        }));
    
    return new Cola.AST_Call({
        args       : [
            sname instanceof Cola.AST_Proto
                ? new Cola.AST_Dot({ expression: sname.expression, property: "prototype" })
                : sname.expression, 
            sname instanceof Cola.AST_Sub
                ? sname.property 
                : new Cola.AST_String({ value: sname.property }), 
            new Cola.AST_Object(dp)],
        expression : func instanceof Cola.AST_Getter || func instanceof Cola.AST_Setter
            ? new Cola.AST_SymbolRef({ name: "_ColaRuntime$$updateProperty" })
            : new Cola.AST_Dot({
                expression : new Cola.AST_SymbolRef({ name: "Object" }),
                property   : "defineProperty"
            })
    });
};


Cola.AST_Toplevel.prototype.toJavaScript = function(options){
    if(this.language == 'js') return this;
    this.language = 'js';

    options = Cola.defaults(options, {
        main_binding : true,
        main_event   : 'DOMContentLoaded',
        parser       : {},
        std          : true,
        path         : ""
    });

    var _ColaRuntime$$ast = Cola.parse(Cola.$_cola, { is_js : true }), 
        _ColaRuntime$$hash = {}, 

        _this,

        required = [], required_hash = {},

    tt = new Cola.TreeTransformer(function(node, descend, in_list){
        var newNode, props = {}, parent = this.parent();
        node = node.clone();

        /*
            main(){
                console.log("hello world");
            }

            to

            window.addEventListener('DOMContentLoaded',
            function main(){
                console.log("hello world");
            }, false);

        */
        if(options.main_binding && parent instanceof Cola.AST_Toplevel && node instanceof Cola.AST_Defun && node.name instanceof Cola.AST_SymbolDefun && node.name.name == "main"){
            node.name = new Cola.AST_SymbolLambda(node.name);
            node = new Cola.AST_Function(node);

            props = {
                args       : [new Cola.AST_String({ value : options.main_event }), node, new Cola.AST_False()],
                expression : new Cola.AST_Dot({
                    property   : 'addEventListener',
                    expression : new Cola.AST_SymbolRef({ name : 'window' })
                })
            };
            
            node = new Cola.AST_SimpleStatement({
                start : node.start,
                end   : node.left,
                body  : new Cola.AST_Call(props)
            });
        } else

        /*
            5 ** 2

            to

            Math.pow(5, 2)
            
        */
        if(node instanceof Cola.AST_Binary && node.operator == '**'){
            props = {
                start      : node.start,
                end        : node.left,
                args       : [node.left, node.right],
                expression : new Cola.AST_Dot({
                    property   : 'pow',
                    expression : new Cola.AST_SymbolRef({ name : 'Math' })
                })
            };

            node = new Cola.AST_Call(props);
        } else 

        /*
            5 %% 2

            to

            _ColaRuntime$$modulo(5, 2)
            
        */
        if(node instanceof Cola.AST_Binary && node.operator == '%%'){
            _ColaRuntime$$hash[Cola._ColaRuntime$$modulo.i] = true;
            props = {
                start      : node.start,
                end        : node.end,
                args       : [node.left, node.right],
                expression : new Cola.AST_SymbolRef({ name  : '_ColaRuntime$$modulo' })
            };
    
            node = new Cola.AST_Call(props);
        } else 

        /*
            a.b?.c();

            to

            if(a.b === "undefined" && a.b === null) a.b.c();

        */
        if(node instanceof Cola.AST_SimpleStatement && (props = Cola.ContainCondAccess(node.body))){
            if(node.body instanceof Cola.AST_CondAccess) node.body = new Cola.AST_Dot(node.body);
            else {
                var expr = node.body;
                while(expr.expression instanceof Cola.AST_Call || expr.expression instanceof Cola.AST_PropAccess){
                    if(expr.expression instanceof Cola.AST_CondAccess){
                        expr.expression = new Cola.AST_Dot(expr.expression);
                        break;
                    }
                    expr = expr.expression;
                }
            }

            node = new Cola.AST_If({
                condition   : Cola.Constructions.IsntSet(props),
                body        : node
            });
        } else

        /*
            alert(a.b?.c());

            to

            alert(typeof a.b === "undefined" && a.b === null ? undefined : a.b.c());

        */
        if(props = Cola.ContainCondAccess(node)){
            if(node instanceof Cola.AST_CondAccess) node = new Cola.AST_Dot(node);
            else {
                var expr = node;
                while(expr.expression instanceof Cola.AST_Call || expr.expression instanceof Cola.AST_PropAccess){
                    if(expr.expression instanceof Cola.AST_CondAccess){
                        expr.expression = new Cola.AST_Dot(expr.expression);
                        break;
                    }
                    expr = expr.expression;
                }
            }

            node = new Cola.AST_Conditional({
                condition   : Cola.Constructions.IsntSet(props),
                consequent  : new Cola.AST_Undefined,
                alternative : node
            });
        } else

        /*
            a.b?.c = 123;

            to

            if(a.b === "undefined" && a.b === null) a.b.c = 123;

        */
        if(node instanceof Cola.AST_SimpleStatement && node.body instanceof Cola.AST_Assign && (props = Cola.ContainCondAccess(node.body.left))){
            if(node.body.left instanceof Cola.AST_CondAccess) node.body.left = new Cola.AST_Dot(node.body.left);
            else {
                var expr = node.body.left;
                while(expr.expression instanceof Cola.AST_Call || expr.expression instanceof Cola.AST_PropAccess){
                    if(expr.expression instanceof Cola.AST_CondAccess){
                        expr.expression = new Cola.AST_Dot(expr.expression);
                        break;
                    }
                    expr = expr.expression;
                }
            }

            node = new Cola.AST_If({
                condition   : Cola.Constructions.IsntSet(props),
                body        : node
            });
        } else

        /*
            alert(a.b?.c = 123);

            to

            alert(typeof a.b === "undefined" && a.b === null ? undefined : a.b?.c = 123);

        */
        if(node instanceof Cola.AST_Assign && (props = Cola.ContainCondAccess(node.left))){
            if(node.left instanceof Cola.AST_CondAccess) node.left = new Cola.AST_Dot(node.left);
            else {
                var expr = node.left;
                while(expr.expression instanceof Cola.AST_Call || expr.expression instanceof Cola.AST_PropAccess){
                    if(expr.expression instanceof Cola.AST_CondAccess){
                        expr.expression = new Cola.AST_Dot(expr.expression);
                        break;
                    }
                    expr = expr.expression;
                }
            }

            node = new Cola.AST_Conditional({
                condition   : Cola.Constructions.IsntSet(props),
                consequent  : new Cola.AST_Undefined,
                alternative : node
            });
        } else

        /*
            a ?= b;

            to

            if(typeof a === "undefined" || a === null) a = b;
            
        */
        if(node instanceof Cola.AST_SimpleStatement && node.body instanceof Cola.AST_Assign && node.body.operator == '?='){
            if(node.body.left instanceof Cola.AST_Sub && node.body.left.property instanceof Cola.AST_Noop){
                props = {
                    property   : "length",
                    expression : node.body.left.expression
                };
                props = {
                    operator : "-",
                    left     : new Cola.AST_Dot(props),
                    right    : new Cola.AST_Number({ value : 1 })
                };

                node.body.left.property = new Cola.AST_Binary(props);
            }

            node.body.operator = '=';
            node = new Cola.AST_If({
                start     : node.start,
                end       : node.end,
                body      : node.clone(),
                condition : Cola.Constructions.IsntSet(node.body.left)
            });
        } else 

        /*
            func(a ?= b);

            to

            func(typeof a === "undefined" || a === null ? a = b : a);
            
        */
        if(node instanceof Cola.AST_Assign && node.operator == '?='){
            if(node.left instanceof Cola.AST_Sub && node.left.property instanceof Cola.AST_Noop){
                props = {
                    property   : "length",
                    expression : node.left.expression
                };
                props = {
                    operator : "-",
                    left     : new Cola.AST_Dot(props),
                    right    : new Cola.AST_Number({ value : 1})
                };

                node.left.property = new Cola.AST_Binary(props);
            }

            node.operator = '=';
            node = new Cola.AST_Conditional({
                start       : node.start,
                end         : node.end,
                condition   : Cola.Constructions.IsntSet(node.left),
                consequent  : node.clone(),
                alternative : node.left
            });
        } else 

        /*
            a ? b

            to

            !(typeof a === "undefined" || a === null) ? a : b
            
        */
        if(node instanceof Cola.AST_Conditional && node.alternative instanceof Cola.AST_Noop){
            node.alternative = node.consequent;
            node.consequent = node.condition;
            node.condition = Cola.Constructions.IsSet(node.condition);
        } else 

        /*
            123 is NaN

            to

            isNaN(123)
            
        */
        if(node instanceof Cola.AST_Binary && node.operator == 'is' && node.right instanceof Cola.AST_SymbolRef && node.right.name == "NaN"){
            props = {
                start      : node.start,
                end        : node.end,
                args       : [node.left],
                expression : new Cola.AST_SymbolRef({ name : 'isNaN' })
            };

            node = new Cola.AST_Call(props);
        } else 

        /*
            123 isnt NaN

            to

            !isNaN(123)
            
        */
        if(node instanceof Cola.AST_Binary && node.operator == 'isnt' && node.right instanceof Cola.AST_SymbolRef && node.right.name == "NaN"){
            props = {
                args       : [node.left],
                expression : new Cola.AST_SymbolRef({ name : 'isNaN' })
            };
            props = {
                start      : node.start,
                end        : node.end,
                operator   : '!',
                expression : new Cola.AST_Call(props)
            };

            node = new Cola.AST_UnaryPrefix(props);
        } else 

        /*
            123 is Number

            to

            123 === Number || Number.prototype && (123 instanceof Number || typeof 123 === typeof Number()))
            
        */
        if(node instanceof Cola.AST_Binary && node.operator == 'is'){
            node = Cola.Constructions.Is(node.left, node.right, node);
        } else 

        /*
            true isnt String

            to

            !(true === String || String.prototype && (true instanceof String || typeof true === typeof String())))
            
        */
        if(node instanceof Cola.AST_Binary && node.operator == 'isnt'){
            node = Cola.Constructions.Isnt(node.left, node.right, node);
        } else 

        /*
            a?

            to

            _ColaRuntime$$isset(a)
            
        */
        if(node instanceof Cola.AST_UnaryPostfix && node.operator == '?'){
            node = Cola.Constructions.IsSet(node.expression, node);
        } else 

        /*
            a = clone b

            to

            a = _ColaRuntime$$clone(b)
            
        */
        if(node instanceof Cola.AST_UnaryPrefix && node.operator == 'clone'){
            _ColaRuntime$$hash[Cola._ColaRuntime$$clone.i] = true;
            props = {
                start      : node.start,
                end        : node.end,
                args       : [node.expression],
                expression : new Cola.AST_SymbolRef({ name : '_ColaRuntime$$clone' })
            };

            node = new Cola.AST_Call(props);
        } else

        /*
            arr[] = 123

            to

            arr.push(123)
            
        */
        if(node instanceof Cola.AST_Assign && node.operator == "=" && node.left instanceof Cola.AST_Sub && node.left.property instanceof Cola.AST_Noop){
            props = {
                property   : "push",
                expression : node.left.expression
            };
            props = {
                start      : node.start,
                end        : node.end,
                args       : [node.right],
                expression : new Cola.AST_Dot(props)
            };

            node = new Cola.AST_Call(props);
        } else

        /*
            arr[] /= 2

            to

            arr[arr.length - 1] /= 2
            
        */
        if(node instanceof Cola.AST_Assign && node.operator != "=" && node.left instanceof Cola.AST_Sub && node.left.property instanceof Cola.AST_Noop){
            props = {
                property   : "length",
                expression : node.left.expression
            };
            props = {
                operator : "-",
                left     : new Cola.AST_Dot(props),
                right    : new Cola.AST_Number({ value : 1})
            };

            node.left.property = new Cola.AST_Binary(props);
        } else

        /*
            func(arr[])

            to

            func(_ColaRuntime$$array_last(arr))
            
        */
        if(node instanceof Cola.AST_Sub && node.property instanceof Cola.AST_Noop){
            _ColaRuntime$$hash[Cola._ColaRuntime$$array_last.i] = true;
            props = {
                start      : node.start, 
                end        : node.end, 
                args       : [node.expression],
                expression : new Cola.AST_SymbolRef({ name  : '_ColaRuntime$$array_last' })
            };

            node = new Cola.AST_Call(props);
        } else

        /*
            arr[-1]

            to

            arr[_ColaRuntime$$array_negate_access(arr, -1)]

        */
        if(node instanceof Cola.AST_Sub && node.property instanceof Cola.AST_UnaryPrefix && node.property.operator == "-" && node.property.expression instanceof Cola.AST_Number){
            _ColaRuntime$$hash[Cola._ColaRuntime$$array_negate_access.i] = true;
            node.property = new Cola.AST_Call({ 
                args       : [node.expression, node.property],
                expression : new Cola.AST_SymbolRef({ name  : '_ColaRuntime$$array_negate_access' })
            });
        } else

        /*
            arr[%index]

            to

            arr[_ColaRuntime$$array_modulo_access(arr, index)]

        */
        if(node instanceof Cola.AST_Sub && node.property instanceof Cola.AST_UnaryPrefix && node.property.operator == "%"){
            _ColaRuntime$$hash[Cola._ColaRuntime$$array_modulo_access.i] = true;
            node.property = new Cola.AST_Call({ 
                args       : [node.expression, node.property.expression],
                expression : new Cola.AST_SymbolRef({ name  : '_ColaRuntime$$array_modulo_access' })
            });
        } else

        /*
            arr[0..1] = 123

            to

            _ColaRuntime$$array_asplice(arr, 0, 1, 123)
            
        */
        if(node instanceof Cola.AST_Assign && node.operator == '=' && node.left instanceof Cola.AST_Sub && node.left.property instanceof Cola.AST_ArrayRange){
            _ColaRuntime$$hash[Cola._ColaRuntime$$array_asplice.i] = true;
            props = {
                start      : node.start,
                end        : node.end, 
                args       : [node.left.expression, node.left.property.from, node.left.property.to, node.right],
                expression : new Cola.AST_SymbolRef({ name  : '_ColaRuntime$$array_asplice' })
            };

            if(node.left.property.to instanceof Cola.AST_Noop) props.args[2] = new Cola.AST_Number({ value : '9e9' });
            else if(node.left.property.triple) props.args[2] = new Cola.AST_Binary({
                operator : "-",
                left     : node.left.property.to,
                right    : new Cola.AST_Number({ value : 1 })
            });

            node = new Cola.AST_Call(props);
        } else

        /*
            func(arr[0..1])

            to

            func(arr.slice(0, 1 + 1))
            
        */
        if(node instanceof Cola.AST_Sub && node.property instanceof Cola.AST_ArrayRange){
            props = {
                property   : "slice",
                expression : node.expression
            };
            props = {
                start      : node.start,
                end        : node.end,
                args       : [node.property.from],
                expression : new Cola.AST_Dot(props)
            };

            if(!node.property.triple && !(node.property.to instanceof Cola.AST_Noop)) props.args[1] = new Cola.AST_Binary({
                operator : "+",
                left     : node.property.to,
                right    : new Cola.AST_Number({ value : 1 })
            }); else 
            if(!(node.property.to instanceof Cola.AST_Noop))  props.args[1] = node.property.to;


            node = new Cola.AST_Call(props);
        } else

        /*
            [0..3]

            to

            _ColaRuntime$$array_range(0, 3)
            
        */
        if(node instanceof Cola.AST_ArrayRange){
            _ColaRuntime$$hash[Cola._ColaRuntime$$array_range.i] = true;
            props = {
                start      : node.start,
                end        : node.end,
                args       : [node.from, node.to],
                expression : new Cola.AST_SymbolRef({ name : '_ColaRuntime$$array_range' })
            };

            if(node.triple) props.args[1] = new Cola.AST_Binary({
                operator : "-",
                left     : node.to,
                right    : new Cola.AST_Number({ value : 1 })
            });

            node = new Cola.AST_Call(props);
        } else

        /*
            const int num = 1, obj.num = 0;

            to

            const num - 1;
            Object.defineProperty(obj, "num", { value: 0, enumerable: true });
            
        */
        if(node instanceof Cola.AST_Var){
            var defCache = []; newNode = [];
            node.definitions.forEach(function(def, i){
                if(def.name instanceof Cola.AST_SymbolVar){
                    if(node.mods && node.mods.indexOf("const") != -1 && !def.value)
                        Cola.Parser.prototype.token_error.call(Cola.Parser.prototype, def.start, "`const` var can't have `undefined` value");

                    defCache.push(def);
                } else if(def.value){ 

                    if(defCache.length != 0){
                        if(!node.mods || node.mods.length == 0 || node.mods.indexOf("const") != -1 && node.mods.length == 1){
                            newNode.push(node.mods.length == 1 ? new Cola.AST_Const(node) : node.clone());
                            newNode[newNode.length - 1].definitions = defCache.map(function(def){
                                def.name = new Cola.AST_SymbolConst(def.name);
                                return def;
                            });
                            defCache = [];
                        } else 
                            Cola.Parser.prototype.token_error.call(Cola.Parser.prototype, node.start, "Var definition can contain only `const` modifer");
                    }

                    var texpr = def.name;
                    while(!(texpr.expression instanceof Cola.AST_Symbol || texpr.expression instanceof Cola.AST_Constant)) texpr = texpr.expression;
                    texpr.expression = new Cola.AST_SymbolRef(texpr.expression);

                    newNode.push(Cola.DefPropWithMods(def, node.mods));
                    newNode[newNode.length - 1] = new Cola.AST_SimpleStatement({
                        body  : newNode[newNode.length - 1]
                    });

                }
            });

            if(defCache.length != 0){
                if(!node.mods || node.mods.length == 0 || node.mods.indexOf("const") != -1 && node.mods.length == 1){
                    newNode.push(node.mods && node.mods.length == 1 ? new Cola.AST_Const(node) : node.clone());
                    newNode[newNode.length - 1].definitions = defCache.map(function(def){
                        def.name = new Cola.AST_SymbolConst(def.name);
                        return def;
                    });
                    defCache = [];
                } else 
                    Cola.Parser.prototype.token_error.call(Cola.Parser.prototype, node.start, "Var definition can contain only `const` modifer");
                    
            }

            node = newNode;
        } else

        /*
            int Math.rand(){} or Math.rand(){}

            to

            Math.rand = function rand(){}
        */
        if((node instanceof Cola.AST_Defun || node instanceof Cola.AST_Function || node instanceof Cola.AST_Setter || node instanceof Cola.AST_Getter) 
            && node.name && !(node.name instanceof Cola.AST_SymbolDefun) && !(node.name instanceof Cola.AST_SymbolLambda)){
            var texpr = node.name, notst = node instanceof Cola.AST_Function;
            while(!(texpr.expression instanceof Cola.AST_Symbol || texpr.expression instanceof Cola.AST_Constant)) texpr = texpr.expression;
            texpr.expression = new Cola.AST_SymbolRef(texpr.expression);

            node = Cola.DefFunWithMods(node, node.mods);

            if(node instanceof Cola.AST_Call && node.expression instanceof Cola.AST_SymbolRef && node.expression.name == "_ColaRuntime$$updateProperty") _ColaRuntime$$hash[Cola._ColaRuntime$$updateProperty.i] = true;

            if(!notst) node = new Cola.AST_SimpleStatement({
                body : node
            });
        } else

        /*
            func(a, b, name : name, c)

            to

            func(a, b, c, new _ColaRuntime$$func_named_args({ name : name }))
            
        */
        if(node instanceof Cola.AST_Call){
            props = { properties : [] };
            
            var delQueue = [];
            node.args.forEach(function(val, i){
                if(!(val instanceof Cola.AST_Namedarg)) return;

                _ColaRuntime$$hash[Cola._ColaRuntime$$func_named_args.i] = true;
                delQueue.push(i);

                props.properties.push(new Cola.AST_ObjectKeyVal({
                    start : val.start,
                    end   : val.end,
                    key   : val.name,
                    value : val.value
                }));
            });

            if(delQueue.length != 0){
                delQueue.reverse().forEach(function(val){
                    node.args.splice(val, 1);
                });

                props = {
                    start      : node.start, 
                    end        : node.end, 
                    args       : [new Cola.AST_Object(props)],
                    expression : new Cola.AST_SymbolRef({ name : '_ColaRuntime$$func_named_args' })
                };

                node.args.push(new Cola.AST_New(props));
            }
        } else

        /*
            class Test extends ParentTest {
        
                const int i = 123;

                Test(){ // constructor
                    super();
                }

                Test.Test2(){ // named constructor
                    super.Test2();
                }

                queryAll("ul li a").forEach((el) => 
                    el.onclick = () => console.log("click")
                );

                covert String method1() => console.log("method");

                get getter() => i;
                set setter(int val) => console.log(val); 

                superExample(){
                    super.superExample();
                }

                selfExample(){
                    query("*").onclick = () => console.log(self);
                }

            }

            to

            Test(){
                this.pre_constructor();

                this.super.constructor.call(this);

                this.post_constructor();
            }
            Test.prototype = _ColaRuntime$$proto(ParentTest);

            Test::Test2 = Test.Test2(){
                this.pre_constructor();

                this.super.Test2.call(this);
        
                this.post_constructor();
            };
            Test.Test2.prototype = Test.prototype;

            Test::pre_constructor(){
                this.super = ParentTest.prototype;
                const int this.i = 123;
            }

            Test::post_constructor(){
                queryAll("ul li a").forEach((el) => 
                    el.onclick = () => console.log("click")
                );
            }

            covert String Test::method1() => console.log("method");

            get Test::getter() => i;
            set Test::setter(int val) => console.log(val); 

            Test::superExample(){
                this.super.superExample.call(this);
            }

            Test::selfExample(){
                var self = this;
                query("*").onclick = () => console.log(self);
            }

        */

        /*
            func(String s, Number n:, Array list..., Boolean b = false, h: 123){
                
            }

            to

            function func(s){
                _ColaRuntime$$func_set_named_args(arguments);
                var _ColaRuntime$$i, list = 3 <= arguments.length ? [].slice.call(arguments, 1, _ColaRuntime$$i = arguments.length - 1) : (_ColaRuntime$$i = 2, []), 
                    b = arguments[_ColaRuntime$$i+0] !== undefined ? arguments[_ColaRuntime$$i+0] : false,
                    n = arguments.n,
                    h = arguments.h !== undefined ? arguments.h : 123;
            }
            
        */
        if((node instanceof Cola.AST_Function || node instanceof Cola.AST_Defun) && node.argnames.length != 0){
            var posed = [], named = [], onfront = true, delQueue = [], pos = 0, splated, aftersplated = -1;

            if(node.mods && node.mods.length != 0)
                Cola.Parser.prototype.token_error.call(Cola.Parser.prototype, node.start, "Function definition outside of class can't contain any modifer");

            node.argnames.forEach(function(val, i){
                if(val.argtype == "positional"){
                    if(val.defval instanceof Cola.AST_Noop && onfront && !val.required) pos++, node.argnames[i] = val.name;
                    else {
                        onfront = false;
                        delQueue.push(i);
                        posed.push({ pos : pos++, val : val });
                    }
                    splated && splated.after++;
                } else if(val.argtype == "named"){
                    delQueue.push(i);
                    named.push(val);
                } else if(val.argtype == "splated"){
                    onfront = false;
                    delQueue.push(i);
                    posed.push(splated = { pos : pos++, after : 0, val : val });
                }
            });
            
            if(delQueue.length != 0)
                delQueue.reverse().forEach(function(val){
                    node.argnames.splice(val, 1);
                });

            props = {
                type        : "dynamic",
                definitions : []
            };

            posed.forEach(function(val, i){
                var pos = val.pos; val = val.val;
                
                if(val.argtype == "splated"){
                    aftersplated = 0;
                    props.definitions.push(new Cola.AST_VarDef({
                        type  : "int",
                        name  : new Cola.AST_SymbolVar({ name : '_ColaRuntime$$i' }),
                        value : null
                    }));

                    props.definitions.push(Cola.Constructions.SplatedVarDef(splated.val.name, splated.pos, splated.after, splated.pos + splated.after + 1));
                }
                else

                if(val.defval instanceof Cola.AST_Noop && !val.required) 
                    props.definitions.push(Cola.Constructions.PosedVarDef(val.name, val.type, pos, aftersplated++));
                else if(val.defval instanceof Cola.AST_Noop && val.required){ 
                    _ColaRuntime$$hash[Cola._ColaRuntime$$error.i] = true;
                    props.definitions.push(Cola.Constructions.PosedWithDefsVarDef(val.name, val.type, new Cola.AST_Call({
                        args       : [new Cola.AST_String({ value : "Argument `" + val.name.name + "` is required!" })],
                        expression : new Cola.AST_SymbolRef({ name : '_ColaRuntime$$error' })
                    }), pos, aftersplated++));
                } else 
                    props.definitions.push(Cola.Constructions.PosedWithDefsVarDef(val.name, val.type, val.defval, pos, aftersplated++));
            });

            named.forEach(function(val, i){
                if(val.defval instanceof Cola.AST_Noop && !val.required) props.definitions.push(new Cola.AST_VarDef({
                    type  : val.type,
                    name  : new Cola.AST_SymbolVar(val.name),
                    value : new Cola.AST_Dot({
                        expression : new Cola.AST_SymbolRef({ name : 'arguments' }),
                        property   : val.name.name
                    })
                })); 
                else if(val.defval instanceof Cola.AST_Noop && val.required){
                    _ColaRuntime$$hash[Cola._ColaRuntime$$error.i] = true;
                    props.definitions.push(Cola.Constructions.NamedVarDef(val.name, val.type, new Cola.AST_Call({
                        args       : [new Cola.AST_String({ value : "Argument `" + val.name.name + "` is required!" })],
                        expression : new Cola.AST_SymbolRef({ name : '_ColaRuntime$$error' })
                    }), val.name.name));
                } else 
                    props.definitions.push(Cola.Constructions.NamedVarDef(val.name, val.type, val.defval, val.name.name));
            });

            if(delQueue.length != 0 || named.length != 0) node.body.unshift(new Cola.AST_Var(props));

            if(named.length != 0){
                _ColaRuntime$$hash[Cola._ColaRuntime$$func_named_args.i] = true;
                _ColaRuntime$$hash[Cola._ColaRuntime$$func_set_named_args.i] = true;
                node.body.unshift(new Cola.AST_SimpleStatement({
                    body : new Cola.AST_Call({
                        args       : [new Cola.AST_SymbolRef({ name : 'arguments' })],
                        expression : new Cola.AST_SymbolRef({ name : '_ColaRuntime$$func_set_named_args' })
                    })
                }));
            }
        } else

        /*
            obj
                ..[0] = yes
                ..foo = bar
                ..baz()
                ..sub:
                    ..subfoo = no
                    ..subaz();
                ;

            to
            
            (function(_ColaRuntime$$expr, arguments){
                _ColaRuntime$$expr[0] = yes;
                _ColaRuntime$$expr.foo = bar;
                _ColaRuntime$$expr.baz();

                (function(_ColaRuntime$$expr, arguments){
                    _ColaRuntime$$expr.subfoo = no;
                    _ColaRuntime$$expr.subaz();

                    return _ColaRuntime$$expr;
                }).call(this, _ColaRuntime$$expr.sub, arguments);

                return _ColaRuntime$$expr;
            }).call(this, obj, arguments);

        */
        if(node instanceof Cola.AST_Cascade){
            _ColaRuntime$$hash[Cola._ColaRuntime$$arguments_def.i] = true;

            props = {
                type       : "dynamic",
                body       : [],
                argnames   : [new Cola.AST_ArgDef({
                    argtype : "positional",
                    type    : "dynamic",
                    defval  : new Cola.AST_Noop(),
                    name    : new Cola.AST_SymbolFunarg({ name : "_ColaRuntime$$expr", start : node.expression.start, end : node.expression.end })
                }), new Cola.AST_ArgDef({
                    argtype : "positional",
                    type    : "dynamic",
                    defval  : new Cola.AST_Noop(),
                    name    : new Cola.AST_SymbolFunarg({ name : "arguments", start : new Cola.AST_Token(), end : new Cola.AST_Token() })
                })] 
            };

            var Expr, Parent = false; 
            node.subexpressions.forEach(function(expr){
                Expr = expr, Parent = false;
                while(true)
                    if( expr instanceof Cola.AST_Call || expr instanceof Cola.AST_PropAccess){
                        Parent = expr;
                        expr = expr.expression;
                    } else 
                    if(expr instanceof Cola.AST_Binary){
                        Parent = expr;
                        expr = expr.left;
                    } else 
                    if(expr instanceof Cola.AST_Array || expr instanceof Cola.AST_ArrayRange || expr instanceof Cola.AST_SymbolRef) break;

                if(!Parent){
                    if(expr instanceof Cola.AST_Array || expr instanceof Cola.AST_ArrayRange) Expr = new Cola.AST_Sub({
                        start      : Expr.start,
                        end        : Expr.end,
                        expression : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$expr" }),
                        property   : expr instanceof Cola.AST_ArrayRange ? expr : ( expr.elements.length == 0 ? new Cola.AST_Noop() : expr.elements[0] )
                    }); else
                    if(expr instanceof Cola.AST_SymbolRef) Expr = new Cola.AST_Dot({
                        start      : Expr.start,
                        end        : Expr.end,
                        expression : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$expr" }),
                        property   : Expr.name
                    });
                } else {
                    if(expr instanceof Cola.AST_Array || expr instanceof Cola.AST_ArrayRange)
                        expr = new Cola.AST_Sub({
                            start      : expr.start,
                            end        : expr.end,
                            expression : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$expr" }),
                            property   : expr instanceof Cola.AST_ArrayRange ? expr : ( expr.elements.length == 0 ? new Cola.AST_Noop() : expr.elements[0] )
                        });
                    else
                        expr = new Cola.AST_Dot({
                            start      : expr.start,
                            end        : expr.end,
                            expression : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$expr" }),
                            property   : expr.name
                        });

                    if( Parent instanceof Cola.AST_Call || Parent instanceof Cola.AST_PropAccess) Parent.expression = expr;
                    else 
                    if(Parent instanceof Cola.AST_Binary) Parent.left = expr;
                }

                props.body.push(new Cola.AST_SimpleStatement({
                    start : Expr.start,
                    end   : Expr.end,
                    body  : Expr
                }));
            });

            props.body.push(new Cola.AST_Return({
                value : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$expr" })
            }));

            props = {
                expression : new Cola.AST_Function(props),
                property   : "call"
            };
        
            node = new Cola.AST_Call({
                start      : node.start,
                end        : node.end,
                args       : [new Cola.AST_SymbolRef({ name : "this" }), node.expression, new Cola.AST_SymbolRef({ name : "arguments" })],
                expression : new Cola.AST_Dot(props)
            });    
        } else 

        /*
            var [c, [b, b2], ..., { key : a }] = obj;
            var { "key" : d } = { key : "val" };

            to

            var c = obj[0], b = obj[1][0], b2 = obj[1][1], _ColaRuntime$$i = obj.length - 1, a = obj[_ColaRuntime$$i++].key;
            var _ColaRuntime$$tmp = { key : "val" }, d = _ColaRuntime$$tmp["key"];

        */
        /*if(node instanceof Cola.AST_Var){
            var defs = [];
            node.definitions.forEach(function(def, i){
                if(!(def.name instanceof Cola.AST_ArrayTemplate || def.name instanceof Cola.AST_ObjectTemplate)){
                    defs.push(def);
                    return;
                }

                var Symbol = def.value instanceof Cola.AST_SymbolRef 
                    ? def.value 
                    : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$tmp" });
                if(!(def.value instanceof Cola.AST_SymbolRef)) defs.push(new Cola.AST_VarDef({
                    type  : node.type,
                    name  : new Cola.AST_SymbolVar(Symbol),
                    value : def.value
                }));

                (function _rec(def, symbol, uid){
                    var skiped = false, k = 0, is_arrayt = def instanceof Cola.AST_ArrayTemplate, _ = is_arrayt ? def.elements : def.properties;
                    _.forEach( is_arrayt 
                        ? function(el, j){
                            if(el instanceof Cola.AST_SymbolRef && el.splated){
                                skiped = true;
                                defs.push(new Cola.AST_VarDef({
                                    type  : "int",
                                    name  : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                    value : null
                                }));
                                el.splated = undefined;
                                defs.push(new Cola.AST_VarDef({
                                    name  : new Cola.AST_SymbolVar(el),
                                    value : new Cola.AST_Conditional({
                                        condition   : new Cola.AST_Binary({
                                            operator  : "<=",
                                            left      : new Cola.AST_Number({ value : _.length }),
                                            right     : new Cola.AST_Dot({
                                                expression : symbol,
                                                property   : "length"
                                            })
                                        }),
                                        consequent  : new Cola.AST_Call({
                                            expression  : new Cola.AST_Dot({ 
                                                property   : "call",
                                                expression : new Cola.AST_Dot({
                                                    property   : "slice",
                                                    expression : new Cola.AST_Array({ elements : [] })
                                                })
                                            }),
                                            args        : [
                                                symbol, 
                                                new Cola.AST_Number({ value : j }),
                                                new Cola.AST_Assign({
                                                    operator : '=',
                                                    left     : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                                    right    : new Cola.AST_Binary({
                                                        operator : '-',
                                                        left     : new Cola.AST_Dot({
                                                            property   : "length",
                                                            expression : symbol
                                                        }),
                                                        right    : new Cola.AST_Number({ value : _.length - j - 1 })
                                                    })
                                                })
                                            ]
                                        }),
                                        alternative : new Cola.AST_Seq({
                                            car : new Cola.AST_Assign({
                                                operator : '=',
                                                left     : new Cola.AST_SymbolRef({ name : "$_cola" + uid + "i" }),
                                                right    : new Cola.AST_Number({ value : j })
                                            }),
                                            cdr : new Cola.AST_Array({ elements : [] })
                                        })
                                    })
                                }));
                            } else
                            if(el instanceof Cola.AST_SymbolRef) defs.push(new Cola.AST_VarDef({
                                start : node.start,
                                end   : node.end,
                                type  : node.type,
                                name  : new Cola.AST_SymbolVar(el),
                                value : new Cola.AST_Sub({ 
                                    expression : symbol, 
                                    property   : !skiped 
                                        ? new Cola.AST_Number({ value : j }) 
                                        : new Cola.AST_Binary({
                                            operator : "+",
                                            left     : new Cola.AST_SymbolRef({ name : "$_cola" + uid + "i" }),
                                            right    : new Cola.AST_Number({ value : k++ })
                                        })
                                })
                            })); else 
                            if(el instanceof Cola.AST_Noop){
                                skiped = true;
                                defs.push(new Cola.AST_VarDef({
                                    type  : "int",
                                    name  : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                    value : new Cola.AST_Binary({
                                        operator : '-',
                                        left     : new Cola.AST_Dot({
                                            property   : "length",
                                            expression : symbol
                                        }),
                                        right    : new Cola.AST_Number({ value : _.length -1 - j })
                                    })
                                }));
                            } else 
                            if(el instanceof Cola.AST_Hole || el instanceof Cola.AST_ArrayTemplate && el.elements.length == 0 || el instanceof Cola.AST_ObjectTemplate && el.properties.length == 0)
                                k++;
                            else
                            _rec(el,  new Cola.AST_Sub({ 
                                expression : symbol, 
                                property   : !skiped 
                                    ? new Cola.AST_Number({ value : j }) 
                                    : new Cola.AST_Binary({
                                        operator : "+",
                                        left     : new Cola.AST_SymbolRef({ name : "$_cola" + uid + "i" }),
                                        right    : new Cola.AST_Number({ value : k++ })
                                    })
                            }), uid + "_");
                        }
                        : function(el, j){
                            if(el.value instanceof Cola.AST_SymbolRef || el.value instanceof Cola.AST_Noop && el.start.type == "name") defs.push(new Cola.AST_VarDef({
                                start : node.start,
                                end   : node.end,
                                type  : node.type,
                                name  : el.value instanceof Cola.AST_Noop ? new Cola.AST_SymbolVar({ name : el.key }) : new Cola.AST_SymbolVar(el.value),
                                value : el.start.type == "name"
                                    ? new Cola.AST_Dot({ 
                                        expression : symbol, 
                                        property   : el.key
                                    })
                                    : new Cola.AST_Sub({
                                        expression : symbol,
                                        property   : new Cola.AST_String({ value : el.key })
                                    })
                            })); else 
                            _rec(el.value,  el.start.type == "name"
                                ? new Cola.AST_Dot({ 
                                    expression : symbol, 
                                    property   : el.key
                                })
                                : new Cola.AST_Sub({
                                    expression : symbol,
                                    property   : new Cola.AST_String({ value : el.key })
                            }), uid + "_");
                        });
                })(def.name, Symbol, "_");
            });

            node.definitions = defs;
        } else*/

        /*
            { String name, age : ages.age } = pro;

            to

            var name = pro.name;
            ages.age = pro.age;

        */
        if(node.body instanceof Cola.AST_Assign && (node.body.left instanceof Cola.AST_ArrayTemplate || node.body.left instanceof Cola.AST_ObjectTemplate ||
          (node.body.left instanceof Cola.AST_Array || node.body.left instanceof Cola.AST_Object) && node.body.left.template) &&
          node instanceof Cola.AST_SimpleStatement){
            if(node.body.left.vardef && node.body.operator != "=") Cola.Parser.prototype.unexpected.call(Cola.Parser.prototype, node.body.left.start);

            node = node.body;
            var defs = [];
            
            var Symbol = node.right instanceof Cola.AST_SymbolRef 
                ? node.right
                : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$tmp" });
            if(!(node.right instanceof Cola.AST_SymbolRef)) defs.push(new Cola.AST_VarDef({
                type  : "dynamic",
                name  : new Cola.AST_SymbolVar(Symbol),
                value : node.right
            }));

            (function _rec(def, symbol, uid){
                var skiped = false, k = 0, is_arrayt = def instanceof Cola.AST_Array || def instanceof Cola.AST_ArrayTemplate, _ = is_arrayt ? def.elements : def.properties;
                _.forEach( is_arrayt 
                    ? function(el, j){
                        if(el instanceof Cola.AST_VarDef && el.name.splated){
                            skiped = true;
                            defs.push(new Cola.AST_VarDef({
                                type  : "int",
                                name  : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                value : null
                            }));
                            el.name.splated = undefined; 
                            el.value = Cola.Constructions.SplatedConditional(symbol, uid, j, _.length - j - 1, _.length);
                            defs.push(el);
                        } else
                        if((el instanceof Cola.AST_SymbolRef || el instanceof Cola.AST_PropAccess) && el.splated){
                            skiped = true;
                            defs.push(new Cola.AST_VarDef({
                                type  : "int",
                                name  : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                value : null
                            }));
                            el.splated = undefined;
                            defs.push(new Cola.AST_Assign({
                                operator : node.operator,
                                left     : el,
                                right    : Cola.Constructions.SplatedConditional(symbol, uid, j, _.length - j - 1, _.length)
                            }));
                        } else
                        if(el instanceof Cola.AST_VarDef){
                            el.value = Cola.Constructions.ValueWithOffset(symbol, uid, !skiped, j, k++);
                            defs.push(el);
                        } else 
                        if(el instanceof Cola.AST_SymbolRef || el instanceof Cola.AST_PropAccess) defs.push(new Cola.AST_Assign({
                            operator : node.operator,
                            left     : el,
                            right    : Cola.Constructions.ValueWithOffset(symbol, uid, !skiped, j, k++)
                        })); else 
                        if(el instanceof Cola.AST_Noop){
                            skiped = true;
                            defs.push(new Cola.AST_VarDef({
                                type  : "int",
                                name  : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                value : new Cola.AST_Binary({
                                    operator : '-',
                                    left     : new Cola.AST_Dot({
                                        property   : "length",
                                        expression : symbol
                                    }),
                                    right    : new Cola.AST_Number({ value : _.length -1 - j })
                                })
                            }));
                        } else 
                        if(el instanceof Cola.AST_Hole || el instanceof Cola.AST_ArrayTemplate && el.elements.length == 0 || el instanceof Cola.AST_ObjectTemplate && el.properties.length == 0)
                            k++;
                        else
                        _rec(el, Cola.Constructions.ValueWithOffset(symbol, uid, !skiped, j, k++), uid + "_");
                    }
                    : function(el, j){
                        if(el.type && (el.value instanceof Cola.AST_SymbolRef || el.value instanceof Cola.AST_Noop && el.start.type == "name")) defs.push(new Cola.AST_VarDef({
                            start : node.start,
                            end   : node.end,
                            type  : el.type,
                            name  : el.value instanceof Cola.AST_Noop ? new Cola.AST_SymbolVar({ name : el.key }) : new Cola.AST_SymbolVar(el.value),
                            value : Cola.Constructions.ValueWithKey(el.start.type == "name" || el.start.type == "keyword", symbol, el.key)
                        })); else 
                        if(el.value instanceof Cola.AST_SymbolRef  || el.value instanceof Cola.AST_PropAccess || el.value instanceof Cola.AST_Noop && el.start.type == "name") defs.push(new Cola.AST_Assign({
                            operator : node.operator,
                            left     : el.value instanceof Cola.AST_Noop ? new Cola.AST_SymbolRef({ name : el.key }) : el.value,
                            right    : Cola.Constructions.ValueWithKey(el.start.type == "name" || el.start.type == "keyword", symbol, el.key)
                        })); else 
                        _rec(el.value, Cola.Constructions.ValueWithKey(el.start.type == "name" || el.start.type == "keyword", symbol, el.key), uid + "_");
                    });
            })(node.left, Symbol, "_");

            if (defs.length == 0) return node;
            node = [];

            var sdef, sdefs = [], prev = defs[0].CTOR;
            defs.forEach(function _(def, i){
                sdef = false;
                
                if(def instanceof prev) sdefs.push(def); 
                else {
                    if(prev == Cola.AST_VarDef) sdef = new Cola.AST_Var({
                        type        : "dynamic",
                        definitions : sdefs
                    }); else if(sdefs.length == 1) sdef = sdefs[0]
                    else {
                        sdefs.reverse().forEach(function(def){
                            if(!sdef) sdef = def;
                            else sdef = new Cola.AST_Seq({
                                car : def,
                                cdr : sdef
                            });
                        });
                    }
                    
                    node.push(!(sdef instanceof Cola.AST_Var)
                        ? new Cola.AST_SimpleStatement({ body : sdef })
                        : sdef
                    );
                    prev = def.CTOR;
                    sdefs = [def];
                }

                if(i == defs.length - 1) _(false);
            });
        } else

        /*
            func({ a : aname, b : bname } = obj)

            to

            func((function(_ColaRuntime$$expr, arguments){
                aname = _ColaRuntime$$expr.a;
                bname = _ColaRuntime$$expr.b;

                return _ColaRuntime$$expr;
            }).call(this, obj, arguments))

        */
        if(node instanceof Cola.AST_Assign && (node.left instanceof Cola.AST_ArrayTemplate || node.left instanceof Cola.AST_ObjectTemplate ||
          (node.left instanceof Cola.AST_Array || node.left instanceof Cola.AST_Object) && node.left.template)){
            if(node.left.vardef) Cola.Parser.prototype.unexpected.call(Cola.Parser.prototype, node.start);
            _ColaRuntime$$hash[Cola._ColaRuntime$$arguments_def.i] = true;

            var defs = [];
            
            var Symbol = new Cola.AST_SymbolRef({ name : "_ColaRuntime$$expr" });

            (function _rec(def, symbol, uid){
                var skiped = false, k = 0, is_arrayt = def instanceof Cola.AST_Array || def instanceof Cola.AST_ArrayTemplate, _ = is_arrayt ? def.elements : def.properties;
                _.forEach( is_arrayt 
                    ? function(el, j){
                        if((el instanceof Cola.AST_SymbolRef || el instanceof Cola.AST_PropAccess) && el.splated){
                            skiped = true;
                            defs.push(new Cola.AST_VarDef({
                                type  : "int",
                                name  : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                value : null
                            }));
                            el.splated = undefined;
                            defs.push(new Cola.AST_Assign({
                                operator : node.operator,
                                left     : el,
                                right    : Cola.Constructions.SplatedConditional(symbol, uid, j, _.length - j - 1, _.length)
                            }));
                        } else
                        if(el instanceof Cola.AST_SymbolRef || el instanceof Cola.AST_PropAccess) defs.push(new Cola.AST_Assign({
                            operator : node.operator,
                            left     : el,
                            right    : Cola.Constructions.ValueWithOffset(symbol, uid, !skiped, j, k++)
                        })); else 
                        if(el instanceof Cola.AST_Noop){
                            skiped = true;
                            defs.push(new Cola.AST_VarDef({
                                type  : "int",
                                name  : new Cola.AST_SymbolVar({ name : "$_cola" + uid + "i" }),
                                value : new Cola.AST_Binary({
                                    operator : '-',
                                    left     : new Cola.AST_Dot({
                                        property   : "length",
                                        expression : symbol
                                    }),
                                    right    : new Cola.AST_Number({ value : _.length -1 - j })
                                })
                            }));
                        } else 
                        if(el instanceof Cola.AST_Hole || el instanceof Cola.AST_ArrayTemplate && el.elements.length == 0 || el instanceof Cola.AST_ObjectTemplate && el.properties.length == 0)
                            k++;
                        else
                        _rec(el, Cola.Constructions.ValueWithOffset(symbol, uid, !skiped, j, k++), uid + "_");
                    }
                    : function(el, j){
                        if(el.value instanceof Cola.AST_SymbolRef  || el.value instanceof Cola.AST_PropAccess || el.value instanceof Cola.AST_Noop && el.start.type == "name") defs.push(new Cola.AST_Assign({
                            operator : node.operator,
                            left     : el.value instanceof Cola.AST_Noop ? new Cola.AST_SymbolRef({ name : el.key }) : el.value,
                            right    : Cola.Constructions.ValueWithKey(el.start.type == "name" || el.start.type == "keyword", symbol, el.key)
                        })); else 
                        _rec(el.value, Cola.Constructions.ValueWithKey(el.start.type == "name" || el.start.type == "keyword", symbol, el.key), uid + "_");
                    });
            })(node.left, Symbol, "_");

            if (defs.length == 0) return node;
            props = {
                type       : "dynamic",
                body       : [],
                argnames   : [new Cola.AST_ArgDef({
                    argtype : "positional",
                    type    : "dynamic",
                    defval  : new Cola.AST_Noop(),
                    name    : new Cola.AST_SymbolFunarg({ name : "_ColaRuntime$$expr", start : node.right.start, end : node.right.end })
                }), new Cola.AST_ArgDef({
                    argtype : "positional",
                    type    : "dynamic",
                    defval  : new Cola.AST_Noop(),
                    name    : new Cola.AST_SymbolFunarg({ name : "arguments" })
                })] 
            };

            var sdef, sdefs = [], prev = defs[0].CTOR;
            defs.forEach(function _(def, i){
                sdef = false;
                
                if(def instanceof prev) sdefs.push(def); 
                else {
                    if(prev == Cola.AST_VarDef) sdef = new Cola.AST_Var({
                        type        : "dynamic",
                        definitions : sdefs
                    }); else if(sdefs.length == 1) sdef = sdefs[0]
                    else {
                        sdefs.reverse().forEach(function(def){
                            if(!sdef) sdef = def;
                            else sdef = new Cola.AST_Seq({
                                car : def,
                                cdr : sdef
                            });
                        });
                    }
                    
                    props.body.push(!(sdef instanceof Cola.AST_Var)
                        ? new Cola.AST_SimpleStatement({ body : sdef })
                        : sdef
                    );
                    prev = def.CTOR;
                    sdefs = [def];
                }

                if(i == defs.length - 1) _(false);
            });

            props.body.push(new Cola.AST_Return({ value : new Cola.AST_SymbolRef({ name : "_ColaRuntime$$expr" }) }));

            props = {
                expression : new Cola.AST_Function(props),
                property   : "call"
            }
        
            node = new Cola.AST_Call({
                start      : node.start,
                end        : node.end,
                args       : [new Cola.AST_SymbolRef({ name : "this" }), node.right, new Cola.AST_SymbolRef({ name : "arguments" })],
                expression : new Cola.AST_Dot(props)
            });
        } else

        /*
            var o = if(a) 'start' else 'finish'; 

            to

            var o = (function(){
                if(a) return 'start'; else return 'finish';
            }).apply(this, arguments);
            
        */
        if(node instanceof Cola.AST_If && node.inline && !(parent instanceof Cola.AST_If && parent.inline)){
            _ColaRuntime$$hash[Cola._ColaRuntime$$arguments_def.i] = true;

            var s = node;

            while (true) {
                s.inline = false;
                s.body = new Cola.AST_Return({
                    value : s.body
                });

                if (s.alternative instanceof Cola.AST_If) s = s.alternative;
                else if (s.alternative == null) break;
                else {
                    s.alternative = new Cola.AST_Return({
                        value : s.alternative
                    });
                    break;
                }
            }

            props = {
                expression : new Cola.AST_Function({
                    type       : "dynamic",
                    body       : [node],
                    argnames   : [] 
                }),
                property   : "apply"
            }
        
            node = new Cola.AST_Call({
                start      : node.start,
                end        : node.end,
                args       : [new Cola.AST_SymbolRef({ name : "this" }), new Cola.AST_SymbolRef({ name : "arguments" })],
                expression : new Cola.AST_Dot(props)
            });
        } else

        /*
            var o = switch {
                case b < 10: f(b);
            };

            to

            var o = (function(){
                switch {
                    case b < 10: return f(b);
                }
            }).apply(this, arguments);
            
        */
        if(node instanceof Cola.AST_Switch && !(parent instanceof Cola.AST_Block)){
            _ColaRuntime$$hash[Cola._ColaRuntime$$arguments_def.i] = true;

            node.body.forEach(function(branch){
                if(!branch.body.length) return;
                branch.body[0] = new Cola.AST_Return({
                    value : branch.body[0].body
                });
            });

            props = {
                expression : new Cola.AST_Function({
                    type       : "dynamic",
                    body       : [node],
                    argnames   : [] 
                }),
                property   : "apply"
            };
        
            node = new Cola.AST_Call({
                start      : node.start,
                end        : node.end,
                args       : [new Cola.AST_SymbolRef({ name : "this" }), new Cola.AST_SymbolRef({ name : "arguments" })],
                expression : new Cola.AST_Dot(props)
            });
        } else

        /*
            switch {
                when b < 10: f(b);
                case b < 15: y(b);
            }

            to

            switch (false) {
                when !(b < 10): f(b);
                case !(b < 15): y(b);
            }

        */
        if(node instanceof Cola.AST_Switch && node.expression instanceof Cola.AST_Noop){
            node.expression = new Cola.AST_False;

            node.body.forEach(function(branch){
                if(branch instanceof Cola.AST_Default) return;

                if(branch.expression instanceof Cola.AST_Seq){
                    var seq = branch.expression;

                    while(true){
                        seq.car = new Cola.AST_UnaryPrefix({
                            operator   : '!',
                            expression : seq.car
                        });
                        if(seq.cdr instanceof Cola.AST_Seq) seq = seq.cdr;
                        else {
                            seq.cdr = new Cola.AST_UnaryPrefix({
                                operator   : '!',
                                expression : seq.cdr
                            });
                            break;
                        }
                    }

                    return;
                }

                branch.expression = new Cola.AST_UnaryPrefix({
                    operator   : '!',
                    expression : branch.expression
                });
            });
        } else

        /*
            switch {
                when b < 10: f(b);
            }

            to

            switch {
                case b < 10: 
                    f(b);
                    break;
            }

        */
        if(node instanceof Cola.AST_When){
            node = new Cola.AST_Case(node);
            node.body.push(new Cola.AST_Break);
        } else 

        /*
            switch (g) {
                case 11, 22: f(g);
            }

            to

            switch (g) {
                case 11: case 22: f(g);
            }

        */
        if(node instanceof Cola.AST_SwitchBranch && !(node instanceof Cola.AST_Default) && node.expression instanceof Cola.AST_Seq){
            var branches = [], seq = node.expression;

            while(true){
                branches.push(new node.CTOR({ expression : seq.car, body : [] }));
                if(seq.cdr instanceof Cola.AST_Seq) seq = seq.cdr;
                else {
                    node.expression = seq.cdr
                    branches.push(node);
                    break;
                }
            }

            node = branches;
        } else 

        /*
            MyClass::prop = (){
    
            };

            to

            MyClass.prototype.prop = (){
    
            };

        */
        if(node instanceof Cola.AST_Proto){
            props = new Cola.AST_Dot(node);
            props.expression = new Cola.AST_Dot(node);
            props.expression.property = "prototype";
            node = props;
        } else 

        /*
            "test @a @{b} {{c}}"

            to

            "test "+a+" "+b+" "+c
            
        */
        if(node instanceof Cola.AST_StringTemplate){
            newNode = new Cola.AST_Binary({
                operator : '+',
                left     : node.body[0],
                right    : node.body[1]
            });
            for(var i = 2; i < node.body.length; i++)
                newNode = new Cola.AST_Binary({
                    operator : '+',
                    left     : newNode,
                    right    : node.body[i]
                });

            newNode.start = node.start;
            newNode.end   = node.end;

            node = newNode;
        } else 

        /*
            /
                ([\w-\.]+)
                @
                ((?:[\w]+\.)+)
                ([a-zA-Z]{2,4})
            /

            to

            /([\w-\.]+)@((?:[\w]+\.)+)([a-zA-Z]{2,4})/
            
        */
        if(node instanceof Cola.AST_RegExp && (node.value.indexOf('\n') != -1 || /\/[\w]*x[\w]*$/.test(node.value))){
            node.value = node.value.replace(/[\r\n\s]/g,'').replace(/(\/[\w]*)x([\w]*$)/, '$1$2');
        } else 

        if(node instanceof Cola.AST_Command && node.name == "include"){
            var included = [];

            node.args.forEach(function(file){

                options.parser.is_js = /\.js$/.test(file);
                options.parser.filename = Cola.notRoot(file) ? options.path + "/" + file : file;

                var tl = Cola.parse(Cola.getSource(options.parser.filename), options.parser);
                if (!options.parser.is_js) tl = tl.toJavaScript({
                    main_binding : options.main_binding,
                    main_event   : options.main_event,
                    parser       : options.parser,
                    path         : Cola.dirname(options.parser.filename),
                    std          : false
                });

                included = included.concat(tl.body);
            });

            return included;
        } else 

        if(node instanceof Cola.AST_Command && node.name == "require"){
            node.args.forEach(function(file){

                if (required_hash[file]) return;
                required_hash[file] = true;

                options.parser.is_js = /\.js$/.test(file);
                options.parser.filename = Cola.notRoot(file) ? options.path + "/" + file : file;

                var tl = Cola.parse(Cola.getSource(options.parser.filename), options.parser);
                if (!options.parser.is_js) tl = tl.toJavaScript({
                    main_binding : options.main_binding,
                    main_event   : options.main_event,
                    parser       : options.parser,
                    path         : Cola.dirname(options.parser.filename),
                    std          : false
                });

                required = required.concat(tl.body);
            });

            return false;
        } else 

        if (node instanceof Cola.AST_Command && node.name == "use") {
            if (node.args[0] == "closure") {
                props = new Cola.AST_Function({
                    type       : "dynamic",
                    body       : node.args[2].body,
                    argnames   : [] 
                });

                if (node.args[1]){
                    _ColaRuntime$$hash[Cola._ColaRuntime$$arguments_def.i] = true;
                    
                    props = new Cola.AST_Dot({
                        expression : props,
                        property   : "apply"
                    });
                }

                node = new Cola.AST_Call({
                    args       : node.args[1] ? [new Cola.AST_SymbolRef({ name : "this" }), new Cola.AST_SymbolRef({ name : "arguments" })] : [],
                    expression : props
                });
                node = new Cola.AST_SimpleStatement({ body : node });
            } else

            node = new Cola.AST_Directive({ value : "use " + node.args[0] });
        }
        
        if(node instanceof Array){
            _this = this;
            node.forEach(function(nd){
                nd._descend(nd, _this);
            })
        } else node._descend(node, this);

        return node;
    });

    _this = this.transform(tt);
    
    _this.body = required.concat(_this.body);

    if(options.std){
        for(var i in _ColaRuntime$$hash) if(_ColaRuntime$$hash.hasOwnProperty(i))
            _this.body.unshift(_ColaRuntime$$ast.body[i]);
    }

    return _this;
};