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

package/dist/debug/dom.mjs

@@ -181,15 +181,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;
@@ -197,8 +196,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)) ;
@@ -210,17 +209,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(
@@ -235,29 +227,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;
@@ -269,7 +260,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);
                 }
               }
             }
@@ -301,7 +293,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];
                       }
@@ -902,7 +894,7 @@ var pendingScopes = [];
 function createScope($global, closestBranch) {
   const scope = {
     ___id: $global.___nextScopeId++,
-    ___pending: 1,
+    ___creating: 1,
     ___closestBranch: closestBranch,
     $global
   };
@@ -914,10 +906,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);
@@ -1387,7 +1386,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]) {
@@ -1410,7 +1409,7 @@ function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
         ownerScope,
         () => {
           for (const scope of scopes) {
-            if (!scope.___pending && !scope.___destroyed) {
+            if (!scope.___creating && !scope.___destroyed) {
               childSignal(scope);
             }
           }
@@ -1430,7 +1429,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);
     }
   };
@@ -1455,7 +1454,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]],
@@ -1532,98 +1531,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,
@@ -1654,6 +1643,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) => {
@@ -1852,6 +1870,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;
@@ -1914,14 +1934,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];
@@ -1955,27 +1975,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);
 };

package/dist/debug/html.js

@@ -305,12 +305,12 @@ runtime.x = (op, id, node, start, placeholderCallback) => {
     // repurpose "op" for callbacks ...carefully
     if (op = runtime.j[id]) {
       placeholderCallback = placeholder.c;
-      placeholder.c = () => placeholderCallback() + op(runtime);
+      placeholder.c = () => placeholderCallback() + op(runtime.r);
     }
   }
 };
 })`
-) : `(e=>{let i,t,r,l={},o=(e,i)=>{e.replaceWith(...i.childNodes),i.remove()};e.d.head.append(e.d.querySelector("style["+e.i+"]")||""),e.j={},e.x=(d,n,a,c,p)=>{"#"==d?(l[n]=t).i++:a==r&&i(),"T"==a.tagName&&(n=a.getAttribute(e.i))&&((c=e.l["^"+n])&&(l[n]={i:1,c(i=e.l[n]||a){for(;i.parentNode!==c.parentNode;)i=i.parentNode;for(;i!=r;(r=c.nextSibling).remove());o(c,a)}}),r=a.nextSibling,t=l[n],i=()=>{c||o(e.l[n],a),--t.i||t.c()},(d=e.j[n])&&(p=t.c,t.c=()=>p()+d(e)))}})`;
+) : `(e=>{let i,t,r,l={},o=(e,i)=>{e.replaceWith(...i.childNodes),i.remove()};e.d.head.append(e.d.querySelector("style["+e.i+"]")||""),e.j={},e.x=(d,n,a,c,p)=>{"#"==d?(l[n]=t).i++:a==r&&i(),"T"==a.tagName&&(n=a.getAttribute(e.i))&&((c=e.l["^"+n])&&(l[n]={i:1,c(i=e.l[n]||a){for(;i.parentNode!==c.parentNode;)i=i.parentNode;for(;i!=r;(r=c.nextSibling).remove());o(c,a)}}),r=a.nextSibling,t=l[n],i=()=>{c||o(e.l[n],a),--t.i||t.c()},(d=e.j[n])&&(p=t.c,t.c=()=>p()+d(e.r)))}})`;
 
 // src/html/serializer.ts
 var { hasOwnProperty } = {};
@@ -1742,9 +1742,9 @@ function hoist(scopeId, id) {
 function resumeClosestBranch(scopeId) {
   const branchId = $chunk.context?.[branchIdKey];
   if (branchId !== void 0 && branchId !== scopeId) {
-    $chunk.writeHTML(
-      $chunk.boundary.state.mark("$" /* ClosestBranch */, "" + scopeId)
-    );
+    writeScope(scopeId, {
+      ["#ClosestBranchId" /* ClosestBranchId */]: branchId
+    });
   }
 }
 var branchIdKey = Symbol();

package/dist/debug/html.mjs

@@ -221,12 +221,12 @@ runtime.x = (op, id, node, start, placeholderCallback) => {
     // repurpose "op" for callbacks ...carefully
     if (op = runtime.j[id]) {
       placeholderCallback = placeholder.c;
-      placeholder.c = () => placeholderCallback() + op(runtime);
+      placeholder.c = () => placeholderCallback() + op(runtime.r);
     }
   }
 };
 })`
-) : `(e=>{let i,t,r,l={},o=(e,i)=>{e.replaceWith(...i.childNodes),i.remove()};e.d.head.append(e.d.querySelector("style["+e.i+"]")||""),e.j={},e.x=(d,n,a,c,p)=>{"#"==d?(l[n]=t).i++:a==r&&i(),"T"==a.tagName&&(n=a.getAttribute(e.i))&&((c=e.l["^"+n])&&(l[n]={i:1,c(i=e.l[n]||a){for(;i.parentNode!==c.parentNode;)i=i.parentNode;for(;i!=r;(r=c.nextSibling).remove());o(c,a)}}),r=a.nextSibling,t=l[n],i=()=>{c||o(e.l[n],a),--t.i||t.c()},(d=e.j[n])&&(p=t.c,t.c=()=>p()+d(e)))}})`;
+) : `(e=>{let i,t,r,l={},o=(e,i)=>{e.replaceWith(...i.childNodes),i.remove()};e.d.head.append(e.d.querySelector("style["+e.i+"]")||""),e.j={},e.x=(d,n,a,c,p)=>{"#"==d?(l[n]=t).i++:a==r&&i(),"T"==a.tagName&&(n=a.getAttribute(e.i))&&((c=e.l["^"+n])&&(l[n]={i:1,c(i=e.l[n]||a){for(;i.parentNode!==c.parentNode;)i=i.parentNode;for(;i!=r;(r=c.nextSibling).remove());o(c,a)}}),r=a.nextSibling,t=l[n],i=()=>{c||o(e.l[n],a),--t.i||t.c()},(d=e.j[n])&&(p=t.c,t.c=()=>p()+d(e.r)))}})`;
 
 // src/html/serializer.ts
 var { hasOwnProperty } = {};
@@ -1658,9 +1658,9 @@ function hoist(scopeId, id) {
 function resumeClosestBranch(scopeId) {
   const branchId = $chunk.context?.[branchIdKey];
   if (branchId !== void 0 && branchId !== scopeId) {
-    $chunk.writeHTML(
-      $chunk.boundary.state.mark("$" /* ClosestBranch */, "" + scopeId)
-    );
+    writeScope(scopeId, {
+      ["#ClosestBranchId" /* ClosestBranchId */]: branchId
+    });
   }
 }
 var branchIdKey = Symbol();

package/dist/dom/control-flow.d.ts

@@ -6,6 +6,7 @@ export declare function createTry(nodeAccessor: Accessor, tryContent: Renderer):
     catch: unknown;
     placeholder: unknown;
 }) => void;
+export declare function renderCatch(scope: Scope, error: unknown, async?: boolean): void;
 export declare function conditional(nodeAccessor: Accessor, ...branches: Renderer[]): (scope: Scope, newBranch: number) => void;
 export declare function patchDynamicTag(fn: <T extends typeof dynamicTag>(cond: T) => T): void;
 export declare let dynamicTag: (nodeAccessor: Accessor, getContent?: ((scope: Scope) => Renderer) | 0, getTagVar?: (() => Signal<unknown>) | 0, inputIsArgs?: 1) => Signal<Renderer | string | undefined>;

package/dist/dom/queue.d.ts

@@ -1,12 +1,14 @@
-import { type Scope } from "../common/types";
+import type { Scope } from "../common/types";
 import type { Signal } from "./signals";
 type ExecFn<S extends Scope = Scope> = (scope: S, arg?: any) => void;
+export declare const caughtError: WeakSet<unknown[]>;
+export declare const placeholderShown: WeakSet<unknown[]>;
 export declare let pendingEffects: unknown[];
 export declare let rendering: boolean;
 export declare function queueRender<T>(scope: Scope, signal: Signal<T>, signalKey: number, value?: T, scopeKey?: number): void;
 export declare function queueEffect<S extends Scope, T extends ExecFn<S>>(scope: S, fn: T): void;
 export declare function run(): void;
 export declare function prepareEffects(fn: () => void): unknown[];
-export declare function runEffects(effects: unknown[]): void;
+export declare let runEffects: (effects: unknown[]) => void;
 export declare let enableCatch: () => void;
 export {};

package/dist/dom/scope.d.ts

@@ -2,6 +2,7 @@ import type { BranchScope, Scope } from "../common/types";
 export declare function createScope($global: Scope["$global"], closestBranch?: BranchScope): Scope;
 export declare function skipScope(scope: Scope): number;
 export declare function finishPendingScopes(): void;
+export declare function findBranchWithKey(scope: Scope, key: string): BranchScope | undefined;
 export declare function destroyBranch(branch: BranchScope): void;
 export declare function removeAndDestroyBranch(branch: BranchScope): void;
 export declare function insertBranchBefore(branch: BranchScope, parentNode: ParentNode, nextSibling: Node | null): void;