@libs-ui/utils 0.1.1-1

package/fesm2022/libs-ui-utils.mjs

@@ -0,0 +1,3234 @@
+import DeviceDetector from 'device-detector-js';
+import Quill from 'quill';
+import { Observable, Subject, fromEvent, takeUntil, filter, tap, mergeMap, startWith, finalize, lastValueFrom, timer } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { TemplateRef, ElementRef, isSignal, 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';
+import CryptoES from 'crypto-es';
+
+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 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 CHARACTER_DATA_EMPTY;
+    }
+    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 (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;
+    }
+    return text.replace(patternEmoji(), '');
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Danh sách các constructor name nguy hiểm
+ */
+const DANGEROUS_CONSTRUCTOR_NAMES = ['Window', 'Document', 'HTMLDocument', 'HTMLElement', 'Element', 'Node', 'Location', 'Navigator', 'Screen', 'History', 'Storage', 'Console', 'Performance'];
+/**
+ * Kiểm tra xem đối tượng có phải là browser global object không
+ */
+const isBrowserGlobalObject = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return obj instanceof Window || obj instanceof Document || obj === window || obj === document || obj === globalThis;
+};
+/**
+ * Kiểm tra xem đối tượng có phải là DOM object không
+ */
+const isDOMObject = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return obj instanceof HTMLElement || obj instanceof Node || obj instanceof Element;
+};
+/**
+ * Kiểm tra xem đối tượng có phải là browser API object không
+ */
+const isBrowserAPIObject = (obj) => {
+    if (obj === null || typeof obj !== 'object' || typeof window === 'undefined') {
+        return false;
+    }
+    return obj === window.location || obj === window.navigator || obj === window.screen || obj === window.history || obj === window.localStorage || obj === window.sessionStorage || obj === window.console || obj === window.performance;
+};
+/**
+ * Kiểm tra constructor name có nằm trong danh sách nguy hiểm không
+ */
+const hasDangerousConstructorName = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    const constructorName = obj.constructor?.name;
+    return constructorName && DANGEROUS_CONSTRUCTOR_NAMES.includes(constructorName);
+};
+/**
+ * Kiểm tra xem đối tượng có phải là DOM object hoặc browser object nguy hiểm không
+ * Những đối tượng này có thể gây ra circular reference và maximum call stack
+ */
+const isDangerousObject = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return isBrowserGlobalObject(obj) || isDOMObject(obj) || isBrowserAPIObject(obj) || hasDangerousConstructorName(obj);
+};
+/**
+ * Kiểm tra đối tượng có phải là Angular/Framework object không
+ */
+const isFrameworkObject = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return obj instanceof TemplateRef || obj instanceof ElementRef;
+};
+/**
+ * Kiểm tra đối tượng có phải là File/Blob object không
+ */
+const isFile = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return obj instanceof File || obj instanceof Blob || Object.prototype.toString.call(obj) === '[object File]';
+};
+/**
+ * Kiểm tra đối tượng có phải là Built-in object không
+ */
+const isBuiltInObject = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return obj instanceof Date || isRegExp(obj) || obj instanceof HttpParams || ('hasOwnProperty' in obj && '__ngContext__' in obj);
+};
+/**
+ * Kiểm tra đối tượng có phải là RegExp object không
+ */
+const isRegExp = (obj) => {
+    return obj instanceof RegExp;
+};
+/**
+ * Kiểm tra đối tượng có phải là Async object không
+ */
+const isAsyncObject = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return false;
+    }
+    return obj instanceof Promise || obj instanceof Observable;
+};
+/**
+ * Kiểm tra đối tượng có phải là Special object cần bỏ qua không
+ * Bao gồm: Framework objects, File objects, Built-in objects, Async objects
+ */
+const isSpecialObject = (obj) => {
+    return isFrameworkObject(obj) || isFile(obj) || isBuiltInObject(obj) || isAsyncObject(obj);
+};
+/**
+ * Kiểm tra đối tượng có phải là dayjs object không
+ */
+const isDayjsObject = (obj) => {
+    return dayjs.isDayjs(obj);
+};
+/**
+ * Kiểm tra đối tượng có phải là object cần bỏ qua trong quá trình convert không
+ */
+const isSkippableObject = (obj) => {
+    return isDangerousObject(obj) || isSpecialObject(obj);
+};
+/**
+ * Kiểm tra đối tượng có phải là Map object không
+ */
+const isMap = (obj) => {
+    return obj instanceof Map;
+};
+/**
+ * Kiểm tra đối tượng có phải là Set object không
+ */
+const isSet = (obj) => {
+    return obj instanceof Set;
+};
+/**
+ * Kiểm tra đối tượng có phải là Array object không
+ */
+const isArray = (obj) => {
+    return Array.isArray(obj);
+};
+/**
+ * Kiểm tra đối tượng có phải là object cần trả về nguyên trạng không
+ * Bao gồm: dangerous objects, special objects, dayjs objects
+ */
+const isReturnAsIsObject = (obj) => {
+    return isSkippableObject(obj) || isDayjsObject(obj);
+};
+/**
+ * Kiểm tra xem đối tượng có an toàn để clone/convert không
+ */
+const isSafeToProcess = (obj) => {
+    return !isDangerousObject(obj);
+};
+
+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();
+};
+
+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ự`);
+    }
+    key = value;
+};
+const keyStore = () => {
+    return key;
+};
+const encrypt3rd = (plainData) => {
+    if (!keyStore()) {
+        throw Error('lỗi chưa setup key mã hóa');
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore());
+    const iv = CryptoES.enc.Hex.parse(keyStore());
+    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 decrypt3rd = (encryptedData) => {
+    if (!keyStore()) {
+        throw Error('lỗi chưa setup key mã hóa');
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore());
+    const iv = CryptoES.enc.Hex.parse(keyStore());
+    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);
+};
+
+let functionCheck = () => {
+    return window.parent !== window.top;
+};
+const updateFunctionCheckEmbedFrame = (functionCustom) => {
+    functionCheck = functionCustom;
+};
+const isEmbedFrame = () => {
+    return functionCheck();
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class UtilsCommunicateMicroKeyGlobal {
+    static KEY_MESSAGE_MODAL = 'LIBS_UI_MODEL_EVENT';
+}
+class UtilsCommunicateMicro {
+    static initdEvent;
+    static subs = new Map();
+    static allMessageSub = new Subject();
+    static initEvent(currentWindow, onDestroy) {
+        if (this.initdEvent) {
+            return;
+        }
+        this.initdEvent = true;
+        if (!this.subs.get(COMMUNICATE_MICRO_KEY_GET_ALL_MESSAGE)) {
+            this.subs.set(COMMUNICATE_MICRO_KEY_GET_ALL_MESSAGE, UtilsCommunicateMicro.allMessageSub);
+        }
+        fromEvent(currentWindow, 'message')
+            .pipe(takeUntil(onDestroy))
+            .subscribe((e) => {
+            const event = { data: { ...e.data } };
+            const data = event.data;
+            const type = data.type;
+            if (!type) {
+                return this.allMessageSub.next(event);
+            }
+            const sub = UtilsCommunicateMicro.GetMessage(type);
+            if (!type || !data.response) {
+                return;
+            }
+            try {
+                if (type.includes(COMMUNICATE_MICRO_PREFIX_TYPE)) {
+                    data.response = JSON.parse(decrypt3rd(data.response));
+                    sub.next(event);
+                    this.allMessageSub.next(event);
+                    return;
+                }
+                data.response = JSON.parse(decrypt(data.response));
+                sub.next(event);
+                this.allMessageSub.next(event);
+            }
+            catch (error) {
+                console.log(error);
+                sub.next(event);
+                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);
+        try {
+            if (isEmbedFrame()) {
+                window?.parent?.postMessage(data, '*');
+                return;
+            }
+            window?.top?.postMessage(data, '*');
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    static PostMessageToChildren(data) {
+        data = this.convertData(data);
+        const iframes = document.querySelectorAll('iframe');
+        Array.from(iframes).forEach((iframe) => {
+            iframe?.contentWindow?.postMessage(data, '*');
+        });
+    }
+    static PostMessageToOpener(data) {
+        if (!window.opener) {
+            return;
+        }
+        data = this.convertData(data);
+        window.opener.postMessage(data, '*');
+    }
+    static convertData(data) {
+        if (!data || !data.type || !data.response) {
+            return data;
+        }
+        data = { ...data };
+        const type = data.type;
+        if (type.includes(COMMUNICATE_MICRO_PREFIX_TYPE)) {
+            try {
+                JSON.parse(decrypt3rd(data.response));
+                return data;
+            }
+            catch (_) {
+                data.response = encrypt3rd(JSON.stringify(data.response));
+                return data;
+            }
+        }
+        try {
+            JSON.parse(decrypt(data.response));
+            return data;
+        }
+        catch (_) {
+            data.response = encrypt(JSON.stringify(data.response));
+            return data;
+        }
+    }
+    static GetMessage(messageType) {
+        if (!this.initdEvent) {
+            throw Error('chưa khơi tạo hàm lắng nghe sự kiện, gọi UtilsCommunicateMicro.initEvent(window) tại root component');
+        }
+        if (typeof messageType === 'string') {
+            let sub = this.subs.get(messageType);
+            if (!sub) {
+                sub = new Subject();
+                this.subs.set(messageType, sub);
+                return sub;
+            }
+            return sub;
+        }
+        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) {
+            return sub;
+        }
+        sub = new Subject();
+        this.subs.set(types, sub);
+        this.initSubject(sub, messageType);
+        return sub;
+    }
+    static initSubject(subRoot, messageType) {
+        messageType.forEach((key) => {
+            this.GetMessage(key).subscribe((e) => {
+                subRoot.next(e);
+            });
+        });
+    }
+}
+
+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);
+    }
+}
+
+const uuid = () => {
+    const timestamp = performance.now() * 1000;
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?/~';
+    let randomString = '';
+    for (let i = 0; i < 5; i++) {
+        randomString += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    const baseString = `${Math.floor(timestamp)}-${randomString}`;
+    const charArray = baseString.split('');
+    for (let i = charArray.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [charArray[i], charArray[j]] = [charArray[j], charArray[i]];
+    }
+    const shuffledString = charArray.join('');
+    return md5(shuffledString);
+};
+
+/* 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 languageKeyCache = 'SR3xQKxHgffiCevPQRralg';
+    static listKeyKeepWhenClearALll = Array();
+    static initdEvent;
+    static storage;
+    static dbName = 'libs-ui-cache';
+    static itemIndexByKey = 'key';
+    static dbVersion = 1;
+    static db = null;
+    static init(config) {
+        if (this.initdEvent) {
+            return;
+        }
+        this.initdEvent = true;
+        if (config.indexedDBName) {
+            this.dbName = config.indexedDBName;
+        }
+        if (config.typeKeyClearLocalStorage) {
+            this.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;
+        }
+        if (config.listKeyKeepWhenClearAll) {
+            this.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearAll;
+        }
+        if (config.languageKeyCache) {
+            this.languageKeyCache = config.languageKeyCache;
+        }
+    }
+    static setLang(lang) {
+        if (!UtilsLanguageConstants.isSupported(lang)) {
+            throw Error(`Language not support ${lang}`);
+        }
+        this.Set(this.languageKeyCache, lang, this.CACHE_EXPIRE_NONE);
+    }
+    static getLang() {
+        return this.Get(this.languageKeyCache, UtilsLanguageConstants.defaultLang);
+    }
+    static openDB() {
+        return new Promise((resolve) => {
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                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 = () => {
+                this.db = request.result;
+                resolve(true);
+            };
+            request.onerror = (event) => {
+                console.trace('Error opening IndexedDB:', event);
+                resolve(false);
+            };
+        });
+    }
+    static async getObjectStore() {
+        if (!this.db) {
+            await this.openDB();
+        }
+        const transaction = this.db?.transaction([this.dbName], 'readwrite');
+        if (!transaction) {
+            return null;
+        }
+        return transaction.objectStore(this.dbName);
+    }
+    static get LocalStorage() {
+        try {
+            if (typeof window.localStorage !== 'undefined') {
+                const OS = getPlatFromBrowser();
+                if (OS.includes('Safari') && parseFloat(OS.split(' ').pop() || '0') >= 16) {
+                    return this.getLocalStorageFakeOnSafari();
+                }
+                return localStorage;
+            }
+            return this.getLocalStorageFake();
+        }
+        catch (error) {
+            console.trace(`LocalStorage `, error);
+            return this.getLocalStorageFake();
+        }
+    }
+    static getLocalStorageFakeOnSafari() {
+        if (typeof window.localStorage !== 'undefined' && !this.storage && Object.keys(localStorage).length) {
+            this.storage = { ...localStorage };
+        }
+        return {
+            setItem: (key, value) => {
+                localStorage.setItem(key, value);
+                this.storage[key] = value;
+            },
+            getItem: (key) => {
+                const value = localStorage.getItem(key);
+                if (value) {
+                    return value;
+                }
+                if (!this.storage || isNil(this.storage[key])) {
+                    return null;
+                }
+                localStorage.setItem(key, this.storage[key]);
+                return this.storage?.[key];
+            },
+            removeItem: (key) => {
+                delete this.storage?.[key];
+                localStorage.removeItem(key);
+            },
+            clear: () => {
+                this.storage = {};
+                localStorage.clear();
+            },
+        };
+    }
+    static getLocalStorageFake() {
+        if (!this.storage) {
+            this.storage = {};
+        }
+        return {
+            setItem: (key, value) => {
+                this.storage[key] = value;
+            },
+            getItem: (key) => {
+                return this.storage?.[key];
+            },
+            removeItem: (key) => {
+                delete this.storage?.[key];
+            },
+            clear: () => {
+                this.storage = {};
+            },
+        };
+    }
+    static async GetAsync(key, default_value, isKeyMD5 = false) {
+        key = isKeyMD5 ? key : md5(key);
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve(default_value);
+            }
+            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 === this.CACHE_EXPIRE_NONE) {
+                    return resolve(data.json);
+                }
+                const currentMillisecond = new Date().valueOf() / 1000;
+                if (data.expire < currentMillisecond) {
+                    return resolve(default_value);
+                }
+                return resolve(data.json);
+            };
+            request.onerror = () => {
+                console.trace(`Get key ${key} Error, return default value: ${default_value}`);
+                return resolve(default_value);
+            };
+        });
+    }
+    static Get(key, default_value) {
+        // support cho những file không thể inject UtilsCache
+        if (!key) {
+            return this.GetDefaultValueBySpecificKey(key, default_value);
+        }
+        const cachedData = this.LocalStorage.getItem(key);
+        if (!cachedData) {
+            return this.GetDefaultValueBySpecificKey(key, default_value);
+        }
+        try {
+            const data = JSON.parse(decrypt(cachedData));
+            if (data.expire === this.CACHE_EXPIRE_NONE) {
+                return data.value ?? default_value;
+            }
+            const currentMillisecond = new Date().valueOf() / 1000;
+            if (data.expire < currentMillisecond) {
+                return this.GetDefaultValueBySpecificKey(key, default_value);
+            }
+            return data.value;
+        }
+        catch (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 = this.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) {
+        // support inject UtilsCache
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            key = isKeyMD5 ? key : md5(key);
+            try {
+                const currentMillisecond = expireTimeBySecond === this.CACHE_EXPIRE_NONE ? this.CACHE_EXPIRE_NONE : new Date().valueOf() / 1000 + expireTimeBySecond;
+                const data = {
+                    value: encrypt(JSON.stringify({ json: value, expire: currentMillisecond })),
+                };
+                data[this.itemIndexByKey] = key;
+                if (!objectStore) {
+                    console.trace(`Can not open object store`);
+                    return resolve({ key, messageError: 'Can not open object store' });
+                }
+                const request = objectStore?.put(data);
+                request.onsuccess = () => {
+                    console.log(`Set key ${key} Success`);
+                    resolve(request.result);
+                };
+                request.onerror = (error) => {
+                    console.trace(`Set key ${key} Error`);
+                    resolve({ key, messageError: get(error, 'message') });
+                };
+            }
+            catch (error) {
+                console.trace(`Set key ${key} Error`);
+                resolve({ key, messageError: get(error, 'message') });
+            }
+        });
+    }
+    static Set(key, value, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT) {
+        // support cho những file không inject UtilsCache
+        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.trace(`Set key ${key} Error`, error);
+            return false;
+        }
+    }
+    static async ClearAsync(key, isMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve();
+            }
+            const request = objectStore.delete(isMD5 ? key : md5(key));
+            request.onsuccess = () => {
+                resolve({ clearSuccess: true });
+            };
+            request.onerror = (event) => {
+                console.trace('Error deleting Key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
+            };
+        });
+    }
+    static Clear(key) {
+        if (key.includes('kc-callback-')) {
+            return;
+        }
+        this.LocalStorage.removeItem(key);
+    }
+    static ClearAllAsync() {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve();
+            }
+            const request = objectStore.clear();
+            request.onsuccess = () => {
+                console.log('clear all successfully');
+                resolve({ clearSuccess: true });
+            };
+            request.onerror = (event) => {
+                console.trace('Error deleting key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
+            };
+        });
+    }
+    static ClearAll() {
+        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 = this.GetDataByKeys(Array.from(keys));
+        this.LocalStorage.clear();
+        this.SetDataByKey(stores);
+    }
+    static GetDataByKeys(keys) {
+        const stores = new Map();
+        keys.forEach((key) => {
+            if (key.includes('kc-callback-')) {
+                stores.set(key, this.LocalStorage.getItem(key));
+                return;
+            }
+            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);
+                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) => {
+    // helper cast để tránh lặp lại kiểu điều kiện ở các return
+    const out = (v) => v;
+    if (!config) {
+        return out(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 out(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 out(dayjs(date, formatOfDate).utc());
+        }
+        const dateInputIsUTC = (dayjs.isDayjs(date) && date.isUTC()) || (typeof date === 'string' && date.includes('Z'));
+        if (dateInputIsUTC) {
+            return out(dayjs(date));
+        }
+        return out(dayjs(date).utc());
+    }
+    if (typeof date === 'string' && !date.includes('Z') && !date.includes('+')) {
+        return out(formatOfDate ? dayjs.tz(date, formatOfDate, config.localeZone || timeZoneSetup) : dayjs.tz(date, config.localeZone || timeZoneSetup));
+    }
+    return out((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 */
+const UtilsHttpParamsRequestInstance = (options, instance) => {
+    return new UtilsHttpParamsRequest(options, instance);
+};
+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;
+        }
+    }
+    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();
+    }
+}
+// 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',
+// };
+
+/* 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 (isArray(data)) {
+        seen.set(data, signal(data.map((item) => convertObjectToSignal(item, cloneDeepIfNotSignal, isSignalPrimitiveType, acceptConvertObjectInnerWritableSignal, seen))));
+        return seen.get(data);
+    }
+    if (isMap(data)) {
+        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);
+    }
+    // Bỏ qua các đối tượng async
+    if (isAsyncObject(data)) {
+        return data;
+    }
+    data = signal(cloneDeepIfNotSignal ? { ...data } : data);
+    seen.set(data, data);
+    for (const key in data()) {
+        const value = data()[key];
+        // Bỏ qua các đối tượng nguy hiểm và đặc biệt
+        if (isReturnAsIsObject(value)) {
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(data(), key)) {
+            data()[key] = convertObjectToSignal(value, cloneDeepIfNotSignal, isSignalPrimitiveType, acceptConvertObjectInnerWritableSignal);
+        }
+    }
+    return data;
+};
+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 || isReturnAsIsObject(dataConvert)) {
+                return dataConvert;
+            }
+            seen.set(dataConvert, dataConvert);
+            data = dataConvert;
+            ignoreCheckSeenHasDataAfterWhile = true;
+            break;
+        }
+        seen.set(data, dataConvert);
+        data = dataConvert;
+    }
+    if (data === null || typeof data === 'function' || typeof data !== 'object' || isReturnAsIsObject(data)) {
+        return data;
+    }
+    if (!ignoreCheckSeenHasDataAfterWhile && seen.has(data)) {
+        return seen.get(data);
+    }
+    if (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 (isMap(data)) {
+        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 (isSet(data)) {
+        const setCopy = new Set();
+        Array.from(data.values()).forEach((value) => {
+            setCopy.add(convertSignalToObject(isCloneDeep ? cloneDeep(value) : value, isCloneDeep));
+        });
+        seen.set(data, setCopy);
+        return seen.get(data);
+    }
+    // Bỏ qua các đối tượng nguy hiểm và đặc biệt
+    if (isReturnAsIsObject(data)) {
+        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)) {
+            // Bỏ qua các đối tượng nguy hiểm để tránh maximum call stack
+            if (isReturnAsIsObject(value)) {
+                result[key] = value;
+                continue;
+            }
+            result[key] = convertSignalToObject(isCloneDeep ? cloneDeep(value) : value, isCloneDeep);
+        }
+    }
+    return result;
+};
+const unwrapSignal = (data) => {
+    while (isSignal(data)) {
+        data = data();
+    }
+    return data;
+};
+
+/* 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, options) => {
+    if (!options?.ignoreUnWrapSignal) {
+        value = unwrapSignal(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, options) => {
+    if (!options?.ignoreUnWrapSignal) {
+        value = unwrapSignal(value);
+    }
+    if (options?.ignoreCheckString && value === '') {
+        return false;
+    }
+    if (options?.ignoreCheckTypePrimitive) {
+        return typeof value === 'object' && isEmptyTypeObject(value);
+    }
+    return isEmptyTypeObject(value);
+};
+/**
+ * Kiểm tra xem một giá trị có phải là object rỗng hay không
+ * @param value Giá trị cần kiểm tra
+ * @returns true nếu giá trị là object rỗng, false nếu không
+ * @example
+ * isEmptyTypeObject({}); // true
+ * isEmptyTypeObject({ a: 1 }); // false
+ */
+const isEmptyTypeObject = (value) => {
+    try {
+        if (isNil(value, { ignoreUnWrapSignal: true }) || value === '') {
+            return true;
+        }
+        if (typeof value !== 'object') {
+            return false;
+        }
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        return Object.keys(value).length === 0;
+    }
+    catch (error) {
+        console.error(error);
+        return false;
+    }
+};
+/**
+ * Kiểm tra xem một giá trị có phải là null, rỗng, undefined hoặc 0 hay không
+ * @param value Giá trị cần kiểm tra
+ * @param options Cấu hình tùy chọn
+ * @param options.ignoreZero Nếu true, sẽ không kiểm tra giá trị 0
+ * @returns true nếu giá trị là null, rỗng, undefined hoặc 0, false nếu không
+ * @example
+ * isTruthy(null); // false
+ * isTruthy(''); // false
+ * isTruthy(undefined); // false
+ * isTruthy(0); // false
+ * isTruthy({}); // true
+ * isTruthy(0, { ignoreZero: true }); // true
+ */
+const isTruthy = (value, options) => {
+    return !isFalsy(value, options);
+};
+/**
+ * Kiểm tra xem một giá trị có phải là null, rỗng, undefined hoặc 0 hay không
+ * @param value Giá trị cần kiểm tra
+ * @param options Cấu hình tùy chọn
+ * @param options.ignoreZero Nếu true, sẽ không kiểm tra giá trị 0
+ * @returns true nếu giá trị là null, rỗng, undefined hoặc 0, false nếu không
+ * @example
+ * isFalsy(null); // true
+ * isFalsy(''); // true
+ * isFalsy(undefined); // true
+ * isFalsy(0); // true
+ * isFalsy({}); // false
+ * isFalsy(0, { ignoreZero: true }); // false
+ */
+const isFalsy = (value, options) => {
+    if (!options?.ignoreUnWrapSignal) {
+        value = unwrapSignal(value);
+    }
+    if (options?.ignoreZero && value === 0) {
+        return false;
+    }
+    if (options?.ignoreCheckString && value === '') {
+        return false;
+    }
+    return !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) => {
+    // helper cast để tránh lặp lại kiểu điều kiện ở các return
+    const out = (v) => v;
+    if (isNil(obj)) {
+        return out(defaultValue);
+    }
+    obj = unwrapSignal(obj);
+    if (path === '') {
+        return out(obj);
+    }
+    if (obj instanceof HttpParams) {
+        return out(obj.get(`${path}`) ?? defaultValue);
+    }
+    if (obj instanceof DOMRect) {
+        return out(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 out(defaultValue);
+        }
+        const val = isSignal(obj[key]) && !keepLastValueIfSignal ? obj[key]() : obj[key];
+        obj = val;
+    }
+    return out(obj ?? defaultValue);
+};
+/**
+ * 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, options) => {
+    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');
+                if (isNil(currentObjectByKey[key])) {
+                    currentObjectByKey[key] = /\[(\d+)]/g.test(nextKey) ? (options?.valueDefaultPathArrayUndefined ?? []) : (options?.valueDefaultPathObjectUndefined ?? {});
+                }
+            }
+            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)) || isDangerousObject(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 (isDayjsObject(data)) {
+        return getDayjs({ date: data.valueOf() });
+    }
+    if (isRegExp(data)) {
+        return new RegExp(data.source, data.flags);
+    }
+    if (isMap(data)) {
+        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 (isSet(data)) {
+        const setCopy = new Set();
+        seen.set(data, setCopy);
+        data.forEach((val) => {
+            setCopy.add(cloneDeep(val, options, seen));
+        });
+        return setCopy;
+    }
+    if (isArray(data)) {
+        seen.set(data, data.map((item) => cloneDeep(item, options, seen)));
+        return seen.get(data);
+    }
+    if (isReturnAsIsObject(data)) {
+        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 (value instanceof Date) {
+            result[key] = new Date(value.getTime());
+            continue;
+        }
+        if (dayjs.isDayjs(value)) {
+            result[key] = getDayjs({ date: value.valueOf() });
+            continue;
+        }
+        if (isRegExp(data)) {
+            result[key] = new RegExp(value.source, value.flags);
+            continue;
+        }
+        if (isReturnAsIsObject(data)) {
+            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) => {
+    // Handle signals
+    if (!options?.ignoreUnWrapSignal) {
+        value1 = unwrapSignal(value1);
+        value2 = unwrapSignal(value2);
+    }
+    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}`);
+    }
+    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) || Array.isArray(value2)) {
+        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 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 nameEventHandleClick;
+})();
+const getDocumentByString = (htmlStr) => {
+    return parser.parseFromString(htmlStr, 'text/html');
+};
+const cloneIBoundingClientRect = (rect) => {
+    return {
+        top: rect['top'],
+        left: rect['left'],
+        width: rect['width'],
+        height: rect['height'],
+        bottom: rect['bottom'],
+    };
+};
+const setStylesElement = (el, styles) => {
+    Object.keys(styles).forEach((key) => set(el, `style.${key}`, styles[key]));
+};
+const getViewport = (win = window) => {
+    const doc = win.document.documentElement, body = win.document.getElementsByTagName('body')[0], w = win.innerWidth || doc.clientWidth || body.clientWidth, h = win.innerHeight || doc.clientHeight || body.clientHeight;
+    return { width: w, height: h };
+};
+const setCaretPosition = (element, position) => {
+    if (!element || !element.setSelectionRange) {
+        return;
+    }
+    element.focus();
+    element.setSelectionRange(position, position);
+};
+const checkViewInScreen = (container, element, elementScroll, maxTopLeft) => {
+    if (!container || !element) {
+        return false;
+    }
+    const rectContainer = cloneIBoundingClientRect(container.getBoundingClientRect());
+    if (elementScroll) {
+        const rectElementScroll = elementScroll.getBoundingClientRect();
+        rectContainer['left'] = rectElementScroll.left;
+        rectContainer['top'] = rectElementScroll.top;
+    }
+    const rectElement = element.getBoundingClientRect();
+    const { left, top } = rectElement;
+    const topContainer = rectContainer['top'];
+    const leftContainer = rectContainer['left'];
+    const widthContainer = rectContainer['width'];
+    const heightContainer = rectContainer['height'];
+    const scrollTopContainer = container.scrollTop;
+    const scrollLeftContainer = container.scrollLeft;
+    const limitTop = topContainer + scrollTopContainer + heightContainer;
+    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) {
+        return true;
+    }
+    return false;
+};
+const checkMouseOverInContainer = (mousePosition, element, rect) => {
+    if (!element && !rect) {
+        return false;
+    }
+    const rectElement = rect || element?.getBoundingClientRect() || {};
+    const { left, top, width, height } = rectElement;
+    const limitLeft = left + width;
+    const limitTop = top + height;
+    const { clientX, clientY } = mousePosition;
+    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;
+    params;
+    constructor(paramString) {
+        this.params = new Array();
+        this.params.length = 0;
+        this.params.push(...this.buildParams(paramString));
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new UtilsUrlSearchParams('');
+        }
+        return this.instance;
+    }
+    static toStringParamObject(params) {
+        const paramsArr = Object.keys(params).map((key) => {
+            return {
+                key,
+                value: params[key],
+            };
+        });
+        return UtilsUrlSearchParams.ToString(paramsArr);
+    }
+    static ToString(params) {
+        let paramsStr = '';
+        params
+            .sort((item1, item2) => item1.key.localeCompare(item2.key))
+            .forEach((item) => {
+            const { key, value } = item;
+            paramsStr = `${paramsStr}${paramsStr ? '&' : ''}${key}=${value}`;
+        });
+        return paramsStr;
+    }
+    buildParams(paramString) {
+        const paramsBuild = new Array();
+        if (!paramString) {
+            return paramsBuild;
+        }
+        const paramsError = paramString.split('?');
+        if (paramsError.length > 2) {
+            paramString = `${paramsError[0]}?${paramsError[1]}&${paramsError.slice(2).join('&')}`;
+        }
+        const params = paramString.replace(/\S+[?]/g, '').split('&');
+        if (params) {
+            params.forEach((param) => {
+                if (param.indexOf('=') < 0) {
+                    return;
+                }
+                let [key, value] = param.split('=');
+                key = key.replace(/[?&]+/g, '');
+                value = decodeURIComponent(value.replace(/\+/g, ' '));
+                if (!paramsBuild.some((param) => param.key === key)) {
+                    paramsBuild.push({ key, value });
+                }
+            });
+        }
+        return paramsBuild;
+    }
+    set(key, value) {
+        const paramByKey = this.params.find((param) => param.key === key);
+        if (!paramByKey) {
+            this.params.push({ key, value: decodeURIComponent(value.replace(/\+/g, ' ')) });
+            return;
+        }
+        paramByKey['value'] = value;
+    }
+    get(key) {
+        return this.params.find((param) => param.key === key)?.value;
+    }
+    has(key) {
+        return this.params.some((param) => param.key === key);
+    }
+    delete(key) {
+        const index = this.params.findIndex((param) => param.key === key);
+        if (index >= 0) {
+            this.params.splice(index, 1);
+        }
+    }
+    length() {
+        return this.params.length;
+    }
+    toString(params) {
+        params = params || this.params;
+        return UtilsUrlSearchParams.ToString(params);
+    }
+    getParamObject() {
+        const params = {};
+        this.params.forEach((item) => {
+            params[item.key] = item.value;
+        });
+        return params;
+    }
+    compareParams(param1, param2) {
+        const params1 = this.toString(this.buildParams(param1));
+        const params2 = this.toString(this.buildParams(param2));
+        return params1 === params2;
+    }
+}
+
+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;
+    static BUFFERED = 229;
+}
+
+/* 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;
+            }
+            const keys = (item instanceof HttpParams ? item.keys() : Object.keys(item)).sort((str1, str2) => str1.localeCompare(str2));
+            keys.forEach((key) => {
+                if (key.toLocaleLowerCase() === 'pem') {
+                    return;
+                }
+                keyBuild = `${keyBuild}${JSON.stringify(get(item, key))}`;
+            });
+            return;
+        }
+        keyBuild = `${keyBuild}${item}`;
+    });
+    const keyCachePlus = md5(keyBuild);
+    const keyCacheMD5 = md5(keyCache);
+    return `${keyCacheMD5}-${md5(`${keyCacheMD5}-${keyCachePlus}`)}`;
+};
+
+const formatNumber = (value) => {
+    const lang = UtilsCache.getLang();
+    if (lang === UtilsLanguageConstants.EN) {
+        return `${value}`.replace(/[,]/g, '');
+    }
+    return `${value}`.replace(/[.]/g, '').replace(/[,]/g, '.');
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const viewDataNumberByLanguage = (value, acceptNegativeValue, parseFixed = 1, ignoreFormatSeparator = false, ignoreParseFloat = false) => {
+    const lang = UtilsCache.getLang();
+    if (!`${value}`.trim()) {
+        return '';
+    }
+    if (isNil(value) || (!acceptNegativeValue && +value <= 0)) {
+        return 0;
+    }
+    if (typeof value === 'string' && !ignoreFormatSeparator) {
+        value = formatNumber(value);
+    }
+    const isFloat = value.toString().includes('.');
+    const [intStr, floatStr] = value.toString().split('.');
+    if (!floatStr?.length) {
+        parseFixed = 0;
+    }
+    const round = (value, parseFixed) => {
+        const fixed = Math.pow(10, parseFixed);
+        return Math.round(value * fixed) / fixed;
+    };
+    if (parseFixed > (floatStr?.length || 0)) {
+        const maxParseFixed = acceptNegativeValue && +value < 0 ? 17 : 16;
+        const fixed = maxParseFixed - (intStr?.length || 0);
+        parseFixed = parseFixed < fixed ? parseFixed : fixed;
+    }
+    if (isFloat && !ignoreParseFloat) {
+        value = parseFloat(round(+value, parseFixed).toFixed(parseFixed));
+    }
+    // Xử lý không format dữ liệu phần thập phân
+    const valueString = value.toString();
+    const index = valueString.indexOf('.');
+    if (index !== -1 && (parseFixed > 3 || ignoreParseFloat)) {
+        let decimalPart = valueString.substring(index + 1, valueString.length);
+        let int = valueString.substring(0, index + 1);
+        if (ignoreParseFloat) {
+            decimalPart = decimalPart.substring(0, parseFixed);
+        }
+        if (lang === UtilsLanguageConstants.EN) {
+            int = int.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+            return `${int}${decimalPart}`;
+        }
+        int = int.replace('.', ',').replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+        return `${int}${decimalPart}`;
+    }
+    if (index === -1 || parseFixed <= 3) {
+        if (lang === UtilsLanguageConstants.EN) {
+            return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+        }
+        return value
+            .toString()
+            .replace('.', ',')
+            .replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+    }
+};
+
+let functionXssFilter = async (value) => {
+    return value;
+};
+const updateFunctionXssFilter = (functionCustom) => {
+    functionXssFilter = functionCustom;
+};
+const xssFilter = async (data) => {
+    return await functionXssFilter(data);
+};
+
+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 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 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 downloadFileByUrlUseXmlRequest = (fileUrl, filename) => {
+    const xmlRequest = new XMLHttpRequest();
+    xmlRequest.open('GET', fileUrl, true);
+    xmlRequest.responseType = 'blob';
+    xmlRequest.onerror = () => {
+        const url = window.URL.createObjectURL(xmlRequest.response);
+        downloadFileByUrl(url, filename);
+    };
+    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 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 getLabelBySizeFile = (size, toFixed = 2) => {
+    if (size < 1024 * 1024) {
+        return ` ${(size / 1024).toFixed(toFixed)} KB`;
+    }
+    return ` ${(size / (1024 * 1024)).toFixed(toFixed)} MB`;
+};
+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 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 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,
+    };
+};
+// 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;
+};
+/**
+ * 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);
+    }
+};
+/**
+ * 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 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 { 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, hasDangerousConstructorName, highlightByKeyword, insertContentWithRange, isArray, isAsyncObject, isBrowserAPIObject, isBrowserGlobalObject, isBuiltInObject, isDOMObject, isDangerousObject, isDayjsObject, isDifferenceDay, isDifferenceMonth, isDifferenceYear, isEmbedFrame, isEmpty, isEqual, isFalsy, isFile, isFrameworkObject, isIncludeAudioExtList, isIncludeDocumentExtList, isIncludeImageExtList, isIncludeVideoExtList, isMap, isNil, isRegExp, isReturnAsIsObject, isSafeToProcess, isSet, isSkippableObject, isSpecialObject, isTruthy, 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, unwrapSignal, updateFunctionCheckEmbedFrame, updateFunctionFormatDate, updateFunctionXssFilter, uppercaseByPosition, uuid, viewDataNumberByLanguage, xssFilter };
+//# sourceMappingURL=libs-ui-utils.mjs.map