@stacksjs/stx 0.2.95 → 0.2.96

package/dist/composables/use-geolocation.js

@@ -1,2 +1,101 @@
-// @bun
-import"../chunk-xv34zbp4.js";function Z(B){return new Promise((J,C)=>{if(!navigator.geolocation){C(Error("Geolocation is not supported"));return}navigator.geolocation.getCurrentPosition(J,C,B)})}function _(B,J,C,M){let F=B*Math.PI/180,q=C*Math.PI/180,z=(C-B)*Math.PI/180,D=(M-J)*Math.PI/180,K=Math.sin(z/2)*Math.sin(z/2)+Math.cos(F)*Math.cos(q)*Math.sin(D/2)*Math.sin(D/2);return 6371000*(2*Math.atan2(Math.sqrt(K),Math.sqrt(1-K)))}function Y(B={}){let{enableHighAccuracy:J=!0,timeout:C=1e4,maximumAge:M=0,immediate:N=!0}=B,F=typeof navigator<"u"&&"geolocation"in navigator,q={coords:null,timestamp:null,error:null,loading:!1,supported:F},z=[],D=null,K=!0,L=()=>{z.forEach((k)=>k(q))},Q=(k)=>{q={...q,coords:{latitude:k.coords.latitude,longitude:k.coords.longitude,altitude:k.coords.altitude,accuracy:k.coords.accuracy,altitudeAccuracy:k.coords.altitudeAccuracy,heading:k.coords.heading,speed:k.coords.speed},timestamp:k.timestamp,error:null,loading:!1},L()},R=(k)=>{q={...q,error:k,loading:!1},L()},O=()=>{if(!F||D!==null)return;q={...q,loading:!0},L(),D=navigator.geolocation.watchPosition(Q,R,{enableHighAccuracy:J,timeout:C,maximumAge:M})},S=()=>{if(D!==null)navigator.geolocation.clearWatch(D),D=null},T=()=>{if(!F)return;q={...q,loading:!0},L(),navigator.geolocation.getCurrentPosition(Q,R,{enableHighAccuracy:J,timeout:C,maximumAge:M})},U=()=>{K=!1,S()},V=()=>{if(K=!0,z.length>0)O()};if(N&&F)O();return{get:()=>q,subscribe:(k)=>{if(z.push(k),k(q),z.length===1&&K&&F&&!N)O();return()=>{if(z=z.filter((X)=>X!==k),z.length===0)S()}},refresh:T,pause:U,resume:V}}function $(B){return Y({...B,immediate:!0})}export{$ as useGeolocationWatch,Y as useGeolocation,Z as getCurrentPosition,_ as calculateDistance};
+export function getCurrentPosition(options) {
+  return new Promise((resolve, reject) => {
+    if (!navigator.geolocation) {
+      reject(Error("Geolocation is not supported"));
+      return;
+    }
+    navigator.geolocation.getCurrentPosition(resolve, reject, options);
+  });
+}
+export function calculateDistance(lat1, lon1, lat2, lon2) {
+  const R = 6371000, \u{3c6}1 = lat1 * Math.PI / 180, \u{3c6}2 = lat2 * Math.PI / 180, \u{394}\u{3c6} = (lat2 - lat1) * Math.PI / 180, \u{394}\u{3bb} = (lon2 - lon1) * Math.PI / 180, a = Math.sin(\u{394}\u{3c6} / 2) * Math.sin(\u{394}\u{3c6} / 2) + Math.cos(\u{3c6}1) * Math.cos(\u{3c6}2) * Math.sin(\u{394}\u{3bb} / 2) * Math.sin(\u{394}\u{3bb} / 2), c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+}
+export function useGeolocation(options = {}) {
+  const {
+    enableHighAccuracy = !0,
+    timeout = 1e4,
+    maximumAge = 0,
+    immediate = !0
+  } = options, supported = typeof navigator < "u" && "geolocation" in navigator;
+  let state = {
+    coords: null,
+    timestamp: null,
+    error: null,
+    loading: !1,
+    supported
+  }, listeners = [], watchId = null, isActive = !0;
+  const notify = () => {
+    listeners.forEach((fn) => fn(state));
+  }, updatePosition = (position) => {
+    state = {
+      ...state,
+      coords: {
+        latitude: position.coords.latitude,
+        longitude: position.coords.longitude,
+        altitude: position.coords.altitude,
+        accuracy: position.coords.accuracy,
+        altitudeAccuracy: position.coords.altitudeAccuracy,
+        heading: position.coords.heading,
+        speed: position.coords.speed
+      },
+      timestamp: position.timestamp,
+      error: null,
+      loading: !1
+    };
+    notify();
+  }, handleError = (error) => {
+    state = {
+      ...state,
+      error,
+      loading: !1
+    };
+    notify();
+  }, startWatch = () => {
+    if (!supported || watchId !== null)
+      return;
+    state = { ...state, loading: !0 };
+    notify();
+    watchId = navigator.geolocation.watchPosition(updatePosition, handleError, { enableHighAccuracy, timeout, maximumAge });
+  }, stopWatch = () => {
+    if (watchId !== null) {
+      navigator.geolocation.clearWatch(watchId);
+      watchId = null;
+    }
+  }, refresh = () => {
+    if (!supported)
+      return;
+    state = { ...state, loading: !0 };
+    notify();
+    navigator.geolocation.getCurrentPosition(updatePosition, handleError, { enableHighAccuracy, timeout, maximumAge });
+  }, pause = () => {
+    isActive = !1;
+    stopWatch();
+  }, resume = () => {
+    isActive = !0;
+    if (listeners.length > 0)
+      startWatch();
+  };
+  if (immediate && supported)
+    startWatch();
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      listeners.push(fn);
+      fn(state);
+      if (listeners.length === 1 && isActive && supported && !immediate)
+        startWatch();
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0)
+          stopWatch();
+      };
+    },
+    refresh,
+    pause,
+    resume
+  };
+}
+export function useGeolocationWatch(options) {
+  return useGeolocation({ ...options, immediate: !0 });
+}

package/dist/composables/use-idle.js

@@ -1,2 +1,182 @@
-// @bun
-import"../chunk-xv34zbp4.js";var _=["mousemove","mousedown","keydown","touchstart","scroll","wheel","resize","visibilitychange"];function x(z={}){let{timeout:k=60000,events:M=_,listenTo:B=typeof document<"u"?document:null,initialState:P=!1,onIdle:G,onActive:Q}=z,J=new Set,j={isIdle:P,lastActive:Date.now(),idleTime:0},H=null,O=null,R=null;function Z(){J.forEach((q)=>q(j))}function $(q){let K=j.isIdle;if(q&&!K)j={...j,isIdle:!0},Z(),G?.(),O=setInterval(()=>{j={...j,idleTime:Date.now()-j.lastActive},Z()},1000);else if(!q&&K){if(j={...j,isIdle:!1,lastActive:Date.now(),idleTime:0},Z(),Q?.(),O)clearInterval(O),O=null}}function X(){if(H)clearTimeout(H);if(!j.isIdle)j={...j,lastActive:Date.now()};$(!1),H=setTimeout(()=>{$(!0)},k)}function C(){X()}function D(){if(document.hidden){if(H)clearTimeout(H);H=setTimeout(()=>{$(!0)},Math.min(k,5000))}else X()}function F(){if(!B||R)return;let q=[];for(let K of M){let Y=K==="visibilitychange"?D:C;B.addEventListener(K,Y,{passive:!0}),q.push([K,Y])}X(),R=()=>{for(let[K,Y]of q)B.removeEventListener(K,Y);if(H)clearTimeout(H),H=null;if(O)clearInterval(O),O=null}}function N(){R?.(),R=null}function U(){X()}if(typeof document<"u")F();return{get:()=>j,subscribe:(q)=>{return J.add(q),q(j),()=>{if(J.delete(q),J.size===0)N()}},reset:U,isIdle:()=>j.isIdle}}function V(z=60000){let k=x({timeout:z});return{get:()=>k.get().isIdle,subscribe:(M)=>{return k.subscribe((B)=>M(B.isIdle))},reset:k.reset}}function E(){let z=x({timeout:Number.POSITIVE_INFINITY});return{get:()=>z.get().lastActive,subscribe:(k)=>{return z.subscribe((M)=>k(M.lastActive))},reset:z.reset}}function W(z,k,M={}){let{warningTime:B=30000,onWarning:P}=M,G=null,Q=!1,J=x({timeout:z-B,onIdle:()=>{if(P){Q=!0;let j=B;P(j),G=setInterval(()=>{if(j-=1000,j<=0){if(G)clearInterval(G),G=null;k()}else P(j)},1000)}else setTimeout(k,B)},onActive:()=>{if(Q){if(Q=!1,G)clearInterval(G),G=null}}});return{reset:J.reset,get:J.get,subscribe:J.subscribe}}export{E as useLastActive,V as useIdleState,x as useIdle,W as useAutoLogout};
+const DEFAULT_EVENTS = [
+  "mousemove",
+  "mousedown",
+  "keydown",
+  "touchstart",
+  "scroll",
+  "wheel",
+  "resize",
+  "visibilitychange"
+];
+export function useIdle(options = {}) {
+  const {
+    timeout = 60000,
+    events = DEFAULT_EVENTS,
+    listenTo = typeof document < "u" ? document : null,
+    initialState = !1,
+    onIdle,
+    onActive
+  } = options, subscribers = new Set;
+  let state = {
+    isIdle: initialState,
+    lastActive: Date.now(),
+    idleTime: 0
+  }, idleTimer = null, idleTimeInterval = null, cleanup = null;
+  function notify() {
+    subscribers.forEach((fn) => fn(state));
+  }
+  function setIdle(isIdle) {
+    const wasIdle = state.isIdle;
+    if (isIdle && !wasIdle) {
+      state = { ...state, isIdle: !0 };
+      notify();
+      onIdle?.();
+      idleTimeInterval = setInterval(() => {
+        state = { ...state, idleTime: Date.now() - state.lastActive };
+        notify();
+      }, 1000);
+    } else if (!isIdle && wasIdle) {
+      state = {
+        ...state,
+        isIdle: !1,
+        lastActive: Date.now(),
+        idleTime: 0
+      };
+      notify();
+      onActive?.();
+      if (idleTimeInterval) {
+        clearInterval(idleTimeInterval);
+        idleTimeInterval = null;
+      }
+    }
+  }
+  function resetTimer() {
+    if (idleTimer)
+      clearTimeout(idleTimer);
+    if (!state.isIdle)
+      state = { ...state, lastActive: Date.now() };
+    setIdle(!1);
+    idleTimer = setTimeout(() => {
+      setIdle(!0);
+    }, timeout);
+  }
+  function handleActivity() {
+    resetTimer();
+  }
+  function handleVisibilityChange() {
+    if (document.hidden) {
+      if (idleTimer)
+        clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        setIdle(!0);
+      }, Math.min(timeout, 5000));
+    } else
+      resetTimer();
+  }
+  function startListening() {
+    if (!listenTo || cleanup)
+      return;
+    const handlers = [];
+    for (const event of events) {
+      const handler = event === "visibilitychange" ? handleVisibilityChange : handleActivity;
+      listenTo.addEventListener(event, handler, { passive: !0 });
+      handlers.push([event, handler]);
+    }
+    resetTimer();
+    cleanup = () => {
+      for (const [event, handler] of handlers)
+        listenTo.removeEventListener(event, handler);
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      if (idleTimeInterval) {
+        clearInterval(idleTimeInterval);
+        idleTimeInterval = null;
+      }
+    };
+  }
+  function stopListening() {
+    cleanup?.();
+    cleanup = null;
+  }
+  function reset() {
+    resetTimer();
+  }
+  if (typeof document < "u")
+    startListening();
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      fn(state);
+      return () => {
+        subscribers.delete(fn);
+        if (subscribers.size === 0)
+          stopListening();
+      };
+    },
+    reset,
+    isIdle: () => state.isIdle
+  };
+}
+export function useIdleState(timeout = 60000) {
+  const idle = useIdle({ timeout });
+  return {
+    get: () => idle.get().isIdle,
+    subscribe: (fn) => {
+      return idle.subscribe((state) => fn(state.isIdle));
+    },
+    reset: idle.reset
+  };
+}
+export function useLastActive() {
+  const idle = useIdle({ timeout: Number.POSITIVE_INFINITY });
+  return {
+    get: () => idle.get().lastActive,
+    subscribe: (fn) => {
+      return idle.subscribe((state) => fn(state.lastActive));
+    },
+    reset: idle.reset
+  };
+}
+export function useAutoLogout(timeout, onLogout, options = {}) {
+  const { warningTime = 30000, onWarning } = options;
+  let warningInterval = null, warningStarted = !1;
+  const idle = useIdle({
+    timeout: timeout - warningTime,
+    onIdle: () => {
+      if (onWarning) {
+        warningStarted = !0;
+        let remaining = warningTime;
+        onWarning(remaining);
+        warningInterval = setInterval(() => {
+          remaining -= 1000;
+          if (remaining <= 0) {
+            if (warningInterval) {
+              clearInterval(warningInterval);
+              warningInterval = null;
+            }
+            onLogout();
+          } else
+            onWarning(remaining);
+        }, 1000);
+      } else
+        setTimeout(onLogout, warningTime);
+    },
+    onActive: () => {
+      if (warningStarted) {
+        warningStarted = !1;
+        if (warningInterval) {
+          clearInterval(warningInterval);
+          warningInterval = null;
+        }
+      }
+    }
+  });
+  return {
+    reset: idle.reset,
+    get: idle.get,
+    subscribe: idle.subscribe
+  };
+}

package/dist/composables/use-intersection-observer.js

@@ -1,2 +1,168 @@
-// @bun
-import"../chunk-xv34zbp4.js";function U(q,z,B={}){let{root:C=null,rootMargin:F="0px",threshold:w=0,once:j=!1,immediate:x=!0}=B,G={isIntersecting:!1,intersectionRatio:0,boundingClientRect:null,intersectionRect:null,isVisible:!1,entry:null},K=[],J=null,P=!1,N=()=>{if(typeof q==="function")return q();return q},W=()=>{K.forEach((H)=>H(G))},X=(H)=>{let D=H[0];if(!D)return;if(G={isIntersecting:D.isIntersecting,intersectionRatio:D.intersectionRatio,boundingClientRect:D.boundingClientRect,intersectionRect:D.intersectionRect,isVisible:D.isIntersecting,entry:D},W(),z)z(D,J);if(j&&D.isIntersecting)R()},Q=()=>{if(typeof IntersectionObserver>"u")return;if(J)return;let H=N();if(!H)return;J=new IntersectionObserver(X,{root:C,rootMargin:F,threshold:w}),J.observe(H),P=!0},R=()=>{if(J)J.disconnect(),J=null;P=!1};if(x)Q();return{get:()=>G,subscribe:(H)=>{if(K.push(H),H(G),K.length===1&&!x&&!P)Q();return()=>{if(K=K.filter((D)=>D!==H),K.length===0&&!z)R()}},isVisible:()=>G.isVisible,stop:R,start:Q}}function Y(q,z){let B=U(q,void 0,z),C=[],F=!1;return{get:()=>B.isVisible(),subscribe:(w)=>{let j=B.subscribe((x)=>{if(x.isVisible!==F)F=x.isVisible,w(x.isVisible)});return C.push(w),w(B.isVisible()),()=>{if(C=C.filter((x)=>x!==w),C.length===0)j()}}}}function Z(q,z,B){return{stop:U(q,(F)=>{if(F.isIntersecting)z()},{...B,once:!0}).stop}}function _(q,z,B={}){let{debounce:C=100,...F}=B,w=!1,j=null,x=U(q,async(G)=>{if(!G.isIntersecting||w)return;if(j)clearTimeout(j);j=setTimeout(async()=>{w=!0;try{await z()}finally{w=!1}},C)},{rootMargin:"100px",...F});return{stop:()=>{if(j)clearTimeout(j);x.stop()},start:x.start,isLoading:()=>w}}function $(q,z,B={}){let{root:C=null,rootMargin:F="0px",threshold:w=0}=B,j=null,x=()=>{if(typeof q==="function")return q();return q},G=()=>{if(typeof IntersectionObserver>"u")return;if(j)return;j=new IntersectionObserver(z,{root:C,rootMargin:F,threshold:w});for(let N of x())j.observe(N)},K=()=>{if(j)j.disconnect(),j=null},J=(N)=>{j?.observe(N)},P=(N)=>{j?.unobserve(N)};return G(),{stop:K,start:G,observe:J,unobserve:P}}export{Z as useLazyLoad,$ as useIntersectionObserverMultiple,U as useIntersectionObserver,_ as useInfiniteScroll,Y as useElementVisibility};
+export function useIntersectionObserver(target, callback, options = {}) {
+  const {
+    root = null,
+    rootMargin = "0px",
+    threshold = 0,
+    once = !1,
+    immediate = !0
+  } = options;
+  let state = {
+    isIntersecting: !1,
+    intersectionRatio: 0,
+    boundingClientRect: null,
+    intersectionRect: null,
+    isVisible: !1,
+    entry: null
+  }, listeners = [], observer = null, isActive = !1;
+  const getElement = () => {
+    if (typeof target === "function")
+      return target();
+    return target;
+  }, notify = () => {
+    listeners.forEach((fn) => fn(state));
+  }, handleIntersect = (entries) => {
+    const entry = entries[0];
+    if (!entry)
+      return;
+    state = {
+      isIntersecting: entry.isIntersecting,
+      intersectionRatio: entry.intersectionRatio,
+      boundingClientRect: entry.boundingClientRect,
+      intersectionRect: entry.intersectionRect,
+      isVisible: entry.isIntersecting,
+      entry
+    };
+    notify();
+    if (callback)
+      callback(entry, observer);
+    if (once && entry.isIntersecting)
+      stop();
+  }, start = () => {
+    if (typeof IntersectionObserver > "u")
+      return;
+    if (observer)
+      return;
+    const element = getElement();
+    if (!element)
+      return;
+    observer = new IntersectionObserver(handleIntersect, {
+      root,
+      rootMargin,
+      threshold
+    });
+    observer.observe(element);
+    isActive = !0;
+  }, stop = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+    isActive = !1;
+  };
+  if (immediate)
+    start();
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      listeners.push(fn);
+      fn(state);
+      if (listeners.length === 1 && !immediate && !isActive)
+        start();
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0 && !callback)
+          stop();
+      };
+    },
+    isVisible: () => state.isVisible,
+    stop,
+    start
+  };
+}
+export function useElementVisibility(target, options) {
+  const observer = useIntersectionObserver(target, void 0, options);
+  let listeners = [], lastValue = !1;
+  return {
+    get: () => observer.isVisible(),
+    subscribe: (fn) => {
+      const unsub = observer.subscribe((state) => {
+        if (state.isVisible !== lastValue) {
+          lastValue = state.isVisible;
+          fn(state.isVisible);
+        }
+      });
+      listeners.push(fn);
+      fn(observer.isVisible());
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0)
+          unsub();
+      };
+    }
+  };
+}
+export function useLazyLoad(target, onVisible, options) {
+  return { stop: useIntersectionObserver(target, (entry) => {
+    if (entry.isIntersecting)
+      onVisible();
+  }, { ...options, once: !0 }).stop };
+}
+export function useInfiniteScroll(sentinel, loadMore, options = {}) {
+  const { debounce = 100, ...observerOptions } = options;
+  let isLoading = !1, debounceTimeout = null;
+  const observer = useIntersectionObserver(sentinel, async (entry) => {
+    if (!entry.isIntersecting || isLoading)
+      return;
+    if (debounceTimeout)
+      clearTimeout(debounceTimeout);
+    debounceTimeout = setTimeout(async () => {
+      isLoading = !0;
+      try {
+        await loadMore();
+      } finally {
+        isLoading = !1;
+      }
+    }, debounce);
+  }, { rootMargin: "100px", ...observerOptions });
+  return {
+    stop: () => {
+      if (debounceTimeout)
+        clearTimeout(debounceTimeout);
+      observer.stop();
+    },
+    start: observer.start,
+    isLoading: () => isLoading
+  };
+}
+export function useIntersectionObserverMultiple(targets, callback, options = {}) {
+  const { root = null, rootMargin = "0px", threshold = 0 } = options;
+  let observer = null;
+  const getElements = () => {
+    if (typeof targets === "function")
+      return targets();
+    return targets;
+  }, start = () => {
+    if (typeof IntersectionObserver > "u")
+      return;
+    if (observer)
+      return;
+    observer = new IntersectionObserver(callback, {
+      root,
+      rootMargin,
+      threshold
+    });
+    for (const element of getElements())
+      observer.observe(element);
+  }, stop = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  }, observe = (element) => {
+    observer?.observe(element);
+  }, unobserve = (element) => {
+    observer?.unobserve(element);
+  };
+  start();
+  return { stop, start, observe, unobserve };
+}

package/dist/composables/use-keyboard.js

@@ -1,2 +1,224 @@
-// @bun
-import"../chunk-xv34zbp4.js";function F(x){let j=x.toLowerCase().split("+").map((O)=>O.trim());return{key:j[j.length-1],ctrl:j.includes("ctrl")||j.includes("control"),alt:j.includes("alt")||j.includes("option"),shift:j.includes("shift"),meta:j.includes("meta")||j.includes("cmd")||j.includes("command")||j.includes("win")}}function L(x,j){let Q=x.key.toLowerCase(),O=x.code.toLowerCase();return(Q===j.key||O===j.key||O===`key${j.key}`||O===`digit${j.key}`||j.key==="space"&&x.code==="Space"||j.key==="enter"&&x.key==="Enter"||j.key==="escape"&&x.key==="Escape"||j.key==="esc"&&x.key==="Escape"||j.key==="tab"&&x.key==="Tab"||j.key==="backspace"&&x.key==="Backspace"||j.key==="delete"&&x.key==="Delete"||j.key==="up"&&x.key==="ArrowUp"||j.key==="down"&&x.key==="ArrowDown"||j.key==="left"&&x.key==="ArrowLeft"||j.key==="right"&&x.key==="ArrowRight")&&x.ctrlKey===j.ctrl&&x.altKey===j.alt&&x.shiftKey===j.shift&&x.metaKey===j.meta}function M(){let x=document.activeElement;if(!x)return!1;let j=x.tagName.toLowerCase();return j==="input"||j==="textarea"||j==="select"||x.isContentEditable}function R(x={}){let{target:j=typeof window<"u"?window:null,capture:Q=!1,passive:O=!0}=x,A={pressed:new Set,lastKey:null,lastEvent:null,ctrl:!1,alt:!1,shift:!1,meta:!1,timestamp:0},E=[],J=null,S=()=>{E.forEach((z)=>z(A))},W=(z)=>{let G=new Set(A.pressed);G.add(z.key.toLowerCase()),G.add(z.code.toLowerCase()),A={pressed:G,lastKey:z.key,lastEvent:z,ctrl:z.ctrlKey,alt:z.altKey,shift:z.shiftKey,meta:z.metaKey,timestamp:Date.now()},S()},X=(z)=>{let G=new Set(A.pressed);G.delete(z.key.toLowerCase()),G.delete(z.code.toLowerCase()),A={pressed:G,lastKey:z.key,lastEvent:z,ctrl:z.ctrlKey,alt:z.altKey,shift:z.shiftKey,meta:z.metaKey,timestamp:Date.now()},S()},Y=()=>{A={...A,pressed:new Set,ctrl:!1,alt:!1,shift:!1,meta:!1},S()},Z=()=>{if(!j)return;let z=j,G={capture:Q,passive:O};if(z.addEventListener("keydown",W,G),z.addEventListener("keyup",X,G),typeof window<"u")window.addEventListener("blur",Y);J=()=>{if(z.removeEventListener("keydown",W,G),z.removeEventListener("keyup",X,G),typeof window<"u")window.removeEventListener("blur",Y)}};return{get:()=>A,subscribe:(z)=>{if(E.length===0)Z();return E.push(z),z(A),()=>{if(E=E.filter((G)=>G!==z),E.length===0&&J)J(),J=null}},isPressed:(z)=>{let G=z.toLowerCase();return A.pressed.has(G)},stop:()=>{if(J)J(),J=null;E=[]}}}function I(x,j,Q={}){let{target:O=typeof window<"u"?window:null,preventDefault:A=!0,stopPropagation:E=!1,ignoreRepeat:J=!0,keyup:S=!1,ignoreInputs:W=!0}=Q;if(!O)return()=>{};let Y=(Array.isArray(x)?x:[x]).map(F),Z=(_)=>{if(J&&_.repeat)return;if(W&&M())return;if(!Y.some(($)=>L(_,$)))return;if(A)_.preventDefault();if(E)_.stopPropagation();j(_)},z=S?"keyup":"keydown",G=O;return G.addEventListener(z,Z),()=>{G.removeEventListener(z,Z)}}function U(x,j={}){let Q=R(j),O=x.toLowerCase(),A=[],E=!1,J=null;return{get:()=>Q.isPressed(O),subscribe:(S)=>{if(A.length===0)J=Q.subscribe((W)=>{let X=W.pressed.has(O);if(X!==E)E=X,A.forEach((Y)=>Y(X))});return A.push(S),S(Q.isPressed(O)),()=>{if(A=A.filter((W)=>W!==S),A.length===0&&J)J(),J=null}}}}function V(x,j,Q={}){let{timeout:O=1000,target:A=typeof window<"u"?window:null}=Q;if(!A)return()=>{};let E=[],J=0,S=(X)=>{let Y=Date.now();if(Y-J>O)E=[];if(J=Y,E.push(X.key.toLowerCase()),E.length>x.length)E=E.slice(-x.length);if(E.length===x.length){if(E.every((z,G)=>z===x[G].toLowerCase()))j(),E=[]}},W=A;return W.addEventListener("keydown",S),()=>{W.removeEventListener("keydown",S)}}var D={save:"ctrl+s",undo:"ctrl+z",redo:"ctrl+shift+z",copy:"ctrl+c",paste:"ctrl+v",cut:"ctrl+x",selectAll:"ctrl+a",find:"ctrl+f",replace:"ctrl+h",newTab:"ctrl+t",closeTab:"ctrl+w",refresh:"ctrl+r",escape:"escape",enter:"enter",saveMac:"meta+s",undoMac:"meta+z",redoMac:"meta+shift+z",copyMac:"meta+c",pasteMac:"meta+v",cutMac:"meta+x"};export{R as useKeyboard,V as useKeySequence,U as useKeyPressed,I as useHotkey,D as shortcuts};
+function parseHotkey(hotkey) {
+  const parts = hotkey.toLowerCase().split("+").map((p) => p.trim());
+  return {
+    key: parts[parts.length - 1],
+    ctrl: parts.includes("ctrl") || parts.includes("control"),
+    alt: parts.includes("alt") || parts.includes("option"),
+    shift: parts.includes("shift"),
+    meta: parts.includes("meta") || parts.includes("cmd") || parts.includes("command") || parts.includes("win")
+  };
+}
+function matchesHotkey(event, hotkey) {
+  const eventKey = event.key.toLowerCase(), eventCode = event.code.toLowerCase();
+  return (eventKey === hotkey.key || eventCode === hotkey.key || eventCode === `key${hotkey.key}` || eventCode === `digit${hotkey.key}` || hotkey.key === "space" && event.code === "Space" || hotkey.key === "enter" && event.key === "Enter" || hotkey.key === "escape" && event.key === "Escape" || hotkey.key === "esc" && event.key === "Escape" || hotkey.key === "tab" && event.key === "Tab" || hotkey.key === "backspace" && event.key === "Backspace" || hotkey.key === "delete" && event.key === "Delete" || hotkey.key === "up" && event.key === "ArrowUp" || hotkey.key === "down" && event.key === "ArrowDown" || hotkey.key === "left" && event.key === "ArrowLeft" || hotkey.key === "right" && event.key === "ArrowRight") && event.ctrlKey === hotkey.ctrl && event.altKey === hotkey.alt && event.shiftKey === hotkey.shift && event.metaKey === hotkey.meta;
+}
+function isInputFocused() {
+  const active = document.activeElement;
+  if (!active)
+    return !1;
+  const tagName = active.tagName.toLowerCase();
+  return tagName === "input" || tagName === "textarea" || tagName === "select" || active.isContentEditable;
+}
+export function useKeyboard(options = {}) {
+  const {
+    target = typeof window < "u" ? window : null,
+    capture = !1,
+    passive = !0
+  } = options;
+  let state = {
+    pressed: new Set,
+    lastKey: null,
+    lastEvent: null,
+    ctrl: !1,
+    alt: !1,
+    shift: !1,
+    meta: !1,
+    timestamp: 0
+  }, listeners = [], cleanup = null;
+  const notify = () => {
+    listeners.forEach((fn) => fn(state));
+  }, handleKeyDown = (e) => {
+    const newPressed = new Set(state.pressed);
+    newPressed.add(e.key.toLowerCase());
+    newPressed.add(e.code.toLowerCase());
+    state = {
+      pressed: newPressed,
+      lastKey: e.key,
+      lastEvent: e,
+      ctrl: e.ctrlKey,
+      alt: e.altKey,
+      shift: e.shiftKey,
+      meta: e.metaKey,
+      timestamp: Date.now()
+    };
+    notify();
+  }, handleKeyUp = (e) => {
+    const newPressed = new Set(state.pressed);
+    newPressed.delete(e.key.toLowerCase());
+    newPressed.delete(e.code.toLowerCase());
+    state = {
+      pressed: newPressed,
+      lastKey: e.key,
+      lastEvent: e,
+      ctrl: e.ctrlKey,
+      alt: e.altKey,
+      shift: e.shiftKey,
+      meta: e.metaKey,
+      timestamp: Date.now()
+    };
+    notify();
+  }, handleBlur = () => {
+    state = {
+      ...state,
+      pressed: new Set,
+      ctrl: !1,
+      alt: !1,
+      shift: !1,
+      meta: !1
+    };
+    notify();
+  }, setupListeners = () => {
+    if (!target)
+      return;
+    const t = target, opts = { capture, passive };
+    t.addEventListener("keydown", handleKeyDown, opts);
+    t.addEventListener("keyup", handleKeyUp, opts);
+    if (typeof window < "u")
+      window.addEventListener("blur", handleBlur);
+    cleanup = () => {
+      t.removeEventListener("keydown", handleKeyDown, opts);
+      t.removeEventListener("keyup", handleKeyUp, opts);
+      if (typeof window < "u")
+        window.removeEventListener("blur", handleBlur);
+    };
+  };
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      if (listeners.length === 0)
+        setupListeners();
+      listeners.push(fn);
+      fn(state);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0 && cleanup) {
+          cleanup();
+          cleanup = null;
+        }
+      };
+    },
+    isPressed: (key) => {
+      const k = key.toLowerCase();
+      return state.pressed.has(k);
+    },
+    stop: () => {
+      if (cleanup) {
+        cleanup();
+        cleanup = null;
+      }
+      listeners = [];
+    }
+  };
+}
+export function useHotkey(hotkey, callback, options = {}) {
+  const {
+    target = typeof window < "u" ? window : null,
+    preventDefault = !0,
+    stopPropagation = !1,
+    ignoreRepeat = !0,
+    keyup = !1,
+    ignoreInputs = !0
+  } = options;
+  if (!target)
+    return () => {};
+  const parsedHotkeys = (Array.isArray(hotkey) ? hotkey : [hotkey]).map(parseHotkey), handler = (e) => {
+    if (ignoreRepeat && e.repeat)
+      return;
+    if (ignoreInputs && isInputFocused())
+      return;
+    if (!parsedHotkeys.some((hk) => matchesHotkey(e, hk)))
+      return;
+    if (preventDefault)
+      e.preventDefault();
+    if (stopPropagation)
+      e.stopPropagation();
+    callback(e);
+  }, eventType = keyup ? "keyup" : "keydown", t = target;
+  t.addEventListener(eventType, handler);
+  return () => {
+    t.removeEventListener(eventType, handler);
+  };
+}
+export function useKeyPressed(key, options = {}) {
+  const keyboard = useKeyboard(options), targetKey = key.toLowerCase();
+  let listeners = [], lastValue = !1, unsubKeyboard = null;
+  return {
+    get: () => keyboard.isPressed(targetKey),
+    subscribe: (fn) => {
+      if (listeners.length === 0)
+        unsubKeyboard = keyboard.subscribe((state) => {
+          const isPressed = state.pressed.has(targetKey);
+          if (isPressed !== lastValue) {
+            lastValue = isPressed;
+            listeners.forEach((l) => l(isPressed));
+          }
+        });
+      listeners.push(fn);
+      fn(keyboard.isPressed(targetKey));
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0 && unsubKeyboard) {
+          unsubKeyboard();
+          unsubKeyboard = null;
+        }
+      };
+    }
+  };
+}
+export function useKeySequence(sequence, callback, options = {}) {
+  const { timeout = 1000, target = typeof window < "u" ? window : null } = options;
+  if (!target)
+    return () => {};
+  let buffer = [], lastTime = 0;
+  const handler = (e) => {
+    const now = Date.now();
+    if (now - lastTime > timeout)
+      buffer = [];
+    lastTime = now;
+    buffer.push(e.key.toLowerCase());
+    if (buffer.length > sequence.length)
+      buffer = buffer.slice(-sequence.length);
+    if (buffer.length === sequence.length) {
+      if (buffer.every((key, i) => key === sequence[i].toLowerCase())) {
+        callback();
+        buffer = [];
+      }
+    }
+  }, t = target;
+  t.addEventListener("keydown", handler);
+  return () => {
+    t.removeEventListener("keydown", handler);
+  };
+}
+export const shortcuts = {
+  save: "ctrl+s",
+  undo: "ctrl+z",
+  redo: "ctrl+shift+z",
+  copy: "ctrl+c",
+  paste: "ctrl+v",
+  cut: "ctrl+x",
+  selectAll: "ctrl+a",
+  find: "ctrl+f",
+  replace: "ctrl+h",
+  newTab: "ctrl+t",
+  closeTab: "ctrl+w",
+  refresh: "ctrl+r",
+  escape: "escape",
+  enter: "enter",
+  saveMac: "meta+s",
+  undoMac: "meta+z",
+  redoMac: "meta+shift+z",
+  copyMac: "meta+c",
+  pasteMac: "meta+v",
+  cutMac: "meta+x"
+};