vsn 0.1.27 → 0.1.30

package/dist/AST/ElementQueryNode.js

@@ -0,0 +1,116 @@
+"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.ElementQueryNode = void 0;
+var Node_1 = require("./Node");
+var ElementQueryNode = /** @class */ (function (_super) {
+    __extends(ElementQueryNode, _super);
+    function ElementQueryNode(query, first) {
+        if (first === void 0) { first = false; }
+        var _this = _super.call(this) || this;
+        _this.query = query;
+        _this.first = first;
+        _this.requiresPrep = true;
+        return _this;
+    }
+    ElementQueryNode.prototype.evaluate = function (scope, dom, tag, forceList) {
+        if (tag === void 0) { tag = null; }
+        if (forceList === void 0) { forceList = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, elements;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = tag;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, dom.getTagForScope(scope)];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        tag = _a;
+                        return [4 /*yield*/, dom.get(this.query, true, tag)];
+                    case 3:
+                        elements = _b.sent();
+                        return [2 /*return*/, this.first && !forceList ? elements[0] : elements];
+                }
+            });
+        });
+    };
+    ElementQueryNode.prototype.prepare = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = tag;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, dom.getTagForScope(scope)];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        tag = _a;
+                        return [4 /*yield*/, dom.get(this.query, true, tag)];
+                    case 3:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ElementQueryNode;
+}(Node_1.Node));
+exports.ElementQueryNode = ElementQueryNode;
+//# sourceMappingURL=ElementQueryNode.js.map

package/dist/AST/ElementQueryNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementQueryNode.js","sourceRoot":"","sources":["../../src/AST/ElementQueryNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,+BAA4B;AAE5B;IAAsC,oCAAI;IAGtC,0BACoB,KAAa,EACb,KAAsB;QAAtB,sBAAA,EAAA,aAAsB;QAF1C,YAII,iBAAO,SACV;QAJmB,WAAK,GAAL,KAAK,CAAQ;QACb,WAAK,GAAL,KAAK,CAAiB;QAJhC,kBAAY,GAAY,IAAI,CAAC;;IAOvC,CAAC;IAEK,mCAAQ,GAAd,UAAe,KAAY,EAAE,GAAQ,EAAE,GAAe,EAAE,SAA0B;QAA3C,oBAAA,EAAA,UAAe;QAAE,0BAAA,EAAA,iBAA0B;;;;;;wBACxE,KAAA,GAAG,CAAA;gCAAH,wBAAG;wBAAI,qBAAM,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC,EAAA;;8BAA/B,SAA+B;;;wBAA5C,GAAG,KAAyC,CAAC;wBAC5B,qBAAM,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,EAAA;;wBAA/C,QAAQ,GAAG,SAAoC;wBACrD,sBAAO,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAC;;;;KAC5D;IAEK,kCAAO,GAAb,UAAc,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;;wBAC3C,KAAA,GAAG,CAAA;gCAAH,wBAAG;wBAAI,qBAAM,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC,EAAA;;8BAA/B,SAA+B;;;wBAA5C,GAAG,KAAyC,CAAC;wBAC7C,qBAAM,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,EAAA;;wBAApC,SAAoC,CAAC;;;;;KACxC;IACL,uBAAC;AAAD,CAAC,AApBD,CAAsC,WAAI,GAoBzC;AApBY,4CAAgB"}

package/dist/AST/ElementStyleNode.d.ts

@@ -0,0 +1,18 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { TreeNode } from "../AST";
+import { Node } from "./Node";
+import { ElementQueryNode } from "./ElementQueryNode";
+import { LiteralNode } from "./LiteralNode";
+export declare class ElementStyleNode extends Node implements TreeNode {
+    readonly elementRef: ElementQueryNode | null;
+    readonly attr: string;
+    protected requiresPrep: boolean;
+    constructor(elementRef: ElementQueryNode | null, attr: string);
+    get name(): LiteralNode<string>;
+    protected _getChildNodes(): Node[];
+    get attributeName(): string;
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any>;
+    prepare(scope: Scope, dom: DOM, tag?: Tag): Promise<void>;
+}

package/dist/AST/ElementStyleNode.js

@@ -0,0 +1,159 @@
+"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.ElementStyleNode = void 0;
+var List_1 = require("../Tag/List");
+var Node_1 = require("./Node");
+var LiteralNode_1 = require("./LiteralNode");
+var ElementStyleNode = /** @class */ (function (_super) {
+    __extends(ElementStyleNode, _super);
+    function ElementStyleNode(elementRef, attr) {
+        var _this = _super.call(this) || this;
+        _this.elementRef = elementRef;
+        _this.attr = attr;
+        _this.requiresPrep = true;
+        return _this;
+    }
+    Object.defineProperty(ElementStyleNode.prototype, "name", {
+        get: function () {
+            return new LiteralNode_1.LiteralNode("$" + this.attributeName);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ElementStyleNode.prototype._getChildNodes = function () {
+        var nodes = [];
+        if (this.elementRef)
+            nodes.push(this.elementRef);
+        return nodes;
+    };
+    Object.defineProperty(ElementStyleNode.prototype, "attributeName", {
+        get: function () {
+            if (this.attr.startsWith('.'))
+                return this.attr.substring(2);
+            return this.attr.substring(1);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ElementStyleNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tags;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.elementRef) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.elementRef.evaluate(scope, dom, tag, true)];
+                    case 1:
+                        tags = _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        if (tag) {
+                            tags = new List_1.TagList(tag);
+                        }
+                        else {
+                            return [2 /*return*/];
+                        }
+                        _a.label = 3;
+                    case 3:
+                        if (tags.length === 1)
+                            return [2 /*return*/, tags[0].scope.get("$" + this.attributeName)];
+                        return [2 /*return*/, tags.map(function (tag) { return tag.scope.get("$" + _this.attributeName); })];
+                }
+            });
+        });
+    };
+    ElementStyleNode.prototype.prepare = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tags, _i, tags_1, t;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.elementRef) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.elementRef.prepare(scope, dom, tag)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.elementRef.evaluate(scope, dom, tag, true)];
+                    case 2:
+                        tags = _a.sent();
+                        _i = 0, tags_1 = tags;
+                        _a.label = 3;
+                    case 3:
+                        if (!(_i < tags_1.length)) return [3 /*break*/, 6];
+                        t = tags_1[_i];
+                        return [4 /*yield*/, t.watchStyle(this.attributeName)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        if (!tag) return [3 /*break*/, 9];
+                        return [4 /*yield*/, tag.watchStyle(this.attributeName)];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ElementStyleNode;
+}(Node_1.Node));
+exports.ElementStyleNode = ElementStyleNode;
+//# sourceMappingURL=ElementStyleNode.js.map

package/dist/AST/ElementStyleNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementStyleNode.js","sourceRoot":"","sources":["../../src/AST/ElementStyleNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,oCAAoC;AAEpC,+BAA4B;AAE5B,6CAA0C;AAE1C;IAAsC,oCAAI;IAGtC,0BACoB,UAAmC,EACnC,IAAY;QAFhC,YAII,iBAAO,SACV;QAJmB,gBAAU,GAAV,UAAU,CAAyB;QACnC,UAAI,GAAJ,IAAI,CAAQ;QAJtB,kBAAY,GAAY,IAAI,CAAC;;IAOvC,CAAC;IAED,sBAAW,kCAAI;aAAf;YACI,OAAO,IAAI,yBAAW,CAAS,MAAI,IAAI,CAAC,aAAe,CAAC,CAAC;QAC7D,CAAC;;;OAAA;IAES,yCAAc,GAAxB;QACI,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,IAAI,IAAI,CAAC,UAAU;YACf,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,sBAAI,2CAAa;aAAjB;YACI,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;gBACzB,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAClC,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QAClC,CAAC;;;OAAA;IAEK,mCAAQ,GAAd,UAAe,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;;;6BAE9C,IAAI,CAAC,UAAU,EAAf,wBAAe;wBACR,qBAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAA;;wBAA5D,IAAI,GAAG,SAAqD,CAAC;;;wBAC1D,IAAI,GAAG,EAAE;4BACZ,IAAI,GAAG,IAAI,cAAO,CAAC,GAAG,CAAC,CAAA;yBAC1B;6BAAM;4BACH,sBAAO;yBACV;;;wBAED,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;4BACjB,sBAAO,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,MAAI,IAAI,CAAC,aAAe,CAAC,EAAC;wBAEvD,sBAAO,IAAI,CAAC,GAAG,CAAC,UAAC,GAAG,IAAK,OAAA,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,MAAI,KAAI,CAAC,aAAe,CAAC,EAAvC,CAAuC,CAAC,EAAC;;;;KACrE;IAEK,kCAAO,GAAb,UAAc,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;;6BAC7C,IAAI,CAAC,UAAU,EAAf,wBAAe;wBACf,qBAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA9C,SAA8C,CAAC;wBACzB,qBAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAA;;wBAArE,IAAI,GAAY,SAAqD;8BACvD,EAAJ,aAAI;;;6BAAJ,CAAA,kBAAI,CAAA;wBAAT,CAAC;wBACR,qBAAM,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,EAAA;;wBAAtC,SAAsC,CAAC;;;wBAD3B,IAAI,CAAA;;;;6BAEd,GAAG,EAAH,wBAAG;wBACT,qBAAM,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,EAAA;;wBAAxC,SAAwC,CAAC;;;;;;KAEhD;IACL,uBAAC;AAAD,CAAC,AArDD,CAAsC,WAAI,GAqDzC;AArDY,4CAAgB"}

package/dist/AST/ForStatementNode.d.ts

@@ -0,0 +1,17 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { Token, TreeNode } from "../AST";
+import { Node } from "./Node";
+import { LiteralNode } from "./LiteralNode";
+import { RootScopeMemberNode } from "./RootScopeMemberNode";
+import { ScopeMemberNode } from "./ScopeMemberNode";
+export declare class ForStatementNode extends Node implements TreeNode {
+    readonly variable: LiteralNode<string>;
+    readonly list: RootScopeMemberNode | ScopeMemberNode;
+    readonly block: RootScopeMemberNode | ScopeMemberNode;
+    constructor(variable: LiteralNode<string>, list: RootScopeMemberNode | ScopeMemberNode, block: RootScopeMemberNode | ScopeMemberNode);
+    protected _getChildNodes(): Node[];
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any>;
+    static parse(lastNode: any, token: any, tokens: Token[]): ForStatementNode;
+}

package/dist/AST/ForStatementNode.js

@@ -0,0 +1,121 @@
+"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.ForStatementNode = void 0;
+var AST_1 = require("../AST");
+var Node_1 = require("./Node");
+var LiteralNode_1 = require("./LiteralNode");
+var ForStatementNode = /** @class */ (function (_super) {
+    __extends(ForStatementNode, _super);
+    function ForStatementNode(variable, list, block) {
+        var _this = _super.call(this) || this;
+        _this.variable = variable;
+        _this.list = list;
+        _this.block = block;
+        return _this;
+    }
+    ForStatementNode.prototype._getChildNodes = function () {
+        return [
+            this.variable,
+            this.list,
+            this.block
+        ];
+    };
+    ForStatementNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var variable, list, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.variable.evaluate(scope, dom, tag)];
+                    case 1:
+                        variable = _a.sent();
+                        return [4 /*yield*/, this.list.evaluate(scope, dom, tag)];
+                    case 2:
+                        list = _a.sent();
+                        i = 0;
+                        _a.label = 3;
+                    case 3:
+                        if (!(i < list.length)) return [3 /*break*/, 6];
+                        scope.set(variable, list[i]);
+                        return [4 /*yield*/, this.block.evaluate(scope, dom, tag)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        i++;
+                        return [3 /*break*/, 3];
+                    case 6: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    ForStatementNode.parse = function (lastNode, token, tokens) {
+        if (tokens[1].type !== AST_1.TokenType.L_PAREN) {
+            throw SyntaxError('Syntax error: Missing (');
+        }
+        if (tokens[3].type !== AST_1.TokenType.OF) {
+            throw SyntaxError('Syntax error: Missing of');
+        }
+        tokens.splice(0, 1); // consume for
+        var loopDef = AST_1.Tree.getNextStatementTokens(tokens);
+        var variableName = loopDef.splice(0, 1)[0];
+        loopDef.splice(0, 1); // consume of
+        var list = AST_1.Tree.processTokens(loopDef);
+        var block = AST_1.Tree.processTokens(AST_1.Tree.getBlockTokens(tokens, null)[0]);
+        return new ForStatementNode(new LiteralNode_1.LiteralNode(variableName.value), list, block);
+    };
+    return ForStatementNode;
+}(Node_1.Node));
+exports.ForStatementNode = ForStatementNode;
+//# sourceMappingURL=ForStatementNode.js.map

package/dist/AST/ForStatementNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForStatementNode.js","sourceRoot":"","sources":["../../src/AST/ForStatementNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,8BAAwD;AACxD,+BAA4B;AAC5B,6CAA0C;AAI1C;IAAsC,oCAAI;IACtC,0BACoB,QAA6B,EAC7B,IAA2C,EAC3C,KAA4C;QAHhE,YAKI,iBAAO,SACV;QALmB,cAAQ,GAAR,QAAQ,CAAqB;QAC7B,UAAI,GAAJ,IAAI,CAAuC;QAC3C,WAAK,GAAL,KAAK,CAAuC;;IAGhE,CAAC;IAES,yCAAc,GAAxB;QACI,OAAO;YACH,IAAI,CAAC,QAAQ;YACb,IAAI,CAAC,IAAI;YACT,IAAI,CAAC,KAAK;SACb,CAAC;IACN,CAAC;IAEY,mCAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;4BAChC,qBAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAhE,QAAQ,GAAW,SAA6C;wBAClD,qBAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAvD,IAAI,GAAU,SAAyC;wBACpD,CAAC,GAAG,CAAC;;;6BAAC,CAAA,CAAC,GAAG,IAAI,CAAC,MAAM,CAAA;wBAC1B,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC7B,qBAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA1C,SAA0C,CAAC;;;wBAFf,CAAC,EAAE,CAAA;;4BAKnC,sBAAO,IAAI,EAAC;;;;KACf;IAEa,sBAAK,GAAnB,UAAoB,QAAQ,EAAE,KAAK,EAAE,MAAe;QAChD,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,eAAS,CAAC,OAAO,EAAE;YACtC,MAAM,WAAW,CAAC,yBAAyB,CAAC,CAAC;SAChD;QACD,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,eAAS,CAAC,EAAE,EAAE;YACjC,MAAM,WAAW,CAAC,0BAA0B,CAAC,CAAC;SACjD;QAED,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,cAAc;QACnC,IAAM,OAAO,GAAY,UAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;QAC7D,IAAM,YAAY,GAAU,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,aAAa;QACnC,IAAM,IAAI,GAAa,UAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACnD,IAAM,KAAK,GAAa,UAAI,CAAC,aAAa,CAAC,UAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEjF,OAAO,IAAI,gBAAgB,CACvB,IAAI,yBAAW,CAAS,YAAY,CAAC,KAAK,CAAC,EAC3C,IAAW,EACX,KAAY,CACf,CAAC;IACN,CAAC;IACL,uBAAC;AAAD,CAAC,AAjDD,CAAsC,WAAI,GAiDzC;AAjDY,4CAAgB"}

package/dist/AST/FunctionArgumentNode.d.ts

@@ -0,0 +1,11 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { TreeNode } from "../AST";
+import { Node } from "./Node";
+export declare class FunctionArgumentNode<T = any> extends Node implements TreeNode {
+    protected args: Node[];
+    constructor(args: Node[]);
+    protected _getChildNodes(): Node[];
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any[]>;
+}

package/dist/AST/FunctionArgumentNode.js

@@ -0,0 +1,100 @@
+"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.FunctionArgumentNode = void 0;
+var Node_1 = require("./Node");
+var FunctionArgumentNode = /** @class */ (function (_super) {
+    __extends(FunctionArgumentNode, _super);
+    function FunctionArgumentNode(args) {
+        var _this = _super.call(this) || this;
+        _this.args = args;
+        return _this;
+    }
+    FunctionArgumentNode.prototype._getChildNodes = function () {
+        return __spreadArray([], this.args);
+    };
+    FunctionArgumentNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var values, _i, _a, arg, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        values = [];
+                        _i = 0, _a = this.args;
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        arg = _a[_i];
+                        _c = (_b = values).push;
+                        return [4 /*yield*/, arg.evaluate(scope, dom, tag)];
+                    case 2:
+                        _c.apply(_b, [_d.sent()]);
+                        _d.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, values];
+                }
+            });
+        });
+    };
+    return FunctionArgumentNode;
+}(Node_1.Node));
+exports.FunctionArgumentNode = FunctionArgumentNode;
+//# sourceMappingURL=FunctionArgumentNode.js.map

package/dist/AST/FunctionArgumentNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionArgumentNode.js","sourceRoot":"","sources":["../../src/AST/FunctionArgumentNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,+BAA4B;AAE5B;IAAmD,wCAAI;IACnD,8BACc,IAAY;QAD1B,YAGI,iBAAO,SACV;QAHa,UAAI,GAAJ,IAAI,CAAQ;;IAG1B,CAAC;IAES,6CAAc,GAAxB;QACI,yBACQ,IAAI,CAAC,IAAe,EAC3B;IACL,CAAC;IAEK,uCAAQ,GAAd,UAAe,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;;wBAC5C,MAAM,GAAU,EAAE,CAAC;8BACE,EAAT,KAAA,IAAI,CAAC,IAAI;;;6BAAT,CAAA,cAAS,CAAA;wBAAhB,GAAG;wBACV,KAAA,CAAA,KAAA,MAAM,CAAA,CAAC,IAAI,CAAA;wBAAC,qBAAM,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA/C,cAAY,SAAmC,EAAC,CAAC;;;wBADnC,IAAS,CAAA;;4BAG3B,sBAAO,MAAM,EAAC;;;;KACjB;IACL,2BAAC;AAAD,CAAC,AApBD,CAAmD,WAAI,GAoBtD;AApBY,oDAAoB"}

package/dist/AST/FunctionCallNode.d.ts

@@ -0,0 +1,13 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { TreeNode } from "../AST";
+import { Node } from "./Node";
+import { FunctionArgumentNode } from "./FunctionArgumentNode";
+export declare class FunctionCallNode<T = any> extends Node implements TreeNode {
+    readonly fnc: TreeNode<(...args: any[]) => any>;
+    readonly args: FunctionArgumentNode<any[]>;
+    constructor(fnc: TreeNode<(...args: any[]) => any>, args: FunctionArgumentNode<any[]>);
+    protected _getChildNodes(): Node[];
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any>;
+}