marko 5.35.21 → 5.35.22

package/dist/runtime/components/ComponentDef.js

@@ -3,10 +3,10 @@
 
 var extend = require("raptor-util/extend");
 var componentUtil = require("@internal/components-util");
-var w10NOOP = require("../helpers/serialize-noop").aJ_;
-var attachBubblingEvent = componentUtil._T_;
+var w10NOOP = require("../helpers/serialize-noop").aK_;
+var attachBubblingEvent = componentUtil._U_;
 var addDelegatedEventHandler =
-require("./event-delegation")._s_;
+require("./event-delegation")._t_;
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
 
@@ -21,25 +21,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.aK_ = componentsContext; // The AsyncWriter that this component is associated with
-  this.s_ = component;
+  this.aL_ = componentsContext; // The AsyncWriter that this component is associated with
+  this.t_ = component;
   this.id = componentId;
 
-  this._c_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this._d_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._u_ = false;
+  this._v_ = false;
 
-  this.t_ = false;
-  this.u_ = 0;
+  this.u_ = false;
+  this.v_ = 0;
 
-  this.aL_ = 0; // The unique integer to use for the next scoped ID
-  this.aM_ = null;
+  this.aM_ = 0; // The unique integer to use for the next scoped ID
+  this.aN_ = null;
 }
 
 ComponentDef.prototype = {
-  aN_: function (key) {
+  aO_: function (key) {
     return (
-    this.aM_ || (this.aM_ = new KeySequence())).aN_(
+    this.aN_ || (this.aN_ = new KeySequence())).aO_(
       key);
   },
 
@@ -73,8 +73,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  aO_: function () {
-    return this.id + "-c" + this.aL_++;
+  aP_: function () {
+    return this.id + "-c" + this.aM_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -82,14 +82,14 @@ ComponentDef.prototype = {
     return attachBubblingEvent(this, handlerMethodName, isOnce, extraArgs);
   },
 
-  get _q_() {
-    return this.s_._q_;
+  get _r_() {
+    return this.t_._r_;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype.aN_;
+ComponentDef.prototype.nk = ComponentDef.prototype.aO_;
 
-ComponentDef._D_ = function (o, types, global, registry) {
+ComponentDef._E_ = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
@@ -103,16 +103,16 @@ ComponentDef._D_ = function (o, types, global, registry) {
 
   var component =
   typeName /* legacy */ &&
-  registry._G_(typeName, id, isLegacy);
+  registry._H_(typeName, id, isLegacy);
 
   // Prevent newly created component from being queued for update since we area
   // just building it from the server info
-  component._b_ = true;
-  component.ak_ = global;
+  component._c_ = true;
+  component.al_ = global;
 
   if (isLegacy) {
     component.widgetConfig = componentProps;
-    component.Z_ = renderBody;
+    component.___ = renderBody;
   } else if (renderBody) {
     (input || (input = {})).renderBody = renderBody;
   }
@@ -146,23 +146,23 @@ ComponentDef._D_ = function (o, types, global, registry) {
     }
   }
 
-  component.O_ = input;
+  component.P_ = input;
 
   if (extra.b) {
-    component.Y_ = extra.b;
+    component.Z_ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component.aD_(customEvents, scope);
+    component.aE_(customEvents, scope);
   }
 
   return {
     id: id,
-    s_: component,
-    _c_: extra.d,
-    u_: extra.f || 0
+    t_: component,
+    _d_: extra.d,
+    v_: extra.f || 0
   };
 };
 

package/dist/runtime/components/ComponentsContext.js

@@ -6,14 +6,14 @@ function ComponentsContext(out, parentComponentsContext) {
   var componentDef;
 
   if (parentComponentsContext) {
-    globalComponentsContext = parentComponentsContext.p_;
-    componentDef = parentComponentsContext.o_;
+    globalComponentsContext = parentComponentsContext.q_;
+    componentDef = parentComponentsContext.p_;
 
     var nestedContextsForParent;
     if (
-    !(nestedContextsForParent = parentComponentsContext._d_))
+    !(nestedContextsForParent = parentComponentsContext._e_))
     {
-      nestedContextsForParent = parentComponentsContext._d_ = [];
+      nestedContextsForParent = parentComponentsContext._e_ = [];
     }
 
     nestedContextsForParent.push(this);
@@ -25,26 +25,26 @@ function ComponentsContext(out, parentComponentsContext) {
     }
   }
 
-  this.p_ = globalComponentsContext;
+  this.q_ = globalComponentsContext;
   this.b_ = [];
-  this.r_ = out;
-  this.o_ = componentDef;
-  this._d_ = undefined;
-  this.v_ =
-  parentComponentsContext && parentComponentsContext.v_;
+  this.s_ = out;
+  this.p_ = componentDef;
+  this._e_ = undefined;
+  this.w_ =
+  parentComponentsContext && parentComponentsContext.w_;
 }
 
 ComponentsContext.prototype = {
-  af_: function (host) {
+  ag_: function (host) {
     var componentDefs = this.b_;
 
-    ComponentsContext._I_(componentDefs, host);
+    ComponentsContext._J_(componentDefs, host);
 
-    this.r_.emit("aP_");
+    this.s_.emit("aQ_");
 
     // Reset things stored in global since global is retained for
     // future renders
-    this.r_.global.b_ = undefined;
+    this.s_.global.b_ = undefined;
 
     return componentDefs;
   }
@@ -56,4 +56,4 @@ function getComponentsContext(out) {
 
 module.exports = exports = ComponentsContext;
 
-exports.S_ = getComponentsContext;
+exports.T_ = getComponentsContext;

package/dist/runtime/components/GlobalComponentsContext.js

@@ -1,10 +1,10 @@
 "use strict";var nextComponentIdProvider =
-require("@internal/components-util")._S_;
+require("@internal/components-util")._T_;
 
 function GlobalComponentsContext(out) {
-  this.q_ = {};
-  this.az_ = undefined;
-  this.aO_ = nextComponentIdProvider(out);
+  this.r_ = {};
+  this.aA_ = undefined;
+  this.aP_ = nextComponentIdProvider(out);
 }
 
 module.exports = GlobalComponentsContext;

package/dist/runtime/components/KeySequence.js

@@ -1,9 +1,9 @@
 "use strict";function KeySequence() {
-  this.aQ_ = Object.create(null);
+  this.aR_ = Object.create(null);
 }
 
-KeySequence.prototype.aN_ = function (key) {
-  var lookup = this.aQ_;
+KeySequence.prototype.aO_ = function (key) {
+  var lookup = this.aR_;
 
   if (lookup[key]) {
     return key + "_" + lookup[key]++;

package/dist/runtime/components/ServerComponent.js

@@ -5,38 +5,38 @@
 class ServerComponent {
   constructor(id, input, out, typeName, customEvents, scope) {
     this.id = id;
-    this.W_ = customEvents;
-    this.X_ = scope;
+    this.X_ = customEvents;
+    this.Y_ = scope;
     this.typeName = typeName;
-    this.Y_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
-    this.___ = 0;
+    this.Z_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
+    this._a_ = 0;
 
     this.onCreate(input, out);
-    this._a_ = this.onInput(input, out) || input;
-    if (this.O_ === undefined) {
-      this.O_ = this._a_;
+    this._b_ = this.onInput(input, out) || input;
+    if (this.P_ === undefined) {
+      this.P_ = this._b_;
     }
     this.onRender(out);
   }
 
   set input(newInput) {
-    this.O_ = newInput;
+    this.P_ = newInput;
   }
 
   get input() {
-    return this.O_;
+    return this.P_;
   }
 
   set state(newState) {
-    this.z_ = newState;
+    this.A_ = newState;
   }
 
   get state() {
-    return this.z_;
+    return this.A_;
   }
 
-  get aC_() {
-    return this.z_;
+  get aD_() {
+    return this.A_;
   }
 
   elId(nestedId) {

package/dist/runtime/components/State.js

@@ -5,42 +5,42 @@ function ensure(state, propertyName) {
   if (!(propertyName in proto)) {
     Object.defineProperty(proto, propertyName, {
       get: function () {
-        return this.A_[propertyName];
+        return this.B_[propertyName];
       },
       set: function (value) {
-        this.ar_(propertyName, value, false /* ensure:false */);
+        this.as_(propertyName, value, false /* ensure:false */);
       }
     });
   }
 }
 
 function State(component) {
-  this.s_ = component;
-  this.A_ = {};
+  this.t_ = component;
+  this.B_ = {};
 
-  this.al_ = false;
+  this.am_ = false;
+  this.ax_ = null;
   this.aw_ = null;
-  this.av_ = null;
-  this.aR_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
+  this.aS_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
 
   Object.seal(this);
 }
 
 State.prototype = {
-  _t_: function () {
-    this.al_ = false;
+  _u_: function () {
+    this.am_ = false;
+    this.ax_ = null;
     this.aw_ = null;
-    this.av_ = null;
-    this.aR_ = null;
+    this.aS_ = null;
   },
 
-  ap_: function (newState) {
+  aq_: function (newState) {
     var key;
-    var rawState = this.A_;
+    var rawState = this.B_;
 
     for (key in rawState) {
       if (!(key in newState)) {
-        this.ar_(
+        this.as_(
           key,
           undefined,
           false /* ensure:false */,
@@ -50,7 +50,7 @@ State.prototype = {
     }
 
     for (key in newState) {
-      this.ar_(
+      this.as_(
         key,
         newState[key],
         true /* ensure:true */,
@@ -58,32 +58,32 @@ State.prototype = {
       );
     }
   },
-  ar_: function (name, value, shouldEnsure, forceDirty) {
-    var rawState = this.A_;
+  as_: function (name, value, shouldEnsure, forceDirty) {
+    var rawState = this.B_;
 
     if (shouldEnsure) {
       ensure(this, name);
     }
 
     if (forceDirty) {
-      var forcedDirtyState = this.aR_ || (this.aR_ = {});
+      var forcedDirtyState = this.aS_ || (this.aS_ = {});
       forcedDirtyState[name] = true;
     } else if (rawState[name] === value) {
       return;
     }
 
-    if (!this.al_) {
+    if (!this.am_) {
       // 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.al_ = true; // Mark the component state as dirty (i.e. modified)
-      this.aw_ = rawState;
-      this.A_ = rawState = extend({}, rawState);
-      this.av_ = {};
-      this.s_.aq_();
+      this.am_ = true; // Mark the component state as dirty (i.e. modified)
+      this.ax_ = rawState;
+      this.B_ = rawState = extend({}, rawState);
+      this.aw_ = {};
+      this.t_.ar_();
     }
 
-    this.av_[name] = value;
+    this.aw_[name] = value;
 
     if (value === undefined) {
       // Don't store state properties with an undefined or null value
@@ -94,7 +94,7 @@ State.prototype = {
     }
   },
   toJSON: function () {
-    return this.A_;
+    return this.B_;
   }
 };
 

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

@@ -1,6 +1,6 @@
 "use strict";var eventDelegation = require("./event-delegation");
-var delegateEvent = eventDelegation.aS_;
-var getEventFromEl = eventDelegation.aT_;
+var delegateEvent = eventDelegation.aT_;
+var getEventFromEl = eventDelegation.aU_;
 
 // 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.r_;
+      var out = componentsContext.s_;
       var data = out.data;
 
-      var attachTargets = data.aU_;
+      var attachTargets = data.aV_;
       if (!attachTargets) {
-        attachTargets = data.aU_ = [];
-        out.on("aP_", function () {
+        attachTargets = data.aV_ = [];
+        out.on("aQ_", 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.aV_ = handleNodeAttach;
-eventDelegation.an_ = handleNodeDetach;
+eventDelegation.aW_ = handleNodeAttach;
+eventDelegation.ao_ = handleNodeDetach;

package/dist/runtime/components/defineComponent.js

@@ -5,7 +5,7 @@ var BaseComponent = require("./Component");
 var BaseState = require("./State");
 
 module.exports = function defineComponent(def, renderer) {
-  if (def.x_) {
+  if (def.y_) {
     return def;
   }
 
@@ -34,7 +34,7 @@ module.exports = function defineComponent(def, renderer) {
     BaseComponent.call(this, id);
   }
 
-  if (!proto.x_) {
+  if (!proto.y_) {
     // Inherit from Component if they didn't already
     inherit(ComponentClass, BaseComponent);
   }
@@ -47,14 +47,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.x_ = true;
+  Component.y_ = true;
 
   function State(component) {
     BaseState.call(this, component);
   }
   inherit(State, BaseState);
-  proto.P_ = State;
-  proto.Q_ = renderer;
+  proto.Q_ = State;
+  proto.R_ = renderer;
 
   return Component;
 };

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

@@ -1,8 +1,8 @@
 "use strict";module.exports = {
+  _M_: new WeakMap(),
   _L_: new WeakMap(),
-  _K_: new WeakMap(),
-  _p_: new WeakMap(),
-  aW_: new WeakMap(),
-  _n_: new WeakMap(),
-  _o_: {}
+  _q_: new WeakMap(),
+  aX_: new WeakMap(),
+  _o_: new WeakMap(),
+  _p_: {}
 };

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

@@ -1,7 +1,7 @@
 "use strict";var componentsUtil = require("@internal/components-util");
-var runtimeId = componentsUtil._P_;
-var componentLookup = componentsUtil._l_;
-var getMarkoPropsFromEl = componentsUtil._r_;
+var runtimeId = componentsUtil._Q_;
+var componentLookup = componentsUtil._m_;
+var getMarkoPropsFromEl = componentsUtil._s_;
 
 var TEXT_NODE = 3;
 
@@ -54,7 +54,7 @@ function delegateEvent(node, eventName, target, event) {
 
   if (extraArgs != null) {
     if (typeof extraArgs === "number") {
-      extraArgs = targetComponent.Y_[extraArgs];
+      extraArgs = targetComponent.Z_[extraArgs];
     }
   }
 
@@ -132,12 +132,12 @@ function addDelegatedEventHandlerToHost(eventType, host) {
 
 function noop() {}
 
-exports.aV_ = noop;
-exports.an_ = noop;
-exports.aS_ = delegateEvent;
-exports.aT_ = getEventFromEl;
-exports._s_ = addDelegatedEventHandler;
-exports._A_ = function (host) {
+exports.aW_ = noop;
+exports.ao_ = noop;
+exports.aT_ = delegateEvent;
+exports.aU_ = getEventFromEl;
+exports._t_ = addDelegatedEventHandler;
+exports._B_ = 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.x_) {
+  if (def.y_) {
     return def;
   }
 

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

@@ -1,17 +1,17 @@
 "use strict"; // eslint-disable-next-line no-constant-binary-expression
 
-var componentLookup = require("@internal/components-util")._l_;
+var componentLookup = require("@internal/components-util")._m_;
 var req = require("@internal/require");
 var makeRenderable = require("../../renderable");
 var getComponentsContext =
-require("../ComponentsContext").S_;
+require("../ComponentsContext").T_;
 var modernRenderer = require("../renderer");
-var resolveComponentKey = modernRenderer.aX_;
+var resolveComponentKey = modernRenderer.aY_;
 
 module.exports = function defineRenderer(renderingLogic) {
   var renderer = renderingLogic.renderer;
 
-  if (renderer && renderer.aY_) {
+  if (renderer && renderer.aZ_) {
     return renderer;
   }
 
@@ -45,13 +45,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.p_;
-      var component = globalComponentsContext.az_;
-      var isReceivingNewInput = !component || component._h_;
+      var globalComponentsContext = componentsContext.q_;
+      var component = globalComponentsContext.aA_;
+      var isReceivingNewInput = !component || component._i_;
       var parentComponentDef;
 
       if (component) {
-        component._h_ = false;
+        component._i_ = false;
       }
 
       // Render the template associated with the component using the final template
@@ -63,17 +63,17 @@ module.exports = function defineRenderer(renderingLogic) {
       var id;
 
       if (!component && componentLookup) {
-        var key = out.aa_;
+        var key = out.ab_;
 
         if (
-        (parentComponentDef = componentsContext.o_) &&
+        (parentComponentDef = componentsContext.p_) &&
         key != null)
         {
           id = resolveComponentKey(key.toString(), parentComponentDef);
         } else if (parentComponentDef) {
-          id = parentComponentDef.aO_();
+          id = parentComponentDef.aP_();
         } else {
-          id = globalComponentsContext.aO_();
+          id = globalComponentsContext.aP_();
         }
 
         component = componentLookup[id];
@@ -106,9 +106,9 @@ module.exports = function defineRenderer(renderingLogic) {
           widgetBody = newProps.renderBody;
         }
       } else if (component) {
-        newProps = newProps || component.N_;
-        widgetBody = component.Z_;
-        widgetState = component.aC_;
+        newProps = newProps || component.O_;
+        widgetBody = component.___;
+        widgetState = component.aD_;
         widgetConfig = component.widgetConfig;
       }
 
@@ -148,7 +148,7 @@ module.exports = function defineRenderer(renderingLogic) {
     };
   }
 
-  renderer.aY_ = true;
+  renderer.aZ_ = 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.aZ_) {
-    return template.aZ_;
+  if (production && template.b__) {
+    return template.b__;
   }
 
   attachDepsAndComponentsToTemplate(template, context);
 
-  var deps = template.aZ_ = Object.keys(template.b__).map(
-    (key) => template.b__[key]
+  var deps = template.b__ = Object.keys(template.ba_).map(
+    (key) => template.ba_[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.b__) return;
+  if (production && target.ba_) return;
 
-  var deps = target.b__ = {};
+  var deps = target.ba_ = {};
   var components = target.b_ = {};
 
   if (!template.meta) {
@@ -83,7 +83,7 @@ function attachDepsAndComponentsToTemplate(target, context) {
 
       attachDepsAndComponentsToTemplate(tag, context);
 
-      if (tag.b__) Object.assign(deps, tag.b__);
+      if (tag.ba_) Object.assign(deps, tag.ba_);
       if (tag.b_) Object.assign(components, tag.b_);
     });
   }