@artrsousa/cpf-cnpj-validator 1.0.0

package/README.md

@@ -0,0 +1,204 @@
+# cpf-cnpj-validator
+
+Biblioteca leve e tipada para **validação, geração e formatação** de **CPF** e **CNPJ** válidos (Brasil), utilizando o algoritmo oficial de dígitos verificadores da Receita Federal.
+
+## Características
+
+* Validação de CPF numérico
+* Validação de CNPJ numérico
+* Suporte a CNPJ alfanumérico (formato futuro da Receita Federal)
+* Escrita em TypeScript
+* ESM-only (Node.js 18+)
+* Sem dependências externas
+
+---
+
+## Instalação
+
+```bash
+npm install cpf-cnpj-validator
+```
+
+---
+
+## Uso
+
+A biblioteca é ESM-only (`"type": "module"`).
+Utilize `import` em Node.js 18+ ou bundlers modernos (Vite, Webpack, etc).
+
+---
+
+## Uso com JavaScript (ES Modules)
+
+```javascript
+import { cpf, cnpj } from 'cpf-cnpj-validator';
+
+// CPF
+cpf.isValid('313.402.809-30');
+cpf.isValid('31340280930');
+
+cpf.generate(); 
+cpf.generate({ formatted: false });
+
+cpf.format('31340280930');
+
+// CNPJ numérico
+cnpj.isValid('11.222.333/0001-81');
+cnpj.isValid('11222333000181');
+
+cnpj.generate();
+cnpj.generate({ formatted: false });
+
+cnpj.format('11222333000181');
+
+// CNPJ alfanumérico
+cnpj.generate({ type: 'alphanumeric' });
+cnpj.generate({ type: 'alphanumeric', formatted: false });
+```
+
+---
+
+## Uso com TypeScript
+
+A biblioteca inclui definições de tipos (`.d.ts`).
+
+```typescript
+import {
+  cpf,
+  cnpj,
+  type CPF,
+  type CNPJ,
+  type CpfGenerateOptions,
+  type CnpjGenerateOptions
+} from 'cpf-cnpj-validator';
+
+const cpfValue: string = '313.402.809-30';
+
+if (cpf.isValid(cpfValue)) {
+  const formatted: string | null = cpf.format(cpfValue);
+  console.log(formatted);
+}
+
+const options: CnpjGenerateOptions = {
+  type: 'alphanumeric',
+  formatted: true,
+};
+
+const novoCnpj: string = cnpj.generate(options);
+```
+
+---
+
+## Tipos Exportados
+
+| Tipo                  | Descrição                     |
+| --------------------- | ----------------------------- |
+| `CPF`                 | Interface da API de CPF       |
+| `CNPJ`                | Interface da API de CNPJ      |
+| `CpfGenerateOptions`  | Opções para `cpf.generate()`  |
+| `CnpjGenerateOptions` | Opções para `cnpj.generate()` |
+
+---
+
+# API
+
+## CPF
+
+### `cpf.isValid(value: string): boolean`
+
+Valida um CPF.
+
+* Aceita com ou sem formatação
+* Rejeita sequências repetidas (ex: `111.111.111-11`)
+* Valida os dígitos verificadores
+
+---
+
+### `cpf.generate(options?: CpfGenerateOptions): string`
+
+Gera um CPF válido aleatoriamente.
+
+| Opção       | Tipo      | Padrão |
+| ----------- | --------- | ------ |
+| `formatted` | `boolean` | `true` |
+
+Exemplo:
+
+```typescript
+cpf.generate();
+cpf.generate({ formatted: false });
+```
+
+---
+
+### `cpf.format(value: string): string | null`
+
+Formata para o padrão:
+
+```
+000.000.000-00
+```
+
+Retorna `null` caso não possua 11 dígitos válidos.
+
+---
+
+## CNPJ
+
+### `cnpj.isValid(value: string): boolean`
+
+Valida CNPJ numérico.
+
+* Aceita com ou sem formatação
+* Rejeita sequências repetidas
+* Valida os dígitos verificadores
+
+---
+
+### `cnpj.generate(options?: CnpjGenerateOptions): string`
+
+Gera um CNPJ válido.
+
+| Opção       | Tipo                          | Padrão      |
+| ----------- | ----------------------------- | ----------- |
+| `type`      | `'numeric' \| 'alphanumeric'` | `'numeric'` |
+| `formatted` | `boolean`                     | `true`      |
+
+Exemplo:
+
+```typescript
+cnpj.generate();
+
+cnpj.generate({
+  type: 'alphanumeric',
+  formatted: false
+});
+```
+
+---
+
+### `cnpj.format(value: string): string | null`
+
+Formata para o padrão:
+
+```
+00.000.000/0000-00
+```
+
+* Funciona para CNPJ numérico
+* Funciona para CNPJ alfanumérico
+* Retorna `null` se não possuir 14 caracteres
+
+---
+
+## Requisitos
+
+* Node.js 18+
+* Ambiente com suporte a ES Modules
+
+---
+
+## Licença
+
+MIT
+

package/dist/cnpj/alphanumeric.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Converte uma letra em seu valor numérico conforme tabela da Receita Federal (A=17 até Z=42).
+ *
+ * Usado no cálculo dos dígitos verificadores do CNPJ alfanumérico.
+ *
+ * @param letter - Uma letra maiúscula (A–Z)
+ * @returns Valor numérico de 17 (A) a 42 (Z), ou 0 se inválido
+ *
+ * @example
+ * convertLetterToNumber('A')  // 17
+ * convertLetterToNumber('Z')  // 42
+ */
+export declare function convertLetterToNumber(letter: string): number;
+/**
+ * Converte um CNPJ alfanumérico em array de números para cálculo dos dígitos verificadores.
+ *
+ * Letras A–Z são mapeadas para 17–42 conforme tabela da Receita Federal;
+ * dígitos 0–9 permanecem como números.
+ *
+ * @param value - CNPJ alfanumérico (ex.: "AB123CDE000142")
+ * @returns Array de números onde letras foram convertidas (17–42) e dígitos mantidos
+ *
+ * @example
+ * convertCnpjToNumbers("AB12")  // [17, 18, 1, 2]
+ */
+export declare function convertCnpjToNumbers(value: string): number[];
+/**
+ * Gera a base alfanumérica do CNPJ (12 caracteres aleatórios: dígitos 0–9 ou letras A–Z).
+ *
+ * Cada posição tem 50% de chance de ser dígito e 50% de ser letra.
+ *
+ * @returns Array com 12 caracteres (números ou letras) que será usada para calcular os dígitos verificadores
+ */
+export declare function generateBaseAlphanumeric(): (number | string)[];
+/**
+ * Calcula os dois dígitos verificadores do CNPJ alfanumérico.
+ *
+ * O primeiro dígito é calculado sobre a base de 12 caracteres; o segundo,
+ * sobre a base mais o primeiro dígito.
+ *
+ * @param baseCNPJ - Array com os 12 caracteres da base (números ou letras)
+ * @returns Tupla [primeiro_dígito, segundo_dígito]
+ */
+export declare function calculateCheckDigits(baseCNPJ: (number | string)[]): [number, number];
+/**
+ * Gera um CNPJ alfanumérico válido (14 caracteres, sem formatação).
+ *
+ * A base (12 caracteres) combina letras A–Z e dígitos 0–9 aleatoriamente.
+ * Os dois últimos caracteres são os dígitos verificadores calculados pelo algoritmo mod 11.
+ *
+ * @returns String com 14 caracteres (letras e números), sem formatação
+ *
+ * @example
+ * generateAlphanumeric()  // ex: "AB123CDE000142"
+ */
+export declare function generateAlphanumeric(): string;
+/**
+ * Valida um CNPJ alfanumérico verificando se os dígitos verificadores estão corretos.
+ *
+ * Remove formatação (. / -) antes de validar. O valor deve ter exatamente 14 caracteres
+ * (letras e dígitos) e os dois últimos devem corresponder ao cálculo mod 11 da base.
+ *
+ * @param value - CNPJ alfanumérico com ou sem formatação (ex.: "AB.123.CDE/0001-42")
+ * @returns `true` se o CNPJ alfanumérico for válido
+ */
+export declare function validateAlphanumeric(value: string): boolean;
+/**
+ * Formata CNPJ alfanumérico no padrão oficial: XX.XXX.XXX/XXXX-XX.
+ *
+ * Remove formatação (. / -) antes de aplicar a máscara.
+ * Funciona igual ao CNPJ numérico, mas aceita letras nas posições da base.
+ *
+ * @param value - CNPJ alfanumérico com ou sem formatação (ex.: "AB123CDE000142")
+ * @returns String no formato XX.XXX.XXX/XXXX-XX, ou `null` se não houver 14 caracteres
+ *
+ * @example
+ * formatAlphanumeric('AB123CDE000142')  // "AB.123.CDE/0001-42"
+ */
+export declare function formatAlphanumeric(value: string): string | null;
+//# sourceMappingURL=alphanumeric.d.ts.map

package/dist/cnpj/alphanumeric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphanumeric.d.ts","sourceRoot":"","sources":["../../src/cnpj/alphanumeric.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAO5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAI5D;AASD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAU9D;AA0BD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAC5B,CAAC,MAAM,EAAE,MAAM,CAAC,CAIlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAK7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAU3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO/D"}

package/dist/cnpj/alphanumeric.js

@@ -0,0 +1,150 @@
+import { ALPHABET, CNPJ_LENGTH } from '../constants.js';
+/**
+ * Converte uma letra em seu valor numérico conforme tabela da Receita Federal (A=17 até Z=42).
+ *
+ * Usado no cálculo dos dígitos verificadores do CNPJ alfanumérico.
+ *
+ * @param letter - Uma letra maiúscula (A–Z)
+ * @returns Valor numérico de 17 (A) a 42 (Z), ou 0 se inválido
+ *
+ * @example
+ * convertLetterToNumber('A')  // 17
+ * convertLetterToNumber('Z')  // 42
+ */
+export function convertLetterToNumber(letter) {
+    const letterMap = {
+        A: 17, B: 18, C: 19, D: 20, E: 21, F: 22, G: 23, H: 24, I: 25,
+        J: 26, K: 27, L: 28, M: 29, N: 30, O: 31, P: 32, Q: 33, R: 34,
+        S: 35, T: 36, U: 37, V: 38, W: 39, X: 40, Y: 41, Z: 42,
+    };
+    return letterMap[letter] ?? 0;
+}
+/**
+ * Converte um CNPJ alfanumérico em array de números para cálculo dos dígitos verificadores.
+ *
+ * Letras A–Z são mapeadas para 17–42 conforme tabela da Receita Federal;
+ * dígitos 0–9 permanecem como números.
+ *
+ * @param value - CNPJ alfanumérico (ex.: "AB123CDE000142")
+ * @returns Array de números onde letras foram convertidas (17–42) e dígitos mantidos
+ *
+ * @example
+ * convertCnpjToNumbers("AB12")  // [17, 18, 1, 2]
+ */
+export function convertCnpjToNumbers(value) {
+    return Array.from(value).map((char) => isNaN(Number(char)) ? convertLetterToNumber(char) : Number(char));
+}
+/**
+ * Remove formatação (. / -) de um CNPJ alfanumérico.
+ */
+function stripFormatting(value) {
+    return value.replace(/[.\/\-]/g, '');
+}
+/**
+ * Gera a base alfanumérica do CNPJ (12 caracteres aleatórios: dígitos 0–9 ou letras A–Z).
+ *
+ * Cada posição tem 50% de chance de ser dígito e 50% de ser letra.
+ *
+ * @returns Array com 12 caracteres (números ou letras) que será usada para calcular os dígitos verificadores
+ */
+export function generateBaseAlphanumeric() {
+    const base = [];
+    for (let i = 0; i < 12; i++) {
+        if (Math.random() < 0.5) {
+            base.push(Math.floor(Math.random() * 10));
+        }
+        else {
+            base.push(ALPHABET.charAt(Math.floor(Math.random() * ALPHABET.length)));
+        }
+    }
+    return base;
+}
+/**
+ * Calcula um dígito verificador para a base usando pesos 2–9 (da direita para esquerda).
+ *
+ * Algoritmo mod 11 conforme especificação do CNPJ alfanumérico da Receita Federal.
+ *
+ * @param digits - Array com a base (12 caracteres numéricos ou letras convertidas)
+ * @returns Dígito verificador (0–9)
+ */
+function calculateCheckDigit(digits) {
+    let sum = 0;
+    let weight = 2;
+    for (let i = digits.length - 1; i >= 0; i--) {
+        const digit = digits[i];
+        const numericValue = typeof digit === 'string' ? convertLetterToNumber(digit) : digit;
+        sum += numericValue * weight;
+        weight = weight === 9 ? 2 : weight + 1;
+    }
+    const rest = sum % 11;
+    return rest < 2 ? 0 : 11 - rest;
+}
+/**
+ * Calcula os dois dígitos verificadores do CNPJ alfanumérico.
+ *
+ * O primeiro dígito é calculado sobre a base de 12 caracteres; o segundo,
+ * sobre a base mais o primeiro dígito.
+ *
+ * @param baseCNPJ - Array com os 12 caracteres da base (números ou letras)
+ * @returns Tupla [primeiro_dígito, segundo_dígito]
+ */
+export function calculateCheckDigits(baseCNPJ) {
+    const firstDigit = calculateCheckDigit(baseCNPJ);
+    const secondDigit = calculateCheckDigit([...baseCNPJ, firstDigit]);
+    return [firstDigit, secondDigit];
+}
+/**
+ * Gera um CNPJ alfanumérico válido (14 caracteres, sem formatação).
+ *
+ * A base (12 caracteres) combina letras A–Z e dígitos 0–9 aleatoriamente.
+ * Os dois últimos caracteres são os dígitos verificadores calculados pelo algoritmo mod 11.
+ *
+ * @returns String com 14 caracteres (letras e números), sem formatação
+ *
+ * @example
+ * generateAlphanumeric()  // ex: "AB123CDE000142"
+ */
+export function generateAlphanumeric() {
+    const base = generateBaseAlphanumeric();
+    const [d1, d2] = calculateCheckDigits(base);
+    const chars = base.map((c) => String(c));
+    return [...chars, String(d1), String(d2)].join('');
+}
+/**
+ * Valida um CNPJ alfanumérico verificando se os dígitos verificadores estão corretos.
+ *
+ * Remove formatação (. / -) antes de validar. O valor deve ter exatamente 14 caracteres
+ * (letras e dígitos) e os dois últimos devem corresponder ao cálculo mod 11 da base.
+ *
+ * @param value - CNPJ alfanumérico com ou sem formatação (ex.: "AB.123.CDE/0001-42")
+ * @returns `true` se o CNPJ alfanumérico for válido
+ */
+export function validateAlphanumeric(value) {
+    const raw = stripFormatting(value);
+    if (raw.length !== CNPJ_LENGTH)
+        return false;
+    const base = raw.slice(0, 12);
+    const digits = convertCnpjToNumbers(base);
+    const [dv1, dv2] = calculateCheckDigits(digits);
+    const originalDv = parseInt(raw.slice(-2), 10);
+    const calculatedDv = dv1 * 10 + dv2;
+    return originalDv === calculatedDv;
+}
+/**
+ * Formata CNPJ alfanumérico no padrão oficial: XX.XXX.XXX/XXXX-XX.
+ *
+ * Remove formatação (. / -) antes de aplicar a máscara.
+ * Funciona igual ao CNPJ numérico, mas aceita letras nas posições da base.
+ *
+ * @param value - CNPJ alfanumérico com ou sem formatação (ex.: "AB123CDE000142")
+ * @returns String no formato XX.XXX.XXX/XXXX-XX, ou `null` se não houver 14 caracteres
+ *
+ * @example
+ * formatAlphanumeric('AB123CDE000142')  // "AB.123.CDE/0001-42"
+ */
+export function formatAlphanumeric(value) {
+    const raw = stripFormatting(value);
+    if (raw.length !== CNPJ_LENGTH)
+        return null;
+    return raw.replace(/^(.{2})(.{3})(.{3})(.{4})(.{2})$/, '$1.$2.$3/$4-$5');
+}

package/dist/cnpj/index.d.ts

@@ -0,0 +1,39 @@
+/** Opções para geração de CNPJ. */
+export type CnpjGenerateOptions = {
+    /**
+     * Tipo de CNPJ a gerar:
+     * - `'numeric'` (padrão): apenas dígitos 0–9
+     * - `'alphanumeric'`: letras A–Z e dígitos (formato futuro da Receita Federal)
+     */
+    type?: 'numeric' | 'alphanumeric';
+    /** Se `true` (padrão), retorna formatado como 00.000.000/0000-00; se `false`, retorna apenas os 14 caracteres. */
+    formatted?: boolean;
+};
+/**
+ * API para validação, geração e formatação de CNPJ (Cadastro Nacional da Pessoa Jurídica).
+ *
+ * Suporta CNPJ numérico (padrão atual) e alfanumérico (formato futuro da Receita Federal).
+ * Todas as funções aceitam CNPJ com ou sem formatação.
+ */
+export interface CNPJ {
+    /**
+     * Verifica se o CNPJ é válido (14 caracteres, dígitos verificadores corretos, não sequência repetida).
+     * @param value - CNPJ com ou sem máscara (numérico ou alfanumérico)
+     * @returns `true` se válido
+     */
+    isValid(value: string): boolean;
+    /**
+     * Gera um CNPJ válido aleatoriamente (numérico ou alfanumérico).
+     * @param options - `type` ('numeric' | 'alphanumeric'), `formatted` (default: true)
+     * @returns CNPJ válido
+     */
+    generate(options?: CnpjGenerateOptions): string;
+    /**
+     * Formata o CNPJ no padrão 00.000.000/0000-00.
+     * @param value - CNPJ com ou sem formatação
+     * @returns String formatada ou `null` se não houver 14 caracteres
+     */
+    format(value: string): string | null;
+}
+export declare const cnpj: CNPJ;
+//# sourceMappingURL=index.d.ts.map

package/dist/cnpj/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cnpj/index.ts"],"names":[],"mappings":"AAoDA,mCAAmC;AACnC,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,GAAG,cAAc,CAAC;IAClC,kHAAkH;IAClH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AA0DF;;;;;GAKG;AACH,MAAM,WAAW,IAAI;IACnB;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAAC;IAChD;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,eAAO,MAAM,IAAI,EAAE,IAIlB,CAAC"}

package/dist/cnpj/index.js

@@ -0,0 +1,104 @@
+import { generateAlphanumeric, formatAlphanumeric, } from './alphanumeric.js';
+function onlyDigits(str) {
+    return String(str).replace(/\D/g, '');
+}
+function cnpjFirstDigit(digits) {
+    const weights = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    const sum = digits.reduce((acc, d, i) => acc + d * weights[i], 0);
+    const rest = sum % 11;
+    return rest < 2 ? 0 : 11 - rest;
+}
+function cnpjSecondDigit(digits) {
+    const weights = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    const sum = digits.reduce((acc, d, i) => acc + d * weights[i], 0);
+    const rest = sum % 11;
+    return rest < 2 ? 0 : 11 - rest;
+}
+/**
+ * Verifica se um CNPJ numérico é válido conforme algoritmo oficial da Receita Federal.
+ *
+ * Realiza a validação dos dois dígitos verificadores calculados com pesos
+ * mod 11. Rejeita CNPJs inválidos como sequências repetidas (11.111.111/1111-11,
+ * 00.000.000/0000-00, etc.). Aceita o valor com ou sem máscara (pontos, barra e traço).
+ *
+ * Nota: Esta função valida apenas CNPJs numéricos. CNPJs alfanuméricos usam outro algoritmo
+ * e são gerados com `generate({ type: 'alphanumeric' })`.
+ *
+ * @param value - CNPJ numérico em qualquer formato (ex.: "11.222.333/0001-81" ou "11222333000181")
+ * @returns `true` se o CNPJ tiver 14 dígitos, dígitos verificadores corretos e não for sequência repetida
+ *
+ * @example
+ * isValid('11.222.333/0001-81')  // true
+ * isValid('11222333000181')      // true
+ * isValid('11.111.111/1111-11')  // false (sequência inválida)
+ * isValid('12345')               // false (incompleto)
+ */
+function isValid(value) {
+    const digits = onlyDigits(value).split('').map(Number);
+    if (digits.length !== 14)
+        return false;
+    if (new Set(digits).size === 1)
+        return false;
+    const base = digits.slice(0, 12);
+    const d1 = cnpjFirstDigit(base);
+    const d2 = cnpjSecondDigit([...base, d1]);
+    return digits[12] === d1 && digits[13] === d2;
+}
+/**
+ * Gera um CNPJ válido aleatoriamente, com dígitos verificadores calculados corretamente.
+ *
+ * Para `type: 'numeric'`, a base (12 primeiros dígitos) é sorteada; os dois últimos
+ * são calculados pelo algoritmo mod 11. Para `type: 'alphanumeric'`, usa letras A–Z
+ * e dígitos conforme especificação futura da Receita Federal.
+ *
+ * @param options - Opções de geração
+ * @param options.type - `'numeric'` (padrão) ou `'alphanumeric'`
+ * @param options.formatted - Se `true` (padrão), retorna formatado; se `false`, retorna sem formatação
+ * @returns CNPJ válido, com ou sem formatação conforme as opções
+ *
+ * @example
+ * generate()                              // ex: "11.222.333/0001-81"
+ * generate({ formatted: false })          // ex: "11222333000181"
+ * generate({ type: 'alphanumeric' })      // ex: "AB.123.CDE/0001-42"
+ * generate({ type: 'alphanumeric', formatted: false })  // ex: "AB123CDE000142"
+ */
+function generate(options) {
+    const { type = 'numeric', formatted = true } = options ?? {};
+    let raw;
+    if (type === 'alphanumeric') {
+        raw = generateAlphanumeric();
+        return formatted ? (formatAlphanumeric(raw) ?? raw) : raw;
+    }
+    const base = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
+    const d1 = cnpjFirstDigit(base);
+    const d2 = cnpjSecondDigit([...base, d1]);
+    raw = [...base, d1, d2].join('');
+    return formatted ? (format(raw) ?? raw) : raw;
+}
+/**
+ * Formata o CNPJ no padrão oficial brasileiro: 00.000.000/0000-00.
+ *
+ * Remove caracteres de formatação (. / -) antes de formatar.
+ * Funciona tanto para CNPJ numérico quanto alfanumérico.
+ * Se o valor não tiver exatamente 14 caracteres, retorna `null`.
+ *
+ * @param value - CNPJ com ou sem formatação (pontos, barra, traço são ignorados)
+ * @returns String no formato 00.000.000/0000-00, ou `null` se não houver 14 caracteres
+ *
+ * @example
+ * format('11222333000181')  // "11.222.333/0001-81"
+ * format('11.222.333/0001-81') // "11.222.333/0001-81"
+ * format('AB123CDE000142')  // "AB.123.CDE/0001-42"
+ * format('123')             // null
+ */
+function format(value) {
+    const digits = onlyDigits(value);
+    if (digits.length !== 14)
+        return null;
+    return digits.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, '$1.$2.$3/$4-$5');
+}
+export const cnpj = {
+    isValid,
+    generate,
+    format,
+};

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+/** Alfabeto utilizado para geração de CNPJ alfanumérico (letras A–Z conforme Receita Federal). */
+export declare const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/** Quantidade de caracteres de um CNPJ (numérico ou alfanumérico), incluindo dígitos verificadores. */
+export declare const CNPJ_LENGTH = 14;
+/** Quantidade de dígitos de um CPF (9 base + 2 verificadores). */
+export declare const CPF_LENGTH = 11;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,eAAO,MAAM,QAAQ,+BAA+B,CAAC;AAErD,uGAAuG;AACvG,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,kEAAkE;AAClE,eAAO,MAAM,UAAU,KAAK,CAAC"}

package/dist/constants.js

@@ -0,0 +1,6 @@
+/** Alfabeto utilizado para geração de CNPJ alfanumérico (letras A–Z conforme Receita Federal). */
+export const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+/** Quantidade de caracteres de um CNPJ (numérico ou alfanumérico), incluindo dígitos verificadores. */
+export const CNPJ_LENGTH = 14;
+/** Quantidade de dígitos de um CPF (9 base + 2 verificadores). */
+export const CPF_LENGTH = 11;

package/dist/cpf/index.d.ts

@@ -0,0 +1,33 @@
+/** Opções para geração de CPF. */
+export type CpfGenerateOptions = {
+    /** Se `true` (padrão), retorna formatado como 000.000.000-00; se `false`, retorna apenas os 11 dígitos. */
+    formatted?: boolean;
+};
+/**
+ * API para validação, geração e formatação de CPF (Cadastro de Pessoa Física).
+ *
+ * Todas as funções aceitam CPF com ou sem formatação. O algoritmo de validação
+ * segue a especificação oficial da Receita Federal (dígitos verificadores mod 11).
+ */
+export interface CPF {
+    /**
+     * Verifica se o CPF é válido (11 dígitos, dígitos verificadores corretos, não sequência repetida).
+     * @param value - CPF com ou sem máscara
+     * @returns `true` se válido
+     */
+    isValid(value: string): boolean;
+    /**
+     * Gera um CPF válido aleatoriamente.
+     * @param options - `formatted` (default: true) — retorna formatado ou apenas dígitos
+     * @returns CPF válido
+     */
+    generate(options?: CpfGenerateOptions): string;
+    /**
+     * Formata o CPF no padrão 000.000.000-00.
+     * @param value - CPF com ou sem formatação
+     * @returns String formatada ou `null` se não houver 11 dígitos
+     */
+    format(value: string): string | null;
+}
+export declare const cpf: CPF;
+//# sourceMappingURL=index.d.ts.map

package/dist/cpf/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cpf/index.ts"],"names":[],"mappings":"AA4CA,kCAAkC;AAClC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,2GAA2G;IAC3G,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AA6CF;;;;;GAKG;AACH,MAAM,WAAW,GAAG;IAClB;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAAC;IAC/C;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,eAAO,MAAM,GAAG,EAAE,GAIjB,CAAC"}

package/dist/cpf/index.js

@@ -0,0 +1,89 @@
+function onlyDigits(str) {
+    return String(str).replace(/\D/g, '');
+}
+function cpfFirstDigit(digits) {
+    const weights = [10, 9, 8, 7, 6, 5, 4, 3, 2];
+    const sum = digits.reduce((acc, d, i) => acc + d * weights[i], 0);
+    const rest = sum % 11;
+    return rest < 2 ? 0 : 11 - rest;
+}
+function cpfSecondDigit(digits) {
+    const weights = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2];
+    const sum = digits.reduce((acc, d, i) => acc + d * weights[i], 0);
+    const rest = sum % 11;
+    return rest < 2 ? 0 : 11 - rest;
+}
+/**
+ * Verifica se um CPF é válido conforme algoritmo oficial da Receita Federal.
+ *
+ * Realiza a validação dos dois dígitos verificadores calculados com pesos
+ * mod 11. Rejeita CPFs inválidos como sequências repetidas (111.111.111-11,
+ * 000.000.000-00, etc.). Aceita o valor com ou sem máscara (pontos e traço).
+ *
+ * @param value - CPF em qualquer formato (ex.: "313.402.809-30" ou "31340280930")
+ * @returns `true` se o CPF tiver 11 dígitos, dígitos verificadores corretos e não for sequência repetida
+ *
+ * @example
+ * isValid('313.402.809-30')  // true
+ * isValid('31340280930')     // true
+ * isValid('111.111.111-11')  // false (sequência inválida)
+ * isValid('123')             // false (incompleto)
+ */
+function isValid(value) {
+    const digits = onlyDigits(value).split('').map(Number);
+    if (digits.length !== 11)
+        return false;
+    if (new Set(digits).size === 1)
+        return false;
+    const base = digits.slice(0, 9);
+    const d1 = cpfFirstDigit(base);
+    const d2 = cpfSecondDigit([...base, d1]);
+    return digits[9] === d1 && digits[10] === d2;
+}
+/**
+ * Gera um CPF válido aleatoriamente, com dígitos verificadores calculados corretamente.
+ *
+ * A base (9 primeiros dígitos) é sorteada; os dois últimos são calculados pelo
+ * algoritmo mod 11. O resultado nunca será sequência repetida.
+ *
+ * @param options - Opções de geração
+ * @param options.formatted - Se `true` (padrão), retorna no padrão 000.000.000-00; se `false`, retorna apenas os 11 dígitos
+ * @returns CPF válido, com ou sem formatação conforme as opções
+ *
+ * @example
+ * generate()                    // ex: "313.402.809-30"
+ * generate({ formatted: false }) // ex: "31340280930"
+ */
+function generate(options) {
+    const { formatted = true } = options ?? {};
+    const base = Array.from({ length: 9 }, () => Math.floor(Math.random() * 10));
+    const d1 = cpfFirstDigit(base);
+    const d2 = cpfSecondDigit([...base, d1]);
+    const raw = [...base, d1, d2].join('');
+    return formatted ? (format(raw) ?? raw) : raw;
+}
+/**
+ * Formata o CPF no padrão oficial brasileiro: 000.000.000-00.
+ *
+ * Remove qualquer caractere que não seja dígito antes de formatar.
+ * Se o valor não tiver exatamente 11 dígitos, retorna `null`.
+ *
+ * @param value - CPF com ou sem formatação (pontos, traço, espaços são ignorados)
+ * @returns String no formato 000.000.000-00, ou `null` se não houver 11 dígitos
+ *
+ * @example
+ * format('31340280930')  // "313.402.809-30"
+ * format('313.402.809-30') // "313.402.809-30"
+ * format('123')          // null
+ */
+function format(value) {
+    const digits = onlyDigits(value);
+    if (digits.length !== 11)
+        return null;
+    return digits.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
+}
+export const cpf = {
+    isValid,
+    generate,
+    format,
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Biblioteca para validação, geração e formatação de CPF e CNPJ (Brasil).
+ *
+ * @packageDocumentation
+ */
+export { cpf, type CPF, type CpfGenerateOptions } from './cpf/index.js';
+export { cnpj, type CNPJ, type CnpjGenerateOptions } from './cnpj/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,IAAI,EAAE,KAAK,IAAI,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+/**
+ * Biblioteca para validação, geração e formatação de CPF e CNPJ (Brasil).
+ *
+ * @packageDocumentation
+ */
+export { cpf } from './cpf/index.js';
+export { cnpj } from './cnpj/index.js';

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@artrsousa/cpf-cnpj-validator",
+  "version": "1.0.0",
+  "description": "Valida e gera CPF e CNPJ válidos (Brasil)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run build && node --test test/cpf.test.js test/cnpj.test.js"
+  },
+  "keywords": [
+    "cpf",
+    "cnpj",
+    "brasil",
+    "validator",
+    "generator",
+    "cadastro",
+    "pessoa física",
+    "pessoa jurídica"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.7.2"
+  }
+}