marko 6.0.39 → 6.0.41

package/dist/debug/dom.js

@@ -24,6 +24,7 @@ __export(dom_exports, {
   attrTag: () => attrTag,
   attrTags: () => attrTags,
   attrs: () => attrs,
+  attrsAndContent: () => attrsAndContent,
   attrsEvents: () => attrsEvents,
   awaitTag: () => awaitTag,
   classAttr: () => classAttr,
@@ -61,6 +62,7 @@ __export(dom_exports, {
   hoist: () => hoist,
   html: () => html,
   init: () => init,
+  insertContent: () => insertContent,
   intersection: () => intersection,
   lifecycle: () => lifecycle,
   localClosures: () => localClosures,
@@ -72,6 +74,7 @@ __export(dom_exports, {
   nodeRef: () => nodeRef,
   on: () => on,
   partialAttrs: () => partialAttrs,
+  partialAttrsAndContent: () => partialAttrsAndContent,
   props: () => props,
   register: () => register,
   registerBoundSignal: () => registerBoundSignal,
@@ -741,895 +744,930 @@ function parseHTML(html2, ns) {
   return parser.content || parser;
 }
 
-// src/dom/dom.ts
-function attr(element, name, value2) {
-  setAttribute(element, name, normalizeAttrValue(value2));
+// src/dom/scope.ts
+function createScope($global, closestBranch) {
+  const scope = {
+    ___id: $global.___nextScopeId++,
+    ___creating: 1,
+    ___closestBranch: closestBranch,
+    $global
+  };
+  pendingScopes.push(scope);
+  return scope;
 }
-function setAttribute(element, name, value2) {
-  if (element.getAttribute(name) != value2) {
-    if (value2 === void 0) {
-      element.removeAttribute(name);
-    } else {
-      element.setAttribute(name, value2);
-    }
+function skipScope(scope) {
+  return scope.$global.___nextScopeId++;
+}
+function findBranchWithKey(scope, key) {
+  let branch = scope.___closestBranch;
+  while (branch && !branch[key]) {
+    branch = branch.___parentBranch;
   }
+  return branch;
 }
-function classAttr(element, value2) {
-  setAttribute(element, "class", classValue(value2) || void 0);
+function destroyBranch(branch) {
+  branch.___parentBranch?.___branchScopes?.delete(branch);
+  destroyNestedBranches(branch);
 }
-function classItems(element, items) {
-  for (const key in items) {
-    classItem(element, key, items[key]);
-  }
+function destroyNestedBranches(branch) {
+  branch.___destroyed = 1;
+  branch.___branchScopes?.forEach(destroyNestedBranches);
+  branch.___abortScopes?.forEach((scope) => {
+    for (const id in scope.___abortControllers) {
+      scope.___abortControllers[id]?.abort();
+    }
+  });
 }
-function classItem(element, name, value2) {
-  element.classList.toggle(name, !!value2);
+function removeAndDestroyBranch(branch) {
+  destroyBranch(branch);
+  removeChildNodes(branch.___startNode, branch.___endNode);
 }
-function styleAttr(element, value2) {
-  setAttribute(element, "style", styleValue(value2) || void 0);
+function insertBranchBefore(branch, parentNode, nextSibling) {
+  insertChildNodes(
+    parentNode,
+    nextSibling,
+    branch.___startNode,
+    branch.___endNode
+  );
 }
-function styleItems(element, items) {
-  for (const key in items) {
-    styleItem(element, key, items[key]);
+function tempDetachBranch(branch) {
+  const fragment = new DocumentFragment();
+  fragment.namespaceURI = branch.___startNode.parentNode.namespaceURI;
+  insertChildNodes(fragment, null, branch.___startNode, branch.___endNode);
+}
+
+// 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 styleItem(element, name, value2) {
-  element.style.setProperty(name, value2 || value2 === 0 ? value2 + "" : "");
+function flushAndWaitFrame() {
+  if (true) {
+    runTask();
+  } else {
+    run();
+  }
+  requestAnimationFrame(triggerMacroTask);
 }
-function data(node, value2) {
-  const normalizedValue = normalizeString(value2);
-  if (node.data !== normalizedValue) {
-    node.data = normalizedValue;
+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);
 }
-function textContent(node, value2) {
-  const normalizedValue = normalizeString(value2);
-  if (node.textContent !== normalizedValue) {
-    node.textContent = normalizedValue;
+
+// src/dom/signals.ts
+function state(valueAccessor, fn) {
+  if (true) {
+    var id = +valueAccessor.slice(
+      valueAccessor.lastIndexOf("/") + 1
+    );
+    valueAccessor = valueAccessor.slice(
+      0,
+      valueAccessor.lastIndexOf("/")
+    );
   }
+  const valueChangeAccessor = "TagVariableChange:" /* TagVariableChange */ + valueAccessor;
+  const update = (scope, value2) => {
+    if (scope[valueAccessor] !== value2) {
+      scope[valueAccessor] = value2;
+      fn(scope, value2);
+    }
+  };
+  return (scope, value2, valueChange) => {
+    if (rendering) {
+      if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value2 || !(valueAccessor in scope)) {
+        scope[valueAccessor] = value2;
+        fn(scope, value2);
+      }
+    } else if (scope[valueChangeAccessor]) {
+      scope[valueChangeAccessor](value2);
+    } else {
+      schedule();
+      queueRender(
+        scope,
+        update,
+        true ? id : valueAccessor,
+        value2
+      );
+    }
+    return value2;
+  };
 }
-function attrs(scope, nodeAccessor, nextAttrs) {
-  const el = scope[nodeAccessor];
-  for (let i = el.attributes.length; i--; ) {
-    const { name } = el.attributes.item(i);
-    if (!(nextAttrs && (name in nextAttrs || hasAttrAlias(el, name, nextAttrs)))) {
-      el.removeAttribute(name);
+function value(valueAccessor, fn = () => {
+}) {
+  return (scope, value2) => {
+    if (!(valueAccessor in scope) || scope[valueAccessor] !== value2) {
+      scope[valueAccessor] = value2;
+      fn(scope, value2);
     }
-  }
-  attrsInternal(scope, nodeAccessor, nextAttrs);
+  };
 }
-function hasAttrAlias(element, attr2, nextAttrs) {
-  return attr2 === "checked" && element.tagName === "INPUT" && "checkedValue" in nextAttrs;
+function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "___id") {
+  return (scope) => {
+    if (scope.___creating) {
+      if (scope[id] === void 0) {
+        scope[id] = defaultPending;
+      } else if (!--scope[id]) {
+        fn(scope);
+      }
+    } else {
+      queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
+    }
+  };
 }
-function partialAttrs(scope, nodeAccessor, nextAttrs, skip) {
-  const el = scope[nodeAccessor];
-  const partial = {};
-  for (let i = el.attributes.length; i--; ) {
-    const { name } = el.attributes.item(i);
-    if (!skip[name] && !(nextAttrs && name in nextAttrs)) {
-      el.removeAttribute(name);
+function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
+  const childSignal = closure(valueAccessor, fn);
+  const loopScopeAccessor = "LoopScopeArray:" /* LoopScopeArray */ + ownerLoopNodeAccessor;
+  const loopScopeMapAccessor = "LoopScopeMap:" /* LoopScopeMap */ + ownerLoopNodeAccessor;
+  const ownerSignal = (ownerScope) => {
+    const scopes = ownerScope[loopScopeAccessor] ||= ownerScope[loopScopeMapAccessor] ? [...ownerScope[loopScopeMapAccessor].values()] : [];
+    const [firstScope] = scopes;
+    if (firstScope) {
+      queueRender(
+        ownerScope,
+        () => {
+          for (const scope of scopes) {
+            if (!scope.___creating && !scope.___destroyed) {
+              childSignal(scope);
+            }
+          }
+        },
+        -1,
+        0,
+        firstScope.___id
+      );
+    }
+  };
+  ownerSignal._ = childSignal;
+  return ownerSignal;
+}
+function conditionalClosure(valueAccessor, ownerConditionalNodeAccessor, branch, fn) {
+  const childSignal = closure(valueAccessor, fn);
+  const scopeAccessor = "ConditionalScope:" /* ConditionalScope */ + ownerConditionalNodeAccessor;
+  const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + ownerConditionalNodeAccessor;
+  const ownerSignal = (scope) => {
+    const ifScope = scope[scopeAccessor];
+    if (ifScope && !ifScope.___creating && scope[branchAccessor] === branch) {
+      queueRender(ifScope, childSignal, -1);
     }
+  };
+  ownerSignal._ = childSignal;
+  return ownerSignal;
+}
+function subscribeToScopeSet(ownerScope, accessor, scope) {
+  const subscribers = ownerScope[accessor] ||= /* @__PURE__ */ new Set();
+  if (!subscribers.has(scope)) {
+    subscribers.add(scope);
+    getAbortSignal(scope, -1).addEventListener(
+      "abort",
+      () => ownerScope[accessor].delete(scope)
+    );
   }
-  for (const key in nextAttrs) {
-    if (!skip[key]) partial[key] = nextAttrs[key];
+}
+function dynamicClosure(...closureSignals) {
+  const [{ ___scopeInstancesAccessor, ___signalIndexAccessor }] = closureSignals;
+  for (let i = closureSignals.length; i--; ) {
+    closureSignals[i].___index = i;
   }
-  attrsInternal(scope, nodeAccessor, partial);
+  return (scope) => {
+    if (scope[___scopeInstancesAccessor]) {
+      for (const childScope of scope[___scopeInstancesAccessor]) {
+        if (!childScope.___creating) {
+          queueRender(
+            childScope,
+            closureSignals[childScope[___signalIndexAccessor]],
+            -1
+          );
+        }
+      }
+    }
+  };
 }
-function attrsInternal(scope, nodeAccessor, nextAttrs) {
-  const el = scope[nodeAccessor];
-  let events;
-  let skip;
-  switch (el.tagName) {
-    case "INPUT":
-      if ("checked" in nextAttrs || "checkedChange" in nextAttrs) {
-        controllable_input_checked(
-          scope,
-          nodeAccessor,
-          nextAttrs.checked,
-          nextAttrs.checkedChange
-        );
-      } else if ("checkedValue" in nextAttrs || "checkedValueChange" in nextAttrs) {
-        controllable_input_checkedValue(
-          scope,
-          nodeAccessor,
-          nextAttrs.checkedValue,
-          nextAttrs.checkedValueChange,
-          nextAttrs.value
-        );
-      } else if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        controllable_input_value(
-          scope,
-          nodeAccessor,
-          nextAttrs.value,
-          nextAttrs.valueChange
-        );
-      } else {
-        break;
+function dynamicClosureRead(valueAccessor, fn, getOwnerScope) {
+  const childSignal = closure(valueAccessor, fn, getOwnerScope);
+  const closureSignal = (scope) => {
+    scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
+    childSignal(scope);
+    subscribeToScopeSet(
+      getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */],
+      closureSignal.___scopeInstancesAccessor,
+      scope
+    );
+  };
+  closureSignal.___scopeInstancesAccessor = "ClosureScopes:" /* ClosureScopes */ + valueAccessor;
+  closureSignal.___signalIndexAccessor = "ClosureSignalIndex:" /* ClosureSignalIndex */ + valueAccessor;
+  return closureSignal;
+}
+function closure(valueAccessor, fn, getOwnerScope) {
+  return (scope) => {
+    fn(
+      scope,
+      (getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */])[valueAccessor]
+    );
+  };
+}
+function setTagVar(scope, childAccessor, tagVarSignal2) {
+  scope[childAccessor]["#TagVariable" /* TagVariable */] = (value2) => tagVarSignal2(scope, value2);
+}
+var tagVarSignal = (scope, value2) => scope["#TagVariable" /* TagVariable */]?.(value2);
+function setTagVarChange(scope, changeHandler) {
+  scope["#TagVariableChange" /* TagVariableChange */] = changeHandler;
+}
+var tagVarSignalChange = (scope, value2) => scope["#TagVariableChange" /* TagVariableChange */]?.(value2);
+var tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
+function nextTagId({ $global }) {
+  const id = tagIdsByGlobal.get($global) || 0;
+  tagIdsByGlobal.set($global, id + 1);
+  return "c" + $global.runtimeId + $global.renderId + id.toString(36);
+}
+function effect(id, fn) {
+  register(id, fn);
+  return (scope) => {
+    queueEffect(scope, fn);
+  };
+}
+function* traverseAllHoisted(scope, path, curIndex = path.length - 1) {
+  if (scope) {
+    if (Symbol.iterator in scope) {
+      for (const s of scope instanceof Map ? scope.values() : scope) {
+        yield* traverseAllHoisted(s, path, curIndex);
       }
-      skip = /^(?:value|checked(?:Value)?)(?:Change)?$/;
-      break;
-    case "SELECT":
-      if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        controllable_select_value(
-          scope,
-          nodeAccessor,
-          nextAttrs.value,
-          nextAttrs.valueChange
-        );
-        skip = /^value(?:Change)?$/;
+    } else if (curIndex) {
+      yield* traverseAllHoisted(scope[path[curIndex]], path, curIndex - 1);
+    } else {
+      yield scope[path[0]];
+    }
+  }
+}
+function hoist(...path) {
+  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) {
+  walker.currentNode = startNode;
+  walkInternal(0, walkCodes, branch);
+}
+function walkInternal(currentWalkIndex, walkCodes, scope) {
+  let value2;
+  let storedMultiplier = 0;
+  let currentMultiplier = 0;
+  let currentScopeIndex = 0;
+  for (; currentWalkIndex < walkCodes.length; ) {
+    value2 = walkCodes.charCodeAt(currentWalkIndex++);
+    currentMultiplier = storedMultiplier;
+    storedMultiplier = 0;
+    if (value2 === 32 /* Get */) {
+      const node = walker.currentNode;
+      scope[true ? getDebugKey(currentScopeIndex, walker.currentNode) : currentScopeIndex] = node;
+      scope["Getter:" /* Getter */ + (true ? getDebugKey(currentScopeIndex++, walker.currentNode) : currentScopeIndex++)] = () => node;
+    } else if (value2 === 37 /* Replace */ || value2 === 49 /* DynamicTagWithVar */) {
+      walker.currentNode.replaceWith(
+        walker.currentNode = scope[true ? getDebugKey(currentScopeIndex++, "#text") : currentScopeIndex++] = new Text()
+      );
+      if (value2 === 49 /* DynamicTagWithVar */) {
+        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : currentScopeIndex++] = skipScope(scope);
       }
-      break;
-    case "TEXTAREA":
-      if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        controllable_input_value(
-          scope,
-          nodeAccessor,
-          nextAttrs.value,
-          nextAttrs.valueChange
-        );
-        skip = /^value(?:Change)?$/;
+    } else if (value2 === 38 /* EndChild */) {
+      return currentWalkIndex;
+    } else if (value2 === 47 /* BeginChild */ || value2 === 48 /* BeginChildWithVar */) {
+      currentWalkIndex = walkInternal(
+        currentWalkIndex,
+        walkCodes,
+        scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : currentScopeIndex++] = createScope(scope.$global, scope.___closestBranch)
+      );
+      if (value2 === 48 /* BeginChildWithVar */) {
+        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : currentScopeIndex++] = skipScope(scope);
       }
-      break;
-    case "DETAILS":
-    case "DIALOG":
-      if ("open" in nextAttrs || "openChange" in nextAttrs) {
-        controllable_detailsOrDialog_open(
-          scope,
-          nodeAccessor,
-          nextAttrs.open,
-          nextAttrs.openChange
-        );
-        skip = /^open(?:Change)?$/;
+    } else if (value2 < 91 /* NextEnd */ + 1) {
+      value2 = 20 /* Next */ * currentMultiplier + value2 - 67 /* Next */;
+      while (value2--) {
+        walker.nextNode();
       }
-      break;
-  }
-  for (const name in nextAttrs) {
-    const value2 = nextAttrs[name];
-    switch (name) {
-      case "class":
-        classAttr(el, value2);
-        break;
-      case "style":
-        styleAttr(el, value2);
-        break;
-      case "content":
-        break;
-      default: {
-        if (isEventHandler(name)) {
-          (events ||= scope["EventAttributes:" /* EventAttributes */ + nodeAccessor] = {})[getEventHandlerName(name)] = value2;
-        } else if (!skip?.test(name)) {
-          attr(el, name, value2);
-        }
+    } else if (value2 < 106 /* OverEnd */ + 1) {
+      value2 = 10 /* Over */ * currentMultiplier + value2 - 97 /* Over */;
+      while (value2--) {
+        walker.nextSibling();
+      }
+    } else if (value2 < 116 /* OutEnd */ + 1) {
+      value2 = 10 /* Out */ * currentMultiplier + value2 - 107 /* Out */;
+      while (value2--) {
+        walker.parentNode();
+      }
+      walker.nextSibling();
+    } else {
+      if (value2 < 117 /* Multiplier */ || value2 > 126 /* MultiplierEnd */) {
+        throw new Error(`Unknown walk code: ${value2}`);
       }
+      storedMultiplier = currentMultiplier * 10 /* Multiplier */ + value2 - 117 /* Multiplier */;
     }
   }
 }
-function attrsEvents(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  const events = scope["EventAttributes:" /* EventAttributes */ + nodeAccessor];
-  switch (scope["ControlledType:" /* ControlledType */ + nodeAccessor]) {
-    case 0 /* InputChecked */:
-      controllable_input_checked_effect(scope, nodeAccessor);
-      break;
-    case 1 /* InputCheckedValue */:
-      controllable_input_checkedValue_effect(scope, nodeAccessor);
-      break;
-    case 2 /* InputValue */:
-      controllable_input_value_effect(scope, nodeAccessor);
-      break;
-    case 3 /* SelectValue */:
-      controllable_select_value_effect(scope, nodeAccessor);
-      break;
-    case 4 /* DetailsOrDialogOpen */:
-      controllable_detailsOrDialog_open_effect(scope, nodeAccessor);
-      break;
-  }
-  for (const name in events) {
-    on(el, name, events[name]);
+function getDebugKey(index, node) {
+  if (typeof node === "string") {
+    return `${node}/${index}`;
+  } else if (node.nodeType === 3 /* Text */) {
+    return `#text/${index}`;
+  } else if (node.nodeType === 8 /* Comment */) {
+    return `#comment/${index}`;
+  } else if (node.nodeType === 1 /* Element */) {
+    return `#${node.tagName.toLowerCase()}/${index}`;
   }
+  return index;
 }
-function html(scope, value2, accessor) {
-  const firstChild = scope[accessor];
-  const parentNode = firstChild.parentNode;
-  const lastChild = scope["DynamicPlaceholderLastChild:" /* DynamicPlaceholderLastChild */ + accessor] || firstChild;
-  const newContent = parseHTML(
-    value2 || value2 === 0 ? value2 + "" : "",
+
+// src/dom/renderer.ts
+function createBranch($global, renderer, parentScope, parentNode) {
+  const branch = createScope($global);
+  const parentBranch = parentScope?.___closestBranch;
+  branch["_" /* Owner */] = renderer.___owner || parentScope;
+  branch.___closestBranch = branch;
+  if (parentBranch) {
+    branch.___parentBranch = parentBranch;
+    (parentBranch.___branchScopes ||= /* @__PURE__ */ new Set()).add(branch);
+  }
+  if (true) {
+    branch.___renderer = renderer;
+  }
+  renderer.___clone?.(
+    branch,
     parentNode.namespaceURI
   );
-  insertChildNodes(
-    parentNode,
-    firstChild,
-    scope[accessor] = newContent.firstChild || newContent.appendChild(new Text()),
-    scope["DynamicPlaceholderLastChild:" /* DynamicPlaceholderLastChild */ + accessor] = newContent.lastChild
-  );
-  removeChildNodes(firstChild, lastChild);
+  return branch;
 }
-function props(scope, nodeIndex, index) {
-  const nextProps = scope[index];
-  const prevProps = scope[index + "-"];
-  const node = scope[nodeIndex];
-  if (prevProps) {
-    for (const name in prevProps) {
-      if (!(name in nextProps)) {
-        node[name] = void 0;
-      }
-    }
-  }
-  for (const name in nextProps) {
-    node[name] = nextProps[name];
-  }
-  scope[index + "-"] = nextProps;
+function createAndSetupBranch($global, renderer, parentScope, parentNode) {
+  return setupBranch(
+    renderer,
+    createBranch($global, renderer, parentScope, parentNode)
+  );
 }
-function normalizeAttrValue(value2) {
-  if (value2 || value2 === 0) {
-    return value2 === true ? "" : value2 + "";
+function setupBranch(renderer, branch) {
+  if (renderer.___setup) {
+    queueRender(branch, renderer.___setup, -1);
   }
+  return branch;
 }
-function normalizeString(value2) {
-  return value2 || value2 === 0 ? value2 + "" : "\u200D";
+function createContent(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 = branch.___endNode = new Text(),
+      walks,
+      branch
+    );
+  };
+  return (owner) => {
+    return {
+      ___id: id,
+      ___clone: clone,
+      ___owner: owner,
+      ___setup: setup,
+      ___params: params,
+      ___accessor: dynamicScopesAccessor
+    };
+  };
 }
-function lifecycle(scope, index, thisObj) {
-  const instance = scope[index];
-  if (instance) {
-    Object.assign(instance, thisObj);
-    instance.onUpdate?.();
-  } else {
-    scope[index] = thisObj;
-    thisObj.onMount?.();
-    getAbortSignal(
-      scope,
-      "LifecycleAbortController:" /* LifecycleAbortController */ + index
-    ).onabort = () => thisObj.onDestroy?.();
-  }
+function registerContent(id, template, walks, setup, params, dynamicScopesAccessor) {
+  return register(
+    id,
+    createContent(id, template, walks, setup, params, dynamicScopesAccessor)
+  );
 }
-function removeChildNodes(startNode, endNode) {
-  const stop = endNode.nextSibling;
-  let current = startNode;
-  while (current !== stop) {
-    const next = current.nextSibling;
-    current.remove();
-    current = next;
+function localClosures(renderer, closureFns) {
+  const closureSignals = {};
+  for (const key in closureFns) {
+    closureSignals[key] = value(key, closureFns[key]);
   }
+  return (owner, closureValues) => {
+    const instance = renderer(owner);
+    instance.___localClosures = closureSignals;
+    instance.___localClosureValues = closureValues;
+    return instance;
+  };
 }
-function insertChildNodes(parentNode, referenceNode, startNode, endNode) {
-  parentNode.insertBefore(toInsertNode(startNode, endNode), referenceNode);
+function createRenderer(template, walks, setup, params) {
+  return createContent("", template, walks, setup, params)();
 }
-function toInsertNode(startNode, endNode) {
-  if (startNode === endNode) return startNode;
-  const parent = new DocumentFragment();
-  const stop = endNode.nextSibling;
-  let current = startNode;
-  while (current !== stop) {
-    const next = current.nextSibling;
-    parent.appendChild(current);
-    current = next;
-  }
-  return parent;
+var cloneCache = {};
+function createCloneableHTML(html2, ns) {
+  const { firstChild, lastChild } = parseHTML(html2, ns);
+  const parent = document.createElementNS(ns, "t");
+  insertChildNodes(parent, null, firstChild, lastChild);
+  return firstChild === lastChild && firstChild.nodeType < 8 /* Comment */ ? (branch, walks) => {
+    walk(
+      branch.___startNode = branch.___endNode = firstChild.cloneNode(true),
+      walks,
+      branch
+    );
+  } : (branch, walks) => {
+    const clone = parent.cloneNode(true);
+    walk(clone.firstChild, walks, branch);
+    branch.___startNode = clone.firstChild;
+    branch.___endNode = clone.lastChild;
+  };
 }
 
-// src/dom/scope.ts
-function createScope($global, closestBranch) {
-  const scope = {
-    ___id: $global.___nextScopeId++,
-    ___creating: 1,
-    ___closestBranch: closestBranch,
-    $global
-  };
-  pendingScopes.push(scope);
-  return scope;
+// src/dom/dom.ts
+function attr(element, name, value2) {
+  setAttribute(element, name, normalizeAttrValue(value2));
 }
-function skipScope(scope) {
-  return scope.$global.___nextScopeId++;
+function setAttribute(element, name, value2) {
+  if (element.getAttribute(name) != value2) {
+    if (value2 === void 0) {
+      element.removeAttribute(name);
+    } else {
+      element.setAttribute(name, value2);
+    }
+  }
 }
-function findBranchWithKey(scope, key) {
-  let branch = scope.___closestBranch;
-  while (branch && !branch[key]) {
-    branch = branch.___parentBranch;
+function classAttr(element, value2) {
+  setAttribute(element, "class", classValue(value2) || void 0);
+}
+function classItems(element, items) {
+  for (const key in items) {
+    classItem(element, key, items[key]);
   }
-  return branch;
 }
-function destroyBranch(branch) {
-  branch.___parentBranch?.___branchScopes?.delete(branch);
-  destroyNestedBranches(branch);
+function classItem(element, name, value2) {
+  element.classList.toggle(name, !!value2);
 }
-function destroyNestedBranches(branch) {
-  branch.___destroyed = 1;
-  branch.___branchScopes?.forEach(destroyNestedBranches);
-  branch.___abortScopes?.forEach((scope) => {
-    for (const id in scope.___abortControllers) {
-      scope.___abortControllers[id]?.abort();
-    }
-  });
+function styleAttr(element, value2) {
+  setAttribute(element, "style", styleValue(value2) || void 0);
 }
-function removeAndDestroyBranch(branch) {
-  destroyBranch(branch);
-  removeChildNodes(branch.___startNode, branch.___endNode);
+function styleItems(element, items) {
+  for (const key in items) {
+    styleItem(element, key, items[key]);
+  }
 }
-function insertBranchBefore(branch, parentNode, nextSibling) {
-  insertChildNodes(
-    parentNode,
-    nextSibling,
-    branch.___startNode,
-    branch.___endNode
-  );
+function styleItem(element, name, value2) {
+  element.style.setProperty(name, value2 || value2 === 0 ? value2 + "" : "");
 }
-function tempDetachBranch(branch) {
-  const fragment = new DocumentFragment();
-  fragment.namespaceURI = branch.___startNode.parentNode.namespaceURI;
-  insertChildNodes(fragment, null, branch.___startNode, branch.___endNode);
+function data(node, value2) {
+  const normalizedValue = normalizeString(value2);
+  if (node.data !== normalizedValue) {
+    node.data = normalizedValue;
+  }
 }
-
-// src/dom/reconcile.ts
-var WRONG_POS = 2147483647;
-function reconcile(parent, oldBranches, newBranches, afterReference) {
-  let oldStart = 0;
-  let newStart = 0;
-  let oldEnd = oldBranches.length - 1;
-  let newEnd = newBranches.length - 1;
-  let oldStartBranch = oldBranches[oldStart];
-  let newStartBranch = newBranches[newStart];
-  let oldEndBranch = oldBranches[oldEnd];
-  let newEndBranch = newBranches[newEnd];
-  let i;
-  let j;
-  let k;
-  let nextSibling;
-  let oldBranch;
-  let newBranch;
-  outer: {
-    while (oldStartBranch === newStartBranch) {
-      ++oldStart;
-      ++newStart;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldStartBranch = oldBranches[oldStart];
-      newStartBranch = newBranches[newStart];
-    }
-    while (oldEndBranch === newEndBranch) {
-      --oldEnd;
-      --newEnd;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldEndBranch = oldBranches[oldEnd];
-      newEndBranch = newBranches[newEnd];
-    }
+function textContent(node, value2) {
+  const normalizedValue = normalizeString(value2);
+  if (node.textContent !== normalizedValue) {
+    node.textContent = normalizedValue;
   }
-  if (oldStart > oldEnd) {
-    if (newStart <= newEnd) {
-      k = newEnd + 1;
-      nextSibling = k < newBranches.length ? newBranches[k].___startNode : afterReference;
-      do {
-        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
-      } while (newStart <= newEnd);
+}
+function attrs(scope, nodeAccessor, nextAttrs) {
+  const el = scope[nodeAccessor];
+  for (let i = el.attributes.length; i--; ) {
+    const { name } = el.attributes.item(i);
+    if (!(nextAttrs && (name in nextAttrs || hasAttrAlias(el, name, nextAttrs)))) {
+      el.removeAttribute(name);
     }
-  } else if (newStart > newEnd) {
-    do {
-      removeAndDestroyBranch(oldBranches[oldStart++]);
-    } while (oldStart <= oldEnd);
-  } else {
-    const oldLength = oldEnd - oldStart + 1;
-    const newLength = newEnd - newStart + 1;
-    const aNullable = oldBranches;
-    const sources = new Array(newLength);
-    for (i = 0; i < newLength; ++i) {
-      sources[i] = -1;
-    }
-    let pos = 0;
-    let synced = 0;
-    const keyIndex = /* @__PURE__ */ new Map();
-    for (j = newStart; j <= newEnd; ++j) {
-      keyIndex.set(newBranches[j], j);
-    }
-    for (i = oldStart; i <= oldEnd && synced < newLength; ++i) {
-      oldBranch = oldBranches[i];
-      j = keyIndex.get(oldBranch);
-      if (j !== void 0) {
-        pos = pos > j ? WRONG_POS : j;
-        ++synced;
-        newBranch = newBranches[j];
-        sources[j - newStart] = i;
-        aNullable[i] = null;
-      }
+  }
+  attrsInternal(scope, nodeAccessor, nextAttrs);
+}
+function attrsAndContent(scope, nodeAccessor, nextAttrs) {
+  attrs(scope, nodeAccessor, nextAttrs);
+  insertContent(scope, nodeAccessor, nextAttrs?.content);
+}
+function hasAttrAlias(element, attr2, nextAttrs) {
+  return attr2 === "checked" && element.tagName === "INPUT" && "checkedValue" in nextAttrs;
+}
+function partialAttrs(scope, nodeAccessor, nextAttrs, skip) {
+  const el = scope[nodeAccessor];
+  const partial = {};
+  for (let i = el.attributes.length; i--; ) {
+    const { name } = el.attributes.item(i);
+    if (!skip[name] && !(nextAttrs && name in nextAttrs)) {
+      el.removeAttribute(name);
     }
-    if (oldLength === oldBranches.length && synced === 0) {
-      for (; newStart < newLength; ++newStart) {
-        insertBranchBefore(newBranches[newStart], parent, afterReference);
+  }
+  for (const key in nextAttrs) {
+    if (!skip[key]) partial[key] = nextAttrs[key];
+  }
+  attrsInternal(scope, nodeAccessor, partial);
+}
+function partialAttrsAndContent(scope, nodeAccessor, nextAttrs, skip) {
+  partialAttrs(scope, nodeAccessor, nextAttrs, skip);
+  insertContent(scope, nodeAccessor, nextAttrs?.content);
+}
+function attrsInternal(scope, nodeAccessor, nextAttrs) {
+  const el = scope[nodeAccessor];
+  let events;
+  let skip;
+  switch (el.tagName) {
+    case "INPUT":
+      if ("checked" in nextAttrs || "checkedChange" in nextAttrs) {
+        controllable_input_checked(
+          scope,
+          nodeAccessor,
+          nextAttrs.checked,
+          nextAttrs.checkedChange
+        );
+      } else if ("checkedValue" in nextAttrs || "checkedValueChange" in nextAttrs) {
+        controllable_input_checkedValue(
+          scope,
+          nodeAccessor,
+          nextAttrs.checkedValue,
+          nextAttrs.checkedValueChange,
+          nextAttrs.value
+        );
+      } else if ("value" in nextAttrs || "valueChange" in nextAttrs) {
+        controllable_input_value(
+          scope,
+          nodeAccessor,
+          nextAttrs.value,
+          nextAttrs.valueChange
+        );
+      } else {
+        break;
       }
-      for (; oldStart < oldLength; ++oldStart) {
-        removeAndDestroyBranch(oldBranches[oldStart]);
+      skip = /^(?:value|checked(?:Value)?)(?:Change)?$/;
+      break;
+    case "SELECT":
+      if ("value" in nextAttrs || "valueChange" in nextAttrs) {
+        controllable_select_value(
+          scope,
+          nodeAccessor,
+          nextAttrs.value,
+          nextAttrs.valueChange
+        );
+        skip = /^value(?:Change)?$/;
       }
-    } else {
-      i = oldLength - synced;
-      while (i > 0) {
-        oldBranch = aNullable[oldStart++];
-        if (oldBranch !== null) {
-          removeAndDestroyBranch(oldBranch);
-          i--;
-        }
+      break;
+    case "TEXTAREA":
+      if ("value" in nextAttrs || "valueChange" in nextAttrs) {
+        controllable_input_value(
+          scope,
+          nodeAccessor,
+          nextAttrs.value,
+          nextAttrs.valueChange
+        );
+        skip = /^value(?:Change)?$/;
       }
-      if (pos === WRONG_POS) {
-        const seq = longestIncreasingSubsequence(sources);
-        j = seq.length - 1;
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-            insertBranchBefore(newBranch, parent, nextSibling);
-          } else {
-            if (j < 0 || i !== seq[j]) {
-              pos = i + newStart;
-              newBranch = newBranches[pos++];
-              nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-              insertBranchBefore(newBranch, parent, nextSibling);
-            } else {
-              --j;
-            }
-          }
-        }
-      } else if (synced !== newLength) {
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
-            insertBranchBefore(newBranch, parent, nextSibling);
-          }
-        }
+      break;
+    case "DETAILS":
+    case "DIALOG":
+      if ("open" in nextAttrs || "openChange" in nextAttrs) {
+        controllable_detailsOrDialog_open(
+          scope,
+          nodeAccessor,
+          nextAttrs.open,
+          nextAttrs.openChange
+        );
+        skip = /^open(?:Change)?$/;
       }
-    }
+      break;
   }
-}
-function longestIncreasingSubsequence(a) {
-  const p = a.slice();
-  const result = [0];
-  let u;
-  let v;
-  for (let i = 0, il = a.length; i < il; ++i) {
-    if (a[i] === -1) {
-      continue;
-    }
-    const j = result[result.length - 1];
-    if (a[j] < a[i]) {
-      p[i] = j;
-      result.push(i);
-      continue;
-    }
-    u = 0;
-    v = result.length - 1;
-    while (u < v) {
-      const c = (u + v) / 2 | 0;
-      if (a[result[c]] < a[i]) {
-        u = c + 1;
-      } else {
-        v = c;
+  for (const name in nextAttrs) {
+    const value2 = nextAttrs[name];
+    switch (name) {
+      case "class":
+        classAttr(el, value2);
+        break;
+      case "style":
+        styleAttr(el, value2);
+        break;
+      case "content": {
+        break;
       }
-    }
-    if (a[i] < a[result[u]]) {
-      if (u > 0) {
-        p[i] = result[u - 1];
+      default: {
+        if (isEventHandler(name)) {
+          (events ||= scope["EventAttributes:" /* EventAttributes */ + nodeAccessor] = {})[getEventHandlerName(name)] = value2;
+        } else if (!skip?.test(name)) {
+          attr(el, name, value2);
+        }
       }
-      result[u] = i;
     }
   }
-  u = result.length;
-  v = result[u - 1];
-  while (u-- > 0) {
-    result[u] = v;
-    v = p[v];
-  }
-  return result;
 }
-
-// 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;
-      }
+function insertContent(scope, nodeAccessor, value2) {
+  const content = normalizeClientRender(value2);
+  const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
+  if (scope[rendererAccessor] !== (scope[rendererAccessor] = content?.___id)) {
+    setConditionalRenderer(scope, nodeAccessor, content, createAndSetupBranch);
+    if (content?.___accessor) {
+      subscribeToScopeSet(
+        content.___owner,
+        content.___accessor,
+        scope["ConditionalScope:" /* ConditionalScope */ + nodeAccessor]
+      );
     }
-    isScheduled = 1;
-    queueMicrotask(flushAndWaitFrame);
   }
 }
-function flushAndWaitFrame() {
-  if (true) {
-    runTask();
-  } else {
-    run();
+function attrsEvents(scope, nodeAccessor) {
+  const el = scope[nodeAccessor];
+  const events = scope["EventAttributes:" /* EventAttributes */ + nodeAccessor];
+  switch (scope["ControlledType:" /* ControlledType */ + nodeAccessor]) {
+    case 0 /* InputChecked */:
+      controllable_input_checked_effect(scope, nodeAccessor);
+      break;
+    case 1 /* InputCheckedValue */:
+      controllable_input_checkedValue_effect(scope, nodeAccessor);
+      break;
+    case 2 /* InputValue */:
+      controllable_input_value_effect(scope, nodeAccessor);
+      break;
+    case 3 /* SelectValue */:
+      controllable_select_value_effect(scope, nodeAccessor);
+      break;
+    case 4 /* DetailsOrDialogOpen */:
+      controllable_detailsOrDialog_open_effect(scope, nodeAccessor);
+      break;
+  }
+  for (const name in events) {
+    on(el, name, events[name]);
   }
-  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);
+function html(scope, value2, accessor) {
+  const firstChild = scope[accessor];
+  const parentNode = firstChild.parentNode;
+  const lastChild = scope["DynamicPlaceholderLastChild:" /* DynamicPlaceholderLastChild */ + accessor] || firstChild;
+  const newContent = parseHTML(
+    value2 || value2 === 0 ? value2 + "" : "",
+    parentNode.namespaceURI
+  );
+  insertChildNodes(
+    parentNode,
+    firstChild,
+    scope[accessor] = newContent.firstChild || newContent.appendChild(new Text()),
+    scope["DynamicPlaceholderLastChild:" /* DynamicPlaceholderLastChild */ + accessor] = newContent.lastChild
+  );
+  removeChildNodes(firstChild, lastChild);
 }
-
-// src/dom/signals.ts
-function state(valueAccessor, fn) {
-  if (true) {
-    var id = +valueAccessor.slice(
-      valueAccessor.lastIndexOf("/") + 1
-    );
-    valueAccessor = valueAccessor.slice(
-      0,
-      valueAccessor.lastIndexOf("/")
-    );
-  }
-  const valueChangeAccessor = "TagVariableChange:" /* TagVariableChange */ + valueAccessor;
-  const update = (scope, value2) => {
-    if (scope[valueAccessor] !== value2) {
-      scope[valueAccessor] = value2;
-      fn(scope, value2);
-    }
-  };
-  return (scope, value2, valueChange) => {
-    if (rendering) {
-      if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value2 || !(valueAccessor in scope)) {
-        scope[valueAccessor] = value2;
-        fn(scope, value2);
-      }
-    } else if (scope[valueChangeAccessor]) {
-      scope[valueChangeAccessor](value2);
-    } else {
-      schedule();
-      queueRender(
-        scope,
-        update,
-        true ? id : valueAccessor,
-        value2
+function normalizeClientRender(value2) {
+  const renderer = normalizeDynamicRenderer(value2);
+  if (renderer) {
+    if (renderer.___id) {
+      return renderer;
+    } else if (true) {
+      throw new Error(
+        `Invalid \`content\` attribute. Received ${typeof value2}`
       );
     }
-    return value2;
-  };
-}
-function value(valueAccessor, fn = () => {
-}) {
-  return (scope, value2) => {
-    if (!(valueAccessor in scope) || scope[valueAccessor] !== value2) {
-      scope[valueAccessor] = value2;
-      fn(scope, value2);
-    }
-  };
+  }
 }
-function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "___id") {
-  return (scope) => {
-    if (scope.___creating) {
-      if (scope[id] === void 0) {
-        scope[id] = defaultPending;
-      } else if (!--scope[id]) {
-        fn(scope);
+function props(scope, nodeIndex, index) {
+  const nextProps = scope[index];
+  const prevProps = scope[index + "-"];
+  const node = scope[nodeIndex];
+  if (prevProps) {
+    for (const name in prevProps) {
+      if (!(name in nextProps)) {
+        node[name] = void 0;
       }
-    } else {
-      queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
-    }
-  };
-}
-function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
-  const childSignal = closure(valueAccessor, fn);
-  const loopScopeAccessor = "LoopScopeArray:" /* LoopScopeArray */ + ownerLoopNodeAccessor;
-  const loopScopeMapAccessor = "LoopScopeMap:" /* LoopScopeMap */ + ownerLoopNodeAccessor;
-  const ownerSignal = (ownerScope) => {
-    const scopes = ownerScope[loopScopeAccessor] ||= ownerScope[loopScopeMapAccessor] ? [...ownerScope[loopScopeMapAccessor].values()] : [];
-    const [firstScope] = scopes;
-    if (firstScope) {
-      queueRender(
-        ownerScope,
-        () => {
-          for (const scope of scopes) {
-            if (!scope.___creating && !scope.___destroyed) {
-              childSignal(scope);
-            }
-          }
-        },
-        -1,
-        0,
-        firstScope.___id
-      );
-    }
-  };
-  ownerSignal._ = childSignal;
-  return ownerSignal;
-}
-function conditionalClosure(valueAccessor, ownerConditionalNodeAccessor, branch, fn) {
-  const childSignal = closure(valueAccessor, fn);
-  const scopeAccessor = "ConditionalScope:" /* ConditionalScope */ + ownerConditionalNodeAccessor;
-  const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + ownerConditionalNodeAccessor;
-  const ownerSignal = (scope) => {
-    const ifScope = scope[scopeAccessor];
-    if (ifScope && !ifScope.___creating && scope[branchAccessor] === branch) {
-      queueRender(ifScope, childSignal, -1);
     }
-  };
-  ownerSignal._ = childSignal;
-  return ownerSignal;
-}
-function subscribeToScopeSet(ownerScope, accessor, scope) {
-  const subscribers = ownerScope[accessor] ||= /* @__PURE__ */ new Set();
-  if (!subscribers.has(scope)) {
-    subscribers.add(scope);
-    getAbortSignal(scope, -1).addEventListener(
-      "abort",
-      () => ownerScope[accessor].delete(scope)
-    );
   }
+  for (const name in nextProps) {
+    node[name] = nextProps[name];
+  }
+  scope[index + "-"] = nextProps;
 }
-function dynamicClosure(...closureSignals) {
-  const [{ ___scopeInstancesAccessor, ___signalIndexAccessor }] = closureSignals;
-  for (let i = closureSignals.length; i--; ) {
-    closureSignals[i].___index = i;
+function normalizeAttrValue(value2) {
+  if (value2 || value2 === 0) {
+    return value2 === true ? "" : value2 + "";
   }
-  return (scope) => {
-    if (scope[___scopeInstancesAccessor]) {
-      for (const childScope of scope[___scopeInstancesAccessor]) {
-        if (!childScope.___creating) {
-          queueRender(
-            childScope,
-            closureSignals[childScope[___signalIndexAccessor]],
-            -1
-          );
-        }
-      }
-    }
-  };
 }
-function dynamicClosureRead(valueAccessor, fn, getOwnerScope) {
-  const childSignal = closure(valueAccessor, fn, getOwnerScope);
-  const closureSignal = (scope) => {
-    scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
-    childSignal(scope);
-    subscribeToScopeSet(
-      getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */],
-      closureSignal.___scopeInstancesAccessor,
-      scope
-    );
-  };
-  closureSignal.___scopeInstancesAccessor = "ClosureScopes:" /* ClosureScopes */ + valueAccessor;
-  closureSignal.___signalIndexAccessor = "ClosureSignalIndex:" /* ClosureSignalIndex */ + valueAccessor;
-  return closureSignal;
+function normalizeString(value2) {
+  return value2 || value2 === 0 ? value2 + "" : "\u200D";
 }
-function closure(valueAccessor, fn, getOwnerScope) {
-  return (scope) => {
-    fn(
+function lifecycle(scope, index, thisObj) {
+  const instance = scope[index];
+  if (instance) {
+    Object.assign(instance, thisObj);
+    instance.onUpdate?.();
+  } else {
+    scope[index] = thisObj;
+    thisObj.onMount?.();
+    getAbortSignal(
       scope,
-      (getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */])[valueAccessor]
-    );
-  };
-}
-function setTagVar(scope, childAccessor, tagVarSignal2) {
-  scope[childAccessor]["#TagVariable" /* TagVariable */] = (value2) => tagVarSignal2(scope, value2);
-}
-var tagVarSignal = (scope, value2) => scope["#TagVariable" /* TagVariable */]?.(value2);
-function setTagVarChange(scope, changeHandler) {
-  scope["#TagVariableChange" /* TagVariableChange */] = changeHandler;
+      "LifecycleAbortController:" /* LifecycleAbortController */ + index
+    ).onabort = () => thisObj.onDestroy?.();
+  }
 }
-var tagVarSignalChange = (scope, value2) => scope["#TagVariableChange" /* TagVariableChange */]?.(value2);
-var tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
-function nextTagId({ $global }) {
-  const id = tagIdsByGlobal.get($global) || 0;
-  tagIdsByGlobal.set($global, id + 1);
-  return "c" + $global.runtimeId + $global.renderId + id.toString(36);
+function removeChildNodes(startNode, endNode) {
+  const stop = endNode.nextSibling;
+  let current = startNode;
+  while (current !== stop) {
+    const next = current.nextSibling;
+    current.remove();
+    current = next;
+  }
 }
-function effect(id, fn) {
-  register(id, fn);
-  return (scope) => {
-    queueEffect(scope, fn);
-  };
+function insertChildNodes(parentNode, referenceNode, startNode, endNode) {
+  parentNode.insertBefore(toInsertNode(startNode, endNode), referenceNode);
 }
-function* traverseAllHoisted(scope, path, curIndex = path.length - 1) {
-  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 toInsertNode(startNode, endNode) {
+  if (startNode === endNode) return startNode;
+  const parent = new DocumentFragment();
+  const stop = endNode.nextSibling;
+  let current = startNode;
+  while (current !== stop) {
+    const next = current.nextSibling;
+    parent.appendChild(current);
+    current = next;
   }
-}
-function hoist(...path) {
-  return (scope) => {
-    const getOne = (...args) => iterator().next().value(...args);
-    const iterator = getOne[Symbol.iterator] = () => traverseAllHoisted(scope, path);
-    return getOne;
-  };
+  return parent;
 }
 
-// src/dom/walker.ts
-var walker = /* @__PURE__ */ document.createTreeWalker(document);
-function walk(startNode, walkCodes, branch) {
-  walker.currentNode = startNode;
-  walkInternal(0, walkCodes, branch);
-}
-function walkInternal(currentWalkIndex, walkCodes, scope) {
-  let value2;
-  let storedMultiplier = 0;
-  let currentMultiplier = 0;
-  let currentScopeIndex = 0;
-  for (; currentWalkIndex < walkCodes.length; ) {
-    value2 = walkCodes.charCodeAt(currentWalkIndex++);
-    currentMultiplier = storedMultiplier;
-    storedMultiplier = 0;
-    if (value2 === 32 /* Get */) {
-      const node = walker.currentNode;
-      scope[true ? getDebugKey(currentScopeIndex, walker.currentNode) : currentScopeIndex] = node;
-      scope["Getter:" /* Getter */ + (true ? getDebugKey(currentScopeIndex++, walker.currentNode) : currentScopeIndex++)] = () => node;
-    } else if (value2 === 37 /* Replace */ || value2 === 49 /* DynamicTagWithVar */) {
-      walker.currentNode.replaceWith(
-        walker.currentNode = scope[true ? getDebugKey(currentScopeIndex++, "#text") : currentScopeIndex++] = new Text()
-      );
-      if (value2 === 49 /* DynamicTagWithVar */) {
-        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : currentScopeIndex++] = skipScope(scope);
+// src/dom/reconcile.ts
+var WRONG_POS = 2147483647;
+function reconcile(parent, oldBranches, newBranches, afterReference) {
+  let oldStart = 0;
+  let newStart = 0;
+  let oldEnd = oldBranches.length - 1;
+  let newEnd = newBranches.length - 1;
+  let oldStartBranch = oldBranches[oldStart];
+  let newStartBranch = newBranches[newStart];
+  let oldEndBranch = oldBranches[oldEnd];
+  let newEndBranch = newBranches[newEnd];
+  let i;
+  let j;
+  let k;
+  let nextSibling;
+  let oldBranch;
+  let newBranch;
+  outer: {
+    while (oldStartBranch === newStartBranch) {
+      ++oldStart;
+      ++newStart;
+      if (oldStart > oldEnd || newStart > newEnd) {
+        break outer;
       }
-    } else if (value2 === 38 /* EndChild */) {
-      return currentWalkIndex;
-    } else if (value2 === 47 /* BeginChild */ || value2 === 48 /* BeginChildWithVar */) {
-      currentWalkIndex = walkInternal(
-        currentWalkIndex,
-        walkCodes,
-        scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : currentScopeIndex++] = createScope(scope.$global, scope.___closestBranch)
-      );
-      if (value2 === 48 /* BeginChildWithVar */) {
-        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : currentScopeIndex++] = skipScope(scope);
+      oldStartBranch = oldBranches[oldStart];
+      newStartBranch = newBranches[newStart];
+    }
+    while (oldEndBranch === newEndBranch) {
+      --oldEnd;
+      --newEnd;
+      if (oldStart > oldEnd || newStart > newEnd) {
+        break outer;
       }
-    } else if (value2 < 91 /* NextEnd */ + 1) {
-      value2 = 20 /* Next */ * currentMultiplier + value2 - 67 /* Next */;
-      while (value2--) {
-        walker.nextNode();
+      oldEndBranch = oldBranches[oldEnd];
+      newEndBranch = newBranches[newEnd];
+    }
+  }
+  if (oldStart > oldEnd) {
+    if (newStart <= newEnd) {
+      k = newEnd + 1;
+      nextSibling = k < newBranches.length ? newBranches[k].___startNode : afterReference;
+      do {
+        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
+      } while (newStart <= newEnd);
+    }
+  } else if (newStart > newEnd) {
+    do {
+      removeAndDestroyBranch(oldBranches[oldStart++]);
+    } while (oldStart <= oldEnd);
+  } else {
+    const oldLength = oldEnd - oldStart + 1;
+    const newLength = newEnd - newStart + 1;
+    const aNullable = oldBranches;
+    const sources = new Array(newLength);
+    for (i = 0; i < newLength; ++i) {
+      sources[i] = -1;
+    }
+    let pos = 0;
+    let synced = 0;
+    const keyIndex = /* @__PURE__ */ new Map();
+    for (j = newStart; j <= newEnd; ++j) {
+      keyIndex.set(newBranches[j], j);
+    }
+    for (i = oldStart; i <= oldEnd && synced < newLength; ++i) {
+      oldBranch = oldBranches[i];
+      j = keyIndex.get(oldBranch);
+      if (j !== void 0) {
+        pos = pos > j ? WRONG_POS : j;
+        ++synced;
+        newBranch = newBranches[j];
+        sources[j - newStart] = i;
+        aNullable[i] = null;
       }
-    } else if (value2 < 106 /* OverEnd */ + 1) {
-      value2 = 10 /* Over */ * currentMultiplier + value2 - 97 /* Over */;
-      while (value2--) {
-        walker.nextSibling();
+    }
+    if (oldLength === oldBranches.length && synced === 0) {
+      for (; newStart < newLength; ++newStart) {
+        insertBranchBefore(newBranches[newStart], parent, afterReference);
       }
-    } else if (value2 < 116 /* OutEnd */ + 1) {
-      value2 = 10 /* Out */ * currentMultiplier + value2 - 107 /* Out */;
-      while (value2--) {
-        walker.parentNode();
+      for (; oldStart < oldLength; ++oldStart) {
+        removeAndDestroyBranch(oldBranches[oldStart]);
       }
-      walker.nextSibling();
     } else {
-      if (value2 < 117 /* Multiplier */ || value2 > 126 /* MultiplierEnd */) {
-        throw new Error(`Unknown walk code: ${value2}`);
+      i = oldLength - synced;
+      while (i > 0) {
+        oldBranch = aNullable[oldStart++];
+        if (oldBranch !== null) {
+          removeAndDestroyBranch(oldBranch);
+          i--;
+        }
+      }
+      if (pos === WRONG_POS) {
+        const seq = longestIncreasingSubsequence(sources);
+        j = seq.length - 1;
+        k = newBranches.length;
+        for (i = newLength - 1; i >= 0; --i) {
+          if (sources[i] === -1) {
+            pos = i + newStart;
+            newBranch = newBranches[pos++];
+            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
+            insertBranchBefore(newBranch, parent, nextSibling);
+          } else {
+            if (j < 0 || i !== seq[j]) {
+              pos = i + newStart;
+              newBranch = newBranches[pos++];
+              nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
+              insertBranchBefore(newBranch, parent, nextSibling);
+            } else {
+              --j;
+            }
+          }
+        }
+      } else if (synced !== newLength) {
+        k = newBranches.length;
+        for (i = newLength - 1; i >= 0; --i) {
+          if (sources[i] === -1) {
+            pos = i + newStart;
+            newBranch = newBranches[pos++];
+            nextSibling = pos < k ? newBranches[pos].___startNode : afterReference;
+            insertBranchBefore(newBranch, parent, nextSibling);
+          }
+        }
       }
-      storedMultiplier = currentMultiplier * 10 /* Multiplier */ + value2 - 117 /* Multiplier */;
     }
   }
 }
-function getDebugKey(index, node) {
-  if (typeof node === "string") {
-    return `${node}/${index}`;
-  } else if (node.nodeType === 3 /* Text */) {
-    return `#text/${index}`;
-  } else if (node.nodeType === 8 /* Comment */) {
-    return `#comment/${index}`;
-  } else if (node.nodeType === 1 /* Element */) {
-    return `#${node.tagName.toLowerCase()}/${index}`;
-  }
-  return index;
-}
-
-// src/dom/renderer.ts
-function createBranch($global, renderer, parentScope, parentNode) {
-  const branch = createScope($global);
-  const parentBranch = parentScope?.___closestBranch;
-  branch["_" /* Owner */] = renderer.___owner || parentScope;
-  branch.___closestBranch = branch;
-  if (parentBranch) {
-    branch.___parentBranch = parentBranch;
-    (parentBranch.___branchScopes ||= /* @__PURE__ */ new Set()).add(branch);
-  }
-  if (true) {
-    branch.___renderer = renderer;
-  }
-  renderer.___clone?.(
-    branch,
-    parentNode.namespaceURI
-  );
-  return 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);
+function longestIncreasingSubsequence(a) {
+  const p = a.slice();
+  const result = [0];
+  let u;
+  let v;
+  for (let i = 0, il = a.length; i < il; ++i) {
+    if (a[i] === -1) {
+      continue;
+    }
+    const j = result[result.length - 1];
+    if (a[j] < a[i]) {
+      p[i] = j;
+      result.push(i);
+      continue;
+    }
+    u = 0;
+    v = result.length - 1;
+    while (u < v) {
+      const c = (u + v) / 2 | 0;
+      if (a[result[c]] < a[i]) {
+        u = c + 1;
+      } else {
+        v = c;
+      }
+    }
+    if (a[i] < a[result[u]]) {
+      if (u > 0) {
+        p[i] = result[u - 1];
+      }
+      result[u] = i;
+    }
   }
-  return branch;
-}
-function createContent(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 = branch.___endNode = new Text(),
-      walks,
-      branch
-    );
-  };
-  return (owner) => {
-    return {
-      ___id: id,
-      ___clone: clone,
-      ___owner: owner,
-      ___setup: setup,
-      ___params: params,
-      ___accessor: dynamicScopesAccessor
-    };
-  };
-}
-function registerContent(id, template, walks, setup, params, dynamicScopesAccessor) {
-  return register(
-    id,
-    createContent(id, template, walks, setup, params, dynamicScopesAccessor)
-  );
-}
-function localClosures(renderer, closureFns) {
-  const closureSignals = {};
-  for (const key in closureFns) {
-    closureSignals[key] = value(key, closureFns[key]);
+  u = result.length;
+  v = result[u - 1];
+  while (u-- > 0) {
+    result[u] = v;
+    v = p[v];
   }
-  return (owner, closureValues) => {
-    const instance = renderer(owner);
-    instance.___localClosures = closureSignals;
-    instance.___localClosureValues = closureValues;
-    return instance;
-  };
-}
-function createRenderer(template, walks, setup, params) {
-  return createContent("", template, walks, setup, params)();
-}
-var cloneCache = {};
-function createCloneableHTML(html2, ns) {
-  const { firstChild, lastChild } = parseHTML(html2, ns);
-  const parent = document.createElementNS(ns, "t");
-  insertChildNodes(parent, null, firstChild, lastChild);
-  return firstChild === lastChild && firstChild.nodeType < 8 /* Comment */ ? (branch, walks) => {
-    walk(
-      branch.___startNode = branch.___endNode = firstChild.cloneNode(true),
-      walks,
-      branch
-    );
-  } : (branch, walks) => {
-    const clone = parent.cloneNode(true);
-    walk(clone.firstChild, walks, branch);
-    branch.___startNode = clone.firstChild;
-    branch.___endNode = clone.lastChild;
-  };
+  return result;
 }
 
 // src/dom/control-flow.ts