vsn 0.1.125 → 0.1.127

package/dist/AST/ElementQueryNode.d.ts

@@ -1,8 +1,9 @@
 import { Scope } from "../Scope";
-import { DOM, EQuerySelectDirection } from "../DOM";
+import { DOM } from "../DOM";
 import { Tag } from "../Tag";
 import { Token, TreeNode } from "../AST";
 import { Node } from "./Node";
+import { EQuerySelectDirection } from "../DOM/AbstractDOM";
 export declare class ElementQueryNode extends Node implements TreeNode {
     readonly query: string;
     readonly first: boolean;

package/dist/AST/ElementQueryNode.js

@@ -52,13 +52,13 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElementQueryNode = void 0;
-var DOM_1 = require("../DOM");
 var Node_1 = require("./Node");
+var AbstractDOM_1 = require("../DOM/AbstractDOM");
 var ElementQueryNode = /** @class */ (function (_super) {
     __extends(ElementQueryNode, _super);
     function ElementQueryNode(query, first, direction) {
         if (first === void 0) { first = false; }
-        if (direction === void 0) { direction = DOM_1.EQuerySelectDirection.ALL; }
+        if (direction === void 0) { direction = AbstractDOM_1.EQuerySelectDirection.ALL; }
         var _this = _super.call(this) || this;
         _this.query = query;
         _this.first = first;
@@ -117,12 +117,12 @@ var ElementQueryNode = /** @class */ (function (_super) {
     ElementQueryNode.parse = function (lastNode, token, tokens) {
         tokens.shift();
         var first = false;
-        var direction = DOM_1.EQuerySelectDirection.ALL;
+        var direction = AbstractDOM_1.EQuerySelectDirection.ALL;
         if (token.full.startsWith('?>')) {
-            direction = DOM_1.EQuerySelectDirection.DOWN;
+            direction = AbstractDOM_1.EQuerySelectDirection.DOWN;
         }
         else if (token.full.startsWith('?<')) {
-            direction = DOM_1.EQuerySelectDirection.UP;
+            direction = AbstractDOM_1.EQuerySelectDirection.UP;
             first = true;
         }
         return new ElementQueryNode(token.value, first, direction);

package/dist/AST/ElementQueryNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"ElementQueryNode.js","sourceRoot":"","sources":["../../src/AST/ElementQueryNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,8BAAkD;AAGlD,+BAA4B;AAE5B;IAAsC,oCAAI;IAGtC,0BACoB,KAAa,EACb,KAAsB,EACtB,SAA4D;QAD5D,sBAAA,EAAA,aAAsB;QACtB,0BAAA,EAAA,YAAmC,2BAAqB,CAAC,GAAG;QAHhF,YAKI,iBAAO,SACV;QALmB,WAAK,GAAL,KAAK,CAAQ;QACb,WAAK,GAAL,KAAK,CAAiB;QACtB,eAAS,GAAT,SAAS,CAAmD;QALtE,kBAAY,GAAY,IAAI,CAAC;;IAQvC,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,EAAE,IAAI,CAAC,SAAS,CAAC,EAAA;;wBAA/D,QAAQ,GAAG,SAAoD;wBACrE,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,EAAE,IAAgB;QAAjC,oBAAA,EAAA,UAAe;QAAE,qBAAA,EAAA,WAAgB;;;;;;wBAC7D,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;IAEa,sBAAK,GAAnB,UAAoB,QAAQ,EAAE,KAAK,EAAE,MAAe;QAChD,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,SAAS,GAAG,2BAAqB,CAAC,GAAG,CAAC;QAC1C,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YAC7B,SAAS,GAAG,2BAAqB,CAAC,IAAI,CAAC;SAC1C;aAAM,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACpC,SAAS,GAAG,2BAAqB,CAAC,EAAE,CAAC;YACrC,KAAK,GAAG,IAAI,CAAC;SAChB;QACD,OAAO,IAAI,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IAC/D,CAAC;IACL,uBAAC;AAAD,CAAC,AAlCD,CAAsC,WAAI,GAkCzC;AAlCY,4CAAgB"}
+{"version":3,"file":"ElementQueryNode.js","sourceRoot":"","sources":["../../src/AST/ElementQueryNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,+BAA4B;AAC5B,kDAAyD;AAEzD;IAAsC,oCAAI;IAGtC,0BACoB,KAAa,EACb,KAAsB,EACtB,SAA4D;QAD5D,sBAAA,EAAA,aAAsB;QACtB,0BAAA,EAAA,YAAmC,mCAAqB,CAAC,GAAG;QAHhF,YAKI,iBAAO,SACV;QALmB,WAAK,GAAL,KAAK,CAAQ;QACb,WAAK,GAAL,KAAK,CAAiB;QACtB,eAAS,GAAT,SAAS,CAAmD;QALtE,kBAAY,GAAY,IAAI,CAAC;;IAQvC,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,EAAE,IAAI,CAAC,SAAS,CAAC,EAAA;;wBAA/D,QAAQ,GAAG,SAAoD;wBACrE,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,EAAE,IAAgB;QAAjC,oBAAA,EAAA,UAAe;QAAE,qBAAA,EAAA,WAAgB;;;;;;wBAC7D,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;IAEa,sBAAK,GAAnB,UAAoB,QAAQ,EAAE,KAAK,EAAE,MAAe;QAChD,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,SAAS,GAAG,mCAAqB,CAAC,GAAG,CAAC;QAC1C,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YAC7B,SAAS,GAAG,mCAAqB,CAAC,IAAI,CAAC;SAC1C;aAAM,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACpC,SAAS,GAAG,mCAAqB,CAAC,EAAE,CAAC;YACrC,KAAK,GAAG,IAAI,CAAC;SAChB;QACD,OAAO,IAAI,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IAC/D,CAAC;IACL,uBAAC;AAAD,CAAC,AAlCD,CAAsC,WAAI,GAkCzC;AAlCY,4CAAgB"}

package/dist/AST/FunctionNode.d.ts

@@ -16,5 +16,5 @@ export declare class FunctionNode extends Node implements TreeNode {
     evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<(...args: any[]) => Promise<any>>;
     collectGarbage(): Promise<void>;
     getFunction(scope: Scope, dom: DOM, tag?: Tag, createFunctionScope?: boolean): Promise<(...args: any[]) => Promise<any>>;
-    static parse<T = FunctionNode>(lastNode: any, token: any, tokens: Token[], cls?: any): FunctionNode;
+    static parse<T = FunctionNode>(lastNode: any, token: any, tokens: Token[], cls?: any): T;
 }

package/dist/AST/LoopNode.d.ts

@@ -0,0 +1,12 @@
+import { Token, TreeNode } from "../AST";
+import { FunctionNode } from "./FunctionNode";
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+export declare class LoopNode extends FunctionNode implements TreeNode {
+    protected looping?: boolean;
+    prepare(scope: Scope, dom: DOM, tag: Tag, meta: any): Promise<void>;
+    loop(func: any): Promise<void>;
+    setTimeout(func: any, time?: number): void;
+    static parse<T = LoopNode>(lastNode: any, token: any, tokens: Token[]): T;
+}

package/dist/AST/LoopNode.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.LoopNode = void 0;
+var FunctionNode_1 = require("./FunctionNode");
+var LoopNode = /** @class */ (function (_super) {
+    __extends(LoopNode, _super);
+    function LoopNode() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.looping = true;
+        return _this;
+    }
+    LoopNode.prototype.prepare = function (scope, dom, tag, meta) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var classPrep, func;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        classPrep = meta === null || meta === void 0 ? void 0 : meta.ClassNodePrepare;
+                        if (!(tag && !classPrep)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getFunction(tag.scope || scope, dom, tag)];
+                    case 1:
+                        func = _a.sent();
+                        this.setTimeout(func);
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, _super.prototype.prepare.call(this, scope, dom, tag, meta)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LoopNode.prototype.loop = function (func) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.looping) return [3 /*break*/, 2];
+                        return [4 /*yield*/, func()];
+                    case 1:
+                        _a.sent();
+                        this.setTimeout(func);
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LoopNode.prototype.setTimeout = function (func, time) {
+        var _this = this;
+        if (time === void 0) { time = 33; }
+        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.loop(func)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, time);
+    };
+    LoopNode.parse = function (lastNode, token, tokens) {
+        return _super.parse.call(this, lastNode, token, tokens, LoopNode);
+    };
+    return LoopNode;
+}(FunctionNode_1.FunctionNode));
+exports.LoopNode = LoopNode;
+//# sourceMappingURL=LoopNode.js.map

package/dist/AST/LoopNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoopNode.js","sourceRoot":"","sources":["../../src/AST/LoopNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,+CAA4C;AAK5C;IAA8B,4BAAY;IAA1C;QAAA,qEA4BC;QA3Ba,aAAO,GAAa,IAAI,CAAC;;IA2BvC,CAAC;IAzBgB,0BAAO,GAApB,UAAqB,KAAY,EAAE,GAAQ,EAAE,GAAe,EAAE,IAAI;QAArB,oBAAA,EAAA,UAAe;;;;;;wBAClD,SAAS,GAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,gBAAgB,CAAC;6BACrC,CAAA,GAAG,IAAI,CAAC,SAAS,CAAA,EAAjB,wBAAiB;wBACJ,qBAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,IAAI,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA3D,IAAI,GAAG,SAAoD;wBACjE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;;4BAE1B,qBAAM,iBAAM,OAAO,YAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAA;;wBAA1C,SAA0C,CAAC;;;;;KAC9C;IAEK,uBAAI,GAAV,UAAW,IAAI;;;;;6BACP,IAAI,CAAC,OAAO,EAAZ,wBAAY;wBACZ,qBAAM,IAAI,EAAE,EAAA;;wBAAZ,SAAY,CAAC;wBACb,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;;;;;;KAE7B;IAED,6BAAU,GAAV,UAAW,IAAI,EAAE,IAAiB;QAAlC,iBAIC;QAJgB,qBAAA,EAAA,SAAiB;QAC9B,UAAU,CAAC;;;4BACP,qBAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAA;;wBAArB,SAAqB,CAAC;;;;aACzB,EAAE,IAAI,CAAC,CAAC;IACb,CAAC;IAEa,cAAK,GAAnB,UAAkC,QAAQ,EAAE,KAAK,EAAE,MAAe;QAC9D,OAAO,OAAM,KAAK,YAAI,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC;IACL,eAAC;AAAD,CAAC,AA5BD,CAA8B,2BAAY,GA4BzC;AA5BY,4BAAQ"}

package/dist/AST/OnNode.d.ts

@@ -5,5 +5,5 @@ import { DOM } from "../DOM";
 import { Tag } from "../Tag";
 export declare class OnNode extends FunctionNode implements TreeNode {
     prepare(scope: Scope, dom: DOM, tag: Tag, meta: any): Promise<void>;
-    static parse(lastNode: any, token: any, tokens: Token[]): OnNode;
+    static parse<T = OnNode>(lastNode: any, token: any, tokens: Token[]): T;
 }

package/dist/AST/OnNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"OnNode.js","sourceRoot":"","sources":["../../src/AST/OnNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,+CAA4C;AAK5C;IAA4B,0BAAY;IAAxC;;IAgBA,CAAC;IAfgB,wBAAO,GAApB,UAAqB,KAAY,EAAE,GAAQ,EAAE,GAAe,EAAE,IAAI;QAArB,oBAAA,EAAA,UAAe;;;;;;;wBAClD,SAAS,GAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,gBAAgB,CAAC;6BACrC,CAAA,GAAG,IAAI,CAAC,SAAS,CAAA,EAAjB,wBAAiB;wBACJ,qBAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA9C,SAAO,SAAuC;wBACpD,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE;4BAAO,cAAO;iCAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;gCAAP,yBAAO;;;;;gDACzD,qBAAM,MAAI,wCAAI,IAAI,KAAC;;4CAAnB,SAAmB,CAAC;4CACpB,qBAAM,IAAI,CAAC,cAAc,EAAE,EAAA;;4CAA3B,SAA2B,CAAC;;;;;yBAC/B,EAAE,IAAI,CAAC,CAAC;;4BAEb,qBAAM,iBAAM,OAAO,YAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAA;;wBAA1C,SAA0C,CAAC;;;;;KAC9C;IAEa,YAAK,GAAnB,UAAoB,QAAQ,EAAE,KAAK,EAAE,MAAe;QAChD,OAAO,OAAM,KAAK,YAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC;IACL,aAAC;AAAD,CAAC,AAhBD,CAA4B,2BAAY,GAgBvC;AAhBY,wBAAM"}
+{"version":3,"file":"OnNode.js","sourceRoot":"","sources":["../../src/AST/OnNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,+CAA4C;AAK5C;IAA4B,0BAAY;IAAxC;;IAgBA,CAAC;IAfgB,wBAAO,GAApB,UAAqB,KAAY,EAAE,GAAQ,EAAE,GAAe,EAAE,IAAI;QAArB,oBAAA,EAAA,UAAe;;;;;;;wBAClD,SAAS,GAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,gBAAgB,CAAC;6BACrC,CAAA,GAAG,IAAI,CAAC,SAAS,CAAA,EAAjB,wBAAiB;wBACJ,qBAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA9C,SAAO,SAAuC;wBACpD,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE;4BAAO,cAAO;iCAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;gCAAP,yBAAO;;;;;gDACzD,qBAAM,MAAI,wCAAI,IAAI,KAAC;;4CAAnB,SAAmB,CAAC;4CACpB,qBAAM,IAAI,CAAC,cAAc,EAAE,EAAA;;4CAA3B,SAA2B,CAAC;;;;;yBAC/B,EAAE,IAAI,CAAC,CAAC;;4BAEb,qBAAM,iBAAM,OAAO,YAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAA;;wBAA1C,SAA0C,CAAC;;;;;KAC9C;IAEa,YAAK,GAAnB,UAAgC,QAAQ,EAAE,KAAK,EAAE,MAAe;QAC5D,OAAO,OAAM,KAAK,YAAI,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3D,CAAC;IACL,aAAC;AAAD,CAAC,AAhBD,CAA4B,2BAAY,GAgBvC;AAhBY,wBAAM"}

package/dist/AST.d.ts

@@ -25,68 +25,70 @@ export declare enum TokenType {
     TYPE_UINT = 3,
     TYPE_FLOAT = 4,
     TYPE_STRING = 5,
-    RETURN = 6,
-    NOT = 7,
-    OF = 8,
-    AS = 9,
-    IN = 10,
-    WITH = 11,
-    NAMED_STACK = 12,
-    FOR = 13,
-    IF = 14,
-    ELSE_IF = 15,
-    ELSE = 16,
-    FUNC = 17,
-    ON = 18,
-    CLASS = 19,
-    NAME = 20,
-    L_BRACE = 21,
-    R_BRACE = 22,
-    L_BRACKET = 23,
-    R_BRACKET = 24,
-    L_PAREN = 25,
-    R_PAREN = 26,
-    TILDE = 27,
-    PERIOD = 28,
-    COMMA = 29,
-    COLON = 30,
-    SEMICOLON = 31,
-    STRING_FORMAT = 32,
-    STRING_LITERAL = 33,
-    NUMBER_LITERAL = 34,
-    BOOLEAN_LITERAL = 35,
-    NULL_LITERAL = 36,
-    STRICT_EQUALS = 37,
-    STRICT_NOT_EQUALS = 38,
-    EQUALS = 39,
-    NOT_EQUALS = 40,
-    GREATER_THAN_EQUAL = 41,
-    LESS_THAN_EQUAL = 42,
-    GREATER_THAN = 43,
-    LESS_THAN = 44,
-    ASSIGN = 45,
-    AND = 46,
-    OR = 47,
-    ADD = 48,
-    SUBTRACT = 49,
-    MULTIPLY = 50,
-    DIVIDE = 51,
-    ADD_ASSIGN = 52,
-    SUBTRACT_ASSIGN = 53,
-    MULTIPLY_ASSIGN = 54,
-    DIVIDE_ASSIGN = 55,
-    EXCLAMATION_POINT = 56,
-    ELEMENT_REFERENCE = 57,
-    ELEMENT_ATTRIBUTE = 58,
-    ELEMENT_STYLE = 59,
-    ELEMENT_QUERY = 60,
-    UNIT = 61,
-    XHR_GET = 62,
-    XHR_POST = 63,
-    XHR_PUT = 64,
-    XHR_DELETE = 65,
-    MODIFIER = 66,
-    DISPATCH_EVENT = 67
+    TYPE_BOOL = 6,
+    RETURN = 7,
+    NOT = 8,
+    OF = 9,
+    AS = 10,
+    IN = 11,
+    WITH = 12,
+    NAMED_STACK = 13,
+    FOR = 14,
+    IF = 15,
+    ELSE_IF = 16,
+    ELSE = 17,
+    FUNC = 18,
+    LOOP = 19,
+    ON = 20,
+    CLASS = 21,
+    NAME = 22,
+    L_BRACE = 23,
+    R_BRACE = 24,
+    L_BRACKET = 25,
+    R_BRACKET = 26,
+    L_PAREN = 27,
+    R_PAREN = 28,
+    TILDE = 29,
+    PERIOD = 30,
+    COMMA = 31,
+    COLON = 32,
+    SEMICOLON = 33,
+    STRING_FORMAT = 34,
+    STRING_LITERAL = 35,
+    NUMBER_LITERAL = 36,
+    BOOLEAN_LITERAL = 37,
+    NULL_LITERAL = 38,
+    STRICT_EQUALS = 39,
+    STRICT_NOT_EQUALS = 40,
+    EQUALS = 41,
+    NOT_EQUALS = 42,
+    GREATER_THAN_EQUAL = 43,
+    LESS_THAN_EQUAL = 44,
+    GREATER_THAN = 45,
+    LESS_THAN = 46,
+    ASSIGN = 47,
+    AND = 48,
+    OR = 49,
+    ADD = 50,
+    SUBTRACT = 51,
+    MULTIPLY = 52,
+    DIVIDE = 53,
+    ADD_ASSIGN = 54,
+    SUBTRACT_ASSIGN = 55,
+    MULTIPLY_ASSIGN = 56,
+    DIVIDE_ASSIGN = 57,
+    EXCLAMATION_POINT = 58,
+    ELEMENT_REFERENCE = 59,
+    ELEMENT_ATTRIBUTE = 60,
+    ELEMENT_STYLE = 61,
+    ELEMENT_QUERY = 62,
+    UNIT = 63,
+    XHR_GET = 64,
+    XHR_POST = 65,
+    XHR_PUT = 66,
+    XHR_DELETE = 67,
+    MODIFIER = 68,
+    DISPATCH_EVENT = 69
 }
 export interface TreeNode<T = any> {
     evaluate(scope: Scope, dom: DOM, tag?: Tag): any;

package/dist/AST.js

@@ -80,6 +80,7 @@ var DispatchEventNode_1 = require("./AST/DispatchEventNode");
 var WithNode_1 = require("./AST/WithNode");
 var AsNode_1 = require("./AST/AsNode");
 var NamedStackNode_1 = require("./AST/NamedStackNode");
+var LoopNode_1 = require("./AST/LoopNode");
 function lower(str) {
     return str ? str.toLowerCase() : null;
 }
@@ -98,68 +99,70 @@ var TokenType;
     TokenType[TokenType["TYPE_UINT"] = 3] = "TYPE_UINT";
     TokenType[TokenType["TYPE_FLOAT"] = 4] = "TYPE_FLOAT";
     TokenType[TokenType["TYPE_STRING"] = 5] = "TYPE_STRING";
-    TokenType[TokenType["RETURN"] = 6] = "RETURN";
-    TokenType[TokenType["NOT"] = 7] = "NOT";
-    TokenType[TokenType["OF"] = 8] = "OF";
-    TokenType[TokenType["AS"] = 9] = "AS";
-    TokenType[TokenType["IN"] = 10] = "IN";
-    TokenType[TokenType["WITH"] = 11] = "WITH";
-    TokenType[TokenType["NAMED_STACK"] = 12] = "NAMED_STACK";
-    TokenType[TokenType["FOR"] = 13] = "FOR";
-    TokenType[TokenType["IF"] = 14] = "IF";
-    TokenType[TokenType["ELSE_IF"] = 15] = "ELSE_IF";
-    TokenType[TokenType["ELSE"] = 16] = "ELSE";
-    TokenType[TokenType["FUNC"] = 17] = "FUNC";
-    TokenType[TokenType["ON"] = 18] = "ON";
-    TokenType[TokenType["CLASS"] = 19] = "CLASS";
-    TokenType[TokenType["NAME"] = 20] = "NAME";
-    TokenType[TokenType["L_BRACE"] = 21] = "L_BRACE";
-    TokenType[TokenType["R_BRACE"] = 22] = "R_BRACE";
-    TokenType[TokenType["L_BRACKET"] = 23] = "L_BRACKET";
-    TokenType[TokenType["R_BRACKET"] = 24] = "R_BRACKET";
-    TokenType[TokenType["L_PAREN"] = 25] = "L_PAREN";
-    TokenType[TokenType["R_PAREN"] = 26] = "R_PAREN";
-    TokenType[TokenType["TILDE"] = 27] = "TILDE";
-    TokenType[TokenType["PERIOD"] = 28] = "PERIOD";
-    TokenType[TokenType["COMMA"] = 29] = "COMMA";
-    TokenType[TokenType["COLON"] = 30] = "COLON";
-    TokenType[TokenType["SEMICOLON"] = 31] = "SEMICOLON";
-    TokenType[TokenType["STRING_FORMAT"] = 32] = "STRING_FORMAT";
-    TokenType[TokenType["STRING_LITERAL"] = 33] = "STRING_LITERAL";
-    TokenType[TokenType["NUMBER_LITERAL"] = 34] = "NUMBER_LITERAL";
-    TokenType[TokenType["BOOLEAN_LITERAL"] = 35] = "BOOLEAN_LITERAL";
-    TokenType[TokenType["NULL_LITERAL"] = 36] = "NULL_LITERAL";
-    TokenType[TokenType["STRICT_EQUALS"] = 37] = "STRICT_EQUALS";
-    TokenType[TokenType["STRICT_NOT_EQUALS"] = 38] = "STRICT_NOT_EQUALS";
-    TokenType[TokenType["EQUALS"] = 39] = "EQUALS";
-    TokenType[TokenType["NOT_EQUALS"] = 40] = "NOT_EQUALS";
-    TokenType[TokenType["GREATER_THAN_EQUAL"] = 41] = "GREATER_THAN_EQUAL";
-    TokenType[TokenType["LESS_THAN_EQUAL"] = 42] = "LESS_THAN_EQUAL";
-    TokenType[TokenType["GREATER_THAN"] = 43] = "GREATER_THAN";
-    TokenType[TokenType["LESS_THAN"] = 44] = "LESS_THAN";
-    TokenType[TokenType["ASSIGN"] = 45] = "ASSIGN";
-    TokenType[TokenType["AND"] = 46] = "AND";
-    TokenType[TokenType["OR"] = 47] = "OR";
-    TokenType[TokenType["ADD"] = 48] = "ADD";
-    TokenType[TokenType["SUBTRACT"] = 49] = "SUBTRACT";
-    TokenType[TokenType["MULTIPLY"] = 50] = "MULTIPLY";
-    TokenType[TokenType["DIVIDE"] = 51] = "DIVIDE";
-    TokenType[TokenType["ADD_ASSIGN"] = 52] = "ADD_ASSIGN";
-    TokenType[TokenType["SUBTRACT_ASSIGN"] = 53] = "SUBTRACT_ASSIGN";
-    TokenType[TokenType["MULTIPLY_ASSIGN"] = 54] = "MULTIPLY_ASSIGN";
-    TokenType[TokenType["DIVIDE_ASSIGN"] = 55] = "DIVIDE_ASSIGN";
-    TokenType[TokenType["EXCLAMATION_POINT"] = 56] = "EXCLAMATION_POINT";
-    TokenType[TokenType["ELEMENT_REFERENCE"] = 57] = "ELEMENT_REFERENCE";
-    TokenType[TokenType["ELEMENT_ATTRIBUTE"] = 58] = "ELEMENT_ATTRIBUTE";
-    TokenType[TokenType["ELEMENT_STYLE"] = 59] = "ELEMENT_STYLE";
-    TokenType[TokenType["ELEMENT_QUERY"] = 60] = "ELEMENT_QUERY";
-    TokenType[TokenType["UNIT"] = 61] = "UNIT";
-    TokenType[TokenType["XHR_GET"] = 62] = "XHR_GET";
-    TokenType[TokenType["XHR_POST"] = 63] = "XHR_POST";
-    TokenType[TokenType["XHR_PUT"] = 64] = "XHR_PUT";
-    TokenType[TokenType["XHR_DELETE"] = 65] = "XHR_DELETE";
-    TokenType[TokenType["MODIFIER"] = 66] = "MODIFIER";
-    TokenType[TokenType["DISPATCH_EVENT"] = 67] = "DISPATCH_EVENT";
+    TokenType[TokenType["TYPE_BOOL"] = 6] = "TYPE_BOOL";
+    TokenType[TokenType["RETURN"] = 7] = "RETURN";
+    TokenType[TokenType["NOT"] = 8] = "NOT";
+    TokenType[TokenType["OF"] = 9] = "OF";
+    TokenType[TokenType["AS"] = 10] = "AS";
+    TokenType[TokenType["IN"] = 11] = "IN";
+    TokenType[TokenType["WITH"] = 12] = "WITH";
+    TokenType[TokenType["NAMED_STACK"] = 13] = "NAMED_STACK";
+    TokenType[TokenType["FOR"] = 14] = "FOR";
+    TokenType[TokenType["IF"] = 15] = "IF";
+    TokenType[TokenType["ELSE_IF"] = 16] = "ELSE_IF";
+    TokenType[TokenType["ELSE"] = 17] = "ELSE";
+    TokenType[TokenType["FUNC"] = 18] = "FUNC";
+    TokenType[TokenType["LOOP"] = 19] = "LOOP";
+    TokenType[TokenType["ON"] = 20] = "ON";
+    TokenType[TokenType["CLASS"] = 21] = "CLASS";
+    TokenType[TokenType["NAME"] = 22] = "NAME";
+    TokenType[TokenType["L_BRACE"] = 23] = "L_BRACE";
+    TokenType[TokenType["R_BRACE"] = 24] = "R_BRACE";
+    TokenType[TokenType["L_BRACKET"] = 25] = "L_BRACKET";
+    TokenType[TokenType["R_BRACKET"] = 26] = "R_BRACKET";
+    TokenType[TokenType["L_PAREN"] = 27] = "L_PAREN";
+    TokenType[TokenType["R_PAREN"] = 28] = "R_PAREN";
+    TokenType[TokenType["TILDE"] = 29] = "TILDE";
+    TokenType[TokenType["PERIOD"] = 30] = "PERIOD";
+    TokenType[TokenType["COMMA"] = 31] = "COMMA";
+    TokenType[TokenType["COLON"] = 32] = "COLON";
+    TokenType[TokenType["SEMICOLON"] = 33] = "SEMICOLON";
+    TokenType[TokenType["STRING_FORMAT"] = 34] = "STRING_FORMAT";
+    TokenType[TokenType["STRING_LITERAL"] = 35] = "STRING_LITERAL";
+    TokenType[TokenType["NUMBER_LITERAL"] = 36] = "NUMBER_LITERAL";
+    TokenType[TokenType["BOOLEAN_LITERAL"] = 37] = "BOOLEAN_LITERAL";
+    TokenType[TokenType["NULL_LITERAL"] = 38] = "NULL_LITERAL";
+    TokenType[TokenType["STRICT_EQUALS"] = 39] = "STRICT_EQUALS";
+    TokenType[TokenType["STRICT_NOT_EQUALS"] = 40] = "STRICT_NOT_EQUALS";
+    TokenType[TokenType["EQUALS"] = 41] = "EQUALS";
+    TokenType[TokenType["NOT_EQUALS"] = 42] = "NOT_EQUALS";
+    TokenType[TokenType["GREATER_THAN_EQUAL"] = 43] = "GREATER_THAN_EQUAL";
+    TokenType[TokenType["LESS_THAN_EQUAL"] = 44] = "LESS_THAN_EQUAL";
+    TokenType[TokenType["GREATER_THAN"] = 45] = "GREATER_THAN";
+    TokenType[TokenType["LESS_THAN"] = 46] = "LESS_THAN";
+    TokenType[TokenType["ASSIGN"] = 47] = "ASSIGN";
+    TokenType[TokenType["AND"] = 48] = "AND";
+    TokenType[TokenType["OR"] = 49] = "OR";
+    TokenType[TokenType["ADD"] = 50] = "ADD";
+    TokenType[TokenType["SUBTRACT"] = 51] = "SUBTRACT";
+    TokenType[TokenType["MULTIPLY"] = 52] = "MULTIPLY";
+    TokenType[TokenType["DIVIDE"] = 53] = "DIVIDE";
+    TokenType[TokenType["ADD_ASSIGN"] = 54] = "ADD_ASSIGN";
+    TokenType[TokenType["SUBTRACT_ASSIGN"] = 55] = "SUBTRACT_ASSIGN";
+    TokenType[TokenType["MULTIPLY_ASSIGN"] = 56] = "MULTIPLY_ASSIGN";
+    TokenType[TokenType["DIVIDE_ASSIGN"] = 57] = "DIVIDE_ASSIGN";
+    TokenType[TokenType["EXCLAMATION_POINT"] = 58] = "EXCLAMATION_POINT";
+    TokenType[TokenType["ELEMENT_REFERENCE"] = 59] = "ELEMENT_REFERENCE";
+    TokenType[TokenType["ELEMENT_ATTRIBUTE"] = 60] = "ELEMENT_ATTRIBUTE";
+    TokenType[TokenType["ELEMENT_STYLE"] = 61] = "ELEMENT_STYLE";
+    TokenType[TokenType["ELEMENT_QUERY"] = 62] = "ELEMENT_QUERY";
+    TokenType[TokenType["UNIT"] = 63] = "UNIT";
+    TokenType[TokenType["XHR_GET"] = 64] = "XHR_GET";
+    TokenType[TokenType["XHR_POST"] = 65] = "XHR_POST";
+    TokenType[TokenType["XHR_PUT"] = 66] = "XHR_PUT";
+    TokenType[TokenType["XHR_DELETE"] = 67] = "XHR_DELETE";
+    TokenType[TokenType["MODIFIER"] = 68] = "MODIFIER";
+    TokenType[TokenType["DISPATCH_EVENT"] = 69] = "DISPATCH_EVENT";
 })(TokenType = exports.TokenType || (exports.TokenType = {}));
 var TOKEN_PATTERNS = [
     {
@@ -188,23 +191,23 @@ var TOKEN_PATTERNS = [
     },
     {
         type: TokenType.TYPE_INT,
-        pattern: /^int+/
+        pattern: /^int\s/
     },
     {
         type: TokenType.TYPE_UINT,
-        pattern: /^uint+/
+        pattern: /^uint\s/
     },
     {
         type: TokenType.TYPE_FLOAT,
-        pattern: /^float+/
+        pattern: /^float\s/
     },
     {
-        type: TokenType.UNIT,
-        pattern: /^\d+\.?\d?(?:cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)/
+        type: TokenType.TYPE_BOOL,
+        pattern: /^bool\s/
     },
     {
-        type: TokenType.TYPE_STRING,
-        pattern: /^string+/
+        type: TokenType.UNIT,
+        pattern: /^\d+\.?\d?(?:cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)/
     },
     {
         type: TokenType.BOOLEAN_LITERAL,
@@ -262,6 +265,10 @@ var TOKEN_PATTERNS = [
         type: TokenType.FUNC,
         pattern: /^func\s/
     },
+    {
+        type: TokenType.LOOP,
+        pattern: /^loop\s/
+    },
     {
         type: TokenType.ON,
         pattern: /^on\s/
@@ -657,6 +664,12 @@ var Tree = /** @class */ (function () {
                 blockNodes.push(node);
                 node = null;
             }
+            else if (token.type === TokenType.LOOP) {
+                node = LoopNode_1.LoopNode.parse(node, token, tokens);
+                lastBlock = node;
+                blockNodes.push(node);
+                node = null;
+            }
             else if (token.type === TokenType.ON) {
                 node = OnNode_1.OnNode.parse(node, token, tokens);
                 lastBlock = node;