sibujs 1.0.0-beta.1

package/dist/chunk-TNNF56IQ.js

@@ -0,0 +1,1750 @@
+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-BPKPPSXC.js";
+import {
+  sbContext
+} from "./chunk-KL3266RS.js";
+import {
+  SVG_NS,
+  bindChildNode,
+  checkLeaks,
+  sbDispose,
+  sbRegisterDisposer,
+  tagFactory
+} from "./chunk-V6F7KUWD.js";
+import {
+  sbBindDynamic
+} from "./chunk-5NCPAWBE.js";
+import {
+  sbDerived
+} from "./chunk-A65GFJBL.js";
+import {
+  sbDisableSSR,
+  sbEffect,
+  sbEnableSSR,
+  sbIsSSR,
+  sbWithSSR
+} from "./chunk-CIF5Z3MP.js";
+import {
+  devAssert
+} from "./chunk-MJNB47HB.js";
+import {
+  enqueueBatchedSignal,
+  isBatching,
+  notifySubscribers,
+  recordDependency,
+  sbBatch,
+  sbSignal,
+  track
+} from "./chunk-GBEYQRO2.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  SVG_NS: () => SVG_NS,
+  a: () => a,
+  abbr: () => abbr,
+  address: () => address,
+  area: () => area,
+  article: () => article,
+  aside: () => aside,
+  audio: () => audio,
+  b: () => b,
+  base: () => base,
+  bdi: () => bdi,
+  bdo: () => bdo,
+  blockquote: () => blockquote,
+  body: () => body,
+  br: () => br,
+  button: () => button,
+  canvas: () => canvas,
+  caption: () => caption,
+  center: () => center,
+  checkLeaks: () => checkLeaks,
+  circle: () => circle,
+  cite: () => cite,
+  clipPath: () => clipPath,
+  code: () => code,
+  col: () => col,
+  colgroup: () => colgroup,
+  customElement: () => customElement,
+  data: () => data,
+  datalist: () => datalist,
+  dd: () => dd,
+  defs: () => defs,
+  del: () => del,
+  details: () => details,
+  dfn: () => dfn,
+  dialog: () => dialog,
+  div: () => div,
+  dl: () => dl,
+  dt: () => dt,
+  ellipse: () => ellipse,
+  em: () => em,
+  embed: () => embed,
+  enqueueBatchedSignal: () => enqueueBatchedSignal,
+  fieldset: () => fieldset,
+  figcaption: () => figcaption,
+  figure: () => figure,
+  font: () => font,
+  footer: () => footer,
+  form: () => form,
+  g: () => g,
+  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,
+  kbd: () => kbd,
+  label: () => label,
+  legend: () => legend,
+  li: () => li,
+  line: () => line,
+  linearGradient: () => linearGradient,
+  link: () => link,
+  main: () => main,
+  map: () => map,
+  mark: () => mark,
+  marker: () => marker,
+  marquee: () => marquee,
+  mask: () => mask,
+  math: () => math,
+  menu: () => menu,
+  meta: () => meta,
+  meter: () => meter,
+  nav: () => nav,
+  noscript: () => noscript,
+  object: () => object,
+  ol: () => ol,
+  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,
+  rect: () => rect,
+  rp: () => rp,
+  rt: () => rt,
+  ruby: () => ruby,
+  s: () => s,
+  samp: () => samp,
+  sbArray: () => sbArray,
+  sbBatch: () => sbBatch,
+  sbBindDynamic: () => sbBindDynamic,
+  sbCatchError: () => sbCatchError,
+  sbCatchErrorAsync: () => sbCatchErrorAsync,
+  sbContext: () => sbContext,
+  sbDeepSignal: () => sbDeepSignal,
+  sbDerived: () => sbDerived,
+  sbDisableSSR: () => sbDisableSSR,
+  sbDispose: () => sbDispose,
+  sbDynamicComponent: () => sbDynamicComponent,
+  sbEach: () => sbEach,
+  sbEffect: () => sbEffect,
+  sbEnableSSR: () => sbEnableSSR,
+  sbErrorBoundary: () => sbErrorBoundary,
+  sbFragment: () => sbFragment,
+  sbGetSlot: () => sbGetSlot,
+  sbIsSSR: () => sbIsSSR,
+  sbLazy: () => sbLazy,
+  sbLoading: () => sbLoading,
+  sbMatch: () => sbMatch,
+  sbMemo: () => sbMemo,
+  sbMemoFn: () => sbMemoFn,
+  sbMount: () => sbMount,
+  sbOnMount: () => sbOnMount,
+  sbOnUnmount: () => sbOnUnmount,
+  sbPortal: () => sbPortal,
+  sbReactiveArray: () => sbReactiveArray,
+  sbRef: () => sbRef,
+  sbRegisterComponent: () => sbRegisterComponent,
+  sbRegisterDisposer: () => sbRegisterDisposer,
+  sbResolveComponent: () => sbResolveComponent,
+  sbSetGlobalErrorHandler: () => sbSetGlobalErrorHandler,
+  sbShow: () => sbShow,
+  sbSignal: () => sbSignal,
+  sbStore: () => sbStore,
+  sbSuspense: () => sbSuspense,
+  sbUnregisterComponent: () => sbUnregisterComponent,
+  sbWatch: () => sbWatch,
+  sbWhen: () => sbWhen,
+  sbWithSSR: () => sbWithSSR,
+  script: () => script,
+  section: () => section,
+  select: () => select,
+  slot: () => slot,
+  small: () => small,
+  source: () => source,
+  span: () => span,
+  stop: () => stop,
+  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,
+  use: () => use,
+  var_: () => var_,
+  video: () => video
+});
+
+// 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[pos] !== "\0") return -1;
+    const start = pos;
+    pos++;
+    let idxStr = "";
+    while (pos < len && template2[pos] !== "\0") idxStr += template2[pos++];
+    if (pos < len) pos++;
+    const idx = Number.parseInt(idxStr, 10);
+    if (Number.isNaN(idx) || idx < 0 || idx >= exprCount) {
+      pos = start;
+      return -1;
+    }
+    return idx;
+  }
+  function readTagName() {
+    let name = "";
+    while (pos < len && /[a-zA-Z0-9\-]/.test(template2[pos])) name += template2[pos++];
+    return name;
+  }
+  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 };
+    }
+    let val = "";
+    while (pos < len && !/[\s>\/]/.test(template2[pos])) val += template2[pos++];
+    return { kind: "static", value: val };
+  }
+  function parseAttrs() {
+    const attrs = [];
+    while (pos < len) {
+      skipWs();
+      if (template2[pos] === ">" || template2[pos] === "/") break;
+      let attrName = "";
+      while (pos < len && /[a-zA-Z0-9\-:_.]/.test(template2[pos])) attrName += template2[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();
+}
+var factoryCache = /* @__PURE__ */ new Map();
+function getFactory(tag, svg2) {
+  const key = svg2 ? `svg:${tag}` : tag;
+  let f = factoryCache.get(key);
+  if (!f) {
+    f = tagFactory(tag, svg2 ? SVG_NS : void 0);
+    factoryCache.set(key, f);
+  }
+  return f;
+}
+function executeElement(tmpl, values) {
+  const props = {};
+  const events = {};
+  let hasEvents = false;
+  for (let i2 = 0; i2 < tmpl.attrs.length; i2++) {
+    const attr = tmpl.attrs[i2];
+    switch (attr.t) {
+      case 0:
+        props[attr.name] = attr.value;
+        break;
+      case 1:
+        props[attr.name] = values[attr.idx];
+        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];
+        }
+        props[attr.name] = val;
+        break;
+      }
+      case 3:
+        events[attr.name] = values[attr.idx];
+        hasEvents = true;
+        break;
+      case 4:
+        props[attr.name] = true;
+        break;
+    }
+  }
+  if (hasEvents) props.on = events;
+  if (tmpl.children.length > 0) {
+    const nodes = executeChildList(tmpl.children, values);
+    props.nodes = nodes.length === 1 ? nodes[0] : nodes;
+  }
+  return getFactory(tmpl.tag, tmpl.svg)(props);
+}
+function executeChildList(children, values) {
+  const nodes = [];
+  for (let i2 = 0; i2 < children.length; i2++) {
+    const child = children[i2];
+    switch (child.t) {
+      case 0:
+        nodes.push(executeElement(child.el, values));
+        break;
+      case 1:
+        nodes.push(child.value);
+        break;
+      case 2:
+        nodes.push(values[child.idx]);
+        break;
+    }
+  }
+  return nodes;
+}
+function html(strings, ...values) {
+  let tmpl = cache.get(strings);
+  if (!tmpl) {
+    tmpl = parseTemplate(strings);
+    cache.set(strings, tmpl);
+  }
+  const result = executeChildList(tmpl, values);
+  if (result.length === 1 && result[0] instanceof Node) {
+    return result[0];
+  }
+  const wrapper = document.createElement("div");
+  for (const node of result) {
+    if (node instanceof Node) {
+      wrapper.appendChild(node);
+    } else if (typeof node === "function") {
+      const placeholder = document.createComment("bind:htm");
+      wrapper.appendChild(placeholder);
+      const teardown = bindChildNode(placeholder, node);
+      sbRegisterDisposer(wrapper, teardown);
+    } else if (node != null) {
+      wrapper.appendChild(document.createTextNode(String(node)));
+    }
+  }
+  return wrapper;
+}
+
+// src/core/rendering/mount.ts
+function sbMount(component, container) {
+  if (!container) {
+    throw new Error("[Sibu] sbMount: container element not found. Make sure the DOM element exists before calling sbMount().");
+  }
+  devAssert(
+    typeof component === "function" || component instanceof Node,
+    "sbMount: 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 });
+      sbDispose(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 sbEach(getArray, render, options) {
+  devAssert(typeof getArray === "function", "sbEach: first argument must be a function that returns an array.");
+  devAssert(typeof render === "function", "sbEach: second argument must be a render function.");
+  devAssert(options && typeof options.key === "function", "sbEach: 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");
+  let oldKeys = [];
+  let nodeMap = /* @__PURE__ */ new Map();
+  let workMap = /* @__PURE__ */ new Map();
+  let newNodes = [];
+  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;
+    }
+    const newKeys = new Array(newLen);
+    for (let i2 = 0; i2 < newLen; i2++) {
+      newKeys[i2] = keyFn(arr[i2]);
+    }
+    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) {
+      oldKeys = newKeys;
+      const tmp2 = nodeMap;
+      nodeMap = workMap;
+      workMap = tmp2;
+      return;
+    }
+    const oldLen = oldKeys.length;
+    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);
+    const isStable = new Uint8Array(newLen);
+    for (let i2 = 0; i2 < lisIndices.length; i2++) {
+      isStable[reusedNewBuf[lisIndices[i2]]] = 1;
+    }
+    let nextRef = end;
+    for (let i2 = newLen - 1; i2 >= 0; i2--) {
+      const node = newNodes[i2];
+      if (isStable[i2]) {
+        nextRef = node;
+      } else {
+        if (node.nextSibling !== nextRef) {
+          parent.insertBefore(node, nextRef);
+        }
+        nextRef = node;
+      }
+    }
+    oldKeys = newKeys;
+    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 sbFragment(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 sbPortal(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 sbRegisterComponent(name, component) {
+  componentRegistry.set(name, component);
+}
+function sbUnregisterComponent(name) {
+  componentRegistry.delete(name);
+}
+function sbResolveComponent(name) {
+  const component = componentRegistry.get(name);
+  if (component) {
+    return component();
+  }
+  return div({ nodes: `[Component "${name}" not found]` });
+}
+function sbDynamicComponent(is) {
+  const container = div({ class: "sibu-dynamic" });
+  function render() {
+    const target = is();
+    let el;
+    if (typeof target === "function") {
+      el = target();
+    } else {
+      el = sbResolveComponent(target);
+    }
+    container.replaceChildren(el);
+  }
+  track(render);
+  return container;
+}
+
+// src/core/rendering/slots.ts
+function sbGetSlot(slots, name = "default") {
+  return slots?.[name];
+}
+
+// src/core/rendering/directives.ts
+function sbShow(condition, element) {
+  const update = () => {
+    element.style.display = condition() ? "" : "none";
+  };
+  track(update);
+  return element;
+}
+function sbWhen(condition, thenBranch, elseBranch) {
+  const anchor = document.createComment("when");
+  let currentNode = null;
+  let initialized = false;
+  const update = () => {
+    const show = condition();
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (currentNode?.parentNode) {
+      currentNode.parentNode.removeChild(currentNode);
+      currentNode = null;
+    }
+    const result = show ? 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 sbMatch(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 sbCatchError(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.sbCatchError:", err);
+        }
+      });
+    }
+    return result;
+  } catch (err) {
+    if (onError) {
+      onError(err, "sync");
+    } else if (globalErrorHandler) {
+      globalErrorHandler(err, "sync");
+    } else {
+      console.error("Unhandled error in Sibu.sbCatchError:", err);
+    }
+    return null;
+  }
+}
+async function sbCatchErrorAsync(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.sbCatchErrorAsync:", err);
+    }
+    return null;
+  }
+}
+function sbSetGlobalErrorHandler(handler) {
+  globalErrorHandler = handler;
+}
+
+// src/core/signals/sbWatch.ts
+function sbWatch(getter, callback) {
+  devAssert(typeof getter === "function", "sbWatch: first argument must be a getter function.");
+  devAssert(typeof callback === "function", "sbWatch: second argument must be a callback function.");
+  if (sbIsSSR()) 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/sbStore.ts
+function sbStore(initialState) {
+  devAssert(
+    initialState !== null && typeof initialState === "object" && !Array.isArray(initialState),
+    "sbStore: argument must be a plain object. For arrays, use sbArray() instead."
+  );
+  const signals = {};
+  Object.keys(initialState).forEach((key) => {
+    const [getter, setter] = sbSignal(initialState[key]);
+    signals[key] = [getter, setter];
+  });
+  const store = new Proxy({}, {
+    get(_, prop) {
+      if (prop in signals) {
+        const getter = signals[prop][0];
+        return getter();
+      }
+      return void 0;
+    },
+    set() {
+      throw new Error("[Sibu] sbStore: 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 sbEffect(() => {
+      const snapshot = getSnapshot();
+      callback(snapshot);
+    });
+  };
+  const subscribeKey = (key, callback) => {
+    let prev = signals[key][0]();
+    return sbEffect(() => {
+      const current = signals[key][0]();
+      if (!Object.is(current, prev)) {
+        const oldPrev = prev;
+        prev = current;
+        callback(current, oldPrev);
+      }
+    });
+  };
+  return [store, { setState, reset, subscribe, subscribeKey, getSnapshot }];
+}
+
+// src/core/signals/sbRef.ts
+function sbRef(initial) {
+  return { current: initial };
+}
+
+// src/core/signals/sbMemo.ts
+function sbMemo(factory) {
+  return sbDerived(factory);
+}
+
+// src/core/signals/sbMemoFn.ts
+function sbMemoFn(callback) {
+  return sbDerived(callback);
+}
+
+// src/core/signals/sbArray.ts
+function sbArray(initial = []) {
+  const [arr, setArr] = sbSignal([...initial]);
+  const actions = {
+    sbPush(...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 sbReactiveArray(initial = []) {
+  let data2 = [...initial];
+  let snapshot = null;
+  const signal = {};
+  function notify() {
+    snapshot = null;
+    if (!enqueueBatchedSignal(signal)) {
+      notifySubscribers(signal);
+    }
+  }
+  function get() {
+    recordDependency(signal);
+    if (snapshot === null) {
+      snapshot = Object.freeze([...data2]);
+    }
+    return snapshot;
+  }
+  const actions = {
+    sbPush(...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/sbDeepSignal.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 sbDeepSignal(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 sbOnMount(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 sbOnUnmount(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 {
+    sbOnMount(() => {
+      startObserving();
+      return void 0;
+    }, element);
+  }
+}
+
+// src/core/rendering/lazy.ts
+function sbLazy(importFn) {
+  let cached = null;
+  return function LazyComponent() {
+    if (cached) {
+      return cached();
+    }
+    const [_status, setStatus] = sbSignal("loading");
+    const [_error, setError] = sbSignal(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 sbSuspense({ 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 sbErrorBoundary({ nodes, fallback, onError }) {
+  injectStyles();
+  const [error, setError] = sbSignal(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 sbLoading(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,
+  sbMount,
+  sbEach,
+  sbFragment,
+  sbPortal,
+  sbRegisterComponent,
+  sbUnregisterComponent,
+  sbResolveComponent,
+  sbDynamicComponent,
+  sbGetSlot,
+  sbShow,
+  sbWhen,
+  sbMatch,
+  sbCatchError,
+  sbCatchErrorAsync,
+  sbSetGlobalErrorHandler,
+  sbWatch,
+  sbStore,
+  sbRef,
+  sbMemo,
+  sbMemoFn,
+  sbArray,
+  sbReactiveArray,
+  sbDeepSignal,
+  sbOnMount,
+  sbOnUnmount,
+  sbLazy,
+  sbSuspense,
+  sbErrorBoundary,
+  sbLoading,
+  index_exports
+};