marko 5.21.4 → 5.21.7

package/dist/runtime/components/ComponentDef.js

@@ -2,9 +2,9 @@
 
 var w10Noop = require("warp10/constants").NOOP;
 var componentUtil = require("./util");
-var attachBubblingEvent = componentUtil._C_;
+var attachBubblingEvent = componentUtil._D_;
 var addDelegatedEventHandler =
-require("./event-delegation")._D_;
+require("./event-delegation")._E_;
 var extend = require("raptor-util/extend");
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
@@ -18,25 +18,25 @@ var FLAG_HAS_RENDER_BODY = 2;
  * later (after the rendered HTML has been added to the DOM)
  */
 function ComponentDef(component, componentId, componentsContext) {
-  this._E_ = componentsContext; // The AsyncWriter that this component is associated with
+  this._F_ = componentsContext; // The AsyncWriter that this component is associated with
   this.h_ = component;
   this.id = componentId;
 
-  this._F_ = undefined; // An array of DOM events that need to be added (in sets of three)
-
-  this._G_ = false;
+  this._G_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
   this._H_ = false;
-  this._I_ = 0;
 
-  this._J_ = 0; // The unique integer to use for the next scoped ID
-  this._K_ = null;
+  this._I_ = false;
+  this._J_ = 0;
+
+  this._K_ = 0; // The unique integer to use for the next scoped ID
+  this._L_ = null;
 }
 
 ComponentDef.prototype = {
-  _L_: function (key) {
+  _M_: function (key) {
     return (
-    this._K_ || (this._K_ = new KeySequence()))._L_(
+    this._L_ || (this._L_ = new KeySequence()))._M_(
     key);
   },
 
@@ -70,8 +70,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  _M_: function () {
-    return this.id + "-c" + this._J_++;
+  _N_: function () {
+    return this.id + "-c" + this._K_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -79,14 +79,14 @@ ComponentDef.prototype = {
     return attachBubblingEvent(this, handlerMethodName, isOnce, extraArgs);
   },
 
-  get _N_() {
-    return this.h_._N_;
+  get _O_() {
+    return this.h_._O_;
   } };
 
 
-ComponentDef.prototype.nk = ComponentDef.prototype._L_;
+ComponentDef.prototype.nk = ComponentDef.prototype._M_;
 
-ComponentDef._O_ = function (o, types, global, registry) {
+ComponentDef._P_ = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
@@ -95,11 +95,11 @@ ComponentDef._O_ = function (o, types, global, registry) {
   var state = extra.s;
   var componentProps = extra.w;
   var flags = extra.f;
-  var component = registry._P_(typeName, id);
+  var component = registry._Q_(typeName, id);
 
   // Prevent newly created component from being queued for update since we area
   // just building it from the server info
-  component.U_ = true;
+  component.V_ = true;
 
   if (flags & FLAG_HAS_RENDER_BODY) {
     (input || (input = {})).renderBody = w10Noop;
@@ -130,25 +130,25 @@ ComponentDef._O_ = function (o, types, global, registry) {
     }
   }
 
-  component.Q_ = input;
+  component.R_ = input;
 
   if (extra.b) {
-    component.N_ = extra.b;
+    component.O_ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component._v_(customEvents, scope);
+    component._w_(customEvents, scope);
   }
 
-  component.S_ = global;
+  component.T_ = global;
 
   return {
     id: id,
     h_: component,
-    _F_: extra.d,
-    _I_: extra.f || 0 };
+    _G_: extra.d,
+    _J_: extra.f || 0 };
 
 };
 

package/dist/runtime/components/ComponentsContext.js

@@ -11,9 +11,9 @@ function ComponentsContext(out, parentComponentsContext) {
 
     var nestedContextsForParent;
     if (
-    !(nestedContextsForParent = parentComponentsContext._Q_))
+    !(nestedContextsForParent = parentComponentsContext._R_))
     {
-      nestedContextsForParent = parentComponentsContext._Q_ = [];
+      nestedContextsForParent = parentComponentsContext._R_ = [];
     }
 
     nestedContextsForParent.push(this);
@@ -27,24 +27,24 @@ function ComponentsContext(out, parentComponentsContext) {
 
   this.e_ = globalComponentsContext;
   this.b_ = [];
-  this.y_ = out;
+  this.z_ = out;
   this.j_ = componentDef;
-  this._Q_ = undefined;
+  this._R_ = undefined;
   this.p_ =
   parentComponentsContext && parentComponentsContext.p_;
 }
 
 ComponentsContext.prototype = {
-  z_: function (host) {
+  A_: function (host) {
     var componentDefs = this.b_;
 
-    ComponentsContext._R_(componentDefs, host);
+    ComponentsContext._S_(componentDefs, host);
 
-    this.y_.emit("_S_");
+    this.z_.emit("_T_");
 
     // Reset things stored in global since global is retained for
     // future renders
-    this.y_.global.b_ = undefined;
+    this.z_.global.b_ = undefined;
 
     return componentDefs;
   } };

package/dist/runtime/components/GlobalComponentsContext.js

@@ -1,9 +1,9 @@
-"use strict";var nextComponentIdProvider = require("./util")._T_;
+"use strict";var nextComponentIdProvider = require("./util")._U_;
 
 function GlobalComponentsContext(out) {
-  this._U_ = {};
-  this._q_ = undefined;
-  this._M_ = nextComponentIdProvider(out);
+  this._V_ = {};
+  this._r_ = undefined;
+  this._N_ = nextComponentIdProvider(out);
 }
 
 module.exports = GlobalComponentsContext;

package/dist/runtime/components/KeySequence.js

@@ -1,9 +1,9 @@
 "use strict";function KeySequence() {
-  this._V_ = Object.create(null);
+  this._W_ = Object.create(null);
 }
 
-KeySequence.prototype._L_ = function (key) {
-  var lookup = this._V_;
+KeySequence.prototype._M_ = function (key) {
+  var lookup = this._W_;
 
   if (lookup[key]) {
     return key + "_" + lookup[key]++;

package/dist/runtime/components/ServerComponent.js

@@ -4,38 +4,38 @@
 class ServerComponent {
   constructor(id, input, out, typeName, customEvents, scope) {
     this.id = id;
-    this.O_ = customEvents;
-    this.G_ = scope;
+    this.P_ = customEvents;
+    this.H_ = scope;
     this.typeName = typeName;
-    this.N_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
-    this._W_ = 0;
+    this.O_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
+    this._X_ = 0;
 
     this.onCreate(input, out);
-    this._X_ = this.onInput(input, out) || input;
-    if (this.Q_ === undefined) {
-      this.Q_ = this._X_;
+    this._Y_ = this.onInput(input, out) || input;
+    if (this.R_ === undefined) {
+      this.R_ = this._Y_;
     }
     this.onRender(out);
   }
 
   set input(newInput) {
-    this.Q_ = newInput;
+    this.R_ = newInput;
   }
 
   get input() {
-    return this.Q_;
+    return this.R_;
   }
 
   set state(newState) {
-    this.J_ = newState;
+    this.K_ = newState;
   }
 
   get state() {
-    return this.J_;
+    return this.K_;
   }
 
-  get _t_() {
-    return this.J_;
+  get _u_() {
+    return this.K_;
   }
 
   elId(nestedId) {

package/dist/runtime/components/State.js

@@ -5,10 +5,10 @@ function ensure(state, propertyName) {
   if (!(propertyName in proto)) {
     Object.defineProperty(proto, propertyName, {
       get: function () {
-        return this._u_[propertyName];
+        return this._v_[propertyName];
       },
       set: function (value) {
-        this._f_(propertyName, value, false /* ensure:false */);
+        this._g_(propertyName, value, false /* ensure:false */);
       } });
 
   }
@@ -16,35 +16,35 @@ function ensure(state, propertyName) {
 
 function State(component) {
   this.h_ = component;
-  this._u_ = {};
+  this._v_ = {};
 
-  this.V_ = false;
+  this.W_ = false;
+  this._m_ = null;
   this._l_ = null;
-  this._k_ = null;
-  this._Y_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
+  this._Z_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
 
   Object.seal(this);
 }
 
 State.prototype = {
-  I_: function () {
+  J_: function () {
     var self = this;
 
-    self.V_ = false;
+    self.W_ = false;
+    self._m_ = null;
     self._l_ = null;
-    self._k_ = null;
-    self._Y_ = null;
+    self._Z_ = null;
   },
 
-  _d_: function (newState) {
+  _e_: function (newState) {
     var state = this;
     var key;
 
-    var rawState = this._u_;
+    var rawState = this._v_;
 
     for (key in rawState) {
       if (!(key in newState)) {
-        state._f_(
+        state._g_(
         key,
         undefined,
         false /* ensure:false */,
@@ -54,7 +54,7 @@ State.prototype = {
     }
 
     for (key in newState) {
-      state._f_(
+      state._g_(
       key,
       newState[key],
       true /* ensure:true */,
@@ -62,32 +62,32 @@ State.prototype = {
 
     }
   },
-  _f_: function (name, value, shouldEnsure, forceDirty) {
-    var rawState = this._u_;
+  _g_: function (name, value, shouldEnsure, forceDirty) {
+    var rawState = this._v_;
 
     if (shouldEnsure) {
       ensure(this, name);
     }
 
     if (forceDirty) {
-      var forcedDirtyState = this._Y_ || (this._Y_ = {});
+      var forcedDirtyState = this._Z_ || (this._Z_ = {});
       forcedDirtyState[name] = true;
     } else if (rawState[name] === value) {
       return;
     }
 
-    if (!this.V_) {
+    if (!this.W_) {
       // This is the first time we are modifying the component state
       // so introduce some properties to do some tracking of
       // changes to the state
-      this.V_ = true; // Mark the component state as dirty (i.e. modified)
-      this._l_ = rawState;
-      this._u_ = rawState = extend({}, rawState);
-      this._k_ = {};
-      this.h_._e_();
+      this.W_ = true; // Mark the component state as dirty (i.e. modified)
+      this._m_ = rawState;
+      this._v_ = rawState = extend({}, rawState);
+      this._l_ = {};
+      this.h_._f_();
     }
 
-    this._k_[name] = value;
+    this._l_[name] = value;
 
     if (value === undefined) {
       // Don't store state properties with an undefined or null value
@@ -98,7 +98,7 @@ State.prototype = {
     }
   },
   toJSON: function () {
-    return this._u_;
+    return this._v_;
   } };
 
 

package/dist/runtime/components/attach-detach.js

@@ -1,6 +1,6 @@
 "use strict";var eventDelegation = require("./event-delegation");
-var delegateEvent = eventDelegation._Z_;
-var getEventFromEl = eventDelegation.a__;
+var delegateEvent = eventDelegation.a__;
+var getEventFromEl = eventDelegation.aa_;
 
 // var componentsUtil = require('./util');
 // var destroyNodeRecursive = componentsUtil.___destroyNodeRecursive;
@@ -11,13 +11,13 @@ function handleNodeAttach(node, componentsContext) {
     var eventName = "onattach";
     var target = getEventFromEl(node, eventName);
     if (target) {
-      var out = componentsContext.y_;
+      var out = componentsContext.z_;
       var data = out.data;
 
-      var attachTargets = data.aa_;
+      var attachTargets = data.ab_;
       if (!attachTargets) {
-        attachTargets = data.aa_ = [];
-        out.on("_S_", function () {
+        attachTargets = data.ab_ = [];
+        out.on("_T_", function () {
           for (var i = 0; i < attachTargets.length; i += 2) {
             var node = attachTargets[i];
             var target = attachTargets[i + 1];
@@ -56,5 +56,5 @@ function handleNodeDetach(node) {
   }
 }
 
-eventDelegation.ab_ = handleNodeAttach;
-eventDelegation.___ = handleNodeDetach;
+eventDelegation.ac_ = handleNodeAttach;
+eventDelegation._a_ = handleNodeDetach;

package/dist/runtime/components/beginComponent/index-browser.js

@@ -12,12 +12,12 @@ ownerComponentDef)
   componentId,
   componentsContext);
 
-  componentsContext.e_._U_[
+  componentsContext.e_._V_[
   componentId] =
   true;
   componentsContext.b_.push(componentDef);
 
-  var out = componentsContext.y_;
+  var out = componentsContext.z_;
   out.bc(component, key, ownerComponentDef && ownerComponentDef.h_);
   return componentDef;
 };

package/dist/runtime/components/beginComponent/index.js

@@ -22,13 +22,13 @@ isImplicitComponent)
 
 
   var ownerIsRenderBoundary =
-  ownerComponentDef && ownerComponentDef._H_;
+  ownerComponentDef && ownerComponentDef._I_;
   var ownerWillRerender =
   ownerComponentDef &&
-  ownerComponentDef._I_ & FLAG_WILL_RERENDER_IN_BROWSER;
+  ownerComponentDef._J_ & FLAG_WILL_RERENDER_IN_BROWSER;
   // On the server
   if (!componentsContext.p_ && ownerWillRerender) {
-    componentDef._I_ |= FLAG_WILL_RERENDER_IN_BROWSER;
+    componentDef._J_ |= FLAG_WILL_RERENDER_IN_BROWSER;
     componentDef._wrr = true;
     return componentDef;
   }
@@ -42,14 +42,14 @@ isImplicitComponent)
 
   componentsContext.b_.push(componentDef);
 
-  let out = componentsContext.y_;
+  let out = componentsContext.z_;
   let runtimeId = out.global.runtimeId;
 
-  componentDef._H_ = true;
-  componentDef.ac_ = componentsContext.p_;
+  componentDef._I_ = true;
+  componentDef.ad_ = componentsContext.p_;
 
   if (isSplitComponent === false && out.global.noBrowserRerender !== true) {
-    componentDef._I_ |= FLAG_WILL_RERENDER_IN_BROWSER;
+    componentDef._J_ |= FLAG_WILL_RERENDER_IN_BROWSER;
     componentDef._wrr = true;
     componentsContext.p_ = false;
   }

package/dist/runtime/components/defineComponent.js

@@ -6,7 +6,7 @@ var BaseComponent = require("./Component");
 var inherit = require("raptor-util/inherit");
 
 module.exports = function defineComponent(def, renderer) {
-  if (def.Y_) {
+  if (def.Z_) {
     return def;
   }
 
@@ -35,7 +35,7 @@ module.exports = function defineComponent(def, renderer) {
     BaseComponent.call(this, id);
   }
 
-  if (!proto.Y_) {
+  if (!proto.Z_) {
     // Inherit from Component if they didn't already
     inherit(ComponentClass, BaseComponent);
   }
@@ -48,14 +48,14 @@ module.exports = function defineComponent(def, renderer) {
 
   // Set a flag on the constructor function to make it clear this is
   // a component so that we can short-circuit this work later
-  Component.Y_ = true;
+  Component.Z_ = true;
 
   function State(component) {
     BaseState.call(this, component);
   }
   inherit(State, BaseState);
-  proto._c_ = State;
-  proto._n_ = renderer;
+  proto._d_ = State;
+  proto._o_ = renderer;
 
   return Component;
 };

package/dist/runtime/components/dom-data.js

@@ -1,7 +1,7 @@
 "use strict";module.exports = {
-  ad_: new WeakMap(),
   ae_: new WeakMap(),
-  E_: new WeakMap(),
   af_: new WeakMap(),
+  F_: new WeakMap(),
   ag_: new WeakMap(),
-  F_: {} };
+  ah_: new WeakMap(),
+  G_: {} };

package/dist/runtime/components/endComponent/index.js

@@ -4,8 +4,8 @@ var ComponentsContext = require("../ComponentsContext");
 var getComponentsContext = ComponentsContext.o_;
 
 module.exports = function endComponent(out, componentDef) {
-  if (componentDef._H_) {
+  if (componentDef._I_) {
     out.w("<!--" + out.global.runtimeId + "/-->");
-    getComponentsContext(out).p_ = componentDef.ac_;
+    getComponentsContext(out).p_ = componentDef.ad_;
   }
 };

package/dist/runtime/components/entry/index-browser.js

@@ -1,9 +1,9 @@
 "use strict";var initComponents = require("../init-components");
-require("../ComponentsContext")._R_ =
-initComponents._R_;
+require("../ComponentsContext")._S_ =
+initComponents._S_;
 
-exports.getComponentForEl = require("../util").ah_;
-exports.init = window.$initComponents = initComponents.ai_;
+exports.getComponentForEl = require("../util").ai_;
+exports.init = window.$initComponents = initComponents.aj_;
 
 var registry = require("../registry");
 exports.register = function (id, component) {

package/dist/runtime/components/entry/index.js

@@ -64,12 +64,12 @@ function addComponentsFromContext(componentsContext, componentsToHydrate) {
     var componentDef = components[i];
     var id = componentDef.id;
     var component = componentDef.h_;
-    var flags = componentDef._I_;
+    var flags = componentDef._J_;
     var input = component.input || 0;
     var typeName = component.typeName;
-    var customEvents = component.O_;
-    var scope = component.G_;
-    var bubblingDomEvents = component.N_;
+    var customEvents = component.P_;
+    var scope = component.H_;
+    var bubblingDomEvents = component.O_;
 
     var state;
     var serializedProps;
@@ -100,16 +100,16 @@ function addComponentsFromContext(componentsContext, componentsToHydrate) {
         }
       }
 
-      component.J_ = undefined; // We don't use `delete` to avoid V8 deoptimization
-      component.Q_ = undefined; // We don't use `delete` to avoid V8 deoptimization
+      component.K_ = undefined; // We don't use `delete` to avoid V8 deoptimization
+      component.R_ = undefined; // We don't use `delete` to avoid V8 deoptimization
       component.typeName = undefined;
       component.id = undefined;
+      component.P_ = undefined;
+      component.H_ = undefined;
       component.O_ = undefined;
-      component.G_ = undefined;
-      component.N_ = undefined;
-      component._W_ = undefined;
       component._X_ = undefined;
-      component.U_ = undefined;
+      component._Y_ = undefined;
+      component.V_ = undefined;
 
       if (isNotEmpty(component)) {
         serializedProps = component;
@@ -118,7 +118,7 @@ function addComponentsFromContext(componentsContext, componentsToHydrate) {
 
     var extra = {
       b: bubblingDomEvents,
-      d: componentDef._F_,
+      d: componentDef._G_,
       e: customEvents,
       f: flags || undefined,
       p: customEvents && scope, // Only serialize scope if we need to attach custom events
@@ -146,7 +146,7 @@ function addComponentsFromContext(componentsContext, componentsToHydrate) {
   components.length = 0;
 
   // Also add any components from nested contexts
-  var nestedContexts = componentsContext._Q_;
+  var nestedContexts = componentsContext._R_;
   if (nestedContexts !== undefined) {
     nestedContexts.forEach(function (nestedContext) {
       addComponentsFromContext(nestedContext, componentsToHydrate);
@@ -158,7 +158,7 @@ function getInitComponentsData(out, componentDefs) {
   const len = componentDefs.length;
   const $global = out.global;
   const isLast = $global.d_;
-  const didSerializeComponents = $global.aj_;
+  const didSerializeComponents = $global.ak_;
   const prefix = $global.componentIdPrefix || $global.widgetIdPrefix;
 
   if (len === 0) {
@@ -171,7 +171,7 @@ function getInitComponentsData(out, componentDefs) {
 
   const TYPE_INDEX = 1;
   const typesLookup =
-  $global.ak_ || ($global.ak_ = new Map());
+  $global.al_ || ($global.al_ = new Map());
   let newTypes;
 
   for (let i = 0; i < len; i++) {
@@ -196,7 +196,7 @@ function getInitComponentsData(out, componentDefs) {
   let serializedGlobals;
 
   if (!didSerializeComponents) {
-    $global.aj_ = true;
+    $global.ak_ = true;
     serializedGlobals = getSerializedGlobals($global);
   }
 

package/dist/runtime/components/event-delegation.js

@@ -1,7 +1,7 @@
 "use strict";var componentsUtil = require("./util");
-var runtimeId = componentsUtil.al_;
-var componentLookup = componentsUtil.C_;
-var getMarkoPropsFromEl = componentsUtil.am_;
+var runtimeId = componentsUtil.am_;
+var componentLookup = componentsUtil.D_;
+var getMarkoPropsFromEl = componentsUtil.an_;
 
 var TEXT_NODE = 3;
 
@@ -54,7 +54,7 @@ function delegateEvent(node, eventName, target, event) {
 
   if (extraArgs != null) {
     if (typeof extraArgs === "number") {
-      extraArgs = targetComponent.N_[extraArgs];
+      extraArgs = targetComponent.O_[extraArgs];
     }
   }
 
@@ -132,12 +132,12 @@ function addDelegatedEventHandlerToHost(eventType, host) {
 
 function noop() {}
 
-exports.ab_ = noop;
-exports.___ = noop;
-exports._Z_ = delegateEvent;
-exports.a__ = getEventFromEl;
-exports._D_ = addDelegatedEventHandler;
-exports.an_ = function (host) {
+exports.ac_ = noop;
+exports._a_ = noop;
+exports.a__ = delegateEvent;
+exports.aa_ = getEventFromEl;
+exports._E_ = addDelegatedEventHandler;
+exports.ao_ = function (host) {
   Object.keys(delegatedEvents).forEach(function (eventType) {
     addDelegatedEventHandlerToHost(eventType, host);
   });