vsn 0.1.122 → 0.1.124

package/dist/DOM.js

@@ -50,6 +50,33 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 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];
@@ -182,6 +209,7 @@ var DOM = /** @class */ (function (_super) {
         return tag.element.closest(q);
     };
     DOM.prototype.querySelectPath = function (path, element) {
+        var e_1, _a;
         if (element === void 0) { element = null; }
         var current = path.shift();
         if (!current)
@@ -189,9 +217,18 @@ var DOM = /** @class */ (function (_super) {
         var elements = Array.from(element ? this.querySelectorElement(element, current) : this.querySelectorAll(current));
         if (path.length > 0) {
             var result = [];
-            for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
-                var _element = elements_1[_i];
-                result.push.apply(result, this.querySelectPath(__spreadArray([], path), _element));
+            try {
+                for (var elements_1 = __values(elements), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
+                    var _element = elements_1_1.value;
+                    result.push.apply(result, __spreadArray([], __read(this.querySelectPath(__spreadArray([], __read(path)), _element))));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
             return result;
         }
@@ -203,20 +240,30 @@ var DOM = /** @class */ (function (_super) {
         return this.querySelectorElement(element, q);
     };
     DOM.prototype.querySelectorElement = function (element, q) {
+        var e_2, _a;
         var parentIndex = q.indexOf(':parent');
         if (parentIndex > -1) {
             var _q = q.substring(0, parentIndex);
             var rest = q.substring(parentIndex + 7);
             if (_q.length > 0) {
                 var nodeList = [];
-                for (var _i = 0, _a = Array.from(this.querySelectorElement(element, _q)); _i < _a.length; _i++) {
-                    var _element = _a[_i];
-                    if (rest.length > 0) {
-                        nodeList.push.apply(nodeList, Array.from(this.querySelectorElement(DOM.getParentElement(_element), rest)));
+                try {
+                    for (var _b = __values(Array.from(this.querySelectorElement(element, _q))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var _element = _c.value;
+                        if (rest.length > 0) {
+                            nodeList.push.apply(nodeList, __spreadArray([], __read(Array.from(this.querySelectorElement(DOM.getParentElement(_element), rest)))));
+                        }
+                        else {
+                            nodeList.push(DOM.getParentElement(_element));
+                        }
                     }
-                    else {
-                        nodeList.push(DOM.getParentElement(_element));
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                     }
+                    finally { if (e_2) throw e_2.error; }
                 }
                 return nodeList;
             }
@@ -254,70 +301,110 @@ var DOM = /** @class */ (function (_super) {
     };
     DOM.prototype.evaluate = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, _a, tag;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var _a, _b, tag, e_3_1;
+            var e_3, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         clearTimeout(this.evaluateTimeout);
-                        _i = 0, _a = this.tags;
-                        _b.label = 1;
+                        _d.label = 1;
                     case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 4];
-                        tag = _a[_i];
-                        return [4 /*yield*/, tag.evaluate()];
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = __values(this.tags), _b = _a.next();
+                        _d.label = 2;
                     case 2:
-                        _b.sent();
-                        _b.label = 3;
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        tag = _b.value;
+                        return [4 /*yield*/, tag.evaluate()];
                     case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/];
+                        _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_3_1 = _d.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
                 }
             });
         });
     };
     DOM.prototype.mutation = function (mutations) {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, mutations_1, mutation, tag, _a, _b, ele, toRemove;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var mutations_1, mutations_1_1, mutation, tag, _a, _b, ele, toRemove, e_4_1, e_5_1;
+            var e_5, _c, e_4, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
-                        _i = 0, mutations_1 = mutations;
-                        _c.label = 1;
+                        _e.trys.push([0, 13, 14, 15]);
+                        mutations_1 = __values(mutations), mutations_1_1 = mutations_1.next();
+                        _e.label = 1;
                     case 1:
-                        if (!(_i < mutations_1.length)) return [3 /*break*/, 9];
-                        mutation = mutations_1[_i];
+                        if (!!mutations_1_1.done) return [3 /*break*/, 12];
+                        mutation = mutations_1_1.value;
                         return [4 /*yield*/, this.getTagForElement(mutation.target)];
                     case 2:
-                        tag = _c.sent();
+                        tag = _e.sent();
                         if (tag) {
                             tag.mutate(mutation);
                         }
                         if (!(mutation.type === 'attributes' && mutation.attributeName === 'class')) return [3 /*break*/, 4];
                         return [4 /*yield*/, ClassNode_1.ClassNode.checkForClassChanges(mutation.target, this, tag)];
                     case 3:
-                        _c.sent();
-                        _c.label = 4;
+                        _e.sent();
+                        _e.label = 4;
                     case 4:
-                        _a = 0, _b = Array.from(mutation.removedNodes);
-                        _c.label = 5;
+                        _e.trys.push([4, 9, 10, 11]);
+                        _a = (e_4 = void 0, __values(Array.from(mutation.removedNodes))), _b = _a.next();
+                        _e.label = 5;
                     case 5:
-                        if (!(_a < _b.length)) return [3 /*break*/, 8];
-                        ele = _b[_a];
+                        if (!!_b.done) return [3 /*break*/, 8];
+                        ele = _b.value;
                         return [4 /*yield*/, this.getTagForElement(ele)];
                     case 6:
-                        toRemove = _c.sent();
+                        toRemove = _e.sent();
                         if (toRemove) {
                             toRemove.deconstruct();
                         }
-                        _c.label = 7;
+                        _e.label = 7;
                     case 7:
-                        _a++;
+                        _b = _a.next();
                         return [3 /*break*/, 5];
-                    case 8:
-                        _i++;
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        e_4_1 = _e.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 11];
+                    case 10:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 11:
+                        mutations_1_1 = mutations_1.next();
                         return [3 /*break*/, 1];
-                    case 9: return [2 /*return*/];
+                    case 12: return [3 /*break*/, 15];
+                    case 13:
+                        e_5_1 = _e.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 15];
+                    case 14:
+                        try {
+                            if (mutations_1_1 && !mutations_1_1.done && (_c = mutations_1.return)) _c.call(mutations_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 15: return [2 /*return*/];
                 }
             });
         });
@@ -345,12 +432,22 @@ var DOM = /** @class */ (function (_super) {
                     return true;
                 };
                 scanChildren = function (e) {
-                    for (var _i = 0, _a = Array.from(e.children); _i < _a.length; _i++) {
-                        var element = _a[_i];
-                        if (!checkElement(element))
-                            continue;
-                        if (element.tagName.toLowerCase() !== 'template')
-                            scanChildren(element);
+                    var e_6, _a;
+                    try {
+                        for (var _b = __values(Array.from(e.children)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var element = _c.value;
+                            if (!checkElement(element))
+                                continue;
+                            if (element.tagName.toLowerCase() !== 'template')
+                                scanChildren(element);
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        }
+                        finally { if (e_6) throw e_6.error; }
                     }
                 };
                 checkElement(ele);
@@ -379,97 +476,179 @@ var DOM = /** @class */ (function (_super) {
     };
     DOM.prototype.setupTags = function (tags) {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, tags_1, tag, _a, tags_2, tag, _b, tags_3, tag, _c, tags_4, tag, _d, tags_5, tag, _e, tags_6, tag, _f, tags_7, tag;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
+            var tags_1, tags_1_1, tag, e_7_1, tags_2, tags_2_1, tag, e_8_1, tags_3, tags_3_1, tag, e_9_1, tags_4, tags_4_1, tag, e_10_1, tags_5, tags_5_1, tag, e_11_1, tags_6, tags_6_1, tag, e_12_1, tags_7, tags_7_1, tag;
+            var e_7, _a, e_8, _b, e_9, _c, e_10, _d, e_11, _e, e_12, _f, e_13, _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
                     case 0:
-                        _i = 0, tags_1 = tags;
-                        _g.label = 1;
+                        _h.trys.push([0, 5, 6, 7]);
+                        tags_1 = __values(tags), tags_1_1 = tags_1.next();
+                        _h.label = 1;
                     case 1:
-                        if (!(_i < tags_1.length)) return [3 /*break*/, 4];
-                        tag = tags_1[_i];
+                        if (!!tags_1_1.done) return [3 /*break*/, 4];
+                        tag = tags_1_1.value;
                         return [4 /*yield*/, tag.buildAttributes()];
                     case 2:
-                        _g.sent();
-                        _g.label = 3;
+                        _h.sent();
+                        _h.label = 3;
                     case 3:
-                        _i++;
+                        tags_1_1 = tags_1.next();
                         return [3 /*break*/, 1];
-                    case 4:
-                        _a = 0, tags_2 = tags;
-                        _g.label = 5;
+                    case 4: return [3 /*break*/, 7];
                     case 5:
-                        if (!(_a < tags_2.length)) return [3 /*break*/, 8];
-                        tag = tags_2[_a];
-                        return [4 /*yield*/, tag.compileAttributes()];
+                        e_7_1 = _h.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 7];
                     case 6:
-                        _g.sent();
-                        _g.label = 7;
+                        try {
+                            if (tags_1_1 && !tags_1_1.done && (_a = tags_1.return)) _a.call(tags_1);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
                     case 7:
-                        _a++;
-                        return [3 /*break*/, 5];
+                        _h.trys.push([7, 12, 13, 14]);
+                        tags_2 = __values(tags), tags_2_1 = tags_2.next();
+                        _h.label = 8;
                     case 8:
-                        _b = 0, tags_3 = tags;
-                        _g.label = 9;
+                        if (!!tags_2_1.done) return [3 /*break*/, 11];
+                        tag = tags_2_1.value;
+                        return [4 /*yield*/, tag.compileAttributes()];
                     case 9:
-                        if (!(_b < tags_3.length)) return [3 /*break*/, 12];
-                        tag = tags_3[_b];
-                        return [4 /*yield*/, tag.setupAttributes()];
+                        _h.sent();
+                        _h.label = 10;
                     case 10:
-                        _g.sent();
-                        _g.label = 11;
-                    case 11:
-                        _b++;
-                        return [3 /*break*/, 9];
+                        tags_2_1 = tags_2.next();
+                        return [3 /*break*/, 8];
+                    case 11: return [3 /*break*/, 14];
                     case 12:
-                        _c = 0, tags_4 = tags;
-                        _g.label = 13;
+                        e_8_1 = _h.sent();
+                        e_8 = { error: e_8_1 };
+                        return [3 /*break*/, 14];
                     case 13:
-                        if (!(_c < tags_4.length)) return [3 /*break*/, 16];
-                        tag = tags_4[_c];
-                        return [4 /*yield*/, tag.extractAttributes()];
+                        try {
+                            if (tags_2_1 && !tags_2_1.done && (_b = tags_2.return)) _b.call(tags_2);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                        return [7 /*endfinally*/];
                     case 14:
-                        _g.sent();
-                        _g.label = 15;
+                        _h.trys.push([14, 19, 20, 21]);
+                        tags_3 = __values(tags), tags_3_1 = tags_3.next();
+                        _h.label = 15;
                     case 15:
-                        _c++;
-                        return [3 /*break*/, 13];
+                        if (!!tags_3_1.done) return [3 /*break*/, 18];
+                        tag = tags_3_1.value;
+                        return [4 /*yield*/, tag.setupAttributes()];
                     case 16:
-                        _d = 0, tags_5 = tags;
-                        _g.label = 17;
+                        _h.sent();
+                        _h.label = 17;
                     case 17:
-                        if (!(_d < tags_5.length)) return [3 /*break*/, 20];
-                        tag = tags_5[_d];
-                        return [4 /*yield*/, tag.connectAttributes()];
-                    case 18:
-                        _g.sent();
-                        _g.label = 19;
+                        tags_3_1 = tags_3.next();
+                        return [3 /*break*/, 15];
+                    case 18: return [3 /*break*/, 21];
                     case 19:
-                        _d++;
-                        return [3 /*break*/, 17];
+                        e_9_1 = _h.sent();
+                        e_9 = { error: e_9_1 };
+                        return [3 /*break*/, 21];
                     case 20:
-                        _e = 0, tags_6 = tags;
-                        _g.label = 21;
+                        try {
+                            if (tags_3_1 && !tags_3_1.done && (_c = tags_3.return)) _c.call(tags_3);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                        return [7 /*endfinally*/];
                     case 21:
-                        if (!(_e < tags_6.length)) return [3 /*break*/, 24];
-                        tag = tags_6[_e];
-                        return [4 /*yield*/, tag.finalize()];
+                        _h.trys.push([21, 26, 27, 28]);
+                        tags_4 = __values(tags), tags_4_1 = tags_4.next();
+                        _h.label = 22;
                     case 22:
-                        _g.sent();
-                        this.queued.splice(this.queued.indexOf(tag.element), 1);
-                        _g.label = 23;
+                        if (!!tags_4_1.done) return [3 /*break*/, 25];
+                        tag = tags_4_1.value;
+                        return [4 /*yield*/, tag.extractAttributes()];
                     case 23:
-                        _e++;
-                        return [3 /*break*/, 21];
+                        _h.sent();
+                        _h.label = 24;
                     case 24:
-                        for (_f = 0, tags_7 = tags; _f < tags_7.length; _f++) {
-                            tag = tags_7[_f];
-                            this.observer.observe(tag.element, {
-                                attributes: true,
-                                characterData: true,
-                                childList: true,
-                                subtree: true
-                            });
+                        tags_4_1 = tags_4.next();
+                        return [3 /*break*/, 22];
+                    case 25: return [3 /*break*/, 28];
+                    case 26:
+                        e_10_1 = _h.sent();
+                        e_10 = { error: e_10_1 };
+                        return [3 /*break*/, 28];
+                    case 27:
+                        try {
+                            if (tags_4_1 && !tags_4_1.done && (_d = tags_4.return)) _d.call(tags_4);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                        return [7 /*endfinally*/];
+                    case 28:
+                        _h.trys.push([28, 33, 34, 35]);
+                        tags_5 = __values(tags), tags_5_1 = tags_5.next();
+                        _h.label = 29;
+                    case 29:
+                        if (!!tags_5_1.done) return [3 /*break*/, 32];
+                        tag = tags_5_1.value;
+                        return [4 /*yield*/, tag.connectAttributes()];
+                    case 30:
+                        _h.sent();
+                        _h.label = 31;
+                    case 31:
+                        tags_5_1 = tags_5.next();
+                        return [3 /*break*/, 29];
+                    case 32: return [3 /*break*/, 35];
+                    case 33:
+                        e_11_1 = _h.sent();
+                        e_11 = { error: e_11_1 };
+                        return [3 /*break*/, 35];
+                    case 34:
+                        try {
+                            if (tags_5_1 && !tags_5_1.done && (_e = tags_5.return)) _e.call(tags_5);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                        return [7 /*endfinally*/];
+                    case 35:
+                        _h.trys.push([35, 40, 41, 42]);
+                        tags_6 = __values(tags), tags_6_1 = tags_6.next();
+                        _h.label = 36;
+                    case 36:
+                        if (!!tags_6_1.done) return [3 /*break*/, 39];
+                        tag = tags_6_1.value;
+                        return [4 /*yield*/, tag.finalize()];
+                    case 37:
+                        _h.sent();
+                        this.queued.splice(this.queued.indexOf(tag.element), 1);
+                        _h.label = 38;
+                    case 38:
+                        tags_6_1 = tags_6.next();
+                        return [3 /*break*/, 36];
+                    case 39: return [3 /*break*/, 42];
+                    case 40:
+                        e_12_1 = _h.sent();
+                        e_12 = { error: e_12_1 };
+                        return [3 /*break*/, 42];
+                    case 41:
+                        try {
+                            if (tags_6_1 && !tags_6_1.done && (_f = tags_6.return)) _f.call(tags_6);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                        return [7 /*endfinally*/];
+                    case 42:
+                        try {
+                            for (tags_7 = __values(tags), tags_7_1 = tags_7.next(); !tags_7_1.done; tags_7_1 = tags_7.next()) {
+                                tag = tags_7_1.value;
+                                this.observer.observe(tag.element, {
+                                    attributes: true,
+                                    characterData: true,
+                                    childList: true,
+                                    subtree: true
+                                });
+                            }
+                        }
+                        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                        finally {
+                            try {
+                                if (tags_7_1 && !tags_7_1.done && (_g = tags_7.return)) _g.call(tags_7);
+                            }
+                            finally { if (e_13) throw e_13.error; }
                         }
                         return [2 /*return*/];
                 }
@@ -480,9 +659,10 @@ var DOM = /** @class */ (function (_super) {
         if (isRoot === void 0) { isRoot = false; }
         if (forComponent === void 0) { forComponent = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var _a, templateNodes, components, _i, _b, n, tag, newTags, toBuild, _c, toBuild_1, element, tag;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var _a, templateNodes, components, _b, _c, n, tag, e_14_1, newTags, toBuild, toBuild_1, toBuild_1_1, element, tag, e_15_1;
+            var e_14, _d, e_15, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         if (!isRoot) return [3 /*break*/, 3];
                         document.body.setAttribute('vsn-root', '');
@@ -490,59 +670,87 @@ var DOM = /** @class */ (function (_super) {
                         _a = this;
                         return [4 /*yield*/, this.buildTag(document.body, true)];
                     case 1:
-                        _a._root = _d.sent();
+                        _a._root = _f.sent();
                         this._root.createScope(true);
                         return [4 /*yield*/, this.setupTags([this._root])];
                     case 2:
-                        _d.sent();
-                        _d.label = 3;
+                        _f.sent();
+                        _f.label = 3;
                     case 3:
                         templateNodes = this.querySelectorElement(ele, 'template');
                         components = [];
-                        _i = 0, _b = Array.from(templateNodes);
-                        _d.label = 4;
+                        _f.label = 4;
                     case 4:
-                        if (!(_i < _b.length)) return [3 /*break*/, 7];
-                        n = _b[_i];
+                        _f.trys.push([4, 9, 10, 11]);
+                        _b = __values(Array.from(templateNodes)), _c = _b.next();
+                        _f.label = 5;
+                    case 5:
+                        if (!!_c.done) return [3 /*break*/, 8];
+                        n = _c.value;
                         if (!ElementHelper_1.ElementHelper.hasVisionAttribute(n))
-                            return [3 /*break*/, 6];
+                            return [3 /*break*/, 7];
                         return [4 /*yield*/, this.buildTag(n)];
-                    case 5:
-                        tag = _d.sent();
+                    case 6:
+                        tag = _f.sent();
                         if (tag)
                             components.push(tag);
-                        _d.label = 6;
-                    case 6:
-                        _i++;
-                        return [3 /*break*/, 4];
+                        _f.label = 7;
                     case 7:
-                        if (!components.length) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.setupTags(components)];
-                    case 8:
-                        _d.sent();
-                        _d.label = 9;
+                        _c = _b.next();
+                        return [3 /*break*/, 5];
+                    case 8: return [3 /*break*/, 11];
                     case 9:
-                        newTags = [];
-                        return [4 /*yield*/, this.discover(ele, forComponent)];
+                        e_14_1 = _f.sent();
+                        e_14 = { error: e_14_1 };
+                        return [3 /*break*/, 11];
                     case 10:
-                        toBuild = _d.sent();
-                        _c = 0, toBuild_1 = toBuild;
-                        _d.label = 11;
+                        try {
+                            if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
+                        }
+                        finally { if (e_14) throw e_14.error; }
+                        return [7 /*endfinally*/];
                     case 11:
-                        if (!(_c < toBuild_1.length)) return [3 /*break*/, 14];
-                        element = toBuild_1[_c];
-                        return [4 /*yield*/, this.buildTag(element)];
+                        if (!components.length) return [3 /*break*/, 13];
+                        return [4 /*yield*/, this.setupTags(components)];
                     case 12:
-                        tag = _d.sent();
-                        if (tag)
-                            newTags.push(tag);
-                        _d.label = 13;
+                        _f.sent();
+                        _f.label = 13;
                     case 13:
-                        _c++;
-                        return [3 /*break*/, 11];
-                    case 14: return [4 /*yield*/, this.setupTags(newTags)];
+                        newTags = [];
+                        return [4 /*yield*/, this.discover(ele, forComponent)];
+                    case 14:
+                        toBuild = _f.sent();
+                        _f.label = 15;
                     case 15:
-                        _d.sent();
+                        _f.trys.push([15, 20, 21, 22]);
+                        toBuild_1 = __values(toBuild), toBuild_1_1 = toBuild_1.next();
+                        _f.label = 16;
+                    case 16:
+                        if (!!toBuild_1_1.done) return [3 /*break*/, 19];
+                        element = toBuild_1_1.value;
+                        return [4 /*yield*/, this.buildTag(element)];
+                    case 17:
+                        tag = _f.sent();
+                        if (tag)
+                            newTags.push(tag);
+                        _f.label = 18;
+                    case 18:
+                        toBuild_1_1 = toBuild_1.next();
+                        return [3 /*break*/, 16];
+                    case 19: return [3 /*break*/, 22];
+                    case 20:
+                        e_15_1 = _f.sent();
+                        e_15 = { error: e_15_1 };
+                        return [3 /*break*/, 22];
+                    case 21:
+                        try {
+                            if (toBuild_1_1 && !toBuild_1_1.done && (_e = toBuild_1.return)) _e.call(toBuild_1);
+                        }
+                        finally { if (e_15) throw e_15.error; }
+                        return [7 /*endfinally*/];
+                    case 22: return [4 /*yield*/, this.setupTags(newTags)];
+                    case 23:
+                        _f.sent();
                         if (isRoot) {
                             this._built = true;
                             this.dispatch('builtRoot');
@@ -556,41 +764,65 @@ var DOM = /** @class */ (function (_super) {
     DOM.prototype.getTagsForElements = function (elements, create) {
         if (create === void 0) { create = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var tags, found, _i, elements_2, element, notFound, i, element, _a, notFound_1, element, _b, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var tags, found, elements_2, elements_2_1, element, notFound, i, element, notFound_1, notFound_1_1, element, _a, _b, e_16_1;
+            var e_17, _c, e_16, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         tags = new TagList_1.TagList();
                         found = [];
-                        for (_i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
-                            element = elements_2[_i];
-                            if (element[Tag_1.Tag.TaggedVariable]) {
-                                tags.push(element[Tag_1.Tag.TaggedVariable]);
-                                found.push(element);
+                        try {
+                            for (elements_2 = __values(elements), elements_2_1 = elements_2.next(); !elements_2_1.done; elements_2_1 = elements_2.next()) {
+                                element = elements_2_1.value;
+                                if (element && element[Tag_1.Tag.TaggedVariable]) {
+                                    tags.push(element[Tag_1.Tag.TaggedVariable]);
+                                    found.push(element);
+                                }
                             }
                         }
-                        if (!create) return [3 /*break*/, 4];
-                        notFound = __spreadArray([], elements);
+                        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                        finally {
+                            try {
+                                if (elements_2_1 && !elements_2_1.done && (_c = elements_2.return)) _c.call(elements_2);
+                            }
+                            finally { if (e_17) throw e_17.error; }
+                        }
+                        if (!create) return [3 /*break*/, 8];
+                        notFound = __spreadArray([], __read(elements));
                         for (i = notFound.length; i >= 0; i--) {
                             element = notFound[i];
                             if (found.indexOf(element) > -1) {
                                 notFound.splice(i, 1);
                             }
                         }
-                        _a = 0, notFound_1 = notFound;
-                        _d.label = 1;
+                        _e.label = 1;
                     case 1:
-                        if (!(_a < notFound_1.length)) return [3 /*break*/, 4];
-                        element = notFound_1[_a];
-                        _c = (_b = tags).push;
-                        return [4 /*yield*/, this.getTagForElement(element, create)];
+                        _e.trys.push([1, 6, 7, 8]);
+                        notFound_1 = __values(notFound), notFound_1_1 = notFound_1.next();
+                        _e.label = 2;
                     case 2:
-                        _c.apply(_b, [_d.sent()]);
-                        _d.label = 3;
+                        if (!!notFound_1_1.done) return [3 /*break*/, 5];
+                        element = notFound_1_1.value;
+                        _b = (_a = tags).push;
+                        return [4 /*yield*/, this.getTagForElement(element, create)];
                     case 3:
-                        _a++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, tags];
+                        _b.apply(_a, [_e.sent()]);
+                        _e.label = 4;
+                    case 4:
+                        notFound_1_1 = notFound_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_16_1 = _e.sent();
+                        e_16 = { error: e_16_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (notFound_1_1 && !notFound_1_1.done && (_d = notFound_1.return)) _d.call(notFound_1);
+                        }
+                        finally { if (e_16) throw e_16.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, tags];
                 }
             });
         });
@@ -602,7 +834,7 @@ var DOM = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (element[Tag_1.Tag.TaggedVariable])
+                        if (element && element[Tag_1.Tag.TaggedVariable])
                             return [2 /*return*/, element[Tag_1.Tag.TaggedVariable]];
                         if (!(element && create)) return [3 /*break*/, 3];
                         if (element instanceof HTMLElement)
@@ -619,12 +851,22 @@ var DOM = /** @class */ (function (_super) {
     };
     DOM.prototype.getTagForScope = function (scope) {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, _a, tag;
-            return __generator(this, function (_b) {
-                for (_i = 0, _a = this.tags; _i < _a.length; _i++) {
-                    tag = _a[_i];
-                    if (tag.uniqueScope && tag.scope === scope)
-                        return [2 /*return*/, tag];
+            var _a, _b, tag;
+            var e_18, _c;
+            return __generator(this, function (_d) {
+                try {
+                    for (_a = __values(this.tags), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        tag = _b.value;
+                        if (tag.uniqueScope && tag.scope === scope)
+                            return [2 /*return*/, tag];
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_18) throw e_18.error; }
                 }
                 return [2 /*return*/, null];
             });
@@ -632,9 +874,10 @@ var DOM = /** @class */ (function (_super) {
     };
     DOM.prototype.resetBranch = function (e) {
         return __awaiter(this, void 0, void 0, function () {
-            var tag, children, _i, children_1, t;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var tag, children, children_1, children_1_1, t, e_19_1;
+            var e_19, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         if (e instanceof Tag_1.Tag)
                             e = e.element;
@@ -643,19 +886,33 @@ var DOM = /** @class */ (function (_super) {
                             tag.findParentTag();
                         }
                         children = Array.from(e.children);
-                        _i = 0, children_1 = children;
-                        _a.label = 1;
+                        _b.label = 1;
                     case 1:
-                        if (!(_i < children_1.length)) return [3 /*break*/, 4];
-                        t = children_1[_i];
-                        return [4 /*yield*/, this.resetBranch(t)];
+                        _b.trys.push([1, 6, 7, 8]);
+                        children_1 = __values(children), children_1_1 = children_1.next();
+                        _b.label = 2;
                     case 2:
-                        _a.sent();
-                        _a.label = 3;
+                        if (!!children_1_1.done) return [3 /*break*/, 5];
+                        t = children_1_1.value;
+                        return [4 /*yield*/, this.resetBranch(t)];
                     case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/];
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        children_1_1 = children_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_19_1 = _b.sent();
+                        e_19 = { error: e_19_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+                        }
+                        finally { if (e_19) throw e_19.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
                 }
             });
         });