marko 5.37.51 → 5.37.52

package/dist/runtime/vdom/morphdom/index.js

@@ -1,31 +1,31 @@
 "use strict";
 var componentsUtil = require("@internal/components-util");
-var existingComponentLookup = componentsUtil._m_;
-var destroyNodeRecursive = componentsUtil._S_;
+var existingComponentLookup = componentsUtil._n_;
+var destroyNodeRecursive = componentsUtil._T_;
 var addComponentRootToKeyedElements =
-componentsUtil._n_;
-var normalizeComponentKey = componentsUtil._V_;
+componentsUtil._o_;
+var normalizeComponentKey = componentsUtil._W_;
 var domData = require("../../components/dom-data");
 var eventDelegation = require("../../components/event-delegation");
 var KeySequence = require("../../components/KeySequence");
-var VElement = require("../vdom").by_;
+var VElement = require("../vdom").bz_;
 var fragment = require("./fragment");
 var helpers = require("./helpers");
 var isTextOnly = require("../is-text-only");
-var virtualizeElement = VElement.cj_;
-var morphAttrs = VElement.ck_;
-var keysByDOMNode = domData._o_;
-var componentByDOMNode = domData._q_;
-var vElementByDOMNode = domData._L_;
-var detachedByDOMNode = domData.aX_;
-
-var insertBefore = helpers.bg_;
-var insertAfter = helpers.bh_;
-var nextSibling = helpers.co_;
-var firstChild = helpers.aB_;
-var removeChild = helpers.bi_;
-var createFragmentNode = fragment._l_;
-var beginFragmentNode = fragment.cs_;
+var virtualizeElement = VElement.ck_;
+var morphAttrs = VElement.cl_;
+var keysByDOMNode = domData._p_;
+var componentByDOMNode = domData._r_;
+var vElementByDOMNode = domData._M_;
+var detachedByDOMNode = domData.aY_;
+
+var insertBefore = helpers.bh_;
+var insertAfter = helpers.bi_;
+var nextSibling = helpers.cp_;
+var firstChild = helpers.aC_;
+var removeChild = helpers.bj_;
+var createFragmentNode = fragment._m_;
+var beginFragmentNode = fragment.ct_;
 
 var ELEMENT_NODE = 1;
 var TEXT_NODE = 3;
@@ -43,7 +43,7 @@ function isAutoKey(key) {
 }
 
 function compareNodeNames(fromEl, toEl) {
-  return fromEl.cf_ === toEl.cf_;
+  return fromEl.cg_ === toEl.cg_;
 }
 
 function caseInsensitiveCompare(a, b) {
@@ -52,7 +52,7 @@ function caseInsensitiveCompare(a, b) {
 
 function onNodeAdded(node, componentsContext) {
   if (node.nodeType === ELEMENT_NODE) {
-    eventDelegation.aW_(node, componentsContext);
+    eventDelegation.aX_(node, componentsContext);
   }
 }
 
@@ -63,7 +63,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
   if (componentsContext) {
     globalComponentsContext = componentsContext.p_;
-    isHydrate = globalComponentsContext.a__;
+    isHydrate = globalComponentsContext.aa_;
   }
 
   function insertVirtualNodeBefore(
@@ -74,21 +74,21 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var realNode = vNode.bq_(host, parentEl.namespaceURI);
+    var realNode = vNode.br_(host, parentEl.namespaceURI);
     insertBefore(realNode, referenceEl, parentEl);
 
     if (
-    vNode.bZ_ === ELEMENT_NODE ||
-    vNode.bZ_ === FRAGMENT_NODE)
+    vNode.c__ === ELEMENT_NODE ||
+    vNode.c__ === FRAGMENT_NODE)
     {
       if (key) {
         keysByDOMNode.set(realNode, key);
-        (isAutoKey(key) ? parentComponent : ownerComponent).K_[
+        (isAutoKey(key) ? parentComponent : ownerComponent).L_[
         key] =
         realNode;
       }
 
-      if (!isTextOnly(vNode.cf_)) {
+      if (!isTextOnly(vNode.cg_)) {
         morphChildren(realNode, vNode, parentComponent);
       }
 
@@ -105,7 +105,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var rootNode = component._F_ = insertBefore(
+    var rootNode = component._G_ = insertBefore(
       createFragmentNode(),
       referenceNode,
       referenceNodeParentEl
@@ -115,7 +115,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     if (key && ownerComponent) {
       key = normalizeComponentKey(key, parentComponent.id);
       addComponentRootToKeyedElements(
-        ownerComponent.K_,
+        ownerComponent.L_,
         key,
         rootNode,
         component.id
@@ -127,7 +127,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphComponent(component, vComponent) {
-    morphChildren(component._F_, vComponent, component);
+    morphChildren(component._G_, vComponent, component);
   }
 
   var detachedNodes = [];
@@ -148,7 +148,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
   function morphChildren(fromNode, toNode, parentComponent) {
     var curFromNodeChild = firstChild(fromNode);
-    var curToNodeChild = toNode.aB_;
+    var curToNodeChild = toNode.aC_;
 
     var curToNodeKey;
     var curFromNodeKey;
@@ -162,16 +162,16 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     var fromComponent;
 
     outer: while (curToNodeChild) {
-      toNextSibling = curToNodeChild.co_;
-      curToNodeType = curToNodeChild.bZ_;
-      curToNodeKey = curToNodeChild.c__;
+      toNextSibling = curToNodeChild.cp_;
+      curToNodeType = curToNodeChild.c__;
+      curToNodeKey = curToNodeChild.ca_;
 
       // Skip <!doctype>
       if (curFromNodeChild && curFromNodeChild.nodeType === DOCTYPE_NODE) {
         curFromNodeChild = nextSibling(curFromNodeChild);
       }
 
-      var ownerComponent = curToNodeChild._N_ || parentComponent;
+      var ownerComponent = curToNodeChild._O_ || parentComponent;
       var referenceComponent;
 
       if (curToNodeType === COMPONENT_NODE) {
@@ -182,7 +182,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         {
           if (isHydrate) {
             var rootNode = beginFragmentNode(curFromNodeChild, fromNode);
-            component._F_ = rootNode;
+            component._G_ = rootNode;
             componentByDOMNode.set(rootNode, component);
 
             if (ownerComponent && curToNodeKey) {
@@ -191,7 +191,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                 parentComponent.id
               );
               addComponentRootToKeyedElements(
-                ownerComponent.K_,
+                ownerComponent.L_,
                 curToNodeKey,
                 rootNode,
                 component.id
@@ -215,7 +215,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             );
           }
         } else {
-          if (matchingFromComponent._F_ !== curFromNodeChild) {
+          if (matchingFromComponent._G_ !== curFromNodeChild) {
             if (
             curFromNodeChild && (
             fromComponent = componentByDOMNode.get(curFromNodeChild)) &&
@@ -225,7 +225,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             {
               // The component associated with the current real DOM node was not rendered
               // so we should just remove it out of the real DOM by destroying it
-              curFromNodeChild = nextSibling(fromComponent._F_);
+              curFromNodeChild = nextSibling(fromComponent._G_);
               destroyComponent(fromComponent);
               continue;
             }
@@ -233,7 +233,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             // We need to move the existing component into
             // the correct location
             insertBefore(
-              matchingFromComponent._F_,
+              matchingFromComponent._G_,
               curFromNodeChild,
               fromNode
             );
@@ -242,7 +242,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             curFromNodeChild && nextSibling(curFromNodeChild);
           }
 
-          if (!curToNodeChild.ae_) {
+          if (!curToNodeChild.af_) {
             morphComponent(component, curToNodeChild);
           }
         }
@@ -267,7 +267,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         // up elements
         curToNodeKey = (
         keySequences[referenceComponent.id] || (
-        keySequences[referenceComponent.id] = new KeySequence())).aO_(
+        keySequences[referenceComponent.id] = new KeySequence())).aP_(
           curToNodeKey);
 
         if (curFromNodeChild) {
@@ -278,12 +278,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
         if (curFromNodeKey === curToNodeKey) {
           // Elements line up. Now we just have to make sure they are compatible
-          if (!curToNodeChild.ae_) {
+          if (!curToNodeChild.af_) {
             // We just skip over the fromNode if it is preserved
 
             if (
             curVFromNodeChild &&
-            curToNodeType === curVFromNodeChild.bZ_ && (
+            curToNodeType === curVFromNodeChild.c__ && (
             curToNodeType !== ELEMENT_NODE ||
             compareNodeNames(curToNodeChild, curVFromNodeChild)))
             {
@@ -317,7 +317,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             }
           }
         } else {
-          matchingFromEl = referenceComponent.K_[curToNodeKey];
+          matchingFromEl = referenceComponent.L_[curToNodeKey];
           if (
           matchingFromEl === undefined ||
           matchingFromEl === curFromNodeChild)
@@ -325,19 +325,19 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             if (isHydrate && curFromNodeChild) {
               if (
               curFromNodeChild.nodeType === ELEMENT_NODE && (
-              curToNodeChild.ae_ ||
+              curToNodeChild.af_ ||
               caseInsensitiveCompare(
                 curFromNodeChild.nodeName,
-                curToNodeChild.cf_ || ""
+                curToNodeChild.cg_ || ""
               )))
               {
                 curVFromNodeChild = virtualizeElement(curFromNodeChild);
-                curVFromNodeChild.cf_ = curToNodeChild.cf_;
+                curVFromNodeChild.cg_ = curToNodeChild.cg_;
                 keysByDOMNode.set(curFromNodeChild, curToNodeKey);
-                referenceComponent.K_[curToNodeKey] =
+                referenceComponent.L_[curToNodeKey] =
                 curFromNodeChild;
 
-                if (curToNodeChild.ae_) {
+                if (curToNodeChild.af_) {
                   vElementByDOMNode.set(curFromNodeChild, curVFromNodeChild);
                 } else {
                   morphEl(
@@ -352,7 +352,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                 curFromNodeChild = fromNextSibling;
                 continue;
               } else if (
-              curToNodeChild.bZ_ === FRAGMENT_NODE &&
+              curToNodeChild.c__ === FRAGMENT_NODE &&
               curFromNodeChild.nodeType === COMMENT_NODE)
               {
                 var content = curFromNodeChild.nodeValue;
@@ -384,11 +384,11 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                   );
                   keysByDOMNode.set(fragment, curToNodeKey);
                   vElementByDOMNode.set(fragment, curToNodeChild);
-                  referenceComponent.K_[curToNodeKey] = fragment;
+                  referenceComponent.L_[curToNodeKey] = fragment;
                   removeChild(curFromNodeChild);
                   removeChild(endNode);
 
-                  if (!curToNodeChild.ae_) {
+                  if (!curToNodeChild.af_) {
                     morphChildren(fragment, curToNodeChild, parentComponent);
                   }
 
@@ -413,12 +413,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
               detachedByDOMNode.set(matchingFromEl, undefined);
             }
 
-            if (!curToNodeChild.ae_) {
+            if (!curToNodeChild.af_) {
               curVFromNodeChild = vElementByDOMNode.get(matchingFromEl);
 
               if (
               curVFromNodeChild &&
-              curToNodeType === curVFromNodeChild.bZ_ && (
+              curToNodeType === curVFromNodeChild.c__ && (
               curToNodeType !== ELEMENT_NODE ||
               compareNodeNames(curVFromNodeChild, curToNodeChild)))
               {
@@ -436,7 +436,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                   if (
                   toNextSibling &&
-                  toNextSibling.c__ === curFromNodeKey)
+                  toNextSibling.ca_ === curFromNodeKey)
                   {
                     // Single element swap
 
@@ -549,18 +549,18 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                 if (
                 caseInsensitiveCompare(
-                  curVFromNodeChild.cf_,
-                  curToNodeChild.cf_
+                  curVFromNodeChild.cg_,
+                  curToNodeChild.cg_
                 ))
                 {
-                  curVFromNodeChild.cf_ = curToNodeChild.cf_;
+                  curVFromNodeChild.cg_ = curToNodeChild.cg_;
                 }
               } else {
                 // Skip over nodes that don't look like ours...
                 curFromNodeChild = fromNextSibling;
                 continue;
               }
-            } else if (curFromNodeKey = curVFromNodeChild.c__) {
+            } else if (curFromNodeKey = curVFromNodeChild.ca_) {
               // We have a keyed element here but our target VDOM node
               // is not keyed so this not doesn't belong
               isCompatible = false;
@@ -587,18 +587,18 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           {
             // Both nodes being compared are Text or Comment nodes
             isCompatible = true;
-            var curToNodeValue = curToNodeChild.bY_;
+            var curToNodeValue = curToNodeChild.bZ_;
             var curFromNodeValue = curFromNodeChild.nodeValue;
             if (curFromNodeValue !== curToNodeValue) {
               if (
               isHydrate &&
               toNextSibling &&
               curFromNodeType === TEXT_NODE &&
-              toNextSibling.bZ_ === TEXT_NODE &&
+              toNextSibling.c__ === TEXT_NODE &&
               curFromNodeValue.startsWith(curToNodeValue) &&
               curFromNodeValue.
               slice(curToNodeValue.length).
-              startsWith(toNextSibling.bY_))
+              startsWith(toNextSibling.bZ_))
               {
                 // In hydrate mode we can use splitText to more efficiently handle
                 // adjacent text vdom nodes that were merged.
@@ -643,10 +643,10 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     }
 
     // We have processed all of the "to nodes".
-    if (fromNode.cr_) {
+    if (fromNode.cs_) {
       // If we are in an unfinished fragment, we have reached the end of the nodes
       // we were matching up and need to end the fragment
-      fromNode.cr_(curFromNodeChild);
+      fromNode.cs_(curFromNodeChild);
     } else {
       // If curFromNodeChild is non-null then we still have some from nodes
       // left over that need to be removed
@@ -675,7 +675,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           referenceComponent = parentComponent;
         } else {
           referenceComponent =
-          curVFromNodeChild && curVFromNodeChild._N_;
+          curVFromNodeChild && curVFromNodeChild._O_;
         }
 
         detachNode(curFromNodeChild, fromNode, referenceComponent);
@@ -686,26 +686,26 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphEl(fromEl, vFromEl, toEl, parentComponent) {
-    var nodeName = toEl.cf_;
-    var constId = toEl.ch_;
+    var nodeName = toEl.cg_;
+    var constId = toEl.ci_;
     vElementByDOMNode.set(fromEl, toEl);
 
-    if (constId !== undefined && vFromEl.ch_ === constId) {
+    if (constId !== undefined && vFromEl.ci_ === constId) {
       return;
     }
 
     morphAttrs(fromEl, vFromEl, toEl);
 
-    if (toEl.ad_) {
+    if (toEl.ae_) {
       return;
     }
 
     if (isTextOnly(nodeName)) {
-      if (toEl.cg_ !== vFromEl.cg_) {
+      if (toEl.ch_ !== vFromEl.ch_) {
         if (nodeName === "textarea") {
-          fromEl.value = toEl.cg_;
+          fromEl.value = toEl.ch_;
         } else {
-          fromEl.textContent = toEl.cg_;
+          fromEl.textContent = toEl.ch_;
         }
       }
     } else {
@@ -730,7 +730,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           detachedFromComponent !== true && detachedFromComponent
         );
 
-        if (eventDelegation.ao_(node) != false) {
+        if (eventDelegation.ap_(node) != false) {
           removeChild(node);
         }
       }

package/dist/runtime/vdom/vdom.js

@@ -12,7 +12,7 @@ var specialHtmlRegexp = /[&<]/;
 function virtualizeChildNodes(node, vdomParent, ownerComponent) {
   var curChild = node.firstChild;
   while (curChild) {
-    vdomParent.bQ_(virtualize(curChild, ownerComponent));
+    vdomParent.bR_(virtualize(curChild, ownerComponent));
     curChild = curChild.nextSibling;
   }
 }
@@ -20,7 +20,7 @@ function virtualizeChildNodes(node, vdomParent, ownerComponent) {
 function virtualize(node, ownerComponent) {
   switch (node.nodeType) {
     case 1:
-      return VElement.cj_(node, virtualizeChildNodes, ownerComponent);
+      return VElement.ck_(node, virtualizeChildNodes, ownerComponent);
     case 3:
       return new VText(node.nodeValue, ownerComponent);
     case 8:
@@ -43,7 +43,7 @@ function virtualizeHTML(html, ownerComponent) {
 
   while (curChild) {
     virtualized = virtualize(curChild, ownerComponent);
-    if (virtualized) vdomFragment.bQ_(virtualized);
+    if (virtualized) vdomFragment.bR_(virtualized);
     curChild = curChild.nextSibling;
   }
 
@@ -70,19 +70,19 @@ Node_prototype.t = function (value) {
     }
   }
 
-  this.bQ_(vdomNode || new VText(value.toString()));
-  return this.ci_();
+  this.bR_(vdomNode || new VText(value.toString()));
+  return this.cj_();
 };
 
-Node_prototype.bV_ = function () {
-  return this.bQ_(new VDocumentFragment());
+Node_prototype.bW_ = function () {
+  return this.bR_(new VDocumentFragment());
 };
 
-exports.bz_ = VComment;
-exports.bA_ = VDocumentFragment;
-exports.by_ = VElement;
-exports.bB_ = VText;
-exports.bC_ = VComponent;
-exports.bD_ = VFragment;
-exports.cj_ = virtualize;
-exports.bE_ = virtualizeHTML;
+exports.bA_ = VComment;
+exports.bB_ = VDocumentFragment;
+exports.bz_ = VElement;
+exports.bC_ = VText;
+exports.bD_ = VComponent;
+exports.bE_ = VFragment;
+exports.ck_ = virtualize;
+exports.bF_ = virtualizeHTML;

package/dist/translator/util/get-component-files.js

@@ -2,7 +2,7 @@
 
 var _escapeRegexp = require("./escape-regexp");
 
-const COMPONENT_FILES_KEY = "ct_";
+const COMPONENT_FILES_KEY = "cu_";
 
 function getComponentFiles({ hub: { file } }) {
   const meta = file.metadata.marko;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "5.37.51",
+  "version": "5.37.52",
   "description": "UI Components + streaming, async, high performance, HTML templating for Node.js and the browser.",
   "keywords": [
     "front-end",

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

@@ -33,13 +33,16 @@ module.exports = function beginComponent(
     ownerComponentDef &&
     ownerComponentDef.___flags & FLAG_WILL_RERENDER_IN_BROWSER;
   // On the server
-  if (!componentsContext.___isPreserved && ownerWillRerender) {
+  if (ownerWillRerender && !componentsContext.___isPreserved) {
     componentDef.___flags |= FLAG_WILL_RERENDER_IN_BROWSER;
     componentDef._wrr = true;
     return componentDef;
   }
 
-  if (isImplicitComponent === true) {
+  if (componentsContext.___forceBoundary) {
+    componentsContext.___forceBoundary = false;
+    isSplitComponent = false;
+  } else if (isImplicitComponent === true) {
     // We don't mount implicit components rendered on the server
     // unless the implicit component is nested within a UI component
     // that will re-render in the browser

package/src/runtime/helpers/skip-serialize.js

@@ -1,5 +1,7 @@
 var toJSONDescriptor = {
+  configurable: true,
   enumerable: false,
+  writable: true,
   value: function emptyInput() {
     return {};
   },

package/src/runtime/helpers/tags-compat/runtime-html.js

@@ -155,17 +155,18 @@ exports.p = function (htmlCompat) {
       // tags to class
       const $global = htmlCompat.$global();
       const state = htmlCompat.ensureState($global);
+      const out = defaultCreateOut($global);
+      const branchId = htmlCompat.nextScopeId();
+
       let writers = writersByGlobal.get($global);
       if (!writers) {
         writersByGlobal.set($global, (writers = { classAPI: [], tagsAPI: [] }));
       }
 
-      const out = defaultCreateOut($global);
-      const branchId = htmlCompat.nextScopeId();
-      let customEvents;
-
       if (renderer5) {
+        const componentsContext = ___getComponentsContext(out);
         const originalInput = input;
+        let customEvents;
         input = {};
 
         for (const key in originalInput) {
@@ -182,23 +183,22 @@ exports.p = function (htmlCompat) {
             input[key === "content" ? "renderBody" : key] = value;
           }
         }
-      }
 
-      if (renderer5) {
+        componentsContext.___forceBoundary = true;
         renderer5(input, out);
+
+        const componentDef = componentsContext.___components[0];
+        if (componentDef) {
+          htmlCompat.writeSetScopeForComponent(branchId, componentDef.id);
+          componentDef.___component.___customEvents = customEvents;
+          if (componentDef.___component.___input.toJSON) {
+            componentDef.___component.___input.toJSON = undefined;
+          }
+        }
       } else {
         renderBody5(out, input, ...args);
       }
 
-      const componentsContext = ___getComponentsContext(out);
-      const componentDef = componentsContext.___components[0];
-      if (componentDef) {
-        componentDef.___component.___customEvents = customEvents;
-        componentDef._wrr = true;
-        componentDef.___flags |= 1; // FLAG_WILL_RERENDER_IN_BROWSER
-        htmlCompat.writeSetScopeForComponent(branchId, componentDef.id);
-      }
-
       let async;
       out.once("finish", (result) => {
         if (result.out.___components) {