marko 5.29.2 → 5.30.0

package/dist/node_modules/@internal/create-readable/index.js

@@ -17,9 +17,9 @@ if (String(OutgoingMessageProto.flush).indexOf("deprecated") !== -1) {
 class Readable extends stream.Readable {
   constructor(template, data) {
     super();
-    this._F_ = template;
-    this._G_ = data;
-    this._H_ = false;
+    this._Z_ = template;
+    this.a__ = data;
+    this.aa_ = false;
   }
 
   write(data) {
@@ -33,19 +33,19 @@ class Readable extends stream.Readable {
   }
 
   _read() {
-    if (this._H_) {
+    if (this.aa_) {
       return;
     }
 
-    this._H_ = true;
-    var template = this._F_;
-    var data = this._G_;
+    this.aa_ = true;
+    var template = this._Z_;
+    var data = this.a__;
     var globalData = data && data.$global;
-    var out = this._F_.createOut(
+    var out = this._Z_.createOut(
     globalData,
     this,
     undefined,
-    template._E_);
+    template._Y_);
 
     template.render(data, out);
     out.end();

package/dist/node_modules/@internal/set-immediate/index-browser.js

@@ -10,7 +10,7 @@ window.addEventListener("message", function (ev) {
   }
 });
 
-exports._I_ = function (callback) {
+exports.ab_ = function (callback) {
   if (queue.push(callback) === 1) {
     window.postMessage(msg, "*");
   }

package/dist/node_modules/@internal/set-immediate/index-worker.js

@@ -1,2 +1,2 @@
-"use strict";exports._I_ = setTimeout;
-exports._J_ = clearTimeout;
+"use strict";exports.ab_ = setTimeout;
+exports.ac_ = clearTimeout;

package/dist/node_modules/@internal/set-immediate/index.js

@@ -1,2 +1,2 @@
-"use strict";exports._I_ = setImmediate;
-exports._J_ = clearImmediate;
+"use strict";exports.ab_ = setImmediate;
+exports.ac_ = clearImmediate;

package/dist/runtime/RenderResult.js

@@ -50,7 +50,7 @@ var proto = RenderResult.prototype = {
     var out = this.A_;
     var componentsContext = out.b_;
     if (componentsContext) {
-      this.b_ = componentsContext._K_(host);
+      this.b_ = componentsContext.ad_(host);
     } else {
       this.b_ = null;
     }
@@ -58,10 +58,10 @@ var proto = RenderResult.prototype = {
     return this;
   },
   getNode: function (host) {
-    return this.A_._L_(host);
+    return this.A_.ae_(host);
   },
   getOutput: function () {
-    return this.A_._M_();
+    return this.A_.af_();
   },
   toString: function () {
     return this.A_.toString();

package/dist/runtime/components/Component.js

@@ -8,8 +8,8 @@ var defaultCreateOut = require("../createOut");
 var getComponentsContext =
 require("./ComponentsContext").e_;
 var componentsUtil = require("@internal/components-util");
-var componentLookup = componentsUtil.T_;
-var destroyNodeRecursive = componentsUtil._A_;
+var componentLookup = componentsUtil._o_;
+var destroyNodeRecursive = componentsUtil._U_;
 var EventEmitter = require("events-light");
 var RenderResult = require("../RenderResult");
 var SubscriptionTracker = require("listener-tracker");
@@ -18,8 +18,8 @@ var updateManager = require("./update-manager");
 var morphdom = require("../vdom/morphdom");
 var eventDelegation = require("./event-delegation");
 var domData = require("./dom-data");
-var componentsByDOMNode = domData.W_;
-var keyedElementsByComponentId = domData.V_;
+var componentsByDOMNode = domData._r_;
+var keyedElementsByComponentId = domData._q_;
 var CONTEXT_KEY = "__subtree_context__";
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -66,7 +66,7 @@ extraArgs)
     args = extraArgs.concat(args);
   }
 
-  var targetComponent = componentLookup[component.H_];
+  var targetComponent = componentLookup[component._a_];
   var targetMethod =
   typeof targetMethodName === "function" ?
   targetMethodName :
@@ -128,8 +128,8 @@ function processUpdateHandlers(component, stateChanges, oldState) {
       handlerMethod.call(component, newValue, oldValue);
     });
 
-    component._g_();
-    component._a_();
+    component._A_();
+    component._v_();
   }
 
   return true;
@@ -169,22 +169,22 @@ var componentProto;
 function Component(id) {
   EventEmitter.call(this);
   this.id = id;
-  this.J_ = null;
-  this._m_ = null;
-  this._N_ = null;
-  this._e_ = null;
-  this.I_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
   this.G_ = null;
-  this.H_ = null;
-  this._O_ = null;
-  this.K_ = undefined;
+  this._G_ = null;
+  this.ag_ = null;
+  this._y_ = null;
+  this._b_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
+  this.___ = null;
+  this._a_ = null;
+  this.ah_ = null;
+  this.U_ = undefined;
+  this._z_ = false;
+  this.ai_ = undefined;
+  this.P_ = false;
   this._f_ = false;
-  this._P_ = undefined;
-  this._Q_ = false;
-  this.N_ = false;
-  this._R_ = false;
-  this._S_ = false;
-  this._b_ = undefined;
+  this.aj_ = false;
+  this.ak_ = false;
+  this.I_ = undefined;
 
   var ssrKeyedElements = keyedElementsByComponentId[id];
 
@@ -197,7 +197,7 @@ function Component(id) {
 }
 
 Component.prototype = componentProto = {
-  X_: true,
+  E_: true,
 
   subscribeTo: function (target) {
     if (!target) {
@@ -205,10 +205,10 @@ Component.prototype = componentProto = {
     }
 
     var subscriptions =
-    this._N_ || (
-    this._N_ = new SubscriptionTracker());
+    this.ag_ || (
+    this.ag_ = new SubscriptionTracker());
 
-    var subscribeToOptions = target.X_ ?
+    var subscribeToOptions = target.E_ ?
     COMPONENT_SUBSCRIBE_TO_OPTIONS :
     NON_COMPONENT_SUBSCRIBE_TO_OPTIONS;
 
@@ -216,7 +216,7 @@ Component.prototype = componentProto = {
   },
 
   emit: function (eventType) {
-    var customEvents = this.G_;
+    var customEvents = this.___;
     var target;
 
     if (customEvents && (target = customEvents[eventType])) {
@@ -247,20 +247,18 @@ Component.prototype = componentProto = {
   },
   getEl: function (key, index) {
     if (key) {
-      var keyedElement =
-      this.l_["@" + resolveKeyHelper(key, index)];
-
-      // eslint-disable-next-line no-constant-condition
-
-
-
-
+      var resolvedKey = resolveKeyHelper(key, index);
+      var keyedElement = this.l_["@" + resolvedKey];
+      if (keyedElement && keyedElement.nodeType === 12 /** FRAGMENT_NODE */) {
+        // eslint-disable-next-line no-constant-condition
 
 
 
 
 
 
+        return walkFragments(keyedElement);
+      }
 
       return keyedElement;
     } else {
@@ -281,15 +279,15 @@ Component.prototype = componentProto = {
   },
   getComponent: function (key, index) {
     var rootNode = this.l_["@" + resolveKeyHelper(key, index)];
-    // eslint-disable-next-line no-constant-condition
-
-
-
+    if (/\[\]$/.test(key)) {
+      // eslint-disable-next-line no-constant-condition
 
 
 
 
 
+      rootNode = rootNode && rootNode[Object.keys(rootNode)[0]];
+    }
     return rootNode && componentsByDOMNode.get(rootNode);
   },
   getComponents: function (key) {
@@ -303,20 +301,20 @@ Component.prototype = componentProto = {
     [];
   },
   destroy: function () {
-    if (this._Q_) {
+    if (this.P_) {
       return;
     }
 
-    var root = this._m_;
+    var root = this._G_;
 
-    this._w_();
+    this._Q_();
 
     var nodes = root.nodes;
 
     nodes.forEach(function (node) {
       destroyNodeRecursive(node);
 
-      if (eventDelegation._T_(node) !== false) {
+      if (eventDelegation.al_(node) !== false) {
         node.parentNode.removeChild(node);
       }
     });
@@ -327,81 +325,81 @@ Component.prototype = componentProto = {
     this.l_ = {};
   },
 
-  _w_: function () {
-    if (this._Q_) {
+  _Q_: function () {
+    if (this.P_) {
       return;
     }
 
-    this._U_();
-    this._Q_ = true;
+    this.am_();
+    this.P_ = true;
 
-    componentsByDOMNode.set(this._m_, undefined);
+    componentsByDOMNode.set(this._G_, undefined);
 
-    this._m_ = null;
+    this._G_ = null;
 
     // Unsubscribe from all DOM events
-    this._d_();
+    this._x_();
 
-    var subscriptions = this._N_;
+    var subscriptions = this.ag_;
     if (subscriptions) {
       subscriptions.removeAllListeners();
-      this._N_ = null;
+      this.ag_ = null;
     }
   },
 
   isDestroyed: function () {
-    return this._Q_;
+    return this.P_;
   },
   get state() {
-    return this.J_;
+    return this.G_;
   },
   set state(newState) {
-    var state = this.J_;
+    var state = this.G_;
     if (!state && !newState) {
       return;
     }
 
     if (!state) {
-      state = this.J_ = new this._V_(this);
+      state = this.G_ = new this.V_(this);
     }
 
-    state._W_(newState || {});
+    state.an_(newState || {});
 
-    if (state._R_) {
-      this._X_();
+    if (state.aj_) {
+      this.ao_();
     }
 
     if (!newState) {
-      this.J_ = null;
+      this.G_ = null;
     }
   },
   setState: function (name, value) {
-    var state = this.J_;
+    var state = this.G_;
 
     if (!state) {
-      state = this.J_ = new this._V_(this);
+      state = this.G_ = new this.V_(this);
     }
     if (typeof name == "object") {
       // Merge in the new state with the old state
       var newState = name;
       for (var k in newState) {
         if (hasOwnProperty.call(newState, k)) {
-          state._Y_(k, newState[k], true /* ensure:true */);
+          state.ap_(k, newState[k], true /* ensure:true */);
         }
       }
     } else {
-      state._Y_(name, value, true /* ensure:true */);
+      state.ap_(name, value, true /* ensure:true */);
     }
   },
 
   setStateDirty: function (name, value) {
-    var state = this.J_;
+    var state = this.G_;
 
     if (arguments.length == 1) {
       value = state[name];
     }
 
-    state._Y_(
+    state.ap_(
     name,
     value,
     true /* ensure:true */,
@@ -410,46 +408,46 @@ Component.prototype = componentProto = {
   },
 
   replaceState: function (newState) {
-    this.J_._W_(newState);
+    this.G_.an_(newState);
   },
 
   get input() {
-    return this.K_;
+    return this.U_;
   },
   set input(newInput) {
-    if (this._S_) {
-      this.K_ = newInput;
+    if (this.ak_) {
+      this.U_ = newInput;
     } else {
-      this._Z_(newInput);
+      this._m_(newInput);
     }
   },
 
-  _Z_: function (newInput, onInput, out) {
+  _m_: function (newInput, onInput, out) {
     onInput = onInput || this.onInput;
     var updatedInput;
 
-    var oldInput = this.K_;
-    this.K_ = undefined;
-    this.a__ = out && out[CONTEXT_KEY] || this.a__;
+    var oldInput = this.U_;
+    this.U_ = undefined;
+    this.aq_ = out && out[CONTEXT_KEY] || this.aq_;
 
     if (onInput) {
       // We need to set a flag to preview `this.input = foo` inside
       // onInput causing infinite recursion
-      this._S_ = true;
+      this.ak_ = true;
       updatedInput = onInput.call(this, newInput || {}, out);
-      this._S_ = false;
+      this.ak_ = false;
     }
 
-    newInput = this._O_ = updatedInput || newInput;
+    newInput = this.ah_ = updatedInput || newInput;
 
-    if (this._R_ = checkInputChanged(this, oldInput, newInput)) {
-      this._X_();
+    if (this.aj_ = checkInputChanged(this, oldInput, newInput)) {
+      this.ao_();
     }
 
-    if (this.K_ === undefined) {
-      this.K_ = newInput;
+    if (this.U_ === undefined) {
+      this.U_ = newInput;
       if (newInput && newInput.$global) {
-        this._P_ = newInput.$global;
+        this.ai_ = newInput.$global;
       }
     }
 
@@ -457,57 +455,57 @@ Component.prototype = componentProto = {
   },
 
   forceUpdate: function () {
-    this._R_ = true;
-    this._X_();
+    this.aj_ = true;
+    this.ao_();
   },
 
-  _X_: function () {
-    if (!this.N_) {
-      this.N_ = true;
-      updateManager.aa_(this);
+  ao_: function () {
+    if (!this._f_) {
+      this._f_ = true;
+      updateManager.ar_(this);
     }
   },
 
   update: function () {
-    if (this._Q_ === true || this.ab_ === false) {
+    if (this.P_ === true || this.as_ === false) {
       return;
     }
 
-    var input = this.K_;
-    var state = this.J_;
+    var input = this.U_;
+    var state = this.G_;
 
-    if (this._R_ === false && state !== null && state._R_ === true) {
-      if (processUpdateHandlers(this, state.ac_, state.ad_, state)) {
-        state._R_ = false;
+    if (this.aj_ === false && state !== null && state.aj_ === true) {
+      if (processUpdateHandlers(this, state.at_, state.au_, state)) {
+        state.aj_ = false;
       }
     }
 
-    if (this.ab_ === true) {
+    if (this.as_ === true) {
       // The UI component is still dirty after process state handlers
       // then we should rerender
 
       if (this.shouldUpdate(input, state) !== false) {
-        this.ae_();
+        this.av_();
       }
     }
 
-    this._a_();
+    this._v_();
   },
 
-  get ab_() {
+  get as_() {
     return (
-      this._R_ === true ||
-      this.J_ !== null && this.J_._R_ === true);
+      this.aj_ === true ||
+      this.G_ !== null && this.G_.aj_ === true);
 
   },
 
-  _a_: function () {
-    this._R_ = false;
-    this.N_ = false;
-    this._O_ = null;
-    var state = this.J_;
+  _v_: function () {
+    this.aj_ = false;
+    this._f_ = false;
+    this.ah_ = null;
+    var state = this.G_;
     if (state) {
-      state._a_();
+      state._v_();
     }
   },
 
@@ -515,72 +513,72 @@ Component.prototype = componentProto = {
     return true;
   },
 
-  ae_: function () {
+  av_: function () {
     var self = this;
-    var renderer = self.af_;
+    var renderer = self.W_;
 
     if (!renderer) {
       throw TypeError();
     }
 
-    var input = this._O_ || this.K_;
+    var input = this.ah_ || this.U_;
 
-    updateManager.ag_(function () {
-      self._n_(input, false).afterInsert(self._b_);
+    updateManager.aw_(function () {
+      self._H_(input, false).afterInsert(self.I_);
     });
 
-    this._a_();
+    this._v_();
   },
 
-  _n_: function (input, isHydrate) {
-    var host = this._b_;
-    var globalData = this._P_;
-    var rootNode = this._m_;
-    var renderer = this.af_;
+  _H_: function (input, isHydrate) {
+    var host = this.I_;
+    var globalData = this.ai_;
+    var rootNode = this._G_;
+    var renderer = this.W_;
     var createOut = renderer.createOut || defaultCreateOut;
     var out = createOut(globalData);
     out.sync();
-    out._b_ = this._b_;
-    out[CONTEXT_KEY] = this.a__;
+    out.I_ = this.I_;
+    out[CONTEXT_KEY] = this.aq_;
 
     var componentsContext = getComponentsContext(out);
     var globalComponentsContext = componentsContext.f_;
-    globalComponentsContext.ah_ = this;
+    globalComponentsContext.ax_ = this;
     globalComponentsContext.g_ = isHydrate;
 
     renderer(input, out);
 
     var result = new RenderResult(out);
 
-    var targetNode = out._M_().ai_;
+    var targetNode = out.af_().ay_;
 
     morphdom(rootNode, targetNode, host, componentsContext);
 
     return result;
   },
 
-  aj_: function () {
-    var root = this._m_;
+  az_: function () {
+    var root = this._G_;
     root.remove();
     return root;
   },
 
-  _d_: function () {
-    var eventListenerHandles = this._e_;
+  _x_: function () {
+    var eventListenerHandles = this._y_;
     if (eventListenerHandles) {
       eventListenerHandles.forEach(removeListener);
-      this._e_ = null;
+      this._y_ = null;
     }
   },
 
-  get ak_() {
-    var state = this.J_;
-    return state && state.al_;
+  get aA_() {
+    var state = this.G_;
+    return state && state.H_;
   },
 
-  am_: function (customEvents, scope) {
-    var finalCustomEvents = this.G_ = {};
-    this.H_ = scope;
+  aB_: function (customEvents, scope) {
+    var finalCustomEvents = this.___ = {};
+    this._a_ = scope;
 
     customEvents.forEach(function (customEvent) {
       var eventType = customEvent[0];
@@ -595,7 +593,7 @@ Component.prototype = componentProto = {
   },
 
   get el() {
-    return walkFragments(this._m_);
+    return walkFragments(this._G_);
   },
 
   get els() {
@@ -605,43 +603,43 @@ Component.prototype = componentProto = {
 
 
 
-    return (this._m_ ? this._m_.nodes : []).filter(function (
+    return (this._G_ ? this._G_.nodes : []).filter(function (
     el)
     {
       return el.nodeType === ELEMENT_NODE;
     });
   },
 
-  an_: emit,
-  ao_(input, out) {
+  aC_: emit,
+  aD_(input, out) {
     this.onCreate && this.onCreate(input, out);
-    this.an_("create", input, out);
+    this.aC_("create", input, out);
   },
 
-  ap_(out) {
+  aE_(out) {
     this.onRender && this.onRender(out);
-    this.an_("render", out);
+    this.aC_("render", out);
   },
 
-  _g_() {
+  _A_() {
     this.onUpdate && this.onUpdate();
-    this.an_("update");
+    this.aC_("update");
   },
 
-  _h_() {
+  _B_() {
     this.onMount && this.onMount();
-    this.an_("mount");
+    this.aC_("mount");
   },
 
-  _U_() {
+  am_() {
     this.onDestroy && this.onDestroy();
-    this.an_("destroy");
+    this.aC_("destroy");
   }
 };
 
 componentProto.elId = componentProto.getElId;
-componentProto.aq_ = componentProto.update;
-componentProto.ar_ = componentProto.destroy;
+componentProto.aF_ = componentProto.update;
+componentProto.aG_ = componentProto.destroy;
 
 // Add all of the following DOM methods to Component.prototype:
 // - appendTo(referenceEl)
@@ -653,7 +651,7 @@ componentProto.ar_ = componentProto.destroy;
 domInsert(
 componentProto,
 function getEl(component) {
-  return component.aj_();
+  return component.az_();
 },
 function afterInsert(component) {
   return component;