@nexus-cross/design-system 1.0.3-beta.1

package/dist/chunks/chunk-UR6JOKVB.mjs

@@ -0,0 +1,65 @@
+import { cn } from './chunk-XALPBGSC.mjs';
+import * as React from 'react';
+import { cva } from 'class-variance-authority';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var textAreaVariants = cva(
+  [
+    "nx:w-full nx:rounded-md nx:border nx:bg-surface-default nx:px-3 nx:py-2 nx:text-sm nx:text-text-primary",
+    "nx:transition-colors nx:duration-200 nx:resize-none",
+    "nx:placeholder:text-text-tertiary",
+    "nx:disabled:cursor-not-allowed nx:disabled:opacity-50"
+  ],
+  {
+    variants: {
+      state: {
+        default: "nx:border-border-default nx:focus:border-text-primary",
+        error: "nx:border-status-negative nx:focus:border-status-negative"
+      }
+    },
+    defaultVariants: { state: "default" }
+  }
+);
+var TextArea = React.forwardRef(
+  ({ className, error, showCount, maxLength, onValueChange, onChange, ...props }, ref) => {
+    const state = error ? "error" : "default";
+    const [count, setCount] = React.useState(0);
+    const handleChange = React.useCallback(
+      (e) => {
+        setCount(e.target.value.length);
+        onValueChange?.(e.target.value);
+        onChange?.(e);
+      },
+      [onValueChange, onChange]
+    );
+    return /* @__PURE__ */ jsxs("div", { className: "nx:flex nx:flex-col", children: [
+      /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          ref,
+          className: cn(textAreaVariants({ state }), className),
+          maxLength,
+          "aria-invalid": error || void 0,
+          onChange: handleChange,
+          ...props
+        }
+      ),
+      showCount && maxLength && /* @__PURE__ */ jsxs(
+        "p",
+        {
+          className: "nx:mt-1 nx:text-right nx:text-xs nx:text-text-tertiary",
+          "aria-live": "polite",
+          "aria-atomic": "true",
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "nx:text-text-primary nx:font-medium", children: count.toLocaleString() }),
+            "/",
+            maxLength.toLocaleString()
+          ]
+        }
+      )
+    ] });
+  }
+);
+TextArea.displayName = "TextArea";
+
+export { TextArea, textAreaVariants };

package/dist/chunks/chunk-VH5FF6DZ.mjs

@@ -0,0 +1,38 @@
+import { cn } from './chunk-XALPBGSC.mjs';
+import * as React from 'react';
+import { cva } from 'class-variance-authority';
+import { jsx } from 'react/jsx-runtime';
+
+var dividerVariants = cva("nx:shrink-0 nx:border-border-default", {
+  variants: {
+    orientation: {
+      horizontal: "nx:w-full nx:border-t",
+      vertical: "nx:self-stretch nx:border-l"
+    },
+    variant: {
+      solid: "nx:border-solid",
+      dashed: "nx:border-dashed",
+      dotted: "nx:border-dotted"
+    }
+  },
+  defaultVariants: {
+    orientation: "horizontal",
+    variant: "solid"
+  }
+});
+var Divider = React.forwardRef(
+  ({ className, orientation, variant, color, style, ...props }, ref) => /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      role: "separator",
+      "aria-orientation": orientation ?? "horizontal",
+      className: cn(dividerVariants({ orientation, variant }), className),
+      style: { ...style, ...color ? { borderColor: color } : {} },
+      ...props
+    }
+  )
+);
+Divider.displayName = "Divider";
+
+export { Divider, dividerVariants };

package/dist/chunks/chunk-WJ2OVQD3.mjs

@@ -0,0 +1,105 @@
+import { cn } from './chunk-XALPBGSC.mjs';
+import * as React from 'react';
+import { Drawer as Drawer$1 } from 'vaul';
+import { cva } from 'class-variance-authority';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var DrawerDirectionCtx = React.createContext("bottom");
+var drawerOverlayVariants = cva("nx:fixed nx:inset-0 nx:z-50 nx:bg-static-black/60", {
+  variants: {
+    blur: {
+      none: "",
+      sm: "nx:backdrop-blur-sm",
+      md: "nx:backdrop-blur-md"
+    }
+  },
+  defaultVariants: { blur: "none" }
+});
+var drawerContentVariants = cva(
+  "nx:fixed nx:z-50 nx:flex nx:flex-col nx:bg-surface-default",
+  {
+    variants: {
+      direction: {
+        bottom: "nx:inset-x-0 nx:bottom-0 nx:mt-24 nx:rounded-t-2xl nx:border-t nx:border-border-default",
+        top: "nx:inset-x-0 nx:top-0 nx:mb-24 nx:rounded-b-2xl nx:border-b nx:border-border-default",
+        left: "nx:inset-y-0 nx:left-0 nx:mr-24 nx:w-[85vw] nx:max-w-sm nx:rounded-r-2xl nx:border-r nx:border-border-default",
+        right: "nx:inset-y-0 nx:right-0 nx:ml-24 nx:w-[85vw] nx:max-w-sm nx:rounded-l-2xl nx:border-l nx:border-border-default"
+      }
+    },
+    defaultVariants: { direction: "bottom" }
+  }
+);
+var DrawerRoot = ({ direction = "bottom", ...props }) => /* @__PURE__ */ jsx(DrawerDirectionCtx.Provider, { value: direction, children: /* @__PURE__ */ jsx(Drawer$1.Root, { shouldScaleBackground: false, direction, ...props }) });
+var DrawerTrigger = (props) => /* @__PURE__ */ jsx(Drawer$1.Trigger, { ...props });
+DrawerTrigger.displayName = "DrawerTrigger";
+var DrawerContent = React.forwardRef(
+  ({
+    className,
+    children,
+    direction: directionProp,
+    showHandle = true,
+    blur,
+    overlayClassName,
+    ...props
+  }, ref) => {
+    const ctxDirection = React.useContext(DrawerDirectionCtx);
+    const direction = directionProp ?? ctxDirection;
+    return /* @__PURE__ */ jsxs(Drawer$1.Portal, { children: [
+      /* @__PURE__ */ jsx(
+        Drawer$1.Overlay,
+        {
+          className: cn(drawerOverlayVariants({ blur }), overlayClassName)
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        Drawer$1.Content,
+        {
+          ref,
+          className: cn(drawerContentVariants({ direction }), className),
+          ...props,
+          children: [
+            showHandle && (direction === "bottom" || direction === "top") && /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: cn(
+                  "nx:flex nx:justify-center",
+                  direction === "bottom" ? "nx:pt-4" : "nx:pb-4"
+                ),
+                children: /* @__PURE__ */ jsx("div", { className: "nx:bg-border-strong nx:h-1.5 nx:w-12 nx:rounded-full" })
+              }
+            ),
+            children
+          ]
+        }
+      )
+    ] });
+  }
+);
+DrawerContent.displayName = "DrawerContent";
+var DrawerClose = (props) => /* @__PURE__ */ jsx(Drawer$1.Close, { ...props });
+DrawerClose.displayName = "DrawerClose";
+var DrawerTitle = ({ className, ...props }) => /* @__PURE__ */ jsx(
+  Drawer$1.Title,
+  {
+    className: cn("nx:text-lg nx:font-semibold nx:text-text-primary", className),
+    ...props
+  }
+);
+DrawerTitle.displayName = "DrawerTitle";
+var DrawerDescription = ({ className, ...props }) => /* @__PURE__ */ jsx(
+  Drawer$1.Description,
+  {
+    className: cn("nx:text-sm nx:text-text-secondary", className),
+    ...props
+  }
+);
+DrawerDescription.displayName = "DrawerDescription";
+var Drawer = Object.assign(DrawerRoot, {
+  Trigger: DrawerTrigger,
+  Content: DrawerContent,
+  Close: DrawerClose,
+  Title: DrawerTitle,
+  Description: DrawerDescription
+});
+
+export { Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerRoot, DrawerTitle, DrawerTrigger, drawerContentVariants, drawerOverlayVariants };

package/dist/chunks/chunk-WNFJ4NJN.mjs

@@ -0,0 +1,55 @@
+import { cn } from './chunk-XALPBGSC.mjs';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var popoverContentClasses = [
+  "nx:z-50 nx:rounded-lg nx:border nx:p-4 nx:shadow-lg nx:outline-none",
+  "nx:bg-surface-default nx:border-border-default nx:text-text-primary",
+  "nx:data-[state=open]:animate-in nx:data-[state=closed]:animate-out",
+  "nx:data-[state=closed]:fade-out-0 nx:data-[state=open]:fade-in-0",
+  "nx:data-[state=closed]:zoom-out-95 nx:data-[state=open]:zoom-in-95",
+  "nx:data-[side=bottom]:slide-in-from-top-2 nx:data-[side=left]:slide-in-from-right-2",
+  "nx:data-[side=right]:slide-in-from-left-2 nx:data-[side=top]:slide-in-from-bottom-2"
+].join(" ");
+var Popover = ({
+  children,
+  trigger,
+  align = "center",
+  side = "bottom",
+  sideOffset = 4,
+  alignOffset,
+  open,
+  onOpenChange,
+  className = "",
+  arrowClassName,
+  onClickTrigger
+}) => {
+  return /* @__PURE__ */ jsxs(PopoverPrimitive.Root, { open, onOpenChange, children: [
+    /* @__PURE__ */ jsx(PopoverPrimitive.Trigger, { asChild: true, onClick: onClickTrigger, children: trigger }),
+    /* @__PURE__ */ jsx(PopoverPrimitive.Portal, { children: /* @__PURE__ */ jsxs(
+      PopoverPrimitive.Content,
+      {
+        align,
+        alignOffset,
+        side,
+        sideOffset,
+        className: cn(popoverContentClasses, className),
+        children: [
+          children,
+          /* @__PURE__ */ jsx(
+            PopoverPrimitive.Arrow,
+            {
+              className: cn("nx:fill-surface-default", arrowClassName)
+            }
+          )
+        ]
+      }
+    ) })
+  ] });
+};
+var PopoverTrigger = PopoverPrimitive.Trigger;
+var PopoverContent = PopoverPrimitive.Content;
+var PopoverArrow = PopoverPrimitive.Arrow;
+var PopoverClose = PopoverPrimitive.Close;
+
+export { Popover, PopoverArrow, PopoverClose, PopoverContent, PopoverTrigger, popoverContentClasses };

package/dist/chunks/chunk-WSWD5ZUJ.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var chunkQJNQCLMV_js = require('./chunk-QJNQCLMV.js');
+var React = require('react');
+var reactSlot = require('@radix-ui/react-slot');
+var classVarianceAuthority = require('class-variance-authority');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var chipVariants = classVarianceAuthority.cva(
+  [
+    "nx:inline-flex nx:items-center nx:gap-1.5 nx:whitespace-nowrap nx:font-medium nx:transition-colors",
+    "nx:select-none nx:rounded-full nx:border",
+    "nx:aria-disabled:opacity-50 nx:aria-disabled:pointer-events-none"
+  ],
+  {
+    variants: {
+      variant: {
+        default: "nx:border-border-default nx:bg-surface-default nx:text-text-primary",
+        filled: "nx:border-transparent nx:bg-surface-hover nx:text-text-primary",
+        outline: "nx:border-border-default nx:bg-transparent nx:text-text-primary",
+        accent: "nx:border-transparent nx:bg-accent-primary/10 nx:text-accent-primary"
+      },
+      size: {
+        sm: "nx:h-6 nx:px-2 nx:text-xs",
+        md: "nx:h-7 nx:px-2.5 nx:text-xs",
+        lg: "nx:h-8 nx:px-3 nx:text-sm"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "md"
+    }
+  }
+);
+var CloseIcon = ({ className }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "svg",
+  {
+    className,
+    viewBox: "0 0 16 16",
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: "2",
+    children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 4l8 8M12 4l-8 8", strokeLinecap: "round" })
+  }
+);
+var Chip = React__namespace.forwardRef(
+  ({
+    className,
+    variant,
+    size,
+    asChild = false,
+    disabled,
+    children,
+    onClose,
+    ...props
+  }, ref) => {
+    const Comp = asChild ? reactSlot.Slot : "div";
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      Comp,
+      {
+        ref,
+        className: chunkQJNQCLMV_js.cn(chipVariants({ variant, size }), className),
+        "aria-disabled": disabled || void 0,
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children }),
+          onClose && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              className: "nx:inline-flex nx:shrink-0 nx:items-center nx:justify-center nx:rounded-full nx:p-0.5 nx:opacity-60 nx:hover:opacity-100 nx:transition-opacity",
+              onClick: disabled ? void 0 : onClose,
+              disabled,
+              "aria-label": "Remove",
+              children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { className: "nx:size-3" })
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+Chip.displayName = "Chip";
+
+exports.Chip = Chip;
+exports.chipVariants = chipVariants;

package/dist/chunks/chunk-XALPBGSC.mjs

@@ -0,0 +1,23 @@
+import { clsx } from 'clsx';
+import { extendTailwindMerge } from 'tailwind-merge';
+
+// src/utils/cn.ts
+var PREFIX = "nx:";
+var twMerge = extendTailwindMerge({ prefix: "nx" });
+function cn(...inputs) {
+  const flat = clsx(inputs);
+  const tokens = flat.split(/\s+/).filter(Boolean);
+  const nxTokens = [];
+  const plainTokens = [];
+  for (const t of tokens) {
+    (t.startsWith(PREFIX) ? nxTokens : plainTokens).push(t);
+  }
+  if (plainTokens.length === 0) return twMerge(flat);
+  if (nxTokens.length === 0) return flat;
+  const prefixed = plainTokens.map((t) => `${PREFIX}${t}`);
+  const prefixedSet = new Set(prefixed);
+  const merged = twMerge([...nxTokens, ...prefixed].join(" "));
+  return merged.split(/\s+/).filter(Boolean).map((cls) => prefixedSet.has(cls) ? cls.slice(PREFIX.length) : cls).join(" ");
+}
+
+export { cn };

package/dist/chunks/chunk-XEHFB62A.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var react = require('react');
+
+// src/hooks/useCheckDevice.ts
+function getMatchMedia(query) {
+  if (typeof window === "undefined") return false;
+  return window.matchMedia(query).matches;
+}
+var DEFAULT_BREAKPOINTS = {
+  mobile: 0,
+  tablet: 768,
+  desktop: 1280
+};
+function buildQueries(bp) {
+  const sorted = Object.entries(bp).sort(([, a], [, b]) => a - b);
+  const queries = {};
+  sorted.forEach(([name, minWidth], i) => {
+    const next = sorted[i + 1];
+    if (minWidth === 0 && next) {
+      queries[name] = `(max-width: ${next[1] - 1}px)`;
+    } else if (!next) {
+      queries[name] = `(min-width: ${minWidth}px)`;
+    } else {
+      queries[name] = `(min-width: ${minWidth}px) and (max-width: ${next[1] - 1}px)`;
+    }
+  });
+  return queries;
+}
+function isLegacy(bp) {
+  if (!bp || typeof bp !== "object") return false;
+  return Object.values(bp).some((v) => typeof v === "string");
+}
+function toLegacyQueries(bp) {
+  return {
+    isDesktop: bp?.isDesktop ?? "(min-width: 1280px)",
+    isTablet: bp?.isTablet ?? "screen and (min-width: 768px) and (max-width: 1279px)",
+    isMobile: bp?.isMobile ?? "(max-width: 767px)"
+  };
+}
+function useCheckDevice(breakPoints) {
+  const serialized = breakPoints ? JSON.stringify(breakPoints) : "";
+  const queries = react.useMemo(() => {
+    if (!breakPoints) return buildQueries(DEFAULT_BREAKPOINTS);
+    if (isLegacy(breakPoints)) return toLegacyQueries(breakPoints);
+    return buildQueries(breakPoints);
+  }, [serialized]);
+  const [result, setResult] = react.useState(() => {
+    const init = {};
+    for (const [key, query] of Object.entries(queries)) {
+      init[key] = getMatchMedia(query);
+    }
+    return init;
+  });
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mqls = Object.entries(queries).map(([key, query]) => ({
+      key,
+      mql: window.matchMedia(query)
+    }));
+    const update = () => {
+      setResult((prev) => {
+        const next = {};
+        let changed = false;
+        for (const { key, mql } of mqls) {
+          next[key] = mql.matches;
+          if (next[key] !== prev[key]) changed = true;
+        }
+        return changed ? next : prev;
+      });
+    };
+    for (const { mql } of mqls) mql.addEventListener("change", update);
+    update();
+    return () => {
+      for (const { mql } of mqls) mql.removeEventListener("change", update);
+    };
+  }, [queries]);
+  return result;
+}
+var useCheckDevice_default = useCheckDevice;
+
+exports.useCheckDevice_default = useCheckDevice_default;

package/dist/chunks/chunk-YEGPB7A7.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var chunkQJNQCLMV_js = require('./chunk-QJNQCLMV.js');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var DefaultSpinner = () => /* @__PURE__ */ jsxRuntime.jsx("div", { className: "nx:flex nx:items-center nx:justify-center nx:py-4", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "nx:h-6 nx:w-6 nx:animate-spin nx:rounded-full nx:border-2 nx:border-border-default nx:border-t-accent-primary" }) });
+var InfiniteScroll = ({
+  className = "",
+  tag = "div",
+  list,
+  scrollTarget = null,
+  rootMargin = 100,
+  loading,
+  loadingElement = /* @__PURE__ */ jsxRuntime.jsx(DefaultSpinner, {}),
+  children,
+  handleLoadMore,
+  ...props
+}) => {
+  const target = react.useRef(null);
+  const listRef = react.useRef(list);
+  const totalCountRef = react.useRef("totalCount" in props ? props.totalCount : void 0);
+  const hasMoreRef = react.useRef("hasMore" in props ? props.hasMore : void 0);
+  const loadingRef = react.useRef(loading);
+  const prevCount = react.useRef(-1);
+  const [count, setCount] = react.useState(0);
+  const io = react.useMemo(() => {
+    if (typeof window === "undefined") return null;
+    return new IntersectionObserver(
+      (entries, observer) => {
+        if (!target.current) return;
+        if (entries[0].intersectionRatio > 0.2) {
+          if (!loadingRef.current) {
+            setCount((v) => v + 1);
+            observer.disconnect();
+          }
+        }
+      },
+      {
+        root: !scrollTarget ? null : "current" in scrollTarget ? scrollTarget.current : scrollTarget,
+        rootMargin: `${rootMargin}px 0px`,
+        threshold: [0.1, 0.2, 0.5, 0.8, 0.9, 1]
+      }
+    );
+  }, [rootMargin, scrollTarget]);
+  const hasNext = react.useCallback(() => {
+    if (!listRef.current || loadingRef.current) return false;
+    if (typeof totalCountRef.current !== "undefined") {
+      return totalCountRef.current > listRef.current.length;
+    }
+    return !!hasMoreRef.current;
+  }, []);
+  react.useEffect(() => {
+    if (count > 0 && prevCount.current < count && (listRef.current ?? []).length && hasNext()) {
+      prevCount.current = count;
+      handleLoadMore();
+    }
+  }, [count, hasNext, handleLoadMore]);
+  react.useEffect(() => {
+    const observeEl = target.current;
+    if (observeEl && io) io.observe(observeEl);
+    return () => {
+      if (observeEl && io) io.unobserve(observeEl);
+    };
+  }, [list, io]);
+  react.useEffect(() => {
+    if ("totalCount" in props) {
+      totalCountRef.current = props.totalCount;
+    } else {
+      hasMoreRef.current = props.hasMore;
+    }
+    listRef.current = [...list || []];
+  }, [list, props]);
+  react.useEffect(() => {
+    loadingRef.current = loading;
+  }, [loading]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chunkQJNQCLMV_js.cn("nx:relative", className), children: [
+    react.createElement(tag, null, children),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: target, className: "nx:relative nx:h-px nx:w-full", children: loading && (list ?? []).length > 0 && loadingElement })
+  ] });
+};
+
+exports.InfiniteScroll = InfiniteScroll;

package/dist/chunks/chunk-YEWKPWK3.mjs

@@ -0,0 +1,80 @@
+import { useMemo, useState, useEffect } from 'react';
+
+// src/hooks/useCheckDevice.ts
+function getMatchMedia(query) {
+  if (typeof window === "undefined") return false;
+  return window.matchMedia(query).matches;
+}
+var DEFAULT_BREAKPOINTS = {
+  mobile: 0,
+  tablet: 768,
+  desktop: 1280
+};
+function buildQueries(bp) {
+  const sorted = Object.entries(bp).sort(([, a], [, b]) => a - b);
+  const queries = {};
+  sorted.forEach(([name, minWidth], i) => {
+    const next = sorted[i + 1];
+    if (minWidth === 0 && next) {
+      queries[name] = `(max-width: ${next[1] - 1}px)`;
+    } else if (!next) {
+      queries[name] = `(min-width: ${minWidth}px)`;
+    } else {
+      queries[name] = `(min-width: ${minWidth}px) and (max-width: ${next[1] - 1}px)`;
+    }
+  });
+  return queries;
+}
+function isLegacy(bp) {
+  if (!bp || typeof bp !== "object") return false;
+  return Object.values(bp).some((v) => typeof v === "string");
+}
+function toLegacyQueries(bp) {
+  return {
+    isDesktop: bp?.isDesktop ?? "(min-width: 1280px)",
+    isTablet: bp?.isTablet ?? "screen and (min-width: 768px) and (max-width: 1279px)",
+    isMobile: bp?.isMobile ?? "(max-width: 767px)"
+  };
+}
+function useCheckDevice(breakPoints) {
+  const serialized = breakPoints ? JSON.stringify(breakPoints) : "";
+  const queries = useMemo(() => {
+    if (!breakPoints) return buildQueries(DEFAULT_BREAKPOINTS);
+    if (isLegacy(breakPoints)) return toLegacyQueries(breakPoints);
+    return buildQueries(breakPoints);
+  }, [serialized]);
+  const [result, setResult] = useState(() => {
+    const init = {};
+    for (const [key, query] of Object.entries(queries)) {
+      init[key] = getMatchMedia(query);
+    }
+    return init;
+  });
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mqls = Object.entries(queries).map(([key, query]) => ({
+      key,
+      mql: window.matchMedia(query)
+    }));
+    const update = () => {
+      setResult((prev) => {
+        const next = {};
+        let changed = false;
+        for (const { key, mql } of mqls) {
+          next[key] = mql.matches;
+          if (next[key] !== prev[key]) changed = true;
+        }
+        return changed ? next : prev;
+      });
+    };
+    for (const { mql } of mqls) mql.addEventListener("change", update);
+    update();
+    return () => {
+      for (const { mql } of mqls) mql.removeEventListener("change", update);
+    };
+  }, [queries]);
+  return result;
+}
+var useCheckDevice_default = useCheckDevice;
+
+export { useCheckDevice_default };