@cyberskill/shared 3.0.0 → 3.2.0

package/dist/react/next-intl/next-intl.hoc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-intl.hoc.js","sources":["../../../src/react/next-intl/next-intl.hoc.tsx"],"sourcesContent":["import type { ComponentType } from 'react';\n\nimport { NextIntlClientProvider } from 'next-intl';\nimport * as React from 'react';\n\nimport type { I_Children } from '#typescript/index.js';\n\nimport type { I_NextIntlLanguage, T_NextIntlMessageList } from './next-intl.type.js';\n\nimport { log } from '../log/index.js';\nimport { NEXT_INTL_DEFAULT_LANGUAGE } from './next-intl.constant.js';\nimport { useNextIntl } from './next-intl.hook.js';\n\n/**\n * Higher-Order Component (HOC) that wraps components with Next.js internationalization support.\n * This HOC provides internationalization capabilities to React components by wrapping them\n * with the NextIntlClientProvider. It automatically handles language detection, message\n * loading, and timezone configuration based on the current language settings.\n *\n * Features:\n * - Automatic language detection and message loading\n * - Timezone configuration based on language settings\n * - Fallback to default language when messages are missing\n * - Warning logging for missing message configurations\n * - Proper display name preservation for debugging\n *\n * @param Component - The React component to wrap with internationalization support.\n * @returns A new component with internationalization capabilities and additional props for languages and messages.\n */\nexport function withNextIntl<T extends I_Children>(Component: ComponentType<T>) {\n    const PageWithI18n = (props: T & { languages: I_NextIntlLanguage[]; messages: T_NextIntlMessageList }) => {\n        const { currentLanguage } = useNextIntl();\n        const { messages, languages } = props;\n        const defaultLang = 'en';\n\n        const defaultMessages = messages[currentLanguage?.value || defaultLang];\n        const timeZone = languages.find(lang => lang.value === currentLanguage?.value)?.timezone ?? NEXT_INTL_DEFAULT_LANGUAGE.timezone;\n\n        if (!messages) {\n            log.warn(`Missing messages for language: ${currentLanguage?.value || defaultLang}`);\n            return null;\n        }\n\n        return (\n            <NextIntlClientProvider\n                locale={currentLanguage?.value || defaultLang}\n                messages={defaultMessages || null}\n                timeZone={timeZone}\n            >\n                <Component {...(props as T)} />\n            </NextIntlClientProvider>\n        );\n    };\n\n    PageWithI18n.displayName = `withNextIntl(${Component.displayName || Component.name || 'Component'})`;\n\n    return PageWithI18n;\n}\n"],"names":["withNextIntl","Component","PageWithI18n","props","currentLanguage","useNextIntl","messages","languages","defaultLang","defaultMessages","timeZone","lang","NEXT_INTL_DEFAULT_LANGUAGE","React","NextIntlClientProvider","log"],"mappings":";;;;;AA6BO,SAASA,EAAmCC,GAA6B;AAC5E,QAAMC,IAAe,CAACC,MAAoF;AACtG,UAAM,EAAE,iBAAAC,EAAA,IAAoBC,EAAA,GACtB,EAAE,UAAAC,GAAU,WAAAC,EAAA,IAAcJ,GAC1BK,IAAc,MAEdC,IAAkBH,EAASF,GAAiB,SAASI,CAAW,GAChEE,IAAWH,EAAU,KAAK,CAAAI,MAAQA,EAAK,UAAUP,GAAiB,KAAK,GAAG,YAAYQ,EAA2B;AAEvH,WAAKN,IAMD,gBAAAO,EAAA;AAAA,MAACC;AAAA,MAAA;AAAA,QACG,QAAQV,GAAiB,SAASI;AAAA,QAClC,UAAUC,KAAmB;AAAA,QAC7B,UAAAC;AAAA,MAAA;AAAA,MAEA,gBAAAG,EAAA,cAACZ,GAAA,EAAW,GAAIE,EAAA,CAAa;AAAA,IAAA,KAVjCY,EAAI,KAAK,kCAAkCX,GAAiB,SAASI,CAAW,EAAE,GAC3E;AAAA,EAYf;AAEA,SAAAN,EAAa,cAAc,gBAAgBD,EAAU,eAAeA,EAAU,QAAQ,WAAW,KAE1FC;AACX;"}

package/dist/react/next-intl/next-intl.hook.js

@@ -12,3 +12,4 @@ export {
   u as useNextIntl,
   x as useTranslateNextIntl
 };
+//# sourceMappingURL=next-intl.hook.js.map

package/dist/react/next-intl/next-intl.hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-intl.hook.js","sources":["../../../src/react/next-intl/next-intl.hook.tsx"],"sourcesContent":["import { useTranslations } from 'next-intl';\nimport { use } from 'react';\n\nimport type { I_NextIntlContext } from './next-intl.type.js';\n\nimport { NextIntlContext } from './next-intl.context.js';\n\n/**\n * React hook that provides access to Next.js internationalization context.\n * This hook retrieves the Next.js internationalization context which contains\n * language information and language switching functionality. It provides a\n * convenient way to access internationalization features within components.\n *\n * The hook will throw an error if used outside of a NextIntlProvider,\n * ensuring proper context usage and providing clear error messages for debugging.\n *\n * @returns The Next.js internationalization context containing language state and control methods.\n * @throws {Error} When used outside of a NextIntlProvider context.\n */\nexport function useNextIntl(): I_NextIntlContext {\n    const context = use(NextIntlContext);\n\n    if (!context) {\n        throw new Error('useNextIntl must be used within a NextIntlProvider');\n    }\n\n    return context;\n}\n\n/**\n * React hook that provides Next.js translation functionality.\n * This hook is a wrapper around next-intl's useTranslations hook,\n * providing access to translation functions and current locale information.\n * It enables internationalization features including text translation,\n * locale switching, and pluralization support for Next.js applications.\n *\n * @returns The useTranslations hook result with translation functions and locale information.\n */\nexport const useTranslateNextIntl: typeof useTranslations = useTranslations;\n"],"names":["useTranslations","use","NextIntlContext","useNextIntl","context","useTranslateNextIntl"],"mappings":"AAmBO,SAAA,mBAAAA,SAAA;AAAA,SAAA,OAAAC,SAAA;AAAA,SAAA,mBAAAC,SAAA;AAAA,SAASC,IAAiC;AAC7C,QAAMC,IAAUH,EAAIC,CAAe;AAEnC,MAAI,CAACE;AACD,UAAM,IAAI,MAAM,oDAAoD;AAGxE,SAAOA;AACX;AAWO,MAAMC,IAA+CL;"}

package/dist/react/next-intl/next-intl.provider.js

@@ -22,3 +22,4 @@ function I({
 export {
   I as NextIntlProvider
 };
+//# sourceMappingURL=next-intl.provider.js.map

package/dist/react/next-intl/next-intl.provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-intl.provider.js","sources":["../../../src/react/next-intl/next-intl.provider.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMemo } from 'react';\n\nimport type { I_Children } from '#typescript/index.js';\n\nimport type { I_NextIntlLanguage, I_NextIntlProviderProps } from './next-intl.type.js';\n\nimport { useStorage } from '../storage/index.js';\nimport { NEXT_INTL_DEFAULT_LANGUAGE } from './next-intl.constant.js';\nimport { NextIntlContext } from './next-intl.context.js';\nimport { withNextIntl } from './next-intl.hoc.js';\n\n/**\n * Base component that serves as a wrapper for the withNextIntl HOC.\n * This component is used internally by the NextIntlProvider to create\n * the language wrapper component with internationalization capabilities.\n *\n * @param props - Component props containing children.\n * @param props.children - React children to be wrapped with internationalization support.\n * @returns A React component that passes through its children.\n */\nfunction LanguageWrapperBase({ children }: I_Children) {\n    return <>{children}</>;\n}\n\nconst LanguageWrapper = withNextIntl(LanguageWrapperBase);\n\n/**\n * Provider component that manages Next.js internationalization state and provides i18n context.\n * This component sets up a complete internationalization system for Next.js applications,\n * including language management, message loading, and persistent language preferences.\n * It integrates with the storage system to remember user language choices and provides\n * a comprehensive i18n context to all child components.\n *\n * Features:\n * - Language state management with persistence\n * - Automatic language detection and fallback\n * - Message loading and caching\n * - Timezone configuration per language\n * - Integration with Next.js internationalization\n * - Memoized context value for performance optimization\n *\n * @param props - Component props containing children, languages, and messages.\n * @param props.children - React children that will have access to the internationalization context.\n * @param props.languages - Array of supported languages with their configurations.\n * @param props.messages - Object containing translation messages for each supported language.\n * @returns A React component that provides internationalization context to its children.\n */\nexport function NextIntlProvider({\n    children,\n    languages,\n    messages,\n}: I_NextIntlProviderProps) {\n    const { value, set } = useStorage<I_NextIntlLanguage>('lang', languages[0]);\n\n    const contextValue = useMemo(\n        () => ({ languages, currentLanguage: value ?? NEXT_INTL_DEFAULT_LANGUAGE, setCurrentLanguage: set }),\n        [languages, set, value],\n    );\n\n    return (\n        <NextIntlContext value={contextValue}>\n            <LanguageWrapper languages={languages} messages={messages}>\n                {children}\n            </LanguageWrapper>\n        </NextIntlContext>\n    );\n}\n"],"names":["React","useMemo","NEXT_INTL_DEFAULT_LANGUAGE","NextIntlContext","withNextIntl","useStorage","LanguageWrapperBase","children","LanguageWrapper","NextIntlProvider","languages","messages","value","set","contextValue"],"mappings":"AAqBA,YAAAA,OAAA;AAAA,SAAA,WAAAC,SAAA;AAAA,SAAA,8BAAAC,SAAA;AAAA,SAAA,mBAAAC,SAAA;AAAA,SAAA,gBAAAC,SAAA;AAAA,SAAA,cAAAC,SAAA;AAAA,SAASC,EAAoB,EAAE,UAAAC,KAAwB;AACnD,2DAAUA,CAAS;AACvB;AAEA,MAAMC,IAAkBJ,EAAaE,CAAmB;AAuBjD,SAASG,EAAiB;AAAA,EAC7B,UAAAF;AAAA,EACA,WAAAG;AAAA,EACA,UAAAC;AACJ,GAA4B;AACxB,QAAM,EAAE,OAAAC,GAAO,KAAAC,EAAA,IAAQR,EAA+B,QAAQK,EAAU,CAAC,CAAC,GAEpEI,IAAeb;AAAA,IACjB,OAAO,EAAE,WAAAS,GAAW,iBAAiBE,KAASV,GAA4B,oBAAoBW;IAC9F,CAACH,GAAWG,GAAKD,CAAK;AAAA,EAAA;AAG1B,SACI,gBAAAZ,EAAA,cAACG,KAAgB,OAAOW,EAAA,mCACnBN,GAAA,EAAgB,WAAAE,GAAsB,UAAAC,EAAA,GAClCJ,CACL,CACJ;AAER;"}

package/dist/react/storage/index.js

@@ -4,3 +4,4 @@ export {
   a as storage,
   e as useStorage
 };
+//# sourceMappingURL=index.js.map

package/dist/react/storage/index.js.map

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

package/dist/react/storage/storage.hook.js

@@ -57,3 +57,4 @@ function S(e, o, a = w) {
 export {
   S as useStorage
 };
+//# sourceMappingURL=storage.hook.js.map

package/dist/react/storage/storage.hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.hook.js","sources":["../../../src/react/storage/storage.hook.tsx"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\n\nimport type { I_Serializer } from '#util/serializer/index.js';\n\nimport { serializer as defaultSerializer } from '#util/serializer/index.js';\n\nimport { catchError } from '../log/index.js';\nimport { storage } from './storage.util.js';\n\n/**\n * React hook that provides persistent storage functionality with automatic serialization.\n * This hook manages state that persists across browser sessions using localForage,\n * with automatic serialization/deserialization of complex data types. It provides\n * a React-friendly interface for storage operations with proper error handling.\n *\n * Features:\n * - Automatic data serialization and deserialization\n * - Persistent storage across browser sessions\n * - Initial value handling and fallback\n * - Error handling with graceful degradation\n * - Automatic storage synchronization\n * - Support for complex data types via custom serializers\n *\n * @param key - The unique storage key for the data.\n * @param initialValue - Optional initial value to use if no stored value exists.\n * @param serializer - Optional custom serializer for complex data types (defaults to JSON serializer).\n * @returns An object containing the current value, set function, and remove function.\n */\nexport function useStorage<T>(\n    key: string,\n    initialValue?: T,\n    serializer: I_Serializer<T> = defaultSerializer as I_Serializer<T>,\n) {\n    const [value, setValue] = useState<T | undefined>(initialValue);\n    const [isLoaded, setIsLoaded] = useState(false);\n\n    useEffect(() => {\n        let isMounted = true;\n\n        const loadValue = async () => {\n            try {\n                const valueFound = await storage.get<string>(key);\n\n                if (isMounted) {\n                    if (valueFound !== null) {\n                        const parsedValue = serializer.deserialize(valueFound);\n                        setValue(parsedValue);\n                    }\n                    else if (initialValue !== undefined) {\n                        const serialized = serializer.serialize(initialValue);\n                        await storage.set(key, serialized);\n                        setValue(initialValue);\n                    }\n                    else {\n                        setValue(undefined);\n                    }\n                }\n            }\n            catch (error) {\n                catchError(error);\n\n                if (isMounted) {\n                    setValue(initialValue);\n                }\n            }\n            finally {\n                if (isMounted)\n                    setIsLoaded(true);\n            }\n        };\n\n        loadValue();\n\n        return () => {\n            isMounted = false;\n            setIsLoaded(false);\n        };\n    }, [key, initialValue, serializer]);\n\n    useEffect(() => {\n        if (!isLoaded)\n            return;\n\n        const saveValue = async () => {\n            try {\n                if (value !== undefined) {\n                    const serialized = serializer.serialize(value);\n                    await storage.set(key, serialized);\n                }\n            }\n            catch (error) {\n                catchError(error);\n            }\n        };\n\n        saveValue();\n    }, [value, key, serializer, isLoaded]);\n\n    const set = useCallback(\n        (newValue: T | ((val: T | undefined) => T)) => {\n            setValue((prev) => {\n                if (typeof newValue === 'function') {\n                    return (newValue as (val: T | undefined) => T)(prev);\n                }\n                return newValue;\n            });\n        },\n        [],\n    );\n\n    const remove = useCallback(async () => {\n        try {\n            await storage.remove(key);\n            setValue(undefined);\n        }\n        catch (error) {\n            catchError(error);\n        }\n    }, [key]);\n\n    return { value, set, remove };\n}\n"],"names":["useStorage","key","initialValue","serializer","defaultSerializer","value","setValue","useState","isLoaded","setIsLoaded","useEffect","isMounted","valueFound","storage","parsedValue","serialized","error","catchError","set","useCallback","newValue","prev","remove"],"mappings":";;;;AA4BO,SAASA,EACZC,GACAC,GACAC,IAA8BC,GAChC;AACE,QAAM,CAACC,GAAOC,CAAQ,IAAIC,EAAwBL,CAAY,GACxD,CAACM,GAAUC,CAAW,IAAIF,EAAS,EAAK;AAE9C,EAAAG,EAAU,MAAM;AACZ,QAAIC,IAAY;AAkChB,YAhCkB,YAAY;AAC1B,UAAI;AACA,cAAMC,IAAa,MAAMC,EAAQ,IAAYZ,CAAG;AAEhD,YAAIU;AACA,cAAIC,MAAe,MAAM;AACrB,kBAAME,IAAcX,EAAW,YAAYS,CAAU;AACrD,YAAAN,EAASQ,CAAW;AAAA,UACxB,WACSZ,MAAiB,QAAW;AACjC,kBAAMa,IAAaZ,EAAW,UAAUD,CAAY;AACpD,kBAAMW,EAAQ,IAAIZ,GAAKc,CAAU,GACjCT,EAASJ,CAAY;AAAA,UACzB;AAEI,YAAAI,EAAS,MAAS;AAAA,MAG9B,SACOU,GAAO;AACV,QAAAC,EAAWD,CAAK,GAEZL,KACAL,EAASJ,CAAY;AAAA,MAE7B,UAAA;AAEI,QAAIS,KACAF,EAAY,EAAI;AAAA,MACxB;AAAA,IACJ,GAEA,GAEO,MAAM;AACT,MAAAE,IAAY,IACZF,EAAY,EAAK;AAAA,IACrB;AAAA,EACJ,GAAG,CAACR,GAAKC,GAAcC,CAAU,CAAC,GAElCO,EAAU,MAAM;AACZ,QAAI,CAACF;AACD;AAcJ,KAZkB,YAAY;AAC1B,UAAI;AACA,YAAIH,MAAU,QAAW;AACrB,gBAAMU,IAAaZ,EAAW,UAAUE,CAAK;AAC7C,gBAAMQ,EAAQ,IAAIZ,GAAKc,CAAU;AAAA,QACrC;AAAA,MACJ,SACOC,GAAO;AACV,QAAAC,EAAWD,CAAK;AAAA,MACpB;AAAA,IACJ,GAEA;AAAA,EACJ,GAAG,CAACX,GAAOJ,GAAKE,GAAYK,CAAQ,CAAC;AAErC,QAAMU,IAAMC;AAAA,IACR,CAACC,MAA8C;AAC3C,MAAAd,EAAS,CAACe,MACF,OAAOD,KAAa,aACZA,EAAuCC,CAAI,IAEhDD,CACV;AAAA,IACL;AAAA,IACA,CAAA;AAAA,EAAC,GAGCE,IAASH,EAAY,YAAY;AACnC,QAAI;AACA,YAAMN,EAAQ,OAAOZ,CAAG,GACxBK,EAAS,MAAS;AAAA,IACtB,SACOU,GAAO;AACV,MAAAC,EAAWD,CAAK;AAAA,IACpB;AAAA,EACJ,GAAG,CAACf,CAAG,CAAC;AAER,SAAO,EAAE,OAAAI,GAAO,KAAAa,GAAK,QAAAI,EAAA;AACzB;"}

package/dist/react/storage/storage.util.js

@@ -66,3 +66,4 @@ const s = {
 export {
   s as storage
 };
+//# sourceMappingURL=storage.util.js.map

package/dist/react/storage/storage.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.util.js","sources":["../../../src/react/storage/storage.util.ts"],"sourcesContent":["import localForage from 'localforage';\n\nimport { catchError } from '../log/index.js';\n\n/**\n * Browser storage utility object using localForage for cross-browser compatibility.\n * This object provides a unified interface for browser storage operations using localForage,\n * which automatically chooses the best available storage method (IndexedDB, WebSQL, or localStorage)\n * based on browser capabilities. It includes comprehensive error handling and type safety.\n */\nexport const storage = {\n    /**\n     * Retrieves a value from browser storage by key.\n     * This method fetches data that was previously stored using the set method.\n     * Returns null if the key doesn't exist or if an error occurs during retrieval.\n     *\n     * @param key - The unique identifier for the stored value.\n     * @returns A promise that resolves to the stored value or null if not found.\n     */\n    async get<T = unknown>(key: string): Promise<T | null> {\n        try {\n            return await localForage.getItem<T>(key);\n        }\n        catch (error) {\n            return catchError(error, { returnValue: null });\n        }\n    },\n    /**\n     * Stores a value in browser storage with a unique key.\n     * This method saves data that can be retrieved later using the get method.\n     * The data is automatically handled by localForage which chooses the optimal\n     * storage method for the browser environment.\n     *\n     * @param key - The unique identifier for the value to store.\n     * @param value - The data to store (will be automatically handled by localForage).\n     * @returns A promise that resolves when the storage operation is complete.\n     */\n    async set<T = unknown>(key: string, value: T): Promise<void> {\n        try {\n            await localForage.setItem(key, value);\n        }\n        catch (error) {\n            catchError(error);\n        }\n    },\n    /**\n     * Removes a value from browser storage by key.\n     * This method permanently deletes the stored data associated with the specified key.\n     * If the key doesn't exist, the operation completes successfully without error.\n     *\n     * @param key - The unique identifier of the value to remove.\n     * @returns A promise that resolves when the removal operation is complete.\n     */\n    async remove(key: string): Promise<void> {\n        try {\n            await localForage.removeItem(key);\n        }\n        catch (error) {\n            catchError(error);\n        }\n    },\n    /**\n     * Retrieves all storage keys.\n     * This method returns an array of all keys that currently have stored values.\n     * Returns an empty array if no keys exist or if an error occurs during retrieval.\n     *\n     * @returns A promise that resolves to an array of storage keys.\n     */\n    async keys(): Promise<string[]> {\n        try {\n            const keys = await localForage.keys();\n\n            return keys ?? [];\n        }\n        catch (error) {\n            return catchError(error, { returnValue: [] });\n        }\n    },\n};\n"],"names":["localForage","catchError","storage","key","error","value"],"mappings":"AAUO,OAAAA,OAAA;AAAA,SAAA,cAAAC,SAAA;AAAA,MAAMC,IAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASnB,MAAM,IAAiBC,GAAgC;AACnD,QAAI;AACA,aAAO,MAAMH,EAAY,QAAWG,CAAG;AAAA,IAC3C,SACOC,GAAO;AACV,aAAOH,EAAWG,GAAO,EAAE,aAAa,MAAM;AAAA,IAClD;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAM,IAAiBD,GAAaE,GAAyB;AACzD,QAAI;AACA,YAAML,EAAY,QAAQG,GAAKE,CAAK;AAAA,IACxC,SACOD,GAAO;AACV,MAAAH,EAAWG,CAAK;AAAA,IACpB;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,OAAOD,GAA4B;AACrC,QAAI;AACA,YAAMH,EAAY,WAAWG,CAAG;AAAA,IACpC,SACOC,GAAO;AACV,MAAAH,EAAWG,CAAK;AAAA,IACpB;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,OAA0B;AAC5B,QAAI;AAGA,aAFa,MAAMJ,EAAY,KAAA,KAEhB,CAAA;AAAA,IACnB,SACOI,GAAO;AACV,aAAOH,EAAWG,GAAO,EAAE,aAAa,CAAA,GAAI;AAAA,IAChD;AAAA,EACJ;AACJ;"}

package/dist/react/toast/index.js

@@ -3,3 +3,4 @@ export {
   r as Toaster,
   a as toast
 };
+//# sourceMappingURL=index.js.map

package/dist/react/toast/index.js.map

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

package/dist/react/userback/index.js

@@ -2,3 +2,4 @@ import { Userback as o } from "./userback.component.js";
 export {
   o as Userback
 };
+//# sourceMappingURL=index.js.map

package/dist/react/userback/index.js.map

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

package/dist/react/userback/userback.component.js

@@ -25,3 +25,4 @@ function d({ token: r, options: n }) {
 export {
   d as Userback
 };
+//# sourceMappingURL=userback.component.js.map

package/dist/react/userback/userback.component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userback.component.js","sources":["../../../src/react/userback/userback.component.tsx"],"sourcesContent":["import UserbackWidget from '@userback/widget';\nimport { useEffect } from 'react';\n\nimport type { I_UserBackProps } from './userback.type.js';\n\n/**\n * Userback feedback widget component for collecting user feedback.\n * This component integrates the Userback feedback widget into React applications,\n * providing a customizable feedback collection interface for users to submit\n * bug reports, feature requests, and general feedback.\n *\n * Features:\n * - Userback widget integration\n * - Customizable feedback collection\n * - Automatic widget initialization\n * - Token-based configuration\n * - Responsive design support\n *\n * @param props - Component props containing token and options.\n * @param props.token - The Userback token for widget authentication.\n * @param props.options - Optional configuration options for the Userback widget.\n * @returns A React component that renders the Userback feedback widget.\n */\nexport function Userback({ token, options }: I_UserBackProps) {\n    useEffect(() => {\n        if (!token) {\n            return;\n        }\n\n        let observer: MutationObserver;\n\n        const loadUserback = async () => {\n            const { hide, ...rest } = options || {};\n\n            await UserbackWidget(token, rest);\n\n            if (hide && hide.length > 0) {\n                hide.forEach((selector: string) => {\n                    document.querySelectorAll(selector).forEach(el => el.remove());\n                });\n            }\n\n            observer = new MutationObserver(() => {\n                if (hide && hide.length > 0) {\n                    hide.forEach((selector: string) => {\n                        document.querySelectorAll(selector).forEach(el => el.remove());\n                    });\n                }\n            });\n\n            observer.observe(document.body, {\n                childList: true,\n                subtree: true,\n            });\n        };\n\n        loadUserback();\n\n        return () => {\n            observer?.disconnect();\n        };\n    }, [token, options]);\n\n    return null;\n}\n"],"names":["UserbackWidget","useEffect","Userback","token","options","observer","hide","rest","selector","el"],"mappings":"AAuBO,OAAAA,OAAA;AAAA,SAAA,aAAAC,SAAA;AAAA,SAASC,EAAS,EAAE,OAAAC,GAAO,SAAAC,KAA4B;AAC1D,SAAAH,EAAU,MAAM;AACZ,QAAI,CAACE;AACD;AAGJ,QAAIE;AA2BJ,YAzBqB,YAAY;AAC7B,YAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASH,KAAW,CAAA;AAErC,YAAMJ,EAAeG,GAAOI,CAAI,GAE5BD,KAAQA,EAAK,SAAS,KACtBA,EAAK,QAAQ,CAACE,MAAqB;AAC/B,iBAAS,iBAAiBA,CAAQ,EAAE,QAAQ,CAAAC,MAAMA,EAAG,QAAQ;AAAA,MACjE,CAAC,GAGLJ,IAAW,IAAI,iBAAiB,MAAM;AAClC,QAAIC,KAAQA,EAAK,SAAS,KACtBA,EAAK,QAAQ,CAACE,MAAqB;AAC/B,mBAAS,iBAAiBA,CAAQ,EAAE,QAAQ,CAAAC,MAAMA,EAAG,QAAQ;AAAA,QACjE,CAAC;AAAA,MAET,CAAC,GAEDJ,EAAS,QAAQ,SAAS,MAAM;AAAA,QAC5B,WAAW;AAAA,QACX,SAAS;AAAA,MAAA,CACZ;AAAA,IACL,GAEA,GAEO,MAAM;AACT,MAAAA,GAAU,WAAA;AAAA,IACd;AAAA,EACJ,GAAG,CAACF,GAAOC,CAAO,CAAC,GAEZ;AACX;"}

package/dist/typescript/common.type.js

@@ -2,3 +2,4 @@ var p = /* @__PURE__ */ ((e) => (e.PRODUCTION = "production", e.STAGING = "stagi
 export {
   p as E_Environment
 };
+//# sourceMappingURL=common.type.js.map

package/dist/typescript/common.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.type.js","sources":["../../src/typescript/common.type.ts"],"sourcesContent":["import type consola from 'consola';\n\n/**\n * Generic object type with string keys and values of type T (defaults to unknown).\n */\nexport type T_Object<T = unknown> = Record<string, T>;\n\n/**\n * Logging interface for browser and Node.js environments, compatible with consola.\n */\nexport interface I_Log {\n    silent: typeof consola['silent'];\n    level: typeof consola['level'];\n    fatal: typeof consola['fatal'];\n    error: typeof consola['error'];\n    warn: typeof consola['warn'];\n    log: typeof consola['log'];\n    info: typeof consola['info'];\n    success: typeof consola['success'];\n    ready: typeof consola['ready'];\n    start: typeof consola['start'];\n    box: typeof consola['box'];\n    debug: typeof consola['debug'];\n    trace: typeof consola['trace'];\n    verbose: typeof consola['verbose'];\n}\n\n/**\n * Base interface for return types with common properties.\n */\nexport interface I_ReturnBase {\n    success: boolean;\n    message?: string;\n    code?: number | string;\n}\n\n/**\n * Success return type with result data.\n * @template T - The main result type\n * @template E - Additional properties to merge with the result (defaults to unknown)\n */\nexport interface I_ReturnSuccess<T, E = unknown> extends I_ReturnBase {\n    success: true;\n    result: T & E;\n}\n\n/**\n * Failure return type with error information.\n */\nexport interface I_ReturnFailure extends I_ReturnBase {\n    success: false;\n    message: string;\n    code: number | string;\n}\n\n/**\n * Discriminated union type for function return values.\n * Provides type-safe handling of success and failure cases.\n *\n * @template T - The success result type (defaults to void)\n * @template E - Additional properties to merge with the result (defaults to unknown)\n *\n * @example\n * ```typescript\n * function fetchUser(id: string): I_Return<User> {\n *   try {\n *     const user = await getUser(id);\n *     return { success: true, result: user };\n *   } catch (error) {\n *     return { success: false, message: error.message, code: 'USER_NOT_FOUND' };\n *   }\n * }\n * ```\n */\nexport type I_Return<T = void, E = unknown> = I_ReturnSuccess<T, E> | I_ReturnFailure;\n\nexport enum E_Environment {\n    PRODUCTION = 'production',\n    STAGING = 'staging',\n    DEVELOPMENT = 'development',\n}\n"],"names":["E_Environment"],"mappings":"AA4EO,IAAKA,sBAAAA,OACRA,EAAA,aAAa,cACbA,EAAA,UAAU,WACVA,EAAA,cAAc,eAHNA,IAAAA,KAAA,CAAA,CAAA;"}

package/dist/typescript/index.js

@@ -2,3 +2,4 @@ import { E_Environment as r } from "./common.type.js";
 export {
   r as E_Environment
 };
+//# sourceMappingURL=index.js.map

package/dist/typescript/index.js.map

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

package/dist/util/common/common.util.js

@@ -1,4 +1,4 @@
-import { E_Environment as r } from "../../typescript/common.type.js";
+import { E_Environment as o } from "../../typescript/common.type.js";
 const p = {
   a: ["à", "á", "ạ", "ả", "ã", "â", "ầ", "ấ", "ậ", "ẩ", "ẫ", "ă", "ằ", "ắ", "ặ", "ẳ", "ẵ"],
   e: ["è", "é", "ẹ", "ẻ", "ẽ", "ê", "ề", "ế", "ệ", "ể", "ễ"],
@@ -7,46 +7,48 @@ const p = {
   u: ["ù", "ú", "ụ", "ủ", "ũ", "ư", "ừ", "ứ", "ự", "ử", "ữ"],
   y: ["ỳ", "ý", "ỵ", "ỷ", "ỹ"],
   d: ["đ"]
-}, s = Object.entries(p).reduce(
-  (e, [n, t]) => (e[n.toUpperCase()] = t.map((o) => o.toUpperCase()), e),
+}, a = Object.entries(p).reduce(
+  (e, [n, t]) => (e[n.toUpperCase()] = t.map((r) => r.toUpperCase()), e),
   {}
-), u = { ...p, ...s }, a = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
+), u = { ...p, ...a }, s = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
 Object.entries(u).forEach(([e, n]) => {
   const t = `(${[e, ...n].join("|")})`;
-  [e, ...n].forEach((o) => {
-    a.set(o, t), i.add(o);
+  [e, ...n].forEach((r) => {
+    s.set(r, t), i.add(r);
   });
 });
-const O = Array.from(i).join(""), D = new RegExp(`[${O}]`, "g");
-function N(e) {
-  return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const O = [...i].join(""), D = new RegExp(`[${O}]`, "g"), N = /[.*+?^${}()|[\]\\]/g;
+function M(e) {
+  return e.replace(N, "\\$&");
 }
 function m(e) {
-  return e = N(e), e.replace(D, (n) => a.get(n) || n);
+  return e = M(e), e.replace(D, (n) => s.get(n) || n);
 }
-function M(e) {
-  return e.normalize("NFD").replace(/\p{Diacritic}/gu, "");
+const f = /\p{Diacritic}/gu;
+function P(e) {
+  return e.normalize("NFD").replace(f, "");
 }
-function T(e, n) {
+function R(e, n) {
   if (!n)
-    return Array.from(new Set(e));
-  const t = /* @__PURE__ */ new Set(), o = [];
+    return [...new Set(e)];
+  const t = /* @__PURE__ */ new Set(), r = [];
   for (const c of e) {
     const E = n(c);
-    t.has(E) || (t.add(E), o.push(c));
+    t.has(E) || (t.add(E), r.push(c));
   }
-  return o;
+  return r;
 }
-function g(e) {
-  const { NODE_ENV: n = r.DEVELOPMENT, NODE_ENV_MODE: t = r.DEVELOPMENT } = e, o = n === r.DEVELOPMENT && t === r.DEVELOPMENT, c = n === r.PRODUCTION && t === r.STAGING, E = n === r.PRODUCTION && t === r.PRODUCTION;
-  if (n === r.PRODUCTION && t === r.DEVELOPMENT)
+function _(e) {
+  const { NODE_ENV: n = o.DEVELOPMENT, NODE_ENV_MODE: t = o.DEVELOPMENT } = e, r = n === o.DEVELOPMENT && t === o.DEVELOPMENT, c = n === o.PRODUCTION && t === o.STAGING, E = n === o.PRODUCTION && t === o.PRODUCTION;
+  if (n === o.PRODUCTION && t === o.DEVELOPMENT)
     throw new Error("NODE_ENV_MODE must be set to staging or production in production environment");
-  return { IS_DEV: o, IS_STAG: c, IS_PROD: E };
+  return { IS_DEV: r, IS_STAG: c, IS_PROD: E };
 }
 export {
-  N as escapeRegExp,
-  g as mapEnvironment,
+  M as escapeRegExp,
+  _ as mapEnvironment,
   m as regexSearchMapper,
-  M as removeAccent,
-  T as uniqueArray
+  P as removeAccent,
+  R as uniqueArray
 };
+//# sourceMappingURL=common.util.js.map

package/dist/util/common/common.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.util.js","sources":["../../../src/util/common/common.util.ts"],"sourcesContent":["import { E_Environment } from '#typescript/index.js';\n\nimport type { I_EnvFlags, I_NodeEnvInput } from './common.type.js';\n\nconst charMap: Record<string, string[]> = {\n    a: ['à', 'á', 'ạ', 'ả', 'ã', 'â', 'ầ', 'ấ', 'ậ', 'ẩ', 'ẫ', 'ă', 'ằ', 'ắ', 'ặ', 'ẳ', 'ẵ'],\n    e: ['è', 'é', 'ẹ', 'ẻ', 'ẽ', 'ê', 'ề', 'ế', 'ệ', 'ể', 'ễ'],\n    i: ['ì', 'í', 'ị', 'ỉ', 'ĩ'],\n    o: ['ò', 'ó', 'ọ', 'ỏ', 'õ', 'ô', 'ồ', 'ố', 'ộ', 'ổ', 'ỗ', 'ơ', 'ờ', 'ớ', 'ợ', 'ở', 'ỡ'],\n    u: ['ù', 'ú', 'ụ', 'ủ', 'ũ', 'ư', 'ừ', 'ứ', 'ự', 'ử', 'ữ'],\n    y: ['ỳ', 'ý', 'ỵ', 'ỷ', 'ỹ'],\n    d: ['đ'],\n};\n\nconst upperCharMap: Record<string, string[]> = Object.entries(charMap).reduce(\n    (map, [key, value]) => {\n        map[key.toUpperCase()] = value.map(char => char.toUpperCase());\n        return map;\n    },\n    {} as Record<string, string[]>,\n);\n\nconst combinedMap = { ...charMap, ...upperCharMap };\n\n// Pre-compute replacement map and search regex for better performance\n// This avoids rebuilding regexes and maps on every function call\nconst replacementMap = new Map<string, string>();\nconst charsToMatch = new Set<string>();\n\nObject.entries(combinedMap).forEach(([baseChar, variations]) => {\n    // The replacement pattern is the same for the base char and all its variations\n    // Example: 'a', 'à', 'á'... all map to '(a|à|á...)'\n    const replacement = `(${[baseChar, ...variations].join('|')})`;\n\n    [baseChar, ...variations].forEach((char) => {\n        replacementMap.set(char, replacement);\n        charsToMatch.add(char);\n    });\n});\n\n// Construct a single regex that matches any character in our map\nconst patternString = [...charsToMatch].join('');\n// We use a character class regex: [abc...]\n// eslint-disable-next-line regexp/no-empty-character-class -- regex is built dynamically from precomputed charMap\nconst searchRegex = new RegExp(`[${patternString}]`, 'g');\n\nconst RE_ESCAPE_REGEXP = /[.*+?^${}()|[\\]\\\\]/g;\n\n/**\n * Escapes special characters in a string for use in a regular expression.\n * This function escapes characters that have special meaning in regex (e.g., ., *, +, ?, etc.)\n * so they are treated as literal characters.\n *\n * @param str - The string to escape.\n * @returns The escaped string safe for use in a RegExp.\n */\nexport function escapeRegExp(str: string): string {\n    return str.replace(RE_ESCAPE_REGEXP, '\\\\$&');\n}\n\n/**\n * Convert a string to a regex pattern that matches the string and its accented variations.\n * This function normalizes the input string and creates a regex pattern that can match\n * both the original characters and their accented equivalents.\n *\n * Optimization: Uses pre-computed regex and map to perform replacement in a single pass (O(N)),\n * instead of iterating through all character groups (O(K*N)).\n * Removed unnecessary NFD normalization which improves performance and fixes\n * matching against NFC target strings.\n *\n * @param str - The string to convert to a regex pattern.\n * @returns The regex pattern as a string that matches the original string and its accented variations.\n */\nexport function regexSearchMapper(str: string) {\n    str = escapeRegExp(str);\n    return str.replace(searchRegex, match => replacementMap.get(match) || match);\n}\n\nconst RE_DIACRITIC = /\\p{Diacritic}/gu;\n\n/**\n * Remove accents from a string.\n * This function normalizes the string using NFD normalization and removes all diacritical marks.\n *\n * @param str - The string to remove accents from.\n * @returns The string without any accents or diacritical marks.\n */\nexport function removeAccent(str: string) {\n    return str.normalize('NFD').replace(RE_DIACRITIC, '');\n}\n\n/**\n * Remove duplicates from an array based on a key function.\n * This function can remove duplicates either by comparing values directly (when no keyFn is provided)\n * or by using a custom key function to determine uniqueness.\n *\n * @param arr - The array to remove duplicates from.\n * @param keyFn - Optional function that returns a unique key for each item in the array.\n * @returns A new array with duplicates removed, maintaining the original order.\n */\nexport function uniqueArray<T>(\n    arr: T[],\n    keyFn?: (item: T) => string | number,\n): T[] {\n    if (!keyFn) {\n        return [...new Set(arr)];\n    }\n\n    const seen = new Set<string | number>();\n    const result: T[] = [];\n\n    for (const item of arr) {\n        const key = keyFn(item);\n        if (!seen.has(key)) {\n            seen.add(key);\n            result.push(item);\n        }\n    }\n\n    return result;\n}\n\n/**\n * Map environment variables to boolean flags indicating the current environment.\n * This function takes NODE_ENV and NODE_ENV_MODE variables and returns flags\n * indicating whether the current environment is development, staging, or production.\n *\n * @param env - The environment variables object containing NODE_ENV and NODE_ENV_MODE.\n * @returns An object containing boolean flags for the environment (IS_DEV, IS_STAG, IS_PROD).\n * @throws {Error} When NODE_ENV is production but NODE_ENV_MODE is development.\n */\nexport function mapEnvironment(env: I_NodeEnvInput): I_EnvFlags {\n    const { NODE_ENV = E_Environment.DEVELOPMENT, NODE_ENV_MODE = E_Environment.DEVELOPMENT } = env;\n\n    const IS_DEV = NODE_ENV === E_Environment.DEVELOPMENT && NODE_ENV_MODE === E_Environment.DEVELOPMENT;\n    const IS_STAG = NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.STAGING;\n    const IS_PROD = NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.PRODUCTION;\n\n    if (NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.DEVELOPMENT) {\n        throw new Error('NODE_ENV_MODE must be set to staging or production in production environment');\n    }\n\n    return { IS_DEV, IS_STAG, IS_PROD };\n}\n"],"names":["E_Environment","charMap","upperCharMap","map","key","value","char","combinedMap","replacementMap","charsToMatch","baseChar","variations","replacement","patternString","searchRegex","RE_ESCAPE_REGEXP","escapeRegExp","str","regexSearchMapper","match","RE_DIACRITIC","removeAccent","uniqueArray","arr","keyFn","seen","result","item","mapEnvironment","env","NODE_ENV","NODE_ENV_MODE","IS_DEV","IS_STAG","IS_PROD"],"mappings":"AAIA,SAAA,iBAAAA,SAAA;AAAA,MAAMC,IAAoC;AAAA,EACtC,GAAG,CAAC,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AAAA,EACvF,GAAG,CAAC,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AAAA,EACzD,GAAG,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG;AAAA,EAC3B,GAAG,CAAC,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AAAA,EACvF,GAAG,CAAC,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AAAA,EACzD,GAAG,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG;AAAA,EAC3B,GAAG,CAAC,GAAG;AACX,GAEMC,IAAyC,OAAO,QAAQD,CAAO,EAAE;AAAA,EACnE,CAACE,GAAK,CAACC,GAAKC,CAAK,OACbF,EAAIC,EAAI,aAAa,IAAIC,EAAM,IAAI,CAAAC,MAAQA,EAAK,aAAa,GACtDH;AAAA,EAEX,CAAA;AACJ,GAEMI,IAAc,EAAE,GAAGN,GAAS,GAAGC,EAAA,GAI/BM,wBAAqB,IAAA,GACrBC,wBAAmB,IAAA;AAEzB,OAAO,QAAQF,CAAW,EAAE,QAAQ,CAAC,CAACG,GAAUC,CAAU,MAAM;AAG5D,QAAMC,IAAc,IAAI,CAACF,GAAU,GAAGC,CAAU,EAAE,KAAK,GAAG,CAAC;AAE3D,GAACD,GAAU,GAAGC,CAAU,EAAE,QAAQ,CAACL,MAAS;AACxC,IAAAE,EAAe,IAAIF,GAAMM,CAAW,GACpCH,EAAa,IAAIH,CAAI;AAAA,EACzB,CAAC;AACL,CAAC;AAGD,MAAMO,IAAgB,CAAC,GAAGJ,CAAY,EAAE,KAAK,EAAE,GAGzCK,IAAc,IAAI,OAAO,IAAID,CAAa,KAAK,GAAG,GAElDE,IAAmB;AAUlB,SAASC,EAAaC,GAAqB;AAC9C,SAAOA,EAAI,QAAQF,GAAkB,MAAM;AAC/C;AAeO,SAASG,EAAkBD,GAAa;AAC3C,SAAAA,IAAMD,EAAaC,CAAG,GACfA,EAAI,QAAQH,GAAa,CAAAK,MAASX,EAAe,IAAIW,CAAK,KAAKA,CAAK;AAC/E;AAEA,MAAMC,IAAe;AASd,SAASC,EAAaJ,GAAa;AACtC,SAAOA,EAAI,UAAU,KAAK,EAAE,QAAQG,GAAc,EAAE;AACxD;AAWO,SAASE,EACZC,GACAC,GACG;AACH,MAAI,CAACA;AACD,WAAO,CAAC,GAAG,IAAI,IAAID,CAAG,CAAC;AAG3B,QAAME,wBAAW,IAAA,GACXC,IAAc,CAAA;AAEpB,aAAWC,KAAQJ,GAAK;AACpB,UAAMnB,IAAMoB,EAAMG,CAAI;AACtB,IAAKF,EAAK,IAAIrB,CAAG,MACbqB,EAAK,IAAIrB,CAAG,GACZsB,EAAO,KAAKC,CAAI;AAAA,EAExB;AAEA,SAAOD;AACX;AAWO,SAASE,EAAeC,GAAiC;AAC5D,QAAM,EAAE,UAAAC,IAAW9B,EAAc,aAAa,eAAA+B,IAAgB/B,EAAc,gBAAgB6B,GAEtFG,IAASF,MAAa9B,EAAc,eAAe+B,MAAkB/B,EAAc,aACnFiC,IAAUH,MAAa9B,EAAc,cAAc+B,MAAkB/B,EAAc,SACnFkC,IAAUJ,MAAa9B,EAAc,cAAc+B,MAAkB/B,EAAc;AAEzF,MAAI8B,MAAa9B,EAAc,cAAc+B,MAAkB/B,EAAc;AACzE,UAAM,IAAI,MAAM,8EAA8E;AAGlG,SAAO,EAAE,QAAAgC,GAAQ,SAAAC,GAAS,SAAAC,EAAA;AAC9B;"}

package/dist/util/common/index.js

@@ -6,3 +6,4 @@ export {
   c as removeAccent,
   m as uniqueArray
 };
+//# sourceMappingURL=index.js.map

package/dist/util/common/index.js.map

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

package/dist/util/index.js

@@ -24,3 +24,4 @@ export {
   x as uniqueArray,
   z as validate
 };
+//# sourceMappingURL=index.js.map

package/dist/util/index.js.map

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

package/dist/util/object/index.js

@@ -7,3 +7,4 @@ export {
   s as normalizeMongoFilter,
   a as setNestedValue
 };
+//# sourceMappingURL=index.js.map

package/dist/util/object/index.js.map

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

package/dist/util/object/object.util.js

@@ -1,52 +1,52 @@
-function p(e) {
+function A(e) {
   try {
     return JSON.parse(e), !0;
   } catch {
     return !1;
   }
 }
-function A(e, t) {
+function p(e, t) {
   let n = e;
-  const o = t.length;
-  for (let r = 0; r < o; r++) {
+  const s = t.length;
+  for (let r = 0; r < s; r++) {
     if (n == null || typeof n != "object")
       return;
-    const s = t[r];
-    if (s !== void 0 && s in n)
-      n = n[s];
+    const o = t[r];
+    if (o !== void 0 && o in n)
+      n = n[o];
     else
       return;
   }
   return n;
 }
-function f(e, t, n, o) {
-  if (o >= t.length)
+function c(e, t, n, s) {
+  if (s >= t.length)
     return e;
-  const r = t[o];
-  if (o === t.length - 1)
+  const r = t[s];
+  if (s === t.length - 1)
     return {
       ...e,
       [r]: n
     };
-  const s = e[r];
+  const o = e[r];
   return {
     ...e,
-    [r]: f(
-      typeof s == "object" && s !== null ? s : {},
+    [r]: c(
+      typeof o == "object" && o !== null ? o : {},
       t,
       n,
-      o + 1
+      s + 1
     )
   };
 }
 function g(e, t, n) {
-  return t.length === 0 ? e : f(e, t, n, 0);
+  return t.length === 0 ? e : c(e, t, n, 0);
 }
-function u(e) {
+function f(e) {
   if (e === null || typeof e != "object")
     return e;
   if (Array.isArray(e))
-    return e.map((o) => u(o));
+    return e.map((s) => f(s));
   if (e instanceof Date)
     return new Date(e.getTime());
   if (e instanceof RegExp)
@@ -55,8 +55,8 @@ function u(e) {
   if (t !== Object.prototype && t !== null)
     return e;
   const n = {};
-  for (const o in e)
-    Object.prototype.hasOwnProperty.call(e, o) && (n[o] = u(e[o]));
+  for (const s in e)
+    Object.hasOwn(e, s) && (n[s] = f(e[s]));
   return n;
 }
 function y(...e) {
@@ -68,22 +68,22 @@ function y(...e) {
   if (t.length === 1)
     return t[0];
   if (t.every(Array.isArray))
-    return [].concat(...t);
+    return t.flat();
   if (t.every((r) => typeof r == "object" && r !== null && !Array.isArray(r))) {
     const r = {};
-    for (const s of t) {
-      const i = s;
-      for (const l in i)
-        if (Object.prototype.hasOwnProperty.call(i, l)) {
-          const a = i[l];
-          if (Object.prototype.hasOwnProperty.call(r, l)) {
-            const c = r[l];
-            typeof a == "object" && a !== null && typeof c == "object" && c !== null ? Array.isArray(a) && Array.isArray(c) ? r[l] = c.concat(a) : !Array.isArray(a) && !Array.isArray(c) ? r[l] = y(
-              c,
-              a
-            ) : r[l] = a : r[l] = a;
+    for (const o of t) {
+      const l = o;
+      for (const i in l)
+        if (Object.hasOwn(l, i)) {
+          const u = l[i];
+          if (Object.hasOwn(r, i)) {
+            const a = r[i];
+            typeof u == "object" && u !== null && typeof a == "object" && a !== null ? Array.isArray(u) && Array.isArray(a) ? r[i] = [...a, ...u] : !Array.isArray(u) && !Array.isArray(a) ? r[i] = y(
+              a,
+              u
+            ) : r[i] = u : r[i] = u;
           } else
-            r[l] = a;
+            r[i] = u;
         }
     }
     return r;
@@ -92,10 +92,10 @@ function y(...e) {
     throw new Error(
       "deepMerge: Cannot merge primitive values. All arguments must be objects or arrays."
     );
-  const n = t.some(Array.isArray), o = t.some(
+  const n = t.some(Array.isArray), s = t.some(
     (r) => typeof r == "object" && r !== null && !Array.isArray(r)
   );
-  throw n && o ? new Error(
+  throw n && s ? new Error(
     "deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects."
   ) : new Error(
     "deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type."
@@ -105,30 +105,31 @@ function h(e) {
   if (!e || typeof e != "object")
     return e;
   const t = {};
-  function n(o, r) {
-    for (const s in o) {
-      if (!Object.prototype.hasOwnProperty.call(o, s))
+  function n(s, r) {
+    for (const o in s) {
+      if (!Object.hasOwn(s, o))
         continue;
-      const i = o[s], l = r ? `${r}.${s}` : s;
-      if (i && typeof i == "object" && !Array.isArray(i)) {
-        let a = !1;
-        for (const c in i)
-          if (Object.prototype.hasOwnProperty.call(i, c) && c.startsWith("$")) {
-            a = !0;
+      const l = s[o], i = r ? `${r}.${o}` : o;
+      if (l && typeof l == "object" && !Array.isArray(l)) {
+        let u = !1;
+        for (const a in l)
+          if (Object.hasOwn(l, a) && a.startsWith("$")) {
+            u = !0;
             break;
           }
-        a ? t[l] = i : n(i, l);
+        u ? t[i] = l : n(l, i);
       } else
-        t[l] = i;
+        t[i] = l;
     }
   }
   return n(e, ""), t;
 }
 export {
-  u as deepClone,
+  f as deepClone,
   y as deepMerge,
-  A as getNestedValue,
-  p as isJSON,
+  p as getNestedValue,
+  A as isJSON,
   h as normalizeMongoFilter,
   g as setNestedValue
 };
+//# sourceMappingURL=object.util.js.map

package/dist/util/object/object.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.util.js","sources":["../../../src/util/object/object.util.ts"],"sourcesContent":["/**\n * Check if a string is a valid JSON string.\n * This function attempts to parse the string as JSON and returns true if successful,\n * false if the string is not valid JSON.\n *\n * @param str - The string to check for valid JSON format.\n * @returns True if the string is a valid JSON string, false otherwise.\n */\nexport function isJSON(str: string): boolean {\n    try {\n        JSON.parse(str);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n\n/**\n * Gets a nested value from an object using a path array.\n * This function traverses the object following the provided path and returns\n * the value at the specified location, or undefined if the path doesn't exist.\n *\n * @param obj - The object to get the value from.\n * @param path - An array of keys representing the path to the desired value.\n * @returns The value at the specified path, or undefined if the path doesn't exist.\n */\nexport function getNestedValue<T>(obj: T, path: (string | number)[]): unknown {\n    // Optimization: Loop is faster than reduce and allows early exit\n    let current: unknown = obj;\n    const len = path.length;\n\n    for (let i = 0; i < len; i++) {\n        // Optimization: Early return if current value is null/undefined or not an object\n        // This avoids unnecessary key lookups and type checks\n        if (current == null || typeof current !== 'object') {\n            return undefined;\n        }\n\n        const key = path[i];\n\n        if (key !== undefined && key in (current as Record<string | number, unknown>)) {\n            current = (current as Record<string | number, unknown>)[key];\n        }\n        else {\n            return undefined;\n        }\n    }\n\n    return current;\n}\n\n/**\n *\n */\nfunction setNestedValueHelper<T>(obj: T, path: (string | number)[], value: unknown, index: number): T {\n    if (index >= path.length)\n        return obj;\n\n    const head = path[index];\n\n    if (index === path.length - 1) {\n        return {\n            ...(obj as Record<string | number, unknown>),\n            [head as string | number]: value,\n        } as T;\n    }\n\n    const current = (obj as Record<string | number, unknown>)[head as string | number];\n\n    return {\n        ...(obj as Record<string | number, unknown>),\n        [head as string | number | symbol]: setNestedValueHelper(\n            typeof current === 'object' && current !== null\n                ? (current as object)\n                : {},\n            path,\n            value,\n            index + 1,\n        ),\n    } as T;\n}\n\n/**\n * Sets a nested value in an object using a path array.\n * This function creates the path if it doesn't exist and sets the value at the specified location.\n * The function returns a new object with the updated value, maintaining immutability.\n *\n * @param obj - The object to set the value in.\n * @param path - An array of keys representing the path to the desired location.\n * @param value - The value to set at the specified path.\n * @returns A new object with the updated value at the specified path.\n */\nexport function setNestedValue<T>(obj: T, path: (string | number)[], value: unknown): T {\n    if (path.length === 0)\n        return obj;\n\n    return setNestedValueHelper(obj, path, value, 0);\n}\n\n/**\n * Deep clones an object or array.\n * This function creates a deep copy of the input, recursively cloning objects and arrays.\n * Primitive values, dates, and other non-plain objects are returned as is (or cloned if supported).\n * Note: This implementation focuses on plain objects and arrays. For complex types like Map/Set/Buffer/ObjectId,\n * it returns the reference or handles them according to specific logic.\n *\n * @param obj - The object to clone.\n * @returns A deep copy of the object.\n */\nexport function deepClone<T>(obj: T): T {\n    if (obj === null || typeof obj !== 'object') {\n        return obj;\n    }\n\n    if (Array.isArray(obj)) {\n        return obj.map(item => deepClone(item)) as unknown as T;\n    }\n\n    if (obj instanceof Date) {\n        return new Date(obj.getTime()) as unknown as T;\n    }\n\n    if (obj instanceof RegExp) {\n        return new RegExp(obj.source, obj.flags) as unknown as T;\n    }\n\n    // Handle Mongoose ObjectId and other custom classes by returning reference\n    // structuredClone would fail here. We assume if it's not a plain object, we keep the reference\n    // unless we want to implement specific cloning logic for every type.\n    // However, we want to clone POJOs (Plain Old JavaScript Objects).\n    const proto = Object.getPrototypeOf(obj);\n    if (proto !== Object.prototype && proto !== null) {\n        return obj;\n    }\n\n    const result = {} as Record<string, unknown>;\n    for (const key in obj) {\n        if (Object.hasOwn(obj, key)) {\n            result[key] = deepClone((obj as Record<string, unknown>)[key]);\n        }\n    }\n\n    return result as T;\n}\n\n/**\n * Deep merges multiple objects into a single object.\n * @param args - The objects to merge. Can be empty, in which case returns an empty object.\n * @returns The merged object.\n */\nexport function deepMerge<T = Record<string, unknown>>(\n    ...args: (object | null | undefined)[]\n): T;\n\n/**\n * Deep merges multiple arrays into a single array.\n * @param args - The arrays to merge. Can be empty, in which case returns an empty array.\n * @returns The merged array.\n */\nexport function deepMerge<T = unknown[]>(\n    ...args: (unknown[] | null | undefined)[]\n): T;\n\n/**\n * Implementation of deepMerge function.\n * @param args - The objects or arrays to merge.\n * @returns The merged result.\n */\nexport function deepMerge<T = Record<string, unknown> | unknown[]>(\n    ...args: (object | unknown[] | null | undefined)[]\n): T {\n    // Handle empty arguments\n    if (args.length === 0) {\n        return {} as T;\n    }\n\n    // Filter out null/undefined and convert to empty objects/arrays\n    const validArgs = args.filter((arg): arg is object => arg !== null && arg !== undefined);\n\n    // If no valid arguments after filtering, return empty object/array\n    if (validArgs.length === 0) {\n        return {} as T;\n    }\n\n    // If only one argument, return it directly\n    if (validArgs.length === 1) {\n        return validArgs[0] as T;\n    }\n\n    // Check if all arguments are arrays\n    if (validArgs.every(Array.isArray)) {\n        return (validArgs as unknown[][]).flat() as T;\n    }\n\n    // Check if all arguments are objects (but not arrays)\n    if (validArgs.every(arg => typeof arg === 'object' && arg !== null && !Array.isArray(arg))) {\n        const result = {} as Record<string, unknown>;\n\n        for (const arg of validArgs) {\n            const obj = arg as Record<string, unknown>;\n            for (const key in obj) {\n                if (Object.hasOwn(obj, key)) {\n                    const value = obj[key];\n                    if (Object.hasOwn(result, key)) {\n                        const existingValue = result[key];\n                        if (\n                            typeof value === 'object' && value !== null\n                            && typeof existingValue === 'object' && existingValue !== null\n                        ) {\n                            if (Array.isArray(value) && Array.isArray(existingValue)) {\n                                result[key] = [...existingValue, ...value];\n                            }\n                            else if (!Array.isArray(value) && !Array.isArray(existingValue)) {\n                                result[key] = deepMerge(\n                                    existingValue as Record<string, unknown>,\n                                    value as Record<string, unknown>,\n                                );\n                            }\n                            else {\n                                // One is array, other is object (shouldn't happen with strict types but possible)\n                                // Overwrite\n                                result[key] = value;\n                            }\n                        }\n                        else {\n                            result[key] = value;\n                        }\n                    }\n                    else {\n                        result[key] = value;\n                    }\n                }\n            }\n        }\n        return result as T;\n    }\n\n    // Check if all arguments are primitive values\n    if (validArgs.every(arg => typeof arg !== 'object' || arg === null)) {\n        throw new Error(\n            'deepMerge: Cannot merge primitive values. All arguments must be objects or arrays.',\n        );\n    }\n\n    // Mixed types error\n    const hasArrays = validArgs.some(Array.isArray);\n    const hasObjects = validArgs.some(arg =>\n        typeof arg === 'object' && arg !== null && !Array.isArray(arg),\n    );\n\n    if (hasArrays && hasObjects) {\n        throw new Error(\n            'deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects.',\n        );\n    }\n\n    // Fallback for unexpected cases\n    throw new Error(\n        'deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type.',\n    );\n}\n\n/**\n * Normalizes MongoDB filters to support both dot notation strings and nested objects.\n * This function converts nested object filters to dot notation format while preserving\n * MongoDB operators to ensure consistent behavior across different filter input formats.\n *\n * @param filter - The filter object to normalize.\n * @returns A normalized filter object with nested objects converted to dot notation,\n *          while preserving MongoDB operators as nested objects.\n *\n * @example\n * ```typescript\n * // Both of these will work the same way:\n * normalizeMongoFilter({ \"location.countryId\": \"240\" })\n * normalizeMongoFilter({ location: { countryId: \"240\" } })\n * // Both return: { \"location.countryId\": \"240\" }\n *\n * // MongoDB operators are preserved:\n * normalizeMongoFilter({ id: { $in: [\"240\", \"59\"] } })\n * // Returns: { id: { $in: [\"240\", \"59\"] } }\n * ```\n */\nexport function normalizeMongoFilter<T extends Record<string, unknown>>(filter: T): T {\n    if (!filter || typeof filter !== 'object') {\n        return filter;\n    }\n\n    const normalized: Record<string, unknown> = {};\n\n    /**\n     *\n     */\n    function flatten(current: Record<string, unknown>, prefix: string) {\n        for (const key in current) {\n            if (!Object.hasOwn(current, key))\n                continue;\n\n            const value = current[key];\n            const newKey = prefix ? `${prefix}.${key}` : key;\n\n            if (value && typeof value === 'object' && !Array.isArray(value)) {\n                // Check for Mongo operator\n                let hasMongoOperator = false;\n                for (const subKey in value as Record<string, unknown>) {\n                    if (Object.hasOwn(value, subKey) && subKey.startsWith('$')) {\n                        hasMongoOperator = true;\n                        break;\n                    }\n                }\n\n                if (hasMongoOperator) {\n                    normalized[newKey] = value;\n                }\n                else {\n                    flatten(value as Record<string, unknown>, newKey);\n                }\n            }\n            else {\n                normalized[newKey] = value;\n            }\n        }\n    }\n\n    flatten(filter, '');\n\n    return normalized as T;\n}\n"],"names":["isJSON","str","getNestedValue","obj","path","current","len","i","key","setNestedValueHelper","value","index","head","setNestedValue","deepClone","item","proto","result","deepMerge","args","validArgs","arg","existingValue","hasArrays","hasObjects","normalizeMongoFilter","filter","normalized","flatten","prefix","newKey","hasMongoOperator","subKey"],"mappings":"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"}

package/dist/util/serializer/index.js

@@ -2,3 +2,4 @@ import { serializer as i } from "./serializer.util.js";
 export {
   i as serializer
 };
+//# sourceMappingURL=index.js.map

package/dist/util/serializer/index.js.map

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

package/dist/util/serializer/serializer.util.js

@@ -1,4 +1,4 @@
-const n = {
+const s = {
   Date: {
     is: (e) => e instanceof Date,
     serialize: (e) => ({ __type: "Date", value: e.toISOString() }),
@@ -6,12 +6,12 @@ const n = {
   },
   Map: {
     is: (e) => e instanceof Map,
-    serialize: (e) => ({ __type: "Map", value: Array.from(e.entries()) }),
+    serialize: (e) => ({ __type: "Map", value: [...e.entries()] }),
     deserialize: (e) => new Map(e)
   },
   Set: {
     is: (e) => e instanceof Set,
-    serialize: (e) => ({ __type: "Set", value: Array.from(e) }),
+    serialize: (e) => ({ __type: "Set", value: [...e] }),
     deserialize: (e) => new Set(e)
   },
   RegExp: {
@@ -21,8 +21,8 @@ const n = {
       value: { source: e.source, flags: e.flags }
     }),
     deserialize: (e) => {
-      const { source: r, flags: t } = e;
-      return new RegExp(r, t);
+      const { source: n, flags: t } = e;
+      return new RegExp(n, t);
     }
   },
   BigInt: {
@@ -41,12 +41,12 @@ const n = {
    * @returns The serialized JSON string that can be safely stored or transmitted.
    */
   serialize(e) {
-    return JSON.stringify(e, function(r, t) {
-      const i = this[r];
+    return JSON.stringify(e, function(n, t) {
+      const i = this[n];
       if (i instanceof Date)
-        return n.Date.serialize(i);
-      for (const o of Object.keys(n)) {
-        const a = n[o];
+        return s.Date.serialize(i);
+      for (const o of Object.keys(s)) {
+        const a = s[o];
         if (a.is(t))
           return a.serialize(t);
       }
@@ -63,9 +63,9 @@ const n = {
    * @returns The deserialized value with all special types reconstructed.
    */
   deserialize(e) {
-    return JSON.parse(e, (r, t) => {
+    return JSON.parse(e, (n, t) => {
       if (t && typeof t == "object" && "__type" in t && typeof t.__type == "string") {
-        const s = t.__type, i = n[s];
+        const r = t.__type, i = s[r];
         if (i)
           return i.deserialize(t.value);
       }
@@ -76,3 +76,4 @@ const n = {
 export {
   p as serializer
 };
+//# sourceMappingURL=serializer.util.js.map

package/dist/util/serializer/serializer.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.util.js","sources":["../../../src/util/serializer/serializer.util.ts"],"sourcesContent":["import type {\n    I_Serializer,\n    I_SerializerTypeWrapper,\n    I_SerializerValueMap,\n    T_SerializerKnownTypes,\n} from './serializer.type.js';\n\n/**\n * Interface for handling serialization and deserialization of specific types.\n * Each handler provides methods to check if a value is of the specific type,\n * serialize it to a format that can be JSON stringified, and deserialize it back.\n */\ninterface I_Handler<T extends T_SerializerKnownTypes> {\n    /** Checks if a value is of the specific type */\n    is: (value: unknown) => value is I_SerializerValueMap[T];\n    /** Serializes a value of the specific type to a format that can be JSON stringified */\n    serialize: (value: I_SerializerValueMap[T]) => I_SerializerTypeWrapper<T>;\n    /** Deserializes a value back to the specific type */\n    deserialize: (value: unknown) => I_SerializerValueMap[T];\n}\n\n/**\n * Type handlers for different JavaScript types that cannot be directly serialized to JSON.\n * Each handler provides methods to serialize and deserialize specific types like Date, Map, Set, etc.\n */\nconst typeHandlers: {\n    [K in T_SerializerKnownTypes]: I_Handler<K>;\n} = {\n    Date: {\n        is: (v): v is Date => v instanceof Date,\n        serialize: v => ({ __type: 'Date', value: v.toISOString() }),\n        deserialize: v => new Date(v as string),\n    },\n    Map: {\n        is: (v): v is Map<unknown, unknown> => v instanceof Map,\n        serialize: v => ({ __type: 'Map', value: [...v.entries()] }),\n        deserialize: v => new Map(v as [unknown, unknown][]),\n    },\n    Set: {\n        is: (v): v is Set<unknown> => v instanceof Set,\n        serialize: v => ({ __type: 'Set', value: [...v] }),\n        deserialize: v => new Set(v as unknown[]),\n    },\n    RegExp: {\n        is: (v): v is RegExp => v instanceof RegExp,\n        serialize: v => ({\n            __type: 'RegExp',\n            value: { source: v.source, flags: v.flags },\n        }),\n        deserialize: (v) => {\n            const { source, flags } = v as { source: string; flags: string };\n            return new RegExp(source, flags);\n        },\n    },\n    BigInt: {\n        is: (v): v is bigint => typeof v === 'bigint',\n        serialize: v => ({ __type: 'BigInt', value: v.toString() }),\n        deserialize: v => BigInt(v as string),\n    },\n};\n\n/**\n * A serializer that can handle complex JavaScript types that cannot be directly JSON stringified.\n * This serializer extends JSON.stringify and JSON.parse to handle types like Date, Map, Set, RegExp, and BigInt.\n *\n * The serializer works by:\n * 1. During serialization: Wrapping special types with type information before JSON stringification\n * 2. During deserialization: Detecting wrapped types and reconstructing them to their original form\n */\nexport const serializer: I_Serializer<unknown> = {\n    /**\n     * Serializes a value to a JSON string.\n     * If the value is of a known type (Date, Map, Set, RegExp, BigInt),\n     * it will be serialized using the corresponding handler.\n     * Otherwise, it will be serialized as is.\n     *\n     * @param value - The value to serialize to a JSON string.\n     * @returns The serialized JSON string that can be safely stored or transmitted.\n     */\n    serialize(value) {\n        return JSON.stringify(value, function (_key, val) {\n            // eslint-disable-next-line ts/no-this-alias\n            const context = this;\n            const originalValue = context[_key];\n\n            if (originalValue instanceof Date) {\n                return typeHandlers.Date.serialize(originalValue);\n            }\n\n            for (const type of Object.keys(typeHandlers) as T_SerializerKnownTypes[]) {\n                const handler = typeHandlers[type];\n\n                if (handler.is(val)) {\n                    return (handler as I_Handler<typeof type>).serialize(val);\n                }\n            }\n\n            return val;\n        });\n    },\n    /**\n     * Deserializes a JSON string to its original value.\n     * If the value is of a known type (Date, Map, Set, RegExp, BigInt),\n     * it will be deserialized using the corresponding handler.\n     * Otherwise, it will be deserialized as is.\n     *\n     * @param json - The JSON string to deserialize back to its original form.\n     * @returns The deserialized value with all special types reconstructed.\n     */\n    deserialize(json) {\n        return JSON.parse(json, (_key, val) => {\n            if (\n                val\n                && typeof val === 'object'\n                && '__type' in val\n                && typeof val.__type === 'string'\n            ) {\n                const type = val.__type as T_SerializerKnownTypes;\n                const handler = typeHandlers[type];\n\n                if (handler) {\n                    return handler.deserialize(val.value);\n                }\n            }\n            return val;\n        });\n    },\n};\n"],"names":["typeHandlers","v","source","flags","serializer","value","_key","val","originalValue","type","handler","json"],"mappings":"AAyBA,MAAMA,IAEF;AAAA,EACA,MAAM;AAAA,IACF,IAAI,CAACC,MAAiBA,aAAa;AAAA,IACnC,WAAW,QAAM,EAAE,QAAQ,QAAQ,OAAOA,EAAE;IAC5C,aAAa,CAAAA,MAAK,IAAI,KAAKA,CAAW;AAAA,EAAA;AAAA,EAE1C,KAAK;AAAA,IACD,IAAI,CAACA,MAAkCA,aAAa;AAAA,IACpD,WAAW,CAAAA,OAAM,EAAE,QAAQ,OAAO,OAAO,CAAC,GAAGA,EAAE,QAAA,CAAS;IACxD,aAAa,CAAAA,MAAK,IAAI,IAAIA,CAAyB;AAAA,EAAA;AAAA,EAEvD,KAAK;AAAA,IACD,IAAI,CAACA,MAAyBA,aAAa;AAAA,IAC3C,WAAW,QAAM,EAAE,QAAQ,OAAO,OAAO,CAAC,GAAGA,CAAC;IAC9C,aAAa,CAAAA,MAAK,IAAI,IAAIA,CAAc;AAAA,EAAA;AAAA,EAE5C,QAAQ;AAAA,IACJ,IAAI,CAACA,MAAmBA,aAAa;AAAA,IACrC,WAAW,CAAAA,OAAM;AAAA,MACb,QAAQ;AAAA,MACR,OAAO,EAAE,QAAQA,EAAE,QAAQ,OAAOA,EAAE,MAAA;AAAA,IAAM;AAAA,IAE9C,aAAa,CAACA,MAAM;AAChB,YAAM,EAAE,QAAAC,GAAQ,OAAAC,EAAA,IAAUF;AAC1B,aAAO,IAAI,OAAOC,GAAQC,CAAK;AAAA,IACnC;AAAA,EAAA;AAAA,EAEJ,QAAQ;AAAA,IACJ,IAAI,CAACF,MAAmB,OAAOA,KAAM;AAAA,IACrC,WAAW,QAAM,EAAE,QAAQ,UAAU,OAAOA,EAAE;IAC9C,aAAa,CAAAA,MAAK,OAAOA,CAAW;AAAA,EAAA;AAE5C,GAUaG,IAAoC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU7C,UAAUC,GAAO;AACb,WAAO,KAAK,UAAUA,GAAO,SAAUC,GAAMC,GAAK;AAG9C,YAAMC,IADU,KACcF,CAAI;AAElC,UAAIE,aAAyB;AACzB,eAAOR,EAAa,KAAK,UAAUQ,CAAa;AAGpD,iBAAWC,KAAQ,OAAO,KAAKT,CAAY,GAA+B;AACtE,cAAMU,IAAUV,EAAaS,CAAI;AAEjC,YAAIC,EAAQ,GAAGH,CAAG;AACd,iBAAQG,EAAmC,UAAUH,CAAG;AAAA,MAEhE;AAEA,aAAOA;AAAA,IACX,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,YAAYI,GAAM;AACd,WAAO,KAAK,MAAMA,GAAM,CAACL,GAAMC,MAAQ;AACnC,UACIA,KACG,OAAOA,KAAQ,YACf,YAAYA,KACZ,OAAOA,EAAI,UAAW,UAC3B;AACE,cAAME,IAAOF,EAAI,QACXG,IAAUV,EAAaS,CAAI;AAEjC,YAAIC;AACA,iBAAOA,EAAQ,YAAYH,EAAI,KAAK;AAAA,MAE5C;AACA,aAAOA;AAAA,IACX,CAAC;AAAA,EACL;AACJ;"}

package/dist/util/string/index.js

@@ -7,3 +7,4 @@ export {
   o as getFileName,
   d as substringBetween
 };
+//# sourceMappingURL=index.js.map

package/dist/util/string/index.js.map

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