vsn 0.1.26 → 0.1.29

package/dist/AST/BlockNode.js

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

package/dist/AST/BlockNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockNode.js","sourceRoot":"","sources":["../../src/AST/BlockNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,+BAA4B;AAE5B;IAA+B,6BAAI;IAC/B,mBACoB,UAAkB;QADtC,YAGI,iBAAO,SACV;QAHmB,gBAAU,GAAV,UAAU,CAAQ;;IAGtC,CAAC;IAES,kCAAc,GAAxB;QACI,yBAAY,IAAI,CAAC,UAAqB,EAAE;IAC5C,CAAC;IAEY,4BAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;;wBACrD,WAAW,GAAQ,IAAI,CAAC;wBACnB,CAAC,GAAG,CAAC;;;6BAAE,CAAA,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAA;wBACxB,qBAAM,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAhE,WAAW,GAAG,SAAkD,CAAC;;;wBADzB,CAAC,EAAE,CAAA;;4BAG/C,sBAAO,WAAW,EAAC;;;;KACtB;IACL,gBAAC;AAAD,CAAC,AAlBD,CAA+B,WAAI,GAkBlC;AAlBY,8BAAS"}

package/dist/AST/BooleanLiteralNode.d.ts

@@ -0,0 +1,5 @@
+import { LiteralNode } from "./LiteralNode";
+export declare class BooleanLiteralNode extends LiteralNode<number> {
+    readonly value: any;
+    constructor(value: any);
+}

package/dist/AST/BooleanLiteralNode.js

@@ -0,0 +1,31 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanLiteralNode = void 0;
+var LiteralNode_1 = require("./LiteralNode");
+var BooleanLiteralNode = /** @class */ (function (_super) {
+    __extends(BooleanLiteralNode, _super);
+    function BooleanLiteralNode(value) {
+        var _this = _super.call(this, value) || this;
+        _this.value = value;
+        _this.value = value === 'true';
+        return _this;
+    }
+    return BooleanLiteralNode;
+}(LiteralNode_1.LiteralNode));
+exports.BooleanLiteralNode = BooleanLiteralNode;
+//# sourceMappingURL=BooleanLiteralNode.js.map

package/dist/AST/BooleanLiteralNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanLiteralNode.js","sourceRoot":"","sources":["../../src/AST/BooleanLiteralNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,6CAA0C;AAE1C;IAAwC,sCAAmB;IACvD,4BACoB,KAAU;QAD9B,YAGI,kBAAM,KAAK,CAAC,SAEf;QAJmB,WAAK,GAAL,KAAK,CAAK;QAG1B,KAAI,CAAC,KAAK,GAAG,KAAK,KAAK,MAAM,CAAC;;IAClC,CAAC;IACL,yBAAC;AAAD,CAAC,AAPD,CAAwC,yBAAW,GAOlD;AAPY,gDAAkB"}

package/dist/AST/ComparisonNode.d.ts

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

package/dist/AST/ComparisonNode.js

@@ -0,0 +1,120 @@
+"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.ComparisonNode = void 0;
+var AST_1 = require("../AST");
+var Node_1 = require("./Node");
+var ComparisonNode = /** @class */ (function (_super) {
+    __extends(ComparisonNode, _super);
+    function ComparisonNode(left, right, type) {
+        var _this = _super.call(this) || this;
+        _this.left = left;
+        _this.right = right;
+        _this.type = type;
+        return _this;
+    }
+    ComparisonNode.prototype._getChildNodes = function () {
+        return [
+            this.left,
+            this.right
+        ];
+    };
+    ComparisonNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var left, right;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.left.evaluate(scope, dom, tag)];
+                    case 1:
+                        left = _a.sent();
+                        return [4 /*yield*/, this.right.evaluate(scope, dom, tag)];
+                    case 2:
+                        right = _a.sent();
+                        switch (this.type) {
+                            case AST_1.TokenType.EQUALS:
+                                return [2 /*return*/, left === right];
+                            case AST_1.TokenType.NOT_EQUALS:
+                                return [2 /*return*/, left !== right];
+                            case AST_1.TokenType.GREATER_THAN:
+                                return [2 /*return*/, left > right];
+                            case AST_1.TokenType.LESS_THAN:
+                                return [2 /*return*/, left < right];
+                            case AST_1.TokenType.GREATER_THAN_EQUAL:
+                                return [2 /*return*/, left >= right];
+                            case AST_1.TokenType.LESS_THAN_EQUAL:
+                                return [2 /*return*/, left <= right];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ComparisonNode.match = function (tokens) {
+        return [
+            AST_1.TokenType.EQUALS,
+            AST_1.TokenType.NOT_EQUALS,
+            AST_1.TokenType.GREATER_THAN,
+            AST_1.TokenType.LESS_THAN,
+            AST_1.TokenType.GREATER_THAN_EQUAL,
+            AST_1.TokenType.LESS_THAN_EQUAL
+        ].indexOf(tokens[0].type) > -1;
+    };
+    ComparisonNode.parse = function (lastNode, token, tokens) {
+        tokens.splice(0, 1); // Remove comparison operator
+        return new ComparisonNode(lastNode, AST_1.Tree.processTokens(AST_1.Tree.getNextStatementTokens(tokens)), token.type);
+    };
+    return ComparisonNode;
+}(Node_1.Node));
+exports.ComparisonNode = ComparisonNode;
+//# sourceMappingURL=ComparisonNode.js.map

package/dist/AST/ComparisonNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComparisonNode.js","sourceRoot":"","sources":["../../src/AST/ComparisonNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,8BAAwD;AACxD,+BAA4B;AAE5B;IAAoC,kCAAI;IACpC,wBACoB,IAAU,EACV,KAAW,EACX,IAAe;QAHnC,YAKI,iBAAO,SACV;QALmB,UAAI,GAAJ,IAAI,CAAM;QACV,WAAK,GAAL,KAAK,CAAM;QACX,UAAI,GAAJ,IAAI,CAAW;;IAGnC,CAAC;IAES,uCAAc,GAAxB;QACI,OAAO;YACH,IAAI,CAAC,IAAY;YACjB,IAAI,CAAC,KAAa;SACrB,CAAC;IACN,CAAC;IAEY,iCAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;4BACvC,qBAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAArD,IAAI,GAAQ,SAAyC;wBACxC,qBAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAAvD,KAAK,GAAQ,SAA0C;wBAC7D,QAAQ,IAAI,CAAC,IAAI,EAAE;4BACf,KAAK,eAAS,CAAC,MAAM;gCACjB,sBAAO,IAAI,KAAK,KAAK,EAAC;4BAC1B,KAAK,eAAS,CAAC,UAAU;gCACrB,sBAAO,IAAI,KAAK,KAAK,EAAC;4BAC1B,KAAK,eAAS,CAAC,YAAY;gCACvB,sBAAO,IAAI,GAAG,KAAK,EAAC;4BACxB,KAAK,eAAS,CAAC,SAAS;gCACpB,sBAAO,IAAI,GAAG,KAAK,EAAC;4BACxB,KAAK,eAAS,CAAC,kBAAkB;gCAC7B,sBAAO,IAAI,IAAI,KAAK,EAAC;4BACzB,KAAK,eAAS,CAAC,eAAe;gCAC1B,sBAAO,IAAI,IAAI,KAAK,EAAC;yBAC5B;;;;;KACJ;IAEa,oBAAK,GAAnB,UAAoB,MAAe;QAC/B,OAAO;YACH,eAAS,CAAC,MAAM;YAChB,eAAS,CAAC,UAAU;YACpB,eAAS,CAAC,YAAY;YACtB,eAAS,CAAC,SAAS;YACnB,eAAS,CAAC,kBAAkB;YAC5B,eAAS,CAAC,eAAe;SAC5B,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA;IAClC,CAAC;IAEa,oBAAK,GAAnB,UAAoB,QAAQ,EAAE,KAAK,EAAE,MAAe;QAChD,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,6BAA6B;QAClD,OAAO,IAAI,cAAc,CAAC,QAAQ,EAAE,UAAI,CAAC,aAAa,CAAC,UAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;IAC5G,CAAC;IACL,qBAAC;AAAD,CAAC,AAlDD,CAAoC,WAAI,GAkDvC;AAlDY,wCAAc"}

package/dist/AST/ConditionalNode.d.ts

@@ -0,0 +1,13 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { TreeNode } from "../AST";
+import { BlockNode } from "./BlockNode";
+import { Node } from "./Node";
+export declare class ConditionalNode extends Node implements TreeNode {
+    readonly condition: Node;
+    readonly block: BlockNode;
+    constructor(condition: Node, block: BlockNode);
+    protected _getChildNodes(): Node[];
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<boolean>;
+}

package/dist/AST/ConditionalNode.js

@@ -0,0 +1,95 @@
+"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.ConditionalNode = void 0;
+var WrappedArray_1 = require("../Scope/WrappedArray");
+var Node_1 = require("./Node");
+var ConditionalNode = /** @class */ (function (_super) {
+    __extends(ConditionalNode, _super);
+    function ConditionalNode(condition, block) {
+        var _this = _super.call(this) || this;
+        _this.condition = condition;
+        _this.block = block;
+        return _this;
+    }
+    ConditionalNode.prototype._getChildNodes = function () {
+        return [
+            this.condition,
+            this.block
+        ];
+    };
+    ConditionalNode.prototype.evaluate = function (scope, dom, tag) {
+        if (tag === void 0) { tag = null; }
+        return __awaiter(this, void 0, void 0, function () {
+            var condition, evaluation;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.condition.evaluate(scope, dom, tag)];
+                    case 1:
+                        condition = _a.sent();
+                        evaluation = false;
+                        if (condition instanceof WrappedArray_1.WrappedArray) {
+                            evaluation = condition.length > 0;
+                        }
+                        else {
+                            evaluation = !!condition;
+                        }
+                        return [2 /*return*/, evaluation];
+                }
+            });
+        });
+    };
+    return ConditionalNode;
+}(Node_1.Node));
+exports.ConditionalNode = ConditionalNode;
+//# sourceMappingURL=ConditionalNode.js.map

package/dist/AST/ConditionalNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionalNode.js","sourceRoot":"","sources":["../../src/AST/ConditionalNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,sDAAmD;AAGnD,+BAA4B;AAE5B;IAAqC,mCAAI;IACrC,yBACoB,SAAe,EACf,KAAgB;QAFpC,YAII,iBAAO,SACV;QAJmB,eAAS,GAAT,SAAS,CAAM;QACf,WAAK,GAAL,KAAK,CAAW;;IAGpC,CAAC;IAES,wCAAc,GAAxB;QACI,OAAO;YACH,IAAI,CAAC,SAAiB;YACtB,IAAI,CAAC,KAAa;SACrB,CAAC;IACN,CAAC;IAEY,kCAAQ,GAArB,UAAsB,KAAY,EAAE,GAAQ,EAAE,GAAe;QAAf,oBAAA,EAAA,UAAe;;;;;4BACvC,qBAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,EAAA;;wBAA1D,SAAS,GAAG,SAA8C;wBAC5D,UAAU,GAAG,KAAK,CAAC;wBAEvB,IAAI,SAAS,YAAY,2BAAY,EAAE;4BACnC,UAAU,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;yBACrC;6BAAM;4BACH,UAAU,GAAG,CAAC,CAAC,SAAS,CAAC;yBAC5B;wBAED,sBAAO,UAAU,EAAC;;;;KACrB;IACL,sBAAC;AAAD,CAAC,AA3BD,CAAqC,WAAI,GA2BxC;AA3BY,0CAAe"}

package/dist/AST/ElementAttributeNode.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 ElementAttributeNode 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/ElementAttributeNode.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.ElementAttributeNode = void 0;
+var List_1 = require("../Tag/List");
+var Node_1 = require("./Node");
+var LiteralNode_1 = require("./LiteralNode");
+var ElementAttributeNode = /** @class */ (function (_super) {
+    __extends(ElementAttributeNode, _super);
+    function ElementAttributeNode(elementRef, attr) {
+        var _this = _super.call(this) || this;
+        _this.elementRef = elementRef;
+        _this.attr = attr;
+        _this.requiresPrep = true;
+        return _this;
+    }
+    Object.defineProperty(ElementAttributeNode.prototype, "name", {
+        get: function () {
+            return new LiteralNode_1.LiteralNode("@" + this.attributeName);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ElementAttributeNode.prototype._getChildNodes = function () {
+        var nodes = [];
+        if (this.elementRef)
+            nodes.push(this.elementRef);
+        return nodes;
+    };
+    Object.defineProperty(ElementAttributeNode.prototype, "attributeName", {
+        get: function () {
+            if (this.attr.startsWith('.'))
+                return this.attr.substring(2);
+            return this.attr.substring(1);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ElementAttributeNode.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)];
+                    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); })];
+                }
+            });
+        });
+    };
+    ElementAttributeNode.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)];
+                    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.watchAttribute(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.watchAttribute(this.attributeName)];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ElementAttributeNode;
+}(Node_1.Node));
+exports.ElementAttributeNode = ElementAttributeNode;
+//# sourceMappingURL=ElementAttributeNode.js.map

package/dist/AST/ElementAttributeNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementAttributeNode.js","sourceRoot":"","sources":["../../src/AST/ElementAttributeNode.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,oCAAoC;AAEpC,+BAA4B;AAE5B,6CAA0C;AAE1C;IAA0C,wCAAI;IAG1C,8BACoB,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,sCAAI;aAAf;YACI,OAAO,IAAI,yBAAW,CAAS,MAAI,IAAI,CAAC,aAAe,CAAC,CAAC;QAC7D,CAAC;;;OAAA;IAES,6CAAc,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,+CAAa;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,uCAAQ,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,CAAC,EAAA;;wBAAtD,IAAI,GAAG,SAA+C,CAAC;;;wBACpD,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,sCAAO,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,CAAC,EAAA;;wBAA/D,IAAI,GAAY,SAA+C;8BACjD,EAAJ,aAAI;;;6BAAJ,CAAA,kBAAI,CAAA;wBAAT,CAAC;wBACR,qBAAM,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAA;;wBAA1C,SAA0C,CAAC;;;wBAD/B,IAAI,CAAA;;;;6BAEd,GAAG,EAAH,wBAAG;wBACT,qBAAM,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAA;;wBAA5C,SAA4C,CAAC;;;;;;KAEpD;IACL,2BAAC;AAAD,CAAC,AArDD,CAA0C,WAAI,GAqD7C;AArDY,oDAAoB"}

package/dist/AST/ElementQueryNode.d.ts

@@ -0,0 +1,12 @@
+import { Scope } from "../Scope";
+import { DOM } from "../DOM";
+import { Tag } from "../Tag";
+import { TreeNode } from "../AST";
+import { Node } from "./Node";
+export declare class ElementQueryNode extends Node implements TreeNode {
+    readonly query: string;
+    protected requiresPrep: boolean;
+    constructor(query: string);
+    evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<import("../Tag/List").TagList>;
+    prepare(scope: Scope, dom: DOM, tag?: Tag): Promise<void>;
+}