validation-br 2.0.0-next-9 → 2.0.0-next-10

package/dist/cjs/certidao.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Certidao
+ * Detalhamento do cálculo da matrícula (CNJ - 32 dígitos)
+ *
+ * @doc
+ * O Número de Matrícula tem a configuração aaaaaa.bb.cc.dddd.e.fffff.ggg.hhhhhhh-ii, onde:
+ *
+ * - aaaaaa: Código Nacional da Serventia (identificação única do cartório) ex.: 10453-9
+ * - bb: Código do Acervo (01-Acervo Próprio e 02-Acervos incorporados)
+ * - cc: Tipo de Serviço Prestado (55 - Serviço de Registro Civil das Pessoas Naturais)
+ * - dddd: Ano do Registro - ex.: 2013
+ * - e: Tipo do livro
+ *    1 - Livro A (Nascimento)
+ *    2 - Livro B (Casamento)
+ *    3 - Livro B Auxiliar (Registro de casamentos religiosos para fins civis)
+ *    4 - Livro C (Óbito)
+ *    5 - Livro C Auxiliar (Registro de Natimortos)
+ *    6 - Livro D (Registro de Proclamas)
+ *    7 - Livro E (Demais atos relativos ao Registro Civil ou Livro E único)
+ *    8 - Livro E (Desdobrado para registro específico das Emancipações)
+ *    9 - Livro E (Desdobrado para registro específico das Interdições)
+ * - fffff: Número do livro - ex.: 00012
+ * - ggg: Número da folha - ex.: 021
+ * - hhhhhhh: Número do Termo - ex.: 0000123
+ * - ii: Dígito Verificador DV, cujo cálculo obedece ao esquema de MÓDULO 11.
+ *
+ * Exemplo de Cálculo: 104539.01.55.2013.1.00012.021.0000123-21
+ *
+ * 1) Cálculo do primeiro DV.
+ *  - Soma-se o produto dos 30 primeiros dígitos por pesos específicos:
+ *    Pesos: 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+ *
+ *    1  0  4  5  3  9  0  1  5  5  2  0  1  3  1  0  0  0  1  2  0  2  1  0  0  0  0  1  2  3
+ *    x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x
+ *    2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9
+ *
+ *    Soma = 288
+ *
+ *  - O somatório encontrado é dividido por 11.
+ *    288 ÷ 11 = 26, com resto 2.
+ *    DV1 = Resto (2). Se resto for 10, DV1 será 1.
+ *
+ * 2) Cálculo do segundo DV.
+ *  - Soma-se o produto dos 31 primeiros dígitos (incluindo DV1) por novos pesos.
+ *    Pesos: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+ *
+ *    1  0  4  5  3  9  0  1  5  5  2  0  1  3  1  0  0  0  1  2  0  2  1  0  0  0  0  1  2  3  2
+ *    x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x
+ *    1  2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9
+ *
+ *    Soma = 309
+ *
+ *  - O somatório encontrado é dividido por 11.
+ *    309 ÷ 11 = 28, com resto 1.
+ *    DV2 = Resto (1). Se resto for 10, DV2 será 1.
+ *
+ * Links:
+ * - http://ghiorzi.org/DVnew.htm#zc
+ * - https://www.arpensp.org.br/calculo-de-matricula
+ *
+ * @param {String} value Matrícula da Certidão
+ * @returns {Boolean}
+ */
+import { Base } from './base';
+export declare enum CertidaoTipoLivro {
+    Nascimento = "1",
+    Casamento = "2",
+    CasamentoReligioso = "3",
+    Obito = "4",
+    Natimorto = "5",
+    Proclamas = "6",
+    Outros = "7"
+}
+export declare enum CertidaoServico {
+    Notas = "51",
+    Protesto = "52",
+    RegistroImoveis = "53",
+    RegistroTitulosDocumentos = "54",
+    RegistroCivilPessoasNaturais = "55",
+    RegistroContratosMaritimos = "56",
+    RegistroDistribuicao = "57"
+}
+export interface FakeCertidaoOptions {
+    cns?: string;
+    acervo?: string;
+    servico?: CertidaoServico;
+    ano?: number;
+    tipoLivro?: CertidaoTipoLivro;
+    livro?: number;
+    folha?: number;
+    termo?: number;
+}
+export declare class Certidao extends Base {
+    protected _value: string;
+    protected _mask: string;
+    constructor(_value: string);
+    protected normalize(): void;
+    /**
+     * Valida se a certidão atual possui o DV correto e tamanho 32
+     */
+    validate(): boolean;
+    /**
+     * Calcula o DV para uma sequência de 30 dígitos
+     * Algoritmo Módulo 97:
+     */
+    static checksum(base30: string): string;
+    /**
+     * Gera uma instância de Certidao válida com dados aleatórios ou específicos
+     */
+    static fake(options?: FakeCertidaoOptions): Certidao;
+}

package/dist/{certidao.js → cjs/certidao.js}

@@ -1,39 +1,66 @@
 "use strict";
 /**
- * DETALHAMENTO DO CÁLCULO DA MATRÍCULA (CNJ - 32 DÍGITOS)
- * ---------------------------------------------------------------------------------
- * A matrícula é composta por 32 algarismos, divididos em 9 blocos:
- * 1. CNS (6 dígitos): Código Nacional da Serventia (Cartório).
- * 2. Acervo (2 dígitos): "01" para próprio, "02" para incorporado.
- * 3. Serviço (2 dígitos): Tipo de registro (ex: 55 para Registro Civil).
- * 4. Ano (4 dígitos): Ano em que o registro foi feito.
- * 5. Tipo de Livro (1 dígito): 1 (Nascimento), 2 (Casamento), etc.
- * 6. Número do Livro (5 dígitos): Sequencial do livro.
- * 7. Número da Folha (3 dígitos): Página do registro.
- * 8. Número do Termo (7 dígitos): Sequencial do registro.
- * 9. DV (2 dígitos): Dígitos verificadores calculados via Módulo 11.
- * * CÁLCULO DO DÍGITO VERIFICADOR (Módulo 11):
- * Para os dois últimos dígitos (DV1 e DV2):
- * * DV1 (31º dígito):
- * - Toma-se os primeiros 30 dígitos.
- * - Multiplica-se cada dígito por pesos decrescentes de 31 a 2.
- * - Soma-se os resultados.
- * - Resto = Soma % 11.
- * - Se Resto < 10, DV1 = Resto. Se Resto == 10, DV1 = 1.
- * * DV2 (32º dígito):
- * - Toma-se os 31 dígitos (30 originais + DV1 calculado).
- * - Multiplica-se cada dígito por pesos decrescentes de 32 a 2.
- * - Soma-se os resultados.
- * - Resto = Soma % 11.
- * - Se Resto < 10, DV2 = Resto. Se Resto == 10, DV2 = 1.
- * ---------------------------------------------------------------------------------
+ * Certidao
+ * Detalhamento do cálculo da matrícula (CNJ - 32 dígitos)
+ *
+ * @doc
+ * O Número de Matrícula tem a configuração aaaaaa.bb.cc.dddd.e.fffff.ggg.hhhhhhh-ii, onde:
+ *
+ * - aaaaaa: Código Nacional da Serventia (identificação única do cartório) ex.: 10453-9
+ * - bb: Código do Acervo (01-Acervo Próprio e 02-Acervos incorporados)
+ * - cc: Tipo de Serviço Prestado (55 - Serviço de Registro Civil das Pessoas Naturais)
+ * - dddd: Ano do Registro - ex.: 2013
+ * - e: Tipo do livro
+ *    1 - Livro A (Nascimento)
+ *    2 - Livro B (Casamento)
+ *    3 - Livro B Auxiliar (Registro de casamentos religiosos para fins civis)
+ *    4 - Livro C (Óbito)
+ *    5 - Livro C Auxiliar (Registro de Natimortos)
+ *    6 - Livro D (Registro de Proclamas)
+ *    7 - Livro E (Demais atos relativos ao Registro Civil ou Livro E único)
+ *    8 - Livro E (Desdobrado para registro específico das Emancipações)
+ *    9 - Livro E (Desdobrado para registro específico das Interdições)
+ * - fffff: Número do livro - ex.: 00012
+ * - ggg: Número da folha - ex.: 021
+ * - hhhhhhh: Número do Termo - ex.: 0000123
+ * - ii: Dígito Verificador DV, cujo cálculo obedece ao esquema de MÓDULO 11.
+ *
+ * Exemplo de Cálculo: 104539.01.55.2013.1.00012.021.0000123-21
+ *
+ * 1) Cálculo do primeiro DV.
+ *  - Soma-se o produto dos 30 primeiros dígitos por pesos específicos:
+ *    Pesos: 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+ *
+ *    1  0  4  5  3  9  0  1  5  5  2  0  1  3  1  0  0  0  1  2  0  2  1  0  0  0  0  1  2  3
+ *    x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x
+ *    2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9
+ *
+ *    Soma = 288
+ *
+ *  - O somatório encontrado é dividido por 11.
+ *    288 ÷ 11 = 26, com resto 2.
+ *    DV1 = Resto (2). Se resto for 10, DV1 será 1.
+ *
+ * 2) Cálculo do segundo DV.
+ *  - Soma-se o produto dos 31 primeiros dígitos (incluindo DV1) por novos pesos.
+ *    Pesos: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+ *
+ *    1  0  4  5  3  9  0  1  5  5  2  0  1  3  1  0  0  0  1  2  0  2  1  0  0  0  0  1  2  3  2
+ *    x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x
+ *    1  2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9 10  0  1  2  3  4  5  6  7  8  9
+ *
+ *    Soma = 309
+ *
+ *  - O somatório encontrado é dividido por 11.
+ *    309 ÷ 11 = 28, com resto 1.
+ *    DV2 = Resto (1). Se resto for 10, DV2 será 1.
  *
  * Links:
- * - https://www.arpensp.org.br/noticia/10670
+ * - http://ghiorzi.org/DVnew.htm#zc
  * - https://www.arpensp.org.br/calculo-de-matricula
- * - https://www.skyinformatica.com.br/produtos/civil/manual2/module_2_6.html
- * - https://atos.cnj.jus.br/files/provimento/provimento_2_27042009_26102012180800.pdf
  *
+ * @param {String} value Matrícula da Certidão
+ * @returns {Boolean}
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Certidao = exports.CertidaoServico = exports.CertidaoTipoLivro = void 0;
@@ -87,23 +114,40 @@ class Certidao extends base_1.Base {
     }
     /**
      * Calcula o DV para uma sequência de 30 dígitos
+     * Algoritmo Módulo 97:
      */
     static checksum(base30) {
         if (!base30)
             throw new ValidationBRError_1.EmptyValueException();
         if (base30.length !== 30)
             throw new ValidationBRError_1.InvalidFormatException();
-        // Pesos de 31 a 2
-        const weights1 = Array.from({ length: 30 }, (_, i) => 31 - i);
-        const soma1 = (0, utils_1.sumElementsByMultipliers)(base30, weights1);
-        let dv1 = soma1 % 11;
+        // Pesos específicos conforme solicitação:
+        // DV1: 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+        const weights1 = [
+            2, 3, 4, 5, 6, 7, 8, 9, 10, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+        ];
+        let sum1 = 0;
+        for (let i = 0; i < 30; i++) {
+            sum1 += parseInt(base30[i], 10) * weights1[i];
+        }
+        let dv1 = sum1 % 11;
         if (dv1 === 10)
             dv1 = 1;
-        // Pesos de 32 a 2
+        // DV2: Inclui o DV1 no final
+        // Pesos: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
         const base31 = base30 + dv1.toString();
-        const weights2 = Array.from({ length: 31 }, (_, i) => 32 - i);
-        const soma2 = (0, utils_1.sumElementsByMultipliers)(base31, weights2);
-        let dv2 = soma2 % 11;
+        const weights2 = [
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+            10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+        ];
+        let sum2 = 0;
+        for (let i = 0; i < 31; i++) {
+            sum2 += parseInt(base31[i], 10) * weights2[i];
+        }
+        let dv2 = sum2 % 11;
         if (dv2 === 10)
             dv2 = 1;
         return `${dv1}${dv2}`;
@@ -113,6 +157,7 @@ class Certidao extends base_1.Base {
      */
     static fake(options = {}) {
         const pad = (n, size) => n.toString().padStart(size, '0');
+        const meupa = (0, utils_1.clearValue)(0, 3, { fillZerosAtLeft: true });
         const cns = options.cns ? pad(options.cns, 6) : pad(Math.floor(Math.random() * 999999), 6);
         const acervo = options.acervo ? pad(options.acervo, 2) : '01';
         const servico = options.servico || CertidaoServico.RegistroCivilPessoasNaturais;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{uuid.js → cjs/uuid.js}

@@ -21,13 +21,16 @@ class UUID extends base_1.Base {
         this._value = this._value.replace(/[^0-9a-z]+/gi, '').toLocaleLowerCase();
     }
     validate() {
-        return /^[0-9a-z]{8}-?[0-9a-z]{4}-?4[0-9a-z]{3}-?[0-9a-z]{4}-?[0-9a-z]{12}$/i.test(this._value);
+        // O quarto grupo (variante, RFC 4122) deve iniciar com 8, 9, a ou b.
+        // Os demais caracteres devem ser hexadecimais (0-9, a-f).
+        return /^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$/i.test(this._value);
     }
-    // 
+    //
     // STATIC
-    // 
+    //
     static fake() {
-        return new UUID(`${random_1.Random.number(8, true)}-${random_1.Random.number(4, true)}-4${random_1.Random.number(3, true)}-${random_1.Random.number(4, true)}-${random_1.Random.number(12, true)}`);
+        const variant = random_1.Random.fromArray(['8', '9', 'a', 'b']);
+        return new UUID(`${random_1.Random.number(8, true)}-${random_1.Random.number(4, true)}-4${random_1.Random.number(3, true)}-${variant}${random_1.Random.alpha(3, false, true)}-${random_1.Random.number(12, true)}`);
     }
 }
 exports.UUID = UUID;

package/dist/esm/_exceptions/ValidationBRError.d.ts

@@ -0,0 +1,24 @@
+export default class ValidationBRError extends Error {
+    constructor(message: string);
+}
+export declare class InvalidChecksumException extends ValidationBRError {
+    constructor();
+}
+export declare class InvalidFormatException extends ValidationBRError {
+    constructor();
+}
+export declare class EmptyValueException extends ValidationBRError {
+    constructor();
+}
+export declare class TooLongException extends ValidationBRError {
+    constructor();
+}
+export declare class TooShortException extends ValidationBRError {
+    constructor();
+}
+export declare class RepeatedSequenceException extends ValidationBRError {
+    constructor();
+}
+export declare class NoChecksumException extends ValidationBRError {
+    constructor();
+}

package/dist/esm/_exceptions/ValidationBRError.js

@@ -0,0 +1,40 @@
+export default class ValidationBRError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+export class InvalidChecksumException extends ValidationBRError {
+    constructor() {
+        super('Dígito verificador inválido');
+    }
+}
+export class InvalidFormatException extends ValidationBRError {
+    constructor() {
+        super('Formato inválido');
+    }
+}
+export class EmptyValueException extends ValidationBRError {
+    constructor() {
+        super('Valor não preenchido');
+    }
+}
+export class TooLongException extends ValidationBRError {
+    constructor() {
+        super('Número de caracteres excedido');
+    }
+}
+export class TooShortException extends ValidationBRError {
+    constructor() {
+        super('Número de caracteres muito curto');
+    }
+}
+export class RepeatedSequenceException extends ValidationBRError {
+    constructor() {
+        super('Sequência de números repetidos não permitida');
+    }
+}
+export class NoChecksumException extends ValidationBRError {
+    constructor() {
+        super('Este objeto não possui dígito verificador');
+    }
+}

package/dist/esm/_helpers/crc.d.ts

@@ -0,0 +1,7 @@
+export declare class CRC {
+    private _value;
+    constructor(_value: string);
+    get value(): string;
+    static numToHex(n: number, digits?: number): string;
+    calculate(invert?: boolean): string;
+}

package/dist/esm/_helpers/crc.js

@@ -0,0 +1,43 @@
+export class CRC {
+    constructor(_value) {
+        this._value = _value;
+    }
+    get value() {
+        return this._value;
+    }
+    // https://github.com/NascentSecureTech/pix-qrcode-utils/blob/01a072f458d63dea2376e631284085405fd8b027/packages/data-schemas/src/data-utils.ts#L9
+    static numToHex(n, digits = 4) {
+        const hex = n.toString(16).toUpperCase();
+        return ('0'.repeat(digits) + hex).slice(-digits);
+    }
+    calculate(invert = false) {
+        const bytes = new TextEncoder().encode(this._value);
+        const crcTable = [
+            0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273,
+            0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7,
+            0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b,
+            0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af,
+            0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b,
+            0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6,
+            0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c,
+            0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+            0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0,
+            0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676,
+            0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 0xcb7d,
+            0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d,
+            0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9,
+            0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
+        ];
+        let crc = 0xffff;
+        for (let i = 0; i < bytes.length; i++) {
+            const c = bytes[i];
+            const j = (c ^ (crc >> 8)) & 0xff;
+            crc = crcTable[j] ^ (crc << 8);
+        }
+        const answer = (crc ^ 0) & 0xffff;
+        const hex = CRC.numToHex(answer, 4);
+        if (invert)
+            return hex.slice(2) + hex.slice(0, 2);
+        return hex;
+    }
+}

package/dist/esm/_helpers/crockford.d.ts

@@ -0,0 +1,31 @@
+export declare class Crockford {
+    private static readonly ALPHABET;
+    /**
+     * Normaliza a string conforme as regras do SINTER/CIB:
+     * 1. Remove pontuação e espaços
+     * 2. Converte para Maiúsculas
+     * 3. Substitui 'I' e 'L' por '1'
+     * 4. Substitui 'O' por '0'
+     * 5. Lança erro para o caractere proibido 'U'
+     */
+    static normalize(value: string): string;
+    /**
+     * Converte um caractere alfanumérico para seu valor decimal (0-31)
+     */
+    static charToInt(char: string): number;
+    /**
+     * Converte um valor numérico (0-31) para o caractere correspondente
+     */
+    static intToChar(value: number): string;
+    /**
+     *
+     * Retorna o alfabeto utilizado
+     */
+    static getAlphabet(): string;
+    static getAlphabet(options: {
+        returnArray: false;
+    }): string;
+    static getAlphabet(options: {
+        returnArray: true;
+    }): string[];
+}

package/dist/esm/_helpers/crockford.js

@@ -0,0 +1,58 @@
+export class Crockford {
+    /**
+     * Normaliza a string conforme as regras do SINTER/CIB:
+     * 1. Remove pontuação e espaços
+     * 2. Converte para Maiúsculas
+     * 3. Substitui 'I' e 'L' por '1'
+     * 4. Substitui 'O' por '0'
+     * 5. Lança erro para o caractere proibido 'U'
+     */
+    static normalize(value) {
+        if (!value)
+            return "";
+        let normalized = value
+            .toUpperCase()
+            .replace(/[-.\s]/g, ""); // Remove hífens, pontos e espaços
+        // Substituições de ambiguidade visual
+        normalized = normalized.replace(/[IL]/g, "1");
+        normalized = normalized.replace(/O/g, "0");
+        // Validação do caractere proibido
+        if (normalized.includes("U")) {
+            throw new Error("O caractere 'U' é proibido no padrão CIB/SINTER para evitar palavras obscenas.");
+        }
+        return normalized;
+    }
+    /**
+     * Converte um caractere alfanumérico para seu valor decimal (0-31)
+     */
+    static charToInt(char) {
+        // Normaliza apenas o caractere para garantir que substituições (como 'i' -> '1') ocorram
+        const cleanChar = this.normalize(char);
+        if (cleanChar.length !== 1) {
+            throw new Error("Deve ser fornecido apenas um caractere.");
+        }
+        const index = this.ALPHABET.indexOf(cleanChar);
+        if (index === -1) {
+            throw new Error(`Caractere '${char}' não pertence ao alfabeto Crockford Base32.`);
+        }
+        return index;
+    }
+    /**
+     * Converte um valor numérico (0-31) para o caractere correspondente
+     */
+    static intToChar(value) {
+        if (value < 0 || value > 31) {
+            throw new Error("O valor deve estar entre 0 e 31 para conversão em Base32.");
+        }
+        return this.ALPHABET[value];
+    }
+    static getAlphabet(options) {
+        const { returnArray = false } = options || {};
+        if (returnArray) {
+            return this.ALPHABET.split('');
+        }
+        return this.ALPHABET;
+    }
+}
+// Alfabeto Base 32 de Douglas Crockford (32 caracteres)
+Crockford.ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";

package/dist/esm/_helpers/mask.d.ts

@@ -0,0 +1,18 @@
+export declare class Mask {
+    private _value;
+    constructor(_value: string);
+    /**
+     * applyMask()
+     * Aplica uma máscara a uma string
+     *
+     * @example
+     * applyMask('59650000', '00.000-000') // -> 59.650-000
+     * applyMask('99877665544', '(00) 0 0000-0000') // -> (99) 8 7766-5544
+     *
+     * @param {String|Number} value Valor original
+     * @param {String} mask
+     * @returns {String}
+     *
+     */
+    apply(mask: string): string;
+}

package/dist/esm/_helpers/mask.js

@@ -0,0 +1,33 @@
+import { clearValue, insertAtPosition } from './utils.js';
+export class Mask {
+    constructor(_value) {
+        this._value = _value;
+    }
+    /**
+     * applyMask()
+     * Aplica uma máscara a uma string
+     *
+     * @example
+     * applyMask('59650000', '00.000-000') // -> 59.650-000
+     * applyMask('99877665544', '(00) 0 0000-0000') // -> (99) 8 7766-5544
+     *
+     * @param {String|Number} value Valor original
+     * @param {String} mask
+     * @returns {String}
+     *
+     */
+    apply(mask) {
+        const maskLen = clearValue(mask).length;
+        let masked = clearValue(this._value, maskLen, {
+            fillZerosAtLeft: true,
+            trimAtRight: true,
+        });
+        const specialChars = ['/', '-', '.', '(', ')', ' '];
+        for (let position = 0; position < mask.length; position += 1) {
+            const current = mask[position];
+            if (specialChars.includes(current))
+                masked = insertAtPosition(masked, current, position);
+        }
+        return masked;
+    }
+}

package/dist/esm/_helpers/random.d.ts

@@ -0,0 +1,27 @@
+export declare class Random {
+    /**
+     * Devolve um inteiro aleatório entre um mínimo e um máximo.
+     */
+    static between(min: number, max: number): number;
+    /**
+     * Devolve um texto aleatório
+     */
+    static alpha(length?: number, isUppercase?: boolean, isHex?: boolean): string;
+    /**
+     * Seleciona um item de um array aleatoramente
+     *
+     * @example
+     * const array = [1, 2, 3, 4, 5];
+     *
+     * const singleItem = Random.fromArray(array); // Pode retornar 1, 2, 3, 4 ou 5
+     * const multipleItems = Random.fromArray(array, 3); // Pode retornar [1, 2, 3], [4, 5, 1], etc.
+     *
+     *
+     */
+    static fromArray<T>(array: T[], length: number): T[];
+    static fromArray<T>(array: T[], length?: 1): T;
+    /**
+     * Cria um número aleatório com a quantidade definida de caracteres
+     */
+    static number(length: number, forceLength?: boolean, isAlpha?: boolean): string;
+}

package/dist/esm/_helpers/random.js

@@ -0,0 +1,50 @@
+export class Random {
+    /**
+     * Devolve um inteiro aleatório entre um mínimo e um máximo.
+     */
+    static between(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    /**
+     * Devolve um texto aleatório
+     */
+    static alpha(length = 1, isUppercase = false, isHex = false) {
+        const letters = isHex ? '0123456789abcdef' : 'abcdefghijklmnopqrstuvwxyz';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = Random.between(0, letters.length - 1);
+            result += letters[index];
+        }
+        if (isUppercase)
+            return result.toLocaleUpperCase();
+        return result;
+    }
+    static fromArray(array, length = 1) {
+        const _get = () => array[Random.between(0, array.length - 1)];
+        if (length === 1)
+            return _get();
+        const result = [];
+        for (let i = 0; i < length; i++) {
+            const item = _get();
+            if (item !== undefined) {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    /**
+     * Cria um número aleatório com a quantidade definida de caracteres
+     */
+    static number(length, forceLength = false, isAlpha = false) {
+        let value;
+        if (isAlpha)
+            value = Math.round(Math.random() * 36 ** length)
+                .toString(36)
+                .toLocaleUpperCase();
+        else
+            value = Math.floor(Math.random() * 10 ** length).toString();
+        if (forceLength)
+            return String(value).padStart(length, '0');
+        return String(value);
+    }
+}