marko 5.31.0 → 5.31.2

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

@@ -4,16 +4,16 @@ var queueMicrotask = require("../../../runtime/queueMicrotask");
 var defineComponent = require("../../../runtime/components/defineComponent");
 var eventDelegation = require("../../../runtime/components/event-delegation");
 var createFragmentNode =
-require("../../../runtime/vdom/morphdom/fragment")._n_;
+require("../../../runtime/vdom/morphdom/fragment")._h_;
 var ComponentDef = require("../../../runtime/components/ComponentDef");
 var domData = require("../../../runtime/components/dom-data");
 var componentsUtil = require("@internal/components-util");
-var loader = require("@internal/loader");
-var componentLookup = componentsUtil._o_;
+var req = require("@internal/require");
+var componentLookup = componentsUtil._i_;
 var addComponentRootToKeyedElements =
-componentsUtil._p_;
-var keyedElementsByComponentId = domData._q_;
-var componentsByDOMNode = domData._r_;
+componentsUtil._j_;
+var keyedElementsByComponentId = domData._k_;
+var componentsByDOMNode = domData._l_;
 var serverComponentRootNodes = {};
 var serverRenderedMeta = {};
 var win = window;
@@ -69,8 +69,8 @@ function addPendingDef(def, type, meta, host, runtimeId) {
   def,
   meta,
   host,
-  runtimeId]);
-
+  runtimeId]
+  );
 }
 
 function load(typeName, isLegacy) {
@@ -81,9 +81,9 @@ function load(typeName, isLegacy) {
     if (target) {
       target = target();
     } else if (isLegacy) {
-      target = exports._k_.load(typeName);
+      target = exports._e_.load(typeName);
     } else {
-      target = loader(typeName);
+      target = req(typeName);
       // eslint-disable-next-line no-constant-condition
 
 
@@ -113,12 +113,12 @@ function getComponentClass(typeName, isLegacy) {
 
   ComponentClass = ComponentClass.Component || ComponentClass;
 
-  if (!ComponentClass.E_) {
+  if (!ComponentClass.w_) {
     ComponentClass = defineComponent(ComponentClass, ComponentClass.renderer);
   }
 
   // Make the component "type" accessible on each component instance
-  ComponentClass.prototype._s_ = typeName;
+  ComponentClass.prototype._m_ = typeName;
 
   // eslint-disable-next-line no-constant-condition
 
@@ -184,9 +184,9 @@ function indexServerComponentBoundaries(node, runtimeId, stack) {
             rootNode = createFragmentNode(startNode.nextSibling, endNode);
           } else {
             rootNode = createFragmentNode(
-            endNode.parentNode.firstChild,
-            endNode);
-
+              endNode.parentNode.firstChild,
+              endNode
+            );
           }
 
           componentId = startNode.nodeValue.substring(runtimeLength + 1);
@@ -198,18 +198,18 @@ function indexServerComponentBoundaries(node, runtimeId, stack) {
             ownerId = parts[1];
             componentId = parts[0];
             if (ownerComponent = componentLookup[ownerId]) {
-              keyedElements = ownerComponent.l_;
+              keyedElements = ownerComponent.J_;
             } else {
               keyedElements =
               keyedElementsByComponentId[ownerId] || (
               keyedElementsByComponentId[ownerId] = {});
             }
             addComponentRootToKeyedElements(
-            keyedElements,
-            key,
-            rootNode,
-            componentId);
-
+              keyedElements,
+              key,
+              rootNode,
+              componentId
+            );
           }
 
           serverComponentRootNodes[componentId] = rootNode;
@@ -221,13 +221,13 @@ function indexServerComponentBoundaries(node, runtimeId, stack) {
     } else if (node.nodeType === 1) {
       // HTML element node
       var markoKey = node.getAttribute("data-marko-key");
-      var markoProps = componentsUtil._t_(node);
+      var markoProps = componentsUtil._n_(node);
       if (markoKey) {
         var separatorIndex = markoKey.indexOf(" ");
         ownerId = markoKey.substring(separatorIndex + 1);
         markoKey = markoKey.substring(0, separatorIndex);
         if (ownerComponent = componentLookup[ownerId]) {
-          keyedElements = ownerComponent.l_;
+          keyedElements = ownerComponent.J_;
         } else {
           keyedElements =
           keyedElementsByComponentId[ownerId] || (
@@ -238,7 +238,7 @@ function indexServerComponentBoundaries(node, runtimeId, stack) {
       if (markoProps) {
         Object.keys(markoProps).forEach(function (key) {
           if (key.slice(0, 2) === "on") {
-            eventDelegation._u_(key.slice(2));
+            eventDelegation._o_(key.slice(2));
           }
         });
       }
@@ -284,38 +284,38 @@ extraArgs,
 handles)
 {
   var removeListener = addEventListenerHelper(
-  el,
-  eventType,
-  isOnce,
-  function (event) {
-    var args = [event, el];
-    if (extraArgs) {
-      args = extraArgs.concat(args);
-    }
-
-    invokeComponentEventHandler(component, targetMethodName, args);
-  });
+    el,
+    eventType,
+    isOnce,
+    function (event) {
+      var args = [event, el];
+      if (extraArgs) {
+        args = extraArgs.concat(args);
+      }
 
+      invokeComponentEventHandler(component, targetMethodName, args);
+    }
+  );
   handles.push(removeListener);
 }
 
 function initComponent(componentDef, host) {
-  var component = componentDef.i_;
+  var component = componentDef.r_;
 
-  if (!component || !component.E_) {
+  if (!component || !component.w_) {
     return; // legacy
   }
 
-  component._v_();
-  component.I_ = host;
+  component._p_();
+  component.A_ = host;
 
-  var isExisting = componentDef._w_;
+  var isExisting = componentDef._q_;
 
   if (isExisting) {
-    component._x_();
+    component._r_();
   }
 
-  var domEvents = componentDef._g_;
+  var domEvents = componentDef._a_;
   if (domEvents) {
     var eventListenerHandles = [];
 
@@ -324,31 +324,31 @@ function initComponent(componentDef, host) {
 
       var eventType = domEventArgs[0];
       var targetMethodName = domEventArgs[1];
-      var eventEl = component.l_[domEventArgs[2]];
+      var eventEl = component.J_[domEventArgs[2]];
       var isOnce = domEventArgs[3];
       var extraArgs = domEventArgs[4];
 
       addDOMEventListeners(
-      component,
-      eventEl,
-      eventType,
-      targetMethodName,
-      isOnce,
-      extraArgs,
-      eventListenerHandles);
-
+        component,
+        eventEl,
+        eventType,
+        targetMethodName,
+        isOnce,
+        extraArgs,
+        eventListenerHandles
+      );
     });
 
     if (eventListenerHandles.length) {
-      component._y_ = eventListenerHandles;
+      component._s_ = eventListenerHandles;
     }
   }
 
-  if (component._z_) {
-    component._A_();
+  if (component._t_) {
+    component._u_();
   } else {
-    component._z_ = true;
-    component._B_();
+    component._t_ = true;
+    component._v_();
   }
 }
 
@@ -364,7 +364,7 @@ function initClientRendered(componentDefs, host) {
   if (!host) host = document;
   // Ensure that event handlers to handle delegating events are
   // always attached before initializing any components
-  eventDelegation._C_(host);
+  eventDelegation._w_(host);
   var len = componentDefs.length;
   var componentDef;
   var i;
@@ -477,15 +477,15 @@ function initServerRendered(renderedComponents, host) {
   // Ensure that event handlers to handle delegating events are
   // always attached before initializing any components
   indexServerComponentBoundaries(host, runtimeId);
-  eventDelegation._C_(host);
+  eventDelegation._w_(host);
 
   if (renderedComponents.g) {
-    meta._D_ = renderedComponents.g;
+    meta._x_ = renderedComponents.g;
   }
 
   if (renderedComponents.t) {
-    meta._E_ = meta._E_ ?
-    meta._E_.concat(renderedComponents.t) :
+    meta._y_ = meta._y_ ?
+    meta._y_.concat(renderedComponents.t) :
     renderedComponents.t;
   }
 
@@ -493,22 +493,13 @@ function initServerRendered(renderedComponents, host) {
   // and return an array of functions to mount these components
   (renderedComponents.w || []).
   map(function (componentDef) {
-    var typeName = meta._E_[componentDef[1]];
-
-    return (
-      registered[typeName] ||
-      document.readyState === "complete" ||
+    var typeName = meta._y_[componentDef[1]];
 
-      // loader.runtime is only going to exist for lasso apps
-      // this code is used to detect if a module was registered
-      // via a browser.json but not executed.
-      loader.runtime &&
-      loader.runtime.resolve &&
-      loader.runtime.resolve(typeName) ?
-
-
-      tryHydrateComponent(componentDef, meta, host, runtimeId) :
-      addPendingDef(componentDef, typeName, meta, host, runtimeId));
+    return registered[typeName] ||
+    document.readyState === "complete" ||
+    req.e(typeName) ?
+    tryHydrateComponent(componentDef, meta, host, runtimeId) :
+    addPendingDef(componentDef, typeName, meta, host, runtimeId);
   }).
   reverse().
   forEach(tryInvoke);
@@ -517,12 +508,12 @@ function initServerRendered(renderedComponents, host) {
 }
 
 function tryHydrateComponent(rawDef, meta, host, runtimeId) {
-  var componentDef = ComponentDef._F_(
-  rawDef,
-  meta._E_,
-  meta._D_,
-  exports);
-
+  var componentDef = ComponentDef._z_(
+    rawDef,
+    meta._y_,
+    meta._x_,
+    exports
+  );
   var mount = hydrateComponentAndGetMount(componentDef, host);
 
   if (!mount) {
@@ -551,19 +542,19 @@ function tryHydrateComponent(rawDef, meta, host, runtimeId) {
 
 function hydrateComponentAndGetMount(componentDef, host) {
   var componentId = componentDef.id;
-  var component = componentDef.i_;
+  var component = componentDef.r_;
   var rootNode = serverComponentRootNodes[componentId];
   var renderResult;
 
   if (rootNode) {
     delete serverComponentRootNodes[componentId];
 
-    component._G_ = rootNode;
+    component._A_ = rootNode;
     componentsByDOMNode.set(rootNode, component);
 
-    if (componentDef.C_ & FLAG_WILL_RERENDER_IN_BROWSER) {
-      component.I_ = host;
-      renderResult = component._H_(component.U_, true);
+    if (componentDef.t_ & FLAG_WILL_RERENDER_IN_BROWSER) {
+      component.A_ = host;
+      renderResult = component._B_(component.N_, true);
       trackComponent(componentDef);
       return function mount() {
         renderResult.afterInsert(host);
@@ -579,7 +570,7 @@ function hydrateComponentAndGetMount(componentDef, host) {
 }
 
 function trackComponent(componentDef) {
-  var component = componentDef.i_;
+  var component = componentDef.r_;
   if (component) {
     componentLookup[component.id] = component;
   }
@@ -590,8 +581,9 @@ function tryInvoke(fn) {
 }
 
 exports.r = register;
-exports._I_ = createComponent;
-exports._J_ = getComponentClass;
-exports.Z_ = win.$initComponents = initServerRendered;
+exports._C_ = createComponent;
+exports._D_ = getComponentClass;
+exports.T_ = win.$initComponents = initServerRendered;
 
-require("../../../runtime/components/ComponentsContext")._K_ = initClientRendered;
+require("../../../runtime/components/ComponentsContext")._E_ =
+initClientRendered;

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

@@ -40,5 +40,5 @@ scope)
   return new ServerComponent(id, input, out, typeName, customEvents, scope);
 }
 
-exports._L_ = true;
-exports._I_ = createComponent;
+exports._F_ = true;
+exports._C_ = createComponent;

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

@@ -1,8 +1,8 @@
 "use strict";var domData = require("../../../runtime/components/dom-data");
-var componentsByDOMNode = domData._r_;
-var keysByDOMNode = domData._M_;
-var vElementsByDOMNode = domData._N_;
-var vPropsByDOMNode = domData._O_;
+var componentsByDOMNode = domData._l_;
+var keysByDOMNode = domData._G_;
+var vElementsByDOMNode = domData._H_;
+var vPropsByDOMNode = domData._I_;
 var markoUID = window.$MUID || (window.$MUID = { i: 0 });
 var runtimeId = markoUID.i++;
 
@@ -27,7 +27,7 @@ function getComponentForEl(el, host) {
         component = componentsByDOMNode.get(node);
       }
     } else if (vElement = vElementsByDOMNode.get(node)) {
-      component = vElement._P_;
+      component = vElement._J_;
     }
 
     if (component) {
@@ -41,7 +41,7 @@ function getComponentForEl(el, host) {
 function destroyComponentForNode(node) {
   var componentToDestroy = componentsByDOMNode.get(node.fragment || node);
   if (componentToDestroy) {
-    componentToDestroy._Q_();
+    componentToDestroy._K_();
     delete componentLookup[componentToDestroy.id];
   }
 }
@@ -51,13 +51,13 @@ function destroyNodeRecursive(node, component) {
     var key;
 
     if (component && (key = keysByDOMNode.get(node))) {
-      if (node === component.l_[key]) {
+      if (node === component.J_[key]) {
         if (componentsByDOMNode.get(node) && /\[\]$/.test(key)) {
-          delete component.l_[key][
+          delete component.J_[key][
           componentsByDOMNode.get(node).id];
 
         } else {
-          delete component.l_[key];
+          delete component.J_[key];
         }
       }
     }
@@ -103,15 +103,15 @@ function getMarkoPropsFromEl(el) {
   var virtualProps;
 
   if (vElement) {
-    virtualProps = vElement._R_;
+    virtualProps = vElement._L_;
   } else {
     virtualProps = vPropsByDOMNode.get(el);
     if (!virtualProps) {
       virtualProps = el.getAttribute("data-marko");
       vPropsByDOMNode.set(
-      el,
-      virtualProps = virtualProps ? JSON.parse(virtualProps) : EMPTY_OBJECT);
-
+        el,
+        virtualProps = virtualProps ? JSON.parse(virtualProps) : EMPTY_OBJECT
+      );
     }
   }
 
@@ -167,13 +167,13 @@ componentId)
 
 
 
-exports._S_ = runtimeId;
-exports._o_ = componentLookup;
-exports.Y_ = getComponentForEl;
-exports._T_ = destroyComponentForNode;
-exports._U_ = destroyNodeRecursive;
-exports._V_ = nextComponentIdProvider;
-exports._W_ = attachBubblingEvent;
-exports._t_ = getMarkoPropsFromEl;
-exports._p_ = addComponentRootToKeyedElements;
-exports._X_ = normalizeComponentKey;
+exports._M_ = runtimeId;
+exports._i_ = componentLookup;
+exports.S_ = getComponentForEl;
+exports._N_ = destroyComponentForNode;
+exports._O_ = destroyNodeRecursive;
+exports._P_ = nextComponentIdProvider;
+exports._Q_ = attachBubblingEvent;
+exports._n_ = getMarkoPropsFromEl;
+exports._j_ = addComponentRootToKeyedElements;
+exports._R_ = normalizeComponentKey;

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

@@ -28,8 +28,8 @@ extraArgs)
 {
   if (handlerMethodName) {
     if (extraArgs) {
-      var component = componentDef.i_;
-      var eventIndex = component._d_++;
+      var component = componentDef.r_;
+      var eventIndex = component.Y_++;
 
       // If we are not going to be doing a rerender in the browser
       // then we need to actually store the extra args with the UI component
@@ -39,11 +39,11 @@ extraArgs)
       // where the extra args will be found when the UI component is
       // rerendered in the browser
 
-      if (!(componentDef.C_ & FLAG_WILL_RERENDER_IN_BROWSER)) {
+      if (!(componentDef.t_ & FLAG_WILL_RERENDER_IN_BROWSER)) {
         if (eventIndex === 0) {
-          component._b_ = [extraArgs];
+          component.W_ = [extraArgs];
         } else {
-          component._b_.push(extraArgs);
+          component.W_.push(extraArgs);
         }
       }
 
@@ -62,10 +62,10 @@ extraArgs)
   }
 }
 
-exports._V_ = nextComponentIdProvider;
-exports._L_ = true;
-exports._W_ = attachBubblingEvent;
-exports._T_ = function noop() {};
-exports._U_ = function noop() {};
+exports._P_ = nextComponentIdProvider;
+exports._F_ = true;
+exports._Q_ = attachBubblingEvent;
+exports._N_ = function noop() {};
+exports._O_ = function noop() {};
 
 // eslint-disable-next-line no-constant-condition

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

@@ -14,11 +14,11 @@ module.exports = function (data) {
     }
   };
   var out = this.createOut(
-  data && data.$global,
-  facade,
-  undefined,
-  this._Y_);
-
+    data && data.$global,
+    facade,
+    undefined,
+    this._S_
+  );
   out.once("error", (err) => {
     facade.write = facade.end = noop;
     writer.abort(err);

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._Z_ = template;
-    this.a__ = data;
-    this.aa_ = false;
+    this._T_ = template;
+    this._U_ = data;
+    this._V_ = false;
   }
 
   write(data) {
@@ -33,20 +33,20 @@ class Readable extends stream.Readable {
   }
 
   _read() {
-    if (this.aa_) {
+    if (this._V_) {
       return;
     }
 
-    this.aa_ = true;
-    var template = this._Z_;
-    var data = this.a__;
+    this._V_ = true;
+    var template = this._T_;
+    var data = this._U_;
     var globalData = data && data.$global;
-    var out = this._Z_.createOut(
-    globalData,
-    this,
-    undefined,
-    template._Y_);
-
+    var out = this._T_.createOut(
+      globalData,
+      this,
+      undefined,
+      template._S_
+    );
     template.render(data, out);
     out.end();
   }

package/dist/node_modules/@internal/loader/fallback-node.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var nodePath = require("path");
+var fs = require("fs");
+var Module = require("module").Module;
+var markoCompiler = require("../../../compiler");
+var cwd = process.cwd();
+var fsOptions = { encoding: "utf8" };
+var requiredCompilerOptions = { modules: "cjs" };
+
+module.exports = function load(templatePath, templateSrc, options) {
+  if (arguments.length === 1) {
+    return doLoad(templatePath);
+  } else if (arguments.length === 2) {
+    // see if second argument is templateSrc (a String)
+    // or options (an Object)
+    var lastArg = arguments[arguments.length - 1];
+    if (typeof lastArg === "string") {
+      return doLoad(templatePath, templateSrc);
+    } else {
+      var finalOptions = templateSrc;
+      return doLoad(templatePath, null, finalOptions);
+    }
+  } else if (arguments.length === 3) {
+    // assume function called according to function signature
+    return doLoad(templatePath, templateSrc, options);
+  } else {
+    throw new Error("Illegal arguments");
+  }
+};
+
+function loadSource(templatePath, compiledSrc) {
+  // Short-circuit loading if the template has already been cached in the Node.js require cache
+  var cached = require.cache[templatePath];
+  if (cached) {
+    return cached.exports;
+  }
+
+  var templateModule = new Module(templatePath, module);
+  templateModule.paths = Module._nodeModulePaths(
+    nodePath.dirname(templatePath)
+  );
+  templateModule.filename = templatePath;
+
+  Module._cache[templatePath] = templateModule;
+
+  templateModule._compile(compiledSrc, templatePath);
+
+  return templateModule.exports;
+}
+
+function getCachedTemplate(templatePath) {
+  var precompiledTemplatePath = templatePath + ".js";
+  var templateModule =
+  require.cache[templatePath] || require.cache[precompiledTemplatePath];
+
+  if (templateModule) {
+    return templateModule.exports;
+  } else if (fs.existsSync(precompiledTemplatePath)) {
+    return require(precompiledTemplatePath);
+  }
+}
+
+function doLoad(templatePath, templateSrc, options) {
+  options = Object.assign(
+    {},
+    markoCompiler.defaultOptions,
+    options,
+    requiredCompilerOptions
+  );
+  templatePath = nodePath.resolve(cwd, templatePath);
+  var template = getCachedTemplate(templatePath);
+
+  if (!template) {
+    if (templateSrc == null) {
+      templateSrc = fs.readFileSync(templatePath, fsOptions);
+    }
+
+    var compiledSrc = markoCompiler.compile(templateSrc, templatePath, options);
+
+    template = loadSource(templatePath, compiledSrc);
+  }
+
+  if (template.default) {
+    template = template.default;
+  }
+
+  return template;
+}

package/dist/node_modules/@internal/loader/index-browser.js

@@ -1,4 +1,2 @@
 "use strict";
-module.exports =
-// eslint-disable-next-line no-undef
-typeof __webpack_require__ !== "undefined" ? __webpack_require__ : require;
+module.exports = require("@internal/require");