@daimo/pay 1.6.1 → 1.6.3

package/build/src/hooks/connectors/useWalletConnectUri.js

@@ -1,93 +0,0 @@
-import { useState, useEffect } from 'react';
-import { useAccount } from 'wagmi';
-import { usePayContext } from '../../components/DaimoPay.js';
-import { useConnect } from '../useConnect.js';
-import { useWalletConnectConnector } from '../useConnectors.js';
-
-function useWalletConnectUri({ enabled } = {
-    enabled: true,
-}) {
-    const { log } = usePayContext();
-    const [uri, setUri] = useState(undefined);
-    const connector = useWalletConnectConnector();
-    const { isConnected } = useAccount();
-    const { connectAsync } = useConnect();
-    useEffect(() => {
-        if (!enabled)
-            return;
-        async function handleMessage(message) {
-            const { type, data } = message;
-            log("WC Message", type, data);
-            if (type === "display_uri") {
-                setUri(data);
-            }
-            /*
-              // This has the URI as well, but we're probably better off using the one in the display_uri event
-              if (type === 'connecting') {
-                const p = await connector.getProvider();
-                const uri = p.signer.uri;
-                setConnectorUri(uri);
-              }
-              */
-        }
-        async function handleDisconnect() {
-            log("WC Disconnect");
-            if (connector)
-                connectWallet(connector);
-        }
-        async function connectWallet(connector) {
-            const result = await connectAsync({ connector });
-            if (result)
-                return result;
-            return false;
-        }
-        async function connectWalletConnect(connector) {
-            try {
-                await connectWallet(connector);
-            }
-            catch (error) {
-                log("catch error");
-                log(error);
-                if (error.code) {
-                    switch (error.code) {
-                        case 4001:
-                            log("error.code - User rejected");
-                            connectWalletConnect(connector); // Regenerate QR code
-                            break;
-                        default:
-                            log("error.code - Unknown Error");
-                            break;
-                    }
-                }
-                else {
-                    // Sometimes the error doesn't respond with a code
-                    log("WalletConnect cannot connect.", error);
-                }
-            }
-        }
-        if (isConnected) {
-            setUri(undefined);
-        }
-        else {
-            if (!connector || uri)
-                return;
-            if (connector && !isConnected) {
-                connectWalletConnect(connector);
-                log("add wc listeners");
-                connector.emitter.on("message", handleMessage);
-                connector.emitter.on("disconnect", handleDisconnect);
-                return () => {
-                    log("remove wc listeners");
-                    connector.emitter.off("message", handleMessage);
-                    connector.emitter.off("disconnect", handleDisconnect);
-                };
-            }
-        }
-    }, [enabled, connector, isConnected]);
-    return {
-        uri,
-    };
-}
-
-export { useWalletConnectUri };
-//# sourceMappingURL=useWalletConnectUri.js.map

package/build/src/hooks/connectors/useWalletConnectUri.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useWalletConnectUri.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useChainIsSupported.js

@@ -1,12 +0,0 @@
-import { useConfig } from 'wagmi';
-
-/** Determines whether the current wagmi configuration supports a given chain. */
-function useChainIsSupported(chainId) {
-    const { chains } = useConfig();
-    if (!chainId)
-        return false;
-    return chains.some((x) => x.id === chainId);
-}
-
-export { useChainIsSupported };
-//# sourceMappingURL=useChainIsSupported.js.map

package/build/src/hooks/useChainIsSupported.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useChainIsSupported.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/build/src/hooks/useChains.js

@@ -1,11 +0,0 @@
-import { useConfig } from 'wagmi';
-
-/** Returns currently configured wagmi chains. */
-function useChains() {
-    const wagmi = useConfig();
-    const chains = wagmi?.chains ?? [];
-    return chains.map((c) => c);
-}
-
-export { useChains };
-//# sourceMappingURL=useChains.js.map

package/build/src/hooks/useChains.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useChains.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/build/src/hooks/useConnect.js

@@ -1,45 +0,0 @@
-import { useConnect as useConnect$1 } from 'wagmi';
-import { usePayContext } from '../components/DaimoPay.js';
-
-/**
- * This is a wrapper around wagmi's useConnect hook that adds some
- * additional functionality.
- */
-function useConnect({ ...props } = {}) {
-    const context = usePayContext();
-    const { connect, connectAsync, connectors, ...rest } = useConnect$1({
-        ...props,
-        mutation: {
-            ...props.mutation,
-            onError(err) {
-                if (err.message) {
-                    if (err.message !== "User rejected request") {
-                        context.log(err.message, err);
-                    }
-                }
-                else {
-                    context.log(`Could not connect.`, err);
-                }
-            },
-        },
-    });
-    return {
-        connect: ({ connector, chainId, mutation, }) => {
-            return connect({
-                connector,
-                chainId: chainId ?? context.options?.initialChainId,
-            }, mutation);
-        },
-        connectAsync: async ({ connector, chainId, mutation, }) => {
-            return connectAsync({
-                connector,
-                chainId: chainId ?? context.options?.initialChainId,
-            }, mutation);
-        },
-        connectors,
-        ...rest,
-    };
-}
-
-export { useConnect };
-//# sourceMappingURL=useConnect.js.map

package/build/src/hooks/useConnect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useConnect.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useConnectCallback.js

@@ -1,18 +0,0 @@
-import { useAccountEffect } from 'wagmi';
-
-const useConnectCallback = ({ onConnect, onDisconnect, }) => {
-    useAccountEffect({
-        onConnect: ({ address, connector, isReconnected }) => {
-            if (!isReconnected) {
-                onConnect?.({
-                    address: address,
-                    connectorId: connector?.id,
-                });
-            }
-        },
-        onDisconnect: () => onDisconnect?.(),
-    });
-};
-
-export { useConnectCallback };
-//# sourceMappingURL=useConnectCallback.js.map

package/build/src/hooks/useConnectCallback.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useConnectCallback.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useConnectors.js

@@ -1,29 +0,0 @@
-import { useConnectors as useConnectors$1 } from 'wagmi';
-
-function useConnectors() {
-    const connectors = useConnectors$1();
-    return connectors ?? [];
-}
-function useConnector(id, uuid) {
-    const connectors = useConnectors();
-    if (id === "injected" && uuid) {
-        return connectors.find((c) => c.id === id && c.name === uuid);
-    }
-    else if (id === "injected") {
-        return connectors.find((c) => c.id === id && c.name.includes("Injected"));
-    }
-    return connectors.find((c) => c.id === id);
-}
-function useWalletConnectConnector() {
-    /*
-    options: {
-      qrcode: false,
-      // or
-      showQrModal: false,
-    }
-    */
-    return useConnector("walletConnect");
-}
-
-export { useConnector, useConnectors, useWalletConnectConnector };
-//# sourceMappingURL=useConnectors.js.map

package/build/src/hooks/useConnectors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useConnectors.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useDaimoPayStatus.js

@@ -1,24 +0,0 @@
-import { writeDaimoPayOrderID } from '@daimo/pay-common';
-import { usePayContext } from '../components/DaimoPay.js';
-
-/** Returns the current payment, or undefined if there is none.
- *
- * Status values:
- * - `payment_unpaid` - the user has not paid yet
- * - `payment_started` - the user has paid & payment is in progress. This status
- *    typically lasts a few seconds.
- * - `payment_completed` - the final call or transfer succeeded
- * - `payment_bounced` - the final call or transfer reverted. Funds were sent
- *    to the payment's configured refund address on the destination chain.
- */
-function useDaimoPayStatus() {
-    const { paymentState } = usePayContext();
-    if (!paymentState || !paymentState.daimoPayOrder)
-        return undefined;
-    const order = paymentState.daimoPayOrder;
-    const paymentId = writeDaimoPayOrderID(order.id);
-    return { paymentId, status: order.intentStatus };
-}
-
-export { useDaimoPayStatus };
-//# sourceMappingURL=useDaimoPayStatus.js.map

package/build/src/hooks/useDaimoPayStatus.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDaimoPayStatus.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useDepositAddressOptions.js

@@ -1,31 +0,0 @@
-import { useState, useEffect } from 'react';
-
-function useDepositAddressOptions({ trpc, usdRequired, mode, }) {
-    const [options, setOptions] = useState([]);
-    const [loading, setLoading] = useState(false);
-    useEffect(() => {
-        const refreshDepositAddressOptions = async (usd, mode) => {
-            setLoading(true);
-            try {
-                const options = await trpc.getDepositAddressOptions.query({
-                    usdRequired: usd,
-                    mode,
-                });
-                setOptions(options);
-            }
-            catch (e) {
-                console.error(e);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        if (usdRequired != null && mode != null) {
-            refreshDepositAddressOptions(usdRequired, mode);
-        }
-    }, [usdRequired, mode]);
-    return { options, loading };
-}
-
-export { useDepositAddressOptions };
-//# sourceMappingURL=useDepositAddressOptions.js.map

package/build/src/hooks/useDepositAddressOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDepositAddressOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useEnsFallbackConfig.js

@@ -1,16 +0,0 @@
-import { createConfig, http } from 'wagmi';
-import { mainnet } from 'wagmi/chains';
-import { useChainIsSupported } from './useChainIsSupported.js';
-
-const ensFallbackConfig = createConfig({
-    chains: [mainnet],
-    transports: {
-        [mainnet.id]: http(),
-    },
-});
-function useEnsFallbackConfig() {
-    return !useChainIsSupported(1) ? ensFallbackConfig : undefined;
-}
-
-export { useEnsFallbackConfig };
-//# sourceMappingURL=useEnsFallbackConfig.js.map

package/build/src/hooks/useEnsFallbackConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useEnsFallbackConfig.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/build/src/hooks/useExternalPaymentOptions.js

@@ -1,49 +0,0 @@
-import { ExternalPaymentOptions } from '@daimo/pay-common';
-import { useState, useEffect } from 'react';
-
-const DEFAULT_EXTERNAL_PAYMENT_OPTIONS = [
-    ExternalPaymentOptions.Coinbase,
-    ExternalPaymentOptions.Binance,
-    ExternalPaymentOptions.Daimo,
-    ExternalPaymentOptions.RampNetwork,
-    ExternalPaymentOptions.Lemon,
-    // Solana and ExternalChains are handled in the SelectMethod component.
-];
-function useExternalPaymentOptions({ trpc, filterIds, platform, usdRequired, mode, }) {
-    const [options, setOptions] = useState([]);
-    const [loading, setLoading] = useState(false);
-    useEffect(() => {
-        const refreshExternalPaymentOptions = async (usd, mode) => {
-            if (!platform)
-                return;
-            setLoading(true);
-            try {
-                const newOptions = await trpc.getExternalPaymentOptions.query({
-                    platform,
-                    mode,
-                    usdRequired: usd,
-                });
-                // Filter out options not in options JSON
-                const enabledExtPaymentOptions = filterIds || DEFAULT_EXTERNAL_PAYMENT_OPTIONS;
-                const filteredOptions = newOptions.filter((option) => enabledExtPaymentOptions.includes(option.id));
-                setOptions(filteredOptions);
-            }
-            catch (error) {
-                console.error(error);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        if (usdRequired != null && mode != null) {
-            refreshExternalPaymentOptions(usdRequired, mode);
-        }
-    }, [usdRequired, filterIds, platform, mode]);
-    return {
-        options,
-        loading,
-    };
-}
-
-export { useExternalPaymentOptions };
-//# sourceMappingURL=useExternalPaymentOptions.js.map

package/build/src/hooks/useExternalPaymentOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useExternalPaymentOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useFitText.js

@@ -1,148 +0,0 @@
-import { useCallback, useRef, useState, useEffect, useLayoutEffect } from 'react';
-import ResizeObserver from 'resize-observer-polyfill';
-
-// https://github.com/saltycrane/use-fit-text
-const LOG_LEVEL = {
-    debug: 10,
-    info: 20,
-    warn: 30,
-    error: 40,
-    none: 100,
-};
-// Suppress `useLayoutEffect` warning when rendering on the server
-// https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85
-const useIsoLayoutEffect = typeof window !== "undefined" &&
-    window.document &&
-    window.document.createElement !== undefined
-    ? useLayoutEffect
-    : useEffect;
-const useFitText = ({ logLevel: logLevelOption = "info", maxFontSize = 100, minFontSize = 20, onFinish, onStart, resolution = 5, } = {}) => {
-    const logLevel = LOG_LEVEL[logLevelOption];
-    const initState = useCallback(() => {
-        return {
-            calcKey: 0,
-            fontSize: maxFontSize,
-            fontSizePrev: minFontSize,
-            fontSizeMax: maxFontSize,
-            fontSizeMin: minFontSize,
-        };
-    }, [maxFontSize, minFontSize]);
-    const ref = useRef(null);
-    const innerHtmlPrevRef = useRef();
-    const isCalculatingRef = useRef(false);
-    const [state, setState] = useState(initState);
-    const { calcKey, fontSize, fontSizeMax, fontSizeMin, fontSizePrev } = state;
-    // Montior div size changes and recalculate on resize
-    let animationFrameId = null;
-    const [ro] = useState(() => new ResizeObserver(() => {
-        animationFrameId = window.requestAnimationFrame(() => {
-            if (isCalculatingRef.current) {
-                return;
-            }
-            onStart && onStart();
-            isCalculatingRef.current = true;
-            // `calcKey` is used in the dependencies array of
-            // `useIsoLayoutEffect` below. It is incremented so that the font size
-            // will be recalculated even if the previous state didn't change (e.g.
-            // when the text fit initially).
-            setState({
-                ...initState(),
-                calcKey: calcKey + 1,
-            });
-        });
-    }));
-    useEffect(() => {
-        if (ref.current) {
-            ro.observe(ref.current);
-        }
-        return () => {
-            animationFrameId && window.cancelAnimationFrame(animationFrameId);
-            ro.disconnect();
-        };
-    }, [animationFrameId, ro]);
-    // Recalculate when the div contents change
-    const innerHtml = ref.current && ref.current.innerHTML;
-    useEffect(() => {
-        if (calcKey === 0 || isCalculatingRef.current)
-            return;
-        if (innerHtml !== innerHtmlPrevRef.current) {
-            onStart && onStart();
-            setState({
-                ...initState(),
-                calcKey: calcKey + 1,
-            });
-        }
-        innerHtmlPrevRef.current = innerHtml;
-    }, [calcKey, initState, innerHtml, onStart]);
-    // Check overflow and resize font
-    useIsoLayoutEffect(() => {
-        // Don't start calculating font size until the `resizeKey` is incremented
-        // above in the `ResizeObserver` callback. This avoids an extra resize
-        // on initialization.
-        if (calcKey === 0) {
-            return;
-        }
-        const isWithinResolution = Math.abs(fontSize - fontSizePrev) <= resolution;
-        const isOverflow = !!ref.current &&
-            (ref.current.scrollHeight > ref.current.offsetHeight ||
-                ref.current.scrollWidth > ref.current.offsetWidth);
-        const isFailed = isOverflow && fontSize === fontSizePrev;
-        const isAsc = fontSize > fontSizePrev;
-        // Return if the font size has been adjusted "enough" (change within `resolution`)
-        // reduce font size by one increment if it's overflowing.
-        if (isWithinResolution) {
-            if (isFailed) {
-                isCalculatingRef.current = false;
-                if (logLevel <= LOG_LEVEL.info) {
-                    console.info(`[use-fit-text] reached \`minFontSize = ${minFontSize}\` without fitting text`);
-                }
-            }
-            else if (isOverflow) {
-                setState({
-                    fontSize: isAsc ? fontSizePrev : fontSizeMin,
-                    fontSizeMax,
-                    fontSizeMin,
-                    fontSizePrev,
-                    calcKey,
-                });
-            }
-            else {
-                isCalculatingRef.current = false;
-                onFinish && onFinish(fontSize);
-            }
-            return;
-        }
-        // Binary search to adjust font size
-        let delta;
-        let newMax = fontSizeMax;
-        let newMin = fontSizeMin;
-        if (isOverflow) {
-            delta = isAsc ? fontSizePrev - fontSize : fontSizeMin - fontSize;
-            newMax = Math.min(fontSizeMax, fontSize);
-        }
-        else {
-            delta = isAsc ? fontSizeMax - fontSize : fontSizePrev - fontSize;
-            newMin = Math.max(fontSizeMin, fontSize);
-        }
-        setState({
-            calcKey,
-            fontSize: fontSize + delta / 2,
-            fontSizeMax: newMax,
-            fontSizeMin: newMin,
-            fontSizePrev: fontSize,
-        });
-    }, [
-        calcKey,
-        fontSize,
-        fontSizeMax,
-        fontSizeMin,
-        fontSizePrev,
-        onFinish,
-        ref,
-        resolution,
-    ]);
-    return { fontSize, ref };
-};
-
-export { useFitText as default };
-//# sourceMappingURL=useFitText.js.map

package/build/src/hooks/useFitText.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFitText.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useFocusTrap.js

@@ -1,60 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { useEffect, useRef } from 'react';
-
-const KEYCODE_TAB = 9;
-function useFocusTrap() {
-    const elRef = useRef(null);
-    function handleFocus(e) {
-        if (!elRef.current)
-            return;
-        var focusableEls = elRef.current.querySelectorAll(`
-        a[href]:not(:disabled),
-        button:not(:disabled),
-        textarea:not(:disabled),
-        input[type="text"]:not(:disabled),
-        input[type="radio"]:not(:disabled),
-        input[type="checkbox"]:not(:disabled),
-        select:not(:disabled)
-      `), firstFocusableEl = focusableEls[0], lastFocusableEl = focusableEls[focusableEls.length - 1];
-        var isTabPressed = e.key === "Tab" || e.keyCode === KEYCODE_TAB;
-        if (!isTabPressed) {
-            return;
-        }
-        if (e.shiftKey) {
-            /* shift + tab */ if (document.activeElement === firstFocusableEl) {
-                lastFocusableEl.focus();
-                e.preventDefault();
-            }
-        } /* tab */
-        else {
-            if (document.activeElement === lastFocusableEl) {
-                firstFocusableEl.focus();
-                e.preventDefault();
-            }
-        }
-    }
-    useEffect(() => {
-        if (elRef.current) {
-            elRef.current.addEventListener("keydown", handleFocus);
-            elRef.current.focus({ preventScroll: true });
-        }
-        return () => {
-            if (elRef.current) {
-                elRef.current.removeEventListener("keydown", handleFocus);
-            }
-        };
-    }, []);
-    return elRef;
-}
-function FocusTrap(props) {
-    const elRef = useFocusTrap();
-    useEffect(() => {
-        if (!elRef.current)
-            return;
-        elRef.current.focus({ preventScroll: true });
-    }, []);
-    return (jsx("div", { ref: elRef, tabIndex: 0, children: props.children }));
-}
-
-export { FocusTrap as default };
-//# sourceMappingURL=useFocusTrap.js.map

package/build/src/hooks/useFocusTrap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFocusTrap.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useGoogleFont.js

@@ -1,45 +0,0 @@
-import { useEffect } from 'react';
-
-function useGoogleFont(font) {
-    useEffect(() => {
-        if (!font)
-            return;
-        font = font.replace(/ /g, "+");
-        const googleapis = document.createElement("link");
-        googleapis.href = `https://fonts.googleapis.com`;
-        googleapis.rel = "preconnect";
-        const gstatic = document.createElement("link");
-        gstatic.href = `https://fonts.gstatic.com`;
-        gstatic.rel = "preconnect";
-        gstatic.crossOrigin = "true";
-        const link = document.createElement("link");
-        link.href = `https://fonts.googleapis.com/css2?family=${font}:wght@400;500;600&display=swap`;
-        link.rel = "stylesheet";
-        document.head.appendChild(googleapis);
-        document.head.appendChild(gstatic);
-        document.head.appendChild(link);
-        return () => {
-            try {
-                document.head.removeChild(googleapis);
-                document.head.removeChild(gstatic);
-                document.head.removeChild(link);
-            }
-            catch { }
-        };
-    }, [font]);
-}
-// TODO: This could be dynamic if theming wasn't set up as css variables
-function useThemeFont(theme) {
-    const themeFonts = {
-        web95: "Lato",
-        retro: "Nunito",
-        midnight: "Inter",
-        minimal: "Inter",
-        rounded: "Nunito",
-    };
-    const font = themeFonts[theme] ?? null;
-    useGoogleFont(font ?? "");
-}
-
-export { useGoogleFont, useThemeFont };
-//# sourceMappingURL=useGoogleFont.js.map

package/build/src/hooks/useGoogleFont.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useGoogleFont.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useIsMobile.js

@@ -1,17 +0,0 @@
-import { useState, useEffect } from 'react';
-import { isMobile } from '../utils/index.js';
-
-function useIsMobile() {
-    const [mobile, setMobile] = useState(isMobile());
-    useEffect(() => {
-        const handleResize = () => {
-            setMobile(isMobile());
-        };
-        window.addEventListener("resize", handleResize);
-        return () => window.removeEventListener("resize", handleResize);
-    }, []);
-    return mobile;
-}
-
-export { useIsMobile as default };
-//# sourceMappingURL=useIsMobile.js.map

package/build/src/hooks/useIsMobile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useIsMobile.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}