@azify/cpf-cnpj 0.1.0

package/README.md

@@ -0,0 +1,43 @@
+# @azify/cpf-cnpj
+
+Validation, formatting, and comparison of CPF/CNPJ, including support for alphanumeric CNPJ (effective Jul/2026).
+
+## Installation
+
+```
+npm install @azify/cpf-cnpj
+```
+
+## Usage
+
+```ts
+import { cpf, cnpj, taxpayer } from '@azify/cpf-cnpj'
+
+cpf.isValid('529.982.247-25') // true
+cpf.isValid('111.111.111-11') // false (invalid check digit)
+cpf.format('52998224725')     // '529.982.247-25'
+cpf.format('123')             // null (doesn't have 11 digits)
+cpf.compare(a, b)             // true | false | null (null if a or b is invalid)
+cpf.clean('529.982.247-25')   // '52998224725'
+
+cnpj.isValid('11.444.777/0001-61') // true
+cnpj.isValid('AB123CD4501E66')     // true (alphanumeric CNPJ)
+cnpj.isValid('11.111.111/1111-11') // false (invalid check digit)
+cnpj.format('11444777000161')      // '11.444.777/0001-61'
+cnpj.format('AB123CD4501E66')      // 'AB.123.CD4/501E-66'
+cnpj.format('123')                 // null (doesn't have 14 positions)
+cnpj.compare(a, b)                 // true | false | null (null if a or b is invalid)
+cnpj.clean('11.444.777/0001-61')   // '11444777000161'
+
+taxpayer.type('52998224725')   // 'cpf' | 'cnpj' | null (null if it's not a valid CPF or CNPJ)
+taxpayer.isValid('invalid')    // false
+taxpayer.format('invalid')     // null
+taxpayer.compare(a, b)         // true | false | null (null if a or b is invalid)
+taxpayer.clean(value)          // normalizes CPF or CNPJ (alphanumeric)
+```
+
+### About `null` returns
+
+- `format` returns `null` when the value doesn't have the expected length (CPF: 11 digits; CNPJ: 14 positions). It **does not** check the verification digit — a well-formed CPF/CNPJ with an invalid checksum is still formatted (e.g., `cpf.format('00000000000')` returns `'000.000.000-00'`). Use `isValid` when you need to guarantee the document is actually valid.
+- `compare` returns `null` (not `false`) when **either** of the two values is invalid — this lets you distinguish "different documents" from "cannot compare".
+- `taxpayer.type` returns `null` when the value is neither a valid CPF nor a valid CNPJ (it doesn't distinguish "not a CPF" from "not a CNPJ").

package/dist/index.d.mts

@@ -0,0 +1,100 @@
+/**
+ * CPF/CNPJ utilities.
+ *
+ * Exposes the `cpf` / `cnpj` objects (with `isValid`, `format`, `compare`, `clean`),
+ * plus a `taxpayer` object for documents of unknown type (`type`, `isValid`, `format`, `compare`,
+ * `clean`). CNPJ validation and formatting also support the alphanumeric CNPJ
+ * (effective Jul/2026). CPF stays numeric.
+ */
+declare function keepDigits(value: string): string;
+declare function keepAlphanumeric(value: string): string;
+/**
+ * @description Validates a CPF (always numeric), including the check digits.
+ * @param value - CPF with or without mask
+ * @returns true if the CPF is valid
+ */
+declare function isValidCpf(value: string): boolean;
+/**
+ * @description Masks a CPF as `XXX.XXX.XXX-XX`.
+ * @param value - CPF with or without mask
+ * @returns Masked CPF, or null if it is not a well-formed (11-digit) CPF
+ */
+declare function formatCpf(value: string): string | null;
+/**
+ * @description Compares two CPFs, returning null if either is invalid.
+ * @param cpf1 - First CPF to compare
+ * @param cpf2 - Second CPF to compare
+ * @returns true if equal, false if different, null if either CPF is invalid
+ */
+declare function compareCpf(cpf1: string, cpf2: string): boolean | null;
+/**
+ * @description Validates a numeric or alphanumeric CNPJ, including the check
+ * digits (mod-11 calc with character value = ASCII - 48).
+ * @param value - CNPJ with or without mask
+ * @returns true if the CNPJ is valid
+ */
+declare function isValidCnpj(value: string): boolean;
+/**
+ * @description Masks a numeric or alphanumeric CNPJ as `XX.XXX.XXX/XXXX-XX`.
+ * @param value - CNPJ with or without mask
+ * @returns Masked CNPJ, or null if it is not a well-formed (14-position) CNPJ
+ */
+declare function formatCnpj(value: string): string | null;
+/**
+ * @description Compares two CNPJs, returning null if either is invalid.
+ * @param cnpj1 - First CNPJ to compare
+ * @param cnpj2 - Second CNPJ to compare
+ * @returns true if equal, false if different, null if either CNPJ is invalid
+ */
+declare function compareCnpj(cnpj1: string, cnpj2: string): boolean | null;
+/**
+ * @description Compare two CPF or CNPJ
+ * @param taxpayer1 - CPF or CNPJ to compare
+ * @param taxpayer2 - CPF or CNPJ to compare
+ * @returns true if CPF or CNPJ are equal, false if not, null if either is invalid
+ */
+declare function compareTaxpayer(taxpayer1: string, taxpayer2: string): boolean | null;
+/**
+ * @description Determines the type of a taxpayer document, validating it.
+ *
+ * Returns the type in lowercase by convention within this module (and the
+ * blacklist subsystem that consumes it). This is intentionally distinct from
+ * the uppercase Pix key-type enum (`'CPF' | 'CNPJ' | 'EVP' | ...`), which is a
+ * different concept — do not compare the two directly.
+ * @param cpfCnpj - CPF or CNPJ to inspect
+ * @returns 'cpf' if a valid CPF, 'cnpj' if a valid CNPJ, null if neither
+ */
+declare function getTaxpayerType(cpfCnpj: string): 'cpf' | 'cnpj' | null;
+/**
+ * @description Validates a taxpayer document (CPF or CNPJ).
+ * @param cpfCnpj - CPF or CNPJ to validate
+ * @returns true if it is a valid CPF or CNPJ
+ */
+declare function isValidTaxpayer(cpfCnpj: string): boolean;
+/**
+ * @description Format CPF or CNPJ
+ * @param cpfCnpj - CPF or CNPJ to format
+ * @returns Formatted CPF or CNPJ or null if CPF or CNPJ is invalid
+ */
+declare function formatTaxpayer(cpfCnpj: string): string | null;
+declare const cpf: {
+    isValid: typeof isValidCpf;
+    format: typeof formatCpf;
+    compare: typeof compareCpf;
+    clean: typeof keepDigits;
+};
+declare const cnpj: {
+    isValid: typeof isValidCnpj;
+    format: typeof formatCnpj;
+    compare: typeof compareCnpj;
+    clean: typeof keepAlphanumeric;
+};
+declare const taxpayer: {
+    type: typeof getTaxpayerType;
+    isValid: typeof isValidTaxpayer;
+    format: typeof formatTaxpayer;
+    compare: typeof compareTaxpayer;
+    clean: typeof keepAlphanumeric;
+};
+
+export { cnpj, cpf, taxpayer };

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * CPF/CNPJ utilities.
+ *
+ * Exposes the `cpf` / `cnpj` objects (with `isValid`, `format`, `compare`, `clean`),
+ * plus a `taxpayer` object for documents of unknown type (`type`, `isValid`, `format`, `compare`,
+ * `clean`). CNPJ validation and formatting also support the alphanumeric CNPJ
+ * (effective Jul/2026). CPF stays numeric.
+ */
+declare function keepDigits(value: string): string;
+declare function keepAlphanumeric(value: string): string;
+/**
+ * @description Validates a CPF (always numeric), including the check digits.
+ * @param value - CPF with or without mask
+ * @returns true if the CPF is valid
+ */
+declare function isValidCpf(value: string): boolean;
+/**
+ * @description Masks a CPF as `XXX.XXX.XXX-XX`.
+ * @param value - CPF with or without mask
+ * @returns Masked CPF, or null if it is not a well-formed (11-digit) CPF
+ */
+declare function formatCpf(value: string): string | null;
+/**
+ * @description Compares two CPFs, returning null if either is invalid.
+ * @param cpf1 - First CPF to compare
+ * @param cpf2 - Second CPF to compare
+ * @returns true if equal, false if different, null if either CPF is invalid
+ */
+declare function compareCpf(cpf1: string, cpf2: string): boolean | null;
+/**
+ * @description Validates a numeric or alphanumeric CNPJ, including the check
+ * digits (mod-11 calc with character value = ASCII - 48).
+ * @param value - CNPJ with or without mask
+ * @returns true if the CNPJ is valid
+ */
+declare function isValidCnpj(value: string): boolean;
+/**
+ * @description Masks a numeric or alphanumeric CNPJ as `XX.XXX.XXX/XXXX-XX`.
+ * @param value - CNPJ with or without mask
+ * @returns Masked CNPJ, or null if it is not a well-formed (14-position) CNPJ
+ */
+declare function formatCnpj(value: string): string | null;
+/**
+ * @description Compares two CNPJs, returning null if either is invalid.
+ * @param cnpj1 - First CNPJ to compare
+ * @param cnpj2 - Second CNPJ to compare
+ * @returns true if equal, false if different, null if either CNPJ is invalid
+ */
+declare function compareCnpj(cnpj1: string, cnpj2: string): boolean | null;
+/**
+ * @description Compare two CPF or CNPJ
+ * @param taxpayer1 - CPF or CNPJ to compare
+ * @param taxpayer2 - CPF or CNPJ to compare
+ * @returns true if CPF or CNPJ are equal, false if not, null if either is invalid
+ */
+declare function compareTaxpayer(taxpayer1: string, taxpayer2: string): boolean | null;
+/**
+ * @description Determines the type of a taxpayer document, validating it.
+ *
+ * Returns the type in lowercase by convention within this module (and the
+ * blacklist subsystem that consumes it). This is intentionally distinct from
+ * the uppercase Pix key-type enum (`'CPF' | 'CNPJ' | 'EVP' | ...`), which is a
+ * different concept — do not compare the two directly.
+ * @param cpfCnpj - CPF or CNPJ to inspect
+ * @returns 'cpf' if a valid CPF, 'cnpj' if a valid CNPJ, null if neither
+ */
+declare function getTaxpayerType(cpfCnpj: string): 'cpf' | 'cnpj' | null;
+/**
+ * @description Validates a taxpayer document (CPF or CNPJ).
+ * @param cpfCnpj - CPF or CNPJ to validate
+ * @returns true if it is a valid CPF or CNPJ
+ */
+declare function isValidTaxpayer(cpfCnpj: string): boolean;
+/**
+ * @description Format CPF or CNPJ
+ * @param cpfCnpj - CPF or CNPJ to format
+ * @returns Formatted CPF or CNPJ or null if CPF or CNPJ is invalid
+ */
+declare function formatTaxpayer(cpfCnpj: string): string | null;
+declare const cpf: {
+    isValid: typeof isValidCpf;
+    format: typeof formatCpf;
+    compare: typeof compareCpf;
+    clean: typeof keepDigits;
+};
+declare const cnpj: {
+    isValid: typeof isValidCnpj;
+    format: typeof formatCnpj;
+    compare: typeof compareCnpj;
+    clean: typeof keepAlphanumeric;
+};
+declare const taxpayer: {
+    type: typeof getTaxpayerType;
+    isValid: typeof isValidTaxpayer;
+    format: typeof formatTaxpayer;
+    compare: typeof compareTaxpayer;
+    clean: typeof keepAlphanumeric;
+};
+
+export { cnpj, cpf, taxpayer };

package/dist/index.js

@@ -0,0 +1,167 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  cnpj: () => cnpj,
+  cpf: () => cpf,
+  taxpayer: () => taxpayer
+});
+module.exports = __toCommonJS(index_exports);
+function keepDigits(value) {
+  return String(value).replace(/\D/g, "");
+}
+function keepAlphanumeric(value) {
+  return String(value).toUpperCase().replace(/[^0-9A-Z]/g, "");
+}
+var CPF_LENGTH = 11;
+var CPF_CHECK_DIGITS = 2;
+function cpfCheckDigit(base) {
+  const length = base.length;
+  const sum = base.split("").reduce((acc, digit, i) => acc + Number(digit) * (length + 1 - i), 0);
+  const remainder = sum % 11;
+  return remainder < 2 ? 0 : 11 - remainder;
+}
+function isValidCpf(value) {
+  if (/[A-Za-z]/.test(String(value))) {
+    return false;
+  }
+  const clean = keepDigits(value);
+  if (clean.length !== CPF_LENGTH) {
+    return false;
+  }
+  if (/^(\d)\1{10}$/.test(clean)) {
+    return false;
+  }
+  const baseLength = CPF_LENGTH - CPF_CHECK_DIGITS;
+  const base = clean.slice(0, baseLength);
+  const dv1 = cpfCheckDigit(base);
+  const dv2 = cpfCheckDigit(base + String(dv1));
+  return clean.slice(baseLength) === `${dv1}${dv2}`;
+}
+function formatCpf(value) {
+  const clean = keepDigits(value);
+  if (clean.length !== CPF_LENGTH) {
+    return null;
+  }
+  return clean.replace(/^(\d{3})(\d{3})(\d{3})(\d{2})$/, "$1.$2.$3-$4");
+}
+function compareCpf(cpf1, cpf2) {
+  if (!isValidCpf(cpf1) || !isValidCpf(cpf2)) {
+    return null;
+  }
+  return keepDigits(cpf1) === keepDigits(cpf2);
+}
+var CNPJ_LENGTH = 14;
+var CNPJ_CHECK_DIGITS = 2;
+var CNPJ_FIRST_DV_WEIGHTS = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+var CNPJ_SECOND_DV_WEIGHTS = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+function cnpjCharValue(char) {
+  return char.charCodeAt(0) - 48;
+}
+function cnpjCheckDigit(base, weights) {
+  const sum = base.split("").reduce((acc, char, i) => acc + cnpjCharValue(char) * weights[i], 0);
+  const remainder = sum % 11;
+  return remainder < 2 ? 0 : 11 - remainder;
+}
+function isValidCnpj(value) {
+  const clean = keepAlphanumeric(value);
+  if (clean.length !== CNPJ_LENGTH || !/^[0-9A-Z]{12}[0-9]{2}$/.test(clean)) {
+    return false;
+  }
+  if (/^(.)\1{13}$/.test(clean)) {
+    return false;
+  }
+  const baseLength = CNPJ_LENGTH - CNPJ_CHECK_DIGITS;
+  const base = clean.slice(0, baseLength);
+  const dv1 = cnpjCheckDigit(base, CNPJ_FIRST_DV_WEIGHTS);
+  const dv2 = cnpjCheckDigit(base + String(dv1), CNPJ_SECOND_DV_WEIGHTS);
+  return clean.slice(baseLength) === `${dv1}${dv2}`;
+}
+function formatCnpj(value) {
+  const clean = keepAlphanumeric(value);
+  if (!/^[0-9A-Z]{12}[0-9]{2}$/.test(clean)) {
+    return null;
+  }
+  return clean.replace(
+    /^([0-9A-Z]{2})([0-9A-Z]{3})([0-9A-Z]{3})([0-9A-Z]{4})(\d{2})$/,
+    "$1.$2.$3/$4-$5"
+  );
+}
+function compareCnpj(cnpj1, cnpj2) {
+  if (!isValidCnpj(cnpj1) || !isValidCnpj(cnpj2)) {
+    return null;
+  }
+  return keepAlphanumeric(cnpj1) === keepAlphanumeric(cnpj2);
+}
+function compareTaxpayer(taxpayer1, taxpayer2) {
+  if (!getTaxpayerType(taxpayer1) || !getTaxpayerType(taxpayer2)) {
+    return null;
+  }
+  return keepAlphanumeric(taxpayer1) === keepAlphanumeric(taxpayer2);
+}
+function getTaxpayerType(cpfCnpj) {
+  if (isValidCpf(cpfCnpj)) {
+    return "cpf";
+  }
+  if (isValidCnpj(cpfCnpj)) {
+    return "cnpj";
+  }
+  return null;
+}
+function isValidTaxpayer(cpfCnpj) {
+  return Boolean(getTaxpayerType(cpfCnpj));
+}
+function formatTaxpayer(cpfCnpj) {
+  const type = getTaxpayerType(cpfCnpj);
+  if (type === "cpf") {
+    return formatCpf(cpfCnpj);
+  } else if (type === "cnpj") {
+    return formatCnpj(cpfCnpj);
+  }
+  return null;
+}
+var cpf = {
+  isValid: isValidCpf,
+  format: formatCpf,
+  compare: compareCpf,
+  clean: keepDigits
+};
+var cnpj = {
+  isValid: isValidCnpj,
+  format: formatCnpj,
+  compare: compareCnpj,
+  clean: keepAlphanumeric
+};
+var taxpayer = {
+  type: getTaxpayerType,
+  isValid: isValidTaxpayer,
+  format: formatTaxpayer,
+  compare: compareTaxpayer,
+  // unknown type → alphanumeric is the safe normalization: works for both a
+  // numeric CPF and an alphanumeric CNPJ, and their lengths never collide
+  clean: keepAlphanumeric
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cnpj,
+  cpf,
+  taxpayer
+});

package/dist/index.mjs

@@ -0,0 +1,140 @@
+// src/index.ts
+function keepDigits(value) {
+  return String(value).replace(/\D/g, "");
+}
+function keepAlphanumeric(value) {
+  return String(value).toUpperCase().replace(/[^0-9A-Z]/g, "");
+}
+var CPF_LENGTH = 11;
+var CPF_CHECK_DIGITS = 2;
+function cpfCheckDigit(base) {
+  const length = base.length;
+  const sum = base.split("").reduce((acc, digit, i) => acc + Number(digit) * (length + 1 - i), 0);
+  const remainder = sum % 11;
+  return remainder < 2 ? 0 : 11 - remainder;
+}
+function isValidCpf(value) {
+  if (/[A-Za-z]/.test(String(value))) {
+    return false;
+  }
+  const clean = keepDigits(value);
+  if (clean.length !== CPF_LENGTH) {
+    return false;
+  }
+  if (/^(\d)\1{10}$/.test(clean)) {
+    return false;
+  }
+  const baseLength = CPF_LENGTH - CPF_CHECK_DIGITS;
+  const base = clean.slice(0, baseLength);
+  const dv1 = cpfCheckDigit(base);
+  const dv2 = cpfCheckDigit(base + String(dv1));
+  return clean.slice(baseLength) === `${dv1}${dv2}`;
+}
+function formatCpf(value) {
+  const clean = keepDigits(value);
+  if (clean.length !== CPF_LENGTH) {
+    return null;
+  }
+  return clean.replace(/^(\d{3})(\d{3})(\d{3})(\d{2})$/, "$1.$2.$3-$4");
+}
+function compareCpf(cpf1, cpf2) {
+  if (!isValidCpf(cpf1) || !isValidCpf(cpf2)) {
+    return null;
+  }
+  return keepDigits(cpf1) === keepDigits(cpf2);
+}
+var CNPJ_LENGTH = 14;
+var CNPJ_CHECK_DIGITS = 2;
+var CNPJ_FIRST_DV_WEIGHTS = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+var CNPJ_SECOND_DV_WEIGHTS = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+function cnpjCharValue(char) {
+  return char.charCodeAt(0) - 48;
+}
+function cnpjCheckDigit(base, weights) {
+  const sum = base.split("").reduce((acc, char, i) => acc + cnpjCharValue(char) * weights[i], 0);
+  const remainder = sum % 11;
+  return remainder < 2 ? 0 : 11 - remainder;
+}
+function isValidCnpj(value) {
+  const clean = keepAlphanumeric(value);
+  if (clean.length !== CNPJ_LENGTH || !/^[0-9A-Z]{12}[0-9]{2}$/.test(clean)) {
+    return false;
+  }
+  if (/^(.)\1{13}$/.test(clean)) {
+    return false;
+  }
+  const baseLength = CNPJ_LENGTH - CNPJ_CHECK_DIGITS;
+  const base = clean.slice(0, baseLength);
+  const dv1 = cnpjCheckDigit(base, CNPJ_FIRST_DV_WEIGHTS);
+  const dv2 = cnpjCheckDigit(base + String(dv1), CNPJ_SECOND_DV_WEIGHTS);
+  return clean.slice(baseLength) === `${dv1}${dv2}`;
+}
+function formatCnpj(value) {
+  const clean = keepAlphanumeric(value);
+  if (!/^[0-9A-Z]{12}[0-9]{2}$/.test(clean)) {
+    return null;
+  }
+  return clean.replace(
+    /^([0-9A-Z]{2})([0-9A-Z]{3})([0-9A-Z]{3})([0-9A-Z]{4})(\d{2})$/,
+    "$1.$2.$3/$4-$5"
+  );
+}
+function compareCnpj(cnpj1, cnpj2) {
+  if (!isValidCnpj(cnpj1) || !isValidCnpj(cnpj2)) {
+    return null;
+  }
+  return keepAlphanumeric(cnpj1) === keepAlphanumeric(cnpj2);
+}
+function compareTaxpayer(taxpayer1, taxpayer2) {
+  if (!getTaxpayerType(taxpayer1) || !getTaxpayerType(taxpayer2)) {
+    return null;
+  }
+  return keepAlphanumeric(taxpayer1) === keepAlphanumeric(taxpayer2);
+}
+function getTaxpayerType(cpfCnpj) {
+  if (isValidCpf(cpfCnpj)) {
+    return "cpf";
+  }
+  if (isValidCnpj(cpfCnpj)) {
+    return "cnpj";
+  }
+  return null;
+}
+function isValidTaxpayer(cpfCnpj) {
+  return Boolean(getTaxpayerType(cpfCnpj));
+}
+function formatTaxpayer(cpfCnpj) {
+  const type = getTaxpayerType(cpfCnpj);
+  if (type === "cpf") {
+    return formatCpf(cpfCnpj);
+  } else if (type === "cnpj") {
+    return formatCnpj(cpfCnpj);
+  }
+  return null;
+}
+var cpf = {
+  isValid: isValidCpf,
+  format: formatCpf,
+  compare: compareCpf,
+  clean: keepDigits
+};
+var cnpj = {
+  isValid: isValidCnpj,
+  format: formatCnpj,
+  compare: compareCnpj,
+  clean: keepAlphanumeric
+};
+var taxpayer = {
+  type: getTaxpayerType,
+  isValid: isValidTaxpayer,
+  format: formatTaxpayer,
+  compare: compareTaxpayer,
+  // unknown type → alphanumeric is the safe normalization: works for both a
+  // numeric CPF and an alphanumeric CNPJ, and their lengths never collide
+  clean: keepAlphanumeric
+};
+export {
+  cnpj,
+  cpf,
+  taxpayer
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@azify/cpf-cnpj",
+  "version": "0.1.0",
+  "description": "CPF/CNPJ validation, formatting and comparison helpers (including alphanumeric CNPJ).",
+  "license": "UNLICENSED",
+  "author": "Azify",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/azifydev/azify-cpf-cnpj.git"
+  },
+  "bugs": {
+    "url": "https://github.com/azifydev/azify-cpf-cnpj/issues"
+  },
+  "homepage": "https://github.com/azifydev/azify-cpf-cnpj#readme",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}