marko 6.0.0-next.3.25 → 6.0.0-next.3.27

package/dist/debug/dom.mjs

@@ -87,62 +87,6 @@ function triggerMacroTask() {
   port2.postMessage(0);
 }
 
-// src/dom/scope.ts
-var pendingScopes = [];
-var debugID = 0;
-function createScope($global) {
-  const scope = {
-    ___pending: 1,
-    $global
-  };
-  if (true) {
-    scope.___debugId = "client-" + debugID++;
-  }
-  pendingScopes.push(scope);
-  return scope;
-}
-function finishPendingScopes() {
-  for (const scope of pendingScopes) {
-    scope.___pending = 0;
-  }
-  pendingScopes = [];
-}
-var emptyScope = createScope({});
-function getEmptyScope(marker) {
-  emptyScope.___startNode = emptyScope.___endNode = marker;
-  return emptyScope;
-}
-function destroyBranch(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();
-      }
-    }
-  }
-}
-function removeAndDestroyBranch(branch) {
-  destroyBranch(branch);
-  let current = branch.___startNode;
-  const stop = branch.___endNode.nextSibling;
-  while (current !== stop) {
-    const next = current.nextSibling;
-    current.remove();
-    current = next;
-  }
-}
-function insertBefore(scope, parent, nextSibling) {
-  let current = scope.___startNode;
-  const stop = scope.___endNode.nextSibling;
-  while (current !== stop) {
-    const next = current.nextSibling;
-    parent.insertBefore(current, nextSibling);
-    current = next;
-  }
-}
-
 // src/common/helpers.ts
 function classValue(value2) {
   return toDelimitedString(value2, " ", stringifyClassObject);
@@ -198,173 +142,6 @@ function normalizeDynamicRenderer(value2) {
   if (value2) return value2.content || value2.default || value2;
 }
 
-// src/dom/reconcile.ts
-var WRONG_POS = 2147483647;
-function reconcile(parent, oldBranches, newBranches, afterReference) {
-  let oldStart = 0;
-  let newStart = 0;
-  let oldEnd = oldBranches.length - 1;
-  let newEnd = newBranches.length - 1;
-  let oldStartBranch = oldBranches[oldStart];
-  let newStartBranch = newBranches[newStart];
-  let oldEndBranch = oldBranches[oldEnd];
-  let newEndBranch = newBranches[newEnd];
-  let i;
-  let j;
-  let k;
-  let nextSibling;
-  let oldBranch;
-  let newBranch;
-  outer: {
-    while (oldStartBranch === newStartBranch) {
-      ++oldStart;
-      ++newStart;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldStartBranch = oldBranches[oldStart];
-      newStartBranch = newBranches[newStart];
-    }
-    while (oldEndBranch === newEndBranch) {
-      --oldEnd;
-      --newEnd;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldEndBranch = oldBranches[oldEnd];
-      newEndBranch = newBranches[newEnd];
-    }
-  }
-  if (oldStart > oldEnd) {
-    if (newStart <= newEnd) {
-      k = newEnd + 1;
-      nextSibling = k < newBranches.length ? newBranches[k].___startNode : afterReference;
-      do {
-        insertBefore(newBranches[newStart++], parent, nextSibling);
-      } while (newStart <= newEnd);
-    }
-  } else if (newStart > newEnd) {
-    do {
-      removeAndDestroyBranch(oldBranches[oldStart++]);
-    } while (oldStart <= oldEnd);
-  } else {
-    const oldLength = oldEnd - oldStart + 1;
-    const newLength = newEnd - newStart + 1;
-    const aNullable = oldBranches;
-    const sources = new Array(newLength);
-    for (i = 0; i < newLength; ++i) {
-      sources[i] = -1;
-    }
-    let pos = 0;
-    let synced = 0;
-    const keyIndex = /* @__PURE__ */ new Map();
-    for (j = newStart; j <= newEnd; ++j) {
-      keyIndex.set(newBranches[j], j);
-    }
-    for (i = oldStart; i <= oldEnd && synced < newLength; ++i) {
-      oldBranch = oldBranches[i];
-      j = keyIndex.get(oldBranch);
-      if (j !== void 0) {
-        pos = pos > j ? WRONG_POS : j;
-        ++synced;
-        newBranch = newBranches[j];
-        sources[j - newStart] = i;
-        aNullable[i] = null;
-      }
-    }
-    if (oldLength === oldBranches.length && synced === 0) {
-      for (; newStart < newLength; ++newStart) {
-        insertBefore(newBranches[newStart], parent, afterReference);
-      }
-      for (; oldStart < oldLength; ++oldStart) {
-        removeAndDestroyBranch(oldBranches[oldStart]);
-      }
-    } else {
-      i = oldLength - synced;
-      while (i > 0) {
-        oldBranch = aNullable[oldStart++];
-        if (oldBranch !== null) {
-          removeAndDestroyBranch(oldBranch);
-          i--;
-        }
-      }
-      if (pos === WRONG_POS) {
-        const seq = longestIncreasingSubsequence(sources);
-        j = seq.length - 1;
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-            insertBefore(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);
-            } else {
-              --j;
-            }
-          }
-        }
-      } else if (synced !== newLength) {
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-            insertBefore(newBranch, parent, nextSibling);
-          }
-        }
-      }
-    }
-  }
-}
-function longestIncreasingSubsequence(a) {
-  const p = a.slice();
-  const result = [];
-  result.push(0);
-  let u;
-  let v;
-  for (let i = 0, il = a.length; i < il; ++i) {
-    if (a[i] === -1) {
-      continue;
-    }
-    const j = result[result.length - 1];
-    if (a[j] < a[i]) {
-      p[i] = j;
-      result.push(i);
-      continue;
-    }
-    u = 0;
-    v = result.length - 1;
-    while (u < v) {
-      const c = (u + v) / 2 | 0;
-      if (a[result[c]] < a[i]) {
-        u = c + 1;
-      } else {
-        v = c;
-      }
-    }
-    if (a[i] < a[result[u]]) {
-      if (u > 0) {
-        p[i] = result[u - 1];
-      }
-      result[u] = i;
-    }
-  }
-  u = result.length;
-  v = result[u - 1];
-  while (u-- > 0) {
-    result[u] = v;
-    v = p[v];
-  }
-  return result;
-}
-
 // src/dom/event.ts
 var elementHandlersByEvent = /* @__PURE__ */ new Map();
 var defaultDelegator = createDelegator();
@@ -393,7 +170,7 @@ function createDelegator() {
   };
 }
 function handleDelegated(ev) {
-  let target = ev.target;
+  let target = !rendering && ev.target;
   if (target) {
     const handlersByElement = elementHandlersByEvent.get(ev.type);
     handlersByElement.get(target)?.(ev, target);
@@ -466,15 +243,20 @@ var Render = class {
       const commentPrefix = data2.i;
       const commentPrefixLen = commentPrefix.length;
       const closestBranchMarkers = /* @__PURE__ */ new Map();
+      const visitNodes = new Set(visits);
+      let lastEndNode;
       data2.v = [];
-      const branchEnd = (branchId, visit, curNode) => {
+      const branchEnd = (branchId, visit, reference) => {
         const branch = scopeLookup[branchId] ||= {};
-        let endNode = curNode;
-        while ((endNode = endNode.previousSibling).nodeType === 8) ;
-        branch.___endNode = endNode;
+        let endNode = reference;
+        while (visitNodes.has(endNode = endNode.previousSibling)) ;
+        if (endNode === lastEndNode) {
+          endNode = reference.parentNode.insertBefore(new Text(), reference);
+        }
+        branch.___endNode = lastEndNode = endNode;
         branch.___startNode ||= endNode;
         for (const [markerScopeId, markerNode] of closestBranchMarkers) {
-          if (branch.___startNode.compareDocumentPosition(markerNode) & 4 && curNode.compareDocumentPosition(markerNode) & 2) {
+          if (branch.___startNode.compareDocumentPosition(markerNode) & 4 && reference.compareDocumentPosition(markerNode) & 2) {
             parentBranchIds.set(markerScopeId, branchId);
             closestBranchMarkers.delete(markerScopeId);
           }
@@ -565,6 +347,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;
@@ -919,7 +702,6 @@ function toValueProp(it) {
 }
 
 // src/dom/parse-html.ts
-var fallback = /* @__PURE__ */ new Text();
 var parser = /* @__PURE__ */ document.createElement("template");
 function parseHTML(html2) {
   parser.innerHTML = html2;
@@ -938,7 +720,7 @@ function parseHTMLOrSingleNode(html2) {
     fragment.appendChild(content);
     return fragment;
   }
-  return fallback;
+  return new Text();
 }
 
 // src/dom/dom.ts
@@ -1112,21 +894,17 @@ function attrsEvents(scope, nodeAccessor) {
     on(el, name, events[name]);
   }
 }
-function html(scope, value2, index) {
-  const firstChild = scope[index];
-  const lastChild = scope[index + "-"] || firstChild;
-  const parentNode = firstChild.parentNode;
-  const afterReference = lastChild.nextSibling;
-  const newContent = parseHTML(value2 || value2 === 0 ? value2 + "" : "<!>");
-  scope[index] = newContent.firstChild;
-  scope[index + "-" /* DynamicPlaceholderLastChild */] = newContent.lastChild;
-  parentNode.insertBefore(newContent, firstChild);
-  let current = firstChild;
-  while (current !== afterReference) {
-    const next = current.nextSibling;
-    current.remove();
-    current = next;
-  }
+function html(scope, value2, accessor) {
+  const firstChild = scope[accessor];
+  const lastChild = scope[accessor + "-" /* DynamicPlaceholderLastChild */] || firstChild;
+  const newContent = parseHTML(
+    value2 || value2 === 0 ? value2 + "" : "<!>"
+    // TODO: is the comment needed
+  );
+  scope[accessor] = newContent.firstChild;
+  scope[accessor + "-" /* DynamicPlaceholderLastChild */] = newContent.lastChild;
+  firstChild.parentNode.insertBefore(newContent, firstChild);
+  removeChildNodes(firstChild, lastChild);
 }
 function props(scope, nodeIndex, index) {
   const nextProps = scope[index];
@@ -1166,6 +944,234 @@ function lifecycle(scope, index, thisObj) {
     ).onabort = () => thisObj.onDestroy?.();
   }
 }
+function removeChildNodes(startNode, endNode) {
+  const stop = endNode.nextSibling;
+  let current = startNode;
+  while (current !== stop) {
+    const next = current.nextSibling;
+    current.remove();
+    current = next;
+  }
+}
+
+// src/dom/scope.ts
+var pendingScopes = [];
+var debugID = 0;
+function createScope($global) {
+  const scope = {
+    ___pending: 1,
+    $global
+  };
+  if (true) {
+    scope.___debugId = "client-" + debugID++;
+  }
+  pendingScopes.push(scope);
+  return scope;
+}
+function finishPendingScopes() {
+  for (const scope of pendingScopes) {
+    scope.___pending = 0;
+  }
+  pendingScopes = [];
+}
+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(destroyNestedBranches);
+  branch.___abortScopes?.forEach((scope) => {
+    for (const id in scope.___abortControllers) {
+      scope.___abortControllers[id]?.abort();
+    }
+  });
+}
+function removeAndDestroyBranch(branch) {
+  destroyBranch(branch);
+  removeChildNodes(branch.___startNode, branch.___endNode);
+}
+function insertBranchBefore(branch, parentNode, nextSibling) {
+  let current = branch.___startNode;
+  const stop = branch.___endNode.nextSibling;
+  while (current !== stop) {
+    const next = current.nextSibling;
+    parentNode.insertBefore(current, nextSibling);
+    current = next;
+  }
+}
+
+// src/dom/reconcile.ts
+var WRONG_POS = 2147483647;
+function reconcile(parent, oldBranches, newBranches, afterReference) {
+  let oldStart = 0;
+  let newStart = 0;
+  let oldEnd = oldBranches.length - 1;
+  let newEnd = newBranches.length - 1;
+  let oldStartBranch = oldBranches[oldStart];
+  let newStartBranch = newBranches[newStart];
+  let oldEndBranch = oldBranches[oldEnd];
+  let newEndBranch = newBranches[newEnd];
+  let i;
+  let j;
+  let k;
+  let nextSibling;
+  let oldBranch;
+  let newBranch;
+  outer: {
+    while (oldStartBranch === newStartBranch) {
+      ++oldStart;
+      ++newStart;
+      if (oldStart > oldEnd || newStart > newEnd) {
+        break outer;
+      }
+      oldStartBranch = oldBranches[oldStart];
+      newStartBranch = newBranches[newStart];
+    }
+    while (oldEndBranch === newEndBranch) {
+      --oldEnd;
+      --newEnd;
+      if (oldStart > oldEnd || newStart > newEnd) {
+        break outer;
+      }
+      oldEndBranch = oldBranches[oldEnd];
+      newEndBranch = newBranches[newEnd];
+    }
+  }
+  if (oldStart > oldEnd) {
+    if (newStart <= newEnd) {
+      k = newEnd + 1;
+      nextSibling = k < newBranches.length ? newBranches[k].___startNode : afterReference;
+      do {
+        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
+      } while (newStart <= newEnd);
+    }
+  } else if (newStart > newEnd) {
+    do {
+      removeAndDestroyBranch(oldBranches[oldStart++]);
+    } while (oldStart <= oldEnd);
+  } else {
+    const oldLength = oldEnd - oldStart + 1;
+    const newLength = newEnd - newStart + 1;
+    const aNullable = oldBranches;
+    const sources = new Array(newLength);
+    for (i = 0; i < newLength; ++i) {
+      sources[i] = -1;
+    }
+    let pos = 0;
+    let synced = 0;
+    const keyIndex = /* @__PURE__ */ new Map();
+    for (j = newStart; j <= newEnd; ++j) {
+      keyIndex.set(newBranches[j], j);
+    }
+    for (i = oldStart; i <= oldEnd && synced < newLength; ++i) {
+      oldBranch = oldBranches[i];
+      j = keyIndex.get(oldBranch);
+      if (j !== void 0) {
+        pos = pos > j ? WRONG_POS : j;
+        ++synced;
+        newBranch = newBranches[j];
+        sources[j - newStart] = i;
+        aNullable[i] = null;
+      }
+    }
+    if (oldLength === oldBranches.length && synced === 0) {
+      for (; newStart < newLength; ++newStart) {
+        insertBranchBefore(newBranches[newStart], parent, afterReference);
+      }
+      for (; oldStart < oldLength; ++oldStart) {
+        removeAndDestroyBranch(oldBranches[oldStart]);
+      }
+    } else {
+      i = oldLength - synced;
+      while (i > 0) {
+        oldBranch = aNullable[oldStart++];
+        if (oldBranch !== null) {
+          removeAndDestroyBranch(oldBranch);
+          i--;
+        }
+      }
+      if (pos === WRONG_POS) {
+        const seq = longestIncreasingSubsequence(sources);
+        j = seq.length - 1;
+        k = newBranches.length;
+        for (i = newLength - 1; i >= 0; --i) {
+          if (sources[i] === -1) {
+            pos = i + newStart;
+            newBranch = newBranches[pos++];
+            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
+            insertBranchBefore(newBranch, parent, nextSibling);
+          } else {
+            if (j < 0 || i !== seq[j]) {
+              pos = i + newStart;
+              newBranch = newBranches[pos++];
+              nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
+              insertBranchBefore(newBranch, parent, nextSibling);
+            } else {
+              --j;
+            }
+          }
+        }
+      } else if (synced !== newLength) {
+        k = newBranches.length;
+        for (i = newLength - 1; i >= 0; --i) {
+          if (sources[i] === -1) {
+            pos = i + newStart;
+            newBranch = newBranches[pos++];
+            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
+            insertBranchBefore(newBranch, parent, nextSibling);
+          }
+        }
+      }
+    }
+  }
+}
+function longestIncreasingSubsequence(a) {
+  const p = a.slice();
+  const result = [];
+  result.push(0);
+  let u;
+  let v;
+  for (let i = 0, il = a.length; i < il; ++i) {
+    if (a[i] === -1) {
+      continue;
+    }
+    const j = result[result.length - 1];
+    if (a[j] < a[i]) {
+      p[i] = j;
+      result.push(i);
+      continue;
+    }
+    u = 0;
+    v = result.length - 1;
+    while (u < v) {
+      const c = (u + v) / 2 | 0;
+      if (a[result[c]] < a[i]) {
+        u = c + 1;
+      } else {
+        v = c;
+      }
+    }
+    if (a[i] < a[result[u]]) {
+      if (u > 0) {
+        p[i] = result[u - 1];
+      }
+      result[u] = i;
+    }
+  }
+  u = result.length;
+  v = result[u - 1];
+  while (u-- > 0) {
+    result[u] = v;
+    v = p[v];
+  }
+  return result;
+}
 
 // src/dom/walker.ts
 var walker = /* @__PURE__ */ document.createTreeWalker(document);
@@ -1174,9 +1180,9 @@ function trimWalkString(walkString) {
   while (walkString.charCodeAt(--end) > 47 /* BeginChild */) ;
   return walkString.slice(0, end + 1);
 }
-function walk(startNode, walkCodes, scope) {
+function walk(startNode, walkCodes, branch) {
   walker.currentNode = startNode;
-  walkInternal(walkCodes, scope, 0);
+  walkInternal(walkCodes, branch, 0);
   walker.currentNode = document;
 }
 function walkInternal(walkCodes, scope, currentWalkIndex) {
@@ -1207,7 +1213,6 @@ function walkInternal(walkCodes, scope, currentWalkIndex) {
       }
     } else if (value2 === 47 /* BeginChild */) {
       const childScope = scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : currentScopeIndex++] = createScope(scope.$global);
-      childScope.___startNode = walker.currentNode;
       childScope.___closestBranch = scope.___closestBranch;
       currentWalkIndex = walkInternal(walkCodes, childScope, currentWalkIndex);
     } else if (value2 === 38 /* EndChild */) {
@@ -1250,7 +1255,7 @@ function createBranchScopeWithRenderer(renderer, $global, parentScope) {
   if (true) {
     branch.___renderer = renderer;
   }
-  initRenderer(renderer, branch);
+  initBranch(renderer, branch);
   return branch;
 }
 function createBranchScopeWithTagNameOrRenderer(tagNameOrRenderer, $global, parentScope) {
@@ -1271,22 +1276,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;
 }
@@ -1367,6 +1375,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;
@@ -1378,16 +1387,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]),
-    prevBranch.___startNode.parentNode,
-    prevBranch.___startNode
+  const prevBranch = scope[nodeAccessor + "!" /* ConditionalScope */] || getEmptyBranch(scope[nodeAccessor]);
+  const newBranch = newRenderer ? createBranchScopeWithTagNameOrRenderer(newRenderer, scope.$global, scope) : getEmptyBranch(scope[nodeAccessor]);
+  insertBranchBefore(
+    newBranch,
+    prevBranch.___endNode.parentNode,
+    prevBranch.___endNode.nextSibling
   );
   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 */;
@@ -1420,16 +1428,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 = [];
@@ -1507,7 +1515,7 @@ function loop(nodeAccessor, renderer, forEach) {
       if (referenceIsMarker) {
         newMap = emptyMarkerMap;
         newArray = emptyMarkerArray;
-        getEmptyScope(referenceNode);
+        getEmptyBranch(referenceNode);
       } else {
         oldArray.forEach(destroyBranch);
         referenceNode.textContent = "";
@@ -1519,7 +1527,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;
@@ -1658,8 +1666,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];
@@ -1719,7 +1727,7 @@ function effect(id, fn) {
 }
 
 // src/dom/queue.ts
-var pendingRender;
+var pendingRenders = [];
 var pendingEffects = [];
 var rendering = false;
 function queueSource(scope, signal, value2) {
@@ -1732,30 +1740,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);
@@ -1766,24 +1766,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;
@@ -1796,22 +1796,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
@@ -1838,13 +1858,13 @@ var RENDERER_REGISTER_ID = prefix + (true ? "renderer" : "r");
 var SET_SCOPE_REGISTER_ID = prefix + (true ? "setScope" : "s");
 
 // src/dom/compat.ts
-var classIdToScope = /* @__PURE__ */ new Map();
+var classIdToBranch = /* @__PURE__ */ new Map();
 var compat = {
   patchConditionals,
   queueEffect,
   init() {
-    register(SET_SCOPE_REGISTER_ID, (scope) => {
-      classIdToScope.set(scope.m5c, scope);
+    register(SET_SCOPE_REGISTER_ID, (branch) => {
+      classIdToBranch.set(branch.m5c, branch);
     });
   },
   registerRenderer(fn) {
@@ -1856,12 +1876,12 @@ var compat = {
   isRenderer(renderer) {
     return renderer.___clone !== void 0;
   },
-  getStartNode(scope) {
-    return scope.___startNode;
+  getStartNode(branch) {
+    return branch.___startNode;
   },
-  setScopeNodes(scope, startNode, endNode) {
-    scope.___startNode = startNode;
-    scope.___endNode = endNode;
+  setScopeNodes(branch, startNode, endNode) {
+    branch.___startNode = startNode;
+    branch.___endNode = endNode;
   },
   runComponentEffects() {
     runEffects(this.effects);
@@ -1889,12 +1909,12 @@ var compat = {
     return renderer;
   },
   render(out, component, renderer, args) {
-    let scope = component.scope;
-    if (!scope) {
-      scope = classIdToScope.get(component.id);
-      if (scope) {
-        component.scope = scope;
-        classIdToScope.delete(component.id);
+    let branch = component.scope;
+    if (!branch) {
+      branch = classIdToBranch.get(component.id);
+      if (branch) {
+        component.scope = branch;
+        classIdToBranch.delete(component.id);
       }
     }
     const applyArgs = renderer.___args || noop;
@@ -1907,18 +1927,18 @@ var compat = {
       }
     }
     component.effects = prepareEffects(() => {
-      if (!scope) {
-        scope = component.scope = createScope(out.global);
-        scope._ = renderer.___owner;
-        initRenderer(renderer, scope);
+      if (!branch) {
+        branch = component.scope = createScope(out.global);
+        branch._ = renderer.___owner;
+        initBranch(renderer, branch);
       } else {
-        applyArgs(scope, MARK);
+        applyArgs(branch, MARK);
         existing = true;
       }
-      applyArgs(scope, args);
+      applyArgs(branch, args);
     });
     if (!existing) {
-      return scope.___startNode === scope.___endNode ? scope.___startNode : scope.___startNode.parentNode;
+      return branch.___startNode === branch.___endNode ? branch.___startNode : branch.___startNode.parentNode;
     }
   }
 };
@@ -1941,6 +1961,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);
@@ -1955,28 +1977,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) => {