@bikky/compiler 0.0.7 → 0.0.9

package/Libraries/BiscuitLibraries.d.ts

@@ -1,3 +1,3 @@
-/// <reference path="GlobalTypes.d.ts" />
-import "./MixinCode.js";
+/// <reference path="GlobalTypes.d.ts" />
+import "./MixinCode.js";
 //# sourceMappingURL=BiscuitLibraries.d.ts.map

package/Libraries/BiscuitLibraries.js

@@ -1,3 +1,3 @@
-/// <reference path="./GlobalTypes.d.ts" />
-import "./MixinCode.js";
+/// <reference path="./GlobalTypes.d.ts" />
+import "./MixinCode.js";
 //# sourceMappingURL=BiscuitLibraries.js.map

package/Libraries/GlobalTypes.d.ts

@@ -1,45 +1,43 @@
 
-declare module BikkyTypes {
+type Writable<T> = { -readonly [P in keyof T]: T[P] }
 
-	type Writable<T> = { -readonly [P in keyof T]: T[P] }
+type GetConstraints<Extras> = Extras extends (Function & { prototype: infer Constraints })[] ? Constraints : never;
+type UnionToIntersection<U> =
+	(U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
+type AllConstraints<Super, Constraints> = UnionToIntersection<Constraints> extends never ? Super : Super & UnionToIntersection<Constraints>;
 
-	type GetConstraints<Extras> = Extras extends (Function & { prototype: infer Constraints })[] ? Constraints : never;
-	type UnionToIntersection<U> =
-		(U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
-	type AllConstraints<Super, Constraints> = UnionToIntersection<Constraints> extends never ? Super : Super & UnionToIntersection<Constraints>;
+type Class<T> = (new (...args: any[]) => T);
+type AbstractClass<T> = Function & { prototype: T };
+type ClassObject<T> = T extends (new (...args: any[]) => infer C) ? C : never;
+type AbstractClassObject<T> = T extends (Function & { prototype: infer C }) ? C : never;
+type AbstractClassArguments<T> = T extends abstract new (...args: infer A) => any ? A : never;
+type ClassArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
 
-	type Class<T> = (new (...args: any[]) => T);
-	type AbstractClass<T> = Function & { prototype: T };
-	type ClassObject<T> = T extends (new (...args: any[]) => infer C) ? C : never;
-	type AbstractClassObject<T> = T extends (Function & { prototype: infer C }) ? C : never;
-	type AbstractClassArguments<T> = T extends abstract new (...args: infer A) => any ? A : never;
-	type ClassArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
+type ConstructArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
+type Prototype<T> = (Function & { prototype: T });
+type ObjectType<T> = T extends (new (...args: any[]) => infer C) ? C : never;
 
-	type ConstructArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
-	type Prototype<T> = (Function & { prototype: T });
-	type ObjectType<T> = T extends (new (...args: any[]) => infer C) ? C : never;
-}
 //Unfortunately Typescript doesn't currently support the following typing (as in the decorator's typing
 // information will not properly alter typescript's typing information):
 //First set of params are the ones supplied in the decorator, like: @mixin(common, extra1, extra2);
 declare function mixin<
 	Super extends Object,
-	Extras extends BikkyTypes.Prototype<any>[]
->(common: BikkyTypes.Prototype<Super>, ...constraints: Extras): (
+	Extras extends Prototype<any>[]
+>(common: Prototype<Super>, ...constraints: Extras): (
 		//Second set of params are the class the decorator is decorating, in this case the mixin.
 		<
 			MixinClass extends Function & { prototype: Object },
-			Mixin extends BikkyTypes.Prototype<MixinClass>,
-			ConstructorArgs extends BikkyTypes.ConstructArguments<Mixin>,
+			Mixin extends Prototype<MixinClass>,
+			ConstructorArgs extends ConstructArguments<Mixin>,
 		>
 			(mixin: MixinClass) => MixinClass & {
 				//We return a mix function that takes the class that the mixin
 				// is to be mixed onto. We want to ensure that the new class
 				// fulfills all the requirements listed with the decorator.
 				mix: <
-					Core extends BikkyTypes.AllConstraints<Super, BikkyTypes.GetConstraints<Extras>>
+					Core extends AllConstraints<Super, GetConstraints<Extras>>
 					>
-					(core: BikkyTypes.Prototype<Core>) =>
+					(core: Prototype<Core>) =>
 					//Lastly we return a function that requires the mixin's constructor arguments and returns 
 					// an object which is a combination of the mixin and the provided core class.
 					(new (...args: ConstructorArgs) => Core & Mixin);
@@ -50,10 +48,10 @@ declare function mixin<
 // decorators are updated.
 declare function makeMixer<
 	MixinClass extends (new (...args: any[]) => object),
-	Mixin extends BikkyTypes.ClassObject<MixinClass>,
-	ConstructorArgs extends BikkyTypes.ConstructArguments<MixinClass>,
-	Super extends Object, Extras extends BikkyTypes.Prototype<any>[]>
-	(mixin: MixinClass, common: BikkyTypes.Prototype<Super>, ...constraints: Extras): (
-		<Core extends BikkyTypes.AllConstraints<Super, BikkyTypes.GetConstraints<Extras>>>(core: { new(...args: any[]): Core } ) =>
+	Mixin extends ClassObject<MixinClass>,
+	ConstructorArgs extends ConstructArguments<MixinClass>,
+	Super extends Object, Extras extends Prototype<any>[]>
+	(mixin: MixinClass, common: Prototype<Super>, ...constraints: Extras): (
+		<Core extends AllConstraints<Super, GetConstraints<Extras>>>(core: { new(...args: any[]): Core } ) =>
 			(new (...args: ConstructorArgs) => Core & Mixin));
 

package/Libraries/MixinCode.d.ts

@@ -1,14 +1,14 @@
-type GetConstraints<Extras> = Extras extends (Function & {
-    prototype: infer Constraints;
-})[] ? Constraints : never;
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type AllConstraints<Super, Constraints> = UnionToIntersection<Constraints> extends never ? Super : Super & UnionToIntersection<Constraints>;
-type Class<T> = (Function & {
-    prototype: T;
-});
-export declare function makeMixerFoo<Mixin extends Object, Super extends Object, Extras extends Class<any>[]>(mixin: Class<Mixin>, common: Class<Super>, ...constraints: Extras): <Core extends AllConstraints<Super, GetConstraints<Extras>>>(core: Function & {
-    prototype: Core;
-}) => new (id: string, name: string, data: any, instance?: any) => Core & Mixin;
-export declare function MixableClass<Base extends Class<Object>>(param: Base): Base;
-export {};
+type GetConstraints<Extras> = Extras extends (Function & {
+    prototype: infer Constraints;
+})[] ? Constraints : never;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type AllConstraints<Super, Constraints> = UnionToIntersection<Constraints> extends never ? Super : Super & UnionToIntersection<Constraints>;
+type Class<T> = (Function & {
+    prototype: T;
+});
+export declare function makeMixerFoo<Mixin extends Object, Super extends Object, Extras extends Class<any>[]>(mixin: Class<Mixin>, common: Class<Super>, ...constraints: Extras): <Core extends AllConstraints<Super, GetConstraints<Extras>>>(core: Function & {
+    prototype: Core;
+}) => new (id: string, name: string, data: any, instance?: any) => Core & Mixin;
+export declare function MixableClass<Base extends Class<Object>>(param: Base): Base;
+export {};
 //# sourceMappingURL=MixinCode.d.ts.map

package/Libraries/MixinCode.js

@@ -1,24 +1,24 @@
-//Propertydescriptor is needed to preserve getters and setters, otherwise we trigger them.
-// We assign functions directly though to preserve the prototype chain when using super() [it's not working].
-function duplicatePrototype(prototype, parent) {
-    var names = Array.from(Object.getOwnPropertyNames(prototype));
-    names.push(...Object.getOwnPropertySymbols(prototype));
-    var result = { __proto__: parent };
-    for (let i = names.length - 1; i >= 0; i--) {
-        let name = names[i];
-        var descriptor = Object.getOwnPropertyDescriptor(prototype, name);
-        Object.defineProperty(result, name, descriptor);
-    }
-    return result;
-}
-var mixingObject = [];
-var mixingBases = [];
-var mixingBaseProtos = [];
-//The following parameter type allows abstract classes, where as new () => Core doesn't.
-export function makeMixerFoo(mixin, common, ...constraints) {
-    if (typeof mixin !== "function" || !mixin.prototype)
-        throw new Error("Can only mix classes into other classes.");
-    return function mix(core) {
+//Propertydescriptor is needed to preserve getters and setters, otherwise we trigger them.
+// We assign functions directly though to preserve the prototype chain when using super() [it's not working].
+function duplicatePrototype(prototype, parent) {
+    var names = Array.from(Object.getOwnPropertyNames(prototype));
+    names.push(...Object.getOwnPropertySymbols(prototype));
+    var result = { __proto__: parent };
+    for (let i = names.length - 1; i >= 0; i--) {
+        let name = names[i];
+        var descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+        Object.defineProperty(result, name, descriptor);
+    }
+    return result;
+}
+var mixingObject = [];
+var mixingBases = [];
+var mixingBaseProtos = [];
+//The following parameter type allows abstract classes, where as new () => Core doesn't.
+export function makeMixerFoo(mixin, common, ...constraints) {
+    if (typeof mixin !== "function" || !mixin.prototype)
+        throw new Error("Can only mix classes into other classes.");
+    return function mix(core) {
         var newClass = eval(`
 		function Mixin_${mixin.name}(...args) {
 			//This allows us to change the prototype which the constructor uses for creating
@@ -35,75 +35,75 @@ export function makeMixerFoo(mixin, common, ...constraints) {
 			return object;
 		};
 		Mixin_${mixin.name}
-		`);
-        var originalPrototypes = [];
-        var current = mixin;
-        originalPrototypes.push(current.prototype);
-        current = current.prototype;
-        while (mixingBaseProtos.indexOf(current.__proto__) < 0 && current.__proto__ != Object.prototype) {
-            originalPrototypes.push(current.__proto__);
-            current = current.__proto__;
-        }
-        var newPrototypes = [];
-        while (originalPrototypes.length > 0) {
-            current = originalPrototypes.pop();
-            let originalClass = current;
-            var prototype = newPrototypes.length == 0 ? core.prototype : newPrototypes[0];
-            let newmix = duplicatePrototype(current, prototype);
-            var edits = {
-                //We override the original isA so that this class appears to be a movable as well as other types.
-                isA(other) {
-                    if (other.prototype == originalClass) {
-                        return true;
-                    }
-                    else {
-                        return super.isA(other);
-                    }
-                },
-            };
-            Object.assign(newmix, edits);
-            newmix.__proto__ = prototype;
-            //This ensures any super calls in the edits to the prototype resolve correctly, because
-            // they're based on the original object the function is defined in, not the prototype the
-            // function ends up on.
-            edits.__proto__ = prototype;
-            newPrototypes.unshift(newmix);
-        }
-        newClass.prototype = newPrototypes[0];
-        newClass.prototype.constructor = newClass;
-        //I wanted to do this on object creation rather than having it be inherited, but that caused a problem with the value
-        // not being accessible in the constructor, which is necessary because the constructor can call other functons.
-        if (mixin.Super) {
-            //console.log("Configuring", mixin.name, "to have a parent that is", newClass.prototype.__proto__.constructor.name);
-            newClass.prototype[mixin.Super] = core.prototype;
-        }
-        //newClass.__proto__ = newPrototypes[0];
-        return newClass;
-    };
-}
-export function MixableClass(param) {
-    //This is done to preserve super calls in mixins.
-    class Mixbase extends param {
-        //@ts-ignore we don't need to call super in this child class.
-        constructor(...args) {
-            //We can't override the class' object using .call or .apply, but we can override it in the base class.
-            var object = mixingObject[0];
-            return object;
-        }
-    }
-    ;
-    mixingBases.push(Mixbase);
-    mixingBaseProtos.push(Mixbase.prototype);
-    return Mixbase;
-}
-if (typeof global !== "undefined") {
-    global.Mixable = MixableClass;
-    global.makeMixer = makeMixerFoo;
-}
-else {
-    Mixable = MixableClass;
-    makeMixer = makeMixerFoo;
-    window.Mixable = MixableClass;
-    window.makeMixer = makeMixerFoo;
-}
+		`);
+        var originalPrototypes = [];
+        var current = mixin;
+        originalPrototypes.push(current.prototype);
+        current = current.prototype;
+        while (mixingBaseProtos.indexOf(current.__proto__) < 0 && current.__proto__ != Object.prototype) {
+            originalPrototypes.push(current.__proto__);
+            current = current.__proto__;
+        }
+        var newPrototypes = [];
+        while (originalPrototypes.length > 0) {
+            current = originalPrototypes.pop();
+            let originalClass = current;
+            var prototype = newPrototypes.length == 0 ? core.prototype : newPrototypes[0];
+            let newmix = duplicatePrototype(current, prototype);
+            var edits = {
+                //We override the original isA so that this class appears to be a movable as well as other types.
+                isA(other) {
+                    if (other.prototype == originalClass) {
+                        return true;
+                    }
+                    else {
+                        return super.isA(other);
+                    }
+                },
+            };
+            Object.assign(newmix, edits);
+            newmix.__proto__ = prototype;
+            //This ensures any super calls in the edits to the prototype resolve correctly, because
+            // they're based on the original object the function is defined in, not the prototype the
+            // function ends up on.
+            edits.__proto__ = prototype;
+            newPrototypes.unshift(newmix);
+        }
+        newClass.prototype = newPrototypes[0];
+        newClass.prototype.constructor = newClass;
+        //I wanted to do this on object creation rather than having it be inherited, but that caused a problem with the value
+        // not being accessible in the constructor, which is necessary because the constructor can call other functons.
+        if (mixin.Super) {
+            //console.log("Configuring", mixin.name, "to have a parent that is", newClass.prototype.__proto__.constructor.name);
+            newClass.prototype[mixin.Super] = core.prototype;
+        }
+        //newClass.__proto__ = newPrototypes[0];
+        return newClass;
+    };
+}
+export function MixableClass(param) {
+    //This is done to preserve super calls in mixins.
+    class Mixbase extends param {
+        //@ts-ignore we don't need to call super in this child class.
+        constructor(...args) {
+            //We can't override the class' object using .call or .apply, but we can override it in the base class.
+            var object = mixingObject[0];
+            return object;
+        }
+    }
+    ;
+    mixingBases.push(Mixbase);
+    mixingBaseProtos.push(Mixbase.prototype);
+    return Mixbase;
+}
+if (typeof global !== "undefined") {
+    global.Mixable = MixableClass;
+    global.makeMixer = makeMixerFoo;
+}
+else {
+    Mixable = MixableClass;
+    makeMixer = makeMixerFoo;
+    window.Mixable = MixableClass;
+    window.makeMixer = makeMixerFoo;
+}
 //# sourceMappingURL=MixinCode.js.map

package/Source/ASTBuilder.d.ts

@@ -0,0 +1,36 @@
+import * as ts from "typescript";
+import { ArithmeticSymbols, AssignmentSymbols, BitwiseOperators, ComparisonOperators, LogicalOperators } from "./ASTInterface/Tokens";
+type AnyExpr = Expression | ts.Expression;
+declare class Expression<NodeType extends ts.Node = ts.Expression> {
+    ast: NodeType;
+    constructor(ast: NodeType);
+    isExpression(): this is Expression<ts.Expression>;
+    getExpression(): ts.Expression;
+    DOT(other: string | ts.MemberName | Expression<ts.MemberName>): Expression<ts.Expression>;
+    LOOKUP(other: number | ts.Expression | Expression): Expression<ts.Expression>;
+    OP(op: keyof typeof ComparisonOperators | keyof typeof LogicalOperators | keyof typeof BitwiseOperators | keyof typeof ArithmeticSymbols, other: ts.Expression | Expression): Expression<ts.Expression>;
+    ASGN(op: keyof typeof AssignmentSymbols, other: ts.Expression | Expression): Expression<ts.AssignmentExpression<ts.EqualsToken>>;
+    toAST(): NodeType;
+}
+export declare function EXP(exp: ts.Expression | Expression): Expression<ts.Expression>;
+export declare function VAR(id: string, val?: ts.Expression | Expression): Expression<ts.VariableStatement>;
+export declare function LET(id: string, val?: ts.Expression | Expression): Expression<ts.VariableStatement>;
+export declare function NOT(exp: Expression | ts.Expression): Expression<ts.Expression>;
+export declare function SUPER(): Expression<ts.SuperExpression>;
+export declare function THIS(): Expression<ts.ThisExpression>;
+export declare function CALL(name: AnyExpr, ...args: AnyExpr[]): Expression<ts.CallExpression>;
+export declare function METHOD_CALL(parent: AnyExpr, name: ts.MemberName | Expression<ts.MemberName>, ...args: AnyExpr[]): Expression;
+export declare function FUNC_CALL(name: AnyExpr, ...args: AnyExpr[]): Expression;
+export declare function FUNC_BIND(name: AnyExpr, newThis: AnyExpr): Expression<ts.Expression>;
+export declare function TYPEOF(other: ts.Expression): Expression<ts.TypeOfExpression>;
+export declare function ID(name: string): Expression<ts.Identifier>;
+export declare function LITERAL(name: string): Expression<ts.StringLiteral>;
+export declare function IF(ifs: ts.Expression | Expression, then: ts.Statement | Statement, elses?: ts.Statement | Statement): ts.IfStatement;
+declare class Statement {
+    statements: (ts.Expression | Expression)[];
+    LINE(exp: ts.Expression | Expression): void;
+    toAST(): ts.Block;
+}
+export declare function STATEMENT(): Statement;
+export {};
+//# sourceMappingURL=ASTBuilder.d.ts.map

package/Source/ASTBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ASTBuilder.d.ts","sourceRoot":"","sources":["ASTBuilder.ts"],"names":[],"mappings":"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"}

package/Source/ASTBuilder.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATEMENT = exports.IF = exports.LITERAL = exports.ID = exports.TYPEOF = exports.FUNC_BIND = exports.FUNC_CALL = exports.METHOD_CALL = exports.CALL = exports.THIS = exports.SUPER = exports.NOT = exports.LET = exports.VAR = exports.EXP = void 0;
+const ts = require("typescript");
+const Tokens_1 = require("./ASTInterface/Tokens");
+const Crawler_1 = require("./ASTInterface/Crawler");
+`EXP(SUPER().ACCESS(Name)).OP(!==, "undefined")`;
+function getAST(item) {
+    if (typeof item === "string")
+        return Crawler_1.Crawler.getContext().factory.createStringLiteral(item);
+    if (item instanceof Expression || item instanceof Statement)
+        return item.toAST();
+    return item;
+}
+class Expression {
+    constructor(ast) {
+        this.ast = ast;
+    }
+    isExpression() {
+        return ts.isExpression(this.ast);
+    }
+    getExpression() {
+        if (!ts.isExpression(this.ast))
+            throw new Error("Error, node requires expression but this is not.");
+        return this.ast;
+    }
+    DOT(other) {
+        if (!this.ast)
+            throw new Error("Can't dot access undefined.");
+        return new Expression(Crawler_1.Crawler.getContext().factory.createPropertyAccessExpression(this.getExpression(), getAST(other)));
+    }
+    LOOKUP(other) {
+        if (!this.ast)
+            throw new Error("Can't [] access undefined.");
+        return new Expression(Crawler_1.Crawler.getContext().factory.createElementAccessExpression(this.getExpression(), typeof other === "number" ? other : getAST(other)));
+    }
+    OP(op, other) {
+        other = getAST(other);
+        if (!this.ast)
+            throw new Error("Can't use nothing as lhs of operator expression..");
+        if (op in Tokens_1.ComparisonOperators) {
+            let opType = Tokens_1.ComparisonOperators[op];
+            return new Expression(Crawler_1.Crawler.getContext().factory.createBinaryExpression(this.getExpression(), opType, other));
+        }
+        if (op in Tokens_1.LogicalOperators) {
+            switch (op) {
+                case "||":
+                    return new Expression(Crawler_1.Crawler.getContext().factory.createLogicalOr(this.getExpression(), other));
+                    break;
+                case "&&":
+                    return new Expression(Crawler_1.Crawler.getContext().factory.createLogicalAnd(this.getExpression(), other));
+                    break;
+                case "!":
+                    break;
+            }
+        }
+        return this;
+    }
+    ASGN(op, other) {
+        other = getAST(other);
+        if (ts.isVariableStatement(this.ast)) {
+            if (op != "=")
+                throw new Error("Cannot declare variable with assignment operator other than =.");
+            let dec = this.ast.declarationList.declarations[0];
+            ts.factory.updateVariableDeclaration(dec, dec.name, dec.exclamationToken, dec.type, other);
+            return this;
+        }
+        switch (op) {
+            case "=":
+                return new Expression(Crawler_1.Crawler.getContext().factory.createAssignment(this.getExpression(), other));
+                break;
+            default:
+                return new Expression(Crawler_1.Crawler.getContext().factory.createBinaryExpression(this.getExpression(), Tokens_1.AssignmentSymbols[op], other));
+                break;
+        }
+        return this;
+    }
+    toAST() {
+        return this.ast;
+    }
+    ;
+}
+function EXP(exp) {
+    if (exp instanceof Expression)
+        return exp;
+    return new Expression(exp);
+}
+exports.EXP = EXP;
+function VAR(id, val) {
+    val = val instanceof Expression ? val.toAST() : val;
+    if (val && ts.isVariableStatement(val))
+        throw new Error("Can't use variable declaration as initialiser for another variable declaration.");
+    let dec = ts.factory.createVariableDeclaration(id, void 0, void 0, val);
+    let node = ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList([dec]));
+    return new Expression(node);
+}
+exports.VAR = VAR;
+function LET(id, val) {
+    val = val instanceof Expression ? val.toAST() : val;
+    if (val && ts.isVariableStatement(val))
+        throw new Error("Can't use variable declaration as initialiser for another variable declaration.");
+    let dec = ts.factory.createVariableDeclaration(id, void 0, void 0, val);
+    let node = ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList([dec], ts.NodeFlags.Let));
+    return new Expression(node);
+}
+exports.LET = LET;
+function NOT(exp) {
+    if (!(exp instanceof Expression))
+        exp = new Expression(exp);
+    if (ts.isVariableStatement(exp.ast))
+        throw new Error("Cannot NOT a variable declaration.");
+    exp.ast = Crawler_1.Crawler.getContext().factory.createLogicalNot(exp.ast);
+    return exp;
+}
+exports.NOT = NOT;
+function SUPER() {
+    return new Expression(Crawler_1.Crawler.getContext().factory.createSuper());
+}
+exports.SUPER = SUPER;
+function THIS() {
+    return new Expression(Crawler_1.Crawler.getContext().factory.createThis());
+}
+exports.THIS = THIS;
+///Call a function.
+function CALL(name, ...args) {
+    return new Expression(Crawler_1.Crawler.getContext().factory.createCallExpression(getAST(name), undefined, args.map((e) => getAST(e))));
+}
+exports.CALL = CALL;
+///Call parent.method.call
+function METHOD_CALL(parent, name, ...args) {
+    if (!(parent instanceof Expression))
+        parent = new Expression(parent);
+    return CALL(parent.DOT(name).DOT(ID("call")), ...args);
+}
+exports.METHOD_CALL = METHOD_CALL;
+function FUNC_CALL(name, ...args) {
+    if (!(name instanceof Expression))
+        name = new Expression(name);
+    return CALL(name.DOT(ID("call")), ...args);
+}
+exports.FUNC_CALL = FUNC_CALL;
+function FUNC_BIND(name, newThis) {
+    if (!(name instanceof Expression))
+        name = new Expression(name);
+    return FUNC_CALL(name, ID("bind"), newThis);
+}
+exports.FUNC_BIND = FUNC_BIND;
+function TYPEOF(other) {
+    return new Expression(Crawler_1.Crawler.getContext().factory.createTypeOfExpression(other));
+}
+exports.TYPEOF = TYPEOF;
+function ID(name) {
+    return new Expression(Crawler_1.Crawler.getContext().factory.createIdentifier(name));
+}
+exports.ID = ID;
+function LITERAL(name) {
+    return new Expression(Crawler_1.Crawler.getContext().factory.createStringLiteral(name));
+}
+exports.LITERAL = LITERAL;
+function IF(ifs, then, elses) {
+    return Crawler_1.Crawler.getContext().factory.createIfStatement(getAST(ifs), getAST(then), elses ? getAST(elses) : elses);
+}
+exports.IF = IF;
+class Statement {
+    constructor() {
+        this.statements = [];
+    }
+    LINE(exp) {
+        this.statements.push(exp);
+    }
+    toAST() {
+        let statements = this.statements.map((e) => Crawler_1.Crawler.getContext().factory.createExpressionStatement(getAST(e)));
+        return Crawler_1.Crawler.getContext().factory.createBlock(statements);
+    }
+}
+function STATEMENT() {
+    return new Statement;
+}
+exports.STATEMENT = STATEMENT;
+//# sourceMappingURL=ASTBuilder.js.map