@stll/stdnum 0.0.1

package/src/pt/cc.ts

@@ -0,0 +1,106 @@
+/**
+ * CC (Cartão de Cidadão, Portuguese Identity number).
+ *
+ * Alphanumeric: numeric civil ID + 2-letter version +
+ * 1 check digit. Validated with a Luhn-like algorithm
+ * over an alphanumeric alphabet (0-9, A-Z = 0-35).
+ *
+ * @see https://pt.wikipedia.org/wiki/Cartão_de_cidadão
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+
+const CC_RE = /^\d{9}[A-Z0-9]{2}\d$/;
+
+const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+const compact = (value: string): string =>
+  clean(value, " ").toUpperCase();
+
+const calcCheckDigit = (value: string): string => {
+  let sum = 0;
+  for (let i = value.length - 1; i >= 0; i--) {
+    const pos = value.length - 1 - i;
+    let n = ALPHABET.indexOf(value[i]!);
+    if (pos % 2 === 0) {
+      n *= 2;
+      if (n > 9) n = Math.floor(n / 10) + (n % 10);
+    }
+    sum += n;
+  }
+  return String((10 - (sum % 10)) % 10);
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "CC must be 12 characters",
+    );
+  }
+
+  if (!CC_RE.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "CC must be 9 digits, 2 alphanumeric version characters, and a check digit",
+    );
+  }
+
+  if (calcCheckDigit(v.slice(0, -1)) !== v.at(-1)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "CC check digit does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, -3)} ${v.slice(-3, -1)} ${v.at(-1)}`;
+};
+
+/** Generate a random valid Portuguese CC number. */
+const generate = (): string => {
+  const digits = randomDigits(9);
+  const v0 = ALPHABET[randomInt(0, 35)]!;
+  const v1 = ALPHABET[randomInt(0, 35)]!;
+  const body = digits + v0 + v1;
+  const check = calcCheckDigit(body);
+  return body + check;
+};
+
+/** Portuguese Identity Card number. */
+const cc: Validator = {
+  name: "Portuguese Identity Card",
+  localName: "Cartão de Cidadão",
+  abbreviation: "CC",
+  aliases: [
+    "cartão de cidadão",
+    "CC",
+    "número de identificação civil",
+  ] as const,
+  candidatePattern: "\\d{8}\\s?\\d\\s?[A-Z]{2}\\d",
+  country: "PT",
+  entityType: "person",
+  description:
+    "Alphanumeric national identity card number with Luhn-like check digit",
+  sourceUrl:
+    "https://pt.wikipedia.org/wiki/Cartão_de_cidadão",
+  lengths: [12] as const,
+  examples: ["000000000ZZ8"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default cc;
+export { compact, format, validate, generate };

package/src/pt/mod.ts

@@ -0,0 +1,2 @@
+export { default as cc } from "./cc";
+export { default as vat } from "./vat";

package/src/pt/vat.ts

@@ -0,0 +1,93 @@
+/**
+ * NIF (Portuguese VAT number).
+ *
+ * 9 digits, no leading 0.
+ * Weights [9,8,7,6,5,4,3,2],
+ * check = (11 - sum) % 11 % 10 === d[8].
+ *
+ * @see https://www.vatify.eu/portugal-vat-number.html
+ * @see https://www.portaldasfinancas.gov.pt/
+ */
+
+import { weightedSum } from "#checksums/weighted-sum";
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type { ValidateResult, Validator } from "../types";
+
+const WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2];
+
+const compact = (value: string): string => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("PT") || v.startsWith("pt")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "Portuguese VAT number must be 9 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Portuguese VAT number must contain only digits",
+    );
+  }
+  if (v[0] === "0") {
+    return err(
+      "INVALID_COMPONENT",
+      "Portuguese VAT number cannot start with 0",
+    );
+  }
+  const sum = weightedSum(v.slice(0, 8), WEIGHTS, 11);
+  const check = ((11 - sum) % 11) % 10;
+  if (check !== Number(v[8])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Portuguese VAT number check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `PT${compact(value)}`;
+
+/** Generate a random valid Portuguese NIF. */
+const generate = (): string => {
+  const payload = String(randomInt(1, 9)) + randomDigits(7);
+  const sum = weightedSum(payload, WEIGHTS, 11);
+  return payload + String(((11 - sum) % 11) % 10);
+};
+
+/** Portuguese VAT Number. */
+const vat: Validator = {
+  name: "Portuguese VAT Number",
+  localName: "Número de Identificação Fiscal",
+  abbreviation: "NIF",
+  aliases: [
+    "NIF",
+    "número de identificação fiscal",
+    "contribuinte",
+  ] as const,
+  candidatePattern: "PT\\d{9}",
+  country: "PT",
+  entityType: "any",
+  sourceUrl: "https://www.portaldasfinancas.gov.pt/",
+  examples: ["501964843"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/ro/cnp.ts

@@ -0,0 +1,171 @@
+/**
+ * CNP (Cod Numeric Personal).
+ *
+ * Romanian personal identification number. 13 digits
+ * encoding gender/century, date of birth, county code,
+ * serial number, and a check digit.
+ *
+ * @see https://ro.wikipedia.org/wiki/Cod_numeric_personal
+ * @see https://www.cnp.ro/
+ */
+
+import { weightedSum } from "#checksums/weighted-sum";
+import { clean } from "#util/clean";
+import { isValidDate } from "#util/date";
+import { randomInt } from "#util/generate";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type {
+  ParsedPersonId,
+  ValidateResult,
+  Validator,
+} from "../types";
+
+const WEIGHTS = [
+  2, 7, 9, 1, 4, 6, 3, 5, 8, 2, 7, 9,
+] as const;
+
+const VALID_COUNTIES = new Set([
+  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+  18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+  46, 47, 48, 49, 50, 51, 52, 70, 80, 81, 82, 83,
+]);
+
+const centuryMap: Record<number, number> = {
+  1: 1900,
+  2: 1900,
+  3: 1800,
+  4: 1800,
+  5: 2000,
+  6: 2000,
+  7: 1900, // foreign residents
+  8: 1900, // foreign residents
+};
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 13) {
+    return err(
+      "INVALID_LENGTH",
+      "CNP must be exactly 13 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "CNP must contain only digits",
+    );
+  }
+
+  const g = Number(v[0]);
+  if (g < 1 || g > 9) {
+    return err(
+      "INVALID_COMPONENT",
+      "CNP gender/century digit is invalid",
+    );
+  }
+
+  const century = centuryMap[g] ?? 1900;
+  const yy = Number(v.slice(1, 3));
+  const mm = Number(v.slice(3, 5));
+  const dd = Number(v.slice(5, 7));
+  const year = century + yy;
+
+  if (!isValidDate(year, mm, dd)) {
+    return err(
+      "INVALID_COMPONENT",
+      "CNP contains an invalid date",
+    );
+  }
+
+  const county = Number(v.slice(7, 9));
+  if (!VALID_COUNTIES.has(county)) {
+    return err(
+      "INVALID_COMPONENT",
+      "CNP county code is invalid",
+    );
+  }
+
+  const sum = weightedSum(v.slice(0, 12), WEIGHTS, 11);
+  const check = sum === 10 ? 1 : sum;
+  if (check !== Number(v[12])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "CNP check digit does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/**
+ * Extract birth date and gender from a CNP.
+ * Returns null if the value is not valid.
+ */
+const parse = (value: string): ParsedPersonId | null => {
+  const result = validate(value);
+  if (!result.valid) return null;
+
+  const v = result.compact;
+  const g = Number(v[0]);
+  const century = centuryMap[g] ?? 1900;
+  const yy = Number(v.slice(1, 3));
+  const mm = Number(v.slice(3, 5));
+  const dd = Number(v.slice(5, 7));
+  const year = century + yy;
+
+  return {
+    birthDate: new Date(year, mm - 1, dd),
+    gender: g % 2 === 1 ? "male" : "female",
+  };
+};
+
+/** Generate a random valid Romanian CNP. */
+const generate = (): string => {
+  for (;;) {
+    const g = String(randomInt(1, 6));
+    const yy = String(randomInt(0, 99)).padStart(2, "0");
+    const mm = String(randomInt(1, 12)).padStart(2, "0");
+    const dd = String(randomInt(1, 28)).padStart(2, "0");
+    const county = String(randomInt(1, 52)).padStart(
+      2,
+      "0",
+    );
+    const serial = String(randomInt(1, 999)).padStart(
+      3,
+      "0",
+    );
+    const payload = g + yy + mm + dd + county + serial;
+    const sum = weightedSum(payload, WEIGHTS, 11);
+    const c = payload + String(sum === 10 ? 1 : sum);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Romanian Personal Identification Number. */
+const cnp: Validator = {
+  name: "Romanian Personal ID",
+  localName: "Cod Numeric Personal",
+  abbreviation: "CNP",
+  aliases: ["CNP", "cod numeric personal"] as const,
+  candidatePattern:
+    "[1-8]\\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\\d|3[01])\\d{6}",
+  country: "RO",
+  entityType: "person",
+  sourceUrl: "https://www.cnp.ro/",
+  examples: ["1630615123457"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default cnp;
+export { compact, format, parse, validate, generate };

package/src/ro/mod.ts

@@ -0,0 +1,2 @@
+export { default as cnp } from "./cnp";
+export { default as vat } from "./vat";

package/src/ro/vat.ts

@@ -0,0 +1,94 @@
+/**
+ * CIF/CUI (Romanian VAT number).
+ *
+ * 2-10 digits. Pad to 10, weights
+ * [7,5,3,2,1,7,5,3,2], check =
+ * (10 * sum) % 11 % 10 === last digit.
+ *
+ * @see https://www.vatify.eu/romania-vat-number.html
+ * @see https://www.anaf.ro/
+ */
+
+import { weightedSum } from "#checksums/weighted-sum";
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type { ValidateResult, Validator } from "../types";
+
+const WEIGHTS = [7, 5, 3, 2, 1, 7, 5, 3, 2];
+
+const compact = (value: string): string => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("RO") || v.startsWith("ro")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length < 2 || v.length > 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Romanian VAT number must be 2 to 10 digits",
+    );
+  }
+  if (!isdigits(v) || v[0] === "0") {
+    return err(
+      "INVALID_FORMAT",
+      "Romanian VAT number must contain only digits " +
+        "and must not start with 0",
+    );
+  }
+  // Pad to 10 digits
+  const padded = v.padStart(10, "0");
+  const sum = weightedSum(padded.slice(0, 9), WEIGHTS, 11);
+  const check = ((sum * 10) % 11) % 10;
+  if (check !== Number(padded[9])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Romanian VAT number check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `RO${compact(value)}`;
+
+/** Generate a random valid Romanian VAT number. */
+const generate = (): string => {
+  for (;;) {
+    const c =
+      String(randomInt(1, 9)) +
+      randomDigits(randomInt(1, 9));
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Romanian VAT Number. */
+const vat: Validator = {
+  name: "Romanian VAT Number",
+  localName: "Cod de Identificare Fiscală",
+  abbreviation: "CIF",
+  aliases: [
+    "CUI",
+    "CIF",
+    "cod de identificare fiscală",
+    "cod fiscal",
+  ] as const,
+  candidatePattern: "RO\\d{2,10}",
+  country: "RO",
+  entityType: "any",
+  sourceUrl: "https://www.anaf.ro/",
+  examples: ["18547290"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/rs/mod.ts

@@ -0,0 +1 @@
+export { default as pib } from "./pib";

package/src/rs/pib.ts

@@ -0,0 +1,83 @@
+/**
+ * PIB (Poreski identifikacioni broj).
+ *
+ * Serbian tax identification number. 9 digits with
+ * a mod 11 checksum (ISO 7064 variant).
+ *
+ * @see https://en.wikipedia.org/wiki/Tax_identification_number_(Serbia)
+ * @see https://www.purs.gov.rs/
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits } from "#util/generate";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type { ValidateResult, Validator } from "../types";
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "PIB must be exactly 9 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "PIB must contain only digits",
+    );
+  }
+
+  // ISO 7064 Mod 11, 10 checksum
+  let t = 10;
+  for (let i = 0; i < 8; i++) {
+    t = (t + Number(v[i])) % 10;
+    if (t === 0) t = 10;
+    t = (t * 2) % 11;
+  }
+  const check = (11 - t) % 10;
+  if (check !== Number(v[8])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "PIB check digit mismatch",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid Serbian PIB. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(9);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Serbian Tax Identification Number. */
+const pib: Validator = {
+  name: "Serbian Tax ID",
+  localName: "Poreski identifikacioni broj",
+  abbreviation: "PIB",
+  aliases: ["PIB", "poreski identifikacioni broj"] as const,
+  candidatePattern: "\\d{9}",
+  country: "RS",
+  entityType: "any",
+  lengths: [9] as const,
+  sourceUrl: "https://www.purs.gov.rs/",
+  examples: ["101134702"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default pib;
+export { compact, format, validate, generate };

package/src/ru/inn.ts

@@ -0,0 +1,109 @@
+/**
+ * INN (Идентификационный номер налогоплательщика).
+ *
+ * Russian taxpayer identification number. 10 digits
+ * for companies (1 check digit), 12 digits for
+ * individuals (2 check digits). Check digits are
+ * computed as weighted sum mod 11 mod 10.
+ *
+ * @see https://en.wikipedia.org/wiki/Taxpayer_Identification_Number_(Russia)
+ * @see https://www.nalog.gov.ru/
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits } from "#util/generate";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type { ValidateResult, Validator } from "../types";
+
+const WEIGHTS_10 = [2, 4, 10, 3, 5, 9, 4, 6, 8] as const;
+const WEIGHTS_11 = [7, 2, 4, 10, 3, 5, 9, 4, 6, 8] as const;
+const WEIGHTS_12 = [
+  3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8,
+] as const;
+
+const checkDigit = (
+  value: string,
+  weights: readonly number[],
+): number => {
+  let sum = 0;
+  for (let i = 0; i < weights.length; i++) {
+    sum += Number(value[i]) * weights[i]!;
+  }
+  return (sum % 11) % 10;
+};
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 10 && v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "INN must be 10 or 12 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "INN must contain only digits",
+    );
+  }
+
+  if (v.length === 10) {
+    const check = checkDigit(v, WEIGHTS_10);
+    if (check !== Number(v[9])) {
+      return err(
+        "INVALID_CHECKSUM",
+        "INN check digit mismatch",
+      );
+    }
+  } else {
+    const check11 = checkDigit(v, WEIGHTS_11);
+    const check12 = checkDigit(v, WEIGHTS_12);
+    if (
+      check11 !== Number(v[10]) ||
+      check12 !== Number(v[11])
+    ) {
+      return err(
+        "INVALID_CHECKSUM",
+        "INN check digit mismatch",
+      );
+    }
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid 10-digit Russian INN. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(10);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Russian Taxpayer Identification Number. */
+const inn: Validator = {
+  name: "Russian Tax ID",
+  localName: "Идентификационный номер налогоплательщика",
+  abbreviation: "ИНН",
+  aliases: ["ИНН", "INN"] as const,
+  candidatePattern: "\\d{10,12}",
+  country: "RU",
+  entityType: "any",
+  lengths: [10, 12] as const,
+  sourceUrl: "https://www.nalog.gov.ru/",
+  examples: ["7707083893", "526317984689"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default inn;
+export { compact, format, validate, generate };

package/src/ru/mod.ts

@@ -0,0 +1 @@
+export { default as inn } from "./inn";

package/src/se/mod.ts

@@ -0,0 +1,3 @@
+export { default as orgnr } from "./orgnr";
+export { default as personnummer } from "./personnummer";
+export { default as vat } from "./vat";