marko 4.24.6 → 4.26.0

package/dist/runtime/vdom/AsyncVDOMBuilder.js

@@ -1,14 +1,13 @@
 var EventEmitter = require("events-light");
 var vdom = require("./vdom");
-var VElement = vdom.bp_;
-var VDocumentFragment = vdom.bq_;
-var VComment = vdom.br_;
-var VText = vdom.bs_;
-var VComponent = vdom.bt_;
-var VFragment = vdom.bu_;
-var virtualizeHTML = vdom.bv_;
+var VElement = vdom.bw_;
+var VDocumentFragment = vdom.bx_;
+var VComment = vdom.by_;
+var VText = vdom.bz_;
+var VComponent = vdom.bA_;
+var VFragment = vdom.bB_;
+var virtualizeHTML = vdom.bC_;
 var RenderResult = require("../RenderResult");
-var defaultDocument = vdom.bw_;
 var morphdom = require("./morphdom");
 var attrsHelper = require("./helpers/attrs");
 
@@ -16,9 +15,9 @@ var EVENT_UPDATE = "update";
 var EVENT_FINISH = "finish";
 
 function State(tree) {
-  this.bx_ = new EventEmitter();
-  this.by_ = tree;
-  this.bz_ = false;
+  this.bD_ = new EventEmitter();
+  this.bE_ = tree;
+  this.bF_ = false;
 }
 
 function AsyncVDOMBuilder(globalData, parentNode, parentOut) {
@@ -29,60 +28,60 @@ function AsyncVDOMBuilder(globalData, parentNode, parentOut) {
   var state;
 
   if (parentOut) {
-    state = parentOut.P_;
+    state = parentOut.C_;
   } else {
     state = new State(parentNode);
   }
 
-  this.bA_ = 1;
-  this.bB_ = 0;
-  this.bC_ = null;
-  this.bD_ = parentOut;
+  this.bG_ = 1;
+  this.bH_ = 0;
+  this.bI_ = null;
+  this.bJ_ = parentOut;
 
   this.data = {};
-  this.P_ = state;
-  this.r_ = parentNode;
+  this.C_ = state;
+  this.ac_ = parentNode;
   this.global = globalData || {};
-  this.bE_ = [parentNode];
-  this.bF_ = false;
-  this.bG_ = undefined;
-  this.h_ = null;
-
-  this.m_ = null;
-  this.o_ = null;
-  this.aQ_ = null;
+  this.bK_ = [parentNode];
+  this.bL_ = false;
+  this.bM_ = undefined;
+  this.t_ = null;
+
+  this.aa_ = null;
+  this.ab_ = null;
+  this.bc_ = null;
 }
 
 var proto = AsyncVDOMBuilder.prototype = {
-  bh_: true,
-  _c_: defaultDocument,
+  bq_: true,
+  E_: typeof document === "object" && document,
 
   bc: function (component, key, ownerComponent) {
     var vComponent = new VComponent(component, key, ownerComponent);
-    return this.bH_(vComponent, 0, true);
+    return this.bN_(vComponent, 0, true);
   },
 
-  aS_: function (component, key, ownerComponent) {
+  bd_: function (component, key, ownerComponent) {
     var vComponent = new VComponent(component, key, ownerComponent, true);
-    this.bH_(vComponent, 0);
+    this.bN_(vComponent, 0);
   },
 
-  bH_: function (child, childCount, pushToStack) {
-    this.r_.bI_(child);
+  bN_: function (child, childCount, pushToStack) {
+    this.ac_.bO_(child);
     if (pushToStack === true) {
-      this.bE_.push(child);
-      this.r_ = child;
+      this.bK_.push(child);
+      this.ac_ = child;
     }
     return childCount === 0 ? this : child;
   },
 
   element: function (tagName, attrs, key, component, childCount, flags, props) {
     var element = new VElement(tagName, attrs, key, component, childCount, flags, props);
-    return this.bH_(element, childCount);
+    return this.bN_(element, childCount);
   },
 
-  bf_: function (tagName, attrs, key, componentDef, props) {
-    return this.element(tagName, attrsHelper(attrs), key, componentDef.n_, 0, 0, props);
+  bn_: function (tagName, attrs, key, componentDef, props) {
+    return this.element(tagName, attrsHelper(attrs), key, componentDef.v_, 0, 0, props);
   },
 
   n: function (node, component) {
@@ -90,13 +89,13 @@ var proto = AsyncVDOMBuilder.prototype = {
     //       and a node can only have one parent node.
     var clone = node.__();
     this.node(clone);
-    clone.aU_ = component;
+    clone._N_ = component;
 
     return this;
   },
 
   node: function (node) {
-    this.r_.bI_(node);
+    this.ac_.bO_(node);
     return this;
   },
 
@@ -115,7 +114,7 @@ var proto = AsyncVDOMBuilder.prototype = {
       text = text.toString();
     }
 
-    this.r_.bI_(new VText(text, ownerComponent));
+    this.ac_.bO_(new VText(text, ownerComponent));
     return this;
   },
 
@@ -125,7 +124,7 @@ var proto = AsyncVDOMBuilder.prototype = {
 
   html: function (html, ownerComponent) {
     if (html != null) {
-      var vdomNode = virtualizeHTML(html, this._c_ || document, ownerComponent);
+      var vdomNode = virtualizeHTML(html, ownerComponent);
       this.node(vdomNode);
     }
 
@@ -134,17 +133,17 @@ var proto = AsyncVDOMBuilder.prototype = {
 
   beginElement: function (tagName, attrs, key, component, childCount, flags, props) {
     var element = new VElement(tagName, attrs, key, component, childCount, flags, props);
-    this.bH_(element, childCount, true);
+    this.bN_(element, childCount, true);
     return this;
   },
 
-  bd_: function (tagName, attrs, key, componentDef, props) {
-    return this.beginElement(tagName, attrsHelper(attrs), key, componentDef.n_, 0, 0, props);
+  bl_: function (tagName, attrs, key, componentDef, props) {
+    return this.beginElement(tagName, attrsHelper(attrs), key, componentDef.v_, 0, 0, props);
   },
 
   bf: function (key, component, preserve) {
     var fragment = new VFragment(key, component, preserve);
-    this.bH_(fragment, null, true);
+    this.bN_(fragment, null, true);
     return this;
   },
 
@@ -153,52 +152,52 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   endElement: function () {
-    var stack = this.bE_;
+    var stack = this.bK_;
     stack.pop();
-    this.r_ = stack[stack.length - 1];
+    this.ac_ = stack[stack.length - 1];
   },
 
   end: function () {
-    this.r_ = undefined;
+    this.ac_ = undefined;
 
-    var remaining = --this.bA_;
-    var parentOut = this.bD_;
+    var remaining = --this.bG_;
+    var parentOut = this.bJ_;
 
     if (remaining === 0) {
       if (parentOut) {
-        parentOut.bJ_();
+        parentOut.bP_();
       } else {
-        this.bK_();
+        this.bQ_();
       }
-    } else if (remaining - this.bB_ === 0) {
-      this.bL_();
+    } else if (remaining - this.bH_ === 0) {
+      this.bR_();
     }
 
     return this;
   },
 
-  bJ_: function () {
-    var remaining = --this.bA_;
+  bP_: function () {
+    var remaining = --this.bG_;
 
     if (remaining === 0) {
-      var parentOut = this.bD_;
+      var parentOut = this.bJ_;
       if (parentOut) {
-        parentOut.bJ_();
+        parentOut.bP_();
       } else {
-        this.bK_();
+        this.bQ_();
       }
-    } else if (remaining - this.bB_ === 0) {
-      this.bL_();
+    } else if (remaining - this.bH_ === 0) {
+      this.bR_();
     }
   },
 
-  bK_: function () {
-    var state = this.P_;
-    state.bz_ = true;
-    state.bx_.emit(EVENT_FINISH, this.bi_());
+  bQ_: function () {
+    var state = this.C_;
+    state.bF_ = true;
+    state.bD_.emit(EVENT_FINISH, this.br_());
   },
 
-  bL_: function () {
+  bR_: function () {
     var lastArray = this._last;
 
     var i = 0;
@@ -233,24 +232,24 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   beginAsync: function (options) {
-    if (this.bF_) {
+    if (this.bL_) {
       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.P_;
+    var state = this.C_;
 
     if (options) {
       if (options.last) {
-        this.bB_++;
+        this.bH_++;
       }
     }
 
-    this.bA_++;
+    this.bG_++;
 
-    var documentFragment = this.r_.bM_();
+    var documentFragment = this.ac_.bS_();
     var asyncOut = new AsyncVDOMBuilder(this.global, documentFragment, this);
 
-    state.bx_.emit("beginAsync", {
+    state.bD_.emit("beginAsync", {
       out: asyncOut,
       parentOut: this
     });
@@ -263,51 +262,51 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   flush: function () {
-    var events = this.P_.bx_;
+    var events = this.C_.bD_;
 
     if (events.listenerCount(EVENT_UPDATE)) {
       events.emit(EVENT_UPDATE, new RenderResult(this));
     }
   },
 
-  H_: function () {
-    return this.P_.by_;
+  aj_: function () {
+    return this.C_.bE_;
   },
 
-  bi_: function () {
-    return this.bN_ || (this.bN_ = new RenderResult(this));
+  br_: function () {
+    return this.bT_ || (this.bT_ = new RenderResult(this));
   },
 
   on: function (event, callback) {
-    var state = this.P_;
+    var state = this.C_;
 
-    if (event === EVENT_FINISH && state.bz_) {
-      callback(this.bi_());
+    if (event === EVENT_FINISH && state.bF_) {
+      callback(this.br_());
     } else if (event === "last") {
       this.onLast(callback);
     } else {
-      state.bx_.on(event, callback);
+      state.bD_.on(event, callback);
     }
 
     return this;
   },
 
   once: function (event, callback) {
-    var state = this.P_;
+    var state = this.C_;
 
-    if (event === EVENT_FINISH && state.bz_) {
-      callback(this.bi_());
+    if (event === EVENT_FINISH && state.bF_) {
+      callback(this.br_());
     } else if (event === "last") {
       this.onLast(callback);
     } else {
-      state.bx_.once(event, callback);
+      state.bD_.once(event, callback);
     }
 
     return this;
   },
 
   emit: function (type, arg) {
-    var events = this.P_.bx_;
+    var events = this.C_.bD_;
     switch (arguments.length) {
       case 1:
         events.emit(type);
@@ -323,17 +322,17 @@ var proto = AsyncVDOMBuilder.prototype = {
   },
 
   removeListener: function () {
-    var events = this.P_.bx_;
+    var events = this.C_.bD_;
     events.removeListener.apply(events, arguments);
     return this;
   },
 
   sync: function () {
-    this.bF_ = true;
+    this.bL_ = true;
   },
 
   isSync: function () {
-    return this.bF_;
+    return this.bL_;
   },
 
   onLast: function (callback) {
@@ -348,20 +347,20 @@ var proto = AsyncVDOMBuilder.prototype = {
     return this;
   },
 
-  G_: function (doc) {
-    var node = this.bG_;
+  ai_: function (host) {
+    var node = this.bM_;
     if (!node) {
-      var vdomTree = this.H_();
-      // Create the root document fragment node
-      doc = doc || this._c_ || document;
-      this.bG_ = node = vdomTree.bO_(doc, null);
-      morphdom(node, vdomTree, doc, this.h_);
+      var vdomTree = this.aj_();
+
+      if (!host) host = this.E_;
+      this.bM_ = node = vdomTree.bU_(host, null);
+      morphdom(node, vdomTree, host, this.t_);
     }
     return node;
   },
 
-  toString: function (doc) {
-    var docFragment = this.G_(doc);
+  toString: function (host) {
+    var docFragment = this.ai_(host);
     var html = "";
 
     var child = docFragment.firstChild;
@@ -399,15 +398,15 @@ var proto = AsyncVDOMBuilder.prototype = {
   isVDOM: true,
 
   c: function (componentDef, key, customEvents) {
-    this.m_ = componentDef;
-    this.o_ = key;
-    this.aQ_ = customEvents;
+    this.aa_ = componentDef;
+    this.ab_ = key;
+    this.bc_ = customEvents;
   }
 };
 
 proto.e = proto.element;
 proto.be = proto.beginElement;
-proto.ee = proto.be_ = proto.endElement;
+proto.ee = proto.bm_ = proto.endElement;
 proto.t = proto.text;
 proto.h = proto.w = proto.write = proto.html;
 

package/dist/runtime/vdom/VComment.js

@@ -2,20 +2,20 @@ var VNode = require("./VNode");
 var inherit = require("raptor-util/inherit");
 
 function VComment(value, ownerComponent) {
-  this.bP_(-1 /* no children */, ownerComponent);
-  this.bQ_ = value;
+  this.bV_(-1 /* no children */, ownerComponent);
+  this.bW_ = value;
 }
 
 VComment.prototype = {
-  bR_: 8,
+  bX_: 8,
 
-  bO_: function (doc) {
-    var nodeValue = this.bQ_;
-    return doc.createComment(nodeValue);
+  bU_: function (host) {
+    var nodeValue = this.bW_;
+    return (host.ownerDocument || host).createComment(nodeValue);
   },
 
   __: function () {
-    return new VComment(this.bQ_);
+    return new VComment(this.bW_);
   }
 };
 

package/dist/runtime/vdom/VComponent.js

@@ -2,14 +2,14 @@ var VNode = require("./VNode");
 var inherit = require("raptor-util/inherit");
 
 function VComponent(component, key, ownerComponent, preserve) {
-  this.bP_(null /* childCount */, ownerComponent);
-  this.bS_ = key;
-  this.n_ = component;
-  this.t_ = preserve;
+  this.bV_(null /* childCount */, ownerComponent);
+  this.bY_ = key;
+  this.v_ = component;
+  this.ae_ = preserve;
 }
 
 VComponent.prototype = {
-  bR_: 2
+  bX_: 2
 };
 
 inherit(VComponent, VNode);

package/dist/runtime/vdom/VDocumentFragment.js

@@ -4,26 +4,26 @@ var extend = require("raptor-util/extend");
 
 function VDocumentFragmentClone(other) {
   extend(this, other);
-  this.bT_ = null;
-  this.bU_ = null;
+  this.bZ_ = null;
+  this.c__ = null;
 }
 
 function VDocumentFragment(out) {
-  this.bP_(null /* childCount */);
-  this.E_ = out;
+  this.bV_(null /* childCount */);
+  this.u_ = out;
 }
 
 VDocumentFragment.prototype = {
-  bR_: 11,
+  bX_: 11,
 
-  bV_: true,
+  ca_: true,
 
   __: function () {
     return new VDocumentFragmentClone(this);
   },
 
-  bO_: function (doc) {
-    return doc.createDocumentFragment();
+  bU_: function (host) {
+    return (host.ownerDocument || host).createDocumentFragment();
   }
 };