marko 5.37.47 → 5.37.49

package/dist/runtime/vdom/VNode.js

@@ -3,78 +3,78 @@
 function VNode() {}
 
 VNode.prototype = {
-  bW_: function (finalChildCount, ownerComponent) {
-    this.ck_ = finalChildCount;
-    this.cl_ = 0;
-    this.cc_ = null;
-    this.cm_ = null;
-    this.c__ = null;
+  bX_: function (finalChildCount, ownerComponent) {
+    this.cl_ = finalChildCount;
+    this.cm_ = 0;
+    this.cd_ = null;
+    this.cn_ = null;
     this.ca_ = null;
-    this._M_ = ownerComponent;
+    this.cb_ = null;
+    this._N_ = ownerComponent;
   },
 
-  get aA_() {
-    var firstChild = this.cc_;
+  get aB_() {
+    var firstChild = this.cd_;
 
-    if (firstChild && firstChild.cb_) {
-      var nestedFirstChild = firstChild.aA_;
+    if (firstChild && firstChild.cc_) {
+      var nestedFirstChild = firstChild.aB_;
       // The first child is a DocumentFragment node.
       // If the DocumentFragment node has a first child then we will return that.
       // Otherwise, the DocumentFragment node is not *really* the first child and
       // we need to skip to its next sibling
-      return nestedFirstChild || firstChild.cn_;
+      return nestedFirstChild || firstChild.co_;
     }
 
     return firstChild;
   },
 
-  get cn_() {
-    var nextSibling = this.ca_;
+  get co_() {
+    var nextSibling = this.cb_;
 
     if (nextSibling) {
-      if (nextSibling.cb_) {
-        var firstChild = nextSibling.aA_;
-        return firstChild || nextSibling.cn_;
+      if (nextSibling.cc_) {
+        var firstChild = nextSibling.aB_;
+        return firstChild || nextSibling.co_;
       }
     } else {
-      var parentNode = this.c__;
-      if (parentNode && parentNode.cb_) {
-        return parentNode.cn_;
+      var parentNode = this.ca_;
+      if (parentNode && parentNode.cc_) {
+        return parentNode.co_;
       }
     }
 
     return nextSibling;
   },
 
-  bP_: function (child) {
-    this.cl_++;
+  bQ_: function (child) {
+    this.cm_++;
 
-    if (hasTextContent(this.ce_)) {
-      if (child.co_) {
-        this.cf_ += child.bX_;
+    if (hasTextContent(this.cf_)) {
+      if (child.cp_) {
+        this.cg_ += child.bY_;
       } else {
         throw TypeError();
       }
     } else {
-      var lastChild = this.cm_;
+      var lastChild = this.cn_;
 
-      child.c__ = this;
+      child.ca_ = this;
 
       if (lastChild) {
-        lastChild.ca_ = child;
+        lastChild.cb_ = child;
       } else {
-        this.cc_ = child;
+        this.cd_ = child;
       }
 
-      this.cm_ = child;
+      this.cn_ = child;
     }
 
     return child;
   },
 
-  ch_: function finishChild() {
-    if (this.cl_ === this.ck_ && this.c__) {
-      return this.c__.ch_();
+  ci_: function finishChild() {
+    if (this.cm_ === this.cl_ && this.ca_) {
+      return this.ca_.ci_();
     } else {
       return this;
     }

package/dist/runtime/vdom/VText.js

@@ -2,21 +2,21 @@
 var VNode = require("./VNode");
 
 function VText(value, ownerComponent) {
-  this.bW_(-1 /* no children */, ownerComponent);
-  this.bX_ = value;
+  this.bX_(-1 /* no children */, ownerComponent);
+  this.bY_ = value;
 }
 
 VText.prototype = {
-  co_: true,
+  cp_: true,
 
-  bY_: 3,
+  bZ_: 3,
 
-  bp_: function (host) {
-    return (host.ownerDocument || host).createTextNode(this.bX_);
+  bq_: function (host) {
+    return (host.ownerDocument || host).createTextNode(this.bY_);
   },
 
-  bQ_: function () {
-    return new VText(this.bX_);
+  bR_: function () {
+    return new VText(this.bY_);
   }
 };
 

package/dist/runtime/vdom/helpers/const-element.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var VElement = require("../vdom").bx_;
+var VElement = require("../vdom").by_;
 var i = 0;
 
 module.exports = function (tagName, attrs, childCount) {
@@ -13,12 +13,12 @@ function ConstVElement(tagName, attrs, childCount) {
 
 ConstVElement.prototype = Object.create(VElement.prototype);
 ConstVElement.prototype.e = function (tagName, attrs, childCount) {
-  var child = this.bP_(
+  var child = this.bQ_(
     new ConstVElement(tagName, attrs, childCount)
   );
 
   if (childCount === 0) {
-    return this.ch_();
+    return this.ci_();
   } else {
     return child;
   }

package/dist/runtime/vdom/hot-reload.js

@@ -1,10 +1,10 @@
 "use strict";var registry = require("@internal/components-registry");
-var setImmediate = require("@internal/set-immediate")._j_;
+var setImmediate = require("@internal/set-immediate")._k_;
 var updateManager = require("../components/update-manager");
 var runtime = require(".");
 
 var createTemplate = runtime.t;
-var createComponent = registry._G_;
+var createComponent = registry._H_;
 var registered = {};
 var instancesByType = {};
 var queue;
@@ -31,12 +31,12 @@ exports.t = runtime.t = function (typeName) {
         }
 
         queue.push(function () {
-          var newProto = registry._H_(typeName).prototype;
+          var newProto = registry._I_(typeName).prototype;
           instances.forEach(function (instance) {
             if (hasLifecycleChanged(instance.__proto__, newProto)) {
               var renderer = instance.Q_;
               instance.Q_ = (input, out) => {
-                instance.aF_(input, out);
+                instance.aG_(input, out);
                 if (instance.onInput) {
                   input = instance.onInput(input, out) || input;
                 }
@@ -44,18 +44,18 @@ exports.t = runtime.t = function (typeName) {
                 instance.Q_(input, out);
               };
 
-              instance.cp_ = true;
-              instance.ao_();
-              instance._x_ = false;
+              instance.cq_ = true;
+              instance.ap_();
+              instance._y_ = false;
 
-              if (instance.ai_) {
-                instance.ai_.removeAllListeners();
-                instance.ai_ = null;
+              if (instance.aj_) {
+                instance.aj_.removeAllListeners();
+                instance.aj_ = null;
               }
             }
 
             instance.__proto__ = newProto;
-            instance._F_(
+            instance._G_(
               instance.O_, false).
             afterInsert(instance.B_);
           });
@@ -71,14 +71,14 @@ exports.t = runtime.t = function (typeName) {
   }
 };
 
-registry._G_ = function (typeName, id) {
+registry._H_ = function (typeName, id) {
   var instances = instancesByType[typeName];
   var instance = createComponent(typeName, id);
 
   if (instances) {
     instances.add(instance);
     instance.once("destroy", function () {
-      if (!instance.cp_) {
+      if (!instance.cq_) {
         instances.delete(instance);
       }
     });
@@ -104,7 +104,7 @@ function hasLifecycleChanged(oldProto, newProto) {
 }
 
 function batchUpdate() {
-  updateManager.ay_(function () {
+  updateManager.az_(function () {
     var pending = queue;
     queue = undefined;
 

package/dist/runtime/vdom/index.js

@@ -17,7 +17,7 @@ function Template(typeName) {
 }
 
 var AsyncVDOMBuilder = require("./AsyncVDOMBuilder");
-require("../createOut").be_(
+require("../createOut").bf_(
   Template.prototype.createOut = function createOut(
   globalData,
   parent,

package/dist/runtime/vdom/morphdom/fragment.js

@@ -1,5 +1,5 @@
 "use strict";var helpers = require("./helpers");
-var insertBefore = helpers.bf_;
+var insertBefore = helpers.bg_;
 
 var fragmentPrototype = {
   nodeType: 12,
@@ -80,8 +80,8 @@ function createFragmentNode(startNode, nextNode, parentNode) {
 
 function beginFragmentNode(startNode, parentNode) {
   var fragment = createFragmentNode(startNode, null, parentNode);
-  fragment.cq_ = function (nextNode) {
-    fragment.cq_ = null;
+  fragment.cr_ = function (nextNode) {
+    fragment.cr_ = null;
     insertBefore(
       fragment.endNode,
       nextNode,
@@ -91,5 +91,5 @@ function beginFragmentNode(startNode, parentNode) {
   return fragment;
 }
 
-exports._k_ = createFragmentNode;
-exports.cr_ = beginFragmentNode;
+exports._l_ = createFragmentNode;
+exports.cs_ = beginFragmentNode;

package/dist/runtime/vdom/morphdom/helpers.js

@@ -35,8 +35,8 @@ function removeChild(node) {
   node.parentNode.removeChild(node);
 }
 
-exports.bf_ = insertBefore;
-exports.bg_ = insertAfter;
-exports.cn_ = nextSibling;
-exports.aA_ = firstChild;
-exports.bh_ = removeChild;
+exports.bg_ = insertBefore;
+exports.bh_ = insertAfter;
+exports.co_ = nextSibling;
+exports.aB_ = firstChild;
+exports.bi_ = removeChild;

package/dist/runtime/vdom/morphdom/index.js

@@ -1,31 +1,31 @@
 "use strict";
 var componentsUtil = require("@internal/components-util");
-var existingComponentLookup = componentsUtil._l_;
-var destroyNodeRecursive = componentsUtil._R_;
+var existingComponentLookup = componentsUtil._m_;
+var destroyNodeRecursive = componentsUtil._S_;
 var addComponentRootToKeyedElements =
-componentsUtil._m_;
-var normalizeComponentKey = componentsUtil._U_;
+componentsUtil._n_;
+var normalizeComponentKey = componentsUtil._V_;
 var domData = require("../../components/dom-data");
 var eventDelegation = require("../../components/event-delegation");
 var KeySequence = require("../../components/KeySequence");
-var VElement = require("../vdom").bx_;
+var VElement = require("../vdom").by_;
 var fragment = require("./fragment");
 var helpers = require("./helpers");
 var isTextOnly = require("../is-text-only");
-var virtualizeElement = VElement.ci_;
-var morphAttrs = VElement.cj_;
-var keysByDOMNode = domData._n_;
-var componentByDOMNode = domData._p_;
-var vElementByDOMNode = domData._K_;
-var detachedByDOMNode = domData.aW_;
-
-var insertBefore = helpers.bf_;
-var insertAfter = helpers.bg_;
-var nextSibling = helpers.cn_;
-var firstChild = helpers.aA_;
-var removeChild = helpers.bh_;
-var createFragmentNode = fragment._k_;
-var beginFragmentNode = fragment.cr_;
+var virtualizeElement = VElement.cj_;
+var morphAttrs = VElement.ck_;
+var keysByDOMNode = domData._o_;
+var componentByDOMNode = domData._q_;
+var vElementByDOMNode = domData._L_;
+var detachedByDOMNode = domData.aX_;
+
+var insertBefore = helpers.bg_;
+var insertAfter = helpers.bh_;
+var nextSibling = helpers.co_;
+var firstChild = helpers.aB_;
+var removeChild = helpers.bi_;
+var createFragmentNode = fragment._l_;
+var beginFragmentNode = fragment.cs_;
 
 var ELEMENT_NODE = 1;
 var TEXT_NODE = 3;
@@ -43,7 +43,7 @@ function isAutoKey(key) {
 }
 
 function compareNodeNames(fromEl, toEl) {
-  return fromEl.ce_ === toEl.ce_;
+  return fromEl.cf_ === toEl.cf_;
 }
 
 function caseInsensitiveCompare(a, b) {
@@ -52,7 +52,7 @@ function caseInsensitiveCompare(a, b) {
 
 function onNodeAdded(node, componentsContext) {
   if (node.nodeType === ELEMENT_NODE) {
-    eventDelegation.aV_(node, componentsContext);
+    eventDelegation.aW_(node, componentsContext);
   }
 }
 
@@ -63,7 +63,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
   if (componentsContext) {
     globalComponentsContext = componentsContext.p_;
-    isHydrate = globalComponentsContext._Z_;
+    isHydrate = globalComponentsContext.a__;
   }
 
   function insertVirtualNodeBefore(
@@ -74,12 +74,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var realNode = vNode.bp_(host, parentEl.namespaceURI);
+    var realNode = vNode.bq_(host, parentEl.namespaceURI);
     insertBefore(realNode, referenceEl, parentEl);
 
     if (
-    vNode.bY_ === ELEMENT_NODE ||
-    vNode.bY_ === FRAGMENT_NODE)
+    vNode.bZ_ === ELEMENT_NODE ||
+    vNode.bZ_ === FRAGMENT_NODE)
     {
       if (key) {
         keysByDOMNode.set(realNode, key);
@@ -88,7 +88,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         realNode;
       }
 
-      if (!isTextOnly(vNode.ce_)) {
+      if (!isTextOnly(vNode.cf_)) {
         morphChildren(realNode, vNode, parentComponent);
       }
 
@@ -105,7 +105,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var rootNode = component._E_ = insertBefore(
+    var rootNode = component._F_ = insertBefore(
       createFragmentNode(),
       referenceNode,
       referenceNodeParentEl
@@ -127,7 +127,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphComponent(component, vComponent) {
-    morphChildren(component._E_, vComponent, component);
+    morphChildren(component._F_, vComponent, component);
   }
 
   var detachedNodes = [];
@@ -148,7 +148,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
   function morphChildren(fromNode, toNode, parentComponent) {
     var curFromNodeChild = firstChild(fromNode);
-    var curToNodeChild = toNode.aA_;
+    var curToNodeChild = toNode.aB_;
 
     var curToNodeKey;
     var curFromNodeKey;
@@ -162,16 +162,16 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     var fromComponent;
 
     outer: while (curToNodeChild) {
-      toNextSibling = curToNodeChild.cn_;
-      curToNodeType = curToNodeChild.bY_;
-      curToNodeKey = curToNodeChild.bZ_;
+      toNextSibling = curToNodeChild.co_;
+      curToNodeType = curToNodeChild.bZ_;
+      curToNodeKey = curToNodeChild.c__;
 
       // Skip <!doctype>
       if (curFromNodeChild && curFromNodeChild.nodeType === DOCTYPE_NODE) {
         curFromNodeChild = nextSibling(curFromNodeChild);
       }
 
-      var ownerComponent = curToNodeChild._M_ || parentComponent;
+      var ownerComponent = curToNodeChild._N_ || parentComponent;
       var referenceComponent;
 
       if (curToNodeType === COMPONENT_NODE) {
@@ -182,7 +182,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         {
           if (isHydrate) {
             var rootNode = beginFragmentNode(curFromNodeChild, fromNode);
-            component._E_ = rootNode;
+            component._F_ = rootNode;
             componentByDOMNode.set(rootNode, component);
 
             if (ownerComponent && curToNodeKey) {
@@ -215,7 +215,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             );
           }
         } else {
-          if (matchingFromComponent._E_ !== curFromNodeChild) {
+          if (matchingFromComponent._F_ !== curFromNodeChild) {
             if (
             curFromNodeChild && (
             fromComponent = componentByDOMNode.get(curFromNodeChild)) &&
@@ -225,7 +225,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             {
               // The component associated with the current real DOM node was not rendered
               // so we should just remove it out of the real DOM by destroying it
-              curFromNodeChild = nextSibling(fromComponent._E_);
+              curFromNodeChild = nextSibling(fromComponent._F_);
               destroyComponent(fromComponent);
               continue;
             }
@@ -233,7 +233,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             // We need to move the existing component into
             // the correct location
             insertBefore(
-              matchingFromComponent._E_,
+              matchingFromComponent._F_,
               curFromNodeChild,
               fromNode
             );
@@ -242,7 +242,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             curFromNodeChild && nextSibling(curFromNodeChild);
           }
 
-          if (!curToNodeChild.ad_) {
+          if (!curToNodeChild.ae_) {
             morphComponent(component, curToNodeChild);
           }
         }
@@ -267,7 +267,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         // up elements
         curToNodeKey = (
         keySequences[referenceComponent.id] || (
-        keySequences[referenceComponent.id] = new KeySequence())).aN_(
+        keySequences[referenceComponent.id] = new KeySequence())).aO_(
           curToNodeKey);
 
         if (curFromNodeChild) {
@@ -278,12 +278,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
         if (curFromNodeKey === curToNodeKey) {
           // Elements line up. Now we just have to make sure they are compatible
-          if (!curToNodeChild.ad_) {
+          if (!curToNodeChild.ae_) {
             // We just skip over the fromNode if it is preserved
 
             if (
             curVFromNodeChild &&
-            curToNodeType === curVFromNodeChild.bY_ && (
+            curToNodeType === curVFromNodeChild.bZ_ && (
             curToNodeType !== ELEMENT_NODE ||
             compareNodeNames(curToNodeChild, curVFromNodeChild)))
             {
@@ -325,19 +325,19 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             if (isHydrate && curFromNodeChild) {
               if (
               curFromNodeChild.nodeType === ELEMENT_NODE && (
-              curToNodeChild.ad_ ||
+              curToNodeChild.ae_ ||
               caseInsensitiveCompare(
                 curFromNodeChild.nodeName,
-                curToNodeChild.ce_ || ""
+                curToNodeChild.cf_ || ""
               )))
               {
                 curVFromNodeChild = virtualizeElement(curFromNodeChild);
-                curVFromNodeChild.ce_ = curToNodeChild.ce_;
+                curVFromNodeChild.cf_ = curToNodeChild.cf_;
                 keysByDOMNode.set(curFromNodeChild, curToNodeKey);
                 referenceComponent.K_[curToNodeKey] =
                 curFromNodeChild;
 
-                if (curToNodeChild.ad_) {
+                if (curToNodeChild.ae_) {
                   vElementByDOMNode.set(curFromNodeChild, curVFromNodeChild);
                 } else {
                   morphEl(
@@ -352,7 +352,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                 curFromNodeChild = fromNextSibling;
                 continue;
               } else if (
-              curToNodeChild.bY_ === FRAGMENT_NODE &&
+              curToNodeChild.bZ_ === FRAGMENT_NODE &&
               curFromNodeChild.nodeType === COMMENT_NODE)
               {
                 var content = curFromNodeChild.nodeValue;
@@ -388,7 +388,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                   removeChild(curFromNodeChild);
                   removeChild(endNode);
 
-                  if (!curToNodeChild.ad_) {
+                  if (!curToNodeChild.ae_) {
                     morphChildren(fragment, curToNodeChild, parentComponent);
                   }
 
@@ -413,12 +413,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
               detachedByDOMNode.set(matchingFromEl, undefined);
             }
 
-            if (!curToNodeChild.ad_) {
+            if (!curToNodeChild.ae_) {
               curVFromNodeChild = vElementByDOMNode.get(matchingFromEl);
 
               if (
               curVFromNodeChild &&
-              curToNodeType === curVFromNodeChild.bY_ && (
+              curToNodeType === curVFromNodeChild.bZ_ && (
               curToNodeType !== ELEMENT_NODE ||
               compareNodeNames(curVFromNodeChild, curToNodeChild)))
               {
@@ -436,7 +436,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                   if (
                   toNextSibling &&
-                  toNextSibling.bZ_ === curFromNodeKey)
+                  toNextSibling.c__ === curFromNodeKey)
                   {
                     // Single element swap
 
@@ -549,18 +549,18 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                 if (
                 caseInsensitiveCompare(
-                  curVFromNodeChild.ce_,
-                  curToNodeChild.ce_
+                  curVFromNodeChild.cf_,
+                  curToNodeChild.cf_
                 ))
                 {
-                  curVFromNodeChild.ce_ = curToNodeChild.ce_;
+                  curVFromNodeChild.cf_ = curToNodeChild.cf_;
                 }
               } else {
                 // Skip over nodes that don't look like ours...
                 curFromNodeChild = fromNextSibling;
                 continue;
               }
-            } else if (curFromNodeKey = curVFromNodeChild.bZ_) {
+            } else if (curFromNodeKey = curVFromNodeChild.c__) {
               // We have a keyed element here but our target VDOM node
               // is not keyed so this not doesn't belong
               isCompatible = false;
@@ -587,18 +587,18 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           {
             // Both nodes being compared are Text or Comment nodes
             isCompatible = true;
-            var curToNodeValue = curToNodeChild.bX_;
+            var curToNodeValue = curToNodeChild.bY_;
             var curFromNodeValue = curFromNodeChild.nodeValue;
             if (curFromNodeValue !== curToNodeValue) {
               if (
               isHydrate &&
               toNextSibling &&
               curFromNodeType === TEXT_NODE &&
-              toNextSibling.bY_ === TEXT_NODE &&
+              toNextSibling.bZ_ === TEXT_NODE &&
               curFromNodeValue.startsWith(curToNodeValue) &&
               curFromNodeValue.
               slice(curToNodeValue.length).
-              startsWith(toNextSibling.bX_))
+              startsWith(toNextSibling.bY_))
               {
                 // In hydrate mode we can use splitText to more efficiently handle
                 // adjacent text vdom nodes that were merged.
@@ -643,10 +643,10 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     }
 
     // We have processed all of the "to nodes".
-    if (fromNode.cq_) {
+    if (fromNode.cr_) {
       // If we are in an unfinished fragment, we have reached the end of the nodes
       // we were matching up and need to end the fragment
-      fromNode.cq_(curFromNodeChild);
+      fromNode.cr_(curFromNodeChild);
     } else {
       // If curFromNodeChild is non-null then we still have some from nodes
       // left over that need to be removed
@@ -675,7 +675,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           referenceComponent = parentComponent;
         } else {
           referenceComponent =
-          curVFromNodeChild && curVFromNodeChild._M_;
+          curVFromNodeChild && curVFromNodeChild._N_;
         }
 
         detachNode(curFromNodeChild, fromNode, referenceComponent);
@@ -686,26 +686,26 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphEl(fromEl, vFromEl, toEl, parentComponent) {
-    var nodeName = toEl.ce_;
-    var constId = toEl.cg_;
+    var nodeName = toEl.cf_;
+    var constId = toEl.ch_;
     vElementByDOMNode.set(fromEl, toEl);
 
-    if (constId !== undefined && vFromEl.cg_ === constId) {
+    if (constId !== undefined && vFromEl.ch_ === constId) {
       return;
     }
 
     morphAttrs(fromEl, vFromEl, toEl);
 
-    if (toEl.ac_) {
+    if (toEl.ad_) {
       return;
     }
 
     if (isTextOnly(nodeName)) {
-      if (toEl.cf_ !== vFromEl.cf_) {
+      if (toEl.cg_ !== vFromEl.cg_) {
         if (nodeName === "textarea") {
-          fromEl.value = toEl.cf_;
+          fromEl.value = toEl.cg_;
         } else {
-          fromEl.textContent = toEl.cf_;
+          fromEl.textContent = toEl.cg_;
         }
       }
     } else {
@@ -730,7 +730,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           detachedFromComponent !== true && detachedFromComponent
         );
 
-        if (eventDelegation.an_(node) != false) {
+        if (eventDelegation.ao_(node) != false) {
           removeChild(node);
         }
       }