@fictjs/runtime 0.3.0 → 0.5.0

package/dist/chunk-TKWN42TA.cjs

@@ -0,0 +1,2259 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk6SOPF5LZcjs = require('./chunk-6SOPF5LZ.cjs');
+
+// src/jsx.ts
+var Fragment = Symbol("Fragment");
+
+// src/node-ops.ts
+function toNodeArray(node) {
+  try {
+    if (Array.isArray(node)) {
+      let allNodes = true;
+      for (const item of node) {
+        let isItemNode = false;
+        try {
+          isItemNode = item instanceof Node;
+        } catch (e2) {
+          isItemNode = false;
+        }
+        if (!isItemNode) {
+          allNodes = false;
+          break;
+        }
+      }
+      if (allNodes) {
+        return node;
+      }
+      const result = [];
+      for (const item of node) {
+        result.push(...toNodeArray(item));
+      }
+      return result;
+    }
+    if (node === null || node === void 0 || node === false) {
+      return [];
+    }
+  } catch (e3) {
+    return [];
+  }
+  let isNode = false;
+  try {
+    isNode = node instanceof Node;
+  } catch (e4) {
+    isNode = false;
+  }
+  if (isNode) {
+    try {
+      if (node instanceof DocumentFragment) {
+        return Array.from(node.childNodes);
+      }
+    } catch (e5) {
+    }
+    return [node];
+  }
+  try {
+    if (typeof node === "object" && node !== null && "marker" in node) {
+      return toNodeArray(node.marker);
+    }
+  } catch (e6) {
+  }
+  try {
+    return [document.createTextNode(String(node))];
+  } catch (e7) {
+    return [document.createTextNode("")];
+  }
+}
+function insertNodesBefore(parent, nodes, anchor) {
+  if (nodes.length === 0) return;
+  if (nodes.length === 1) {
+    const node = nodes[0];
+    if (node === void 0 || node === null) return;
+    if (node.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
+      parent.ownerDocument.adoptNode(node);
+    }
+    try {
+      parent.insertBefore(node, anchor);
+    } catch (e) {
+      if (parent.ownerDocument) {
+        try {
+          const clone = parent.ownerDocument.importNode(node, true);
+          parent.insertBefore(clone, anchor);
+          return;
+        } catch (e8) {
+        }
+      }
+      throw e;
+    }
+    return;
+  }
+  const doc = parent.ownerDocument;
+  if (doc) {
+    const frag = doc.createDocumentFragment();
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node === void 0 || node === null) continue;
+      if (node.nodeType === 11) {
+        const childrenArr = Array.from(node.childNodes);
+        for (let j = 0; j < childrenArr.length; j++) {
+          frag.appendChild(childrenArr[j]);
+        }
+      } else {
+        if (node.ownerDocument !== doc) {
+          doc.adoptNode(node);
+        }
+        frag.appendChild(node);
+      }
+    }
+    parent.insertBefore(frag, anchor);
+    return;
+  }
+  const insertSingle = (nodeToInsert, anchorNode) => {
+    if (nodeToInsert.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
+      parent.ownerDocument.adoptNode(nodeToInsert);
+    }
+    try {
+      parent.insertBefore(nodeToInsert, anchorNode);
+      return nodeToInsert;
+    } catch (e) {
+      if (parent.ownerDocument) {
+        try {
+          const clone = parent.ownerDocument.importNode(nodeToInsert, true);
+          parent.insertBefore(clone, anchorNode);
+          return clone;
+        } catch (e9) {
+        }
+      }
+      throw e;
+    }
+  };
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const node = nodes[i];
+    if (node === void 0 || node === null) continue;
+    const isFrag = node.nodeType === 11;
+    if (isFrag) {
+      const childrenArr = Array.from(node.childNodes);
+      for (let j = childrenArr.length - 1; j >= 0; j--) {
+        const child = childrenArr[j];
+        anchor = insertSingle(child, anchor);
+      }
+    } else {
+      anchor = insertSingle(node, anchor);
+    }
+  }
+}
+function removeNodes(nodes) {
+  for (const node of nodes) {
+    _optionalChain([node, 'access', _2 => _2.parentNode, 'optionalAccess', _3 => _3.removeChild, 'call', _4 => _4(node)]);
+  }
+}
+var SLOT_START = "fict:slot:start";
+var SLOT_END = "fict:slot:end";
+function isSlotStart(node) {
+  return !!(node && node.nodeType === 8 && node.data === SLOT_START);
+}
+function isSlotEnd(node) {
+  return !!(node && node.nodeType === 8 && node.data === SLOT_END);
+}
+function getSlotEnd(start) {
+  let depth = 1;
+  let cursor = start.nextSibling;
+  while (cursor) {
+    if (isSlotStart(cursor)) {
+      depth++;
+    } else if (isSlotEnd(cursor)) {
+      depth--;
+      if (depth === 0) {
+        return cursor;
+      }
+    }
+    cursor = cursor.nextSibling;
+  }
+  const owner = _nullishCoalesce(start.ownerDocument, () => ( document));
+  const end = owner.createComment(SLOT_END);
+  if (start.parentNode) {
+    start.parentNode.insertBefore(end, start.nextSibling);
+  }
+  return end;
+}
+function resolvePath(root, path) {
+  let current = root;
+  for (const index of path) {
+    if (!current) return null;
+    let child = current.firstChild;
+    let currentIndex = 0;
+    while (child) {
+      if (isSlotStart(child)) {
+        if (currentIndex === index) {
+          current = child;
+          break;
+        }
+        const end = getSlotEnd(child);
+        child = end.nextSibling;
+        currentIndex++;
+        continue;
+      }
+      if (currentIndex === index) {
+        current = child;
+        break;
+      }
+      currentIndex++;
+      child = child.nextSibling;
+    }
+    if (!child) {
+      return null;
+    }
+  }
+  return current;
+}
+
+// src/transition.ts
+function startTransition(fn) {
+  const prev = _chunk6SOPF5LZcjs.setTransitionContext.call(void 0, true);
+  try {
+    fn();
+  } finally {
+    _chunk6SOPF5LZcjs.setTransitionContext.call(void 0, prev);
+    _chunk6SOPF5LZcjs.scheduleFlush.call(void 0, );
+  }
+}
+function useTransition() {
+  const pending = _chunk6SOPF5LZcjs.signal.call(void 0, false);
+  const start = (fn) => {
+    startTransition(() => {
+      pending(true);
+      try {
+        fn();
+      } finally {
+        pending(false);
+      }
+    });
+  };
+  return [() => pending(), start];
+}
+function useDeferredValue(getValue) {
+  const deferredValue = _chunk6SOPF5LZcjs.signal.call(void 0, getValue());
+  _chunk6SOPF5LZcjs.createEffect.call(void 0, () => {
+    const newValue = getValue();
+    const currentDeferred = _chunk6SOPF5LZcjs.untrack.call(void 0, () => deferredValue());
+    if (currentDeferred !== newValue) {
+      startTransition(() => {
+        deferredValue(newValue);
+      });
+    }
+  });
+  return () => deferredValue();
+}
+
+// src/scheduler.ts
+function batch2(fn) {
+  return _chunk6SOPF5LZcjs.batch.call(void 0, fn);
+}
+function untrack2(fn) {
+  return _chunk6SOPF5LZcjs.untrack.call(void 0, fn);
+}
+
+// src/hydration.ts
+var hydrationStack = [];
+function withHydration(root, fn) {
+  const owner = _nullishCoalesce(root.ownerDocument, () => ( document));
+  hydrationStack.push({
+    cursor: root.firstChild,
+    boundary: null,
+    owner
+  });
+  try {
+    fn();
+  } finally {
+    hydrationStack.pop();
+  }
+}
+function withHydrationRange(start, end, owner, fn) {
+  hydrationStack.push({
+    cursor: start,
+    boundary: end,
+    owner
+  });
+  try {
+    fn();
+  } finally {
+    hydrationStack.pop();
+  }
+}
+function claimNodes(templateRoot, fallback) {
+  const ctx = hydrationStack[hydrationStack.length - 1];
+  if (!ctx || !ctx.cursor) {
+    return fallback();
+  }
+  const count = templateRoot.nodeType === 11 ? templateRoot.childNodes.length : 1;
+  if (count === 0) return fallback();
+  const claimed = [];
+  let cursor = ctx.cursor;
+  for (let i = 0; i < count; i++) {
+    if (!cursor || cursor === ctx.boundary) {
+      return fallback();
+    }
+    claimed.push(cursor);
+    cursor = cursor.nextSibling;
+  }
+  ctx.cursor = cursor;
+  if (claimed.length === 1) {
+    return claimed[0];
+  }
+  const frag = ctx.owner.createDocumentFragment();
+  for (const node of claimed) {
+    frag.appendChild(node);
+  }
+  return frag;
+}
+function isHydratingActive() {
+  return hydrationStack.length > 0;
+}
+
+// src/binding.ts
+var isDev = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || _optionalChain([process, 'access', _5 => _5.env, 'optionalAccess', _6 => _6.NODE_ENV]) !== "production";
+function isReactive(value) {
+  if (typeof value !== "function") return false;
+  if (_chunk6SOPF5LZcjs.isSignal.call(void 0, value) || _chunk6SOPF5LZcjs.isComputed.call(void 0, value)) return true;
+  if (_chunk6SOPF5LZcjs.isEffect.call(void 0, value) || _chunk6SOPF5LZcjs.isEffectScope.call(void 0, value)) return false;
+  return value.length === 0;
+}
+function isStrictlyReactive(value) {
+  if (typeof value !== "function") return false;
+  return _chunk6SOPF5LZcjs.isSignal.call(void 0, value) || _chunk6SOPF5LZcjs.isComputed.call(void 0, value) || isPropGetterFn(value);
+}
+var PROP_GETTER_MARKER = Symbol.for("fict:prop-getter");
+function isPropGetterFn(value) {
+  if (typeof value !== "function") return false;
+  return value[PROP_GETTER_MARKER] === true;
+}
+function unwrap(value) {
+  return isReactive(value) ? value() : value;
+}
+function callEventHandler(handler, event, node, data) {
+  if (!handler) return;
+  const context = _nullishCoalesce(_nullishCoalesce(node, () => ( event.currentTarget)), () => ( void 0));
+  const invoke = (fn) => {
+    if (typeof fn === "function") {
+      const result = data === void 0 ? fn.call(context, event) : fn.call(context, data, event);
+      if (typeof result === "function" && result !== fn) {
+        if (data === void 0) {
+          ;
+          result.call(context, event);
+        } else {
+          ;
+          result.call(context, data, event);
+        }
+      } else if (result && typeof result.handleEvent === "function") {
+        ;
+        result.handleEvent.call(result, event);
+      }
+    } else if (fn && typeof fn.handleEvent === "function") {
+      fn.handleEvent.call(fn, event);
+    }
+  };
+  invoke(handler);
+}
+function createTextBinding(value) {
+  const text = document.createTextNode("");
+  if (isReactive(value)) {
+    _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+      const v = value();
+      const fmt = formatTextValue(v);
+      if (text.data !== fmt) {
+        text.data = fmt;
+      }
+    });
+  } else {
+    text.data = formatTextValue(value);
+  }
+  return text;
+}
+function bindText(textNode, getValue) {
+  return _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const value = formatTextValue(getValue());
+    if (textNode.data !== value) {
+      textNode.data = value;
+    }
+  });
+}
+function formatTextValue(value) {
+  if (value == null || value === false) {
+    return "";
+  }
+  return String(value);
+}
+function createAttributeBinding(el, key, value, setter) {
+  if (isReactive(value)) {
+    _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+      setter(el, key, value());
+    });
+  } else {
+    setter(el, key, value);
+  }
+}
+function bindAttribute(el, key, getValue) {
+  let prevValue = void 0;
+  return _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const value = getValue();
+    if (value === prevValue) return;
+    prevValue = value;
+    if (value === void 0 || value === null || value === false) {
+      el.removeAttribute(key);
+    } else if (value === true) {
+      el.setAttribute(key, "");
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  });
+}
+function bindProperty(el, key, getValue) {
+  const PROPERTY_BINDING_KEYS = /* @__PURE__ */ new Set([
+    "value",
+    "checked",
+    "selected",
+    "disabled",
+    "readOnly",
+    "multiple",
+    "muted"
+  ]);
+  let prevValue = void 0;
+  return _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const next = getValue();
+    if (next === prevValue) return;
+    prevValue = next;
+    if (PROPERTY_BINDING_KEYS.has(key) && (next === void 0 || next === null)) {
+      const fallback = key === "checked" || key === "selected" ? false : "";
+      el[key] = fallback;
+      return;
+    }
+    ;
+    el[key] = next;
+  });
+}
+function createStyleBinding(el, value) {
+  const target = el;
+  if (isReactive(value)) {
+    let prev;
+    _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+      const next = value();
+      applyStyle(target, next, prev);
+      prev = next;
+    });
+  } else {
+    applyStyle(target, value, void 0);
+  }
+}
+function bindStyle(el, getValue) {
+  const target = el;
+  let prev;
+  return _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const next = getValue();
+    applyStyle(target, next, prev);
+    prev = next;
+  });
+}
+function applyStyle(el, value, prev) {
+  if (typeof value === "string") {
+    el.style.cssText = value;
+  } else if (value && typeof value === "object") {
+    const styles = value;
+    if (typeof prev === "string") {
+      el.style.cssText = "";
+    }
+    if (prev && typeof prev === "object") {
+      const prevStyles = prev;
+      for (const key of Object.keys(prevStyles)) {
+        if (!(key in styles)) {
+          const cssProperty = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+          el.style.removeProperty(cssProperty);
+        }
+      }
+    }
+    for (const [prop2, v] of Object.entries(styles)) {
+      if (v != null) {
+        const cssProperty = prop2.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const unitless = isUnitlessStyleProperty(prop2) || isUnitlessStyleProperty(cssProperty);
+        const valueStr = typeof v === "number" && !unitless ? `${v}px` : String(v);
+        el.style.setProperty(cssProperty, valueStr);
+      } else {
+        const cssProperty = prop2.replace(/([A-Z])/g, "-$1").toLowerCase();
+        el.style.removeProperty(cssProperty);
+      }
+    }
+  } else {
+    if (prev && typeof prev === "object") {
+      const prevStyles = prev;
+      for (const key of Object.keys(prevStyles)) {
+        const cssProperty = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+        el.style.removeProperty(cssProperty);
+      }
+    } else if (typeof prev === "string") {
+      el.style.cssText = "";
+    }
+  }
+}
+var isUnitlessStyleProperty = isDev ? (prop2) => _chunk6SOPF5LZcjs.UnitlessStyles.has(prop2) : (prop2) => prop2 === "opacity" || prop2 === "zIndex";
+function createClassBinding(el, value) {
+  if (isReactive(value)) {
+    let prev = {};
+    _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+      const next = value();
+      prev = applyClass(el, next, prev);
+    });
+  } else {
+    applyClass(el, value, {});
+  }
+}
+function bindClass(el, getValue) {
+  let prev = {};
+  let prevString;
+  return _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const next = getValue();
+    if (typeof next === "string") {
+      if (next === prevString) return;
+      prevString = next;
+      el.className = next;
+      prev = {};
+      return;
+    }
+    prevString = void 0;
+    prev = applyClass(el, next, prev);
+  });
+}
+function toggleClassKey(node, key, value) {
+  const classNames = key.trim().split(/\s+/);
+  for (let i = 0, len = classNames.length; i < len; i++) {
+    node.classList.toggle(classNames[i], value);
+  }
+}
+function applyClass(el, value, prev) {
+  const prevState = prev && typeof prev === "object" ? prev : {};
+  if (typeof value === "string") {
+    el.className = value;
+    return {};
+  }
+  if (value && typeof value === "object") {
+    const classes = value;
+    const classKeys = Object.keys(classes);
+    const prevKeys = Object.keys(prevState);
+    for (let i = 0, len = prevKeys.length; i < len; i++) {
+      const key = prevKeys[i];
+      if (!key || key === "undefined" || classes[key]) continue;
+      toggleClassKey(el, key, false);
+      delete prevState[key];
+    }
+    for (let i = 0, len = classKeys.length; i < len; i++) {
+      const key = classKeys[i];
+      const classValue = !!classes[key];
+      if (!key || key === "undefined" || prevState[key] === classValue || !classValue) continue;
+      toggleClassKey(el, key, true);
+      prevState[key] = classValue;
+    }
+    return prevState;
+  }
+  if (!value) {
+    for (const key of Object.keys(prevState)) {
+      if (key && key !== "undefined") {
+        toggleClassKey(el, key, false);
+      }
+    }
+    return {};
+  }
+  return prevState;
+}
+function classList(node, value, prev = {}) {
+  return applyClass(node, value, prev);
+}
+function insert(parent, getValue, markerOrCreateElement, createElementFn) {
+  const hostRoot = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+  let marker;
+  let ownsMarker = false;
+  let createFn = createElementFn;
+  if (markerOrCreateElement instanceof Node) {
+    marker = markerOrCreateElement;
+    createFn = createElementFn;
+  } else {
+    marker = document.createComment("fict:insert");
+    parent.appendChild(marker);
+    createFn = markerOrCreateElement;
+    ownsMarker = true;
+  }
+  let currentNodes = [];
+  let currentText = null;
+  let currentRoot = null;
+  const clearCurrentNodes = () => {
+    if (currentNodes.length > 0) {
+      removeNodes(currentNodes);
+      currentNodes = [];
+    }
+  };
+  const setTextNode = (textValue, shouldInsert, parentNode) => {
+    if (!currentText) {
+      currentText = document.createTextNode(textValue);
+    } else if (currentText.data !== textValue) {
+      currentText.data = textValue;
+    }
+    if (!shouldInsert) {
+      clearCurrentNodes();
+      return;
+    }
+    if (currentNodes.length === 1 && currentNodes[0] === currentText) {
+      return;
+    }
+    clearCurrentNodes();
+    insertNodesBefore(parentNode, [currentText], marker);
+    currentNodes = [currentText];
+  };
+  const dispose = _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const value = getValue();
+    const parentNode = marker.parentNode;
+    const isPrimitive = value == null || value === false || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+    if (isPrimitive) {
+      if (currentRoot) {
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+        currentRoot = null;
+      }
+      if (!parentNode) {
+        clearCurrentNodes();
+        return;
+      }
+      const textValue = value == null || value === false ? "" : String(value);
+      const shouldInsert = value != null && value !== false;
+      setTextNode(textValue, shouldInsert, parentNode);
+      return;
+    }
+    if (currentRoot) {
+      _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+      currentRoot = null;
+    }
+    clearCurrentNodes();
+    const root = _chunk6SOPF5LZcjs.createRootContext.call(void 0, hostRoot);
+    const prev = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root);
+    let nodes = [];
+    let handledError = false;
+    try {
+      let newNode;
+      if (value instanceof Node) {
+        newNode = value;
+      } else if (Array.isArray(value)) {
+        if (value.every((v) => v instanceof Node)) {
+          newNode = value;
+        } else {
+          if (createFn) {
+            const mapped = [];
+            for (const item of value) {
+              mapped.push(...toNodeArray(createFn(item)));
+            }
+            newNode = mapped;
+          } else {
+            newNode = document.createTextNode(String(value));
+          }
+        }
+      } else {
+        newNode = createFn ? createFn(value) : document.createTextNode(String(value));
+      }
+      nodes = toNodeArray(newNode);
+      if (root.suspended) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      if (parentNode) {
+        insertNodesBefore(parentNode, nodes, marker);
+      }
+    } catch (err) {
+      if (_chunk6SOPF5LZcjs.handleSuspend.call(void 0, err, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      if (_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "renderChild" }, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      throw err;
+    } finally {
+      _chunk6SOPF5LZcjs.popRoot.call(void 0, prev);
+      if (!handledError) {
+        _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root);
+      }
+    }
+    currentRoot = root;
+    currentNodes = nodes;
+  });
+  return () => {
+    dispose();
+    if (currentRoot) {
+      _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+      currentRoot = null;
+    }
+    clearCurrentNodes();
+    if (ownsMarker) {
+      _optionalChain([marker, 'access', _7 => _7.parentNode, 'optionalAccess', _8 => _8.removeChild, 'call', _9 => _9(marker)]);
+    }
+  };
+}
+function insertBetween(start, end, getValue, createElementFn) {
+  const hostRoot = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+  let currentNodes = [];
+  let currentText = null;
+  let currentRoot = null;
+  let initialHydrating = _chunk6SOPF5LZcjs.__fictIsHydrating.call(void 0, );
+  const collectBetween = () => {
+    const nodes = [];
+    let cursor = start.nextSibling;
+    while (cursor && cursor !== end) {
+      nodes.push(cursor);
+      cursor = cursor.nextSibling;
+    }
+    return nodes;
+  };
+  const clearCurrentNodes = () => {
+    if (currentNodes.length > 0) {
+      removeNodes(currentNodes);
+      currentNodes = [];
+    }
+  };
+  const setTextNode = (textValue, shouldInsert) => {
+    if (!currentText) {
+      currentText = document.createTextNode(textValue);
+    } else if (currentText.data !== textValue) {
+      currentText.data = textValue;
+    }
+    if (!shouldInsert) {
+      clearCurrentNodes();
+      return;
+    }
+    if (currentNodes.length === 1 && currentNodes[0] === currentText) {
+      return;
+    }
+    clearCurrentNodes();
+    const parentNode = start.parentNode;
+    if (parentNode) {
+      insertNodesBefore(parentNode, [currentText], end);
+      currentNodes = [currentText];
+    }
+  };
+  const dispose = _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const value = getValue();
+    const parentNode = start.parentNode;
+    const isPrimitive = value == null || value === false || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+    if (isPrimitive) {
+      if (initialHydrating && isHydratingActive() && parentNode) {
+        const existing = collectBetween();
+        if (existing.length > 0) {
+          currentNodes = existing;
+          const only = existing.length === 1 ? existing[0] : null;
+          currentText = only && only.nodeType === 3 ? only : null;
+        }
+      }
+      if (currentRoot) {
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+        currentRoot = null;
+      }
+      if (!parentNode) {
+        clearCurrentNodes();
+        return;
+      }
+      const textValue = value == null || value === false ? "" : String(value);
+      const shouldInsert = value != null && value !== false;
+      setTextNode(textValue, shouldInsert);
+      initialHydrating = false;
+      return;
+    }
+    if (currentRoot) {
+      _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+      currentRoot = null;
+    }
+    clearCurrentNodes();
+    const root = _chunk6SOPF5LZcjs.createRootContext.call(void 0, hostRoot);
+    const prev = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root);
+    let nodes = [];
+    let handledError = false;
+    try {
+      let newNode = void 0;
+      const createValue = () => {
+        if (value instanceof Node) {
+          return value;
+        }
+        if (Array.isArray(value)) {
+          if (value.every((v) => v instanceof Node)) {
+            return value;
+          }
+          if (createElementFn) {
+            const mapped = [];
+            for (const item of value) {
+              mapped.push(...toNodeArray(createElementFn(item)));
+            }
+            return mapped;
+          }
+          return document.createTextNode(String(value));
+        }
+        return createElementFn ? createElementFn(value) : document.createTextNode(String(value));
+      };
+      if (initialHydrating && isHydratingActive() && parentNode) {
+        withHydrationRange(start.nextSibling, end, _nullishCoalesce(parentNode.ownerDocument, () => ( document)), () => {
+          newNode = createValue();
+        });
+      } else {
+        newNode = createValue();
+      }
+      nodes = toNodeArray(newNode);
+      if (root.suspended) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      if (parentNode && !initialHydrating) {
+        insertNodesBefore(parentNode, nodes, end);
+      }
+    } catch (err) {
+      if (_chunk6SOPF5LZcjs.handleSuspend.call(void 0, err, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      if (_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "renderChild" }, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      throw err;
+    } finally {
+      _chunk6SOPF5LZcjs.popRoot.call(void 0, prev);
+      if (!handledError) {
+        _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root);
+      }
+    }
+    currentRoot = root;
+    currentNodes = initialHydrating ? collectBetween() : nodes;
+    initialHydrating = false;
+  });
+  return () => {
+    dispose();
+    if (currentRoot) {
+      _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+      currentRoot = null;
+    }
+    clearCurrentNodes();
+  };
+}
+function createChildBinding(parent, getValue, createElementFn) {
+  const marker = document.createComment("fict:child");
+  parent.appendChild(marker);
+  const hostRoot = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+  const dispose = _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    const root = _chunk6SOPF5LZcjs.createRootContext.call(void 0, hostRoot);
+    const prev = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root);
+    let nodes = [];
+    let handledError = false;
+    try {
+      const value = getValue();
+      if (value == null || value === false) {
+        return;
+      }
+      const output = createElementFn(value);
+      nodes = toNodeArray(output);
+      const parentNode = marker.parentNode;
+      if (parentNode) {
+        insertNodesBefore(parentNode, nodes, marker);
+      }
+      return () => {
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        removeNodes(nodes);
+      };
+    } catch (err) {
+      if (_chunk6SOPF5LZcjs.handleSuspend.call(void 0, err, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      if (_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "renderChild" }, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      throw err;
+    } finally {
+      _chunk6SOPF5LZcjs.popRoot.call(void 0, prev);
+      if (!handledError) {
+        _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root);
+      }
+    }
+  });
+  return {
+    marker,
+    dispose: () => {
+      dispose();
+      _optionalChain([marker, 'access', _10 => _10.parentNode, 'optionalAccess', _11 => _11.removeChild, 'call', _12 => _12(marker)]);
+    }
+  };
+}
+function delegateEvents(eventNames, doc = window.document) {
+  const e = doc[_chunk6SOPF5LZcjs.$$EVENTS] || (doc[_chunk6SOPF5LZcjs.$$EVENTS] = /* @__PURE__ */ new Set());
+  for (let i = 0, l = eventNames.length; i < l; i++) {
+    const name = eventNames[i];
+    if (!e.has(name)) {
+      e.add(name);
+      doc.addEventListener(name, globalEventHandler);
+    }
+  }
+}
+function clearDelegatedEvents(doc = window.document) {
+  const e = doc[_chunk6SOPF5LZcjs.$$EVENTS];
+  if (e) {
+    for (const name of e.keys()) {
+      doc.removeEventListener(name, globalEventHandler);
+    }
+    delete doc[_chunk6SOPF5LZcjs.$$EVENTS];
+  }
+}
+function globalEventHandler(e) {
+  const asNode = (value) => value && typeof value.nodeType === "number" ? value : null;
+  const asElement = (value) => {
+    const n = asNode(value);
+    if (!n) return null;
+    if (n.nodeType === 1) return n;
+    return n.parentElement;
+  };
+  let node = asElement(e.target);
+  const key = `$$${e.type}`;
+  const dataKey = `${key}Data`;
+  const oriTarget = e.target;
+  const oriCurrentTarget = e.currentTarget;
+  let lastHandled = null;
+  const retarget = (value) => Object.defineProperty(e, "target", {
+    configurable: true,
+    value
+  });
+  const handleNode = () => {
+    if (!node) return false;
+    const handler = node[key];
+    if (handler && !node.disabled) {
+      const resolveData = (value) => {
+        if (typeof value === "function") {
+          try {
+            const fn = value;
+            return fn.length > 0 ? fn(e) : fn();
+          } catch (e10) {
+            return value();
+          }
+        }
+        return value;
+      };
+      const rawData = node[dataKey];
+      const hasData = rawData !== void 0;
+      const resolvedNodeData = hasData ? resolveData(rawData) : void 0;
+      batch2(() => {
+        if (typeof handler === "function") {
+          callEventHandler(handler, e, node, hasData ? resolvedNodeData : void 0);
+        } else if (Array.isArray(handler)) {
+          const tupleData = resolveData(handler[1]);
+          callEventHandler(handler[0], e, node, tupleData);
+        }
+      });
+      if (e.cancelBubble) return false;
+    }
+    const shadowHost = node.host;
+    if (shadowHost && typeof shadowHost !== "string" && !shadowHost._$host && (() => {
+      const targetNode = asNode(e.target);
+      return targetNode ? node.contains(targetNode) : false;
+    })()) {
+      retarget(shadowHost);
+    }
+    return true;
+  };
+  const walkUpTree = () => {
+    while (handleNode() && node) {
+      node = asElement(node._$host || node.parentNode || node.host);
+    }
+  };
+  Object.defineProperty(e, "currentTarget", {
+    configurable: true,
+    get() {
+      return node || document;
+    }
+  });
+  if (e.composedPath) {
+    const path = e.composedPath();
+    retarget(path[0]);
+    for (let i = 0; i < path.length - 2; i++) {
+      const nextNode = asElement(path[i]);
+      if (!nextNode || nextNode === lastHandled) continue;
+      node = nextNode;
+      if (!handleNode()) break;
+      lastHandled = node;
+      if (node._$host) {
+        node = node._$host;
+        walkUpTree();
+        break;
+      }
+      if (node.parentNode === oriCurrentTarget) {
+        break;
+      }
+    }
+  } else {
+    walkUpTree();
+  }
+  retarget(oriTarget);
+}
+function addEventListener(node, name, handler, delegate) {
+  if (handler == null) return;
+  if (delegate) {
+    if (Array.isArray(handler)) {
+      ;
+      node[`$$${name}`] = handler[0];
+      node[`$$${name}Data`] = handler[1];
+    } else {
+      ;
+      node[`$$${name}`] = handler;
+    }
+  } else if (Array.isArray(handler)) {
+    const handlerFn = handler[0];
+    node.addEventListener(name, (e) => handlerFn.call(node, handler[1], e));
+  } else {
+    node.addEventListener(name, handler);
+  }
+}
+function bindEvent(el, eventName, handler, options) {
+  if (handler == null) return () => {
+  };
+  const rootRef = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+  const shouldDelegate = options == null && _chunk6SOPF5LZcjs.DelegatedEvents.has(eventName);
+  if (shouldDelegate) {
+    const key = `$$${eventName}`;
+    delegateEvents([eventName]);
+    const resolveHandler = isStrictlyReactive(handler) ? handler : () => handler;
+    el[key] = function(...args) {
+      try {
+        const fn = resolveHandler();
+        callEventHandler(fn, args[0], el);
+      } catch (err) {
+        if (!_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "event", eventName }, rootRef)) {
+          throw err;
+        }
+      }
+    };
+    return () => {
+      el[key] = void 0;
+    };
+  }
+  const getHandler = isStrictlyReactive(handler) ? handler : () => handler;
+  const wrapped = (event) => {
+    try {
+      const resolved = getHandler();
+      callEventHandler(resolved, event, el);
+    } catch (err) {
+      if (_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "event", eventName }, rootRef)) {
+        return;
+      }
+      throw err;
+    }
+  };
+  el.addEventListener(eventName, wrapped, options);
+  const cleanup = () => el.removeEventListener(eventName, wrapped, options);
+  _chunk6SOPF5LZcjs.registerRootCleanup.call(void 0, cleanup);
+  return cleanup;
+}
+function bindRef(el, ref) {
+  if (ref == null) return () => {
+  };
+  const getRef = isReactive(ref) ? ref : () => ref;
+  const applyRef2 = (refValue) => {
+    if (refValue == null) return;
+    if (typeof refValue === "function") {
+      ;
+      refValue(el);
+    } else if (typeof refValue === "object" && "current" in refValue) {
+      ;
+      refValue.current = el;
+    }
+  };
+  const initialRef = getRef();
+  applyRef2(initialRef);
+  if (isReactive(ref)) {
+    const cleanup2 = _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+      const currentRef = getRef();
+      applyRef2(currentRef);
+    });
+    _chunk6SOPF5LZcjs.registerRootCleanup.call(void 0, cleanup2);
+    const nullifyCleanup = () => {
+      const currentRef = getRef();
+      if (currentRef && typeof currentRef === "object" && "current" in currentRef) {
+        ;
+        currentRef.current = null;
+      }
+    };
+    _chunk6SOPF5LZcjs.registerRootCleanup.call(void 0, nullifyCleanup);
+    return () => {
+      cleanup2();
+      nullifyCleanup();
+    };
+  }
+  const cleanup = () => {
+    const refValue = getRef();
+    if (refValue && typeof refValue === "object" && "current" in refValue) {
+      ;
+      refValue.current = null;
+    }
+  };
+  _chunk6SOPF5LZcjs.registerRootCleanup.call(void 0, cleanup);
+  return cleanup;
+}
+function spread(node, props = {}, isSVG = false, skipChildren = false) {
+  const prevProps = {};
+  if (!skipChildren && "children" in props) {
+    _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+      prevProps.children = props.children;
+    });
+  }
+  _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    if (typeof props.ref === "function") {
+      ;
+      props.ref(node);
+    }
+  });
+  _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    assign(node, props, isSVG, true, prevProps, true);
+  });
+  return prevProps;
+}
+function assign(node, props, isSVG = false, skipChildren = false, prevProps = {}, skipRef = false) {
+  props = props || {};
+  for (const prop2 in prevProps) {
+    if (!(prop2 in props)) {
+      if (prop2 === "children") continue;
+      prevProps[prop2] = assignProp(node, prop2, null, prevProps[prop2], isSVG, skipRef, props);
+    }
+  }
+  for (const prop2 in props) {
+    if (prop2 === "children") {
+      if (!skipChildren) {
+        prevProps.children = props.children;
+      }
+      continue;
+    }
+    const value = props[prop2];
+    prevProps[prop2] = assignProp(node, prop2, value, prevProps[prop2], isSVG, skipRef, props);
+  }
+}
+function assignProp(node, prop2, value, prev, isSVG, skipRef, props) {
+  if (prop2 === "style") {
+    applyStyle(node, value, prev);
+    return value;
+  }
+  if (prop2 === "classList") {
+    return applyClass(node, value, prev);
+  }
+  if (value === prev) return prev;
+  if (prop2 === "ref") {
+    if (!skipRef && typeof value === "function") {
+      ;
+      value(node);
+    }
+    return value;
+  }
+  if (prop2.slice(0, 3) === "on:") {
+    const eventName = prop2.slice(3);
+    if (typeof value === "string") {
+      node.setAttribute(prop2, value);
+      return value;
+    }
+    if (prev && typeof prev !== "string") node.removeEventListener(eventName, prev);
+    if (value) node.addEventListener(eventName, value);
+    return value;
+  }
+  if (prop2.slice(0, 10) === "oncapture:") {
+    const eventName = prop2.slice(10);
+    if (prev) node.removeEventListener(eventName, prev, true);
+    if (value) node.addEventListener(eventName, value, true);
+    return value;
+  }
+  if (prop2.slice(0, 2) === "on") {
+    const eventName = prop2.slice(2).toLowerCase();
+    const shouldDelegate = _chunk6SOPF5LZcjs.DelegatedEvents.has(eventName);
+    if (!shouldDelegate && prev) {
+      const handler = Array.isArray(prev) ? prev[0] : prev;
+      node.removeEventListener(eventName, handler);
+    }
+    if (shouldDelegate || value) {
+      addEventListener(node, eventName, value, shouldDelegate);
+      if (shouldDelegate) delegateEvents([eventName]);
+    }
+    return value;
+  }
+  if (prop2.slice(0, 5) === "attr:") {
+    if (value == null) node.removeAttribute(prop2.slice(5));
+    else node.setAttribute(prop2.slice(5), String(value));
+    return value;
+  }
+  if (prop2.slice(0, 5) === "bool:") {
+    if (value) node.setAttribute(prop2.slice(5), "");
+    else node.removeAttribute(prop2.slice(5));
+    return value;
+  }
+  if (prop2.slice(0, 5) === "prop:") {
+    ;
+    node[prop2.slice(5)] = value;
+    return value;
+  }
+  if (prop2 === "class" || prop2 === "className") {
+    if (value == null) node.removeAttribute("class");
+    else node.className = String(value);
+    return value;
+  }
+  const isCE = node.nodeName.includes("-") || "is" in props;
+  if (!isSVG) {
+    const propAlias = isDev ? _chunk6SOPF5LZcjs.getPropAlias.call(void 0, prop2, node.tagName) : void 0;
+    const isProperty = isDev ? _chunk6SOPF5LZcjs.Properties.has(prop2) : prop2 in node;
+    const isChildProp = isDev ? _chunk6SOPF5LZcjs.ChildProperties.has(prop2) : prop2 === "innerHTML" || prop2 === "textContent" || prop2 === "innerText" || prop2 === "children";
+    if (propAlias || isProperty || isChildProp || isCE) {
+      const propName = propAlias || prop2;
+      if (isCE && !isProperty && !isChildProp && !propAlias) {
+        ;
+        node[toPropertyName(propName)] = value;
+      } else {
+        ;
+        node[propName] = value;
+      }
+      return value;
+    }
+  }
+  if (isSVG && prop2.indexOf(":") > -1) {
+    const [prefix, name] = prop2.split(":");
+    const ns = _chunk6SOPF5LZcjs.SVGNamespace[prefix];
+    if (ns) {
+      if (value == null) node.removeAttributeNS(ns, name);
+      else node.setAttributeNS(ns, name, String(value));
+      return value;
+    }
+  }
+  const attrName = prop2 === "htmlFor" ? "for" : prop2;
+  if (value == null) node.removeAttribute(attrName);
+  else node.setAttribute(attrName, String(value));
+  return value;
+}
+function toPropertyName(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+function createConditional(condition, renderTrue, createElementFn, renderFalse, startOverride, endOverride) {
+  const useProvided = !!(startOverride && endOverride);
+  const startMarker = useProvided ? startOverride : document.createComment("fict:cond:start");
+  const endMarker = useProvided ? endOverride : document.createComment("fict:cond:end");
+  const fragment = useProvided ? startMarker : document.createDocumentFragment();
+  if (!useProvided) {
+    ;
+    fragment.append(startMarker, endMarker);
+  }
+  const hostRoot = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+  let currentNodes = [];
+  let currentRoot = null;
+  let lastCondition = void 0;
+  let pendingRender = false;
+  let initialHydrating = _chunk6SOPF5LZcjs.__fictIsHydrating.call(void 0, );
+  const collectBetween = () => {
+    const nodes = [];
+    let cursor = startMarker.nextSibling;
+    while (cursor && cursor !== endMarker) {
+      nodes.push(cursor);
+      cursor = cursor.nextSibling;
+    }
+    return nodes;
+  };
+  const conditionMemo = _chunk6SOPF5LZcjs.computed.call(void 0, condition);
+  const runConditional = () => {
+    const cond = conditionMemo();
+    const parent = startMarker.parentNode;
+    if (!parent) {
+      pendingRender = true;
+      return;
+    }
+    pendingRender = false;
+    if (initialHydrating && isHydratingActive()) {
+      initialHydrating = false;
+      lastCondition = cond;
+      const render3 = cond ? renderTrue : renderFalse;
+      if (!render3) {
+        currentNodes = collectBetween();
+        return;
+      }
+      const root2 = _chunk6SOPF5LZcjs.createRootContext.call(void 0, hostRoot);
+      const prev2 = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root2);
+      let handledError2 = false;
+      try {
+        withHydrationRange(
+          startMarker.nextSibling,
+          endMarker,
+          _nullishCoalesce(parent.ownerDocument, () => ( document)),
+          () => {
+            const output = _chunk6SOPF5LZcjs.untrack.call(void 0, render3);
+            if (output == null || output === false) {
+              return;
+            }
+            createElementFn(output);
+          }
+        );
+        currentNodes = collectBetween();
+      } catch (err) {
+        if (_chunk6SOPF5LZcjs.handleSuspend.call(void 0, err, root2)) {
+          handledError2 = true;
+          _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root2);
+          return;
+        }
+        if (_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "renderChild" }, root2)) {
+          handledError2 = true;
+          _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root2);
+          return;
+        }
+        throw err;
+      } finally {
+        _chunk6SOPF5LZcjs.popRoot.call(void 0, prev2);
+        if (!handledError2) {
+          _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root2);
+          currentRoot = root2;
+        } else {
+          currentRoot = null;
+        }
+      }
+      return;
+    }
+    if (lastCondition === cond && currentNodes.length > 0) {
+      return;
+    }
+    if (lastCondition === cond && lastCondition === false && renderFalse === void 0) {
+      return;
+    }
+    lastCondition = cond;
+    if (currentRoot) {
+      _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+      currentRoot = null;
+    }
+    removeNodes(currentNodes);
+    currentNodes = [];
+    const render2 = cond ? renderTrue : renderFalse;
+    if (!render2) {
+      return;
+    }
+    const root = _chunk6SOPF5LZcjs.createRootContext.call(void 0, hostRoot);
+    const prev = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root);
+    let handledError = false;
+    try {
+      const output = _chunk6SOPF5LZcjs.untrack.call(void 0, render2);
+      if (output == null || output === false) {
+        return;
+      }
+      const el = createElementFn(output);
+      const nodes = toNodeArray(el);
+      insertNodesBefore(parent, nodes, endMarker);
+      currentNodes = nodes;
+    } catch (err) {
+      if (_chunk6SOPF5LZcjs.handleSuspend.call(void 0, err, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      if (_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "renderChild" }, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        return;
+      }
+      throw err;
+    } finally {
+      _chunk6SOPF5LZcjs.popRoot.call(void 0, prev);
+      if (!handledError) {
+        _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root);
+        currentRoot = root;
+      } else {
+        currentRoot = null;
+      }
+    }
+  };
+  const dispose = _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, runConditional);
+  return {
+    marker: fragment,
+    flush: () => {
+      if (pendingRender) {
+        runConditional();
+      }
+    },
+    dispose: () => {
+      dispose();
+      if (currentRoot) {
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+      }
+      removeNodes(currentNodes);
+      currentNodes = [];
+      _optionalChain([startMarker, 'access', _13 => _13.parentNode, 'optionalAccess', _14 => _14.removeChild, 'call', _15 => _15(startMarker)]);
+      _optionalChain([endMarker, 'access', _16 => _16.parentNode, 'optionalAccess', _17 => _17.removeChild, 'call', _18 => _18(endMarker)]);
+    }
+  };
+}
+function createShow(el, condition, displayValue) {
+  const originalDisplay = _nullishCoalesce(displayValue, () => ( el.style.display));
+  _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    el.style.display = condition() ? originalDisplay : "none";
+  });
+}
+function createPortal(container, render2, createElementFn) {
+  const parentRoot = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+  const marker = document.createComment("fict:portal");
+  container.appendChild(marker);
+  let currentNodes = [];
+  let currentRoot = null;
+  const dispose = _chunk6SOPF5LZcjs.createRenderEffect.call(void 0, () => {
+    if (currentRoot) {
+      _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+      currentRoot = null;
+    }
+    if (currentNodes.length > 0) {
+      removeNodes(currentNodes);
+      currentNodes = [];
+    }
+    const root = _chunk6SOPF5LZcjs.createRootContext.call(void 0, parentRoot);
+    const prev = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root);
+    let handledError = false;
+    try {
+      const output = render2();
+      if (output != null && output !== false) {
+        const el = createElementFn(output);
+        const nodes = toNodeArray(el);
+        if (marker.parentNode) {
+          insertNodesBefore(marker.parentNode, nodes, marker);
+        }
+        currentNodes = nodes;
+      }
+    } catch (err) {
+      if (_chunk6SOPF5LZcjs.handleSuspend.call(void 0, err, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        currentNodes = [];
+        return;
+      }
+      if (_chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "renderChild" }, root)) {
+        handledError = true;
+        _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+        currentNodes = [];
+        return;
+      }
+      throw err;
+    } finally {
+      _chunk6SOPF5LZcjs.popRoot.call(void 0, prev);
+      if (!handledError) {
+        _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root);
+        currentRoot = root;
+      } else {
+        currentRoot = null;
+      }
+    }
+  });
+  const portalDispose = () => {
+    dispose();
+    if (currentRoot) {
+      _chunk6SOPF5LZcjs.destroyRoot.call(void 0, currentRoot);
+    }
+    if (currentNodes.length > 0) {
+      removeNodes(currentNodes);
+    }
+    _optionalChain([marker, 'access', _19 => _19.parentNode, 'optionalAccess', _20 => _20.removeChild, 'call', _21 => _21(marker)]);
+  };
+  if (parentRoot) {
+    parentRoot.destroyCallbacks.push(portalDispose);
+  }
+  return {
+    marker,
+    dispose: portalDispose
+  };
+}
+
+// src/props.ts
+var PROP_GETTER_MARKER2 = Symbol.for("fict:prop-getter");
+var propGetters = /* @__PURE__ */ new WeakSet();
+var rawToProxy = /* @__PURE__ */ new WeakMap();
+var proxyToRaw = /* @__PURE__ */ new WeakMap();
+function __fictProp(getter) {
+  if (typeof getter === "function" && getter.length === 0) {
+    propGetters.add(getter);
+    if (Object.isExtensible(getter)) {
+      try {
+        ;
+        getter[PROP_GETTER_MARKER2] = true;
+      } catch (e11) {
+      }
+    }
+  }
+  return getter;
+}
+function isPropGetter(value) {
+  if (typeof value !== "function") return false;
+  const fn = value;
+  return propGetters.has(fn) || fn[PROP_GETTER_MARKER2] === true;
+}
+function createPropsProxy(props) {
+  if (!props || typeof props !== "object") {
+    return props;
+  }
+  if (proxyToRaw.has(props)) {
+    return props;
+  }
+  const cached = rawToProxy.get(props);
+  if (cached) {
+    return cached;
+  }
+  const proxy = new Proxy(props, {
+    get(target, prop2, receiver) {
+      const value = Reflect.get(target, prop2, receiver);
+      if (isPropGetter(value)) {
+        return value();
+      }
+      return value;
+    },
+    set(target, prop2, value, receiver) {
+      return Reflect.set(target, prop2, value, receiver);
+    },
+    has(target, prop2) {
+      return prop2 in target;
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, prop2) {
+      return Object.getOwnPropertyDescriptor(target, prop2);
+    }
+  });
+  rawToProxy.set(props, proxy);
+  proxyToRaw.set(proxy, props);
+  return proxy;
+}
+function unwrapProps(props) {
+  if (!props || typeof props !== "object") {
+    return props;
+  }
+  return _nullishCoalesce(proxyToRaw.get(props), () => ( props));
+}
+function __fictPropsRest(props, exclude) {
+  const raw = unwrapProps(props);
+  const out = {};
+  const excludeSet = new Set(exclude);
+  for (const key of Reflect.ownKeys(raw)) {
+    if (excludeSet.has(key)) continue;
+    out[key] = raw[key];
+  }
+  return createPropsProxy(out);
+}
+function mergeProps(...sources) {
+  const validSources = sources.filter(
+    (s) => s != null && (typeof s === "object" || typeof s === "function")
+  );
+  if (validSources.length === 0) {
+    return {};
+  }
+  if (validSources.length === 1 && typeof validSources[0] === "object") {
+    return validSources[0];
+  }
+  const resolveSource = (src) => {
+    const value = typeof src === "function" ? src() : src;
+    if (!value || typeof value !== "object") return void 0;
+    return unwrapProps(value);
+  };
+  const hasProp = (prop2) => {
+    for (const src of validSources) {
+      const raw = resolveSource(src);
+      if (raw && prop2 in raw) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const readProp = (prop2) => {
+    for (let i = validSources.length - 1; i >= 0; i--) {
+      const src = validSources[i];
+      const raw = resolveSource(src);
+      if (!raw || !(prop2 in raw)) continue;
+      const value = raw[prop2];
+      if (typeof src === "function" && !isPropGetter(value)) {
+        return __fictProp(() => {
+          const latest = resolveSource(src);
+          if (!latest || !(prop2 in latest)) return void 0;
+          return latest[prop2];
+        });
+      }
+      return value;
+    }
+    return void 0;
+  };
+  return new Proxy({}, {
+    get(_, prop2) {
+      return readProp(prop2);
+    },
+    has(_, prop2) {
+      return hasProp(prop2);
+    },
+    ownKeys() {
+      const keys = /* @__PURE__ */ new Set();
+      for (const src of validSources) {
+        const raw = resolveSource(src);
+        if (raw) {
+          for (const key of Reflect.ownKeys(raw)) {
+            keys.add(key);
+          }
+        }
+      }
+      return Array.from(keys);
+    },
+    getOwnPropertyDescriptor(_, prop2) {
+      if (!hasProp(prop2)) return void 0;
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => readProp(prop2)
+      };
+    }
+  });
+}
+function keyed(target, key, options) {
+  return prop(() => {
+    const resolvedTarget = isPropGetter(target) ? target() : target;
+    const resolvedKey = typeof key === "function" ? key() : key;
+    return resolvedTarget[resolvedKey];
+  }, options);
+}
+function prop(getter, options) {
+  if (isPropGetter(getter)) {
+    return getter;
+  }
+  const fn = getter;
+  const unwrap2 = _optionalChain([options, 'optionalAccess', _22 => _22.unwrap]) !== false;
+  return __fictProp(
+    _chunk6SOPF5LZcjs.createMemo.call(void 0, () => {
+      const value = fn();
+      if (unwrap2 && isPropGetter(value)) {
+        return value();
+      }
+      return value;
+    })
+  );
+}
+
+// src/dom.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+var isDev2 = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || _optionalChain([process, 'access', _23 => _23.env, 'optionalAccess', _24 => _24.NODE_ENV]) !== "production";
+var nextComponentId = 1;
+function render(view, container) {
+  const root = _chunk6SOPF5LZcjs.createRootContext.call(void 0, );
+  const prev = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root);
+  let dom = void 0;
+  try {
+    const output = view();
+    if (_chunk6SOPF5LZcjs.__fictIsHydrating.call(void 0, )) {
+      withHydration(container, () => {
+        dom = createElement(output);
+      });
+    } else {
+      dom = createElement(output);
+    }
+  } finally {
+    _chunk6SOPF5LZcjs.popRoot.call(void 0, prev);
+  }
+  if (!_chunk6SOPF5LZcjs.__fictIsHydrating.call(void 0, )) {
+    container.replaceChildren(dom);
+  }
+  container.setAttribute("data-fict-fine-grained", "1");
+  _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root);
+  const teardown = () => {
+    _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+    container.innerHTML = "";
+  };
+  return teardown;
+}
+function hydrateComponent(view, container) {
+  const root = _chunk6SOPF5LZcjs.createRootContext.call(void 0, );
+  const prev = _chunk6SOPF5LZcjs.pushRoot.call(void 0, root);
+  _chunk6SOPF5LZcjs.__fictEnterHydration.call(void 0, );
+  try {
+    withHydration(container, () => {
+      view();
+    });
+  } finally {
+    _chunk6SOPF5LZcjs.__fictExitHydration.call(void 0, );
+    _chunk6SOPF5LZcjs.popRoot.call(void 0, prev);
+  }
+  container.setAttribute("data-fict-fine-grained", "1");
+  _chunk6SOPF5LZcjs.flushOnMount.call(void 0, root);
+  const teardown = () => {
+    _chunk6SOPF5LZcjs.destroyRoot.call(void 0, root);
+  };
+  return teardown;
+}
+function createElement(node) {
+  return createElementWithContext(node, null);
+}
+function resolveNamespace(tagName, namespace) {
+  if (tagName === "svg") return "svg";
+  if (tagName === "math") return "mathml";
+  if (namespace === "mathml") return "mathml";
+  if (namespace === "svg") return "svg";
+  if (isDev2 && _chunk6SOPF5LZcjs.SVGElements.has(tagName)) return "svg";
+  return null;
+}
+function createElementWithContext(node, namespace) {
+  if (node instanceof Node) {
+    return node;
+  }
+  if (node === null || node === void 0 || node === false) {
+    return document.createTextNode("");
+  }
+  if (isReactive(node)) {
+    const resolved = node();
+    if (resolved === node) {
+      return document.createTextNode("");
+    }
+    return createElementWithContext(resolved, namespace);
+  }
+  if (typeof node === "object" && node !== null && !(node instanceof Node)) {
+    if ("marker" in node) {
+      const handle = node;
+      if (typeof handle.dispose === "function") {
+        _chunk6SOPF5LZcjs.registerRootCleanup.call(void 0, handle.dispose);
+      }
+      if (typeof handle.flush === "function") {
+        const runFlush = () => handle.flush && handle.flush();
+        if (typeof queueMicrotask === "function") {
+          queueMicrotask(runFlush);
+        } else {
+          Promise.resolve().then(runFlush).catch(() => void 0);
+        }
+      }
+      return createElement(handle.marker);
+    }
+  }
+  if (Array.isArray(node)) {
+    const frag = document.createDocumentFragment();
+    for (const child of node) {
+      appendChildNode(frag, child, namespace);
+    }
+    return frag;
+  }
+  if (typeof node === "string" || typeof node === "number") {
+    return document.createTextNode(String(node));
+  }
+  if (typeof node === "boolean") {
+    return document.createTextNode("");
+  }
+  const vnode = node;
+  if (typeof vnode.type === "function") {
+    const rawProps = unwrapProps(_nullishCoalesce(vnode.props, () => ( {})));
+    const baseProps = vnode.key === void 0 ? rawProps : new Proxy(rawProps, {
+      get(target, prop2, receiver) {
+        if (prop2 === "key") return vnode.key;
+        return Reflect.get(target, prop2, receiver);
+      },
+      has(target, prop2) {
+        if (prop2 === "key") return true;
+        return prop2 in target;
+      },
+      ownKeys(target) {
+        const keys = new Set(Reflect.ownKeys(target));
+        keys.add("key");
+        return Array.from(keys);
+      },
+      getOwnPropertyDescriptor(target, prop2) {
+        if (prop2 === "key") {
+          return { enumerable: true, configurable: true, value: vnode.key };
+        }
+        return Object.getOwnPropertyDescriptor(target, prop2);
+      }
+    });
+    const props = createPropsProxy(baseProps);
+    const hook = isDev2 ? _chunk6SOPF5LZcjs.getDevtoolsHook.call(void 0, ) : void 0;
+    const parentId = hook ? _chunk6SOPF5LZcjs.__fictGetCurrentComponentId.call(void 0, ) : void 0;
+    const componentId = hook ? nextComponentId++ : void 0;
+    if (_optionalChain([hook, 'optionalAccess', _25 => _25.registerComponent]) && componentId !== void 0) {
+      hook.registerComponent(componentId, vnode.type.name || "Anonymous", parentId);
+    }
+    const ctx = _chunk6SOPF5LZcjs.__fictPushContext.call(void 0, );
+    if (componentId !== void 0) {
+      ctx.componentId = componentId;
+      if (parentId !== void 0) {
+        ctx.parentId = parentId;
+      }
+    }
+    try {
+      const rendered = vnode.type(props);
+      if (hook && componentId !== void 0) {
+        _chunk6SOPF5LZcjs.onMount.call(void 0, () => {
+          _optionalChain([hook, 'access', _26 => _26.componentMount, 'optionalCall', _27 => _27(componentId)]);
+        });
+        _chunk6SOPF5LZcjs.onCleanup.call(void 0, () => _optionalChain([hook, 'access', _28 => _28.componentUnmount, 'optionalCall', _29 => _29(componentId)]));
+      }
+      if (_chunk6SOPF5LZcjs.__fictIsResumable.call(void 0, ) && !_chunk6SOPF5LZcjs.__fictIsHydrating.call(void 0, )) {
+        const content = createElementWithContext(rendered, namespace);
+        const host = namespace === "svg" ? document.createElementNS(SVG_NS, "fict-host") : namespace === "mathml" ? document.createElementNS(MATHML_NS, "fict-host") : document.createElement("fict-host");
+        host.setAttribute("data-fict-host", "");
+        if (namespace === null && host.style) {
+          ;
+          host.style.display = "contents";
+        }
+        const meta = vnode.type.__fictMeta;
+        const typeKey = (_nullishCoalesce(_optionalChain([meta, 'optionalAccess', _30 => _30.id]), () => ( vnode.type.name))) || "Anonymous";
+        _chunk6SOPF5LZcjs.__fictRegisterScope.call(void 0, ctx, host, typeKey, rawProps);
+        if (_optionalChain([meta, 'optionalAccess', _31 => _31.resume])) {
+          host.setAttribute("data-fict-h", meta.resume);
+        }
+        if (content instanceof DocumentFragment) {
+          host.append(...Array.from(content.childNodes));
+        } else {
+          host.appendChild(content);
+        }
+        return host;
+      }
+      return createElementWithContext(rendered, namespace);
+    } catch (err) {
+      if (_chunk6SOPF5LZcjs.handleSuspend.call(void 0, err)) {
+        return document.createComment("fict:suspend");
+      }
+      _chunk6SOPF5LZcjs.handleError.call(void 0, err, { source: "render", componentName: vnode.type.name });
+      throw err;
+    } finally {
+      _chunk6SOPF5LZcjs.__fictPopContext.call(void 0, );
+    }
+  }
+  if (vnode.type === Fragment) {
+    const frag = document.createDocumentFragment();
+    const children = _optionalChain([vnode, 'access', _32 => _32.props, 'optionalAccess', _33 => _33.children]);
+    appendChildren(frag, children, namespace);
+    return frag;
+  }
+  const tagName = typeof vnode.type === "string" ? vnode.type : "div";
+  const resolvedNamespace = resolveNamespace(tagName, namespace);
+  const el = resolvedNamespace === "svg" ? document.createElementNS(SVG_NS, tagName) : resolvedNamespace === "mathml" ? document.createElementNS(MATHML_NS, tagName) : document.createElement(tagName);
+  applyProps(el, _nullishCoalesce(vnode.props, () => ( {})), resolvedNamespace === "svg");
+  appendChildren(
+    el,
+    _optionalChain([vnode, 'access', _34 => _34.props, 'optionalAccess', _35 => _35.children]),
+    tagName === "foreignObject" ? null : resolvedNamespace
+  );
+  return el;
+}
+function template(html, isImportNode, isSVG, isMathML) {
+  let node = null;
+  const create = () => {
+    const t = document.createElement("template");
+    if (isSVG) {
+      t.innerHTML = `<svg>${html}</svg>`;
+      const wrapper = t.content.firstChild;
+      if (isDev2 && wrapper.childNodes.length !== 1) {
+        console.warn(
+          `[fict] template() received multi-root SVG content (${wrapper.childNodes.length} nodes). Returning a DocumentFragment. This may indicate a compiler bug or invalid JSX structure.`
+        );
+      }
+      if (wrapper.childNodes.length === 1) {
+        return wrapper.firstChild;
+      }
+      const fragment = document.createDocumentFragment();
+      fragment.append(...Array.from(wrapper.childNodes));
+      return fragment;
+    }
+    if (isMathML) {
+      t.innerHTML = `<math>${html}</math>`;
+      const wrapper = t.content.firstChild;
+      if (isDev2 && wrapper.childNodes.length !== 1) {
+        console.warn(
+          `[fict] template() received multi-root MathML content (${wrapper.childNodes.length} nodes). Returning a DocumentFragment. This may indicate a compiler bug or invalid JSX structure.`
+        );
+      }
+      if (wrapper.childNodes.length === 1) {
+        return wrapper.firstChild;
+      }
+      const fragment = document.createDocumentFragment();
+      fragment.append(...Array.from(wrapper.childNodes));
+      return fragment;
+    }
+    t.innerHTML = html;
+    const content = t.content;
+    if (isDev2 && content.childNodes.length !== 1) {
+      console.warn(
+        `[fict] template() received multi-root content (${content.childNodes.length} nodes). Returning a DocumentFragment. This may indicate a compiler bug or invalid JSX structure.`
+      );
+    }
+    if (content.childNodes.length === 1) {
+      return content.firstChild;
+    }
+    return content;
+  };
+  const fn = isImportNode ? () => untrack2(() => {
+    const base = node || (node = create());
+    return isHydratingActive() ? claimNodes(base, () => document.importNode(base, true)) : document.importNode(base, true);
+  }) : () => {
+    const base = node || (node = create());
+    return isHydratingActive() ? claimNodes(base, () => base.cloneNode(true)) : base.cloneNode(true);
+  };
+  fn.cloneNode = fn;
+  return fn;
+}
+function isBindingHandle(node) {
+  return node !== null && typeof node === "object" && "marker" in node && "dispose" in node && typeof node.dispose === "function";
+}
+function appendChildNode(parent, child, namespace) {
+  if (child === null || child === void 0 || child === false) {
+    return;
+  }
+  if (isBindingHandle(child)) {
+    appendChildNode(parent, child.marker, namespace);
+    _optionalChain([child, 'access', _36 => _36.flush, 'optionalCall', _37 => _37()]);
+    return;
+  }
+  if (typeof child === "function" && child.length === 0) {
+    const childGetter = child;
+    createChildBinding(parent, childGetter, (node) => createElementWithContext(node, namespace));
+    return;
+  }
+  if (Array.isArray(child)) {
+    for (const item of child) {
+      appendChildNode(parent, item, namespace);
+    }
+    return;
+  }
+  let domNode;
+  if (typeof child !== "object" || child === null) {
+    domNode = document.createTextNode(String(_nullishCoalesce(child, () => ( ""))));
+  } else {
+    domNode = createElementWithContext(child, namespace);
+  }
+  if (domNode.nodeType === 11) {
+    const children = Array.from(domNode.childNodes);
+    for (const node of children) {
+      appendChildNode(parent, node, namespace);
+    }
+    return;
+  }
+  if (domNode.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
+    parent.ownerDocument.adoptNode(domNode);
+  }
+  try {
+    parent.appendChild(domNode);
+  } catch (e) {
+    if (parent.ownerDocument) {
+      const clone = parent.ownerDocument.importNode(domNode, true);
+      parent.appendChild(clone);
+      return;
+    }
+    throw e;
+  }
+}
+function appendChildren(parent, children, namespace) {
+  if (children === void 0) return;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      appendChildren(parent, child, namespace);
+    }
+    return;
+  }
+  appendChildNode(parent, children, namespace);
+}
+function applyRef(el, value) {
+  if (typeof value === "function") {
+    const refFn = value;
+    refFn(el);
+    const root = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+    if (root) {
+      _chunk6SOPF5LZcjs.registerRootCleanup.call(void 0, () => {
+        refFn(null);
+      });
+    } else if (isDev2) {
+      console.warn(
+        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
+      );
+    }
+  } else if (value && typeof value === "object" && "current" in value) {
+    const refObj = value;
+    refObj.current = el;
+    const root = _chunk6SOPF5LZcjs.getCurrentRoot.call(void 0, );
+    if (root) {
+      _chunk6SOPF5LZcjs.registerRootCleanup.call(void 0, () => {
+        refObj.current = null;
+      });
+    } else if (isDev2) {
+      console.warn(
+        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
+      );
+    }
+  }
+}
+function applyProps(el, props, isSVG = false) {
+  props = unwrapProps(props);
+  const tagName = el.tagName;
+  const isCE = tagName.includes("-") || "is" in props;
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children") continue;
+    if (key === "ref") {
+      applyRef(el, value);
+      continue;
+    }
+    if (isEventKey(key)) {
+      bindEvent(
+        el,
+        eventNameFromProp(key),
+        value
+      );
+      continue;
+    }
+    if (key.slice(0, 3) === "on:") {
+      bindEvent(
+        el,
+        key.slice(3),
+        value,
+        false
+        // Non-delegated
+      );
+      continue;
+    }
+    if (key.slice(0, 10) === "oncapture:") {
+      bindEvent(
+        el,
+        key.slice(10),
+        value,
+        true
+        // Capture
+      );
+      continue;
+    }
+    if (key === "class" || key === "className") {
+      createClassBinding(el, value);
+      continue;
+    }
+    if (key === "classList") {
+      createClassBinding(el, value);
+      continue;
+    }
+    if (key === "style") {
+      createStyleBinding(
+        el,
+        value
+      );
+      continue;
+    }
+    if (key === "dangerouslySetInnerHTML" && value && typeof value === "object") {
+      const htmlValue = value.__html;
+      if (htmlValue !== void 0) {
+        if (isReactive(htmlValue)) {
+          createAttributeBinding(el, "innerHTML", htmlValue, setInnerHTML);
+        } else {
+          el.innerHTML = htmlValue;
+        }
+      }
+      continue;
+    }
+    if (isDev2 && _chunk6SOPF5LZcjs.ChildProperties.has(key) || key === "innerHTML" || key === "textContent" || key === "innerText" || key === "children") {
+      createAttributeBinding(el, key, value, setProperty);
+      continue;
+    }
+    if (key.slice(0, 5) === "attr:") {
+      createAttributeBinding(el, key.slice(5), value, setAttribute);
+      continue;
+    }
+    if (key.slice(0, 5) === "bool:") {
+      createAttributeBinding(el, key.slice(5), value, setBoolAttribute);
+      continue;
+    }
+    if (key.slice(0, 5) === "prop:") {
+      createAttributeBinding(el, key.slice(5), value, setProperty);
+      continue;
+    }
+    const propAlias = !isSVG && isDev2 ? _chunk6SOPF5LZcjs.getPropAlias.call(void 0, key, tagName) : void 0;
+    const isProperty = !isSVG ? isDev2 ? _chunk6SOPF5LZcjs.Properties.has(key) : key in el : false;
+    if (propAlias || isProperty || isCE && !isSVG) {
+      const propName = propAlias || key;
+      if (isCE && !isProperty && !propAlias) {
+        createAttributeBinding(
+          el,
+          toPropertyName2(propName),
+          value,
+          setProperty
+        );
+      } else {
+        createAttributeBinding(el, propName, value, setProperty);
+      }
+      continue;
+    }
+    if (isSVG && key.indexOf(":") > -1) {
+      const [prefix, name] = key.split(":");
+      const ns = _chunk6SOPF5LZcjs.SVGNamespace[prefix];
+      if (ns) {
+        createAttributeBinding(
+          el,
+          key,
+          value,
+          (el2, _key, val) => setAttributeNS(el2, ns, name, val)
+        );
+        continue;
+      }
+    }
+    const attrName = key === "htmlFor" ? "for" : key;
+    createAttributeBinding(el, attrName, value, setAttribute);
+  }
+}
+function toPropertyName2(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+var setAttribute = (el, key, value) => {
+  if (value === void 0 || value === null || value === false) {
+    el.removeAttribute(key);
+    return;
+  }
+  if (value === true) {
+    el.setAttribute(key, "");
+    return;
+  }
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number") {
+    el.setAttribute(key, String(value));
+    return;
+  }
+  if (key in el) {
+    ;
+    el[key] = value;
+    return;
+  }
+  el.setAttribute(key, String(value));
+};
+var setProperty = (el, key, value) => {
+  if (value === void 0 || value === null) {
+    const fallback = key === "checked" || key === "selected" ? false : "";
+    el[key] = fallback;
+    return;
+  }
+  if (key === "style" && typeof value === "object" && value !== null) {
+    for (const k in value) {
+      const v = value[k];
+      if (v !== void 0) {
+        ;
+        el.style[k] = String(v);
+      }
+    }
+    return;
+  }
+  ;
+  el[key] = value;
+};
+var setInnerHTML = (el, _key, value) => {
+  const next = value == null ? "" : String(value);
+  const node = el;
+  if (node.innerHTML === next) return;
+  node.innerHTML = next;
+};
+var setBoolAttribute = (el, key, value) => {
+  if (value) {
+    el.setAttribute(key, "");
+  } else {
+    el.removeAttribute(key);
+  }
+};
+function setAttributeNS(el, namespace, name, value) {
+  if (value == null) {
+    el.removeAttributeNS(namespace, name);
+  } else {
+    el.setAttributeNS(namespace, name, String(value));
+  }
+}
+function isEventKey(key) {
+  return key.startsWith("on") && key.length > 2 && key[2].toUpperCase() === key[2];
+}
+function eventNameFromProp(key) {
+  return key.slice(2).toLowerCase();
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.withHydrationRange = withHydrationRange; exports.isHydratingActive = isHydratingActive; exports.Fragment = Fragment; exports.toNodeArray = toNodeArray; exports.insertNodesBefore = insertNodesBefore; exports.removeNodes = removeNodes; exports.getSlotEnd = getSlotEnd; exports.resolvePath = resolvePath; exports.startTransition = startTransition; exports.useTransition = useTransition; exports.useDeferredValue = useDeferredValue; exports.batch = batch2; exports.untrack = untrack2; exports.isReactive = isReactive; exports.unwrap = unwrap; exports.callEventHandler = callEventHandler; exports.createTextBinding = createTextBinding; exports.bindText = bindText; exports.createAttributeBinding = createAttributeBinding; exports.bindAttribute = bindAttribute; exports.bindProperty = bindProperty; exports.createStyleBinding = createStyleBinding; exports.bindStyle = bindStyle; exports.createClassBinding = createClassBinding; exports.bindClass = bindClass; exports.classList = classList; exports.insert = insert; exports.insertBetween = insertBetween; exports.createChildBinding = createChildBinding; exports.delegateEvents = delegateEvents; exports.clearDelegatedEvents = clearDelegatedEvents; exports.addEventListener = addEventListener; exports.bindEvent = bindEvent; exports.bindRef = bindRef; exports.spread = spread; exports.assign = assign; exports.createConditional = createConditional; exports.createShow = createShow; exports.createPortal = createPortal; exports.__fictProp = __fictProp; exports.createPropsProxy = createPropsProxy; exports.__fictPropsRest = __fictPropsRest; exports.mergeProps = mergeProps; exports.keyed = keyed; exports.prop = prop; exports.render = render; exports.hydrateComponent = hydrateComponent; exports.createElement = createElement; exports.template = template;
+//# sourceMappingURL=chunk-TKWN42TA.cjs.map