@jvsoft/utils 0.0.13-alpha.4 → 0.0.13-alpha.6

package/fesm2022/jvsoft-utils.mjs

@@ -0,0 +1,1867 @@
+import { Validators, FormGroup, FormControl, FormArray } from '@angular/forms';
+import { untilDestroyed } from '@ngneat/until-destroy';
+import { startWith, debounceTime, tap, isObservable, switchMap, of, finalize } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Buffer } from 'buffer';
+import CryptoJS from 'crypto-js';
+import { formatDate } from '@angular/common';
+import { saveAs } from 'file-saver';
+import { ReactiveFormConfig } from '@rxweb/reactive-form-validators';
+import moment from 'moment';
+import swal from 'sweetalert2';
+import { jwtDecode } from 'jwt-decode';
+import * as i0 from '@angular/core';
+import { Pipe } from '@angular/core';
+import * as i1 from '@angular/platform-browser';
+
+/**
+ * Realiza una fusión profunda entre dos objetos, sin modificar el original.
+ * Si el valor en target no es un objeto, lo reemplaza directamente.
+ *
+ * @param source - Objeto fuente que se clonará y fusionará.
+ * @param target - Objeto destino cuyos valores se fusionarán.
+ * @returns Un nuevo objeto con la fusión profunda.
+ */
+function deepMerge(source, target) {
+    // Crea un clon profundo sin usar JSON.parse(JSON.stringify)
+    let cloneSource = deepClone(source);
+    if (typeof target !== 'object' || target === null) {
+        return target;
+    }
+    if (typeof cloneSource !== 'object' || cloneSource === null) {
+        cloneSource = Array.isArray(target) ? [] : {};
+    }
+    for (const key of Object.keys(target)) {
+        const targetValue = target[key];
+        const sourceValue = cloneSource[key];
+        if (typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue)) {
+            cloneSource[key] = deepMerge(sourceValue, targetValue);
+        }
+        else {
+            cloneSource[key] = targetValue;
+        }
+    }
+    return cloneSource; // Retorna el clon y no modifica el original
+}
+/**
+ * Realiza una clonación profunda de un objeto, manejando funciones, fechas y arrays.
+ *
+ * @param obj - Objeto a clonar.
+ * @returns Una copia profunda del objeto.
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj; // Devuelve el valor si no es un objeto
+    }
+    // Manejar instancias de Date
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    // Manejar funciones devolviendo una copia directa
+    if (typeof obj === 'function') {
+        return obj.bind({}); // Devuelve una copia de la función enlazada a un contexto vacío
+    }
+    // Crear un nuevo objeto o array
+    const clonedObj = Array.isArray(obj) ? [] : {};
+    // Clonar recursivamente las propiedades del objeto
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clonedObj[key] = deepClone(obj[key]);
+        }
+    }
+    return clonedObj;
+}
+/**
+ * Busca un elemento en un array o jerarquía de objetos según un campo y valor especificado.
+ *
+ * @param datosFn - Objeto con los parámetros de búsqueda: items, campo, valor y opcionalmente campoHijo.
+ * @returns El elemento encontrado o undefined si no existe.
+ */
+function buscarPorCampo(datosFn) {
+    for (const item of datosFn.items) {
+        // Verifica si el campo coincide con el valor
+        if (item[datosFn.campo] === datosFn.valor) {
+            return item;
+        }
+        // Verifica si hay un campo hijo y si es un array
+        if (datosFn.campoHijo && item[datosFn.campoHijo] && Array.isArray(item[datosFn.campoHijo])) {
+            // Realiza la búsqueda recursiva en el campo hijo
+            const encontrado = buscarPorCampo({
+                items: item[datosFn.campoHijo], // Asegura el tipo correcto
+                campo: datosFn.campo,
+                valor: datosFn.valor,
+                campoHijo: datosFn.campoHijo,
+            });
+            // Si se encuentra el valor en el campo hijo, retorna el resultado
+            if (encontrado) {
+                return encontrado;
+            }
+        }
+    }
+    // Si no se encuentra nada, retorna undefined
+    return undefined;
+}
+/**
+ * Suma los valores de las propiedades especificadas de un objeto.
+ *
+ * @param item - Objeto con las propiedades a sumar.
+ * @param campos - Array de nombres de las propiedades a sumar.
+ * @returns La suma de los valores de las propiedades.
+ */
+function sumarPropiedades(item, campos) {
+    const datosSumar = campos.map(campo => (item[campo] * 1));
+    return datosSumar.reduce((a, b) => a + b, 0);
+}
+/**
+ * Verifica si el valor proporcionado es un número válido.
+ *
+ * @param value - Valor a verificar.
+ * @returns true si es un número, false en caso contrario.
+ */
+function esNumero(value) {
+    return !isNaN(Number(value));
+}
+/**
+ * Suma los valores de las propiedades especificadas en un array de objetos.
+ *
+ * @param arrayObjetos - Array de objetos a procesar.
+ * @param campos - Array de nombres de las propiedades a sumar.
+ * @returns Objeto con la suma de cada propiedad.
+ */
+function sumarObjetos(arrayObjetos, campos) {
+    return arrayObjetos.reduce((accumulator, item) => {
+        campos.forEach(campo => {
+            const valor = Number(item[campo]);
+            if (!isNaN(valor)) {
+                accumulator[campo] = (accumulator[campo] ?? 0) + valor;
+            }
+        });
+        return accumulator;
+    }, {});
+}
+/**
+ * Obtiene los valores únicos de un array.
+ *
+ * @param array - Array de valores.
+ * @returns Array con los valores únicos.
+ */
+function getUniqueValues(array) {
+    return array.filter((currentValue, index, arr) => (arr.indexOf(currentValue) === index));
+}
+/**
+ * Obtiene los objetos únicos de un array según una propiedad específica.
+ *
+ * @param objetos - Array de objetos.
+ * @param campo - Nombre de la propiedad para determinar unicidad.
+ * @returns Array de objetos únicos por la propiedad.
+ */
+function getUniqueValuesByProperty(objetos, campo) {
+    const objetosUnicos = {};
+    objetos.forEach(objeto => {
+        // Verificar si el objeto tiene el campo especificado
+        // @ts-ignore
+        if (objeto.hasOwnProperty(campo)) {
+            // @ts-ignore
+            const valorCampo = objeto[campo];
+            // Utilizar el valor del campo como clave en un objeto para asegurar que no haya duplicados
+            objetosUnicos[valorCampo] = objeto;
+        }
+    });
+    // Convertir el objeto de claves únicas de vuelta a una lista de objetos
+    return Object.values(objetosUnicos);
+}
+/**
+ * Ordena un array de valores numéricos o alfabéticos.
+ *
+ * @param array - Array a ordenar.
+ * @param numeros - Si es true, ordena como números.
+ * @param sentido - 'ASC' para ascendente, 'DESC' para descendente.
+ * @returns Array ordenado.
+ */
+function ordenarArray(array, numeros = false, sentido = 'ASC') {
+    if (numeros) {
+        if (sentido != 'ASC') {
+            return array.sort((a, b) => b - a);
+        }
+        return array.sort((a, b) => a - b);
+    }
+    return array.sort((a, b) => (a > b) ? 1 : ((b > a) ? -1 : 0));
+}
+/**
+ * Ordena un array de objetos por una propiedad específica.
+ *
+ * @param objData - Array de objetos a ordenar.
+ * @param propiedad - Propiedad por la que se ordena.
+ * @param numeros - (Obsoleto) Si es true, ordena como números.
+ * @returns Array ordenado.
+ */
+function ordenarPorPropiedad(objData, propiedad, /**@deprecated*/ numeros = false) {
+    return ordenarPorPropiedades(objData, { propiedades: [propiedad], direcciones: ['asc'] });
+}
+/**
+ * Ordena un array de objetos por varias propiedades y direcciones.
+ *
+ * @param arr - Array de objetos a ordenar.
+ * @param options - Opciones con propiedades y direcciones de orden.
+ * @returns Array ordenado.
+ */
+function ordenarPorPropiedades(arr, options) {
+    const { propiedades, direcciones = [] } = options;
+    const orden = direcciones.map(d => d === 'desc' ? -1 : 1);
+    return [...arr].sort((a, b) => {
+        return propiedades.reduce((acc, propiedad, index) => {
+            if (acc !== 0)
+                return acc; // Si ya hay diferencia, no seguir comparando
+            const aValue = a[propiedad];
+            const bValue = b[propiedad];
+            if (typeof aValue === 'string' && typeof bValue === 'string') {
+                return aValue.localeCompare(bValue) * orden[index]; // 🔹 Comparación alfabética
+            }
+            if (typeof aValue === 'number' && typeof bValue === 'number') {
+                return (aValue - bValue) * orden[index]; // 🔹 Comparación numérica
+            }
+            return 0; // En caso de valores no comparables
+        }, 0);
+    });
+}
+/**
+ * Agrupa los elementos de un array según una clave o función de clave.
+ *
+ * @param array - Array de objetos a agrupar.
+ * @param key - Propiedad o función para agrupar.
+ * @returns Objeto con los grupos por clave.
+ */
+function groupBy(array, key) {
+    const keyFn = key instanceof Function ? key : (obj) => obj[key];
+    return array.reduce((objectsByKeyValue, obj) => {
+        const value = keyFn(obj);
+        objectsByKeyValue[value] = (objectsByKeyValue[value] || []).concat(obj);
+        return objectsByKeyValue;
+    }, {});
+}
+/**
+ * Agrupa y anida los elementos de un array según una lista de propiedades.
+ *
+ * @param arr - Array de objetos a agrupar.
+ * @param properties - Propiedades para agrupar de forma anidada.
+ * @returns Objeto anidado por los grupos de propiedades.
+ */
+function nestGroupsBy(arr, properties) {
+    const fnGroupBy = (conversions, property2) => {
+        return conversions.reduce((acc, obj) => {
+            const key = obj[property2];
+            if (!acc[key]) {
+                acc[key] = [];
+            }
+            acc[key].push(obj);
+            return acc;
+        }, {});
+    };
+    properties = Array.from(properties);
+    if (properties.length === 1) {
+        return fnGroupBy(arr, properties[0]);
+    }
+    const property = properties.shift();
+    const grouped = fnGroupBy(arr, property);
+    Object.keys(grouped).forEach(key => {
+        grouped[key] = nestGroupsBy(grouped[key], Array.from(properties));
+    });
+    return grouped;
+}
+/**
+ * Obtiene un valor de un objeto usando una ruta de propiedad anidada.
+ *
+ * @param obj - Objeto de entrada.
+ * @param path - Ruta en formato punto (ej: "cliente.orden").
+ * @returns El valor encontrado o undefined si no existe.
+ */
+function getValueByPath(obj, path) {
+    return path.split('.').reduce((acc, key) => acc?.[key], obj);
+}
+/**
+ * Retorna el valor máximo del campo especificado (incluso anidado) en un arreglo de objetos.
+ *
+ * @param data - Lista de objetos a procesar.
+ * @param campo - Nombre del campo a evaluar, puede ser anidado (ej. "campo.orden").
+ * @param incrementar - Si es true, retorna el valor máximo + 1. Por defecto es true.
+ * @returns El valor máximo encontrado, posiblemente incrementado.
+ */
+function obtenerUltimoOrden(data, campo, incrementar = true) {
+    const max = data.reduce((mayor, item) => {
+        const valor = Number(getValueByPath(item, campo)) || 0;
+        return valor > mayor ? valor : mayor;
+    }, 0);
+    return incrementar ? max + 1 : max;
+}
+/**
+ * Elimina una o varias columnas específicas (por índice) de una tabla representada como array de arrays.
+ *
+ * @param data - Array de filas (cada fila debe ser un array).
+ * @param columnIndex - Índice o lista de índices de las columnas a eliminar.
+ * @returns Nuevo array con las columnas eliminadas.
+ */
+function eliminarColumnaPorIndex(data, columnIndex) {
+    if (!Array.isArray(data))
+        return [];
+    // Normalizar a array único y ordenado (descendente para evitar reindexación al splicing)
+    const indices = Array.isArray(columnIndex)
+        ? [...new Set(columnIndex)].filter((i) => (typeof i === 'number' && i >= 0)).sort((a, b) => b - a)
+        : [columnIndex];
+    return data.map((row) => {
+        if (!Array.isArray(row))
+            return row;
+        const newRow = [...row];
+        for (const index of indices) {
+            if (index >= 0 && index < newRow.length) {
+                newRow.splice(index, 1);
+            }
+        }
+        return newRow;
+    });
+}
+/**
+ * Elimina elementos duplicados de un array de objetos según claves específicas.
+ *
+ * @param array - Array de objetos.
+ * @param claves - Claves para determinar unicidad. Si no se especifica, compara todo el objeto.
+ * @returns Array sin duplicados.
+ */
+function eliminarDuplicados(array, claves) {
+    const unicos = new Map();
+    for (const item of array) {
+        const claveUnica = claves && claves.length > 0
+            ? claves.map(k => item[k]).join('|')
+            : JSON.stringify(item);
+        if (!unicos.has(claveUnica)) {
+            unicos.set(claveUnica, item);
+        }
+    }
+    return Array.from(unicos.values());
+}
+/**
+ * Elimina elementos de un array origen que estén presentes en otro array, según claves específicas.
+ *
+ * @param origen - Array original.
+ * @param elementosAEliminar - Elementos a eliminar del array origen.
+ * @param claves - Claves para comparar los objetos. Si no se especifica, compara todo el objeto.
+ * @returns Array filtrado sin los elementos eliminados.
+ */
+function eliminarElementos(origen, elementosAEliminar, claves) {
+    const clavesSet = new Set();
+    for (const item of elementosAEliminar) {
+        const key = claves && claves.length > 0
+            ? claves.map(k => item[k]).join('|')
+            : JSON.stringify(item);
+        clavesSet.add(key);
+    }
+    return origen.filter(item => {
+        const key = claves && claves.length > 0
+            ? claves.map(k => item[k]).join('|')
+            : JSON.stringify(item);
+        return !clavesSet.has(key);
+    });
+}
+
+/**
+ * Devuelve un valor de visualización para un elemento buscado.
+ * Compatible con listas simples, objetos y campos múltiples.
+ */
+function mostrarValorEnBusqueda(campos, idxSel) {
+    const buscarEnLista = (lista) => {
+        if (!lista)
+            return null;
+        if (campos.campoId === '*object*' || campos.campoId === '*objeto*') {
+            return lista.find((x) => JSON.stringify(x).trim() === JSON.stringify(idxSel).trim());
+        }
+        return lista.find((x) => x[campos.campoId] === idxSel);
+    };
+    const impDataMostrar = () => {
+        let vD = buscarEnLista(campos.lista) || (campos.opcExtra && buscarEnLista(campos.opcExtra));
+        if (!vD)
+            return '';
+        if (Array.isArray(campos.campoValue)) {
+            return campos.campoValue.map((vCampo) => vD[vCampo] ?? '').join(' - ').trim();
+        }
+        return (vD[campos.campoValue] ?? '').trim();
+    };
+    if (esNumero(idxSel)) {
+        if ((idxSel > 0 && campos.lista?.length) || (idxSel && typeof idxSel === 'object')) {
+            return impDataMostrar();
+        }
+    }
+    else if (campos.lista?.length) {
+        return impDataMostrar();
+    }
+    return '';
+}
+/**
+ * Filtra datos locales de un array basado en un valor de búsqueda.
+ */
+function filtrarDatosLocal(data, value, campoBuscar) {
+    if (!value)
+        return data;
+    const normalizar = (val) => val?.toString()?.toLowerCase() ?? '';
+    const esNum = !isNaN(Number(value));
+    return data.filter(item => {
+        const campos = Array.isArray(campoBuscar) ? campoBuscar : [campoBuscar];
+        return campos.some(campo => {
+            const campoVal = item[campo];
+            if (campoVal == null)
+                return false;
+            return esNum
+                ? campoVal.toString().includes(value.toString())
+                : normalizar(campoVal).includes(normalizar(value));
+        });
+    });
+}
+/**
+ * Vincula un FormControl a datos locales para autocompletado.
+ */
+function changeSelectData(objThis, { formControl, data, campoBuscar, variableResultado }) {
+    objThis.filtrados[variableResultado] = formControl.valueChanges.pipe(untilDestroyed(objThis)).pipe(startWith(''), map(value => data ? filtrarDatosLocal(data, value, campoBuscar) : []));
+}
+/**
+ * Vincula un FormControl a datos locales obtenidos de dataServidor o dataServidorSuscripcion.
+ */
+function changeSelect(control, formControl, tipo, campoBuscar, campoFiltro = null) {
+    const filtro = campoFiltro ?? tipo;
+    control.filtrados[filtro] = formControl.valueChanges.pipe(untilDestroyed(control)).pipe(startWith(''), map(value => {
+        const partes = tipo.split('.');
+        const varN = control.dataServidor?.[partes[0]]?.[partes[1]] ??
+            control.dataServidor?.[tipo] ??
+            control.dataServidorSuscripcion?.[tipo]?.getValue();
+        return varN ? filtrarDatosLocal(varN, value, campoBuscar) : [];
+    }));
+}
+/**
+ * Función genérica para vincular un FormControl con datos desde API o Promise.
+ * Preparada para migrar a signals en el futuro.
+ */
+function changeSelectReformateado(config) {
+    const { objThis, tipoReq, formControl, queryService, campoId, minLength = 3, dataExtra = {}, dataExtraVariable = [], anonimo = false, variableResultado = tipoReq, } = config;
+    formControl.valueChanges.pipe(debounceTime(500), tap(() => {
+        objThis.filtrados[variableResultado + 'tmp'] = isObservable(objThis.filtrados[variableResultado])
+            ? []
+            : objThis.filtrados[variableResultado] || [];
+        if (objThis.filtrados[variableResultado] !== objThis.filtrados[variableResultado + 'tmp']) {
+            objThis.filtrados[variableResultado] = [];
+        }
+        objThis.isLoading = true;
+    }), switchMap(value => {
+        if (campoId) {
+            const existe = objThis.filtrados[variableResultado + 'tmp']
+                .findIndex((item) => item[campoId] === value);
+            if (existe >= 0) {
+                return of({ [tipoReq]: objThis.filtrados[variableResultado + 'tmp'] });
+            }
+        }
+        if (!value || value.length < minLength) {
+            objThis.isLoading = false;
+            return of({ [tipoReq]: [] });
+        }
+        const extraVars = Object.fromEntries(dataExtraVariable.map(v => [v.campo, v.ctrlValue.value]));
+        const query = queryService.getDataMethod('GET', tipoReq, { ...dataExtra, ...extraVars, txtBuscar: value }, anonimo);
+        if (esPromise(query)) {
+            return query.then((data) => ({ [tipoReq]: data[tipoReq] ?? [] }))
+                .finally(() => { objThis.isLoading = false; });
+        }
+        return query.pipe(finalize(() => { objThis.isLoading = false; }));
+    })).subscribe((data) => {
+        objThis.filtrados[variableResultado] = data[tipoReq] ?? [];
+    });
+}
+/**
+ * Alias para compatibilidad.
+ */
+function changeSelectDataApi(objThis, dataFiltro) {
+    return changeSelectReformateado({
+        objThis,
+        tipoReq: dataFiltro.tipoReq,
+        formControl: dataFiltro.formControl,
+        queryService: dataFiltro.queryService,
+        campoId: dataFiltro.campoId,
+        minLength: dataFiltro.minLength,
+        dataExtra: dataFiltro.dataExtra,
+        dataExtraVariable: dataFiltro.dataExtraVariable,
+        anonimo: dataFiltro.anonimo,
+        variableResultado: dataFiltro.variableResultado,
+    });
+}
+/**
+ * Alias para compatibilidad.
+ */
+function changeSelectApi(control, queryService, formControl, tipo, dataExtra = {}, dataExtraVariable = null, minLength = 1, anonimo = false) {
+    return changeSelectReformateado({
+        objThis: control,
+        tipoReq: tipo,
+        formControl,
+        queryService,
+        minLength,
+        dataExtra,
+        dataExtraVariable: dataExtraVariable ?? [],
+        anonimo,
+    });
+}
+/**
+ * Comprueba si un valor es una Promesa.
+ */
+function esPromise(valor) {
+    return !!valor && typeof valor.then === 'function';
+}
+
+function seleccionarTextoInput(event) {
+    event.target.select();
+}
+
+function b64Encode(val) {
+    return Buffer.from(val, 'binary').toString('base64');
+}
+function b64Decode(val) {
+    return Buffer.from(val, 'base64').toString('binary');
+}
+/**
+ * Codificar string a Base64 (UTF-8 seguro)
+ */
+function encodeBase64String(str) {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(str);
+    let binary = '';
+    bytes.forEach(b => binary += String.fromCharCode(b));
+    return btoa(binary);
+}
+/**
+ * Decodificar Base64 a string (UTF-8 seguro)
+ */
+function decodeBase64String(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder();
+    return decoder.decode(bytes);
+}
+/**
+ * Codificar un objeto a base64 (UTF-8 seguro)
+ */
+function encodeBase64Object(obj) {
+    return encodeBase64String(JSON.stringify(obj));
+}
+/**
+ * Decodificar un base64 y obtener el objeto original
+ */
+function decodeBase64Object(b64) {
+    return JSON.parse(decodeBase64String(b64));
+}
+/**
+ * Codificar archivo a Base64 (retorna solo el contenido, sin "data:...")
+ */
+function encodeBase64File(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const result = reader.result;
+            resolve(result.split(',')[1]); // quita el prefijo "data:...;base64,"
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+}
+/**
+ * Decodificar Base64 a Blob (para reconstruir archivos en Angular)
+ */
+function decodeBase64ToBlob(b64, mimeType = 'application/octet-stream') {
+    const byteChars = atob(b64);
+    const byteNumbers = new Array(byteChars.length);
+    for (let i = 0; i < byteChars.length; i++) {
+        byteNumbers[i] = byteChars.charCodeAt(i);
+    }
+    return new Blob([new Uint8Array(byteNumbers)], { type: mimeType });
+}
+
+function getBrowserName() {
+    const agent = window.navigator.userAgent.toLowerCase();
+    switch (true) {
+        case agent.indexOf('edge') > -1:
+            return 'edge';
+        case agent.indexOf('opr') > -1 && !!window.opr:
+            return 'opera';
+        case agent.indexOf('chrome') > -1 && !!window.chrome:
+            return 'chrome';
+        case agent.indexOf('trident') > -1:
+            return 'ie';
+        case agent.indexOf('firefox') > -1:
+            return 'firefox';
+        case agent.indexOf('safari') > -1:
+            return 'safari';
+        default:
+            return 'other';
+    }
+}
+
+// import * as CryptoJS from 'crypto-js';
+// var CryptoJS = require("crypto-js");
+// Clave secreta (debe ser de 16, 24 o 32 caracteres)
+const secretKey = CryptoJS.enc.Utf8.parse('JVSoftSecret@20615178350');
+const iv = CryptoJS.enc.Utf8.parse('AnSalHuaJVSoft07'); // Debe ser de 16 bytes
+// Función para encriptar texto
+function encriptar(text) {
+    const encrypted = CryptoJS.AES.encrypt(text, secretKey, {
+        iv: iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7,
+    });
+    return encrypted.toString(); // Texto cifrado en Base64
+}
+// Función para desencriptar texto
+function desencriptar(ciphertext) {
+    const decrypted = CryptoJS.AES.decrypt(ciphertext, secretKey, {
+        iv: iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7,
+    });
+    return decrypted.toString(CryptoJS.enc.Utf8);
+}
+
+function formatearFechaFormato(val, format = 'dd/MM/yyyy') {
+    return val ? formatDate(val, format, 'es-PE') : '';
+}
+function formatearFecha(val, hora = '00:00:00') {
+    if (val) {
+        if (val.length <= 10) {
+            val = val + ' ' + hora;
+        }
+        return new Date(val);
+    }
+    return val;
+}
+function formatearFechaCadena(fecha) {
+    const year = parseInt(fecha.substring(0, 4), 10);
+    const month = parseInt(fecha.substring(4, 6), 10) - 1;
+    const day = parseInt(fecha.substring(6, 8), 10);
+    return new Date(year, month, day);
+}
+
+function maskEmail(email) {
+    const [user, domain] = email.split("@");
+    if (user.length <= 2) {
+        return `${user[0]}***@${domain}`; // 🔹 Si el usuario es muy corto, no se oculta nada
+    }
+    if (user.length <= 4) {
+        return `${user[0]}***${user.slice(-1)}@${domain}`; // 🔹 Muestra 1 al inicio y 1 al final
+    }
+    return `${user.slice(0, 2)}***${user.slice(-2)}@${domain}`; // 🔹 Muestra 2 al inicio y 2 al final
+}
+function isEmail(email) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+const mimeTypes = {
+    // Imágenes
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'png': 'image/png',
+    'gif': 'image/gif',
+    'webp': 'image/webp',
+    'svg': 'image/svg+xml',
+    'ico': 'image/x-icon',
+    'bmp': 'image/bmp',
+    // Documentos
+    'pdf': 'application/pdf',
+    'doc': 'application/msword',
+    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'xls': 'application/vnd.ms-excel',
+    'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'ppt': 'application/vnd.ms-powerpoint',
+    'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'txt': 'text/plain',
+    'csv': 'text/csv',
+    'json': 'application/json',
+    'xml': 'application/xml',
+    'html': 'text/html',
+    // Audio
+    'mp3': 'audio/mpeg',
+    'wav': 'audio/wav',
+    'ogg': 'audio/ogg',
+    'm4a': 'audio/mp4',
+    // Video
+    'mp4': 'video/mp4',
+    'avi': 'video/x-msvideo',
+    'mov': 'video/quicktime',
+    'wmv': 'video/x-ms-wmv',
+    'flv': 'video/x-flv',
+    'webm': 'video/webm',
+    'mkv': 'video/x-matroska',
+    // Archivos comprimidos
+    'zip': 'application/zip',
+    'rar': 'application/vnd.rar',
+    '7z': 'application/x-7z-compressed',
+    'tar': 'application/x-tar',
+    'gz': 'application/gzip',
+    'bz2': 'application/x-bzip2',
+    // Otros formatos
+    'js': 'application/javascript',
+    'css': 'text/css',
+    'ts': 'application/typescript',
+    'md': 'text/markdown',
+    'exe': 'application/octet-stream',
+    'eot': 'application/vnd.ms-fontobject',
+    'woff': 'font/woff',
+    'woff2': 'font/woff2',
+    'ttf': 'font/ttf',
+    'otf': 'font/otf',
+};
+function obtenerMimeType(nombreArchivo) {
+    const extension = nombreArchivo.split('.').pop()?.toLowerCase();
+    return extension ? mimeTypes[extension] || 'application/octet-stream' : null;
+}
+function sanitizarNombreArchivo(nombre, reemplazo = '_') {
+    // 1. Quitar caracteres no válidos para nombres de archivo
+    const nombreSanitizado = nombre.replace(/[\/\\:*?"<>|]/g, reemplazo);
+    // 2. Reemplazar espacios múltiples o al inicio/final
+    const nombreLimpio = nombreSanitizado.trim().replace(/\s+/g, reemplazo);
+    // 3. Asegurar longitud máxima (opcional, aquí 255 caracteres)
+    return nombreLimpio.substring(0, 255);
+}
+function getDataArchivoFromPath(value, conTimeStamp = false) {
+    const partesPath = value.split('/');
+    const nombreCompleto = partesPath[partesPath.length - 1];
+    let timeStamp = 1;
+    let nombreSinTimeStamp = nombreCompleto;
+    const partesNombre = nombreCompleto.split('-');
+    if (partesNombre.length > 1) {
+        timeStamp = partesNombre[0] * 1;
+        partesNombre.shift();
+        nombreSinTimeStamp = partesNombre.join('-');
+    }
+    if (conTimeStamp) {
+        return {
+            nombre: nombreCompleto,
+            extension: nombreCompleto.split('.').pop(),
+            d: timeStamp,
+            fechaSubida: timeStamp ? new Date(timeStamp * 1000) : '',
+        };
+    }
+    return {
+        nombre: nombreSinTimeStamp,
+        extension: nombreSinTimeStamp.split('.').pop(),
+        d: timeStamp,
+        fechaSubida: timeStamp ? new Date(timeStamp * 1000) : '',
+    };
+}
+function convertirBytes(valor, unidadSalida = null, incluirUnidad = true) {
+    const unidades = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const indiceEntrada = unidadSalida ? unidades.indexOf(unidadSalida) : 0;
+    if (indiceEntrada === -1) {
+        // Unidad de entrada no válida
+        return null;
+    }
+    let indiceActual = indiceEntrada;
+    let resultado = valor;
+    let cont = 0;
+    while (cont < 6 && (indiceActual < unidades.length - 1) && (resultado >= 1024)) {
+        resultado /= 1024;
+        indiceActual++;
+    }
+    if (incluirUnidad) {
+        return `${resultado.toFixed(2)} ${unidades[indiceActual]}`;
+    }
+    return resultado;
+}
+function downLoadFileStream(data, type, nombreArchivo) {
+    const blob = new Blob([data], { type });
+    saveAs(blob, nombreArchivo);
+}
+
+function establecerQuitarRequired(formulario, establecer = [], quitar = [], camposDisabled = []) {
+    establecer.forEach((control) => {
+        if (!formulario.get(control)?.hasValidator(Validators.required)) {
+            formulario.get(control)?.addValidators([Validators.required]);
+            formulario.get(control)?.enable();
+            formulario.get(control)?.updateValueAndValidity();
+        }
+    });
+    const deshabilitar = (strControl) => {
+        if (camposDisabled == 'todos') {
+            formulario.get(strControl)?.disable();
+            console.log(strControl);
+        }
+        else {
+            if (camposDisabled.includes(strControl)) {
+                formulario.get(strControl)?.disable();
+            }
+        }
+    };
+    quitar.forEach(control => {
+        if (formulario.get(control)?.hasValidator(Validators.required)) {
+            formulario.get(control)?.removeValidators([Validators.required]);
+            formulario.get(control)?.updateValueAndValidity();
+        }
+        deshabilitar(control);
+    });
+}
+function getFormValidationErrors(form) {
+    const result = [];
+    Object.keys(form.controls).forEach(key => {
+        const formProperty = form.get(key);
+        if (formProperty instanceof FormGroup) {
+            result.push(...getFormValidationErrors(formProperty));
+        }
+        const controlErrors = formProperty?.errors;
+        if (controlErrors) {
+            Object.keys(controlErrors).forEach(keyError => {
+                result.push({
+                    control: key,
+                    error: keyError,
+                    value: controlErrors[keyError]
+                });
+            });
+        }
+    });
+    return result;
+}
+function mensajesErrorFormControl(control) {
+    if (!control || !control.errors || !control.touched)
+        return '';
+    ReactiveFormConfig.set({
+        // RxwebValidators
+        validationMessage: {
+            required: 'Es requerido',
+            numeric: 'Debe ser numérico valido',
+            // minLength: 'minimum length is {{1}}',
+            // maxLength: 'allowed max length is {{1}}',
+        },
+    });
+    const errorMessages = {
+        required: 'Es requerido',
+        numeric: 'Debe ser numérico válido',
+        min: `Valor mínimo permitido: ${control.errors['min']?.min}`,
+        minValue: 'Debe ser positivo',
+        minlength: `Mínimo ${control.errors['minlength']?.requiredLength} caracteres.`,
+        maxlength: `Caracteres ${control.errors['maxlength']?.actualLength}/${control.errors['maxlength']?.requiredLength}`,
+        email: 'No se cumple con el formato de Correo Electrónico',
+        isNumeric: 'Debe seleccionar una opción',
+        hasNumber: 'Se requiere al menos un número',
+        hasCapitalCase: 'Se requiere al menos una mayúscula',
+        hasSmallCase: 'Se requiere al menos una minúscula',
+        hasSpecialCharacters: 'Se requiere al menos un carácter especial',
+        NoPassswordMatch: 'La contraseña no coincide',
+        itemSelected: 'Debe seleccionar una opción de la lista',
+        inputMask: 'El formato ingresado no es válido',
+    };
+    // Devuelve el primer mensaje de error encontrado
+    for (const errorKey of Object.keys(control.errors)) {
+        if (errorMessages[errorKey]) {
+            return errorMessages[errorKey];
+        }
+    }
+    // Si el error tiene un mensaje personalizado, usarlo
+    return control.errors[Object.keys(control.errors)[0]]?.message || '';
+}
+function toFormData(formValue) {
+    const formData = new FormData();
+    Object.keys(formValue).forEach((key) => {
+        const value = formValue[key];
+        if (value === null || value === undefined) {
+            return; // Ignorar valores nulos o indefinidos
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+                if (typeof item === 'object' && item !== null) {
+                    if ('file' in item) {
+                        formData.append(`${key}[${index}]`, item.file);
+                    }
+                    else {
+                        formData.append(`${key}[${index}]`, JSON.stringify(item));
+                    }
+                }
+                else {
+                    formData.append(`${key}[${index}]`, item.toString());
+                }
+            });
+        }
+        else if (typeof value === 'object') {
+            // Si es un objeto (pero no un array), convertirlo a JSON
+            formData.append(key, JSON.stringify(value));
+        }
+        else {
+            // Para valores primitivos (string, number, boolean)
+            formData.append(key, value.toString());
+        }
+    });
+    return formData;
+}
+function markAsTouchedWithoutEmitEvent(control) {
+    if (control instanceof FormControl) {
+        control.markAsTouched({ onlySelf: true });
+        control.updateValueAndValidity({ emitEvent: false });
+    }
+    else if (control instanceof FormGroup || control instanceof FormArray) {
+        Object.values(control.controls).forEach(childControl => {
+            markAsTouchedWithoutEmitEvent(childControl);
+        });
+        control.updateValueAndValidity({ emitEvent: false });
+    }
+}
+function setControlDesdeLista(config) {
+    const lista = config.lista$?.getValue() ?? [];
+    if (!lista.length)
+        return;
+    let seleccionado;
+    if (config.idProp && config.idValor !== undefined) {
+        seleccionado = lista.find((item) => item[config.idProp] === config.idValor);
+    }
+    else if (config.usarPrimeraOpcion) {
+        seleccionado = lista[0];
+    }
+    console.log(seleccionado);
+    if (!seleccionado)
+        return;
+    let valor;
+    if (config.selector) {
+        valor = config.selector(seleccionado);
+    }
+    else if (config.idProp) {
+        valor = seleccionado[config.idProp];
+    }
+    else {
+        valor = seleccionado;
+    }
+    if (config.formControl) {
+        config.formControl.setValue(valor);
+    }
+    else if (config.formGroup && config.controlName) {
+        const control = config.formGroup.get(config.controlName);
+        if (control instanceof FormControl) {
+            control.setValue(valor);
+        }
+    }
+}
+function transformarFechasPorNombreDeCampo(formValue) {
+    const retData = {};
+    Object.entries(formValue).forEach(([key, value]) => {
+        // ✅ No procesar Blob o File
+        if (value instanceof Blob || value instanceof File) {
+            retData[key] = value;
+            return;
+        }
+        if (value instanceof Date) {
+            if (/^d[A-Za-z]+/.test(key)) {
+                retData[key] = moment(value).format('YYYY-MM-DD');
+            }
+            else {
+                retData[key] = new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate(), value.getHours(), value.getMinutes(), value.getSeconds()));
+            }
+        }
+        else if (/^dt[A-Za-z]+/.test(key) && typeof value === 'string') {
+            if (/\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}/.test(value)) {
+                retData[key] = new Date(value + 'Z');
+            }
+            else if (/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(value) || /\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}/.test(value)) {
+                retData[key] = new Date(value + ':00.000Z');
+            }
+            else {
+                console.warn('FECHA INVALIDA AL ENVIAR (FormInter):', key, value);
+                retData[key] = value;
+            }
+        }
+        else if (Array.isArray(value)) {
+            if (value.every(v => v instanceof File || v instanceof Blob)) {
+                retData[key] = value;
+            }
+            else {
+                retData[key] = value.map(item => typeof item === 'object' && item !== null
+                    ? transformarFechasPorNombreDeCampo(item)
+                    : item);
+            }
+        }
+        else if (typeof value === 'object' && value !== null) {
+            retData[key] = transformarFechasPorNombreDeCampo(value);
+        }
+        else {
+            retData[key] = value;
+        }
+    });
+    return retData;
+}
+
+function mensajeAlerta(tipo, titulo, mensaje, opciones) {
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje,
+            icon: tipo,
+            confirmButtonText: 'Aceptar',
+            // customClass: {
+            // 	confirmButton: 'btn btn-lg btn-outline-success mx-2',
+            // 	cancelButton: 'btn btn-lg btn-outline-dark mx-2'
+            // },
+            // buttonsStyling: false
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+function mensajeTimer(tipo, titulo, mensaje, milisegundos = 3000, showLoading = true, opciones) {
+    let timerInterval;
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje + '<br> Se cerrará en <strong> X </strong> segundos.',
+            icon: tipo,
+            timer: milisegundos,
+            showCancelButton: false,
+            showConfirmButton: false,
+            willOpen: () => {
+                if (showLoading) {
+                    swal.showLoading();
+                }
+                timerInterval = setInterval(() => {
+                    const impr = Math.ceil(((swal.getTimerLeft() ?? 1) / 1000));
+                    if (swal.getHtmlContainer()) {
+                        // @ts-ignore
+                        swal.getHtmlContainer().querySelector('strong').textContent = String(impr);
+                    }
+                }, 100);
+            },
+            willClose: () => {
+                clearInterval(timerInterval);
+            }
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+// @ts-ignore
+function mensajeConfirmacion(tipo, titulo, mensaje, opciones) {
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje,
+            icon: tipo,
+            showCancelButton: true,
+            // confirmButtonColor: '#3f51b5',
+            // cancelButtonColor: '#ffffff',
+            confirmButtonText: 'Confirmar',
+            cancelButtonText: 'Cancelar',
+            reverseButtons: true,
+            // customClass: {
+            // 	confirmButton: 'btn btn-lg btn-outline-success mx-2',
+            // 	cancelButton: 'btn btn-lg btn-outline-dark mx-2'
+            // },
+            // buttonsStyling: false
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+function mensajeToast(tipo, titulo, mensaje, opciones) {
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje,
+            icon: tipo,
+            confirmButtonText: 'Aceptar',
+            toast: true,
+            position: 'top-end',
+            showConfirmButton: false,
+            timer: 3000,
+            timerProgressBar: true,
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+
+function mensajesDeError(error, toast = false) {
+    let msg;
+    if (error.error && error.error instanceof ArrayBuffer) {
+        const msgArrayBuffer = (arrayBuffer) => {
+            try {
+                const mensajeError = JSON.parse(new TextDecoder("utf-8").decode(arrayBuffer));
+                return mensajeError.message || 'Error desconocido';
+            }
+            catch (parseError) {
+                console.error('Error al analizar la respuesta JSON:', parseError);
+                return 'Error al analizar la respuesta JSON';
+            }
+        };
+        msg = msgArrayBuffer(error.error);
+    }
+    else {
+        switch (error.status) {
+            case 0:
+                // msg = error.message;
+                msg = 'El servidor no responde, verifica tu conexion a la red';
+                console.log(error);
+                break;
+            case 401:
+                if (error.error && typeof error.error == 'object') {
+                    if (error.error.message) {
+                        msg = error.error.message;
+                    }
+                    else if (error.error.error) {
+                        msg = error.error.error;
+                    }
+                    else {
+                        msg = JSON.stringify(error.error);
+                        console.log(error);
+                    }
+                }
+                else if (error.error && typeof error.error == 'string') {
+                    msg = error.error;
+                }
+                else {
+                    msg = 'Acceso no autorizado';
+                    console.log(error);
+                }
+                break;
+            case 422:
+                let strEr = '';
+                console.log(typeof error.error.errors);
+                console.log(error.error.errors);
+                if (error.error.errors) {
+                    Object.keys(error.error.errors).forEach(o => {
+                        strEr += '<li>' + error.error.errors[o][0] + '</li>';
+                    });
+                    msg = (error.error.message ?? '') + '<ul>' + strEr + '</ul>';
+                }
+                else if (error.error.error) {
+                    msg = error.error.msg;
+                }
+                break;
+            case 429:
+            case 400:
+            case 500:
+            case 503:
+                msg = error.error.message;
+                break;
+            case 504:
+                msg = 'No se puede conectar al servidor. Comprueba tu conexion a la red - ' + error.statusText;
+                break;
+            default:
+                msg = error?.error?.message ?? 'Error de Sistema';
+                console.log(error);
+                break;
+        }
+    }
+    if (!msg) {
+        msg = error.statusText ?? 'Error inesperado o datos inexistentes.';
+    }
+    let tituloFinal = 'Error!';
+    let mensajeFinal;
+    if (msg.includes('Hmac::doVerify')) {
+        console.log(error, msg);
+        return;
+    }
+    else if (msg == 'Server Error') {
+        console.log(error, msg);
+        return;
+    }
+    else if (msg.includes('[IMSSP]')) {
+        mensajeFinal = 'Error en consulta de registros.';
+    }
+    else if (msg.includes('Tiempo de espera de la')) {
+        mensajeFinal = 'Hubo un error en la solicitud de datos, por favor actualice (SHIFT + F5)';
+    }
+    else {
+        mensajeFinal = msg;
+    }
+    if (toast) {
+        mensajeToast('error', tituloFinal, mensajeFinal);
+    }
+    else {
+        mensajeAlerta('error', tituloFinal, mensajeFinal);
+    }
+    throw new Error(mensajeFinal);
+}
+
+let dataSessionStorageKey = {
+    tokenStringKey: 'JVSoftTkn',
+    changePasswordKey: 'chPwd',
+    logoUrl: 'logo_url',
+    logoLogin: 'login-logo',
+    backgroundLogin: 'login-background',
+    favicon: 'favicon',
+    darkMode: 'darkMode',
+    serverTimestamp: 'srvtmstp',
+    apiDataKey: 'reqDt',
+};
+let localStorageKeys = dataSessionStorageKey;
+function inicializarVariablesSessionStorage(datSesion) {
+    dataSessionStorageKey = datSesion;
+}
+function setJwtTokenData(data) {
+    localStorage.setItem(dataSessionStorageKey.tokenStringKey, data);
+}
+function jwtTokenData(key = dataSessionStorageKey.tokenStringKey) {
+    const tokenObj = localStorage.getItem(key);
+    try {
+        return JSON.parse(tokenObj);
+    }
+    catch (error) {
+        return null;
+    }
+}
+function jwtToken(key = dataSessionStorageKey.tokenStringKey) {
+    const varJwtTokenData = jwtTokenData(key);
+    if (varJwtTokenData) {
+        return varJwtTokenData.access_token;
+    }
+    return '';
+}
+function jwtTokenExpiracion(key = dataSessionStorageKey.tokenStringKey) {
+    const jwtStr = jwtToken(key);
+    if (!jwtStr)
+        return null;
+    try {
+        const decodedToken = jwtDecode(jwtStr);
+        return decodedToken.exp ? decodedToken.exp * 1000 : null; // Convertir a milisegundos
+    }
+    catch (e) {
+        return null;
+    }
+}
+function jwtTokenExpiracionFaltante() {
+    return Math.abs(moment().diff(jwtTokenExpiracion(), 'seconds'));
+}
+function setCambiarPwd(accion = true) {
+    localStorage.setItem(dataSessionStorageKey.changePasswordKey, (accion ? 1 : 0).toString());
+}
+function getCambiarPwd() {
+    const frmCambioPwd = localStorage.getItem(dataSessionStorageKey.changePasswordKey);
+    if (!frmCambioPwd) {
+        return null;
+    }
+    return frmCambioPwd == '1';
+}
+function delLocalStorage(keyElim = [
+    dataSessionStorageKey.tokenStringKey,
+    dataSessionStorageKey.changePasswordKey,
+    dataSessionStorageKey.apiDataKey,
+]) {
+    keyElim.forEach(key => {
+        localStorage.removeItem(key);
+    });
+}
+function getLocalStorage(key) {
+    return localStorage.getItem(key);
+}
+function setLocalStorage(key, value = '') {
+    localStorage.setItem(key, value.toString());
+}
+
+function roundToDecimal(number, decimal) {
+    return parseFloat(number.toFixed(decimal));
+}
+function numberToWords(num) {
+    if (num === 0)
+        return 'cero';
+    if (num < 0)
+        return 'menos ' + numberToWords(Math.abs(num));
+    if (num > 999999999999)
+        return 'número demasiado grande';
+    const ones = ['', 'un', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve'];
+    const onesFinal = ['', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve'];
+    const tens = ['', 'diez', 'veinte', 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta', 'noventa'];
+    const teens = ['diez', 'once', 'doce', 'trece', 'catorce', 'quince', 'dieciséis', 'diecisiete', 'dieciocho', 'diecinueve'];
+    const hundreds = ['', 'ciento', 'doscientos', 'trescientos', 'cuatrocientos', 'quinientos', 'seiscientos', 'setecientos', 'ochocientos', 'novecientos'];
+    // Función auxiliar para "un"/"uno"
+    const getOneForm = (n, isFinal) => n === 1 ? (isFinal ? 'uno' : 'un') : onesFinal[n];
+    let words = '';
+    // Miles de millones (ahora sí se ejecuta)
+    if (num >= 1000000000) {
+        const billions = Math.floor(num / 1000000000);
+        words += (billions === 1 ? 'mil' : numberToWords(billions) + ' mil') + ' millones ';
+        num %= 1000000000;
+    }
+    // Millones
+    if (num >= 1000000) {
+        const millions = Math.floor(num / 1000000);
+        words += millions === 1 ? 'un millón ' : numberToWords(millions) + ' millones ';
+        num %= 1000000;
+    }
+    // Miles
+    if (num >= 1000) {
+        const thousands = Math.floor(num / 1000);
+        words += thousands === 1 ? 'mil ' : numberToWords(thousands) + ' mil ';
+        num %= 1000;
+    }
+    // Centenas (con tratamiento especial para "ciento uno")
+    if (num >= 100) {
+        if (num === 100) {
+            words += 'cien';
+            num = 0;
+        }
+        else {
+            words += hundreds[Math.floor(num / 100)];
+            num %= 100;
+            if (num > 0) {
+                words += ' ' + getOneForm(num, true); // Siempre "uno" después de ciento
+                num = 0;
+            }
+        }
+    }
+    // Decenas y unidades
+    if (num > 0) {
+        const isFinalWord = words === '';
+        if (num < 10) {
+            words += getOneForm(num, isFinalWord);
+        }
+        else if (num < 20) {
+            words += teens[num - 10];
+        }
+        else if (num < 30) {
+            if (num === 21)
+                words += 'veintiuno';
+            else if (num === 22)
+                words += 'veintidós';
+            else if (num === 23)
+                words += 'veintitrés';
+            else if (num === 26)
+                words += 'veintiséis';
+            else
+                words += `veinti${onesFinal[num % 10]}`;
+        }
+        else {
+            words += tens[Math.floor(num / 10)];
+            if (num % 10 > 0) {
+                words += ' y ' + getOneForm(num % 10, isFinalWord);
+            }
+        }
+    }
+    return words.trim().replace(/\s+/g, ' ');
+}
+
+function objectPropertiesToType(formFields) {
+    Object.keys(formFields).filter(control => !!formFields[control]).forEach(control => {
+        if (/^dt[a-zA-Z]+/.test(control)) {
+            formFields[control] = formatDate(formFields[control], 'yyyy-MM-dd HH:mm', 'es-PE');
+        }
+        else if (control.startsWith('d')) {
+            formFields[control] = formatearFecha(formFields[control]);
+        }
+        else if (control.startsWith('n')) {
+            formFields[control] = Number(formFields[control]);
+        }
+    });
+    return formFields;
+}
+function objectPropertiesBoolean(formFields, retorno = 'boolean') {
+    Object.keys(formFields).forEach(control => {
+        const valRetorno = (ctrl) => {
+            switch (retorno) {
+                case 'boolean':
+                    formFields[ctrl] = formFields[ctrl] == 1;
+                    break;
+                case 'bit':
+                    formFields[ctrl] = formFields[ctrl] ? 1 : 0;
+                    break;
+            }
+        };
+        if (control.charAt(0) == 'b' || (control.charAt(0) == 'i' && control.indexOf('Estado') !== -1)) {
+            valRetorno(control);
+        }
+    });
+    return formFields;
+}
+
+function generateRandomString(length) {
+    let result = '';
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+/**
+ * Obtiene el host (hostname) de una URL o cadena host[:port].
+ * Opcionalmente puede devolver también el puerto si está presente.
+ *
+ * - Acepta inputs como:
+ *   'https://example.com/path', 'example.com:3000', 'localhost', 'http://[::1]:4200'
+ * - Usa la API URL cuando es posible (más robusta) y cae a un regex de respaldo.
+ *
+ * @param url Cadena que representa una URL o host
+ * @param options
+ * @param options.includePort Si es true, incluye":puerto" cuando exista (por defecto false)
+ * @param options.includeProtocol Incluye "http://" o "https://" según corresponda (por defecto false)
+ */
+function obtenerHostDesdeUrl(url, options) {
+    if (!url)
+        return null;
+    const includePort = !!options?.includePort;
+    const includeProtocol = !!options?.includeProtocol;
+    // Intentar con API URL
+    try {
+        const candidate = url.includes('://') ? url : `http://${url}`;
+        const parsed = new URL(candidate);
+        const protocol = includeProtocol ? `${parsed.protocol}//` : '';
+        const hostname = parsed.hostname;
+        const port = parsed.port;
+        if (!hostname)
+            return null;
+        return `${protocol}${hostname}${includePort && port ? `:${port}` : ''}`;
+    }
+    catch {
+        // Regex fallback
+        const regex = /^(?:(?<protocol>[a-z]+):\/\/)?(?:www\.)?(?<host>\[[^\]]+\]|[A-Za-z0-9.-]+)(?::(?<port>\d{1,5}))?/;
+        const match = String(url).match(regex);
+        if (!match?.groups)
+            return null;
+        let host = match.groups['host'];
+        if (host.startsWith('[') && host.endsWith(']')) {
+            host = host.slice(1, -1);
+        }
+        const port = match.groups['port'];
+        const protocol = includeProtocol ? `${match.groups['protocol'] ?? 'http'}://` : '';
+        return `${protocol}${host}${includePort && port ? `:${port}` : ''}`;
+    }
+}
+/** @deprecated Alias compatible (deprecated) — preferir usar `obtenerHostDesdeUrl`. */
+const extraerDominio = (url, options) => obtenerHostDesdeUrl(url, options);
+
+function verificarRUC(ruc) {
+    const f = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+    const rucArray = ruc.split('');
+    const nArray = f.map((item, idx) => {
+        return item * parseFloat(rucArray[idx]);
+    });
+    const suma = nArray.reduce((a, b) => a + b, 0);
+    const residuo = suma % 11;
+    const residuo2 = 11 - residuo;
+    // @residuo=CONVERT(Integer,Right(CONVERT(VarChar,@residuo),1))
+    const residuo3 = residuo2.toString().charAt(residuo2.toString().length - 1);
+    const ultimoCaracter = ruc.toString().charAt(ruc.toString().length - 1);
+    if (residuo3 == ultimoCaracter) {
+        return true;
+    }
+    mensajeAlerta('error', 'Datos No válidos', ' El número de RUC no es válido');
+    return false;
+}
+
+class DataModel {
+    modelosChk = {}; // Usar any para valores dinámicos
+    checkbox;
+    constructor() {
+        this.checkbox = new ForCheckboxModel(this);
+    }
+    generarId(row, campoValor, separador = '') {
+        if (typeof campoValor == 'string') {
+            campoValor = [campoValor];
+        }
+        return campoValor.map(data => row[data]).join(separador);
+    }
+    // Agrega controles al objeto modelosChk
+    agregarControles(lista, idLista, limpiar = true, campoValor = null, campoValorSeparador = '') {
+        if (limpiar) {
+            this.modelosChk = {};
+        }
+        const asignarValor = (dat, idLista, campoValor, key) => {
+            if (!key) {
+                key = dat[idLista] + (campoValor.includes('.') ? '' : `.${campoValor}`);
+            }
+            const mat = campoValor.match(/^([in])[A-Z][a-zA-Z]+/);
+            if (mat) {
+                this.modelosChk[key] = dat[campoValor] * 1;
+            }
+            else {
+                this.modelosChk[key] = dat[campoValor];
+            }
+        };
+        lista.forEach(dat => {
+            if (campoValor === null) {
+                // Caso 1: Sin campoValor, se asigna false
+                this.modelosChk[dat[idLista]] = false;
+            }
+            else if (typeof campoValor === 'string') {
+                // Caso 2: campoValor es un string
+                asignarValor(dat, idLista, campoValor, dat[idLista]);
+            }
+            else if (campoValorSeparador) {
+                const idStr = this.generarId(dat, campoValor, campoValorSeparador);
+                // Caso 2: campoValor es un string
+                asignarValor(dat, idLista, '.', idStr);
+            }
+            else {
+                // Caso 3: campoValor es un array de strings
+                campoValor.forEach(data => asignarValor(dat, idLista, data));
+            }
+        });
+    }
+    // Establece el estado de un índice
+    setState(idx, state) {
+        this.modelosChk[idx] = state;
+    }
+    // Obtiene el estado de un índice
+    getState(idx) {
+        return this.modelosChk[idx];
+    }
+    getDataMultiple(idx) {
+        const camposMod = Object.keys(this.modelosChk).filter(key => key.split('.')[0] == idx);
+        const vRet = {};
+        camposMod.forEach(key => {
+            vRet[key.split('.')[1]] = this.modelosChk[key];
+        });
+        return vRet;
+    }
+    // Genera una lista basada en el estado de los índices
+    generarLista(tipoRetorno = null, esCampoNumerico = false) {
+        const strLista = [];
+        const objLista = {};
+        Object.keys(this.modelosChk).forEach(key => {
+            if ((esCampoNumerico && esNumero(this.modelosChk[key])) ||
+                (this.modelosChk[key])) {
+                strLista.push(key);
+                objLista[key] = this.modelosChk[key];
+            }
+        });
+        if (tipoRetorno === 'array') {
+            return strLista;
+        }
+        if (tipoRetorno === 'object') {
+            return objLista;
+        }
+        return strLista.join(',');
+    }
+    generarFormGroupFromModelosChk(tipo) {
+        const formGroupObj = {};
+        let validadores = [];
+        if (tipo == 'number') {
+            validadores = [
+                Validators.required,
+                Validators.min(1)
+            ];
+        }
+        Object.keys(this.modelosChk).forEach(key => {
+            formGroupObj[key] = new FormControl(this.modelosChk[key], validadores);
+        });
+        return new FormGroup(formGroupObj);
+        // return this.formBuilder.group(formGroupObj);
+    }
+}
+class ForCheckboxModel {
+    modeloCheck;
+    constructor(modeloCheck) {
+        this.modeloCheck = modeloCheck;
+    }
+    get cantidadActivos() {
+        return Object.values(this.modeloCheck.modelosChk).filter(Boolean).length;
+    }
+    get existenActivados() {
+        return this.cantidadActivos > 0;
+    }
+    get todosActivos() {
+        const total = Object.keys(this.modeloCheck.modelosChk).length;
+        const activos = this.cantidadActivos;
+        return activos > 0 && total === activos;
+    }
+    get algunosActivos() {
+        const total = Object.keys(this.modeloCheck.modelosChk).length;
+        const activos = this.cantidadActivos;
+        return activos > 0 && total !== activos;
+    }
+    establecerTodos(activo) {
+        Object.keys(this.modeloCheck.modelosChk).forEach(idx => this.modeloCheck.modelosChk[idx] = activo);
+    }
+}
+
+class DataEnListaPipe {
+    transform(coleccion, idBuscar, dato) {
+        if (coleccion) {
+            if (Array.isArray(idBuscar)) {
+                return coleccion.find(item => {
+                    const arrCoincide = [];
+                    idBuscar.forEach((campo, idx) => {
+                        // @ts-ignore
+                        arrCoincide.push((item[campo] == dato[idx]));
+                    });
+                    return arrCoincide.every(e => e === true);
+                });
+            }
+            // @ts-ignore
+            return coleccion.find(item => item[idBuscar] == dato);
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DataEnListaPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: DataEnListaPipe, isStandalone: true, name: "dataEnLista" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DataEnListaPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dataEnLista',
+                }]
+        }] });
+function dataEnLista(coleccion, idBuscar, dato) {
+    return new DataEnListaPipe().transform(coleccion, idBuscar, dato);
+}
+
+class DateDiffStringPipe {
+    transform(startingDate, endingDate) {
+        let startDate = new Date(startingDate);
+        // user not pass endingDate then set current date as end date.
+        if (!endingDate) {
+            endingDate = new Date();
+        }
+        let endDate = new Date(endingDate);
+        // chack start date and end date and base on condication alter date.
+        if (startDate > endDate) {
+            const swap = startDate;
+            startDate = endDate;
+            endDate = swap;
+        }
+        const disgregado = this.separarMilisegundos(endDate.getTime() - startDate.getTime());
+        // console.log(disgregado);
+        const formatearATexto = (arrayToFill, campo, texto, textoPlural = 's') => {
+            if (campo > 0) {
+                arrayToFill.push(campo + ' ' + texto + (campo > 1 ? textoPlural : ''));
+            }
+            return arrayToFill;
+        };
+        let arrDFinal = [];
+        arrDFinal = formatearATexto(arrDFinal, disgregado.years, 'año');
+        arrDFinal = formatearATexto(arrDFinal, disgregado.months, 'mes', 'es');
+        arrDFinal = formatearATexto(arrDFinal, disgregado.weeks, 'semana');
+        arrDFinal = formatearATexto(arrDFinal, disgregado.days, 'día');
+        arrDFinal = formatearATexto(arrDFinal, disgregado.hours, 'hora');
+        arrDFinal = formatearATexto(arrDFinal, disgregado.minutes, 'minuto');
+        arrDFinal = formatearATexto(arrDFinal, disgregado.seconds, 'segundo');
+        if (arrDFinal.length > 3) {
+            arrDFinal.splice(3);
+            arrDFinal.splice(-1, 0, 'y');
+        }
+        else {
+            if (arrDFinal.length > 1) {
+                arrDFinal.splice(-1, 0, 'y');
+            }
+        }
+        return arrDFinal.join(' ');
+    }
+    separarMilisegundos(milisegundos) {
+        const todoEnSegundos = milisegundos / 1000;
+        let secsUsed = 0;
+        const years = Math.floor(todoEnSegundos / 31536000);
+        if (years > 0) {
+            secsUsed += (years * 31536000);
+        }
+        const months = Math.floor((todoEnSegundos - secsUsed) / 2628288);
+        if (months > 0) {
+            secsUsed += (months * 2628288);
+        }
+        const weeks = Math.floor((todoEnSegundos - secsUsed) / 604800);
+        if (weeks > 0) {
+            secsUsed += (weeks * 604800);
+        }
+        const days = Math.floor((todoEnSegundos - secsUsed) / 86400);
+        if (days > 0) {
+            secsUsed += (days * 86400);
+        }
+        const hours = Math.floor((todoEnSegundos - secsUsed) / 3600);
+        if (hours > 0) {
+            secsUsed += (hours * 3600);
+        }
+        const minutes = Math.floor((todoEnSegundos - secsUsed) / 60);
+        if (minutes > 0) {
+            secsUsed += (minutes * 60);
+        }
+        const seconds = Math.round(todoEnSegundos - secsUsed);
+        return {
+            years,
+            months,
+            weeks,
+            days,
+            hours,
+            minutes,
+            seconds,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DateDiffStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: DateDiffStringPipe, isStandalone: true, name: "dateDiffString" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DateDiffStringPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateDiffString',
+                    pure: true
+                }]
+        }] });
+function dateDiffString(startingDate, endingDate) {
+    return new DateDiffStringPipe().transform(startingDate, endingDate);
+}
+
+class FiltroPipe {
+    transform(items, opcionesBusqueda) {
+        if (!items || !Array.isArray(items))
+            return [];
+        if (!opcionesBusqueda.texto || opcionesBusqueda.texto.length < (opcionesBusqueda.longitudMinima ?? 1))
+            return items;
+        const normalize = (() => {
+            const from = 'ÃÀÁÄÂÈÉËÊÌÍÏÎÒÓÖÔÙÚÜÛãàáäâèéëêìíïîòóöôùúüûÑñÇç';
+            const to = 'AAAAAEEEEIIIIOOOOUUUUaaaaaeeeeiiiioooouuuunncc';
+            const mapping = {};
+            for (let i = 0; i < from.length; i++) {
+                mapping[from[i]] = to[i];
+            }
+            return (str) => {
+                return str.split('').map(c => mapping[c] || c).join('');
+            };
+        })();
+        const textoNormalizado = normalize(opcionesBusqueda.texto.toLowerCase());
+        return items.filter(item => {
+            // 🔹 Manejo de `mostrarObligado`
+            if (opcionesBusqueda.mostrarObligado) {
+                const { campo, items: obligados } = opcionesBusqueda.mostrarObligado;
+                if (obligados.includes(item[campo]))
+                    return true;
+            }
+            // 🔹 Manejo de `campo`
+            if (opcionesBusqueda.campo) {
+                if (Array.isArray(opcionesBusqueda.campo)) {
+                    return opcionesBusqueda.campo.some(campo => {
+                        const valor = item[campo];
+                        return valor ? normalize(valor.toLowerCase()).includes(textoNormalizado) : false;
+                    });
+                }
+                else {
+                    const valor = item[opcionesBusqueda.campo];
+                    return valor ? normalize(valor.toLowerCase()).includes(textoNormalizado) : false;
+                }
+            }
+            return false;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FiltroPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: FiltroPipe, isStandalone: true, name: "filtro" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FiltroPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'filtro'
+                }]
+        }] });
+
+class FormControlIsRequiredPipe {
+    transform(formControl, ...args) {
+        if (!formControl) {
+            return false;
+        }
+        return formControl.hasValidator(Validators.required);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FormControlIsRequiredPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: FormControlIsRequiredPipe, isStandalone: true, name: "formControlIsRequired" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FormControlIsRequiredPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'formControlIsRequired'
+                }]
+        }] });
+function formControlIsRequired(formControl) {
+    return new FormControlIsRequiredPipe().transform(formControl);
+}
+
+class JsonParsePipe {
+    transform(value, ...args) {
+        if (!value) {
+            return [];
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (e) {
+            console.warn('La cadena "' + value + '" no es JSON');
+            return [];
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JsonParsePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: JsonParsePipe, isStandalone: true, name: "jsonParse" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JsonParsePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'jsonParse'
+                }]
+        }] });
+
+class NoSanitizePipe {
+    domSanitizer;
+    constructor(domSanitizer) {
+        this.domSanitizer = domSanitizer;
+    }
+    transform(html) {
+        return this.domSanitizer.bypassSecurityTrustHtml(html);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: NoSanitizePipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: NoSanitizePipe, isStandalone: true, name: "noSanitize" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: NoSanitizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'noSanitize' }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+
+class TipoValorFuncionPipe {
+    transform(datoParam, defaultValue, ...param) {
+        if (datoParam === undefined || datoParam === null) {
+            return defaultValue;
+        }
+        if (typeof datoParam === 'function') {
+            return datoParam(...param);
+        }
+        return datoParam;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TipoValorFuncionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: TipoValorFuncionPipe, isStandalone: true, name: "tipoValorFuncion" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TipoValorFuncionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'tipoValorFuncion',
+                    standalone: true, // Para usarlo en standalone components
+                }]
+        }] });
+function tipoValorFuncion(datoParam, defaultValue, ...param) {
+    return new TipoValorFuncionPipe().transform(datoParam, defaultValue, ...param);
+}
+
+class ZeroFillPipe {
+    transform(value, digitos, ...args) {
+        let s = value + '';
+        while (s.length < digitos) {
+            s = '0' + s;
+        }
+        return s;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ZeroFillPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: ZeroFillPipe, isStandalone: true, name: "zeroFill" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ZeroFillPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'zeroFill',
+                }]
+        }] });
+function zeroFill(value, digitos, ...args) {
+    return new ZeroFillPipe().transform(value, digitos, args);
+}
+
+// export * from './otros';
+
+/*
+ * Public API Surface of utils
+ */
+// export * from './functions/common.function';
+// export * from './lib/utils.component';
+// export * from './lib/utils.service';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DataEnListaPipe, DataModel, DateDiffStringPipe, FiltroPipe, FormControlIsRequiredPipe, JsonParsePipe, NoSanitizePipe, TipoValorFuncionPipe, ZeroFillPipe, b64Decode, b64Encode, buscarPorCampo, changeSelect, changeSelectApi, changeSelectData, changeSelectDataApi, changeSelectReformateado, convertirBytes, dataEnLista, dateDiffString, decodeBase64Object, decodeBase64String, decodeBase64ToBlob, deepClone, deepMerge, delLocalStorage, desencriptar, downLoadFileStream, eliminarColumnaPorIndex, eliminarDuplicados, eliminarElementos, encodeBase64File, encodeBase64Object, encodeBase64String, encriptar, esNumero, establecerQuitarRequired, extraerDominio, formControlIsRequired, formatearFecha, formatearFechaCadena, formatearFechaFormato, generateRandomString, getBrowserName, getCambiarPwd, getDataArchivoFromPath, getFormValidationErrors, getLocalStorage, getUniqueValues, getUniqueValuesByProperty, groupBy, inicializarVariablesSessionStorage, isEmail, jwtToken, jwtTokenData, jwtTokenExpiracion, jwtTokenExpiracionFaltante, localStorageKeys, markAsTouchedWithoutEmitEvent, maskEmail, mensajeAlerta, mensajeConfirmacion, mensajeTimer, mensajeToast, mensajesDeError, mensajesErrorFormControl, mostrarValorEnBusqueda, nestGroupsBy, numberToWords, objectPropertiesBoolean, objectPropertiesToType, obtenerHostDesdeUrl, obtenerMimeType, obtenerUltimoOrden, ordenarArray, ordenarPorPropiedad, ordenarPorPropiedades, roundToDecimal, sanitizarNombreArchivo, seleccionarTextoInput, setCambiarPwd, setControlDesdeLista, setJwtTokenData, setLocalStorage, sumarObjetos, sumarPropiedades, tipoValorFuncion, toFormData, transformarFechasPorNombreDeCampo, verificarRUC, zeroFill };
+//# sourceMappingURL=jvsoft-utils.mjs.map