marko 5.31.1 → 5.31.3

package/dist/core-tags/components/preserve-tag.js

@@ -1,81 +1 @@
-"use strict";var ComponentsContext = require("../../runtime/components/ComponentsContext");
-var getComponentsContext = ComponentsContext.e_;
-
-module.exports = function render(input, out) {
-  var isComponent = !input.n;
-  var shouldPreserve = !("i" in input) || input.i;
-  var componentsContext = out.b_;
-
-  if (typeof document === "object") {
-    var isHydrate =
-    componentsContext && componentsContext.f_.g_;
-    var ownerComponent = out.h_.i_;
-    var referenceComponent = ownerComponent;
-    var key = out.j_;
-    var checkKey = key;
-
-    if (key[0] !== "@") {
-      var parentComponent = componentsContext.k_.i_;
-      if (ownerComponent !== parentComponent) {
-        referenceComponent = parentComponent;
-        checkKey += ":" + ownerComponent.id;
-      }
-    }
-
-    var isPreserved =
-    shouldPreserve && (
-    isHydrate || referenceComponent.l_[checkKey]);
-
-    if (isComponent) {
-      out.bf(key, ownerComponent, shouldPreserve);
-
-      if (!isPreserved && input.renderBody) {
-        input.renderBody(out);
-      }
-
-      out.ef();
-    } else {
-      if (isPreserved) {
-        if (input.b) {
-          out.m_.n_ = true;
-        } else {
-          out.beginElement("", null, key, ownerComponent);
-          out.m_.o_ = true;
-          out.endElement();
-        }
-      } else if (input.renderBody) {
-        input.renderBody(out);
-      }
-    }
-  } else {
-    if (isComponent) {
-      out.bf(
-        out.j_,
-        out.h_.i_,
-        true
-      );
-    }
-
-    if (input.renderBody) {
-      if (shouldPreserve) {
-        var parentPreserved = false;
-
-        if (componentsContext) {
-          parentPreserved = componentsContext.p_;
-        } else {
-          componentsContext = getComponentsContext(out);
-        }
-
-        componentsContext.p_ = true;
-        input.renderBody(out);
-        componentsContext.p_ = parentPreserved;
-      } else {
-        input.renderBody(out);
-      }
-    }
-
-    if (isComponent) {
-      out.ef();
-    }
-  }
-};
+"use strict";module.exports = require("@internal/preserve-tag");

package/dist/core-tags/core/await/AsyncValue.js

@@ -5,30 +5,30 @@ function AsyncValue() {
    * The data that was provided via call to resolve(data).
    * This property is assumed to be public and available for inspection.
    */
-  this.q_ = undefined;
+  this.e_ = undefined;
 
   /**
    * The data that was provided via call to reject(err)
    * This property is assumed to be public and available for inspection.
    */
-  this.r_ = undefined;
+  this.f_ = undefined;
 
   /**
    * The queue of callbacks that are waiting for data
    */
-  this.s_ = undefined;
+  this.g_ = undefined;
 
   /**
    * The state of the data holder (STATE_INITIAL, STATE_RESOLVED, or STATE_REJECTED)
    */
-  this.t_ = false;
+  this.h_ = false;
 }
 
 function notifyCallbacks(asyncValue, err, value) {
-  var callbacks = asyncValue.s_;
+  var callbacks = asyncValue.g_;
   if (callbacks) {
     // clear out the registered callbacks (we still have reference to the original value)
-    asyncValue.s_ = undefined;
+    asyncValue.g_ = undefined;
 
     // invoke all of the callbacks and use their scope
     for (var i = 0; i < callbacks.length; i++) {
@@ -46,14 +46,14 @@ AsyncValue.prototype = {
    * The given callback will be invoked when there is an error or resolved data
    * available.
    */
-  u_: function (callback) {
+  i_: function (callback) {
     // Do we already have data or error?
-    if (this.t_) {
+    if (this.h_) {
       // invoke the callback immediately
-      return callback(this.r_, this.q_);
+      return callback(this.f_, this.e_);
     }
 
-    var callbacks = this.s_ || (this.s_ = []);
+    var callbacks = this.g_ || (this.g_ = []);
     callbacks.push(callback);
   },
 
@@ -63,19 +63,19 @@ AsyncValue.prototype = {
    * its initial state so that any future requests to load data will trigger a
    * new load call.
    */
-  v_: function (err) {
-    if (this.t_) {
+  j_: function (err) {
+    if (this.h_) {
       return;
     }
 
     // remember the error
-    this.r_ = err;
+    this.f_ = err;
 
     // Go to the rejected state if we don't have a loader.
     // If we do have a loader then return to the initial state
     // (we do this so that next call to done() will trigger load
     // again in case the error was transient).
-    this.t_ = true;
+    this.h_ = true;
 
     // always notify callbacks regardless of whether or not we return to the initial state
     notifyCallbacks(this, err, null);
@@ -84,8 +84,8 @@ AsyncValue.prototype = {
   /**
    * This method will trigger any callbacks to be notified of data.
    */
-  w_: function (value) {
-    if (this.t_) {
+  k_: function (value) {
+    if (this.h_) {
       return;
     }
 
@@ -94,10 +94,10 @@ AsyncValue.prototype = {
 
       var finalPromise = value.then(
         function onFulfilled(value) {
-          queueMicrotask(asyncValue.w_.bind(asyncValue, value));
+          queueMicrotask(asyncValue.k_.bind(asyncValue, value));
         },
         function onRejected(err) {
-          queueMicrotask(asyncValue.v_.bind(asyncValue, err));
+          queueMicrotask(asyncValue.j_.bind(asyncValue, err));
         }
       );
 
@@ -106,10 +106,10 @@ AsyncValue.prototype = {
       }
     } else {
       // remember the state
-      this.q_ = value;
+      this.e_ = value;
 
       // go to the resolved state
-      this.t_ = true;
+      this.h_ = true;
 
       // notify callbacks
       notifyCallbacks(this, null, value);

package/dist/core-tags/core/await/renderer.js

@@ -24,9 +24,9 @@ function requestData(provider, timeout) {
 
     var callback = function (err, data) {
       if (err) {
-        asyncValue.v_(err);
+        asyncValue.j_(err);
       } else {
-        asyncValue.w_(data);
+        asyncValue.k_(data);
       }
     };
 
@@ -38,11 +38,11 @@ function requestData(provider, timeout) {
     provider(null, callback);
 
     if (value !== undefined) {
-      asyncValue.w_(value);
+      asyncValue.k_(value);
     }
   } else {
     // Assume the provider is a data object...
-    asyncValue.w_(provider);
+    asyncValue.k_(provider);
   }
 
   if (timeout == null) {
@@ -64,10 +64,10 @@ function requestData(provider, timeout) {
       if (!error) error = new Error(errorMsg);
       error.code = "ERR_AWAIT_TIMEDOUT";
       error.name = "TimeoutError";
-      asyncValue.v_(error);
+      asyncValue.j_(error);
     }, timeout);
 
-    asyncValue.u_(function () {
+    asyncValue.i_(function () {
       if (timeoutId != null) {
         clearTimeout(timeoutId);
       }
@@ -91,8 +91,8 @@ module.exports = function awaitTag(input, out) {
   var asyncValue = requestData(provider, timeout);
   var placeholderRenderer = input.placeholder && input.placeholder.renderBody;
 
-  if (asyncValue.t_) {
-    renderContents(asyncValue.r_, asyncValue.q_, input, out);
+  if (asyncValue.h_) {
+    renderContents(asyncValue.f_, asyncValue.e_, input, out);
     return;
   }
 
@@ -109,8 +109,8 @@ module.exports = function awaitTag(input, out) {
     awaitInfo.after = input.showAfter;
 
     clientReorderContext =
-    out.global.x_ || (
-    out.global.x_ = {
+    out.global.l_ || (
+    out.global.l_ = {
       instances: [],
       nextId: 0
     });
@@ -210,7 +210,7 @@ module.exports = function awaitTag(input, out) {
     }
   }
 
-  asyncValue.u_(renderBody);
+  asyncValue.i_(renderBody);
 };
 
 function renderContents(err, data, input, out) {

package/dist/core-tags/core/await/reorderer-renderer.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var escapeDoubleQuotes =
-require("../../../runtime/html/helpers/escape-quotes").y_;
+require("../../../runtime/html/helpers/escape-quotes").m_;
 
 module.exports = function (input, out) {
   // We cannot call beginSync() when using renderSync(). In this case we will
@@ -20,7 +20,7 @@ module.exports = function (input, out) {
 
   global.__awaitReordererInvoked = true;
 
-  if (out.global.x_) {
+  if (out.global.l_) {
     out.flush();
   }
 
@@ -31,7 +31,7 @@ module.exports = function (input, out) {
   });
 
   out.onLast(function (next) {
-    var awaitContext = global.x_;
+    var awaitContext = global.l_;
     var remaining;
 
     // Validate that we have remaining <await> instances that need handled

package/dist/node_modules/@internal/components-beginComponent/index-browser.js

@@ -7,17 +7,17 @@ key,
 ownerComponentDef)
 {
   var componentId = component.id;
-  var componentDef = componentsContext.k_ = new ComponentDef(
+  var componentDef = componentsContext.n_ = new ComponentDef(
     component,
     componentId,
     componentsContext
   );
-  componentsContext.f_.z_[
+  componentsContext.o_.p_[
   componentId] =
   true;
   componentsContext.b_.push(componentDef);
 
-  var out = componentsContext.A_;
-  out.bc(component, key, ownerComponentDef && ownerComponentDef.i_);
+  var out = componentsContext.q_;
+  out.bc(component, key, ownerComponentDef && ownerComponentDef.r_);
   return componentDef;
 };

package/dist/node_modules/@internal/components-beginComponent/index.js

@@ -21,20 +21,20 @@ existingComponentDef)
   // widget.  It should be removed when the legacy compat layer is removed.
   var componentDef =
   existingComponentDef || (
-  componentsContext.k_ = new ComponentDef(
+  componentsContext.n_ = new ComponentDef(
     component,
     componentId,
     componentsContext
   ));
 
   var ownerIsRenderBoundary =
-  ownerComponentDef && ownerComponentDef.B_;
+  ownerComponentDef && ownerComponentDef.s_;
   var ownerWillRerender =
   ownerComponentDef &&
-  ownerComponentDef.C_ & FLAG_WILL_RERENDER_IN_BROWSER;
+  ownerComponentDef.t_ & FLAG_WILL_RERENDER_IN_BROWSER;
   // On the server
-  if (!componentsContext.p_ && ownerWillRerender) {
-    componentDef.C_ |= FLAG_WILL_RERENDER_IN_BROWSER;
+  if (!componentsContext.u_ && ownerWillRerender) {
+    componentDef.t_ |= FLAG_WILL_RERENDER_IN_BROWSER;
     componentDef._wrr = true;
     return componentDef;
   }
@@ -48,20 +48,20 @@ existingComponentDef)
 
   componentsContext.b_.push(componentDef);
 
-  let out = componentsContext.A_;
+  let out = componentsContext.q_;
   let runtimeId = out.global.runtimeId;
 
-  componentDef.B_ = true;
-  componentDef.D_ = componentsContext.p_;
+  componentDef.s_ = true;
+  componentDef.v_ = componentsContext.u_;
 
   if (isSplitComponent === false && out.global.noBrowserRerender !== true) {
-    componentDef.C_ |= FLAG_WILL_RERENDER_IN_BROWSER;
+    componentDef.t_ |= FLAG_WILL_RERENDER_IN_BROWSER;
     componentDef._wrr = true;
-    componentsContext.p_ = false;
+    componentsContext.u_ = false;
   }
 
   if (out.global.oldHydrateNoCreate === true) {
-    componentDef.C_ |= FLAG_OLD_HYDRATE_NO_CREATE;
+    componentDef.t_ |= FLAG_OLD_HYDRATE_NO_CREATE;
   }
 
   if ((ownerIsRenderBoundary || ownerWillRerender) && key != null) {

package/dist/node_modules/@internal/components-define-widget-legacy/index-browser.js

@@ -21,7 +21,7 @@ function noop() {}
 module.exports = function defineWidget(def, renderer) {
   def = def.Widget || def;
 
-  if (def.E_) {
+  if (def.w_) {
     return def;
   }
 
@@ -51,7 +51,7 @@ module.exports = function defineWidget(def, renderer) {
     BaseComponent.call(this, id, doc);
   }
 
-  if (!proto.E_) {
+  if (!proto.w_) {
     // Inherit from Component if they didn't already
     ComponentClass.prototype = Object.create(BaseComponent.prototype);
     for (var propName in proto) {
@@ -64,16 +64,16 @@ module.exports = function defineWidget(def, renderer) {
   // The same prototype will be used by our constructor after
   // we he have set up the prototype chain using the inherit function
   proto = Component.prototype = ComponentClass.prototype;
-  proto.F_ = true;
+  proto.x_ = true;
 
   proto.constructor = def.constructor = Component;
 
   Object.defineProperty(proto, "state", {
     get: function () {
-      var raw = this.G_ && this.G_.H_;
+      var raw = this.y_ && this.y_.z_;
 
       if (raw && !raw.toJSON) {
-        Object.defineProperty(this.G_.H_, "toJSON", stateToJSONDef);
+        Object.defineProperty(this.y_.z_, "toJSON", stateToJSONDef);
       }
 
       return raw;
@@ -103,7 +103,7 @@ module.exports = function defineWidget(def, renderer) {
 
 
 
-      return this.I_;
+      return this.A_;
     }
   });
 
@@ -121,37 +121,37 @@ module.exports = function defineWidget(def, renderer) {
 
 
 
-      return this.J_;
+      return this.B_;
     }
   });
 
   // get legacy methods
 
-  proto.K_ = proto.onRender;
+  proto.C_ = proto.onRender;
   Object.defineProperty(proto, "onRender", {
     get: noop,
     set: function (v) {
-      proto.K_ = v;
+      proto.C_ = v;
     }
   });
 
-  proto.L_ = proto.onUpdate;
+  proto.D_ = proto.onUpdate;
   Object.defineProperty(proto, "onUpdate", {
     get: function () {
       return modernMountOrUpdate;
     },
     set: function (v) {
-      proto.L_ = v;
+      proto.D_ = v;
     }
   });
 
-  proto.M_ = proto.onDestroy;
+  proto.E_ = proto.onDestroy;
   Object.defineProperty(proto, "onDestroy", {
     get: function () {
       return modernOnDestory;
     },
     set: function (v) {
-      proto.M_ = v;
+      proto.E_ = v;
     }
   });
 
@@ -160,13 +160,13 @@ module.exports = function defineWidget(def, renderer) {
   proto.onMount = modernMountOrUpdate;
 
   if (legacyInit) {
-    proto.N_ = legacyInit;
+    proto.F_ = legacyInit;
   }
 
   // convert legacy to modern
-  proto.O_ = proto.update;
+  proto.G_ = proto.update;
   proto.update = function () {
-    if (this.P_) {
+    if (this.H_) {
       // eslint-disable-next-line no-constant-condition
 
 
@@ -178,36 +178,36 @@ module.exports = function defineWidget(def, renderer) {
 
 
       this.destroy = modernOnDestory;
-      this.P_ = false;
+      this.H_ = false;
     }
-    this.Q_ = true;
-    if (this.J_) {
+    this.I_ = true;
+    if (this.B_) {
       this.onBeforeUpdate && this.onBeforeUpdate();
     }
 
-    this.O_();
-    this.Q_ = false;
+    this.G_();
+    this.I_ = false;
   };
 
   function modernMountOrUpdate() {
     var self = this;
-    var el = this.l_["@_wbind"];
-    var prevEl = this.J_;
+    var el = this.J_["@_wbind"];
+    var prevEl = this.B_;
 
     if (prevEl !== el) {
-      this.J_ = el;
+      this.B_ = el;
 
       if (prevEl) {
         this.onBeforeDestroy && this.onBeforeDestroy();
-        this.M_ && this.M_();
-        this.R_ = undefined;
+        this.E_ && this.E_();
+        this.K_ = undefined;
         this.removeAllListeners();
       }
 
       if (el) {
-        this.N_ && this.N_(this.widgetConfig || {});
-        this.K_ && this.K_({ firstRender: true });
-        this.R_ = legacyRender;
+        this.F_ && this.F_(this.widgetConfig || {});
+        this.C_ && this.C_({ firstRender: true });
+        this.K_ = legacyRender;
 
         // eslint-disable-next-line no-constant-condition
 
@@ -224,45 +224,45 @@ module.exports = function defineWidget(def, renderer) {
       }
     } else if (el) {
       if (prevEl) {
-        this.L_ && this.L_();
+        this.D_ && this.D_();
       }
 
-      if (this.S_) {
-        this.K_ &&
-        this.K_({ firstRender: false });
+      if (this.L_) {
+        this.C_ &&
+        this.C_({ firstRender: false });
       }
     }
 
-    this.T_ = this.U_;
-    this.U_ = null;
-    this.S_ = false;
+    this.M_ = this.N_;
+    this.N_ = null;
+    this.L_ = false;
   }
 
   function legacyRender() {
-    if (!this.Q_) {
+    if (!this.I_) {
       this.onBeforeUpdate && this.onBeforeUpdate();
     }
 
-    this.S_ = true;
+    this.L_ = true;
   }
 
   function modernOnDestory() {
-    if (this.J_) {
+    if (this.B_) {
       this.onBeforeDestroy && this.onBeforeDestroy();
-      this.M_ && this.M_();
-      this.J_ = null;
+      this.E_ && this.E_();
+      this.B_ = null;
     }
   }
 
   // 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.E_ = true;
+  Component.w_ = true;
 
   function State() {
     BaseState.apply(this, arguments);
   }
   inherit(State, BaseState);
-  proto.V_ = State;
+  proto.O_ = State;
 
   jQuery.patchComponent(
     window.$,
@@ -297,7 +297,7 @@ module.exports = function defineWidget(def, renderer) {
   if (renderer) {
     // Add the rendering related methods as statics on the
     // new component constructor function
-    Component.renderer = proto.W_ = renderer;
+    Component.renderer = proto.P_ = renderer;
     Component.render = renderer.render;
     Component.renderSync = renderer.renderSync;
   }
@@ -320,7 +320,7 @@ module.exports = function defineWidget(def, renderer) {
       template = req(template);
     }
 
-    registry.r(template.X_, function () {
+    registry.r(template.Q_, function () {
       return Component;
     });
   }

package/dist/node_modules/@internal/components-define-widget-legacy/index.js

@@ -1,11 +1,11 @@
 "use strict";module.exports = function defineWidget(def, renderer) {
-  if (def.E_) {
+  if (def.w_) {
     return def;
   }
 
   if (renderer) {
     return {
-      E_: true,
+      w_: true,
       _isWidget: true,
       renderer: renderer,
       render: renderer.render,
@@ -13,6 +13,6 @@
       template: renderer.template
     };
   } else {
-    return { E_: true, _isWidget: true };
+    return { w_: true, _isWidget: true };
   }
 };

package/dist/node_modules/@internal/components-endComponent/index.js

@@ -1,11 +1,11 @@
 "use strict";
 
 var ComponentsContext = require("../../../runtime/components/ComponentsContext");
-var getComponentsContext = ComponentsContext.e_;
+var getComponentsContext = ComponentsContext.R_;
 
 module.exports = function endComponent(out, componentDef) {
-  if (componentDef.B_) {
+  if (componentDef.s_) {
     out.w("<!--" + out.global.runtimeId + "/-->");
-    getComponentsContext(out).p_ = componentDef.D_;
+    getComponentsContext(out).u_ = componentDef.v_;
   }
 };

package/dist/node_modules/@internal/components-entry/index-browser.js

@@ -1,8 +1,8 @@
 "use strict";var registry = require("@internal/components-registry");
 
 exports.getComponentForEl =
-require("@internal/components-util").Y_;
-exports.init = registry.Z_;
+require("@internal/components-util").S_;
+exports.init = registry.T_;
 exports.register = function (id, component) {
   registry.r(id, function () {
     return component;