vsn 0.1.27 → 0.1.28

package/dist/AST/FunctionCallNode.js

@@ -0,0 +1,102 @@
+"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 __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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionCallNode = void 0;
+var Node_1 = require("./Node");
+var ScopeMemberNode_1 = require("./ScopeMemberNode");
+var FunctionCallNode = /** @class */ (function (_super) {
+    __extends(FunctionCallNode, _super);
+    function FunctionCallNode(fnc, args) {
+        var _this = _super.call(this) || this;
+        _this.fnc = fnc;
+        _this.args = args;
+        return _this;
+    }
+    FunctionCallNode.prototype._getChildNodes = function () {
+        return [
+            this.fnc,
+            this.args
+        ];
+    };
+    FunctionCallNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var functionScope, values;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        functionScope = scope;
+                        if (!(this.fnc instanceof ScopeMemberNode_1.ScopeMemberNode)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.fnc.scope.evaluate(scope, dom, tag)];
+                    case 1:
+                        functionScope = _b.sent();
+                        _b.label = 2;
+                    case 2: return [4 /*yield*/, this.args.evaluate(scope, dom, tag)];
+                    case 3:
+                        values = _b.sent();
+                        return [4 /*yield*/, this.fnc.evaluate(scope, dom, tag)];
+                    case 4: return [2 /*return*/, (_a = (_b.sent())).call.apply(_a, __spreadArray([functionScope.wrapped || functionScope], values))];
+                }
+            });
+        });
+    };
+    return FunctionCallNode;
+}(Node_1.Node));
+exports.FunctionCallNode = FunctionCallNode;
+//# sourceMappingURL=FunctionCallNode.js.map

package/dist/AST/FunctionCallNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionCallNode.js","sourceRoot":"","sources":["../../src/AST/FunctionCallNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,+BAA4B;AAE5B,qDAAkD;AAElD;IAA+C,oCAAI;IAC/C,0BACoB,GAAsC,EACtC,IAAiC;QAFrD,YAII,iBAAO,SACV;QAJmB,SAAG,GAAH,GAAG,CAAmC;QACtC,UAAI,GAAJ,IAAI,CAA6B;;IAGrD,CAAC;IAES,yCAAc,GAAxB;QACI,OAAO;YACH,IAAI,CAAC,GAAW;YAChB,IAAI,CAAC,IAAY;SACpB,CAAA;IACL,CAAC;IAEY,mCAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;;;wBACrD,aAAa,GAAU,KAAK,CAAC;6BAC7B,CAAA,IAAI,CAAC,GAAG,YAAY,iCAAe,CAAA,EAAnC,wBAAmC;wBACnB,qBAAM,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA9D,aAAa,GAAG,SAA8C,CAAC;;4BAEpD,qBAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAlD,MAAM,GAAG,SAAyC;wBAChD,qBAAM,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;4BAAhD,sBAAO,CAAA,KAAA,CAAC,SAAwC,CAAC,CAAA,CAAC,IAAI,0BAAC,aAAa,CAAC,OAAO,IAAI,aAAa,GAAK,MAAM,IAAE;;;;KAC7G;IACL,uBAAC;AAAD,CAAC,AAvBD,CAA+C,WAAI,GAuBlD;AAvBY,4CAAgB"}

package/dist/AST/IfStatementNode.d.ts

@@ -0,0 +1,14 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { Token, TreeNode } from "../AST";
+import { Node } from "./Node";
+import { ConditionalNode } from "./ConditionalNode";
+export declare class IfStatementNode extends Node implements TreeNode {
+    protected nodes: ConditionalNode[];
+    constructor(nodes: ConditionalNode[]);
+    protected _getChildNodes(): Node[];
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any>;
+    static parseConditional(tokens: Token[]): ConditionalNode;
+    static parse(lastNode: any, token: any, tokens: Token[]): IfStatementNode;
+}

package/dist/AST/IfStatementNode.js

@@ -0,0 +1,128 @@
+"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 __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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IfStatementNode = void 0;
+var AST_1 = require("../AST");
+var Node_1 = require("./Node");
+var ConditionalNode_1 = require("./ConditionalNode");
+var LiteralNode_1 = require("./LiteralNode");
+var IfStatementNode = /** @class */ (function (_super) {
+    __extends(IfStatementNode, _super);
+    function IfStatementNode(nodes) {
+        var _this = _super.call(this) || this;
+        _this.nodes = nodes;
+        return _this;
+    }
+    IfStatementNode.prototype._getChildNodes = function () {
+        return __spreadArray([], this.nodes);
+    };
+    IfStatementNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, condition, uno;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this.nodes;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 5];
+                        condition = _a[_i];
+                        return [4 /*yield*/, condition.evaluate(scope, dom, tag)];
+                    case 2:
+                        uno = _b.sent();
+                        if (!uno) return [3 /*break*/, 4];
+                        return [4 /*yield*/, condition.block.evaluate(scope, dom, tag)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    IfStatementNode.parseConditional = function (tokens) {
+        if ([
+            AST_1.TokenType.IF,
+            AST_1.TokenType.ELSE_IF
+        ].indexOf(tokens[0].type) === -1) {
+            throw SyntaxError('Invalid Syntax');
+        }
+        tokens.splice(0, 1); // consume if and else if
+        return new ConditionalNode_1.ConditionalNode(AST_1.Tree.processTokens(AST_1.Tree.getBlockTokens(tokens, null)[0]), AST_1.Tree.processTokens(AST_1.Tree.getBlockTokens(tokens, null)[0]));
+    };
+    IfStatementNode.parse = function (lastNode, token, tokens) {
+        if (tokens[1].type !== AST_1.TokenType.L_PAREN) {
+            throw SyntaxError('If statement needs to be followed by a condition encased in parenthesis.');
+        }
+        var nodes = [];
+        nodes.push(IfStatementNode.parseConditional(tokens));
+        while (tokens.length > 0 && AST_1.TokenType.ELSE_IF === tokens[0].type) {
+            nodes.push(IfStatementNode.parseConditional(tokens));
+        }
+        if (tokens.length > 0 && AST_1.TokenType.ELSE === tokens[0].type) {
+            tokens.splice(0, 1); // Consume else
+            nodes.push(new ConditionalNode_1.ConditionalNode(new LiteralNode_1.LiteralNode(true), AST_1.Tree.processTokens(AST_1.Tree.getBlockTokens(tokens, null)[0])));
+        }
+        return new IfStatementNode(nodes);
+    };
+    return IfStatementNode;
+}(Node_1.Node));
+exports.IfStatementNode = IfStatementNode;
+//# sourceMappingURL=IfStatementNode.js.map

package/dist/AST/IfStatementNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IfStatementNode.js","sourceRoot":"","sources":["../../src/AST/IfStatementNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,8BAAwD;AACxD,+BAA4B;AAC5B,qDAAkD;AAClD,6CAA0C;AAE1C;IAAqC,mCAAI;IACrC,yBACc,KAAwB;QADtC,YAGI,iBAAO,SACV;QAHa,WAAK,GAAL,KAAK,CAAmB;;IAGtC,CAAC;IAES,wCAAc,GAAxB;QACI,yBACQ,IAAI,CAAC,KAAgB,EAC5B;IACL,CAAC;IAEY,kCAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;;8BACvB,EAAV,KAAA,IAAI,CAAC,KAAK;;;6BAAV,CAAA,cAAU,CAAA;wBAAvB,SAAS;wBACK,qBAAM,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAxD,GAAG,GAAY,SAAyC;6BAC1D,GAAG,EAAH,wBAAG;wBACI,qBAAM,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;4BAAtD,sBAAO,SAA+C,EAAC;;wBAHvC,IAAU,CAAA;;;;;;KAMrC;IAEa,gCAAgB,GAA9B,UAA+B,MAAe;QAC1C,IAAI;YACA,eAAS,CAAC,EAAE;YACZ,eAAS,CAAC,OAAO;SACpB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAG;YAC/B,MAAM,WAAW,CAAC,gBAAgB,CAAC,CAAC;SACvC;QAED,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,yBAAyB;QAC9C,OAAO,IAAI,iCAAe,CACtB,UAAI,CAAC,aAAa,CAAC,UAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EACxD,UAAI,CAAC,aAAa,CAAC,UAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAC3D,CAAC;IACN,CAAC;IAEa,qBAAK,GAAnB,UAAoB,QAAQ,EAAE,KAAK,EAAE,MAAe;QAChD,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,eAAS,CAAC,OAAO,EAAE;YACtC,MAAM,WAAW,CAAC,0EAA0E,CAAC,CAAC;SACjG;QACD,IAAM,KAAK,GAAsB,EAAE,CAAC;QACpC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;QAErD,OAAM,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,eAAS,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;YAC7D,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;SACxD;QAED,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,eAAS,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;YACxD,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe;YACpC,KAAK,CAAC,IAAI,CAAC,IAAI,iCAAe,CAC1B,IAAI,yBAAW,CAAC,IAAI,CAAC,EACrB,UAAI,CAAC,aAAa,CAAC,UAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAC3D,CAAC,CAAA;SACL;QAED,OAAO,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IACL,sBAAC;AAAD,CAAC,AA1DD,CAAqC,WAAI,GA0DxC;AA1DY,0CAAe"}

package/dist/AST/InNode.d.ts

@@ -0,0 +1,15 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { Token, TreeNode } from "../AST";
+import { Node } from "./Node";
+export declare class InNode extends Node implements TreeNode {
+    readonly left: TreeNode;
+    readonly right: TreeNode;
+    readonly flip: boolean;
+    constructor(left: TreeNode, right: TreeNode, flip?: boolean);
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<boolean>;
+    protected _getChildNodes(): Node[];
+    static match(tokens: Token[]): boolean;
+    static parse(lastNode: any, token: any, tokens: Token[]): InNode;
+}

package/dist/AST/InNode.js

@@ -0,0 +1,107 @@
+"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 __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.InNode = void 0;
+var AST_1 = require("../AST");
+var Node_1 = require("./Node");
+var InNode = /** @class */ (function (_super) {
+    __extends(InNode, _super);
+    function InNode(left, right, flip) {
+        if (flip === void 0) { flip = false; }
+        var _this = _super.call(this) || this;
+        _this.left = left;
+        _this.right = right;
+        _this.flip = flip;
+        return _this;
+    }
+    InNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var toCheck, array, inArray;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.left.evaluate(scope, dom, tag)];
+                    case 1:
+                        toCheck = _a.sent();
+                        return [4 /*yield*/, this.right.evaluate(scope, dom, tag)];
+                    case 2:
+                        array = _a.sent();
+                        inArray = array.indexOf(toCheck) > -1;
+                        if (this.flip)
+                            inArray = !inArray;
+                        return [2 /*return*/, inArray];
+                }
+            });
+        });
+    };
+    InNode.prototype._getChildNodes = function () {
+        return [
+            this.left,
+            this.right
+        ];
+    };
+    InNode.match = function (tokens) {
+        return tokens[0].type === AST_1.TokenType.IN || (tokens[0].type === AST_1.TokenType.NOT && tokens[1].type === AST_1.TokenType.IN);
+    };
+    InNode.parse = function (lastNode, token, tokens) {
+        var flip = tokens[0].type === AST_1.TokenType.NOT;
+        if (flip)
+            tokens.splice(0, 1); // consume not
+        tokens.splice(0, 1); // consume in
+        var containedTokens = AST_1.Tree.getNextStatementTokens(tokens, false, false, true);
+        return new InNode(lastNode, AST_1.Tree.processTokens(containedTokens), flip);
+    };
+    return InNode;
+}(Node_1.Node));
+exports.InNode = InNode;
+//# sourceMappingURL=InNode.js.map

package/dist/AST/InNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InNode.js","sourceRoot":"","sources":["../../src/AST/InNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,8BAAwD;AACxD,+BAA4B;AAE5B;IAA4B,0BAAI;IAC5B,gBACoB,IAAc,EACd,KAAe,EACf,IAAqB;QAArB,qBAAA,EAAA,YAAqB;QAHzC,YAKI,iBAAO,SACV;QALmB,UAAI,GAAJ,IAAI,CAAU;QACd,WAAK,GAAL,KAAK,CAAU;QACf,UAAI,GAAJ,IAAI,CAAiB;;IAGzC,CAAC;IAEY,yBAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;4BACzC,qBAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAnD,OAAO,GAAG,SAAyC;wBAC3C,qBAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAlD,KAAK,GAAG,SAA0C;wBAEpD,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;wBAC1C,IAAI,IAAI,CAAC,IAAI;4BACT,OAAO,GAAG,CAAC,OAAO,CAAC;wBACvB,sBAAO,OAAO,EAAC;;;;KAClB;IAES,+BAAc,GAAxB;QACI,OAAO;YACH,IAAI,CAAC,IAAY;YACjB,IAAI,CAAC,KAAa;SACrB,CAAC;IACN,CAAC;IAEa,YAAK,GAAnB,UAAoB,MAAe;QAC/B,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,eAAS,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,eAAS,CAAC,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,eAAS,CAAC,EAAE,CAAC,CAAC;IACpH,CAAC;IAEa,YAAK,GAAnB,UAAoB,QAAQ,EAAE,KAAK,EAAE,MAAe;QAChD,IAAM,IAAI,GAAY,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,eAAS,CAAC,GAAG,CAAC;QACvD,IAAI,IAAI;YACJ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,cAAc;QACvC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,aAAa;QAElC,IAAM,eAAe,GAAG,UAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAChF,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,UAAI,CAAC,aAAa,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC,CAAC;IAC3E,CAAC;IACL,aAAC;AAAD,CAAC,AAvCD,CAA4B,WAAI,GAuC/B;AAvCY,wBAAM"}

package/dist/AST/IndexNode.d.ts

@@ -0,0 +1,16 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { Token, TreeNode } from "../AST";
+import { Node } from "./Node";
+export declare class IndexNode extends Node implements TreeNode {
+    readonly object: Node;
+    readonly index: Node;
+    readonly indexTwo: Node;
+    constructor(object: Node, index: Node, indexTwo?: Node);
+    protected _getChildNodes(): Node[];
+    negativeIndex(obj: any[], index: number | string): number | string;
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any>;
+    static match(tokens: Token[]): boolean;
+    static parse(lastNode: any, token: any, tokens: Token[]): IndexNode;
+}

package/dist/AST/IndexNode.js

@@ -0,0 +1,126 @@
+"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 __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.IndexNode = void 0;
+var AST_1 = require("../AST");
+var Node_1 = require("./Node");
+var IndexNode = /** @class */ (function (_super) {
+    __extends(IndexNode, _super);
+    function IndexNode(object, index, indexTwo) {
+        if (indexTwo === void 0) { indexTwo = null; }
+        var _this = _super.call(this) || this;
+        _this.object = object;
+        _this.index = index;
+        _this.indexTwo = indexTwo;
+        return _this;
+    }
+    IndexNode.prototype._getChildNodes = function () {
+        var children = [
+            this.object,
+            this.index
+        ];
+        if (this.indexTwo)
+            children.push(this.indexTwo);
+        return children;
+    };
+    IndexNode.prototype.negativeIndex = function (obj, index) {
+        if (Number.isFinite(index) && index < 0)
+            return obj.length + index;
+        return index;
+    };
+    IndexNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, index, _a, _b, indexTwo, _c, _d, values, i;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this.object.evaluate(scope, dom, tag)];
+                    case 1:
+                        obj = _e.sent();
+                        _a = this.negativeIndex;
+                        _b = [obj];
+                        return [4 /*yield*/, this.index.evaluate(scope, dom, tag)];
+                    case 2:
+                        index = _a.apply(this, _b.concat([_e.sent()]));
+                        if (!(Number.isFinite(index) && this.indexTwo)) return [3 /*break*/, 4];
+                        _c = this.negativeIndex;
+                        _d = [obj];
+                        return [4 /*yield*/, this.indexTwo.evaluate(scope, dom, tag)];
+                    case 3:
+                        indexTwo = _c.apply(this, _d.concat([_e.sent()]));
+                        values = [];
+                        for (i = index; i <= indexTwo; i++) {
+                            values.push(obj[i]);
+                        }
+                        return [2 /*return*/, values];
+                    case 4: return [2 /*return*/, (obj)[index]];
+                }
+            });
+        });
+    };
+    IndexNode.match = function (tokens) {
+        return tokens[0].type === AST_1.TokenType.L_BRACKET;
+    };
+    IndexNode.parse = function (lastNode, token, tokens) {
+        var valueTokens = AST_1.Tree.getBlockTokens(tokens, AST_1.TokenType.COLON);
+        var values = [];
+        for (var _i = 0, valueTokens_1 = valueTokens; _i < valueTokens_1.length; _i++) {
+            var arg = valueTokens_1[_i];
+            values.push(AST_1.Tree.processTokens(arg));
+        }
+        return new IndexNode(lastNode, values[0], values.length > 1 && values[1]);
+    };
+    return IndexNode;
+}(Node_1.Node));
+exports.IndexNode = IndexNode;
+//# sourceMappingURL=IndexNode.js.map

package/dist/AST/IndexNode.js.map

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

package/dist/AST/LiteralNode.d.ts

@@ -0,0 +1,10 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { TreeNode } from "../AST";
+import { Node } from "./Node";
+export declare class LiteralNode<T = any> extends Node implements TreeNode {
+    readonly value: T;
+    constructor(value: T);
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<T>;
+}

package/dist/AST/LiteralNode.js

@@ -0,0 +1,74 @@
+"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 __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.LiteralNode = void 0;
+var Node_1 = require("./Node");
+var LiteralNode = /** @class */ (function (_super) {
+    __extends(LiteralNode, _super);
+    function LiteralNode(value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        return _this;
+    }
+    LiteralNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.value];
+            });
+        });
+    };
+    return LiteralNode;
+}(Node_1.Node));
+exports.LiteralNode = LiteralNode;
+//# sourceMappingURL=LiteralNode.js.map

package/dist/AST/LiteralNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiteralNode.js","sourceRoot":"","sources":["../../src/AST/LiteralNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,+BAA4B;AAE5B;IAA0C,+BAAI;IAC1C,qBACoB,KAAQ;QAD5B,YAGI,iBAAO,SACV;QAHmB,WAAK,GAAL,KAAK,CAAG;;IAG5B,CAAC;IAEY,8BAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;gBACzD,sBAAO,IAAI,CAAC,KAAK,EAAC;;;KACrB;IACL,kBAAC;AAAD,CAAC,AAVD,CAA0C,WAAI,GAU7C;AAVY,kCAAW"}

package/dist/AST/Node.d.ts

@@ -0,0 +1,19 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { TreeNode } from "../AST";
+export declare abstract class Node implements TreeNode {
+    protected requiresPrep: boolean;
+    protected _isPreparationRequired: boolean;
+    protected childNodes: Node[];
+    protected nodeCache: {
+        [key: string]: Node[];
+    };
+    abstract evaluate(scope: Scope, dom: DOM, tag?: Tag): any;
+    isPreparationRequired(): boolean;
+    prepare(scope: Scope, dom: DOM, tag?: Tag): Promise<void>;
+    protected _getChildNodes(): Node[];
+    getChildNodes(): Node[];
+    findChildrenByType<T = Node>(t: any): T[];
+    findChildrenByTypes<T = Node>(types: any[], cacheKey?: string): T[];
+}