sibujs 1.2.0 → 1.3.0

package/dist/chunk-3AIRKM3B.js

@@ -0,0 +1,1263 @@
+import {
+  effect
+} from "./chunk-CHF5OHIA.js";
+import {
+  batch,
+  signal
+} from "./chunk-WZSPOOER.js";
+
+// src/browser/media.ts
+function media(query) {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    const [matches2] = signal(false);
+    return { matches: matches2, dispose: () => {
+    } };
+  }
+  const mql = window.matchMedia(query);
+  const [matches, setMatches] = signal(mql.matches);
+  const handler = (event) => {
+    setMatches(event.matches);
+  };
+  mql.addEventListener("change", handler);
+  function dispose() {
+    mql.removeEventListener("change", handler);
+  }
+  return { matches, dispose };
+}
+
+// src/browser/resize.ts
+function resolveTarget(target) {
+  return typeof target === "function" ? target : () => target.current;
+}
+function resize(target) {
+  const [width, setWidth] = signal(0);
+  const [height, setHeight] = signal(0);
+  let observer = null;
+  if (typeof window === "undefined" || typeof ResizeObserver === "undefined") {
+    return { width, height, dispose: () => {
+    } };
+  }
+  const getter = resolveTarget(target);
+  const cleanup = effect(() => {
+    const el = getter();
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+    if (!el) return;
+    observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry) {
+        batch(() => {
+          setWidth(entry.contentRect.width);
+          setHeight(entry.contentRect.height);
+        });
+      }
+    });
+    observer.observe(el);
+  });
+  function dispose() {
+    cleanup();
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  }
+  return { width, height, dispose };
+}
+
+// src/browser/scroll.ts
+function scroll(target) {
+  const [x, setX] = signal(0);
+  const [y, setY] = signal(0);
+  const [isScrolling, setIsScrolling] = signal(false);
+  let scrollTimer = null;
+  if (typeof window === "undefined") {
+    return { x, y, isScrolling, dispose: () => {
+    } };
+  }
+  const handler = () => {
+    const el = target ? target() : null;
+    batch(() => {
+      if (el) {
+        setX(el.scrollLeft);
+        setY(el.scrollTop);
+      } else {
+        setX(window.scrollX ?? window.pageXOffset ?? 0);
+        setY(window.scrollY ?? window.pageYOffset ?? 0);
+      }
+      setIsScrolling(true);
+    });
+    if (scrollTimer !== null) clearTimeout(scrollTimer);
+    scrollTimer = setTimeout(() => {
+      setIsScrolling(false);
+      scrollTimer = null;
+    }, 150);
+  };
+  const scrollTarget = target ? target() : null;
+  const eventTarget = scrollTarget || window;
+  eventTarget.addEventListener("scroll", handler, { passive: true });
+  function dispose() {
+    eventTarget.removeEventListener("scroll", handler);
+    if (scrollTimer !== null) {
+      clearTimeout(scrollTimer);
+      scrollTimer = null;
+    }
+  }
+  return { x, y, isScrolling, dispose };
+}
+
+// src/browser/online.ts
+function online() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    const [online3] = signal(true);
+    return { online: online3, dispose: () => {
+    } };
+  }
+  const [online2, setOnline] = signal(navigator.onLine);
+  const onOnline = () => setOnline(true);
+  const onOffline = () => setOnline(false);
+  window.addEventListener("online", onOnline);
+  window.addEventListener("offline", onOffline);
+  function dispose() {
+    window.removeEventListener("online", onOnline);
+    window.removeEventListener("offline", onOffline);
+  }
+  return { online: online2, dispose };
+}
+
+// src/browser/geo.ts
+function geo(options) {
+  const [latitude, setLatitude] = signal(null);
+  const [longitude, setLongitude] = signal(null);
+  const [accuracy, setAccuracy] = signal(null);
+  const [error, setError] = signal(null);
+  let watchId = null;
+  if (typeof navigator !== "undefined" && navigator.geolocation) {
+    watchId = navigator.geolocation.watchPosition(
+      (position) => {
+        batch(() => {
+          setLatitude(position.coords.latitude);
+          setLongitude(position.coords.longitude);
+          setAccuracy(position.coords.accuracy);
+          setError(null);
+        });
+      },
+      (err) => {
+        setError(err);
+      },
+      options
+    );
+  }
+  function dispose() {
+    if (watchId !== null && typeof navigator !== "undefined" && navigator.geolocation) {
+      navigator.geolocation.clearWatch(watchId);
+      watchId = null;
+    }
+  }
+  return { latitude, longitude, accuracy, error, dispose };
+}
+
+// src/browser/battery.ts
+function battery() {
+  const [level, setLevel] = signal(null);
+  const [charging, setCharging] = signal(null);
+  const [chargingTime, setChargingTime] = signal(null);
+  const [dischargingTime, setDischargingTime] = signal(null);
+  const [supported, setSupported] = signal(false);
+  let battery2 = null;
+  let onLevelChange = null;
+  let onChargingChange = null;
+  let onChargingTimeChange = null;
+  let onDischargingTimeChange = null;
+  let disposed = false;
+  if (typeof navigator !== "undefined" && "getBattery" in navigator) {
+    setSupported(true);
+    navigator.getBattery().then((bm) => {
+      if (disposed) return;
+      battery2 = bm;
+      batch(() => {
+        setLevel(bm.level);
+        setCharging(bm.charging);
+        setChargingTime(bm.chargingTime);
+        setDischargingTime(bm.dischargingTime);
+      });
+      onLevelChange = () => setLevel(bm.level);
+      onChargingChange = () => setCharging(bm.charging);
+      onChargingTimeChange = () => setChargingTime(bm.chargingTime);
+      onDischargingTimeChange = () => setDischargingTime(bm.dischargingTime);
+      bm.addEventListener("levelchange", onLevelChange);
+      bm.addEventListener("chargingchange", onChargingChange);
+      bm.addEventListener("chargingtimechange", onChargingTimeChange);
+      bm.addEventListener("dischargingtimechange", onDischargingTimeChange);
+    });
+  }
+  function dispose() {
+    disposed = true;
+    if (battery2) {
+      if (onLevelChange) battery2.removeEventListener("levelchange", onLevelChange);
+      if (onChargingChange) battery2.removeEventListener("chargingchange", onChargingChange);
+      if (onChargingTimeChange) battery2.removeEventListener("chargingtimechange", onChargingTimeChange);
+      if (onDischargingTimeChange) battery2.removeEventListener("dischargingtimechange", onDischargingTimeChange);
+      battery2 = null;
+    }
+  }
+  return { level, charging, chargingTime, dischargingTime, supported, dispose };
+}
+
+// src/browser/idle.ts
+var ACTIVITY_EVENTS = ["mousemove", "mousedown", "keydown", "touchstart", "scroll"];
+function idle(timeout = 6e4) {
+  const [idle2, setIdle] = signal(false);
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return { idle: idle2, dispose: () => {
+    } };
+  }
+  let timer = null;
+  function resetTimer() {
+    setIdle(false);
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      setIdle(true);
+    }, timeout);
+  }
+  for (const event of ACTIVITY_EVENTS) {
+    document.addEventListener(event, resetTimer, { passive: true });
+  }
+  resetTimer();
+  function dispose() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    for (const event of ACTIVITY_EVENTS) {
+      document.removeEventListener(event, resetTimer);
+    }
+  }
+  return { idle: idle2, dispose };
+}
+
+// src/browser/permissions.ts
+function permissions(name) {
+  const [state, setState] = signal("prompt");
+  let permissionStatus = null;
+  let onChange = null;
+  let disposed = false;
+  if (typeof navigator === "undefined" || !navigator.permissions) {
+    setState("unsupported");
+    return { state, dispose: () => {
+    } };
+  }
+  navigator.permissions.query({ name }).then((status) => {
+    if (disposed) return;
+    permissionStatus = status;
+    setState(status.state);
+    onChange = () => {
+      setState(status.state);
+    };
+    status.addEventListener("change", onChange);
+  }).catch(() => {
+    setState("unsupported");
+  });
+  function dispose() {
+    disposed = true;
+    if (permissionStatus && onChange) {
+      permissionStatus.removeEventListener("change", onChange);
+      permissionStatus = null;
+      onChange = null;
+    }
+  }
+  return { state, dispose };
+}
+
+// src/browser/clipboard.ts
+function clipboard() {
+  const [text, setText] = signal("");
+  const [copied, setCopied] = signal(false);
+  let copiedTimer = null;
+  async function copy(value) {
+    if (typeof navigator === "undefined" || !navigator.clipboard) {
+      return;
+    }
+    await navigator.clipboard.writeText(value);
+    setText(value);
+    setCopied(true);
+    if (copiedTimer !== null) clearTimeout(copiedTimer);
+    copiedTimer = setTimeout(() => {
+      setCopied(false);
+      copiedTimer = null;
+    }, 2e3);
+  }
+  function dispose() {
+    if (copiedTimer !== null) {
+      clearTimeout(copiedTimer);
+      copiedTimer = null;
+    }
+  }
+  return { text, copy, copied, dispose };
+}
+
+// src/browser/dragDrop.ts
+function resolveTarget2(target) {
+  return typeof target === "function" ? target : () => target.current;
+}
+function draggable(element, data) {
+  const [isDragging, setIsDragging] = signal(false);
+  if (typeof window === "undefined") {
+    return { isDragging, dispose: () => {
+    } };
+  }
+  let currentEl = null;
+  let onDragStart = null;
+  let onDragEnd = null;
+  const getter = resolveTarget2(element);
+  const cleanup = effect(() => {
+    if (currentEl && onDragStart && onDragEnd) {
+      currentEl.removeEventListener("dragstart", onDragStart);
+      currentEl.removeEventListener("dragend", onDragEnd);
+    }
+    const el = getter();
+    currentEl = el;
+    if (!el) return;
+    el.draggable = true;
+    onDragStart = (e) => {
+      setIsDragging(true);
+      if (e.dataTransfer && data !== void 0) {
+        e.dataTransfer.setData("application/json", JSON.stringify(data));
+      }
+    };
+    onDragEnd = () => {
+      setIsDragging(false);
+    };
+    el.addEventListener("dragstart", onDragStart);
+    el.addEventListener("dragend", onDragEnd);
+  });
+  function dispose() {
+    cleanup();
+    if (currentEl && onDragStart && onDragEnd) {
+      currentEl.removeEventListener("dragstart", onDragStart);
+      currentEl.removeEventListener("dragend", onDragEnd);
+      currentEl = null;
+    }
+  }
+  return { isDragging, dispose };
+}
+function dropZone(element, options) {
+  const [isOver, setIsOver] = signal(false);
+  if (typeof window === "undefined") {
+    return { isOver, dispose: () => {
+    } };
+  }
+  let currentEl = null;
+  let onDragOver = null;
+  let onDragEnter = null;
+  let onDragLeave = null;
+  let onDrop = null;
+  const getter = resolveTarget2(element);
+  const cleanup = effect(() => {
+    if (currentEl && onDragOver && onDragEnter && onDragLeave && onDrop) {
+      currentEl.removeEventListener("dragover", onDragOver);
+      currentEl.removeEventListener("dragenter", onDragEnter);
+      currentEl.removeEventListener("dragleave", onDragLeave);
+      currentEl.removeEventListener("drop", onDrop);
+    }
+    const el = getter();
+    currentEl = el;
+    if (!el) return;
+    onDragOver = (e) => {
+      e.preventDefault();
+    };
+    onDragEnter = (e) => {
+      e.preventDefault();
+      setIsOver(true);
+    };
+    onDragLeave = () => {
+      setIsOver(false);
+    };
+    onDrop = (e) => {
+      e.preventDefault();
+      setIsOver(false);
+      let transferData = null;
+      if (e.dataTransfer) {
+        const raw = e.dataTransfer.getData("application/json");
+        if (raw) {
+          try {
+            transferData = JSON.parse(raw);
+          } catch {
+            transferData = raw;
+          }
+        }
+      }
+      options.onDrop(transferData, e);
+    };
+    el.addEventListener("dragover", onDragOver);
+    el.addEventListener("dragenter", onDragEnter);
+    el.addEventListener("dragleave", onDragLeave);
+    el.addEventListener("drop", onDrop);
+  });
+  function dispose() {
+    cleanup();
+    if (currentEl && onDragOver && onDragEnter && onDragLeave && onDrop) {
+      currentEl.removeEventListener("dragover", onDragOver);
+      currentEl.removeEventListener("dragenter", onDragEnter);
+      currentEl.removeEventListener("dragleave", onDragLeave);
+      currentEl.removeEventListener("drop", onDrop);
+      currentEl = null;
+    }
+  }
+  return { isOver, dispose };
+}
+
+// src/browser/title.ts
+function title(value) {
+  if (typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const previousTitle = document.title;
+  if (typeof value === "function") {
+    const cleanup = effect(() => {
+      document.title = value();
+    });
+    return () => {
+      cleanup();
+      document.title = previousTitle;
+    };
+  }
+  document.title = value;
+  return () => {
+    document.title = previousTitle;
+  };
+}
+
+// src/browser/colorScheme.ts
+function colorScheme() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    const [scheme2] = signal("light");
+    return { scheme: scheme2, dispose: () => {
+    } };
+  }
+  const mql = window.matchMedia("(prefers-color-scheme: dark)");
+  const [scheme, setScheme] = signal(mql.matches ? "dark" : "light");
+  const handler = (event) => {
+    setScheme(event.matches ? "dark" : "light");
+  };
+  mql.addEventListener("change", handler);
+  function dispose() {
+    mql.removeEventListener("change", handler);
+  }
+  return { scheme, dispose };
+}
+
+// src/browser/format.ts
+function formatNumber(value, options) {
+  const { locale, ...formatOptions } = options ?? {};
+  return new Intl.NumberFormat(locale, formatOptions).format(value);
+}
+function formatCurrency(value, currency, options) {
+  const { locale, ...formatOptions } = options ?? {};
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    ...formatOptions
+  }).format(value);
+}
+
+// src/browser/visibility.ts
+function visibility() {
+  if (typeof document === "undefined") {
+    const [visible2] = signal(true);
+    return { visible: visible2, dispose: () => {
+    } };
+  }
+  const [visible, setVisible] = signal(!document.hidden);
+  const handler = () => setVisible(!document.hidden);
+  document.addEventListener("visibilitychange", handler);
+  function dispose() {
+    document.removeEventListener("visibilitychange", handler);
+  }
+  return { visible, dispose };
+}
+
+// src/browser/network.ts
+function network() {
+  const connection = typeof navigator !== "undefined" ? navigator.connection ?? navigator.mozConnection ?? navigator.webkitConnection : void 0;
+  const [effectiveType, setEffectiveType] = signal(connection?.effectiveType ?? "unknown");
+  const [downlink, setDownlink] = signal(connection?.downlink ?? 0);
+  const [rtt, setRtt] = signal(connection?.rtt ?? 0);
+  const [saveData, setSaveData] = signal(connection?.saveData ?? false);
+  if (!connection) {
+    return { effectiveType, downlink, rtt, saveData, dispose: () => {
+    } };
+  }
+  const update = () => {
+    setEffectiveType(connection.effectiveType ?? "unknown");
+    setDownlink(connection.downlink ?? 0);
+    setRtt(connection.rtt ?? 0);
+    setSaveData(connection.saveData ?? false);
+  };
+  connection.addEventListener("change", update);
+  function dispose() {
+    connection?.removeEventListener("change", update);
+  }
+  return { effectiveType, downlink, rtt, saveData, dispose };
+}
+
+// src/browser/mouse.ts
+function mouse(options = {}) {
+  const [x, setX] = signal(0);
+  const [y, setY] = signal(0);
+  if (typeof window === "undefined") {
+    return { x, y, dispose: () => {
+    } };
+  }
+  const target = options.target ?? window;
+  const trackTouch = options.touch ?? true;
+  const onMove = (e) => {
+    setX(e.clientX);
+    setY(e.clientY);
+  };
+  const onTouchMove = (e) => {
+    if (e.touches.length === 0) return;
+    setX(e.touches[0].clientX);
+    setY(e.touches[0].clientY);
+  };
+  target.addEventListener("mousemove", onMove, { passive: true });
+  if (trackTouch) {
+    target.addEventListener("touchmove", onTouchMove, { passive: true });
+  }
+  function dispose() {
+    target.removeEventListener("mousemove", onMove);
+    if (trackTouch) {
+      target.removeEventListener("touchmove", onTouchMove);
+    }
+  }
+  return { x, y, dispose };
+}
+
+// src/browser/swipe.ts
+function swipe(target, options = {}) {
+  const threshold = options.threshold ?? 50;
+  const [direction, setDirection] = signal(null);
+  if (typeof window === "undefined") {
+    return { direction, dispose: () => {
+    } };
+  }
+  let startX = 0;
+  let startY = 0;
+  let tracking = false;
+  const onStart = (e) => {
+    if (e.touches.length === 0) return;
+    startX = e.touches[0].clientX;
+    startY = e.touches[0].clientY;
+    tracking = true;
+  };
+  const onEnd = (e) => {
+    if (!tracking) return;
+    tracking = false;
+    const touch = e.changedTouches[0];
+    if (!touch) return;
+    const dx = touch.clientX - startX;
+    const dy = touch.clientY - startY;
+    const absX = Math.abs(dx);
+    const absY = Math.abs(dy);
+    if (Math.max(absX, absY) < threshold) return;
+    let dir;
+    if (absX > absY) {
+      dir = dx > 0 ? "right" : "left";
+    } else {
+      dir = dy > 0 ? "down" : "up";
+    }
+    setDirection(dir);
+    options.onSwipe?.(dir, Math.max(absX, absY));
+  };
+  target.addEventListener("touchstart", onStart, { passive: true });
+  target.addEventListener("touchend", onEnd, { passive: true });
+  function dispose() {
+    target.removeEventListener("touchstart", onStart);
+    target.removeEventListener("touchend", onEnd);
+  }
+  return { direction, dispose };
+}
+
+// src/browser/windowSize.ts
+function windowSize() {
+  if (typeof window === "undefined") {
+    const [width2] = signal(0);
+    const [height2] = signal(0);
+    return { width: width2, height: height2, dispose: () => {
+    } };
+  }
+  const [width, setWidth] = signal(window.innerWidth);
+  const [height, setHeight] = signal(window.innerHeight);
+  const handler = () => {
+    setWidth(window.innerWidth);
+    setHeight(window.innerHeight);
+  };
+  window.addEventListener("resize", handler, { passive: true });
+  function dispose() {
+    window.removeEventListener("resize", handler);
+  }
+  return { width, height, dispose };
+}
+
+// src/browser/urlState.ts
+function urlState() {
+  if (typeof window === "undefined") {
+    const [params2] = signal(new URLSearchParams());
+    const [hash2] = signal("");
+    return {
+      params: params2,
+      hash: hash2,
+      setParams: () => {
+      },
+      setHash: () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const [params, setParamsSignal] = signal(new URLSearchParams(window.location.search));
+  const [hash, setHashSignal] = signal(window.location.hash);
+  const syncFromLocation = () => {
+    setParamsSignal(new URLSearchParams(window.location.search));
+    setHashSignal(window.location.hash);
+  };
+  const onPopState = () => syncFromLocation();
+  window.addEventListener("popstate", onPopState);
+  function setParams(next, opts = {}) {
+    const p = next instanceof URLSearchParams ? next : new URLSearchParams(next);
+    const query = p.toString();
+    const newUrl = `${window.location.pathname}${query ? `?${query}` : ""}${window.location.hash}`;
+    if (opts.replace) window.history.replaceState(null, "", newUrl);
+    else window.history.pushState(null, "", newUrl);
+    setParamsSignal(new URLSearchParams(p));
+  }
+  function setHash(next, opts = {}) {
+    const normalized = next.startsWith("#") ? next : next ? `#${next}` : "";
+    const newUrl = `${window.location.pathname}${window.location.search}${normalized}`;
+    if (opts.replace) window.history.replaceState(null, "", newUrl);
+    else window.history.pushState(null, "", newUrl);
+    setHashSignal(normalized);
+  }
+  function dispose() {
+    window.removeEventListener("popstate", onPopState);
+  }
+  return { params, hash, setParams, setHash, dispose };
+}
+
+// src/browser/broadcast.ts
+function broadcast(channelName) {
+  if (typeof BroadcastChannel === "undefined") {
+    const [last2] = signal(null);
+    return { last: last2, post: () => {
+    }, dispose: () => {
+    } };
+  }
+  const [last, setLast] = signal(null);
+  const channel = new BroadcastChannel(channelName);
+  const handler = (ev) => setLast(ev.data);
+  channel.addEventListener("message", handler);
+  function post(message) {
+    channel.postMessage(message);
+  }
+  function dispose() {
+    channel.removeEventListener("message", handler);
+    channel.close();
+  }
+  return { last, post, dispose };
+}
+
+// src/browser/fullscreen.ts
+function fullscreen() {
+  if (typeof document === "undefined") {
+    const [isFullscreen2] = signal(false);
+    const [element2] = signal(null);
+    return {
+      isFullscreen: isFullscreen2,
+      element: element2,
+      enter: async () => {
+      },
+      exit: async () => {
+      },
+      toggle: async () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const [isFullscreen, setIsFullscreen] = signal(!!document.fullscreenElement);
+  const [element, setElement] = signal(document.fullscreenElement);
+  const handler = () => {
+    setIsFullscreen(!!document.fullscreenElement);
+    setElement(document.fullscreenElement);
+  };
+  document.addEventListener("fullscreenchange", handler);
+  async function enter(el) {
+    if (!document.fullscreenElement && el.requestFullscreen) {
+      await el.requestFullscreen();
+    }
+  }
+  async function exit() {
+    if (document.fullscreenElement && document.exitFullscreen) {
+      await document.exitFullscreen();
+    }
+  }
+  async function toggle(el) {
+    if (document.fullscreenElement) await exit();
+    else await enter(el);
+  }
+  function dispose() {
+    document.removeEventListener("fullscreenchange", handler);
+  }
+  return { isFullscreen, element, enter, exit, toggle, dispose };
+}
+
+// src/browser/wakeLock.ts
+function wakeLock() {
+  const [active, setActive] = signal(false);
+  if (typeof navigator === "undefined" || !("wakeLock" in navigator) || typeof document === "undefined") {
+    return {
+      active,
+      request: async () => {
+      },
+      release: async () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const api = navigator.wakeLock;
+  let sentinel = null;
+  async function request() {
+    try {
+      sentinel = await api.request("screen");
+      setActive(true);
+      sentinel.addEventListener("release", () => {
+        setActive(false);
+      });
+    } catch {
+      setActive(false);
+    }
+  }
+  async function release() {
+    if (sentinel && !sentinel.released) {
+      await sentinel.release();
+    }
+    sentinel = null;
+    setActive(false);
+  }
+  const onVisibility = () => {
+    if (sentinel?.released && !document.hidden) {
+      void request();
+    }
+  };
+  document.addEventListener("visibilitychange", onVisibility);
+  function dispose() {
+    document.removeEventListener("visibilitychange", onVisibility);
+    void release();
+  }
+  return { active, request, release, dispose };
+}
+
+// src/browser/animationFrame.ts
+function animationFrame(options = {}) {
+  const [delta, setDelta] = signal(0);
+  const [elapsed, setElapsed] = signal(0);
+  const [running, setRunning] = signal(false);
+  if (typeof requestAnimationFrame === "undefined") {
+    return {
+      delta,
+      elapsed,
+      running,
+      pause: () => {
+      },
+      resume: () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  let id = null;
+  let prev = -1;
+  let start = -1;
+  const minFrameMs = options.fpsLimit ? 1e3 / options.fpsLimit : 0;
+  const step = (now) => {
+    if (start < 0) start = now;
+    const firstTick = prev < 0;
+    const dt = firstTick ? 0 : now - prev;
+    if (firstTick || dt >= minFrameMs) {
+      setDelta(dt);
+      setElapsed(now - start);
+      prev = now;
+    }
+    id = requestAnimationFrame(step);
+  };
+  function resume() {
+    if (id !== null) return;
+    setRunning(true);
+    id = requestAnimationFrame(step);
+  }
+  function pause() {
+    if (id !== null) {
+      cancelAnimationFrame(id);
+      id = null;
+    }
+    setRunning(false);
+    prev = -1;
+    start = -1;
+  }
+  function dispose() {
+    pause();
+  }
+  if (options.immediate !== false) resume();
+  return { delta, elapsed, running, pause, resume, dispose };
+}
+
+// src/browser/mutationObserver.ts
+function mutationObserver(target, options = { childList: true, subtree: true }) {
+  const [records, setRecords] = signal([]);
+  if (typeof MutationObserver === "undefined") {
+    return { records, dispose: () => {
+    } };
+  }
+  const observer = new MutationObserver((batch2) => {
+    setRecords(batch2);
+  });
+  observer.observe(target, options);
+  function dispose() {
+    observer.disconnect();
+  }
+  return { records, dispose };
+}
+
+// src/browser/bounds.ts
+var ZERO = {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0
+};
+function readRect(el) {
+  const r = el.getBoundingClientRect();
+  return {
+    x: r.x,
+    y: r.y,
+    width: r.width,
+    height: r.height,
+    top: r.top,
+    left: r.left,
+    right: r.right,
+    bottom: r.bottom
+  };
+}
+function bounds(target) {
+  const [rect, setRect] = signal(ZERO);
+  if (typeof window === "undefined" || !target) {
+    return {
+      rect,
+      refresh: () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  function refresh() {
+    setRect(readRect(target));
+  }
+  refresh();
+  let resizeObserver = null;
+  if (typeof ResizeObserver !== "undefined") {
+    resizeObserver = new ResizeObserver(refresh);
+    resizeObserver.observe(target);
+  }
+  const onScroll = () => refresh();
+  window.addEventListener("scroll", onScroll, { passive: true, capture: true });
+  function dispose() {
+    resizeObserver?.disconnect();
+    window.removeEventListener("scroll", onScroll, { capture: true });
+  }
+  return { rect, refresh, dispose };
+}
+
+// src/browser/keyboard.ts
+function keyboard(options = {}) {
+  const [pressed, setPressed] = signal(/* @__PURE__ */ new Set());
+  if (typeof window === "undefined") {
+    return {
+      pressed,
+      isPressed: () => false,
+      dispose: () => {
+      }
+    };
+  }
+  const target = options.target ?? window;
+  const filter = options.keys ? new Set(options.keys) : null;
+  const onDown = (e) => {
+    if (filter && !filter.has(e.key)) return;
+    setPressed((prev) => {
+      if (prev.has(e.key)) return prev;
+      const next = new Set(prev);
+      next.add(e.key);
+      return next;
+    });
+  };
+  const onUp = (e) => {
+    if (filter && !filter.has(e.key)) return;
+    setPressed((prev) => {
+      if (!prev.has(e.key)) return prev;
+      const next = new Set(prev);
+      next.delete(e.key);
+      return next;
+    });
+  };
+  const onBlur = () => setPressed(/* @__PURE__ */ new Set());
+  target.addEventListener("keydown", onDown);
+  target.addEventListener("keyup", onUp);
+  window.addEventListener("blur", onBlur);
+  function isPressed(key) {
+    return pressed().has(key);
+  }
+  function dispose() {
+    target.removeEventListener("keydown", onDown);
+    target.removeEventListener("keyup", onUp);
+    window.removeEventListener("blur", onBlur);
+  }
+  return { pressed, isPressed, dispose };
+}
+
+// src/browser/speech.ts
+function speech() {
+  const [speaking, setSpeaking] = signal(false);
+  const [paused, setPaused] = signal(false);
+  if (typeof window === "undefined" || typeof window.speechSynthesis === "undefined") {
+    return {
+      speaking,
+      paused,
+      speak: () => {
+      },
+      pause: () => {
+      },
+      resume: () => {
+      },
+      cancel: () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const synth = window.speechSynthesis;
+  const interval = setInterval(() => {
+    setSpeaking(synth.speaking);
+    setPaused(synth.paused);
+  }, 200);
+  function speak(text, options = {}) {
+    const u = new SpeechSynthesisUtterance(text);
+    if (options.lang) u.lang = options.lang;
+    if (options.rate != null) u.rate = options.rate;
+    if (options.pitch != null) u.pitch = options.pitch;
+    if (options.volume != null) u.volume = options.volume;
+    if (options.voice) {
+      const voices = synth.getVoices();
+      const match = voices.find((v) => v.name === options.voice);
+      if (match) u.voice = match;
+    }
+    u.addEventListener("start", () => setSpeaking(true));
+    u.addEventListener("end", () => {
+      setSpeaking(false);
+      setPaused(false);
+    });
+    u.addEventListener("error", () => {
+      setSpeaking(false);
+      setPaused(false);
+    });
+    synth.speak(u);
+  }
+  function dispose() {
+    clearInterval(interval);
+    synth.cancel();
+  }
+  return {
+    speaking,
+    paused,
+    speak,
+    pause: () => synth.pause(),
+    resume: () => synth.resume(),
+    cancel: () => synth.cancel(),
+    dispose
+  };
+}
+
+// src/browser/gamepad.ts
+function gamepad() {
+  const [pads, setPads] = signal([]);
+  if (typeof window === "undefined" || typeof navigator === "undefined" || typeof navigator.getGamepads !== "function") {
+    return { pads, dispose: () => {
+    } };
+  }
+  let rafId = null;
+  function snapshot(pad) {
+    return {
+      index: pad.index,
+      id: pad.id,
+      connected: pad.connected,
+      buttons: pad.buttons.map((b) => ({ pressed: b.pressed, value: b.value })),
+      axes: [...pad.axes]
+    };
+  }
+  function equal(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      const pa = a[i];
+      const pb = b[i];
+      if (pa.index !== pb.index || pa.connected !== pb.connected) return false;
+      if (pa.buttons.length !== pb.buttons.length) return false;
+      for (let j = 0; j < pa.buttons.length; j++) {
+        if (pa.buttons[j].pressed !== pb.buttons[j].pressed) return false;
+        if (pa.buttons[j].value !== pb.buttons[j].value) return false;
+      }
+      if (pa.axes.length !== pb.axes.length) return false;
+      for (let j = 0; j < pa.axes.length; j++) {
+        if (pa.axes[j] !== pb.axes[j]) return false;
+      }
+    }
+    return true;
+  }
+  function poll() {
+    const raw = navigator.getGamepads();
+    const snap = Array.from(raw).filter((g) => g !== null).map(snapshot);
+    const current = pads();
+    if (!equal(current, snap)) setPads(snap);
+    rafId = requestAnimationFrame(poll);
+  }
+  function startPolling() {
+    if (rafId === null) poll();
+  }
+  function stopPolling() {
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+  }
+  const onConnect = () => startPolling();
+  const onDisconnect = () => {
+    const raw = navigator.getGamepads();
+    const hasAny = Array.from(raw).some((g) => g !== null);
+    if (!hasAny) stopPolling();
+  };
+  window.addEventListener("gamepadconnected", onConnect);
+  window.addEventListener("gamepaddisconnected", onDisconnect);
+  const initial = Array.from(navigator.getGamepads()).some((g) => g !== null);
+  if (initial) startPolling();
+  function dispose() {
+    stopPolling();
+    window.removeEventListener("gamepadconnected", onConnect);
+    window.removeEventListener("gamepaddisconnected", onDisconnect);
+  }
+  return { pads, dispose };
+}
+
+// src/browser/pointerLock.ts
+function pointerLock() {
+  const [locked, setLocked] = signal(false);
+  if (typeof document === "undefined") {
+    return {
+      locked,
+      request: () => {
+      },
+      exit: () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const handler = () => {
+    setLocked(!!document.pointerLockElement);
+  };
+  document.addEventListener("pointerlockchange", handler);
+  function request(element) {
+    if (typeof element.requestPointerLock === "function") {
+      element.requestPointerLock();
+    }
+  }
+  function exit() {
+    if (typeof document.exitPointerLock === "function") {
+      document.exitPointerLock();
+    }
+  }
+  function dispose() {
+    document.removeEventListener("pointerlockchange", handler);
+  }
+  return { locked, request, exit, dispose };
+}
+
+// src/browser/vibrate.ts
+function vibrate(pattern) {
+  if (typeof navigator === "undefined" || typeof navigator.vibrate !== "function") {
+    return false;
+  }
+  return navigator.vibrate(pattern);
+}
+
+// src/browser/favicon.ts
+function favicon(url) {
+  if (typeof document === "undefined") return;
+  let link = document.querySelector("link[rel='icon']");
+  if (!link) {
+    link = document.createElement("link");
+    link.rel = "icon";
+    document.head.appendChild(link);
+  }
+  link.href = url;
+}
+function svgFavicon(svg) {
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+
+// src/browser/textSelection.ts
+function textSelection() {
+  const [text, setText] = signal("");
+  const [rect, setRect] = signal(null);
+  if (typeof document === "undefined") {
+    return {
+      text,
+      rect,
+      hasSelection: () => false,
+      clear: () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const handler = () => {
+    const sel = document.getSelection();
+    if (!sel || sel.rangeCount === 0 || sel.isCollapsed) {
+      setText("");
+      setRect(null);
+      return;
+    }
+    setText(sel.toString());
+    try {
+      const r = sel.getRangeAt(0).getBoundingClientRect();
+      setRect(r.width > 0 || r.height > 0 ? r : null);
+    } catch {
+      setRect(null);
+    }
+  };
+  document.addEventListener("selectionchange", handler);
+  function clear() {
+    const sel = document.getSelection();
+    sel?.removeAllRanges();
+    setText("");
+    setRect(null);
+  }
+  function dispose() {
+    document.removeEventListener("selectionchange", handler);
+  }
+  return {
+    text,
+    rect,
+    hasSelection: () => text().length > 0,
+    clear,
+    dispose
+  };
+}
+
+// src/browser/imageLoader.ts
+function imageLoader(src) {
+  const [status, setStatus] = signal("pending");
+  const [image, setImage] = signal(null);
+  const [width, setWidth] = signal(0);
+  const [height, setHeight] = signal(0);
+  if (typeof Image === "undefined") {
+    return {
+      status,
+      image,
+      width,
+      height,
+      dispose: () => {
+      }
+    };
+  }
+  let current = null;
+  let disposed = false;
+  function start(url) {
+    if (current) {
+      current.onload = null;
+      current.onerror = null;
+    }
+    setStatus("pending");
+    setImage(null);
+    const img = new Image();
+    current = img;
+    img.onload = () => {
+      if (disposed || current !== img) return;
+      setImage(img);
+      setWidth(img.naturalWidth);
+      setHeight(img.naturalHeight);
+      setStatus("loaded");
+    };
+    img.onerror = () => {
+      if (disposed || current !== img) return;
+      setStatus("error");
+    };
+    img.src = url;
+  }
+  if (typeof src === "function") {
+    start(src());
+  } else {
+    start(src);
+  }
+  function dispose() {
+    disposed = true;
+    if (current) {
+      current.onload = null;
+      current.onerror = null;
+      current = null;
+    }
+  }
+  return { status, image, width, height, dispose };
+}
+
+export {
+  media,
+  resize,
+  scroll,
+  online,
+  geo,
+  battery,
+  idle,
+  permissions,
+  clipboard,
+  draggable,
+  dropZone,
+  title,
+  colorScheme,
+  formatNumber,
+  formatCurrency,
+  visibility,
+  network,
+  mouse,
+  swipe,
+  windowSize,
+  urlState,
+  broadcast,
+  fullscreen,
+  wakeLock,
+  animationFrame,
+  mutationObserver,
+  bounds,
+  keyboard,
+  speech,
+  gamepad,
+  pointerLock,
+  vibrate,
+  favicon,
+  svgFavicon,
+  textSelection,
+  imageLoader
+};