marko 5.37.6 → 6.0.0-3.12

package/dist/dom.js

@@ -0,0 +1,1370 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/dom.ts
+var dom_exports = {};
+__export(dom_exports, {
+  attr: () => attr,
+  attrTag: () => attrTag,
+  attrTags: () => attrTags,
+  attrs: () => attrs,
+  attrsEvents: () => attrsEvents,
+  childClosures: () => childClosures,
+  classAttr: () => classAttr,
+  closure: () => closure,
+  compat: () => compat,
+  conditional: () => conditional,
+  conditionalOnlyChild: () => conditionalOnlyChild,
+  controllable_detailsOrDialog_open: () => controllable_detailsOrDialog_open,
+  controllable_detailsOrDialog_open_effect: () => controllable_detailsOrDialog_open_effect,
+  controllable_input_checked: () => controllable_input_checked,
+  controllable_input_checkedValue: () => controllable_input_checkedValue,
+  controllable_input_checkedValue_effect: () => controllable_input_checkedValue_effect,
+  controllable_input_checked_effect: () => controllable_input_checked_effect,
+  controllable_input_value: () => controllable_input_value,
+  controllable_input_value_effect: () => controllable_input_value_effect,
+  controllable_select_value: () => controllable_select_value,
+  controllable_select_value_effect: () => controllable_select_value_effect,
+  controllable_textarea_value: () => controllable_input_value,
+  controllable_textarea_value_effect: () => controllable_input_value_effect,
+  createRenderer: () => createRenderer,
+  createRendererWithOwner: () => createRendererWithOwner,
+  createScope: () => createScope,
+  createTemplate: () => createTemplate,
+  data: () => data,
+  dynamicClosure: () => dynamicClosure,
+  dynamicSubscribers: () => dynamicSubscribers,
+  dynamicTagAttrs: () => dynamicTagAttrs,
+  effect: () => effect,
+  forIn: () => forIn,
+  forOf: () => forOf,
+  forTo: () => forTo,
+  getAbortSignal: () => getAbortSignal,
+  html: () => html,
+  inChild: () => inChild,
+  inConditionalScope: () => inConditionalScope,
+  inLoopScope: () => inLoopScope,
+  init: () => init,
+  intersection: () => intersection,
+  intersections: () => intersections,
+  lifecycle: () => lifecycle,
+  loopIn: () => loopIn,
+  loopOf: () => loopOf,
+  loopTo: () => loopTo,
+  nextTagId: () => nextTagId,
+  nodeRef: () => nodeRef,
+  on: () => on,
+  partialAttrs: () => partialAttrs,
+  props: () => props,
+  register: () => register,
+  registerBoundSignal: () => registerBoundSignal,
+  registerSubscriber: () => registerSubscriber,
+  resetAbortSignal: () => resetAbortSignal,
+  run: () => run,
+  setTagVar: () => setTagVar,
+  setTagVarChange: () => setTagVarChange,
+  state: () => state,
+  styleAttr: () => styleAttr,
+  tagVarSignal: () => tagVarSignal,
+  tagVarSignalChange: () => tagVarSignalChange,
+  textContent: () => textContent,
+  value: () => value
+});
+module.exports = __toCommonJS(dom_exports);
+
+// src/common/attr-tag.ts
+var empty = [], rest = Symbol();
+function attrTag(attrs2) {
+  return attrs2[Symbol.iterator] = attrTagIterator, attrs2[rest] = empty, attrs2;
+}
+function attrTags(first, attrs2) {
+  return first ? (first[rest] === empty ? first[rest] = [attrs2] : first[rest].push(attrs2), first) : attrTag(attrs2);
+}
+function* attrTagIterator() {
+  yield this, yield* this[rest];
+}
+
+// src/common/for.ts
+function forIn(obj, cb) {
+  for (let key in obj)
+    cb(key, obj[key]);
+}
+function forOf(list, cb) {
+  if (list) {
+    let i = 0;
+    for (let item of list)
+      cb(item, i++);
+  }
+}
+function forTo(to, from, step, cb) {
+  let start = from || 0, delta = step || 1;
+  for (let steps = (to - start) / delta, i = 0; i <= steps; i++)
+    cb(start + i * delta);
+}
+
+// src/dom/schedule.ts
+var port2 = /* @__PURE__ */ (() => {
+  let { port1, port2: port22 } = new MessageChannel();
+  return port1.onmessage = () => {
+    isScheduled = !1, run();
+  }, port22;
+})(), isScheduled;
+function schedule() {
+  isScheduled || (isScheduled = !0, queueMicrotask(flushAndWaitFrame));
+}
+function flushAndWaitFrame() {
+  run(), requestAnimationFrame(triggerMacroTask);
+}
+function triggerMacroTask() {
+  port2.postMessage(0);
+}
+
+// src/common/meta.ts
+var DEFAULT_RUNTIME_ID = "M", DEFAULT_RENDER_ID = "_";
+
+// src/dom/scope.ts
+function createScope($global) {
+  return {
+    u: 1,
+    $global
+  };
+}
+var emptyScope = createScope({});
+function getEmptyScope(marker) {
+  return emptyScope.a = emptyScope.b = marker, emptyScope;
+}
+function destroyScope(scope) {
+  _destroyScope(scope), scope.d?.h?.delete(scope);
+  let closureSignals = scope.x?.c;
+  if (closureSignals)
+    for (let signal of closureSignals)
+      signal.j?.(scope);
+  return scope;
+}
+function _destroyScope(scope) {
+  scope.h?.forEach(_destroyScope);
+  let controllers = scope.l;
+  if (controllers)
+    for (let ctrl of controllers.values())
+      ctrl.abort();
+}
+function onDestroy(scope) {
+  let parentScope = scope.d;
+  for (; parentScope && !parentScope.h?.has(scope); )
+    (parentScope.h ||= /* @__PURE__ */ new Set()).add(scope), scope = parentScope, parentScope = scope.d;
+}
+function removeAndDestroyScope(scope) {
+  destroyScope(scope);
+  let current = scope.a, stop = scope.b.nextSibling;
+  for (; current !== stop; ) {
+    let next = current.nextSibling;
+    current.remove(), current = next;
+  }
+}
+function insertBefore(scope, parent, nextSibling) {
+  let current = scope.a, stop = scope.b.nextSibling;
+  for (; current !== stop; ) {
+    let next = current.nextSibling;
+    parent.insertBefore(current, nextSibling), current = next;
+  }
+}
+
+// src/dom/resume.ts
+var registeredValues = {}, Render = class {
+  m = [];
+  n = {};
+  y = {
+    _: registeredValues
+  };
+  constructor(renders, runtimeId, renderId) {
+    this.z = renders, this.A = runtimeId, this.o = renderId, this.p = renders[renderId], this.q();
+  }
+  w() {
+    this.p.w(), this.q();
+  }
+  q() {
+    let data2 = this.p, serializeContext = this.y, scopeLookup = this.n, visits = data2.v, cleanupOwners = /* @__PURE__ */ new Map();
+    if (visits.length) {
+      let commentPrefixLen = data2.i.length, cleanupMarkers = /* @__PURE__ */ new Map();
+      data2.v = [];
+      let sectionEnd = (visit, scopeId = this.f, curNode = visit) => {
+        let scope = scopeLookup[scopeId] ||= {}, endNode = curNode;
+        for (; (endNode = endNode.previousSibling).nodeType === 8; ) ;
+        scope.b = endNode;
+        let startNode = scope.a ||= endNode, len = cleanupMarkers.size;
+        for (let [markerScopeId, markerNode] of cleanupMarkers) {
+          if (!len--) break;
+          markerScopeId !== scopeId && startNode.compareDocumentPosition(markerNode) & 4 && curNode.compareDocumentPosition(markerNode) & 2 && (cleanupOwners.set("" + markerScopeId, scopeId), cleanupMarkers.delete(markerScopeId));
+        }
+        return cleanupMarkers.set(scopeId, visit), scope;
+      };
+      for (let visit of visits) {
+        let commentText = visit.data, token = commentText[commentPrefixLen], scopeId = parseInt(commentText.slice(commentPrefixLen + 1)), scope = scopeLookup[scopeId] ||= {}, dataIndex = commentText.indexOf(" ") + 1, data3 = dataIndex ? commentText.slice(dataIndex) : "";
+        if (token === "*" /* Node */)
+          scope[data3] = visit.previousSibling;
+        else if (token === "$" /* Cleanup */)
+          cleanupMarkers.set(scopeId, visit);
+        else if (token === "[" /* SectionStart */)
+          this.f && (data3 && sectionEnd(visit), this.m.push(this.f)), this.f = scopeId, scope.a = visit;
+        else if (token === "]" /* SectionEnd */) {
+          if (scope[data3] = visit, scopeId < this.f) {
+            let currParent = visit.parentNode, startNode = sectionEnd(visit).a;
+            currParent && currParent !== startNode.parentNode && currParent.prepend(startNode), this.f = this.m.pop();
+          }
+        } else if (token === "|" /* SectionSingleNodesEnd */) {
+          scope[parseInt(data3)] = visit;
+          let childScopeIds = JSON.parse(
+            "[" + data3.slice(data3.indexOf(" ") + 1) + "]"
+          ), curNode = visit;
+          for (let i = childScopeIds.length - 1; i >= 0; i--)
+            curNode = sectionEnd(visit, childScopeIds[i], curNode).b;
+        }
+      }
+    }
+    let resumes = data2.r;
+    if (resumes) {
+      data2.r = [];
+      let len = resumes.length, i = 0;
+      try {
+        for (isResuming = !0; i < len; ) {
+          let resumeData = resumes[i++];
+          if (typeof resumeData == "function") {
+            let scopes = resumeData(serializeContext), { $global } = scopeLookup;
+            $global || (scopeLookup.$global = $global = scopes.$ || {}, $global.runtimeId = this.A, $global.renderId = this.o);
+            for (let scopeId in scopes)
+              if (scopeId !== "$") {
+                let scope = scopes[scopeId], prevScope = scopeLookup[scopeId];
+                scope.$global = $global, prevScope !== scope && (scopeLookup[scopeId] = Object.assign(
+                  scope,
+                  prevScope
+                ));
+                let cleanupOwnerId = cleanupOwners.get(scopeId);
+                cleanupOwnerId && (scope.d = scopes[cleanupOwnerId], onDestroy(scope));
+              }
+          } else i === len || typeof resumes[i] != "string" ? delete this.z[this.o] : registeredValues[resumes[i++]](
+            scopeLookup[resumeData],
+            scopeLookup[resumeData]
+          );
+        }
+      } finally {
+        isResuming = !1;
+      }
+    }
+  }
+}, isResuming = !1;
+function register(id, obj) {
+  return registeredValues[id] = obj, obj;
+}
+function registerBoundSignal(id, signal) {
+  return registeredValues[id] = (scope) => (valueOrOp) => signal(scope, valueOrOp), signal;
+}
+function getRegisteredWithScope(id, scope) {
+  let val = registeredValues[id];
+  return scope ? val(scope) : val;
+}
+function init(runtimeId = DEFAULT_RUNTIME_ID) {
+  let resumeRender = (renderId) => resumeRender[renderId] = renders[renderId] = new Render(renders, runtimeId, renderId), renders;
+  window[runtimeId] ? setRenders(window[runtimeId]) : Object.defineProperty(window, runtimeId, {
+    configurable: !0,
+    set: setRenders
+  });
+  function setRenders(v) {
+    renders = v;
+    for (let renderId in v)
+      resumeRender(renderId);
+    Object.defineProperty(window, runtimeId, {
+      configurable: !0,
+      value: resumeRender
+    });
+  }
+}
+function registerSubscriber(id, signal) {
+  return register(id, signal.g), signal;
+}
+function nodeRef(id, key) {
+  return register(id, (scope) => () => scope[key]);
+}
+
+// src/dom/signals.ts
+var MARK = {}, CLEAN = {}, DIRTY = {};
+function state(valueAccessor, fn, getIntersection) {
+  let valueSignal = value(valueAccessor, fn, getIntersection), markAccessor = valueAccessor + "#" /* Mark */, valueChangeAccessor = valueAccessor + "@" /* TagVariableChange */;
+  return (scope, valueOrOp, valueChange) => (rendering ? valueSignal(
+    scope,
+    valueOrOp === MARK || valueOrOp === CLEAN || valueOrOp === DIRTY || (scope[valueChangeAccessor] = valueChange) || scope[markAccessor] === void 0 ? valueOrOp : CLEAN
+  ) : scope[valueChangeAccessor] ? scope[valueChangeAccessor](valueOrOp) : queueSource(scope, valueSignal, valueOrOp), valueOrOp);
+}
+function value(valueAccessor, fn, getIntersection) {
+  let markAccessor = valueAccessor + "#" /* Mark */, intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
+  return (scope, valueOrOp) => {
+    if (valueOrOp === MARK)
+      (scope[markAccessor] = (scope[markAccessor] ?? 0) + 1) === 1 && intersection2?.(scope, MARK);
+    else if (valueOrOp !== DIRTY) {
+      let existing = scope[markAccessor] !== void 0;
+      (scope[markAccessor] ||= 1) === 1 && (valueOrOp === CLEAN || existing && scope[valueAccessor] === valueOrOp ? intersection2?.(scope, CLEAN) : (scope[valueAccessor] = valueOrOp, fn && fn(scope, valueOrOp), intersection2?.(scope, DIRTY))), scope[markAccessor]--;
+    }
+  };
+}
+var accessorId = 0;
+function intersection(count, fn, getIntersection) {
+  let dirtyAccessor = "?" /* Dynamic */ + accessorId++, markAccessor = dirtyAccessor + "#" /* Mark */, intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
+  return (scope, op) => {
+    op === MARK ? (scope[markAccessor] = (scope[markAccessor] ?? 0) + 1) === 1 && intersection2?.(scope, MARK) : scope[markAccessor] === void 0 ? (scope[markAccessor] = count - 1, scope[dirtyAccessor] = !0) : --scope[markAccessor] === 0 ? op === DIRTY || scope[dirtyAccessor] ? (scope[dirtyAccessor] = !1, fn(scope, 0), intersection2?.(scope, DIRTY)) : intersection2?.(scope, CLEAN) : scope[dirtyAccessor] ||= op === DIRTY;
+  };
+}
+var defaultGetOwnerScope = (scope) => scope._;
+function closure(ownerValueAccessor, fn, getOwnerScope = defaultGetOwnerScope, getIntersection) {
+  let dirtyAccessor = "?" /* Dynamic */ + accessorId++, markAccessor = dirtyAccessor + 1, getOwnerValueAccessor = typeof ownerValueAccessor == "function" ? ownerValueAccessor : () => ownerValueAccessor, intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
+  return (scope, op) => {
+    if (op === MARK)
+      (scope[markAccessor] = (scope[markAccessor] ?? 0) + 1) === 1 && intersection2?.(scope, MARK);
+    else {
+      let ownerScope, ownerValueAccessor2;
+      if (scope[markAccessor] === void 0) {
+        ownerScope = getOwnerScope(scope), ownerValueAccessor2 = getOwnerValueAccessor(scope);
+        let ownerMark = ownerScope[ownerValueAccessor2 + "#" /* Mark */], ownerHasRun = ownerMark === void 0 ? !ownerScope.u : ownerMark === 0;
+        scope[markAccessor] = ownerHasRun ? 1 : 2, op = DIRTY;
+      }
+      --scope[markAccessor] === 0 ? op === DIRTY || scope[dirtyAccessor] ? (scope[dirtyAccessor] = !1, ownerScope ||= getOwnerScope(scope), ownerValueAccessor2 ||= getOwnerValueAccessor(scope), fn && fn(scope, ownerScope[ownerValueAccessor2]), intersection2?.(scope, DIRTY)) : intersection2?.(scope, CLEAN) : scope[dirtyAccessor] ||= op === DIRTY;
+    }
+  };
+}
+function dynamicClosure(ownerValueAccessor, fn, getOwnerScope = defaultGetOwnerScope, getIntersection) {
+  let getOwnerValueAccessor = typeof ownerValueAccessor == "function" ? ownerValueAccessor : () => ownerValueAccessor, signalFn = closure(
+    getOwnerValueAccessor,
+    fn,
+    getOwnerScope,
+    getIntersection
+  ), subscribeFns = /* @__PURE__ */ new WeakMap();
+  return signalFn.g = (scope) => {
+    let subscribeFn = (value2) => signalFn(scope, value2), ownerScope = getOwnerScope(scope), providerSubscriptionsAccessor = getOwnerValueAccessor(scope) + "*" /* Subscribers */;
+    subscribeFns.set(scope, subscribeFn), (ownerScope[providerSubscriptionsAccessor] ||= /* @__PURE__ */ new Set()).add(subscribeFn);
+  }, signalFn.j = (scope) => {
+    let ownerScope = getOwnerScope(scope), providerSubscriptionsAccessor = getOwnerValueAccessor(scope) + "*" /* Subscribers */;
+    ownerScope[providerSubscriptionsAccessor]?.delete(subscribeFns.get(scope)), subscribeFns.delete(scope);
+  }, signalFn;
+}
+function childClosures(closureSignals, childAccessor) {
+  let signal = (scope, op) => {
+    let childScope = scope[childAccessor];
+    for (let closureSignal of closureSignals)
+      closureSignal(childScope, op);
+  };
+  return signal.g = (scope) => {
+    let childScope = scope[childAccessor];
+    for (let closureSignal of closureSignals)
+      closureSignal.g?.(childScope);
+  }, signal.j = (scope) => {
+    let childScope = scope[childAccessor];
+    for (let closureSignal of closureSignals)
+      closureSignal.j?.(childScope);
+  }, signal;
+}
+function dynamicSubscribers(valueAccessor) {
+  let subscribersAccessor = valueAccessor + "*" /* Subscribers */;
+  return (scope, op) => {
+    let subscribers = scope[subscribersAccessor];
+    if (subscribers)
+      for (let subscriber of subscribers)
+        subscriber(op);
+  };
+}
+function setTagVar(scope, childAccessor, tagVarSignal2) {
+  scope[childAccessor]["/" /* TagVariable */] = (valueOrOp) => tagVarSignal2(scope, valueOrOp);
+}
+var tagVarSignal = (scope, valueOrOp) => scope["/" /* TagVariable */]?.(valueOrOp);
+function setTagVarChange(scope, changeHandler) {
+  scope["@" /* TagVariableChange */] = changeHandler;
+}
+var tagVarSignalChange = (scope, value2) => scope["@" /* TagVariableChange */]?.(value2), renderBodyClosures = (renderBody, childScope, op) => {
+  let signals = renderBody?.c;
+  if (signals)
+    for (let signal of signals)
+      signal(childScope, op);
+};
+var tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
+function nextTagId({ $global }) {
+  let id = tagIdsByGlobal.get($global) || 0;
+  return tagIdsByGlobal.set($global, id + 1), "c" + $global.runtimeId + $global.renderId + id.toString(36);
+}
+function inChild(childAccessor, signal) {
+  return (scope, valueOrOp) => {
+    signal(scope[childAccessor], valueOrOp);
+  };
+}
+function intersections(signals) {
+  return (scope, op) => {
+    for (let signal of signals)
+      signal(scope, op);
+  };
+}
+function effect(id, fn) {
+  return register(id, fn), (scope) => {
+    queueEffect(scope, fn);
+  };
+}
+
+// src/dom/queue.ts
+var pendingSignals = [], pendingEffects = [], rendering = !1;
+function queueSource(scope, signal, value2) {
+  return schedule(), rendering = !0, signal(scope, MARK), rendering = !1, pendingSignals.push(scope, signal, value2), value2;
+}
+function queueEffect(scope, fn) {
+  pendingEffects.push(scope, fn);
+}
+function run() {
+  let signals = pendingSignals, effects = pendingEffects;
+  try {
+    rendering = !0, pendingSignals = [], runSignals(signals);
+  } finally {
+    rendering = !1;
+  }
+  pendingEffects = [], runEffects(effects);
+}
+function prepareEffects(fn) {
+  let prevSignals = pendingSignals, prevEffects = pendingEffects, preparedEffects = pendingEffects = [], preparedSignals = pendingSignals = [];
+  try {
+    rendering = !0, fn(), pendingSignals = prevSignals, runSignals(preparedSignals);
+  } finally {
+    rendering = !1, pendingSignals = prevSignals, pendingEffects = prevEffects;
+  }
+  return preparedEffects;
+}
+function runEffects(effects = pendingEffects) {
+  for (let i = 0; i < effects.length; i += 2 /* Total */) {
+    let scope = effects[i], fn = effects[i + 1];
+    fn(scope, scope);
+  }
+}
+function runSignals(signals) {
+  for (let i = 0; i < signals.length; i += 3 /* Total */) {
+    let scope = signals[i + 0 /* Scope */], signal = signals[i + 1 /* Signal */], value2 = signals[i + 2 /* Value */];
+    signal(scope, value2);
+  }
+}
+
+// src/dom/abort-signal.ts
+function resetAbortSignal(scope, id) {
+  let controllers = scope.l;
+  if (controllers) {
+    let ctrl = controllers.get(id);
+    ctrl && (queueEffect(null, () => ctrl.abort()), controllers.delete(id));
+  }
+}
+function getAbortSignal(scope, id) {
+  let controllers = scope.l ||= /* @__PURE__ */ new Map(), controller = controllers.get(id);
+  return controller || (onDestroy(scope), controllers.set(id, controller = new AbortController())), controller.signal;
+}
+
+// src/common/compat-meta.ts
+var prefix = "$C_", RENDERER_REGISTER_ID = prefix + "r", SET_SCOPE_REGISTER_ID = prefix + "s";
+
+// src/common/helpers.ts
+function classValue(value2) {
+  return toDelimitedString(value2, " ", stringifyClassObject);
+}
+function stringifyClassObject(name, value2) {
+  return value2 ? name : "";
+}
+function styleValue(value2) {
+  return toDelimitedString(value2, ";", stringifyStyleObject);
+}
+var NON_DIMENSIONAL = /^(--|ta|or|li|z)|n-c|i(do|nk|m|t)|w$|we/;
+function stringifyStyleObject(name, value2) {
+  return value2 || value2 === 0 ? `${name}:${typeof value2 == "number" && value2 && !NON_DIMENSIONAL.test(name) ? value2 + "px" : value2}` : "";
+}
+function toDelimitedString(val, delimiter, stringify) {
+  switch (typeof val) {
+    case "string":
+      return val;
+    case "object":
+      if (val !== null) {
+        let result = "", curDelimiter = "";
+        if (Array.isArray(val))
+          for (let v of val) {
+            let part = toDelimitedString(v, delimiter, stringify);
+            part !== "" && (result += curDelimiter + part, curDelimiter = delimiter);
+          }
+        else
+          for (let name in val) {
+            let v = val[name], part = stringify(name, v);
+            part !== "" && (result += curDelimiter + part, curDelimiter = delimiter);
+          }
+        return result;
+      }
+  }
+  return "";
+}
+function isEventHandler(name) {
+  return /^on[A-Z-]/.test(name);
+}
+function getEventHandlerName(name) {
+  return name[2] === "-" ? name.slice(3) : name.slice(2).toLowerCase();
+}
+function normalizeDynamicRenderer(value2) {
+  if (value2) return value2.renderBody || value2.default || value2;
+}
+
+// src/dom/reconcile.ts
+var WRONG_POS = 2147483647;
+function reconcile(parent, oldScopes, newScopes, afterReference) {
+  let oldStart = 0, newStart = 0, oldEnd = oldScopes.length - 1, newEnd = newScopes.length - 1, oldStartScope = oldScopes[oldStart], newStartScope = newScopes[newStart], oldEndScope = oldScopes[oldEnd], newEndScope = newScopes[newEnd], i, j, k, nextSibling, oldScope, newScope;
+  outer: {
+    for (; oldStartScope === newStartScope; ) {
+      if (++oldStart, ++newStart, oldStart > oldEnd || newStart > newEnd)
+        break outer;
+      oldStartScope = oldScopes[oldStart], newStartScope = newScopes[newStart];
+    }
+    for (; oldEndScope === newEndScope; ) {
+      if (--oldEnd, --newEnd, oldStart > oldEnd || newStart > newEnd)
+        break outer;
+      oldEndScope = oldScopes[oldEnd], newEndScope = newScopes[newEnd];
+    }
+  }
+  if (oldStart > oldEnd) {
+    if (newStart <= newEnd) {
+      k = newEnd + 1, nextSibling = k < newScopes.length ? newScopes[k].a : afterReference;
+      do
+        insertBefore(newScopes[newStart++], parent, nextSibling);
+      while (newStart <= newEnd);
+    }
+  } else if (newStart > newEnd)
+    do
+      removeAndDestroyScope(oldScopes[oldStart++]);
+    while (oldStart <= oldEnd);
+  else {
+    let oldLength = oldEnd - oldStart + 1, newLength = newEnd - newStart + 1, aNullable = oldScopes, sources = new Array(newLength);
+    for (i = 0; i < newLength; ++i)
+      sources[i] = -1;
+    let pos = 0, synced = 0, keyIndex = /* @__PURE__ */ new Map();
+    for (j = newStart; j <= newEnd; ++j)
+      keyIndex.set(newScopes[j], j);
+    for (i = oldStart; i <= oldEnd && synced < newLength; ++i)
+      oldScope = oldScopes[i], j = keyIndex.get(oldScope), j !== void 0 && (pos = pos > j ? WRONG_POS : j, ++synced, newScope = newScopes[j], sources[j - newStart] = i, aNullable[i] = null);
+    if (oldLength === oldScopes.length && synced === 0) {
+      for (; newStart < newLength; ++newStart)
+        insertBefore(newScopes[newStart], parent, afterReference);
+      for (; oldStart < oldLength; ++oldStart)
+        removeAndDestroyScope(oldScopes[oldStart]);
+    } else {
+      for (i = oldLength - synced; i > 0; )
+        oldScope = aNullable[oldStart++], oldScope !== null && (removeAndDestroyScope(oldScope), i--);
+      if (pos === WRONG_POS) {
+        let seq = longestIncreasingSubsequence(sources);
+        for (j = seq.length - 1, k = newScopes.length, i = newLength - 1; i >= 0; --i)
+          sources[i] === -1 ? (pos = i + newStart, newScope = newScopes[pos++], nextSibling = pos < k ? newScopes[pos].a : afterReference, insertBefore(newScope, parent, nextSibling)) : j < 0 || i !== seq[j] ? (pos = i + newStart, newScope = newScopes[pos++], nextSibling = pos < k ? newScopes[pos].a : afterReference, insertBefore(newScope, parent, nextSibling)) : --j;
+      } else if (synced !== newLength)
+        for (k = newScopes.length, i = newLength - 1; i >= 0; --i)
+          sources[i] === -1 && (pos = i + newStart, newScope = newScopes[pos++], nextSibling = pos < k ? newScopes[pos].a : afterReference, insertBefore(newScope, parent, nextSibling));
+    }
+  }
+}
+function longestIncreasingSubsequence(a) {
+  let p = a.slice(), result = [];
+  result.push(0);
+  let u, v;
+  for (let i = 0, il = a.length; i < il; ++i) {
+    if (a[i] === -1)
+      continue;
+    let j = result[result.length - 1];
+    if (a[j] < a[i]) {
+      p[i] = j, result.push(i);
+      continue;
+    }
+    for (u = 0, v = result.length - 1; u < v; ) {
+      let c = (u + v) / 2 | 0;
+      a[result[c]] < a[i] ? u = c + 1 : v = c;
+    }
+    a[i] < a[result[u]] && (u > 0 && (p[i] = result[u - 1]), result[u] = i);
+  }
+  for (u = result.length, v = result[u - 1]; u-- > 0; )
+    result[u] = v, v = p[v];
+  return result;
+}
+
+// src/dom/event.ts
+var elementHandlersByEvent = /* @__PURE__ */ new Map(), defaultDelegator = createDelegator();
+function on(element, type, handler) {
+  let handlersByElement = elementHandlersByEvent.get(type);
+  handlersByElement || elementHandlersByEvent.set(type, handlersByElement = /* @__PURE__ */ new WeakMap()), handlersByElement.has(element) || defaultDelegator(element, type, handleDelegated), handlersByElement.set(element, handler || void 0);
+}
+function createDelegator() {
+  let delegatedEventsByRoot = /* @__PURE__ */ new WeakMap();
+  return function(node, type, handler) {
+    let root = node.getRootNode(), delegatedEvents = delegatedEventsByRoot.get(root);
+    delegatedEvents || delegatedEventsByRoot.set(root, delegatedEvents = /* @__PURE__ */ new Set()), delegatedEvents.has(type) || (delegatedEvents.add(type), root.addEventListener(type, handler, !0));
+  };
+}
+function handleDelegated(ev) {
+  let target = ev.target;
+  if (target) {
+    let handlersByElement = elementHandlersByEvent.get(ev.type);
+    if (handlersByElement.get(target)?.(ev, target), ev.bubbles)
+      for (; (target = target.parentElement) && !ev.cancelBubble; )
+        handlersByElement.get(target)?.(ev, target);
+  }
+}
+
+// src/dom/resolve-cursor-position.ts
+function resolveCursorPosition(updatedValue, initialValue, initialPosition, inputType2) {
+  if (initialPosition !== initialValue.length || // short regex to match input types that delete backwards
+  /kw/.test(inputType2)) {
+    let before = initialValue.slice(0, initialPosition), after = initialValue.slice(initialPosition);
+    if (updatedValue.startsWith(before))
+      return initialPosition;
+    if (updatedValue.endsWith(after))
+      return updatedValue.length - after.length;
+    {
+      let relevantChars = stripSpacesAndPunctuation(before).length, pos = 0, relevantIndex = 0;
+      for (; relevantIndex < relevantChars; )
+        stripSpacesAndPunctuation(updatedValue[pos]) && relevantIndex++, pos++;
+      return pos;
+    }
+  }
+  return -1;
+}
+function stripSpacesAndPunctuation(str) {
+  return str.replace(/[^\p{L}\p{N}]/gu, "");
+}
+
+// src/dom/controllable.ts
+function controllable_input_checked(scope, nodeAccessor, checked, checkedChange) {
+  setCheckboxValue(
+    scope,
+    nodeAccessor,
+    0 /* InputChecked */,
+    normalizeBoolProp(checked),
+    checkedChange
+  );
+}
+function controllable_input_checked_effect(scope, nodeAccessor) {
+  let el = scope[nodeAccessor];
+  syncControllable(el, "input", hasCheckboxChanged, () => {
+    let checkedChange = scope[nodeAccessor + ";" /* ControlledHandler */];
+    checkedChange && (scope[nodeAccessor + "=" /* ControlledType */] = 6 /* Pending */, checkedChange(el.checked), run(), scope[nodeAccessor + "=" /* ControlledType */] === 6 /* Pending */ && (el.checked = !el.checked));
+  });
+}
+function controllable_input_checkedValue(scope, nodeAccessor, checkedValue, checkedValueChange, value2) {
+  scope[nodeAccessor + ":" /* ControlledValue */] = checkedValue, attr(scope[nodeAccessor], "value", value2), setCheckboxValue(
+    scope,
+    nodeAccessor,
+    1 /* InputCheckedValue */,
+    Array.isArray(checkedValue) ? checkedValue.includes(value2) : checkedValue === value2,
+    checkedValueChange
+  );
+}
+function controllable_input_checkedValue_effect(scope, nodeAccessor) {
+  let el = scope[nodeAccessor];
+  syncControllable(el, "input", hasCheckboxChanged, () => {
+    let checkedValueChange = scope[nodeAccessor + ";" /* ControlledHandler */];
+    if (checkedValueChange) {
+      let oldValue = scope[nodeAccessor + ":" /* ControlledValue */];
+      scope[nodeAccessor + "=" /* ControlledType */] = 6 /* Pending */, checkedValueChange(
+        Array.isArray(oldValue) ? updateList(oldValue, el.value, el.checked) : el.checked ? el.value : void 0
+      ), run(), scope[nodeAccessor + "=" /* ControlledType */] === 6 /* Pending */ && (el.checked = !el.checked);
+    }
+  });
+}
+function controllable_input_value(scope, nodeAccessor, value2, valueChange) {
+  let el = scope[nodeAccessor], normalizedValue = normalizeStrProp(value2);
+  scope[nodeAccessor + ";" /* ControlledHandler */] = valueChange, valueChange ? (scope[nodeAccessor + "=" /* ControlledType */] = 0 /* InputChecked */, scope[nodeAccessor + ":" /* ControlledValue */] = value2, el.isConnected ? setValueAndUpdateSelection(el, normalizedValue) : el.defaultValue = normalizedValue) : (scope[nodeAccessor + "=" /* ControlledType */] = 5 /* None */, el.defaultValue = normalizedValue);
+}
+function controllable_input_value_effect(scope, nodeAccessor) {
+  let el = scope[nodeAccessor];
+  isResuming && (scope[nodeAccessor + ":" /* ControlledValue */] = el.defaultValue), syncControllable(el, "input", hasValueChanged, (ev) => {
+    let valueChange = scope[nodeAccessor + ";" /* ControlledHandler */];
+    valueChange && (scope[nodeAccessor + "=" /* ControlledType */] = 6 /* Pending */, ev && (inputType = ev.inputType), valueChange(el.value), run(), scope[nodeAccessor + "=" /* ControlledType */] === 6 /* Pending */ && setValueAndUpdateSelection(
+      el,
+      scope[nodeAccessor + ":" /* ControlledValue */]
+    ), inputType = "");
+  });
+}
+function controllable_select_value(scope, nodeAccessor, value2, valueChange) {
+  scope[nodeAccessor + ";" /* ControlledHandler */] = valueChange, valueChange ? (scope[nodeAccessor + "=" /* ControlledType */] = 3 /* SelectValue */, scope[nodeAccessor + ":" /* ControlledValue */] = value2) : scope[nodeAccessor + "=" /* ControlledType */] = 5 /* None */, setSelectOptions(
+    scope[nodeAccessor],
+    value2,
+    valueChange
+  );
+}
+function controllable_select_value_effect(scope, nodeAccessor) {
+  let el = scope[nodeAccessor];
+  syncControllable(el, "input", hasSelectChanged, () => {
+    let valueChange = scope[nodeAccessor + ";" /* ControlledHandler */];
+    valueChange && (scope[nodeAccessor + "=" /* ControlledType */] = 6 /* Pending */, valueChange(
+      Array.isArray(scope[nodeAccessor + ":" /* ControlledValue */]) ? Array.from(el.selectedOptions, toValueProp) : el.value
+    ), run(), scope[nodeAccessor + "=" /* ControlledType */] === 6 /* Pending */ && setSelectOptions(
+      el,
+      scope[nodeAccessor + ":" /* ControlledValue */],
+      valueChange
+    ));
+  });
+}
+function setSelectOptions(el, value2, valueChange) {
+  if (Array.isArray(value2))
+    for (let opt of el.options) {
+      let selected = value2.includes(opt.value);
+      valueChange ? opt.selected = selected : opt.defaultSelected = selected;
+    }
+  else {
+    let normalizedValue = normalizeStrProp(value2);
+    if (valueChange)
+      el.value = normalizedValue;
+    else
+      for (let opt of el.options)
+        opt.defaultSelected = opt.value === normalizedValue;
+  }
+}
+function controllable_detailsOrDialog_open(scope, nodeAccessor, open, openChange) {
+  scope[nodeAccessor + ";" /* ControlledHandler */] = openChange, openChange ? scope[nodeAccessor + "=" /* ControlledType */] = 4 /* DetailsOrDialogOpen */ : scope[nodeAccessor + "=" /* ControlledType */] = 5 /* None */, scope[nodeAccessor].open = normalizeBoolProp(open);
+}
+function controllable_detailsOrDialog_open_effect(scope, nodeAccessor) {
+  let el = scope[nodeAccessor], hasChanged = () => el.open !== scope[nodeAccessor + ":" /* ControlledValue */];
+  syncControllable(
+    el,
+    el.tagName === "DIALOG" ? "close" : "toggle",
+    hasChanged,
+    () => {
+      let openChange = scope[nodeAccessor + ";" /* ControlledHandler */];
+      openChange && hasChanged() && (scope[nodeAccessor + "=" /* ControlledType */] = 6 /* Pending */, openChange(el.open), run(), scope[nodeAccessor + "=" /* ControlledType */] === 6 /* Pending */ && (el.open = !el.open));
+    }
+  );
+}
+var inputType = "";
+function setValueAndUpdateSelection(el, value2) {
+  let initialValue = el.value;
+  if (initialValue !== value2)
+    if (el.getRootNode().activeElement === el) {
+      let initialPosition = el.selectionStart;
+      el.value = value2;
+      let updatedPosition = resolveCursorPosition(
+        el.value,
+        initialValue,
+        initialPosition,
+        inputType
+      );
+      ~updatedPosition && el.setSelectionRange(updatedPosition, updatedPosition);
+    } else
+      el.value = value2;
+}
+function setCheckboxValue(scope, nodeAccessor, type, checked, checkedChange) {
+  scope[nodeAccessor + ";" /* ControlledHandler */] = checkedChange, checkedChange ? (scope[nodeAccessor + "=" /* ControlledType */] = type, scope[nodeAccessor].checked = checked) : (scope[nodeAccessor + "=" /* ControlledType */] = 5 /* None */, scope[nodeAccessor].defaultChecked = checked);
+}
+var delegateFormControl = createDelegator(), formChangeHandlers = /* @__PURE__ */ new WeakMap();
+function syncControllable(el, event, hasChanged, onChange) {
+  formChangeHandlers.set(el, onChange), delegateFormControl(el, event, onFormChange), el.form && delegateFormControl(el.form, "reset", onFormReset), isResuming && hasChanged(el) && queueMicrotask(onChange);
+}
+function onFormChange(ev) {
+  formChangeHandlers.get(ev.target)?.(ev);
+}
+function onFormReset(ev) {
+  let handlers = [];
+  for (let el of ev.target.elements) {
+    let handler = formChangeHandlers.get(el);
+    handler && hasFormElementChanged(el) && handlers.push(handler);
+  }
+  requestAnimationFrame(() => {
+    if (!ev.defaultPrevented)
+      for (let change of handlers)
+        change();
+  });
+}
+function hasValueChanged(el) {
+  return el.value !== el.defaultValue;
+}
+function hasCheckboxChanged(el) {
+  return el.checked !== el.defaultChecked;
+}
+function hasSelectChanged(el) {
+  for (let opt of el.options)
+    if (opt.selected !== opt.defaultSelected)
+      return !0;
+}
+function hasFormElementChanged(el) {
+  return el.options ? hasSelectChanged(el) : hasValueChanged(el) || hasCheckboxChanged(el);
+}
+function normalizeStrProp(value2) {
+  return normalizeAttrValue(value2) || "";
+}
+function normalizeBoolProp(value2) {
+  return value2 != null && value2 !== !1;
+}
+function updateList(arr, val, push) {
+  let index = arr.indexOf(val);
+  return (push ? !~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 fallback = document.createTextNode(""), parser = /* @__PURE__ */ new Range();
+function parseHTML(html2) {
+  return parser.createContextualFragment(html2);
+}
+function parseHTMLOrSingleNode(html2) {
+  let content = parseHTML(html2);
+  return content.firstChild ? content.firstChild === content.lastChild && // If the firstChild is a comment it's possible its
+  // a single replaced node, in which case the walker can't replace
+  // the node itself.
+  content.firstChild.nodeType !== 8 ? content.firstChild : content : fallback;
+}
+
+// src/dom/dom.ts
+function attr(element, name, value2) {
+  setAttribute(element, name, normalizeAttrValue(value2));
+}
+function setAttribute(element, name, value2) {
+  element.getAttribute(name) != value2 && (value2 === void 0 ? element.removeAttribute(name) : element.setAttribute(name, value2));
+}
+function classAttr(element, value2) {
+  setAttribute(element, "class", classValue(value2) || void 0);
+}
+function styleAttr(element, value2) {
+  setAttribute(element, "style", styleValue(value2) || void 0);
+}
+function data(node, value2) {
+  let normalizedValue = normalizeString(value2);
+  node.data !== normalizedValue && (node.data = normalizedValue);
+}
+function textContent(node, value2) {
+  let normalizedValue = normalizeString(value2);
+  node.textContent !== normalizedValue && (node.textContent = normalizedValue);
+}
+function attrs(scope, nodeAccessor, nextAttrs) {
+  let el = scope[nodeAccessor];
+  for (let { name } of el.attributes)
+    nextAttrs && (name in nextAttrs || hasAttrAlias(el, name, nextAttrs)) || el.removeAttribute(name);
+  attrsInternal(scope, nodeAccessor, nextAttrs);
+}
+function hasAttrAlias(element, attr2, nextAttrs) {
+  return attr2 === "checked" && element.tagName === "INPUT" && "checkedValue" in nextAttrs;
+}
+function partialAttrs(scope, nodeAccessor, nextAttrs, skip) {
+  let el = scope[nodeAccessor], partial = {};
+  for (let { name } of el.attributes)
+    !skip[name] && !(nextAttrs && name in nextAttrs) && el.removeAttribute(name);
+  for (let key in nextAttrs)
+    skip[key] || (partial[key] = nextAttrs[key]);
+  attrsInternal(scope, nodeAccessor, partial);
+}
+function attrsInternal(scope, nodeAccessor, nextAttrs) {
+  let el = scope[nodeAccessor], events, 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;
+      skip = /^(?:value|checked(?:Value)?)(?:Change)?$/;
+      break;
+    case "SELECT":
+      ("value" in nextAttrs || "valueChange" in nextAttrs) && (controllable_select_value(
+        scope,
+        nodeAccessor,
+        nextAttrs.value,
+        nextAttrs.valueChange
+      ), skip = /^value(?:Change)?$/);
+      break;
+    case "TEXTAREA":
+      ("value" in nextAttrs || "valueChange" in nextAttrs) && (controllable_input_value(
+        scope,
+        nodeAccessor,
+        nextAttrs.value,
+        nextAttrs.valueChange
+      ), skip = /^value(?:Change)?$/);
+      break;
+    case "DETAILS":
+    case "DIALOG":
+      ("open" in nextAttrs || "openChange" in nextAttrs) && (controllable_detailsOrDialog_open(
+        scope,
+        nodeAccessor,
+        nextAttrs.open,
+        nextAttrs.openChange
+      ), skip = /^open(?:Change)?$/);
+      break;
+  }
+  for (let name in nextAttrs) {
+    let value2 = nextAttrs[name];
+    switch (name) {
+      case "class":
+        classAttr(el, value2);
+        break;
+      case "style":
+        styleAttr(el, value2);
+        break;
+      case "renderBody":
+        break;
+      default:
+        isEventHandler(name) ? (events ||= scope[nodeAccessor + "~" /* EventAttributes */] = {})[getEventHandlerName(name)] = value2 : skip?.test(name) || attr(el, name, value2);
+    }
+  }
+}
+function attrsEvents(scope, nodeAccessor) {
+  let el = scope[nodeAccessor], events = scope[nodeAccessor + "~" /* EventAttributes */];
+  switch (scope[nodeAccessor + "=" /* ControlledType */]) {
+    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 (let name in events)
+    on(el, name, events[name]);
+}
+function html(scope, value2, index) {
+  let firstChild = scope[index], lastChild = scope[index + "-"] || firstChild, parentNode = firstChild.parentNode, afterReference = lastChild.nextSibling, newContent = parseHTML(value2 || value2 === 0 ? value2 + "" : "<!>");
+  scope[index] = newContent.firstChild, scope[index + "-" /* DynamicPlaceholderLastChild */] = newContent.lastChild, parentNode.insertBefore(newContent, firstChild);
+  let current = firstChild;
+  for (; current !== afterReference; ) {
+    let next = current.nextSibling;
+    current.remove(), current = next;
+  }
+}
+function props(scope, nodeIndex, index) {
+  let nextProps = scope[index], prevProps = scope[index + "-"], node = scope[nodeIndex];
+  if (prevProps)
+    for (let name in prevProps)
+      name in nextProps || (node[name] = void 0);
+  for (let name in nextProps)
+    node[name] = nextProps[name];
+  scope[index + "-"] = nextProps;
+}
+function normalizeAttrValue(value2) {
+  if (value2 || value2 === 0)
+    return value2 === !0 ? "" : value2 + "";
+}
+function normalizeString(value2) {
+  return value2 || value2 === 0 ? value2 + "" : "\u200D";
+}
+function lifecycle(scope, index, thisObj) {
+  let instance = scope[index];
+  instance ? (Object.assign(instance, thisObj), instance.onUpdate?.()) : (scope[index] = thisObj, thisObj.onMount?.(), getAbortSignal(
+    scope,
+    "-" /* LifecycleAbortController */ + index
+  ).onabort = () => thisObj.onDestroy?.());
+}
+
+// src/dom/walker.ts
+var walker = /* @__PURE__ */ document.createTreeWalker(document);
+function trimWalkString(walkString) {
+  let end = walkString.length;
+  for (; walkString.charCodeAt(--end) > 47 /* BeginChild */; ) ;
+  return walkString.slice(0, end + 1);
+}
+function walk(startNode, walkCodes, scope) {
+  walker.currentNode = startNode, walkInternal(walkCodes, scope, scope, 0), walker.currentNode = document.documentElement;
+}
+function walkInternal(walkCodes, scope, cleanupOwnerScope, currentWalkIndex) {
+  let value2, storedMultiplier = 0, currentMultiplier = 0, currentScopeIndex = 0;
+  for (cleanupOwnerScope !== scope && (scope.d = cleanupOwnerScope); value2 = walkCodes.charCodeAt(currentWalkIndex++); )
+    if (currentMultiplier = storedMultiplier, storedMultiplier = 0, value2 >= 117 /* Multiplier */)
+      storedMultiplier = currentMultiplier * 10 /* Multiplier */ + value2 - 117 /* Multiplier */;
+    else if (value2 >= 107 /* Out */) {
+      for (value2 = 10 /* Out */ * currentMultiplier + value2 - 107 /* Out */; value2--; )
+        walker.parentNode();
+      walker.nextSibling();
+    } else if (value2 >= 97 /* Over */)
+      for (value2 = 10 /* Over */ * currentMultiplier + value2 - 97 /* Over */; value2--; )
+        walker.nextSibling();
+    else if (value2 >= 67 /* Next */)
+      for (value2 = 20 /* Next */ * currentMultiplier + value2 - 67 /* Next */; value2--; )
+        walker.nextNode();
+    else if (value2 === 47 /* BeginChild */)
+      currentWalkIndex = walkInternal(
+        walkCodes,
+        scope[currentScopeIndex++] = createScope(scope.$global),
+        cleanupOwnerScope,
+        currentWalkIndex
+      );
+    else {
+      if (value2 === 38 /* EndChild */)
+        return currentWalkIndex;
+      if (value2 === 32 /* Get */)
+        scope[currentScopeIndex++] = walker.currentNode;
+      else {
+        let newNode = scope[currentScopeIndex++] = document.createTextNode(""), current = walker.currentNode;
+        current.parentNode.replaceChild(newNode, current), walker.currentNode = newNode;
+      }
+    }
+  return currentWalkIndex;
+}
+
+// src/dom/renderer.ts
+function createScopeWithRenderer(renderer, $global, ownerScope) {
+  let newScope = createScope($global);
+  if (newScope._ = newScope.d = renderer.B || ownerScope, newScope.x = renderer, initRenderer(renderer, newScope), renderer.c)
+    for (let signal of renderer.c)
+      signal.g?.(newScope);
+  return newScope;
+}
+function createScopeWithTagNameOrRenderer(tagNameOrRenderer, $global, ownerScope) {
+  if (typeof tagNameOrRenderer != "string")
+    return createScopeWithRenderer(tagNameOrRenderer, $global, ownerScope);
+  let newScope = createScope($global);
+  return newScope._ = newScope.d = ownerScope, newScope[0] = newScope.a = newScope.b = document.createElement(tagNameOrRenderer), newScope;
+}
+function initRenderer(renderer, scope) {
+  let dom = renderer.k();
+  return walk(
+    dom.nodeType === 11 /* DocumentFragment */ ? dom.firstChild : dom,
+    renderer.C,
+    scope
+  ), scope.a = dom.nodeType === 11 /* DocumentFragment */ ? dom.firstChild : dom, scope.b = dom.nodeType === 11 /* DocumentFragment */ ? dom.lastChild : dom, renderer.s && renderer.s(scope), dom;
+}
+function dynamicTagAttrs(nodeAccessor, getRenderBody, inputIsArgs) {
+  return (scope, attrsOrOp) => {
+    let renderer = scope[nodeAccessor + "(" /* ConditionalRenderer */];
+    if (!renderer || attrsOrOp === DIRTY)
+      return;
+    let childScope = scope[nodeAccessor + "!" /* ConditionalScope */];
+    if (attrsOrOp === MARK || attrsOrOp === CLEAN)
+      return renderer.e?.(childScope, attrsOrOp);
+    let renderBody = getRenderBody?.(scope);
+    if (typeof renderer == "string")
+      setConditionalRendererOnlyChild(childScope, 0, renderBody), attrs(childScope, 0, attrsOrOp());
+    else if (renderer.e) {
+      let attributes = attrsOrOp();
+      renderer.e(
+        childScope,
+        inputIsArgs ? attributes : [
+          renderBody ? {
+            ...attributes,
+            renderBody
+          } : attributes
+        ]
+      );
+    }
+  };
+}
+function createRendererWithOwner(template, rawWalks, setup, getClosureSignals, getArgs) {
+  let args, closureSignals, id = {}, walks = rawWalks ? /* @__PURE__ */ trimWalkString(rawWalks) : " ";
+  return (owner) => ({
+    t: id,
+    D: template,
+    C: walks,
+    s: setup,
+    k: _clone,
+    B: owner,
+    E: void 0,
+    get e() {
+      return args ||= getArgs?.();
+    },
+    get c() {
+      return closureSignals ||= new Set(getClosureSignals?.());
+    }
+  });
+}
+function createRenderer(template, walks, setup, getClosureSignals, getArgs) {
+  return createRendererWithOwner(
+    template,
+    walks,
+    setup,
+    getClosureSignals,
+    getArgs
+  )();
+}
+function _clone() {
+  return (this.E ||= parseHTMLOrSingleNode(
+    this.D
+  )).cloneNode(!0);
+}
+
+// src/dom/control-flow.ts
+function patchConditionals(fn) {
+  conditional = fn(conditional), conditionalOnlyChild = fn(conditionalOnlyChild);
+}
+var conditional = function(nodeAccessor, fn, getIntersection) {
+  let rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */, childScopeAccessor = nodeAccessor + "!" /* ConditionalScope */, intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
+  return (scope, newRendererOrOp) => {
+    if (newRendererOrOp === DIRTY) return;
+    let currentRenderer = scope[rendererAccessor], op = newRendererOrOp;
+    if (newRendererOrOp !== MARK && newRendererOrOp !== CLEAN) {
+      let normalizedRenderer = normalizeDynamicRenderer(newRendererOrOp);
+      isDifferentRenderer(normalizedRenderer, currentRenderer) ? (currentRenderer = scope[rendererAccessor] = normalizedRenderer, setConditionalRenderer(scope, nodeAccessor, normalizedRenderer), fn && fn(scope), op = DIRTY) : op = CLEAN;
+    }
+    intersection2?.(scope, op), renderBodyClosures(currentRenderer, scope[childScopeAccessor], op);
+  };
+};
+function inConditionalScope(signal, nodeAccessor) {
+  let scopeAccessor = nodeAccessor + "!" /* ConditionalScope */, rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
+  return (scope, op) => {
+    let conditionalScope = scope[scopeAccessor];
+    if (conditionalScope) {
+      let conditionalRenderer = scope[rendererAccessor];
+      (!conditionalRenderer?.c || conditionalRenderer.c.has(signal)) && signal(conditionalScope, op);
+    }
+  };
+}
+function setConditionalRenderer(scope, nodeAccessor, newRenderer) {
+  let newScope, prevScope = scope[nodeAccessor + "!" /* ConditionalScope */];
+  newRenderer ? (newScope = scope[nodeAccessor + "!" /* ConditionalScope */] = createScopeWithTagNameOrRenderer(
+    newRenderer,
+    scope.$global,
+    scope
+  ), prevScope = prevScope || getEmptyScope(scope[nodeAccessor])) : (newScope = getEmptyScope(scope[nodeAccessor]), scope[nodeAccessor + "!" /* ConditionalScope */] = void 0), insertBefore(
+    newScope,
+    prevScope.a.parentNode,
+    prevScope.a
+  ), removeAndDestroyScope(prevScope);
+}
+var conditionalOnlyChild = function(nodeAccessor, fn, getIntersection) {
+  let rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */, childScopeAccessor = nodeAccessor + "!" /* ConditionalScope */, intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
+  return (scope, newRendererOrOp) => {
+    if (newRendererOrOp === DIRTY) return;
+    let currentRenderer = scope[rendererAccessor], op = newRendererOrOp;
+    if (newRendererOrOp !== MARK && newRendererOrOp !== CLEAN) {
+      let normalizedRenderer = normalizeDynamicRenderer(newRendererOrOp);
+      isDifferentRenderer(normalizedRenderer, currentRenderer) ? (currentRenderer = scope[rendererAccessor] = normalizedRenderer, setConditionalRendererOnlyChild(
+        scope,
+        nodeAccessor,
+        normalizedRenderer
+      ), fn && fn(scope), op = DIRTY) : op = CLEAN;
+    }
+    intersection2?.(scope, op), renderBodyClosures(currentRenderer, scope[childScopeAccessor], op);
+  };
+};
+function setConditionalRendererOnlyChild(scope, nodeAccessor, newRenderer) {
+  let prevScope = scope[nodeAccessor + "!" /* ConditionalScope */], referenceNode = scope[nodeAccessor];
+  if (referenceNode.textContent = "", newRenderer) {
+    let newScope = scope[nodeAccessor + "!" /* ConditionalScope */] = createScopeWithTagNameOrRenderer(newRenderer, scope.$global, scope);
+    insertBefore(newScope, referenceNode, null);
+  }
+  prevScope && destroyScope(prevScope);
+}
+var emptyMarkerMap = /* @__PURE__ */ new Map([[Symbol(), getEmptyScope(void 0)]]), emptyMarkerArray = [
+  /* @__PURE__ */ getEmptyScope(void 0)
+], emptyMap = /* @__PURE__ */ new Map(), emptyArray = [];
+function loopOf(nodeAccessor, renderer) {
+  return loop(
+    nodeAccessor,
+    renderer,
+    ([all, by = bySecondArg], cb) => {
+      typeof by == "string" ? forOf(
+        all,
+        (item, i) => cb(item[by], [item, i])
+      ) : forOf(all, (item, i) => cb(by(item, i), [item, i]));
+    }
+  );
+}
+function loopIn(nodeAccessor, renderer) {
+  return loop(
+    nodeAccessor,
+    renderer,
+    ([obj, by = byFirstArg], cb) => forIn(obj, (key, value2) => cb(by(key, value2), [key, value2]))
+  );
+}
+function loopTo(nodeAccessor, renderer) {
+  return loop(
+    nodeAccessor,
+    renderer,
+    ([to, from, step, by = byFirstArg], cb) => forTo(to, from, step, (v) => cb(by(v), [v]))
+  );
+}
+function loop(nodeAccessor, renderer, forEach) {
+  let loopScopeAccessor = nodeAccessor + "!" /* LoopScopeArray */, closureSignals = renderer.c, params = renderer.e;
+  return (scope, valueOrOp) => {
+    if (valueOrOp === DIRTY) return;
+    if (valueOrOp === MARK || valueOrOp === CLEAN) {
+      let loopScopes = scope[loopScopeAccessor] ?? scope[nodeAccessor + "(" /* LoopScopeMap */]?.values() ?? [];
+      if (loopScopes !== emptyMarkerArray)
+        for (let childScope of loopScopes) {
+          params?.(childScope, valueOrOp);
+          for (let signal of closureSignals)
+            signal(childScope, valueOrOp);
+        }
+      return;
+    }
+    let referenceNode = scope[nodeAccessor], referenceIsMarker = referenceNode.nodeType === 8 || referenceNode.nodeType === 3, oldMap = scope[nodeAccessor + "(" /* LoopScopeMap */] || (referenceIsMarker ? emptyMarkerMap : emptyMap), oldArray = scope[nodeAccessor + "!" /* LoopScopeArray */] || Array.from(oldMap.values()), newMap, newArray, afterReference, parentNode, needsReconciliation = !0;
+    if (forEach(valueOrOp, (key, args) => {
+      let childScope = oldMap.get(key), closureOp = CLEAN;
+      if (childScope || (childScope = createScopeWithRenderer(renderer, scope.$global, scope), closureOp = DIRTY), params && params(childScope, args), closureSignals)
+        for (let signal of closureSignals)
+          signal(childScope, closureOp);
+      newMap ? (newMap.set(key, childScope), newArray.push(childScope)) : (newMap = /* @__PURE__ */ new Map([[key, childScope]]), newArray = [childScope]);
+    }), newMap || (referenceIsMarker ? (newMap = emptyMarkerMap, newArray = emptyMarkerArray, getEmptyScope(referenceNode)) : (oldArray.forEach(destroyScope), referenceNode.textContent = "", newMap = emptyMap, newArray = emptyArray, needsReconciliation = !1)), needsReconciliation) {
+      if (referenceIsMarker) {
+        oldMap === emptyMarkerMap && getEmptyScope(referenceNode);
+        let oldLastChild = oldArray[oldArray.length - 1];
+        afterReference = oldLastChild.b.nextSibling, parentNode = oldLastChild.a.parentNode;
+      } else
+        afterReference = null, parentNode = referenceNode;
+      reconcile(parentNode, oldArray, newArray, afterReference);
+    }
+    scope[nodeAccessor + "(" /* LoopScopeMap */] = newMap, scope[nodeAccessor + "!" /* LoopScopeArray */] = newArray;
+  };
+}
+function inLoopScope(signal, loopNodeAccessor) {
+  let loopScopeAccessor = loopNodeAccessor + "!" /* LoopScopeArray */;
+  return (scope, op) => {
+    let loopScopes = scope[loopScopeAccessor] ?? scope[loopNodeAccessor + "(" /* LoopScopeMap */]?.values() ?? [];
+    if (loopScopes !== emptyMarkerArray)
+      for (let scope2 of loopScopes)
+        signal(scope2, op);
+  };
+}
+function bySecondArg(_item, index) {
+  return index;
+}
+function byFirstArg(name) {
+  return name;
+}
+function isDifferentRenderer(a, b) {
+  return a !== b && (a?.t || 0) !== b?.t;
+}
+
+// src/dom/compat.ts
+var classIdToScope = /* @__PURE__ */ new Map(), compat = {
+  patchConditionals,
+  queueEffect,
+  init() {
+    register(SET_SCOPE_REGISTER_ID, (scope) => {
+      classIdToScope.set(scope.m5c, scope);
+    });
+  },
+  registerRenderer(fn) {
+    register(RENDERER_REGISTER_ID, fn);
+  },
+  isOp(value2) {
+    return value2 === MARK || value2 === CLEAN || value2 === DIRTY;
+  },
+  isRenderer(renderer) {
+    return renderer.k !== void 0;
+  },
+  getStartNode(scope) {
+    return scope.a;
+  },
+  setScopeNodes(scope, startNode, endNode) {
+    scope.a = startNode, scope.b = endNode;
+  },
+  runComponentEffects() {
+    runEffects(this.effects);
+  },
+  resolveRegistered(value2, {
+    runtimeId,
+    componentIdPrefix
+  }) {
+    return Array.isArray(value2) && typeof value2[0] == "string" ? getRegisteredWithScope(
+      value2[0],
+      value2.length === 2 && window[runtimeId]?.[componentIdPrefix === "s" ? "_" : componentIdPrefix]?.n[value2[1]]
+    ) : value2;
+  },
+  createRenderer(setup, clone, args) {
+    let renderer = createRenderer(
+      "",
+      void 0,
+      setup,
+      void 0,
+      args && (() => args)
+    );
+    return renderer.k = clone, renderer;
+  },
+  render(out, component, renderer, input) {
+    let scope = component.scope;
+    scope || (scope = classIdToScope.get(component.id), scope && (component.scope = scope, classIdToScope.delete(component.id)));
+    let args = renderer.e || noop, existing = !1;
+    if (component.effects = prepareEffects(() => {
+      if (scope)
+        args(scope, MARK), existing = !0;
+      else {
+        scope = component.scope = createScopeWithRenderer(renderer, out.global);
+        let closures = renderer.c;
+        if (closures)
+          for (let signal of closures)
+            signal(component.scope, CLEAN);
+      }
+      args(scope, input);
+    }), !existing)
+      return scope.a === scope.b ? scope.a : scope.a.parentNode;
+  }
+};
+function noop() {
+}
+
+// src/dom/template.ts
+var createTemplate = (templateId, ...rendererArgs) => {
+  let renderer = createRenderer(...rendererArgs);
+  return renderer.mount = mount, renderer._ = renderer, register(templateId, renderer);
+};
+function mount(input = {}, reference, position) {
+  let scope, dom, { $global } = input;
+  $global ? ({ $global, ...input } = input, $global = {
+    runtimeId: DEFAULT_RUNTIME_ID,
+    renderId: DEFAULT_RENDER_ID,
+    ...$global
+  }) : $global = {
+    runtimeId: DEFAULT_RUNTIME_ID,
+    renderId: DEFAULT_RENDER_ID
+  };
+  let args = this.e, effects = prepareEffects(() => {
+    scope = createScope($global), dom = initRenderer(this, scope), args && args(scope, [input]);
+  });
+  switch (position) {
+    case "afterbegin":
+      reference.insertBefore(dom, reference.firstChild);
+      break;
+    case "afterend":
+      reference.parentElement.insertBefore(dom, reference.nextSibling);
+      break;
+    case "beforebegin":
+      reference.parentElement.insertBefore(dom, reference);
+      break;
+    default:
+      reference.appendChild(dom);
+      break;
+  }
+  return runEffects(effects), {
+    update: (newInput) => {
+      args && runEffects(
+        prepareEffects(() => {
+          args(scope, MARK), args(scope, [newInput]);
+        })
+      );
+    },
+    destroy: () => {
+      removeAndDestroyScope(scope);
+    }
+  };
+}