marko 5.33.8 → 5.33.10

package/dist/runtime/vdom/AsyncVDOMBuilder.js

@@ -3,20 +3,20 @@ var RenderResult = require("../RenderResult");
 var attrsHelper = require("./helpers/attrs");
 var morphdom = require("./morphdom");
 var vdom = require("./vdom");
-var VElement = vdom.bv_;
-var VDocumentFragment = vdom.bw_;
-var VText = vdom.bx_;
-var VComponent = vdom.by_;
-var VFragment = vdom.bz_;
-var virtualizeHTML = vdom.bA_;
+var VElement = vdom.bw_;
+var VDocumentFragment = vdom.bx_;
+var VText = vdom.by_;
+var VComponent = vdom.bz_;
+var VFragment = vdom.bA_;
+var virtualizeHTML = vdom.bB_;
 
 var EVENT_UPDATE = "update";
 var EVENT_FINISH = "finish";
 
 function State(tree) {
-  this.bB_ = new EventEmitter();
-  this.bC_ = tree;
-  this.bD_ = false;
+  this.bC_ = new EventEmitter();
+  this.bD_ = tree;
+  this.bE_ = false;
 }
 
 function AsyncVDOMBuilder(globalData, parentNode, parentOut) {
@@ -27,49 +27,49 @@ function AsyncVDOMBuilder(globalData, parentNode, parentOut) {
   var state;
 
   if (parentOut) {
-    state = parentOut.y_;
+    state = parentOut.z_;
   } else {
     state = new State(parentNode);
   }
 
-  this.bE_ = 1;
-  this.bF_ = 0;
-  this.bG_ = null;
-  this.bH_ = parentOut;
+  this.bF_ = 1;
+  this.bG_ = 0;
+  this.bH_ = null;
+  this.bI_ = parentOut;
 
   this.data = {};
-  this.y_ = state;
-  this._Z_ = parentNode;
+  this.z_ = state;
+  this.aa_ = parentNode;
   this.global = globalData || {};
-  this.bI_ = [parentNode];
-  this.bJ_ = false;
-  this.bK_ = undefined;
+  this.bJ_ = [parentNode];
+  this.bK_ = false;
+  this.bL_ = undefined;
   this.b_ = null;
 
-  this._X_ = null;
-  this._Y_ = null;
-  this.b__ = null;
+  this._Z_ = null;
+  this.a__ = null;
+  this.ba_ = null;
 }
 
 var proto = AsyncVDOMBuilder.prototype = {
-  bp_: true,
-  A_: typeof document === "object" && document,
+  bq_: true,
+  B_: typeof document === "object" && document,
 
   bc: function (component, key, ownerComponent) {
     var vComponent = new VComponent(component, key, ownerComponent);
-    return this.bL_(vComponent, 0, true);
+    return this.bM_(vComponent, 0, true);
   },
 
-  ba_: function (component, key, ownerComponent) {
+  bb_: function (component, key, ownerComponent) {
     var vComponent = new VComponent(component, key, ownerComponent, true);
-    this.bL_(vComponent, 0);
+    this.bM_(vComponent, 0);
   },
 
-  bL_: function (child, childCount, pushToStack) {
-    this._Z_.bM_(child);
+  bM_: function (child, childCount, pushToStack) {
+    this.aa_.bN_(child);
     if (pushToStack === true) {
-      this.bI_.push(child);
-      this._Z_ = child;
+      this.bJ_.push(child);
+      this.aa_ = child;
     }
     return childCount === 0 ? this : child;
   },
@@ -84,15 +84,15 @@ var proto = AsyncVDOMBuilder.prototype = {
       flags,
       props
     );
-    return this.bL_(element, childCount);
+    return this.bM_(element, childCount);
   },
 
-  bj_: function (tagName, attrs, key, componentDef, props) {
+  bk_: function (tagName, attrs, key, componentDef, props) {
     return this.element(
       tagName,
       attrsHelper(attrs),
       key,
-      componentDef.r_,
+      componentDef.s_,
       0,
       0,
       props
@@ -102,15 +102,15 @@ var proto = AsyncVDOMBuilder.prototype = {
   n: function (node, component) {
     // NOTE: We do a shallow clone since we assume the node is being reused
     //       and a node can only have one parent node.
-    var clone = node.bN_();
+    var clone = node.bO_();
     this.node(clone);
-    clone._J_ = component;
+    clone._L_ = component;
 
     return this;
   },
 
   node: function (node) {
-    this._Z_.bM_(node);
+    this.aa_.bN_(node);
     return this;
   },
 
@@ -129,7 +129,7 @@ var proto = AsyncVDOMBuilder.prototype = {
       text = text.toString();
     }
 
-    this._Z_.bM_(new VText(text, ownerComponent));
+    this.aa_.bN_(new VText(text, ownerComponent));
     return this;
   },
 
@@ -160,16 +160,16 @@ var proto = AsyncVDOMBuilder.prototype = {
       flags,
       props
     );
-    this.bL_(element, childCount, true);
+    this.bM_(element, childCount, true);
     return this;
   },
 
-  bh_: function (tagName, attrs, key, componentDef, props) {
+  bi_: function (tagName, attrs, key, componentDef, props) {
     return this.beginElement(
       tagName,
       attrsHelper(attrs),
       key,
-      componentDef.r_,
+      componentDef.s_,
       0,
       0,
       props
@@ -178,7 +178,7 @@ var proto = AsyncVDOMBuilder.prototype = {
 
   bf: function (key, component, preserve) {
     var fragment = new VFragment(key, component, preserve);
-    this.bL_(fragment, null, true);
+    this.bM_(fragment, null, true);
     return this;
   },
 
@@ -187,52 +187,52 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   endElement: function () {
-    var stack = this.bI_;
+    var stack = this.bJ_;
     stack.pop();
-    this._Z_ = stack[stack.length - 1];
+    this.aa_ = stack[stack.length - 1];
   },
 
   end: function () {
-    this._Z_ = undefined;
+    this.aa_ = undefined;
 
-    var remaining = --this.bE_;
-    var parentOut = this.bH_;
+    var remaining = --this.bF_;
+    var parentOut = this.bI_;
 
     if (remaining === 0) {
       if (parentOut) {
-        parentOut.bO_();
+        parentOut.bP_();
       } else {
-        this.bP_();
+        this.bQ_();
       }
-    } else if (remaining - this.bF_ === 0) {
-      this.bQ_();
+    } else if (remaining - this.bG_ === 0) {
+      this.bR_();
     }
 
     return this;
   },
 
-  bO_: function () {
-    var remaining = --this.bE_;
+  bP_: function () {
+    var remaining = --this.bF_;
 
     if (remaining === 0) {
-      var parentOut = this.bH_;
+      var parentOut = this.bI_;
       if (parentOut) {
-        parentOut.bO_();
+        parentOut.bP_();
       } else {
-        this.bP_();
+        this.bQ_();
       }
-    } else if (remaining - this.bF_ === 0) {
-      this.bQ_();
+    } else if (remaining - this.bG_ === 0) {
+      this.bR_();
     }
   },
 
-  bP_: function () {
-    var state = this.y_;
-    state.bD_ = true;
-    state.bB_.emit(EVENT_FINISH, this.br_());
+  bQ_: function () {
+    var state = this.z_;
+    state.bE_ = true;
+    state.bC_.emit(EVENT_FINISH, this.bs_());
   },
 
-  bQ_: function () {
+  bR_: function () {
     var lastArray = this._last;
 
     var i = 0;
@@ -267,26 +267,26 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   beginAsync: function (options) {
-    if (this.bJ_) {
+    if (this.bK_) {
       throw Error(
         "Tried to render async while in sync mode. Note: Client side await is not currently supported in re-renders (Issue: #942)."
       );
     }
 
-    var state = this.y_;
+    var state = this.z_;
 
     if (options) {
       if (options.last) {
-        this.bF_++;
+        this.bG_++;
       }
     }
 
-    this.bE_++;
+    this.bF_++;
 
-    var documentFragment = this._Z_.bR_();
+    var documentFragment = this.aa_.bS_();
     var asyncOut = new AsyncVDOMBuilder(this.global, documentFragment, this);
 
-    state.bB_.emit("beginAsync", {
+    state.bC_.emit("beginAsync", {
       out: asyncOut,
       parentOut: this
     });
@@ -299,51 +299,51 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   flush: function () {
-    var events = this.y_.bB_;
+    var events = this.z_.bC_;
 
     if (events.listenerCount(EVENT_UPDATE)) {
       events.emit(EVENT_UPDATE, new RenderResult(this));
     }
   },
 
-  af_: function () {
-    return this.y_.bC_;
+  ag_: function () {
+    return this.z_.bD_;
   },
 
-  br_: function () {
-    return this.bS_ || (this.bS_ = new RenderResult(this));
+  bs_: function () {
+    return this.bT_ || (this.bT_ = new RenderResult(this));
   },
 
   on: function (event, callback) {
-    var state = this.y_;
+    var state = this.z_;
 
-    if (event === EVENT_FINISH && state.bD_) {
-      callback(this.br_());
+    if (event === EVENT_FINISH && state.bE_) {
+      callback(this.bs_());
     } else if (event === "last") {
       this.onLast(callback);
     } else {
-      state.bB_.on(event, callback);
+      state.bC_.on(event, callback);
     }
 
     return this;
   },
 
   once: function (event, callback) {
-    var state = this.y_;
+    var state = this.z_;
 
-    if (event === EVENT_FINISH && state.bD_) {
-      callback(this.br_());
+    if (event === EVENT_FINISH && state.bE_) {
+      callback(this.bs_());
     } else if (event === "last") {
       this.onLast(callback);
     } else {
-      state.bB_.once(event, callback);
+      state.bC_.once(event, callback);
     }
 
     return this;
   },
 
   emit: function (type, arg) {
-    var events = this.y_.bB_;
+    var events = this.z_.bC_;
     switch (arguments.length) {
       case 1:
         events.emit(type);
@@ -359,17 +359,17 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   removeListener: function () {
-    var events = this.y_.bB_;
+    var events = this.z_.bC_;
     events.removeListener.apply(events, arguments);
     return this;
   },
 
   sync: function () {
-    this.bJ_ = true;
+    this.bK_ = true;
   },
 
   isSync: function () {
-    return this.bJ_;
+    return this.bK_;
   },
 
   onLast: function (callback) {
@@ -384,20 +384,20 @@ var proto = AsyncVDOMBuilder.prototype = {
     return this;
   },
 
-  ae_: function (host) {
-    var node = this.bK_;
+  af_: function (host) {
+    var node = this.bL_;
     if (!node) {
-      var vdomTree = this.af_();
+      var vdomTree = this.ag_();
 
-      if (!host) host = this.A_;
-      this.bK_ = node = vdomTree.bl_(host, null);
+      if (!host) host = this.B_;
+      this.bL_ = node = vdomTree.bm_(host, null);
       morphdom(node, vdomTree, host, this.b_);
     }
     return node;
   },
 
   toString: function (host) {
-    var docFragment = this.ae_(host);
+    var docFragment = this.af_(host);
     var html = "";
 
     var child = docFragment.firstChild;
@@ -435,15 +435,15 @@ var proto = AsyncVDOMBuilder.prototype = {
   isVDOM: true,
 
   c: function (componentDef, key, customEvents) {
-    this._X_ = componentDef;
-    this._Y_ = key;
-    this.b__ = customEvents;
+    this._Z_ = componentDef;
+    this.a__ = key;
+    this.ba_ = customEvents;
   }
 };
 
 proto.e = proto.element;
 proto.be = proto.beginElement;
-proto.ee = proto.bi_ = proto.endElement;
+proto.ee = proto.bj_ = proto.endElement;
 proto.t = proto.text;
 proto.h = proto.w = proto.write = proto.html;
 

package/dist/runtime/vdom/VComponent.js

@@ -2,14 +2,14 @@
 var VNode = require("./VNode");
 
 function VComponent(component, key, ownerComponent, preserve) {
-  this.bT_(null /* childCount */, ownerComponent);
-  this.bU_ = key;
-  this.r_ = component;
-  this.aa_ = preserve;
+  this.bU_(null /* childCount */, ownerComponent);
+  this.bV_ = key;
+  this.s_ = component;
+  this.ac_ = preserve;
 }
 
 VComponent.prototype = {
-  bV_: 2
+  bW_: 2
 };
 
 inherit(VComponent, VNode);

package/dist/runtime/vdom/VDocumentFragment.js

@@ -4,25 +4,25 @@ var VNode = require("./VNode");
 
 function VDocumentFragmentClone(other) {
   extend(this, other);
-  this.bW_ = null;
   this.bX_ = null;
+  this.bY_ = null;
 }
 
 function VDocumentFragment(out) {
-  this.bT_(null /* childCount */);
-  this.q_ = out;
+  this.bU_(null /* childCount */);
+  this.r_ = out;
 }
 
 VDocumentFragment.prototype = {
-  bV_: 11,
+  bW_: 11,
 
-  bY_: true,
+  bZ_: true,
 
-  bN_: function () {
+  bO_: function () {
     return new VDocumentFragmentClone(this);
   },
 
-  bl_: function (host) {
+  bm_: function (host) {
     return (host.ownerDocument || host).createDocumentFragment();
   }
 };