marko 5.33.8 → 5.33.10

package/dist/runtime/components/ComponentDef.js

@@ -3,9 +3,9 @@
 var extend = require("raptor-util/extend");
 var w10Noop = require("warp10/constants").NOOP;
 var componentUtil = require("@internal/components-util");
-var attachBubblingEvent = componentUtil._Q_;
+var attachBubblingEvent = componentUtil._S_;
 var addDelegatedEventHandler =
-require("./event-delegation")._o_;
+require("./event-delegation")._q_;
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
 
@@ -20,25 +20,25 @@ var FLAG_OLD_HYDRATE_NO_CREATE = 8;
  * later (after the rendered HTML has been added to the DOM)
  */
 function ComponentDef(component, componentId, componentsContext) {
-  this.aH_ = componentsContext; // The AsyncWriter that this component is associated with
-  this.r_ = component;
+  this.aI_ = componentsContext; // The AsyncWriter that this component is associated with
+  this.s_ = component;
   this.id = componentId;
 
-  this._a_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this._b_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._q_ = false;
+  this._s_ = false;
 
-  this.s_ = false;
-  this.t_ = 0;
+  this.t_ = false;
+  this.u_ = 0;
 
-  this.aI_ = 0; // The unique integer to use for the next scoped ID
-  this.aJ_ = null;
+  this.aJ_ = 0; // The unique integer to use for the next scoped ID
+  this.aK_ = null;
 }
 
 ComponentDef.prototype = {
-  aK_: function (key) {
+  aL_: function (key) {
     return (
-    this.aJ_ || (this.aJ_ = new KeySequence())).aK_(
+    this.aK_ || (this.aK_ = new KeySequence())).aL_(
       key);
   },
 
@@ -72,8 +72,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  aL_: function () {
-    return this.id + "-c" + this.aI_++;
+  aM_: function () {
+    return this.id + "-c" + this.aJ_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -81,14 +81,14 @@ ComponentDef.prototype = {
     return attachBubblingEvent(this, handlerMethodName, isOnce, extraArgs);
   },
 
-  get _m_() {
-    return this.r_._m_;
+  get _o_() {
+    return this.s_._o_;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype.aK_;
+ComponentDef.prototype.nk = ComponentDef.prototype.aL_;
 
-ComponentDef._z_ = function (o, types, global, registry) {
+ComponentDef._B_ = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
@@ -102,15 +102,15 @@ ComponentDef._z_ = function (o, types, global, registry) {
 
   var component =
   typeName /* legacy */ &&
-  registry._C_(typeName, id, isLegacy);
+  registry._E_(typeName, id, isLegacy);
 
   // Prevent newly created component from being queued for update since we area
   // just building it from the server info
-  component.___ = true;
+  component._a_ = true;
 
   if (isLegacy) {
     component.widgetConfig = componentProps;
-    component.X_ = renderBody;
+    component.Y_ = renderBody;
   } else if (renderBody) {
     (input || (input = {})).renderBody = renderBody;
   }
@@ -144,25 +144,25 @@ ComponentDef._z_ = function (o, types, global, registry) {
     }
   }
 
-  component.N_ = input;
+  component.O_ = input;
 
   if (extra.b) {
-    component.W_ = extra.b;
+    component.X_ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component.aB_(customEvents, scope);
+    component.aC_(customEvents, scope);
   }
 
-  component.ai_ = global;
+  component.aj_ = global;
 
   return {
     id: id,
-    r_: component,
-    _a_: extra.d,
-    t_: extra.f || 0
+    s_: component,
+    _b_: extra.d,
+    u_: extra.f || 0
   };
 };
 

package/dist/runtime/components/ComponentsContext.js

@@ -6,14 +6,14 @@ function ComponentsContext(out, parentComponentsContext) {
   var componentDef;
 
   if (parentComponentsContext) {
-    globalComponentsContext = parentComponentsContext.o_;
-    componentDef = parentComponentsContext.n_;
+    globalComponentsContext = parentComponentsContext.p_;
+    componentDef = parentComponentsContext.o_;
 
     var nestedContextsForParent;
     if (
-    !(nestedContextsForParent = parentComponentsContext._b_))
+    !(nestedContextsForParent = parentComponentsContext._c_))
     {
-      nestedContextsForParent = parentComponentsContext._b_ = [];
+      nestedContextsForParent = parentComponentsContext._c_ = [];
     }
 
     nestedContextsForParent.push(this);
@@ -25,26 +25,26 @@ function ComponentsContext(out, parentComponentsContext) {
     }
   }
 
-  this.o_ = globalComponentsContext;
+  this.p_ = globalComponentsContext;
   this.b_ = [];
-  this.q_ = out;
-  this.n_ = componentDef;
-  this._b_ = undefined;
-  this.u_ =
-  parentComponentsContext && parentComponentsContext.u_;
+  this.r_ = out;
+  this.o_ = componentDef;
+  this._c_ = undefined;
+  this.v_ =
+  parentComponentsContext && parentComponentsContext.v_;
 }
 
 ComponentsContext.prototype = {
-  ad_: function (host) {
+  ae_: function (host) {
     var componentDefs = this.b_;
 
-    ComponentsContext._E_(componentDefs, host);
+    ComponentsContext._G_(componentDefs, host);
 
-    this.q_.emit("aM_");
+    this.r_.emit("aN_");
 
     // Reset things stored in global since global is retained for
     // future renders
-    this.q_.global.b_ = undefined;
+    this.r_.global.b_ = undefined;
 
     return componentDefs;
   }
@@ -56,4 +56,4 @@ function getComponentsContext(out) {
 
 module.exports = exports = ComponentsContext;
 
-exports.R_ = getComponentsContext;
+exports.S_ = getComponentsContext;

package/dist/runtime/components/GlobalComponentsContext.js

@@ -1,10 +1,10 @@
 "use strict";var nextComponentIdProvider =
-require("@internal/components-util")._P_;
+require("@internal/components-util")._R_;
 
 function GlobalComponentsContext(out) {
-  this.p_ = {};
-  this.ax_ = undefined;
-  this.aL_ = nextComponentIdProvider(out);
+  this.q_ = {};
+  this.ay_ = undefined;
+  this.aM_ = nextComponentIdProvider(out);
 }
 
 module.exports = GlobalComponentsContext;

package/dist/runtime/components/KeySequence.js

@@ -1,9 +1,9 @@
 "use strict";function KeySequence() {
-  this.aN_ = Object.create(null);
+  this.aO_ = Object.create(null);
 }
 
-KeySequence.prototype.aK_ = function (key) {
-  var lookup = this.aN_;
+KeySequence.prototype.aL_ = function (key) {
+  var lookup = this.aO_;
 
   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.U_ = customEvents;
-    this.V_ = scope;
+    this.V_ = customEvents;
+    this.W_ = scope;
     this.typeName = typeName;
-    this.W_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
-    this.Y_ = 0;
+    this.X_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
+    this.Z_ = 0;
 
     this.onCreate(input, out);
-    this.Z_ = this.onInput(input, out) || input;
-    if (this.N_ === undefined) {
-      this.N_ = this.Z_;
+    this.___ = this.onInput(input, out) || input;
+    if (this.O_ === undefined) {
+      this.O_ = this.___;
     }
     this.onRender(out);
   }
 
   set input(newInput) {
-    this.N_ = newInput;
+    this.O_ = newInput;
   }
 
   get input() {
-    return this.N_;
+    return this.O_;
   }
 
   set state(newState) {
-    this.y_ = newState;
+    this.z_ = newState;
   }
 
   get state() {
-    return this.y_;
+    return this.z_;
   }
 
-  get aA_() {
-    return this.y_;
+  get aB_() {
+    return this.z_;
   }
 
   elId(nestedId) {

package/dist/runtime/components/State.js

@@ -5,46 +5,46 @@ function ensure(state, propertyName) {
   if (!(propertyName in proto)) {
     Object.defineProperty(proto, propertyName, {
       get: function () {
-        return this.z_[propertyName];
+        return this.A_[propertyName];
       },
       set: function (value) {
-        this.ap_(propertyName, value, false /* ensure:false */);
+        this.aq_(propertyName, value, false /* ensure:false */);
       }
     });
   }
 }
 
 function State(component) {
-  this.r_ = component;
-  this.z_ = {};
+  this.s_ = component;
+  this.A_ = {};
 
-  this.aj_ = false;
+  this.ak_ = false;
+  this.av_ = null;
   this.au_ = null;
-  this.at_ = null;
-  this.aO_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
+  this.aP_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
 
   Object.seal(this);
 }
 
 State.prototype = {
-  _p_: function () {
+  _r_: function () {
     var self = this;
 
-    self.aj_ = false;
+    self.ak_ = false;
+    self.av_ = null;
     self.au_ = null;
-    self.at_ = null;
-    self.aO_ = null;
+    self.aP_ = null;
   },
 
-  an_: function (newState) {
+  ao_: function (newState) {
     var state = this;
     var key;
 
-    var rawState = this.z_;
+    var rawState = this.A_;
 
     for (key in rawState) {
       if (!(key in newState)) {
-        state.ap_(
+        state.aq_(
           key,
           undefined,
           false /* ensure:false */,
@@ -54,7 +54,7 @@ State.prototype = {
     }
 
     for (key in newState) {
-      state.ap_(
+      state.aq_(
         key,
         newState[key],
         true /* ensure:true */,
@@ -62,32 +62,32 @@ State.prototype = {
       );
     }
   },
-  ap_: function (name, value, shouldEnsure, forceDirty) {
-    var rawState = this.z_;
+  aq_: function (name, value, shouldEnsure, forceDirty) {
+    var rawState = this.A_;
 
     if (shouldEnsure) {
       ensure(this, name);
     }
 
     if (forceDirty) {
-      var forcedDirtyState = this.aO_ || (this.aO_ = {});
+      var forcedDirtyState = this.aP_ || (this.aP_ = {});
       forcedDirtyState[name] = true;
     } else if (rawState[name] === value) {
       return;
     }
 
-    if (!this.aj_) {
+    if (!this.ak_) {
       // 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.aj_ = true; // Mark the component state as dirty (i.e. modified)
-      this.au_ = rawState;
-      this.z_ = rawState = extend({}, rawState);
-      this.at_ = {};
-      this.r_.ao_();
+      this.ak_ = true; // Mark the component state as dirty (i.e. modified)
+      this.av_ = rawState;
+      this.A_ = rawState = extend({}, rawState);
+      this.au_ = {};
+      this.s_.ap_();
     }
 
-    this.at_[name] = value;
+    this.au_[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.z_;
+    return this.A_;
   }
 };
 

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

@@ -1,6 +1,6 @@
 "use strict";var eventDelegation = require("./event-delegation");
-var delegateEvent = eventDelegation.aP_;
-var getEventFromEl = eventDelegation.aQ_;
+var delegateEvent = eventDelegation.aQ_;
+var getEventFromEl = eventDelegation.aR_;
 
 // var componentsUtil = require('@internal/components-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.q_;
+      var out = componentsContext.r_;
       var data = out.data;
 
-      var attachTargets = data.aR_;
+      var attachTargets = data.aS_;
       if (!attachTargets) {
-        attachTargets = data.aR_ = [];
-        out.on("aM_", function () {
+        attachTargets = data.aS_ = [];
+        out.on("aN_", 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.aS_ = handleNodeAttach;
-eventDelegation.al_ = handleNodeDetach;
+eventDelegation.aT_ = handleNodeAttach;
+eventDelegation.am_ = handleNodeDetach;

package/dist/runtime/components/defineComponent.js

@@ -6,7 +6,7 @@ var BaseComponent = require("./Component");
 var BaseState = require("./State");
 
 module.exports = function defineComponent(def, renderer) {
-  if (def.w_) {
+  if (def.x_) {
     return def;
   }
 
@@ -35,7 +35,7 @@ module.exports = function defineComponent(def, renderer) {
     BaseComponent.call(this, id);
   }
 
-  if (!proto.w_) {
+  if (!proto.x_) {
     // 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.w_ = true;
+  Component.x_ = true;
 
   function State(component) {
     BaseState.call(this, component);
   }
   inherit(State, BaseState);
-  proto.O_ = State;
-  proto.P_ = renderer;
+  proto.P_ = State;
+  proto.Q_ = renderer;
 
   return Component;
 };

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

@@ -1,8 +1,8 @@
 "use strict";module.exports = {
+  _K_: new WeakMap(),
+  _J_: new WeakMap(),
+  _n_: new WeakMap(),
+  aU_: new WeakMap(),
   _I_: new WeakMap(),
-  _H_: new WeakMap(),
-  _l_: new WeakMap(),
-  aT_: new WeakMap(),
-  _G_: new WeakMap(),
-  _k_: {}
+  _m_: {}
 };

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

@@ -1,7 +1,7 @@
 "use strict";var componentsUtil = require("@internal/components-util");
-var runtimeId = componentsUtil._M_;
-var componentLookup = componentsUtil._i_;
-var getMarkoPropsFromEl = componentsUtil._n_;
+var runtimeId = componentsUtil._O_;
+var componentLookup = componentsUtil._k_;
+var getMarkoPropsFromEl = componentsUtil._p_;
 
 var TEXT_NODE = 3;
 
@@ -54,7 +54,7 @@ function delegateEvent(node, eventName, target, event) {
 
   if (extraArgs != null) {
     if (typeof extraArgs === "number") {
-      extraArgs = targetComponent.W_[extraArgs];
+      extraArgs = targetComponent.X_[extraArgs];
     }
   }
 
@@ -132,12 +132,12 @@ function addDelegatedEventHandlerToHost(eventType, host) {
 
 function noop() {}
 
-exports.aS_ = noop;
-exports.al_ = noop;
-exports.aP_ = delegateEvent;
-exports.aQ_ = getEventFromEl;
-exports._o_ = addDelegatedEventHandler;
-exports._w_ = function (host) {
+exports.aT_ = noop;
+exports.am_ = noop;
+exports.aQ_ = delegateEvent;
+exports.aR_ = getEventFromEl;
+exports._q_ = addDelegatedEventHandler;
+exports._y_ = function (host) {
   Object.keys(delegatedEvents).forEach(function (eventType) {
     addDelegatedEventHandlerToHost(eventType, host);
   });

package/dist/runtime/components/legacy/defineComponent-legacy.js

@@ -8,7 +8,7 @@ var defineRenderer;
 var defineWidget;
 
 module.exports = function defineComponent(def) {
-  if (def.w_) {
+  if (def.x_) {
     return def;
   }
 

package/dist/runtime/components/legacy/defineRenderer-legacy.js

@@ -1,16 +1,16 @@
 "use strict";
-var componentLookup = require("@internal/components-util")._i_;
+var componentLookup = require("@internal/components-util")._k_;
 var req = require("@internal/require");
 var makeRenderable = require("../../renderable");
 var getComponentsContext =
-require("../ComponentsContext").R_;
+require("../ComponentsContext").S_;
 var modernRenderer = require("../renderer");
-var resolveComponentKey = modernRenderer.aU_;
+var resolveComponentKey = modernRenderer.aV_;
 
 module.exports = function defineRenderer(renderingLogic) {
   var renderer = renderingLogic.renderer;
 
-  if (renderer && renderer.aV_) {
+  if (renderer && renderer.aW_) {
     return renderer;
   }
 
@@ -44,13 +44,13 @@ module.exports = function defineRenderer(renderingLogic) {
     // takes care of re-using existing components.
     renderer = function renderer(input, out) {
       var componentsContext = getComponentsContext(out);
-      var globalComponentsContext = componentsContext.o_;
-      var component = globalComponentsContext.ax_;
-      var isReceivingNewInput = !component || component._f_;
+      var globalComponentsContext = componentsContext.p_;
+      var component = globalComponentsContext.ay_;
+      var isReceivingNewInput = !component || component._g_;
       var parentComponentDef;
 
       if (component) {
-        component._f_ = false;
+        component._g_ = false;
       }
 
       // Render the template associated with the component using the final template
@@ -62,17 +62,17 @@ module.exports = function defineRenderer(renderingLogic) {
       var id;
 
       if (!component && componentLookup) {
-        var key = out._Y_;
+        var key = out.a__;
 
         if (
-        (parentComponentDef = componentsContext.n_) &&
+        (parentComponentDef = componentsContext.o_) &&
         key != null)
         {
           id = resolveComponentKey(key.toString(), parentComponentDef);
         } else if (parentComponentDef) {
-          id = parentComponentDef.aL_();
+          id = parentComponentDef.aM_();
         } else {
-          id = globalComponentsContext.aL_();
+          id = globalComponentsContext.aM_();
         }
 
         component = componentLookup[id];
@@ -105,9 +105,9 @@ module.exports = function defineRenderer(renderingLogic) {
           widgetBody = newProps.renderBody;
         }
       } else if (component) {
-        newProps = newProps || component.M_;
-        widgetBody = component.X_;
-        widgetState = component.aA_;
+        newProps = newProps || component.N_;
+        widgetBody = component.Y_;
+        widgetState = component.aB_;
         widgetConfig = component.widgetConfig;
       }
 
@@ -147,7 +147,7 @@ module.exports = function defineRenderer(renderingLogic) {
     };
   }
 
-  renderer.aV_ = true;
+  renderer.aW_ = true;
   renderer.createOut = template ? template.createOut : renderingLogic.createOut;
   renderer.template = template;
 

package/dist/runtime/components/legacy/dependencies/index.js

@@ -4,14 +4,14 @@ var env = process.env.NODE_ENV;
 var production = !env || env !== "development";
 
 function getRootDeps(template, context) {
-  if (production && template.aW_) {
-    return template.aW_;
+  if (production && template.aX_) {
+    return template.aX_;
   }
 
   attachDepsAndComponentsToTemplate(template, context);
 
-  var deps = template.aW_ = Object.keys(template.aX_).map(
-    (key) => template.aX_[key]
+  var deps = template.aX_ = Object.keys(template.aY_).map(
+    (key) => template.aY_[key]
   );
   var initModule = getInitModule(template.path, template.b_);
 
@@ -38,9 +38,9 @@ function attachDepsAndComponentsToTemplate(target, context) {
   }
 
   if (typeof template.createOut !== "function") return;
-  if (production && target.aX_) return;
+  if (production && target.aY_) return;
 
-  var deps = target.aX_ = {};
+  var deps = target.aY_ = {};
   var components = target.b_ = {};
 
   if (!template.meta) {
@@ -84,7 +84,7 @@ function attachDepsAndComponentsToTemplate(target, context) {
 
       attachDepsAndComponentsToTemplate(tag, context);
 
-      if (tag.aX_) Object.assign(deps, tag.aX_);
+      if (tag.aY_) Object.assign(deps, tag.aY_);
       if (tag.b_) Object.assign(components, tag.b_);
     });
   }