@libs-ui/utils 0.2.28 → 0.2.30-6.1

package/fesm2022/libs-ui-utils.mjs

@@ -1,27 +1,249 @@
-import { TemplateRef, ElementRef, signal } from '@angular/core';
+import DeviceDetector from 'device-detector-js';
+import Quill from 'quill';
+import { fromEvent, tap, takeUntil, mergeMap, startWith, finalize, lastValueFrom, timer, Subject, filter, Observable } from 'rxjs';
 import CryptoES from 'crypto-es';
 import { HttpParams } from '@angular/common/http';
-import { Subject, fromEvent, filter } from 'rxjs';
+import { isSignal, TemplateRef, ElementRef, signal, InjectionToken } from '@angular/core';
+import dayjs from 'dayjs';
+import 'dayjs/locale/en';
+import 'dayjs/locale/vi';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import localeData from 'dayjs/plugin/localeData';
+import timezone from 'dayjs/plugin/timezone';
+import updateLocale from 'dayjs/plugin/updateLocale';
+import utc from 'dayjs/plugin/utc';
 
-const getPlatFromBrowser = () => {
-    const userAgent = navigator.userAgent;
-    let tem;
-    let match = userAgent.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
-    if (/trident/i.test(match[1])) {
-        tem = /\brv[ :]+(\d+)/g.exec(userAgent) || [];
-        return 'IE ' + (tem[1] || '');
+/* eslint-disable no-useless-escape */
+const patternEmail = () => {
+    return /^[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]@[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]\.[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]$/;
+};
+const patternUrl = () => {
+    return /^(http|https|ftp):(\/){2}[^\s]+[.]{1}[^\s]+$/;
+};
+const patternHostUrl = () => {
+    return /^((https|http|ftp):[/]{2}[^/\s]+)/;
+};
+const patternDomain = () => {
+    return /^([a-zA-Z0-9])(([a-z0-9-]{1,61})?[a-z0-9]{1})?(\.[a-z0-9](([a-z0-9-]{1,61})?[a-z0-9]{1})?)?(\.[a-zA-Z]{2,4})+$/;
+};
+const patternMobilePhone = () => {
+    return /^(\+?84|0|84)([0-9]{9})$/;
+};
+const patternPhone = () => {
+    return /^(\+?84|[0-9]|84)([0-9]{2,9})$/;
+};
+const patternPhoneNormal = () => {
+    return /^(\+?84|[0-9]|84)([0-9]{9,10})$/;
+};
+const patternNumber = () => {
+    return /\d+/g;
+};
+const patternEncodeUri = () => {
+    return /%([0-9A-F]{2})/g;
+};
+const patternName = () => {
+    return /^\w+[A-Za-z\s\d]+$/;
+};
+const patternNameUtf8 = () => {
+    return /^[ àáảãạăắằẵặẳâầấậẫẩđèéẻẽẹêềếểễệìíỉĩịòóỏõọôồốổỗộơờớởỡợùúủũụưừứửữựỳýỷỹÀÁẢÃẠĂẮẰẴẶẲÂẦẤẬẪẨĐÈÉẺẼẸÊỀẾỂỄỆÌÍỈĨỊÒÓỎÕỌÔỒỐỔỖỘƠỜỚỞỠỢÙÚỦŨỤƯỪỨỬỮỰỲÝỶỸA-Za-z0-9]+$/;
+};
+const patternNameSpecial = () => {
+    return /[~!@#$%^&*()-+=<>,?\/\\:;"']/;
+};
+const patternNameProfile = () => {
+    return /([\w\W\d\s]+)+/;
+};
+const patternEmoji = () => {
+    return /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/g;
+};
+const patternRuleFieldReplace = () => {
+    return /[{]{2}[a-zA-Z_-]+[}]{2}/g;
+};
+const patternGetFieldByRuleFieldReplace = () => {
+    return /[a-zA-Z_-]+/g;
+};
+const patternPem = () => {
+    return /^(0|1):([0-9]{1,2}):(\{\{path-api\}\}):([a-zA-Z0-9\/]+)$/g;
+};
+const patternTax = () => {
+    return /^([0-9]){10}(-[0-9]{3})?$/;
+};
+const patternKey = () => {
+    return /^([0-9]){10}(-[0-9]{3})?$/;
+};
+const patternAccount = () => {
+    return /^(?=.*@)[a-z0-9@._-]{2,63}$/;
+};
+
+const highlightByKeyword = (value, search, ignoreHighlight, classHightLight) => {
+    if (!value) {
+        return '&mdash;';
+    }
+    try {
+        if (!search || ignoreHighlight) {
+            return value;
+        }
+        const keysReplace = getValueReplace(search, value);
+        if (!keysReplace || !keysReplace.length) {
+            return value;
+        }
+        if (!classHightLight) {
+            classHightLight = 'bg-[#19344a] text-white';
+        }
+        keysReplace.forEach(key => {
+            const regExp = new RegExp(key, 'gi');
+            value = value?.replace(regExp, `<span class="${classHightLight}">$&</span>`);
+        });
+    }
+    catch (error) {
+        console.log(error);
+    }
+    finally {
+        // eslint-disable-next-line no-unsafe-finally
+        return value;
+    }
+};
+const getValueReplace = (search, value) => {
+    const searchConvert = deleteUnicode(search).toLowerCase();
+    const valueConvert = deleteUnicode(value).toLowerCase();
+    const keys = new Set();
+    let i = 0;
+    while ((i = valueConvert.indexOf(searchConvert, i)) >= 0) {
+        const endIndex = i + search.length;
+        keys.add(value.substring(i, endIndex));
+        i += +valueConvert.length;
+    }
+    return Array.from(keys);
+};
+const formatTextCompare = (text, options) => {
+    if (!text) {
+        return text;
+    }
+    text = text.normalize("NFC");
+    return formatByOptions(text, options);
+};
+const fullNameFormat = (value) => {
+    if (!value) {
+        return value;
+    }
+    return capitalize(value, { lowercaseOtherCharacter: true, trim: true, removeMultipleSpace: true, removeEmoji: true });
+};
+const capitalize = (text, options) => {
+    if (!text) {
+        return text;
+    }
+    text = formatByOptions(text, options);
+    return text.split(' ').map(word => firstLetterToUpperCase(word)).join(' ');
+};
+const firstLetterToUpperCase = (text, options) => {
+    if (!text) {
+        return text;
+    }
+    return uppercaseByPosition(text, 0, options);
+};
+const uppercaseByPosition = (text, position, options) => {
+    if (!text) {
+        return text;
+    }
+    text = formatByOptions(text, options);
+    return `${text.substring(0, position)}${text.charAt(position).toUpperCase()}${text.substring(position + 1)}`;
+};
+const formatByOptions = (text, options) => {
+    if (!text || !options) {
+        return text;
+    }
+    if (options?.uppercaseOtherCharacter) {
+        text = text.toUpperCase();
     }
-    if (match[1] === 'Chrome') {
-        tem = userAgent.match(/\b(OPR|Edge)\/(\d+)/);
-        if (tem !== null) {
-            return tem.slice(1).join(' ').replace('OPR', 'Opera');
+    if (options?.lowercaseOtherCharacter) {
+        text = text.toLowerCase();
+    }
+    if (options?.removeMultipleSpace) {
+        text = text.replace(/\u200B|\u00A0/g, "");
+        text = text.replace(/\s+/g, ' ');
+    }
+    if (options?.removeEmoji) {
+        text = removeEmoji(text);
+    }
+    if (options?.removeUnicode) {
+        text = deleteUnicode(text);
+    }
+    if (options?.trim) {
+        text = text.trim();
+    }
+    return text;
+};
+const escapeHtml = (str) => {
+    if (!str || typeof str !== 'string') {
+        return str;
+    }
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+};
+const decodeEscapeHtml = (str) => {
+    const htmlTag = document.createElement('textarea');
+    htmlTag.innerHTML = str;
+    while (str) {
+        if (str === htmlTag.value) {
+            str = htmlTag.value;
+            htmlTag.remove();
+            break;
         }
+        str = htmlTag.value;
+        htmlTag.innerHTML = str;
+    }
+    return str;
+};
+const deleteUnicode = (str) => {
+    str = str.replace(/à|á|ạ|ả|ã|â|ầ|ấ|ậ|ẩ|ẫ|ă|ằ|ắ|ặ|ẳ|ẵ/g, 'a');
+    str = str.replace(/è|é|ẹ|ẻ|ẽ|ê|ề|ế|ệ|ể|ễ|ễ/g, 'e');
+    str = str.replace(/ì|í|ị|ỉ|ĩ/g, 'i');
+    str = str.replace(/ò|ó|ọ|ỏ|õ|ô|ồ|ố|ộ|ổ|ỗ|ơ|ờ|ớ|ợ|ở|ỡ/g, 'o');
+    str = str.replace(/ù|ú|ụ|ủ|ũ|ư|ừ|ứ|ự|ử|ữ/g, 'u');
+    str = str.replace(/ỳ|ý|ỵ|ỷ|ỹ/g, 'y');
+    str = str.replace(/đ/g, 'd');
+    str = str.replace(/À|Á|Ạ|Ả|Ã|Â|Ầ|Ấ|Ậ|Ẩ|Ẫ|Ă|Ằ|Ắ|Ặ|Ẳ|Ẵ/g, 'A');
+    str = str.replace(/È|É|Ẹ|Ẻ|Ẽ|Ê|Ề|Ế|Ệ|Ể|Ễ/g, 'E');
+    str = str.replace(/Ì|Í|Ị|Ỉ|Ĩ/g, 'I');
+    str = str.replace(/Ò|Ó|Ọ|Ỏ|Õ|Ô|Ồ|Ố|Ộ|Ổ|Ỗ|Ơ|Ờ|Ớ|Ợ|Ở|Ỡ/g, 'O');
+    str = str.replace(/Ù|Ú|Ụ|Ủ|Ũ|Ư|Ừ|Ứ|Ự|Ử|Ữ/g, 'U');
+    str = str.replace(/Ỳ|Ý|Ỵ|Ỷ|Ỹ/g, 'Y');
+    str = str.replace(/Đ/g, 'D');
+    str = str.replace(/\u0300|\u0301|\u0303|\u0309|\u0323/g, ""); // ̀ ́ ̃ ̉ ̣  huyền, sắc, ngã, hỏi, nặng
+    str = str.replace(/\u02C6|\u0306|\u031B/g, ""); // ˆ ̆ ̛  Â, Ê, Ă, Ơ, Ư
+    return str.normalize("NFC");
+};
+const removeEmoji = (text) => {
+    if (!text || !text.trim()) {
+        return text;
     }
-    match = match[2] ? [match[1], match[2]] : [navigator.appName, navigator.appVersion, '-?'];
-    if ((tem = userAgent.match(/version\/(\d+)/i)) !== null) {
-        match.splice(1, 1, tem[1]);
+    return text.replace(patternEmoji(), '');
+};
+
+const deviceDetector = new DeviceDetector();
+const parser = new DOMParser();
+const quill = new Quill(document.createElement('div'));
+const getDeviceInfo = () => {
+    return deviceDetector.parse(window.navigator.userAgent);
+};
+const getPlatFromBrowser = () => {
+    const info = getDeviceInfo();
+    return `${info.client?.name} ${info.client?.version}`;
+};
+const getEventNameHandleClick = (() => {
+    const deviceInfo = getDeviceInfo();
+    let nameEventHandleClick = deviceInfo.device?.type === 'desktop' ? 'click' : 'touchstart';
+    if ('onpointerdown' in window) {
+        nameEventHandleClick = 'pointerdown';
     }
-    return match.join(' ');
+    return nameEventHandleClick;
+})();
+const getDocumentByString = (htmlStr) => {
+    return parser.parseFromString(htmlStr, 'text/html');
 };
 const cloneIBoundingClientRect = (rect) => {
     return {
@@ -29,10 +251,10 @@ const cloneIBoundingClientRect = (rect) => {
         left: rect['left'],
         width: rect['width'],
         height: rect['height'],
-        bottom: rect['bottom']
+        bottom: rect['bottom'],
     };
 };
-const setStyles = (el, styles, render2) => {
+const setStylesElement = (el, styles, render2) => {
     Object.keys(styles).forEach((key) => render2.setStyle(el, key, styles[key]));
 };
 const getViewport = (win = window) => {
@@ -68,7 +290,10 @@ const checkViewInScreen = (container, element, elementScroll, maxTopLeft) => {
     const limitLeft = leftContainer + scrollLeftContainer + widthContainer;
     const maxTopItem = top + (maxTopLeft?.top || 0);
     const maxLeftItem = left + (maxTopLeft?.left || 0);
-    if (topContainer <= maxTopItem && maxTopItem <= limitTop && leftContainer <= maxLeftItem && maxLeftItem <= limitLeft) {
+    if (topContainer <= maxTopItem &&
+        maxTopItem <= limitTop &&
+        leftContainer <= maxLeftItem &&
+        maxLeftItem <= limitLeft) {
         return true;
     }
     return false;
@@ -82,11 +307,181 @@ const checkMouseOverInContainer = (mousePosition, element, rect) => {
     const limitLeft = left + width;
     const limitTop = top + height;
     const { clientX, clientY } = mousePosition;
-    if (left <= clientX && clientX <= limitLeft && top <= clientY && clientY <= limitTop) {
+    if (left <= clientX &&
+        clientX <= limitLeft &&
+        top <= clientY &&
+        clientY <= limitTop) {
         return true;
     }
     return false;
 };
+const getDragEventByElement = (config) => {
+    let timer;
+    const addClass = () => {
+        timer = setTimeout(() => {
+            document.body.classList.add('!select-none');
+            document.body.classList.add('!cursor-grabbing');
+        }, 250);
+    };
+    const removeClass = () => {
+        document.body.classList.remove('!select-none');
+        document.body.classList.remove('!cursor-grabbing');
+        clearTimeout(timer);
+    };
+    fromEvent(config.elementMouseDown, 'mouseleave')
+        .pipe(tap(() => document.body.classList.remove('cursor-pointer')), takeUntil(config.onDestroy))
+        .subscribe();
+    fromEvent(config.elementMouseDown, 'mouseenter')
+        .pipe(tap(() => document.body.classList.add('cursor-pointer')), takeUntil(config.onDestroy))
+        .subscribe();
+    const mouseDown = fromEvent(config.elementMouseDown, 'mousedown').pipe(tap((e) => {
+        e.stopPropagation();
+        addClass();
+        config.functionMouseDown?.(e);
+    }));
+    const mouseup = fromEvent(config.elementMouseUp || document, 'mouseup').pipe(tap((e) => {
+        e.stopPropagation();
+        removeClass();
+        config.functionMouseUp?.(e);
+    }));
+    const mousemove = fromEvent(config.elementMouseMove || document, 'mousemove').pipe(tap((e) => {
+        e.stopPropagation();
+        config.functionMouseMove?.(e);
+    }), takeUntil(mouseup));
+    return mouseDown.pipe(mergeMap((e) => config.isStartWithMouseDownEvent
+        ? mousemove.pipe(startWith(e))
+        : mousemove), takeUntil(config.onDestroy), finalize(removeClass));
+};
+const getHTMLFromQuill = async (data, options) => {
+    const { replaceNewLineTo = '<br>', replaceTagBRTo, replaceTags, replaceBrToDiv } = options || {};
+    const delta = (typeof data === 'string') ? await getDeltaFromHTML(data) : data;
+    if (options?.functionReplaceDelta) {
+        options.functionReplaceDelta(delta);
+    }
+    delta.ops.forEach((op) => {
+        if (op.insert) {
+            if (typeof op.insert === 'string') {
+                if (replaceNewLineTo) {
+                    op.insert = op.insert.replace(/\n/g, replaceNewLineTo);
+                }
+                if (replaceTagBRTo) {
+                    op.insert = op.insert.replace(/<br>/g, replaceTagBRTo);
+                }
+                if (replaceTags?.length) {
+                    for (const tag of replaceTags) {
+                        op.insert = op.insert.replace(new RegExp(`<${tag.tag}>`, 'g'), `<${tag.replaceTo}>`);
+                        op.insert = op.insert.replace(new RegExp(`</${tag.tag}>`, 'g'), `</${tag.replaceTo}>`);
+                    }
+                }
+            }
+        }
+    });
+    quill.setContents(delta);
+    let htmlText = options?.getRootHtml ? quill.root.innerHTML : quill.root.firstElementChild?.innerHTML;
+    if (replaceBrToDiv) {
+        htmlText = convertHtmlToDivBlocks(htmlText || '');
+    }
+    return decodeEscapeHtml(htmlText || '');
+};
+const convertHtmlToDivBlocks = (html) => {
+    const BREAK_TOKEN = '<<<BREAK>>>';
+    // Bước 1: thay <br> thành token tạm
+    const normalizedHtml = html.replace(/<br\s*\/?>/gi, BREAK_TOKEN);
+    // Bước 2: tách theo token
+    const parts = normalizedHtml.split(BREAK_TOKEN);
+    const parser = new DOMParser();
+    const divs = [];
+    for (const raw of parts) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        // parse mỗi phần nhỏ như một document riêng
+        const doc = parser.parseFromString(trimmed, 'text/html');
+        const body = doc.body;
+        // Lấy lại nội dung bên trong body
+        divs.push(`<div>${body.innerHTML}</div>`);
+    }
+    return divs.join('');
+};
+const getDeltaFromHTML = async (html) => {
+    quill.root.innerHTML = html;
+    setTimeout(() => {
+        console.log(quill.getContents());
+    }, 1000);
+    await lastValueFrom(timer(1000));
+    return quill.getContents();
+};
+const processPasteData = async (e, config) => {
+    const element = config.element;
+    const files = e.clipboardData?.files;
+    if (files?.length) {
+        e.preventDefault();
+        config.handlerPasteFile?.(files);
+        config.callBack?.('file');
+        return;
+    }
+    // Lưu selection TRƯỚC khi prevent default
+    const selection = window.getSelection();
+    let savedRange = null;
+    if (selection && selection.rangeCount > 0) {
+        const range = selection.getRangeAt(0);
+        // Chỉ lưu nếu range nằm trong contentText element
+        const container = range.commonAncestorContainer;
+        const isInContentElement = element.contains(container.nodeType === Node.TEXT_NODE ? container.parentNode : container);
+        if (isInContentElement) {
+            savedRange = range.cloneRange();
+        }
+    }
+    // Prevent default để tự xử lý paste
+    e.preventDefault();
+    // Sử dụng Quill để clean HTML content
+    const htmlContent = e.clipboardData?.getData('text/html') || '';
+    const plainText = e.clipboardData?.getData('text/plain') || '';
+    let contentToInsert = (plainText || '').replace(/\n/g, '<br>');
+    if (htmlContent) {
+        contentToInsert = await getHTMLFromQuill(htmlContent);
+    }
+    if (!contentToInsert) {
+        config.callBack?.('no-content');
+        return;
+    }
+    if (savedRange) {
+        insertContentWithRange(contentToInsert, savedRange, element);
+        config.callBack?.('range');
+        return;
+    }
+    element.innerHTML += contentToInsert;
+    config.callBack?.('content');
+};
+const insertContentWithRange = (content, savedRange, element) => {
+    const selection = window.getSelection();
+    if (!selection) {
+        // Fallback: append vào cuối
+        element.innerHTML += content;
+        return;
+    }
+    // Restore selection
+    selection.removeAllRanges();
+    selection.addRange(savedRange);
+    // Xóa nội dung đã select (nếu có)
+    savedRange.deleteContents();
+    // Tạo document fragment từ HTML content
+    const tempDiv = document.createElement('div');
+    tempDiv.innerHTML = content;
+    const fragment = document.createDocumentFragment();
+    while (tempDiv.firstChild) {
+        fragment.appendChild(tempDiv.firstChild);
+    }
+    // Insert fragment tại vị trí range
+    savedRange.insertNode(fragment);
+    // Di chuyển cursor đến cuối nội dung vừa insert
+    if (fragment.lastChild) {
+        savedRange.setStartAfter(fragment.lastChild);
+    }
+    savedRange.collapse(true);
+    selection.removeAllRanges();
+    selection.addRange(savedRange);
+};
 
 class UtilsUrlSearchParams {
     static instance;
@@ -185,6 +580,46 @@ class UtilsUrlSearchParams {
     }
 }
 
+let key$1 = '12~@#loqwsxacva(3rdhaq12';
+/**
+ * @description Thiết lập key mã hóa
+ * @param value key mã hóa, độ dài bằng 24 hoặc 32 ký tự.
+ */
+const setKeyCrypto = (value) => {
+    if (value.length !== 24 && value.length !== 32) {
+        throw Error(`key.length = ${value.length}; Key phải là 1 chuỗi dài 24 hoặc 32 ký tự`);
+    }
+    key$1 = value;
+};
+const keyStore$1 = () => {
+    return key$1;
+};
+const encrypt = (plainData) => {
+    if (!keyStore$1()) {
+        throw Error("lỗi chưa setup key mã hóa");
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore$1());
+    const iv = CryptoES.enc.Hex.parse(keyStore$1());
+    const mode = CryptoES.mode.CBC;
+    const padding = CryptoES.pad.Pkcs7;
+    const options = { iv: iv, mode: mode, padding: padding };
+    return CryptoES.AES.encrypt(plainData, key, options).toString();
+};
+const decrypt = (encryptedData) => {
+    if (!keyStore$1()) {
+        throw Error("lỗi chưa setup key mã hóa");
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore$1());
+    const iv = CryptoES.enc.Hex.parse(keyStore$1());
+    const mode = CryptoES.mode.CBC;
+    const padding = CryptoES.pad.Pkcs7;
+    const options = { iv: iv, mode: mode, padding: padding };
+    return CryptoES.AES.decrypt(encryptedData, key, options).toString(CryptoES.enc.Utf8);
+};
+const md5 = (plainData) => {
+    return CryptoES.MD5(plainData).toString();
+};
+
 const uuid = () => {
     const timestamp = performance.now() * 1000;
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?/~';
@@ -199,379 +634,93 @@ const uuid = () => {
         [charArray[i], charArray[j]] = [charArray[j], charArray[i]];
     }
     const shuffledString = charArray.join('');
-    return shuffledString;
+    return md5(shuffledString);
 };
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-const isNil = (value) => {
-    return value === null || value === undefined;
-};
-const isEmpty = (value) => {
-    return value === null || value === '' || value === undefined || (typeof value === 'object' && (JSON.stringify(value) === '{}' || JSON.stringify(value) === '[]'));
+const UtilsHttpParamsRequestInstance = (options, instance) => {
+    return new UtilsHttpParamsRequest(options, instance);
 };
-const get = (obj, path, defaultValue = undefined) => {
-    if (obj == null) {
-        return defaultValue;
-    }
-    const paths = Array.isArray(path) ? path : path.replace(/\[(\d+)]/g, '.$1').split('.');
-    for (let i = 0; i < paths.length; i++) {
-        if (obj == null || !Object.prototype.hasOwnProperty.call(obj, paths[i])) {
-            return defaultValue;
+class UtilsHttpParamsRequest extends HttpParams {
+    params = new HttpParams();
+    constructor(options, instance) {
+        super(options);
+        if (!instance) {
+            this.params = new HttpParams(options);
+            return;
+        }
+        if (instance instanceof UtilsHttpParamsRequest) {
+            this.params = instance.getInstance();
+            return;
+        }
+        if (instance instanceof HttpParams) {
+            this.params = instance;
+            return;
         }
-        obj = obj[paths[i]];
     }
-    return obj;
-};
-const set = (obj, path, value) => {
-    if (!obj || typeof obj !== "object") {
-        throw new Error("The first argument must be an object");
+    getInstance() {
+        return this.params;
     }
-    const pathArray = Array.isArray(path) ? path : path.replace(/\[(\d+)]/g, '.[$1]').split('.');
-    let current = obj;
-    pathArray.forEach((key, index) => {
-        if (index < pathArray.length - 1) {
-            if (!(key in current) || typeof current[key] !== "object") {
-                const nextKey = pathArray[index + 1];
-                key = key.replace(/\[(\d+)]/g, '$1');
-                current[key] = /\[(\d+)]/g.test(nextKey) ? [] : {};
-            }
-            current = current[key];
+    setInstance(instance) {
+        if (instance instanceof UtilsHttpParamsRequest) {
+            this.params = instance.getInstance();
+            return;
+        }
+        if (instance instanceof HttpParams) {
+            this.params = instance;
             return;
         }
-        // Gán giá trị ở cuối đường dẫn
-        current[key] = value;
-    });
-    return obj;
-};
-const cloneDeep = (value) => {
-    if (value === null || typeof value !== 'object') {
-        return value;
     }
-    if (value instanceof Date) {
-        return new Date(value.getTime());
+    set(param, value) {
+        this.params = this.params.set(param, value);
+        return this;
     }
-    if (value instanceof RegExp) {
-        return new RegExp(value.source, value.flags);
+    has(param) {
+        return this.params.has(param);
     }
-    if (value instanceof Map) {
-        const mapCopy = new Map();
-        value.forEach((val, key) => {
-            mapCopy.set(cloneDeep(key), cloneDeep(val));
-        });
-        return mapCopy;
+    get(param) {
+        return this.params.get(param);
     }
-    if (value instanceof Set) {
-        const setCopy = new Set();
-        value.forEach(val => {
-            setCopy.add(cloneDeep(val));
-        });
-        return setCopy;
+    getAll(param) {
+        return this.params.getAll(param);
     }
-    if (Array.isArray(value)) {
-        return value.map(item => cloneDeep(item));
+    keys() {
+        return this.params.keys();
     }
-    const result = {};
-    for (const key in value) {
-        if (value[key] instanceof TemplateRef || value[key] instanceof ElementRef || value[key] instanceof Element) {
-            result[key] = value[key];
-            continue;
-        }
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-            result[key] = cloneDeep(value[key]);
-        }
+    append(param, value) {
+        this.params = this.params.append(param, value);
+        return this;
     }
-    return result;
-};
-const convertObjectToSignal = (data) => {
-    if (data === null || typeof data !== 'object') {
-        return data;
+    appendAll(params) {
+        this.params = this.params.appendAll(params);
+        return this;
     }
-    if (Array.isArray(data)) {
-        if (typeof data[0] !== 'object') {
-            return signal(data);
-        }
-        return signal(data.map(item => convertObjectToSignal(cloneDeep(item))));
+    delete(param, value) {
+        this.params = this.params.delete(param, value);
+        return this;
     }
-    data = signal(data);
-    for (const key in data()) {
-        const value = data()[key];
-        if (value instanceof TemplateRef || value instanceof ElementRef || value instanceof Element || value instanceof Date || value instanceof RegExp || value instanceof Set || value instanceof Map) {
-            continue;
-        }
-        if (Object.prototype.hasOwnProperty.call(data(), key)) {
-            data()[key] = convertObjectToSignal(cloneDeep(data()[key]));
-        }
-    }
-    return data;
-};
-const convertSignalToObject = (data) => {
-    if (data === null || typeof data !== 'object' || !(data instanceof signal)) {
-        return data;
-    }
-    if (Array.isArray(data)) {
-        if (typeof data[0] !== 'object') {
-            return signal(data);
-        }
-        return signal(data.map(item => convertObjectToSignal(cloneDeep(item))));
-    }
-    data = signal(data);
-    for (const key in data()) {
-        const value = data()[key];
-        if (value instanceof TemplateRef || value instanceof ElementRef || value instanceof Element || value instanceof Date || value instanceof RegExp || value instanceof Set || value instanceof Map) {
-            continue;
-        }
-        if (Object.prototype.hasOwnProperty.call(data(), key)) {
-            data()[key] = convertObjectToSignal(cloneDeep(data()[key]));
-        }
-    }
-    return data;
-};
-const keyBy = (data, key) => {
-    if (!data || !data.length || !key) {
-        return {};
-    }
-    return data.reduce((dir, nextItem) => {
-        const valueOfKey = nextItem[key];
-        if (typeof valueOfKey !== 'string' && typeof valueOfKey !== 'number') {
-            return dir;
-        }
-        dir[valueOfKey] = nextItem;
-        return dir;
-    }, {});
-};
-const groupBy = (data, key) => {
-    if (!data || !Object.keys(data).length || !key) {
-        return {};
-    }
-    return data.reduce((dir, nextItem) => {
-        const valueOfKey = nextItem[key];
-        if (typeof valueOfKey !== 'string' && typeof valueOfKey !== 'number') {
-            return dir;
-        }
-        if (!dir[valueOfKey]) {
-            dir[valueOfKey] = [];
-        }
-        dir[valueOfKey].push(nextItem);
-        return dir;
-    }, {});
-};
-const range = (start, end, step) => {
-    if (end === undefined || end === null) {
-        end = start;
-        start = 0;
-    }
-    if (!step) {
-        step = end < 0 ? -1 : 1;
-    }
-    const valueStartByStep = step + start;
-    const direction = start < end ? 'asc' : 'desc';
-    if ((direction === 'asc' && (valueStartByStep < start || valueStartByStep > end)) || (direction === 'desc' && (valueStartByStep > start || valueStartByStep < end))) {
-        return [start];
-    }
-    const arr = new Array();
-    for (let index = 0; index < Math.abs(end - start); index++) {
-        let value = start + index * step;
-        if (index === 0) {
-            value = start;
-        }
-        if ((direction === 'asc' && (value < start || value > end)) || (direction === 'desc' && (value > start || value < end))) {
-            return arr;
-        }
-        arr.push(value);
-    }
-    return arr;
-};
-const isEqual = (value1, value2) => {
-    if (value1 === value2 || (value1 === null && value2 === null) || (value1 === undefined && value2 === undefined)) {
-        return true;
-    }
-    if (typeof value1 !== 'object' || typeof value2 !== 'object' || (Array.isArray(value1) && !Array.isArray(value2))) {
-        return false;
-    }
-    if (Array.isArray(value1)) {
-        if (value1.length !== value2.length) {
-            return false;
-        }
-        return !value1.some((item, index) => !isEqual(item, value2[index]));
-    }
-    if (Object.keys(value1).length !== Object.keys(value2).length) {
-        return false;
-    }
-    return !Object.keys(value1).some((key) => !isEqual(value1[key], value2[key]));
-};
-const uniqBy = (data, key) => {
-    if (!key || !data || !data.length || typeof data[0] !== 'object') {
-        console.log('vao dauy r', !key, !data, !data.length, typeof data[0] !== 'object');
-        return Array.from(new Set(data));
-    }
-    const dataUnique = keyBy(data, key);
-    return Object.keys(dataUnique).map(key => dataUnique[key]);
-};
-const generateInterface = (obj, interfaceName) => {
-    const generateType = (value) => {
-        if (value === null) {
-            return 'null';
-        }
-        const type = typeof value;
-        if (type === 'string') {
-            return 'string';
-        }
-        if (type === 'number') {
-            return 'number';
-        }
-        if (type === 'boolean') {
-            return 'boolean';
-        }
-        if (type === 'undefined') {
-            return 'any';
-        }
-        if (value instanceof Date) {
-            return 'Date';
-        }
-        if (value instanceof RegExp) {
-            return 'RegExp';
-        }
-        if (Array.isArray(value)) {
-            if (value.length === 0) {
-                return 'Array<any>';
-            }
-            return `Array<${generateType(value[0])}>`;
-        }
-        if (type === 'object') {
-            let interfaceStr = '{\n';
-            for (const key in value) {
-                if (Object.prototype.hasOwnProperty.call(value, key)) {
-                    const valueType = generateType(value[key]);
-                    interfaceStr += `  ${key}: ${valueType};\n`;
-                }
-            }
-            interfaceStr += '}';
-            return interfaceStr;
-        }
-        return 'any';
-    };
-    const interfaceStr = `interface ${interfaceName} ${generateType(obj)}`;
-    return interfaceStr;
-};
-
-;
-const step = 20;
-const percent = 0.05;
-const colorStepContrastFromOrigin = (color, stepNumber) => {
-    return colorContrastFromOrigin(color).find(item => item.step === stepNumber);
-};
-const colorContrastFromOrigin = (color) => {
-    const parsedColorsArray = parseColorValues(color);
-    const colors = [];
-    let calculatedShades = [];
-    let calculatedTints = [];
-    if (parsedColorsArray !== null) {
-        for (let i = 0; i < parsedColorsArray.length; i++) {
-            calculatedShades = calculateShades(parsedColorsArray[i]);
-            calculatedTints = calculateTints(parsedColorsArray[i]);
-        }
-        for (let i = 0; i <= step; i++) {
-            colors.push({ step: i * 5, label: `${i * 5}%`, dark: `#${calculatedShades[i]}`, light: `#${calculatedTints[i]}` });
-        }
-    }
-    return colors;
-};
-const parseColorValues = (colorValues) => {
-    let colorValuesArray = colorValues.match(/\b[0-9A-Fa-f]{3}\b|[0-9A-Fa-f]{6}\b/g);
-    if (colorValuesArray) {
-        colorValuesArray = colorValuesArray.map((item) => {
-            if (item.length === 3) {
-                let newItem = item.toString().split('');
-                newItem = newItem.reduce((acc, it) => {
-                    return acc + it + it;
-                }, '');
-                return newItem;
-            }
-            return item;
-        });
-    }
-    return colorValuesArray;
-};
-const calculateShades = (colorValue) => {
-    return calculate(colorValue, rgbShade).concat("000000");
-};
-const calculateTints = (colorValue) => {
-    return calculate(colorValue, rgbTint).concat("ffffff");
-};
-const calculate = (colorValue, shadeOrTint) => {
-    const color = hexToRGB(colorValue);
-    const shadeValues = [];
-    for (let i = 0; i < step; i++) {
-        shadeValues[i] = rgbToHex(shadeOrTint(color, i));
-    }
-    return shadeValues;
-};
-const rgbShade = (rgb, i) => { return { red: rgb.red * (1 - percent * i), green: rgb.green * (1 - percent * i), blue: rgb.blue * (1 - percent * i) }; };
-const rgbTint = (rgb, i) => { return { red: rgb.red + (255 - rgb.red) * i * percent, green: rgb.green + (255 - rgb.green) * i * percent, blue: rgb.blue + (255 - rgb.blue) * i * percent }; };
-const rgbToHex = (rgb) => { return intToHex(rgb.red) + intToHex(rgb.green) + intToHex(rgb.blue); };
-const hexToRGB = (colorValue) => { return { red: parseInt(colorValue.substr(0, 2), 16), green: parseInt(colorValue.substr(2, 2), 16), blue: parseInt(colorValue.substr(4, 2), 16) }; };
-const intToHex = (rgbint) => { return pad(Math.min(Math.max(Math.round(rgbint), 0), 255).toString(16), 2); };
-const pad = (number, length) => {
-    let str = '' + number;
-    while (str.length < length) {
-        str = '0' + str;
-    }
-    return str;
-};
-const listColorDefine$1 = ['#E62222', '#B81B1B', '#EB4E4E', '#F97316', '#C75C12', '#FA8F45', '#FFB700', '#CC9200', '#FFC533', '#84CC16', '#6AA312', '#9dd645', '#00BC62', '#00A757', '#33DA8A', '#06B6D4', '#1B59C4', '#4E8CF7', '#0EA5E9',
-    '#1B59C4', '#4E8CF7', '#226FF5', '#1B59C4', '#4E8CF7', '#6366F1', '#4F52C1', '#8285F4', '#5B04B3', '#49038F', '#7C36C2', '#D946EF', '#AE38BF', '#E16BF2', '#EC4899', '#BD3A7A', '#F06DAD', '#F43F5E', '#C3324B', '#F6657E', '#757380', '#5E5C66', '#918F99',
-    '#202020', '#1A1A1A', '#4D4D4D'
-];
-const GetColorById = (str) => {
-    let hashString = 0;
-    if (!str) {
-        return '';
-    }
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hashString = ((hashString << 5) - hashString) + char;
-        hashString = hashString & hashString;
-    }
-    return listColorDefine$1[Math.abs(hashString) % listColorDefine$1.length];
-};
-
-let key$1 = '12~@#loqwsxacva(3rdhaq12';
-const setKeyCrypto = (value) => {
-    if (value.length !== 24 && value.length !== 32) {
-        throw Error(`key.length = ${value.length}; Key phải là 1 chuỗi dài 24 hoặc 32 ký tự`);
-    }
-    key$1 = value;
-};
-const keyStore$1 = () => {
-    return key$1;
-};
-const encrypt = (plainData) => {
-    if (!keyStore$1()) {
-        throw Error("lỗi chưa setup key mã hóa");
-    }
-    const key = CryptoES.enc.Hex.parse(keyStore$1());
-    const iv = CryptoES.enc.Hex.parse(keyStore$1());
-    const mode = CryptoES.mode.CBC;
-    const padding = CryptoES.pad.Pkcs7;
-    const options = { iv: iv, mode: mode, padding: padding };
-    return CryptoES.AES.encrypt(plainData, key, options).toString();
-};
-const decrypt = (encryptedData) => {
-    if (!keyStore$1()) {
-        throw Error("lỗi chưa setup key mã hóa");
+    toString() {
+        return this.params.toString();
     }
-    const key = CryptoES.enc.Hex.parse(keyStore$1());
-    const iv = CryptoES.enc.Hex.parse(keyStore$1());
-    const mode = CryptoES.mode.CBC;
-    const padding = CryptoES.pad.Pkcs7;
-    const options = { iv: iv, mode: mode, padding: padding };
-    return CryptoES.AES.decrypt(encryptedData, key, options).toString(CryptoES.enc.Utf8);
-};
-const md5 = (plainData) => {
-    return CryptoES.MD5(plainData).toString();
-};
+}
+// Demo su dung GET_PATH_VARIABLE
+// interface Person {
+//   name: string;
+//   age: number;
+//   location: string;
+// }
+// type c = GET_PATH_VARIABLE<Person, unknown>;
+// const a: c = {
+//   "pathVariable-age": 1,
+//   "pathVariable-location": '12',
+//   "pathVariable-name": '124',
+// };
 
 let key = '12~@#loqwsxacva(3rdhaq12';
+/**
+ * @description Thiết lập key mã hóa
+ * @param value key mã hóa, độ dài bằng 24 hoặc 32 ký tự.
+ */
 const setKeyCrypto3rd = (value) => {
     if (value.length !== 24 && value.length !== 32) {
         throw Error(`key.length = ${value.length}; Key phải là 1 chuỗi dài 24 hoặc 32 ký tự`);
@@ -604,219 +753,6 @@ const decrypt3rd = (encryptedData) => {
     return CryptoES.AES.decrypt(encryptedData, key, options).toString(CryptoES.enc.Utf8);
 };
 
-class UtilsKeyCodeConstant {
-    static MAC_ENTER = 3;
-    static BACKSPACE = 8;
-    static TAB = 9;
-    static NUM_CENTER = 12;
-    static ENTER = 13;
-    static SHIFT = 16;
-    static CONTROL = 17;
-    static ALT = 18;
-    static PAUSE = 19;
-    static CAPS_LOCK = 20;
-    static ESCAPE = 27;
-    static SPACE = 32;
-    static PAGE_UP = 33;
-    static PAGE_DOWN = 34;
-    static END = 35;
-    static HOME = 36;
-    static LEFT_ARROW = 37;
-    static UP_ARROW = 38;
-    static RIGHT_ARROW = 39;
-    static DOWN_ARROW = 40;
-    static PLUS_SIGN = 43;
-    static PRINT_SCREEN = 44;
-    static INSERT = 45;
-    static DELETE = 46;
-    static ZERO = 48;
-    static ONE = 49;
-    static TWO = 50;
-    static THREE = 51;
-    static FOUR = 52;
-    static FIVE = 53;
-    static SIX = 54;
-    static SEVEN = 55;
-    static EIGHT = 56;
-    static NINE = 57;
-    static FF_SEMICOLON = 59; // Firefox (Gecko) fires this for semicolon instead of 186
-    static FF_EQUALS = 61; // Firefox (Gecko) fires this for equals instead of 187
-    static QUESTION_MARK = 63;
-    static AT_SIGN = 64;
-    static A = 65;
-    static B = 66;
-    static C = 67;
-    static D = 68;
-    static E = 69;
-    static F = 70;
-    static G = 71;
-    static H = 72;
-    static I = 73;
-    static J = 74;
-    static K = 75;
-    static L = 76;
-    static M = 77;
-    static N = 78;
-    static O = 79;
-    static P = 80;
-    static Q = 81;
-    static R = 82;
-    static S = 83;
-    static T = 84;
-    static U = 85;
-    static V = 86;
-    static W = 87;
-    static X = 88;
-    static Y = 89;
-    static Z = 90;
-    static META = 91; // WIN_KEY_LEFT
-    static MAC_WK_CMD_LEFT = 91;
-    static MAC_WK_CMD_RIGHT = 93;
-    static CONTEXT_MENU = 93;
-    static NUMPAD_ZERO = 96;
-    static NUMPAD_ONE = 97;
-    static NUMPAD_TWO = 98;
-    static NUMPAD_THREE = 99;
-    static NUMPAD_FOUR = 100;
-    static NUMPAD_FIVE = 101;
-    static NUMPAD_SIX = 102;
-    static NUMPAD_SEVEN = 103;
-    static NUMPAD_EIGHT = 104;
-    static NUMPAD_NINE = 105;
-    static NUMPAD_MULTIPLY = 106;
-    static NUMPAD_PLUS = 107;
-    static NUMPAD_MINUS = 109;
-    static NUMPAD_PERIOD = 110;
-    static NUMPAD_DIVIDE = 111;
-    static F1 = 112;
-    static F2 = 113;
-    static F3 = 114;
-    static F4 = 115;
-    static F5 = 116;
-    static F6 = 117;
-    static F7 = 118;
-    static F8 = 119;
-    static F9 = 120;
-    static F10 = 121;
-    static F11 = 122;
-    static F12 = 123;
-    static NUM_LOCK = 144;
-    static SCROLL_LOCK = 145;
-    static FIRST_MEDIA = 166;
-    static FF_MINUS = 173;
-    static MUTE = 173; // Firefox (Gecko) fires 181 for MUTE
-    static VOLUME_DOWN = 174; // Firefox (Gecko) fires 182 for VOLUME_DOWN
-    static VOLUME_UP = 175; // Firefox (Gecko) fires 183 for VOLUME_UP
-    static FF_MUTE = 181;
-    static FF_VOLUME_DOWN = 182;
-    static LAST_MEDIA = 183;
-    static FF_VOLUME_UP = 183;
-    static SEMICOLON = 186; // Firefox (Gecko) fires 59 for SEMICOLON
-    static EQUALS = 187; // Firefox (Gecko) fires 61 for EQUALS
-    static COMMA = 188;
-    static DASH = 189; // Firefox (Gecko) fires 173 for DASH/MINUS
-    static PERIOD = 190;
-    static SLASH = 191;
-    static APOSTROPHE = 192;
-    static TILDE = 192;
-    static OPEN_SQUARE_BRACKET = 219;
-    static BACKSLASH = 220;
-    static CLOSE_SQUARE_BRACKET = 221;
-    static SINGLE_QUOTE = 222;
-    static MAC_META = 224;
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const HttpParamsRequestInstance = (options, instance) => {
-    return new UtilsHttpParamsRequest(options, instance);
-};
-class UtilsHttpParamsRequest extends HttpParams {
-    params;
-    constructor(options, instance) {
-        super(options);
-        if (!instance) {
-            this.params = new HttpParams(options);
-            return;
-        }
-        if (instance instanceof UtilsHttpParamsRequest) {
-            this.params = instance.getInstance();
-            return;
-        }
-        if (instance instanceof HttpParams) {
-            this.params = instance;
-            return;
-        }
-    }
-    getInstance() {
-        return this.params;
-    }
-    setInstance(instance) {
-        if (instance instanceof UtilsHttpParamsRequest) {
-            this.params = instance.getInstance();
-            return;
-        }
-        if (instance instanceof HttpParams) {
-            this.params = instance;
-            return;
-        }
-    }
-    set(param, value) {
-        this.params = this.params.set(param, value);
-        return this;
-    }
-    has(param) {
-        return this.params.has(param);
-    }
-    get(param) {
-        return this.params.get(param);
-    }
-    getAll(param) {
-        return this.params.getAll(param);
-    }
-    keys() {
-        return this.params.keys();
-    }
-    append(param, value) {
-        this.params = this.params.append(param, value);
-        return this;
-    }
-    appendAll(params) {
-        this.params = this.params.appendAll(params);
-        return this;
-    }
-    delete(param, value) {
-        this.params = this.params.delete(param, value);
-        return this;
-    }
-    toString() {
-        return this.params.toString();
-    }
-}
-
-class UtilsLanguageConstants {
-    static VI = 'vi';
-    static EN = 'en';
-    static defaultLang = UtilsLanguageConstants.VI;
-}
-;
-
-const getKeyCacheByArrayObject = (keyCache, argumentsValue) => {
-    if (!keyCache || !argumentsValue) {
-        return '';
-    }
-    let keyBuild = `${JSON.stringify(argumentsValue.slice(1))}-key-cache-plus`;
-    if (argumentsValue && argumentsValue[0] instanceof HttpParams) {
-        const httpParams = argumentsValue[0];
-        const keys = argumentsValue[0].keys().sort((str1, str2) => str1.localeCompare(str2));
-        keys.forEach(key => {
-            keyBuild = `${keyBuild}${JSON.stringify(httpParams.get(key))}`;
-        });
-    }
-    const keyCachePlus = md5(keyBuild);
-    const keyCacheMD5 = md5(keyCache);
-    return `${keyCacheMD5}-${md5(`${keyCacheMD5}-${keyCachePlus}`)}`;
-};
-
 let functionCheck = () => {
     return window.parent !== window.top;
 };
@@ -827,22 +763,34 @@ const isEmbedFrame = () => {
     return functionCheck();
 };
 
+const ERROR_MESSAGE_EMPTY_VALID = 'i18n_valid_empty_message';
+const ERROR_MESSAGE_PATTEN_VALID = 'i18n_valid_pattern_message';
+const ERROR_MESSAGE_MIN_VALID = 'i18n_message_error_input_min_value';
+const ERROR_MESSAGE_MAX_VALID = 'i18n_message_error_input_max_value';
+const ERROR_MESSAGE_MIN_LENGTH = 'i18n_message_error_input_min_length';
+const ERROR_MESSAGE_MAX_LENGTH = 'i18n_message_error_input_max_length';
+const CHARACTER_DATA_EMPTY = '__';
+const DEFAULT_START_PAGE_0 = 'defaultStartPage0';
+const COMMUNICATE_MICRO_PREFIX_TYPE = '3RD_INTEGRATE_MICRO_SITE_';
+const COMMUNICATE_MICRO_KEY_GET_ALL_MESSAGE = 'MICRO_SITES_ALL_MESSAGE';
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
+class UtilsCommunicateMicroKeyGlobal {
+    static KEY_MESSAGE_MODAL = 'LIBS_UI_MODEL_EVENT';
+}
 class UtilsCommunicateMicro {
-    static KEY_GET_ALL_MESSAGE = 'MICRO_SITES_ALL_MESSAGE';
-    static PREFIX_TYPE = '3RD_INTEGRATE_MICRO_SITE_';
     static initdEvent;
     static subs = new Map();
     static allMessageSub = new Subject();
-    static initEvent(currentWindow) {
+    static initEvent(currentWindow, onDestroy) {
         if (this.initdEvent) {
             return;
         }
         this.initdEvent = true;
-        if (!this.subs.get(UtilsCommunicateMicro.KEY_GET_ALL_MESSAGE)) {
-            this.subs.set(UtilsCommunicateMicro.KEY_GET_ALL_MESSAGE, UtilsCommunicateMicro.allMessageSub);
+        if (!this.subs.get(COMMUNICATE_MICRO_KEY_GET_ALL_MESSAGE)) {
+            this.subs.set(COMMUNICATE_MICRO_KEY_GET_ALL_MESSAGE, UtilsCommunicateMicro.allMessageSub);
         }
-        fromEvent(currentWindow, 'message').subscribe(e => {
+        fromEvent(currentWindow, 'message').pipe(takeUntil(onDestroy)).subscribe(e => {
             const event = { data: { ...e.data } };
             const data = event.data;
             const type = data.type;
@@ -854,7 +802,7 @@ class UtilsCommunicateMicro {
                 return;
             }
             try {
-                if (type.includes(UtilsCommunicateMicro.PREFIX_TYPE)) {
+                if (type.includes(COMMUNICATE_MICRO_PREFIX_TYPE)) {
                     data.response = JSON.parse(decrypt3rd(data.response));
                     sub.next(event);
                     this.allMessageSub.next(event);
@@ -870,6 +818,10 @@ class UtilsCommunicateMicro {
                 this.allMessageSub.next(event);
             }
         });
+        UtilsCommunicateMicro.GetMessage(UtilsCache.typeKeyClearLocalStorage).pipe(filter(e => e.data.response !== UtilsCache.idService), takeUntil(onDestroy)).subscribe(() => {
+            console.log('clear all cache by event');
+            UtilsCache.ClearAll();
+        });
     }
     static PostMessageToParent(data) {
         data = this.convertData(data);
@@ -904,14 +856,13 @@ class UtilsCommunicateMicro {
         }
         data = { ...data };
         const type = data.type;
-        if (type.includes(this.PREFIX_TYPE)) {
+        if (type.includes(COMMUNICATE_MICRO_PREFIX_TYPE)) {
             try {
                 JSON.parse(decrypt3rd(data.response));
                 return data;
             }
-            catch (error) {
-                console.log(error);
-                data.response = decrypt3rd(JSON.stringify(data.response));
+            catch (_) {
+                data.response = encrypt3rd(JSON.stringify(data.response));
                 return data;
             }
         }
@@ -919,9 +870,8 @@ class UtilsCommunicateMicro {
             JSON.parse(decrypt(data.response));
             return data;
         }
-        catch (error) {
-            console.log(error);
-            data.response = decrypt(JSON.stringify(data.response));
+        catch (_) {
+            data.response = encrypt(JSON.stringify(data.response));
             return data;
         }
     }
@@ -941,6 +891,9 @@ class UtilsCommunicateMicro {
         if (!Array.isArray(messageType) || !messageType.length) {
             throw new Error('message type empty');
         }
+        if (messageType.length === 1) {
+            return this.GetMessage(messageType[0]);
+        }
         const types = messageType.sort().join(';');
         let sub = this.subs.get(types);
         if (sub) {
@@ -958,90 +911,149 @@ class UtilsCommunicateMicro {
             });
         });
     }
-    postMessageToParent(data) {
-        UtilsCommunicateMicro.PostMessageToParent(data);
-    }
-    postMessageToChildren(data) {
-        UtilsCommunicateMicro.PostMessageToChildren(data);
+}
+
+class UtilsLanguageConstants {
+    static VI = "vi"; // Tiếng Việt
+    static EN = "en"; // Tiếng Anh
+    static FR = "fr"; // Tiếng Pháp
+    static DE = "de"; // Tiếng Đức
+    static ES = "es"; // Tiếng Tây Ban Nha
+    static ZH = "zh"; // Tiếng Trung (Giản thể)
+    static ZH_TW = "zh-TW"; // Tiếng Trung (Phồn thể)
+    static JA = "ja"; // Tiếng Nhật
+    static KO = "ko"; // Tiếng Hàn
+    static RU = "ru"; // Tiếng Nga
+    static IT = "it"; // Tiếng Ý
+    static PT = "pt"; // Tiếng Bồ Đào Nha
+    static TH = "th"; // Tiếng Thái
+    static ID = "id"; // Tiếng Indonesia
+    static MS = "ms"; // Tiếng Malaysia
+    static AR = "ar"; // Tiếng Ả Rập
+    static HI = "hi"; // Tiếng Hindi
+    static BN = "bn"; // Tiếng Bengal
+    static TR = "tr"; // Tiếng Thổ Nhĩ Kỳ
+    static NL = "nl"; // Tiếng Hà Lan
+    static KM = "km"; // Tiếng Khmer (Campuchia)
+    static LO = "lo"; // Tiếng Lào
+    static MY = "my"; // Tiếng Miến Điện (Myanmar)
+    static TL = "tl"; // Tiếng Tagalog (Philippines)
+    static CEB = "ceb"; // Tiếng Cebuano (Philippines)
+    static JV = "jv"; // Tiếng Java (Indonesia)
+    static SU = "su"; // Tiếng Sundanese (Indonesia)
+    // Ngôn ngữ mặc định
+    static defaultLang = UtilsLanguageConstants.VI;
+    // Danh sách các ngôn ngữ được hỗ trợ
+    static supportedLanguages = new Set([
+        UtilsLanguageConstants.VI,
+        UtilsLanguageConstants.EN,
+        UtilsLanguageConstants.FR,
+        UtilsLanguageConstants.DE,
+        UtilsLanguageConstants.ES,
+        UtilsLanguageConstants.ZH,
+        UtilsLanguageConstants.ZH_TW,
+        UtilsLanguageConstants.JA,
+        UtilsLanguageConstants.KO,
+        UtilsLanguageConstants.RU,
+        UtilsLanguageConstants.IT,
+        UtilsLanguageConstants.PT,
+        UtilsLanguageConstants.TH,
+        UtilsLanguageConstants.ID,
+        UtilsLanguageConstants.MS,
+        UtilsLanguageConstants.AR,
+        UtilsLanguageConstants.HI,
+        UtilsLanguageConstants.BN,
+        UtilsLanguageConstants.TR,
+        UtilsLanguageConstants.NL,
+        UtilsLanguageConstants.KM,
+        UtilsLanguageConstants.LO,
+        UtilsLanguageConstants.MY,
+        UtilsLanguageConstants.TL,
+        UtilsLanguageConstants.CEB,
+        UtilsLanguageConstants.JV,
+        UtilsLanguageConstants.SU,
+    ]);
+    /**
+     * Kiểm tra xem ngôn ngữ đầu vào có được hỗ trợ không
+     * @param lang Mã ngôn ngữ cần kiểm tra
+     * @returns True nếu được hỗ trợ, False nếu không
+     */
+    static isSupported(lang) {
+        return UtilsLanguageConstants.supportedLanguages.has(lang);
     }
 }
 
 /* eslint-disable no-async-promise-executor */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 class UtilsCache {
+    static CACHE_EXPIRE_TIME_DEFAULT = 5 * 60;
     static CACHE_EXPIRE_NONE = -1;
+    static idService = uuid();
     static typeKeyClearLocalStorage = 'LIBS_UI_CLEAR_LOCAL_STORAGE_EVENT';
-    static listKeyKeepWhenClearALll = Array();
     static languageKeyCache = 'SR3xQKxHgffiCevPQRralg';
+    static listKeyKeepWhenClearALll = Array();
     static initdEvent;
-    static CACHE_EXPIRE_TIME_DEFAULT = 5 * 60;
-    static language = signal(UtilsLanguageConstants.defaultLang);
-    static idService = uuid();
     static storage;
     static dbName = 'libs-ui-cache';
     static itemIndexByKey = 'key';
     static dbVersion = 1;
     static db = null;
     static init(config) {
-        if (UtilsCache.initdEvent) {
+        if (this.initdEvent) {
             return;
         }
-        UtilsCache.initdEvent = true;
+        this.initdEvent = true;
         if (config.indexedDBName) {
-            UtilsCache.dbName = config.indexedDBName;
+            this.dbName = config.indexedDBName;
         }
         if (config.typeKeyClearLocalStorage) {
-            UtilsCache.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;
+            this.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;
         }
-        if (config.listKeyKeepWhenClearALll) {
-            UtilsCache.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearALll;
+        if (config.listKeyKeepWhenClearAll) {
+            this.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearAll;
         }
         if (config.languageKeyCache) {
-            UtilsCache.languageKeyCache = config.languageKeyCache;
+            this.languageKeyCache = config.languageKeyCache;
         }
-        UtilsCommunicateMicro.GetMessage(UtilsCache.typeKeyClearLocalStorage).pipe(filter(e => e.data.response !== UtilsCache.idService)).subscribe(() => {
-            UtilsCache.ClearAll();
-        });
     }
     static setLang(lang) {
-        if (lang !== UtilsLanguageConstants.VI && lang !== UtilsLanguageConstants.EN) {
-            throw Error('Language support vi | en');
+        if (!UtilsLanguageConstants.isSupported(lang)) {
+            throw Error(`Language not support ${lang}`);
         }
-        UtilsCache.language.set(lang);
-        UtilsCache.Set(UtilsCache.languageKeyCache, lang);
+        this.Set(this.languageKeyCache, lang, this.CACHE_EXPIRE_NONE);
     }
     static getLang() {
-        return UtilsCache.language();
+        return this.Get(this.languageKeyCache, UtilsLanguageConstants.defaultLang);
     }
     static openDB() {
         return new Promise(resolve => {
-            const request = indexedDB.open(UtilsCache.dbName, UtilsCache.dbVersion);
+            const request = indexedDB.open(this.dbName, this.dbVersion);
             request.onupgradeneeded = (event) => {
                 const db = event.target.result;
-                if (!db.objectStoreNames.contains(UtilsCache.dbName)) {
-                    const objectStore = db.createObjectStore(UtilsCache.dbName, { keyPath: 'id', autoIncrement: true });
-                    objectStore.createIndex(UtilsCache.itemIndexByKey, UtilsCache.itemIndexByKey, { unique: true });
+                if (!db.objectStoreNames.contains(this.dbName)) {
+                    const objectStore = db.createObjectStore(this.dbName, { keyPath: this.itemIndexByKey });
+                    objectStore.createIndex(this.itemIndexByKey, this.itemIndexByKey, { unique: true });
                 }
             };
             request.onsuccess = () => {
-                UtilsCache.db = request.result;
-                setTimeout(() => {
-                    UtilsCache.DeleteKeyStartWithAsync('');
-                }, 2000);
+                this.db = request.result;
                 resolve(true);
             };
             request.onerror = (event) => {
-                console.error('Error opening IndexedDB:', event);
+                console.trace('Error opening IndexedDB:', event);
                 resolve(false);
             };
         });
     }
     static async getObjectStore() {
-        if (!UtilsCache.db) {
-            await UtilsCache.openDB();
+        if (!this.db) {
+            await this.openDB();
+        }
+        const transaction = this.db?.transaction([this.dbName], 'readwrite');
+        if (!transaction) {
+            return null;
         }
-        const transaction = UtilsCache.db?.transaction([UtilsCache.dbName], 'readwrite');
-        return transaction?.objectStore(UtilsCache.dbName);
+        return transaction.objectStore(this.dbName);
     }
     static get LocalStorage() {
         try {
@@ -1055,12 +1067,12 @@ class UtilsCache {
             return this.getLocalStorageFake();
         }
         catch (error) {
-            console.log(error);
+            console.trace(`LocalStorage `, error);
             return this.getLocalStorageFake();
         }
     }
     static getLocalStorageFakeOnSafari() {
-        if (typeof window.localStorage !== 'undefined' && !UtilsCache.storage && Object.keys(localStorage).length) {
+        if (typeof window.localStorage !== 'undefined' && !this.storage && Object.keys(localStorage).length) {
             this.storage = { ...localStorage };
         }
         return {
@@ -1090,7 +1102,7 @@ class UtilsCache {
         };
     }
     static getLocalStorageFake() {
-        if (!UtilsCache.storage) {
+        if (!this.storage) {
             this.storage = {};
         }
         return {
@@ -1110,19 +1122,18 @@ class UtilsCache {
     }
     static async GetAsync(key, default_value, isKeyMD5 = false) {
         key = isKeyMD5 ? key : md5(key);
-        return new Promise(async (resolve, reject) => {
-            const objectStore = await UtilsCache.getObjectStore();
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
             if (!objectStore) {
                 return resolve(default_value);
             }
-            const index = objectStore.index(UtilsCache.itemIndexByKey);
-            const request = index.get(key);
+            const request = objectStore.get(key);
             request.onsuccess = () => {
                 if (!request.result) {
                     return resolve(default_value);
                 }
                 const data = JSON.parse(decrypt(request.result.value));
-                if (data.expire === UtilsCache.CACHE_EXPIRE_NONE) {
+                if (data.expire === this.CACHE_EXPIRE_NONE) {
                     return resolve(data.json);
                 }
                 const currentMillisecond = (new Date().valueOf() / 1000);
@@ -1132,7 +1143,8 @@ class UtilsCache {
                 return resolve(data.json);
             };
             request.onerror = () => {
-                reject(request.error);
+                console.trace(`Get key ${key} Error, return default value: ${default_value}`);
+                return resolve(default_value);
             };
         });
     }
@@ -1146,8 +1158,8 @@ class UtilsCache {
         }
         try {
             const data = JSON.parse(decrypt(cachedData));
-            if (data.expire === UtilsCache.CACHE_EXPIRE_NONE) {
-                return data.value;
+            if (data.expire === this.CACHE_EXPIRE_NONE) {
+                return data.value ?? default_value;
             }
             const currentMillisecond = (new Date().valueOf() / 1000);
             if (data.expire < currentMillisecond) {
@@ -1156,97 +1168,71 @@ class UtilsCache {
             return data.value;
         }
         catch (error) {
-            console.log(error);
+            console.trace(`Get key ${key} Error, return default value: ${default_value}`, error);
             return this.GetDefaultValueBySpecificKey(key, default_value);
         }
     }
     static GetDefaultValueBySpecificKey(key, default_value) {
         return default_value;
     }
-    static async SetAsync(key, value, expireTimeBySecond = UtilsCache.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) {
-        return new Promise(async (resolve, reject) => {
-            let objectStore = await UtilsCache.getObjectStore();
+    static async SetAsync(key, value, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
             key = isKeyMD5 ? key : md5(key);
             try {
-                const currentMillisecond = expireTimeBySecond === UtilsCache.CACHE_EXPIRE_NONE ? UtilsCache.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
+                const currentMillisecond = expireTimeBySecond === this.CACHE_EXPIRE_NONE ? this.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
                 const data = {
-                    key: key,
                     value: encrypt(JSON.stringify({ json: value, expire: currentMillisecond })),
                 };
+                data[this.itemIndexByKey] = key;
                 if (!objectStore) {
-                    return resolve(-1);
+                    console.trace(`Can not open object store`);
+                    return resolve({ key, messageError: 'Can not open object store' });
                 }
-                const index = objectStore.index(UtilsCache.itemIndexByKey);
-                const getIndexKeyRequest = index.get(key);
-                getIndexKeyRequest.onsuccess = async () => {
-                    const item = getIndexKeyRequest.result;
-                    if (item) {
-                        await UtilsCache.ClearAsync(key, true);
-                        objectStore = await UtilsCache.getObjectStore();
-                    }
-                    if (!objectStore) {
-                        return resolve(-1);
-                    }
-                    const request = objectStore.add(data);
-                    request.onsuccess = () => {
-                        resolve(request.result);
-                    };
-                    request.onerror = () => {
-                        console.log(request.error);
-                        return resolve(-1);
-                    };
+                const request = objectStore?.put(data);
+                request.onsuccess = () => {
+                    console.log(`Set key ${key} Success`);
+                    resolve(request.result);
                 };
-                getIndexKeyRequest.onerror = (event) => {
-                    console.error('Error fetching item by name:', event.target.error);
-                    reject(event.target.error);
+                request.onerror = (error) => {
+                    console.trace(`Set key ${key} Error`);
+                    resolve({ key, messageError: get(error, 'message') });
                 };
             }
             catch (error) {
-                console.log(error);
-                resolve({});
+                console.trace(`Set key ${key} Error`);
+                resolve({ key, messageError: get(error, 'message') });
             }
         });
     }
-    static Set(key, value, expireTimeBySecond = UtilsCache.CACHE_EXPIRE_TIME_DEFAULT) {
-        if (value === undefined || value === null || value === '') {
-            return;
-        }
-        const currentMillisecond = expireTimeBySecond === UtilsCache.CACHE_EXPIRE_NONE ? UtilsCache.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
+    static Set(key, value, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT) {
+        const currentMillisecond = expireTimeBySecond === this.CACHE_EXPIRE_NONE ? this.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
         const data = {
             value: value,
             expire: currentMillisecond
         };
         try {
             this.LocalStorage.setItem(key, encrypt(JSON.stringify(data)));
+            return true;
         }
         catch (error) {
-            console.log(error);
+            console.trace(`Set key ${key} Error`, error);
+            return false;
         }
     }
     static async ClearAsync(key, isMD5 = false) {
         return new Promise(async (resolve) => {
-            const objectStore = await UtilsCache.getObjectStore();
+            const objectStore = await this.getObjectStore();
             if (!objectStore) {
-                return resolve({});
+                return resolve();
             }
-            const index = objectStore.index(UtilsCache.itemIndexByKey);
-            const getRequest = index.get(isMD5 ? key : md5(key));
-            getRequest.onsuccess = () => {
-                const result = getRequest.result;
-                if (result) {
-                    const deleteRequest = objectStore.delete(result.id); // Xóa theo id của item tìm được
-                    deleteRequest.onsuccess = () => {
-                        resolve({});
-                    };
-                    deleteRequest.onerror = () => {
-                        resolve({});
-                    };
-                    return;
-                }
-                resolve({});
+            const request = objectStore.delete(isMD5 ? key : md5(key));
+            request.onsuccess = () => {
+                resolve({ clearSuccess: true });
             };
-            getRequest.onerror = () => {
-                resolve({});
+            request.onerror = (event) => {
+                console.trace('Error deleting Key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
             };
         });
     }
@@ -1257,38 +1243,41 @@ class UtilsCache {
         this.LocalStorage.removeItem(key);
     }
     static ClearAllAsync() {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.deleteDatabase(this.dbName);
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve();
+            }
+            const request = objectStore.clear();
             request.onsuccess = () => {
-                console.log('Database deleted successfully');
-                resolve(true);
+                console.log('clear all successfully');
+                resolve({ clearSuccess: true });
             };
             request.onerror = (event) => {
-                console.error('Error deleting database:', event.target.error);
-                reject(event.target.error);
-            };
-            request.onblocked = () => {
-                console.warn('Delete request is blocked');
+                console.trace('Error deleting key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
             };
         });
     }
     static ClearAll() {
-        const keys = [...UtilsCache.listKeyKeepWhenClearALll];
+        if (isEmbedFrame()) {
+            const data = {
+                type: this.typeKeyClearLocalStorage,
+                response: {
+                    idEvent: this.idService
+                }
+            };
+            UtilsCommunicateMicro.PostMessageToParent(data);
+        }
+        const keys = [...this.listKeyKeepWhenClearALll];
         Object.keys(this.LocalStorage).forEach(key => {
             if (key.includes('kc-callback-')) {
                 keys.push(key);
             }
         });
-        const stores = UtilsCache.GetDataByKeys(Array.from(keys));
+        const stores = this.GetDataByKeys(Array.from(keys));
         this.LocalStorage.clear();
-        UtilsCache.SetDataByKey(stores);
-        const data = {
-            type: UtilsCache.typeKeyClearLocalStorage,
-            response: {
-                idEvent: this.idService
-            }
-        };
-        UtilsCommunicateMicro.PostMessageToParent(data);
+        this.SetDataByKey(stores);
     }
     static GetDataByKeys(keys) {
         const stores = new Map();
@@ -1297,62 +1286,1051 @@ class UtilsCache {
                 stores.set(key, this.LocalStorage.getItem(key));
                 return;
             }
-            stores.set(key, UtilsCache.Get(key));
+            stores.set(key, this.Get(key));
         });
         return stores;
     }
-    static SetDataByKey(stores) {
-        stores.forEach((value, key) => {
-            if (key.includes('kc-callback-')) {
-                this.LocalStorage.setItem(key, value);
+    static SetDataByKey(stores) {
+        stores.forEach((value, key) => {
+            if (key.includes('kc-callback-')) {
+                this.LocalStorage.setItem(key, value);
+                return;
+            }
+            if (key === this.languageKeyCache) {
+                return this.setLang(value);
+            }
+            this.Set(key, value, this.CACHE_EXPIRE_NONE);
+        });
+    }
+    static DeleteKeyStartWithAsync(keyCacheStartWith, isKeyMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve({});
+            }
+            // Lấy tất cả các keys từ index
+            const request = objectStore.getAll();
+            keyCacheStartWith = isKeyMD5 ? keyCacheStartWith : md5(keyCacheStartWith);
+            request.onsuccess = (e) => {
+                const data = e.target.result;
+                if (!Array.isArray(data)) {
+                    return resolve({});
+                }
+                data.forEach(obj => {
+                    if (obj[this.itemIndexByKey].startsWith(keyCacheStartWith)) {
+                        this.ClearAsync(obj[this.itemIndexByKey], true);
+                    }
+                });
+                return resolve({});
+            };
+            request.onerror = () => {
+                return resolve({});
+            };
+        });
+    }
+    static DeleteKeyStartWith(keyCache, isMD5 = false) {
+        keyCache = isMD5 ? md5(keyCache) : keyCache;
+        const keys = Object.keys(this.LocalStorage);
+        if (!keys || !keys.length) {
+            return;
+        }
+        keys.forEach(key => {
+            if (key.startsWith(keyCache)) {
+                this.Clear(key);
+            }
+        });
+    }
+    static DeleteDatabaseIndexDB(dbName) {
+        return new Promise((resolve) => {
+            dbName = (dbName || this.dbName);
+            const request = indexedDB.deleteDatabase(dbName);
+            request.onsuccess = () => {
+                console.trace('Database deleted successfully');
+                resolve({ deleteSuccess: true });
+            };
+            request.onerror = (event) => {
+                const error = event.target.error;
+                console.trace('Error deleting database:', error);
+                resolve({ messageError: get(error || {}, 'message'), deleteSuccess: false });
+            };
+            request.onblocked = () => {
+                console.trace('Delete request is blocked');
+                resolve({ messageError: 'Delete request is blocked', deleteSuccess: false });
+            };
+        });
+    }
+}
+
+dayjs.extend(localeData);
+dayjs.extend(updateLocale);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(customParseFormat);
+let timeZoneSetup = "Asia/Ho_Chi_Minh";
+const setDefaultTimeZone = (localeZone = timeZoneSetup) => {
+    timeZoneSetup = localeZone;
+    dayjs.tz.setDefault(localeZone);
+};
+let functionFormatDate = undefined;
+const updateFunctionFormatDate = (functionCustom) => {
+    functionFormatDate = functionCustom;
+};
+/**
+  * @description Lấy đối tượng dayjs theo config
+  * @param config nếu không có config sẽ trả về đối tượng dayjs là thời gian hiện tại
+  * @param config.date thời gian cần lấy
+  * @param config.returnDayjsIfConfigDateNotExist true nếu muốn trả về đối tượng dayjs nếu config.date không có
+  * @param config.utc true nếu muốn lấy thời gian UTC
+  * @param config.formatOfDate định dạng thời gian đang được truyền vào
+*/
+const getDayjs = (config) => {
+    if (!config) {
+        return dayjs().tz();
+    }
+    config.date = !config.date && config.returnDayjsIfConfigDateNotExist ? dayjs().tz() : config.date;
+    if (typeof config.date === 'number') {
+        config.date = dayjs.unix(config.date);
+    }
+    if (!config.date) {
+        return undefined;
+    }
+    let { date, utc, formatOfDate } = config;
+    while (isSignal(date)) {
+        date = date();
+    }
+    while (isSignal(utc)) {
+        utc = utc();
+    }
+    while (isSignal(formatOfDate)) {
+        formatOfDate = formatOfDate();
+    }
+    if (utc) {
+        if (formatOfDate) {
+            return dayjs(date, formatOfDate).utc();
+        }
+        const dateInputIsUTC = (dayjs.isDayjs(date) && date.isUTC()) || (typeof date === 'string' && date.includes('Z'));
+        if (dateInputIsUTC) {
+            return dayjs(date);
+        }
+        return dayjs(date).utc();
+    }
+    if (typeof date === 'string' && !date.includes('Z') && !date.includes('+')) {
+        return (formatOfDate ? dayjs.tz(date, formatOfDate, config.localeZone || timeZoneSetup) : dayjs.tz(date, config.localeZone || timeZoneSetup));
+    }
+    return (formatOfDate ? dayjs(date, formatOfDate) : dayjs(date)).tz();
+};
+/**
+ * @description Kiểm tra xem hai ngày có khác nhau không (khác ngày trong tuần)
+ * @param date1 ngày thứ nhất cần so sánh
+ * @param date2 ngày thứ hai cần so sánh
+ * @returns true nếu hai ngày khác nhau, false nếu giống nhau hoặc không thể so sánh
+ */
+const isDifferenceDay = (date1, date2) => {
+    if (isDifferenceMonth(date1, date2)) {
+        return true;
+    }
+    const day1 = getDayjs({ date: date1 })?.day();
+    const day2 = getDayjs({ date: date2 })?.day();
+    return day1 !== day2;
+};
+/**
+ * @description Kiểm tra xem hai ngày có khác tháng không
+ * @param date1 ngày thứ nhất cần so sánh
+ * @param date2 ngày thứ hai cần so sánh
+ * @returns true nếu hai ngày khác tháng, false nếu cùng tháng hoặc không thể so sánh
+ */
+const isDifferenceMonth = (date1, date2) => {
+    if (isDifferenceYear(date1, date2)) {
+        return true;
+    }
+    const month1 = getDayjs({ date: date1 })?.month();
+    const month2 = getDayjs({ date: date2 })?.month();
+    return month1 !== month2;
+};
+/**
+ * @description Kiểm tra xem hai ngày có khác năm không
+ * @param date1 ngày thứ nhất cần so sánh
+ * @param date2 ngày thứ hai cần so sánh
+ * @returns true nếu hai ngày khác năm, false nếu cùng năm hoặc không thể so sánh
+ */
+const isDifferenceYear = (date1, date2) => {
+    const year1 = getDayjs({ date: date1 })?.year();
+    const year2 = getDayjs({ date: date2 })?.year();
+    return year1 !== year2;
+};
+/**
+ * @description Lấy ra chuỗi thời gian hiển thị theo định dạng và ngôn ngữ
+ * @param date thời gian cần định dạng
+ * @param format định dạng thời gian muốn lấy ra
+ * @param lang lấy theo ngôn ngữ
+ */
+const formatDate = (date, formatOutput = 'YYYY/MM/DD HH:mm', lang, formatInput) => {
+    if (!date) {
+        return '';
+    }
+    lang = lang || UtilsCache.getLang();
+    if (functionFormatDate) {
+        return functionFormatDate(date, formatOutput, lang);
+    }
+    date = getDayjs({ date, formatOfDate: formatInput }).locale(lang);
+    if (lang === 'vi') {
+        dayjs.updateLocale('vi', {
+            monthsShort: 'Thg 1_Thg 2_Thg 3_Thg 4_Thg 5_Thg 6_Thg 7_Thg 8_Thg 9_Thg 10_Thg 11_Thg 12'.split('_')
+        });
+    }
+    return date.format(getFormatData(getTypeByFormat(formatOutput), lang)) || '';
+};
+const getTypeByFormat = (format) => {
+    if (format === 'dm' || format === 'dmy' || format === 'dmy hm' || format === 'my') {
+        return format;
+    }
+    if (format === 'DD/MM/YYYY' || format === 'YYYY-MM-DD' || format === 'dd/MM/yyyy' || format === 'dd-MM-yyyy' || format === 'dd/mm/yyyy') {
+        return 'dmy';
+    }
+    if (format === 'MM-DD' || format === 'dd/MM' || format === 'dd/mm') {
+        return 'dm';
+    }
+    if (format === 'M/YYYY' || format === 'YYYY-MM' || format === 'MM/yyyy') {
+        return 'my';
+    }
+    if (format === 'YYYY/MM/DD hh:mm:ss' || format === 'dmy hms' || format === 'dd/mm/yyyy hh:mm:ss') {
+        return 'dmy hms';
+    }
+    if (format === 'hh:mm' || format === 'HH:mm') {
+        return 'hh:mm';
+    }
+    if (format === 'hh:mm A' || format === 'HH:mm A') {
+        return 'hh:mm A';
+    }
+    return 'dmy hm';
+};
+const getFormatData = (type, lang) => {
+    switch (type) {
+        case 'dm':
+            if (lang === 'vi') {
+                return 'D MMM';
+            }
+            return 'MMM D';
+        case 'dmy':
+            if (lang === 'vi') {
+                return 'D MMM, YYYY';
+            }
+            return 'MMM D, YYYY';
+        case 'dmy hm':
+            if (lang === 'vi') {
+                return 'D MMM, YYYY HH:mm';
+            }
+            return 'MMM D, YYYY HH:mm';
+        case 'my':
+            if (lang === 'vi') {
+                return 'MMM, YYYY';
+            }
+            return 'MMM YYYY ';
+        case 'dmy hms':
+            if (lang === 'vi') {
+                return 'D MMM, YYYY HH:mm:ss';
+            }
+            return 'MMM D, YYYY HH:mm:ss';
+        case 'hh:mm':
+        case 'HH:mm':
+            return 'HH:mm';
+        case 'hh:mm A':
+        case 'HH:mm A':
+            return 'HH:mm A';
+    }
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**Các hàm tương tự thư viện lodash */
+/**
+ * Kiểm tra xem một giá trị có phải là null hoặc undefined hay không
+ * @param value Giá trị cần kiểm tra
+ * @returns true nếu giá trị là null hoặc undefined, false nếu không
+ * @example
+ * isNil(null); // true
+ * isNil(undefined); // true
+ * isNil(0); // false
+ * isNil('hello'); // false
+ */
+const isNil = (value) => {
+    return value === null || value === undefined;
+};
+/**
+ * Kiểm tra xem một giá trị có phải là rỗng hay không
+ * @param value Giá trị cần kiểm tra
+ * @returns true nếu giá trị là null, rỗng hoặc undefined, false nếu không
+ * @example
+ * isEmpty(null); // true
+ * isEmpty(''); // true
+ * isEmpty(undefined); // true
+ * isEmpty({}); // true
+ * isEmpty([]); // true
+ * isEmpty([1, 2, 3]); // false
+ * isEmpty({ a: 1 }); // false
+ */
+const isEmpty = (value) => {
+    while (isSignal(value)) {
+        value = value();
+    }
+    return value === null || value === '' || value === undefined || (typeof value === 'object' && (JSON.stringify(value) === '{}' || JSON.stringify(value) === '[]'));
+};
+/**
+ * Loại bỏ các thuộc tính của đối tượng dựa trên một hàm điều kiện
+ * @param objData Đối tượng cần xử lý
+ * @param predicate Hàm điều kiện để kiểm tra giá trị của thuộc tính. Nếu hàm trả về true thì thuộc tính đó sẽ bị loại bỏ
+ * @returns Đối tượng mới sau khi đã loại bỏ các thuộc tính thỏa mãn điều kiện
+ * @example
+ * const obj = { a: 1, b: null, c: 3, d: undefined };
+ * omitBy(obj, isNil); // { a: 1, c: 3 }
+ */
+const omitBy = (objData, predicate) => {
+    if (!objData || typeof objData !== 'object' || Array.isArray(objData)) {
+        return objData;
+    }
+    const newObj = {};
+    Object.keys(objData).forEach((key) => {
+        const valueOfKey = get(objData, key);
+        if (!predicate(valueOfKey)) {
+            set(newObj, key, valueOfKey);
+        }
+    });
+    return newObj;
+};
+/**
+ * Lấy giá trị từ đối tượng theo đường dẫn chỉ định
+ *
+ * Hàm này giúp bạn truy cập vào các thuộc tính sâu bên trong một đối tượng một cách an toàn,
+ * tránh lỗi khi thuộc tính không tồn tại.
+ *
+ * @param obj Đối tượng nguồn cần lấy giá trị
+ * @param path Đường dẫn đến thuộc tính cần lấy. Có thể là:
+ *   - Chuỗi: 'user.profile.name' hoặc 'items[0].title'
+ *   - Mảng: ['user', 'profile', 'name'] hoặc ['items', '0', 'title']
+ *   - Chuỗi rỗng '': trả về chính đối tượng gốc
+ * @param defaultValue Giá trị mặc định trả về khi không tìm thấy thuộc tính (mặc định: undefined)
+ * @param keepLastValueIfSignal Có giữ nguyên signal cuối cùng hay không (mặc định: false - sẽ gọi signal())
+ * @returns Giá trị tìm được hoặc giá trị mặc định
+ *
+ * @example
+ * // Ví dụ cơ bản
+ * const user = { name: 'John', age: 30 };
+ * get(user, 'name'); // 'John'
+ * get(user, 'email'); // undefined
+ * get(user, 'email', 'no-email'); // 'no-email'
+ *
+ * @example
+ * // Truyền path rỗng - trả về chính đối tượng gốc
+ * const data = { name: 'Alice', age: 25 };
+ * get(data, ''); // { name: 'Alice', age: 25 } (chính đối tượng data)
+ * get(data, '', 'default'); // { name: 'Alice', age: 25 } (bỏ qua defaultValue)
+ *
+ * @example
+ * // Truy cập thuộc tính sâu
+ * const data = {
+ *   user: {
+ *     profile: {
+ *       name: 'Alice',
+ *       settings: { theme: 'dark' }
+ *     }
+ *   }
+ * };
+ * get(data, 'user.profile.name'); // 'Alice'
+ * get(data, 'user.profile.settings.theme'); // 'dark'
+ * get(data, 'user.profile.avatar', 'default.jpg'); // 'default.jpg'
+ *
+ * @example
+ * // Truy cập mảng
+ * const items = [
+ *   { name: 'Item 1', price: 100 },
+ *   { name: 'Item 2', price: 200 }
+ * ];
+ * get(items, '[0].name'); // 'Item 1'
+ * get(items, '[1].name'); // 'Item 2'
+ * get(items, '[2].name', 'Not found'); // 'Not found'
+ *
+ * @example
+ * // Sử dụng với mảng path
+ * const nested = { a: { b: { c: 'deep value' } } };
+ * get(nested, ['a', 'b', 'c']); // 'deep value'
+ * get(nested, ['a', 'b', 'd'], 'default'); // 'default'
+ *
+ * @example
+ * // Trường hợp đặc biệt
+ * get(null, 'any.path'); // undefined
+ * get(undefined, 'any.path', 'fallback'); // 'fallback'
+ */
+const get = (obj, path, defaultValue, keepLastValueIfSignal) => {
+    if (isNil(obj)) {
+        return defaultValue;
+    }
+    while (isSignal(obj)) {
+        obj = obj();
+    }
+    if (path === '') {
+        return obj;
+    }
+    if (obj instanceof HttpParams) {
+        return (obj.get(`${path}`) ?? defaultValue);
+    }
+    if (obj instanceof DOMRect) {
+        return obj[path];
+    }
+    const paths = Array.isArray(path)
+        ? path
+        : path
+            .replace(/\[(\d+)]/g, '.$1')
+            .split('.')
+            .filter((key) => key);
+    for (const index in paths) {
+        const key = paths[index];
+        if (obj instanceof CSSStyleDeclaration) {
+            obj = obj[key];
+            continue;
+        }
+        if (obj instanceof HTMLElement) {
+            obj = obj[key];
+            continue;
+        }
+        if (isNil(obj) || !Object.prototype.hasOwnProperty.call(obj, key)) {
+            return defaultValue;
+        }
+        const val = isSignal(obj[key]) && !keepLastValueIfSignal ? obj[key]() : obj[key];
+        obj = val;
+    }
+    return obj;
+};
+/**
+ * Thiết lập giá trị cho một thuộc tính trong đối tượng theo đường dẫn chỉ định
+ * @param obj Đối tượng cần thiết lập giá trị
+ * @param path Đường dẫn đến thuộc tính, có thể là chuỗi (vd: 'a.b.c') hoặc mảng (vd: ['a', 'b', 'c'])
+ * @param value Giá trị cần thiết lập
+ * @returns Đối tượng sau khi đã thiết lập giá trị
+ * @throws Error nếu tham số đầu tiên không phải là đối tượng
+ * @example
+ * const obj = { a: { b: 1 } };
+ * set(obj, 'a.b', 2); // { a: { b: 2 } }
+ */
+const set = (obj, path, value) => {
+    if (!obj || (typeof obj !== 'object' && !isSignal(obj)) || (isSignal(obj) && typeof obj() !== 'object')) {
+        throw new Error('The first argument must be an object');
+    }
+    if (obj instanceof HttpParams) {
+        return obj.set(`${path}`, value);
+    }
+    const pathArray = Array.isArray(path)
+        ? path
+        : path
+            .replace(/\[(\d+)]/g, '.[$1]')
+            .split('.')
+            .filter((key) => key);
+    let currentObjectByKey = isSignal(obj) ? obj() : obj;
+    let preObjectByKey = obj;
+    pathArray.forEach((key, index) => {
+        if (index < pathArray.length - 1) {
+            if (!(key in currentObjectByKey) || (typeof currentObjectByKey[key] !== 'object' && !isSignal(currentObjectByKey[key]))) {
+                const nextKey = pathArray[index + 1];
+                key = key.replace(/\[(\d+)]/g, '$1');
+                currentObjectByKey[key] = /\[(\d+)]/g.test(nextKey) ? [] : {};
+            }
+            currentObjectByKey = key ? currentObjectByKey[key] : currentObjectByKey;
+            preObjectByKey = currentObjectByKey;
+            currentObjectByKey = isSignal(currentObjectByKey) ? currentObjectByKey() : currentObjectByKey;
+            return;
+        }
+        if (typeof currentObjectByKey !== 'object') {
+            return;
+        }
+        // Gán giá trị ở cuối đường dẫn
+        key = key.replace(/\[(\d+)]/g, '$1');
+        const valueOfKey = currentObjectByKey[key];
+        const valueOfKeyIsSignal = isSignal(valueOfKey);
+        if (valueOfKeyIsSignal && (typeof valueOfKey() !== 'object' || valueOfKey() === null)) {
+            valueOfKey.set(isSignal(value) ? value() : value);
+            return;
+        }
+        if (isSignal(preObjectByKey)) {
+            preObjectByKey.update((data) => {
+                const dataOfKey = data[key];
+                if (isNil(dataOfKey) || !valueOfKeyIsSignal) {
+                    data[key] = value;
+                }
+                if (valueOfKeyIsSignal) {
+                    valueOfKey.set(isSignal(value) ? value() : value);
+                }
+                if (Array.isArray(data)) {
+                    return [...data];
+                }
+                return { ...data };
+            });
+            return;
+        }
+        if (valueOfKeyIsSignal) {
+            valueOfKey.set(isSignal(value) ? value() : value);
+            return;
+        }
+        currentObjectByKey[key] = value;
+    });
+    return obj;
+};
+/**
+ * Tạo một bản sao sâu của một đối tượng hoặc giá trị bất kỳ
+ * @param data Dữ liệu cần sao chép
+ * @param options Tùy chọn cấu hình
+ * @param options.ignoreSignal Nếu true, sẽ không sao chép các signal mà trả về signal gốc
+ * @param seen WeakMap để theo dõi các tham chiếu đã được sao chép, tránh lặp vô hạn với các tham chiếu vòng
+ * @returns Bản sao sâu của dữ liệu đầu vào
+ * @example
+ * const obj = {
+ *   a: 1,
+ *   b: { c: 2 },
+ *   d: [1, 2, 3]
+ * };
+ * const clone = cloneDeep(obj);
+ * // clone là một bản sao hoàn toàn độc lập của obj
+ */
+const cloneDeep = (data, options = { ignoreSignal: false }, seen = new WeakMap()) => {
+    if (data === null || (typeof data !== 'object' && !isSignal(data))) {
+        return data;
+    }
+    if (seen.has(data)) {
+        return seen.get(data);
+    }
+    if (data instanceof HttpParams) {
+        return new UtilsHttpParamsRequest(undefined, data);
+    }
+    if (data instanceof Date) {
+        return new Date(data.getTime());
+    }
+    if (dayjs.isDayjs(data)) {
+        return getDayjs({ date: data.valueOf() });
+    }
+    if (data instanceof RegExp) {
+        return new RegExp(data.source, data.flags);
+    }
+    if (data instanceof Map) {
+        const mapCopy = new Map();
+        seen.set(data, mapCopy);
+        data.forEach((val, key) => {
+            mapCopy.set(cloneDeep(key, options, seen), cloneDeep(val, options, seen));
+        });
+        return mapCopy;
+    }
+    if (data instanceof Set) {
+        const setCopy = new Set();
+        seen.set(data, setCopy);
+        data.forEach((val) => {
+            setCopy.add(cloneDeep(val, options, seen));
+        });
+        return setCopy;
+    }
+    if (Array.isArray(data)) {
+        seen.set(data, data.map((item) => cloneDeep(item, options, seen)));
+        return seen.get(data);
+    }
+    if (data instanceof File || data instanceof Blob || Object.prototype.toString.call(data) === '[object File]') {
+        return data;
+    }
+    if (data instanceof TemplateRef || data instanceof ElementRef || data instanceof Element || data instanceof Promise || data instanceof Observable) {
+        return data;
+    }
+    if (isSignal(data)) {
+        if (options?.ignoreSignal) {
+            return data;
+        }
+        seen.set(data, signal(cloneDeep(data(), options, seen)));
+        return seen.get(data);
+    }
+    const result = {};
+    seen.set(data, result);
+    for (const key in data) {
+        const value = data[key];
+        if (value instanceof HttpParams) {
+            result[key] = new UtilsHttpParamsRequest(undefined, value);
+            continue;
+        }
+        if (dayjs.isDayjs(value)) {
+            result[key] = getDayjs({ date: value.valueOf() });
+            continue;
+        }
+        if (value instanceof TemplateRef || value instanceof ElementRef || value instanceof Element || value instanceof Promise || value instanceof Observable) {
+            result[key] = value;
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            result[key] = cloneDeep(value, options, seen);
+        }
+    }
+    return result;
+};
+/**
+ * Chuyển đổi một mảng các đối tượng thành một đối tượng với khóa được chỉ định
+ * @param data Mảng các đối tượng cần chuyển đổi
+ * @param key Tên thuộc tính được sử dụng làm khóa trong đối tượng kết quả
+ * @returns Đối tượng với các giá trị từ mảng được đánh key theo thuộc tính đã chỉ định
+ * @example
+ * const data = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' }
+ * ];
+ * keyBy(data, 'id');
+ * // Kết quả: {
+ * //   '1': { id: 1, name: 'John' },
+ * //   '2': { id: 2, name: 'Jane' }
+ * // }
+ */
+const keyBy = (data, key) => {
+    if (!data || !data.length || !key) {
+        return {};
+    }
+    return data.reduce((dir, nextItem) => {
+        const valueOfKey = get(nextItem, key);
+        if (typeof valueOfKey !== 'string' && typeof valueOfKey !== 'number' && typeof valueOfKey !== 'boolean') {
+            return dir;
+        }
+        if (!Object.keys(dir).includes(`${valueOfKey}`)) {
+            dir[`${valueOfKey}`] = nextItem;
+        }
+        return dir;
+    }, {});
+};
+/**
+ * Nhóm các đối tượng trong một mảng thành các nhóm dựa trên một thuộc tính cụ thể
+ * @param data Mảng các đối tượng cần nhóm
+ * @param key Tên thuộc tính được sử dụng làm khóa nhóm
+ * @returns Đối tượng với các giá trị từ mảng được nhóm theo thuộc tính đã chỉ định
+ * @example
+ * const data = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' },
+ *   { id: 1, name: 'John' }
+ * ];
+ * groupBy(data, 'id');
+ * // Kết quả: {
+ * //   '1': [
+ * //     { id: 1, name: 'John' },
+ * //     { id: 1, name: 'John' }
+ * //   ],
+ * //   '2': [
+ * //     { id: 2, name: 'Jane' }
+ * // }
+ */
+const groupBy = (data, key) => {
+    if (!data || !data.length || !Object.keys(get(data, '0')).length || !key) {
+        return {};
+    }
+    return data.reduce((dir, nextItem) => {
+        const valueOfKey = get(nextItem, key);
+        if (typeof valueOfKey !== 'string' && typeof valueOfKey !== 'number' && typeof valueOfKey !== 'boolean') {
+            return dir;
+        }
+        if (!Object.keys(dir).includes(`${valueOfKey}`)) {
+            dir[`${valueOfKey}`] = [];
+        }
+        dir[`${valueOfKey}`].push(nextItem);
+        return dir;
+    }, {});
+};
+/**
+ * Tạo một mảng các số từ giá trị bắt đầu đến giá trị kết thúc với bước nhảy tùy chọn
+ * @param start Giá trị bắt đầu của dãy số. Nếu chỉ có một tham số, đây sẽ là giá trị kết thúc và giá trị bắt đầu sẽ là 0
+ * @param end Giá trị kết thúc của dãy số (tùy chọn)
+ * @param step Bước nhảy giữa các số trong dãy (tùy chọn). Mặc định là 1 nếu end > start, -1 nếu end < start
+ * @returns Mảng các số từ start đến end với bước nhảy step
+ * @example
+ * range(4);      // [0, 1, 2, 3]
+ * range(1, 5);   // [1, 2, 3, 4]
+ * range(0, 20, 5); // [0, 5, 10, 15]
+ * range(5, 2);   // [5, 4, 3]
+ */
+const range = (start, end, step) => {
+    if (end === undefined || end === null) {
+        end = start;
+        start = 0;
+    }
+    if (!step) {
+        step = end < 0 ? -1 : 1;
+    }
+    if (end < start && step > 0) {
+        step *= -1;
+    }
+    const valueStartByStep = step + start;
+    const direction = start < end ? 'asc' : 'desc';
+    if ((direction === 'asc' && (valueStartByStep < start || valueStartByStep > end)) || (direction === 'desc' && (valueStartByStep > start || valueStartByStep < end))) {
+        return [start];
+    }
+    const arr = new Array();
+    for (let index = 0; index < Math.abs(end - start); index++) {
+        let value = start + index * step;
+        if (index === 0) {
+            value = start;
+        }
+        if ((direction === 'asc' && (value < start || value > end)) || (direction === 'desc' && (value > start || value < end))) {
+            return arr;
+        }
+        arr.push(value);
+    }
+    return arr;
+};
+/**
+ * So sánh hai giá trị bất kỳ có bằng nhau hay không
+ * @param value1 Giá trị thứ nhất cần so sánh
+ * @param value2 Giá trị thứ hai cần so sánh
+ * @param exactlyPosition Có so sánh chính xác vị trí các phần tử trong mảng hay không
+ * @returns true nếu hai giá trị bằng nhau, false nếu không bằng nhau
+ * @example
+ * isEqual([1,2,3], [1,2,3]); // true
+ * isEqual([1,2,3], [3,2,1]); // true khi exactlyPosition = false
+ * isEqual([1,2,3], [3,2,1]); // false khi exactlyPosition = true
+ * isEqual({a:1}, {a:1}); // true
+ */
+const isEqual = (value1, value2, options) => {
+    const { exactlyPosition = false, ignoreExactlyDataType = false } = options || {};
+    if (value1 === value2 || (value1 === null && value2 === null) || (value1 === undefined && value2 === undefined)) {
+        return true;
+    }
+    if (ignoreExactlyDataType) {
+        return isEqual(isNil(value1) ? undefined : `${value1}`, isNil(value2) ? undefined : `${value2}`);
+    }
+    // Handle signals
+    while (isSignal(value1)) {
+        value1 = value1();
+    }
+    while (isSignal(value2)) {
+        value2 = value2();
+    }
+    if (typeof value1 !== 'object' || typeof value2 !== 'object' || (Array.isArray(value1) && !Array.isArray(value2)) || (!Array.isArray(value1) && Array.isArray(value2))) {
+        return false;
+    }
+    if (Array.isArray(value1)) {
+        if (value1.length !== value2.length) {
+            return false;
+        }
+        if (!exactlyPosition) {
+            return !value1.some((item) => !value2.includes(item));
+        }
+        return !value1.some((item, index) => !isEqual(item, value2[index], options));
+    }
+    if (Object.keys(value1).length !== Object.keys(value2).length) {
+        return false;
+    }
+    return !Object.keys(value1).some((key) => !isEqual(value1[key], value2[key], options));
+};
+/**
+ * Loại bỏ các phần tử trùng lặp trong mảng dựa trên một thuộc tính chỉ định
+ * @param data Mảng dữ liệu cần xử lý
+ * @param key Tên thuộc tính dùng để so sánh trùng lặp. Nếu không có key thì so sánh trực tiếp giá trị
+ * @returns Mảng mới chứa các phần tử không trùng lặp
+ * @example
+ * const arr = [
+ *   { id: 1, name: 'A' },
+ *   { id: 2, name: 'B' },
+ *   { id: 1, name: 'C' }
+ * ];
+ * uniqBy(arr, 'id'); // [{ id: 1, name: 'A' }, { id: 2, name: 'B' }]
+ *
+ * const numbers = [1, 2, 2, 3, 3];
+ * uniqBy(numbers); // [1, 2, 3]
+ *
+ * const numbersSignal = [signal(1), signal(2), signal(3), signal(2), signal(5), signal(4), signal(1), signal(6), signal(7), signal(6)];
+ * uniqBy(numbersSignal); // [signal(1), signal(2), signal(3), signal(5), signal(4), signal(6), signal(7)]
+ */
+const uniqBy = (data, key) => {
+    if (!key || !data?.length || typeof get(data, '0') !== 'object') {
+        // Xử lý mảng chứa signal values
+        if (data[0] && isSignal(data[0])) {
+            const seen = new Set();
+            return data.filter((item) => {
+                const value = `${get(item, '')}`;
+                if (seen.has(value)) {
+                    return false;
+                }
+                seen.add(value);
+                return true;
+            });
+        }
+        // Xử lý mảng primitive values
+        return Array.from(new Set(data));
+    }
+    const dataUnique = keyBy(data, key);
+    return Object.keys(dataUnique).map((key) => dataUnique[key]);
+};
+const generateInterface = (obj, interfaceName) => {
+    const generateType = (value) => {
+        if (value === null) {
+            return 'null';
+        }
+        const type = typeof value;
+        if (type === 'string') {
+            return 'string';
+        }
+        if (type === 'number') {
+            return 'number';
+        }
+        if (type === 'boolean') {
+            return 'boolean';
+        }
+        if (type === 'undefined') {
+            return 'any';
+        }
+        if (value instanceof Date) {
+            return 'Date';
+        }
+        if (value instanceof RegExp) {
+            return 'RegExp';
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                return 'Array<any>';
+            }
+            return `Array<${generateType(value[0])}>`;
+        }
+        if (type === 'object') {
+            let interfaceStr = '{\n';
+            for (const key in value) {
+                if (Object.prototype.hasOwnProperty.call(value, key)) {
+                    const valueType = generateType(value[key]);
+                    interfaceStr += `  ${key}: ${valueType};\n`;
+                }
+            }
+            interfaceStr += '}';
+            return interfaceStr;
+        }
+        return 'any';
+    };
+    const interfaceStr = `interface ${interfaceName} ${generateType(obj)}`;
+    return interfaceStr;
+};
+
+;
+const step = 20;
+const percent = 0.05;
+const colorStepContrastFromOrigin = (color, stepNumber) => {
+    return colorContrastFromOrigin(color).find(item => item.step === stepNumber);
+};
+const colorContrastFromOrigin = (color) => {
+    const parsedColorsArray = parseColorValues(color);
+    const colors = [];
+    let calculatedShades = [];
+    let calculatedTints = [];
+    if (parsedColorsArray !== null) {
+        for (let i = 0; i < parsedColorsArray.length; i++) {
+            calculatedShades = calculateShades(parsedColorsArray[i]);
+            calculatedTints = calculateTints(parsedColorsArray[i]);
+        }
+        for (let i = 0; i <= step; i++) {
+            colors.push({ step: i * 5, label: `${i * 5}%`, dark: `#${calculatedShades[i]}`, light: `#${calculatedTints[i]}` });
+        }
+    }
+    return colors;
+};
+const parseColorValues = (colorValues) => {
+    let colorValuesArray = colorValues.match(/\b[0-9A-Fa-f]{3}\b|[0-9A-Fa-f]{6}\b/g);
+    if (colorValuesArray) {
+        colorValuesArray = colorValuesArray.map((item) => {
+            if (item.length === 3) {
+                let newItem = item.toString().split('');
+                newItem = newItem.reduce((acc, it) => {
+                    return acc + it + it;
+                }, '');
+                return newItem;
+            }
+            return item;
+        });
+    }
+    return colorValuesArray;
+};
+const calculateShades = (colorValue) => {
+    return calculate(colorValue, rgbShade).concat("000000");
+};
+const calculateTints = (colorValue) => {
+    return calculate(colorValue, rgbTint).concat("ffffff");
+};
+const calculate = (colorValue, shadeOrTint) => {
+    const color = hexToRGB(colorValue);
+    const shadeValues = [];
+    for (let i = 0; i < step; i++) {
+        shadeValues[i] = rgbToHex(shadeOrTint(color, i));
+    }
+    return shadeValues;
+};
+const rgbShade = (rgb, i) => { return { red: rgb.red * (1 - percent * i), green: rgb.green * (1 - percent * i), blue: rgb.blue * (1 - percent * i) }; };
+const rgbTint = (rgb, i) => { return { red: rgb.red + (255 - rgb.red) * i * percent, green: rgb.green + (255 - rgb.green) * i * percent, blue: rgb.blue + (255 - rgb.blue) * i * percent }; };
+const rgbToHex = (rgb) => { return intToHex(rgb.red) + intToHex(rgb.green) + intToHex(rgb.blue); };
+const hexToRGB = (colorValue) => { return { red: parseInt(colorValue.substr(0, 2), 16), green: parseInt(colorValue.substr(2, 2), 16), blue: parseInt(colorValue.substr(4, 2), 16) }; };
+const intToHex = (rgbint) => { return pad(Math.min(Math.max(Math.round(rgbint), 0), 255).toString(16), 2); };
+const pad = (number, length) => {
+    let str = '' + number;
+    while (str.length < length) {
+        str = '0' + str;
+    }
+    return str;
+};
+const listColorDefine = ['#E62222', '#B81B1B', '#EB4E4E', '#F97316', '#C75C12', '#FA8F45', '#FFB700', '#CC9200', '#FFC533', '#84CC16', '#6AA312', '#9dd645', '#00BC62', '#00A757', '#33DA8A', '#06B6D4', '#1B59C4', '#4E8CF7', '#0EA5E9',
+    '#1B59C4', '#4E8CF7', '#226FF5', '#1B59C4', '#4E8CF7', '#6366F1', '#4F52C1', '#8285F4', '#5B04B3', '#49038F', '#7C36C2', '#D946EF', '#AE38BF', '#E16BF2', '#EC4899', '#BD3A7A', '#F06DAD', '#F43F5E', '#C3324B', '#F6657E', '#757380', '#5E5C66', '#918F99',
+    '#202020', '#1A1A1A', '#4D4D4D'
+];
+const getColorById = (str) => {
+    let hashString = 0;
+    if (!str) {
+        return '';
+    }
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hashString = ((hashString << 5) - hashString) + char;
+        hashString = hashString & hashString;
+    }
+    return listColorDefine[Math.abs(hashString) % listColorDefine.length];
+};
+
+class UtilsKeyCodeConstant {
+    static MAC_ENTER = 3;
+    static BACKSPACE = 8;
+    static TAB = 9;
+    static NUM_CENTER = 12;
+    static ENTER = 13;
+    static SHIFT = 16;
+    static CONTROL = 17;
+    static ALT = 18;
+    static PAUSE = 19;
+    static CAPS_LOCK = 20;
+    static ESCAPE = 27;
+    static SPACE = 32;
+    static PAGE_UP = 33;
+    static PAGE_DOWN = 34;
+    static END = 35;
+    static HOME = 36;
+    static LEFT_ARROW = 37;
+    static UP_ARROW = 38;
+    static RIGHT_ARROW = 39;
+    static DOWN_ARROW = 40;
+    static PLUS_SIGN = 43;
+    static PRINT_SCREEN = 44;
+    static INSERT = 45;
+    static DELETE = 46;
+    static ZERO = 48;
+    static ONE = 49;
+    static TWO = 50;
+    static THREE = 51;
+    static FOUR = 52;
+    static FIVE = 53;
+    static SIX = 54;
+    static SEVEN = 55;
+    static EIGHT = 56;
+    static NINE = 57;
+    static FF_SEMICOLON = 59; // Firefox (Gecko) fires this for semicolon instead of 186
+    static FF_EQUALS = 61; // Firefox (Gecko) fires this for equals instead of 187
+    static QUESTION_MARK = 63;
+    static AT_SIGN = 64;
+    static A = 65;
+    static B = 66;
+    static C = 67;
+    static D = 68;
+    static E = 69;
+    static F = 70;
+    static G = 71;
+    static H = 72;
+    static I = 73;
+    static J = 74;
+    static K = 75;
+    static L = 76;
+    static M = 77;
+    static N = 78;
+    static O = 79;
+    static P = 80;
+    static Q = 81;
+    static R = 82;
+    static S = 83;
+    static T = 84;
+    static U = 85;
+    static V = 86;
+    static W = 87;
+    static X = 88;
+    static Y = 89;
+    static Z = 90;
+    static META = 91; // WIN_KEY_LEFT
+    static MAC_WK_CMD_LEFT = 91;
+    static MAC_WK_CMD_RIGHT = 93;
+    static CONTEXT_MENU = 93;
+    static NUMPAD_ZERO = 96;
+    static NUMPAD_ONE = 97;
+    static NUMPAD_TWO = 98;
+    static NUMPAD_THREE = 99;
+    static NUMPAD_FOUR = 100;
+    static NUMPAD_FIVE = 101;
+    static NUMPAD_SIX = 102;
+    static NUMPAD_SEVEN = 103;
+    static NUMPAD_EIGHT = 104;
+    static NUMPAD_NINE = 105;
+    static NUMPAD_MULTIPLY = 106;
+    static NUMPAD_PLUS = 107;
+    static NUMPAD_MINUS = 109;
+    static NUMPAD_PERIOD = 110;
+    static NUMPAD_DIVIDE = 111;
+    static F1 = 112;
+    static F2 = 113;
+    static F3 = 114;
+    static F4 = 115;
+    static F5 = 116;
+    static F6 = 117;
+    static F7 = 118;
+    static F8 = 119;
+    static F9 = 120;
+    static F10 = 121;
+    static F11 = 122;
+    static F12 = 123;
+    static NUM_LOCK = 144;
+    static SCROLL_LOCK = 145;
+    static FIRST_MEDIA = 166;
+    static FF_MINUS = 173;
+    static MUTE = 173; // Firefox (Gecko) fires 181 for MUTE
+    static VOLUME_DOWN = 174; // Firefox (Gecko) fires 182 for VOLUME_DOWN
+    static VOLUME_UP = 175; // Firefox (Gecko) fires 183 for VOLUME_UP
+    static FF_MUTE = 181;
+    static FF_VOLUME_DOWN = 182;
+    static LAST_MEDIA = 183;
+    static FF_VOLUME_UP = 183;
+    static SEMICOLON = 186; // Firefox (Gecko) fires 59 for SEMICOLON
+    static EQUALS = 187; // Firefox (Gecko) fires 61 for EQUALS
+    static COMMA = 188;
+    static DASH = 189; // Firefox (Gecko) fires 173 for DASH/MINUS
+    static PERIOD = 190;
+    static SLASH = 191;
+    static APOSTROPHE = 192;
+    static TILDE = 192;
+    static OPEN_SQUARE_BRACKET = 219;
+    static BACKSLASH = 220;
+    static CLOSE_SQUARE_BRACKET = 221;
+    static SINGLE_QUOTE = 222;
+    static MAC_META = 224;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const getKeyCacheByArrayObject = (keyCache, argumentsValue) => {
+    if (!keyCache || !argumentsValue) {
+        return '';
+    }
+    let keyBuild = `${JSON.stringify(argumentsValue.slice(1))}-key-cache-plus`;
+    argumentsValue.forEach((item) => {
+        if (typeof item === 'object') {
+            if (Array.isArray(item)) {
+                keyBuild = `${keyBuild}${JSON.stringify(item)}`;
                 return;
             }
-            if (key === UtilsCache.languageKeyCache) {
-                return UtilsCache.setLang(value);
-            }
-            UtilsCache.Set(key, value, UtilsCache.CACHE_EXPIRE_NONE);
-        });
-    }
-    static DeleteKeyStartWithAsync(keyCacheStartWith, isKeyMD5 = false) {
-        return new Promise(async (resolve) => {
-            const objectStore = await UtilsCache.getObjectStore();
-            if (!objectStore) {
-                return resolve({});
-            }
-            const index = objectStore.index(UtilsCache.itemIndexByKey);
-            // Lấy tất cả các keys từ index
-            const request = index.getAll();
-            keyCacheStartWith = isKeyMD5 ? keyCacheStartWith : md5(keyCacheStartWith);
-            request.onsuccess = (e) => {
-                const data = e.target.result;
-                if (!Array.isArray(data)) {
-                    return resolve({});
+            const keys = (item instanceof HttpParams ? item.keys() : Object.keys(item)).sort(((str1, str2) => str1.localeCompare(str2)));
+            keys.forEach(key => {
+                if (key.toLocaleLowerCase() === 'pem') {
+                    return;
                 }
-                data.forEach(obj => {
-                    if (obj.key.startsWith(keyCacheStartWith)) {
-                        UtilsCache.ClearAsync(obj.key, true);
-                    }
-                });
-                return resolve({});
-            };
-            request.onerror = () => {
-                return resolve({});
-            };
-        });
-    }
-    static DeleteKeyStartWith(keyCache, isMD5 = false) {
-        keyCache = isMD5 ? md5(keyCache) : keyCache;
-        const keys = Object.keys(UtilsCache.LocalStorage);
-        if (!keys || !keys.length) {
+                keyBuild = `${keyBuild}${JSON.stringify(get(item, key))}`;
+            });
             return;
         }
-        keys.forEach(key => {
-            if (key.startsWith(keyCache)) {
-                this.Clear(key);
-            }
-        });
-    }
-}
+        keyBuild = `${keyBuild}${item}`;
+    });
+    const keyCachePlus = md5(keyBuild);
+    const keyCacheMD5 = md5(keyCache);
+    return `${keyCacheMD5}-${md5(`${keyCacheMD5}-${keyCachePlus}`)}`;
+};
 
 const formatNumber = (value) => {
     const lang = UtilsCache.getLang();
@@ -1414,138 +2392,521 @@ const viewDataNumberByLanguage = (value, acceptNegativeValue, parseFixed = 1, ig
     }
 };
 
-const emojiPattern = () => {
-    return /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/g;
+let functionXssFilter = async (value) => {
+    return value;
 };
-const removeEmoji = (text) => {
-    if (!text || !text.trim()) {
-        return text;
-    }
-    return text.replace(emojiPattern(), '');
+const updateFunctionXssFilter = (functionCustom) => {
+    functionXssFilter = functionCustom;
+};
+const xssFilter = async (data) => {
+    return await functionXssFilter(data);
 };
 
-const escapeHtml = (data) => {
-    if (!data || typeof data !== 'string') {
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Chuyển đổi một đối tượng hoặc giá trị thành signal
+ * @param data Dữ liệu cần chuyển đổi thành signal
+ * @param cloneDeepIfNotSignal Có thực hiện sao chép sâu dữ liệu trước khi chuyển đổi hay không nếu data không phải signal. Mặc định là true.
+ * Đặt false nếu muốn giữ nguyên tham chiếu đến dữ liệu gốc.
+ * Nếu muốn sao chép sâu đối tượng signal thì đặt cloneDeepIfNotSignal là true và acceptConvertObjectInnerWritableSignal là true.
+ * @param isSignalPrimitiveType Có chuyển đổi các giá trị nguyên thủy (string, number, boolean) thành signal hay không. Mặc định là false.
+ * Đặt true nếu muốn bọc các giá trị nguyên thủy trong signal.
+ * @param acceptConvertObjectInnerWritableSignal Có tiếp tục tìm kiếm và chuyển đổi các đối tượng bên trong signal hay không. Mặc định là false.
+ * Đặt true nếu muốn tìm và chuyển đổi các đối tượng bên trong signal hoặc chính nó thành signal mới.
+ * @returns Dữ liệu đã được chuyển đổi theo kiểu T
+ */
+const convertObjectToSignal = (data, cloneDeepIfNotSignal = true, isSignalPrimitiveType = false, acceptConvertObjectInnerWritableSignal = false, seen = new WeakMap()) => {
+    if ((data === null || typeof data !== 'object') && !isSignal(data)) {
+        return (isSignalPrimitiveType ? signal(data) : data);
+    }
+    if (seen.has(data)) {
+        return seen.get(data);
+    }
+    if (isSignal(data)) {
+        if (!acceptConvertObjectInnerWritableSignal) {
+            return data;
+        }
+        seen.set(data, convertObjectToSignal(data(), cloneDeepIfNotSignal, isSignalPrimitiveType, acceptConvertObjectInnerWritableSignal, seen));
+        return seen.get(data);
+    }
+    if (Array.isArray(data)) {
+        seen.set(data, signal(data.map(item => convertObjectToSignal(item, cloneDeepIfNotSignal, isSignalPrimitiveType, acceptConvertObjectInnerWritableSignal, seen))));
+        return seen.get(data);
+    }
+    if (data instanceof Map) {
+        const mapCopy = new Map();
+        Array.from(data.keys()).forEach(key => {
+            mapCopy.set(key, convertObjectToSignal(data.get(key), cloneDeepIfNotSignal, isSignalPrimitiveType, acceptConvertObjectInnerWritableSignal));
+        });
+        seen.set(data, signal(mapCopy));
+        return seen.get(data);
+    }
+    if (data instanceof Promise || data instanceof Observable) {
         return data;
     }
-    return data
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&#039;");
-};
-
-const deleteUnicode = (str) => {
-    str = str.replace(/à|á|ạ|ả|ã|â|ầ|ấ|ậ|ẩ|ẫ|ă|ằ|ắ|ặ|ẳ|ẵ/g, 'a');
-    str = str.replace(/è|é|ẹ|ẻ|ẽ|ê|ề|ế|ệ|ể|ễ|ễ/g, 'e');
-    str = str.replace(/ì|í|ị|ỉ|ĩ/g, 'i');
-    str = str.replace(/ò|ó|ọ|ỏ|õ|ô|ồ|ố|ộ|ổ|ỗ|ơ|ờ|ớ|ợ|ở|ỡ/g, 'o');
-    str = str.replace(/ù|ú|ụ|ủ|ũ|ư|ừ|ứ|ự|ử|ữ/g, 'u');
-    str = str.replace(/ỳ|ý|ỵ|ỷ|ỹ/g, 'y');
-    str = str.replace(/đ/g, 'd');
-    str = str.replace(/À|Á|Ạ|Ả|Ã|Â|Ầ|Ấ|Ậ|Ẩ|Ẫ|Ă|Ằ|Ắ|Ặ|Ẳ|Ẵ/g, 'A');
-    str = str.replace(/È|É|Ẹ|Ẻ|Ẽ|Ê|Ề|Ế|Ệ|Ể|Ễ/g, 'E');
-    str = str.replace(/Ì|Í|Ị|Ỉ|Ĩ/g, 'I');
-    str = str.replace(/Ò|Ó|Ọ|Ỏ|Õ|Ô|Ồ|Ố|Ộ|Ổ|Ỗ|Ơ|Ờ|Ớ|Ợ|Ở|Ỡ/g, 'O');
-    str = str.replace(/Ù|Ú|Ụ|Ủ|Ũ|Ư|Ừ|Ứ|Ự|Ử|Ữ/g, 'U');
-    str = str.replace(/Ỳ|Ý|Ỵ|Ỷ|Ỹ/g, 'Y');
-    str = str.replace(/Đ/g, 'D');
-    str = str.replace(/\u0300|\u0301|\u0303|\u0309|\u0323/g, ""); // ̀ ́ ̃ ̉ ̣  huyền, sắc, ngã, hỏi, nặng
-    str = str.replace(/\u02C6|\u0306|\u031B/g, ""); // ˆ ̆ ̛  Â, Ê, Ă, Ơ, Ư
-    return str.normalize();
+    data = signal(cloneDeepIfNotSignal ? { ...data } : data);
+    seen.set(data, data);
+    for (const key in data()) {
+        const value = data()[key];
+        if (value instanceof TemplateRef || value instanceof File || value instanceof Blob || Object.prototype.toString.call(value) === '[object File]' || value instanceof ElementRef || value instanceof Element || value instanceof Date || value instanceof RegExp || value instanceof Set || value instanceof Map || value instanceof Promise || value instanceof Observable || value instanceof HttpParams) {
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(data(), key)) {
+            data()[key] = convertObjectToSignal(value, cloneDeepIfNotSignal, isSignalPrimitiveType, acceptConvertObjectInnerWritableSignal);
+        }
+    }
+    return data;
 };
-
-const listColorDefine = ['#E62222', '#B81B1B', '#EB4E4E', '#F97316', '#C75C12', '#FA8F45', '#FFB700', '#CC9200', '#FFC533', '#84CC16', '#6AA312', '#9dd645', '#00BC62', '#00A757', '#33DA8A', '#06B6D4', '#1B59C4', '#4E8CF7', '#0EA5E9',
-    '#1B59C4', '#4E8CF7', '#226FF5', '#1B59C4', '#4E8CF7', '#6366F1', '#4F52C1', '#8285F4', '#5B04B3', '#49038F', '#7C36C2', '#D946EF', '#AE38BF', '#E16BF2', '#EC4899', '#BD3A7A', '#F06DAD', '#F43F5E', '#C3324B', '#F6657E', '#757380', '#5E5C66', '#918F99',
-    '#202020', '#1A1A1A', '#4D4D4D'
-];
-const getColorById = (str) => {
-    let hashString = 0;
-    if (!str) {
-        return '';
+const convertSignalToObject = (data, isCloneDeep = true, seen = new WeakMap()) => {
+    let ignoreCheckSeenHasDataAfterWhile = false;
+    while (isSignal(data) && !seen.has(data)) {
+        const dataConvert = data();
+        if (typeof dataConvert === 'object') {
+            if (dataConvert === null) {
+                return dataConvert;
+            }
+            seen.set(dataConvert, dataConvert);
+            data = dataConvert;
+            ignoreCheckSeenHasDataAfterWhile = true;
+            break;
+        }
+        seen.set(data, dataConvert);
+        data = dataConvert;
     }
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hashString = ((hashString << 5) - hashString) + char;
-        hashString = hashString & hashString;
+    if (data === null || typeof data === 'function' || typeof data !== 'object') {
+        return data;
     }
-    return listColorDefine[Math.abs(hashString) % listColorDefine.length];
+    if (!ignoreCheckSeenHasDataAfterWhile && seen.has(data)) {
+        return seen.get(data);
+    }
+    if (Array.isArray(data)) {
+        if (!isSignal(data[0])) {
+            return data;
+        }
+        seen.set(data, data.map(item => convertSignalToObject((isCloneDeep ? cloneDeep(item) : item), isCloneDeep, seen)));
+        return seen.get(data);
+    }
+    if (data instanceof Map) {
+        const mapCopy = new Map();
+        Array.from(data.keys()).forEach(key => {
+            mapCopy.set(key, convertSignalToObject(isCloneDeep ? cloneDeep(data.get(key)) : data.get(key), isCloneDeep));
+        });
+        seen.set(data, mapCopy);
+        return seen.get(data);
+    }
+    if (data instanceof File || data instanceof Blob || Object.prototype.toString.call(data) === '[object File]') {
+        return data;
+    }
+    if (data instanceof TemplateRef || data instanceof ElementRef || data instanceof Element || data instanceof Promise || data instanceof Observable || data instanceof HttpParams) {
+        return data;
+    }
+    const result = isCloneDeep ? {} : data;
+    seen.set(data, result);
+    for (const key in data) {
+        const value = data[key];
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            result[key] = convertSignalToObject(isCloneDeep ? cloneDeep(value) : value, isCloneDeep);
+        }
+    }
+    return result;
 };
 
-const ERROR_MESSAGE_EMPTY_VALID = 'i18n_valid_empty_message';
-const ERROR_MESSAGE_PATTEN_VALID = 'i18n_valid_pattern_message';
-const ERROR_MESSAGE_MIN_VALID = 'i18n_message_error_input_min_value';
-const ERROR_MESSAGE_MAX_VALID = 'i18n_message_error_input_max_value';
-const ERROR_MESSAGE_MIN_LENGTH = 'i18n_message_error_input_min_length';
-const ERROR_MESSAGE_MAX_LENGTH = 'i18n_message_error_input_max_length';
-const CHARACTER_DATA_EMPTY = '__';
-
-/* eslint-disable no-useless-escape */
-const PATTERN_EMAIL = () => {
-    return /^[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]@[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]\.[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]$/;
-};
-const PATTERN_URL = () => {
-    return /^(http|https|ftp):(\/){2}[^\s]+[.]{1}[^\s]+$/;
-};
-const PATTERN_HOST_URL = () => {
-    return /^((https|http|ftp):[/]{2}[^/\s]+)/;
-};
-const PATTERN_DOMAIN = () => {
-    return /^([a-zA-Z0-9])(([a-z0-9-]{1,61})?[a-z0-9]{1})?(\.[a-z0-9](([a-z0-9-]{1,61})?[a-z0-9]{1})?)?(\.[a-zA-Z]{2,4})+$/;
-};
-const PATTERN_MOBILE_PHONE = () => {
-    return /^(\+?84|0|84)([0-9]{9})$/;
-};
-const PATTERN_PHONE = () => {
-    return /^(\+?84|[0-9]|84)([0-9]{2,9})$/;
-};
-const PATTERN_PHONE_NORMAL = () => {
-    return /^(\+?84|[0-9]|84)([0-9]{9,10})$/;
-};
-const PATTERN_NUMBER = () => {
-    return /\d+/g;
+const ENCODE_URI_PATTERN = /%([0-9A-F]{2})/g;
+const decodeURI = (value) => {
+    return decodeURIComponent(value.split('').map((c) => {
+        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join(''));
+};
+const encodeURI = (value) => {
+    return encodeURIComponent(value).replace(ENCODE_URI_PATTERN, (match, p1) => {
+        return String.fromCharCode(parseInt(p1, 16));
+    });
 };
-const PATTERN_ENCODE_URI = () => {
-    return /%([0-9A-F]{2})/g;
+const endCodeUrl = (params, isBody) => {
+    params = omitBy(params, param => param === '' || isNil(param));
+    let res = '';
+    for (const p in params) {
+        res += `&${p}=${encodeURIComponent(params[p])}`;
+    }
+    return res === '' ? '' : `${isBody ? '' : '?'}${res.substring(1)}`;
 };
-const PATTERN_NAME = () => {
-    return /^\w+[A-Za-z\s\d]+$/;
+
+const base64Encode = (value) => {
+    return btoa(encodeURI(value));
+};
+const base64Decode = (value) => {
+    return decodeURI(atob(value));
+};
+const convertBase64ToBlob = (dataBase64) => {
+    const BASE64_MARKER = ';base64,';
+    if (dataBase64.indexOf(BASE64_MARKER) === -1) {
+        const parts = dataBase64.split(',');
+        const contentType = parts[0].split(':')[1];
+        const raw = parts[1];
+        const blob = new Blob([raw], { type: contentType });
+        return blob;
+    }
+    const parts = dataBase64.split(BASE64_MARKER);
+    const contentType = parts[0].split(':')[1];
+    const raw = window.atob(parts[1]);
+    const rawLength = raw.length;
+    const uInt8Array = new Uint8Array(rawLength);
+    for (let i = 0; i < rawLength; ++i) {
+        uInt8Array[i] = raw.charCodeAt(i);
+    }
+    const blob = new Blob([uInt8Array], { type: contentType });
+    return blob;
+};
+const convertFileToBase64_ObjectUrl = async (file) => {
+    if (!file.type.match(/image.*/)) {
+        return URL.createObjectURL(file);
+    }
+    return await convertFileToBase64(file);
+};
+const convertFileToBase64 = (file) => {
+    return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.onload = (event) => {
+            resolve(event.target?.result ?? '');
+        };
+    });
 };
-const PATTERN_NAME_UTF8 = () => {
-    return /^[ àáảãạăắằẵặẳâầấậẫẩđèéẻẽẹêềếểễệìíỉĩịòóỏõọôồốổỗộơờớởỡợùúủũụưừứửữựỳýỷỹÀÁẢÃẠĂẮẰẴẶẲÂẦẤẬẪẨĐÈÉẺẼẸÊỀẾỂỄỆÌÍỈĨỊÒÓỎÕỌÔỒỐỔỖỘƠỜỚỞỠỢÙÚỦŨỤƯỪỨỬỮỰỲÝỶỸA-Za-z0-9]+$/;
+
+const downloadFileByUrlUseXmlRequest = (fileUrl, filename) => {
+    const xmlRequest = new XMLHttpRequest();
+    xmlRequest.open('GET', fileUrl, true);
+    xmlRequest.responseType = 'blob';
+    xmlRequest.onload = () => {
+        const url = window.URL.createObjectURL(xmlRequest.response);
+        downloadFileByUrl(url, filename);
+    };
+    xmlRequest.send();
+};
+const downloadFileByUrl = async (fileUrl, filename, onlyOpen) => {
+    const downloadFileElement = document.createElement('a');
+    if (!onlyOpen) {
+        const response = await fetch(fileUrl);
+        if (response.ok) {
+            const blob = await response.blob();
+            fileUrl = URL.createObjectURL(blob);
+        }
+    }
+    downloadFileElement.href = fileUrl;
+    downloadFileElement.download = filename;
+    downloadFileElement.target = '_blank';
+    downloadFileElement.click();
+    downloadFileElement.remove();
+};
+const downloadImageFromELement = (imageElement, typeFileDownload, nameFile) => {
+    const parentElement = imageElement?.src;
+    const blobData = convertBase64ToBlob(parentElement);
+    const blob = new Blob([blobData], { type: typeFileDownload || "image/png" });
+    const url = window.URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = nameFile || 'barcode';
+    link.click();
 };
-const PATTERN_NAME_SPECIAL = () => {
-    return /[~!@#$%^&*()-+=<>,?\/\\:;"']/;
+
+const LINK_IMAGE_ERROR_TOKEN_INJECT = new InjectionToken('LINK_IMAGE_ERROR_TOKEN_INJECT');
+const PROCESS_BAR_STANDARD_CONFIG_DEFAULT_TOKEN_INJECT = new InjectionToken('PROCESS_BAR_STANDARD_CONFIG_DEFAULT_TOKEN_INJECT');
+const PROCESS_BAR_STEPS_CONFIG_DEFAULT_TOKEN_INJECT = new InjectionToken('PROCESS_BAR_STEPS_CONFIG_DEFAULT_TOKEN_INJECT');
+
+const isTypeImage = (file) => file.type.match(/image.*/) ? true : false;
+const isTypeVideo = (file) => file.type.match(/video.*/) ? true : false;
+const isTypeAudio = (file) => file.type.match(/audio.*/) ? true : false;
+const isTypeFile = (file) => file instanceof File || Object.prototype.toString.call(file) === '[object File]' ? true : false;
+const ExcelExtList = ['xls', 'xlsx', 'application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'];
+const DocumentExtList = ['doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'pdf', 'json', 'xml', 'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/vnd.ms-powerpoint',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'application/pdf',
+    'application/json',
+    'application/xml'];
+const isIncludeDocumentExtList = (ext, listExt = DocumentExtList) => listExt.includes(ext) || listExt.includes(`application/${ext}`);
+const ImageExtList = ['gif', 'jpg', 'jpeg', 'png', 'image/gif', 'image/jpeg', 'image/jpeg', 'image/png'];
+const isIncludeImageExtList = (ext, listExt = ImageExtList) => listExt.includes(ext);
+const VideoExtList = ['mp4', 'mov', 'mpg', 'avi', 'wmv', 'video/mp4', 'video/quicktime', 'video/mpeg', 'video/x-msvideo', 'video/x-ms-wmv'];
+const isIncludeVideoExtList = (ext, listExt = VideoExtList) => listExt.includes(ext);
+const AudioExtList = ['mp3', 'wav', 'ogg', 'aac', 'm4a', 'flac', 'wma', 'audio/mpeg', 'audio/wav', 'audio/ogg', 'audio/aac', 'audio/mp4', 'audio/flac', 'audio/x-ms-wma'];
+const isIncludeAudioExtList = (ext, listExt = AudioExtList) => listExt.includes(ext);
+const getFileExtension = (file) => {
+    if (file instanceof File && file.type) {
+        return (file.type.split('/').pop() || '').toLowerCase();
+    }
+    file = file;
+    if (file.mimetype || file.file?.type) {
+        return file.mimetype || file.file?.type;
+    }
+    let fileName = file.name;
+    const url = get(file, 'url') || get(file, 'origin_url');
+    if (!fileName && !url) {
+        return;
+    }
+    if (!fileName && url) {
+        fileName = url.split('/').pop() || '';
+        set(file, 'name', fileName);
+    }
+    const dots = fileName.split(".");
+    if (!dots) {
+        return;
+    }
+    return (dots.pop() || '').toLowerCase();
 };
-const PATTERN_NAME_PROFILE = () => {
-    return /([\w\W\d\s]+)+/;
+const getLabelBySizeFile = (size, toFixed = 2) => {
+    if (size < 1024 * 1024) {
+        return ` ${(size / 1024).toFixed(toFixed)} KB`;
+    }
+    return ` ${(size / (1024 * 1024)).toFixed(toFixed)} MB`;
 };
-const PATTERN_EMOJI = () => {
-    return /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/g;
+const convertBlobToFile = (blob, fileName) => {
+    const type = blob.type.split('/')[1];
+    const name = fileName ? `${fileName.split('.')[0]}.${type}` : `${uuid()}.${type}`;
+    return new File([blob], name, { type: blob.type, lastModified: Date.now() });
 };
-const PATTERN_RULE_FIELD_REPLACE = () => {
-    return /[{]{2}[a-zA-Z_-]+[}]{2}/g;
+const convertUrlToFile = (url, fileName) => {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.onload = function () {
+            const reader = new FileReader();
+            reader.onloadend = () => {
+                const file = convertBase64ToBlob(reader.result);
+                resolve(convertBlobToFile(file, fileName || Date.now().toLocaleString()));
+            };
+            reader.onerror = () => resolve(undefined);
+            reader.readAsDataURL(xhr.response);
+        };
+        xhr.onerror = (err) => {
+            reject(err);
+        };
+        xhr.open('GET', url);
+        xhr.responseType = 'blob';
+        xhr.send();
+    });
 };
-const PATTERN_GET_FIELD_BY_RULE_FIELD_REPLACE = () => {
-    return /[a-zA-Z_-]+/g;
+
+const DEFAULT_MIN_TICK_COUNT = 5;
+const DEFAULT_MAX_TICK_COUNT = 10;
+const MIN_DISTANCE_TO_ZERO = 3;
+const NEGATIVE_THRESHOLD = -5;
+const FALLBACK_NEGATIVE_VALUE = -4;
+const MAX_POW_NUMBER = 14;
+const MAX_TEMPLATE_NUMBER = 10;
+/**
+ * Tính toán smart axis scale cho biểu đồ
+ *
+ * @param maxData - Giá trị tối đa của dữ liệu
+ * @param options - Các tùy chọn cấu hình axis scale
+ * @returns Cấu hình axis scale bao gồm stepSize, max, min, tickAmount
+ *
+ * @throws {Error} INVALID_NEGATIVE_DATA - khi maxData < 0 mà acceptNegative = false
+ * @throws {Error} MISSING_MIN_NEGATIVE - khi acceptNegative = true nhưng thiếu minNegative
+ * @throws {Error} INVALID_RANGE - khi maxData < minNegative
+ * @throws {Error} INVALID_MIN_NEGATIVE - khi minNegative >= 0
+ *
+ * @example
+ * ```typescript
+ * const result = getSmartAxisScale(100, { minTickCount: 5, maxTickCount: 10 });
+ * // returns { stepSize: 20, max: 120, min: 0, tickAmount: 6 }
+ * ```
+ */
+const getSmartAxisScale = (originalMaxData, options) => {
+    let maxData = originalMaxData;
+    validateInputs(maxData, options);
+    const minTickCount = options?.minTickCount || DEFAULT_MIN_TICK_COUNT;
+    const maxTickCount = options?.maxTickCount || DEFAULT_MAX_TICK_COUNT;
+    let scaleDirection = 1;
+    let rangeDistance = maxData;
+    if (options?.acceptNegative && !isNil(options.minNegative)) {
+        if (maxData === 0) {
+            maxData = -1;
+        }
+        if (maxData <= 0) {
+            rangeDistance = options.minNegative;
+        }
+        if (rangeDistance > NEGATIVE_THRESHOLD) {
+            rangeDistance = FALLBACK_NEGATIVE_VALUE;
+        }
+        if (maxData > 0) {
+            rangeDistance = maxData + Math.abs(options.minNegative);
+            scaleDirection = -1;
+        }
+    }
+    if (Math.abs(rangeDistance) < MIN_DISTANCE_TO_ZERO) {
+        rangeDistance = MIN_DISTANCE_TO_ZERO;
+    }
+    const stepCandidates = getStepCandidates(maxData, minTickCount, options?.minNegative || 0, options?.acceptStepIsTypeFloat, options?.stepCandidates, options?.acceptNegative);
+    for (const step of stepCandidates) {
+        let tickCount = Math.abs(Math.ceil(rangeDistance / step)) + (scaleDirection === -1 ? 2 : 1);
+        let maxValue = maxData <= 0 ? 0 : step * tickCount * scaleDirection;
+        let minValue = 0;
+        if (tickCount >= minTickCount && tickCount <= maxTickCount) {
+            if (maxData < maxValue) {
+                if (options?.acceptNegative) {
+                    let tick = 1;
+                    while (!isNil(options.minNegative) && tick <= tickCount && minValue >= options.minNegative) {
+                        minValue = tick * step;
+                        tick++;
+                    }
+                }
+                const maxValuePositive = maxValue - Math.abs(minValue);
+                tickCount = maxValuePositive - originalMaxData > Math.abs(step) && tickCount - 1 >= minTickCount ? tickCount - 1 : tickCount;
+                maxValue = (step * tickCount * scaleDirection) - (minValue * scaleDirection);
+                return {
+                    stepSize: Math.abs(step),
+                    max: maxValue,
+                    min: minValue,
+                    tickAmount: tickCount
+                };
+            }
+        }
+    }
+    let step = Math.ceil(rangeDistance / minTickCount) || 1;
+    let maxValue = step * minTickCount;
+    if (rangeDistance === maxValue) {
+        step = step + Math.ceil(step / 10);
+        maxValue = step * minTickCount;
+    }
+    return {
+        stepSize: Math.abs(step),
+        max: maxValue,
+        min: 0,
+        tickAmount: minTickCount
+    };
 };
-const PATTERN_PEM = () => {
-    return /^(0|1):([0-9]{1,2}):(\{\{path-api\}\}):([a-zA-Z0-9\/]+)$/g;
+// Cache cho các giá trị lũy thừa 10 để tối ưu hiệu suất
+const POWER_CACHE = new Map();
+/**
+ * Tạo danh sách các step candidates cho việc tính toán scale
+ * @param maxData - Giá trị dữ liệu tối đa
+ * @param minStep - Số bước tối thiểu
+ * @param minNegative - Giá trị âm tối thiểu
+ * @param acceptStepIsTypeFloat - Có chấp nhận step thập phân không
+ * @param stepCandidatesByOptions - Step candidates do người dùng cung cấp
+ * @param includeNegativeSteps - Có bao gồm các step âm không
+ * @returns Danh sách các step candidates
+ */
+const getStepCandidates = (maxData, minStep, minNegative, acceptStepIsTypeFloat = false, stepCandidatesByOptions, includeNegativeSteps = false) => {
+    // Nếu có step candidates tùy chỉnh, sử dụng chúng
+    if (stepCandidatesByOptions && stepCandidatesByOptions.length > 0) {
+        return stepCandidatesByOptions;
+    }
+    const stepCandidates = new Array();
+    const maxValueStep = Math.abs(Math.max(maxData, Math.abs(minNegative || 0))) / minStep;
+    // Tạo step candidates dựa trên lũy thừa của 10
+    for (let powNumber = 0; powNumber <= MAX_POW_NUMBER; powNumber++) {
+        // Sử dụng cache để tối ưu hiệu suất
+        if (!POWER_CACHE.has(powNumber)) {
+            POWER_CACHE.set(powNumber, Math.pow(10, powNumber));
+        }
+        const powValue = POWER_CACHE.get(powNumber);
+        for (let templateNumber = 1; templateNumber < MAX_TEMPLATE_NUMBER; templateNumber++) {
+            // Thêm step thập phân nếu được chấp nhận
+            if (acceptStepIsTypeFloat) {
+                const step = powValue * (((templateNumber - 1) * 2 + 1) / 2);
+                stepCandidates.push(step);
+            }
+            const step = powValue * templateNumber;
+            stepCandidates.push(step);
+            // Dừng khi step đã đủ lớn
+            if (step >= maxValueStep) {
+                checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
+                return stepCandidates;
+            }
+        }
+    }
+    checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
+    return stepCandidates;
 };
-const PATTERN_TAX = () => {
-    return /^([0-9]){10}(-[0-9]{3})?$/;
+/**
+ * Kiểm tra và thêm các step âm vào danh sách candidates nếu cần
+ * @param stepCandidates - Danh sách step candidates hiện tại
+ * @param acceptNegative - Có chấp nhận giá trị âm không
+ * @param minNegative - Giá trị âm tối thiểu
+ */
+const checkAndSetNegativeSteps = (stepCandidates, acceptNegative, minNegative) => {
+    if (acceptNegative && minNegative < 0) {
+        // Tạo các step âm và thêm vào đầu danh sách
+        const negativeSteps = [...stepCandidates].map(step => -step);
+        stepCandidates.unshift(...negativeSteps);
+    }
 };
-const PATTERN_KEY = () => {
-    return /^([0-9]){10}(-[0-9]{3})?$/;
+/**
+ * Kiểm tra tính hợp lệ của các tham số đầu vào
+ * @param maxData - Giá trị dữ liệu tối đa
+ * @param options - Các tùy chọn cấu hình
+ * @throws {Error} Khi các tham số không hợp lệ
+ */
+const validateInputs = (maxData, options) => {
+    // Kiểm tra maxData âm khi không chấp nhận giá trị âm
+    if (maxData < 0 && !options?.acceptNegative) {
+        throw new Error("maxData is less than 0 and acceptNegative is false");
+    }
+    if (options?.acceptNegative) {
+        // Kiểm tra minNegative có được cung cấp không
+        if (isNil(options.minNegative)) {
+            throw new Error("minNegative is required when acceptNegative is true");
+        }
+        // Kiểm tra maxData phải >= minNegative
+        if (maxData < options.minNegative) {
+            throw new Error("maxData is less than minNegative");
+        }
+        // Kiểm tra minNegative phải là số âm
+        if (options.minNegative >= 0) {
+            throw new Error("minNegative must be negative");
+        }
+    }
 };
-const PATTERN_ACCOUNT = () => {
-    return /^(?=.*@)[a-z0-9@._-]{2,63}$/;
+
+const protectString = (input) => {
+    const xorKey = 77;
+    const encoded = input
+        .split('')
+        .map((char) => String.fromCharCode(char.charCodeAt(0) ^ xorKey))
+        .reverse()
+        .join('');
+    return btoa(encoded);
+};
+const revealString = (encoded) => {
+    const xorKey = 77;
+    const base = atob(encoded);
+    const decoded = base
+        .split('')
+        .reverse()
+        .map(c => String.fromCharCode(c.charCodeAt(0) ^ xorKey))
+        .join('');
+    return decoded;
+};
+const createUniqueRandomIntGenerator = (min, max) => {
+    if (max - min + 1 < min + 10) {
+        throw new Error(`Range too small: need at least min + 10 unique values`);
+    }
+    const history = [];
+    return () => {
+        let num;
+        let loop = 0;
+        do {
+            num = Math.floor(Math.random() * (max - min + 1)) + min;
+            loop++;
+            if (loop > 1000) {
+                break;
+            }
+        } while (history.includes(num));
+        history.push(num);
+        if (history.length > 10) {
+            history.shift();
+        }
+        return num;
+    };
 };
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { CHARACTER_DATA_EMPTY, ERROR_MESSAGE_EMPTY_VALID, ERROR_MESSAGE_MAX_LENGTH, ERROR_MESSAGE_MAX_VALID, ERROR_MESSAGE_MIN_LENGTH, ERROR_MESSAGE_MIN_VALID, ERROR_MESSAGE_PATTEN_VALID, GetColorById, HttpParamsRequestInstance, PATTERN_ACCOUNT, PATTERN_DOMAIN, PATTERN_EMAIL, PATTERN_EMOJI, PATTERN_ENCODE_URI, PATTERN_GET_FIELD_BY_RULE_FIELD_REPLACE, PATTERN_HOST_URL, PATTERN_KEY, PATTERN_MOBILE_PHONE, PATTERN_NAME, PATTERN_NAME_PROFILE, PATTERN_NAME_SPECIAL, PATTERN_NAME_UTF8, PATTERN_NUMBER, PATTERN_PEM, PATTERN_PHONE, PATTERN_PHONE_NORMAL, PATTERN_RULE_FIELD_REPLACE, PATTERN_TAX, PATTERN_URL, UtilsCache, UtilsCommunicateMicro, UtilsHttpParamsRequest, UtilsKeyCodeConstant, UtilsLanguageConstants, UtilsUrlSearchParams, checkMouseOverInContainer, checkViewInScreen, cloneDeep, cloneIBoundingClientRect, colorContrastFromOrigin, colorStepContrastFromOrigin, convertObjectToSignal, convertSignalToObject, decrypt, decrypt3rd, deleteUnicode, emojiPattern, encrypt, encrypt3rd, escapeHtml, formatNumber, generateInterface, get, getColorById, getKeyCacheByArrayObject, getPlatFromBrowser, getViewport, groupBy, isEmbedFrame, isEmpty, isEqual, isNil, keyBy, listColorDefine$1 as listColorDefine, md5, range, removeEmoji, rgbToHex, set, setCaretPosition, setKeyCrypto, setKeyCrypto3rd, setStyles, uniqBy, updateFunctionCheckEmbedFrame, uuid, viewDataNumberByLanguage };
+export { AudioExtList, CHARACTER_DATA_EMPTY, COMMUNICATE_MICRO_KEY_GET_ALL_MESSAGE, COMMUNICATE_MICRO_PREFIX_TYPE, DEFAULT_START_PAGE_0, DocumentExtList, ENCODE_URI_PATTERN, ERROR_MESSAGE_EMPTY_VALID, ERROR_MESSAGE_MAX_LENGTH, ERROR_MESSAGE_MAX_VALID, ERROR_MESSAGE_MIN_LENGTH, ERROR_MESSAGE_MIN_VALID, ERROR_MESSAGE_PATTEN_VALID, ExcelExtList, ImageExtList, LINK_IMAGE_ERROR_TOKEN_INJECT, PROCESS_BAR_STANDARD_CONFIG_DEFAULT_TOKEN_INJECT, PROCESS_BAR_STEPS_CONFIG_DEFAULT_TOKEN_INJECT, UtilsCache, UtilsCommunicateMicro, UtilsCommunicateMicroKeyGlobal, UtilsHttpParamsRequest, UtilsHttpParamsRequestInstance, UtilsKeyCodeConstant, UtilsLanguageConstants, UtilsUrlSearchParams, VideoExtList, base64Decode, base64Encode, capitalize, checkMouseOverInContainer, checkViewInScreen, cloneDeep, cloneIBoundingClientRect, colorContrastFromOrigin, colorStepContrastFromOrigin, convertBase64ToBlob, convertBlobToFile, convertFileToBase64, convertFileToBase64_ObjectUrl, convertHtmlToDivBlocks, convertObjectToSignal, convertSignalToObject, convertUrlToFile, createUniqueRandomIntGenerator, decodeEscapeHtml, decodeURI, decrypt, decrypt3rd, deleteUnicode, downloadFileByUrl, downloadFileByUrlUseXmlRequest, downloadImageFromELement, encodeURI, encrypt, encrypt3rd, endCodeUrl, escapeHtml, firstLetterToUpperCase, formatDate, formatNumber, formatTextCompare, fullNameFormat, generateInterface, get, getColorById, getDayjs, getDeltaFromHTML, getDeviceInfo, getDocumentByString, getDragEventByElement, getEventNameHandleClick, getFileExtension, getHTMLFromQuill, getKeyCacheByArrayObject, getLabelBySizeFile, getPlatFromBrowser, getSmartAxisScale, getViewport, groupBy, highlightByKeyword, insertContentWithRange, isDifferenceDay, isDifferenceMonth, isDifferenceYear, isEmbedFrame, isEmpty, isEqual, isIncludeAudioExtList, isIncludeDocumentExtList, isIncludeImageExtList, isIncludeVideoExtList, isNil, isTypeAudio, isTypeFile, isTypeImage, isTypeVideo, keyBy, listColorDefine, md5, omitBy, patternAccount, patternDomain, patternEmail, patternEmoji, patternEncodeUri, patternGetFieldByRuleFieldReplace, patternHostUrl, patternKey, patternMobilePhone, patternName, patternNameProfile, patternNameSpecial, patternNameUtf8, patternNumber, patternPem, patternPhone, patternPhoneNormal, patternRuleFieldReplace, patternTax, patternUrl, processPasteData, protectString, range, removeEmoji, revealString, rgbToHex, set, setCaretPosition, setDefaultTimeZone, setKeyCrypto, setKeyCrypto3rd, setStylesElement, uniqBy, updateFunctionCheckEmbedFrame, updateFunctionFormatDate, updateFunctionXssFilter, uppercaseByPosition, uuid, viewDataNumberByLanguage, xssFilter };
 //# sourceMappingURL=libs-ui-utils.mjs.map