marko 5.37.51 → 5.37.53

package/dist/runtime/vdom/VFragment.js

@@ -1,21 +1,21 @@
 "use strict";var inherit = require("raptor-util/inherit");
 var domData = require("../components/dom-data");
-var keysByDOMNode = domData._o_;
-var vElementByDOMNode = domData._L_;
-var createFragmentNode = require("./morphdom/fragment")._l_;
+var keysByDOMNode = domData._p_;
+var vElementByDOMNode = domData._M_;
+var createFragmentNode = require("./morphdom/fragment")._m_;
 var VNode = require("./VNode");
 
 function VFragment(key, ownerComponent, preserve) {
-  this.bX_(null /* childCount */, ownerComponent);
-  this.c__ = key;
-  this.ae_ = preserve;
+  this.bY_(null /* childCount */, ownerComponent);
+  this.ca_ = key;
+  this.af_ = preserve;
 }
 
 VFragment.prototype = {
-  bZ_: 12,
-  bq_: function () {
+  c__: 12,
+  br_: function () {
     var fragment = createFragmentNode();
-    keysByDOMNode.set(fragment, this.c__);
+    keysByDOMNode.set(fragment, this.ca_);
     vElementByDOMNode.set(fragment, this);
     return fragment;
   }

package/dist/runtime/vdom/VNode.js

@@ -3,78 +3,78 @@
 function VNode() {}
 
 VNode.prototype = {
-  bX_: function (finalChildCount, ownerComponent) {
-    this.cl_ = finalChildCount;
-    this.cm_ = 0;
-    this.cd_ = null;
-    this.cn_ = null;
-    this.ca_ = null;
+  bY_: function (finalChildCount, ownerComponent) {
+    this.cm_ = finalChildCount;
+    this.cn_ = 0;
+    this.ce_ = null;
+    this.co_ = null;
     this.cb_ = null;
-    this._N_ = ownerComponent;
+    this.cc_ = null;
+    this._O_ = ownerComponent;
   },
 
-  get aB_() {
-    var firstChild = this.cd_;
+  get aC_() {
+    var firstChild = this.ce_;
 
-    if (firstChild && firstChild.cc_) {
-      var nestedFirstChild = firstChild.aB_;
+    if (firstChild && firstChild.cd_) {
+      var nestedFirstChild = firstChild.aC_;
       // 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.co_;
+      return nestedFirstChild || firstChild.cp_;
     }
 
     return firstChild;
   },
 
-  get co_() {
-    var nextSibling = this.cb_;
+  get cp_() {
+    var nextSibling = this.cc_;
 
     if (nextSibling) {
-      if (nextSibling.cc_) {
-        var firstChild = nextSibling.aB_;
-        return firstChild || nextSibling.co_;
+      if (nextSibling.cd_) {
+        var firstChild = nextSibling.aC_;
+        return firstChild || nextSibling.cp_;
       }
     } else {
-      var parentNode = this.ca_;
-      if (parentNode && parentNode.cc_) {
-        return parentNode.co_;
+      var parentNode = this.cb_;
+      if (parentNode && parentNode.cd_) {
+        return parentNode.cp_;
       }
     }
 
     return nextSibling;
   },
 
-  bQ_: function (child) {
-    this.cm_++;
+  bR_: function (child) {
+    this.cn_++;
 
-    if (hasTextContent(this.cf_)) {
-      if (child.cp_) {
-        this.cg_ += child.bY_;
+    if (hasTextContent(this.cg_)) {
+      if (child.cq_) {
+        this.ch_ += child.bZ_;
       } else {
         throw TypeError();
       }
     } else {
-      var lastChild = this.cn_;
+      var lastChild = this.co_;
 
-      child.ca_ = this;
+      child.cb_ = this;
 
       if (lastChild) {
-        lastChild.cb_ = child;
+        lastChild.cc_ = child;
       } else {
-        this.cd_ = child;
+        this.ce_ = child;
       }
 
-      this.cn_ = child;
+      this.co_ = child;
     }
 
     return child;
   },
 
-  ci_: function finishChild() {
-    if (this.cm_ === this.cl_ && this.ca_) {
-      return this.ca_.ci_();
+  cj_: function finishChild() {
+    if (this.cn_ === this.cm_ && this.cb_) {
+      return this.cb_.cj_();
     } else {
       return this;
     }

package/dist/runtime/vdom/VText.js

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

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

@@ -1,6 +1,6 @@
 "use strict";
 
-var VElement = require("../vdom").by_;
+var VElement = require("../vdom").bz_;
 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.bQ_(
+  var child = this.bR_(
     new ConstVElement(tagName, attrs, childCount)
   );
 
   if (childCount === 0) {
-    return this.ci_();
+    return this.cj_();
   } 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")._k_;
+var setImmediate = require("@internal/set-immediate")._l_;
 var updateManager = require("../components/update-manager");
 var runtime = require(".");
 
 var createTemplate = runtime.t;
-var createComponent = registry._H_;
+var createComponent = registry._I_;
 var registered = {};
 var instancesByType = {};
 var queue;
@@ -31,33 +31,33 @@ exports.t = runtime.t = function (typeName) {
         }
 
         queue.push(function () {
-          var newProto = registry._I_(typeName).prototype;
+          var newProto = registry._J_(typeName).prototype;
           instances.forEach(function (instance) {
             if (hasLifecycleChanged(instance.__proto__, newProto)) {
-              var renderer = instance.Q_;
-              instance.Q_ = (input, out) => {
-                instance.aG_(input, out);
+              var renderer = instance.R_;
+              instance.R_ = (input, out) => {
+                instance.aH_(input, out);
                 if (instance.onInput) {
                   input = instance.onInput(input, out) || input;
                 }
-                instance.Q_ = renderer;
-                instance.Q_(input, out);
+                instance.R_ = renderer;
+                instance.R_(input, out);
               };
 
-              instance.cq_ = true;
-              instance.ap_();
-              instance._y_ = false;
+              instance.cr_ = true;
+              instance.aq_();
+              instance._z_ = false;
 
-              if (instance.aj_) {
-                instance.aj_.removeAllListeners();
-                instance.aj_ = null;
+              if (instance.ak_) {
+                instance.ak_.removeAllListeners();
+                instance.ak_ = null;
               }
             }
 
             instance.__proto__ = newProto;
-            instance._G_(
-              instance.O_, false).
-            afterInsert(instance.B_);
+            instance._H_(
+              instance.P_, false).
+            afterInsert(instance.C_);
           });
         });
       }
@@ -71,14 +71,14 @@ exports.t = runtime.t = function (typeName) {
   }
 };
 
-registry._H_ = function (typeName, id) {
+registry._I_ = function (typeName, id) {
   var instances = instancesByType[typeName];
   var instance = createComponent(typeName, id);
 
   if (instances) {
     instances.add(instance);
     instance.once("destroy", function () {
-      if (!instance.cq_) {
+      if (!instance.cr_) {
         instances.delete(instance);
       }
     });
@@ -104,7 +104,7 @@ function hasLifecycleChanged(oldProto, newProto) {
 }
 
 function batchUpdate() {
-  updateManager.az_(function () {
+  updateManager.aA_(function () {
     var pending = queue;
     queue = undefined;
 

package/dist/runtime/vdom/index.js

@@ -13,11 +13,11 @@ exports.t = function createTemplate(typeName) {
 };
 
 function Template(typeName) {
-  this.path = this.R_ = typeName;
+  this.path = this.S_ = typeName;
 }
 
 var AsyncVDOMBuilder = require("./AsyncVDOMBuilder");
-require("../createOut").bf_(
+require("../createOut").bg_(
   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.bg_;
+var insertBefore = helpers.bh_;
 
 var fragmentPrototype = {
   nodeType: 12,
@@ -80,8 +80,8 @@ function createFragmentNode(startNode, nextNode, parentNode) {
 
 function beginFragmentNode(startNode, parentNode) {
   var fragment = createFragmentNode(startNode, null, parentNode);
-  fragment.cr_ = function (nextNode) {
-    fragment.cr_ = null;
+  fragment.cs_ = function (nextNode) {
+    fragment.cs_ = null;
     insertBefore(
       fragment.endNode,
       nextNode,
@@ -91,5 +91,5 @@ function beginFragmentNode(startNode, parentNode) {
   return fragment;
 }
 
-exports._l_ = createFragmentNode;
-exports.cs_ = beginFragmentNode;
+exports._m_ = createFragmentNode;
+exports.ct_ = beginFragmentNode;

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

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