marko 6.0.0-next.3.63 → 6.0.0-next.3.65

package/dist/dom.js

@@ -211,48 +211,42 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
   let renders = window[runtimeId], defineRuntime = (desc) => Object.defineProperty(window, runtimeId, desc), resumeRender, initRuntime = (renders2) => {
     defineRuntime({
       value: resumeRender = (renderId) => {
-        let render = resumeRender[renderId] = renders2[renderId] || renders2(renderId), walk2 = render.w, commentPrefixLen = render.i.length, scopeStack = [], scopeLookup = render.s = {}, serializeContext = {
+        let render = resumeRender[renderId] = renders2[renderId] || renders2(renderId), walk2 = render.w, commentPrefixLen = render.i.length, branchStack = [], scopeLookup = render.s = {}, serializeContext = {
           _: registeredValues
-        }, branchIds = /* @__PURE__ */ new Set(), parentBranchIds = /* @__PURE__ */ new Map(), closestBranchMarkers = /* @__PURE__ */ new Map(), currentScopeId;
+        }, branchIds = /* @__PURE__ */ new Set(), parentBranchIds = /* @__PURE__ */ new Map(), currentBranchId;
         return render.w = () => {
           walk2.call(render);
           let visits = render.v, resumes = render.r;
           if (visits.length) {
             let visitNodes = new Set(visits), lastEndNode;
-            render.v = [];
-            let branchEnd = (branchId, visit, reference) => {
+            visits.length = 0;
+            let branchEnd = (branchId, reference) => {
               let branch = scopeLookup[branchId] ||= {}, endNode = reference;
               for (; visitNodes.has(endNode = endNode.previousSibling); ) ;
-              endNode === lastEndNode && (endNode = reference.parentNode.insertBefore(
+              return endNode === lastEndNode && (endNode = reference.parentNode.insertBefore(
                 new Text(),
                 reference
-              )), branch.h = lastEndNode = endNode, branch.g ||= endNode;
-              for (let [markerScopeId, markerNode] of closestBranchMarkers)
-                branch.g.compareDocumentPosition(markerNode) & 4 && reference.compareDocumentPosition(markerNode) & 2 && (parentBranchIds.set(markerScopeId, branchId), closestBranchMarkers.delete(markerScopeId));
-              return branchIds.add(branchId), closestBranchMarkers.set(branchId, visit), branch;
+              )), branch.j = lastEndNode = endNode, branch.h ||= endNode, branchIds.add(branchId), branch;
             };
-            for (let visit of visits) {
+            for (let visit of visitNodes) {
               let commentText = visit.data, dataIndex = commentText.indexOf(" ") + 1, scopeId = commentText.slice(
                 commentPrefixLen + 1,
                 dataIndex ? dataIndex - 1 : commentText.length
               ), scope = scopeLookup[scopeId] ||= {
-                l: +scopeId
+                m: +scopeId
               }, data2 = dataIndex ? commentText.slice(dataIndex) : "", token = commentText[commentPrefixLen];
               if (token === "*" /* Node */) {
                 let node = scope[data2] = visit.previousSibling;
                 scope["j" /* Getter */ + data2] = () => node;
-              } else if (token === "$" /* ClosestBranch */)
-                closestBranchMarkers.set(scopeId, visit);
-              else if (token === "[" /* BranchStart */)
-                currentScopeId && (dataIndex && branchEnd(currentScopeId, visit, visit), scopeStack.push(currentScopeId)), currentScopeId = scopeId, scope.g = visit;
+              } else if (token === "[" /* BranchStart */)
+                currentBranchId && dataIndex && (branchEnd(currentBranchId, visit), currentBranchId = branchStack.pop()), currentBranchId && (branchStack.push(currentBranchId), parentBranchIds.set(scopeId, currentBranchId)), currentBranchId = scopeId, scope.h = visit;
               else if (token === "]" /* BranchEnd */) {
                 scope[data2] = visit;
                 let curParent = visit.parentNode, startNode = branchEnd(
-                  currentScopeId,
-                  visit,
+                  currentBranchId,
                   visit
-                ).g;
-                curParent !== startNode.parentNode && curParent.prepend(startNode), currentScopeId = scopeStack.pop();
+                ).h;
+                curParent !== startNode.parentNode && curParent.prepend(startNode), currentBranchId = branchStack.pop();
               } else if (token === "|" /* BranchSingleNode */ || token === "=" /* BranchSingleNodeOnlyChildInParent */) {
                 let next = data2.indexOf(" "), curNode = visit;
                 for (scope[~next ? data2.slice(0, next) : data2] = token === "=" /* BranchSingleNodeOnlyChildInParent */ ? visit.parentNode : visit; ~next; ) {
@@ -262,7 +256,7 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                     start,
                     ~next ? next : data2.length
                   );
-                  curNode = branchEnd(childScopeId, visit, curNode).h;
+                  curNode = branchEnd(childScopeId, curNode).j, parentBranchIds.set(childScopeId, scopeId);
                 }
               }
             }
@@ -274,18 +268,18 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                 let serialized = resumes[i];
                 if (typeof serialized == "function") {
                   let scopes = serialized(serializeContext), { $global } = scopeLookup;
-                  $global || (scopeLookup.$global = $global = scopes.$ || {}, $global.runtimeId = runtimeId, $global.renderId = renderId, $global.m = 1e6);
+                  $global || (scopeLookup.$global = $global = scopes.$ || {}, $global.runtimeId = runtimeId, $global.renderId = renderId, $global.n = 1e6);
                   for (let scopeId in scopes)
                     if (scopeId !== "$") {
                       let scope = scopes[scopeId], prevScope = scopeLookup[scopeId];
-                      scope.$global = $global, scope.l = +scopeId, prevScope !== scope && (scopeLookup[scopeId] = Object.assign(
+                      scope.$global = $global, scope.m = +scopeId, prevScope !== scope && (scopeLookup[scopeId] = Object.assign(
                         scope,
                         prevScope
                       ));
-                      let parentBranchId = parentBranchIds.get(scopeId);
-                      if (parentBranchId && (scope.j = scopes[parentBranchId]), branchIds.has(scopeId)) {
-                        let branch = scope, parentBranch = branch.j;
-                        scope.j = branch, parentBranch && (branch.n = parentBranch, (parentBranch.z ||= /* @__PURE__ */ new Set()).add(
+                      let parentBranchId = scope.g || parentBranchIds.get(scopeId);
+                      if (parentBranchId && (scope.k = scopes[parentBranchId]), branchIds.has(scopeId)) {
+                        let branch = scope, parentBranch = branch.k;
+                        scope.k = branch, parentBranch && (branch.u = parentBranch, (parentBranch.A ||= /* @__PURE__ */ new Set()).add(
                           branch
                         ));
                       }
@@ -718,47 +712,53 @@ function toInsertNode(startNode, endNode) {
 var pendingScopes = [];
 function createScope($global, closestBranch) {
   let scope = {
-    l: $global.m++,
+    m: $global.n++,
     o: 1,
-    j: closestBranch,
+    k: closestBranch,
     $global
   };
   return pendingScopes.push(scope), scope;
 }
 function skipScope(scope) {
-  return scope.$global.m++;
+  return scope.$global.n++;
 }
 function finishPendingScopes() {
   for (let scope of pendingScopes)
     scope.o = 0;
   pendingScopes = [];
 }
+function findBranchWithKey(scope, key) {
+  let branch = scope.k;
+  for (; branch && !branch[key]; )
+    branch = branch.u;
+  return branch;
+}
 function destroyBranch(branch) {
-  branch.n?.z?.delete(branch), destroyNestedBranches(branch);
+  branch.u?.A?.delete(branch), destroyNestedBranches(branch);
 }
 function destroyNestedBranches(branch) {
-  branch.q = 1, branch.z?.forEach(destroyNestedBranches), branch.H?.forEach((scope) => {
-    for (let id in scope.t)
-      scope.t[id]?.abort();
+  branch.p = 1, branch.A?.forEach(destroyNestedBranches), branch.J?.forEach((scope) => {
+    for (let id in scope.x)
+      scope.x[id]?.abort();
   });
 }
 function removeAndDestroyBranch(branch) {
-  destroyBranch(branch), removeChildNodes(branch.g, branch.h);
+  destroyBranch(branch), removeChildNodes(branch.h, branch.j);
 }
 function insertBranchBefore(branch, parentNode, nextSibling) {
   insertChildNodes(
     parentNode,
     nextSibling,
-    branch.g,
-    branch.h
+    branch.h,
+    branch.j
   );
 }
 function tempDetatchBranch(branch) {
   insertChildNodes(
     new DocumentFragment(),
     null,
-    branch.g,
-    branch.h
+    branch.h,
+    branch.j
   );
 }
 
@@ -780,7 +780,7 @@ function reconcile(parent, oldBranches, newBranches, afterReference) {
   }
   if (oldStart > oldEnd) {
     if (newStart <= newEnd) {
-      k = newEnd + 1, nextSibling = k < newBranches.length ? newBranches[k].g : afterReference;
+      k = newEnd + 1, nextSibling = k < newBranches.length ? newBranches[k].h : afterReference;
       do
         insertBranchBefore(newBranches[newStart++], parent, nextSibling);
       while (newStart <= newEnd);
@@ -809,10 +809,10 @@ function reconcile(parent, oldBranches, newBranches, afterReference) {
       if (pos === WRONG_POS) {
         let seq = longestIncreasingSubsequence(sources);
         for (j = seq.length - 1, k = newBranches.length, i = newLength - 1; i >= 0; --i)
-          sources[i] === -1 ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].g : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : j < 0 || i !== seq[j] ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].g : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : --j;
+          sources[i] === -1 ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].h : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : j < 0 || i !== seq[j] ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].h : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : --j;
       } else if (synced !== newLength)
         for (k = newBranches.length, i = newLength - 1; i >= 0; --i)
-          sources[i] === -1 && (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].g : afterReference, insertBranchBefore(newBranch, parent, nextSibling));
+          sources[i] === -1 && (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].h : afterReference, insertBranchBefore(newBranch, parent, nextSibling));
     }
   }
 }
@@ -859,7 +859,7 @@ function walkInternal(currentWalkIndex, walkCodes, scope) {
         currentWalkIndex = walkInternal(
           currentWalkIndex,
           walkCodes,
-          scope[currentScopeIndex++] = createScope(scope.$global, scope.j)
+          scope[currentScopeIndex++] = createScope(scope.$global, scope.k)
         ), value2 === 48 /* BeginChildWithVar */ && (scope[currentScopeIndex++] = skipScope(scope));
       else if (value2 < 92)
         for (value2 = 20 /* Next */ * currentMultiplier + value2 - 67 /* Next */; value2--; )
@@ -878,8 +878,8 @@ function walkInternal(currentWalkIndex, walkCodes, scope) {
 
 // src/dom/renderer.ts
 function createBranch($global, renderer, parentScope, parentNode) {
-  let branch = createScope($global), parentBranch = parentScope?.j;
-  return branch._ = renderer.u || parentScope, branch.j = branch, parentBranch && (branch.n = parentBranch, (parentBranch.z ||= /* @__PURE__ */ new Set()).add(branch)), renderer.A?.(
+  let branch = createScope($global), parentBranch = parentScope?.k;
+  return branch._ = renderer.y || parentScope, branch.k = branch, parentBranch && (branch.u = parentBranch, (parentBranch.A ||= /* @__PURE__ */ new Set()).add(branch)), renderer.B?.(
     branch,
     parentNode.namespaceURI
   ), branch;
@@ -891,10 +891,10 @@ function createAndSetupBranch($global, renderer, parentScope, parentNode) {
   );
 }
 function setupBranch(renderer, branch) {
-  return (renderer.B || renderer.D) && queueRender(
+  return (renderer.C || renderer.E) && queueRender(
     branch,
     (branch2) => {
-      renderer.B?.(branch2), renderer.D?.(branch2);
+      renderer.C?.(branch2), renderer.E?.(branch2);
     },
     -1
   ), branch;
@@ -908,19 +908,19 @@ function createContent(id, template, walks, setup, params, closures, dynamicScop
     ))(branch, walks);
   } : (branch) => {
     walk(
-      branch.g = branch.h = new Text(),
+      branch.h = branch.j = new Text(),
       walks,
       branch
     );
   };
   return (owner) => ({
-    l: id,
-    A: clone,
-    u: owner,
-    B: setup,
-    k: params,
-    D: closures,
-    x: dynamicScopesAccessor
+    m: id,
+    B: clone,
+    y: owner,
+    C: setup,
+    l: params,
+    E: closures,
+    z: dynamicScopesAccessor
   });
 }
 function registerContent(id, template, walks, setup, params, closures, dynamicScopesAccessor) {
@@ -945,13 +945,13 @@ function createCloneableHTML(html2, ns) {
   let { firstChild, lastChild } = parseHTML(html2, ns), parent = document.createElementNS(ns, "t");
   return insertChildNodes(parent, null, firstChild, lastChild), firstChild === lastChild && firstChild.nodeType < 8 /* Comment */ ? (branch, walks) => {
     walk(
-      branch.g = branch.h = firstChild.cloneNode(!0),
+      branch.h = branch.j = firstChild.cloneNode(!0),
       walks,
       branch
     );
   } : (branch, walks) => {
     let clone = parent.cloneNode(!0);
-    walk(clone.firstChild, walks, branch), branch.g = clone.firstChild, branch.h = clone.lastChild;
+    walk(clone.firstChild, walks, branch), branch.h = clone.firstChild, branch.j = clone.lastChild;
   };
 }
 
@@ -992,7 +992,7 @@ function value(valueAccessor, fn = () => {
     (!(valueAccessor in scope) || scope[valueAccessor] !== value2) && (scope[valueAccessor] = value2, fn(scope, value2));
   };
 }
-function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "l") {
+function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "m") {
   return (scope) => {
     scope.o ? scope[id] === void 0 ? scope[id] = defaultPending : --scope[id] || fn(scope) : queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
   };
@@ -1004,11 +1004,11 @@ function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
       ownerScope,
       () => {
         for (let scope of scopes)
-          !scope.o && !scope.q && childSignal(scope);
+          !scope.o && !scope.p && childSignal(scope);
       },
       -1,
       0,
-      firstScope.l
+      firstScope.m
     );
   };
   return ownerSignal._ = childSignal, ownerSignal;
@@ -1028,9 +1028,9 @@ function subscribeToScopeSet(ownerScope, accessor, scope) {
   ));
 }
 function dynamicClosure(...closureSignals) {
-  let [{ E: ___scopeInstancesAccessor, F: ___signalIndexAccessor }] = closureSignals;
+  let [{ F: ___scopeInstancesAccessor, G: ___signalIndexAccessor }] = closureSignals;
   for (let i = closureSignals.length; i--; )
-    closureSignals[i].I = i;
+    closureSignals[i].K = i;
   return (scope) => {
     if (scope[___scopeInstancesAccessor])
       for (let childScope of scope[___scopeInstancesAccessor])
@@ -1043,13 +1043,13 @@ function dynamicClosure(...closureSignals) {
 }
 function dynamicClosureRead(valueAccessor, fn, getOwnerScope) {
   let childSignal = closure(valueAccessor, fn, getOwnerScope), closureSignal = (scope) => {
-    scope[closureSignal.F] = closureSignal.I, childSignal(scope), subscribeToScopeSet(
+    scope[closureSignal.G] = closureSignal.K, childSignal(scope), subscribeToScopeSet(
       getOwnerScope ? getOwnerScope(scope) : scope._,
-      closureSignal.E,
+      closureSignal.F,
       scope
     );
   };
-  return closureSignal.E = "a" /* ClosureScopes */ + valueAccessor, closureSignal.F = "b" /* ClosureSignalIndex */ + valueAccessor, closureSignal;
+  return closureSignal.F = "a" /* ClosureScopes */ + valueAccessor, closureSignal.G = "b" /* ClosureSignalIndex */ + valueAccessor, closureSignal;
 }
 function closure(valueAccessor, fn, getOwnerScope) {
   return (scope) => {
@@ -1091,73 +1091,55 @@ function hoist(...path) {
 function awaitTag(nodeAccessor, renderer) {
   let promiseAccessor = "n" /* Promise */ + nodeAccessor, branchAccessor = "d" /* ConditionalScope */ + nodeAccessor;
   return (scope, promise) => {
-    let tryBranch = scope.j, awaitBranch = scope[branchAccessor], referenceNode = scope[nodeAccessor], namespaceNode = (awaitBranch?.g ?? referenceNode).parentNode;
-    for (; tryBranch && !tryBranch.d; )
-      tryBranch = tryBranch.n;
-    let thisPromise = scope[promiseAccessor] = promise.then((data2) => {
-      if (scope.j?.q || scope[promiseAccessor] !== thisPromise)
-        return;
-      scope[promiseAccessor] = void 0;
-      let effects = prepareEffects(() => {
-        (!awaitBranch || !tryBranch) && (insertBranchBefore(
-          awaitBranch ??= scope[branchAccessor] = createAndSetupBranch(
-            scope.$global,
-            renderer,
-            scope,
-            namespaceNode
-          ),
-          referenceNode.parentNode,
-          referenceNode
-        ), referenceNode.remove()), renderer.k?.(awaitBranch, [data2]);
-      });
-      if (tryBranch) {
-        if (!--tryBranch.y) {
-          let placeholderBranch = tryBranch.c;
-          placeholderBranch ? (insertBranchBefore(
-            tryBranch,
-            placeholderBranch.g.parentNode,
-            placeholderBranch.g
-          ), removeAndDestroyBranch(placeholderBranch)) : insertBranchBefore(
-            tryBranch,
+    let tryWithPlaceholder = findBranchWithKey(
+      scope,
+      "d" /* PlaceholderContent */
+    ), awaitBranch = scope[branchAccessor], referenceNode = scope[nodeAccessor], namespaceNode = (awaitBranch?.h ?? referenceNode).parentNode, thisPromise = scope[promiseAccessor] = promise.then((data2) => {
+      if (!(scope.k?.p || scope[promiseAccessor] !== thisPromise) && (scope[promiseAccessor] = void 0, runEffects(
+        prepareEffects(() => {
+          tryWithPlaceholder && placeholderShown.add(pendingEffects), (!awaitBranch || !tryWithPlaceholder) && (insertBranchBefore(
+            awaitBranch ??= scope[branchAccessor] = createAndSetupBranch(
+              scope.$global,
+              renderer,
+              scope,
+              namespaceNode
+            ),
             referenceNode.parentNode,
             referenceNode
-          );
-        }
-      } else
-        runEffects(effects);
+          ), referenceNode.remove()), renderer.l?.(awaitBranch, [data2]);
+        })
+      ), tryWithPlaceholder && !--tryWithPlaceholder.q)) {
+        let placeholderBranch = tryWithPlaceholder.c;
+        tryWithPlaceholder.c = void 0, placeholderBranch ? (insertBranchBefore(
+          tryWithPlaceholder,
+          placeholderBranch.h.parentNode,
+          placeholderBranch.h
+        ), removeAndDestroyBranch(placeholderBranch)) : insertBranchBefore(
+          tryWithPlaceholder,
+          referenceNode.parentNode,
+          referenceNode
+        ), tryWithPlaceholder.H && runEffects(tryWithPlaceholder.H, !0);
+      }
     }).catch((error) => {
-      let tryBranch2 = scope.j;
-      for (; tryBranch2 && !tryBranch2.b; )
-        tryBranch2 = tryBranch2.n;
-      tryBranch2 ? (setConditionalRenderer(
-        tryBranch2._,
-        tryBranch2.a,
-        tryBranch2.b,
-        createAndSetupBranch
-      ), tryBranch2.b.k?.(
-        tryBranch2._["d" /* ConditionalScope */ + tryBranch2.a],
-        [error]
-      )) : setTimeout(() => {
-        throw error;
-      });
+      renderCatch(scope, error, !0);
     });
-    tryBranch ? (tryBranch.y || (tryBranch.y = 0, requestAnimationFrame(() => {
-      if (tryBranch.y && !tryBranch.q) {
-        let placeholderBranch = tryBranch.c = createAndSetupBranch(
+    tryWithPlaceholder ? (placeholderShown.add(pendingEffects), tryWithPlaceholder.q || (tryWithPlaceholder.q = 0, requestAnimationFrame(() => {
+      if (tryWithPlaceholder.q && !tryWithPlaceholder.p) {
+        let placeholderBranch = tryWithPlaceholder.c = createAndSetupBranch(
           scope.$global,
-          tryBranch.d,
-          tryBranch._,
-          tryBranch.g.parentNode
+          tryWithPlaceholder.d,
+          tryWithPlaceholder._,
+          tryWithPlaceholder.h.parentNode
         );
         insertBranchBefore(
           placeholderBranch,
-          tryBranch.g.parentNode,
-          tryBranch.g
-        ), tempDetatchBranch(tryBranch);
+          tryWithPlaceholder.h.parentNode,
+          tryWithPlaceholder.h
+        ), tempDetatchBranch(tryWithPlaceholder);
       }
-    })), tryBranch.y++) : awaitBranch && (awaitBranch.g.parentNode.insertBefore(
+    })), tryWithPlaceholder.q++) : awaitBranch && (awaitBranch.h.parentNode.insertBefore(
       referenceNode,
-      awaitBranch.g
+      awaitBranch.h
     ), tempDetatchBranch(awaitBranch));
   };
 }
@@ -1176,6 +1158,26 @@ function createTry(nodeAccessor, tryContent) {
     ));
   };
 }
+function renderCatch(scope, error, async) {
+  let tryWithCatch = findBranchWithKey(scope, "b" /* CatchContent */);
+  if (tryWithCatch) {
+    let placeholderBranch = tryWithCatch.c;
+    placeholderBranch && (tryWithCatch._["d" /* ConditionalScope */ + tryWithCatch.a] = placeholderBranch, destroyBranch(tryWithCatch)), caughtError.add(pendingEffects), setConditionalRenderer(
+      tryWithCatch._,
+      tryWithCatch.a,
+      tryWithCatch.b,
+      createAndSetupBranch
+    ), tryWithCatch.b.l?.(
+      tryWithCatch._["d" /* ConditionalScope */ + tryWithCatch.a],
+      [error]
+    );
+  } else if (async)
+    setTimeout(() => {
+      throw error;
+    });
+  else
+    throw error;
+}
 function conditional(nodeAccessor, ...branches) {
   let branchAccessor = "c" /* ConditionalRenderer */ + nodeAccessor;
   return (scope, newBranch) => {
@@ -1194,7 +1196,7 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
   let childScopeAccessor = "d" /* ConditionalScope */ + nodeAccessor, rendererAccessor = "c" /* ConditionalRenderer */ + nodeAccessor;
   return (scope, newRenderer, getInput) => {
     let normalizedRenderer = normalizeDynamicRenderer(newRenderer);
-    if (scope[rendererAccessor] !== (scope[rendererAccessor] = normalizedRenderer?.l || normalizedRenderer) || getContent && !(normalizedRenderer || scope[childScopeAccessor]))
+    if (scope[rendererAccessor] !== (scope[rendererAccessor] = normalizedRenderer?.m || normalizedRenderer) || getContent && !(normalizedRenderer || scope[childScopeAccessor]))
       if (setConditionalRenderer(
         scope,
         nodeAccessor,
@@ -1208,15 +1210,15 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
             0,
             content,
             createAndSetupBranch
-          ), content.x && subscribeToScopeSet(
-            content.u,
-            content.x,
+          ), content.z && subscribeToScopeSet(
+            content.y,
+            content.z,
             scope[childScopeAccessor]["d" /* ConditionalScope */ + 0]
           );
         }
-      } else normalizedRenderer?.x && subscribeToScopeSet(
-        normalizedRenderer.u,
-        normalizedRenderer.x,
+      } else normalizedRenderer?.z && subscribeToScopeSet(
+        normalizedRenderer.y,
+        normalizedRenderer.z,
         scope[childScopeAccessor]
       );
     if (normalizedRenderer) {
@@ -1227,9 +1229,9 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
           0,
           (inputIsArgs ? args[0] : args) || {}
         );
-      else if (normalizedRenderer.k)
+      else if (normalizedRenderer.l)
         if (inputIsArgs)
-          normalizedRenderer.k(
+          normalizedRenderer.l(
             scope[childScopeAccessor],
             normalizedRenderer._ ? args[0] : args
           );
@@ -1238,7 +1240,7 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
             ...args,
             content: getContent(scope)
           } : args || {};
-          normalizedRenderer.k(
+          normalizedRenderer.l(
             scope[childScopeAccessor],
             normalizedRenderer._ ? inputWithContent : [inputWithContent]
           );
@@ -1247,8 +1249,8 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
   };
 };
 function setConditionalRenderer(scope, nodeAccessor, newRenderer, createBranch2) {
-  let referenceNode = scope[nodeAccessor], prevBranch = scope["d" /* ConditionalScope */ + nodeAccessor], parentNode = referenceNode.nodeType > 1 /* Element */ ? (prevBranch?.g || referenceNode).parentNode : referenceNode, newBranch = scope["d" /* ConditionalScope */ + nodeAccessor] = newRenderer && createBranch2(scope.$global, newRenderer, scope, parentNode);
-  referenceNode === parentNode ? (prevBranch && (destroyBranch(prevBranch), referenceNode.textContent = ""), newBranch && insertBranchBefore(newBranch, parentNode, null)) : prevBranch ? (newBranch ? insertBranchBefore(newBranch, parentNode, prevBranch.g) : parentNode.insertBefore(referenceNode, prevBranch.g), removeAndDestroyBranch(prevBranch)) : newBranch && (insertBranchBefore(newBranch, parentNode, referenceNode), referenceNode.remove());
+  let referenceNode = scope[nodeAccessor], prevBranch = scope["d" /* ConditionalScope */ + nodeAccessor], parentNode = referenceNode.nodeType > 1 /* Element */ ? (prevBranch?.h || referenceNode).parentNode : referenceNode, newBranch = scope["d" /* ConditionalScope */ + nodeAccessor] = newRenderer && createBranch2(scope.$global, newRenderer, scope, parentNode);
+  referenceNode === parentNode ? (prevBranch && (destroyBranch(prevBranch), referenceNode.textContent = ""), newBranch && insertBranchBefore(newBranch, parentNode, null)) : prevBranch ? (newBranch ? insertBranchBefore(newBranch, parentNode, prevBranch.h) : parentNode.insertBefore(referenceNode, prevBranch.h), removeAndDestroyBranch(prevBranch)) : newBranch && (insertBranchBefore(newBranch, parentNode, referenceNode), referenceNode.remove());
 }
 function loopOf(nodeAccessor, renderer) {
   return loop(
@@ -1277,17 +1279,17 @@ function loopTo(nodeAccessor, renderer) {
   );
 }
 function loop(nodeAccessor, renderer, forEach) {
-  let params = renderer.k;
+  let params = renderer.l;
   return (scope, value2) => {
     let referenceNode = scope[nodeAccessor], oldMap = scope["m" /* LoopScopeMap */ + nodeAccessor], oldArray = oldMap ? scope["l" /* LoopScopeArray */ + nodeAccessor] || [
       ...oldMap.values()
-    ] : [], parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldArray[0].g.parentNode : referenceNode, newMap = scope["m" /* LoopScopeMap */ + nodeAccessor] = /* @__PURE__ */ new Map(), newArray = scope["l" /* LoopScopeArray */ + nodeAccessor] = [];
+    ] : [], parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldArray[0].h.parentNode : referenceNode, newMap = scope["m" /* LoopScopeMap */ + nodeAccessor] = /* @__PURE__ */ new Map(), newArray = scope["l" /* LoopScopeArray */ + nodeAccessor] = [];
     forEach(value2, (key, args) => {
       let branch = oldMap?.get(key) || createAndSetupBranch(scope.$global, renderer, scope, parentNode);
       params?.(branch, args), newMap.set(key, branch), newArray.push(branch);
     });
     let afterReference = null;
-    referenceNode !== parentNode && (oldArray.length ? (afterReference = oldArray[oldArray.length - 1].h.nextSibling, newArray.length || parentNode.insertBefore(referenceNode, afterReference)) : newArray.length && (afterReference = referenceNode.nextSibling, referenceNode.remove())), reconcile(parentNode, oldArray, newArray, afterReference);
+    referenceNode !== parentNode && (oldArray.length ? (afterReference = oldArray[oldArray.length - 1].j.nextSibling, newArray.length || parentNode.insertBefore(referenceNode, afterReference)) : newArray.length && (afterReference = referenceNode.nextSibling, referenceNode.remove())), reconcile(parentNode, oldArray, newArray, afterReference);
   };
 }
 function createBranchWithTagNameOrRenderer($global, tagNameOrRenderer, parentScope, parentNode) {
@@ -1297,7 +1299,7 @@ function createBranchWithTagNameOrRenderer($global, tagNameOrRenderer, parentSco
     parentScope,
     parentNode
   );
-  return typeof tagNameOrRenderer == "string" ? branch[0] = branch.g = branch.h = document.createElementNS(
+  return typeof tagNameOrRenderer == "string" ? branch[0] = branch.h = branch.j = document.createElementNS(
     tagNameOrRenderer === "svg" ? "http://www.w3.org/2000/svg" : tagNameOrRenderer === "math" ? "http://www.w3.org/1998/Math/MathML" : parentNode.namespaceURI,
     tagNameOrRenderer
   ) : setupBranch(tagNameOrRenderer, branch), branch;
@@ -1310,21 +1312,21 @@ function byFirstArg(name) {
 }
 
 // src/dom/queue.ts
-var pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map(), pendingEffects = [], rendering = !1, scopeKeyOffset = 1e3;
-function queueRender(scope, signal, signalKey, value2, scopeKey = scope.l) {
+var pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map(), caughtError = /* @__PURE__ */ new WeakSet(), placeholderShown = /* @__PURE__ */ new WeakSet(), pendingEffects = [], rendering = !1, scopeKeyOffset = 1e3;
+function queueRender(scope, signal, signalKey, value2, scopeKey = scope.m) {
   let key = scopeKey * scopeKeyOffset + signalKey, existingRender = signalKey >= 0 && pendingRendersLookup.get(key);
   if (existingRender)
-    existingRender.G = value2;
+    existingRender.I = value2;
   else {
     let render = {
-      p: key,
-      C: scope,
-      J: signal,
-      G: value2
+      t: key,
+      D: scope,
+      L: signal,
+      I: value2
     }, i = pendingRenders.push(render) - 1;
     for (; i; ) {
       let parentIndex = i - 1 >> 1, parent = pendingRenders[parentIndex];
-      if (key - parent.p >= 0) break;
+      if (key - parent.t >= 0) break;
       pendingRenders[i] = parent, i = parentIndex;
     }
     signalKey >= 0 && pendingRendersLookup.set(key, render), pendingRenders[i] = render;
@@ -1352,62 +1354,63 @@ function prepareEffects(fn) {
   }
   return preparedEffects;
 }
-function runEffects(effects) {
+var runEffects = (effects) => {
   for (let i = 0, scope; i < effects.length; )
     effects[i++](
       scope = effects[i++],
       scope
     );
-}
+};
 function runRenders() {
   for (; pendingRenders.length; ) {
     let render = pendingRenders[0], item = pendingRenders.pop();
     if (render !== item) {
-      let i = 0, mid = pendingRenders.length >> 1, key = (pendingRenders[0] = item).p;
+      let i = 0, mid = pendingRenders.length >> 1, key = (pendingRenders[0] = item).t;
       for (; i < mid; ) {
         let bestChild = (i << 1) + 1, right = bestChild + 1;
-        if (right < pendingRenders.length && pendingRenders[right].p - pendingRenders[bestChild].p < 0 && (bestChild = right), pendingRenders[bestChild].p - key >= 0)
+        if (right < pendingRenders.length && pendingRenders[right].t - pendingRenders[bestChild].t < 0 && (bestChild = right), pendingRenders[bestChild].t - key >= 0)
           break;
         pendingRenders[i] = pendingRenders[bestChild], i = bestChild;
       }
       pendingRenders[i] = item;
     }
-    render.C.j?.q || runRender(render);
+    render.D.k?.p || runRender(render);
   }
   finishPendingScopes();
 }
-var runRender = (render) => render.J(render.C, render.G), enableCatch = () => {
+var runRender = (render) => render.L(render.D, render.I), enableCatch = () => {
   enableCatch = () => {
-  }, runRender = /* @__PURE__ */ ((runRender2) => (render) => {
+  };
+  let handlePendingTry = (fn, scope, branch) => {
+    for (; branch; ) {
+      if (branch.q)
+        return (branch.H ||= []).push(fn, scope);
+      branch = branch.u;
+    }
+  };
+  runEffects = /* @__PURE__ */ ((runEffects2) => (effects, checkPending = placeholderShown.has(effects)) => {
+    if (checkPending || caughtError.has(effects)) {
+      let i = 0, fn, scope, branch;
+      for (; i < effects.length; )
+        fn = effects[i++], scope = effects[i++], branch = scope.k, !branch?.p && !(checkPending && handlePendingTry(fn, scope, branch)) && fn(scope, scope);
+    } else
+      runEffects2(effects);
+  })(runEffects), runRender = /* @__PURE__ */ ((runRender2) => (render) => {
     try {
       runRender2(render);
     } catch (error) {
-      let branch = render.C.j;
-      for (; branch && !branch.b; )
-        branch = branch.n;
-      if (branch)
-        setConditionalRenderer(
-          branch._,
-          branch.a,
-          branch.b,
-          createAndSetupBranch
-        ), branch.b.k?.(
-          branch._["d" /* ConditionalScope */ + branch.a],
-          [error]
-        );
-      else
-        throw error;
+      renderCatch(render.D, error);
     }
   })(runRender);
 };
 
 // src/dom/abort-signal.ts
 function resetAbortSignal(scope, id) {
-  let ctrl = scope.t?.[id];
-  ctrl && (queueEffect(ctrl, abort), scope.t[id] = void 0);
+  let ctrl = scope.x?.[id];
+  ctrl && (queueEffect(ctrl, abort), scope.x[id] = void 0);
 }
 function getAbortSignal(scope, id) {
-  return scope.j && (scope.j.H ||= /* @__PURE__ */ new Set()).add(scope), ((scope.t ||= {})[id] ||= new AbortController()).signal;
+  return scope.k && (scope.k.J ||= /* @__PURE__ */ new Set()).add(scope), ((scope.x ||= {})[id] ||= new AbortController()).signal;
 }
 function abort(ctrl) {
   ctrl.abort();
@@ -1429,13 +1432,13 @@ var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
     register(RENDERER_REGISTER_ID, fn);
   },
   isRenderer(renderer) {
-    return renderer.A;
+    return renderer.B;
   },
   getStartNode(branch) {
-    return branch.g;
+    return branch.h;
   },
   setScopeNodes(branch, startNode, endNode) {
-    branch.g = startNode, branch.h = endNode;
+    branch.h = startNode, branch.j = endNode;
   },
   runComponentEffects() {
     runEffects(this.effects);
@@ -1454,9 +1457,9 @@ var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
   },
   createRenderer(params, clone) {
     let renderer = createRenderer(0, 0, 0, params);
-    return renderer.A = (branch) => {
+    return renderer.B = (branch) => {
       let cloned = clone();
-      branch.g = cloned.startNode, branch.h = cloned.endNode;
+      branch.h = cloned.startNode, branch.j = cloned.endNode;
     }, renderer;
   },
   render(out, component, renderer, args) {
@@ -1469,14 +1472,14 @@ var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
         normalizedInput[key === "renderBody" ? "content" : key] = input[key];
     }
     if (component.effects = prepareEffects(() => {
-      branch ? existing = !0 : (out.global.m ||= 0, branch = component.scope = createAndSetupBranch(
+      branch ? existing = !0 : (out.global.n ||= 0, branch = component.scope = createAndSetupBranch(
         out.global,
         renderer,
-        renderer.u,
+        renderer.y,
         document.body
-      )), renderer.k?.(branch, renderer._ ? args[0] : args);
+      )), renderer.l?.(branch, renderer._ ? args[0] : args);
     }), !existing)
-      return toInsertNode(branch.g, branch.h);
+      return toInsertNode(branch.h, branch.j);
   }
 };
 
@@ -1494,12 +1497,12 @@ var createTemplate = (id, template, walks, setup, inputSignal) => {
 function mount(input = {}, reference, position) {
   let branch, parentNode = reference, nextSibling = null, { $global } = input;
   switch ($global ? ({ $global, ...input } = input, $global = {
-    m: 0,
+    n: 0,
     runtimeId: DEFAULT_RUNTIME_ID,
     renderId: DEFAULT_RENDER_ID,
     ...$global
   }) : $global = {
-    m: 0,
+    n: 0,
     runtimeId: DEFAULT_RUNTIME_ID,
     renderId: DEFAULT_RENDER_ID
   }, position) {
@@ -1513,19 +1516,19 @@ function mount(input = {}, reference, position) {
       parentNode = reference.parentNode, nextSibling = reference.nextSibling;
       break;
   }
-  let args = this.k, effects = prepareEffects(() => {
+  let args = this.l, effects = prepareEffects(() => {
     branch = createBranch(
       $global,
       this,
       void 0,
       parentNode
-    ), this.B?.(branch), args?.(branch, input);
+    ), this.C?.(branch), args?.(branch, input);
   });
   return insertChildNodes(
     parentNode,
     nextSibling,
-    branch.g,
-    branch.h
+    branch.h,
+    branch.j
   ), runEffects(effects), {
     update(newInput) {
       args && runEffects(