@masterkeymaterial/ui 0.0.1 → 0.0.2

package/src/util/util.ts

@@ -0,0 +1,2151 @@
+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];
+}