marko 6.0.0-next.3.62 → 6.0.0-next.3.64

package/dist/dom.js

@@ -285,7 +285,7 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                       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(
+                        scope.j = branch, parentBranch && (branch.t = parentBranch, (parentBranch.z ||= /* @__PURE__ */ new Set()).add(
                           branch
                         ));
                       }
@@ -719,7 +719,7 @@ var pendingScopes = [];
 function createScope($global, closestBranch) {
   let scope = {
     l: $global.m++,
-    o: 1,
+    n: 1,
     j: closestBranch,
     $global
   };
@@ -730,16 +730,22 @@ function skipScope(scope) {
 }
 function finishPendingScopes() {
   for (let scope of pendingScopes)
-    scope.o = 0;
+    scope.n = 0;
   pendingScopes = [];
 }
+function findBranchWithKey(scope, key) {
+  let branch = scope.j;
+  for (; branch && !branch[key]; )
+    branch = branch.t;
+  return branch;
+}
 function destroyBranch(branch) {
-  branch.n?.z?.delete(branch), destroyNestedBranches(branch);
+  branch.t?.z?.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.o = 1, branch.z?.forEach(destroyNestedBranches), branch.I?.forEach((scope) => {
+    for (let id in scope.u)
+      scope.u[id]?.abort();
   });
 }
 function removeAndDestroyBranch(branch) {
@@ -879,7 +885,7 @@ 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?.(
+  return branch._ = renderer.x || parentScope, branch.j = branch, parentBranch && (branch.t = parentBranch, (parentBranch.z ||= /* @__PURE__ */ new Set()).add(branch)), renderer.A?.(
     branch,
     parentNode.namespaceURI
   ), branch;
@@ -916,11 +922,11 @@ function createContent(id, template, walks, setup, params, closures, dynamicScop
   return (owner) => ({
     l: id,
     A: clone,
-    u: owner,
+    x: owner,
     B: setup,
     k: params,
     D: closures,
-    x: dynamicScopesAccessor
+    y: dynamicScopesAccessor
   });
 }
 function registerContent(id, template, walks, setup, params, closures, dynamicScopesAccessor) {
@@ -994,7 +1000,7 @@ function value(valueAccessor, fn = () => {
 }
 function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "l") {
   return (scope) => {
-    scope.o ? scope[id] === void 0 ? scope[id] = defaultPending : --scope[id] || fn(scope) : queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
+    scope.n ? scope[id] === void 0 ? scope[id] = defaultPending : --scope[id] || fn(scope) : queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
   };
 }
 function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
@@ -1004,7 +1010,7 @@ function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
       ownerScope,
       () => {
         for (let scope of scopes)
-          !scope.o && !scope.q && childSignal(scope);
+          !scope.n && !scope.o && childSignal(scope);
       },
       -1,
       0,
@@ -1016,7 +1022,7 @@ function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
 function conditionalClosure(valueAccessor, ownerConditionalNodeAccessor, branch, fn) {
   let childSignal = closure(valueAccessor, fn), scopeAccessor = "d" /* ConditionalScope */ + ownerConditionalNodeAccessor, branchAccessor = "c" /* ConditionalRenderer */ + ownerConditionalNodeAccessor, ownerSignal = (scope) => {
     let ifScope = scope[scopeAccessor];
-    ifScope && !ifScope.o && scope[branchAccessor] === branch && queueRender(ifScope, childSignal, -1);
+    ifScope && !ifScope.n && scope[branchAccessor] === branch && queueRender(ifScope, childSignal, -1);
   };
   return ownerSignal._ = childSignal, ownerSignal;
 }
@@ -1030,11 +1036,11 @@ function subscribeToScopeSet(ownerScope, accessor, scope) {
 function dynamicClosure(...closureSignals) {
   let [{ E: ___scopeInstancesAccessor, F: ___signalIndexAccessor }] = closureSignals;
   for (let i = closureSignals.length; i--; )
-    closureSignals[i].I = i;
+    closureSignals[i].J = i;
   return (scope) => {
     if (scope[___scopeInstancesAccessor])
       for (let childScope of scope[___scopeInstancesAccessor])
-        childScope.o || queueRender(
+        childScope.n || queueRender(
           childScope,
           closureSignals[childScope[___signalIndexAccessor]],
           -1
@@ -1043,7 +1049,7 @@ 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.F] = closureSignal.J, childSignal(scope), subscribeToScopeSet(
       getOwnerScope ? getOwnerScope(scope) : scope._,
       closureSignal.E,
       scope
@@ -1091,71 +1097,53 @@ 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?.g ?? referenceNode).parentNode, thisPromise = scope[promiseAccessor] = promise.then((data2) => {
+      if (!(scope.j?.o || 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.k?.(awaitBranch, [data2]);
+        })
+      ), tryWithPlaceholder && !--tryWithPlaceholder.p)) {
+        let placeholderBranch = tryWithPlaceholder.c;
+        tryWithPlaceholder.c = void 0, placeholderBranch ? (insertBranchBefore(
+          tryWithPlaceholder,
+          placeholderBranch.g.parentNode,
+          placeholderBranch.g
+        ), removeAndDestroyBranch(placeholderBranch)) : insertBranchBefore(
+          tryWithPlaceholder,
+          referenceNode.parentNode,
+          referenceNode
+        ), tryWithPlaceholder.G && runEffects(tryWithPlaceholder.G, !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.p || (tryWithPlaceholder.p = 0, requestAnimationFrame(() => {
+      if (tryWithPlaceholder.p && !tryWithPlaceholder.o) {
+        let placeholderBranch = tryWithPlaceholder.c = createAndSetupBranch(
           scope.$global,
-          tryBranch.d,
-          tryBranch._,
-          tryBranch.g.parentNode
+          tryWithPlaceholder.d,
+          tryWithPlaceholder._,
+          tryWithPlaceholder.g.parentNode
         );
         insertBranchBefore(
           placeholderBranch,
-          tryBranch.g.parentNode,
-          tryBranch.g
-        ), tempDetatchBranch(tryBranch);
+          tryWithPlaceholder.g.parentNode,
+          tryWithPlaceholder.g
+        ), tempDetatchBranch(tryWithPlaceholder);
       }
-    })), tryBranch.y++) : awaitBranch && (awaitBranch.g.parentNode.insertBefore(
+    })), tryWithPlaceholder.p++) : awaitBranch && (awaitBranch.g.parentNode.insertBefore(
       referenceNode,
       awaitBranch.g
     ), tempDetatchBranch(awaitBranch));
@@ -1176,6 +1164,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.k?.(
+      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) => {
@@ -1208,15 +1216,15 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
             0,
             content,
             createAndSetupBranch
-          ), content.x && subscribeToScopeSet(
-            content.u,
+          ), content.y && subscribeToScopeSet(
             content.x,
+            content.y,
             scope[childScopeAccessor]["d" /* ConditionalScope */ + 0]
           );
         }
-      } else normalizedRenderer?.x && subscribeToScopeSet(
-        normalizedRenderer.u,
+      } else normalizedRenderer?.y && subscribeToScopeSet(
         normalizedRenderer.x,
+        normalizedRenderer.y,
         scope[childScopeAccessor]
       );
     if (normalizedRenderer) {
@@ -1310,21 +1318,21 @@ function byFirstArg(name) {
 }
 
 // src/dom/queue.ts
-var pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map(), pendingEffects = [], rendering = !1, scopeKeyOffset = 1e3;
+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.l) {
   let key = scopeKey * scopeKeyOffset + signalKey, existingRender = signalKey >= 0 && pendingRendersLookup.get(key);
   if (existingRender)
-    existingRender.G = value2;
+    existingRender.H = value2;
   else {
     let render = {
-      p: key,
+      q: key,
       C: scope,
-      J: signal,
-      G: value2
+      K: signal,
+      H: 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.q >= 0) break;
       pendingRenders[i] = parent, i = parentIndex;
     }
     signalKey >= 0 && pendingRendersLookup.set(key, render), pendingRenders[i] = render;
@@ -1352,62 +1360,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).q;
       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].q - pendingRenders[bestChild].q < 0 && (bestChild = right), pendingRenders[bestChild].q - key >= 0)
           break;
         pendingRenders[i] = pendingRenders[bestChild], i = bestChild;
       }
       pendingRenders[i] = item;
     }
-    render.C.j?.q || runRender(render);
+    render.C.j?.o || runRender(render);
   }
   finishPendingScopes();
 }
-var runRender = (render) => render.J(render.C, render.G), enableCatch = () => {
+var runRender = (render) => render.K(render.C, render.H), enableCatch = () => {
   enableCatch = () => {
-  }, runRender = /* @__PURE__ */ ((runRender2) => (render) => {
+  };
+  let handlePendingTry = (fn, scope, branch) => {
+    for (; branch; ) {
+      if (branch.p)
+        return (branch.G ||= []).push(fn, scope);
+      branch = branch.t;
+    }
+  };
+  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.j, !branch?.o && !(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.C, 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.u?.[id];
+  ctrl && (queueEffect(ctrl, abort), scope.u[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.j && (scope.j.I ||= /* @__PURE__ */ new Set()).add(scope), ((scope.u ||= {})[id] ||= new AbortController()).signal;
 }
 function abort(ctrl) {
   ctrl.abort();
@@ -1472,7 +1481,7 @@ var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
       branch ? existing = !0 : (out.global.m ||= 0, branch = component.scope = createAndSetupBranch(
         out.global,
         renderer,
-        renderer.u,
+        renderer.x,
         document.body
       )), renderer.k?.(branch, renderer._ ? args[0] : args);
     }), !existing)