sibujs 1.2.0 → 1.4.0

package/dist/chunk-QWZG56ET.js

@@ -0,0 +1,2744 @@
+import {
+  __resetIdCounter,
+  createId
+} from "./chunk-YT6HQ6AM.js";
+import {
+  a,
+  abbr,
+  address,
+  area,
+  article,
+  aside,
+  audio,
+  b,
+  base,
+  bdi,
+  bdo,
+  blockquote,
+  body,
+  br,
+  button,
+  canvas,
+  caption,
+  center,
+  circle,
+  cite,
+  clipPath,
+  code,
+  col,
+  colgroup,
+  customElement,
+  data,
+  datalist,
+  dd,
+  defs,
+  del,
+  details,
+  dfn,
+  dialog,
+  div,
+  dl,
+  dt,
+  ellipse,
+  em,
+  embed,
+  fieldset,
+  figcaption,
+  figure,
+  font,
+  footer,
+  form,
+  g,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  head,
+  header,
+  hr,
+  i,
+  iframe,
+  img,
+  input,
+  ins,
+  kbd,
+  label,
+  legend,
+  li,
+  line,
+  linearGradient,
+  link,
+  main,
+  map,
+  mark,
+  marker,
+  marquee,
+  mask,
+  math,
+  menu,
+  meta,
+  meter,
+  nav,
+  noscript,
+  object,
+  ol,
+  optgroup,
+  option,
+  output,
+  p,
+  param,
+  path,
+  pattern,
+  picture,
+  polygon,
+  polyline,
+  portal,
+  pre,
+  progress,
+  q,
+  radialGradient,
+  rect,
+  rp,
+  rt,
+  ruby,
+  s,
+  samp,
+  script,
+  section,
+  select,
+  slot,
+  small,
+  source,
+  span,
+  stop,
+  strong,
+  style,
+  sub,
+  summary,
+  sup,
+  svg,
+  symbol,
+  table,
+  tbody,
+  td,
+  template,
+  text,
+  textarea,
+  tfoot,
+  th,
+  thead,
+  time,
+  title,
+  tr,
+  track as track2,
+  tspan,
+  u,
+  ul,
+  use,
+  var_,
+  video
+} from "./chunk-32DY64NT.js";
+import {
+  watch
+} from "./chunk-NYVAC6P5.js";
+import {
+  context
+} from "./chunk-BGN5ZMP4.js";
+import {
+  SVG_NS,
+  bindChildNode,
+  tagFactory
+} from "./chunk-F3FA4F32.js";
+import {
+  bindAttribute,
+  bindDynamic,
+  checkLeaks,
+  dispose,
+  registerDisposer
+} from "./chunk-PTQJDMRT.js";
+import {
+  derived
+} from "./chunk-NEKUBFPT.js";
+import {
+  isUrlAttribute,
+  sanitizeUrl
+} from "./chunk-CMBFNA7L.js";
+import {
+  effect,
+  on
+} from "./chunk-CHF5OHIA.js";
+import {
+  disableSSR,
+  enableSSR,
+  isSSR,
+  withSSR
+} from "./chunk-EUZND3CB.js";
+import {
+  batch,
+  enqueueBatchedSignal,
+  isBatching,
+  signal
+} from "./chunk-WZSPOOER.js";
+import {
+  notifySubscribers,
+  recordDependency,
+  track,
+  untracked
+} from "./chunk-ZD6OAMTH.js";
+import {
+  __export,
+  devAssert,
+  devWarn,
+  isDev
+} from "./chunk-5X6PP2UK.js";
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  DynamicComponent: () => DynamicComponent,
+  ErrorBoundary: () => ErrorBoundary,
+  ErrorDisplay: () => ErrorDisplay,
+  Fragment: () => Fragment,
+  KeepAlive: () => KeepAlive,
+  Loading: () => Loading,
+  Portal: () => Portal,
+  SVG_NS: () => SVG_NS,
+  Suspense: () => Suspense,
+  __resetIdCounter: () => __resetIdCounter,
+  a: () => a,
+  abbr: () => abbr,
+  action: () => action,
+  address: () => address,
+  area: () => area,
+  array: () => array,
+  article: () => article,
+  aside: () => aside,
+  asyncDerived: () => asyncDerived,
+  audio: () => audio,
+  autoResize: () => autoResize,
+  b: () => b,
+  base: () => base,
+  batch: () => batch,
+  bdi: () => bdi,
+  bdo: () => bdo,
+  bindDynamic: () => bindDynamic,
+  blockquote: () => blockquote,
+  body: () => body,
+  br: () => br,
+  button: () => button,
+  canvas: () => canvas,
+  caption: () => caption,
+  catchError: () => catchError,
+  catchErrorAsync: () => catchErrorAsync,
+  center: () => center,
+  checkLeaks: () => checkLeaks,
+  circle: () => circle,
+  cite: () => cite,
+  clickOutside: () => clickOutside,
+  clipPath: () => clipPath,
+  code: () => code,
+  col: () => col,
+  colgroup: () => colgroup,
+  context: () => context,
+  copyOnClick: () => copyOnClick,
+  createId: () => createId,
+  customElement: () => customElement,
+  data: () => data,
+  datalist: () => datalist,
+  dd: () => dd,
+  deepEqual: () => deepEqual,
+  deepSignal: () => deepSignal,
+  defer: () => defer,
+  defs: () => defs,
+  del: () => del,
+  derived: () => derived,
+  details: () => details,
+  dfn: () => dfn,
+  dialog: () => dialog,
+  disableSSR: () => disableSSR,
+  dispose: () => dispose,
+  div: () => div,
+  dl: () => dl,
+  dt: () => dt,
+  each: () => each,
+  effect: () => effect,
+  ellipse: () => ellipse,
+  em: () => em,
+  embed: () => embed,
+  enableSSR: () => enableSSR,
+  enqueueBatchedSignal: () => enqueueBatchedSignal,
+  fieldset: () => fieldset,
+  figcaption: () => figcaption,
+  figure: () => figure,
+  font: () => font,
+  footer: () => footer,
+  form: () => form,
+  g: () => g,
+  getSlot: () => getSlot,
+  h1: () => h1,
+  h2: () => h2,
+  h3: () => h3,
+  h4: () => h4,
+  h5: () => h5,
+  h6: () => h6,
+  head: () => head,
+  header: () => header,
+  hr: () => hr,
+  html: () => html,
+  i: () => i,
+  iframe: () => iframe,
+  img: () => img,
+  input: () => input,
+  ins: () => ins,
+  isBatching: () => isBatching,
+  isSSR: () => isSSR,
+  kbd: () => kbd,
+  label: () => label,
+  lazy: () => lazy,
+  legend: () => legend,
+  li: () => li,
+  line: () => line,
+  linearGradient: () => linearGradient,
+  link: () => link,
+  longPress: () => longPress,
+  main: () => main,
+  map: () => map,
+  mark: () => mark,
+  marker: () => marker,
+  marquee: () => marquee,
+  mask: () => mask,
+  match: () => match,
+  math: () => math,
+  memo: () => memo,
+  memoFn: () => memoFn,
+  menu: () => menu,
+  meta: () => meta,
+  meter: () => meter,
+  mount: () => mount,
+  nav: () => nav,
+  nextTick: () => nextTick,
+  noscript: () => noscript,
+  object: () => object,
+  ol: () => ol,
+  on: () => on,
+  onCleanup: () => onCleanup,
+  onMount: () => onMount,
+  onUnmount: () => onUnmount,
+  optgroup: () => optgroup,
+  option: () => option,
+  output: () => output,
+  p: () => p,
+  param: () => param,
+  path: () => path,
+  pattern: () => pattern,
+  picture: () => picture,
+  polygon: () => polygon,
+  polyline: () => polyline,
+  portal: () => portal,
+  pre: () => pre,
+  progress: () => progress,
+  q: () => q,
+  radialGradient: () => radialGradient,
+  reactiveArray: () => reactiveArray,
+  rect: () => rect,
+  ref: () => ref,
+  registerComponent: () => registerComponent,
+  registerDisposer: () => registerDisposer,
+  resolveComponent: () => resolveComponent,
+  rp: () => rp,
+  rt: () => rt,
+  ruby: () => ruby,
+  s: () => s,
+  samp: () => samp,
+  script: () => script,
+  section: () => section,
+  select: () => select,
+  setGlobalErrorHandler: () => setGlobalErrorHandler,
+  show: () => show,
+  signal: () => signal,
+  slot: () => slot,
+  small: () => small,
+  source: () => source,
+  span: () => span,
+  stop: () => stop,
+  store: () => store,
+  strict: () => strict,
+  strictEffect: () => strictEffect,
+  strong: () => strong,
+  style: () => style,
+  sub: () => sub,
+  summary: () => summary,
+  sup: () => sup,
+  svg: () => svg,
+  symbol: () => symbol,
+  table: () => table,
+  tagFactory: () => tagFactory,
+  tbody: () => tbody,
+  td: () => td,
+  template: () => template,
+  text: () => text,
+  textarea: () => textarea,
+  tfoot: () => tfoot,
+  th: () => th,
+  thead: () => thead,
+  time: () => time,
+  title: () => title,
+  tr: () => tr,
+  track: () => track2,
+  transition: () => transition,
+  trapFocus: () => trapFocus,
+  tspan: () => tspan,
+  u: () => u,
+  ul: () => ul,
+  unregisterComponent: () => unregisterComponent,
+  untracked: () => untracked,
+  use: () => use,
+  var_: () => var_,
+  video: () => video,
+  watch: () => watch,
+  when: () => when,
+  withSSR: () => withSSR,
+  writable: () => writable
+});
+
+// src/core/rendering/htm.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SVG_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "circle",
+  "ellipse",
+  "g",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect",
+  "text",
+  "tspan",
+  "defs",
+  "clipPath",
+  "mask",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "use",
+  "symbol",
+  "marker"
+]);
+var cache = /* @__PURE__ */ new WeakMap();
+function parseTemplate(strings) {
+  const exprCount = strings.length - 1;
+  let template2 = strings[0];
+  for (let i2 = 0; i2 < exprCount; i2++) {
+    template2 += `\0${i2}\0${strings[i2 + 1]}`;
+  }
+  let pos = 0;
+  const len = template2.length;
+  function skipWs() {
+    while (pos < len && (template2[pos] === " " || template2[pos] === "	" || template2[pos] === "\n" || template2[pos] === "\r"))
+      pos++;
+  }
+  function tryExprIdx() {
+    if (template2.charCodeAt(pos) !== 0) return -1;
+    const start = pos;
+    pos++;
+    let idx = 0;
+    while (pos < len && template2.charCodeAt(pos) !== 0) {
+      idx = idx * 10 + (template2.charCodeAt(pos) - 48);
+      pos++;
+    }
+    if (pos < len) pos++;
+    if (idx < 0 || idx >= exprCount) {
+      pos = start;
+      return -1;
+    }
+    return idx;
+  }
+  function readTagName() {
+    const start = pos;
+    while (pos < len) {
+      const c = template2.charCodeAt(pos);
+      if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45) {
+        pos++;
+      } else break;
+    }
+    return template2.slice(start, pos);
+  }
+  function parseAttrValue() {
+    skipWs();
+    if (template2[pos] !== "=") return { kind: "bool" };
+    pos++;
+    skipWs();
+    const exprIdx = tryExprIdx();
+    if (exprIdx >= 0) return { kind: "expr", idx: exprIdx };
+    const quote = template2[pos];
+    if (quote === '"' || quote === "'") {
+      pos++;
+      const statics = [];
+      const exprs = [];
+      let current = "";
+      while (pos < len && template2[pos] !== quote) {
+        const innerIdx = tryExprIdx();
+        if (innerIdx >= 0) {
+          statics.push(current);
+          current = "";
+          exprs.push(innerIdx);
+        } else {
+          current += template2[pos++];
+        }
+      }
+      if (pos < len) pos++;
+      statics.push(current);
+      if (exprs.length === 0) {
+        return { kind: "static", value: statics[0] };
+      }
+      return { kind: "mixed", statics, exprs };
+    }
+    const valStart = pos;
+    while (pos < len) {
+      const c = template2.charCodeAt(pos);
+      if (c === 32 || c === 9 || c === 10 || c === 13 || c === 62 || c === 47) break;
+      pos++;
+    }
+    const val = template2.slice(valStart, pos);
+    return { kind: "static", value: val };
+  }
+  function parseAttrs() {
+    const attrs = [];
+    while (pos < len) {
+      skipWs();
+      if (template2[pos] === ">" || template2[pos] === "/") break;
+      const attrStart = pos;
+      while (pos < len) {
+        const c = template2.charCodeAt(pos);
+        if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45 || c === 58 || c === 95 || c === 46) {
+          pos++;
+        } else break;
+      }
+      const attrName = template2.slice(attrStart, pos);
+      if (!attrName) break;
+      const val = parseAttrValue();
+      if (attrName.startsWith("on:")) {
+        if (val.kind === "expr") {
+          attrs.push({ t: 3, name: attrName.slice(3), idx: val.idx });
+        }
+      } else if (val.kind === "bool") {
+        attrs.push({ t: 4, name: attrName });
+      } else if (val.kind === "static") {
+        attrs.push({ t: 0, name: attrName, value: val.value });
+      } else if (val.kind === "expr") {
+        attrs.push({ t: 1, name: attrName, idx: val.idx });
+      } else if (val.kind === "mixed") {
+        attrs.push({ t: 2, name: attrName, statics: val.statics, exprs: val.exprs });
+      }
+    }
+    return attrs;
+  }
+  function collapseWs(s2) {
+    return s2.replace(/\s+/g, " ");
+  }
+  function parseTextChildren(children) {
+    let text2 = "";
+    while (pos < len && template2[pos] !== "<") {
+      const idx = tryExprIdx();
+      if (idx >= 0) {
+        const collapsed2 = collapseWs(text2);
+        if (collapsed2) children.push({ t: 1, value: collapsed2 });
+        text2 = "";
+        children.push({ t: 2, idx });
+      } else {
+        text2 += template2[pos++];
+      }
+    }
+    const collapsed = collapseWs(text2);
+    if (collapsed) children.push({ t: 1, value: collapsed });
+  }
+  function parseChildren() {
+    const children = [];
+    while (pos < len) {
+      if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") break;
+      if (template2[pos] === "<") {
+        pos++;
+        const tag = readTagName();
+        const attrs = parseAttrs();
+        skipWs();
+        const isVoid = VOID_ELEMENTS.has(tag);
+        const isSelfClosing = template2[pos] === "/";
+        if (isSelfClosing) pos++;
+        if (pos < len) pos++;
+        if (isVoid || isSelfClosing) {
+          children.push({ t: 0, el: { tag, svg: SVG_TAGS.has(tag), attrs, children: [] } });
+        } else {
+          const inner = parseChildren();
+          if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") {
+            pos += 2;
+            readTagName();
+            skipWs();
+            if (pos < len && template2[pos] === ">") pos++;
+          }
+          children.push({ t: 0, el: { tag, svg: SVG_TAGS.has(tag), attrs, children: inner } });
+        }
+      } else {
+        parseTextChildren(children);
+      }
+    }
+    return children;
+  }
+  return parseChildren();
+}
+function executeElement(tmpl, values) {
+  const el = tmpl.svg ? document.createElementNS(SVG_NS, tmpl.tag) : document.createElement(tmpl.tag);
+  for (let i2 = 0; i2 < tmpl.attrs.length; i2++) {
+    const attr = tmpl.attrs[i2];
+    switch (attr.t) {
+      case 0:
+        el.setAttribute(attr.name, attr.value);
+        break;
+      case 1: {
+        const name = attr.name;
+        if (name[0] === "o" && name[1] === "n") break;
+        const val = values[attr.idx];
+        if (typeof val === "function") {
+          registerDisposer(el, bindAttribute(el, name, val));
+        } else if (val != null) {
+          const str = String(val);
+          el.setAttribute(name, isUrlAttribute(name) ? sanitizeUrl(str) : str);
+        }
+        break;
+      }
+      case 2: {
+        let val = attr.statics[0];
+        for (let j = 0; j < attr.exprs.length; j++) {
+          val += String(values[attr.exprs[j]]) + attr.statics[j + 1];
+        }
+        el.setAttribute(attr.name, val);
+        break;
+      }
+      case 3:
+        el.addEventListener(attr.name, values[attr.idx]);
+        break;
+      case 4:
+        el.setAttribute(attr.name, "");
+        break;
+    }
+  }
+  for (let i2 = 0; i2 < tmpl.children.length; i2++) {
+    const child = tmpl.children[i2];
+    switch (child.t) {
+      case 0:
+        el.appendChild(executeElement(child.el, values));
+        break;
+      case 1:
+        el.appendChild(document.createTextNode(child.value));
+        break;
+      case 2: {
+        const val = values[child.idx];
+        if (typeof val === "function") {
+          const ph = document.createComment("");
+          el.appendChild(ph);
+          registerDisposer(el, bindChildNode(ph, val));
+        } else if (val instanceof Node) {
+          el.appendChild(val);
+        } else if (Array.isArray(val)) {
+          for (let j = 0; j < val.length; j++) {
+            const item = val[j];
+            if (item instanceof Node) {
+              el.appendChild(item);
+            } else if (item != null && typeof item !== "boolean") {
+              el.appendChild(document.createTextNode(String(item)));
+            }
+          }
+        } else if (val != null && typeof val !== "boolean") {
+          el.appendChild(document.createTextNode(String(val)));
+        }
+        break;
+      }
+    }
+  }
+  return el;
+}
+function html(strings, ...values) {
+  let tmpl = cache.get(strings);
+  if (!tmpl) {
+    tmpl = parseTemplate(strings);
+    cache.set(strings, tmpl);
+  }
+  if (tmpl.length === 1 && tmpl[0].t === 0) {
+    return executeElement(tmpl[0].el, values);
+  }
+  const wrapper = document.createElement("div");
+  for (let i2 = 0; i2 < tmpl.length; i2++) {
+    const child = tmpl[i2];
+    switch (child.t) {
+      case 0:
+        wrapper.appendChild(executeElement(child.el, values));
+        break;
+      case 1:
+        wrapper.appendChild(document.createTextNode(child.value));
+        break;
+      case 2: {
+        const val = values[child.idx];
+        if (val instanceof Node) {
+          wrapper.appendChild(val);
+        } else if (typeof val === "function") {
+          const ph = document.createComment("bind:htm");
+          wrapper.appendChild(ph);
+          registerDisposer(wrapper, bindChildNode(ph, val));
+        } else if (Array.isArray(val)) {
+          for (let j = 0; j < val.length; j++) {
+            const item = val[j];
+            if (item instanceof Node) {
+              wrapper.appendChild(item);
+            } else if (item != null && typeof item !== "boolean") {
+              wrapper.appendChild(document.createTextNode(String(item)));
+            }
+          }
+        } else if (val != null && typeof val !== "boolean") {
+          wrapper.appendChild(document.createTextNode(String(val)));
+        }
+        break;
+      }
+    }
+  }
+  if (wrapper.childNodes.length === 1 && wrapper.firstChild instanceof Element) {
+    return wrapper.firstChild;
+  }
+  return wrapper;
+}
+
+// src/core/rendering/mount.ts
+function mount(component, container) {
+  if (!container) {
+    throw new Error(
+      "[Sibu] mount: container element not found. Make sure the DOM element exists before calling mount()."
+    );
+  }
+  devAssert(
+    typeof component === "function" || component instanceof Node,
+    "mount: first argument must be a component function or a DOM Node."
+  );
+  const startTime = typeof performance !== "undefined" ? performance.now() : 0;
+  const node = typeof component === "function" ? component() : component;
+  const duration = typeof performance !== "undefined" ? performance.now() - startTime : 0;
+  container.appendChild(node);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) {
+    hook.emit("app:init", { rootElement: node, container, duration });
+  }
+  return {
+    node,
+    unmount() {
+      if (hook) hook.emit("app:unmount", { rootElement: node });
+      dispose(node);
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+  };
+}
+
+// src/core/rendering/each.ts
+var _isDev = isDev();
+function resolveNodeChild(child) {
+  if (typeof child === "function") {
+    return resolveNodeChild(child());
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  return document.createTextNode(String(child));
+}
+function longestIncreasingSubsequence(arr, len) {
+  if (len === 0) return [];
+  const tails = [];
+  const predecessor = new Array(len);
+  for (let i2 = 0; i2 < len; i2++) {
+    const val = arr[i2];
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (arr[tails[mid]] < val) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    tails[lo] = i2;
+    predecessor[i2] = lo > 0 ? tails[lo - 1] : -1;
+  }
+  const lisLength = tails.length;
+  const result = new Array(lisLength);
+  let k = tails[lisLength - 1];
+  for (let i2 = lisLength - 1; i2 >= 0; i2--) {
+    result[i2] = k;
+    k = predecessor[k];
+  }
+  return result;
+}
+function each(getArray, render, options) {
+  devAssert(typeof getArray === "function", "each: first argument must be a function that returns an array.");
+  devAssert(typeof render === "function", "each: second argument must be a render function.");
+  devAssert(
+    options && typeof options.key === "function",
+    "each: options.key must be a function that returns a unique key per item."
+  );
+  const anchor = document.createComment("each:anchor");
+  const end = document.createComment("each:end");
+  const oldKeysBufA = [];
+  const oldKeysBufB = [];
+  let oldKeys = oldKeysBufA;
+  let oldLen = 0;
+  let nodeMap = /* @__PURE__ */ new Map();
+  let workMap = /* @__PURE__ */ new Map();
+  let newNodes = [];
+  let newKeysBuf = [];
+  let isStableBuf = new Uint8Array(0);
+  const oldKeyIndex = /* @__PURE__ */ new Map();
+  let reusedNewBuf = [];
+  let reusedOldBuf = [];
+  const keyIndexMap = /* @__PURE__ */ new Map();
+  let initialized = false;
+  let sentinelInserted = false;
+  const keyFn = options.key;
+  const update = () => {
+    const arr = getArray();
+    const newLen = arr.length;
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (!sentinelInserted) {
+      parent.insertBefore(end, anchor.nextSibling);
+      sentinelInserted = true;
+    }
+    if (newKeysBuf.length < newLen) {
+      newKeysBuf = new Array(newLen);
+    }
+    for (let i2 = 0; i2 < newLen; i2++) {
+      newKeysBuf[i2] = keyFn(arr[i2]);
+    }
+    const newKeys = newKeysBuf;
+    if (newNodes.length < newLen) {
+      newNodes = new Array(newLen);
+    }
+    workMap.clear();
+    keyIndexMap.clear();
+    for (let i2 = 0; i2 < newLen; i2++) {
+      keyIndexMap.set(newKeys[i2], i2);
+    }
+    for (let i2 = 0; i2 < newLen; i2++) {
+      const key = newKeys[i2];
+      const existing = nodeMap.get(key);
+      let node;
+      if (existing !== void 0) {
+        node = existing;
+      } else {
+        const itemKey = key;
+        const itemGetter = () => getArray()[keyIndexMap.get(itemKey)];
+        const indexGetter = () => keyIndexMap.get(itemKey);
+        try {
+          node = resolveNodeChild(render(itemGetter, indexGetter));
+        } catch (err) {
+          if (_isDev) {
+            devWarn(
+              `each: render threw for item at index ${i2} (key="${newKeys[i2]}"): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+          node = document.createComment(`each:error:${i2}`);
+        }
+      }
+      workMap.set(key, node);
+      newNodes[i2] = node;
+    }
+    for (const [key, node] of nodeMap) {
+      if (!workMap.has(key)) {
+        dispose(node);
+        if (node.parentNode) {
+          parent.removeChild(node);
+        }
+      }
+    }
+    if (newLen === 0) {
+      oldLen = 0;
+      const tmp2 = nodeMap;
+      nodeMap = workMap;
+      workMap = tmp2;
+      return;
+    }
+    oldKeyIndex.clear();
+    for (let i2 = 0; i2 < oldLen; i2++) {
+      oldKeyIndex.set(oldKeys[i2], i2);
+    }
+    if (reusedNewBuf.length < newLen) {
+      reusedNewBuf = new Array(newLen);
+      reusedOldBuf = new Array(newLen);
+    }
+    let reusedCount = 0;
+    for (let i2 = 0; i2 < newLen; i2++) {
+      const oldIdx = oldKeyIndex.get(newKeys[i2]);
+      if (oldIdx !== void 0) {
+        reusedNewBuf[reusedCount] = i2;
+        reusedOldBuf[reusedCount] = oldIdx;
+        reusedCount++;
+      }
+    }
+    const lisIndices = longestIncreasingSubsequence(reusedOldBuf, reusedCount);
+    if (isStableBuf.length < newLen) {
+      isStableBuf = new Uint8Array(newLen);
+    } else {
+      isStableBuf.fill(0, 0, newLen);
+    }
+    for (let i2 = 0; i2 < lisIndices.length; i2++) {
+      isStableBuf[reusedNewBuf[lisIndices[i2]]] = 1;
+    }
+    let nextRef = end;
+    for (let i2 = newLen - 1; i2 >= 0; i2--) {
+      const node = newNodes[i2];
+      if (isStableBuf[i2]) {
+        nextRef = node;
+      } else {
+        if (node.nextSibling !== nextRef) {
+          parent.insertBefore(node, nextRef);
+        }
+        nextRef = node;
+      }
+    }
+    const nextOld = oldKeys === oldKeysBufA ? oldKeysBufB : oldKeysBufA;
+    if (nextOld.length < newLen) nextOld.length = newLen;
+    for (let i2 = 0; i2 < newLen; i2++) nextOld[i2] = newKeys[i2];
+    oldKeys = nextOld;
+    oldLen = newLen;
+    const tmp = nodeMap;
+    nodeMap = workMap;
+    workMap = tmp;
+    initialized = true;
+  };
+  track(update);
+  if (!initialized) {
+    queueMicrotask(() => {
+      if (!initialized && anchor.parentNode) {
+        update();
+      }
+    });
+  }
+  return anchor;
+}
+
+// src/core/rendering/fragment.ts
+function Fragment(nodes) {
+  const frag = document.createDocumentFragment();
+  for (const child of nodes) {
+    if (child == null || typeof child === "boolean") continue;
+    if (Array.isArray(child)) {
+      for (const nested of child) {
+        if (nested == null || typeof nested === "boolean") continue;
+        frag.appendChild(resolveChild(nested));
+      }
+    } else {
+      frag.appendChild(resolveChild(child));
+    }
+  }
+  return frag;
+}
+function resolveChild(child) {
+  if (child == null) {
+    return document.createTextNode("");
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  if (typeof child === "function") {
+    const result = child();
+    if (result instanceof Node) return result;
+    return document.createTextNode(String(result ?? ""));
+  }
+  return document.createTextNode(String(child));
+}
+
+// src/core/rendering/portal.ts
+function Portal(nodes, target) {
+  const anchor = document.createComment("portal");
+  const container = target || document.body;
+  let portalContent = null;
+  queueMicrotask(() => {
+    try {
+      portalContent = nodes();
+      container.appendChild(portalContent);
+    } catch (err) {
+      console.error("[Portal] Render error:", err);
+    }
+  });
+  const observer = new MutationObserver(() => {
+    if (!anchor.isConnected && portalContent) {
+      portalContent.remove();
+      portalContent = null;
+      observer.disconnect();
+    }
+  });
+  queueMicrotask(() => {
+    if (anchor.parentNode) {
+      observer.observe(anchor.parentNode, { childList: true });
+    }
+  });
+  return anchor;
+}
+
+// src/core/rendering/dynamic.ts
+var componentRegistry = /* @__PURE__ */ new Map();
+function registerComponent(name, component) {
+  componentRegistry.set(name, component);
+}
+function unregisterComponent(name) {
+  componentRegistry.delete(name);
+}
+function resolveComponent(name) {
+  const component = componentRegistry.get(name);
+  if (component) {
+    return component();
+  }
+  return div({ nodes: `[Component "${name}" not found]` });
+}
+function DynamicComponent(is) {
+  const container = div({ class: "sibu-dynamic" });
+  function render() {
+    const target = is();
+    let el;
+    if (typeof target === "function") {
+      el = target();
+    } else {
+      el = resolveComponent(target);
+    }
+    for (const child of Array.from(container.childNodes)) {
+      dispose(child);
+    }
+    container.replaceChildren(el);
+  }
+  track(render);
+  return container;
+}
+
+// src/core/rendering/slots.ts
+function getSlot(slots, name = "default") {
+  return slots?.[name];
+}
+
+// src/core/rendering/directives.ts
+function show(condition, element) {
+  const update = () => {
+    element.style.display = condition() ? "" : "none";
+  };
+  track(update);
+  return element;
+}
+function when(condition, thenBranch, elseBranch) {
+  const anchor = document.createComment("when");
+  let currentNode = null;
+  let lastCondition;
+  let initialized = false;
+  const update = () => {
+    const show2 = condition();
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (initialized && show2 === lastCondition) return;
+    lastCondition = show2;
+    if (currentNode?.parentNode) {
+      dispose(currentNode);
+      currentNode.parentNode.removeChild(currentNode);
+      currentNode = null;
+    }
+    const result = show2 ? thenBranch() : elseBranch ? elseBranch() : null;
+    if (result != null) {
+      const node = result instanceof Node ? result : document.createTextNode(String(result));
+      parent.insertBefore(node, anchor.nextSibling);
+      currentNode = node;
+    }
+    initialized = true;
+  };
+  track(update);
+  if (!initialized) {
+    queueMicrotask(() => {
+      if (!initialized && anchor.parentNode) update();
+    });
+  }
+  return anchor;
+}
+function match(value, cases, fallback) {
+  const anchor = document.createComment("match");
+  let currentNode = null;
+  let lastKey;
+  let initialized = false;
+  const update = () => {
+    const key = String(value());
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (initialized && key === lastKey) return;
+    lastKey = key;
+    if (currentNode?.parentNode) {
+      dispose(currentNode);
+      currentNode.parentNode.removeChild(currentNode);
+      currentNode = null;
+    }
+    const renderFn = cases[key] || fallback;
+    if (renderFn) {
+      const result = renderFn();
+      if (result != null) {
+        const node = result instanceof Node ? result : document.createTextNode(String(result));
+        parent.insertBefore(node, anchor.nextSibling);
+        currentNode = node;
+      }
+    }
+    initialized = true;
+  };
+  track(update);
+  if (!initialized) {
+    queueMicrotask(() => {
+      if (!initialized && anchor.parentNode) update();
+    });
+  }
+  return anchor;
+}
+
+// src/core/rendering/keepAlive.ts
+function KeepAlive(activeKey, cases, options) {
+  const anchor = document.createComment("keep-alive");
+  const cache2 = /* @__PURE__ */ new Map();
+  const lruOrder = [];
+  const max = options?.max ?? 0;
+  let currentKey;
+  let currentNode = null;
+  let initialized = false;
+  const update = () => {
+    const key = activeKey();
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (initialized && key === currentKey) return;
+    if (currentNode?.parentNode) {
+      parent.removeChild(currentNode);
+    }
+    currentKey = key;
+    let node = cache2.get(key);
+    if (!node) {
+      const factory = cases[key];
+      if (!factory) {
+        currentNode = null;
+        initialized = true;
+        return;
+      }
+      node = factory();
+      cache2.set(key, node);
+      lruOrder.push(key);
+      if (max > 0 && lruOrder.length > max) {
+        const evictKey = lruOrder.shift();
+        const evictNode = cache2.get(evictKey);
+        if (evictNode) {
+          dispose(evictNode);
+          if (evictNode.parentNode) evictNode.parentNode.removeChild(evictNode);
+          cache2.delete(evictKey);
+        }
+      }
+    } else {
+      const idx = lruOrder.indexOf(key);
+      if (idx !== -1) {
+        lruOrder.splice(idx, 1);
+        lruOrder.push(key);
+      }
+    }
+    parent.insertBefore(node, anchor.nextSibling);
+    currentNode = node;
+    initialized = true;
+  };
+  track(update);
+  if (!initialized) {
+    queueMicrotask(() => {
+      if (!initialized && anchor.parentNode) update();
+    });
+  }
+  return anchor;
+}
+
+// src/core/rendering/action.ts
+function action(element, actionFn, param2) {
+  const cleanup = actionFn(element, param2);
+  if (typeof cleanup === "function") {
+    registerDisposer(element, cleanup);
+  }
+}
+var clickOutside = (element, callback) => {
+  const handler = (e) => {
+    if (!element.contains(e.target)) {
+      callback();
+    }
+  };
+  document.addEventListener("pointerdown", handler, true);
+  return () => document.removeEventListener("pointerdown", handler, true);
+};
+var longPress = (element, options) => {
+  const duration = options.duration ?? 500;
+  let timer = null;
+  const start = () => {
+    timer = setTimeout(() => {
+      options.callback();
+      timer = null;
+    }, duration);
+  };
+  const cancel = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  element.addEventListener("pointerdown", start);
+  element.addEventListener("pointerup", cancel);
+  element.addEventListener("pointerleave", cancel);
+  return () => {
+    cancel();
+    element.removeEventListener("pointerdown", start);
+    element.removeEventListener("pointerup", cancel);
+    element.removeEventListener("pointerleave", cancel);
+  };
+};
+var copyOnClick = (element, getText) => {
+  const handler = () => {
+    const text2 = typeof getText === "function" ? getText() : element.textContent ?? "";
+    navigator.clipboard.writeText(text2);
+  };
+  element.addEventListener("click", handler);
+  return () => element.removeEventListener("click", handler);
+};
+var autoResize = (element) => {
+  const resize = () => {
+    element.style.overflow = "hidden";
+    element.style.height = "auto";
+    element.style.height = `${element.scrollHeight}px`;
+  };
+  resize();
+  element.addEventListener("input", resize);
+  return () => element.removeEventListener("input", resize);
+};
+var trapFocus = (element) => {
+  const focusable = 'a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex="-1"])';
+  const handler = (e) => {
+    if (e.key !== "Tab") return;
+    const elements = Array.from(element.querySelectorAll(focusable));
+    if (elements.length === 0) return;
+    const first = elements[0];
+    const last = elements[elements.length - 1];
+    if (e.shiftKey && document.activeElement === first) {
+      e.preventDefault();
+      last.focus();
+    } else if (!e.shiftKey && document.activeElement === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  };
+  element.addEventListener("keydown", handler);
+  return () => element.removeEventListener("keydown", handler);
+};
+
+// src/core/rendering/catch.ts
+var globalErrorHandler = null;
+function catchError(fn, onError) {
+  try {
+    const result = fn();
+    if (result && typeof result.then === "function") {
+      result.catch((err) => {
+        if (onError) {
+          onError(err, "async");
+        } else if (globalErrorHandler) {
+          globalErrorHandler(err, "async");
+        } else {
+          console.error("Unhandled async error in Sibu.catchError:", err);
+        }
+      });
+    }
+    return result;
+  } catch (err) {
+    if (onError) {
+      onError(err, "sync");
+    } else if (globalErrorHandler) {
+      globalErrorHandler(err, "sync");
+    } else {
+      console.error("Unhandled error in Sibu.catchError:", err);
+    }
+    return null;
+  }
+}
+async function catchErrorAsync(fn, onError) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (onError) {
+      onError(err, "async");
+    } else if (globalErrorHandler) {
+      globalErrorHandler(err, "async");
+    } else {
+      console.error("Unhandled async error in Sibu.catchErrorAsync:", err);
+    }
+    return null;
+  }
+}
+function setGlobalErrorHandler(handler) {
+  globalErrorHandler = handler;
+}
+
+// src/core/signals/store.ts
+function store(initialState) {
+  devAssert(
+    initialState !== null && typeof initialState === "object" && !Array.isArray(initialState),
+    "store: argument must be a plain object. For arrays, use array() instead."
+  );
+  const signals = {};
+  Object.keys(initialState).forEach((key) => {
+    const [getter, setter] = signal(initialState[key]);
+    signals[key] = [getter, setter];
+  });
+  const store2 = new Proxy({}, {
+    get(_, prop) {
+      if (prop in signals) {
+        const getter = signals[prop][0];
+        return getter();
+      }
+      return void 0;
+    },
+    set() {
+      throw new Error(
+        "[Sibu] store: Direct mutation is not allowed. Use actions.setState() to update store properties."
+      );
+    }
+  });
+  const getSnapshot = () => {
+    const snapshot = {};
+    Object.keys(signals).forEach((key) => {
+      snapshot[key] = signals[key][0]();
+    });
+    return snapshot;
+  };
+  const setState = (patch) => {
+    const current = getSnapshot();
+    const nextState = typeof patch === "function" ? patch(current) : patch;
+    Object.entries(nextState).forEach(([key, value]) => {
+      if (key in signals) {
+        signals[key][1](value);
+      }
+    });
+  };
+  const reset = () => {
+    Object.keys(initialState).forEach((key) => {
+      const setter = signals[key][1];
+      setter(initialState[key]);
+    });
+  };
+  const subscribe = (callback) => {
+    let first = true;
+    return effect(() => {
+      const snapshot = getSnapshot();
+      if (first) {
+        first = false;
+        return;
+      }
+      callback(snapshot);
+    });
+  };
+  const subscribeKey = (key, callback) => {
+    let prev;
+    let first = true;
+    return effect(() => {
+      const current = signals[key][0]();
+      if (first) {
+        prev = current;
+        first = false;
+        return;
+      }
+      if (!Object.is(current, prev)) {
+        const oldPrev = prev;
+        prev = current;
+        callback(current, oldPrev);
+      }
+    });
+  };
+  return [store2, { setState, reset, subscribe, subscribeKey, getSnapshot }];
+}
+
+// src/core/signals/ref.ts
+function ref(initial) {
+  const [get, set] = signal(initial);
+  return {
+    get current() {
+      return get();
+    },
+    set current(value) {
+      set(value);
+    }
+  };
+}
+
+// src/core/signals/memo.ts
+function memo(factory) {
+  return derived(factory);
+}
+
+// src/core/signals/memoFn.ts
+function memoFn(callback) {
+  return derived(callback);
+}
+
+// src/core/signals/array.ts
+function array(initial = []) {
+  const [arr, setArr] = signal([...initial]);
+  const actions = {
+    push(...items) {
+      setArr((prev) => [...prev, ...items]);
+    },
+    pop() {
+      let removed;
+      setArr((prev) => {
+        const copy = [...prev];
+        removed = copy.pop();
+        return copy;
+      });
+      return removed;
+    },
+    shift() {
+      let removed;
+      setArr((prev) => {
+        const copy = [...prev];
+        removed = copy.shift();
+        return copy;
+      });
+      return removed;
+    },
+    unshift(...items) {
+      setArr((prev) => [...items, ...prev]);
+    },
+    splice(start, deleteCount = 0, ...items) {
+      let removed = [];
+      setArr((prev) => {
+        const copy = [...prev];
+        removed = copy.splice(start, deleteCount, ...items);
+        return copy;
+      });
+      return removed;
+    },
+    remove(index) {
+      setArr((prev) => prev.filter((_, i2) => i2 !== index));
+    },
+    removeWhere(predicate) {
+      setArr((prev) => {
+        const idx = prev.findIndex(predicate);
+        if (idx === -1) return prev;
+        return prev.filter((_, i2) => i2 !== idx);
+      });
+    },
+    set(items) {
+      setArr([...items]);
+    },
+    update(index, value) {
+      setArr((prev) => prev.map((item, i2) => i2 === index ? value : item));
+    },
+    updateWhere(predicate, updater) {
+      setArr((prev) => prev.map((item) => predicate(item) ? updater(item) : item));
+    },
+    sort(compareFn) {
+      setArr((prev) => [...prev].sort(compareFn));
+    },
+    reverse() {
+      setArr((prev) => [...prev].reverse());
+    },
+    filter(predicate) {
+      setArr((prev) => prev.filter(predicate));
+    },
+    map(transform) {
+      setArr((prev) => prev.map(transform));
+    },
+    clear() {
+      setArr([]);
+    }
+  };
+  return [arr, actions];
+}
+function reactiveArray(initial = []) {
+  let data2 = [...initial];
+  let snapshot = null;
+  const signal2 = {};
+  function notify() {
+    snapshot = null;
+    if (!enqueueBatchedSignal(signal2)) {
+      notifySubscribers(signal2);
+    }
+  }
+  function get() {
+    recordDependency(signal2);
+    if (snapshot === null) {
+      snapshot = Object.freeze([...data2]);
+    }
+    return snapshot;
+  }
+  const actions = {
+    push(...items) {
+      if (items.length === 0) return;
+      data2.push(...items);
+      notify();
+    },
+    pop() {
+      if (data2.length === 0) return void 0;
+      const removed = data2.pop();
+      notify();
+      return removed;
+    },
+    shift() {
+      if (data2.length === 0) return void 0;
+      const removed = data2.shift();
+      notify();
+      return removed;
+    },
+    unshift(...items) {
+      if (items.length === 0) return;
+      data2.unshift(...items);
+      notify();
+    },
+    splice(start, deleteCount = 0, ...items) {
+      const removed = data2.splice(start, deleteCount, ...items);
+      if (removed.length > 0 || items.length > 0) {
+        notify();
+      }
+      return removed;
+    },
+    remove(index) {
+      if (index < 0 || index >= data2.length) return;
+      data2.splice(index, 1);
+      notify();
+    },
+    removeWhere(predicate) {
+      const idx = data2.findIndex(predicate);
+      if (idx === -1) return;
+      data2.splice(idx, 1);
+      notify();
+    },
+    set(items) {
+      data2 = [...items];
+      notify();
+    },
+    update(index, value) {
+      if (index < 0 || index >= data2.length) return;
+      if (Object.is(data2[index], value)) return;
+      data2[index] = value;
+      notify();
+    },
+    updateWhere(predicate, updater) {
+      let changed = false;
+      for (let i2 = 0; i2 < data2.length; i2++) {
+        if (predicate(data2[i2])) {
+          const updated = updater(data2[i2]);
+          if (!Object.is(data2[i2], updated)) {
+            data2[i2] = updated;
+            changed = true;
+          }
+        }
+      }
+      if (changed) notify();
+    },
+    sort(compareFn) {
+      if (data2.length <= 1) return;
+      data2.sort(compareFn);
+      notify();
+    },
+    reverse() {
+      if (data2.length <= 1) return;
+      data2.reverse();
+      notify();
+    },
+    filter(predicate) {
+      const filtered = data2.filter(predicate);
+      if (filtered.length === data2.length) return;
+      data2 = filtered;
+      notify();
+    },
+    map(transform) {
+      let changed = false;
+      for (let i2 = 0; i2 < data2.length; i2++) {
+        const transformed = transform(data2[i2], i2);
+        if (!Object.is(data2[i2], transformed)) {
+          data2[i2] = transformed;
+          changed = true;
+        }
+      }
+      if (changed) notify();
+    },
+    clear() {
+      if (data2.length === 0) return;
+      data2 = [];
+      notify();
+    }
+  };
+  return [get, actions];
+}
+
+// src/core/signals/deepSignal.ts
+function deepEqual(a2, b2, seen) {
+  if (Object.is(a2, b2)) return true;
+  if (a2 == null || b2 == null) return false;
+  if (typeof a2 !== typeof b2) return false;
+  if (typeof a2 !== "object") return false;
+  if (a2 instanceof Date && b2 instanceof Date) return a2.getTime() === b2.getTime();
+  if (a2 instanceof RegExp && b2 instanceof RegExp) return a2.toString() === b2.toString();
+  if (!seen) seen = /* @__PURE__ */ new Set();
+  if (seen.has(a2)) return true;
+  seen.add(a2);
+  if (Array.isArray(a2)) {
+    if (!Array.isArray(b2)) return false;
+    if (a2.length !== b2.length) return false;
+    return a2.every((val, i2) => deepEqual(val, b2[i2], seen));
+  }
+  const keysA = Object.keys(a2);
+  const keysB = Object.keys(b2);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every(
+    (key) => deepEqual(a2[key], b2[key], seen)
+  );
+}
+function deepSignal(initial) {
+  return signal(initial, { equals: (a2, b2) => deepEqual(a2, b2) });
+}
+
+// src/core/signals/writable.ts
+function writable(get, set, options) {
+  const getter = derived(get, options);
+  const setter = (value) => {
+    batch(() => set(value));
+  };
+  return [getter, setter];
+}
+
+// src/core/signals/asyncDerived.ts
+function asyncDerived(factory, initial) {
+  const [value, setValue] = signal(initial);
+  const [loading, setLoading] = signal(false);
+  const [error, setError] = signal(null);
+  const [tick, setTick] = signal(0);
+  let runId = 0;
+  effect(() => {
+    tick();
+    const currentRun = ++runId;
+    setLoading(true);
+    setError(null);
+    let promise;
+    try {
+      promise = factory();
+    } catch (err) {
+      setError(err);
+      setLoading(false);
+      return;
+    }
+    promise.then(
+      (result) => {
+        if (currentRun !== runId) return;
+        setValue(result);
+        setLoading(false);
+      },
+      (err) => {
+        if (currentRun !== runId) return;
+        setError(err);
+        setLoading(false);
+      }
+    );
+  });
+  return {
+    value,
+    loading,
+    error,
+    refresh: () => setTick((n) => n + 1)
+  };
+}
+
+// src/core/rendering/lifecycle.ts
+function safeCall(cb, hookName) {
+  try {
+    cb();
+  } catch (err) {
+    devWarn(`${hookName}: callback threw: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function onMount(callback, element) {
+  if (typeof document === "undefined") return;
+  if (element) {
+    if (element.isConnected) {
+      queueMicrotask(() => {
+        safeCall(callback, "onMount");
+      });
+      return;
+    }
+    const observer = new MutationObserver(() => {
+      if (element.isConnected) {
+        observer.disconnect();
+        safeCall(callback, "onMount");
+      }
+    });
+    queueMicrotask(() => {
+      if (element.isConnected) {
+        safeCall(callback, "onMount");
+      } else {
+        observer.observe(document.body, { childList: true, subtree: true });
+      }
+    });
+  } else {
+    queueMicrotask(() => {
+      safeCall(callback, "onMount");
+    });
+  }
+}
+function onUnmount(callback, element) {
+  const startObserving = () => {
+    const observer = new MutationObserver(() => {
+      if (!element.isConnected) {
+        observer.disconnect();
+        safeCall(callback, "onUnmount");
+      }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+  };
+  if (element.isConnected) {
+    startObserving();
+  } else {
+    onMount(() => {
+      startObserving();
+      return void 0;
+    }, element);
+  }
+}
+function onCleanup(callback, element) {
+  registerDisposer(element, callback);
+}
+
+// src/core/strict.ts
+function strict(fn) {
+  const result = fn();
+  if (isDev()) {
+    queueMicrotask(() => {
+      try {
+        fn();
+      } catch (err) {
+        console.warn("[Sibu strict] second run threw:", err);
+      }
+    });
+  }
+  return result;
+}
+function strictEffect(fn) {
+  if (!isDev()) {
+    return effect(fn);
+  }
+  const firstTeardown = effect(fn);
+  let secondTeardown = null;
+  queueMicrotask(() => {
+    try {
+      secondTeardown = effect(fn);
+    } catch (err) {
+      console.warn("[Sibu strictEffect] second run threw:", err);
+    }
+  });
+  return () => {
+    firstTeardown();
+    if (secondTeardown) secondTeardown();
+  };
+}
+
+// src/reactivity/nextTick.ts
+function nextTick() {
+  return new Promise((resolve) => {
+    queueMicrotask(() => {
+      if (typeof requestAnimationFrame === "function") {
+        requestAnimationFrame(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+// src/reactivity/concurrent.ts
+function defer(getter) {
+  const [value, setValue] = signal(getter());
+  let pending = false;
+  let latest = value();
+  const flush = () => {
+    pending = false;
+    setValue(latest);
+  };
+  const schedule = () => {
+    if (pending) return;
+    pending = true;
+    queueMicrotask(() => {
+      if (typeof requestAnimationFrame === "function") {
+        requestAnimationFrame(flush);
+      } else {
+        flush();
+      }
+    });
+  };
+  track(() => {
+    latest = getter();
+    schedule();
+  });
+  return value;
+}
+var IDLE_FALLBACK_MS = 16;
+function scheduleIdle(fn) {
+  const g2 = globalThis;
+  if (typeof g2.requestIdleCallback === "function") {
+    g2.requestIdleCallback(fn, { timeout: IDLE_FALLBACK_MS * 4 });
+    return;
+  }
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(() => fn());
+    return;
+  }
+  setTimeout(fn, IDLE_FALLBACK_MS);
+}
+function transition() {
+  const [pending, setPending] = signal(false);
+  function start(fn) {
+    setPending(true);
+    scheduleIdle(() => {
+      let result;
+      try {
+        result = fn();
+      } catch {
+        setPending(false);
+        return;
+      }
+      if (result && typeof result.then === "function") {
+        result.then(
+          () => setPending(false),
+          () => setPending(false)
+        );
+      } else {
+        setPending(false);
+      }
+    });
+  }
+  return { pending, start };
+}
+
+// src/core/rendering/lazy.ts
+function lazy(importFn) {
+  let cached = null;
+  return function LazyComponent() {
+    if (cached) {
+      return cached();
+    }
+    const [_status, setStatus] = signal("loading");
+    const [_error, setError] = signal(null);
+    const container = div({ class: "sibu-lazy" });
+    importFn().then((mod) => {
+      cached = mod.default;
+      const rendered = cached();
+      container.replaceChildren(rendered);
+      setStatus("loaded");
+    }).catch((err) => {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      setStatus("error");
+      container.replaceChildren(
+        div({
+          class: "sibu-lazy-error",
+          nodes: `Failed to load component: ${errorObj.message}`
+        })
+      );
+    });
+    container.appendChild(span({ class: "sibu-lazy-loading", nodes: "Loading..." }));
+    return container;
+  };
+}
+function Suspense({ nodes, fallback }) {
+  const container = div({ class: "sibu-suspense" });
+  const fallbackEl = fallback();
+  container.appendChild(fallbackEl);
+  queueMicrotask(() => {
+    try {
+      const childEl = nodes();
+      if (childEl.classList.contains("sibu-lazy")) {
+        const observer = new MutationObserver(() => {
+          const loading = childEl.querySelector(".sibu-lazy-loading");
+          if (!loading) {
+            observer.disconnect();
+            container.replaceChildren(childEl);
+          }
+        });
+        observer.observe(childEl, { childList: true, subtree: true });
+        if (!childEl.querySelector(".sibu-lazy-loading")) {
+          container.replaceChildren(childEl);
+        }
+      } else {
+        container.replaceChildren(childEl);
+      }
+    } catch {
+    }
+  });
+  return container;
+}
+
+// src/components/ErrorDisplay.ts
+var _isDev2 = isDev();
+var STYLES = `
+  .sibu-error-display {
+    border: 1px solid var(--sibu-err-border, #e5484d);
+    border-radius: 10px;
+    margin: 12px 0;
+    background: #0f0f1a;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    color: #e5e7eb;
+    overflow: hidden;
+  }
+  .sibu-error-display[data-severity="warning"] { --sibu-err-border: #d97706; --sibu-err-accent: #d97706; }
+  .sibu-error-display[data-severity="info"] { --sibu-err-border: #3b82f6; --sibu-err-accent: #3b82f6; }
+  .sibu-error-display { --sibu-err-accent: #e5484d; }
+
+  .sibu-error-display .sibu-err-header {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 12px 18px;
+    background: var(--sibu-err-accent);
+    color: white;
+    user-select: none;
+  }
+  .sibu-error-display .sibu-err-icon {
+    font-family: 'SF Mono', 'JetBrains Mono', 'Fira Code', monospace;
+    font-weight: bold;
+    font-size: 1.05em;
+    padding: 2px 8px;
+    background: rgba(0, 0, 0, 0.22);
+    border-radius: 4px;
+    letter-spacing: 0.02em;
+  }
+  .sibu-error-display .sibu-err-title {
+    margin: 0;
+    font-size: 0.98em;
+    font-weight: 600;
+    flex: 1;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    white-space: nowrap;
+  }
+  .sibu-error-display .sibu-err-timestamp {
+    font-size: 0.75em;
+    opacity: 0.85;
+    font-family: 'SF Mono', 'JetBrains Mono', monospace;
+  }
+
+  .sibu-error-display .sibu-err-body {
+    padding: 16px 18px;
+  }
+  .sibu-error-display .sibu-err-message {
+    font-family: 'SF Mono', 'JetBrains Mono', 'Fira Code', monospace;
+    margin: 0 0 14px;
+    color: #fecaca;
+    word-break: break-word;
+    font-size: 0.9em;
+    line-height: 1.55;
+    padding: 10px 12px;
+    background: rgba(229, 72, 77, 0.08);
+    border-left: 3px solid var(--sibu-err-accent);
+    border-radius: 4px;
+  }
+
+  .sibu-error-display .sibu-err-section {
+    margin-top: 14px;
+    border-radius: 6px;
+    border: 1px solid #2a2a3e;
+    background: #0a0a14;
+    overflow: hidden;
+  }
+  .sibu-error-display .sibu-err-section-head {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 6px 12px;
+    background: #16162a;
+    border-bottom: 1px solid #2a2a3e;
+    font-size: 0.72em;
+    color: #8b8fa3;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    font-weight: 600;
+  }
+  .sibu-error-display .sibu-err-copy-btn {
+    background: transparent;
+    border: 1px solid #3a3a4e;
+    border-radius: 4px;
+    color: #a0a3b8;
+    cursor: pointer;
+    padding: 2px 10px;
+    font-size: 0.95em;
+    font-family: inherit;
+    transition: all 0.12s ease;
+  }
+  .sibu-error-display .sibu-err-copy-btn:hover {
+    background: #2a2a3e;
+    color: #e5e7eb;
+    border-color: #4a4a5e;
+  }
+
+  .sibu-error-display .sibu-err-stack {
+    margin: 0;
+    padding: 10px 12px;
+    overflow-x: auto;
+    font-family: 'SF Mono', 'JetBrains Mono', monospace;
+    font-size: 0.8em;
+    line-height: 1.7;
+  }
+  .sibu-error-display .sibu-err-frame {
+    display: flex;
+    gap: 10px;
+    padding: 1px 0;
+  }
+  .sibu-error-display .sibu-err-line {
+    display: inline-block;
+    min-width: 2.2ch;
+    color: #4b5066;
+    text-align: right;
+    user-select: none;
+    flex-shrink: 0;
+  }
+  .sibu-error-display .sibu-err-fn {
+    color: #7dd3fc;
+    font-weight: 500;
+  }
+  .sibu-error-display .sibu-err-loc {
+    color: #6b7280;
+    white-space: nowrap;
+  }
+  .sibu-error-display .sibu-err-cause-label {
+    margin: 12px 0 6px;
+    color: #a0a3b8;
+    font-size: 0.75em;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .sibu-error-display .sibu-err-meta {
+    margin: 0;
+    padding: 10px 12px;
+    font-family: 'SF Mono', 'JetBrains Mono', monospace;
+    font-size: 0.78em;
+    color: #a0a3b8;
+    display: grid;
+    grid-template-columns: minmax(120px, auto) 1fr;
+    gap: 4px 16px;
+  }
+  .sibu-error-display .sibu-err-meta dt { color: #6b7280; }
+  .sibu-error-display .sibu-err-meta dd { margin: 0; color: #d1d5db; word-break: break-word; }
+
+  .sibu-error-display .sibu-err-actions {
+    display: flex;
+    gap: 8px;
+    margin-top: 16px;
+  }
+  .sibu-error-display .sibu-err-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 8px 18px;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 13px;
+    font-weight: 500;
+    transition: all 0.12s ease;
+    font-family: inherit;
+  }
+  .sibu-error-display .sibu-err-btn-retry {
+    background: var(--sibu-err-accent);
+    color: white;
+  }
+  .sibu-error-display .sibu-err-btn-retry:hover { filter: brightness(1.1); }
+  .sibu-error-display .sibu-err-btn-reload {
+    background: #1f2133;
+    color: #d1d5db;
+    border: 1px solid #3a3a4e;
+  }
+  .sibu-error-display .sibu-err-btn-reload:hover { background: #2a2b40; }
+`;
+var _stylesInjected = false;
+function injectStyles() {
+  if (_stylesInjected || typeof document === "undefined") return;
+  const el = style({ nodes: STYLES });
+  document.head.appendChild(el);
+  _stylesInjected = true;
+}
+function parseStack(stack) {
+  const frames = [];
+  const lines = stack.split("\n");
+  for (const raw of lines) {
+    const line2 = raw.trim();
+    const chrome = line2.match(/^at\s+(?:(.+?)\s+\((.+)\)|(.+))$/);
+    if (chrome) {
+      frames.push({ fn: chrome[1] || "(anonymous)", loc: chrome[2] || chrome[3] || "" });
+      continue;
+    }
+    const ff = line2.match(/^(.+?)@(.+)$/);
+    if (ff) {
+      frames.push({ fn: ff[1] || "(anonymous)", loc: ff[2] || "" });
+    }
+  }
+  return frames;
+}
+function normalizeError(err) {
+  if (err instanceof Error) {
+    const code2 = err.code ?? err.name ?? "ERROR";
+    const message = err.message || "Unknown error";
+    const stack = err.stack ?? "";
+    const frames = parseStack(stack);
+    const rawCause = err.cause;
+    const cause = rawCause != null ? normalizeError(rawCause) : null;
+    return { code: code2, message, stack, frames, cause };
+  }
+  return {
+    code: "NON_ERROR",
+    message: typeof err === "string" ? err : JSON.stringify(err),
+    stack: "",
+    frames: [],
+    cause: null
+  };
+}
+function buildCopyText(err, meta2) {
+  const lines = [];
+  lines.push(`[${err.code}] ${err.message}`);
+  if (err.stack) {
+    lines.push("");
+    lines.push(err.stack);
+  }
+  if (err.cause) {
+    lines.push("");
+    lines.push("Caused by:");
+    lines.push(`  [${err.cause.code}] ${err.cause.message}`);
+    if (err.cause.stack) {
+      const indented = err.cause.stack.split("\n").map((l) => `  ${l}`).join("\n");
+      lines.push(indented);
+    }
+  }
+  if (meta2 && Object.keys(meta2).length > 0) {
+    lines.push("");
+    lines.push("Metadata:");
+    for (const [k, v] of Object.entries(meta2)) {
+      lines.push(`  ${k}: ${String(v)}`);
+    }
+  }
+  lines.push("");
+  lines.push(`At: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  if (typeof navigator !== "undefined" && navigator.userAgent) {
+    lines.push(`UA: ${navigator.userAgent}`);
+  }
+  return lines.join("\n");
+}
+function renderFrames(frames) {
+  const rows = frames.map(
+    (f, i2) => div({
+      class: "sibu-err-frame",
+      nodes: [
+        span({ class: "sibu-err-line", nodes: String(i2 + 1) }),
+        span({ class: "sibu-err-fn", nodes: f.fn }),
+        span({ class: "sibu-err-loc", nodes: ` \u2014 ${f.loc}` })
+      ]
+    })
+  );
+  return pre({ class: "sibu-err-stack", nodes: rows });
+}
+function renderCauseChain(cause) {
+  if (!cause) return [];
+  return [
+    div({ class: "sibu-err-cause-label", nodes: "Caused by" }),
+    div({
+      class: "sibu-err-section",
+      nodes: [
+        div({
+          class: "sibu-err-section-head",
+          nodes: [span({ nodes: `[${cause.code}] ${cause.message}` }), span({ nodes: "" })]
+        }),
+        cause.frames.length > 0 ? renderFrames(cause.frames) : div({ class: "sibu-err-stack", nodes: "(no stack)" })
+      ]
+    }),
+    ...renderCauseChain(cause.cause)
+  ];
+}
+function renderMetadata(meta2) {
+  const rows = [];
+  for (const [k, v] of Object.entries(meta2)) {
+    rows.push(document.createElement("dt"));
+    rows[rows.length - 1].textContent = k;
+    const dd2 = document.createElement("dd");
+    dd2.textContent = v == null ? "(null)" : String(v);
+    rows.push(dd2);
+  }
+  const dl2 = document.createElement("dl");
+  dl2.className = "sibu-err-meta";
+  for (const r of rows) dl2.appendChild(r);
+  return dl2;
+}
+function ErrorDisplay(props) {
+  injectStyles();
+  const severity = props.severity ?? "error";
+  const normalized = normalizeError(props.error);
+  const showDetails = props.alwaysShowDetails ?? _isDev2;
+  const headline = props.title ?? normalized.message;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  const [copyLabel, setCopyLabel] = signal("Copy");
+  const copyBtn = button({
+    class: "sibu-err-copy-btn",
+    nodes: () => copyLabel(),
+    on: {
+      click: () => {
+        const text2 = buildCopyText(normalized, props.metadata);
+        if (typeof navigator !== "undefined" && navigator.clipboard) {
+          navigator.clipboard.writeText(text2).then(
+            () => {
+              setCopyLabel("Copied!");
+              setTimeout(() => setCopyLabel("Copy"), 1500);
+            },
+            () => {
+              setCopyLabel("Copy failed");
+              setTimeout(() => setCopyLabel("Copy"), 1500);
+            }
+          );
+        }
+      }
+    }
+  });
+  const header2 = div({
+    class: "sibu-err-header",
+    nodes: [
+      code({ class: "sibu-err-icon", nodes: normalized.code }),
+      h3({ class: "sibu-err-title", nodes: headline }),
+      span({ class: "sibu-err-timestamp", nodes: timestamp })
+    ]
+  });
+  const bodyChildren = [p({ class: "sibu-err-message", nodes: normalized.message })];
+  if (showDetails && normalized.frames.length > 0) {
+    bodyChildren.push(
+      div({
+        class: "sibu-err-section",
+        nodes: [
+          div({
+            class: "sibu-err-section-head",
+            nodes: [span({ nodes: "Stack Trace" }), copyBtn]
+          }),
+          renderFrames(normalized.frames)
+        ]
+      })
+    );
+  } else if (showDetails) {
+    bodyChildren.push(
+      div({
+        class: "sibu-err-section",
+        nodes: [
+          div({
+            class: "sibu-err-section-head",
+            nodes: [span({ nodes: "Details" }), copyBtn]
+          }),
+          div({ class: "sibu-err-stack", nodes: "(no stack available)" })
+        ]
+      })
+    );
+  }
+  if (showDetails) {
+    bodyChildren.push(...renderCauseChain(normalized.cause));
+  }
+  if (showDetails && props.metadata && Object.keys(props.metadata).length > 0) {
+    bodyChildren.push(
+      div({
+        class: "sibu-err-section",
+        nodes: [
+          div({ class: "sibu-err-section-head", nodes: [span({ nodes: "Metadata" })] }),
+          renderMetadata(props.metadata)
+        ]
+      })
+    );
+  }
+  if (showDetails && typeof navigator !== "undefined" && navigator.userAgent) {
+    bodyChildren.push(
+      div({
+        class: "sibu-err-section",
+        nodes: [
+          div({ class: "sibu-err-section-head", nodes: [span({ nodes: "Environment" })] }),
+          div({
+            class: "sibu-err-meta",
+            nodes: (() => {
+              const dl2 = document.createElement("dl");
+              dl2.className = "sibu-err-meta";
+              const entries = [
+                ["User Agent", navigator.userAgent],
+                ["URL", typeof location !== "undefined" ? location.href : "(n/a)"],
+                ["Timestamp", (/* @__PURE__ */ new Date()).toISOString()]
+              ];
+              for (const [k, v] of entries) {
+                const dt2 = document.createElement("dt");
+                dt2.textContent = k;
+                const dd2 = document.createElement("dd");
+                dd2.textContent = v;
+                dl2.appendChild(dt2);
+                dl2.appendChild(dd2);
+              }
+              return dl2;
+            })()
+          })
+        ]
+      })
+    );
+  }
+  const actionButtons = [];
+  if (props.onRetry) {
+    actionButtons.push(
+      button({
+        class: "sibu-err-btn sibu-err-btn-retry",
+        nodes: props.retryLabel ?? "Retry",
+        on: { click: props.onRetry }
+      })
+    );
+  }
+  if (!props.hideReload && typeof location !== "undefined") {
+    actionButtons.push(
+      button({
+        class: "sibu-err-btn sibu-err-btn-reload",
+        nodes: "Reload Page",
+        on: { click: () => location.reload() }
+      })
+    );
+  }
+  if (actionButtons.length > 0) {
+    bodyChildren.push(div({ class: "sibu-err-actions", nodes: actionButtons }));
+  }
+  const body2 = div({ class: "sibu-err-body", nodes: bodyChildren });
+  return div({
+    class: "sibu-error-display",
+    "data-severity": severity,
+    nodes: [header2, body2]
+  });
+}
+
+// src/components/ErrorBoundary.ts
+var errorBoundaryStyles = `
+  .sibu-error-boundary {
+    position: relative;
+  }
+
+  .sibu-error-fallback {
+    border: 1px solid #e5484d;
+    border-radius: 8px;
+    padding: 0;
+    margin: 10px 0;
+    background: #1a1a2e;
+    box-shadow: 0 4px 24px rgba(0, 0, 0, 0.4);
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    color: #e1e1e6;
+    overflow: hidden;
+  }
+
+  .sibu-error-fallback .sibu-error-header {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 12px 16px;
+    background: #e5484d;
+    color: white;
+  }
+
+  .sibu-error-fallback .sibu-error-title {
+    margin: 0;
+    font-size: 0.95em;
+    font-weight: 600;
+  }
+
+  .sibu-error-fallback .sibu-error-source {
+    margin-left: auto;
+    font-size: 0.8em;
+    opacity: 0.9;
+    font-family: 'SF Mono', 'Fira Code', 'Roboto Mono', monospace;
+  }
+
+  .sibu-error-fallback .sibu-error-body {
+    padding: 16px;
+  }
+
+  .sibu-error-fallback .sibu-error-message {
+    font-family: 'SF Mono', 'Fira Code', 'Roboto Mono', monospace;
+    margin: 0 0 12px 0;
+    color: #f1a9a0;
+    word-break: break-word;
+    font-size: 0.9em;
+    line-height: 1.5;
+  }
+
+  .sibu-error-fallback .sibu-error-stack-container {
+    position: relative;
+    margin: 0 0 12px 0;
+    border-radius: 6px;
+    border: 1px solid #2a2a3e;
+    background: #12121f;
+    overflow: hidden;
+  }
+
+  .sibu-error-fallback .sibu-error-stack-label {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 6px 12px;
+    background: #1e1e32;
+    border-bottom: 1px solid #2a2a3e;
+    font-size: 0.75em;
+    color: #888;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .sibu-error-fallback .sibu-error-copy-btn {
+    background: transparent;
+    border: 1px solid #3a3a4e;
+    border-radius: 4px;
+    color: #888;
+    cursor: pointer;
+    padding: 2px 8px;
+    font-size: 1em;
+    transition: all 0.15s ease;
+  }
+
+  .sibu-error-fallback .sibu-error-copy-btn:hover {
+    background: #2a2a3e;
+    color: #ccc;
+    border-color: #4a4a5e;
+  }
+
+  .sibu-error-fallback .sibu-error-stack pre {
+    margin: 0;
+    padding: 12px;
+    overflow-x: auto;
+    font-family: 'SF Mono', 'Fira Code', 'Roboto Mono', monospace;
+    font-size: 0.82em;
+    line-height: 1.6;
+    color: #a0a0b0;
+  }
+
+  .sibu-error-fallback .sibu-error-stack .sibu-line-num {
+    display: inline-block;
+    width: 3ch;
+    margin-right: 12px;
+    color: #555;
+    text-align: right;
+    user-select: none;
+  }
+
+  .sibu-error-fallback .sibu-error-stack .sibu-stack-fn {
+    color: #7ec8e3;
+  }
+
+  .sibu-error-fallback .sibu-error-stack .sibu-stack-loc {
+    color: #666;
+  }
+
+  .sibu-error-fallback .sibu-error-actions {
+    display: flex;
+    gap: 8px;
+  }
+
+  .sibu-error-fallback .sibu-error-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 8px 18px;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 13px;
+    font-weight: 500;
+    transition: all 0.15s ease;
+  }
+
+  .sibu-error-fallback .sibu-error-btn-retry {
+    background: #e5484d;
+    color: white;
+  }
+
+  .sibu-error-fallback .sibu-error-btn-retry:hover {
+    background: #d13438;
+  }
+
+  .sibu-error-fallback .sibu-error-btn-reload {
+    background: #2a2a3e;
+    color: #ccc;
+    border: 1px solid #3a3a4e;
+  }
+
+  .sibu-error-fallback .sibu-error-btn-reload:hover {
+    background: #3a3a4e;
+  }
+`;
+var stylesInjected = false;
+function injectStyles2() {
+  if (!stylesInjected && typeof document !== "undefined") {
+    const styleElement = style({ nodes: errorBoundaryStyles });
+    document.head.appendChild(styleElement);
+    stylesInjected = true;
+  }
+}
+var fallbackCache = /* @__PURE__ */ new WeakMap();
+function getMemoizedFallback(fallbackFn, error, retry) {
+  let cache2 = fallbackCache.get(fallbackFn);
+  if (!cache2) {
+    cache2 = /* @__PURE__ */ new Map();
+    fallbackCache.set(fallbackFn, cache2);
+  }
+  const key = error.message;
+  if (!cache2.has(key)) {
+    cache2.set(key, fallbackFn(error, retry));
+  }
+  return cache2.get(key);
+}
+function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
+  injectStyles2();
+  const [error, setError] = signal(null);
+  const retry = () => {
+    if (fallback) {
+      fallbackCache.delete(fallback);
+    }
+    setError(null);
+  };
+  if (resetKeys && resetKeys.length > 0) {
+    let initialized = false;
+    effect(() => {
+      for (const k of resetKeys) {
+        try {
+          k();
+        } catch {
+        }
+      }
+      if (!initialized) {
+        initialized = true;
+        return;
+      }
+      if (error() !== null) retry();
+    });
+  }
+  const handleError = (e) => {
+    const errorObj = e instanceof Error ? e : new Error(String(e));
+    setError(errorObj);
+    onError?.(errorObj);
+    return errorObj;
+  };
+  const defaultFallback = (err, retryFn) => {
+    return ErrorDisplay({ error: err, severity: "error", onRetry: retryFn });
+  };
+  const tryRenderFallback = (err) => {
+    const fn = fallback || defaultFallback;
+    try {
+      return getMemoizedFallback(fn, err, retry);
+    } catch (fallbackError) {
+      const propagateError = fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError));
+      queueMicrotask(() => {
+        if (container.parentNode) {
+          container.dispatchEvent(
+            new CustomEvent("sibu:error-propagate", {
+              bubbles: true,
+              detail: { error: propagateError }
+            })
+          );
+        }
+      });
+      return document.createComment("error-boundary-failed");
+    }
+  };
+  const container = div({
+    class: "sibu-error-boundary",
+    nodes: () => {
+      const currentError = error();
+      if (currentError) {
+        return tryRenderFallback(currentError);
+      }
+      try {
+        const result = nodes();
+        if (result && typeof result.then === "function") {
+          const asyncContainer = div({ class: "sibu-error-async" });
+          asyncContainer.appendChild(span({ class: "sibu-lazy-loading", nodes: "Loading..." }));
+          result.then((el) => {
+            asyncContainer.replaceChildren(el);
+          }).catch((e) => {
+            const err = handleError(e);
+            asyncContainer.replaceChildren(tryRenderFallback(err));
+          });
+          return asyncContainer;
+        }
+        return result;
+      } catch (e) {
+        const errorObj = handleError(e);
+        return tryRenderFallback(errorObj);
+      }
+    }
+  });
+  container.addEventListener("sibu:error-propagate", (e) => {
+    if (error()) return;
+    e.stopPropagation();
+    const customEvent = e;
+    const propagatedError = customEvent.detail?.error;
+    if (propagatedError) {
+      handleError(propagatedError);
+    }
+  });
+  return container;
+}
+
+// src/components/Loading.ts
+var loadingStyles = `
+  @keyframes sibu-spin {
+    to { transform: rotate(360deg); }
+  }
+
+  @keyframes sibu-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+  }
+
+  .sibu-loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    gap: 10px;
+  }
+
+  .sibu-loading-spinner {
+    width: 24px;
+    height: 24px;
+    border: 3px solid #e0e0e0;
+    border-top-color: #3b82f6;
+    border-radius: 50%;
+    animation: sibu-spin 0.8s linear infinite;
+  }
+
+  .sibu-loading-dots {
+    display: flex;
+    gap: 4px;
+  }
+
+  .sibu-loading-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background-color: #3b82f6;
+    animation: sibu-pulse 1.2s ease-in-out infinite;
+  }
+
+  .sibu-loading-dot:nth-child(2) { animation-delay: 0.2s; }
+  .sibu-loading-dot:nth-child(3) { animation-delay: 0.4s; }
+
+  .sibu-loading-text {
+    color: #6b7280;
+    font-size: 14px;
+  }
+
+  .sibu-loading-sm .sibu-loading-spinner { width: 16px; height: 16px; border-width: 2px; }
+  .sibu-loading-sm .sibu-loading-dot { width: 6px; height: 6px; }
+  .sibu-loading-lg .sibu-loading-spinner { width: 40px; height: 40px; border-width: 4px; }
+  .sibu-loading-lg .sibu-loading-dot { width: 12px; height: 12px; }
+  .sibu-loading-lg .sibu-loading-dots { gap: 6px; }
+`;
+var loadingStylesInjected = false;
+function injectLoadingStyles() {
+  if (!loadingStylesInjected && typeof document !== "undefined") {
+    document.head.appendChild(style({ nodes: loadingStyles }));
+    loadingStylesInjected = true;
+  }
+}
+function Loading(props = {}) {
+  injectLoadingStyles();
+  const { text: text2, variant = "spinner", size = "md" } = props;
+  const sizeClass = size !== "md" ? ` sibu-loading-${size}` : "";
+  if (variant === "dots") {
+    return div({
+      class: `sibu-loading${sizeClass}`,
+      nodes: [
+        div({
+          class: "sibu-loading-dots",
+          nodes: [
+            span({ class: "sibu-loading-dot" }),
+            span({ class: "sibu-loading-dot" }),
+            span({ class: "sibu-loading-dot" })
+          ]
+        }),
+        text2 ? span({ class: "sibu-loading-text", nodes: text2 }) : null
+      ].filter(Boolean)
+    });
+  }
+  return div({
+    class: `sibu-loading${sizeClass}`,
+    nodes: [
+      div({ class: "sibu-loading-spinner" }),
+      text2 ? span({ class: "sibu-loading-text", nodes: text2 }) : null
+    ].filter(Boolean)
+  });
+}
+
+export {
+  html,
+  mount,
+  each,
+  Fragment,
+  Portal,
+  registerComponent,
+  unregisterComponent,
+  resolveComponent,
+  DynamicComponent,
+  getSlot,
+  show,
+  when,
+  match,
+  KeepAlive,
+  action,
+  clickOutside,
+  longPress,
+  copyOnClick,
+  autoResize,
+  trapFocus,
+  catchError,
+  catchErrorAsync,
+  setGlobalErrorHandler,
+  store,
+  ref,
+  memo,
+  memoFn,
+  array,
+  reactiveArray,
+  deepEqual,
+  deepSignal,
+  writable,
+  asyncDerived,
+  onMount,
+  onUnmount,
+  onCleanup,
+  strict,
+  strictEffect,
+  nextTick,
+  defer,
+  transition,
+  lazy,
+  Suspense,
+  ErrorDisplay,
+  ErrorBoundary,
+  Loading,
+  index_exports
+};