Validador de CNPJ (numérico e alfanumérico)

const PESOS = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
const CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';

// Valor do caractere = código ASCII - 48 (0-9 = 0-9, A = 17 ... Z = 42)
function dv(base: string): number {
  const pesos = PESOS.slice(13 - base.length);
  const soma = [...base].reduce((s, c, i) => s + (c.charCodeAt(0) - 48) * pesos[i], 0);
  const r = soma % 11;
  return r < 2 ? 0 : 11 - r;
}

export function validarCnpj(valor: string): boolean {
  const c = valor.replace(/[.\/-]/g, '').toUpperCase();
  if (!/^[A-Z0-9]{12}\d{2}$/.test(c) || /^(.)\1+$/.test(c)) return false;
  const d1 = dv(c.slice(0, 12));
  return c.slice(12) === `${d1}${dv(c.slice(0, 12) + d1)}`;
}

export function gerarCnpj(alfanumerico = false): string {
  const pool = alfanumerico ? CHARS : CHARS.slice(0, 10);
  const limite = 256 - (256 % pool.length); // evita viés de módulo
  let raiz = '';
  while (raiz.length < 8) {
    const [b] = crypto.getRandomValues(new Uint8Array(1));
    if (b < limite) raiz += pool[b % pool.length];
  }
  const base = raiz + '0001';
  const d1 = dv(base);
  return `${base}${d1}${dv(base + d1)}`;
}

export const mascarar = (c: string) =>
  c.replace(/^(.{2})(.{3})(.{3})(.{4})(.{2})$/, '$1.$2.$3/$4-$5');

import re
import secrets

PESOS = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"


def dv(base: str) -> int:
    # Valor do caractere = ord(c) - 48 (A = 17 ... Z = 42)
    pesos = PESOS[13 - len(base):]
    r = sum((ord(c) - 48) * p for c, p in zip(base, pesos)) % 11
    return 0 if r < 2 else 11 - r


def validar_cnpj(valor: str) -> bool:
    c = re.sub(r"[./-]", "", valor).upper()
    if not re.fullmatch(r"[A-Z0-9]{12}[0-9]{2}", c) or len(set(c)) == 1:
        return False
    d1 = dv(c[:12])
    return c[12:] == f"{d1}{dv(c[:12] + str(d1))}"


def gerar_cnpj(alfanumerico: bool = False) -> str:
    pool = CHARS if alfanumerico else CHARS[:10]
    base = "".join(secrets.choice(pool) for _ in range(8)) + "0001"
    d1 = dv(base)
    return f"{base}{d1}{dv(base + str(d1))}"


def mascarar(c: str) -> str:
    return f"{c[:2]}.{c[2:5]}.{c[5:8]}/{c[8:12]}-{c[12:]}"

import java.security.SecureRandom;
import java.util.Locale;
import java.util.regex.Pattern;

public final class Cnpj {
    private static final int[] PESOS = {6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
    private static final String CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final Pattern FORMATO = Pattern.compile("^[A-Z0-9]{12}\d{2}$");
    private static final SecureRandom RNG = new SecureRandom();

    // Valor do caractere = código ASCII - 48 (A = 17 ... Z = 42)
    static int dv(String base) {
        int offset = 13 - base.length(), soma = 0;
        for (int i = 0; i < base.length(); i++) {
            soma += (base.charAt(i) - 48) * PESOS[offset + i];
        }
        int r = soma % 11;
        return r < 2 ? 0 : 11 - r;
    }

    public static boolean validar(String valor) {
        String c = valor.replaceAll("[./-]", "").toUpperCase(Locale.ROOT);
        if (!FORMATO.matcher(c).matches() || c.chars().distinct().count() == 1) return false;
        int d1 = dv(c.substring(0, 12));
        int d2 = dv(c.substring(0, 12) + d1);
        return c.endsWith("" + d1 + d2);
    }

    public static String gerar(boolean alfanumerico) {
        String pool = alfanumerico ? CHARS : CHARS.substring(0, 10);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 8; i++) sb.append(pool.charAt(RNG.nextInt(pool.length())));
        String base = sb.append("0001").toString();
        int d1 = dv(base);
        return base + d1 + dv(base + d1);
    }
}

using System.Linq;
using System.Security.Cryptography;
using System.Text.RegularExpressions;

public static class Cnpj
{
    static readonly int[] Pesos = { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
    const string Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    // ECMAScript: \d aceita só 0-9 (sem dígitos Unicode)
    static readonly Regex Formato = new(@"^[A-Z0-9]{12}\d{2}$", RegexOptions.ECMAScript);

    // Valor do caractere = código ASCII - 48 (A = 17 ... Z = 42)
    static int Dv(string b)
    {
        int offset = 13 - b.Length, soma = 0;
        for (int i = 0; i < b.Length; i++) soma += (b[i] - 48) * Pesos[offset + i];
        int r = soma % 11;
        return r < 2 ? 0 : 11 - r;
    }

    public static bool Validar(string valor)
    {
        var c = Regex.Replace(valor, @"[./-]", "").ToUpperInvariant();
        if (!Formato.IsMatch(c) || c.Distinct().Count() == 1) return false;
        int d1 = Dv(c[..12]);
        return c[12..] == $"{d1}{Dv(c[..12] + d1)}";
    }

    public static string Gerar(bool alfanumerico = false)
    {
        var pool = alfanumerico ? Chars : Chars[..10];
        var raiz = new string(Enumerable.Range(0, 8)
            .Select(_ => pool[RandomNumberGenerator.GetInt32(pool.Length)]).ToArray());
        var b = raiz + "0001";
        int d1 = Dv(b);
        return $"{b}{d1}{Dv(b + d1)}";
    }
}

# Sem máscara, já em maiúsculas (numérico e alfanumérico)
^[A-Z0-9]{12}\d{2}$

# Com máscara XX.XXX.XXX/XXXX-XX
^[A-Z0-9]{2}\.[A-Z0-9]{3}\.[A-Z0-9]{3}/[A-Z0-9]{4}-\d{2}$

# Só o formato antigo (vai rejeitar CNPJ alfanumérico)
^\d{14}$

-- BIGINT ou NUMERIC(14) quebra com letras e perde o zero à esquerda.
-- Guarde sem máscara, em maiúsculas, como texto de 14 posições (PostgreSQL):
ALTER TABLE empresa
  ALTER COLUMN cnpj TYPE CHAR(14) USING LPAD(cnpj::text, 14, '0');

ALTER TABLE empresa
  ADD CONSTRAINT cnpj_formato CHECK (cnpj ~ '^[A-Z0-9]{12}[0-9]{2}$');

-- Matriz e filiais da mesma empresa compartilham a raiz (8 primeiros):
SELECT LEFT(cnpj, 8) AS raiz, COUNT(*) AS estabelecimentos
FROM empresa
GROUP BY LEFT(cnpj, 8);