@masterkeymaterial/ui 0.0.2 → 0.0.3

package/src/util/util.ts

@@ -1,2151 +0,0 @@
-import { WritableSignal } from "@angular/core";
-import { IFieldComponent } from "../fields/Formulario/Formulario";
-
-export class LibUtil {
-
-  static loglevel = 0;
-  static formConfigs: Partial<IFieldComponent<any>> = {};
-
-  static classof = (o: any): IClassOf => {
-    let nomeClasse = Object.prototype.toString.call(o).slice(8, -1).toLowerCase();
-    if (nomeClasse == "number") {
-      if (o.toString() == "NaN") {
-        nomeClasse = "nan";
-      }
-    }
-    return nomeClasse as IClassOf;
-  };
-
-  static wait = (ms: number) => {
-    // Essa mecânica usa um setTimeout. A mecânica do Queue não foi implementada
-    return new Promise(r => setTimeout(r, ms))
-  };
-
-  static clonar = (i: any) => {
-    // Clona com a técnica de montar e desmontar string.
-    // Não funciona para objetos com serviços (Date, File, Map, Set, etc)
-    let parsed = null;
-    try {
-      let stringified = JSON.stringify(i);
-      if (stringified == null) return null;
-      if (stringified == "") return "";
-      parsed = JSON.parse(stringified);
-      if (parsed == null) return null;
-    } catch (e) {
-      return null;
-    }
-    return parsed;
-  };
-
-  static limparObject = (o: any) => {
-    // Converte (Object) Limpar Nulos e Vazios
-    if (LibUtil.classof(o) == "object") {
-      for (let propName in o) {
-        if (
-          o[propName as keyof typeof o] === null ||
-          o[propName as keyof typeof o] === undefined ||
-          o[propName as keyof typeof o] === "" ||
-          o[propName as keyof typeof o] === "undefined"
-        ) {
-          delete o[propName as keyof typeof o];
-        }
-      }
-    }
-    return o;
-  };
-
-  static mascarar = (texto: any, mascara: any): string | undefined => {
-    // Informando uma máscara e um texto, retorna dado mascarado.
-    // Mascaras: 0=Numero, A=Letra, Outros repete.
-    if (LibUtil.classof(mascara) != "string") {
-      // Se passar uma funcao para a mascara, Executa a função enviando o texto e deve retornar uma string da mascara para esse texto.
-      if (LibUtil.classof(mascara) == "function") {
-        mascara = mascara(texto); // Sobreextreve a mascara a ser executada pelo retorno da função.
-      }
-    }
-    if (mascara) {
-      if (texto) {
-        if (LibUtil.classof(texto) != "string") texto = texto?.toString();
-        if (LibUtil.classof(mascara) != "string") mascara = mascara?.toString(); // Se a chegar até aqui e ainda não for string
-        let ms = [...LibUtil.clonar(mascara)];
-        let ss = [...LibUtil.clonar(texto)];
-        // this.l("ss: ", ss);
-        let ts: any = [];
-        let pm = 0;
-        ss.forEach(s => {
-          let t = null;
-          if (/[0-9]/.test(s)) {
-            t = "0";
-          } else if (/[a-zA-Z]/.test(s)) {
-            t = "A";
-          } else {
-            t = " ";
-          }
-          ts.push(t);
-          pm++;
-        });
-        // this.l("ts: ", ts);
-        // this.l("ms: ", ms);
-        let r: any = [];
-        for (let tp = 0, mp = 0; (tp < ts.length) && (mp < ms.length); tp++, mp++) {
-          if (((ms[mp] === "0" || ms[mp] === "A") && (ms[mp] == ts[tp]))
-            || (ms[mp] === "S" && (ts[tp] === "A" || ts[tp] === "0"))) {
-            // FORMATO IGUAL.
-            r.push(ss[tp]);
-          } else {
-            // MESMO CARACTER
-            if (ss[tp] === ms[mp]) {
-              r.push(ss[tp]);
-            } else {
-              // this.l("> ", ss[tp], " vs ", ms[mp])
-              // Mágica: Coloca o especial que o usuário não colocou.
-              if (ms[mp] != "0" && ms[mp] != "A" && ms[mp] != "S") {
-                r.push(ms[mp]);
-                tp--;
-              } else {
-                mp--;
-              }
-            }
-          }
-        }
-        return r.join("");
-      }
-    } else {
-      console.log("❌ Mascarar Requer Texto: ", texto, " e Mascara: ", mascara);
-    }
-    return undefined;
-  };
-
-  static tryParseJSON(val: any): any[] | null {
-    try {
-      return JSON.parse(val);
-    } catch (e) {
-      return null;
-    }
-  }
-
-  static contem = (strMaior: string, strMenor: string): boolean => {
-    // Comparardor de string CONTEM
-    strMaior = LibUtil.removeAcentos(strMaior).toLowerCase();
-    strMenor = LibUtil.removeAcentos(strMenor).toLowerCase();
-    return (strMaior.includes(strMenor));
-  };
-
-  static removeAcentos = (s: string): string => {
-    if (s == null) return "";
-    // Remove acentos e depois chama Apenas Números e Letras.
-    s = s.toString();
-    let r = "";
-    let sS = "áàãâäéèêëíìîïóòõôöúùûüçÁÀÃÂÄÉÈÊËÍÌÎÏÓÒÕÖÔÚÙÛÜÇ";
-    let sN = "aaaaaeeeeiiiiooooouuuucAAAAAEEEEIIIIOOOOOUUUUC";
-    for (let p = 0; p < s.length; p++) {
-      let pSS = sS.indexOf(s.charAt(p)); // <= Procura
-      if (pSS != -1) {
-        r += sN.charAt(pSS); // Substitui mesma posicao
-      } else {
-        r += s.charAt(p);
-      }
-    }
-    return r;
-  };
-
-  static fileReader = async (arquivo: File, eventos?: Function): Promise<string | null> => {
-    return new Promise((r) => {
-      let leitor = new FileReader();
-      let gatilhos = (event: any) => {
-        if (event.type == "error") {
-          r(null);
-        }
-        else if (event.type == "loadend") {
-          // Quando terminar, o result já é a string completa.
-          let buffer = leitor.result as string;
-          r(buffer);
-        }
-        if (eventos)
-          eventos(event, Math.trunc((event.loaded / event.total) * 100));
-      }
-      if (arquivo) {
-        if (arquivo.name != "") {
-          leitor.addEventListener("loadstart", gatilhos);
-          leitor.addEventListener("progress", gatilhos);
-          leitor.addEventListener("error", gatilhos);
-          leitor.addEventListener("abort", gatilhos);
-          leitor.addEventListener("load", gatilhos);
-          leitor.addEventListener("loadend", gatilhos);
-          leitor.readAsDataURL(arquivo);
-        }
-        else {
-          LOG(1, "⚠️ fileReader() - Nome do arquivo necessário: ", arquivo.name);
-          r(null);
-        }
-      } else {
-        LOG(1, "⚠️ fileReader() - Arquivo Nulo: ", arquivo);
-        r(null);
-      }
-    });
-  };
-
-  static removeHtmlTags(texto: string): string {
-    return texto.replace(/<\/?[^>]+(>|$)/g, "");
-  }
-
-  // Salva a posição do cursor
-  static saveCursorPosition(element: any, plus: number = 0): { start: number; end: number, plus: number } | null {
-    const selection = window.getSelection();
-    if (!selection || selection.rangeCount === 0) return null;
-    const range = selection.getRangeAt(0);
-    const preCaretRange = range.cloneRange();
-    if (!element) return null;
-    preCaretRange.selectNodeContents(element);
-    preCaretRange.setEnd(range.startContainer, range.startOffset);
-    const start = preCaretRange.toString().length;
-    return {
-      start: start,
-      end: start + range.toString().length,
-      plus
-    };
-  }
-
-  // Restaura a posição do cursor
-  static restoreCursorPosition(element: any, position: { start: number; end: number, plus: number }) {
-    if (!element) return;
-    const selection = window.getSelection();
-    if (!selection) return;
-    let charIndex = 0;
-    const range = document.createRange();
-    range.setStart(element, 0);
-    range.collapse(true);
-    const nodeIterator = (node: Node): boolean => {
-      if (node.nodeType === Node.TEXT_NODE) {
-        const textNode = node as Text;
-        const nextCharIndex = charIndex + (textNode.length || 0);
-        if (position.start >= charIndex && position.start <= nextCharIndex) {
-          range.setStart(textNode, position.start - charIndex);
-          range.setEnd(textNode, position.start - charIndex);
-          return true;
-        }
-        charIndex = nextCharIndex;
-      } else {
-        for (let i = 0; i < node.childNodes.length; i++) {
-          if (nodeIterator(node.childNodes[i])) {
-            return true;
-          }
-        }
-      }
-      return false;
-    };
-    nodeIterator(element);
-    selection.removeAllRanges();
-    selection.addRange(range);
-  }
-
-  static formatJson(texto: string, colorir: boolean = false): string {
-    let retorno = "";
-    try {
-      retorno = JSON.stringify(texto, null, 2);
-    } catch (e) {
-      LOG(1, "⚠️ JSON Inválido: Não foi possível formatar o JSON.");
-      return texto;
-    }
-
-    if (colorir) {
-      let keyNameStart: string = '<span class="json-key">';
-      let nullStart: string = '<span class="json-null">';
-      let numberStart: string = '<span class="json-number">';
-      let booleanStart: string = '<span class="json-boolean">';
-      let stringStart: string = '<span class="json-string">';
-      let spanEnd: string = '</span>';
-      // Identificar a posição das chaves do json e adicionar as tags de span
-      retorno = retorno.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-      retorno = retorno.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
-        let cls = nullStart;
-        if (/^"/.test(match)) {
-          if (/:$/.test(match)) {
-            cls = keyNameStart;
-          } else {
-            cls = stringStart;
-          }
-        } else if (/true|false/.test(match)) {
-          cls = booleanStart;
-        } else if (/null/.test(match)) {
-          cls = nullStart;
-        } else if (/undefined/.test(match)) {
-          cls = nullStart;
-        } else {
-          cls = numberStart;
-        }
-        return cls + match + spanEnd;
-      });
-    }
-
-    // Remove aspas duplas das chaves (mantém aspas dos valores string)
-    retorno = retorno.replace(/"([^"]+)"(\s*):/g, '$1$2:');
-
-    return retorno;
-  }
-
-  static async copy(content: string): Promise<void> {
-    try {
-      await this.copyHtml(content);
-    } catch (erro) {
-      LOG(1, "❌ %cFalha ao copiar como HTML, tentando como texto puro", "color:red;", erro);
-      this.copyPlainText(content);
-    }
-  }
-
-  private static copyPlainText(text: string) {
-    const elemento = document.createElement('textarea');
-    elemento.style.position = 'fixed';
-    elemento.style.opacity = '0';
-    elemento.style.whiteSpace = 'pre';
-    elemento.value = text;
-    document.body.appendChild(elemento);
-    elemento.select();
-    elemento.setSelectionRange(0, 99999);
-    const result = document.execCommand('copy');
-    if (!result) {
-      LOG(1, "❌ Falha ao copiar via execCommand.");
-    }
-    LOG(1, "🫤! Cópia via execCommand: ", text);
-    elemento.remove();
-  }
-
-  private static async copyHtml(html?: string) {
-    if (!html) {
-      html = "";
-      LOG(1, "❌ %cNão foi possível copiar.", "color:red;");
-      return;
-    }
-    try {
-      // Remove tags HTML para gerar a versão texto puro
-      const plainText = this.stripHtmlTags(html);
-      if (navigator.clipboard && window.isSecureContext) {
-        const clipboardItem = new ClipboardItem({
-          'text/plain': new Blob([plainText], { type: 'text/plain' }),
-          'text/html': new Blob([html], { type: 'text/html' })
-        });
-        await navigator.clipboard.write([clipboardItem]);
-        console.groupCollapsed("✅ %cCopiado para a área de transferência.", "color:aquamarine;");
-        LOG(1, plainText);
-        console.groupEnd();
-        return;
-      }
-
-      // Fallback: copia HTML usando execCommand
-      const elemento = document.createElement('div');
-      elemento.style.position = 'fixed';
-      elemento.style.opacity = '0';
-      elemento.innerHTML = html;
-      document.body.appendChild(elemento);
-
-      const range = document.createRange();
-      range.selectNodeContents(elemento);
-      const selection = window.getSelection();
-      selection?.removeAllRanges();
-      selection?.addRange(range);
-
-      document.execCommand('copy');
-      console.groupCollapsed("➡️ %cCopiado para a área de transferência. (execCommand)", "color:lightblue;");
-      LOG(1, plainText);
-      console.groupEnd();
-      elemento.remove();
-    } catch (erro) {
-      LOG(1, "❌ Erro ao copiar:", erro);
-      throw erro;
-    }
-  }
-
-  private static stripHtmlTags(html: string): string {
-    // Cria um elemento temporário para extrair texto puro
-    const temp = document.createElement('div');
-    temp.innerHTML = html;
-    // Substitui <br> por quebras de linha antes de extrair o texto
-    temp.innerHTML = temp.innerHTML.replace(/<br\s*\/?>/gi, '\n');
-    return temp.textContent || temp.innerText || '';
-  }
-
-  static apenasNumeros = (s: string | number = ""): string => {
-    if (s == null) return "";
-    // Ignora qualquer outro caracter além de Numeros
-    return s.toString().replace(/(?![0-9])./g, "");
-  }
-
-  static frequencia = (array: any): any => {
-    // Retorna o total de encontro na array.
-    // Quando é objeto converte pra string pra poder contar
-    let f: any = {};
-    for (let e of array) {
-      let s = e;
-      if (LibUtil.classof(e) == "object") s = JSON.stringify(e);
-      f[s] ? f[s]++ : (f[s] = 1);
-    }
-    return f;
-  }
-
-  static formats: IUtilFormatters = {
-    cpf: {
-      mask: "000.000.000-00",
-      regex: "^([0-9]{3}([\.]?[0-9]{3}){2}[-]?[0-9]{2})$",
-      validate: (cpf: any) => {
-        let m1 = [10, 9, 8, 7, 6, 5, 4, 3, 2];
-        let m2 = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2];
-        if (!cpf) { return false; }
-        cpf = LibUtil.apenasNumeros(cpf);
-        if (cpf.length != 11) { return false; }
-        let temp = cpf.slice(0, 9);
-        let c = 0;
-        for (let i = 0; i < 9; i++) { c += Number(temp.charAt(i)) * m1[i]; }
-        let r = c % 11;
-        (r < 2) ? r = 0 : r = 11 - r;
-        temp += r.toString();
-        c = 0;
-        for (let i = 0; i < 10; i++) { c += Number(temp.charAt(i)) * m2[i]; }
-        r = c % 11;
-        (r < 2) ? r = 0 : r = 11 - r;
-        if (cpf.charAt(10) != r.toString()) {
-          return false;
-        };
-        let char0 = cpf.charAt(0);
-        let repChar0 = LibUtil.frequencia(cpf)[char0];
-        if (repChar0 >= 11) {
-          return false;
-        }
-        return true;
-      }
-    },
-    cnpj: {
-      mask: "00.000.000/0000-00",
-      regex: "^([0-9]{2}([\.]?[0-9]{3}){2}[\/]?[0-9]{4}[-]?[0-9]{2})$",
-      validate: (cnpj: any) => {
-        let m1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
-        let m2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
-        if (!cnpj) { return false; }
-        cnpj = LibUtil.apenasNumeros(cnpj);
-        if (cnpj.length != 14) { return false; }
-        let temp = cnpj.slice(0, 12);
-        let c = 0;
-        for (let i = 0; i < 12; i++) { c += Number(temp.charAt(i)) * m1[i]; }
-        let r = (c % 11);
-        (r < 2) ? r = 0 : r = 11 - r;
-        temp += r.toString();
-        c = 0;
-        for (let i = 0; i < 13; i++) { c += Number(temp.charAt(i)) * m2[i]; }
-        r = (c % 11);
-        (r < 2) ? r = 0 : r = 11 - r;
-        return cnpj.charAt(13) == r.toString();
-      }
-    },
-    cpf_cnpj: {
-      mask: (str: string) => {
-        if (LibUtil.apenasNumeros(str).length <= 11) {
-          return "000.000.000-00"
-        } else {
-          return "00.000.000/0000-00"
-        };
-      },
-      regex: "^([0-9]{2}([\.]?[0-9]{3}){2}[\/]?[0-9]{4}[-]?[0-9]{2})|([0-9]{3}([\.]?[0-9]{3}){2}[-]?[0-9]{2})$",
-      validate: (cpf_cnpj: any) => {
-        if (LibUtil.apenasNumeros(cpf_cnpj).length <= 11) {
-          return LibUtil.formats.cpf.validate?.(cpf_cnpj) ?? false;
-        } else {
-          return LibUtil.formats.cnpj.validate?.(cpf_cnpj) ?? false;
-        };
-      }
-    },
-    cnh: {
-      mask: "00000000000",
-      regex: "^([0-9]{11})$",
-      validate: (cnh: any) => {
-        if (!cnh) { return false; }
-        cnh = LibUtil.apenasNumeros(cnh);
-        if (cnh.length != 11) { return false; }
-        return true;
-      },
-    },
-    pis: {
-      mask: "000.00000.00-0",
-      regex: "^([0-9]{3}[\.]?[0-9]{5}[\.]?[0-9]{2}[-]?[0-9]{1})$",
-      validate: (pis: any) => {
-        if (!pis) { return false; }
-        pis = LibUtil.apenasNumeros(pis);
-        if (pis.length != 11) { return false; }
-        return true;
-      },
-    },
-    dia: {
-      mask: "00",
-      regex: "^(0[1-9]|[1-9]|[1-2][0-9]|3[0-1])$",
-      validate: (dia: any) => {
-        if (!dia) { return false; }
-        dia = LibUtil.apenasNumeros(dia);
-        let diaNum = Number(dia);
-        return diaNum >= 1 && diaNum <= 31;
-      },
-    },
-    mes: {
-      mask: "00",
-      regex: "^(0[1-9]|1[0-2])$",
-      validate: (mes: any) => {
-        if (!mes) { return false; }
-        mes = LibUtil.apenasNumeros(mes);
-        let mesNum = Number(mes);
-        return mesNum >= 1 && mesNum <= 12;
-      },
-    },
-    ano: {
-      mask: "0000",
-      regex: "^([0-2]?([0-9]){3})$",
-      validate: (ano: any) => {
-        if (!ano) { return false; }
-        ano = LibUtil.apenasNumeros(ano);
-        let anoNum = Number(ano);
-        return anoNum >= 1000 && anoNum <= 2999;
-      },
-    },
-    anoRecente: {
-      mask: "0000",
-      regex: "^(19([0-9]){2})|(20([0-9]){2})|(21([0-9]){2})$",
-      validate: (anoRecente: any) => {
-        if (!anoRecente) { return false; }
-        anoRecente = LibUtil.apenasNumeros(anoRecente);
-        let anoNum = Number(anoRecente);
-        return anoNum >= 1900 && anoNum <= 2199;
-      },
-    },
-    data: {
-      mask: "0000-00-00",
-      regex: "^([0-9]{4}(-[0-9]{2}){2})$",
-      validate: (data: any) => {
-        if (!data) { return false; }
-        data = LibUtil.apenasNumeros(data);
-        return new RegExp(LibUtil.formats.data.regex).test(data);
-      },
-    },
-    dataIso: {
-      mask: "0000-00-00T00:00:00.000Z",
-      regex: "^([0-9]{4}(-[0-9]{2}){2}T[0-9]{2}(:[0-9]{2}){2}\.[0-9]{3}Z)$",
-      validate: (dataIso: any) => {
-        if (!dataIso) { return false; }
-        dataIso = LibUtil.apenasNumeros(dataIso);
-        return new RegExp(LibUtil.formats.dataIso.regex).test(dataIso);
-      },
-    },
-    numero: {
-      mask: "#0",
-      regex: "^[0-9]*$",
-      validate: (numero: any) => {
-        if (!numero) { return false; }
-        numero = LibUtil.apenasNumeros(numero);
-        return numero.length > 0;
-      },
-    },
-    decimal: {
-      mask: "#0,00",
-      regex: "^[0-9,]*$",
-      validate: (decimal: any) => {
-        if (!decimal) { return false; }
-        return new RegExp(LibUtil.formats.decimal.regex).test(decimal);
-      },
-    },
-    letra: {
-      mask: "A",
-      regex: "^[A-Za-z]*$",
-      validate: (letra: any) => {
-        if (!letra) { return false; }
-        return new RegExp(LibUtil.formats.letra.regex).test(letra);
-      },
-    },
-    numeroELetra: {
-      mask: "S",
-      regex: "^[A-Za-z0-9]*$",
-      validate: (numeroELetra: any) => {
-        if (!numeroELetra) { return false; }
-        return new RegExp(LibUtil.formats.numeroELetra.regex).test(numeroELetra);
-      }
-    },
-    ip: {
-      mask: "000.000.000.000",
-      regex: "^([0-2]?[0-9]?[0-9]([\.][0-2]?[0-9]?[0-9]){3})$",
-      validate: (ip: any) => {
-        if (!ip) { return false; }
-        const regex = new RegExp(LibUtil.formats.ip.regex);
-        if (!regex.test(ip)) { return false; }
-        const parts = ip.split('.').map(Number);
-        return parts.every((part: number) => part >= 0 && part <= 255);
-      }
-    },
-    email: {
-      mask: "S",
-      regex: "^(([a-zA-Z0-9_+-\.]+)+)@([a-zA-Z0-9_+-\.]+\.[a-zA-Z]+)+$",
-      validate: (email: any) => {
-        if (!email) { return false; }
-        return new RegExp(LibUtil.formats.email.regex).test(email);
-      }
-    },
-    cep: {
-      mask: "00000-000",
-      regex: "^([0-9]{5}[-]?[0-9]{3})$",
-      validate: (cep: any) => {
-        if (!cep) { return false; }
-        cep = LibUtil.apenasNumeros(cep);
-        return new RegExp(LibUtil.formats.cep.regex).test(cep);
-      }
-    }
-  }
-
-  static stringToDataBR = (data: string | null | undefined): string | null => {
-    let resultado = null;
-    if (LibUtil.classof(data) == "null" || LibUtil.classof(data) == "undefined") {
-      return null;
-    } else if (LibUtil.classof(data) == "string") {
-      // Quando a data é "YYYY-MM-DD", ascrescenta 1 espaço para UTC.
-      if (new RegExp("^[12][0-9]{3}[-][0-1][0-9][-][0-3][0-9]$").test(data!)) {
-        data += " ";
-      }
-      // Tentativa Direta:
-      resultado = new Date(data!).toLocaleString().replace(",", "");
-
-      // Falhando, tenta converter pra número.
-      if (resultado.toUpperCase() == "INVALID DATE") {
-        resultado = new Date(Number(data)).toLocaleString().replace(",", "");
-
-        // Agora tenta ver se a data inicia no formato br já
-        if (resultado.toUpperCase() == "INVALID DATE") {
-          // DD/MM/YYYY ?
-          if (new RegExp("^[0-3][0-9][/][0-1][0-9][/][0-2][0-9]{3}").test(data!)) {
-            resultado = new Date(LibUtil.dataToIsoData(data!)).toLocaleString().replace(",", "");
-          }
-        }
-      }
-    } else {
-      LOG(1, "❌ stringToDataBR(): A data precisa ser formato string: ", data, LibUtil.classof(data));
-    }
-    return resultado;
-  }
-
-  // ISO 8601 (Padrão Internacional)
-  static dataToIsoData = (data: string): string => {
-    // Converter de DD/MM/YYYY para YYYY-MM-DD
-    if (new RegExp("^[0-3][0-9][/][0-1][0-9][/][0-2][0-9]{3}").test(data)) {
-
-    }
-    if (new RegExp("^[0-3][0-9][/][0-1][0-9][/][0-2][0-9]{3}").test(data)) {
-      let novaData = data.slice(6, 10) + "-" + data.slice(3, 5) + "-" + data.slice(0, 2);
-      let resto = data.slice(10, data.length);
-      if (resto != "" && new RegExp("^ [0-2][0-9]:[0-5][0-9]:[0-5][0-9]").test(resto)) {
-        novaData += resto;
-      }
-      return novaData;
-    }
-    return data; // < Se falhar
-  };
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-  // ============================ SIGNALS DIRETO => CRUD E UTEIS ============================ \\
-
-  // SET (SIGNAL)
-  static sinalSet<T>(sinal: WritableSignal<any | undefined>, item: Partial<T>) {
-    sinal.update(i => {
-      if (!i) return item;
-      return { ...i, ...item };
-    });
-  }
-
-  // CREATE (SIGNAL)
-  static sinalCreate<T>(sinal: WritableSignal<any[] | undefined>, item: T) {
-    sinal.update(i => {
-      if (!i) return [item];
-      return [...i, item];
-    });
-  }
-
-  // UPDATE (SIGNAL)
-  static sinalUpdate<T>(sinal: WritableSignal<any[] | undefined>, item: Partial<T>, k: string, v?: string) {
-    if (v != null && item) {
-      sinal.update(i => {
-        if (!i) return i;
-        return i.map((o: T) => o[k as keyof T] === v ? { ...o, ...item } : o);
-      });
-    } else {
-      if (v == null) {
-        // PATCH UPDATE
-        let value = item[k as keyof T];
-        if (value != null) {
-          sinal.update(i => {
-            if (!i) return i;
-            return i.map((o: T) => o[k as keyof T] === value ? { ...o, ...item } : o);
-          });
-        } else {
-          LOG(1, `⚠️ sinalUpdate: A chave ${k} está nula. Passe o V desta chave para atualizar.`);
-        }
-      } else {
-        LOG(1, `❌ Item ${k} chegou nulo para Update.`);
-      }
-    }
-  }
-
-  // DELETE (SIGNAL)
-  static sinalDelete<T>(sinal: WritableSignal<any[] | undefined>, k: string, v?: string) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i) return i;
-        return i.filter((o: T) => o[k as keyof T] !== v);
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para Delete.`);
-    }
-  }
-
-  // CLEAR (SIGNAL)
-  static sinalClear<T>(sinal: WritableSignal<any[] | undefined>) {
-    sinal.set(undefined);
-  }
-
-  // EXISTS (SIGNAL) - Verifica se um item existe na lista
-  static sinalExists<T>(sinal: WritableSignal<any[] | undefined>, k: Extract<keyof T, string>, v: string): boolean {
-    if (v != null) {
-      const items = sinal();
-      if (!items) return false;
-      return items.some((o: T) => o[k] === v);
-    } else {
-      return false;
-    }
-  }
-
-
-  // MOVE UP (SIGNAL) - Move um item uma posição para cima
-  static sinalMoveUp<T>(sinal: WritableSignal<any[] | undefined>, k: Extract<keyof T, string>, v: string) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i || i.length <= 1) return i;
-        const index = i.findIndex((o: T) => o[k] === v);
-        if (index <= 0) return i; // Já está no topo ou não encontrado
-
-        const newArray = [...i];
-        [newArray[index - 1], newArray[index]] = [newArray[index], newArray[index - 1]];
-        return newArray;
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para MoveUp.`);
-    }
-  }
-
-  // MOVE DOWN (SIGNAL) - Move um item uma posição para baixo
-  static sinalMoveDown<T>(sinal: WritableSignal<any[] | undefined>, k: Extract<keyof T, string>, v: string) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i || i.length <= 1) return i;
-
-        const index = i.findIndex((o: T) => o[k] === v);
-        if (index < 0 || index >= i.length - 1) return i; // Já está no final ou não encontrado
-
-        const newArray = [...i];
-        [newArray[index], newArray[index + 1]] = [newArray[index + 1], newArray[index]];
-        return newArray;
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para MoveDown.`);
-    }
-  }
-
-  // MOVE TO INDEX (SIGNAL) - Move um item para uma posição específica
-  static sinalMoveToIndex<T>(sinal: WritableSignal<any[] | undefined>, k: Extract<keyof T, string>, v: string, targetIndex: number) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i || i.length <= 1) return i;
-        const currentIndex = i.findIndex((o: T) => o[k] === v);
-        if (currentIndex < 0 || targetIndex < 0 || targetIndex >= i.length || currentIndex === targetIndex) {
-          return i; // Item não encontrado, índice inválido ou já está na posição
-        }
-        const newArray = [...i];
-        const [movedItem] = newArray.splice(currentIndex, 1);
-        newArray.splice(targetIndex, 0, movedItem);
-        return newArray;
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para MoveToIndex.`);
-    }
-  }
-
-  static FlatRecursivo<T>(lista: T[], keyRecursive: keyof T): T[] {
-    if (LibUtil.classof(lista) != "array") return [];
-
-    let novaArray: T[] = [];
-    lista.map(objeto => {
-      if (LibUtil.classof(objeto) != "object") return;
-      let novoObjeto: T = {} as T;
-      for (let prop in objeto) {
-        if (prop != keyRecursive) novoObjeto[prop] = objeto[prop];
-      }
-      novaArray = [...novaArray, novoObjeto];
-      let children = objeto[keyRecursive] as T[];
-      if (children != null) {
-        novaArray = [...novaArray, ...LibUtil.FlatRecursivo(children, keyRecursive)];
-      }
-    })
-    return novaArray;
-  }
-
-  // ============================ SIGNALS RECURSIVO => CRUD E UTEIS ============================ \\
-
-  // Adiciona um novo item em uma estrutura hierárquica baseado na chave pai
-  // CREATE RECURSIVE (SIGNAL)
-  static sinalCreateRecursive<T>(sinal: WritableSignal<any[] | undefined>, item: T, keyRecursive: keyof T, keyPai: Extract<keyof T, string>, valuePai?: string) {
-    sinal.update(i => {
-      if (!i) return [item];
-      if (valuePai != null) {
-        return i.map((o: T) => {
-          return LibUtil._recursiveCreate<T>(o, item, keyRecursive, keyPai, valuePai);
-        });
-      } else {
-        // Sem Pai inserir direto na raiz
-        return [...i, item];
-      }
-    });
-  }
-
-  // Encontra o item pai pela chave e adiciona o novo item no array de filhos
-  static _recursiveCreate<T>(atual: T, novo: T, keyRecursive: keyof T, keyPai: Extract<keyof T, string>, valuePai: string): T {
-    if (atual[keyPai] === valuePai) {
-      // Encontrou o pai, adiciona o item no array recursivo
-      if (atual[keyRecursive] == null) {
-        (atual[keyRecursive] as T[]) = [novo];
-      } else {
-        (atual[keyRecursive] as T[]) = [...(atual[keyRecursive] as T[]), novo];
-      }
-      return atual;
-    }
-    if (atual[keyRecursive] == null || (atual[keyRecursive] as T[])?.length == 0) return atual;
-    (atual[keyRecursive] as T[]) = [
-      ...(atual[keyRecursive] as T[]).map(child => {
-        return LibUtil._recursiveCreate(child, novo, keyRecursive, keyPai, valuePai);
-      })
-    ];
-    return atual;
-  }
-
-  // Atualiza um item específico em uma estrutura hierárquica
-  // UPDATE RECURSIVE (SIGNAL)
-  static sinalUpdateRecursive<T>(sinal: WritableSignal<any[] | undefined>, item: Partial<T>, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i) return i;
-        return i.map((o: T) => {
-          return LibUtil._recursiveUpdate<T>(o, item, keyRecursive, k, v);
-        });
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para Update Recursivo.`);
-    }
-  }
-
-  // Encontra o item pela chave e atualiza suas propriedades
-  static _recursiveUpdate<T>(atual: T, novo: Partial<T>, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string): T {
-    if (atual[k] === v) {
-      LOG(1, "Editado", { ...atual, ...novo })
-      return { ...atual, ...novo };
-    }
-    if (atual[keyRecursive] == null || (atual[keyRecursive] as T[])?.length == 0) return atual;
-    (atual[keyRecursive] as T[]) = [
-      ...(atual[keyRecursive] as T[]).map(child => {
-        return LibUtil._recursiveUpdate(child, novo, keyRecursive, k, v);
-      })
-    ];
-    return atual;
-  }
-
-  // Remove um item específico de uma estrutura hierárquica
-  // DELETE RECURSIVE (SIGNAL)
-  static sinalDeleteRecursive<T>(sinal: WritableSignal<any[] | undefined>, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i) return i;
-        // Primeiro verifica se precisa deletar no nível raiz
-        const filteredRoot = i.filter((o: T) => o[k] !== v);
-        // Se encontrou e removeu no nível raiz, retorna o array filtrado
-        if (filteredRoot.length !== i.length) {
-          return filteredRoot;
-        }
-        // Se não encontrou no nível raiz, processa recursivamente
-        return i.map((o: T) => {
-          return LibUtil._recursiveDelete<T>(o, keyRecursive, k, v);
-        });
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para Delete Recursivo.`);
-    }
-  }
-  // Encontra e remove o item pela chave, filtrando do array de filhos
-  static _recursiveDelete<T>(atual: T, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string): T {
-    // Se tem filhos, processa os filhos
-    if (atual[keyRecursive] && (atual[keyRecursive] as T[])?.length > 0) {
-      const children = atual[keyRecursive] as T[];
-      // Remove o item dos filhos se existir e processa recursivamente os filhos restantes
-      const filteredChildren = children
-        .filter(child => child[k] !== v)
-        .map(child => LibUtil._recursiveDelete(child, keyRecursive, k, v));
-      return { ...atual, [keyRecursive]: filteredChildren };
-    }
-    return atual;
-  }
-
-  // EXISTS RECURSIVE (SIGNAL) - Verifica se um item existe em uma estrutura hierárquica
-  static sinalExistsRecursive<T>(sinal: WritableSignal<any[] | undefined>, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string): boolean {
-    if (v != null) {
-      const items = sinal();
-      if (!items) return false;
-      return items.some((o: T) => {
-        return LibUtil._recursiveExists<T>(o, keyRecursive, k, v);
-      });
-    } else {
-      return false;
-    }
-  }
-
-  // Função auxiliar para busca recursiva
-  static _recursiveExists<T>(atual: T, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string): boolean {
-    // Verifica se o item atual é o que estamos procurando
-    if (atual[k] === v) return true;
-    // Se tem filhos, procura recursivamente
-    if (atual[keyRecursive] && (atual[keyRecursive] as T[])?.length > 0) {
-      const children = atual[keyRecursive] as T[];
-      return children.some(child => LibUtil._recursiveExists(child, keyRecursive, k, v));
-    }
-    return false;
-  }
-
-  // Move um item uma posição para cima na hierarquia
-  // MOVE UP RECURSIVE (SIGNAL) - Para estruturas hierárquicas
-  static sinalMoveUpRecursive<T>(sinal: WritableSignal<any[] | undefined>, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i || i.length <= 1) return i;
-        // Primeiro verifica se precisa mover no nível raiz
-        const rootIndex = i.findIndex((o: T) => o[k] === v);
-        if (rootIndex > 0) {
-          const newArray = [...i];
-          [newArray[rootIndex - 1], newArray[rootIndex]] = [newArray[rootIndex], newArray[rootIndex - 1]];
-          return newArray;
-        }
-        // Se não encontrou no nível raiz, processa recursivamente
-        return i.map((o: T) => {
-          return LibUtil._recursiveMoveUp<T>(o, keyRecursive, k, v);
-        });
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para MoveUp Recursivo.`);
-    }
-  }
-
-  // Encontra o item e troca sua posição com o anterior no array
-  static _recursiveMoveUp<T>(atual: T, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string): T {
-    // Se tem filhos, processa os filhos primeiro
-    if (atual[keyRecursive] && (atual[keyRecursive] as T[])?.length > 0) {
-      const children = atual[keyRecursive] as T[];
-      // Verifica se precisa mover dentro dos filhos
-      const targetIndex = children.findIndex(child => child[k] === v);
-      if (targetIndex > 0) {
-        const newChildren = [...children];
-        [newChildren[targetIndex - 1], newChildren[targetIndex]] = [newChildren[targetIndex], newChildren[targetIndex - 1]];
-        return { ...atual, [keyRecursive]: newChildren };
-      }
-      // Se não encontrou, processa recursivamente os filhos
-      const processedChildren = children.map(child =>
-        LibUtil._recursiveMoveUp(child, keyRecursive, k, v)
-      );
-      return { ...atual, [keyRecursive]: processedChildren };
-    }
-    return atual;
-  }
-
-  // Move um item uma posição para baixo na hierarquia
-  // MOVE DOWN RECURSIVE (SIGNAL) - Para estruturas hierárquicas
-  static sinalMoveDownRecursive<T>(sinal: WritableSignal<any[] | undefined>, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string) {
-    if (v != null) {
-      sinal.update(i => {
-        if (!i || i.length <= 1) return i;
-        // Primeiro verifica se precisa mover no nível raiz
-        const rootIndex = i.findIndex((o: T) => o[k] === v);
-        if (rootIndex >= 0 && rootIndex < i.length - 1) {
-          const newArray = [...i];
-          [newArray[rootIndex], newArray[rootIndex + 1]] = [newArray[rootIndex + 1], newArray[rootIndex]];
-          return newArray;
-        }
-        // Se não encontrou no nível raiz, processa recursivamente
-        return i.map((o: T) => {
-          return LibUtil._recursiveMoveDown<T>(o, keyRecursive, k, v);
-        });
-      });
-    } else {
-      LOG(1, `⚠️ Chave ${k} chegou nula para MoveDown Recursivo.`);
-    }
-  }
-
-  // Encontra o item e troca sua posição com o próximo no array
-  static _recursiveMoveDown<T>(atual: T, keyRecursive: keyof T, k: Extract<keyof T, string>, v: string): T {
-    if (atual[keyRecursive] && (atual[keyRecursive] as T[])?.length > 0) {
-      const children = atual[keyRecursive] as T[];
-      // Verifica se precisa mover dentro dos filhos
-      const targetIndex = children.findIndex(child => child[k] === v);
-      if (targetIndex >= 0 && targetIndex < children.length - 1) {
-        const newChildren = [...children];
-        [newChildren[targetIndex], newChildren[targetIndex + 1]] = [newChildren[targetIndex + 1], newChildren[targetIndex]];
-        return { ...atual, [keyRecursive]: newChildren };
-      }
-      // Se não encontrou, processa recursivamente os filhos
-      const processedChildren = children.map(child =>
-        LibUtil._recursiveMoveDown(child, keyRecursive, k, v)
-      );
-      return { ...atual, [keyRecursive]: processedChildren };
-    }
-    return atual;
-  }
-
-  static sinalSetOrderRecursive<T>(sinal: WritableSignal<any[] | undefined>, keyRecursive: keyof T, k: Extract<keyof T, string>, propOrder: keyof T) {
-    sinal.update(i => {
-      if (!i) return i;
-      return i.map((o: T, i) => {
-        return LibUtil._recursiveSetOrder<T>(o, keyRecursive, k, propOrder, i);
-      });
-    });
-  }
-
-  static _recursiveSetOrder<T>(atual: T, keyRecursive: keyof T, k: Extract<keyof T, string>, propOrder: keyof T, index: number): T {
-    atual = { ...atual, [propOrder]: index };
-    if (atual[keyRecursive] == null || (atual[keyRecursive] as T[])?.length == 0) return atual;
-    (atual[keyRecursive] as T[]) = [
-      ...(atual[keyRecursive] as T[]).map((child, i) => {
-        return LibUtil._recursiveSetOrder(child, keyRecursive, k, propOrder, i);
-      })
-    ];
-    return atual;
-  }
-
-  // ============================ ATALHOS PERSONALIZADOS ============================ \\
-
-  static Q = (query: any) => {
-    // Busca elemento único, podendo buscar ele mesmo. (Bifurcacado)
-    if (LibUtil.classof(query) == "string") return document.querySelector(query);
-    return query;
-  };
-
-  static QAll = (query: any): any[] => {
-    // Sempre retorna uma array de encontrados. Inclusive uma array com um LibUtil.Q
-    if (LibUtil.classof(query) == "string") {
-      // Se buscando uma string, retorna a array do select encontrado
-      return Array.from(document.querySelectorAll(query));
-    } else if (LibUtil.classof(query).endsWith("Element")) {
-      // Quando buscar um único elemento, retorna o elemento em uma lista.
-      return [query];
-    } else if (LibUtil.classof(query) == "array") {
-      // Quando buscar uma array, retorna a propria array. (Bifurcado)
-      return query;
-    } else {
-      LOG(1, "⚠️ QAll() - Requer String / Elemento / Array. ClassOf: ", LibUtil.classof(query), " Query: ", query);
-      return [];
-    }
-  };
-
-  static QverOff = (query: Element | HTMLElement | string | null = "body"): any[] => {
-    // Adiciona Classe Oculto em todos os elementos do Query
-    // Retorna uma array de elementos por causa do QAll
-    return LibUtil.aCadaElemento(query, (e: any) => {
-      e?.classList.add("oculto");
-    });
-  };
-
-  static QverOn = (query: Element | HTMLElement | string | null = "body") => {
-    // Remove classe Oculto em todos os elementos do Query
-    // Retorna uma array de elementos por causa do QAll
-    return LibUtil.aCadaElemento(query, (e: any) => {
-      e?.classList.remove("oculto");
-    });
-  };
-
-  static dataGetMs = (data: string | null = null): number => {
-    // Retorna Milisegundos da data no formato Javascript
-    if (data != null) {
-      if (data.length > 10) {
-        // Recomendado que os dados cheguem: 'YYYY-MM-DD HH:MM:SS'
-        return new Date(data).getTime(); // Recomendado que os dados 
-      } else {
-        let dataCortada = data.split("-");
-        let oDia: number = Number(dataCortada[2]);
-        let oMes: number = Number(dataCortada[1]) - 1;
-        let oAno: number = Number(dataCortada[0]);
-        return new Date(oAno, oMes, oDia).getTime();
-      }
-    } else return new Date().getTime();
-  };
-
-  static dataMsToSegundos = (num: number, reverse: boolean = false) => {
-    if (reverse) {
-      return num * 1000;
-    }
-    return Math.trunc(num / 1000); // 1000 ms == 1s
-  }
-
-  static dataMsToDias = (num: number, reverse: boolean = false) => {
-    // 1000 * 3600 * 24 Considerando todo dia tiver 24 horas (~23h 56m 4.1s)
-    // (360º translacao / 86400000) = ~4.1
-    // Então o erro de 1 dia ocorre 1x ao ano (Dia represeta 1436min).
-    // Por isso, é melhor trabalhar com Dias em vez de outro formato maior.
-    if (reverse) {
-      return Math.trunc(num * 86400000);
-    }
-    return Math.trunc(num / 86400000);
-  };
-
-  static dataGetSegundosDiferenca = (msDe: number, msAte: number | null = null): number => {
-    // Retorna a diferença de segundos entre dois MS
-    if (msAte == null) msAte = LibUtil.dataGetMs();
-    return LibUtil.dataMsToSegundos(msAte - msDe);
-  };
-
-  static dataGetDiasDiferenca = (msDe: number, msAte: number | null = null): number => {
-    // Retorna a diferença de dias entre dois MS
-    if (msAte == null) msAte = LibUtil.dataGetMs();
-    return LibUtil.dataMsToDias(msAte - msDe);
-  };
-
-  static dataShowTempoDiferenca = (msDe: number | string, msAte: number | string | null = null) => {
-    if (LibUtil.classof(msDe) == "string") msDe = LibUtil.dataGetMs(msDe as string);
-    if (LibUtil.classof(msAte) == "string") msAte = LibUtil.dataGetMs(msAte as string);
-    let dias = LibUtil.dataGetDiasDiferenca(msDe as number, msAte as number | null);
-    if (dias < 0) {
-      dias = dias * -1;
-    }
-    let strTempo = "";
-    if (dias > 29) { // Em Meses
-      if (dias < 60) {
-        strTempo = "1 mês";
-      } else {
-        if (dias > 365) { // Em Anos (+ Meses restantes)
-          let anos = Math.floor(dias / 365);
-          let diasRestoAno = dias % 365;
-          if (anos < 2) {
-            strTempo += anos + " ano ";
-          } else {
-            strTempo += anos + " anos ";
-          }
-          if (diasRestoAno > 30) {
-            if (diasRestoAno < 60) {
-              strTempo += "1 mês";
-            } else {
-              strTempo += Math.floor(diasRestoAno / 30) + " meses";
-            }
-          }
-        } else {
-          strTempo = Math.floor(dias / 30) + " meses";
-        }
-      }
-    } else {
-      if (dias < 1) {
-        let segundos = LibUtil.dataGetSegundosDiferenca(msDe as number, msAte as number);
-        if (segundos > 7199) { // Em Horas
-          strTempo = Math.floor(segundos / 3600) + " horas";
-        } else {
-          if (segundos > 3599) {
-            strTempo = "1 hora";
-          } else {
-            if (segundos > 119) { // Em Minutos
-              strTempo = Math.floor(segundos / 60) + " minutos";
-            } else {
-              if (segundos > 59) {
-                strTempo = "1 minuto";
-              } else {
-                strTempo = Math.floor(segundos) + " segundos";
-              }
-            }
-          }
-        }
-      } else { // Em Dias
-        strTempo = dias + " dias";
-      }
-    }
-    if (strTempo.includes("NaN")) return "";
-    return strTempo;
-  }
-
-  static displayCelular = (area: string, numero: string, isoDDI?: string): string => {
-    if (numero == null) numero = ""
-    else numero = LibUtil.apenasNumeros(numero);
-    if (area == null) area = "";
-    else area = LibUtil.apenasEstes(area, "0-9\+");
-    if (numero == "" && area == "") return "";
-    let displayArea = area;
-    let displayNumero = numero;
-    let displayFlag = "";
-    if (numero != "" && displayArea == "") displayArea = "+55"
-    if (displayArea == "+55") {
-      numero = numero.slice(0, 11); // No brasil o limite é 9.
-      displayNumero = numero;
-      let apenasCelular = numero.slice(2, 11);
-      if (apenasCelular.length == 9) {
-        apenasCelular = apenasCelular.slice(0, 5) + "-" + apenasCelular.slice(5, 9);
-      }
-      displayNumero = "(" + numero.slice(0, 2) + ") " + apenasCelular;
-    }
-    if (isoDDI != null) {
-      displayFlag = LibUtil.displayFlag(isoDDI);
-    }
-    return `${displayFlag}<a href="tel:${area || ""}${numero || ""}">${displayArea} ${displayNumero}</a>`
-  }
-
-  static displayFlag = (pais: string): string => {
-    if (pais != null) {
-      return `<img class="flagSizeIco" src="/images/Paises/${pais || "transparent"}.svg" alt="${pais || "transparent"}" onerror="base_imgonerror(this);"> `
-    }
-    return "";
-  }
-
-  static diaEMes(data: string): string {
-    //Retorna: 01 de Abril
-    let arrData = LibUtil.stringToDataBR(data)?.split(" ")?.[0]?.split("/");
-    return arrData?.[0] + " de " + LibUtil.meses.get(Number(arrData?.[1] || 0))?.[0];
-  }
-
-  // =============== Gerenciamento Monetário / Numérico / Locale =================== \\
-  static toNumber = (valor: any, casas: number = 2): number => {
-    // Informando String/Number, converte para o número de casas c.casas (padrão 2).
-    // LibUtil.toNumber("R$ 1.222,333") => 1222.33
-    if (valor != null) {
-      if (LibUtil.classof(valor) == "string") {
-        // Possiveis separadores
-        let us = [".", ","].reduce((x, y) => (valor.lastIndexOf(x) > valor.lastIndexOf(y)) ? x : y);
-        let posPonto = valor.lastIndexOf(us)
-        if (posPonto >= 0) {
-          let i = valor.slice(0, posPonto);
-          let d = valor.slice(posPonto + 1).slice(0, 2).padEnd(2, "0");
-          i = [...i.toString()].filter(a => { return new RegExp(LibUtil.formats.numero.regex).test(a) }).join("");
-          d = [...d.toString()].filter(a => { return new RegExp(LibUtil.formats.numero.regex).test(a) }).join("");
-          valor = i + "." + d;
-        } else {
-          valor = [...valor.toString()].filter(a => { return new RegExp(LibUtil.formats.numero.regex).test(a) }).join("").padStart(3, "0")
-          valor = valor.padStart(casas, "0");
-          valor = valor.slice(0, -(casas)) + (casas > 0 ? "." : "") + valor.slice(-(casas));
-        }
-      } else if (LibUtil.classof(valor) == "number") {
-        valor = valor.toFixed(casas); // <= Vira String, mas essa função apenas devolve Number
-      } else {
-        LOG(1, "❌ toNumber() - Formato de entrada não implementado: ", LibUtil.classof(valor));
-      }
-      return Number(valor); // <= OutPut Number
-    }
-    return 0; // <= OutPut Number
-  };
-
-  // ============================= ARMAZENADORES ESTÁTICOS ============================ \\
-  static a: any = {
-    ALL: "*/*", // ContentType Blob
-    FORMDATA: "multipart/form-data", // ContentType FORM
-    GET: "GET", // Api Method GET
-    HTML: "text/html", // ContentType HTML
-    JSON: "application/json", // ContentType JSON
-    POST: "POST", // Api Method POST
-    DELETE: "DELETE", // Api Method DELETE
-    SVGINI: "<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='currentColor' viewBox='0 0 16 16'>",
-    SVGFIM: "</svg>",
-    timers: [] as any, // Array para guardar timers em andamento ou finalizados
-    wpool: null as any | null, // WorkerPool quando iniciado
-  }
-
-  static meses = new Map([
-    [1, ["Janeiro", "JAN", "01"]],
-    [2, ["Fevereiro", "FEV", "02"]],
-    [3, ["Março", "MAR", "03"]],
-    [4, ["Abril", "ABR", "04"]],
-    [5, ["Maio", "MAI", "05"]],
-    [6, ["Junho", "JUN", "06"]],
-    [7, ["Julho", "JUL", "07"]],
-    [8, ["Agosto", "AGO", "08"]],
-    [9, ["Setembro", "SET", "09"]],
-    [10, ["Outubro", "OUT", "10"]],
-    [11, ["Novembro", "NOV", "11"]],
-    [12, ["Dezembro", "DEZ", "12"]],
-  ]);
-
-  // ============================ TOOLS e JS HELPERS ================================ \\
-
-  static isJson = (s: any): boolean => {
-    try {
-      JSON.parse(s);
-    } catch (e) {
-      return false;
-    }
-    return true;
-  };
-
-  static stringify = (o: any): string => {
-    // Converte o Objeto em String JSON, e aproveita e já remove alguns caracteres de controle.
-    return JSON.stringify(o)
-      ?.replace(new RegExp("\n", 'g'), "")
-      ?.replace(new RegExp("\r", 'g'), "")
-      ?.replace(new RegExp("\t", 'g'), "")
-      ?.replace(new RegExp("\b", 'g'), "")
-      ?.replace(new RegExp("\f", 'g'), "")
-  };
-
-  static parseJSON = (t: any) => {
-    // Se for um JSON válido. Retorna o objeto, se não null.
-    if (t === "") return "";
-    let resultado = null;
-    try {
-      resultado = JSON.parse(t);
-    } catch (e) {
-      LOG(1, "❌ JSON Inválido: Não foi possível converter o JSON.");
-      return null;
-    }
-    return resultado;
-  };
-
-  // String qualquer em string com números
-  static convertToNumeric = (texto: string): Array<number> => {
-    let arrayDeNumeros = [];
-    for (const char of texto) {
-      arrayDeNumeros.push(char.codePointAt(0) || 0);
-    }
-    return arrayDeNumeros;
-  }
-
-  // COnversor para Texto.
-  static convertToTexto = (arrayNumeros: Array<number>): string => {
-    return String.fromCodePoint(...arrayNumeros);
-  }
-
-  // Conversor para Texto, separado por virgula
-  static convertToTexto2 = (stringNumeros: string): string => {
-    return String.fromCodePoint(...stringNumeros.split(",").map(i => Number(i)));
-  }
-
-  static aCadaElemento = (query: any, fn: Function): any[] => {
-    // A cada elemento encontrado pelo QAll executa a funcao
-    let elementos = LibUtil.QAll(query);
-    elementos.forEach((e: any) => {
-      fn(e);
-    });
-    // Sempre retorna uma array por caus do QAll
-    return elementos;
-  };
-
-  // Executa a FUNCAO em todas as propriedades deste OA. Inclusive Obj.Obj... (Matriz de Dados)
-  static aCadaSubPropriedade = (OA: any, funcao: Function | null = null, exceto: string = "Object") => {
-    let c = 0;
-    for (let a in OA) {
-      if (LibUtil.classof(OA[a]) != exceto) {
-        if (funcao) {
-          funcao(OA[a], a, OA);
-        }
-      }
-      c++;
-      // Se o atual é objeto, itera internamente
-      if (LibUtil.classof(OA[a]) == "object") {
-        c += LibUtil.aCadaSubPropriedade(OA[a], funcao, exceto);
-      }
-      // Se o atual é array, itera internamente
-      if (LibUtil.classof(OA[a]) == "array") {
-        c += LibUtil.aCadaSubPropriedade(OA[a], funcao, exceto);
-      }
-    }
-    return c;
-  };
-
-  static apenasEstes = (s: string = "", regexPossiveis: string = "0-9\+"): string => {
-    if (s == null) return "";
-    let regex = new RegExp("(?![" + regexPossiveis + "]).");
-    return s.toString().replace(regex, "");
-  }
-
-  static getV = (keys: string | string[], objeto: any): any => {
-    // Retorna o valor do chave informada, podendo ser obj.obj.chave
-    // LibUtil.getV("a.b.c",{a:{b:{c:"d"}}})
-    if (LibUtil.classof(objeto) == "object") {
-      if (LibUtil.classof(keys) == "string") {
-        if (keys.includes(".")) {
-          // Multi
-          let ks: string[] = (keys as string).split(".");
-          let lastObj = objeto;
-          let lastV = {};
-          // Iterar o Keys, Ver Obj atual e Setar Conteudo;
-          ks.forEach((k) => {
-            if (lastObj) { // Pode ficar nulo durante
-              lastV = lastObj[k];
-              if (typeof lastV == "object") {
-                lastObj = lastV;
-              } else {
-                lastObj = null;
-              }
-            }
-          });
-          return lastV;
-        } else {
-          // Simples
-          return objeto[(keys as string)];
-        }
-      } else if (LibUtil.classof(keys) == "array") {
-        // Array de Keys. Faz um loop e de forma recursiva tenta pegar o valor. Se o valor não for nulo, interrompe e retorna.
-        let lastV = null;
-        for (let k of (keys as string[])) {
-          lastV = LibUtil.getV(k, objeto);
-          if (lastV != null) {
-            return lastV;
-          }
-        }
-      } else {
-        LOG(1, "❌ getV() - Nome da propriedade precisa ser em String. (" + LibUtil.classof(keys) + "):", keys);
-      }
-    } else {
-      LOG(1, "❌ Para ver a chave, o parametro objeto precisa receber um objeto. (" + typeof objeto + ")");
-    }
-    return null;
-  };
-
-  static setV = (keys: string, value: any, objeto: any) => {
-    // Retorna o valor do chave informada, podendo ser obj.obj.chave
-    // LibUtil.setV("a.b.c","mudei",{a:{b:{c:"d"}}})
-    if (typeof objeto == "object") {
-      if (LibUtil.classof(keys) == "string") {
-        if (keys.includes(".")) {
-          // Multi
-          let ks: string[] = keys.split(".");
-          let lastObj = objeto;
-          // Iterar o Keys, Ver Obj atual e Setar Conteudo;
-          ks.forEach((k) => {
-            if (ks.indexOf(k) == (ks.length - 1)) {
-              // Último
-              lastObj[k] = value;
-            } else {
-              if (LibUtil.classof(lastObj[k]) != "object") {
-                lastObj[k] = {};
-              }
-            }
-            lastObj = lastObj[k];
-          });
-          return objeto;
-        } else {
-          // Set direto, não tem ponto e é string
-          objeto[keys] = value;
-          return objeto;
-        }
-      } else {
-        LOG(1, "❌ setV() - Nome da propriedade precisa ser em string. (" + LibUtil.classof(keys) + "):", keys);
-      }
-    } else {
-      LOG(1, "❌ setV() - Objeto precisa receber um objeto. (" + typeof objeto + ")");
-    }
-    return null;
-  };
-
-  static geraObjForm = (form: any) => {
-    // Gerar Objeto a partir de um Form Entries
-    if (LibUtil.classof(form) != "object") {
-      // Se vier o Elemento Form / o Query do Form
-      form = LibUtil.Q(form);
-    }
-    // Coleta apenas os campos com value.
-    let rObjeto: any = [...form.querySelectorAll(" *[name]")]
-      .map(o => { return { [o.name]: o.value } })
-      .reduce((a, o) => { a = { ...a, ...o }; return a; }, {});
-    if (form) {
-
-      for (let [k, v] of Object.entries(rObjeto)) {
-        LibUtil.setV(k, v, rObjeto);
-        if (k.includes(".")) {
-          delete rObjeto[k];
-        }
-      }
-      Array.from(form.querySelectorAll("mk-sel")).forEach((e: any) => {
-        // rObjeto[mk.name] = mk.value;
-        LibUtil.setV(e.name, e.value, rObjeto);
-      });
-      // Aqui apenas coleta os mkBot que foram modificados pelo usuário.
-      Array.from(form.querySelectorAll("mk-bot.changed")).forEach((e: any) => {
-        // rObjeto[mk.name] = mk.value;
-        LibUtil.setV(e.name, e.value, rObjeto);
-      });
-    }
-    return rObjeto;
-  }
-
-  static funcoesDinamicas = new Map<string, Function>();
-  static aCada1s = () => {
-    Array.from(LibUtil.funcoesDinamicas.values()).map((fn: Function) => { if (fn != null) fn() });
-    setTimeout(() => {
-      LibUtil.aCada1s();
-    }, 1000);
-  };
-
-  static cortarString = (linha: string, regex: string, casas: any) => {
-    let resultado: any = "";
-    try {
-      resultado = new RegExp(regex).exec(linha)?.groups?.["ok"];
-    } catch (e) {
-      LOG(1, "Regex Inválido. ", e);
-      return "0";
-    }
-    if ((!casas) || (casas == "") || (casas <= 0)) casas = 0;
-    return `${LibUtil.toNumber(resultado, casas)}`;
-  }
-
-  static uuid = () => {
-    // Padrão UUIDV4 - Gerador de identificador unico
-    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c: any) => { // c = String
-      return (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16);
-    }).toString().toUpperCase();
-  }
-
-  // mk.isRoute("/Pesagem$") // <= Rota termina com /Pesagem
-  static isRoute = (rotaRegex: string) => {
-    return new RegExp(rotaRegex).test(window.location.pathname);
-  }
-
-  static verificarIgualdade(array: any[], propriedades: string[]) {
-    // Verifica se várias propriedades estão iguais em todos os objetos de um array.
-    if (array.length <= 1) return true;
-    const primeiro = array[0];
-    return array.every(objeto => {
-      return propriedades.every(propriedade => {
-        // Verifica se a propriedade existe em ambos os objetos antes da comparação
-        if (!(propriedade in objeto) || !(propriedade in primeiro)) {
-          LOG(1, `⚠️ Propriedade '${propriedade}' ausente em um ou mais objetos.`);
-          return false; // considera falso se a propriedade não existir
-        }
-        return objeto[propriedade] === primeiro[propriedade];
-      });
-    });
-  }
-
-  static individualNoObjeto(array: any[], propriedade: string): any[] {
-    // Ignora os Objetos que esta Propriedade se repetir.
-    let novoSet = new Set(array.map((o) => { return o[propriedade] }));
-    return array.map((o) => {
-      if (novoSet.has(o[propriedade])) {
-        novoSet.delete(o[propriedade]);
-        return o;
-      } else return null;
-    }).filter(o => o);
-  }
-
-  static hasFaltante(array: any[], propriedades: string[]) {
-    // Verifica as propriedades informadas estão disponíveis em todos os objetos do array.
-    if (array.length <= 0) return false;
-    return array.every(objeto => {
-      return propriedades.every(propriedade => {
-        if (!(propriedade in objeto)) {
-          return true;
-        }
-        return false;
-      });
-    });
-  }
-
-  static somarEmObjeto(lista: any[], propriedade: string) {
-    // Soma uma determinada propriedade em uma lista
-    return lista.reduce((acc: number, val: any) => {
-      if (LibUtil.classof(val[propriedade]) == "number") {
-        return acc + val[propriedade];
-      }
-      return acc;
-    }, 0);
-  }
-
-  static capitalize = (texto?: string | null): string => {
-    let arrayTexto = texto?.toString().split(" ");
-    return arrayTexto?.map(str => {
-      let str_low = str.toLowerCase();
-      if (["da", "de", "do", "das", "dos", "e"].includes(str_low)) {
-        return str_low;
-      } else {
-        return str_low.charAt(0).toUpperCase() + str_low.slice(1);
-      }
-    }).join(" ") || "";
-  };
-
-  static GetParam = (name: string | null = null, url: string | null = null) => {
-    // Coleta o valor do parametro da url.
-    if (!url) url = document.location.toString();
-    if (name != null) {
-      return new URL(url).searchParams.get(name);
-    } else {
-      return new URL(url).searchParams.toString();
-    }
-  }
-
-  static getParamObject = (url?: string) => {
-    if (!url) url = document.location.toString();
-    return url?.split("?")[1]?.split("&")?.reduce((acc: any, val: string) => {
-      const [key, value] = val.split("=");
-      acc[key] = value;
-      return acc;
-    }, {});
-  }
-
-  static toQueryString(obj?: any, urlAtual: string = ""): string {
-    if (obj) {
-      // Quando é GET, modifica a URL e acrescenta os QUERYSTRING do objeto enviado por parametro.
-      if (obj != null) {
-        if (!urlAtual.includes("?")) {
-          urlAtual = urlAtual + "?"; // Cria o divisor entre os dados do query e o endereço destino.
-        }
-        let queryStrings = "";
-        if (LibUtil.classof(obj) == "object") {
-          for (let propriedade in obj) {
-            if (LibUtil.classof(obj[propriedade]) == "object") {
-              let propJson = JSON.stringify(obj[propriedade]);
-              queryStrings += `&${propriedade}=${propJson}`;
-              LOG(1, `⚠️ toQueryString() - Uma propriedade enviada: '${propriedade}' era um objeto. Url`, urlAtual);
-            } else {
-              if (obj[propriedade] != null) {
-                queryStrings += `&${propriedade}=${obj[propriedade]}`;
-              }
-            }
-          }
-        } else {
-          LOG(1, "❌ Dados enviados via GET precisam ser Object. Dados: ", LibUtil.classof(obj));
-        }
-        urlAtual = urlAtual + queryStrings;
-      }
-    }
-    if (urlAtual.endsWith("?")) urlAtual = urlAtual.slice(0, -1); // Remove o ? final se não tiver nada depois.
-    urlAtual = urlAtual.replaceAll("?&", "?");
-    return urlAtual;
-  }
-
-  /**
-   * Mapeia uma EntidadeA para EntidadeB usando o TRANSFORMA
-   * É nescessário informar o DE/PARA/TRANSFORMA de cada propriedade.
-   */
-  static mapearEntidade<T, U>(
-    entidadeOrigem: T,
-    mapeamento: MapeamentoItem<T, U>[]
-  ): U {
-    const entidadeDestino: any = {};
-    mapeamento.forEach(item => {
-      const valor = entidadeOrigem[item.de];
-      if (valor !== undefined) {
-        entidadeDestino[item.para] = item.transforma(valor);
-      } else {
-        entidadeDestino[item.para] = null;
-      }
-    });
-    return entidadeDestino as U;
-
-  }
-
-  /**
-   * Faz uma tentativa de obter uma url, mas se falhar, retorna nulo
-   */
-  static getURL(urlQuery?: string) {
-    let url;
-    if (urlQuery) {
-      try {
-        url = new URL(urlQuery);
-      } catch (e) {
-        LOG(1, "❌ URL INVÁLIDA: ", urlQuery);
-      }
-    }
-    return url;
-  }
-
-  static conversorCSS(texto: string): string[] {
-    const regex = /\.([a-z0-9-]+)\s*{.*?}/g;
-    let arrayTexto = texto.replace(/\s+/g, ' ').replace(/[\r\n]/g, '').replace(regex, (match, group1) => group1 + ",").trim().split(",");
-    return arrayTexto.map(i => i.trim()).filter(o => o != "");
-  }
-
-  static sort<T, K extends keyof T>(array: T[], propriedade: K): T[] {
-    return array.sort((a, b) => (a[propriedade] < b[propriedade] ? -1 : 1));
-  }
-
-  static converteEnterEmBr(texto: string): string {
-    return texto.replace(/\n/g, "<br>");
-  }
-
-  static hasHtmlTags(texto: string): boolean {
-    const regex = /<\/?[a-z][\s\S]*>/i;
-    return regex.test(texto);
-  }
-
-
-  /**
-   * Une duas listas quando elas tem uma propriedade em comum
-   * @param listaA Lista a ser sobreescrita ou preenchida
-   * @param listaB Lista com os dados para preencher ou sobreescrever
-   * @param propEmComum Nome da propriedade que, se estiver em comum nas listas, será populado, do contrário não.
-   * @returns Lista Unida por um Filtro.
-   */
-  static Union(listaA: any[], listaB: any[], propEmComum?: string): any[] {
-    let resultado = listaA.map(itensA => ({
-      ...itensA,
-      ...listaB.filter(o => o[propEmComum as keyof typeof o]?.toString() == itensA[propEmComum as keyof typeof listaA]?.toString())[0],
-    }));
-    G_START(3, "Unindo Listas...")
-    LOG(3, "ListaA: ", listaA);
-    LOG(3, "ListaB: ", listaB);
-    LOG(3, "Resultado: ", resultado);
-    G_END(3);
-    return resultado;
-  }
-
-  /**
-   * Gera uma string menor que a informada.
-   * @returns 
-   */
-  static gerarHashCurto(texto: string, tamanho: number = 8): string {
-    let hash = 0;
-    for (let i = 0; i < texto.length; i++) {
-      hash = ((hash << 5) - hash) + texto.charCodeAt(i);
-      hash = hash & hash; // Converte para inteiro de 32 bits
-    }
-    // Converter para string hexadecimal positiva e pegar os primeiros caracteres
-    return Math.abs(hash).toString(16).substring(0, tamanho);
-  }
-
-  static gerarNomeColection(nomeSistema: string, colecao: string): string {
-    return LibUtil.gerarHashCurto(nomeSistema) + "_" + colecao;
-  }
-
-
-  static apenasNumerosLetras = (s: string = ""): string => {
-    if (s == null) return "";
-    // Ignora qualquer outro caracter além de Numeros e Letras formato ocidental
-    return s.replace(/(?![a-zA-Z0-9])./g, "");
-  };
-
-  static removeEspecias = (s: string): string => {
-    if (s == null) return "";
-    // Remove acentos e depois chama Apenas Números e Letras.
-    s = s.toString();
-    return LibUtil.apenasNumerosLetras(LibUtil.removeAcentos(s));
-  };
-
-  static LerTexto = async (texto = "Teste som: 1, 2, 3.", locutor = 0) => {
-    let lerVoz = window.speechSynthesis;
-    let listaVozes = lerVoz.getVoices().filter(o => o.lang.toLowerCase() == "pt-br");
-    let locutorEncontrado = listaVozes[locutor] || listaVozes[0] || null;
-    return new Promise((r) => {
-      if (lerVoz.speaking) {
-        LOG(1, ">> Ainda está reproduzindo. Tente mais tarde.");
-        return;
-      }
-      if (texto != "") {
-        const ssu = new SpeechSynthesisUtterance(texto);
-        ssu.lang = "pt-BR";
-        ssu.voice = locutorEncontrado;
-        ssu.pitch = 0; // Tom de voz
-        ssu.rate = 1.5; // Velocidade
-        ssu.onend = (ev) => { r(true) };
-        ssu.onerror = (ev) => { LOG(1, "❌ Erro: ", ev.error); r(false) };
-        lerVoz.cancel();
-        lerVoz.speak(ssu);
-      }
-    });
-  }
-
-  static async LerProximoERemover(playlist: string[]) {
-    if (await LibUtil.LerTexto(playlist[0]) == true) {
-      playlist.shift();
-    }
-    return playlist;
-  }
-
-  static LeituraInterrompida() {
-    window.speechSynthesis.cancel();
-  }
-
-  static gerarNumeroInteiro(min: number, max: number): any {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-  }
-
-  static SelectInner(e: HTMLInputElement) {
-    // Seleciona texto do elemento
-    if (window.getSelection) {
-      const selection = window.getSelection();
-      const range = document.createRange();
-      range.selectNodeContents(e);
-      selection?.removeAllRanges();
-      selection?.addRange(range);
-    }
-  }
-
-  static generatePrimaryKey(item: any, primarykey: string): any {
-    if (item == null) {
-      LOG(1, "❌ Não foi possível gerar uma chave, pois o objeto ainda não está preenchido.")
-      return item;
-    }
-
-    if (LibUtil.classof(item) != "object") {
-      LOG(1, "⚠️ Não foi possível gerar uma chave neste tipo de variável: ", LibUtil.classof(item));
-      return item;
-    }
-
-    if (item[primarykey] != null) {
-      LOG(5, "Chave não gerada no objeto, pois já estava preenchido com:", item[primarykey]);
-      return item;
-    }
-
-    item[primarykey] = LibUtil.uuid();
-    return item;
-  }
-
-  static hslToHex(h: number, s: number, l: number) {
-    // Normalize saturation and lightness to a 0-1 range
-    s /= 100;
-    l /= 100;
-
-    let c = (1 - Math.abs(2 * l - 1)) * s,
-      x = c * (1 - Math.abs(((h / 60) % 2) - 1)),
-      m = l - c / 2,
-      r = 0,
-      g = 0,
-      b = 0;
-
-    if (0 <= h && h < 60) {
-      r = c;
-      g = x;
-      b = 0;
-    } else if (60 <= h && h < 120) {
-      r = x;
-      g = c;
-      b = 0;
-    } else if (120 <= h && h < 180) {
-      r = 0;
-      g = c;
-      b = x;
-    } else if (180 <= h && h < 240) {
-      r = 0;
-      g = x;
-      b = c;
-    } else if (240 <= h && h < 300) {
-      r = x;
-      g = 0;
-      b = c;
-    } else if (300 <= h && h < 360) {
-      r = c;
-      g = 0;
-      b = x;
-    }
-
-    // Convert RGB values to 0-255 range
-    r = Math.round((r + m) * 255);
-    g = Math.round((g + m) * 255);
-    b = Math.round((b + m) * 255);
-
-    // Convert RGB components to hexadecimal and pad with leading zero if needed
-    const toHex = (c: any) => {
-      const hex = c.toString(16);
-      return hex.length === 1 ? '0' + hex : hex;
-    };
-
-    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-  }
-
-  static isFilled(dados: any): boolean {
-    if (LibUtil.classof(dados) == "array") {
-      if ((dados as Array<any>).length && (dados as Array<any>).length > 0) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  static replace(regex: string, valor: string | number): string {
-    if (typeof valor === "number") valor = valor.toString();
-    return valor.replace(new RegExp(regex, 'g'), '');
-  }
-
-  // Mínimo 2 timestamps
-  static calculateJitter(timestamps: number[]): number {
-    if (timestamps.length < 2) return 0;
-
-    const delays = [];
-    for (let i = 1; i < timestamps.length; i++) {
-      delays.push(timestamps[i] - timestamps[i - 1]);
-    }
-
-    if (delays.length < 2) return 0;
-    let totalJitterDifference = 0;
-
-    for (let i = 1; i < delays.length; i++) {
-      totalJitterDifference += Math.abs(delays[i] - delays[i - 1]);
-    }
-
-    return totalJitterDifference / (delays.length - 1);
-  }
-
-  // Soma os valores dos arrays por índice
-  static somarPorIndice = (arrays: number[][]): number[] => {
-    if (arrays.length === 0) return [];
-    return arrays.reduce((acc, arr) =>
-      arr.map((val, i) => (acc[i] || 0) + val)
-    );
-  }
-
-  // Soma os valores dos arrays
-  static somarArrayInterna = (arrays: number[][]): number[] => {
-    if (arrays.length === 0) return [];
-    return arrays.map(a => a.reduce((acc, v) => acc + v, 0));
-  }
-
-  // Faz o download de um Blob()
-  static downloadBlob = (blob: Blob, nomeArquivo: string) => {
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = nomeArquivo;
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-    URL.revokeObjectURL(url);
-  }
-
-  static wordsToCamelCase(texto: string): string {
-    // Se houver espaços, traços, undercores, converte para camelCase
-    return texto.split(/[\s-_]+/)
-      .map((word, index) =>
-        index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
-      ).join('');
-  }
-
-  static camelCase(texto: string): string {
-    return texto.charAt(0).toLowerCase() + texto.slice(1);
-  }
-
-  static pascalCase(texto: string): string {
-    return texto.charAt(0).toUpperCase() + texto.slice(1);
-  }
-
-  static dashedCase(texto: string): string {
-    // Converte camelCase ou PascalCase para dashed-case
-    return texto.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-  }
-
-  static separaWordsCase(texto: string): string {
-    // Separa as palavras ao trocar de letra minúscula para maiúscula.
-    // CodigoIBGE => Codigo IBGE
-    let textoSeparado = texto.replace(/([a-z])([A-Z])/g, '$1 $2');
-    return textoSeparado;
-  }
-
-  // Separa as palavras por espaço, traço ou underline, e retorna um array com as palavras.
-  static wordsArray(texto: string): string[] {
-    return texto.split(/[\s-_]+/).filter(word => word.length > 0);
-  }
-
-  static tentaAcentuarTexto(s: string | string[]): string {
-    // Utiliza regras de acentuação de português para tentar acentuar a palavra informada.
-    if (LibUtil.classof(s) == "array") {
-      return (s as string[]).map((palavra) => LibUtil.tentaAcentuarTexto(palavra)).join(" ");
-    }
-    let texto = (s as string);
-    if (texto.endsWith("ao")) {
-      texto = texto.slice(0, -2) + "ão"; // Ex: mão
-    }
-    if (texto.endsWith("oes")) {
-      texto = texto.slice(0, -3) + "ões"; // Ex: permissões
-    }
-    if (texto.endsWith("cao") || texto.endsWith("çao") || (texto.endsWith("cão") && texto != "cão")) {
-      texto = texto.slice(0, -3) + "ção"; // Ex: ação
-    }
-    if (texto.endsWith("coes") || texto.endsWith("çoes") || texto.endsWith("cões")) {
-      texto = texto.slice(0, -4) + "ções"; // Ex: observações
-    }
-
-    return texto;
-  }
-
-  static pluralOf(word: string | string[]): string {
-    // Retorna o plural da palavra informada em português
-    if (LibUtil.classof(word) == "array") {
-      return (word as string[]).map((palavra) => LibUtil.pluralOf(palavra)).join(" ");
-    }
-
-    let texto = (word as string);
-    if (texto.endsWith("ão")) {
-      return texto.slice(0, -2) + "ões";
-    } else if (texto.endsWith("ões")) {
-      return texto.slice(0, -3) + "ões";
-    } else if (texto.endsWith("r") || texto.endsWith("s") || texto.endsWith("z")) {
-      return texto + "es";
-    } else if (texto.endsWith("m")) {
-      return texto.slice(0, -1) + "ns";
-    } else if (texto.endsWith("l")) {
-      return texto.slice(0, -1) + "is";
-    } else {
-      return texto + "s";
-    }
-  }
-
-  static setLogLevel(level: number): void {
-    LibUtil.loglevel = level;
-  }
-
-  static setFormConfigs(configs: Partial<IFieldComponent<any>>): void {
-    LibUtil.formConfigs = configs;
-  }
-
-  static paraPortugues(texto: string): string {
-    let acentuado = LibUtil.tentaAcentuarTexto(LibUtil.wordsArray(LibUtil.separaWordsCase(texto)))
-    return LibUtil.replaceDicionario(acentuado);
-  }
-
-  static paraPortuguesPlural(texto: string): string {
-    let plural = LibUtil.pluralOf(LibUtil.paraPortugues(texto))
-    return plural;
-  }
-
-  // Dicionário
-  static replaceDicionario(texto: string): string {
-    if (texto.startsWith("Is ")) {
-      texto = texto.replace(/^Is /, "É ");
-    }
-    texto = texto.replaceAll("Codigo", "Código");
-    texto = texto.replaceAll("Icone", "Ícone");
-    texto = texto.replaceAll("Enderec", "Endereç");
-    texto = texto.replaceAll("Balanc", "Balanç");
-    texto = texto.replaceAll("Usuari", "Usuári");
-    texto = texto.replaceAll("Lancamento", "Lançamento");
-    texto = texto.replaceAll("Referencia", "Referência");
-    texto = texto.replaceAll("Ultim", "Últim");
-    texto = texto.replaceAll("Numero", "Número");
-    texto = texto.replaceAll("Inicio", "Início");
-    texto = texto.replaceAll("Socio", "Sócio");
-    texto = texto.replaceAll("Socia", "Sócia");
-    texto = texto.replaceAll("Especie", "Espécie");
-    texto = texto.replaceAll("Cobranca", "Cobrança");
-    texto = texto.replaceAll("Modulo", "Módulo");
-    texto = texto.replaceAll("Servico", "Serviço");
-    texto = texto.replaceAll("Aliquota", "Alíquota");
-    texto = texto.replaceAll("Calculo", "Cálculo");
-    texto = texto.replaceAll("Unitario", "Unitário");
-    texto = texto.replaceAll("Procedencia", "Procedência");
-    texto = texto.replaceAll("Mudanca", "Mudança");
-    texto = texto.replaceAll("Pratica", "Prática");
-    texto = texto.replaceAll("Propria", "Própria");
-    texto = texto.replaceAll("Impropria", "Imprópria");
-    texto = texto.replaceAll("Responsavel", "Responsável");
-    texto = texto.replaceAll("Conjuge", "Cônjuge");
-    texto = texto.replaceAll("Cafe", "Café");
-    texto = texto.replaceAll("Transferencia", "Transferência");
-    texto = texto.replaceAll("Bancaria", "Bancária");
-    texto = texto.replaceAll("Agencia", "Agência");
-    texto = texto.replaceAll("Digito", "Dígito");
-
-    if (texto.includes("Mes ")) texto = texto.replaceAll("Mes ", "Mês ");
-    if (texto.endsWith("Mes")) texto = texto.replace(/Mes$/, "Mês");
-    if (texto.includes("Ate ")) texto = texto.replaceAll("Ate ", "Até ");
-    if (texto.endsWith("Ate")) texto = texto.replace(/Ate$/, "Até");
-    if (texto.includes("Socio ")) texto = texto.replaceAll("Socio ", "Sócio ");
-    if (texto.endsWith("Socio")) texto = texto.replace(/Socio$/, "Sócio");
-    if (texto.includes("Socia ")) texto = texto.replaceAll("Socia ", "Sócia ");
-    if (texto.endsWith("Socia")) texto = texto.replace(/Socia$/, "Sócia");
-    return texto;
-  }
-
-}
-
-
-
-
-////////////////////////////////////
-// CONSOLES: LOG - WARN - ERR ...
-////////////////////////////////////
-// LibUtil.loglevel: 1,2,3 => Bigger will see more
-
-export const LOG = (level: number, ...attr: any) => {
-  if (LibUtil.loglevel >= level) {
-    return console.log(...attr);
-  }
-}
-
-// export const WARN = (level: number, ...attr: any) => {
-//   if (LibUtil.loglevel >= level) {
-//     return console.warn(...attr);
-//   }
-// }
-
-// export const ERR = (level: number, ...attr: any) => {
-//   if (LibUtil.loglevel >= level) {
-//     return console.error(...attr);
-//   }
-// }
-
-export const G_START = (level: number, ...attr: any) => {
-  if (LibUtil.loglevel >= level) {
-    return console.groupCollapsed(...attr);
-  }
-}
-
-export const G_START_OPEN = (level: number, ...attr: any) => {
-  if (LibUtil.loglevel >= level) {
-    return console.group(...attr);
-  }
-}
-
-export const G_END = (level: number, ...attr: any) => {
-  if (LibUtil.loglevel >= level) {
-    return console.groupEnd();
-  }
-}
-
-// LOG COLAPSADO
-export const LOGC = (level: number, title: string, ...attr: any) => {
-  G_START(level, title);
-  LOG(level, ...attr);
-  G_END(level);
-}
-
-
-
-export type IClassOf = "string" | "number" | "nan" | "object" | "array" | "boolean" | "undefined" | "null" | "function" | "date" | "regexp" | "error" | "symbol" | "bigint"
-
-export interface IFormatter {
-  mask: string | ((value: any) => string);
-  regex: string;
-  validate: (value: any) => boolean;
-}
-
-export interface IUtilFormatters {
-  cpf: IFormatter;
-  cnpj: IFormatter;
-  cpf_cnpj: IFormatter;
-  cnh: IFormatter;
-  pis: IFormatter;
-  dia: IFormatter;
-  mes: IFormatter;
-  ano: IFormatter;
-  anoRecente: IFormatter;
-  data: IFormatter;
-  dataIso: IFormatter;
-  numero: IFormatter;
-  decimal: IFormatter;
-  letra: IFormatter;
-  numeroELetra: IFormatter;
-  ip: IFormatter;
-  email: IFormatter;
-  cep: IFormatter;
-}
-
-export interface MapeamentoItem<T, U> {
-  de: keyof T;
-  para: keyof U;
-  transforma: (v: T[keyof T]) => U[keyof U];
-}