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

package/dist/common/accessor.d.ts

@@ -21,5 +21,6 @@ export declare enum AccessorProp {
     PlaceholderBranch = "c",
     PlaceholderContent = "d",
     TagVariable = "e",
-    TagVariableChange = "f"
+    TagVariableChange = "f",
+    ClosestBranchId = "g"
 }

package/dist/common/accessor.debug.d.ts

@@ -21,5 +21,6 @@ export declare enum AccessorProp {
     PlaceholderBranch = "#PlaceholderBranch",
     PlaceholderContent = "#PlaceholderContent",
     TagVariable = "#TagVariable",
-    TagVariableChange = "#TagVariableChange"
+    TagVariableChange = "#TagVariableChange",
+    ClosestBranchId = "#ClosestBranchId"
 }

package/dist/common/types.d.ts

@@ -10,6 +10,7 @@ export interface BranchScope extends Scope {
     ___branchScopes: Set<BranchScope> | undefined;
     ___renderer: ClientRenderer | string;
     ___pendingAsyncCount: number | undefined;
+    ___effects: unknown[] | undefined;
 }
 export interface Scope {
     $global: Record<string, unknown> & {
@@ -18,7 +19,7 @@ export interface Scope {
     _: Scope | undefined;
     ___id: number;
     ___args: unknown;
-    ___pending: 1 | 0 | undefined;
+    ___creating: 1 | 0 | undefined;
     ___abortControllers: Record<string | number, AbortController | void> | undefined;
     ___closestBranch: BranchScope | undefined;
     [x: string | number]: any;
@@ -28,8 +29,7 @@ export declare enum ResumeSymbol {
     BranchStart = "[",
     BranchEnd = "]",
     BranchSingleNode = "|",
-    BranchSingleNodeOnlyChildInParent = "=",
-    ClosestBranch = "$"
+    BranchSingleNodeOnlyChildInParent = "="
 }
 export { AccessorPrefix, AccessorProp } from "./accessor.debug";
 export declare enum NodeType {

package/dist/debug/dom.js

@@ -269,15 +269,14 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
         const render = resumeRender[renderId] = renders2[renderId] || renders2(renderId);
         const walk2 = render.w;
         const commentPrefixLen = render.i.length;
-        const scopeStack = [];
+        const branchStack = [];
         const scopeLookup = render.s = {};
         const serializeContext = {
           _: registeredValues
         };
         const branchIds = /* @__PURE__ */ new Set();
         const parentBranchIds = /* @__PURE__ */ new Map();
-        const closestBranchMarkers = /* @__PURE__ */ new Map();
-        let currentScopeId;
+        let currentBranchId;
         render.w = () => {
           walk2.call(render);
           const visits = render.v;
@@ -285,8 +284,8 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
           if (visits.length) {
             const visitNodes = new Set(visits);
             let lastEndNode;
-            render.v = [];
-            const branchEnd = (branchId, visit, reference) => {
+            visits.length = 0;
+            const branchEnd = (branchId, reference) => {
               const branch = scopeLookup[branchId] ||= {};
               let endNode = reference;
               while (visitNodes.has(endNode = endNode.previousSibling)) ;
@@ -298,17 +297,10 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
               }
               branch.___endNode = lastEndNode = endNode;
               branch.___startNode ||= endNode;
-              for (const [markerScopeId, markerNode] of closestBranchMarkers) {
-                if (branch.___startNode.compareDocumentPosition(markerNode) & 4 && reference.compareDocumentPosition(markerNode) & 2) {
-                  parentBranchIds.set(markerScopeId, branchId);
-                  closestBranchMarkers.delete(markerScopeId);
-                }
-              }
               branchIds.add(branchId);
-              closestBranchMarkers.set(branchId, visit);
               return branch;
             };
-            for (const visit of visits) {
+            for (const visit of visitNodes) {
               const commentText = visit.data;
               const dataIndex = commentText.indexOf(" ") + 1;
               const scopeId = commentText.slice(
@@ -323,29 +315,28 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
               if (token === "*" /* Node */) {
                 const node = scope[data2] = visit.previousSibling;
                 scope["Getter:" /* Getter */ + data2] = () => node;
-              } else if (token === "$" /* ClosestBranch */) {
-                closestBranchMarkers.set(scopeId, visit);
               } else if (token === "[" /* BranchStart */) {
-                if (currentScopeId) {
-                  if (dataIndex) {
-                    branchEnd(currentScopeId, visit, visit);
-                  }
-                  scopeStack.push(currentScopeId);
+                if (currentBranchId && dataIndex) {
+                  branchEnd(currentBranchId, visit);
+                  currentBranchId = branchStack.pop();
+                }
+                if (currentBranchId) {
+                  branchStack.push(currentBranchId);
+                  parentBranchIds.set(scopeId, currentBranchId);
                 }
-                currentScopeId = scopeId;
+                currentBranchId = scopeId;
                 scope.___startNode = visit;
               } else if (token === "]" /* BranchEnd */) {
                 scope[data2] = visit;
                 const curParent = visit.parentNode;
                 const startNode = branchEnd(
-                  currentScopeId,
-                  visit,
+                  currentBranchId,
                   visit
                 ).___startNode;
                 if (curParent !== startNode.parentNode) {
                   curParent.prepend(startNode);
                 }
-                currentScopeId = scopeStack.pop();
+                currentBranchId = branchStack.pop();
               } else if (token === "|" /* BranchSingleNode */ || token === "=" /* BranchSingleNodeOnlyChildInParent */) {
                 let next = data2.indexOf(" ");
                 let curNode = visit;
@@ -357,7 +348,8 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                     start,
                     ~next ? next : data2.length
                   );
-                  curNode = branchEnd(childScopeId, visit, curNode).___endNode;
+                  curNode = branchEnd(childScopeId, curNode).___endNode;
+                  parentBranchIds.set(childScopeId, scopeId);
                 }
               }
             }
@@ -389,7 +381,7 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                           prevScope
                         );
                       }
-                      const parentBranchId = parentBranchIds.get(scopeId);
+                      const parentBranchId = scope["#ClosestBranchId" /* ClosestBranchId */] || parentBranchIds.get(scopeId);
                       if (parentBranchId) {
                         scope.___closestBranch = scopes[parentBranchId];
                       }
@@ -990,7 +982,7 @@ var pendingScopes = [];
 function createScope($global, closestBranch) {
   const scope = {
     ___id: $global.___nextScopeId++,
-    ___pending: 1,
+    ___creating: 1,
     ___closestBranch: closestBranch,
     $global
   };
@@ -1002,10 +994,17 @@ function skipScope(scope) {
 }
 function finishPendingScopes() {
   for (const scope of pendingScopes) {
-    scope.___pending = 0;
+    scope.___creating = 0;
   }
   pendingScopes = [];
 }
+function findBranchWithKey(scope, key) {
+  let branch = scope.___closestBranch;
+  while (branch && !branch[key]) {
+    branch = branch.___parentBranch;
+  }
+  return branch;
+}
 function destroyBranch(branch) {
   branch.___parentBranch?.___branchScopes?.delete(branch);
   destroyNestedBranches(branch);
@@ -1475,7 +1474,7 @@ function value(valueAccessor, fn = () => {
 }
 function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "___id") {
   return (scope) => {
-    if (scope.___pending) {
+    if (scope.___creating) {
       if (scope[id] === void 0) {
         scope[id] = defaultPending;
       } else if (!--scope[id]) {
@@ -1498,7 +1497,7 @@ function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
         ownerScope,
         () => {
           for (const scope of scopes) {
-            if (!scope.___pending && !scope.___destroyed) {
+            if (!scope.___creating && !scope.___destroyed) {
               childSignal(scope);
             }
           }
@@ -1518,7 +1517,7 @@ function conditionalClosure(valueAccessor, ownerConditionalNodeAccessor, branch,
   const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + ownerConditionalNodeAccessor;
   const ownerSignal = (scope) => {
     const ifScope = scope[scopeAccessor];
-    if (ifScope && !ifScope.___pending && scope[branchAccessor] === branch) {
+    if (ifScope && !ifScope.___creating && scope[branchAccessor] === branch) {
       queueRender(ifScope, childSignal, -1);
     }
   };
@@ -1543,7 +1542,7 @@ function dynamicClosure(...closureSignals) {
   return (scope) => {
     if (scope[___scopeInstancesAccessor]) {
       for (const childScope of scope[___scopeInstancesAccessor]) {
-        if (!childScope.___pending) {
+        if (!childScope.___creating) {
           queueRender(
             childScope,
             closureSignals[childScope[___signalIndexAccessor]],
@@ -1620,98 +1619,88 @@ function awaitTag(nodeAccessor, renderer) {
   const promiseAccessor = "Promise:" /* Promise */ + nodeAccessor;
   const branchAccessor = "ConditionalScope:" /* ConditionalScope */ + nodeAccessor;
   return (scope, promise) => {
-    let tryBranch = scope.___closestBranch;
+    const tryWithPlaceholder = findBranchWithKey(
+      scope,
+      "#PlaceholderContent" /* PlaceholderContent */
+    );
     let awaitBranch = scope[branchAccessor];
     const referenceNode = scope[nodeAccessor];
     const namespaceNode = (awaitBranch?.___startNode ?? referenceNode).parentNode;
-    while (tryBranch && !tryBranch["#PlaceholderContent" /* PlaceholderContent */]) {
-      tryBranch = tryBranch.___parentBranch;
-    }
     const thisPromise = scope[promiseAccessor] = promise.then((data2) => {
       if (scope.___closestBranch?.___destroyed || scope[promiseAccessor] !== thisPromise) {
         return;
       }
       scope[promiseAccessor] = void 0;
-      const effects = prepareEffects(() => {
-        if (!awaitBranch || !tryBranch) {
-          insertBranchBefore(
-            awaitBranch ??= scope[branchAccessor] = createAndSetupBranch(
-              scope.$global,
-              renderer,
-              scope,
-              namespaceNode
-            ),
-            referenceNode.parentNode,
-            referenceNode
-          );
-          referenceNode.remove();
-        }
-        renderer.___params?.(awaitBranch, [data2]);
-      });
-      if (tryBranch) {
-        if (!--tryBranch.___pendingAsyncCount) {
-          const placeholderBranch = tryBranch["#PlaceholderBranch" /* PlaceholderBranch */];
+      runEffects(
+        prepareEffects(() => {
+          if (tryWithPlaceholder) {
+            placeholderShown.add(pendingEffects);
+          }
+          if (!awaitBranch || !tryWithPlaceholder) {
+            insertBranchBefore(
+              awaitBranch ??= scope[branchAccessor] = createAndSetupBranch(
+                scope.$global,
+                renderer,
+                scope,
+                namespaceNode
+              ),
+              referenceNode.parentNode,
+              referenceNode
+            );
+            referenceNode.remove();
+          }
+          renderer.___params?.(awaitBranch, [data2]);
+        })
+      );
+      if (tryWithPlaceholder) {
+        tryWithPlaceholder;
+        if (!--tryWithPlaceholder.___pendingAsyncCount) {
+          const placeholderBranch = tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */];
+          tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */] = void 0;
           if (placeholderBranch) {
             insertBranchBefore(
-              tryBranch,
+              tryWithPlaceholder,
               placeholderBranch.___startNode.parentNode,
               placeholderBranch.___startNode
             );
             removeAndDestroyBranch(placeholderBranch);
           } else {
             insertBranchBefore(
-              tryBranch,
+              tryWithPlaceholder,
               referenceNode.parentNode,
               referenceNode
             );
           }
+          if (tryWithPlaceholder.___effects) {
+            runEffects(tryWithPlaceholder.___effects, true);
+          }
         }
-      } else {
-        runEffects(effects);
       }
     }).catch((error) => {
-      let tryBranch2 = scope.___closestBranch;
-      while (tryBranch2 && !tryBranch2["#CatchContent" /* CatchContent */]) {
-        tryBranch2 = tryBranch2.___parentBranch;
-      }
-      if (!tryBranch2) {
-        setTimeout(() => {
-          throw error;
-        });
-      } else {
-        setConditionalRenderer(
-          tryBranch2._,
-          tryBranch2["#BranchAccessor" /* BranchAccessor */],
-          tryBranch2["#CatchContent" /* CatchContent */],
-          createAndSetupBranch
-        );
-        tryBranch2["#CatchContent" /* CatchContent */].___params?.(
-          tryBranch2._["ConditionalScope:" /* ConditionalScope */ + tryBranch2["#BranchAccessor" /* BranchAccessor */]],
-          [error]
-        );
-      }
+      renderCatch(scope, error, true);
     });
-    if (tryBranch) {
-      if (!tryBranch.___pendingAsyncCount) {
-        tryBranch.___pendingAsyncCount = 0;
+    if (tryWithPlaceholder) {
+      placeholderShown.add(pendingEffects);
+      if (!tryWithPlaceholder.___pendingAsyncCount) {
+        tryWithPlaceholder.___pendingAsyncCount = 0;
         requestAnimationFrame(() => {
-          if (tryBranch.___pendingAsyncCount && !tryBranch.___destroyed) {
-            const placeholderBranch = tryBranch["#PlaceholderBranch" /* PlaceholderBranch */] = createAndSetupBranch(
+          if (tryWithPlaceholder.___pendingAsyncCount && !tryWithPlaceholder.___destroyed) {
+            const placeholderBranch = tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */] = createAndSetupBranch(
               scope.$global,
-              tryBranch["#PlaceholderContent" /* PlaceholderContent */],
-              tryBranch._,
-              tryBranch.___startNode.parentNode
+              tryWithPlaceholder["#PlaceholderContent" /* PlaceholderContent */],
+              tryWithPlaceholder._,
+              tryWithPlaceholder.___startNode.parentNode
             );
             insertBranchBefore(
               placeholderBranch,
-              tryBranch.___startNode.parentNode,
-              tryBranch.___startNode
+              tryWithPlaceholder.___startNode.parentNode,
+              tryWithPlaceholder.___startNode
             );
-            tempDetatchBranch(tryBranch);
+            tempDetatchBranch(tryWithPlaceholder);
           }
         });
       }
-      tryBranch.___pendingAsyncCount++;
+      tryWithPlaceholder.___pendingAsyncCount++;
     } else if (awaitBranch) {
       awaitBranch.___startNode.parentNode.insertBefore(
         referenceNode,
@@ -1742,6 +1731,35 @@ function createTry(nodeAccessor, tryContent) {
     }
   };
 }
+function renderCatch(scope, error, async) {
+  const tryWithCatch = findBranchWithKey(scope, "#CatchContent" /* CatchContent */);
+  if (!tryWithCatch) {
+    if (async) {
+      setTimeout(() => {
+        throw error;
+      });
+    } else {
+      throw error;
+    }
+  } else {
+    const placeholderBranch = tryWithCatch["#PlaceholderBranch" /* PlaceholderBranch */];
+    if (placeholderBranch) {
+      tryWithCatch._["ConditionalScope:" /* ConditionalScope */ + tryWithCatch["#BranchAccessor" /* BranchAccessor */]] = placeholderBranch;
+      destroyBranch(tryWithCatch);
+    }
+    caughtError.add(pendingEffects);
+    setConditionalRenderer(
+      tryWithCatch._,
+      tryWithCatch["#BranchAccessor" /* BranchAccessor */],
+      tryWithCatch["#CatchContent" /* CatchContent */],
+      createAndSetupBranch
+    );
+    tryWithCatch["#CatchContent" /* CatchContent */].___params?.(
+      tryWithCatch._["ConditionalScope:" /* ConditionalScope */ + tryWithCatch["#BranchAccessor" /* BranchAccessor */]],
+      [error]
+    );
+  }
+}
 function conditional(nodeAccessor, ...branches) {
   const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
   return (scope, newBranch) => {
@@ -1940,6 +1958,8 @@ function byFirstArg(name) {
 // src/dom/queue.ts
 var pendingRenders = [];
 var pendingRendersLookup = /* @__PURE__ */ new Map();
+var caughtError = /* @__PURE__ */ new WeakSet();
+var placeholderShown = /* @__PURE__ */ new WeakSet();
 var pendingEffects = [];
 var rendering = false;
 var scopeKeyOffset = 1e3;
@@ -2002,14 +2022,14 @@ 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() {
   while (pendingRenders.length) {
     const render = pendingRenders[0];
@@ -2043,27 +2063,37 @@ var runRender = (render) => render.___signal(render.___scope, render.___value);
 var enableCatch = () => {
   enableCatch = () => {
   };
+  const handlePendingTry = (fn, scope, branch) => {
+    while (branch) {
+      if (branch.___pendingAsyncCount) {
+        return (branch.___effects ||= []).push(fn, scope);
+      }
+      branch = branch.___parentBranch;
+    }
+  };
+  runEffects = /* @__PURE__ */ ((runEffects2) => (effects, checkPending = placeholderShown.has(effects)) => {
+    if (checkPending || caughtError.has(effects)) {
+      let i = 0;
+      let fn;
+      let scope;
+      let branch;
+      for (; i < effects.length; ) {
+        fn = effects[i++];
+        scope = effects[i++];
+        branch = scope.___closestBranch;
+        if (!branch?.___destroyed && !(checkPending && handlePendingTry(fn, scope, branch))) {
+          fn(scope, scope);
+        }
+      }
+    } else {
+      runEffects2(effects);
+    }
+  })(runEffects);
   runRender = /* @__PURE__ */ ((runRender2) => (render) => {
     try {
       runRender2(render);
     } catch (error) {
-      let branch = render.___scope.___closestBranch;
-      while (branch && !branch["#CatchContent" /* CatchContent */])
-        branch = branch.___parentBranch;
-      if (!branch) {
-        throw error;
-      } else {
-        setConditionalRenderer(
-          branch._,
-          branch["#BranchAccessor" /* BranchAccessor */],
-          branch["#CatchContent" /* CatchContent */],
-          createAndSetupBranch
-        );
-        branch["#CatchContent" /* CatchContent */].___params?.(
-          branch._["ConditionalScope:" /* ConditionalScope */ + branch["#BranchAccessor" /* BranchAccessor */]],
-          [error]
-        );
-      }
+      renderCatch(render.___scope, error);
     }
   })(runRender);
 };