marko 5.33.3 → 5.33.5

package/dist/runtime/vdom/VText.js

@@ -2,21 +2,21 @@
 var VNode = require("./VNode");
 
 function VText(value, ownerComponent) {
-  this.c__(-1 /* no children */, ownerComponent);
-  this.ct_ = value;
+  this.bT_(-1 /* no children */, ownerComponent);
+  this.cm_ = value;
 }
 
 VText.prototype = {
-  cs_: true,
+  cl_: true,
 
-  cb_: 3,
+  bV_: 3,
 
-  bo_: function (host) {
-    return (host.ownerDocument || host).createTextNode(this.ct_);
+  bl_: function (host) {
+    return (host.ownerDocument || host).createTextNode(this.cm_);
   },
 
-  bU_: function () {
-    return new VText(this.ct_);
+  bN_: function () {
+    return new VText(this.cm_);
   }
 };
 

package/dist/runtime/vdom/helpers/const-element.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var VElement = require("../vdom").bC_;
+var VElement = require("../vdom").bv_;
 var i = 0;
 
 module.exports = function (tagName, attrs, childCount) {
@@ -13,12 +13,12 @@ function ConstVElement(tagName, attrs, childCount) {
 
 ConstVElement.prototype = Object.create(VElement.prototype);
 ConstVElement.prototype.e = function (tagName, attrs, childCount) {
-  var child = this.bT_(
+  var child = this.bM_(
     new ConstVElement(tagName, attrs, childCount)
   );
 
   if (childCount === 0) {
-    return this.ck_();
+    return this.cd_();
   } else {
     return child;
   }

package/dist/runtime/vdom/hot-reload.js

@@ -44,7 +44,7 @@ exports.t = runtime.t = function (typeName) {
                 instance.P_(input, out);
               };
 
-              instance.cu_ = true;
+              instance.cn_ = true;
               instance.am_();
               instance._t_ = false;
 
@@ -78,7 +78,7 @@ registry._C_ = function (typeName, id) {
   if (instances) {
     instances.add(instance);
     instance.once("destroy", function () {
-      if (!instance.cu_) {
+      if (!instance.cn_) {
         instances.delete(instance);
       }
     });

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

@@ -80,8 +80,8 @@ function createFragmentNode(startNode, nextNode, parentNode) {
 
 function beginFragmentNode(startNode, parentNode) {
   var fragment = createFragmentNode(startNode, null, parentNode);
-  fragment.cv_ = function (nextNode) {
-    fragment.cv_ = null;
+  fragment.co_ = function (nextNode) {
+    fragment.co_ = null;
     insertBefore(
       fragment.endNode,
       nextNode,
@@ -92,4 +92,4 @@ function beginFragmentNode(startNode, parentNode) {
 }
 
 exports._h_ = createFragmentNode;
-exports.cw_ = beginFragmentNode;
+exports.cp_ = beginFragmentNode;

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

@@ -37,6 +37,6 @@ function removeChild(node) {
 
 exports.bc_ = insertBefore;
 exports.bd_ = insertAfter;
-exports.cr_ = nextSibling;
+exports.ck_ = nextSibling;
 exports.ay_ = firstChild;
 exports.be_ = removeChild;

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

@@ -8,11 +8,11 @@ var normalizeComponentKey = componentsUtil._R_;
 var domData = require("../../components/dom-data");
 var eventDelegation = require("../../components/event-delegation");
 var KeySequence = require("../../components/KeySequence");
-var VElement = require("../vdom").bC_;
+var VElement = require("../vdom").bv_;
 var fragment = require("./fragment");
 var helpers = require("./helpers");
-var virtualizeElement = VElement.cm_;
-var morphAttrs = VElement.cn_;
+var virtualizeElement = VElement.cf_;
+var morphAttrs = VElement.cg_;
 var keysByDOMNode = domData._G_;
 var componentByDOMNode = domData._l_;
 var vElementByDOMNode = domData._H_;
@@ -20,11 +20,11 @@ var detachedByDOMNode = domData.aT_;
 
 var insertBefore = helpers.bc_;
 var insertAfter = helpers.bd_;
-var nextSibling = helpers.cr_;
+var nextSibling = helpers.ck_;
 var firstChild = helpers.ay_;
 var removeChild = helpers.be_;
 var createFragmentNode = fragment._h_;
-var beginFragmentNode = fragment.cw_;
+var beginFragmentNode = fragment.cp_;
 
 var ELEMENT_NODE = 1;
 var TEXT_NODE = 3;
@@ -42,7 +42,7 @@ function isAutoKey(key) {
 }
 
 function compareNodeNames(fromEl, toEl) {
-  return fromEl.ch_ === toEl.ch_;
+  return fromEl.ca_ === toEl.ca_;
 }
 
 function caseInsensitiveCompare(a, b) {
@@ -73,12 +73,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var realNode = vNode.bo_(host, parentEl.namespaceURI);
+    var realNode = vNode.bl_(host, parentEl.namespaceURI);
     insertBefore(realNode, referenceEl, parentEl);
 
     if (
-    vNode.cb_ === ELEMENT_NODE ||
-    vNode.cb_ === FRAGMENT_NODE)
+    vNode.bV_ === ELEMENT_NODE ||
+    vNode.bV_ === FRAGMENT_NODE)
     {
       if (key) {
         keysByDOMNode.set(realNode, key);
@@ -87,7 +87,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         realNode;
       }
 
-      if (vNode.ch_ !== "textarea") {
+      if (vNode.ca_ !== "textarea") {
         morphChildren(realNode, vNode, parentComponent);
       }
 
@@ -161,9 +161,9 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     var fromComponent;
 
     outer: while (curToNodeChild) {
-      toNextSibling = curToNodeChild.cr_;
-      curToNodeType = curToNodeChild.cb_;
-      curToNodeKey = curToNodeChild.ca_;
+      toNextSibling = curToNodeChild.ck_;
+      curToNodeType = curToNodeChild.bV_;
+      curToNodeKey = curToNodeChild.bU_;
 
       // Skip <!doctype>
       if (curFromNodeChild && curFromNodeChild.nodeType === DOCTYPE_NODE) {
@@ -282,7 +282,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
             if (
             curVFromNodeChild &&
-            curToNodeType === curVFromNodeChild.cb_ && (
+            curToNodeType === curVFromNodeChild.bV_ && (
             curToNodeType !== ELEMENT_NODE ||
             compareNodeNames(curToNodeChild, curVFromNodeChild)))
             {
@@ -327,11 +327,11 @@ function morphdom(fromNode, toNode, host, componentsContext) {
               curToNodeChild.aa_ ||
               caseInsensitiveCompare(
                 curFromNodeChild.nodeName,
-                curToNodeChild.ch_ || ""
+                curToNodeChild.ca_ || ""
               )))
               {
                 curVFromNodeChild = virtualizeElement(curFromNodeChild);
-                curVFromNodeChild.ch_ = curToNodeChild.ch_;
+                curVFromNodeChild.ca_ = curToNodeChild.ca_;
                 keysByDOMNode.set(curFromNodeChild, curToNodeKey);
                 referenceComponent.J_[curToNodeKey] =
                 curFromNodeChild;
@@ -351,7 +351,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                 curFromNodeChild = fromNextSibling;
                 continue;
               } else if (
-              curToNodeChild.cb_ === FRAGMENT_NODE &&
+              curToNodeChild.bV_ === FRAGMENT_NODE &&
               curFromNodeChild.nodeType === COMMENT_NODE)
               {
                 var content = curFromNodeChild.nodeValue;
@@ -418,7 +418,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
               if (
               curVFromNodeChild &&
-              curToNodeType === curVFromNodeChild.cb_ && (
+              curToNodeType === curVFromNodeChild.bV_ && (
               curToNodeType !== ELEMENT_NODE ||
               compareNodeNames(curVFromNodeChild, curToNodeChild)))
               {
@@ -436,7 +436,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                   if (
                   toNextSibling &&
-                  toNextSibling.ca_ === curFromNodeKey)
+                  toNextSibling.bU_ === curFromNodeKey)
                   {
                     // Single element swap
 
@@ -549,18 +549,18 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                 if (
                 caseInsensitiveCompare(
-                  curVFromNodeChild.ch_,
-                  curToNodeChild.ch_
+                  curVFromNodeChild.ca_,
+                  curToNodeChild.ca_
                 ))
                 {
-                  curVFromNodeChild.ch_ = curToNodeChild.ch_;
+                  curVFromNodeChild.ca_ = curToNodeChild.ca_;
                 }
               } else {
                 // Skip over nodes that don't look like ours...
                 curFromNodeChild = fromNextSibling;
                 continue;
               }
-            } else if (curFromNodeKey = curVFromNodeChild.ca_) {
+            } else if (curFromNodeKey = curVFromNodeChild.bU_) {
               // We have a keyed element here but our target VDOM node
               // is not keyed so this not doesn't belong
               isCompatible = false;
@@ -587,7 +587,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           {
             // Both nodes being compared are Text or Comment nodes
             isCompatible = true;
-            var curToNodeValue = curToNodeChild.ct_;
+            var curToNodeValue = curToNodeChild.cm_;
             var curFromNodeValue = curFromNodeChild.nodeValue;
             if (curFromNodeValue !== curToNodeValue) {
               if (
@@ -638,10 +638,10 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     }
 
     // We have processed all of the "to nodes".
-    if (fromNode.cv_) {
+    if (fromNode.co_) {
       // 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.cv_(curFromNodeChild);
+      fromNode.co_(curFromNodeChild);
     } else {
       // If curFromNodeChild is non-null then we still have some from nodes
       // left over that need to be removed
@@ -681,11 +681,11 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphEl(fromEl, vFromEl, toEl, parentComponent) {
-    var nodeName = toEl.ch_;
-    var constId = toEl.cj_;
+    var nodeName = toEl.ca_;
+    var constId = toEl.cc_;
     vElementByDOMNode.set(fromEl, toEl);
 
-    if (constId !== undefined && vFromEl.cj_ === constId) {
+    if (constId !== undefined && vFromEl.cc_ === constId) {
       return;
     }
 
@@ -696,8 +696,8 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     }
 
     if (nodeName === "textarea") {
-      if (toEl.ci_ !== vFromEl.ci_) {
-        fromEl.value = toEl.ci_;
+      if (toEl.cb_ !== vFromEl.cb_) {
+        fromEl.value = toEl.cb_;
       }
     } else {
       morphChildren(fromEl, toEl, parentComponent);

package/dist/runtime/vdom/vdom.js

@@ -11,7 +11,7 @@ var specialHtmlRegexp = /[&<]/;
 function virtualizeChildNodes(node, vdomParent, ownerComponent) {
   var curChild = node.firstChild;
   while (curChild) {
-    vdomParent.bT_(virtualize(curChild, ownerComponent));
+    vdomParent.bM_(virtualize(curChild, ownerComponent));
     curChild = curChild.nextSibling;
   }
 }
@@ -19,7 +19,7 @@ function virtualizeChildNodes(node, vdomParent, ownerComponent) {
 function virtualize(node, ownerComponent) {
   switch (node.nodeType) {
     case 1:
-      return VElement.cm_(node, virtualizeChildNodes, ownerComponent);
+      return VElement.cf_(node, virtualizeChildNodes, ownerComponent);
     case 3:
       return new VText(node.nodeValue, ownerComponent);
     case 11:
@@ -38,7 +38,7 @@ function virtualizeHTML(html, ownerComponent) {
   var curChild = parseHTML(html);
 
   while (curChild) {
-    vdomFragment.bT_(virtualize(curChild, ownerComponent));
+    vdomFragment.bM_(virtualize(curChild, ownerComponent));
     curChild = curChild.nextSibling;
   }
 
@@ -65,18 +65,18 @@ Node_prototype.t = function (value) {
     }
   }
 
-  this.bT_(vdomNode || new VText(value.toString()));
-  return this.ck_();
+  this.bM_(vdomNode || new VText(value.toString()));
+  return this.cd_();
 };
 
-Node_prototype.bY_ = function () {
-  return this.bT_(new VDocumentFragment());
+Node_prototype.bR_ = function () {
+  return this.bM_(new VDocumentFragment());
 };
 
-exports.bD_ = VDocumentFragment;
-exports.bC_ = VElement;
-exports.bE_ = VText;
-exports.bF_ = VComponent;
-exports.bG_ = VFragment;
-exports.cm_ = virtualize;
-exports.bH_ = virtualizeHTML;
+exports.bw_ = VDocumentFragment;
+exports.bv_ = VElement;
+exports.bx_ = VText;
+exports.by_ = VComponent;
+exports.bz_ = VFragment;
+exports.cf_ = virtualize;
+exports.bA_ = virtualizeHTML;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "5.33.3",
+  "version": "5.33.5",
   "description": "UI Components + streaming, async, high performance, HTML templating for Node.js and the browser.",
   "keywords": [
     "front-end",
@@ -61,11 +61,11 @@
     "tags-html.d.ts"
   ],
   "scripts": {
-    "build": "babel ./src --out-dir ./dist --copy-files --config-file ../../babel.config.js --env-name=production"
+    "build": "babel ./src --out-dir ./dist --extensions .js --copy-files --config-file ../../babel.config.js --env-name=production"
   },
   "dependencies": {
-    "@marko/compiler": "^5.35.1",
-    "@marko/translator-default": "^5.32.1",
+    "@marko/compiler": "^5.35.4",
+    "@marko/translator-default": "^5.32.3",
     "app-module-path": "^2.2.0",
     "argly": "^1.2.0",
     "browser-refresh-client": "1.1.4",

package/src/runtime/helpers/tags-compat/dom-debug.js

@@ -0,0 +1 @@
+require("./runtime-dom.js").p(require("@marko/runtime-tags/debug/dom").compat);

package/src/runtime/helpers/tags-compat/dom-debug.mjs

@@ -0,0 +1,3 @@
+import { compat } from "@marko/runtime-tags/debug/dom";
+import { p } from "./runtime-dom.js";
+p(compat);

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

@@ -0,0 +1 @@
+require("./runtime-dom.js").p(require("@marko/runtime-tags/dom").compat);

package/src/runtime/helpers/tags-compat/dom.mjs

@@ -0,0 +1,3 @@
+import { compat } from "@marko/runtime-tags/dom";
+import { p } from "./runtime-dom.js";
+p(compat);

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

@@ -0,0 +1,3 @@
+exports.s = require("./runtime-html.js").p(
+  require("@marko/runtime-tags/debug/html"),
+);

package/src/runtime/helpers/tags-compat/html-debug.mjs

@@ -0,0 +1,3 @@
+import * as api from "@marko/runtime-tags/debug/html";
+import { p } from "./runtime-html.js";
+export const s = p(api);

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

@@ -0,0 +1 @@
+exports.s = require("./runtime-html.js").p(require("@marko/runtime-tags/html"));

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

@@ -0,0 +1,3 @@
+import * as api from "@marko/runtime-tags/html";
+import { p } from "./runtime-html.js";
+export const s = p(api);

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

@@ -0,0 +1,231 @@
+const { ___componentLookup } = require("@internal/components-util");
+const {
+  ___getComponentsContext,
+} = require("../../components/ComponentsContext");
+const defineComponent = require("../../components/defineComponent");
+const { r: registerComponent } = require("../../components/registry");
+const createRenderer = require("../../components/renderer");
+const defaultCreateOut = require("../../createOut");
+const morphdom = require("../../vdom/morphdom");
+const { ___createFragmentNode } = require("../../vdom/morphdom/fragment");
+const dynamicTag = require("../dynamic-tag");
+
+exports.p = function (domCompat) {
+  dynamicTag.___runtimeCompat = function tagsToVdom(
+    renderer,
+    renderBody,
+    args,
+  ) {
+    const tagsRenderer = domCompat.resolveRenderer(renderer || renderBody);
+
+    if (tagsRenderer) {
+      return (input, out) =>
+        TagsCompat({ i: args ? args : input, r: tagsRenderer }, out);
+    }
+
+    return renderer;
+  };
+
+  const TagsCompatId = "tags-compat";
+  const TagsCompat = createRenderer(
+    function (_, out, componentDef, component) {
+      const isHydrate =
+        ___getComponentsContext(out).___globalContext.___isHydrate;
+      const input = Array.isArray(_.i) ? _.i : [_.i];
+      const tagsRenderer = domCompat.resolveRenderer(_.r);
+      const newNode = domCompat.render(
+        isHydrate,
+        out,
+        component,
+        tagsRenderer,
+        input,
+      );
+
+      out.bf(out.___assignedKey, component, !newNode);
+      if (newNode) {
+        out.node({ ___actualize: () => newNode });
+      }
+      out.ef();
+    },
+    // eslint-disable-next-line no-constant-condition
+    "MARKO_DEBUG"
+      ? {
+          t: TagsCompatId,
+          d: true,
+        }
+      : {
+          t: TagsCompatId,
+        },
+    {},
+  );
+
+  registerComponent(TagsCompatId, () => ({
+    _: TagsCompat,
+    Component: defineComponent(
+      {
+        onMount: domCompat.runComponentEffects,
+        onUpdate: domCompat.runComponentEffects,
+      },
+      TagsCompat,
+    ),
+  }));
+
+  // (
+  //   nodeAccessor: Accessor,
+  //   dynamicTagAttrs?: IntersectionSignal,
+  //   intersection?: IntersectionSignal,
+  //   valueWithIntersection?: ValueSignal
+  // )
+
+  const rendererCache = new WeakMap();
+
+  domCompat.patchConditionals((conditional) => (...args) => {
+    const signal = conditional(...args);
+    const hasAttrs = args.length > 1;
+    return (scope, renderer, clean) => {
+      return signal(scope, create5to6Renderer(renderer, hasAttrs), clean);
+    };
+  });
+
+  function create5to6Renderer(renderer, hasAttrs) {
+    let newRenderer = renderer;
+    if (renderer && typeof renderer !== "string") {
+      const rendererFromAnywhere =
+        renderer._ ||
+        renderer.render ||
+        (renderer.renderer && renderer.renderer.renderer) ||
+        renderer.renderer;
+
+      if (!domCompat.isRenderer(rendererFromAnywhere || renderer)) {
+        newRenderer = rendererCache.get(renderer);
+        if (!newRenderer) {
+          const { Component } = renderer;
+          if (Component) {
+            const setCustomEvents = Component.prototype.___setCustomEvents;
+            Component.prototype.___setCustomEvents = function (
+              customEvents,
+              scopeId,
+            ) {
+              for (const customEvent of customEvents) {
+                customEvent[1] = domCompat.resolveRenderer(customEvent[1]);
+              }
+
+              setCustomEvents.call(this, customEvents, scopeId);
+            };
+          }
+          newRenderer = domCompat.createRenderer(
+            (scope) => {
+              if (!hasAttrs) {
+                renderAndMorph(scope, rendererFromAnywhere, renderer, {});
+              }
+            },
+            () => {
+              const realFragment = document.createDocumentFragment();
+              ___createFragmentNode(null, null, realFragment);
+              return realFragment;
+            },
+            (scope, input, clean) => {
+              if (clean) return;
+              renderAndMorph(scope, rendererFromAnywhere, renderer, input);
+            },
+          );
+          rendererCache.set(renderer, newRenderer);
+        }
+      }
+    }
+    return newRenderer;
+  }
+
+  domCompat.register("@marko/tags-compat-5-to-6", create5to6Renderer);
+
+  function renderAndMorph(scope, renderer, renderBody, input) {
+    const out = defaultCreateOut();
+    let host = domCompat.getStartNode(scope);
+    let rootNode = host.fragment;
+    if (!rootNode) {
+      const component = (scope.marko5Component = ___componentLookup[scope.m5c]);
+      rootNode = component.___rootNode;
+      host = rootNode.startNode;
+      domCompat.setScopeNodes(host, rootNode.endNode);
+    }
+    const existingComponent = scope.marko5Component;
+    const componentsContext = ___getComponentsContext(out);
+    const globalComponentsContext = componentsContext.___globalContext;
+    let customEvents;
+    globalComponentsContext.___rerenderComponent = existingComponent;
+    out.sync();
+    if (renderer) {
+      const [rawInput] = input;
+      const normalizedInput = {};
+
+      for (const key in rawInput) {
+        let value = rawInput[key];
+        if (key.startsWith("on")) {
+          const c = key[2];
+          customEvents = customEvents || {};
+          customEvents[(c === "-" ? "" : c.toLowerCase()) + key.slice(3)] = [
+            value,
+          ];
+        } else {
+          normalizedInput[key] = rawInput[key];
+        }
+      }
+
+      renderer(normalizedInput, out);
+    } else {
+      RenderBodyComponent({ renderBody, args: input }, out);
+    }
+
+    domCompat.queueEffect(scope, () => {
+      const targetNode = out.___getOutput().___firstChild;
+      morphdom(rootNode, targetNode, host, componentsContext);
+      const componentDefs = componentsContext.___initComponents(
+        getRootNode(host),
+      );
+      const component = componentDefs[0].___component;
+      component.___rootNode = rootNode;
+      component.___input = input[0];
+      component.___customEvents = customEvents;
+      scope.marko5Component = component;
+    });
+  }
+
+  function getRootNode(el) {
+    var cur = el;
+    while (cur.parentNode) cur = cur.parentNode;
+    return cur;
+  }
+
+  const RenderBodyComponentId = "renderbody-renderer";
+  const RenderBodyComponent = createRenderer(
+    function (input, out, _componentDef) {
+      dynamicTag(
+        out,
+        input.renderBody,
+        null,
+        null,
+        input.args,
+        null,
+        _componentDef,
+        "0",
+      );
+    },
+    // eslint-disable-next-line no-constant-condition
+    "MARKO_DEBUG"
+      ? {
+          t: RenderBodyComponentId,
+          i: true,
+          d: true,
+        }
+      : {
+          t: RenderBodyComponentId,
+          i: true,
+        },
+    {},
+  );
+
+  registerComponent(RenderBodyComponentId, () => ({
+    _: RenderBodyComponent,
+    Component: defineComponent({}, RenderBodyComponent),
+  }));
+};