general-library-union 3.2.35 → 3.2.37

package/esm2022/src/app/core/servicios/utils.service.mjs

@@ -0,0 +1,349 @@
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-cookie-service";
+import * as i2 from "./click-posicion.service";
+export class UtilsService {
+    cookieService;
+    document;
+    clickPositionService;
+    RESERVADAS_SQL_NOPUEDECONTENER = [';'];
+    reservadas = ['ALTER', 'DELETE', 'DROP', 'MODIFY', 'CREATE', 'DATABASE', 'TABLE', 'UPDATE', 'TRIGGER', 'GRANT', 'REVOKE', 'CALL', 'INSERT', 'TRUNCATE', 'USE', '--'];
+    constructor(cookieService, document, clickPositionService) {
+        this.cookieService = cookieService;
+        this.document = document;
+        this.clickPositionService = clickPositionService;
+    }
+    generarLlave() {
+        let result = '';
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        const charactersLength = 32;
+        for (let i = 0; i < charactersLength; i++) {
+            result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+        return result.toLowerCase();
+    }
+    generarPin(cantidad) {
+        let result = '';
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < cantidad; i++) {
+            result += characters.charAt(Math.floor(Math.random() * cantidad));
+        }
+        return result.toLowerCase();
+    }
+    rightpad(str, length, char) {
+        if (str === undefined) {
+            return null;
+        }
+        if (typeof str !== 'string' || typeof length !== 'number') {
+            throw new TypeError('Los argumentos deben ser una cadena y un número.');
+        }
+        if (str.length >= length) {
+            return str;
+        }
+        char = char || ' '; // Utiliza un espacio como carácter de relleno si no se proporciona uno
+        var padLength = length - str.length;
+        var padding = char.repeat(padLength);
+        return str + padding;
+    }
+    validarCampoNumerico(event) {
+        const input = event.target;
+        const regex = /[^0-9]/gi;
+        input.value = input.value.replace(regex, '');
+    }
+    isNotBlank(str) {
+        return str != null && str.trim().length > 0;
+    }
+    isBlank(str) {
+        return str == null || str?.trim() === '';
+    }
+    validarCampoObligatorio(valor) {
+        // Verificar si el valor no es null ni undefined
+        if (valor !== null && valor !== undefined) {
+            // Verificar si el valor no es una cadena vacía (en caso de ser una cadena)
+            if (typeof valor === 'string' && valor.trim() === '') {
+                return false;
+            }
+            // Verificar si el valor no es un arreglo vacío (en caso de ser un arreglo)
+            if (Array.isArray(valor) && valor.length === 0) {
+                return false;
+            }
+            /*if (typeof valor === 'object' && Object.keys(valor).length === 0) {
+              return false;
+            }*/
+            return true;
+        }
+        return false;
+    }
+    capitalizeFully(inputString) {
+        if (!inputString) {
+            return '';
+        }
+        const words = inputString.split(' ');
+        const capitalizedWords = words.map(word => {
+            if (word.length > 0) {
+                return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+            }
+            return '';
+        });
+        const result = capitalizedWords.join(' ');
+        return result;
+    }
+    ordenarSelectItemsAlfabeticamente(arrayDeObjetos) {
+        arrayDeObjetos.sort((a, b) => {
+            const nombreA = a.label.toLowerCase();
+            const nombreB = b.label.toLowerCase();
+            if (nombreA < nombreB) {
+                return -1;
+            }
+            if (nombreA > nombreB) {
+                return 1;
+            }
+            return 0;
+        });
+        return arrayDeObjetos;
+    }
+    obtenerParametroDeURL(urlString, parametro) {
+        const url = new URL(urlString);
+        const searchParams = new URLSearchParams(url.search);
+        return searchParams.get(parametro);
+    }
+    validarEmail(email) {
+        const patronEmail = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+        return patronEmail.test(email);
+    }
+    obtenerBase() {
+        var basePortal = null;
+        var paginaActual = window.location.href;
+        var url = new URL(paginaActual);
+        var params = new URLSearchParams(url.search);
+        if (paginaActual.toString().includes('PortalSara')) {
+            for (var match of paginaActual.matchAll(/(?<inicio>.*)\/(?<seguridad>.*)\/(?<sitio>.*)\/(?<pagina>.*)/g)) {
+                basePortal = match.groups?.seguridad;
+            }
+        }
+        else if (params?.get('us_id')) {
+            paginaActual = window.parent.location.href;
+            for (var match of paginaActual.matchAll(/(?<inicio>.*)\/(?<seguridad>.*)\/(?<sitio>.*)\/(?<pagina>.*)/g)) {
+                basePortal = match.groups?.seguridad;
+            }
+        }
+        else {
+            const regex = /^.*?\/\/.*?\/(.*?)\//g; // Expresión regular para obtener la primera parte de la URL
+            const match = Array.from(paginaActual.matchAll(regex));
+            if (match && match[0] && match[0][1]) {
+                basePortal = match[0][1];
+            }
+        }
+        return basePortal;
+    }
+    validarEspacio(caracter) {
+        const regex = /\s/; // La expresión regular para espacios en blanco
+        return regex.test(caracter); // Devuelve true si el carácter es un espacio en blanco
+    }
+    validarTextoSQL(valor, obligatorio, select, longitud, validarSentencia) {
+        // Verifica obligatoriedad
+        if (obligatorio && (valor == null || valor.trim().length == 0 || valor == '--')) {
+            return 'Obligatorio';
+        }
+        // Verifica longitud máxima
+        if (longitud > 0) {
+            if (valor != null && valor != '--' && valor.length > longitud) {
+                return 'Longitud maxima de ' + longitud;
+            }
+        }
+        // Realiza las demás validacion solo en el caso de que la cadena SQL/valor no sea vacia
+        if (valor == null || valor.trim().length == 0 || valor == '--')
+            return null;
+        if (validarSentencia) {
+            if (select) {
+                if (!valor.toUpperCase().startsWith('SELECT')) {
+                    return 'El texto debe iniciar con la palabra Select';
+                }
+            }
+            else {
+                if (valor.toUpperCase().includes('SELECT')) {
+                    return 'No puede contener la palabra Select';
+                }
+            }
+        }
+        var indice;
+        var mensaje;
+        this.RESERVADAS_SQL_NOPUEDECONTENER.forEach(item => {
+            if (valor.includes(item)) {
+                mensaje = 'No puede contener ' + item;
+            }
+        });
+        this.reservadas.forEach(item => {
+            if (valor.toUpperCase().includes(item.toUpperCase())) {
+                indice = (valor.toUpperCase().indexOf(item.toUpperCase()));
+                if (indice == 0 || (this.validarEspacio(valor.charAt(indice - 1)) && this.validarEspacio(valor.charAt(item.length + indice)))) {
+                    mensaje = 'No puede contener ' + item;
+                }
+            }
+        });
+        return mensaje;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    validarTextoArchivoJasper(texto) {
+        if (texto.trim() == '' || texto == null) {
+            return "El campo no puede estar vacio";
+        }
+        if (texto.match("^[^\\D].*")) {
+            return "El campo no puede iniciar con numeros";
+        }
+        if (texto.match("^[^\\S].*")) {
+            return "El campo no puede iniciar con caracteres en blanco";
+        }
+        if (!texto.match("^[^\\W].*")) {
+            return "El campo no puede iniciar con caracteres especiales";
+        }
+        return null;
+    }
+    resizeWindowIFrame() {
+        if (window.frameElement != null) {
+            this.resizeIframeKeepPosition(window.frameElement);
+        }
+    }
+    /**
+     * Funcion para mantener la posición actual en el iframe.
+     * @param obj es un "FrameElement"
+     */
+    resizeIframeKeepPosition(obj) {
+        var ifrm = obj;
+        var doc = ifrm.contentDocument ? ifrm.contentDocument : ifrm.contentWindow.document;
+        var tamanio = this.getDocHeight(doc) + 40;
+        ifrm.style.height = tamanio + "px";
+    }
+    getDocHeight(doc) {
+        console.log('getDocHeight');
+        let navegador = this.obtenerNavegador().toLowerCase();
+        var height = 0;
+        doc = doc || document;
+        const appRoot = doc.querySelector('app-root');
+        const swalPopup = doc.querySelector('.swal2-popup');
+        if (swalPopup) {
+            return swalPopup.offsetHeight + 40;
+        }
+        // Si encuentra el elemento <app-root>, retorna su altura
+        if (appRoot) {
+            return appRoot.offsetHeight;
+        }
+        //var body = doc.body, html = doc.documentElement;
+        //height = Math.max( body.scrollHeight, body.offsetHeight, 
+        //html.clientHeight, html.scrollHeight, html.offsetHeight );
+        if (navegador.indexOf('firefox') !== -1) {
+            if (doc.formDetalleConvocatoria) {
+                let cantidadMiles = height / 1000;
+                height = height + 600 + (cantidadMiles * 40);
+            }
+        }
+        //	console.warn('FCO : llama a getDocHeight');
+        return height;
+    }
+    obtenerNavegador() {
+        var ua = navigator.userAgent, tem, M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+        if (/trident/i.test(M[1])) {
+            tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
+            return 'IE ' + (tem[1] || '');
+        }
+        if (M[1] === 'Chrome') {
+            tem = ua.match(/\b(OPR|Edge)\/(\d+)/);
+            if (tem != null)
+                return tem.slice(1).join(' ').replace('OPR', 'Opera');
+        }
+        M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
+        if ((tem = ua.match(/version\/(\d+)/i)) != null)
+            M.splice(1, 1, tem[1]);
+        return M.join(' ');
+    }
+    obtenerUrlApi(urlapi) {
+        if (urlapi) {
+            return urlapi;
+        }
+        switch (this.getTokenKey('aplicacion')) {
+            case '1':
+                return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');
+            case '13':
+                return window['env']['urlapimana'] ? window['env']['urlapimana'] : this.cookieService.get('urlnucleo');
+            case '10':
+                return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');
+            //return window['env']['urlapi'] ? window['env']['urlapi'] : this.cookieService.get('urlnucleo');
+            case '77':
+                return window['env']['urlapimanaaps'] ? window['env']['urlapimanaaps'] : this.cookieService.get('urlnucleo');
+            default:
+                return this.cookieService.get('urlnucleo');
+        }
+    }
+    getTokenKey(key) {
+        try {
+            const data = this._decodeToken();
+            return data[key].toString();
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    _decodeToken() {
+        try {
+            const token = this.getItem('token', '');
+            const data = token.split('.')[1];
+            return JSON.parse(atob(data));
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    getItem(key, defaultValue) {
+        return localStorage.getItem(this.obtenerBase() + '_' + key) ?? defaultValue;
+    }
+    cambiarTema(tema) {
+        localStorage.setItem(this.obtenerBase() + '_' + 'tema', tema);
+        let linkTema = this.document.getElementById('temaApp');
+        linkTema.href = `${tema}.css`;
+    }
+    calcularPosicionDialog() {
+        const { x, y } = this.clickPositionService.getClickPosition();
+        console.log('lastClickPosition');
+        console.log(x);
+        console.log(y);
+        //const elemento = event.target as HTMLElement;
+        //const elementoCoordenada = elemento.getBoundingClientRect();
+        //const iframe =  window.frameElement;
+        var ifrm = window.frameElement;
+        var doc = ifrm.contentDocument ? ifrm.contentDocument : ifrm.contentWindow.document;
+        var tamanio = this.getDocHeight(doc) + 40;
+        const iframeOffsetTop = tamanio ? -(tamanio / 2) : 0;
+        const dialog = document.querySelector('.p-dialog');
+        if (dialog) {
+            var topPosition = iframeOffsetTop + y;
+            const calculoPosicionPopup = y + (dialog.offsetHeight / 2);
+            if (calculoPosicionPopup > tamanio) {
+                var diferencia = calculoPosicionPopup - tamanio;
+                topPosition = topPosition - diferencia - 10;
+            }
+            dialog.style.top = `${topPosition}px`;
+        }
+    }
+    validarPalabra(texto) {
+        const pletras = /^[a-zA-Z][0-9a-zA-Z]*$/;
+        return pletras.test(texto);
+    }
+    isNumeric(value) {
+        return !isNaN(Number(value));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: UtilsService, deps: [{ token: i1.CookieService }, { token: DOCUMENT }, { token: i2.ClickPosicionService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: UtilsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.CookieService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i2.ClickPosicionService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../../../src/app/core/servicios/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { CookieService } from 'ngx-cookie-service';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { ClickPosicionService } from './click-posicion.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UtilsService {\r\n\r\n  private RESERVADAS_SQL_NOPUEDECONTENER: any[] = [';']\r\n  private reservadas: any[] = ['ALTER', 'DELETE', 'DROP', 'MODIFY', 'CREATE', 'DATABASE', 'TABLE', 'UPDATE', 'TRIGGER', 'GRANT', 'REVOKE', 'CALL', 'INSERT', 'TRUNCATE', 'USE', '--']\r\n  \r\n  constructor(private cookieService: CookieService, @Inject(DOCUMENT) private document: Document, private clickPositionService: ClickPosicionService){\r\n  }\r\n  \r\n  public generarLlave() {\r\n    let result = '';\r\n    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\r\n    const charactersLength = 32;\r\n    for (let i = 0; i < charactersLength; i++) {\r\n      result += characters.charAt(Math.floor(Math.random() * charactersLength));\r\n    }\r\n\r\n    return result.toLowerCase();\r\n  }\r\n\r\n\r\n\r\n  public generarPin(cantidad: number) {\r\n    let result = '';\r\n    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\r\n    for (let i = 0; i < cantidad; i++) {\r\n      result += characters.charAt(Math.floor(Math.random() * cantidad));\r\n    }\r\n\r\n    return result.toLowerCase();\r\n  }\r\n\r\n  rightpad(str, length, char) {\r\n    if (str === undefined) {\r\n      return null;\r\n    }\r\n    if (typeof str !== 'string' || typeof length !== 'number') {\r\n      throw new TypeError('Los argumentos deben ser una cadena y un número.');\r\n    }\r\n\r\n    if (str.length >= length) {\r\n      return str;\r\n    }\r\n\r\n    char = char || ' '; // Utiliza un espacio como carácter de relleno si no se proporciona uno\r\n\r\n    var padLength = length - str.length;\r\n    var padding = char.repeat(padLength);\r\n\r\n    return str + padding;\r\n  }\r\n\r\n  validarCampoNumerico(event: any) {\r\n    const input = event.target;\r\n    const regex = /[^0-9]/gi;\r\n    input.value = input.value.replace(regex, '');\r\n  }\r\n\r\n  isNotBlank(str: string | String | null | undefined): boolean {\r\n    return str != null && str.trim().length > 0;\r\n  }\r\n\r\n  isBlank(str: string | String | null | undefined): boolean {\r\n    return str == null || str?.trim() === '';\r\n  }\r\n\r\n  validarCampoObligatorio(valor): boolean {\r\n    // Verificar si el valor no es null ni undefined\r\n    if (valor !== null && valor !== undefined) {\r\n      // Verificar si el valor no es una cadena vacía (en caso de ser una cadena)\r\n      if (typeof valor === 'string' && valor.trim() === '') {\r\n        return false;\r\n      }\r\n      // Verificar si el valor no es un arreglo vacío (en caso de ser un arreglo)\r\n      if (Array.isArray(valor) && valor.length === 0) {\r\n        return false;\r\n      }\r\n      /*if (typeof valor === 'object' && Object.keys(valor).length === 0) {\r\n        return false;\r\n      }*/\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  capitalizeFully(inputString: string): string {\r\n    if (!inputString) {\r\n      return '';\r\n    }\r\n    const words = inputString.split(' ');\r\n    const capitalizedWords = words.map(word => {\r\n      if (word.length > 0) {\r\n        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\r\n      }\r\n      return '';\r\n    });\r\n    const result = capitalizedWords.join(' ');\r\n    return result;\r\n  }\r\n\r\n  ordenarSelectItemsAlfabeticamente(arrayDeObjetos: any[]): any[] {\r\n    arrayDeObjetos.sort((a, b) => {\r\n      const nombreA = a.label.toLowerCase();\r\n      const nombreB = b.label.toLowerCase();\r\n\r\n      if (nombreA < nombreB) {\r\n        return -1;\r\n      }\r\n      if (nombreA > nombreB) {\r\n        return 1;\r\n      }\r\n      return 0;\r\n    });\r\n    return arrayDeObjetos;\r\n  }\r\n\r\n  obtenerParametroDeURL(urlString: string, parametro: string): string | null {\r\n    const url = new URL(urlString);\r\n    const searchParams = new URLSearchParams(url.search);\r\n    return searchParams.get(parametro);\r\n  }\r\n\r\n  validarEmail(email: string): boolean {\r\n    const patronEmail = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/;\r\n    return patronEmail.test(email);\r\n  }\r\n\r\n  obtenerBase(): (string | null) {\r\n\r\n    var basePortal: string = null;\r\n    var paginaActual: any = window.location.href\r\n    var url = new URL(paginaActual);\r\n    var params = new URLSearchParams(url.search);\r\n    if (paginaActual.toString().includes('PortalSara')) {\r\n      for (var match of paginaActual.matchAll(/(?<inicio>.*)\\/(?<seguridad>.*)\\/(?<sitio>.*)\\/(?<pagina>.*)/g)) {\r\n        basePortal = match.groups?.seguridad;\r\n      }\r\n    } else if (params?.get('us_id')) {\r\n      paginaActual = window.parent.location.href;\r\n      for (var match of paginaActual.matchAll(/(?<inicio>.*)\\/(?<seguridad>.*)\\/(?<sitio>.*)\\/(?<pagina>.*)/g)) {\r\n        basePortal = match.groups?.seguridad;\r\n      }\r\n    } else {\r\n      const regex = /^.*?\\/\\/.*?\\/(.*?)\\//g; // Expresión regular para obtener la primera parte de la URL\r\n      const match = Array.from(paginaActual.matchAll(regex));\r\n\r\n      if (match && match[0] && match[0][1]) {\r\n        basePortal = match[0][1];\r\n      }\r\n    }\r\n    return basePortal;\r\n  }\r\n\r\n  private validarEspacio(caracter: string): boolean {\r\n    const regex = /\\s/; // La expresión regular para espacios en blanco\r\n    return regex.test(caracter); // Devuelve true si el carácter es un espacio en blanco\r\n  }\r\n\r\n  public validarTextoSQL(valor: string, obligatorio: boolean, select: boolean, longitud: number, validarSentencia: boolean): (string | null) {\r\n    // Verifica obligatoriedad\r\n    if (obligatorio && (valor == null || valor.trim().length == 0 || valor == '--')) {\r\n      return 'Obligatorio';\r\n    }\r\n    // Verifica longitud máxima\r\n    if (longitud > 0) {\r\n      if (valor != null && valor != '--' && valor.length > longitud) {\r\n        return 'Longitud maxima de ' + longitud;\r\n      }\r\n    }\r\n    // Realiza las demás validacion solo en el caso de que la cadena SQL/valor no sea vacia\r\n    if (valor == null || valor.trim().length == 0 || valor == '--')\r\n      return null;\r\n\r\n    if (validarSentencia) {\r\n      if (select) {\r\n        if (!valor.toUpperCase().startsWith('SELECT')) {\r\n          return 'El texto debe iniciar con la palabra Select';\r\n        }\r\n      } else {\r\n        if (valor.toUpperCase().includes('SELECT')) {\r\n          return 'No puede contener la palabra Select';\r\n        }\r\n      }\r\n    }\r\n    var indice: number;\r\n    var mensaje: string;\r\n    this.RESERVADAS_SQL_NOPUEDECONTENER.forEach(item => {\r\n      if (valor.includes(item)) {\r\n        mensaje = 'No puede contener ' + item;\r\n      }\r\n    })\r\n    this.reservadas.forEach(item => {\r\n      if (valor.toUpperCase().includes(item.toUpperCase())) {\r\n        indice = (valor.toUpperCase().indexOf(item.toUpperCase()));\r\n        if (indice == 0 || (this.validarEspacio(valor.charAt(indice - 1)) && this.validarEspacio(valor.charAt(item.length + indice)))) {\r\n          mensaje = 'No puede contener ' + item;\r\n        }\r\n      }\r\n    })\r\n    return mensaje;\r\n  }\r\n\r\n  sleep(ms: number): Promise<void> {\r\n    return new Promise((resolve) => setTimeout(resolve, ms));\r\n  }\r\n\r\n  validarTextoArchivoJasper(texto: string): (string | null) {\r\n    if (texto.trim() == '' || texto == null) {\r\n      return \"El campo no puede estar vacio\";\r\n    }\r\n    if (texto.match(\"^[^\\\\D].*\")) {\r\n      return \"El campo no puede iniciar con numeros\";\r\n    }\r\n    if (texto.match(\"^[^\\\\S].*\")) {\r\n      return \"El campo no puede iniciar con caracteres en blanco\";\r\n    }\r\n    if (!texto.match(\"^[^\\\\W].*\")) {\r\n      return \"El campo no puede iniciar con caracteres especiales\";\r\n    }\r\n    return null;\r\n  }\r\n\r\n  resizeWindowIFrame() {\r\n\t\tif ( window.frameElement != null) {\r\n\t\t\tthis.resizeIframeKeepPosition(window.frameElement);\r\n\t\t}\r\n\t}\r\n\t\r\n\t/**\r\n\t * Funcion para mantener la posición actual en el iframe.\r\n\t * @param obj es un \"FrameElement\"\r\n\t */\r\n\tprivate resizeIframeKeepPosition(obj) {\r\n\t\t\r\n\t\tvar ifrm = obj;\r\n\t\tvar doc = ifrm.contentDocument ? ifrm.contentDocument: ifrm.contentWindow.document;\r\n    var tamanio: number=  this.getDocHeight( doc )  + 40\r\n\t\tifrm.style.height = tamanio + \"px\";\r\n\t}\r\n\r\n\tprivate getDocHeight(doc){\r\n    console.log('getDocHeight')\r\n\t\tlet navegador = this.obtenerNavegador().toLowerCase();\r\n\t\tvar height = 0;\r\n\t\tdoc = doc || document;\r\n    const appRoot = doc.querySelector('app-root');\r\n\r\n    const swalPopup = doc.querySelector('.swal2-popup');\r\n    if (swalPopup) {\r\n        return swalPopup.offsetHeight + 40;\r\n    }\r\n\r\n    // Si encuentra el elemento <app-root>, retorna su altura\r\n    if (appRoot) {\r\n        return appRoot.offsetHeight;\r\n    }\r\n\t\t//var body = doc.body, html = doc.documentElement;\r\n\t\t//height = Math.max( body.scrollHeight, body.offsetHeight, \r\n\t\t//html.clientHeight, html.scrollHeight, html.offsetHeight );\r\n\t\t\r\n\t\tif (navegador.indexOf('firefox') !== -1){\r\n\t\t\tif(doc.formDetalleConvocatoria){\r\n\t\t\t\tlet cantidadMiles = height / 1000;\r\n\t\t\t\theight = height + 600 + (cantidadMiles*40)\r\n\t\t\t}\r\n\t\t}\r\n\t\t\r\n\t//\tconsole.warn('FCO : llama a getDocHeight');\r\n\t\r\n\t\treturn height;\r\n\t}\r\n\r\n\tobtenerNavegador(){\r\n\t\tvar ua= navigator.userAgent, tem, \r\n\t\tM= ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\\/))\\/?\\s*(\\d+)/i) || [];\r\n\t\tif(/trident/i.test(M[1])){\r\n\t\t\ttem=  /\\brv[ :]+(\\d+)/g.exec(ua) || [];\r\n\t\t\treturn 'IE '+(tem[1] || '');\r\n\t\t}\r\n\t\tif(M[1]=== 'Chrome'){\r\n\t\t\ttem= ua.match(/\\b(OPR|Edge)\\/(\\d+)/);\r\n\t\t\tif(tem!= null) return tem.slice(1).join(' ').replace('OPR', 'Opera');\r\n\t\t}\r\n\t\tM= M[2]? [M[1], M[2]]: [navigator.appName, navigator.appVersion, '-?'];\r\n\t\tif((tem= ua.match(/version\\/(\\d+)/i))!= null) M.splice(1, 1, tem[1]);\r\n\t\treturn M.join(' ');\r\n\t}\r\n\r\n  obtenerUrlApi(urlapi?: string ): string {\r\n    if (urlapi){\r\n      return urlapi;\r\n    }\r\n    switch (this.getTokenKey('aplicacion')) {\r\n      case '1':\r\n        return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');\r\n      case '13':\r\n        return window['env']['urlapimana'] ? window['env']['urlapimana'] : this.cookieService.get('urlnucleo');\r\n      case '10':\r\n        return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');\r\n        //return window['env']['urlapi'] ? window['env']['urlapi'] : this.cookieService.get('urlnucleo');\r\n      case '77':\r\n        return window['env']['urlapimanaaps'] ? window['env']['urlapimanaaps'] : this.cookieService.get('urlnucleo');\r\n      default:\r\n        return  this.cookieService.get('urlnucleo');\r\n    }\r\n  }\r\n\r\n  private getTokenKey(key: string): string {\r\n    try {\r\n      const data = this._decodeToken();\r\n      return data[key].toString();\r\n    } catch (error) {\r\n      return undefined;\r\n    }\r\n  }\r\n\r\n  private _decodeToken(): any {\r\n    try {\r\n      const token = this.getItem('token', '');\r\n      const data = token.split('.')[1];\r\n      return JSON.parse(atob(data));\r\n    } catch (error) {\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  getItem(key: string, defaultValue?: string): string | undefined {\r\n    return localStorage.getItem(this.obtenerBase() + '_' +  key) ?? defaultValue;\r\n  }\r\n\r\n  cambiarTema(tema : ('temaClaro' | 'temaOscuro')){\r\n    localStorage.setItem(this.obtenerBase() + '_' +'tema', tema);\r\n    let linkTema = this.document.getElementById('temaApp') as HTMLLinkElement;\r\n    linkTema.href = `${tema}.css`\r\n  }\r\n\r\n  calcularPosicionDialog() {\r\n    const { x, y } = this.clickPositionService.getClickPosition();\r\n\r\n    console.log('lastClickPosition')\r\n    console.log(x)\r\n    console.log(y)\r\n    //const elemento = event.target as HTMLElement;\r\n    //const elementoCoordenada = elemento.getBoundingClientRect();\r\n\r\n    //const iframe =  window.frameElement;\r\n    var ifrm: any = window.frameElement;\r\n\t\tvar doc = ifrm.contentDocument ? ifrm.contentDocument: ifrm.contentWindow.document;\r\n    var tamanio: number=  this.getDocHeight( doc )  + 40\r\n    const iframeOffsetTop = tamanio ? -(tamanio/2) : 0;\r\n\r\n    const dialog = document.querySelector('.p-dialog') as HTMLElement;\r\n\r\n    if (dialog) {\r\n      var topPosition = iframeOffsetTop + y;\r\n      const calculoPosicionPopup = y + (dialog.offsetHeight/2)\r\n      if (calculoPosicionPopup > tamanio) {\r\n        var diferencia = calculoPosicionPopup - tamanio;\r\n        topPosition = topPosition - diferencia - 10;\r\n      }\r\n      dialog.style.top = `${topPosition}px`;\r\n    }\r\n  }\r\n  \r\n  validarPalabra(texto: string): boolean {\r\n    const pletras = /^[a-zA-Z][0-9a-zA-Z]*$/;\r\n    return pletras.test(texto);\r\n  }\r\n\r\n  isNumeric(value: string): boolean {\r\n    return !isNaN(Number(value));\r\n  }\r\n  \r\n}"]}

package/esm2022/src/app/core/sharedlib.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SharedLibModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: SharedLibModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.4", ngImport: i0, type: SharedLibModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: SharedLibModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: SharedLibModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [],
+                    exports: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkbGliLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvY29yZS9zaGFyZWRsaWIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBVXpDLE1BQU0sT0FBTyxlQUFlO3VHQUFmLGVBQWU7d0dBQWYsZUFBZTt3R0FBZixlQUFlOzsyRkFBZixlQUFlO2tCQVIzQixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxFQUNiO29CQUNELE9BQU8sRUFBRSxFQUNOO29CQUNILE9BQU8sRUFBRSxFQUNSO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgZGVjbGFyYXRpb25zOiBbXHJcbiAgXSxcclxuICBpbXBvcnRzOiBbXHJcbiAgICBdLFxyXG4gIGV4cG9ydHM6IFtcclxuICBdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTaGFyZWRMaWJNb2R1bGUge31cclxuIl19

package/esm2022/src/app/core/utilidades/color.util.mjs

@@ -0,0 +1,177 @@
+export class ColorUtil {
+    /**
+     * Define las variables CSS del tema y las agrega al documento.
+     * Se definene 9 colores alternativos más el color principal.
+     * Adicional se agregan las componentes HSL del color para hacer
+     * variaciones personalizadas y ajustar la opacidad.
+     * @param color Color principal del tema
+     */
+    static addPalleteToRoot(color) {
+        const head = (document.head || document.getElementsByTagName('head')[0]);
+        const style = document.createElement('style');
+        const { hue, saturation, lightness } = this.RGB2HSL(color);
+        const contrast = this.contrastColor(color) === 1 ? '--color-50' : '--color-900';
+        const intermediateColors = [50, 75, 85];
+        let index = 0;
+        const css = ':root { ' +
+            this._generatePalette(color)
+                .map((color, position) => {
+                if (index < 100) {
+                    index = intermediateColors[position] ? intermediateColors[position] : 100;
+                }
+                else {
+                    index += 100;
+                }
+                return `--color-${index}: ${color};`;
+            })
+                .join('') +
+            `--color-h: ${hue};` +
+            `--color-s: ${saturation}%;` +
+            `--color-l: ${lightness}%;` +
+            `--color-contrast: var(${contrast});` +
+            '}';
+        style.type = 'text/css';
+        style.appendChild(document.createTextNode(css));
+        head.appendChild(style);
+    }
+    /**
+     * Mezcla dos colores en proporción a un porcentaje para obtener un
+     * nuevo color.
+     * @param baseColor Color base para mezclar
+     * @param color Color que se quiere mezclar
+     * @param weight Porcentaje que se quiere mezclar. Entre 0 y 1
+     * @returns Color resultante en formato RGB (#AABBCC)
+     */
+    static mix(baseColor, color, weight) {
+        const newColor = [];
+        baseColor = this._normalizeColor(baseColor);
+        color = this._normalizeColor(color);
+        const rgbColorBase = this._getRGBValues(baseColor);
+        const rgbColorAdjust = this._getRGBValues(color);
+        ['red', 'green', 'blue'].forEach((part) => {
+            newColor.push(Math.round(rgbColorAdjust[part] + (rgbColorBase[part] - rgbColorAdjust[part]) * weight)
+                .toString(16)
+                .padStart(2, '0'));
+        });
+        return '#' + newColor.join('');
+    }
+    /**
+     * Aclara un color proporcionalmente.
+     * @param color Color base para modificar
+     * @param percent Porcentaje de blanco que se agrega
+     * @returns Nuevo color más claro
+     */
+    static tint(color, percent) {
+        return this.mix('#fff', color, percent);
+    }
+    /**
+     * Oscurece un color proporcionalmente.
+     * @param color Color base para modificar
+     * @param percent  Porcentaje de negro que se agrega
+     * @returns Nuevo color más oscuro
+     */
+    static shade(color, percent) {
+        return this.mix('#000', color, percent);
+    }
+    /**
+     * Transforma un color en RGB a su equivalente en formato HSL
+     * @param color Color en formato RGB
+     * @returns Arreglo de componentes HSL
+     */
+    static RGB2HSL(color) {
+        color = this._normalizeColor(color);
+        let { red, green, blue } = this._getRGBValues(color);
+        red /= 255;
+        green /= 255;
+        blue /= 255;
+        const max = Math.max(red, green, blue);
+        const min = Math.min(red, green, blue);
+        let hue = 0;
+        let saturation = 0;
+        let lightness = (max + min) / 2;
+        if (max != min) {
+            const delta = max - min;
+            saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+            switch (max) {
+                case red:
+                    hue = (green - blue) / delta + (green < blue ? 6 : 0);
+                    break;
+                case green:
+                    hue = (blue - red) / delta + 2;
+                    break;
+                case blue:
+                    hue = (red - green) / delta + 4;
+                    break;
+            }
+            hue /= 6;
+        }
+        hue = Math.round(hue * 360);
+        saturation = Math.round(saturation * 100);
+        lightness = Math.round(lightness * 100);
+        return { hue, saturation, lightness };
+    }
+    /**
+     * Retorna 1 (blanco) o 0 (negro) para contrastar el color enviado.
+     * @param color Color del cual se quiere buscar el contraste
+     * @returns Blanco o Negro en RGB
+     */
+    static contrastColor(color) {
+        color = this._normalizeColor(color);
+        const { red, green, blue } = this._getRGBValues(color);
+        return red * 0.299 + green * 0.587 + blue * 0.114 > 186 ? 0 : 1;
+    }
+    /**
+     * Valida que la cadena de texto represente un color RGB válido y
+     * retorna las componentes del color en formato de seis caracteres.
+     * @param color Color en formato RGB. Ejemplo: (#000)
+     * @returns String del color sin el simbolo #
+     */
+    static _normalizeColor(color) {
+        const rgbColor = color.match(/^#([0-9A-F]{3}|[0-9A-F]{6})$/i);
+        if (!rgbColor) {
+            throw new Error(`${color} is not a RGB color.`);
+        }
+        const colorParts = rgbColor[1].toLowerCase();
+        if (colorParts.length === 3) {
+            return colorParts.replace(/(.)/g, '$1$1');
+        }
+        return colorParts;
+    }
+    /**
+     * Transforma un color Hexadecimal a Decimal en sus respectivas
+     * comopnenetes.
+     * @param color Color en Hecadecimal para descomponer
+     * @returns Un objeto {red, green, blue} en decimal
+     */
+    static _getRGBValues(color) {
+        const red = parseInt(color.slice(0, 2), 16);
+        const green = parseInt(color.slice(2, 4), 16);
+        const blue = parseInt(color.slice(4, 6), 16);
+        return { red, green, blue };
+    }
+    /**
+     * Define una paleta de 10 colores, 5 más claros y 4 más oscuros basados
+     * en el color principal. El color principal será el color medio de la paleta
+     * @param color Color base para definir los demás colores
+     * @returns Arreglo de todos los colores de la paleta
+     */
+    static _generatePalette(color) {
+        const palette = [];
+        for (let i = 0; i < 5; i++) {
+            if (i === 0) {
+                palette.push(this.tint(color, (5 - i) * 0.19));
+                palette.push(this.tint(color, (4.8 - i) * 0.19));
+                palette.push(this.tint(color, (4.55 - i) * 0.19));
+            }
+            else {
+                palette.push(this.tint(color, (5 - i) * 0.19));
+            }
+        }
+        palette.push(color);
+        for (let i = 1; i < 5; i++) {
+            palette.push(this.shade(color, i * 0.15));
+        }
+        return palette;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"color.util.js","sourceRoot":"","sources":["../../../../../../src/app/core/utilidades/color.util.ts"],"names":[],"mappings":"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","sourcesContent":["export class ColorUtil {\r\n  /**\r\n   * Define las variables CSS del tema y las agrega al documento.\r\n   * Se definene 9 colores alternativos más el color principal.\r\n   * Adicional se agregan las componentes HSL del color para hacer\r\n   * variaciones personalizadas y ajustar la opacidad.\r\n   * @param color Color principal del tema\r\n   */\r\n  static addPalleteToRoot(color: string): void {\r\n    const head = (document.head || document.getElementsByTagName('head')[0]) as HTMLHeadElement;\r\n    const style = document.createElement('style') as HTMLStyleElement;\r\n    const { hue, saturation, lightness } = this.RGB2HSL(color);\r\n    const contrast = this.contrastColor(color) === 1 ? '--color-50' : '--color-900';\r\n\r\n    const intermediateColors = [50, 75, 85]\r\n    let index = 0;\r\n    const css =\r\n      ':root { ' +\r\n      this._generatePalette(color)\r\n        .map((color, position) => {\r\n          if(index < 100){\r\n            index = intermediateColors[position] ? intermediateColors[position] : 100;\r\n          } else {\r\n            index += 100;\r\n          }\r\n          return `--color-${index}: ${color};`;\r\n        })\r\n        .join('') +\r\n      `--color-h: ${hue};` +\r\n      `--color-s: ${saturation}%;` +\r\n      `--color-l: ${lightness}%;` +\r\n      `--color-contrast: var(${contrast});` +\r\n      '}';\r\n    style.type = 'text/css';\r\n    style.appendChild(document.createTextNode(css));\r\n    head.appendChild(style);\r\n  }\r\n\r\n  /**\r\n   * Mezcla dos colores en proporción a un porcentaje para obtener un\r\n   * nuevo color.\r\n   * @param baseColor Color base para mezclar\r\n   * @param color Color que se quiere mezclar\r\n   * @param weight Porcentaje que se quiere mezclar. Entre 0 y 1\r\n   * @returns Color resultante en formato RGB (#AABBCC)\r\n   */\r\n  static mix(baseColor: string, color: string, weight: number): string {\r\n    const newColor = [];\r\n    baseColor = this._normalizeColor(baseColor);\r\n    color = this._normalizeColor(color);\r\n\r\n    const rgbColorBase = this._getRGBValues(baseColor);\r\n    const rgbColorAdjust = this._getRGBValues(color);\r\n\r\n    ['red', 'green', 'blue'].forEach((part) => {\r\n      newColor.push(\r\n        Math.round(rgbColorAdjust[part] + (rgbColorBase[part] - rgbColorAdjust[part]) * weight)\r\n          .toString(16)\r\n          .padStart(2, '0')\r\n      );\r\n    });\r\n\r\n    return '#' + newColor.join('');\r\n  }\r\n\r\n  /**\r\n   * Aclara un color proporcionalmente.\r\n   * @param color Color base para modificar\r\n   * @param percent Porcentaje de blanco que se agrega\r\n   * @returns Nuevo color más claro\r\n   */\r\n  static tint(color: string, percent: number): string {\r\n    return this.mix('#fff', color, percent);\r\n  }\r\n\r\n  /**\r\n   * Oscurece un color proporcionalmente.\r\n   * @param color Color base para modificar\r\n   * @param percent  Porcentaje de negro que se agrega\r\n   * @returns Nuevo color más oscuro\r\n   */\r\n  static shade(color: string, percent: number): string {\r\n    return this.mix('#000', color, percent);\r\n  }\r\n\r\n  /**\r\n   * Transforma un color en RGB a su equivalente en formato HSL\r\n   * @param color Color en formato RGB\r\n   * @returns Arreglo de componentes HSL\r\n   */\r\n  static RGB2HSL(color: string): { hue: number; saturation: number; lightness: number } {\r\n    color = this._normalizeColor(color);\r\n\r\n    let { red, green, blue } = this._getRGBValues(color);\r\n    red /= 255;\r\n    green /= 255;\r\n    blue /= 255;\r\n\r\n    const max = Math.max(red, green, blue);\r\n    const min = Math.min(red, green, blue);\r\n\r\n    let hue = 0;\r\n    let saturation = 0;\r\n    let lightness = (max + min) / 2;\r\n\r\n    if (max != min) {\r\n      const delta = max - min;\r\n      saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);\r\n      switch (max) {\r\n        case red:\r\n          hue = (green - blue) / delta + (green < blue ? 6 : 0);\r\n          break;\r\n        case green:\r\n          hue = (blue - red) / delta + 2;\r\n          break;\r\n        case blue:\r\n          hue = (red - green) / delta + 4;\r\n          break;\r\n      }\r\n      hue /= 6;\r\n    }\r\n\r\n    hue = Math.round(hue * 360);\r\n    saturation = Math.round(saturation * 100);\r\n    lightness = Math.round(lightness * 100);\r\n\r\n    return { hue, saturation, lightness };\r\n  }\r\n\r\n  /**\r\n   * Retorna 1 (blanco) o 0 (negro) para contrastar el color enviado.\r\n   * @param color Color del cual se quiere buscar el contraste\r\n   * @returns Blanco o Negro en RGB\r\n   */\r\n  static contrastColor(color: string): number {\r\n    color = this._normalizeColor(color);\r\n    const { red, green, blue } = this._getRGBValues(color);\r\n    return red * 0.299 + green * 0.587 + blue * 0.114 > 186 ? 0 : 1;\r\n  }\r\n\r\n  /**\r\n   * Valida que la cadena de texto represente un color RGB válido y\r\n   * retorna las componentes del color en formato de seis caracteres.\r\n   * @param color Color en formato RGB. Ejemplo: (#000)\r\n   * @returns String del color sin el simbolo #\r\n   */\r\n  private static _normalizeColor(color: string): string {\r\n    const rgbColor = color.match(/^#([0-9A-F]{3}|[0-9A-F]{6})$/i);\r\n    if (!rgbColor) {\r\n      throw new Error(`${color} is not a RGB color.`);\r\n    }\r\n\r\n    const colorParts = rgbColor[1].toLowerCase();\r\n    if (colorParts.length === 3) {\r\n      return colorParts.replace(/(.)/g, '$1$1');\r\n    }\r\n\r\n    return colorParts;\r\n  }\r\n\r\n  /**\r\n   * Transforma un color Hexadecimal a Decimal en sus respectivas\r\n   * comopnenetes.\r\n   * @param color Color en Hecadecimal para descomponer\r\n   * @returns Un objeto {red, green, blue} en decimal\r\n   */\r\n  private static _getRGBValues(color: string): { red: number; green: number; blue: number } {\r\n    const red = parseInt(color.slice(0, 2), 16);\r\n    const green = parseInt(color.slice(2, 4), 16);\r\n    const blue = parseInt(color.slice(4, 6), 16);\r\n    return { red, green, blue };\r\n  }\r\n\r\n  /**\r\n   * Define una paleta de 10 colores, 5 más claros y 4 más oscuros basados\r\n   * en el color principal. El color principal será el color medio de la paleta\r\n   * @param color Color base para definir los demás colores\r\n   * @returns Arreglo de todos los colores de la paleta\r\n   */\r\n  private static _generatePalette(color: string): string[] {\r\n    const palette = [];\r\n    for (let i = 0; i < 5; i++) {\r\n      if(i === 0) {\r\n        palette.push(this.tint(color, (5 - i) * 0.19));\r\n        palette.push(this.tint(color, (4.8 - i) * 0.19));\r\n        palette.push(this.tint(color, (4.55 - i) * 0.19));\r\n      } else {\r\n        palette.push(this.tint(color, (5 - i) * 0.19));\r\n      }\r\n    }\r\n    palette.push(color);\r\n    for (let i = 1; i < 5; i++) {\r\n      palette.push(this.shade(color, i * 0.15));\r\n    }\r\n    return palette;\r\n  }\r\n}\r\n"]}

package/esm2022/src/app/layout/api/menuchangeevent.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudWNoYW5nZWV2ZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9sYXlvdXQvYXBpL21lbnVjaGFuZ2VldmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBNZW51Q2hhbmdlRXZlbnQge1xyXG4gICAga2V5OiBzdHJpbmc7XHJcbiAgICByb3V0ZUV2ZW50PzogYm9vbGVhbjtcclxufSJdfQ==