@omnitron-dev/prism 0.1.1

package/dist/chunk-WC2WM2JD.js

@@ -0,0 +1,883 @@
+import { createPrismTheme } from './chunk-DXXZ3ITR.js';
+import { defaultPrismConfig } from './chunk-XWL6J6IO.js';
+import { useSettingsStore } from './chunk-DDY7TLUI.js';
+import { createContext, useContext, useMemo, useEffect, useCallback, useState, useRef, createElement } from 'react';
+import createCache from '@emotion/cache';
+import { CacheProvider } from '@emotion/react';
+import { ThemeProvider, useTheme } from '@mui/material/styles';
+import CssBaseline from '@mui/material/CssBaseline';
+import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider';
+import { AdapterDayjs } from '@mui/x-date-pickers/AdapterDayjs';
+import rtlPlugin from 'stylis-plugin-rtl';
+import { useMediaQuery as useMediaQuery$1 } from '@mui/material';
+export { useMediaQuery as useMuiMediaQuery } from '@mui/material';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import useMediaQuery from '@mui/material/useMediaQuery';
+
+var PrismContext = createContext(null);
+PrismContext.displayName = "PrismContext";
+function usePrismContext() {
+  const context = useContext(PrismContext);
+  if (!context) {
+    throw new Error("usePrismContext must be used within a PrismProvider");
+  }
+  return context;
+}
+function usePrefersDarkMode() {
+  return useMediaQuery$1("(prefers-color-scheme: dark)");
+}
+function useResolvedMode(mode) {
+  const prefersDark = usePrefersDarkMode();
+  if (mode === "system") {
+    return prefersDark ? "dark" : "light";
+  }
+  return mode;
+}
+function mergeConfig(base, overrides) {
+  if (!overrides) return base;
+  return {
+    ...base,
+    ...overrides,
+    paths: { ...base.paths, ...overrides.paths },
+    registries: { ...base.registries, ...overrides.registries },
+    theme: { ...base.theme, ...overrides.theme },
+    style: { ...base.style, ...overrides.style },
+    features: { ...base.features, ...overrides.features }
+  };
+}
+var noOpDrawerWarning = () => {
+  if (process.env.NODE_ENV !== "production") {
+    console.warn(
+      "[PrismProvider] Settings drawer is now managed by SettingsProvider. Use useSettingsDrawer() from @omnitron-dev/prism/components/settings instead."
+    );
+  }
+};
+function PrismProvider({
+  children,
+  config: configOverrides,
+  defaultSettings,
+  disableCssBaseline = false,
+  themeOverrides
+}) {
+  const config = useMemo(() => mergeConfig(defaultPrismConfig, configOverrides), [configOverrides]);
+  const {
+    // State values
+    mode: storeMode,
+    preset: storePreset,
+    direction: storeDirection,
+    primaryColor: storePrimaryColor,
+    contrast: storeContrast,
+    compactSidebar,
+    fontSize: storeFontSize,
+    fontFamily: storeFontFamily,
+    navLayout: storeNavLayout,
+    navColor: storeNavColor,
+    // Actions (stable references from Zustand)
+    setMode,
+    toggleMode,
+    setPreset,
+    setDirection,
+    setCompactSidebar,
+    reset: resetSettings
+  } = useSettingsStore();
+  useEffect(() => {
+    if (defaultSettings?.mode) setMode(defaultSettings.mode);
+    if (defaultSettings?.preset) setPreset(defaultSettings.preset);
+    if (defaultSettings?.direction) setDirection(defaultSettings.direction);
+  }, []);
+  const settings = useMemo(
+    () => ({
+      mode: storeMode,
+      preset: storePreset,
+      direction: storeDirection,
+      sidebarCollapsed: compactSidebar,
+      settingsDrawerOpen: false,
+      // Managed by SettingsProvider component
+      primaryColor: storePrimaryColor,
+      contrast: storeContrast,
+      fontSize: storeFontSize,
+      fontFamily: storeFontFamily ?? "Public Sans Variable",
+      navLayout: storeNavLayout,
+      navColor: storeNavColor
+    }),
+    [
+      storeMode,
+      storePreset,
+      storeDirection,
+      compactSidebar,
+      storePrimaryColor,
+      storeContrast,
+      storeFontSize,
+      storeFontFamily,
+      storeNavLayout,
+      storeNavColor
+    ]
+  );
+  const toggleSidebar = useCallback(() => {
+    const current = useSettingsStore.getState().compactSidebar;
+    setCompactSidebar(!current);
+  }, [setCompactSidebar]);
+  const emotionCache = useMemo(
+    () => storeDirection === "rtl" ? createCache({ key: "prism-rtl", stylisPlugins: [rtlPlugin] }) : createCache({ key: "prism-ltr" }),
+    [storeDirection]
+  );
+  useEffect(() => {
+    if (typeof document !== "undefined") {
+      document.documentElement.dir = storeDirection;
+    }
+  }, [storeDirection]);
+  useEffect(() => {
+    if (typeof document !== "undefined") {
+      if (storeFontSize && storeFontSize !== 16) {
+        document.documentElement.style.fontSize = `${storeFontSize}px`;
+      } else {
+        document.documentElement.style.removeProperty("font-size");
+      }
+    }
+  }, [storeFontSize]);
+  const resolvedMode = useResolvedMode(storeMode);
+  const theme = useMemo(
+    () => createPrismTheme({
+      preset: storePreset,
+      mode: resolvedMode,
+      direction: storeDirection,
+      primaryColor: storePrimaryColor || config.theme.primaryColor,
+      typography: config.theme.typography,
+      cssVariables: config.theme.cssVariables,
+      components: config.theme.components,
+      contrast: storeContrast,
+      fontFamily: storeFontFamily,
+      fontSize: storeFontSize,
+      overrides: themeOverrides
+    }),
+    [
+      storePreset,
+      resolvedMode,
+      storeDirection,
+      storePrimaryColor,
+      storeContrast,
+      storeFontSize,
+      storeFontFamily,
+      config.theme,
+      themeOverrides
+    ]
+  );
+  const contextValue = useMemo(
+    () => ({
+      config,
+      theme,
+      settings,
+      // Zustand actions (stable references)
+      setMode,
+      toggleMode,
+      setPreset,
+      setDirection,
+      toggleSidebar,
+      setSidebarCollapsed: setCompactSidebar,
+      resetSettings,
+      // Deprecated drawer controls (no-ops, stable module-level reference)
+      openSettingsDrawer: noOpDrawerWarning,
+      closeSettingsDrawer: noOpDrawerWarning,
+      toggleSettingsDrawer: noOpDrawerWarning
+    }),
+    [
+      config,
+      theme,
+      settings,
+      setMode,
+      toggleMode,
+      setPreset,
+      setDirection,
+      toggleSidebar,
+      setCompactSidebar,
+      resetSettings
+    ]
+  );
+  return /* @__PURE__ */ jsx(CacheProvider, { value: emotionCache, children: /* @__PURE__ */ jsx(PrismContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(ThemeProvider, { theme, children: /* @__PURE__ */ jsxs(LocalizationProvider, { dateAdapter: AdapterDayjs, children: [
+    !disableCssBaseline && /* @__PURE__ */ jsx(CssBaseline, {}),
+    children
+  ] }) }) }) });
+}
+function composeProviders(providers) {
+  const ComposedProviders = ({ children }) => (
+    // Build the provider tree from inside-out (reverse iteration)
+    providers.reduceRight((acc, provider) => {
+      if (Array.isArray(provider)) {
+        const [Component, props] = provider;
+        return createElement(Component, { ...props, children: acc });
+      }
+      return createElement(provider, { children: acc });
+    }, children)
+  );
+  ComposedProviders.displayName = "ComposedProviders";
+  return ComposedProviders;
+}
+function createProviderStack(baseProviders, options = {}) {
+  const { displayName = "ProviderStack" } = options;
+  return (config = {}) => {
+    const { prepend = [], append = [], replace } = config;
+    const providers = replace ?? [...prepend, ...baseProviders, ...append];
+    const Component = composeProviders(providers);
+    Component.displayName = displayName;
+    return Component;
+  };
+}
+function ProviderStack({ providers, children }) {
+  const Provider = useMemo(() => composeProviders(providers), [providers]);
+  return /* @__PURE__ */ jsx(Provider, { children });
+}
+function withProviderProps(Provider, props) {
+  const BoundProvider = ({ children }) => createElement(Provider, { ...props, children });
+  BoundProvider.displayName = `withProviderProps(${Provider.displayName || Provider.name || "Component"})`;
+  return BoundProvider;
+}
+function conditionalProvider(Provider, condition, props) {
+  if (!condition) return null;
+  if (props) {
+    return [Provider, props];
+  }
+  return Provider;
+}
+function filterProviders(providers) {
+  return providers.filter((p) => p != null);
+}
+function useSetState(initialState) {
+  const [state, setInternalState] = useState(initialState);
+  const setState = useCallback((patch) => {
+    setInternalState((prevState) => {
+      const newPartial = typeof patch === "function" ? patch(prevState) : patch;
+      return { ...prevState, ...newPartial };
+    });
+  }, []);
+  const resetState = useCallback(() => {
+    setInternalState(typeof initialState === "function" ? initialState() : initialState);
+  }, [initialState]);
+  return {
+    state,
+    setState,
+    resetState
+  };
+}
+function useMultiSelect(options = {}) {
+  const { initial = [], maxSelections, onChange } = options;
+  const [selected, setInternalSelected] = useState(initial);
+  const selectedSet = useMemo(() => new Set(selected), [selected]);
+  const setSelected = useCallback(
+    (items) => {
+      const limited = maxSelections ? items.slice(0, maxSelections) : items;
+      setInternalSelected(limited);
+      onChange?.(limited);
+    },
+    [maxSelections, onChange]
+  );
+  const isSelected = useCallback((item) => selectedSet.has(item), [selectedSet]);
+  const select = useCallback(
+    (item) => {
+      if (selectedSet.has(item)) return;
+      if (maxSelections && selected.length >= maxSelections) return;
+      const newSelected = [...selected, item];
+      setInternalSelected(newSelected);
+      onChange?.(newSelected);
+    },
+    [selected, selectedSet, maxSelections, onChange]
+  );
+  const deselect = useCallback(
+    (item) => {
+      if (!selectedSet.has(item)) return;
+      const newSelected = selected.filter((s) => s !== item);
+      setInternalSelected(newSelected);
+      onChange?.(newSelected);
+    },
+    [selected, selectedSet, onChange]
+  );
+  const toggle = useCallback(
+    (item) => {
+      if (selectedSet.has(item)) {
+        deselect(item);
+      } else {
+        select(item);
+      }
+    },
+    [selectedSet, select, deselect]
+  );
+  const selectMany = useCallback(
+    (items) => {
+      const toAdd = items.filter((item) => !selectedSet.has(item));
+      if (toAdd.length === 0) return;
+      let newSelected = [...selected, ...toAdd];
+      if (maxSelections) {
+        newSelected = newSelected.slice(0, maxSelections);
+      }
+      setInternalSelected(newSelected);
+      onChange?.(newSelected);
+    },
+    [selected, selectedSet, maxSelections, onChange]
+  );
+  const deselectMany = useCallback(
+    (items) => {
+      const toRemove = new Set(items);
+      const newSelected = selected.filter((s) => !toRemove.has(s));
+      if (newSelected.length === selected.length) return;
+      setInternalSelected(newSelected);
+      onChange?.(newSelected);
+    },
+    [selected, onChange]
+  );
+  const clear = useCallback(() => {
+    if (selected.length === 0) return;
+    setInternalSelected([]);
+    onChange?.([]);
+  }, [selected.length, onChange]);
+  const selectAll = useCallback(
+    (allItems) => {
+      const limited = maxSelections ? allItems.slice(0, maxSelections) : allItems;
+      setInternalSelected(limited);
+      onChange?.(limited);
+    },
+    [maxSelections, onChange]
+  );
+  const isAllSelected = useCallback(
+    (allItems) => {
+      if (allItems.length === 0) return false;
+      return allItems.every((item) => selectedSet.has(item));
+    },
+    [selectedSet]
+  );
+  const isPartiallySelected = useCallback(
+    (allItems) => {
+      if (allItems.length === 0) return false;
+      const selectedCount = allItems.filter((item) => selectedSet.has(item)).length;
+      return selectedCount > 0 && selectedCount < allItems.length;
+    },
+    [selectedSet]
+  );
+  return {
+    selected,
+    count: selected.length,
+    isEmpty: selected.length === 0,
+    isSelected,
+    toggle,
+    select,
+    deselect,
+    selectMany,
+    deselectMany,
+    clear,
+    setSelected,
+    selectAll,
+    isAllSelected,
+    isPartiallySelected
+  };
+}
+function isLocalStorageAvailable() {
+  try {
+    const testKey = "__prism_test__";
+    localStorage.setItem(testKey, testKey);
+    localStorage.removeItem(testKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function serialize(value) {
+  return JSON.stringify(value);
+}
+function deserialize(value, fallback) {
+  if (value === null) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function useLocalStorage(key, initialValue) {
+  const storageAvailable = useMemo(() => isLocalStorageAvailable(), []);
+  const [storedValue, setStoredValue] = useState(() => {
+    if (!storageAvailable) return initialValue;
+    try {
+      const item = localStorage.getItem(key);
+      return deserialize(item, initialValue);
+    } catch (error) {
+      console.warn(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+  const setValue = useCallback(
+    (value) => {
+      setStoredValue((prev) => {
+        const newValue = value instanceof Function ? value(prev) : value;
+        if (storageAvailable) {
+          try {
+            localStorage.setItem(key, serialize(newValue));
+          } catch (error) {
+            console.warn(`Error setting localStorage key "${key}":`, error);
+          }
+        }
+        return newValue;
+      });
+    },
+    [key, storageAvailable]
+  );
+  const removeValue = useCallback(() => {
+    setStoredValue(initialValue);
+    if (storageAvailable) {
+      try {
+        localStorage.removeItem(key);
+      } catch (error) {
+        console.warn(`Error removing localStorage key "${key}":`, error);
+      }
+    }
+  }, [key, initialValue, storageAvailable]);
+  useEffect(() => {
+    if (!storageAvailable) {
+      return void 0;
+    }
+    const handleStorageChange = (event) => {
+      if (event.key === key && event.newValue !== null) {
+        setStoredValue(deserialize(event.newValue, initialValue));
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  }, [key, initialValue, storageAvailable]);
+  return [storedValue, setValue, removeValue];
+}
+function useCopyToClipboard(options = {}) {
+  const { resetTimeout = 2e3, onSuccess, onError } = options;
+  const [state, setState] = useState("idle");
+  const [copiedText, setCopiedText] = useState(null);
+  const timeoutRef = useRef(null);
+  useEffect(
+    () => () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    },
+    []
+  );
+  const reset = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    setState("idle");
+    setCopiedText(null);
+  }, []);
+  const copy = useCallback(
+    async (text) => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = null;
+      }
+      if (!navigator?.clipboard) {
+        const error = new Error("Clipboard API not available");
+        setState("error");
+        onError?.(error);
+        return false;
+      }
+      try {
+        await navigator.clipboard.writeText(text);
+        setCopiedText(text);
+        setState("success");
+        onSuccess?.(text);
+        if (resetTimeout > 0) {
+          timeoutRef.current = setTimeout(reset, resetTimeout);
+        }
+        return true;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to copy");
+        setState("error");
+        onError?.(error);
+        if (resetTimeout > 0) {
+          timeoutRef.current = setTimeout(reset, resetTimeout);
+        }
+        return false;
+      }
+    },
+    [resetTimeout, reset, onSuccess, onError]
+  );
+  return useMemo(
+    () => ({
+      state,
+      copiedText,
+      copy,
+      reset
+    }),
+    [state, copiedText, copy, reset]
+  );
+}
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+function useDebounceCallback(callback, delay = 500) {
+  const timeoutRef = useRef(null);
+  const callbackRef = useRef(callback);
+  const argsRef = useRef(null);
+  callbackRef.current = callback;
+  const cancel = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    argsRef.current = null;
+  }, []);
+  const flush = useCallback(() => {
+    if (timeoutRef.current && argsRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+      callbackRef.current(...argsRef.current);
+      argsRef.current = null;
+    }
+  }, []);
+  const debouncedCallback = useCallback(
+    (...args) => {
+      argsRef.current = args;
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        callbackRef.current(...args);
+        timeoutRef.current = null;
+        argsRef.current = null;
+      }, delay);
+    },
+    [delay]
+  );
+  useEffect(
+    () => () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    },
+    []
+  );
+  return { debouncedCallback, cancel, flush };
+}
+function getTimeParts(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  return { hours, minutes, seconds };
+}
+function formatTime(totalSeconds) {
+  const { hours, minutes, seconds } = getTimeParts(totalSeconds);
+  const pad = (n) => n.toString().padStart(2, "0");
+  if (hours > 0) {
+    return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
+  }
+  return `${pad(minutes)}:${pad(seconds)}`;
+}
+function useCountdown(options) {
+  const { duration, autoStart = false, onComplete, onTick, interval = 1e3 } = options;
+  const [seconds, setSeconds] = useState(duration);
+  const [isRunning, setIsRunning] = useState(autoStart);
+  const intervalRef = useRef(null);
+  const onCompleteRef = useRef(onComplete);
+  const onTickRef = useRef(onTick);
+  useEffect(() => {
+    onCompleteRef.current = onComplete;
+    onTickRef.current = onTick;
+  }, [onComplete, onTick]);
+  useEffect(
+    () => () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    },
+    []
+  );
+  useEffect(() => {
+    if (!isRunning) {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+      return void 0;
+    }
+    intervalRef.current = setInterval(() => {
+      setSeconds((prev) => {
+        const next = prev - 1;
+        onTickRef.current?.(next);
+        if (next <= 0) {
+          setIsRunning(false);
+          onCompleteRef.current?.();
+          return 0;
+        }
+        return next;
+      });
+    }, interval);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [isRunning, interval]);
+  const start = useCallback(() => {
+    if (seconds > 0) {
+      setIsRunning(true);
+    }
+  }, [seconds]);
+  const pause = useCallback(() => {
+    setIsRunning(false);
+  }, []);
+  const reset = useCallback(() => {
+    setIsRunning(false);
+    setSeconds(duration);
+  }, [duration]);
+  const setDuration = useCallback((newDuration) => {
+    setIsRunning(false);
+    setSeconds(newDuration);
+  }, []);
+  return {
+    seconds,
+    isRunning,
+    isFinished: seconds <= 0,
+    formatted: formatTime(seconds),
+    parts: getTimeParts(seconds),
+    start,
+    pause,
+    reset,
+    setDuration
+  };
+}
+function useBreakpoints() {
+  const theme = useTheme();
+  const isXsUp = useMediaQuery(theme.breakpoints.up("xs"));
+  const isSmUp = useMediaQuery(theme.breakpoints.up("sm"));
+  const isMdUp = useMediaQuery(theme.breakpoints.up("md"));
+  const isLgUp = useMediaQuery(theme.breakpoints.up("lg"));
+  const isXlUp = useMediaQuery(theme.breakpoints.up("xl"));
+  const { current, isXs, isSm, isMd, isLg, isXl } = useMemo(() => {
+    let currentBreakpoint = "xs";
+    if (isXlUp) currentBreakpoint = "xl";
+    else if (isLgUp) currentBreakpoint = "lg";
+    else if (isMdUp) currentBreakpoint = "md";
+    else if (isSmUp) currentBreakpoint = "sm";
+    return {
+      current: currentBreakpoint,
+      isXs: !isSmUp,
+      isSm: isSmUp && !isMdUp,
+      isMd: isMdUp && !isLgUp,
+      isLg: isLgUp && !isXlUp,
+      isXl: isXlUp
+    };
+  }, [isXsUp, isSmUp, isMdUp, isLgUp, isXlUp]);
+  const isMobile = !isMdUp;
+  const isTablet = isMdUp && !isLgUp;
+  const isDesktop = isLgUp;
+  const up = useMemo(
+    () => (breakpoint) => {
+      switch (breakpoint) {
+        case "xs":
+          return isXsUp;
+        case "sm":
+          return isSmUp;
+        case "md":
+          return isMdUp;
+        case "lg":
+          return isLgUp;
+        case "xl":
+          return isXlUp;
+        default:
+          return false;
+      }
+    },
+    [isXsUp, isSmUp, isMdUp, isLgUp, isXlUp]
+  );
+  const down = useMemo(
+    () => (breakpoint) => {
+      switch (breakpoint) {
+        case "xs":
+          return false;
+        // Nothing is below xs
+        case "sm":
+          return !isSmUp;
+        case "md":
+          return !isMdUp;
+        case "lg":
+          return !isLgUp;
+        case "xl":
+          return !isXlUp;
+        default:
+          return false;
+      }
+    },
+    [isSmUp, isMdUp, isLgUp, isXlUp]
+  );
+  const only = useMemo(
+    () => (breakpoint) => {
+      switch (breakpoint) {
+        case "xs":
+          return isXs;
+        case "sm":
+          return isSm;
+        case "md":
+          return isMd;
+        case "lg":
+          return isLg;
+        case "xl":
+          return isXl;
+        default:
+          return false;
+      }
+    },
+    [isXs, isSm, isMd, isLg, isXl]
+  );
+  const between = useMemo(
+    () => (start, end) => {
+      const breakpointOrder = ["xs", "sm", "md", "lg", "xl"];
+      const startIndex = breakpointOrder.indexOf(start);
+      const endIndex = breakpointOrder.indexOf(end);
+      const currentIndex = breakpointOrder.indexOf(current);
+      return currentIndex >= startIndex && currentIndex <= endIndex;
+    },
+    [current]
+  );
+  const values = useMemo(
+    () => ({
+      xs: theme.breakpoints.values.xs,
+      sm: theme.breakpoints.values.sm,
+      md: theme.breakpoints.values.md,
+      lg: theme.breakpoints.values.lg,
+      xl: theme.breakpoints.values.xl
+    }),
+    [theme.breakpoints.values]
+  );
+  return {
+    current,
+    isXs,
+    isSm,
+    isMd,
+    isLg,
+    isXl,
+    isMobile,
+    isTablet,
+    isDesktop,
+    up,
+    down,
+    only,
+    between,
+    values
+  };
+}
+function useIsClient() {
+  const [isClient, setIsClient] = useState(false);
+  useEffect(() => {
+    setIsClient(true);
+  }, []);
+  return isClient;
+}
+function useMounted() {
+  const mountedRef = useRef(false);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const isMounted = useCallback(() => mountedRef.current, []);
+  return { isMounted };
+}
+function usePrevious(value) {
+  const ref = useRef(void 0);
+  useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+function useEventListener(eventName, handler, element, options) {
+  const savedHandler = useRef(handler);
+  useEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+  useEffect(() => {
+    const targetElement = element?.current ?? window;
+    if (!targetElement?.addEventListener) {
+      return void 0;
+    }
+    const eventListener = (event) => savedHandler.current(event);
+    targetElement.addEventListener(eventName, eventListener, options);
+    return () => {
+      targetElement.removeEventListener(eventName, eventListener, options);
+    };
+  }, [eventName, element, options]);
+}
+function useClickOutside(handler, providedRef) {
+  const internalRef = useRef(null);
+  const ref = providedRef ?? internalRef;
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+  useEffect(() => {
+    const listener = (event) => {
+      const element = ref.current;
+      if (!element || element.contains(event.target)) {
+        return;
+      }
+      handlerRef.current(event);
+    };
+    document.addEventListener("mousedown", listener);
+    document.addEventListener("touchstart", listener);
+    return () => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, [ref]);
+  return ref;
+}
+function useInterval(callback, delay) {
+  const savedCallback = useRef(callback);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    if (delay === null) {
+      return void 0;
+    }
+    const tick = () => savedCallback.current();
+    const id = setInterval(tick, delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+function useTimeout(callback, delay) {
+  const savedCallback = useRef(callback);
+  const timeoutRef = useRef(null);
+  const [isActive, setIsActive] = useState(true);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  const clear = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+      setIsActive(false);
+    }
+  }, []);
+  const reset = useCallback(() => {
+    clear();
+    timeoutRef.current = setTimeout(() => {
+      savedCallback.current();
+      setIsActive(false);
+    }, delay);
+    setIsActive(true);
+  }, [clear, delay]);
+  useEffect(() => {
+    reset();
+    return clear;
+  }, [reset, clear]);
+  return useMemo(() => ({ reset, clear, isActive }), [reset, clear, isActive]);
+}
+
+export { PrismContext, PrismProvider, ProviderStack, composeProviders, conditionalProvider, createProviderStack, filterProviders, useBreakpoints, useClickOutside, useCopyToClipboard, useCountdown, useDebounce, useDebounceCallback, useEventListener, useInterval, useIsClient, useLocalStorage, useMounted, useMultiSelect, usePrevious, usePrismContext, useSetState, useTimeout, withProviderProps };
+//# sourceMappingURL=chunk-WC2WM2JD.js.map
+//# sourceMappingURL=chunk-WC2WM2JD.js.map