sibujs 1.0.2 → 1.0.3

package/dist/chunk-QJ5KLY2S.js

@@ -1,1821 +0,0 @@
-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-6SNF5MZK.js";
-import {
-  context
-} from "./chunk-QQS7BSPA.js";
-import {
-  SVG_NS,
-  bindChildNode,
-  checkLeaks,
-  dispose,
-  registerDisposer,
-  tagFactory
-} from "./chunk-VI4KRBSU.js";
-import {
-  bindAttribute,
-  bindDynamic,
-  isUrlAttribute,
-  sanitizeUrl
-} from "./chunk-DKGHW6MX.js";
-import {
-  derived
-} from "./chunk-EQACK65C.js";
-import {
-  disableSSR,
-  effect,
-  enableSSR,
-  isSSR,
-  withSSR
-} from "./chunk-G4AX3DQ4.js";
-import {
-  batch,
-  devAssert,
-  enqueueBatchedSignal,
-  isBatching,
-  notifySubscribers,
-  recordDependency,
-  signal,
-  track
-} from "./chunk-ONOO74UN.js";
-import {
-  __export
-} from "./chunk-MLKGABMK.js";
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  DynamicComponent: () => DynamicComponent,
-  ErrorBoundary: () => ErrorBoundary,
-  Fragment: () => Fragment,
-  Loading: () => Loading,
-  Portal: () => Portal,
-  SVG_NS: () => SVG_NS,
-  Suspense: () => Suspense,
-  a: () => a,
-  abbr: () => abbr,
-  address: () => address,
-  area: () => area,
-  array: () => array,
-  article: () => article,
-  aside: () => aside,
-  audio: () => audio,
-  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,
-  clipPath: () => clipPath,
-  code: () => code,
-  col: () => col,
-  colgroup: () => colgroup,
-  context: () => context,
-  customElement: () => customElement,
-  data: () => data,
-  datalist: () => datalist,
-  dd: () => dd,
-  deepSignal: () => deepSignal,
-  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,
-  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,
-  noscript: () => noscript,
-  object: () => object,
-  ol: () => ol,
-  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,
-  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,
-  tspan: () => tspan,
-  u: () => u,
-  ul: () => ul,
-  unregisterComponent: () => unregisterComponent,
-  use: () => use,
-  var_: () => var_,
-  video: () => video,
-  watch: () => watch,
-  when: () => when,
-  withSSR: () => withSSR
-});
-
-// 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) {
-              el.appendChild(document.createTextNode(String(item)));
-            }
-          }
-        } else if (val != null) {
-          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) {
-              wrapper.appendChild(document.createTextNode(String(item)));
-            }
-          }
-        } else if (val != null) {
-          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
-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 = [];
-  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();
-    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 {
-        node = resolveNodeChild(render(arr[i2], i2));
-      }
-      workMap.set(key, node);
-      newNodes[i2] = node;
-    }
-    for (const [key, node] of nodeMap) {
-      if (!workMap.has(key) && 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) continue;
-    if (Array.isArray(child)) {
-      for (const nested of child) {
-        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);
-    }
-    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 initialized = false;
-  const update = () => {
-    const show2 = condition();
-    const parent = anchor.parentNode;
-    if (!parent) return;
-    if (currentNode?.parentNode) {
-      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 initialized = false;
-  const update = () => {
-    const key = String(value());
-    const parent = anchor.parentNode;
-    if (!parent) return;
-    if (currentNode?.parentNode) {
-      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/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/watch.ts
-function watch(getter, callback) {
-  devAssert(typeof getter === "function", "watch: first argument must be a getter function.");
-  devAssert(typeof callback === "function", "watch: second argument must be a callback function.");
-  if (isSSR()) return () => {
-  };
-  let oldValue = getter();
-  const subscriber = () => {
-    const newValue = getter();
-    if (!Object.is(newValue, oldValue)) {
-      callback(newValue, oldValue);
-      oldValue = newValue;
-    }
-  };
-  const teardown = track(subscriber);
-  return teardown;
-}
-
-// 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) => {
-    return effect(() => {
-      const snapshot = getSnapshot();
-      callback(snapshot);
-    });
-  };
-  const subscribeKey = (key, callback) => {
-    let prev = signals[key][0]();
-    return effect(() => {
-      const current = signals[key][0]();
-      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) {
-  return { current: initial };
-}
-
-// 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) {
-  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 (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]));
-  }
-  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]));
-}
-function deepSignal(initial) {
-  const state = { value: initial };
-  function get() {
-    recordDependency(state);
-    return state.value;
-  }
-  function set(next) {
-    const newValue = typeof next === "function" ? next(state.value) : next;
-    if (deepEqual(newValue, state.value)) return;
-    state.value = newValue;
-    if (!enqueueBatchedSignal(state)) {
-      notifySubscribers(state);
-    }
-  }
-  return [get, set];
-}
-
-// src/core/rendering/lifecycle.ts
-function onMount(callback, element) {
-  if (typeof document === "undefined") return;
-  if (element) {
-    if (element.isConnected) {
-      queueMicrotask(() => {
-        callback();
-      });
-      return;
-    }
-    const observer = new MutationObserver(() => {
-      if (element.isConnected) {
-        observer.disconnect();
-        callback();
-      }
-    });
-    queueMicrotask(() => {
-      if (element.isConnected) {
-        callback();
-      } else {
-        observer.observe(document.body, { childList: true, subtree: true });
-      }
-    });
-  } else {
-    queueMicrotask(() => {
-      callback();
-    });
-  }
-}
-function onUnmount(callback, element) {
-  const startObserving = () => {
-    const observer = new MutationObserver(() => {
-      if (!element.isConnected) {
-        observer.disconnect();
-        callback();
-      }
-    });
-    observer.observe(document.body, { childList: true, subtree: true });
-  };
-  if (element.isConnected) {
-    startObserving();
-  } else {
-    onMount(() => {
-      startObserving();
-      return void 0;
-    }, element);
-  }
-}
-
-// 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/ErrorBoundary.ts
-var errorBoundaryStyles = `
-  .sibu-error-boundary {
-    position: relative;
-  }
-
-  .sibu-error-fallback {
-    border: 2px solid #dc3545;
-    border-radius: 8px;
-    padding: 20px;
-    margin: 10px 0;
-    background: linear-gradient(135deg, #fff5f5 0%, #ffebee 100%);
-    box-shadow: 0 2px 12px rgba(220, 53, 69, 0.15);
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-  }
-
-  .sibu-error-fallback .sibu-error-title {
-    margin: 0 0 12px 0;
-    color: #dc3545;
-    font-size: 1.1em;
-    font-weight: 600;
-  }
-
-  .sibu-error-fallback .sibu-error-message {
-    font-family: 'SF Mono', 'Fira Code', 'Roboto Mono', monospace;
-    background-color: rgba(0, 0, 0, 0.04);
-    padding: 10px 14px;
-    border-radius: 6px;
-    border: 1px solid rgba(0, 0, 0, 0.08);
-    margin: 10px 0;
-    color: #495057;
-    word-break: break-word;
-    font-size: 0.9em;
-    line-height: 1.5;
-  }
-
-  .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: 14px;
-    font-weight: 500;
-    transition: all 0.2s ease;
-    margin-top: 8px;
-    background-color: #dc3545;
-    color: white;
-  }
-
-  .sibu-error-fallback .sibu-error-btn:hover {
-    background-color: #c82333;
-    transform: translateY(-1px);
-    box-shadow: 0 2px 8px rgba(220, 53, 69, 0.3);
-  }
-
-  .sibu-error-fallback .sibu-error-btn:active {
-    transform: translateY(0);
-  }
-`;
-var stylesInjected = false;
-function injectStyles() {
-  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 }) {
-  injectStyles();
-  const [error, setError] = signal(null);
-  const retry = () => {
-    if (fallback) {
-      fallbackCache.delete(fallback);
-    }
-    setError(null);
-  };
-  const handleError = (e) => {
-    const errorObj = e instanceof Error ? e : new Error(String(e));
-    setError(errorObj);
-    onError?.(errorObj);
-    return errorObj;
-  };
-  const defaultFallback = (err, retryFn) => div({
-    class: "sibu-error-fallback",
-    nodes: [
-      h3({
-        nodes: "Something went wrong",
-        class: "sibu-error-title"
-      }),
-      p({
-        nodes: err.message,
-        class: "sibu-error-message"
-      }),
-      button({
-        nodes: "Retry",
-        class: "sibu-error-btn",
-        on: { click: 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,
-  catchError,
-  catchErrorAsync,
-  setGlobalErrorHandler,
-  watch,
-  store,
-  ref,
-  memo,
-  memoFn,
-  array,
-  reactiveArray,
-  deepSignal,
-  onMount,
-  onUnmount,
-  lazy,
-  Suspense,
-  ErrorBoundary,
-  Loading,
-  index_exports
-};