marko 6.0.119 → 6.0.120

package/dist/debug/dom.mjs

@@ -264,6 +264,14 @@ function stripSpacesAndPunctuation(str) {
   return str.replace(/[^\p{L}\p{N}]/gu, "");
 }
 
+// src/dom/parse-html.ts
+var parsers = {};
+function parseHTML(html, ns) {
+  const parser = parsers[ns] ||= document.createElementNS(ns, "template");
+  parser.innerHTML = html;
+  return parser.content || parser;
+}
+
 // src/dom/scope.ts
 var nextScopeId = 1e6;
 function createScope($global, closestBranch) {
@@ -327,6 +335,247 @@ function tempDetachBranch(branch) {
   );
 }
 
+// src/dom/schedule.ts
+var runTask;
+var isScheduled;
+var channel;
+function schedule() {
+  if (!isScheduled) {
+    if (true) {
+      if (console.createTask) {
+        const task = console.createTask("queue");
+        runTask = () => task.run(run);
+      } else {
+        runTask = run;
+      }
+    }
+    isScheduled = 1;
+    queueMicrotask(flushAndWaitFrame);
+  }
+}
+function flushAndWaitFrame() {
+  if (true) {
+    runTask();
+  } else {
+    run();
+  }
+  requestAnimationFrame(triggerMacroTask);
+}
+function triggerMacroTask() {
+  if (!channel) {
+    channel = new MessageChannel();
+    channel.port1.onmessage = () => {
+      isScheduled = 0;
+      if (true) {
+        const run2 = runTask;
+        runTask = void 0;
+        run2();
+      } else {
+        run();
+      }
+    };
+  }
+  channel.port2.postMessage(0);
+}
+
+// src/dom/signals.ts
+function _let(id, fn) {
+  const valueAccessor = true ? id.slice(0, id.lastIndexOf("/")) : decodeAccessor(id);
+  const valueChangeAccessor = "TagVariableChange:" /* TagVariableChange */ + valueAccessor;
+  if (true) {
+    id = +id.slice(id.lastIndexOf("/") + 1);
+  }
+  return (scope, value, valueChange) => {
+    if (rendering) {
+      if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value || scope["#Creating" /* Creating */]) {
+        scope[valueAccessor] = value;
+        fn?.(scope);
+      }
+    } else if (scope[valueChangeAccessor]) {
+      scope[valueChangeAccessor](value);
+    } else if (scope[valueAccessor] !== (scope[valueAccessor] = value) && fn) {
+      schedule();
+      queueRender(scope, fn, id);
+    }
+    return value;
+  };
+}
+function _const(valueAccessor, fn) {
+  if (false) valueAccessor = decodeAccessor(valueAccessor);
+  return (scope, value) => {
+    if (!(valueAccessor in scope) || scope[valueAccessor] !== value) {
+      scope[valueAccessor] = value;
+      fn?.(scope);
+    }
+  };
+}
+function _or(id, fn, defaultPending = 1, scopeIdAccessor = "#Id" /* Id */) {
+  return (scope) => {
+    if (scope["#Creating" /* Creating */]) {
+      if (id in scope) {
+        if (!--scope[id]) {
+          fn(scope);
+        }
+      } else {
+        scope[id] = defaultPending;
+      }
+    } else {
+      queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
+    }
+  };
+}
+function _for_closure(ownerLoopNodeAccessor, fn) {
+  if (false)
+    ownerLoopNodeAccessor = decodeAccessor(ownerLoopNodeAccessor);
+  const scopeAccessor = "BranchScopes:" /* BranchScopes */ + ownerLoopNodeAccessor;
+  const ownerSignal = (ownerScope) => {
+    const scopes = toArray(ownerScope[scopeAccessor]);
+    if (scopes.length) {
+      queueRender(
+        ownerScope,
+        () => {
+          for (const scope of scopes) {
+            if (!scope["#Creating" /* Creating */] && !scope["#Destroyed" /* Destroyed */]) {
+              fn(scope);
+            }
+          }
+        },
+        -1,
+        0,
+        scopes[0]["#Id" /* Id */]
+      );
+    }
+  };
+  ownerSignal._ = fn;
+  return ownerSignal;
+}
+function _if_closure(ownerConditionalNodeAccessor, branch, fn) {
+  if (false)
+    ownerConditionalNodeAccessor = decodeAccessor(
+      ownerConditionalNodeAccessor
+    );
+  const scopeAccessor = "BranchScopes:" /* BranchScopes */ + ownerConditionalNodeAccessor;
+  const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + ownerConditionalNodeAccessor;
+  const ownerSignal = (scope) => {
+    const ifScope = scope[scopeAccessor];
+    if (ifScope && !ifScope["#Creating" /* Creating */] && (scope[branchAccessor] || 0) === branch) {
+      queueRender(ifScope, fn, -1);
+    }
+  };
+  ownerSignal._ = fn;
+  return ownerSignal;
+}
+function subscribeToScopeSet(ownerScope, accessor, scope) {
+  const subscribers = ownerScope[accessor] ||= /* @__PURE__ */ new Set();
+  if (!subscribers.has(scope)) {
+    subscribers.add(scope);
+    $signal(scope, -1).addEventListener(
+      "abort",
+      () => ownerScope[accessor].delete(scope)
+    );
+  }
+}
+function _closure(...closureSignals) {
+  const [{ ___scopeInstancesAccessor, ___signalIndexAccessor }] = closureSignals;
+  for (let i = closureSignals.length; i--; ) {
+    closureSignals[i].___index = i;
+  }
+  return (scope) => {
+    if (scope[___scopeInstancesAccessor]) {
+      for (const childScope of scope[___scopeInstancesAccessor]) {
+        if (!childScope["#Creating" /* Creating */]) {
+          queueRender(
+            childScope,
+            closureSignals[childScope[___signalIndexAccessor]],
+            -1
+          );
+        }
+      }
+    }
+  };
+}
+function _closure_get(valueAccessor, fn, getOwnerScope, resumeId) {
+  if (false) valueAccessor = decodeAccessor(valueAccessor);
+  const closureSignal = ((scope) => {
+    scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
+    fn(scope);
+    subscribeToScopeSet(
+      getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */],
+      closureSignal.___scopeInstancesAccessor,
+      scope
+    );
+  });
+  closureSignal.___scopeInstancesAccessor = "ClosureScopes:" /* ClosureScopes */ + valueAccessor;
+  closureSignal.___signalIndexAccessor = "ClosureSignalIndex:" /* ClosureSignalIndex */ + valueAccessor;
+  resumeId && _resume(resumeId, closureSignal);
+  return closureSignal;
+}
+function _child_setup(setup) {
+  setup._ = (scope, owner) => {
+    scope["_" /* Owner */] = owner;
+    queueRender(scope, setup, -1);
+  };
+  return setup;
+}
+function _var(scope, childAccessor, signal) {
+  scope[true ? childAccessor : decodeAccessor(childAccessor)]["#TagVariable" /* TagVariable */] = (value) => signal(scope, value);
+}
+var _return = (scope, value) => scope["#TagVariable" /* TagVariable */]?.(value);
+function _return_change(scope, changeHandler) {
+  if (changeHandler) {
+    scope["#TagVariableChange" /* TagVariableChange */] = changeHandler;
+  }
+}
+var _var_change = true ? (scope, value, name = "This") => {
+  if (typeof scope["#TagVariableChange" /* TagVariableChange */] !== "function") {
+    throw new TypeError(`${name} is a readonly tag variable.`);
+  }
+  scope["#TagVariableChange" /* TagVariableChange */](value);
+} : (scope, value) => scope["#TagVariableChange" /* TagVariableChange */]?.(value);
+var tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
+function _id({ ["$global" /* Global */]: $global }) {
+  const id = tagIdsByGlobal.get($global) || 0;
+  tagIdsByGlobal.set($global, id + 1);
+  return "c" + $global.runtimeId + $global.renderId + id.toString(36);
+}
+function _script(id, fn) {
+  _resume(id, fn);
+  return (scope) => {
+    queueEffect(scope, fn);
+  };
+}
+function _el_read(value) {
+  if (rendering) {
+    _el_read_error();
+  }
+  return value;
+}
+function* traverseAllHoisted(scope, path, curIndex = path.length - 1) {
+  if (rendering) {
+    _hoist_read_error();
+  }
+  if (scope) {
+    if (Symbol.iterator in scope) {
+      for (const s of scope instanceof Map ? scope.values() : scope) {
+        yield* traverseAllHoisted(s, path, curIndex);
+      }
+    } else if (curIndex) {
+      yield* traverseAllHoisted(scope[path[curIndex]], path, curIndex - 1);
+    } else {
+      yield scope[path[0]];
+    }
+  }
+}
+function _hoist(...path) {
+  if (false)
+    path = path.map((p) => typeof p === "string" ? p : decodeAccessor(p));
+  return (scope) => {
+    const getOne = (...args) => iterator().next().value?.(...args);
+    const iterator = getOne[Symbol.iterator] = () => traverseAllHoisted(scope, path);
+    return getOne;
+  };
+}
+
 // src/dom/walker.ts
 var walker = /* @__PURE__ */ document.createTreeWalker(document);
 function walk(startNode, walkCodes, branch) {
@@ -345,14 +594,14 @@ function walkInternal(currentWalkIndex, walkCodes, scope) {
     storedMultiplier = 0;
     if (value === 32 /* Get */) {
       const node = walker.currentNode;
-      scope[id = true ? getDebugKey(currentScopeIndex++, node) : decodeAccessor(currentScopeIndex++)] = node;
+      scope[id = true ? getDebugKey(currentScopeIndex++, node) : decodeAccessor2(currentScopeIndex++)] = node;
       scope["Getter:" /* Getter */ + id] = () => node;
     } else if (value === 37 /* Replace */ || value === 49 /* DynamicTagWithVar */) {
       walker.currentNode.replaceWith(
-        walker.currentNode = scope[true ? getDebugKey(currentScopeIndex++, "#text") : decodeAccessor(currentScopeIndex++)] = new Text()
+        walker.currentNode = scope[true ? getDebugKey(currentScopeIndex++, "#text") : decodeAccessor2(currentScopeIndex++)] = new Text()
       );
       if (value === 49 /* DynamicTagWithVar */) {
-        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : decodeAccessor(currentScopeIndex++)] = skipScope();
+        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : decodeAccessor2(currentScopeIndex++)] = skipScope();
       }
     } else if (value === 38 /* EndChild */) {
       return currentWalkIndex;
@@ -360,13 +609,13 @@ function walkInternal(currentWalkIndex, walkCodes, scope) {
       currentWalkIndex = walkInternal(
         currentWalkIndex,
         walkCodes,
-        scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : decodeAccessor(currentScopeIndex++)] = createScope(
+        scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : decodeAccessor2(currentScopeIndex++)] = createScope(
           scope["$global" /* Global */],
           scope["#ClosestBranch" /* ClosestBranch */]
         )
       );
       if (value === 48 /* BeginChildWithVar */) {
-        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : decodeAccessor(currentScopeIndex++)] = skipScope();
+        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : decodeAccessor2(currentScopeIndex++)] = skipScope();
       }
     } else if (value < 91 /* NextEnd */ + 1) {
       value = 20 /* Next */ * currentMultiplier + value - 67 /* Next */;
@@ -405,19 +654,116 @@ function getDebugKey(index, node) {
   return index;
 }
 
-// src/dom/resume.ts
-var registeredValues = {};
-var branchesEnabled;
-function enableBranches() {
-  branchesEnabled = 1;
-}
-function init(runtimeId = DEFAULT_RUNTIME_ID) {
+// src/dom/renderer.ts
+function createBranch($global, renderer, parentScope, parentNode) {
+  const branch = createScope($global);
+  branch["_" /* Owner */] = renderer.___owner || parentScope;
+  setParentBranch(branch, parentScope?.["#ClosestBranch" /* ClosestBranch */]);
   if (true) {
-    const descriptor = Object.getOwnPropertyDescriptor(self, runtimeId);
-    if (descriptor && (descriptor.set || descriptor.configurable === false)) {
-      throw new Error(
-        `Marko initialized multiple times with the same $global.runtimeId of ${JSON.stringify(runtimeId)}. It could be that there are multiple copies of Marko running on the page.`
-      );
+    branch["#Renderer" /* Renderer */] = renderer;
+  }
+  renderer.___clone?.(
+    branch,
+    parentNode.namespaceURI
+  );
+  return branch;
+}
+function setParentBranch(branch, parentBranch) {
+  if (parentBranch) {
+    branch["#ParentBranch" /* ParentBranch */] = parentBranch;
+    (parentBranch["#BranchScopes" /* BranchScopes */] ||= /* @__PURE__ */ new Set()).add(branch);
+  }
+  branch["#ClosestBranch" /* ClosestBranch */] = branch;
+}
+function createAndSetupBranch($global, renderer, parentScope, parentNode) {
+  return setupBranch(
+    renderer,
+    createBranch($global, renderer, parentScope, parentNode)
+  );
+}
+function setupBranch(renderer, branch) {
+  if (renderer.___setup) {
+    queueRender(branch, renderer.___setup, -1);
+  }
+  return branch;
+}
+function _content(id, template, walks, setup, params, dynamicScopesAccessor) {
+  walks = walks ? walks.replace(/[^\0-1]+$/, "") : "";
+  setup = setup ? setup._ || setup : void 0;
+  params ||= void 0;
+  const clone = template ? (branch, ns) => {
+    ((cloneCache[ns] ||= {})[template] ||= createCloneableHTML(
+      template,
+      ns
+    ))(branch, walks);
+  } : (branch) => {
+    walk(
+      branch["#StartNode" /* StartNode */] = branch["#EndNode" /* EndNode */] = new Text(),
+      walks,
+      branch
+    );
+  };
+  return (owner) => {
+    return {
+      ___id: id,
+      ___clone: clone,
+      ___owner: owner,
+      ___setup: setup,
+      ___params: params,
+      ___accessor: dynamicScopesAccessor
+    };
+  };
+}
+function _content_resume(id, template, walks, setup, params, dynamicScopesAccessor) {
+  return _resume(
+    id,
+    _content(id, template, walks, setup, params, dynamicScopesAccessor)
+  );
+}
+function _content_closures(renderer, closureFns) {
+  const closureSignals = {};
+  for (const key in closureFns) {
+    closureSignals[key] = _const(true ? key : +key, closureFns[key]);
+  }
+  return (owner, closureValues) => {
+    const instance = renderer(owner);
+    instance.___localClosures = closureSignals;
+    instance.___localClosureValues = closureValues;
+    return instance;
+  };
+}
+var cloneCache = {};
+function createCloneableHTML(html, ns) {
+  const { firstChild, lastChild } = parseHTML(html, ns);
+  const parent = document.createElementNS(ns, "t");
+  insertChildNodes(parent, null, firstChild, lastChild);
+  return firstChild === lastChild && firstChild.nodeType < 8 /* Comment */ ? (branch, walks) => {
+    walk(
+      branch["#StartNode" /* StartNode */] = branch["#EndNode" /* EndNode */] = firstChild.cloneNode(true),
+      walks,
+      branch
+    );
+  } : (branch, walks) => {
+    const clone = parent.cloneNode(true);
+    walk(clone.firstChild, walks, branch);
+    branch["#StartNode" /* StartNode */] = clone.firstChild;
+    branch["#EndNode" /* EndNode */] = clone.lastChild;
+  };
+}
+
+// src/dom/resume.ts
+var registeredValues = {};
+var branchesEnabled;
+function enableBranches() {
+  branchesEnabled = 1;
+}
+function init(runtimeId = DEFAULT_RUNTIME_ID) {
+  if (true) {
+    const descriptor = Object.getOwnPropertyDescriptor(self, runtimeId);
+    if (descriptor && (descriptor.set || descriptor.configurable === false)) {
+      throw new Error(
+        `Marko initialized multiple times with the same $global.runtimeId of ${JSON.stringify(runtimeId)}. It could be that there are multiple copies of Marko running on the page.`
+      );
     }
   }
   const renders = self[runtimeId];
@@ -433,7 +779,7 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
           _: registeredValues
         };
         const visitBranches = branchesEnabled && /* @__PURE__ */ ((branchScopesStack = [], branchStarts = [], orphanBranches = [], curBranchScopes) => {
-          return (branchId, branch, childBranch, endedBranches, accessor, singleNode, parent = visit.parentNode, startVisit = visit, i = orphanBranches.length) => {
+          return (branchId, branch, endedBranches, accessor, singleNode, parent = visit.parentNode, startVisit = visit, i = orphanBranches.length) => {
             if (visitType !== "[" /* BranchStart */) {
               visitScope["Getter:" /* Getter */ + nextToken(
                 /* read accessor */
@@ -452,7 +798,10 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                   ["#Id" /* Id */]: branchId
                 }
               );
-              branch["#ClosestBranch" /* ClosestBranch */] = branch;
+              setParentBranch(branch, branch["#ClosestBranch" /* ClosestBranch */]);
+              if (branch["#AwaitCounter" /* AwaitCounter */] = render.p?.[branchId]) {
+                branch["#AwaitCounter" /* AwaitCounter */].m = render.m;
+              }
               if (singleNode) {
                 while (startVisit.previousSibling && ~visits.indexOf(
                   startVisit = startVisit.previousSibling
@@ -475,10 +824,7 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                 branch["#EndNode" /* EndNode */] = visit.previousSibling === startVisit ? startVisit : parent.insertBefore(new Text(), visit);
               }
               while (i && orphanBranches[--i]["#Id" /* Id */] > branchId) {
-                (childBranch = orphanBranches.pop())["#ParentBranch" /* ParentBranch */] = branch;
-                (branch["#BranchScopes" /* BranchScopes */] ||= /* @__PURE__ */ new Set()).add(
-                  childBranch
-                );
+                setParentBranch(orphanBranches.pop(), branch);
               }
               nextToken(
                 /* read optional next branchId */
@@ -608,7 +954,7 @@ function _var_resume(id, signal) {
   return signal;
 }
 function _el(id, accessor) {
-  const getterAccessor = "Getter:" /* Getter */ + (true ? accessor : decodeAccessor2(accessor));
+  const getterAccessor = "Getter:" /* Getter */ + (true ? accessor : decodeAccessor3(accessor));
   return _resume(id, (scope) => () => {
     return scope[getterAccessor]();
   });
@@ -770,463 +1116,120 @@ function setSelectOptions(el, value, valueChange) {
     } else {
       for (const opt of el.options) {
         opt.defaultSelected = opt.value === normalizedValue;
-      }
-    }
-  }
-}
-function _attr_details_or_dialog_open(scope, nodeAccessor, open, openChange) {
-  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = openChange;
-  if (openChange) {
-    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 4 /* DetailsOrDialogOpen */;
-  } else {
-    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 5 /* None */;
-  }
-  scope[nodeAccessor].open = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = normalizeBoolProp(open);
-}
-function _attr_details_or_dialog_open_script(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  const hasChanged = () => el.open !== scope["ControlledValue:" /* ControlledValue */ + nodeAccessor];
-  syncControllable(
-    el,
-    el.tagName === "DIALOG" ? "close" : "toggle",
-    hasChanged,
-    () => {
-      const openChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
-      if (openChange && hasChanged()) {
-        const newValue = el.open;
-        el.open = !newValue;
-        openChange(newValue);
-        run();
-      }
-    }
-  );
-}
-var inputType = "";
-function setValueAndUpdateSelection(el, value) {
-  if (el.value !== value) {
-    const updatedPosition = resolveCursorPosition(
-      inputType,
-      el.getRootNode().activeElement === el && el.selectionStart,
-      el.value,
-      el.value = value
-    );
-    if (~updatedPosition) {
-      el.setSelectionRange(updatedPosition, updatedPosition);
-    }
-  }
-}
-function setCheckboxValue(scope, nodeAccessor, type, checked, checkedChange) {
-  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = checkedChange;
-  if (checkedChange) {
-    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = type;
-    scope[nodeAccessor].checked = checked;
-  } else {
-    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 5 /* None */;
-    scope[nodeAccessor].defaultChecked = checked;
-  }
-}
-var controllableDelegate = createDelegator();
-function syncControllable(el, event, hasChanged, onChange) {
-  if (!el._) {
-    controllableDelegate(el, event, handleChange);
-    if (el.form) {
-      controllableDelegate(el.form, "reset", handleFormReset);
-    }
-    if (isResuming && hasChanged(el)) {
-      queueMicrotask(onChange);
-    }
-  }
-  el._ = onChange;
-}
-function handleChange(ev) {
-  ev.target._?.(ev);
-}
-function handleFormReset(ev) {
-  const handlers = [];
-  for (const el of ev.target.elements) {
-    if (el._ && hasFormElementChanged(el)) {
-      handlers.push(el._);
-    }
-  }
-  requestAnimationFrame(() => {
-    if (!ev.defaultPrevented) {
-      for (const change of handlers) {
-        change();
-      }
-    }
-  });
-}
-function hasValueChanged(el) {
-  return el.value !== el.defaultValue;
-}
-function hasCheckboxChanged(el) {
-  return el.checked !== el.defaultChecked;
-}
-function hasSelectChanged(el) {
-  for (const opt of el.options) {
-    if (opt.selected !== opt.defaultSelected) {
-      return true;
-    }
-  }
-}
-function hasFormElementChanged(el) {
-  return el.options ? hasSelectChanged(el) : hasValueChanged(el) || hasCheckboxChanged(el);
-}
-function normalizeStrProp(value) {
-  return normalizeAttrValue(value) || "";
-}
-function normalizeBoolProp(value) {
-  return value != null && value !== false;
-}
-function updateList(arr, val, push2) {
-  const index = arr.indexOf(val);
-  return (push2 ? !~index && [...arr, val] : ~index && arr.slice(0, index).concat(arr.slice(index + 1))) || arr;
-}
-function toValueProp(it) {
-  return it.value;
-}
-
-// src/dom/parse-html.ts
-var parsers = {};
-function parseHTML(html, ns) {
-  const parser = parsers[ns] ||= document.createElementNS(ns, "template");
-  parser.innerHTML = html;
-  return parser.content || parser;
-}
-
-// src/dom/schedule.ts
-var runTask;
-var isScheduled;
-var channel;
-function schedule() {
-  if (!isScheduled) {
-    if (true) {
-      if (console.createTask) {
-        const task = console.createTask("queue");
-        runTask = () => task.run(run);
-      } else {
-        runTask = run;
-      }
-    }
-    isScheduled = 1;
-    queueMicrotask(flushAndWaitFrame);
-  }
-}
-function flushAndWaitFrame() {
-  if (true) {
-    runTask();
-  } else {
-    run();
-  }
-  requestAnimationFrame(triggerMacroTask);
-}
-function triggerMacroTask() {
-  if (!channel) {
-    channel = new MessageChannel();
-    channel.port1.onmessage = () => {
-      isScheduled = 0;
-      if (true) {
-        const run2 = runTask;
-        runTask = void 0;
-        run2();
-      } else {
-        run();
-      }
-    };
-  }
-  channel.port2.postMessage(0);
-}
-
-// src/dom/signals.ts
-function _let(id, fn) {
-  const valueAccessor = true ? id.slice(0, id.lastIndexOf("/")) : decodeAccessor3(id);
-  const valueChangeAccessor = "TagVariableChange:" /* TagVariableChange */ + valueAccessor;
-  if (true) {
-    id = +id.slice(id.lastIndexOf("/") + 1);
-  }
-  return (scope, value, valueChange) => {
-    if (rendering) {
-      if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value || scope["#Creating" /* Creating */]) {
-        scope[valueAccessor] = value;
-        fn?.(scope);
-      }
-    } else if (scope[valueChangeAccessor]) {
-      scope[valueChangeAccessor](value);
-    } else if (scope[valueAccessor] !== (scope[valueAccessor] = value) && fn) {
-      schedule();
-      queueRender(scope, fn, id);
-    }
-    return value;
-  };
-}
-function _const(valueAccessor, fn) {
-  if (false) valueAccessor = decodeAccessor3(valueAccessor);
-  return (scope, value) => {
-    if (!(valueAccessor in scope) || scope[valueAccessor] !== value) {
-      scope[valueAccessor] = value;
-      fn?.(scope);
-    }
-  };
-}
-function _or(id, fn, defaultPending = 1, scopeIdAccessor = "#Id" /* Id */) {
-  return (scope) => {
-    if (scope["#Creating" /* Creating */]) {
-      if (id in scope) {
-        if (!--scope[id]) {
-          fn(scope);
-        }
-      } else {
-        scope[id] = defaultPending;
-      }
-    } else {
-      queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
-    }
-  };
-}
-function _for_closure(ownerLoopNodeAccessor, fn) {
-  if (false)
-    ownerLoopNodeAccessor = decodeAccessor3(ownerLoopNodeAccessor);
-  const scopeAccessor = "BranchScopes:" /* BranchScopes */ + ownerLoopNodeAccessor;
-  const ownerSignal = (ownerScope) => {
-    const scopes = toArray(ownerScope[scopeAccessor]);
-    if (scopes.length) {
-      queueRender(
-        ownerScope,
-        () => {
-          for (const scope of scopes) {
-            if (!scope["#Creating" /* Creating */] && !scope["#Destroyed" /* Destroyed */]) {
-              fn(scope);
-            }
-          }
-        },
-        -1,
-        0,
-        scopes[0]["#Id" /* Id */]
-      );
-    }
-  };
-  ownerSignal._ = fn;
-  return ownerSignal;
-}
-function _if_closure(ownerConditionalNodeAccessor, branch, fn) {
-  if (false)
-    ownerConditionalNodeAccessor = decodeAccessor3(
-      ownerConditionalNodeAccessor
-    );
-  const scopeAccessor = "BranchScopes:" /* BranchScopes */ + ownerConditionalNodeAccessor;
-  const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + ownerConditionalNodeAccessor;
-  const ownerSignal = (scope) => {
-    const ifScope = scope[scopeAccessor];
-    if (ifScope && !ifScope["#Creating" /* Creating */] && (scope[branchAccessor] || 0) === branch) {
-      queueRender(ifScope, fn, -1);
-    }
-  };
-  ownerSignal._ = fn;
-  return ownerSignal;
-}
-function subscribeToScopeSet(ownerScope, accessor, scope) {
-  const subscribers = ownerScope[accessor] ||= /* @__PURE__ */ new Set();
-  if (!subscribers.has(scope)) {
-    subscribers.add(scope);
-    $signal(scope, -1).addEventListener(
-      "abort",
-      () => ownerScope[accessor].delete(scope)
-    );
-  }
-}
-function _closure(...closureSignals) {
-  const [{ ___scopeInstancesAccessor, ___signalIndexAccessor }] = closureSignals;
-  for (let i = closureSignals.length; i--; ) {
-    closureSignals[i].___index = i;
-  }
-  return (scope) => {
-    if (scope[___scopeInstancesAccessor]) {
-      for (const childScope of scope[___scopeInstancesAccessor]) {
-        if (!childScope["#Creating" /* Creating */]) {
-          queueRender(
-            childScope,
-            closureSignals[childScope[___signalIndexAccessor]],
-            -1
-          );
-        }
-      }
-    }
-  };
-}
-function _closure_get(valueAccessor, fn, getOwnerScope) {
-  if (false) valueAccessor = decodeAccessor3(valueAccessor);
-  const closureSignal = ((scope) => {
-    scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
-    fn(scope);
-    subscribeToScopeSet(
-      getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */],
-      closureSignal.___scopeInstancesAccessor,
-      scope
-    );
-  });
-  closureSignal.___scopeInstancesAccessor = "ClosureScopes:" /* ClosureScopes */ + valueAccessor;
-  closureSignal.___signalIndexAccessor = "ClosureSignalIndex:" /* ClosureSignalIndex */ + valueAccessor;
-  return closureSignal;
-}
-function _child_setup(setup) {
-  setup._ = (scope, owner) => {
-    scope["_" /* Owner */] = owner;
-    queueRender(scope, setup, -1);
-  };
-  return setup;
-}
-function _var(scope, childAccessor, signal) {
-  scope[true ? childAccessor : decodeAccessor3(childAccessor)]["#TagVariable" /* TagVariable */] = (value) => signal(scope, value);
-}
-var _return = (scope, value) => scope["#TagVariable" /* TagVariable */]?.(value);
-function _return_change(scope, changeHandler) {
-  if (changeHandler) {
-    scope["#TagVariableChange" /* TagVariableChange */] = changeHandler;
+      }
+    }
   }
 }
-var _var_change = true ? (scope, value, name = "This") => {
-  if (typeof scope["#TagVariableChange" /* TagVariableChange */] !== "function") {
-    throw new TypeError(`${name} is a readonly tag variable.`);
+function _attr_details_or_dialog_open(scope, nodeAccessor, open, openChange) {
+  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = openChange;
+  if (openChange) {
+    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 4 /* DetailsOrDialogOpen */;
+  } else {
+    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 5 /* None */;
   }
-  scope["#TagVariableChange" /* TagVariableChange */](value);
-} : (scope, value) => scope["#TagVariableChange" /* TagVariableChange */]?.(value);
-var tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
-function _id({ ["$global" /* Global */]: $global }) {
-  const id = tagIdsByGlobal.get($global) || 0;
-  tagIdsByGlobal.set($global, id + 1);
-  return "c" + $global.runtimeId + $global.renderId + id.toString(36);
+  scope[nodeAccessor].open = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = normalizeBoolProp(open);
 }
-function _script(id, fn) {
-  _resume(id, fn);
-  return (scope) => {
-    queueEffect(scope, fn);
-  };
+function _attr_details_or_dialog_open_script(scope, nodeAccessor) {
+  const el = scope[nodeAccessor];
+  const hasChanged = () => el.open !== scope["ControlledValue:" /* ControlledValue */ + nodeAccessor];
+  syncControllable(
+    el,
+    el.tagName === "DIALOG" ? "close" : "toggle",
+    hasChanged,
+    () => {
+      const openChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
+      if (openChange && hasChanged()) {
+        const newValue = el.open;
+        el.open = !newValue;
+        openChange(newValue);
+        run();
+      }
+    }
+  );
 }
-function _el_read(value) {
-  if (rendering) {
-    _el_read_error();
+var inputType = "";
+function setValueAndUpdateSelection(el, value) {
+  if (el.value !== value) {
+    const updatedPosition = resolveCursorPosition(
+      inputType,
+      el.getRootNode().activeElement === el && el.selectionStart,
+      el.value,
+      el.value = value
+    );
+    if (~updatedPosition) {
+      el.setSelectionRange(updatedPosition, updatedPosition);
+    }
   }
-  return value;
 }
-function* traverseAllHoisted(scope, path, curIndex = path.length - 1) {
-  if (rendering) {
-    _hoist_read_error();
+function setCheckboxValue(scope, nodeAccessor, type, checked, checkedChange) {
+  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = checkedChange;
+  if (checkedChange) {
+    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = type;
+    scope[nodeAccessor].checked = checked;
+  } else {
+    scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 5 /* None */;
+    scope[nodeAccessor].defaultChecked = checked;
   }
-  if (scope) {
-    if (Symbol.iterator in scope) {
-      for (const s of scope instanceof Map ? scope.values() : scope) {
-        yield* traverseAllHoisted(s, path, curIndex);
-      }
-    } else if (curIndex) {
-      yield* traverseAllHoisted(scope[path[curIndex]], path, curIndex - 1);
-    } else {
-      yield scope[path[0]];
+}
+var controllableDelegate = createDelegator();
+function syncControllable(el, event, hasChanged, onChange) {
+  if (!el._) {
+    controllableDelegate(el, event, handleChange);
+    if (el.form) {
+      controllableDelegate(el.form, "reset", handleFormReset);
+    }
+    if (isResuming && hasChanged(el)) {
+      queueMicrotask(onChange);
     }
   }
+  el._ = onChange;
 }
-function _hoist(...path) {
-  if (false)
-    path = path.map((p) => typeof p === "string" ? p : decodeAccessor3(p));
-  return (scope) => {
-    const getOne = (...args) => iterator().next().value?.(...args);
-    const iterator = getOne[Symbol.iterator] = () => traverseAllHoisted(scope, path);
-    return getOne;
-  };
+function handleChange(ev) {
+  ev.target._?.(ev);
 }
-
-// src/dom/renderer.ts
-function createBranch($global, renderer, parentScope, parentNode) {
-  const branch = createScope($global);
-  const parentBranch = parentScope?.["#ClosestBranch" /* ClosestBranch */];
-  branch["_" /* Owner */] = renderer.___owner || parentScope;
-  branch["#ClosestBranch" /* ClosestBranch */] = branch;
-  if (parentBranch) {
-    branch["#ParentBranch" /* ParentBranch */] = parentBranch;
-    (parentBranch["#BranchScopes" /* BranchScopes */] ||= /* @__PURE__ */ new Set()).add(branch);
-  }
-  if (true) {
-    branch["#Renderer" /* Renderer */] = renderer;
+function handleFormReset(ev) {
+  const handlers = [];
+  for (const el of ev.target.elements) {
+    if (el._ && hasFormElementChanged(el)) {
+      handlers.push(el._);
+    }
   }
-  renderer.___clone?.(
-    branch,
-    parentNode.namespaceURI
-  );
-  return branch;
+  requestAnimationFrame(() => {
+    if (!ev.defaultPrevented) {
+      for (const change of handlers) {
+        change();
+      }
+    }
+  });
 }
-function createAndSetupBranch($global, renderer, parentScope, parentNode) {
-  return setupBranch(
-    renderer,
-    createBranch($global, renderer, parentScope, parentNode)
-  );
+function hasValueChanged(el) {
+  return el.value !== el.defaultValue;
 }
-function setupBranch(renderer, branch) {
-  if (renderer.___setup) {
-    queueRender(branch, renderer.___setup, -1);
+function hasCheckboxChanged(el) {
+  return el.checked !== el.defaultChecked;
+}
+function hasSelectChanged(el) {
+  for (const opt of el.options) {
+    if (opt.selected !== opt.defaultSelected) {
+      return true;
+    }
   }
-  return branch;
 }
-function _content(id, template, walks, setup, params, dynamicScopesAccessor) {
-  walks = walks ? walks.replace(/[^\0-1]+$/, "") : "";
-  setup = setup ? setup._ || setup : void 0;
-  params ||= void 0;
-  const clone = template ? (branch, ns) => {
-    ((cloneCache[ns] ||= {})[template] ||= createCloneableHTML(
-      template,
-      ns
-    ))(branch, walks);
-  } : (branch) => {
-    walk(
-      branch["#StartNode" /* StartNode */] = branch["#EndNode" /* EndNode */] = new Text(),
-      walks,
-      branch
-    );
-  };
-  return (owner) => {
-    return {
-      ___id: id,
-      ___clone: clone,
-      ___owner: owner,
-      ___setup: setup,
-      ___params: params,
-      ___accessor: dynamicScopesAccessor
-    };
-  };
+function hasFormElementChanged(el) {
+  return el.options ? hasSelectChanged(el) : hasValueChanged(el) || hasCheckboxChanged(el);
 }
-function _content_resume(id, template, walks, setup, params, dynamicScopesAccessor) {
-  return _resume(
-    id,
-    _content(id, template, walks, setup, params, dynamicScopesAccessor)
-  );
+function normalizeStrProp(value) {
+  return normalizeAttrValue(value) || "";
 }
-function _content_closures(renderer, closureFns) {
-  const closureSignals = {};
-  for (const key in closureFns) {
-    closureSignals[key] = _const(true ? key : +key, closureFns[key]);
-  }
-  return (owner, closureValues) => {
-    const instance = renderer(owner);
-    instance.___localClosures = closureSignals;
-    instance.___localClosureValues = closureValues;
-    return instance;
-  };
+function normalizeBoolProp(value) {
+  return value != null && value !== false;
 }
-var cloneCache = {};
-function createCloneableHTML(html, ns) {
-  const { firstChild, lastChild } = parseHTML(html, ns);
-  const parent = document.createElementNS(ns, "t");
-  insertChildNodes(parent, null, firstChild, lastChild);
-  return firstChild === lastChild && firstChild.nodeType < 8 /* Comment */ ? (branch, walks) => {
-    walk(
-      branch["#StartNode" /* StartNode */] = branch["#EndNode" /* EndNode */] = firstChild.cloneNode(true),
-      walks,
-      branch
-    );
-  } : (branch, walks) => {
-    const clone = parent.cloneNode(true);
-    walk(clone.firstChild, walks, branch);
-    branch["#StartNode" /* StartNode */] = clone.firstChild;
-    branch["#EndNode" /* EndNode */] = clone.lastChild;
-  };
+function updateList(arr, val, push2) {
+  const index = arr.indexOf(val);
+  return (push2 ? !~index && [...arr, val] : ~index && arr.slice(0, index).concat(arr.slice(index + 1))) || arr;
+}
+function toValueProp(it) {
+  return it.value;
 }
 
 // src/dom/dom.ts
@@ -1692,63 +1695,74 @@ function _await_promise(nodeAccessor, params) {
   if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
   const promiseAccessor = "Promise:" /* Promise */ + nodeAccessor;
   const branchAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-  const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
   _enable_catch();
   return (scope, promise) => {
-    let awaitCounter;
-    let renderData;
-    const tryWithPlaceholder = findBranchWithKey(
-      scope,
-      "#PlaceholderContent" /* PlaceholderContent */
-    );
-    if (tryWithPlaceholder) {
-      renderData = self[tryWithPlaceholder["$global" /* Global */].runtimeId]?.[tryWithPlaceholder["$global" /* Global */].renderId];
-      awaitCounter = tryWithPlaceholder["#AwaitCounter" /* AwaitCounter */] ||= renderData?.p?.[tryWithPlaceholder["#Id" /* Id */]];
-      if (!awaitCounter?.i) {
-        awaitCounter = tryWithPlaceholder["#AwaitCounter" /* AwaitCounter */] = {
-          d: 1,
-          i: 0,
-          c() {
-            if (!--awaitCounter.i) {
-              const placeholderBranch = tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */];
-              tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */] = 0;
-              if (placeholderBranch) {
-                placeholderBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
-                  tryWithPlaceholder["#StartNode" /* StartNode */].parentNode,
-                  placeholderBranch["#StartNode" /* StartNode */]
-                );
-                removeAndDestroyBranch(placeholderBranch);
-              }
-              queueEffect(tryWithPlaceholder, (scope2) => {
-                const pendingEffects2 = scope2["#PendingEffects" /* PendingEffects */];
-                if (pendingEffects2) {
-                  scope2["#PendingEffects" /* PendingEffects */] = [];
-                  runEffects(pendingEffects2, true);
-                }
-              });
+    let awaitBranch = scope[branchAccessor];
+    const tryBranch = findBranchWithKey(scope, "#PlaceholderContent" /* PlaceholderContent */) || awaitBranch;
+    let awaitCounter = tryBranch["#AwaitCounter" /* AwaitCounter */];
+    if (!awaitCounter?.i) {
+      awaitCounter = tryBranch["#AwaitCounter" /* AwaitCounter */] = {
+        i: 0,
+        c() {
+          if (--awaitCounter.i) return 1;
+          if (tryBranch === scope[branchAccessor]) {
+            if (scope[nodeAccessor].parentNode) {
+              scope[nodeAccessor].replaceWith(
+                scope[branchAccessor]["#StartNode" /* StartNode */].parentNode
+              );
+            }
+          } else {
+            const placeholderBranch = tryBranch["#PlaceholderBranch" /* PlaceholderBranch */];
+            if (placeholderBranch) {
+              tryBranch["#PlaceholderBranch" /* PlaceholderBranch */] = 0;
+              placeholderBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
+                tryBranch["#StartNode" /* StartNode */].parentNode,
+                placeholderBranch["#StartNode" /* StartNode */]
+              );
+              removeAndDestroyBranch(placeholderBranch);
             }
           }
-        };
+          queueEffect(tryBranch, (scope2) => {
+            const pendingEffects2 = scope2["#PendingEffects" /* PendingEffects */];
+            if (pendingEffects2) {
+              scope2["#PendingEffects" /* PendingEffects */] = [];
+              runEffects(pendingEffects2, 1);
+            }
+          });
+        }
+      };
+    }
+    placeholderShown.add(pendingEffects);
+    if (!scope[promiseAccessor]) {
+      if (awaitBranch) {
+        awaitBranch["#PendingRenders" /* PendingRenders */] ||= [];
       }
-      placeholderShown.add(pendingEffects);
-      if (!scope[promiseAccessor] && !awaitCounter.i++) {
+      if (!awaitCounter.i++) {
         requestAnimationFrame(
           () => awaitCounter.i && runEffects(
             prepareEffects(
               () => queueRender(
-                tryWithPlaceholder,
+                tryBranch === awaitBranch ? scope : tryBranch,
                 () => {
-                  insertBranchBefore(
-                    tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */] = createAndSetupBranch(
-                      scope["$global" /* Global */],
-                      tryWithPlaceholder["#PlaceholderContent" /* PlaceholderContent */],
-                      tryWithPlaceholder["_" /* Owner */],
-                      tryWithPlaceholder["#StartNode" /* StartNode */].parentNode
-                    ),
-                    tryWithPlaceholder["#StartNode" /* StartNode */].parentNode,
-                    tryWithPlaceholder["#StartNode" /* StartNode */]
-                  );
-                  tempDetachBranch(tryWithPlaceholder);
+                  if (tryBranch["#PlaceholderContent" /* PlaceholderContent */]) {
+                    insertBranchBefore(
+                      tryBranch["#PlaceholderBranch" /* PlaceholderBranch */] = createAndSetupBranch(
+                        scope["$global" /* Global */],
+                        tryBranch["#PlaceholderContent" /* PlaceholderContent */],
+                        tryBranch["_" /* Owner */],
+                        tryBranch["#StartNode" /* StartNode */].parentNode
+                      ),
+                      tryBranch["#StartNode" /* StartNode */].parentNode,
+                      tryBranch["#StartNode" /* StartNode */]
+                    );
+                    tempDetachBranch(tryBranch);
+                  } else if (!awaitBranch["#DetachedAwait" /* DetachedAwait */]) {
+                    awaitBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
+                      scope[nodeAccessor],
+                      awaitBranch["#StartNode" /* StartNode */]
+                    );
+                    tempDetachBranch(tryBranch);
+                  }
                 },
                 -1
               )
@@ -1756,61 +1770,52 @@ function _await_promise(nodeAccessor, params) {
           )
         );
       }
-    } else if (scope[branchAccessor] && !scope[promiseAccessor]) {
-      scope[branchAccessor]["#StartNode" /* StartNode */].parentNode.insertBefore(
-        scope[nodeAccessor],
-        scope[branchAccessor]["#StartNode" /* StartNode */]
-      );
-      tempDetachBranch(scope[branchAccessor]);
     }
     const thisPromise = scope[promiseAccessor] = promise.then(
       (data) => {
         if (thisPromise === scope[promiseAccessor]) {
+          const referenceNode = scope[nodeAccessor];
           scope[promiseAccessor] = 0;
-          schedule();
+          queueMicrotask(run);
           queueRender(
             scope,
             () => {
-              if (scope[branchAccessor]) {
-                if (!tryWithPlaceholder) {
-                  scope[nodeAccessor].replaceWith(
-                    scope[branchAccessor]["#StartNode" /* StartNode */].parentNode
-                  );
-                }
-              } else {
+              if ((awaitBranch = scope[branchAccessor])["#DetachedAwait" /* DetachedAwait */]) {
+                pendingScopes.push(awaitBranch);
+                setupBranch(
+                  awaitBranch["#DetachedAwait" /* DetachedAwait */],
+                  awaitBranch
+                );
+                awaitBranch["#DetachedAwait" /* DetachedAwait */] = 0;
                 insertBranchBefore(
-                  scope[branchAccessor] = createAndSetupBranch(
-                    scope["$global" /* Global */],
-                    scope[rendererAccessor],
-                    scope,
-                    scope[nodeAccessor].parentNode
-                  ),
+                  awaitBranch,
                   scope[nodeAccessor].parentNode,
                   scope[nodeAccessor]
                 );
-                scope[nodeAccessor].remove();
+                referenceNode.remove();
               }
-              params?.(scope[branchAccessor], [data]);
-              if (awaitCounter) {
-                placeholderShown.add(pendingEffects);
-                awaitCounter.c();
-                if (!awaitCounter.d) {
-                  const fnScopes = /* @__PURE__ */ new Map();
-                  const effects = renderData.m();
-                  for (let i = 0; i < pendingEffects.length; ) {
-                    const fn = pendingEffects[i++];
-                    let scopes = fnScopes.get(fn);
-                    if (!scopes) {
-                      fnScopes.set(fn, scopes = /* @__PURE__ */ new Set());
-                    }
-                    scopes.add(pendingEffects[i++]);
+              params?.(awaitBranch, [data]);
+              const pendingRenders2 = awaitBranch["#PendingRenders" /* PendingRenders */];
+              awaitBranch["#PendingRenders" /* PendingRenders */] = 0;
+              pendingRenders2?.forEach(queuePendingRender);
+              placeholderShown.add(pendingEffects);
+              awaitCounter.c();
+              if (awaitCounter.m) {
+                const fnScopes = /* @__PURE__ */ new Map();
+                const effects = awaitCounter.m();
+                for (let i = 0; i < pendingEffects.length; ) {
+                  const fn = pendingEffects[i++];
+                  let scopes = fnScopes.get(fn);
+                  if (!scopes) {
+                    fnScopes.set(fn, scopes = /* @__PURE__ */ new Set());
                   }
-                  for (let i = 0; i < effects.length; ) {
-                    const fn = effects[i++];
-                    const scope2 = effects[i++];
-                    if (!fnScopes.get(fn)?.has(scope2)) {
-                      queueEffect(scope2, fn);
-                    }
+                  scopes.add(pendingEffects[i++]);
+                }
+                for (let i = 0; i < effects.length; ) {
+                  const fn = effects[i++];
+                  const scope2 = effects[i++];
+                  if (!fnScopes.get(fn)?.has(scope2)) {
+                    queueEffect(scope2, fn);
                   }
                 }
               }
@@ -1821,8 +1826,7 @@ function _await_promise(nodeAccessor, params) {
       },
       (error) => {
         if (thisPromise === scope[promiseAccessor]) {
-          if (awaitCounter) awaitCounter.i = 0;
-          scope[promiseAccessor] = 0;
+          awaitCounter.i = scope[promiseAccessor] = 0;
           schedule();
           queueRender(scope, renderCatch, -1, error);
         }
@@ -1831,10 +1835,17 @@ function _await_promise(nodeAccessor, params) {
   };
 }
 function _await_content(nodeAccessor, template, walks, setup) {
-  const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + (true ? nodeAccessor : decodeAccessor4(nodeAccessor));
+  if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
+  const branchAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
   const renderer = _content("", template, walks, setup)();
   return (scope) => {
-    scope[rendererAccessor] = renderer;
+    (scope[branchAccessor] = createBranch(
+      scope["$global" /* Global */],
+      renderer,
+      scope,
+      scope[nodeAccessor].parentNode
+    ))["#DetachedAwait" /* DetachedAwait */] = renderer;
+    pendingScopes.pop();
   };
 }
 function _try(nodeAccessor, template, walks, setup) {
@@ -2137,6 +2148,7 @@ function byFirstArg(name) {
 // src/dom/queue.ts
 var pendingRenders = [];
 var pendingRendersLookup = /* @__PURE__ */ new Map();
+var asyncRendersLookup;
 var caughtError = /* @__PURE__ */ new WeakSet();
 var placeholderShown = /* @__PURE__ */ new WeakSet();
 var pendingEffects = [];
@@ -2145,50 +2157,56 @@ var rendering;
 var scopeKeyOffset = 1e3;
 function queueRender(scope, signal, signalKey, value, scopeKey = scope["#Id" /* Id */]) {
   const key = scopeKey * scopeKeyOffset + signalKey;
-  const existingRender = signalKey >= 0 && pendingRendersLookup.get(key);
-  if (existingRender) {
-    existingRender.___value = value;
+  let render = signalKey >= 0 && pendingRendersLookup.get(key);
+  if (render) {
+    render.___value = value;
   } else {
-    const render = {
-      ___key: key,
-      ___scope: scope,
-      ___signal: signal,
-      ___value: value
-    };
-    let i = pendingRenders.push(render) - 1;
-    while (i) {
-      const parentIndex = i - 1 >> 1;
-      const parent = pendingRenders[parentIndex];
-      if (key - parent.___key >= 0) break;
-      pendingRenders[i] = parent;
-      i = parentIndex;
-    }
+    queuePendingRender(
+      render = {
+        ___key: key,
+        ___scope: scope,
+        ___signal: signal,
+        ___value: value
+      }
+    );
     signalKey >= 0 && pendingRendersLookup.set(key, render);
-    pendingRenders[i] = render;
   }
 }
+function queuePendingRender(render) {
+  let i = pendingRenders.push(render) - 1;
+  while (i) {
+    const parentIndex = i - 1 >> 1;
+    const parent = pendingRenders[parentIndex];
+    if (render.___key - parent.___key >= 0) break;
+    pendingRenders[i] = parent;
+    i = parentIndex;
+  }
+  pendingRenders[i] = render;
+}
 function queueEffect(scope, fn) {
   pendingEffects.push(fn, scope);
 }
 function run() {
   const effects = pendingEffects;
+  asyncRendersLookup = /* @__PURE__ */ new Map();
   try {
     rendering = 1;
     runRenders();
   } finally {
+    pendingRendersLookup = asyncRendersLookup;
+    asyncRendersLookup = rendering = 0;
     pendingRenders = [];
-    pendingRendersLookup = /* @__PURE__ */ new Map();
     pendingEffects = [];
-    rendering = 0;
   }
   runEffects(effects);
 }
 function prepareEffects(fn) {
   const prevRenders = pendingRenders;
-  const prevRendersLookup = pendingRendersLookup;
   const prevEffects = pendingEffects;
+  const prevLookup = asyncRendersLookup;
   const preparedEffects = pendingEffects = [];
   pendingRenders = [];
+  asyncRendersLookup = pendingRendersLookup;
   pendingRendersLookup = /* @__PURE__ */ new Map();
   try {
     rendering = 1;
@@ -2196,8 +2214,9 @@ function prepareEffects(fn) {
     runRenders();
   } finally {
     rendering = 0;
+    pendingRendersLookup = asyncRendersLookup;
+    asyncRendersLookup = prevLookup;
     pendingRenders = prevRenders;
-    pendingRendersLookup = prevRendersLookup;
     pendingEffects = prevEffects;
   }
   return preparedEffects;
@@ -2272,6 +2291,17 @@ var _enable_catch = () => {
   })(runEffects);
   runRender = /* @__PURE__ */ ((runRender2) => (render) => {
     try {
+      let branch = render.___scope["#ClosestBranch" /* ClosestBranch */];
+      while (branch) {
+        if (branch["#PendingRenders" /* PendingRenders */]) {
+          asyncRendersLookup.set(
+            render.___key,
+            render
+          );
+          return branch["#PendingRenders" /* PendingRenders */].push(render);
+        }
+        branch = branch["#ParentBranch" /* ParentBranch */];
+      }
       runRender2(render);
     } catch (error) {
       renderCatch(render.___scope, error);