marko 6.0.0-next.3.58 → 6.0.0-next.3.60

package/dist/dom.js

@@ -22,6 +22,7 @@ __export(dom_exports, {
   attrTags: () => attrTags,
   attrs: () => attrs,
   attrsEvents: () => attrsEvents,
+  awaitTag: () => awaitTag,
   classAttr: () => classAttr,
   compat: () => compat,
   conditional: () => conditional,
@@ -41,11 +42,13 @@ __export(dom_exports, {
   createContent: () => createContent,
   createRenderer: () => createRenderer,
   createTemplate: () => createTemplate,
+  createTry: () => createTry,
   data: () => data,
   dynamicClosure: () => dynamicClosure,
   dynamicClosureRead: () => dynamicClosureRead,
   dynamicTag: () => dynamicTag,
   effect: () => effect,
+  enableCatch: () => enableCatch,
   forIn: () => forIn,
   forOf: () => forOf,
   forTo: () => forTo,
@@ -203,95 +206,114 @@ function stripSpacesAndPunctuation(str) {
 var DEFAULT_RUNTIME_ID = "M", DEFAULT_RENDER_ID = "_";
 
 // src/dom/resume.ts
-var registeredValues = {}, Render = class {
-  q = [];
-  s = {};
-  E = {
-    _: registeredValues
-  };
-  constructor(renders, runtimeId, renderId) {
-    Object.assign(this, renders[renderId]), this.F = renders, this.G = runtimeId, this.t = renderId, this.H = this.w, this.u(), this.w = () => {
-      this.H(), this.u();
-    };
-  }
-  u() {
-    let serializeContext = this.E, scopeLookup = this.s, visits = this.v, branchIds = /* @__PURE__ */ new Set(), parentBranchIds = /* @__PURE__ */ new Map();
-    if (visits.length) {
-      let commentPrefixLen = this.i.length, closestBranchMarkers = /* @__PURE__ */ new Map(), visitNodes = new Set(visits), lastEndNode;
-      this.v = [];
-      let branchEnd = (branchId, visit, reference) => {
-        let branch = scopeLookup[branchId] ||= {}, endNode = reference;
-        for (; visitNodes.has(endNode = endNode.previousSibling); ) ;
-        endNode === lastEndNode && (endNode = reference.parentNode.insertBefore(new Text(), reference)), branch.b = lastEndNode = endNode, branch.a ||= endNode;
-        for (let [markerScopeId, markerNode] of closestBranchMarkers)
-          branch.a.compareDocumentPosition(markerNode) & 4 && reference.compareDocumentPosition(markerNode) & 2 && (parentBranchIds.set(markerScopeId, branchId), closestBranchMarkers.delete(markerScopeId));
-        return branchIds.add(branchId), closestBranchMarkers.set(branchId, visit), branch;
-      };
-      for (let visit of visits) {
-        let commentText = visit.data, dataIndex = commentText.indexOf(" ") + 1, scopeId = commentText.slice(
-          commentPrefixLen + 1,
-          dataIndex ? dataIndex - 1 : commentText.length
-        ), scope = scopeLookup[scopeId] ||= { d: +scopeId }, data2 = dataIndex ? commentText.slice(dataIndex) : "", token = commentText[commentPrefixLen];
-        if (token === "*" /* Node */) {
-          let node = scope[data2] = visit.previousSibling;
-          scope[data2 + ">" /* Getter */] = () => node;
-        } else if (token === "$" /* ClosestBranch */)
-          closestBranchMarkers.set(scopeId, visit);
-        else if (token === "[" /* BranchStart */)
-          this.f && (dataIndex && branchEnd(this.f, visit, visit), this.q.push(this.f)), this.f = scopeId, scope.a = visit;
-        else if (token === "]" /* BranchEnd */) {
-          scope[data2] = visit;
-          let curParent = visit.parentNode, startNode = branchEnd(
-            this.f,
-            visit,
-            visit
-          ).a;
-          curParent !== startNode.parentNode && curParent.prepend(startNode), this.f = this.q.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; ) {
-            let start = next + 1;
-            next = data2.indexOf(" ", start);
-            let childScopeId = data2.slice(start, ~next ? next : data2.length);
-            curNode = branchEnd(childScopeId, visit, curNode).b;
-          }
-        }
-      }
-    }
-    let resumes = this.r;
-    if (resumes) {
-      this.r = [];
-      let len = resumes.length, i = 0;
-      try {
-        for (isResuming = !0; i < len; ) {
-          let resumeData = resumes[i++];
-          if (typeof resumeData == "function") {
-            let scopes = resumeData(serializeContext), { $global } = scopeLookup;
-            $global || (scopeLookup.$global = $global = scopes.$ || {}, $global.runtimeId = this.G, $global.renderId = this.t, $global.g = 1e6);
-            for (let scopeId in scopes)
-              if (scopeId !== "$") {
-                let scope = scopes[scopeId], prevScope = scopeLookup[scopeId];
-                scope.$global = $global, scope.d = +scopeId, prevScope !== scope && (scopeLookup[scopeId] = Object.assign(
-                  scope,
-                  prevScope
-                ));
-                let parentBranchId = parentBranchIds.get(scopeId);
-                if (parentBranchId && (scope.c = scopes[parentBranchId]), branchIds.has(scopeId)) {
-                  let branch = scope, parentBranch = branch.c;
-                  scope.c = branch, parentBranch && (branch.x = parentBranch, (parentBranch.n ||= /* @__PURE__ */ new Set()).add(branch));
+var registeredValues = {};
+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 = {
+          _: registeredValues
+        }, branchIds = /* @__PURE__ */ new Set(), parentBranchIds = /* @__PURE__ */ new Map(), closestBranchMarkers = /* @__PURE__ */ new Map(), currentScopeId;
+        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) => {
+              let branch = scopeLookup[branchId] ||= {}, endNode = reference;
+              for (; visitNodes.has(endNode = endNode.previousSibling); ) ;
+              endNode === lastEndNode && (endNode = reference.parentNode.insertBefore(
+                new Text(),
+                reference
+              )), branch.b = lastEndNode = endNode, branch.a ||= endNode;
+              for (let [markerScopeId, markerNode] of closestBranchMarkers)
+                branch.a.compareDocumentPosition(markerNode) & 4 && reference.compareDocumentPosition(markerNode) & 2 && (parentBranchIds.set(markerScopeId, branchId), closestBranchMarkers.delete(markerScopeId));
+              return branchIds.add(branchId), closestBranchMarkers.set(branchId, visit), branch;
+            };
+            for (let visit of visits) {
+              let commentText = visit.data, dataIndex = commentText.indexOf(" ") + 1, scopeId = commentText.slice(
+                commentPrefixLen + 1,
+                dataIndex ? dataIndex - 1 : commentText.length
+              ), scope = scopeLookup[scopeId] ||= {
+                e: +scopeId
+              }, data2 = dataIndex ? commentText.slice(dataIndex) : "", token = commentText[commentPrefixLen];
+              if (token === "*" /* Node */) {
+                let node = scope[data2] = visit.previousSibling;
+                scope[data2 + ">" /* Getter */] = () => 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.a = visit;
+              else if (token === "]" /* BranchEnd */) {
+                scope[data2] = visit;
+                let curParent = visit.parentNode, startNode = branchEnd(
+                  currentScopeId,
+                  visit,
+                  visit
+                ).a;
+                curParent !== startNode.parentNode && curParent.prepend(startNode), currentScopeId = scopeStack.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; ) {
+                  let start = next + 1;
+                  next = data2.indexOf(" ", start);
+                  let childScopeId = data2.slice(
+                    start,
+                    ~next ? next : data2.length
+                  );
+                  curNode = branchEnd(childScopeId, visit, curNode).b;
                 }
               }
-          } else i === len || typeof resumes[i] != "string" ? delete this.F[this.t] : registeredValues[resumes[i++]](
-            scopeLookup[resumeData],
-            scopeLookup[resumeData]
-          );
-        }
-      } finally {
-        isResuming = !1;
+            }
+          }
+          if (resumes)
+            try {
+              render.r = [], isResuming = !0;
+              for (let i = 0; i < resumes.length; i++) {
+                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.f = 1e6);
+                  for (let scopeId in scopes)
+                    if (scopeId !== "$") {
+                      let scope = scopes[scopeId], prevScope = scopeLookup[scopeId];
+                      scope.$global = $global, scope.e = +scopeId, prevScope !== scope && (scopeLookup[scopeId] = Object.assign(
+                        scope,
+                        prevScope
+                      ));
+                      let parentBranchId = parentBranchIds.get(scopeId);
+                      if (parentBranchId && (scope.c = scopes[parentBranchId]), branchIds.has(scopeId)) {
+                        let branch = scope, parentBranch = branch.c;
+                        scope.c = branch, parentBranch && (branch.g = parentBranch, (parentBranch.o ||= /* @__PURE__ */ new Set()).add(
+                          branch
+                        ));
+                      }
+                    }
+                } else
+                  registeredValues[resumes[++i]](
+                    scopeLookup[serialized],
+                    scopeLookup[serialized]
+                  );
+              }
+            } finally {
+              isResuming = !1;
+            }
+        }, render;
       }
-    }
-  }
-}, isResuming = !1;
+    });
+  };
+  if (renders) {
+    initRuntime(renders);
+    for (let renderId in renders)
+      resumeRender(renderId).w();
+  } else
+    defineRuntime({
+      configurable: !0,
+      set: initRuntime
+    });
+}
+var isResuming = !1;
 function register(id, obj) {
   return registeredValues[id] = obj, obj;
 }
@@ -302,22 +324,6 @@ function getRegisteredWithScope(id, scope) {
   let val = registeredValues[id];
   return scope ? val(scope) : val;
 }
-function init(runtimeId = DEFAULT_RUNTIME_ID) {
-  let resumeRender = (renderId) => resumeRender[renderId] = renders[renderId] = new Render(renders, runtimeId, renderId), renders;
-  window[runtimeId] ? setRenders(window[runtimeId]) : Object.defineProperty(window, runtimeId, {
-    configurable: !0,
-    set: setRenders
-  });
-  function setRenders(v) {
-    renders = v;
-    for (let renderId in v)
-      resumeRender(renderId);
-    Object.defineProperty(window, runtimeId, {
-      configurable: !0,
-      value: resumeRender
-    });
-  }
-}
 function nodeRef(id, key) {
   return register(id, (scope) => () => scope[key]());
 }
@@ -712,7 +718,7 @@ function toInsertNode(startNode, endNode) {
 var pendingScopes = [];
 function createScope($global, closestBranch) {
   let scope = {
-    d: $global.g++,
+    e: $global.f++,
     h: 1,
     c: closestBranch,
     $global
@@ -720,7 +726,7 @@ function createScope($global, closestBranch) {
   return pendingScopes.push(scope), scope;
 }
 function skipScope(scope) {
-  return scope.$global.g++;
+  return scope.$global.f++;
 }
 function finishPendingScopes() {
   for (let scope of pendingScopes)
@@ -728,12 +734,12 @@ function finishPendingScopes() {
   pendingScopes = [];
 }
 function destroyBranch(branch) {
-  branch.x?.n?.delete(branch), destroyNestedBranches(branch);
+  branch.g?.o?.delete(branch), destroyNestedBranches(branch);
 }
 function destroyNestedBranches(branch) {
-  branch.y = 1, branch.n?.forEach(destroyNestedBranches), branch.I?.forEach((scope) => {
-    for (let id in scope.k)
-      scope.k[id]?.abort();
+  branch.k = 1, branch.o?.forEach(destroyNestedBranches), branch.A?.forEach((scope) => {
+    for (let id in scope.l)
+      scope.l[id]?.abort();
   });
 }
 function removeAndDestroyBranch(branch) {
@@ -747,90 +753,15 @@ function insertBranchBefore(branch, parentNode, nextSibling) {
     branch.b
   );
 }
-
-// src/dom/queue.ts
-var pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map(), pendingEffects = [], rendering = !1, scopeKeyOffset = 1e3;
-function queueRender(scope, signal, signalKey, value2, scopeKey = scope.d) {
-  let key = scopeKey * scopeKeyOffset + signalKey, existingRender = signalKey >= 0 && pendingRendersLookup.get(key);
-  if (existingRender)
-    existingRender.z = value2;
-  else {
-    let render = {
-      j: key,
-      A: scope,
-      J: signal,
-      z: value2
-    }, i = pendingRenders.push(render) - 1;
-    for (; i; ) {
-      let parentIndex = i - 1 >> 1, parent = pendingRenders[parentIndex];
-      if (key - parent.j >= 0) break;
-      pendingRenders[i] = parent, i = parentIndex;
-    }
-    signalKey >= 0 && pendingRendersLookup.set(key, render), pendingRenders[i] = render;
-  }
-}
-function queueEffect(scope, fn) {
-  pendingEffects.push(fn, scope);
-}
-function run() {
-  let effects = pendingEffects;
-  try {
-    rendering = !0, runRenders();
-  } finally {
-    pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map(), pendingEffects = [], rendering = !1;
-  }
-  runEffects(effects);
-}
-function prepareEffects(fn) {
-  let prevRenders = pendingRenders, prevRendersLookup = pendingRendersLookup, prevEffects = pendingEffects, preparedEffects = pendingEffects = [];
-  pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map();
-  try {
-    rendering = !0, fn(), runRenders();
-  } finally {
-    rendering = !1, pendingRenders = prevRenders, pendingRendersLookup = prevRendersLookup, pendingEffects = prevEffects;
-  }
-  return preparedEffects;
-}
-function 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).j;
-      for (; i < mid; ) {
-        let bestChild = (i << 1) + 1, right = bestChild + 1;
-        if (right < pendingRenders.length && pendingRenders[right].j - pendingRenders[bestChild].j < 0 && (bestChild = right), pendingRenders[bestChild].j - key >= 0)
-          break;
-        pendingRenders[i] = pendingRenders[bestChild], i = bestChild;
-      }
-      pendingRenders[i] = item;
-    }
-    render.A.c?.y || render.J(render.A, render.z);
-  }
-  finishPendingScopes();
-}
-
-// src/dom/abort-signal.ts
-function resetAbortSignal(scope, id) {
-  let ctrl = scope.k?.[id];
-  ctrl && (queueEffect(ctrl, abort), scope.k[id] = void 0);
-}
-function getAbortSignal(scope, id) {
-  return scope.c && (scope.c.I ||= /* @__PURE__ */ new Set()).add(scope), ((scope.k ||= {})[id] ||= new AbortController()).signal;
-}
-function abort(ctrl) {
-  ctrl.abort();
+function tempDetatchBranch(branch) {
+  insertChildNodes(
+    branch.a.ownerDocument.createDocumentFragment(),
+    null,
+    branch.a,
+    branch.b
+  );
 }
 
-// src/common/compat-meta.ts
-var prefix = "$C_", RENDERER_REGISTER_ID = prefix + "r", SET_SCOPE_REGISTER_ID = prefix + "s", RENDER_BODY_ID = prefix + "b";
-
 // src/dom/reconcile.ts
 var WRONG_POS = 2147483647;
 function reconcile(parent, oldBranches, newBranches, afterReference) {
@@ -948,7 +879,7 @@ function walkInternal(currentWalkIndex, walkCodes, scope) {
 // src/dom/renderer.ts
 function createBranch($global, renderer, parentScope, parentNode) {
   let branch = createScope($global), parentBranch = parentScope?.c;
-  return branch._ = renderer.l || parentScope, branch.c = branch, parentBranch && (branch.x = parentBranch, (parentBranch.n ||= /* @__PURE__ */ new Set()).add(branch)), renderer.o?.(
+  return branch._ = renderer.m || parentScope, branch.c = branch, parentBranch && (branch.g = parentBranch, (parentBranch.o ||= /* @__PURE__ */ new Set()).add(branch)), renderer.p?.(
     branch,
     parentNode.namespaceURI
   ), branch;
@@ -960,10 +891,10 @@ function createAndSetupBranch($global, renderer, parentScope, parentNode) {
   );
 }
 function setupBranch(renderer, branch) {
-  return (renderer.p || renderer.B) && queueRender(
+  return (renderer.q || renderer.u) && queueRender(
     branch,
     (branch2) => {
-      renderer.p?.(branch2), renderer.B?.(branch2);
+      renderer.q?.(branch2), renderer.u?.(branch2);
     },
     -1
   ), branch;
@@ -983,13 +914,13 @@ function createContent(id, template, walks, setup, params, closures, dynamicScop
     );
   };
   return (owner) => ({
-    d: id,
-    o: clone,
-    l: owner,
-    p: setup,
-    e: params,
-    B: closures,
-    m: dynamicScopesAccessor
+    e: id,
+    p: clone,
+    m: owner,
+    q: setup,
+    d: params,
+    u: closures,
+    n: dynamicScopesAccessor
   });
 }
 function registerContent(id, template, walks, setup, params, closures, dynamicScopesAccessor) {
@@ -1061,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__ */ "d") {
+function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "e") {
   return (scope) => {
     scope.h ? scope[id] === void 0 ? scope[id] = defaultPending : --scope[id] || fn(scope) : queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
   };
@@ -1073,11 +1004,11 @@ function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
       ownerScope,
       () => {
         for (let scope of scopes)
-          !scope.h && !scope.y && childSignal(scope);
+          !scope.h && !scope.k && childSignal(scope);
       },
       -1,
       0,
-      firstScope.d
+      firstScope.e
     );
   };
   return ownerSignal._ = childSignal, ownerSignal;
@@ -1097,9 +1028,9 @@ function subscribeToScopeSet(ownerScope, accessor, scope) {
   ));
 }
 function dynamicClosure(...closureSignals) {
-  let [{ C: ___scopeInstancesAccessor, D: ___signalIndexAccessor }] = closureSignals;
+  let [{ x: ___scopeInstancesAccessor, y: ___signalIndexAccessor }] = closureSignals;
   for (let i = closureSignals.length; i--; )
-    closureSignals[i].K = i;
+    closureSignals[i].B = i;
   return (scope) => {
     if (scope[___scopeInstancesAccessor])
       for (let childScope of scope[___scopeInstancesAccessor])
@@ -1112,13 +1043,13 @@ function dynamicClosure(...closureSignals) {
 }
 function dynamicClosureRead(valueAccessor, fn, getOwnerScope) {
   let childSignal = closure(valueAccessor, fn, getOwnerScope), closureSignal = (scope) => {
-    scope[closureSignal.D] = closureSignal.K, childSignal(scope), subscribeToScopeSet(
+    scope[closureSignal.y] = closureSignal.B, childSignal(scope), subscribeToScopeSet(
       getOwnerScope ? getOwnerScope(scope) : scope._,
-      closureSignal.C,
+      closureSignal.x,
       scope
     );
   };
-  return closureSignal.C = valueAccessor + "!" /* ClosureScopes */, closureSignal.D = valueAccessor + "(" /* ClosureSignalIndex */, closureSignal;
+  return closureSignal.x = valueAccessor + "!" /* ClosureScopes */, closureSignal.y = valueAccessor + "(" /* ClosureSignalIndex */, closureSignal;
 }
 function closure(valueAccessor, fn, getOwnerScope) {
   return (scope) => {
@@ -1157,6 +1088,94 @@ function hoist(...path) {
 }
 
 // src/dom/control-flow.ts
+function awaitTag(nodeAccessor, renderer) {
+  let promiseAccessor = nodeAccessor + "?" /* Promise */, branchAccessor = nodeAccessor + "!" /* ConditionalScope */;
+  return (scope, promise) => {
+    let tryBranch = scope.c, awaitBranch = scope[branchAccessor], referenceNode = scope[nodeAccessor], namespaceNode = (awaitBranch?.a ?? referenceNode).parentNode;
+    for (; tryBranch && !tryBranch["%" /* PlaceholderContent */]; )
+      tryBranch = tryBranch.g;
+    let thisPromise = scope[promiseAccessor] = promise.then((data2) => {
+      if (scope.c?.k || 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.d?.(awaitBranch, [data2]);
+      });
+      if (tryBranch) {
+        if (!--tryBranch["." /* PendingCount */]) {
+          let placeholderBranch = tryBranch["#" /* PlaceholderBranch */];
+          placeholderBranch ? (insertBranchBefore(
+            tryBranch,
+            placeholderBranch.a.parentNode,
+            placeholderBranch.a
+          ), removeAndDestroyBranch(placeholderBranch)) : insertBranchBefore(
+            tryBranch,
+            referenceNode.parentNode,
+            referenceNode
+          );
+        }
+      } else
+        runEffects(effects);
+    }).catch((error) => {
+      let tryBranch2 = scope.c;
+      for (; tryBranch2 && !tryBranch2["^" /* CatchContent */]; )
+        tryBranch2 = tryBranch2.g;
+      tryBranch2 ? (setConditionalRenderer(
+        tryBranch2._,
+        tryBranch2["*" /* BranchAccessor */],
+        tryBranch2["^" /* CatchContent */],
+        createAndSetupBranch
+      ), tryBranch2["^" /* CatchContent */].d?.(
+        tryBranch2._[tryBranch2["*" /* BranchAccessor */] + "!" /* ConditionalScope */],
+        [error]
+      )) : setTimeout(() => {
+        throw error;
+      });
+    });
+    tryBranch ? (tryBranch["." /* PendingCount */] || (tryBranch["." /* PendingCount */] = 0, requestAnimationFrame(() => {
+      if (tryBranch["." /* PendingCount */] && !tryBranch.k) {
+        let placeholderBranch = tryBranch["#" /* PlaceholderBranch */] = createAndSetupBranch(
+          scope.$global,
+          tryBranch["%" /* PlaceholderContent */],
+          tryBranch._,
+          tryBranch.a.parentNode
+        );
+        insertBranchBefore(
+          placeholderBranch,
+          tryBranch.a.parentNode,
+          tryBranch.a
+        ), tempDetatchBranch(tryBranch);
+      }
+    })), tryBranch["." /* PendingCount */]++) : awaitBranch && (awaitBranch.a.parentNode.insertBefore(
+      referenceNode,
+      awaitBranch.a
+    ), tempDetatchBranch(awaitBranch));
+  };
+}
+function createTry(nodeAccessor, tryContent) {
+  let branchAccessor = nodeAccessor + "!" /* ConditionalScope */;
+  return (scope, input) => {
+    scope[branchAccessor] || setConditionalRenderer(
+      scope,
+      nodeAccessor,
+      tryContent,
+      createAndSetupBranch
+    );
+    let branch = scope[branchAccessor];
+    branch && (branch["*" /* BranchAccessor */] = nodeAccessor, branch["^" /* CatchContent */] = normalizeDynamicRenderer(input.catch), branch["%" /* PlaceholderContent */] = normalizeDynamicRenderer(
+      input.placeholder
+    ));
+  };
+}
 function conditional(nodeAccessor, ...branches) {
   let branchAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
   return (scope, newBranch) => {
@@ -1175,7 +1194,7 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
   let childScopeAccessor = nodeAccessor + "!" /* ConditionalScope */, rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
   return (scope, newRenderer, getInput) => {
     let normalizedRenderer = normalizeDynamicRenderer(newRenderer);
-    if (scope[rendererAccessor] !== (scope[rendererAccessor] = normalizedRenderer?.d || normalizedRenderer) || getContent && !(normalizedRenderer || scope[childScopeAccessor]))
+    if (scope[rendererAccessor] !== (scope[rendererAccessor] = normalizedRenderer?.e || normalizedRenderer) || getContent && !(normalizedRenderer || scope[childScopeAccessor]))
       if (setConditionalRenderer(
         scope,
         nodeAccessor,
@@ -1189,15 +1208,15 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
             0,
             content,
             createAndSetupBranch
-          ), content.m && subscribeToScopeSet(
-            content.l,
+          ), content.n && subscribeToScopeSet(
             content.m,
+            content.n,
             scope[childScopeAccessor][0 + "!" /* ConditionalScope */]
           );
         }
-      } else normalizedRenderer?.m && subscribeToScopeSet(
-        normalizedRenderer.l,
+      } else normalizedRenderer?.n && subscribeToScopeSet(
         normalizedRenderer.m,
+        normalizedRenderer.n,
         scope[childScopeAccessor]
       );
     if (normalizedRenderer) {
@@ -1208,9 +1227,9 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
           0,
           (inputIsArgs ? args[0] : args) || {}
         );
-      else if (normalizedRenderer.e)
+      else if (normalizedRenderer.d)
         if (inputIsArgs)
-          normalizedRenderer.e(
+          normalizedRenderer.d(
             scope[childScopeAccessor],
             normalizedRenderer._ ? args[0] : args
           );
@@ -1219,7 +1238,7 @@ var dynamicTag = function(nodeAccessor, getContent, getTagVar, inputIsArgs) {
             ...args,
             content: getContent(scope)
           } : args || {};
-          normalizedRenderer.e(
+          normalizedRenderer.d(
             scope[childScopeAccessor],
             normalizedRenderer._ ? inputWithContent : [inputWithContent]
           );
@@ -1258,7 +1277,7 @@ function loopTo(nodeAccessor, renderer) {
   );
 }
 function loop(nodeAccessor, renderer, forEach) {
-  let params = renderer.e;
+  let params = renderer.d;
   return (scope, value2) => {
     let referenceNode = scope[nodeAccessor], oldMap = scope[nodeAccessor + "(" /* LoopScopeMap */], oldArray = oldMap ? scope[nodeAccessor + "!" /* LoopScopeArray */] || [
       ...oldMap.values()
@@ -1290,6 +1309,113 @@ function byFirstArg(name) {
   return name;
 }
 
+// src/dom/queue.ts
+var pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map(), pendingEffects = [], rendering = !1, scopeKeyOffset = 1e3;
+function queueRender(scope, signal, signalKey, value2, scopeKey = scope.e) {
+  let key = scopeKey * scopeKeyOffset + signalKey, existingRender = signalKey >= 0 && pendingRendersLookup.get(key);
+  if (existingRender)
+    existingRender.z = value2;
+  else {
+    let render = {
+      j: key,
+      t: scope,
+      C: signal,
+      z: value2
+    }, i = pendingRenders.push(render) - 1;
+    for (; i; ) {
+      let parentIndex = i - 1 >> 1, parent = pendingRenders[parentIndex];
+      if (key - parent.j >= 0) break;
+      pendingRenders[i] = parent, i = parentIndex;
+    }
+    signalKey >= 0 && pendingRendersLookup.set(key, render), pendingRenders[i] = render;
+  }
+}
+function queueEffect(scope, fn) {
+  pendingEffects.push(fn, scope);
+}
+function run() {
+  let effects = pendingEffects;
+  try {
+    rendering = !0, runRenders();
+  } finally {
+    pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map(), pendingEffects = [], rendering = !1;
+  }
+  runEffects(effects);
+}
+function prepareEffects(fn) {
+  let prevRenders = pendingRenders, prevRendersLookup = pendingRendersLookup, prevEffects = pendingEffects, preparedEffects = pendingEffects = [];
+  pendingRenders = [], pendingRendersLookup = /* @__PURE__ */ new Map();
+  try {
+    rendering = !0, fn(), runRenders();
+  } finally {
+    rendering = !1, pendingRenders = prevRenders, pendingRendersLookup = prevRendersLookup, pendingEffects = prevEffects;
+  }
+  return preparedEffects;
+}
+function 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).j;
+      for (; i < mid; ) {
+        let bestChild = (i << 1) + 1, right = bestChild + 1;
+        if (right < pendingRenders.length && pendingRenders[right].j - pendingRenders[bestChild].j < 0 && (bestChild = right), pendingRenders[bestChild].j - key >= 0)
+          break;
+        pendingRenders[i] = pendingRenders[bestChild], i = bestChild;
+      }
+      pendingRenders[i] = item;
+    }
+    render.t.c?.k || runRender(render);
+  }
+  finishPendingScopes();
+}
+var runRender = (render) => render.C(render.t, render.z), enableCatch = () => {
+  enableCatch = () => {
+  }, runRender = /* @__PURE__ */ ((runRender2) => (render) => {
+    try {
+      runRender2(render);
+    } catch (error) {
+      let branch = render.t.c;
+      for (; branch && !branch["^" /* CatchContent */]; )
+        branch = branch.g;
+      if (branch)
+        setConditionalRenderer(
+          branch._,
+          branch["*" /* BranchAccessor */],
+          branch["^" /* CatchContent */],
+          createAndSetupBranch
+        ), branch["^" /* CatchContent */].d?.(
+          branch._[branch["*" /* BranchAccessor */] + "!" /* ConditionalScope */],
+          [error]
+        );
+      else
+        throw error;
+    }
+  })(runRender);
+};
+
+// src/dom/abort-signal.ts
+function resetAbortSignal(scope, id) {
+  let ctrl = scope.l?.[id];
+  ctrl && (queueEffect(ctrl, abort), scope.l[id] = void 0);
+}
+function getAbortSignal(scope, id) {
+  return scope.c && (scope.c.A ||= /* @__PURE__ */ new Set()).add(scope), ((scope.l ||= {})[id] ||= new AbortController()).signal;
+}
+function abort(ctrl) {
+  ctrl.abort();
+}
+
+// src/common/compat-meta.ts
+var prefix = "$C_", RENDERER_REGISTER_ID = prefix + "r", SET_SCOPE_REGISTER_ID = prefix + "s", RENDER_BODY_ID = prefix + "b";
+
 // src/dom/compat.ts
 var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
   patchDynamicTag,
@@ -1303,7 +1429,7 @@ var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
     register(RENDERER_REGISTER_ID, fn);
   },
   isRenderer(renderer) {
-    return renderer.o;
+    return renderer.p;
   },
   getStartNode(branch) {
     return branch.a;
@@ -1328,7 +1454,7 @@ var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
   },
   createRenderer(params, clone) {
     let renderer = createRenderer(0, 0, 0, params);
-    return renderer.o = (branch) => {
+    return renderer.p = (branch) => {
       let cloned = clone();
       branch.a = cloned.startNode, branch.b = cloned.endNode;
     }, renderer;
@@ -1343,12 +1469,12 @@ var classIdToBranch = /* @__PURE__ */ new Map(), compat = {
         normalizedInput[key === "renderBody" ? "content" : key] = input[key];
     }
     if (component.effects = prepareEffects(() => {
-      branch ? existing = !0 : (out.global.g ||= 0, branch = component.scope = createAndSetupBranch(
+      branch ? existing = !0 : (out.global.f ||= 0, branch = component.scope = createAndSetupBranch(
         out.global,
         renderer,
-        renderer.l,
+        renderer.m,
         document.body
-      )), renderer.e?.(branch, renderer._ ? args[0] : args);
+      )), renderer.d?.(branch, renderer._ ? args[0] : args);
     }), !existing)
       return toInsertNode(branch.a, branch.b);
   }
@@ -1368,12 +1494,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 = {
-    g: 0,
+    f: 0,
     runtimeId: DEFAULT_RUNTIME_ID,
     renderId: DEFAULT_RENDER_ID,
     ...$global
   }) : $global = {
-    g: 0,
+    f: 0,
     runtimeId: DEFAULT_RUNTIME_ID,
     renderId: DEFAULT_RENDER_ID
   }, position) {
@@ -1387,13 +1513,13 @@ function mount(input = {}, reference, position) {
       parentNode = reference.parentNode, nextSibling = reference.nextSibling;
       break;
   }
-  let args = this.e, effects = prepareEffects(() => {
+  let args = this.d, effects = prepareEffects(() => {
     branch = createBranch(
       $global,
       this,
       void 0,
       parentNode
-    ), this.p?.(branch), args?.(branch, input);
+    ), this.q?.(branch), args?.(branch, input);
   });
   return insertChildNodes(
     parentNode,