devtoolz-library 1.0.0

package/dist/crypt.js

@@ -0,0 +1,77 @@
+"use strict";
+// import { CipherGCMTypes, createCipheriv, createDecipheriv } from 'crypto';
+// import { CryptProvider } from './enums/cryptProvider';
+// export class Crypt {
+//     private _getIV(provider: CryptProvider): Buffer {
+//         switch (provider) {
+//             case CryptProvider.Rijndael:
+//                 return Buffer.from([0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9, 0x5, 0x46, 0x9c, 0xea, 0xa8, 0x4b, 0x73, 0xcc]);
+//             default:
+//                 return Buffer.from([0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9]);
+//         }
+//     }
+//     private _getAlgorithm(provider: CryptProvider): string {
+//         switch (provider) {
+//             case CryptProvider.Rijndael:
+//                 return 'aes-256-cbc';
+//             case CryptProvider.RC2:
+//                 return 'rc2-cbc';
+//             case CryptProvider.DES:
+//                 return 'des-cbc';
+//             case CryptProvider.TripleDES:
+//                 return 'des-ede3-cbc';
+//             default:
+//                 throw new Error('Invalid crypt provider');
+//         }
+//     }
+//     private _getKeyBytes(key: string, algorithm: string): Buffer {
+//         let validSize: number;
+//         // Define o tamanho da chave com base no algoritmo
+//         switch (algorithm) {
+//             case 'aes-256-cbc':
+//                 validSize = 32; // 32 bytes = 256 bits
+//                 break;
+//             case 'rc2-cbc':
+//                 validSize = 16; // 16 bytes = 128 bits
+//                 break;
+//             case 'des-cbc':
+//                 validSize = 8; // 8 bytes = 64 bits
+//                 break;
+//             case 'des-ede3-cbc':
+//                 validSize = 24; // 24 bytes = 192 bits (3DES)
+//                 break;
+//             default:
+//                 throw new Error('Invalid algorithm');
+//         }
+//         let keyBuffer = Buffer.from(key);
+//         // Ajusta o tamanho da chave para o tamanho válido
+//         if (keyBuffer.length > validSize) {
+//             keyBuffer = keyBuffer.slice(0, validSize); // Trunca se maior
+//         } else if (keyBuffer.length < validSize) {
+//             keyBuffer = Buffer.concat([keyBuffer, Buffer.alloc(validSize - keyBuffer.length, '*')]); // Preenche se menor
+//         }
+//         return keyBuffer;
+//     }
+//     public encrypt(value: string, key: string, provider: CryptProvider): string {
+//         const algorithm = this._getAlgorithm(provider);
+//         const keyBuffer = this._getKeyBytes(key, algorithm);
+//         const iv = this._getIV(provider);
+//         const cipher = createCipheriv(algorithm, keyBuffer, iv);
+//         let encrypted = cipher.update(value, 'utf8', 'base64');
+//         encrypted += cipher.final('base64');
+//         return encrypted;
+//     }
+//     public decrypt(value: string, key: string, provider: CryptProvider): string | null {
+//         const algorithm = this._getAlgorithm(provider);
+//         const keyBuffer = this._getKeyBytes(key, algorithm);
+//         const iv = this._getIV(provider);
+//         const decipher = createDecipheriv(algorithm, keyBuffer, iv);
+//         try {
+//             let decrypted = decipher.update(value, 'base64', 'utf8');
+//             decrypted += decipher.final('utf8');
+//             return decrypted;
+//         } catch (error) {
+//             return null; // Retorna null em caso de erro
+//         }
+//     }
+// }

package/dist/documents/cnpj/cnpj.d.ts

@@ -0,0 +1,14 @@
+import { IValidationResult } from "../models/validation-result.model";
+export declare class Cnpj {
+    readonly rootDigits: string;
+    readonly orderDigits: string;
+    readonly firstVerifyDigit: string;
+    readonly secondVerifyDigit: string;
+    private constructor();
+    toString(): string;
+    toFormatted(): string;
+    static validate(value: string): IValidationResult;
+    static generate(formatted?: boolean): Cnpj;
+    static parse(value: string): Cnpj;
+    static tryParse(value: string): Cnpj | null;
+}

package/dist/documents/cnpj/cnpj.formatter.d.ts

@@ -0,0 +1,5 @@
+import { IFormatter } from "../interfaces/formatter.interface";
+export declare class CnpjFormatter implements IFormatter {
+    applyMask(cnpj: string): string;
+    removeMask(cnpj: string): string;
+}

package/dist/documents/cnpj/cnpj.formatter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CnpjFormatter = void 0;
+class CnpjFormatter {
+    applyMask(cnpj) {
+        return cnpj.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, "$1.$2.$3/$4-$5");
+    }
+    removeMask(cnpj) {
+        return cnpj.replace(/[^\d]/g, "");
+    }
+}
+exports.CnpjFormatter = CnpjFormatter;

package/dist/documents/cnpj/cnpj.generator.d.ts

@@ -0,0 +1,9 @@
+import "../../extensions/string.extensions";
+import { IGenerator } from "../interfaces/generator.interface";
+export declare class CnpjGenerator implements IGenerator {
+    private readonly _formatter;
+    private _isRepeatedDigits;
+    private _calcVerifyingDigit;
+    private _generateCalculatingDigits;
+    generate(formatted?: boolean): string;
+}

package/dist/documents/cnpj/cnpj.generator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CnpjGenerator = void 0;
+const random_1 = require("../../random");
+require("../../extensions/string.extensions");
+const cnpj_formatter_1 = require("./cnpj.formatter");
+class CnpjGenerator {
+    constructor() {
+        this._formatter = new cnpj_formatter_1.CnpjFormatter();
+    }
+    _isRepeatedDigits(cnpj) {
+        return /^(\d)\1{13}$/.test(cnpj);
+    }
+    _calcVerifyingDigit(startCounter, digits) {
+        let result = 0;
+        digits.forEach(digit => {
+            result += digit.toNumber() * startCounter;
+            startCounter--;
+            if (startCounter < 2)
+                startCounter = 9;
+        });
+        const rest = result % 11;
+        return (rest < 2 ? 0 : 11 - rest).toString();
+    }
+    _generateCalculatingDigits() {
+        const random = new random_1.Random(0, 9, true);
+        let digits = "";
+        do {
+            digits = "";
+            for (let i = 0; i < 12; i++)
+                digits += random.generate(true).toString();
+        } while (this._isRepeatedDigits(digits));
+        return digits;
+    }
+    generate(formatted = false) {
+        const calculating = this._generateCalculatingDigits();
+        const first = this._calcVerifyingDigit(5, calculating);
+        const second = this._calcVerifyingDigit(6, calculating + first);
+        const cnpj = calculating + first + second;
+        return formatted ? this._formatter.applyMask(cnpj) : cnpj;
+    }
+}
+exports.CnpjGenerator = CnpjGenerator;

package/dist/documents/cnpj/cnpj.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cnpj = void 0;
+const cnpj_validator_1 = require("./cnpj.validator");
+const cnpj_generator_1 = require("./cnpj.generator");
+const cnpj_formatter_1 = require("./cnpj.formatter");
+class Cnpj {
+    constructor(rootDigits, orderDigits, firstVerifyDigit, secondVerifyDigit) {
+        this.rootDigits = rootDigits;
+        this.orderDigits = orderDigits;
+        this.firstVerifyDigit = firstVerifyDigit;
+        this.secondVerifyDigit = secondVerifyDigit;
+        Object.freeze(this);
+    }
+    toString() {
+        return this.rootDigits + this.orderDigits + this.firstVerifyDigit + this.secondVerifyDigit;
+    }
+    toFormatted() {
+        const formatter = new cnpj_formatter_1.CnpjFormatter();
+        return formatter.applyMask(this.toString());
+    }
+    static validate(value) {
+        const validator = new cnpj_validator_1.CnpjValidator();
+        return validator.validate(value ?? "");
+    }
+    static generate(formatted) {
+        const generator = new cnpj_generator_1.CnpjGenerator();
+        const generatedValue = generator.generate(formatted);
+        return this.parse(generatedValue);
+    }
+    static parse(value) {
+        const result = this.validate(value);
+        if (!result.isValid)
+            throw new Error(result.message);
+        const digits = value.replace(/[^\d]/g, "");
+        return new Cnpj(digits.substring(0, 8), digits.substring(8, 12), digits[12], digits[13]);
+    }
+    static tryParse(value) {
+        try {
+            return Cnpj.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.Cnpj = Cnpj;

package/dist/documents/cnpj/cnpj.validator.d.ts

@@ -0,0 +1,11 @@
+import "../../extensions/string.extensions";
+import { IValidator } from "../interfaces/validator.interface";
+import { IValidationResult } from "../models/validation-result.model";
+export declare class CnpjValidator implements IValidator {
+    private readonly _formatter;
+    private _isRepeatedDigits;
+    private _isFormatValid;
+    private _calcVerifyingDigit;
+    private _fail;
+    validate(value: string): IValidationResult;
+}

package/dist/documents/cnpj/cnpj.validator.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CnpjValidator = void 0;
+const regexPatterns_1 = require("../../constants/regexPatterns");
+require("../../extensions/string.extensions");
+const cnpj_formatter_1 = require("./cnpj.formatter");
+class CnpjValidator {
+    constructor() {
+        this._formatter = new cnpj_formatter_1.CnpjFormatter();
+    }
+    _isRepeatedDigits(cnpj) {
+        return /^(\d)\1{13}$/.test(cnpj);
+    }
+    _isFormatValid(cnpj) {
+        return regexPatterns_1.cnpjPattern.test(cnpj);
+    }
+    _calcVerifyingDigit(startCounter, digits) {
+        let result = 0;
+        digits.forEach(digit => {
+            result += digit.toNumber() * startCounter;
+            startCounter--;
+            if (startCounter < 2)
+                startCounter = 9;
+        });
+        const rest = result % 11;
+        return (rest < 2 ? 0 : 11 - rest).toString();
+    }
+    _fail(message) {
+        return { isValid: false, message };
+    }
+    validate(value) {
+        if (!value || value.isEmpty())
+            return this._fail("CNPJ está vazio.");
+        if (!this._isFormatValid(value))
+            return this._fail("CNPJ com formato inválido.");
+        const cnpj = this._formatter.removeMask(value);
+        if (this._isRepeatedDigits(cnpj))
+            return this._fail("CNPJ não pode ter todos os dígitos iguais.");
+        const calculating = cnpj.substring(0, 12);
+        const first = cnpj[12];
+        const second = cnpj[13];
+        if (this._calcVerifyingDigit(5, calculating) !== first)
+            return this._fail("Primeiro dígito verificador é inválido.");
+        if (this._calcVerifyingDigit(6, calculating + first) !== second)
+            return this._fail("Segundo dígito verificador é inválido.");
+        return { isValid: true, message: "Válido" };
+    }
+}
+exports.CnpjValidator = CnpjValidator;

package/dist/documents/cnpj/tests/cnpj.formatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/documents/cnpj/tests/cnpj.formatter.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cnpj_formatter_1 = require("../cnpj.formatter");
+describe("CnpjFormatter", () => {
+    let formatter;
+    beforeEach(() => {
+        formatter = new cnpj_formatter_1.CnpjFormatter();
+    });
+    // -------------------------------------------------------------------------
+    // applyMask
+    // -------------------------------------------------------------------------
+    describe("applyMask", () => {
+        it("deve formatar CNPJ sem máscara para o padrão NN.NNN.NNN/NNNN-NN", () => {
+            expect(formatter.applyMask("11222333000181")).toBe("11.222.333/0001-81");
+        });
+        it("deve formatar CNPJ iniciado com zero", () => {
+            expect(formatter.applyMask("00000000000191")).toBe("00.000.000/0001-91");
+        });
+        it("deve retornar string vazia ao receber string vazia", () => {
+            expect(formatter.applyMask("")).toBe("");
+        });
+        it("não deve alterar entrada com menos de 14 dígitos", () => {
+            expect(formatter.applyMask("1234567")).toBe("1234567");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // removeMask
+    // -------------------------------------------------------------------------
+    describe("removeMask", () => {
+        it("deve remover pontos, barra e traço do CNPJ formatado", () => {
+            expect(formatter.removeMask("11.222.333/0001-81")).toBe("11222333000181");
+        });
+        it("deve retornar o mesmo valor se não houver máscara", () => {
+            expect(formatter.removeMask("11222333000181")).toBe("11222333000181");
+        });
+        it("deve remover qualquer caractere não numérico", () => {
+            expect(formatter.removeMask("11 222 333 0001 81")).toBe("11222333000181");
+        });
+        it("deve retornar string vazia ao receber string vazia", () => {
+            expect(formatter.removeMask("")).toBe("");
+        });
+        it("deve retornar string vazia ao receber apenas caracteres não numéricos", () => {
+            expect(formatter.removeMask("..//--")).toBe("");
+        });
+        it("deve preservar zeros à esquerda", () => {
+            expect(formatter.removeMask("00.000.000/0001-91")).toBe("00000000000191");
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Simetria — applyMask ↔ removeMask
+    // -------------------------------------------------------------------------
+    describe("simetria entre applyMask e removeMask", () => {
+        it("removeMask(applyMask(raw)) deve retornar o valor original", () => {
+            const raw = "11222333000181";
+            expect(formatter.removeMask(formatter.applyMask(raw))).toBe(raw);
+        });
+        it("applyMask(removeMask(formatted)) deve retornar o valor original", () => {
+            const formatted = "11.222.333/0001-81";
+            expect(formatter.applyMask(formatter.removeMask(formatted))).toBe(formatted);
+        });
+    });
+});

package/dist/documents/cnpj/tests/cnpj.generator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/documents/cnpj/tests/cnpj.generator.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cnpj_generator_1 = require("../cnpj.generator");
+const cnpj_validator_1 = require("../cnpj.validator");
+describe("CnpjGenerator", () => {
+    let generator;
+    let validator;
+    beforeEach(() => {
+        generator = new cnpj_generator_1.CnpjGenerator();
+        validator = new cnpj_validator_1.CnpjValidator();
+    });
+    // -------------------------------------------------------------------------
+    // generate — sem máscara
+    // -------------------------------------------------------------------------
+    describe("generate sem formatação", () => {
+        it("deve retornar uma string com 14 dígitos", () => {
+            const result = generator.generate();
+            expect(result).toHaveLength(14);
+            expect(result).toMatch(/^\d{14}$/);
+        });
+        it("deve gerar um CNPJ matematicamente válido", () => {
+            const result = generator.generate();
+            const validation = validator.validate(result);
+            expect(validation.isValid).toBe(true);
+        });
+        it("não deve gerar CNPJ com todos os dígitos iguais", () => {
+            for (let i = 0; i < 20; i++) {
+                const result = generator.generate();
+                expect(result).not.toMatch(/^(\d)\1{13}$/);
+            }
+        });
+        it("deve gerar CNPJs diferentes entre chamadas", () => {
+            const results = new Set(Array.from({ length: 20 }, () => generator.generate()));
+            expect(results.size).toBeGreaterThan(1);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // generate — com máscara
+    // -------------------------------------------------------------------------
+    describe("generate com formatação", () => {
+        it("deve retornar CNPJ no formato NN.NNN.NNN/NNNN-NN", () => {
+            const result = generator.generate(true);
+            expect(result).toMatch(/^\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}$/);
+        });
+        it("deve gerar um CNPJ formatado matematicamente válido", () => {
+            const result = generator.generate(true);
+            const validation = validator.validate(result);
+            expect(validation.isValid).toBe(true);
+        });
+    });
+});

package/dist/documents/cnpj/tests/cnpj.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/documents/cnpj/tests/cnpj.test.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cnpj_1 = require("../cnpj");
+describe("Cnpj", () => {
+    // -------------------------------------------------------------------------
+    // parse
+    // -------------------------------------------------------------------------
+    describe("parse", () => {
+        it("deve retornar uma instância de Cnpj para CNPJ válido sem máscara", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11222333000181");
+            expect(cnpj).toBeInstanceOf(cnpj_1.Cnpj);
+        });
+        it("deve retornar uma instância de Cnpj para CNPJ válido com máscara", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11.222.333/0001-81");
+            expect(cnpj).toBeInstanceOf(cnpj_1.Cnpj);
+        });
+        it("deve lançar erro para CNPJ inválido", () => {
+            expect(() => cnpj_1.Cnpj.parse("00000000000000")).toThrow();
+        });
+        it("deve lançar erro para string vazia", () => {
+            expect(() => cnpj_1.Cnpj.parse("")).toThrow();
+        });
+        it("deve extrair rootDigits com 8 caracteres", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11222333000181");
+            expect(cnpj.rootDigits).toBe("11222333");
+        });
+        it("deve extrair orderDigits com 4 caracteres", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11222333000181");
+            expect(cnpj.orderDigits).toBe("0001");
+        });
+        it("deve extrair firstVerifyDigit com 1 caractere", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11222333000181");
+            expect(cnpj.firstVerifyDigit).toMatch(/^\d$/);
+        });
+        it("deve extrair secondVerifyDigit com 1 caractere", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11222333000181");
+            expect(cnpj.secondVerifyDigit).toMatch(/^\d$/);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // tryParse
+    // -------------------------------------------------------------------------
+    describe("tryParse", () => {
+        it("deve retornar instância de Cnpj para CNPJ válido", () => {
+            const cnpj = cnpj_1.Cnpj.tryParse("11222333000181");
+            expect(cnpj).toBeInstanceOf(cnpj_1.Cnpj);
+        });
+        it("deve retornar null para CNPJ inválido", () => {
+            const cnpj = cnpj_1.Cnpj.tryParse("00000000000000");
+            expect(cnpj).toBeNull();
+        });
+        it("deve retornar null para string vazia", () => {
+            const cnpj = cnpj_1.Cnpj.tryParse("");
+            expect(cnpj).toBeNull();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // validate
+    // -------------------------------------------------------------------------
+    describe("validate", () => {
+        it("deve retornar isValid true para CNPJ válido", () => {
+            const result = cnpj_1.Cnpj.validate("11222333000181");
+            expect(result.isValid).toBe(true);
+        });
+        it("deve retornar isValid false para CNPJ inválido", () => {
+            const result = cnpj_1.Cnpj.validate("00000000000000");
+            expect(result.isValid).toBe(false);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // generate
+    // -------------------------------------------------------------------------
+    describe("generate", () => {
+        it("deve retornar uma instância de Cnpj", () => {
+            const cnpj = cnpj_1.Cnpj.generate();
+            expect(cnpj).toBeInstanceOf(cnpj_1.Cnpj);
+        });
+        it("deve gerar um CNPJ com rootDigits de 8 caracteres", () => {
+            const cnpj = cnpj_1.Cnpj.generate();
+            expect(cnpj.rootDigits).toHaveLength(8);
+        });
+        it("deve gerar um CNPJ com orderDigits de 4 caracteres", () => {
+            const cnpj = cnpj_1.Cnpj.generate();
+            expect(cnpj.orderDigits).toHaveLength(4);
+        });
+        it("deve gerar um CNPJ com firstVerifyDigit de 1 caractere numérico", () => {
+            const cnpj = cnpj_1.Cnpj.generate();
+            expect(cnpj.firstVerifyDigit).toMatch(/^\d$/);
+        });
+        it("deve gerar um CNPJ com secondVerifyDigit de 1 caractere numérico", () => {
+            const cnpj = cnpj_1.Cnpj.generate();
+            expect(cnpj.secondVerifyDigit).toMatch(/^\d$/);
+        });
+        it("deve gerar CNPJ matematicamente válido", () => {
+            const cnpj = cnpj_1.Cnpj.generate();
+            const result = cnpj_1.Cnpj.validate(cnpj.toString());
+            expect(result.isValid).toBe(true);
+        });
+        it("deve gerar CNPJ formatado matematicamente válido ao passar formatted=true", () => {
+            const cnpj = cnpj_1.Cnpj.generate(true);
+            const result = cnpj_1.Cnpj.validate(cnpj.toString());
+            expect(result.isValid).toBe(true);
+        });
+        it("deve gerar CNPJs diferentes entre chamadas", () => {
+            const results = new Set(Array.from({ length: 20 }, () => cnpj_1.Cnpj.generate().toString()));
+            expect(results.size).toBeGreaterThan(1);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // toString / toFormatted
+    // -------------------------------------------------------------------------
+    describe("toString", () => {
+        it("deve retornar 14 dígitos sem máscara", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11.222.333/0001-81");
+            expect(cnpj.toString()).toBe("11222333000181");
+        });
+        it("deve retornar apenas dígitos", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11.222.333/0001-81");
+            expect(cnpj.toString()).toMatch(/^\d{14}$/);
+        });
+    });
+    describe("toFormatted", () => {
+        it("deve retornar o CNPJ no formato NN.NNN.NNN/NNNN-NN", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11222333000181");
+            expect(cnpj.toFormatted()).toBe("11.222.333/0001-81");
+        });
+        it("deve retornar o mesmo resultado independente de o input ter máscara", () => {
+            const semMascara = cnpj_1.Cnpj.parse("11222333000181").toFormatted();
+            const comMascara = cnpj_1.Cnpj.parse("11.222.333/0001-81").toFormatted();
+            expect(semMascara).toBe(comMascara);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Imutabilidade
+    // -------------------------------------------------------------------------
+    describe("imutabilidade", () => {
+        it("rootDigits não deve ser alterável externamente", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11.222.333/0001-81");
+            expect(() => {
+                cnpj.rootDigits = "00000000";
+            }).toThrow();
+        });
+        it("orderDigits não deve ser alterável externamente", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11.222.333/0001-81");
+            expect(() => {
+                cnpj.orderDigits = "0000";
+            }).toThrow();
+        });
+        it("firstVerifyDigit não deve ser alterável externamente", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11.222.333/0001-81");
+            expect(() => {
+                cnpj.firstVerifyDigit = "0";
+            }).toThrow();
+        });
+        it("secondVerifyDigit não deve ser alterável externamente", () => {
+            const cnpj = cnpj_1.Cnpj.parse("11.222.333/0001-81");
+            expect(() => {
+                cnpj.secondVerifyDigit = "0";
+            }).toThrow();
+        });
+    });
+});

package/dist/documents/cnpj/tests/cnpj.validator.test.d.ts

@@ -0,0 +1 @@
+export {};