sibujs 1.0.2 → 1.0.3

package/dist/chunk-K7BPE427.js

@@ -1,1432 +0,0 @@
-import {
-  useComputed,
-  useEffect
-} from "./chunk-6IWEHW57.js";
-import {
-  SVG_NS,
-  a,
-  abbr,
-  address,
-  area,
-  article,
-  aside,
-  audio,
-  b,
-  base,
-  batch,
-  bdi,
-  bdo,
-  bindDynamic,
-  blockquote,
-  body,
-  br,
-  button,
-  canvas,
-  caption,
-  center,
-  circle,
-  cite,
-  clipPath,
-  code,
-  col,
-  colgroup,
-  customElement,
-  data,
-  datalist,
-  dd,
-  defs,
-  del,
-  details,
-  dfn,
-  dialog,
-  dispose,
-  div,
-  dl,
-  dt,
-  ellipse,
-  em,
-  embed,
-  enqueueBatchedSignal,
-  fieldset,
-  figcaption,
-  figure,
-  font,
-  footer,
-  form,
-  g,
-  h1,
-  h2,
-  h3,
-  h4,
-  h5,
-  h6,
-  head,
-  header,
-  hr,
-  html,
-  i,
-  iframe,
-  img,
-  input,
-  ins,
-  isBatching,
-  kbd,
-  label,
-  legend,
-  li,
-  line,
-  linearGradient,
-  link,
-  main,
-  map,
-  mark,
-  marker,
-  marquee,
-  mask,
-  math,
-  menu,
-  meta,
-  meter,
-  nav,
-  noscript,
-  notifySubscribers,
-  object,
-  ol,
-  optgroup,
-  option,
-  output,
-  p,
-  param,
-  path,
-  pattern,
-  picture,
-  polygon,
-  polyline,
-  portal,
-  pre,
-  progress,
-  q,
-  radialGradient,
-  recordDependency,
-  rect,
-  registerDisposer,
-  rp,
-  rt,
-  ruby,
-  s,
-  samp,
-  script,
-  section,
-  select,
-  slot,
-  small,
-  source,
-  span,
-  stop,
-  strong,
-  style,
-  sub,
-  summary,
-  sup,
-  svg,
-  symbol,
-  table,
-  tagFactory,
-  tbody,
-  td,
-  template,
-  text,
-  textarea,
-  tfoot,
-  th,
-  thead,
-  time,
-  title,
-  tr,
-  track,
-  track2,
-  tspan,
-  u,
-  ul,
-  use,
-  useState,
-  var_,
-  video
-} from "./chunk-EJMYGAGQ.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,
-  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,
-  circle: () => circle,
-  cite: () => cite,
-  clipPath: () => clipPath,
-  code: () => code,
-  col: () => col,
-  colgroup: () => colgroup,
-  createContext: () => createContext,
-  customElement: () => customElement,
-  data: () => data,
-  datalist: () => datalist,
-  dd: () => dd,
-  defs: () => defs,
-  del: () => del,
-  details: () => details,
-  dfn: () => dfn,
-  dialog: () => dialog,
-  dispose: () => dispose,
-  div: () => div,
-  dl: () => dl,
-  dt: () => dt,
-  each: () => each,
-  ellipse: () => ellipse,
-  em: () => em,
-  embed: () => embed,
-  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,
-  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,
-  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,
-  rect: () => rect,
-  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,
-  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,
-  unregisterComponent: () => unregisterComponent,
-  use: () => use,
-  useArray: () => useArray,
-  useCallback: () => useCallback,
-  useComputed: () => useComputed,
-  useDeepState: () => useDeepState,
-  useEffect: () => useEffect,
-  useMemo: () => useMemo,
-  useReactiveArray: () => useReactiveArray,
-  useRef: () => useRef,
-  useState: () => useState,
-  useStore: () => useStore,
-  useWatch: () => useWatch,
-  var_: () => var_,
-  video: () => video,
-  when: () => when
-});
-
-// src/core/mount.ts
-function mount(component, container) {
-  if (!container) {
-    throw new Error("Mount target element not found.");
-  }
-  const node = typeof component === "function" ? component() : component;
-  container.appendChild(node);
-  return {
-    node,
-    unmount() {
-      dispose(node);
-      if (node.parentNode) {
-        node.parentNode.removeChild(node);
-      }
-    }
-  };
-}
-
-// src/core/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) {
-  if (arr.length === 0) return [];
-  const tails = [];
-  const predecessor = new Array(arr.length);
-  for (let i2 = 0; i2 < arr.length; 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;
-    if (lo > 0) {
-      predecessor[i2] = tails[lo - 1];
-    } else {
-      predecessor[i2] = -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) {
-  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 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]);
-    }
-    workMap.clear();
-    for (let i2 = 0; i2 < newLen; i2++) {
-      const key = newKeys[i2];
-      const existing = nodeMap.get(key);
-      if (existing !== void 0) {
-        workMap.set(key, existing);
-      } else {
-        workMap.set(key, resolveNodeChild(render(arr[i2], i2)));
-      }
-    }
-    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;
-    const oldKeyIndex = /* @__PURE__ */ new Map();
-    for (let i2 = 0; i2 < oldLen; i2++) {
-      oldKeyIndex.set(oldKeys[i2], i2);
-    }
-    const reusedNewIndices = [];
-    const reusedOldPositions = [];
-    for (let i2 = 0; i2 < newLen; i2++) {
-      const oldIdx = oldKeyIndex.get(newKeys[i2]);
-      if (oldIdx !== void 0) {
-        reusedNewIndices.push(i2);
-        reusedOldPositions.push(oldIdx);
-      }
-    }
-    const lisIndices = longestIncreasingSubsequence(reusedOldPositions);
-    const isStable = new Uint8Array(newLen);
-    for (let i2 = 0; i2 < lisIndices.length; i2++) {
-      isStable[reusedNewIndices[lisIndices[i2]]] = 1;
-    }
-    let nextRef = end;
-    for (let i2 = newLen - 1; i2 >= 0; i2--) {
-      const node = workMap.get(newKeys[i2]);
-      if (isStable[i2]) {
-        nextRef = node;
-      } else {
-        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/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/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/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" });
-  const [, _setVersion] = useState(0);
-  const render = () => {
-    const target = is();
-    let el;
-    if (typeof target === "function") {
-      el = target();
-    } else {
-      el = resolveComponent(target);
-    }
-    container.replaceChildren(el);
-  };
-  queueMicrotask(render);
-  return container;
-}
-
-// src/core/slots.ts
-function getSlot(slots, name = "default") {
-  return slots?.[name];
-}
-
-// src/core/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/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/useWatch.ts
-function useWatch(getter, callback) {
-  let oldValue = getter();
-  const subscriber = () => {
-    const newValue = getter();
-    if (newValue !== oldValue) {
-      callback(newValue, oldValue);
-      oldValue = newValue;
-    }
-  };
-  const teardown = track(subscriber);
-  return teardown;
-}
-
-// src/core/useStore.ts
-function useStore(initialState) {
-  const signals = {};
-  Object.keys(initialState).forEach((key) => {
-    const [getter, setter] = useState(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("Direct mutation of store is not allowed. Use actions.setState.");
-    }
-  });
-  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 useEffect(() => {
-      const snapshot = getSnapshot();
-      callback(snapshot);
-    });
-  };
-  const subscribeKey = (key, callback) => {
-    let prev = signals[key][0]();
-    return useEffect(() => {
-      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/useRef.ts
-function useRef(initial) {
-  return { current: initial };
-}
-
-// src/core/useMemo.ts
-function useMemo(factory) {
-  return useComputed(factory);
-}
-
-// src/core/useCallback.ts
-function useCallback(callback) {
-  return useComputed(callback);
-}
-
-// src/core/useArray.ts
-function useArray(initial = []) {
-  const [arr, setArr] = useState([...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 useReactiveArray(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 = {
-    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/useDeepState.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 useDeepState(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/lifecycle.ts
-function onMount(callback, element) {
-  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();
-    }, element);
-  }
-}
-
-// src/core/context.ts
-function createContext(defaultValue) {
-  const [getValue, setValue] = useState(defaultValue);
-  return {
-    provide(value) {
-      setValue(value);
-    },
-    use() {
-      return getValue;
-    },
-    get() {
-      return getValue();
-    },
-    set(value) {
-      setValue(value);
-    }
-  };
-}
-
-// src/core/lazy.ts
-function lazy(importFn) {
-  let cached = null;
-  return function LazyComponent() {
-    if (cached) {
-      return cached();
-    }
-    const [_status, setStatus] = useState("loading");
-    const [_error, setError] = useState(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 cache = fallbackCache.get(fallbackFn);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    fallbackCache.set(fallbackFn, cache);
-  }
-  const key = error.message;
-  if (!cache.has(key)) {
-    cache.set(key, fallbackFn(error, retry));
-  }
-  return cache.get(key);
-}
-function ErrorBoundary({ nodes, fallback, onError }) {
-  injectStyles();
-  const [error, setError] = useState(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));
-      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-lg .sibu-loading-spinner { width: 40px; height: 40px; border-width: 4px; }
-`;
-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 {
-  mount,
-  each,
-  Fragment,
-  Portal,
-  registerComponent,
-  unregisterComponent,
-  resolveComponent,
-  DynamicComponent,
-  getSlot,
-  show,
-  when,
-  match,
-  catchError,
-  catchErrorAsync,
-  setGlobalErrorHandler,
-  useWatch,
-  useStore,
-  useRef,
-  useMemo,
-  useCallback,
-  useArray,
-  useReactiveArray,
-  useDeepState,
-  onMount,
-  onUnmount,
-  createContext,
-  lazy,
-  Suspense,
-  ErrorBoundary,
-  Loading,
-  index_exports
-};