tool-shack 1.1.1 → 1.1.2

package/dist/cjs/index.cjs

@@ -0,0 +1,1097 @@
+"use strict";
+var __webpack_modules__ = {
+    "./src/browser/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            deleteCookie: ()=>deleteCookie,
+            detectOS: ()=>detectOS,
+            downloadFile: ()=>downloadFile,
+            getCookie: ()=>getCookie,
+            getQueryParams: ()=>getQueryParams,
+            isPageVisible: ()=>isPageVisible,
+            isPushNotificationSupported: ()=>isPushNotificationSupported,
+            isScrollBehaviorSupported: ()=>isScrollBehaviorSupported,
+            isShareSupported: ()=>isShareSupported,
+            isTabFocused: ()=>isTabFocused,
+            isTouchSupported: ()=>isTouchSupported,
+            networkStatusListener: ()=>networkStatusListener,
+            pageVisibilityListener: ()=>pageVisibilityListener,
+            preferColorScheme: ()=>preferColorScheme,
+            preferDarkColorScheme: ()=>preferDarkColorScheme,
+            preferLightColorScheme: ()=>preferLightColorScheme,
+            scrollToElement: ()=>scrollToElement,
+            scrollToPosition: ()=>scrollToPosition,
+            setCookie: ()=>setCookie,
+            tabFocusListener: ()=>tabFocusListener
+        });
+        const setCookie = (name, value, options)=>{
+            let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+            if (options?.days !== void 0) {
+                const expires = new Date(Date.now() + 86400000 * options.days).toUTCString();
+                cookieString += `; expires=${expires}`;
+            }
+            cookieString += `; path=${options?.path ?? '/'}`;
+            if (options?.domain) cookieString += `; domain=${options.domain}`;
+            if (options?.secure) cookieString += '; secure';
+            if (options?.sameSite) cookieString += `; samesite=${options.sameSite}`;
+            document.cookie = cookieString;
+        };
+        const deleteCookie = (name, options)=>{
+            setCookie(name, '', {
+                ...options,
+                days: -1
+            });
+        };
+        const detectOS = ()=>{
+            if ("u" < typeof navigator) return 'unknown';
+            const userAgent = navigator.userAgent.toLowerCase();
+            if (/iphone|ipad|ipod/.test(userAgent)) return 'ios';
+            if (/android/.test(userAgent)) return 'android';
+            if (/macintosh|mac os x/.test(userAgent)) return 'macos';
+            if (/windows|win32|win64/.test(userAgent)) return 'windows';
+            if (/linux/.test(userAgent)) return 'linux';
+            return 'unknown';
+        };
+        const downloadFile = (data, filename, mimeType = 'text/plain')=>{
+            const blob = 'string' == typeof data ? new Blob([
+                data
+            ], {
+                type: mimeType
+            }) : data;
+            const url = URL.createObjectURL(blob);
+            const tempLink = document.createElement('a');
+            tempLink.href = url;
+            tempLink.download = filename;
+            tempLink.style.display = 'none';
+            document.body.appendChild(tempLink);
+            tempLink.click();
+            document.body.removeChild(tempLink);
+            URL.revokeObjectURL(url);
+        };
+        const getCookie = (name)=>{
+            const encodedName = encodeURIComponent(name);
+            for (const part of document.cookie.split(';')){
+                const entry = part.trim();
+                const separatorIndex = entry.indexOf('=');
+                if (-1 !== separatorIndex) {
+                    if (entry.slice(0, separatorIndex) === encodedName) return decodeURIComponent(entry.slice(separatorIndex + 1));
+                }
+            }
+            return null;
+        };
+        const getQueryParams = (url)=>{
+            const result = {};
+            const base = "u" > typeof window ? window.location.href : 'http://localhost/';
+            try {
+                new URL(url ?? base, base).searchParams.forEach((value, key)=>{
+                    result[key] = value;
+                });
+            } catch  {}
+            return result;
+        };
+        const isPageVisible = ()=>!document.hidden;
+        const isPushNotificationSupported = ()=>'Notification' in window && 'serviceWorker' in navigator && 'PushManager' in window;
+        const isScrollBehaviorSupported = ()=>'scrollBehavior' in document.documentElement.style;
+        const isShareSupported = ()=>!!('navigator' in window && 'share' in window.navigator && !!navigator.share);
+        const isTabFocused = isPageVisible;
+        const isTouchSupported = ()=>!!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch);
+        const networkStatusListener = (onOnline, onOffline)=>{
+            const handleOnline = ()=>onOnline?.();
+            const handleOffline = ()=>onOffline?.();
+            window.addEventListener('online', handleOnline);
+            window.addEventListener('offline', handleOffline);
+            return ()=>{
+                window.removeEventListener('online', handleOnline);
+                window.removeEventListener('offline', handleOffline);
+            };
+        };
+        const pageVisibilityListener = (onVisible, onHidden)=>{
+            const handleVisibilityChange = ()=>{
+                if (isPageVisible()) onVisible?.();
+                else onHidden?.();
+            };
+            document.addEventListener('visibilitychange', handleVisibilityChange);
+            return ()=>{
+                document.removeEventListener('visibilitychange', handleVisibilityChange);
+            };
+        };
+        const preferLightColorScheme = ()=>!!window.matchMedia('(prefers-color-scheme: light)').matches;
+        const preferDarkColorScheme = ()=>!!window.matchMedia('(prefers-color-scheme: dark)').matches;
+        const preferColorScheme = ()=>preferLightColorScheme() ? 'light' : 'dark';
+        var getElementOffset = __webpack_require__("./src/dom/getElementOffset.ts");
+        const scrollToPosition = (x, y, smoothScroll = true, target = window)=>{
+            if (smoothScroll && isScrollBehaviorSupported()) target.scrollTo({
+                top: y,
+                left: x,
+                behavior: 'smooth'
+            });
+            else target.scrollTo(x, y);
+        };
+        const scrollToElement = (element, offset = 0, smoothScroll = true)=>{
+            scrollToPosition(0, (0, getElementOffset.M)(element).top - offset, smoothScroll);
+        };
+        const tabFocusListener = pageVisibilityListener;
+    },
+    "./src/dateTime/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            dateAsIso: ()=>dateAsIso,
+            isSameDay: ()=>isSameDay,
+            parseDuration: ()=>parseDuration,
+            timeAgo: ()=>timeAgo
+        });
+        const dateAsIso = (date)=>{
+            const timezoneOffset = date.getTimezoneOffset();
+            let isoFormat = '';
+            isoFormat += `${date.getFullYear()}-${padNumber(date.getMonth() + 1)}-${padNumber(date.getDate())}`;
+            isoFormat += `T${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(date.getSeconds())}`;
+            isoFormat += `${timezoneOffset <= 0 ? '+' : '-'}${padNumber(Math.floor(Math.abs(timezoneOffset) / 60))}:${padNumber(Math.abs(timezoneOffset) % 60)}`;
+            return isoFormat;
+        };
+        const padNumber = (number)=>`${number}`.padStart(2, '0');
+        const isSameDay = (firstDate, secondDate)=>{
+            const dateA = firstDate instanceof Date ? firstDate : new Date(firstDate);
+            const dateB = secondDate instanceof Date ? secondDate : new Date(secondDate);
+            return dateA.getFullYear() === dateB.getFullYear() && dateA.getMonth() === dateB.getMonth() && dateA.getDate() === dateB.getDate();
+        };
+        const parseDuration = (durationInMs)=>{
+            durationInMs = Math.abs(durationInMs);
+            return {
+                days: Math.floor(durationInMs / 86400000),
+                hours: Math.floor(durationInMs / 3600000) % 24,
+                minutes: Math.floor(durationInMs / 60000) % 60,
+                seconds: Math.floor(durationInMs / 1000) % 60,
+                milliseconds: Math.floor(durationInMs) % 1000
+            };
+        };
+        const timeAgo = (date, locale = 'en')=>{
+            const targetDate = date instanceof Date ? date : new Date(date);
+            const diffInSeconds = Math.round((targetDate.getTime() - Date.now()) / 1000);
+            const absDiff = Math.abs(diffInSeconds);
+            const formatter = new Intl.RelativeTimeFormat(locale, {
+                numeric: 'auto'
+            });
+            if (absDiff < 60) return formatter.format(diffInSeconds, 'second');
+            const diffInMinutes = Math.round(diffInSeconds / 60);
+            if (Math.abs(diffInMinutes) < 60) return formatter.format(diffInMinutes, 'minute');
+            const diffInHours = Math.round(diffInMinutes / 60);
+            if (Math.abs(diffInHours) < 24) return formatter.format(diffInHours, 'hour');
+            const diffInDays = Math.round(diffInHours / 24);
+            if (Math.abs(diffInDays) < 30) return formatter.format(diffInDays, 'day');
+            const diffInMonths = Math.round(diffInDays / 30);
+            if (Math.abs(diffInMonths) < 12) return formatter.format(diffInMonths, 'month');
+            const diffInYears = Math.round(diffInDays / 365);
+            return formatter.format(diffInYears, 'year');
+        };
+    },
+    "./src/dom/getElementOffset.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        const getElementOffset = (element)=>{
+            const box = element.getBoundingClientRect();
+            return {
+                top: box.top + window.pageYOffset,
+                left: box.left + window.pageXOffset
+            };
+        };
+        __webpack_require__.d(__webpack_exports__, {}, {
+            M: getElementOffset
+        });
+    },
+    "./src/dom/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            addAsyncEventListener: ()=>addAsyncEventListener,
+            addClickOutsideListener: ()=>addClickOutsideListener,
+            addEventListener: ()=>addEventListener,
+            appendAfter: ()=>appendAfter,
+            appendBefore: ()=>appendBefore,
+            copyToClipboard: ()=>copyToClipboard,
+            createElement: ()=>createElement,
+            fireEvent: ()=>fireEvent,
+            getElementOffset: ()=>getElementOffset.M,
+            isInViewport: ()=>isInViewport,
+            toggleFullscreen: ()=>toggleFullscreen,
+            toggleFullscreenWithFallback: ()=>toggleFullscreenWithFallback,
+            waitForElement: ()=>waitForElement
+        });
+        const addAsyncEventListener = (elementSelector, listeners, acceptBubbling = true)=>{
+            const removals = [];
+            for(const eventName in listeners){
+                const functionList = listeners[eventName] instanceof Array ? listeners[eventName] : [
+                    listeners[eventName]
+                ];
+                functionList.forEach((listener)=>{
+                    const handleEvent = (event)=>{
+                        const target = event.target;
+                        if (!target) return;
+                        if (!acceptBubbling && target.matches(elementSelector)) listener(event);
+                        else if (acceptBubbling && target.closest(elementSelector)) listener(event);
+                    };
+                    document.addEventListener(eventName, handleEvent);
+                    removals.push(()=>{
+                        document.removeEventListener(eventName, handleEvent);
+                    });
+                });
+            }
+            return ()=>{
+                removals.forEach((remove)=>{
+                    remove();
+                });
+            };
+        };
+        const addClickOutsideListener = (element, callback)=>{
+            const handleClick = (event)=>{
+                const target = event.target;
+                if (!!target && !element.contains(target)) callback(event);
+            };
+            document.addEventListener('click', handleClick);
+            return ()=>{
+                document.removeEventListener('click', handleClick);
+            };
+        };
+        const addEventListener = (element, listeners)=>{
+            const elementList = element instanceof Array || element instanceof HTMLCollection || element instanceof NodeList ? Array.from(element) : [
+                element
+            ];
+            elementList.forEach((targetElement)=>{
+                for(const eventName in listeners){
+                    const functionList = listeners[eventName] instanceof Array ? listeners[eventName] : [
+                        listeners[eventName]
+                    ];
+                    functionList.forEach((listener)=>targetElement.addEventListener(eventName, listener));
+                }
+            });
+        };
+        const appendAfter = (newNode, referenceNode)=>!!referenceNode.parentElement?.insertBefore(newNode, referenceNode.nextSibling);
+        const appendBefore = (newNode, referenceNode)=>!!referenceNode.parentElement?.insertBefore(newNode, referenceNode);
+        const copyToClipboard = async (text)=>{
+            try {
+                if ("u" > typeof navigator && navigator.clipboard?.writeText) {
+                    await navigator.clipboard.writeText(text);
+                    return true;
+                }
+            } catch  {}
+            try {
+                const tempTextarea = document.createElement('textarea');
+                tempTextarea.value = text;
+                tempTextarea.style.position = 'fixed';
+                tempTextarea.style.opacity = '0';
+                tempTextarea.style.pointerEvents = 'none';
+                document.body.appendChild(tempTextarea);
+                try {
+                    tempTextarea.focus();
+                    tempTextarea.select();
+                    return document.execCommand('copy');
+                } finally{
+                    document.body.removeChild(tempTextarea);
+                }
+            } catch  {
+                return false;
+            }
+        };
+        function createElement(tagName, props) {
+            const element = document.createElement(tagName);
+            if (props) {
+                const propsRecord = props;
+                for(const key in props){
+                    const value = propsRecord[key];
+                    if ('role' === key) element.setAttribute(key, value);
+                    else if ('aria' === key) for (const [ariaKey, ariaValue] of Object.entries(props.aria))element.setAttribute(`aria-${ariaKey}`, ariaValue);
+                    else if ('style' === key) Object.assign(element.style, props.style);
+                    else if ('children' === key) {
+                        const fragment = document.createDocumentFragment();
+                        for (const child of props.children)if ('string' == typeof child) fragment.appendChild(document.createTextNode(child));
+                        else fragment.appendChild(child);
+                        element.appendChild(fragment);
+                    } else if ('listeners' === key) for(const eventName in props.listeners){
+                        const functionList = props.listeners[eventName] instanceof Array ? props.listeners[eventName] : [
+                            props.listeners[eventName]
+                        ];
+                        functionList.forEach((listener)=>element.addEventListener(eventName, listener));
+                    }
+                    else if ('dataset' === key) Object.assign(element.dataset, props.dataset);
+                    else element[key] = value;
+                }
+            }
+            return element;
+        }
+        const fireEvent = (element, eventType)=>element.dispatchEvent(new Event(eventType));
+        var getElementOffset = __webpack_require__("./src/dom/getElementOffset.ts");
+        const isInViewport = (element, offset = 0)=>{
+            const rect = element.getBoundingClientRect();
+            const windowHeight = window.innerHeight || document.documentElement.clientHeight;
+            const windowWidth = window.innerWidth || document.documentElement.clientWidth;
+            return rect.top <= windowHeight + offset && rect.bottom >= -offset && rect.left <= windowWidth + offset && rect.right >= -offset;
+        };
+        const toggleFullscreen = async (element = document.documentElement)=>{
+            if (document.fullscreenElement) await document.exitFullscreen();
+            else await element.requestFullscreen();
+        };
+        const pseudoFullscreenState = new WeakMap();
+        const restorePseudoFullscreen = (element, state)=>{
+            switch(state.mode){
+                case 'class':
+                    if (state.added) element.classList.remove(state.className);
+                    break;
+                case 'style':
+                    element.style.position = state.position;
+                    element.style.top = state.top;
+                    element.style.left = state.left;
+                    element.style.width = state.width;
+                    element.style.height = state.height;
+                    element.style.zIndex = state.zIndex;
+                    element.style.overflow = state.overflow;
+                    break;
+                default:
+                    {
+                        const _exhaustive = state;
+                        throw new Error(`Unhandled pseudo-fullscreen state: ${_exhaustive}`);
+                    }
+            }
+            pseudoFullscreenState.delete(element);
+        };
+        const toggleFullscreenWithFallback = async (element = document.documentElement, options)=>{
+            const isNativeSupported = 'function' == typeof element.requestFullscreen && 'function' == typeof document.exitFullscreen;
+            if (isNativeSupported) {
+                if (document.fullscreenElement) {
+                    await document.exitFullscreen();
+                    return false;
+                }
+                await element.requestFullscreen();
+                return true;
+            }
+            const existingState = pseudoFullscreenState.get(element);
+            if (existingState) {
+                restorePseudoFullscreen(element, existingState);
+                return false;
+            }
+            const customClass = options?.className;
+            const zIndex = options?.zIndex ?? 9999;
+            if (customClass) {
+                const added = !element.classList.contains(customClass);
+                if (added) element.classList.add(customClass);
+                pseudoFullscreenState.set(element, {
+                    mode: 'class',
+                    className: customClass,
+                    added
+                });
+            } else {
+                const styleState = {
+                    mode: 'style',
+                    position: element.style.position,
+                    top: element.style.top,
+                    left: element.style.left,
+                    width: element.style.width,
+                    height: element.style.height,
+                    zIndex: element.style.zIndex,
+                    overflow: element.style.overflow
+                };
+                element.style.position = 'fixed';
+                element.style.top = '0';
+                element.style.left = '0';
+                element.style.width = '100vw';
+                element.style.height = '100vh';
+                element.style.zIndex = String(zIndex);
+                element.style.overflow = 'auto';
+                pseudoFullscreenState.set(element, styleState);
+            }
+            return true;
+        };
+        const waitForElement = (selector, timeout = 5000, parent = document)=>new Promise((resolve, reject)=>{
+                const existing = parent.querySelector(selector);
+                if (existing) return resolve(existing);
+                const observer = new MutationObserver(()=>{
+                    const el = parent.querySelector(selector);
+                    if (el) {
+                        observer.disconnect();
+                        clearTimeout(timer);
+                        resolve(el);
+                    }
+                });
+                const timer = setTimeout(()=>{
+                    observer.disconnect();
+                    reject(new Error(`Timeout waiting for element matching selector: "${selector}"`));
+                }, timeout);
+                observer.observe(parent instanceof Document ? parent.body || parent.documentElement : parent, {
+                    childList: true,
+                    subtree: true
+                });
+            });
+    },
+    "./src/general/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            chunk: ()=>chunk,
+            clamp: ()=>clamp,
+            groupBy: ()=>groupBy,
+            isEmpty: ()=>isEmpty,
+            isEqual: ()=>isEqual,
+            isNil: ()=>isNil,
+            isValidJson: ()=>isValidJson,
+            pick: ()=>pick,
+            unique: ()=>unique
+        });
+        const chunk = (array, size = 1)=>{
+            if (size <= 0 || !array.length) return [];
+            const result = [];
+            for(let i = 0; i < array.length; i += size)result.push(array.slice(i, i + size));
+            return result;
+        };
+        const clamp = (value, min, max)=>Math.min(Math.max(value, min), max);
+        const groupBy = (array, keyFn)=>{
+            const result = Object.create(null);
+            array.forEach((item, index)=>{
+                const key = keyFn(item, index);
+                if (!result[key]) result[key] = [];
+                result[key].push(item);
+            });
+            return result;
+        };
+        const isNil = (value)=>null == value;
+        const isEmpty = (value)=>{
+            if (value instanceof Function) return false;
+            if (value instanceof Map || value instanceof Set) return 0 === value.size;
+            if (null !== value && 'object' == typeof value && null === Object.getPrototypeOf(value)) return !Object.keys(value).length;
+            return isNil(value) || value instanceof Object && !Object.keys(value).length && Object.getPrototypeOf(value) === Object.prototype || !String(value.valueOf()).length;
+        };
+        const isEqual = (a, b)=>{
+            if (Object.is(a, b)) return true;
+            if (isNil(a) || isNil(b)) return a === b;
+            if (typeof a !== typeof b) return false;
+            if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+            if (a instanceof RegExp && b instanceof RegExp) return a.toString() === b.toString();
+            if (Array.isArray(a) || Array.isArray(b)) {
+                if (!Array.isArray(a) || !Array.isArray(b)) return false;
+                if (a.length !== b.length) return false;
+                for(let index = 0; index < a.length; index++)if (!isEqual(a[index], b[index])) return false;
+                return true;
+            }
+            if ('object' == typeof a && 'object' == typeof b && null !== a && null !== b) {
+                const aRecord = a;
+                const bRecord = b;
+                const aKeys = Object.keys(aRecord);
+                const bKeys = Object.keys(bRecord);
+                if (aKeys.length !== bKeys.length) return false;
+                for (const key of aKeys){
+                    if (!Object.prototype.hasOwnProperty.call(bRecord, key)) return false;
+                    if (!isEqual(aRecord[key], bRecord[key])) return false;
+                }
+                return true;
+            }
+            return false;
+        };
+        const isValidJson = (value)=>{
+            try {
+                JSON.parse(value);
+            } catch  {
+                return false;
+            }
+            return true;
+        };
+        const pick = (object, keys)=>{
+            const result = {};
+            for (const key of keys)if (key in object) result[key] = object[key];
+            return result;
+        };
+        const unique = (array, keyFn)=>{
+            if (!keyFn) return Array.from(new Set(array));
+            const seen = new Set();
+            const result = [];
+            array.forEach((item, index)=>{
+                const key = keyFn(item, index);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    result.push(item);
+                }
+            });
+            return result;
+        };
+    },
+    "./src/schedule/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            debounce: ()=>debounce,
+            retry: ()=>retry,
+            runAnimation: ()=>runAnimation_runAnimation,
+            runAsync: ()=>runAsync,
+            sleep: ()=>sleep,
+            throttle: ()=>throttle
+        });
+        const debounce = (callback, delay = 300)=>{
+            let timer = null;
+            const debounced = (...args)=>{
+                if (null !== timer) clearTimeout(timer);
+                timer = setTimeout(()=>{
+                    callback(...args);
+                    timer = null;
+                }, delay);
+            };
+            debounced.cancel = ()=>{
+                if (null !== timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+            };
+            return debounced;
+        };
+        const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+        const retry = async (asyncOperation, options)=>{
+            const retries = options?.retries ?? 3;
+            const baseDelay = options?.delay ?? 1000;
+            const backoff = options?.backoff ?? true;
+            let lastError;
+            for(let attempt = 0; attempt <= retries; attempt++)try {
+                return await asyncOperation();
+            } catch (error) {
+                lastError = error;
+                if (attempt < retries) {
+                    const currentDelay = backoff ? baseDelay * Math.pow(2, attempt) : baseDelay;
+                    if (currentDelay > 0) await sleep(currentDelay);
+                }
+            }
+            throw lastError;
+        };
+        const runAnimation_runAnimation = (callback, autoStart = true)=>{
+            let isRunning = false;
+            let requestedAnimationFrame = null;
+            const runAnimation = ()=>{
+                requestedAnimationFrame = requestAnimationFrame(()=>{
+                    callback.call(void 0);
+                    if (isRunning) runAnimation();
+                });
+            };
+            const startAnimation = ()=>{
+                if (isRunning) return;
+                isRunning = true;
+                runAnimation();
+            };
+            const stopAnimation = ()=>{
+                if (!isRunning) return;
+                isRunning = false;
+                if (null !== requestedAnimationFrame) cancelAnimationFrame(requestedAnimationFrame);
+            };
+            if (autoStart) startAnimation();
+            return {
+                startAnimation,
+                stopAnimation
+            };
+        };
+        const runAsync = (workerFunction)=>{
+            const worker = new Worker(URL.createObjectURL(new Blob([
+                `postMessage((${workerFunction})());`
+            ])));
+            return new Promise((resolve, reject)=>{
+                worker.onmessage = ({ data })=>{
+                    resolve(data);
+                    worker.terminate();
+                };
+                worker.onerror = (error)=>{
+                    reject(error);
+                    worker.terminate();
+                };
+            });
+        };
+        const throttle = (callback, limit = 300)=>{
+            let timer = null;
+            let lastArgs = null;
+            const throttled = (...args)=>{
+                if (null === timer) {
+                    callback(...args);
+                    timer = setTimeout(()=>{
+                        timer = null;
+                        if (null !== lastArgs) {
+                            const currentArgs = lastArgs;
+                            lastArgs = null;
+                            throttled(...currentArgs);
+                        }
+                    }, limit);
+                } else lastArgs = args;
+            };
+            throttled.cancel = ()=>{
+                if (null !== timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+                lastArgs = null;
+            };
+            return throttled;
+        };
+    },
+    "./src/storage/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            clearLocalStorage: ()=>clearLocalStorage,
+            clearSessionStorage: ()=>clearSessionStorage,
+            getLocalStorage: ()=>getLocalStorage,
+            getSessionStorage: ()=>getSessionStorage,
+            removeLocalStorage: ()=>removeLocalStorage,
+            removeSessionStorage: ()=>removeSessionStorage,
+            setLocalStorage: ()=>setLocalStorage,
+            setSessionStorage: ()=>setSessionStorage
+        });
+        const clearLocalStorage = ()=>{
+            try {
+                if ("u" > typeof localStorage) localStorage.clear();
+            } catch  {}
+        };
+        const clearSessionStorage = ()=>{
+            try {
+                if ("u" > typeof sessionStorage) sessionStorage.clear();
+            } catch  {}
+        };
+        var decodeBase64 = __webpack_require__("./src/string/decodeBase64.ts");
+        const getLocalStorage = (key, fallback = null, options)=>{
+            try {
+                if ("u" < typeof localStorage) return fallback;
+                const raw = localStorage.getItem(key);
+                if (null === raw) return fallback;
+                let json = raw;
+                if (options?.encode) try {
+                    json = (0, decodeBase64.y)(raw);
+                } catch  {
+                    json = raw;
+                }
+                return JSON.parse(json);
+            } catch  {
+                return fallback;
+            }
+        };
+        const getSessionStorage = (key, fallback = null, options)=>{
+            try {
+                if ("u" < typeof sessionStorage) return fallback;
+                const raw = sessionStorage.getItem(key);
+                if (null === raw) return fallback;
+                let json = raw;
+                if (options?.encode) try {
+                    json = (0, decodeBase64.y)(raw);
+                } catch  {
+                    json = raw;
+                }
+                return JSON.parse(json);
+            } catch  {
+                return fallback;
+            }
+        };
+        const removeLocalStorage = (key)=>{
+            try {
+                if ("u" > typeof localStorage) localStorage.removeItem(key);
+            } catch  {}
+        };
+        const removeSessionStorage = (key)=>{
+            try {
+                if ("u" > typeof sessionStorage) sessionStorage.removeItem(key);
+            } catch  {}
+        };
+        var encodeBase64 = __webpack_require__("./src/string/encodeBase64.ts");
+        const setLocalStorage = (key, value, options)=>{
+            try {
+                if ("u" < typeof localStorage) return false;
+                const json = JSON.stringify(value);
+                if (void 0 === json) return false;
+                const payload = options?.encode ? (0, encodeBase64.W)(json) : json;
+                localStorage.setItem(key, payload);
+                return true;
+            } catch  {
+                return false;
+            }
+        };
+        const setSessionStorage = (key, value, options)=>{
+            try {
+                if ("u" < typeof sessionStorage) return false;
+                const json = JSON.stringify(value);
+                if (void 0 === json) return false;
+                const payload = options?.encode ? (0, encodeBase64.W)(json) : json;
+                sessionStorage.setItem(key, payload);
+                return true;
+            } catch  {
+                return false;
+            }
+        };
+    },
+    "./src/string/decodeBase64.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        const decodeBase64 = (value)=>decodeURIComponent(Array.prototype.map.call(atob(value), (character)=>`%${`00${character.charCodeAt(0).toString(16)}`.slice(-2)}`).join(''));
+        __webpack_require__.d(__webpack_exports__, {}, {
+            y: decodeBase64
+        });
+    },
+    "./src/string/encodeBase64.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        const encodeBase64 = (value)=>btoa(encodeURIComponent(value).replace(/%([0-9A-F]{2})/g, (_, p1)=>String.fromCharCode(parseInt(p1, 16))));
+        __webpack_require__.d(__webpack_exports__, {}, {
+            W: encodeBase64
+        });
+    },
+    "./src/string/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            byteSize: ()=>byteSize,
+            camelCase: ()=>camelCase,
+            capitalize: ()=>capitalize,
+            decodeBase64: ()=>decodeBase64.y,
+            encodeBase64: ()=>encodeBase64.W,
+            escapeHTML: ()=>escapeHTML,
+            formatBytes: ()=>formatBytes,
+            kebabCase: ()=>kebabCase,
+            mask: ()=>mask,
+            pascalCase: ()=>pascalCase,
+            randomCryptoString: ()=>randomCryptoString,
+            randomString: ()=>randomString,
+            removeDiacritics: ()=>removeDiacritics,
+            slugify: ()=>slugify,
+            snakeCase: ()=>snakeCase,
+            truncate: ()=>truncate,
+            unescapeHTML: ()=>unescapeHTML
+        });
+        const byteSize = (value)=>new Blob([
+                value
+            ]).size;
+        const removeDiacritics = (value)=>value.normalize('NFD').toString().replace(/[\u0300-\u036f]/g, '');
+        const camelCase = (value)=>removeDiacritics(value).trim().replace(/^[-_\s]+|[-_\s]+$/g, '').replace(/[-_\s]+(.)?/g, (_, character)=>character ? character.toUpperCase() : '').replace(/^[A-Z]/, (character)=>character.toLowerCase());
+        const capitalize = (value)=>value.length ? value.charAt(0).toUpperCase() + value.slice(1) : '';
+        var decodeBase64 = __webpack_require__("./src/string/decodeBase64.ts");
+        var encodeBase64 = __webpack_require__("./src/string/encodeBase64.ts");
+        const escapeHTML = (html)=>html.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+        const formatBytes = (bytes, decimals = 2)=>{
+            if (bytes <= 0 || isNaN(bytes)) return '0 Bytes';
+            const k = 1024;
+            const decimalCount = Math.max(0, decimals);
+            const sizes = [
+                'Bytes',
+                'KB',
+                'MB',
+                'GB',
+                'TB',
+                'PB'
+            ];
+            const index = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
+            const value = bytes / Math.pow(k, index);
+            return `${parseFloat(value.toFixed(decimalCount))} ${sizes[index]}`;
+        };
+        const kebabCase = (value)=>removeDiacritics(value).trim().replace(/([a-z\d])([A-Z])/g, '$1-$2').replace(/[-_\s]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase();
+        const mask = (value, options)=>{
+            const visibleStart = options?.visibleStart ?? 0;
+            const visibleEnd = options?.visibleEnd ?? 0;
+            const maskChar = options?.maskChar ?? '*';
+            if (!value.length) return '';
+            const totalVisible = visibleStart + visibleEnd;
+            if (totalVisible >= value.length) return value;
+            const start = value.slice(0, visibleStart);
+            const end = visibleEnd > 0 ? value.slice(-visibleEnd) : '';
+            const maskedLength = value.length - totalVisible;
+            const maskedMiddle = maskChar.repeat(maskedLength);
+            return `${start}${maskedMiddle}${end}`;
+        };
+        const pascalCase = (value)=>capitalize(camelCase(value));
+        const DEFAULT_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        const randomCryptoString = (length = 16, charset = DEFAULT_CHARSET)=>{
+            const charsetLength = charset.length;
+            const randomValues = new Uint32Array(length);
+            crypto.getRandomValues(randomValues);
+            let result = '';
+            for (const value of randomValues)result += charset.charAt(value % charsetLength);
+            return result;
+        };
+        const randomString_DEFAULT_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        const randomString = (length = 16, charset = randomString_DEFAULT_CHARSET)=>{
+            let result = '';
+            const charsetLength = charset.length;
+            for(let i = 0; i < length; i++)result += charset.charAt(Math.floor(Math.random() * charsetLength));
+            return result;
+        };
+        const slugify = (value, separator = '-')=>{
+            separator = separator.trim().substring(0, 1) || '-';
+            const escapedSeparator = separator.replace(/[.*+?^${}()|[\]\\-]/g, '\\$&');
+            const removeCharsRegex = new RegExp(`[^\\w\\s${escapedSeparator}]`, 'g');
+            const multipleSeparatorsRegex = new RegExp(`${escapedSeparator}+`, 'g');
+            const trimSeparatorsRegex = new RegExp(`^${escapedSeparator}+|${escapedSeparator}+$`, 'g');
+            return removeDiacritics(value.trim().toLowerCase()).replace(removeCharsRegex, '').replace(/\s+/g, separator).replace(multipleSeparatorsRegex, separator).replace(trimSeparatorsRegex, '');
+        };
+        const snakeCase = (value)=>removeDiacritics(value).trim().replace(/([a-z\d])([A-Z])/g, '$1_$2').replace(/[-_\s]+/g, '_').replace(/^_+|_+$/g, '').toLowerCase();
+        const truncate = (value, maxLength, appendedString = '...')=>{
+            if (maxLength < appendedString.length) return appendedString.slice(0, maxLength);
+            return value.length > maxLength ? value.slice(0, maxLength - appendedString.length) + appendedString : value;
+        };
+        const unescapeHTML = (html)=>{
+            const tempTextarea = document.createElement('textarea');
+            tempTextarea.innerHTML = html;
+            return tempTextarea.value;
+        };
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _browser_index_js__rspack_import_0 = __webpack_require__("./src/browser/index.ts");
+    var _dateTime_index_js__rspack_import_1 = __webpack_require__("./src/dateTime/index.ts");
+    var _dom_index_js__rspack_import_2 = __webpack_require__("./src/dom/index.ts");
+    var _general_index_js__rspack_import_3 = __webpack_require__("./src/general/index.ts");
+    var _schedule_index_js__rspack_import_4 = __webpack_require__("./src/schedule/index.ts");
+    var _storage_index_js__rspack_import_5 = __webpack_require__("./src/storage/index.ts");
+    var _string_index_js__rspack_import_6 = __webpack_require__("./src/string/index.ts");
+    __webpack_require__.d(__webpack_exports__, {
+        addAsyncEventListener: ()=>_dom_index_js__rspack_import_2.addAsyncEventListener,
+        addClickOutsideListener: ()=>_dom_index_js__rspack_import_2.addClickOutsideListener,
+        addEventListener: ()=>_dom_index_js__rspack_import_2.addEventListener,
+        appendAfter: ()=>_dom_index_js__rspack_import_2.appendAfter,
+        appendBefore: ()=>_dom_index_js__rspack_import_2.appendBefore,
+        byteSize: ()=>_string_index_js__rspack_import_6.byteSize,
+        camelCase: ()=>_string_index_js__rspack_import_6.camelCase,
+        capitalize: ()=>_string_index_js__rspack_import_6.capitalize,
+        chunk: ()=>_general_index_js__rspack_import_3.chunk,
+        clamp: ()=>_general_index_js__rspack_import_3.clamp,
+        clearLocalStorage: ()=>_storage_index_js__rspack_import_5.clearLocalStorage,
+        clearSessionStorage: ()=>_storage_index_js__rspack_import_5.clearSessionStorage,
+        copyToClipboard: ()=>_dom_index_js__rspack_import_2.copyToClipboard,
+        createElement: ()=>_dom_index_js__rspack_import_2.createElement,
+        dateAsIso: ()=>_dateTime_index_js__rspack_import_1.dateAsIso,
+        debounce: ()=>_schedule_index_js__rspack_import_4.debounce,
+        decodeBase64: ()=>_string_index_js__rspack_import_6.decodeBase64,
+        deleteCookie: ()=>_browser_index_js__rspack_import_0.deleteCookie,
+        detectOS: ()=>_browser_index_js__rspack_import_0.detectOS,
+        downloadFile: ()=>_browser_index_js__rspack_import_0.downloadFile,
+        encodeBase64: ()=>_string_index_js__rspack_import_6.encodeBase64,
+        escapeHTML: ()=>_string_index_js__rspack_import_6.escapeHTML,
+        fireEvent: ()=>_dom_index_js__rspack_import_2.fireEvent,
+        formatBytes: ()=>_string_index_js__rspack_import_6.formatBytes,
+        getCookie: ()=>_browser_index_js__rspack_import_0.getCookie,
+        getElementOffset: ()=>_dom_index_js__rspack_import_2.getElementOffset,
+        getLocalStorage: ()=>_storage_index_js__rspack_import_5.getLocalStorage,
+        getQueryParams: ()=>_browser_index_js__rspack_import_0.getQueryParams,
+        getSessionStorage: ()=>_storage_index_js__rspack_import_5.getSessionStorage,
+        groupBy: ()=>_general_index_js__rspack_import_3.groupBy,
+        isEmpty: ()=>_general_index_js__rspack_import_3.isEmpty,
+        isEqual: ()=>_general_index_js__rspack_import_3.isEqual,
+        isInViewport: ()=>_dom_index_js__rspack_import_2.isInViewport,
+        isNil: ()=>_general_index_js__rspack_import_3.isNil,
+        isPageVisible: ()=>_browser_index_js__rspack_import_0.isPageVisible,
+        isPushNotificationSupported: ()=>_browser_index_js__rspack_import_0.isPushNotificationSupported,
+        isSameDay: ()=>_dateTime_index_js__rspack_import_1.isSameDay,
+        isScrollBehaviorSupported: ()=>_browser_index_js__rspack_import_0.isScrollBehaviorSupported,
+        isShareSupported: ()=>_browser_index_js__rspack_import_0.isShareSupported,
+        isTabFocused: ()=>_browser_index_js__rspack_import_0.isTabFocused,
+        isTouchSupported: ()=>_browser_index_js__rspack_import_0.isTouchSupported,
+        isValidJson: ()=>_general_index_js__rspack_import_3.isValidJson,
+        kebabCase: ()=>_string_index_js__rspack_import_6.kebabCase,
+        mask: ()=>_string_index_js__rspack_import_6.mask,
+        networkStatusListener: ()=>_browser_index_js__rspack_import_0.networkStatusListener,
+        pageVisibilityListener: ()=>_browser_index_js__rspack_import_0.pageVisibilityListener,
+        parseDuration: ()=>_dateTime_index_js__rspack_import_1.parseDuration,
+        pascalCase: ()=>_string_index_js__rspack_import_6.pascalCase,
+        pick: ()=>_general_index_js__rspack_import_3.pick,
+        preferColorScheme: ()=>_browser_index_js__rspack_import_0.preferColorScheme,
+        preferDarkColorScheme: ()=>_browser_index_js__rspack_import_0.preferDarkColorScheme,
+        preferLightColorScheme: ()=>_browser_index_js__rspack_import_0.preferLightColorScheme,
+        randomCryptoString: ()=>_string_index_js__rspack_import_6.randomCryptoString,
+        randomString: ()=>_string_index_js__rspack_import_6.randomString,
+        removeDiacritics: ()=>_string_index_js__rspack_import_6.removeDiacritics,
+        removeLocalStorage: ()=>_storage_index_js__rspack_import_5.removeLocalStorage,
+        removeSessionStorage: ()=>_storage_index_js__rspack_import_5.removeSessionStorage,
+        retry: ()=>_schedule_index_js__rspack_import_4.retry,
+        runAnimation: ()=>_schedule_index_js__rspack_import_4.runAnimation,
+        runAsync: ()=>_schedule_index_js__rspack_import_4.runAsync,
+        scrollToElement: ()=>_browser_index_js__rspack_import_0.scrollToElement,
+        scrollToPosition: ()=>_browser_index_js__rspack_import_0.scrollToPosition,
+        setCookie: ()=>_browser_index_js__rspack_import_0.setCookie,
+        setLocalStorage: ()=>_storage_index_js__rspack_import_5.setLocalStorage,
+        setSessionStorage: ()=>_storage_index_js__rspack_import_5.setSessionStorage,
+        sleep: ()=>_schedule_index_js__rspack_import_4.sleep,
+        slugify: ()=>_string_index_js__rspack_import_6.slugify,
+        snakeCase: ()=>_string_index_js__rspack_import_6.snakeCase,
+        tabFocusListener: ()=>_browser_index_js__rspack_import_0.tabFocusListener,
+        throttle: ()=>_schedule_index_js__rspack_import_4.throttle,
+        timeAgo: ()=>_dateTime_index_js__rspack_import_1.timeAgo,
+        toggleFullscreen: ()=>_dom_index_js__rspack_import_2.toggleFullscreen,
+        toggleFullscreenWithFallback: ()=>_dom_index_js__rspack_import_2.toggleFullscreenWithFallback,
+        truncate: ()=>_string_index_js__rspack_import_6.truncate,
+        unescapeHTML: ()=>_string_index_js__rspack_import_6.unescapeHTML,
+        unique: ()=>_general_index_js__rspack_import_3.unique,
+        waitForElement: ()=>_dom_index_js__rspack_import_2.waitForElement
+    });
+})();
+exports.addAsyncEventListener = __webpack_exports__.addAsyncEventListener;
+exports.addClickOutsideListener = __webpack_exports__.addClickOutsideListener;
+exports.addEventListener = __webpack_exports__.addEventListener;
+exports.appendAfter = __webpack_exports__.appendAfter;
+exports.appendBefore = __webpack_exports__.appendBefore;
+exports.byteSize = __webpack_exports__.byteSize;
+exports.camelCase = __webpack_exports__.camelCase;
+exports.capitalize = __webpack_exports__.capitalize;
+exports.chunk = __webpack_exports__.chunk;
+exports.clamp = __webpack_exports__.clamp;
+exports.clearLocalStorage = __webpack_exports__.clearLocalStorage;
+exports.clearSessionStorage = __webpack_exports__.clearSessionStorage;
+exports.copyToClipboard = __webpack_exports__.copyToClipboard;
+exports.createElement = __webpack_exports__.createElement;
+exports.dateAsIso = __webpack_exports__.dateAsIso;
+exports.debounce = __webpack_exports__.debounce;
+exports.decodeBase64 = __webpack_exports__.decodeBase64;
+exports.deleteCookie = __webpack_exports__.deleteCookie;
+exports.detectOS = __webpack_exports__.detectOS;
+exports.downloadFile = __webpack_exports__.downloadFile;
+exports.encodeBase64 = __webpack_exports__.encodeBase64;
+exports.escapeHTML = __webpack_exports__.escapeHTML;
+exports.fireEvent = __webpack_exports__.fireEvent;
+exports.formatBytes = __webpack_exports__.formatBytes;
+exports.getCookie = __webpack_exports__.getCookie;
+exports.getElementOffset = __webpack_exports__.getElementOffset;
+exports.getLocalStorage = __webpack_exports__.getLocalStorage;
+exports.getQueryParams = __webpack_exports__.getQueryParams;
+exports.getSessionStorage = __webpack_exports__.getSessionStorage;
+exports.groupBy = __webpack_exports__.groupBy;
+exports.isEmpty = __webpack_exports__.isEmpty;
+exports.isEqual = __webpack_exports__.isEqual;
+exports.isInViewport = __webpack_exports__.isInViewport;
+exports.isNil = __webpack_exports__.isNil;
+exports.isPageVisible = __webpack_exports__.isPageVisible;
+exports.isPushNotificationSupported = __webpack_exports__.isPushNotificationSupported;
+exports.isSameDay = __webpack_exports__.isSameDay;
+exports.isScrollBehaviorSupported = __webpack_exports__.isScrollBehaviorSupported;
+exports.isShareSupported = __webpack_exports__.isShareSupported;
+exports.isTabFocused = __webpack_exports__.isTabFocused;
+exports.isTouchSupported = __webpack_exports__.isTouchSupported;
+exports.isValidJson = __webpack_exports__.isValidJson;
+exports.kebabCase = __webpack_exports__.kebabCase;
+exports.mask = __webpack_exports__.mask;
+exports.networkStatusListener = __webpack_exports__.networkStatusListener;
+exports.pageVisibilityListener = __webpack_exports__.pageVisibilityListener;
+exports.parseDuration = __webpack_exports__.parseDuration;
+exports.pascalCase = __webpack_exports__.pascalCase;
+exports.pick = __webpack_exports__.pick;
+exports.preferColorScheme = __webpack_exports__.preferColorScheme;
+exports.preferDarkColorScheme = __webpack_exports__.preferDarkColorScheme;
+exports.preferLightColorScheme = __webpack_exports__.preferLightColorScheme;
+exports.randomCryptoString = __webpack_exports__.randomCryptoString;
+exports.randomString = __webpack_exports__.randomString;
+exports.removeDiacritics = __webpack_exports__.removeDiacritics;
+exports.removeLocalStorage = __webpack_exports__.removeLocalStorage;
+exports.removeSessionStorage = __webpack_exports__.removeSessionStorage;
+exports.retry = __webpack_exports__.retry;
+exports.runAnimation = __webpack_exports__.runAnimation;
+exports.runAsync = __webpack_exports__.runAsync;
+exports.scrollToElement = __webpack_exports__.scrollToElement;
+exports.scrollToPosition = __webpack_exports__.scrollToPosition;
+exports.setCookie = __webpack_exports__.setCookie;
+exports.setLocalStorage = __webpack_exports__.setLocalStorage;
+exports.setSessionStorage = __webpack_exports__.setSessionStorage;
+exports.sleep = __webpack_exports__.sleep;
+exports.slugify = __webpack_exports__.slugify;
+exports.snakeCase = __webpack_exports__.snakeCase;
+exports.tabFocusListener = __webpack_exports__.tabFocusListener;
+exports.throttle = __webpack_exports__.throttle;
+exports.timeAgo = __webpack_exports__.timeAgo;
+exports.toggleFullscreen = __webpack_exports__.toggleFullscreen;
+exports.toggleFullscreenWithFallback = __webpack_exports__.toggleFullscreenWithFallback;
+exports.truncate = __webpack_exports__.truncate;
+exports.unescapeHTML = __webpack_exports__.unescapeHTML;
+exports.unique = __webpack_exports__.unique;
+exports.waitForElement = __webpack_exports__.waitForElement;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "addAsyncEventListener",
+    "addClickOutsideListener",
+    "addEventListener",
+    "appendAfter",
+    "appendBefore",
+    "byteSize",
+    "camelCase",
+    "capitalize",
+    "chunk",
+    "clamp",
+    "clearLocalStorage",
+    "clearSessionStorage",
+    "copyToClipboard",
+    "createElement",
+    "dateAsIso",
+    "debounce",
+    "decodeBase64",
+    "deleteCookie",
+    "detectOS",
+    "downloadFile",
+    "encodeBase64",
+    "escapeHTML",
+    "fireEvent",
+    "formatBytes",
+    "getCookie",
+    "getElementOffset",
+    "getLocalStorage",
+    "getQueryParams",
+    "getSessionStorage",
+    "groupBy",
+    "isEmpty",
+    "isEqual",
+    "isInViewport",
+    "isNil",
+    "isPageVisible",
+    "isPushNotificationSupported",
+    "isSameDay",
+    "isScrollBehaviorSupported",
+    "isShareSupported",
+    "isTabFocused",
+    "isTouchSupported",
+    "isValidJson",
+    "kebabCase",
+    "mask",
+    "networkStatusListener",
+    "pageVisibilityListener",
+    "parseDuration",
+    "pascalCase",
+    "pick",
+    "preferColorScheme",
+    "preferDarkColorScheme",
+    "preferLightColorScheme",
+    "randomCryptoString",
+    "randomString",
+    "removeDiacritics",
+    "removeLocalStorage",
+    "removeSessionStorage",
+    "retry",
+    "runAnimation",
+    "runAsync",
+    "scrollToElement",
+    "scrollToPosition",
+    "setCookie",
+    "setLocalStorage",
+    "setSessionStorage",
+    "sleep",
+    "slugify",
+    "snakeCase",
+    "tabFocusListener",
+    "throttle",
+    "timeAgo",
+    "toggleFullscreen",
+    "toggleFullscreenWithFallback",
+    "truncate",
+    "unescapeHTML",
+    "unique",
+    "waitForElement"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map