marko 6.0.0-next.3.25 → 6.0.0-next.3.26

package/dist/common/types.d.ts

@@ -3,6 +3,7 @@ export type Falsy = undefined | null | false | 0 | "";
 export type CommentWalker = TreeWalker & Record<string, Comment>;
 export interface BranchScope extends Scope {
     ___parentBranch: BranchScope | undefined;
+    ___branchDepth: number;
     ___destroyed: 1 | undefined;
     ___abortScopes: Set<Scope> | undefined;
     ___branchScopes: Set<BranchScope> | undefined;

package/dist/debug/dom.js

@@ -194,21 +194,23 @@ function finishPendingScopes() {
   }
   pendingScopes = [];
 }
-var emptyScope = createScope({});
-function getEmptyScope(marker) {
-  emptyScope.___startNode = emptyScope.___endNode = marker;
-  return emptyScope;
+var emptyBranch = createScope({});
+function getEmptyBranch(marker) {
+  emptyBranch.___startNode = emptyBranch.___endNode = marker;
+  return emptyBranch;
 }
 function destroyBranch(branch) {
+  branch.___parentBranch?.___branchScopes?.delete(branch);
+  destroyNestedBranches(branch);
+}
+function destroyNestedBranches(branch) {
   branch.___destroyed = 1;
-  branch.___branchScopes?.forEach(destroyBranch);
-  if (branch.___abortScopes) {
-    for (const scope of branch.___abortScopes) {
-      for (const id in scope.___abortControllers) {
-        scope.___abortControllers[id]?.abort();
-      }
+  branch.___branchScopes?.forEach(destroyNestedBranches);
+  branch.___abortScopes?.forEach((scope) => {
+    for (const id in scope.___abortControllers) {
+      scope.___abortControllers[id]?.abort();
     }
-  }
+  });
 }
 function removeAndDestroyBranch(branch) {
   destroyBranch(branch);
@@ -220,9 +222,9 @@ function removeAndDestroyBranch(branch) {
     current = next;
   }
 }
-function insertBefore(scope, parent, nextSibling) {
-  let current = scope.___startNode;
-  const stop = scope.___endNode.nextSibling;
+function insertBranchBefore(branch, parent, nextSibling) {
+  let current = branch.___startNode;
+  const stop = branch.___endNode.nextSibling;
   while (current !== stop) {
     const next = current.nextSibling;
     parent.insertBefore(current, nextSibling);
@@ -327,7 +329,7 @@ function reconcile(parent, oldBranches, newBranches, afterReference) {
       k = newEnd + 1;
       nextSibling = k < newBranches.length ? newBranches[k].___startNode : afterReference;
       do {
-        insertBefore(newBranches[newStart++], parent, nextSibling);
+        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
       } while (newStart <= newEnd);
     }
   } else if (newStart > newEnd) {
@@ -361,7 +363,7 @@ function reconcile(parent, oldBranches, newBranches, afterReference) {
     }
     if (oldLength === oldBranches.length && synced === 0) {
       for (; newStart < newLength; ++newStart) {
-        insertBefore(newBranches[newStart], parent, afterReference);
+        insertBranchBefore(newBranches[newStart], parent, afterReference);
       }
       for (; oldStart < oldLength; ++oldStart) {
         removeAndDestroyBranch(oldBranches[oldStart]);
@@ -384,13 +386,13 @@ function reconcile(parent, oldBranches, newBranches, afterReference) {
             pos = i + newStart;
             newBranch = newBranches[pos++];
             nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-            insertBefore(newBranch, parent, nextSibling);
+            insertBranchBefore(newBranch, parent, nextSibling);
           } else {
             if (j < 0 || i !== seq[j]) {
               pos = i + newStart;
               newBranch = newBranches[pos++];
               nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-              insertBefore(newBranch, parent, nextSibling);
+              insertBranchBefore(newBranch, parent, nextSibling);
             } else {
               --j;
             }
@@ -403,7 +405,7 @@ function reconcile(parent, oldBranches, newBranches, afterReference) {
             pos = i + newStart;
             newBranch = newBranches[pos++];
             nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-            insertBefore(newBranch, parent, nextSibling);
+            insertBranchBefore(newBranch, parent, nextSibling);
           }
         }
       }
@@ -652,6 +654,7 @@ var Render = class {
                 if (branchIds.has(scopeId)) {
                   const branch = scope;
                   const parentBranch = branch.___closestBranch;
+                  branch.___branchDepth = +scopeId;
                   scope.___closestBranch = branch;
                   if (parentBranch) {
                     branch.___parentBranch = parentBranch;
@@ -1337,7 +1340,7 @@ function createBranchScopeWithRenderer(renderer, $global, parentScope) {
   if (true) {
     branch.___renderer = renderer;
   }
-  initRenderer(renderer, branch);
+  initBranch(renderer, branch);
   return branch;
 }
 function createBranchScopeWithTagNameOrRenderer(tagNameOrRenderer, $global, parentScope) {
@@ -1358,22 +1361,25 @@ function createBranch($global, ownerScope, parentScope) {
   branch._ = ownerScope;
   branch.___closestBranch = branch;
   if (parentBranch) {
+    branch.___branchDepth = parentBranch.___branchDepth + 1;
     branch.___parentBranch = parentBranch;
     (parentBranch.___branchScopes ||= /* @__PURE__ */ new Set()).add(branch);
+  } else {
+    branch.___branchDepth = 1;
   }
   return branch;
 }
-function initRenderer(renderer, scope) {
+function initBranch(renderer, branch) {
   const dom = renderer.___clone();
   walk(
     dom.nodeType === 11 /* DocumentFragment */ ? dom.firstChild : dom,
     renderer.___walks,
-    scope
+    branch
   );
-  scope.___startNode = dom.nodeType === 11 /* DocumentFragment */ ? dom.firstChild : dom;
-  scope.___endNode = dom.nodeType === 11 /* DocumentFragment */ ? dom.lastChild : dom;
+  branch.___startNode = dom.nodeType === 11 /* DocumentFragment */ ? dom.firstChild : dom;
+  branch.___endNode = dom.nodeType === 11 /* DocumentFragment */ ? dom.lastChild : dom;
   if (renderer.___setup) {
-    queueRender(scope, renderer.___setup);
+    queueRender(branch, renderer.___setup);
   }
   return dom;
 }
@@ -1454,6 +1460,7 @@ var conditional = function conditional2(nodeAccessor, fn, getIntersection) {
     if (newRendererOrOp !== MARK && newRendererOrOp !== CLEAN) {
       const normalizedRenderer = normalizeDynamicRenderer(newRendererOrOp);
       if (isDifferentRenderer(normalizedRenderer, currentRenderer)) {
+        scope[rendererAccessor] = normalizedRenderer;
         setConditionalRenderer(scope, nodeAccessor, normalizedRenderer);
         fn && fn(scope);
         op = DIRTY;
@@ -1465,16 +1472,15 @@ var conditional = function conditional2(nodeAccessor, fn, getIntersection) {
   };
 };
 function setConditionalRenderer(scope, nodeAccessor, newRenderer) {
-  const newBranch = newRenderer ? createBranchScopeWithTagNameOrRenderer(newRenderer, scope.$global, scope) : void 0;
-  const prevBranch = scope[nodeAccessor + "!" /* ConditionalScope */] || getEmptyScope(scope[nodeAccessor]);
-  insertBefore(
-    newBranch || getEmptyScope(scope[nodeAccessor]),
+  const prevBranch = scope[nodeAccessor + "!" /* ConditionalScope */] || getEmptyBranch(scope[nodeAccessor]);
+  const newBranch = newRenderer ? createBranchScopeWithTagNameOrRenderer(newRenderer, scope.$global, scope) : getEmptyBranch(scope[nodeAccessor]);
+  insertBranchBefore(
+    newBranch,
     prevBranch.___startNode.parentNode,
     prevBranch.___startNode
   );
   removeAndDestroyBranch(prevBranch);
-  scope[nodeAccessor + "(" /* ConditionalRenderer */] = newRenderer;
-  scope[nodeAccessor + "!" /* ConditionalScope */] = newBranch;
+  scope[nodeAccessor + "!" /* ConditionalScope */] = newRenderer && newBranch;
 }
 var conditionalOnlyChild = function conditional3(nodeAccessor, fn, getIntersection) {
   const rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
@@ -1507,16 +1513,16 @@ function setConditionalRendererOnlyChild(scope, nodeAccessor, newRenderer) {
   const newBranch = newRenderer ? createBranchScopeWithTagNameOrRenderer(newRenderer, scope.$global, scope) : void 0;
   referenceNode.textContent = "";
   if (newBranch) {
-    insertBefore(newBranch, referenceNode, null);
+    insertBranchBefore(newBranch, referenceNode, null);
   }
   prevBranch && destroyBranch(prevBranch);
   scope[nodeAccessor + "!" /* ConditionalScope */] = newBranch;
 }
 var emptyMarkerMap = /* @__PURE__ */ new Map([
-  [Symbol(), getEmptyScope(void 0)]
+  [Symbol(), getEmptyBranch(void 0)]
 ]);
 var emptyMarkerArray = [
-  /* @__PURE__ */ getEmptyScope(void 0)
+  /* @__PURE__ */ getEmptyBranch(void 0)
 ];
 var emptyMap = /* @__PURE__ */ new Map();
 var emptyArray = [];
@@ -1594,7 +1600,7 @@ function loop(nodeAccessor, renderer, forEach) {
       if (referenceIsMarker) {
         newMap = emptyMarkerMap;
         newArray = emptyMarkerArray;
-        getEmptyScope(referenceNode);
+        getEmptyBranch(referenceNode);
       } else {
         oldArray.forEach(destroyBranch);
         referenceNode.textContent = "";
@@ -1606,7 +1612,7 @@ function loop(nodeAccessor, renderer, forEach) {
     if (needsReconciliation) {
       if (referenceIsMarker) {
         if (oldMap === emptyMarkerMap) {
-          getEmptyScope(referenceNode);
+          getEmptyBranch(referenceNode);
         }
         const oldLastChild = oldArray[oldArray.length - 1];
         afterReference = oldLastChild.___endNode.nextSibling;
@@ -1745,8 +1751,8 @@ function conditionalClosure(ownerConditionalNodeAccessor, getRenderer, fn, getIn
   return helperSignal;
 }
 var defaultGetOwnerScope = (scope) => scope._;
-function dynamicClosure(ownerValueAccessor, fn, getOwnerScope = defaultGetOwnerScope, getIntersection) {
-  const ownerSubscribersAccessor = ownerValueAccessor + "*" /* Subscribers */;
+function dynamicClosure(fn, getOwnerScope = defaultGetOwnerScope, getIntersection) {
+  const ownerSubscribersAccessor = "?" /* Dynamic */ + accessorId++;
   const _signal = closure(fn, getIntersection);
   const helperSignal = (ownerScope, value2) => {
     const subscribers = ownerScope[ownerSubscribersAccessor];
@@ -1806,7 +1812,7 @@ function effect(id, fn) {
 }
 
 // src/dom/queue.ts
-var pendingRender;
+var pendingRenders = [];
 var pendingEffects = [];
 var rendering = false;
 function queueSource(scope, signal, value2) {
@@ -1819,30 +1825,22 @@ function queueSource(scope, signal, value2) {
   return value2;
 }
 function queueRender(scope, signal, value2) {
-  const nextRender = {
+  let i = pendingRenders.length;
+  const render = {
     ___scope: scope,
     ___signal: signal,
     ___value: value2,
-    ___next: void 0
+    ___index: i
   };
-  if (!pendingRender) {
-    pendingRender = nextRender;
-  } else if (comparePendingRenders(pendingRender, nextRender) < 0) {
-    if (rendering) {
-      throw new Error(
-        "attempted to queue a render before the currently executing render"
-      );
-    }
-    nextRender.___next = pendingRender;
-    pendingRender = nextRender;
-  } else {
-    let curRender = pendingRender;
-    while (curRender.___next && comparePendingRenders(curRender.___next, nextRender) >= 0) {
-      curRender = curRender.___next;
-    }
-    nextRender.___next = curRender.___next;
-    curRender.___next = nextRender;
+  pendingRenders.push(render);
+  while (i) {
+    const parentIndex = i - 1 >> 1;
+    const parent = pendingRenders[parentIndex];
+    if (comparePendingRenders(render, parent) >= 0) break;
+    pendingRenders[i] = parent;
+    i = parentIndex;
   }
+  pendingRenders[i] = render;
 }
 function queueEffect(scope, fn) {
   pendingEffects.push(scope, fn);
@@ -1853,24 +1851,24 @@ function run() {
     rendering = true;
     runRenders();
   } finally {
-    pendingRender = void 0;
+    pendingRenders = [];
+    pendingEffects = [];
     rendering = false;
   }
-  pendingEffects = [];
   runEffects(effects);
 }
 function prepareEffects(fn) {
-  const prevRender = pendingRender;
+  const prevRenders = pendingRenders;
   const prevEffects = pendingEffects;
   const preparedEffects = pendingEffects = [];
-  pendingRender = void 0;
+  pendingRenders = [];
   try {
     rendering = true;
     fn();
     runRenders();
   } finally {
     rendering = false;
-    pendingRender = prevRender;
+    pendingRenders = prevRenders;
     pendingEffects = prevEffects;
   }
   return preparedEffects;
@@ -1883,22 +1881,42 @@ function runEffects(effects = pendingEffects) {
   }
 }
 function runRenders() {
-  while (pendingRender) {
-    if (!pendingRender.___scope.___closestBranch?.___destroyed) {
-      pendingRender.___signal(pendingRender.___scope, pendingRender.___value);
+  while (pendingRenders.length) {
+    const render = pendingRenders[0];
+    const next = pendingRenders.pop();
+    if (render !== next) {
+      let i = 0;
+      const mid = pendingRenders.length >> 1;
+      const item = pendingRenders[0] = next;
+      while (i < mid) {
+        let bestChild = (i << 1) + 1;
+        const right = bestChild + 1;
+        if (right < pendingRenders.length && comparePendingRenders(
+          pendingRenders[right],
+          pendingRenders[bestChild]
+        ) < 0) {
+          bestChild = right;
+        }
+        if (comparePendingRenders(pendingRenders[bestChild], item) >= 0) {
+          break;
+        } else {
+          pendingRenders[i] = pendingRenders[bestChild];
+          i = bestChild;
+        }
+      }
+      pendingRenders[i] = item;
+    }
+    if (!render.___scope.___closestBranch?.___destroyed) {
+      render.___signal(render.___scope, render.___value);
     }
-    pendingRender = pendingRender.___next;
   }
   finishPendingScopes();
 }
 function comparePendingRenders(a, b) {
-  if (a.___scope.___pending || b.___scope.___pending) return 0;
-  const aStart = ownerStartNode(a.___scope);
-  const bStart = ownerStartNode(b.___scope);
-  return aStart === bStart ? 0 : aStart ? bStart ? aStart.compareDocumentPosition(bStart) & 2 ? -1 : 1 : -1 : 1;
+  return getBranchDepth(a) - getBranchDepth(b) || a.___index - b.___index;
 }
-function ownerStartNode(scope) {
-  return (scope.___closestBranch || scope).___startNode;
+function getBranchDepth(render) {
+  return render.___scope.___closestBranch?.___branchDepth || 0;
 }
 
 // src/dom/abort-signal.ts
@@ -1997,7 +2015,7 @@ var compat = {
       if (!scope) {
         scope = component.scope = createScope(out.global);
         scope._ = renderer.___owner;
-        initRenderer(renderer, scope);
+        initBranch(renderer, scope);
       } else {
         applyArgs(scope, MARK);
         existing = true;
@@ -2028,6 +2046,8 @@ var createTemplate = (templateId, ...rendererArgs) => {
 };
 function mount(input = {}, reference, position) {
   let branch, dom;
+  let parentNode = reference;
+  let nextSibling = null;
   let { $global } = input;
   if ($global) {
     ({ $global, ...input } = input);
@@ -2042,28 +2062,26 @@ function mount(input = {}, reference, position) {
       renderId: DEFAULT_RENDER_ID
     };
   }
-  const args = this.___args;
-  const effects = prepareEffects(() => {
-    branch = createScope($global);
-    dom = initRenderer(this, branch);
-    if (args) {
-      args(branch, [input]);
-    }
-  });
   switch (position) {
     case "beforebegin":
-      reference.parentNode.insertBefore(dom, reference);
+      parentNode = reference.parentNode;
+      nextSibling = reference;
       break;
     case "afterbegin":
-      reference.insertBefore(dom, reference.firstChild);
+      nextSibling = reference.firstChild;
       break;
     case "afterend":
-      reference.parentNode.insertBefore(dom, reference.nextSibling);
-      break;
-    default:
-      reference.appendChild(dom);
+      parentNode = reference.parentNode;
+      nextSibling = reference.nextSibling;
       break;
   }
+  const args = this.___args;
+  const effects = prepareEffects(() => {
+    branch = createScope($global);
+    dom = initBranch(this, branch);
+    args?.(branch, [input]);
+  });
+  parentNode.insertBefore(dom, nextSibling);
   runEffects(effects);
   return {
     update: (newInput) => {