vsn 0.1.26 → 0.1.29

package/dist/vsn.js

@@ -0,0 +1,181 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vision = exports.Tag = exports.SimplePromise = exports.MessageList = exports.EventDispatcher = exports.Model = exports.Field = exports.property = exports.Property = exports.Controller = exports.WrappedArray = exports.ScopeReference = exports.Scope = exports.DOM = exports.Vision = void 0;
+var DOM_1 = require("./DOM");
+var WrappedArray_1 = require("./Scope/WrappedArray");
+var Registry_1 = require("./Registry");
+require("./Types");
+require("./Formats");
+var Configuration_1 = require("./Configuration");
+var VisionHelper_1 = require("./helpers/VisionHelper");
+var AST_1 = require("./AST");
+var Query_1 = require("./Query");
+var EventDispatcher_1 = require("./EventDispatcher");
+var DynamicScopeData_1 = require("./Scope/DynamicScopeData");
+var Vision = /** @class */ (function (_super) {
+    __extends(Vision, _super);
+    function Vision() {
+        var _this = _super.call(this) || this;
+        _this.registry = Registry_1.Registry.instance;
+        _this.config = Configuration_1.Configuration.instance;
+        if (VisionHelper_1.VisionHelper.document) {
+            document.addEventListener("DOMContentLoaded", _this.setup.bind(_this));
+        }
+        else {
+            console.warn('No dom, running in CLI mode.');
+        }
+        _this.registry.classes.register('Object', Object);
+        _this.registry.classes.register('WrappedArray', WrappedArray_1.WrappedArray);
+        _this.registry.classes.register('Data', DynamicScopeData_1.DynamicScopeData);
+        if (VisionHelper_1.VisionHelper.window) {
+            window['Vision'] = Vision;
+            window['Registry'] = Registry_1.Registry;
+            window['vision'] = window['vsn'] = _this;
+            window['Tree'] = AST_1.Tree;
+            window['$'] = Query_1.Query;
+            VisionHelper_1.VisionHelper.window.dispatchEvent(new Event('vsn'));
+        }
+        return _this;
+    }
+    Object.defineProperty(Vision.prototype, "dom", {
+        get: function () {
+            return this._dom;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Vision.prototype.eval = function (code) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._dom.eval(code)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Vision.prototype.setup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var body, startTime, now, setupTime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        body = document.body;
+                        body.setAttribute('vsn-root', '');
+                        this._dom = DOM_1.DOM.instance;
+                        startTime = new Date().getTime();
+                        return [4 /*yield*/, this._dom.buildFrom(document, true)];
+                    case 1:
+                        _a.sent();
+                        now = (new Date()).getTime();
+                        setupTime = now - startTime;
+                        console.warn("Took " + setupTime + "ms to start up VisionJS. https://www.vsnjs.com/");
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(Vision, "instance", {
+        get: function () {
+            if (!Vision._instance)
+                Vision._instance = new Vision();
+            return Vision._instance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Vision;
+}(EventDispatcher_1.EventDispatcher));
+exports.Vision = Vision;
+__exportStar(require("./attributes/_imports"), exports);
+__exportStar(require("./Registry"), exports);
+__exportStar(require("./Attribute"), exports);
+__exportStar(require("./AST"), exports);
+var DOM_2 = require("./DOM");
+Object.defineProperty(exports, "DOM", { enumerable: true, get: function () { return DOM_2.DOM; } });
+var Scope_1 = require("./Scope");
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return Scope_1.Scope; } });
+var ScopeReference_1 = require("./Scope/ScopeReference");
+Object.defineProperty(exports, "ScopeReference", { enumerable: true, get: function () { return ScopeReference_1.ScopeReference; } });
+var WrappedArray_2 = require("./Scope/WrappedArray");
+Object.defineProperty(exports, "WrappedArray", { enumerable: true, get: function () { return WrappedArray_2.WrappedArray; } });
+var Controller_1 = require("./Controller");
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return Controller_1.Controller; } });
+var Property_1 = require("./Scope/properties/Property");
+Object.defineProperty(exports, "Property", { enumerable: true, get: function () { return Property_1.Property; } });
+Object.defineProperty(exports, "property", { enumerable: true, get: function () { return Property_1.property; } });
+var Field_1 = require("./Model/Field");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return Field_1.Field; } });
+var Model_1 = require("./Model");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return Model_1.Model; } });
+var EventDispatcher_2 = require("./EventDispatcher");
+Object.defineProperty(exports, "EventDispatcher", { enumerable: true, get: function () { return EventDispatcher_2.EventDispatcher; } });
+var MessageList_1 = require("./MessageList");
+Object.defineProperty(exports, "MessageList", { enumerable: true, get: function () { return MessageList_1.MessageList; } });
+var SimplePromise_1 = require("./SimplePromise");
+Object.defineProperty(exports, "SimplePromise", { enumerable: true, get: function () { return SimplePromise_1.SimplePromise; } });
+var Tag_1 = require("./Tag");
+Object.defineProperty(exports, "Tag", { enumerable: true, get: function () { return Tag_1.Tag; } });
+exports.vision = Vision.instance;
+//# sourceMappingURL=vsn.js.map

package/dist/vsn.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsn",
-  "version": "0.1.26",
+  "version": "0.1.29",
   "description": "SEO Friendly Javascript/Typescript Framework",
   "keywords": [
     "framework",
@@ -17,11 +17,7 @@
     "sample": "rm -rf sample/dist/ && tsc -p sample/ && node sample/dist/sample/index.js"
   },
   "license": "MIT",
-  "dependencies": {
-    "simple-ts-event-dispatcher": "^0.1.6",
-    "simple-ts-models": "^0.1.3",
-    "simple-ts-promise": "^0.1.6"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/jasmine": "^3.6.10",
     "codecov": "^3.8.1",

package/src/AST/ArithmeticAssignmentNode.ts

@@ -0,0 +1,236 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {DOMObject} from "../DOM/DOMObject";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+import {RootScopeMemberNode} from "./RootScopeMemberNode";
+import {ScopeMemberNode} from "./ScopeMemberNode";
+import {ElementQueryNode} from "./ElementQueryNode";
+import {ElementAttributeNode} from "./ElementAttributeNode";
+import {ElementStyleNode} from "./ElementStyleNode";
+import {UnitLiteral} from "./UnitLiteralNode";
+import {Controller} from "../vsn";
+
+export class ArithmeticAssignmentNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: RootScopeMemberNode | ScopeMemberNode,
+        public readonly right: TreeNode,
+        public readonly type: TokenType
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.left as Node,
+            this.right as Node
+        ]
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let scopes = [];
+        const name: string = await this.left.name.evaluate(scope, dom, tag);
+
+        if (this.left instanceof ScopeMemberNode) {
+            const inner = await this.left.scope.evaluate(scope, dom, tag);
+            if (this.left.scope instanceof ElementQueryNode) {
+                scopes.push(...inner);
+            } else if (inner instanceof Scope) {
+                scopes.push(inner);
+            } else if (inner instanceof Controller) {
+                scopes.push(inner.scope);
+            } else {
+                scopes.push(scope)
+            }
+        } else if ((this.left instanceof ElementAttributeNode || this.left instanceof ElementStyleNode) && this.left.elementRef) {
+            scopes = await this.left.elementRef.evaluate(scope, dom, tag);
+        } else
+            scopes.push(scope);
+
+        const values = [];
+        for (let localScope of scopes) {
+            if (localScope instanceof DOMObject) {
+                await this.handleDOMObject(name, dom, localScope, tag);
+            } else {
+                if (localScope['$wrapped'] && localScope['$scope']) {
+                    localScope = localScope['$scope'];
+                }
+
+                // We get the values from the passed scope, but set the value on the local scope
+                let left: number | Array<any> | string = await this.left.evaluate(scope, dom, tag);
+                let right: number | Array<any> | string = await this.right.evaluate(scope, dom, tag);
+
+                if (left instanceof Array) {
+                    left = this.handleArray(name, left, right, localScope);
+                } else if ((left as any) instanceof UnitLiteral || right instanceof UnitLiteral) {
+                    left = this.handleUnit(name, left, right, localScope);
+                } else if (Number.isFinite(left)) {
+                    left = this.handleNumber(name, left, right, localScope);
+                } else {
+                    left = this.handleString(name, left, right, localScope);
+                }
+
+                values.push(left);
+            }
+        }
+        return values.length > 1 ? values : values[0];
+    }
+
+    public handleNumber(key, left, right, scope) {
+        if (right !== null && !Number.isFinite(right))
+            right = parseFloat(`${right}`);
+
+        left = left as number;
+        right = right as number;
+
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left = right;
+                break;
+            case TokenType.ADD_ASSIGN:
+                left += right;
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                left -= right;
+                break;
+            case TokenType.MULTIPLY_ASSIGN:
+                left *= right;
+                break;
+            case TokenType.DIVIDE_ASSIGN:
+                left /= right;
+                break;
+        }
+        scope.set(key, left);
+        return left;
+    }
+
+    public handleString(key, left, right, scope) {
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left = right;
+                break;
+            case TokenType.ADD_ASSIGN:
+                left = `${left}${right}`;
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                left.replace(right, '');
+                break;
+            case TokenType.MULTIPLY_ASSIGN:
+                left *= right;
+                break;
+            case TokenType.DIVIDE_ASSIGN:
+                left /= right;
+                break;
+        }
+
+        scope.set(key, left);
+        return left;
+    }
+
+    public handleUnit(key, left, right, scope) {
+        if (!(left instanceof UnitLiteral)) {
+            left = new UnitLiteral(left);
+        }
+
+        if (!(right instanceof UnitLiteral)) {
+            right = new UnitLiteral(right);
+        }
+        const unit = left.unit || right.unit || 'px';
+
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left = right;
+                break;
+            case TokenType.ADD_ASSIGN:
+                left = new UnitLiteral(`${left.amount+right.amount}${unit}`);
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                left = new UnitLiteral(`${left.amount-right.amount}${unit}`);
+                break;
+            case TokenType.MULTIPLY_ASSIGN:
+                left = new UnitLiteral(`${left.amount*right.amount}${unit}`);
+                break;
+            case TokenType.DIVIDE_ASSIGN:
+                left = new UnitLiteral(`${left.amount/right.amount}${unit}`);
+                break;
+        }
+
+        scope.set(key, left);
+        return left;
+    }
+
+    public async handleDOMObject(key: string, dom: DOM, domObject: DOMObject, tag: Tag) {
+        let left = domObject.scope.get(key);
+        let right: number | Array<any> | string = await this.right.evaluate(domObject.scope, dom, tag);
+        if (left instanceof Array)
+            return this.handleArray(key, left, right, domObject.scope);
+
+        return this.handleString(key, left, right, domObject.scope);
+    }
+
+    public handleArray(key, left, right, scope) {
+        if (!(right instanceof Array))
+            right = [right];
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left.splice(0, left.length);
+                left.push(...right);
+                break;
+            case TokenType.ADD_ASSIGN:
+                left.push(...right);
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                for (let i = left.length - 1; i >= 0; i--) {
+                    if (right.indexOf(left[i]) > -1) {
+                        left.splice(i, 1);
+                        i++;
+                    }
+                }
+                break;
+            case TokenType.TILDE:
+                for (const toggle of right) {
+                    const index = left.indexOf(toggle);
+                    if (index > -1) {
+                        left.splice(index, 1);
+                    } else {
+                        left.push(toggle);
+                    }
+                }
+                break;
+        }
+
+        /*
+         We have to trigger a change manually here. Setting the variable on the scope with an array won't trigger
+         it since we are modifying values inside of the array instance.
+         */
+        scope.dispatch(`change:${key}`);
+
+        return left;
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return [
+            TokenType.ASSIGN,
+            TokenType.ADD_ASSIGN,
+            TokenType.SUBTRACT_ASSIGN,
+            TokenType.MULTIPLY_ASSIGN,
+            TokenType.DIVIDE_ASSIGN,
+            TokenType.TILDE,
+        ].indexOf(tokens[0].type) > -1;
+    }
+
+    public static parse(lastNode: any, token, tokens: Token[]): ArithmeticAssignmentNode {
+        if (!(lastNode instanceof RootScopeMemberNode) && !(lastNode instanceof ScopeMemberNode) && !(lastNode instanceof ElementAttributeNode) && !(lastNode instanceof ElementStyleNode)) {
+            throw SyntaxError(`Invalid assignment syntax near ${Tree.toCode(tokens.splice(0, 10))}`);
+        }
+        tokens.splice(0, 1); // consume =
+        const assignmentTokens: Token[] = Tree.getNextStatementTokens(tokens, false, false, true);
+
+        return new ArithmeticAssignmentNode(
+            lastNode as RootScopeMemberNode,
+            Tree.processTokens(assignmentTokens),
+            token.type
+        );
+    }
+}

package/src/AST/ArithmeticNode.ts

@@ -0,0 +1,52 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class ArithmeticNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: TreeNode,
+        public readonly right: TreeNode,
+        public readonly type: TokenType
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.left as Node,
+            this.right as Node
+        ]
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const left: any = await this.left.evaluate(scope, dom, tag);
+        const right: any = await this.right.evaluate(scope, dom, tag);
+
+        switch (this.type) {
+            case TokenType.ADD:
+                return left + right;
+            case TokenType.SUBTRACT:
+                return left - right;
+            case TokenType.MULTIPLY:
+                return left * right;
+            case TokenType.DIVIDE:
+                return left / right;
+        }
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return [
+            TokenType.ADD,
+            TokenType.SUBTRACT,
+            TokenType.MULTIPLY,
+            TokenType.DIVIDE
+        ].indexOf(tokens[0].type) > -1
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        tokens.splice(0, 1); // Remove arithmetic operator
+        return new ArithmeticNode(lastNode, Tree.processTokens(Tree.getNextStatementTokens(tokens)), token.type)
+    }
+}

package/src/AST/ArrayNode.ts

@@ -0,0 +1,39 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {WrappedArray} from "../Scope/WrappedArray";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class ArrayNode extends Node implements TreeNode {
+    constructor(
+        public readonly values: Node[]
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return new Array(...this.values);
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const arr: WrappedArray<any> = new WrappedArray();
+        for (const val of this.values) {
+            arr.push(await val.evaluate(scope, dom, tag));
+        }
+        return arr;
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return tokens[0].type === TokenType.L_BRACKET;
+    }
+
+    public static parse(lastNode, token, tokens: Token[]): ArrayNode {
+        const valueTokens: Token[][] = Tree.getBlockTokens(tokens);
+        const values: Node[] = [];
+        for (const arg of valueTokens) {
+            values.push(Tree.processTokens(arg));
+        }
+        return new ArrayNode(values);
+    }
+}

package/src/AST/BlockNode.ts

@@ -0,0 +1,25 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class BlockNode extends Node implements TreeNode {
+    constructor(
+        public readonly statements: Node[]
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [...(this.statements as Node[])];
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let returnValue: any = null;
+        for (let i = 0; i < this.statements.length; i++) {
+            returnValue = await this.statements[i].evaluate(scope, dom, tag);
+        }
+        return returnValue;
+    }
+}

package/src/AST/BooleanLiteralNode.ts

@@ -0,0 +1,10 @@
+import {LiteralNode} from "./LiteralNode";
+
+export class BooleanLiteralNode extends LiteralNode<number> {
+    constructor(
+        public readonly value: any
+    ) {
+        super(value);
+        this.value = value === 'true';
+    }
+}

package/src/AST/ComparisonNode.ts

@@ -0,0 +1,57 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class ComparisonNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: Node,
+        public readonly right: Node,
+        public readonly type: TokenType
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.left as Node,
+            this.right as Node
+        ];
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const left: any = await this.left.evaluate(scope, dom, tag);
+        const right: any = await this.right.evaluate(scope, dom, tag);
+        switch (this.type) {
+            case TokenType.EQUALS:
+                return left === right;
+            case TokenType.NOT_EQUALS:
+                return left !== right;
+            case TokenType.GREATER_THAN:
+                return left > right;
+            case TokenType.LESS_THAN:
+                return left < right;
+            case TokenType.GREATER_THAN_EQUAL:
+                return left >= right;
+            case TokenType.LESS_THAN_EQUAL:
+                return left <= right;
+        }
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return [
+            TokenType.EQUALS,
+            TokenType.NOT_EQUALS,
+            TokenType.GREATER_THAN,
+            TokenType.LESS_THAN,
+            TokenType.GREATER_THAN_EQUAL,
+            TokenType.LESS_THAN_EQUAL
+        ].indexOf(tokens[0].type) > -1
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        tokens.splice(0, 1); // Remove comparison operator
+        return new ComparisonNode(lastNode, Tree.processTokens(Tree.getNextStatementTokens(tokens)), token.type)
+    }
+}

package/src/AST/ConditionalNode.ts

@@ -0,0 +1,36 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {WrappedArray} from "../Scope/WrappedArray";
+import {TreeNode} from "../AST";
+import {BlockNode} from "./BlockNode";
+import {Node} from "./Node";
+
+export class ConditionalNode extends Node implements TreeNode {
+    constructor(
+        public readonly condition: Node,
+        public readonly block: BlockNode
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.condition as Node,
+            this.block as Node
+        ];
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const condition = await this.condition.evaluate(scope, dom, tag);
+        let evaluation = false;
+
+        if (condition instanceof WrappedArray) {
+            evaluation = condition.length > 0;
+        } else {
+            evaluation = !!condition;
+        }
+
+        return evaluation;
+    }
+}