marko 5.31.0 → 5.31.2

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

@@ -2,11 +2,11 @@
 var specialElHandlers = require("./specialElHandlers");
 var KeySequence = require("../../components/KeySequence");
 var componentsUtil = require("@internal/components-util");
-var existingComponentLookup = componentsUtil._o_;
-var destroyNodeRecursive = componentsUtil._U_;
+var existingComponentLookup = componentsUtil._i_;
+var destroyNodeRecursive = componentsUtil._O_;
 var addComponentRootToKeyedElements =
-componentsUtil._p_;
-var normalizeComponentKey = componentsUtil._X_;
+componentsUtil._j_;
+var normalizeComponentKey = componentsUtil._R_;
 var VElement = require("../vdom").bs_;
 var virtualizeElement = VElement.ce_;
 var morphAttrs = VElement.cf_;
@@ -14,9 +14,9 @@ var eventDelegation = require("../../components/event-delegation");
 var fragment = require("./fragment");
 var helpers = require("./helpers");
 var domData = require("../../components/dom-data");
-var keysByDOMNode = domData._M_;
-var componentByDOMNode = domData._r_;
-var vElementByDOMNode = domData._N_;
+var keysByDOMNode = domData._G_;
+var componentByDOMNode = domData._l_;
+var vElementByDOMNode = domData._H_;
 var detachedByDOMNode = domData.aT_;
 
 var insertBefore = helpers.bd_;
@@ -24,7 +24,7 @@ var insertAfter = helpers.be_;
 var nextSibling = helpers.cj_;
 var firstChild = helpers.ay_;
 var removeChild = helpers.bf_;
-var createFragmentNode = fragment._n_;
+var createFragmentNode = fragment._h_;
 var beginFragmentNode = fragment.cp_;
 
 var ELEMENT_NODE = 1;
@@ -62,8 +62,8 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   var keySequences = Object.create(null);
 
   if (componentsContext) {
-    globalComponentsContext = componentsContext.f_;
-    isHydrate = globalComponentsContext.g_;
+    globalComponentsContext = componentsContext.o_;
+    isHydrate = globalComponentsContext._W_;
   }
 
   function insertVirtualNodeBefore(
@@ -83,7 +83,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     {
       if (key) {
         keysByDOMNode.set(realNode, key);
-        (isAutoKey(key) ? parentComponent : ownerComponent).l_[
+        (isAutoKey(key) ? parentComponent : ownerComponent).J_[
         key] =
         realNode;
       }
@@ -105,21 +105,21 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var rootNode = component._G_ = insertBefore(
-    createFragmentNode(),
-    referenceNode,
-    referenceNodeParentEl);
-
+    var rootNode = component._A_ = insertBefore(
+      createFragmentNode(),
+      referenceNode,
+      referenceNodeParentEl
+    );
     componentByDOMNode.set(rootNode, component);
 
     if (key && ownerComponent) {
       key = normalizeComponentKey(key, parentComponent.id);
       addComponentRootToKeyedElements(
-      ownerComponent.l_,
-      key,
-      rootNode,
-      component.id);
-
+        ownerComponent.J_,
+        key,
+        rootNode,
+        component.id
+      );
       keysByDOMNode.set(rootNode, key);
     }
 
@@ -127,7 +127,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphComponent(component, vComponent) {
-    morphChildren(component._G_, vComponent, component);
+    morphChildren(component._A_, vComponent, component);
   }
 
   var detachedNodes = [];
@@ -171,31 +171,31 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         curFromNodeChild = nextSibling(curFromNodeChild);
       }
 
-      var ownerComponent = curToNodeChild._P_ || parentComponent;
+      var ownerComponent = curToNodeChild._J_ || parentComponent;
       var referenceComponent;
 
       if (curToNodeType === COMPONENT_NODE) {
-        var component = curToNodeChild.i_;
+        var component = curToNodeChild.r_;
         if (
         (matchingFromComponent = existingComponentLookup[component.id]) ===
         undefined)
         {
           if (isHydrate === true) {
             var rootNode = beginFragmentNode(curFromNodeChild, fromNode);
-            component._G_ = rootNode;
+            component._A_ = rootNode;
             componentByDOMNode.set(rootNode, component);
 
             if (ownerComponent && curToNodeKey) {
               curToNodeKey = normalizeComponentKey(
-              curToNodeKey,
-              parentComponent.id);
-
+                curToNodeKey,
+                parentComponent.id
+              );
               addComponentRootToKeyedElements(
-              ownerComponent.l_,
-              curToNodeKey,
-              rootNode,
-              component.id);
-
+                ownerComponent.J_,
+                curToNodeKey,
+                rootNode,
+                component.id
+              );
 
               keysByDOMNode.set(rootNode, curToNodeKey);
             }
@@ -205,27 +205,27 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             curFromNodeChild = nextSibling(rootNode);
           } else {
             insertVirtualComponentBefore(
-            curToNodeChild,
-            curFromNodeChild,
-            fromNode,
-            component,
-            curToNodeKey,
-            ownerComponent,
-            parentComponent);
-
+              curToNodeChild,
+              curFromNodeChild,
+              fromNode,
+              component,
+              curToNodeKey,
+              ownerComponent,
+              parentComponent
+            );
           }
         } else {
-          if (matchingFromComponent._G_ !== curFromNodeChild) {
+          if (matchingFromComponent._A_ !== curFromNodeChild) {
             if (
             curFromNodeChild && (
             fromComponent = componentByDOMNode.get(curFromNodeChild)) &&
-            globalComponentsContext.z_[
+            globalComponentsContext.p_[
             fromComponent.id] ===
             undefined)
             {
               // 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._G_);
+              curFromNodeChild = nextSibling(fromComponent._A_);
               destroyComponent(fromComponent);
               continue;
             }
@@ -233,16 +233,16 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             // We need to move the existing component into
             // the correct location
             insertBefore(
-            matchingFromComponent._G_,
-            curFromNodeChild,
-            fromNode);
-
+              matchingFromComponent._A_,
+              curFromNodeChild,
+              fromNode
+            );
           } else {
             curFromNodeChild =
             curFromNodeChild && nextSibling(curFromNodeChild);
           }
 
-          if (!curToNodeChild.o_) {
+          if (!curToNodeChild.aa_) {
             morphComponent(component, curToNodeChild);
           }
         }
@@ -268,7 +268,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         curToNodeKey = (
         keySequences[referenceComponent.id] || (
         keySequences[referenceComponent.id] = new KeySequence())).aK_(
-        curToNodeKey);
+          curToNodeKey);
 
         if (curFromNodeChild) {
           curFromNodeKey = keysByDOMNode.get(curFromNodeChild);
@@ -278,33 +278,33 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
         if (curFromNodeKey === curToNodeKey) {
           // Elements line up. Now we just have to make sure they are compatible
-          if (!curToNodeChild.o_) {
+          if (!curToNodeChild.aa_) {
             // We just skip over the fromNode if it is preserved
 
             if (compareNodeNames(curToNodeChild, curVFromNodeChild)) {
               morphEl(
-              curFromNodeChild,
-              curVFromNodeChild,
-              curToNodeChild,
-              parentComponent);
-
+                curFromNodeChild,
+                curVFromNodeChild,
+                curToNodeChild,
+                parentComponent
+              );
             } else {
               // Remove the old node
               detachNode(curFromNodeChild, fromNode, ownerComponent);
 
               // Incompatible nodes. Just move the target VNode into the DOM at this position
               insertVirtualNodeBefore(
-              curToNodeChild,
-              curToNodeKey,
-              curFromNodeChild,
-              fromNode,
-              ownerComponent,
-              parentComponent);
-
+                curToNodeChild,
+                curToNodeKey,
+                curFromNodeChild,
+                fromNode,
+                ownerComponent,
+                parentComponent
+              );
             }
           }
         } else {
-          matchingFromEl = referenceComponent.l_[curToNodeKey];
+          matchingFromEl = referenceComponent.J_[curToNodeKey];
           if (
           matchingFromEl === undefined ||
           matchingFromEl === curFromNodeChild)
@@ -312,27 +312,27 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             if (isHydrate === true && curFromNodeChild) {
               if (
               curFromNodeChild.nodeType === ELEMENT_NODE && (
-              curToNodeChild.o_ ||
+              curToNodeChild.aa_ ||
               caseInsensitiveCompare(
-              curFromNodeChild.nodeName,
-              curToNodeChild.bZ_ || "")))
-
+                curFromNodeChild.nodeName,
+                curToNodeChild.bZ_ || ""
+              )))
               {
                 curVFromNodeChild = virtualizeElement(curFromNodeChild);
                 curVFromNodeChild.bZ_ = curToNodeChild.bZ_;
                 keysByDOMNode.set(curFromNodeChild, curToNodeKey);
-                referenceComponent.l_[curToNodeKey] =
+                referenceComponent.J_[curToNodeKey] =
                 curFromNodeChild;
 
-                if (curToNodeChild.o_) {
+                if (curToNodeChild.aa_) {
                   vElementByDOMNode.set(curFromNodeChild, curVFromNodeChild);
                 } else {
                   morphEl(
-                  curFromNodeChild,
-                  curVFromNodeChild,
-                  curToNodeChild,
-                  parentComponent);
-
+                    curFromNodeChild,
+                    curVFromNodeChild,
+                    curToNodeChild,
+                    parentComponent
+                  );
                 }
 
                 curToNodeChild = toNextSibling;
@@ -366,17 +366,17 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                   }
 
                   var fragment = createFragmentNode(
-                  curFromNodeChild,
-                  endNode.nextSibling,
-                  fromNode);
-
+                    curFromNodeChild,
+                    endNode.nextSibling,
+                    fromNode
+                  );
                   keysByDOMNode.set(fragment, curToNodeKey);
                   vElementByDOMNode.set(fragment, curToNodeChild);
-                  referenceComponent.l_[curToNodeKey] = fragment;
+                  referenceComponent.J_[curToNodeKey] = fragment;
                   removeChild(curFromNodeChild);
                   removeChild(endNode);
 
-                  if (!curToNodeChild.o_) {
+                  if (!curToNodeChild.aa_) {
                     morphChildren(fragment, curToNodeChild, parentComponent);
                   }
 
@@ -388,20 +388,20 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             }
 
             insertVirtualNodeBefore(
-            curToNodeChild,
-            curToNodeKey,
-            curFromNodeChild,
-            fromNode,
-            ownerComponent,
-            parentComponent);
-
+              curToNodeChild,
+              curToNodeKey,
+              curFromNodeChild,
+              fromNode,
+              ownerComponent,
+              parentComponent
+            );
             fromNextSibling = curFromNodeChild;
           } else {
             if (detachedByDOMNode.get(matchingFromEl) !== undefined) {
               detachedByDOMNode.set(matchingFromEl, undefined);
             }
 
-            if (!curToNodeChild.o_) {
+            if (!curToNodeChild.aa_) {
               curVFromNodeChild = vElementByDOMNode.get(matchingFromEl);
 
               if (compareNodeNames(curVFromNodeChild, curToNodeChild)) {
@@ -456,20 +456,20 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                 }
 
                 morphEl(
-                matchingFromEl,
-                curVFromNodeChild,
-                curToNodeChild,
-                parentComponent);
-
+                  matchingFromEl,
+                  curVFromNodeChild,
+                  curToNodeChild,
+                  parentComponent
+                );
               } else {
                 insertVirtualNodeBefore(
-                curToNodeChild,
-                curToNodeKey,
-                curFromNodeChild,
-                fromNode,
-                ownerComponent,
-                parentComponent);
-
+                  curToNodeChild,
+                  curToNodeKey,
+                  curFromNodeChild,
+                  fromNode,
+                  ownerComponent,
+                  parentComponent
+                );
                 detachNode(matchingFromEl, fromNode, ownerComponent);
               }
             } else {
@@ -502,7 +502,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           curFromNodeChild = fromNextSibling;
 
           if (
-          !globalComponentsContext.z_[fromComponent.id])
+          !globalComponentsContext.p_[fromComponent.id])
           {
             destroyComponent(fromComponent);
           }
@@ -524,9 +524,9 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                 if (
                 caseInsensitiveCompare(
-                curVFromNodeChild.bZ_,
-                curToNodeChild.bZ_))
-
+                  curVFromNodeChild.bZ_,
+                  curToNodeChild.bZ_
+                ))
                 {
                   curVFromNodeChild.bZ_ = curToNodeChild.bZ_;
                 }
@@ -550,11 +550,11 @@ function morphdom(fromNode, toNode, host, componentsContext) {
               // the current "from" node to match the current
               // target DOM node.
               morphEl(
-              curFromNodeChild,
-              curVFromNodeChild,
-              curToNodeChild,
-              parentComponent);
-
+                curFromNodeChild,
+                curVFromNodeChild,
+                curToNodeChild,
+                parentComponent
+              );
             }
           } else if (
           curFromNodeType === TEXT_NODE ||
@@ -572,8 +572,8 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             toNextSibling.bT_ === TEXT_NODE)
             {
               fromNextSibling = curFromNodeChild.splitText(
-              curToNodeChild.cl_.length);
-
+                curToNodeChild.cl_.length
+              );
             }
             if (curFromNodeChild.nodeValue !== curToNodeChild.cl_) {
               curFromNodeChild.nodeValue = curToNodeChild.cl_;
@@ -597,13 +597,13 @@ function morphdom(fromNode, toNode, host, componentsContext) {
       // nodes. Therefore, we will just append the current "to" node
       // to the end
       insertVirtualNodeBefore(
-      curToNodeChild,
-      curToNodeKey,
-      curFromNodeChild,
-      fromNode,
-      ownerComponent,
-      parentComponent);
-
+        curToNodeChild,
+        curToNodeKey,
+        curFromNodeChild,
+        fromNode,
+        ownerComponent,
+        parentComponent
+      );
 
       curToNodeChild = toNextSibling;
       curFromNodeChild = fromNextSibling;
@@ -626,7 +626,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         if (fromComponent = componentByDOMNode.get(curFromNodeChild)) {
           curFromNodeChild = fromNextSibling;
           if (
-          !globalComponentsContext.z_[fromComponent.id])
+          !globalComponentsContext.p_[fromComponent.id])
           {
             destroyComponent(fromComponent);
           }
@@ -642,7 +642,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           referenceComponent = parentComponent;
         } else {
           referenceComponent =
-          curVFromNodeChild && curVFromNodeChild._P_;
+          curVFromNodeChild && curVFromNodeChild._J_;
         }
 
         detachNode(curFromNodeChild, fromNode, referenceComponent);
@@ -662,7 +662,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
     morphAttrs(fromEl, vFromEl, toEl);
 
-    if (toEl.n_) {
+    if (toEl.a__) {
       return;
     }
 
@@ -681,7 +681,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
 
 
-  morphChildren(fromNode, toNode, toNode.i_);
+  morphChildren(fromNode, toNode, toNode.r_);
 
   detachedNodes.forEach(function (node) {
     var detachedFromComponent = detachedByDOMNode.get(node);
@@ -694,9 +694,9 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         componentToDestroy.destroy();
       } else if (node.parentNode) {
         destroyNodeRecursive(
-        node,
-        detachedFromComponent !== true && detachedFromComponent);
-
+          node,
+          detachedFromComponent !== true && detachedFromComponent
+        );
 
         if (eventDelegation.al_(node) != false) {
           removeChild(node);

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

@@ -48,8 +48,8 @@ SpecialElHandlers.prototype = {
     syncBooleanAttrProp(fromEl, toEl, "checked");
     syncBooleanAttrProp(fromEl, toEl, "disabled");
 
-    if (fromEl.value != toEl.q_) {
-      fromEl.value = toEl.q_;
+    if (fromEl.value != toEl.e_) {
+      fromEl.value = toEl.e_;
     }
 
     if (fromEl.hasAttribute("value") && !toEl.cc_("value")) {
@@ -62,7 +62,7 @@ SpecialElHandlers.prototype = {
       return;
     }
 
-    var newValue = toEl.q_;
+    var newValue = toEl.e_;
     if (fromEl.value != newValue) {
       fromEl.value = newValue;
     }
@@ -87,14 +87,14 @@ SpecialElHandlers.prototype = {
     if (!toEl.cc_("multiple")) {
       var selected = 0;
       forEachOption(
-      toEl,
-      function (option, i) {
-        if (option.cc_("selected")) {
-          selected = i;
-        }
-      },
-      -1);
-
+        toEl,
+        function (option, i) {
+          if (option.cc_("selected")) {
+            selected = i;
+          }
+        },
+        -1
+      );
 
       if (fromEl.selectedIndex !== selected) {
         fromEl.selectedIndex = selected;

package/dist/runtime/vdom/vdom.js

@@ -25,8 +25,8 @@ function virtualize(node, ownerComponent) {
     case 11:
       var vdomDocFragment = new VDocumentFragment();
       virtualizeChildNodes(node, vdomDocFragment, ownerComponent);
-      return vdomDocFragment;}
-
+      return vdomDocFragment;
+  }
 }
 
 function virtualizeHTML(html, ownerComponent) {

package/dist/taglib/index.js

@@ -13,9 +13,9 @@ function register(taglibProps, taglibPath) {
 
 function registerFromFile(taglibPath) {
   return register(
-  compiler.taglib._loader.loadTaglibFromFile(taglibPath),
-  taglibPath);
-
+    compiler.taglib._loader.loadTaglibFromFile(taglibPath),
+    taglibPath
+  );
 }
 
 exports.clearCache = clearCache;

package/package.json

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

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

@@ -1,81 +1 @@
-var ComponentsContext = require("../../runtime/components/ComponentsContext");
-var getComponentsContext = ComponentsContext.___getComponentsContext;
-
-module.exports = function render(input, out) {
-  var isComponent = !input.n;
-  var shouldPreserve = !("i" in input) || input.i;
-  var componentsContext = out.___components;
-
-  if (typeof document === "object") {
-    var isHydrate =
-      componentsContext && componentsContext.___globalContext.___isHydrate;
-    var ownerComponent = out.___assignedComponentDef.___component;
-    var referenceComponent = ownerComponent;
-    var key = out.___assignedKey;
-    var checkKey = key;
-
-    if (key[0] !== "@") {
-      var parentComponent = componentsContext.___componentDef.___component;
-      if (ownerComponent !== parentComponent) {
-        referenceComponent = parentComponent;
-        checkKey += ":" + ownerComponent.id;
-      }
-    }
-
-    var isPreserved =
-      shouldPreserve &&
-      (isHydrate || referenceComponent.___keyedElements[checkKey]);
-
-    if (isComponent) {
-      out.bf(key, ownerComponent, shouldPreserve);
-
-      if (!isPreserved && input.renderBody) {
-        input.renderBody(out);
-      }
-
-      out.ef();
-    } else {
-      if (isPreserved) {
-        if (input.b) {
-          out.___parent.___preserveBody = true;
-        } else {
-          out.beginElement("", null, key, ownerComponent);
-          out.___parent.___preserve = true;
-          out.endElement();
-        }
-      } else if (input.renderBody) {
-        input.renderBody(out);
-      }
-    }
-  } else {
-    if (isComponent) {
-      out.bf(
-        out.___assignedKey,
-        out.___assignedComponentDef.___component,
-        true
-      );
-    }
-
-    if (input.renderBody) {
-      if (shouldPreserve) {
-        var parentPreserved = false;
-
-        if (componentsContext) {
-          parentPreserved = componentsContext.___isPreserved;
-        } else {
-          componentsContext = getComponentsContext(out);
-        }
-
-        componentsContext.___isPreserved = true;
-        input.renderBody(out);
-        componentsContext.___isPreserved = parentPreserved;
-      } else {
-        input.renderBody(out);
-      }
-    }
-
-    if (isComponent) {
-      out.ef();
-    }
-  }
-};
+module.exports = require("@internal/preserve-tag");