marko 5.29.2 → 5.30.0

package/dist/runtime/vdom/VFragment.js

@@ -1,21 +1,21 @@
 "use strict";var domData = require("../components/dom-data");
-var keysByDOMNode = domData._s_;
-var vElementByDOMNode = domData._t_;
+var keysByDOMNode = domData._M_;
+var vElementByDOMNode = domData._N_;
 var VNode = require("./VNode");
 var inherit = require("raptor-util/inherit");
-var createFragmentNode = require("./morphdom/fragment").S_;
+var createFragmentNode = require("./morphdom/fragment")._n_;
 
 function VFragment(key, ownerComponent, preserve) {
-  this.bx_(null /* childCount */, ownerComponent);
-  this.by_ = key;
+  this.bR_(null /* childCount */, ownerComponent);
+  this.bS_ = key;
   this.o_ = preserve;
 }
 
 VFragment.prototype = {
-  bz_: 12,
-  bw_: function () {
+  bT_: 12,
+  bQ_: function () {
     var fragment = createFragmentNode();
-    keysByDOMNode.set(fragment, this.by_);
+    keysByDOMNode.set(fragment, this.bS_);
     vElementByDOMNode.set(fragment, this);
     return fragment;
   }

package/dist/runtime/vdom/VNode.js

@@ -2,81 +2,81 @@
 function VNode() {}
 
 VNode.prototype = {
-  bx_: function (finalChildCount, ownerComponent) {
-    this.bN_ = finalChildCount;
-    this.bO_ = 0;
-    this.bD_ = null;
-    this.bP_ = null;
-    this.bA_ = null;
-    this.bB_ = null;
-    this._v_ = ownerComponent;
+  bR_: function (finalChildCount, ownerComponent) {
+    this.cg_ = finalChildCount;
+    this.ch_ = 0;
+    this.bX_ = null;
+    this.ci_ = null;
+    this.bU_ = null;
+    this.bV_ = null;
+    this._P_ = ownerComponent;
   },
 
-  get ai_() {
-    var firstChild = this.bD_;
+  get ay_() {
+    var firstChild = this.bX_;
 
-    if (firstChild && firstChild.bC_) {
-      var nestedFirstChild = firstChild.ai_;
+    if (firstChild && firstChild.bW_) {
+      var nestedFirstChild = firstChild.ay_;
       // 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.bQ_;
+      return nestedFirstChild || firstChild.cj_;
     }
 
     return firstChild;
   },
 
-  get bQ_() {
-    var nextSibling = this.bB_;
+  get cj_() {
+    var nextSibling = this.bV_;
 
     if (nextSibling) {
-      if (nextSibling.bC_) {
-        var firstChild = nextSibling.ai_;
-        return firstChild || nextSibling.bQ_;
+      if (nextSibling.bW_) {
+        var firstChild = nextSibling.ay_;
+        return firstChild || nextSibling.cj_;
       }
     } else {
-      var parentNode = this.bA_;
-      if (parentNode && parentNode.bC_) {
-        return parentNode.bQ_;
+      var parentNode = this.bU_;
+      if (parentNode && parentNode.bW_) {
+        return parentNode.cj_;
       }
     }
 
     return nextSibling;
   },
 
-  bp_: function (child) {
-    this.bO_++;
+  bJ_: function (child) {
+    this.ch_++;
 
-    if (this.bF_ === "textarea") {
-      if (child.bR_) {
-        var childValue = child.bS_;
-        this.bG_ = (this.bG_ || "") + childValue;
+    if (this.bZ_ === "textarea") {
+      if (child.ck_) {
+        var childValue = child.cl_;
+        this.c__ = (this.c__ || "") + childValue;
       } else if (child.o_ || child.n_) {
-        this.bT_ = true;
+        this.cm_ = true;
       } else {
         throw TypeError();
       }
     } else {
-      var lastChild = this.bP_;
+      var lastChild = this.ci_;
 
-      child.bA_ = this;
+      child.bU_ = this;
 
       if (lastChild) {
-        lastChild.bB_ = child;
+        lastChild.bV_ = child;
       } else {
-        this.bD_ = child;
+        this.bX_ = child;
       }
 
-      this.bP_ = child;
+      this.ci_ = child;
     }
 
     return child;
   },
 
-  bI_: function finishChild() {
-    if (this.bO_ === this.bN_ && this.bA_) {
-      return this.bA_.bI_();
+  cb_: function finishChild() {
+    if (this.ch_ === this.cg_ && this.bU_) {
+      return this.bU_.cb_();
     } else {
       return this;
     }

package/dist/runtime/vdom/VText.js

@@ -2,21 +2,21 @@
 var inherit = require("raptor-util/inherit");
 
 function VText(value, ownerComponent) {
-  this.bx_(-1 /* no children */, ownerComponent);
-  this.bS_ = value;
+  this.bR_(-1 /* no children */, ownerComponent);
+  this.cl_ = value;
 }
 
 VText.prototype = {
-  bR_: true,
+  ck_: true,
 
-  bz_: 3,
+  bT_: 3,
 
-  bw_: function (host) {
-    return (host.ownerDocument || host).createTextNode(this.bS_);
+  bQ_: function (host) {
+    return (host.ownerDocument || host).createTextNode(this.cl_);
   },
 
-  bq_: function () {
-    return new VText(this.bS_);
+  bK_: function () {
+    return new VText(this.cl_);
   }
 };
 

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

@@ -1,22 +1,25 @@
 "use strict";
 
+
 var classHelper = require("../../helpers/class-value");
 var styleHelper = require("../../helpers/style-value");
+var parseHTML = require("../parse-html");
 
 /**
  * Helper for processing dynamic attributes
  */
 module.exports = function (attributes) {
-  if (attributes != null) {
+  if (typeof attributes === "string") {
     // eslint-disable-next-line no-constant-condition
 
 
 
 
 
+    return parseAttrs(attributes);
+  }
 
-
-
+  if (attributes) {
     var newAttributes = {};
 
     for (var attrName in attributes) {
@@ -38,4 +41,21 @@ module.exports = function (attributes) {
   }
 
   return attributes;
-};
+};
+
+function parseAttrs(str) {
+  if (str === "") {
+    return {};
+  }
+
+  var attrs = parseHTML("<a " + str + ">").attributes;
+  var result = {};
+  var attr;
+
+  for (var len = attrs.length, i = 0; i < len; i++) {
+    attr = attrs[i];
+    result[attr.name] = attr.value;
+  }
+
+  return result;
+}

package/dist/runtime/vdom/helpers/merge-attrs.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var attrs = require("./attrs");
+
+/**
+ * Merges attribute objects into a object.
+ */
+module.exports = function mergeAttrs() {
+  var len = arguments.length;
+  var result = {};
+  for (var i = 0; i < len; i++) {
+    Object.assign(result, attrs(arguments[i]));
+  }
+
+  return result;
+};

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

@@ -1,6 +1,6 @@
 "use strict";
 
-var VElement = require("../vdom").aZ_;
+var VElement = require("../vdom").bs_;
 
 module.exports = function (
 tagName,

package/dist/runtime/vdom/helpers/v-text.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var VText = require("../vdom").ba_;
+var VText = require("../vdom").bu_;
 
 module.exports = function (value) {
   return new VText(value);

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

@@ -4,7 +4,7 @@ var registry = require("@internal/components-registry");
 var updateManager = require("../components/update-manager");
 
 var createTemplate = runtime.t;
-var createComponent = registry._o_;
+var createComponent = registry._I_;
 var registered = {};
 var instancesByType = {};
 var queue;
@@ -31,33 +31,33 @@ runtime.t = function (typeName) {
         }
 
         queue.push(function () {
-          var newProto = registry._p_(typeName).prototype;
+          var newProto = registry._J_(typeName).prototype;
           instances.forEach(function (instance) {
             if (hasLifecycleChanged(instance.__proto__, newProto)) {
-              var renderer = instance.af_;
-              instance.af_ = (input, out) => {
-                instance.ao_(input, out);
+              var renderer = instance.W_;
+              instance.W_ = (input, out) => {
+                instance.aD_(input, out);
                 if (instance.onInput) {
                   input = instance.onInput(input, out) || input;
                 }
-                instance.af_ = renderer;
-                instance.af_(input, out);
+                instance.W_ = renderer;
+                instance.W_(input, out);
               };
 
-              instance.bU_ = true;
-              instance._U_();
-              instance._f_ = false;
+              instance.cn_ = true;
+              instance.am_();
+              instance._z_ = false;
 
-              if (instance._N_) {
-                instance._N_.removeAllListeners();
-                instance._N_ = null;
+              if (instance.ag_) {
+                instance.ag_.removeAllListeners();
+                instance.ag_ = null;
               }
             }
 
             instance.__proto__ = newProto;
-            instance._n_(
-            instance.K_, false).
-            afterInsert(instance._b_);
+            instance._H_(
+            instance.U_, false).
+            afterInsert(instance.I_);
           });
         });
       }
@@ -71,14 +71,14 @@ runtime.t = function (typeName) {
   }
 };
 
-registry._o_ = 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.bU_) {
+      if (!instance.cn_) {
         instances.delete(instance);
       }
     });
@@ -104,7 +104,7 @@ function hasLifecycleChanged(oldProto, newProto) {
 }
 
 function batchUpdate() {
-  updateManager.ag_(function () {
+  updateManager.aw_(function () {
     var pending = queue;
     queue = undefined;
 

package/dist/runtime/vdom/index.js

@@ -15,11 +15,11 @@ exports.t = function createTemplate(typeName) {
 };
 
 function Template(typeName) {
-  this.aY_ = typeName;
+  this.path = this.X_ = typeName;
 }
 
 var AsyncVDOMBuilder = require("./AsyncVDOMBuilder");
-require("../createOut").aI_(
+require("../createOut").bc_(
 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.aJ_;
+var insertBefore = helpers.bd_;
 
 var fragmentPrototype = {
   nodeType: 12,
@@ -80,8 +80,8 @@ function createFragmentNode(startNode, nextNode, parentNode) {
 
 function beginFragmentNode(startNode, parentNode) {
   var fragment = createFragmentNode(startNode, null, parentNode);
-  fragment.bV_ = function (nextNode) {
-    fragment.bV_ = null;
+  fragment.co_ = function (nextNode) {
+    fragment.co_ = null;
     insertBefore(
     fragment.endNode,
     nextNode,
@@ -91,5 +91,5 @@ function beginFragmentNode(startNode, parentNode) {
   return fragment;
 }
 
-exports.S_ = createFragmentNode;
-exports.bW_ = beginFragmentNode;
+exports._n_ = createFragmentNode;
+exports.cp_ = beginFragmentNode;

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

@@ -35,8 +35,8 @@ function removeChild(node) {
   node.parentNode.removeChild(node);
 }
 
-exports.aJ_ = insertBefore;
-exports.aK_ = insertAfter;
-exports.bQ_ = nextSibling;
-exports.ai_ = firstChild;
-exports.aL_ = removeChild;
+exports.bd_ = insertBefore;
+exports.be_ = insertAfter;
+exports.cj_ = nextSibling;
+exports.ay_ = firstChild;
+exports.bf_ = removeChild;