@stacksjs/stx 0.2.95 → 0.2.97

package/dist/components.js

@@ -1,2 +1,213 @@
-// @bun
-import{fp as a,gp as b,hp as c,ip as d}from"./chunk-hbehnm18.js";import"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";export{a as validateComponentProps,d as registerComponentDirectives,c as componentDirective,b as applyPropDefaults};
+import * as path from "node:path";
+import { ErrorCodes, inlineError } from "./error-handling.js";
+import { safeEvaluateObject } from "./safe-evaluator.js";
+import { renderComponentWithSlot } from "./utils.js";
+function parsePropsString(propsString, context) {
+  const props = {};
+  let inner = propsString.trim();
+  if (inner.startsWith("{"))
+    inner = inner.slice(1);
+  if (inner.endsWith("}"))
+    inner = inner.slice(0, -1);
+  inner = inner.trim();
+  if (!inner)
+    return props;
+  let pos = 0;
+  while (pos < inner.length) {
+    while (pos < inner.length && /\s/.test(inner[pos]))
+      pos++;
+    if (pos >= inner.length)
+      break;
+    let key = "";
+    if (inner[pos] === '"' || inner[pos] === "'") {
+      const quote = inner[pos];
+      pos++;
+      while (pos < inner.length && inner[pos] !== quote)
+        if (inner[pos] === "\\" && pos + 1 < inner.length) {
+          key += inner[pos + 1];
+          pos += 2;
+        } else {
+          key += inner[pos];
+          pos++;
+        }
+      pos++;
+    } else
+      while (pos < inner.length && /[\w$]/.test(inner[pos])) {
+        key += inner[pos];
+        pos++;
+      }
+    while (pos < inner.length && /\s/.test(inner[pos]))
+      pos++;
+    if (inner[pos] === ":")
+      pos++;
+    while (pos < inner.length && /\s/.test(inner[pos]))
+      pos++;
+    let value;
+    const valueStart = pos;
+    if (inner[pos] === '"' || inner[pos] === "'") {
+      const quote = inner[pos];
+      pos++;
+      let strValue = "";
+      while (pos < inner.length && inner[pos] !== quote)
+        if (inner[pos] === "\\" && pos + 1 < inner.length) {
+          strValue += inner[pos + 1];
+          pos += 2;
+        } else {
+          strValue += inner[pos];
+          pos++;
+        }
+      pos++;
+      value = strValue;
+    } else if (inner[pos] === "{") {
+      let depth = 1;
+      pos++;
+      while (pos < inner.length && depth > 0) {
+        if (inner[pos] === "{")
+          depth++;
+        else if (inner[pos] === "}")
+          depth--;
+        else if (inner[pos] === '"' || inner[pos] === "'") {
+          const q = inner[pos];
+          pos++;
+          while (pos < inner.length && inner[pos] !== q) {
+            if (inner[pos] === "\\")
+              pos++;
+            pos++;
+          }
+        }
+        pos++;
+      }
+      const objStr = inner.slice(valueStart, pos);
+      value = parsePropsString(objStr, context);
+    } else if (inner[pos] === "[") {
+      let depth = 1;
+      pos++;
+      while (pos < inner.length && depth > 0) {
+        if (inner[pos] === "[")
+          depth++;
+        else if (inner[pos] === "]")
+          depth--;
+        else if (inner[pos] === '"' || inner[pos] === "'") {
+          const q = inner[pos];
+          pos++;
+          while (pos < inner.length && inner[pos] !== q) {
+            if (inner[pos] === "\\")
+              pos++;
+            pos++;
+          }
+        }
+        pos++;
+      }
+      const arrStr = inner.slice(valueStart, pos);
+      try {
+        value = JSON.parse(arrStr.replace(/'/g, '"'));
+      } catch {
+        value = arrStr;
+      }
+    } else {
+      let rawValue = "";
+      while (pos < inner.length && inner[pos] !== "," && !/\s/.test(inner[pos])) {
+        rawValue += inner[pos];
+        pos++;
+      }
+      rawValue = rawValue.trim();
+      if (rawValue === "true")
+        value = !0;
+      else if (rawValue === "false")
+        value = !1;
+      else if (rawValue === "null")
+        value = null;
+      else if (rawValue === "undefined")
+        value = void 0;
+      else if (/^-?\d+(\.\d+)?$/.test(rawValue))
+        value = Number(rawValue);
+      else if (rawValue in context)
+        value = context[rawValue];
+      else
+        value = rawValue;
+    }
+    if (key)
+      props[key] = value;
+    while (pos < inner.length && /\s/.test(inner[pos]))
+      pos++;
+    if (inner[pos] === ",")
+      pos++;
+  }
+  return props;
+}
+export function validateComponentProps(props, schema, componentName) {
+  const errors = [];
+  for (const [propName, definition] of Object.entries(schema)) {
+    const value = props[propName];
+    if (definition.required && (value === void 0 || value === null)) {
+      errors.push(`Component "${componentName}": Missing required prop "${propName}"`);
+      continue;
+    }
+    if (value === void 0 || value === null)
+      continue;
+    const types = Array.isArray(definition.type) ? definition.type : [definition.type];
+    if (!types.includes("any")) {
+      const actualType = getActualType(value);
+      if (!types.includes(actualType))
+        errors.push(`Component "${componentName}": Prop "${propName}" expected ${types.join(" | ")}, got ${actualType}`);
+    }
+    if (definition.validator && !definition.validator(value))
+      errors.push(`Component "${componentName}": Prop "${propName}" failed custom validation`);
+  }
+  return errors;
+}
+export function applyPropDefaults(props, schema) {
+  const result = { ...props };
+  for (const [propName, definition] of Object.entries(schema))
+    if (result[propName] === void 0 && definition.default !== void 0)
+      result[propName] = typeof definition.default === "function" ? definition.default() : definition.default;
+  return result;
+}
+function getActualType(value) {
+  if (Array.isArray(value))
+    return "array";
+  if (value === null)
+    return "null";
+  return typeof value;
+}
+export const componentDirective = {
+  name: "component",
+  handler: async (content, params, context, filePath) => {
+    if (params.length < 1)
+      return inlineError("Component", "component directive requires at least the component name", ErrorCodes.INVALID_DIRECTIVE_SYNTAX);
+    const componentName = params[0].replace(/['"]/g, "");
+    let props = {};
+    if (params.length > 1)
+      try {
+        const propsString = params.slice(1).join(",").trim();
+        if (propsString.startsWith("{")) {
+          props = safeEvaluateObject(propsString, context);
+          if (Object.keys(props).length === 0)
+            props = parsePropsString(propsString, context);
+        } else {
+          const varName = propsString.trim(), contextValue = context[varName];
+          if (contextValue && typeof contextValue === "object" && !Array.isArray(contextValue))
+            props = contextValue;
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Component props parsing error:", message);
+        return inlineError("Component", `Error parsing component props: ${message}`, ErrorCodes.EVALUATION_ERROR);
+      }
+    const options = context.__stx_options || {}, componentsDir = options.componentsDir || "components", dependencies = new Set;
+    if (!context.__processedComponents)
+      context.__processedComponents = new Set;
+    const processedComponents = context.__processedComponents;
+    try {
+      return await renderComponentWithSlot(componentName, props, "", componentsDir, context, filePath, options, processedComponents, dependencies);
+    } catch (error) {
+      console.error("Component rendering error:", error);
+      const msg = error instanceof Error ? error.message : String(error);
+      return inlineError("Component", `Error rendering component: ${msg}`, ErrorCodes.COMPONENT_RENDER_ERROR);
+    }
+  },
+  hasEndTag: !1
+};
+export function registerComponentDirectives() {
+  return [componentDirective];
+}

package/dist/composables/index.js

@@ -1,2 +1,220 @@
-// @bun
-import"../chunk-xv34zbp4.js";export{p as useWindowSize,PA as useWebSocket,lA as useWakeLock,y as useVisibility,ZB as useToggle,h as useTitle,XB as useTimeout,VB as useThrottle,kA as useTextSelection,FA as useTextObserver,B as useStorage,ej as useSpeechSynthesis,sj as useSpeechRecognition,Cj as useShare,H as useSessionStorage,bA as useSelectionPopup,IB as useSearchParams,w as useScroll,TA as useSSE,HB as useRoute,lj as useResizeObserverMultiple,dj as useResizeObserver,C as usePreferredReducedMotion,z as usePreferredLight,x as usePreferredDark,D as usePreferredContrast,Oj as usePost,i as usePointer,gj as usePermissions,Mj as usePermission,ZA as useParallax,M as useOnline,Zj as useNotification,f as useNetwork,CA as useMutationObserver,n as useMouseInElement,a as useMouse,OB as useMeta,q as useMediaQuery,G as useLocalStorage,Gj as useLazyLoad,wA as useLastActive,o as useKeyboard,s as useKeySequence,u as useKeyPressed,L as useIsTablet,F as useIsMobile,Q as useIsDesktop,WB as useInterval,Ij as useIntersectionObserverMultiple,Aj as useIntersectionObserver,Hj as useInfiniteScroll,pA as useIdleState,gA as useIdle,t as useHotkey,m as useGeolocationWatch,b as useGeolocation,Vj as useFullscreen,qB as useFocus,Kj as useFetch,k as useFavicon,rA as useEyeDropper,UA as useEventSource,KB as useEventListener,Bj as useElementVisibility,vA as useElementTextSelection,cj as useElementSize,XA as useDeviceOrientation,YA as useDeviceMotion,SB as useDebouncedValue,RB as useDebounce,DB as useDark,_B as useCounter,mA as useCopySelection,P as useCookies,O as useCookie,aA as useConditionalWakeLock,CB as useColorMode,oA as useColorHistory,Z as useClipboard,$B as useClickOutside,EA as useChildListObserver,VA as useChannel,JA as useBroadcastChannel,E as useBreakpoint,ij as useBattery,cA as useAutoWakeLock,yA as useAutoLogout,DA as useAttributeObserver,Nj as useAsyncData,xB as useAsync,Wj as toggleFullscreen,GA as stopSpeaking,BA as speak,e as shortcuts,Uj as shareWithFallback,Ej as shareURL,Fj as shareText,Lj as shareFiles,Qj as shareCurrentPage,Dj as share,S as setCookie,qA as requestOrientationPermission,qj as requestNotificationPermission,xA as requestMotionPermission,vj as requestMediaPermissions,V as removeCookie,Rj as prefetch,tA as pickColor,bj as permissionGroups,W as parseCookies,_j as notify,xj as notifications,AB as navigate,RA as isWebSocketSupported,nA as isWakeLockSupported,AA as isSpeechSynthesisSupported,jA as isSpeechRecognitionSupported,pj as isPermissionGranted,LA as isMutationObserverSupported,Xj as isInFullscreen,eA as isEyeDropperSupported,fA as isEventSourceSupported,_A as isDeviceOrientationSupported,$A as isDeviceMotionSupported,oj as isCharging,NA as isBroadcastChannelSupported,uA as hexToRgb,sA as hexToHsl,aj as hasResizeObserver,kj as hasNotificationPermission,yj as hasMicrophonePermission,hj as hasGeolocationPermission,wj as hasCameraPermission,tj as hasBattery,GB as goForward,BB as goBack,HA as getVoices,K as getStorageSize,J as getStorageKeys,d as getCurrentPosition,R as getCookie,rj as getBatteryLevel,Tj as createShareableFile,_ as copyToClipboard,I as clearStorage,Pj as clearFetchCache,X as clearCookies,$j as canNotify,l as calculateDistance,KA as broadcast,U as breakpoints};
+export {
+  useStorage,
+  useLocalStorage,
+  useSessionStorage,
+  clearStorage,
+  getStorageKeys,
+  getStorageSize
+} from "./use-storage.js";
+export {
+  useCookie,
+  useCookies,
+  getCookie,
+  setCookie,
+  removeCookie,
+  parseCookies,
+  clearCookies
+} from "./use-cookie.js";
+export {
+  useClipboard,
+  copyToClipboard
+} from "./use-clipboard.js";
+export {
+  useMediaQuery,
+  usePreferredDark,
+  usePreferredLight,
+  usePreferredReducedMotion,
+  usePreferredContrast,
+  useBreakpoint,
+  useIsMobile,
+  useIsTablet,
+  useIsDesktop,
+  breakpoints
+} from "./use-media-query.js";
+export {
+  useNetwork,
+  useOnline
+} from "./use-network.js";
+export {
+  useWindowSize,
+  useScroll,
+  useVisibility,
+  useTitle,
+  useFavicon
+} from "./use-window.js";
+export {
+  useGeolocation,
+  useGeolocationWatch,
+  getCurrentPosition,
+  calculateDistance
+} from "./use-geolocation.js";
+export {
+  useMouse,
+  useMouseInElement,
+  usePointer
+} from "./use-mouse.js";
+export {
+  useKeyboard,
+  useHotkey,
+  useKeyPressed,
+  useKeySequence,
+  shortcuts
+} from "./use-keyboard.js";
+export {
+  useIntersectionObserver,
+  useElementVisibility,
+  useLazyLoad,
+  useInfiniteScroll,
+  useIntersectionObserverMultiple
+} from "./use-intersection-observer.js";
+export {
+  useFetch,
+  useAsyncData,
+  usePost,
+  clearFetchCache,
+  prefetch
+} from "./use-fetch.js";
+export {
+  useFullscreen,
+  toggleFullscreen,
+  isInFullscreen
+} from "./use-fullscreen.js";
+export {
+  useNotification,
+  notify,
+  canNotify,
+  requestNotificationPermission,
+  notifications
+} from "./use-notification.js";
+export {
+  useShare,
+  share,
+  shareURL,
+  shareText,
+  shareFiles,
+  shareCurrentPage,
+  shareWithFallback,
+  createShareableFile
+} from "./use-share.js";
+export {
+  usePermission,
+  usePermissions,
+  isPermissionGranted,
+  hasCameraPermission,
+  hasMicrophonePermission,
+  hasGeolocationPermission,
+  hasNotificationPermission,
+  requestMediaPermissions,
+  permissionGroups
+} from "./use-permissions.js";
+export {
+  useResizeObserver,
+  useResizeObserverMultiple,
+  useElementSize,
+  hasResizeObserver
+} from "./use-resize-observer.js";
+export {
+  useBattery,
+  getBatteryLevel,
+  isCharging,
+  hasBattery
+} from "./use-battery.js";
+export {
+  useSpeechRecognition,
+  useSpeechSynthesis,
+  isSpeechRecognitionSupported,
+  isSpeechSynthesisSupported,
+  speak,
+  stopSpeaking,
+  getVoices
+} from "./use-speech.js";
+export {
+  useBroadcastChannel,
+  broadcast,
+  isBroadcastChannelSupported
+} from "./use-broadcast-channel.js";
+export {
+  useWebSocket,
+  isWebSocketSupported
+} from "./use-websocket.js";
+export {
+  useChannel
+} from "./use-channel.js";
+export {
+  useDeviceOrientation,
+  useDeviceMotion,
+  useParallax,
+  isDeviceOrientationSupported,
+  isDeviceMotionSupported,
+  requestOrientationPermission,
+  requestMotionPermission
+} from "./use-device-orientation.js";
+export {
+  useMutationObserver,
+  useAttributeObserver,
+  useChildListObserver,
+  useTextObserver,
+  isMutationObserverSupported
+} from "./use-mutation-observer.js";
+export {
+  useEventSource,
+  useSSE,
+  isEventSourceSupported
+} from "./use-event-source.js";
+export {
+  useIdle,
+  useIdleState,
+  useLastActive,
+  useAutoLogout
+} from "./use-idle.js";
+export {
+  useTextSelection,
+  useElementTextSelection,
+  useSelectionPopup,
+  useCopySelection
+} from "./use-text-selection.js";
+export {
+  useWakeLock,
+  useAutoWakeLock,
+  useConditionalWakeLock,
+  isWakeLockSupported
+} from "./use-wake-lock.js";
+export {
+  useEyeDropper,
+  useColorHistory,
+  pickColor,
+  hexToRgb,
+  hexToHsl,
+  isEyeDropperSupported
+} from "./use-eye-dropper.js";
+export {
+  navigate,
+  goBack,
+  goForward,
+  useRoute,
+  useSearchParams
+} from "./use-router.js";
+export {
+  useEventListener
+} from "./use-event-listener.js";
+export {
+  useMeta
+} from "./use-meta.js";
+export {
+  useDebounce,
+  useDebouncedValue,
+  useThrottle,
+  useInterval,
+  useTimeout
+} from "./use-timer.js";
+export {
+  useToggle,
+  useCounter,
+  useClickOutside,
+  useFocus,
+  useAsync
+} from "./use-utilities.js";
+export {
+  useColorMode,
+  useDark
+} from "./use-color-mode.js";

package/dist/composables/use-battery.js

@@ -1,2 +1,101 @@
-// @bun
-import"../chunk-xv34zbp4.js";function D(){return typeof navigator<"u"&&"getBattery"in navigator}function K(){return{charging:!1,chargingTime:0,dischargingTime:0,level:1}}function L(){let q=D(),j=K(),x=[],g=null,E=!1,F=()=>{x.forEach((m)=>m(j))},w=()=>{if(g)j={charging:g.charging,chargingTime:g.chargingTime,dischargingTime:g.dischargingTime,level:g.level},F()},G=async()=>{if(E||!q)return;try{let m=navigator;if(m.getBattery)g=await m.getBattery(),j={charging:g.charging,chargingTime:g.chargingTime,dischargingTime:g.dischargingTime,level:g.level},g.addEventListener("chargingchange",w),g.addEventListener("chargingtimechange",w),g.addEventListener("dischargingtimechange",w),g.addEventListener("levelchange",w),E=!0,F()}catch{}},H=()=>{if(g)g.removeEventListener("chargingchange",w),g.removeEventListener("chargingtimechange",w),g.removeEventListener("dischargingtimechange",w),g.removeEventListener("levelchange",w),g=null;E=!1};return{get:()=>j,subscribe:(m)=>{if(x.length===0)G();return x.push(m),m(j),()=>{if(x=x.filter((J)=>J!==m),x.length===0)H()}},isSupported:()=>q,getPercentage:()=>Math.round(j.level*100),isLow:(m=0.2)=>j.level<=m&&!j.charging,isCritical:()=>j.level<=0.1&&!j.charging}}async function M(){if(!D())return null;try{let q=navigator;if(q.getBattery){let j=await q.getBattery();return Math.round(j.level*100)}}catch{}return null}async function N(){if(!D())return null;try{let q=navigator;if(q.getBattery)return(await q.getBattery()).charging}catch{}return null}function O(){return D()}export{L as useBattery,N as isCharging,O as hasBattery,M as getBatteryLevel};
+function isBatterySupported() {
+  return typeof navigator < "u" && "getBattery" in navigator;
+}
+function createInitialState() {
+  return {
+    charging: !1,
+    chargingTime: 0,
+    dischargingTime: 0,
+    level: 1
+  };
+}
+export function useBattery() {
+  const supported = isBatterySupported();
+  let state = createInitialState(), listeners = [], battery = null, initialized = !1;
+  const notify = () => {
+    listeners.forEach((fn) => fn(state));
+  }, updateState = () => {
+    if (battery) {
+      state = {
+        charging: battery.charging,
+        chargingTime: battery.chargingTime,
+        dischargingTime: battery.dischargingTime,
+        level: battery.level
+      };
+      notify();
+    }
+  }, init = async () => {
+    if (initialized || !supported)
+      return;
+    try {
+      const nav = navigator;
+      if (nav.getBattery) {
+        battery = await nav.getBattery();
+        state = {
+          charging: battery.charging,
+          chargingTime: battery.chargingTime,
+          dischargingTime: battery.dischargingTime,
+          level: battery.level
+        };
+        battery.addEventListener("chargingchange", updateState);
+        battery.addEventListener("chargingtimechange", updateState);
+        battery.addEventListener("dischargingtimechange", updateState);
+        battery.addEventListener("levelchange", updateState);
+        initialized = !0;
+        notify();
+      }
+    } catch {}
+  }, cleanup = () => {
+    if (battery) {
+      battery.removeEventListener("chargingchange", updateState);
+      battery.removeEventListener("chargingtimechange", updateState);
+      battery.removeEventListener("dischargingtimechange", updateState);
+      battery.removeEventListener("levelchange", updateState);
+      battery = null;
+    }
+    initialized = !1;
+  };
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      if (listeners.length === 0)
+        init();
+      listeners.push(fn);
+      fn(state);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0)
+          cleanup();
+      };
+    },
+    isSupported: () => supported,
+    getPercentage: () => Math.round(state.level * 100),
+    isLow: (threshold = 0.2) => state.level <= threshold && !state.charging,
+    isCritical: () => state.level <= 0.1 && !state.charging
+  };
+}
+export async function getBatteryLevel() {
+  if (!isBatterySupported())
+    return null;
+  try {
+    const nav = navigator;
+    if (nav.getBattery) {
+      const battery = await nav.getBattery();
+      return Math.round(battery.level * 100);
+    }
+  } catch {}
+  return null;
+}
+export async function isCharging() {
+  if (!isBatterySupported())
+    return null;
+  try {
+    const nav = navigator;
+    if (nav.getBattery)
+      return (await nav.getBattery()).charging;
+  } catch {}
+  return null;
+}
+export function hasBattery() {
+  return isBatterySupported();
+}

package/dist/composables/use-broadcast-channel.js

@@ -1,2 +1,80 @@
-// @bun
-import"../chunk-xv34zbp4.js";function K(){return typeof window<"u"&&"BroadcastChannel"in window}function R(F,D={}){let z=K(),G=new Set,A=new Map,q={isSupported:z,isClosed:!1,channel:null,lastMessage:null,error:null};function H(){G.forEach((j)=>j(q))}function I(j,w){let J=A.get(j);if(J)J.forEach((Q)=>Q(w))}if(z)try{let j=new BroadcastChannel(F);j.onmessage=(w)=>{q={...q,lastMessage:w.data},H(),I("message",w),D.onMessage?.(w)},j.onmessageerror=(w)=>{q={...q,error:Error("Message error")},H(),I("error",w),D.onError?.(w)},q={...q,channel:j}}catch(j){q={...q,error:j}}function M(j){if(q.channel&&!q.isClosed)q.channel.postMessage(j)}function O(){if(q.channel&&!q.isClosed)q.channel.close(),q={...q,isClosed:!0,channel:null},H()}function P(j,w){if(!A.has(j))A.set(j,new Set);return A.get(j).add(w),()=>{A.get(j)?.delete(w)}}return{get:()=>q,subscribe:(j)=>{return G.add(j),j(q),()=>{G.delete(j)}},post:M,close:O,isSupported:()=>z,on:P}}function T(F,D){if(!K())return;let z=new BroadcastChannel(F);z.postMessage(D),z.close()}export{R as useBroadcastChannel,K as isBroadcastChannelSupported,T as broadcast};
+export function isBroadcastChannelSupported() {
+  return typeof window < "u" && "BroadcastChannel" in window;
+}
+export function useBroadcastChannel(channelName, options = {}) {
+  const supported = isBroadcastChannelSupported(), subscribers = new Set, eventListeners = new Map;
+  let state = {
+    isSupported: supported,
+    isClosed: !1,
+    channel: null,
+    lastMessage: null,
+    error: null
+  };
+  function notify() {
+    subscribers.forEach((fn) => fn(state));
+  }
+  function emitEvent(type, event) {
+    const listeners = eventListeners.get(type);
+    if (listeners)
+      listeners.forEach((fn) => fn(event));
+  }
+  if (supported)
+    try {
+      const channel = new BroadcastChannel(channelName);
+      channel.onmessage = (event) => {
+        state = { ...state, lastMessage: event.data };
+        notify();
+        emitEvent("message", event);
+        options.onMessage?.(event);
+      };
+      channel.onmessageerror = (event) => {
+        state = { ...state, error: Error("Message error") };
+        notify();
+        emitEvent("error", event);
+        options.onError?.(event);
+      };
+      state = { ...state, channel };
+    } catch (error) {
+      state = { ...state, error };
+    }
+  function post(message) {
+    if (state.channel && !state.isClosed)
+      state.channel.postMessage(message);
+  }
+  function close() {
+    if (state.channel && !state.isClosed) {
+      state.channel.close();
+      state = { ...state, isClosed: !0, channel: null };
+      notify();
+    }
+  }
+  function on(event, callback) {
+    if (!eventListeners.has(event))
+      eventListeners.set(event, new Set);
+    eventListeners.get(event).add(callback);
+    return () => {
+      eventListeners.get(event)?.delete(callback);
+    };
+  }
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      fn(state);
+      return () => {
+        subscribers.delete(fn);
+      };
+    },
+    post,
+    close,
+    isSupported: () => supported,
+    on
+  };
+}
+export function broadcast(channelName, message) {
+  if (!isBroadcastChannelSupported())
+    return;
+  const channel = new BroadcastChannel(channelName);
+  channel.postMessage(message);
+  channel.close();
+}