@stll/stdnum 0.0.1

package/src/ai/tin.ts

@@ -0,0 +1,98 @@
+/** Generate a random valid Anguilla TIN. */
+const generate = (): string => {
+  const prefix = Math.random() < 0.5 ? "1" : "2";
+  return prefix + randomDigits(9);
+};
+
+/**
+ * TIN (Anguilla Tax Identification Number).
+ *
+ * Issued by the Inland Revenue Department (IRD) to
+ * individuals and entities for tax purposes. The
+ * number consists of 10 digits including a prefix
+ * digit and check digit:
+ *   - Prefix 1: individual TIN
+ *   - Prefix 2: non-individual (business) TIN
+ *
+ * Formatted as XXXXX-XXXXX.
+ *
+ * Source: OECD CRS TIN information sheet.
+ *
+ * PERSON/ENTITY
+ *
+ * @see https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Anguilla-TIN.pdf
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits } from "#util/generate";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+
+const compact = (value: string): string => {
+  return clean(value, " -").trim();
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Anguilla TIN must be 10 digits",
+    );
+  }
+
+  if (!/^\d{10}$/.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Anguilla TIN must contain only digits",
+    );
+  }
+
+  const prefix = v[0];
+
+  if (prefix !== "1" && prefix !== "2") {
+    return err(
+      "INVALID_COMPONENT",
+      "Anguilla TIN must start with 1 (individual) or 2 (business)",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 5)}-${v.slice(5)}`;
+};
+
+/**
+ * Anguilla Tax Identification Number.
+ *
+ * Examples derived from stdnum-js test suite
+ * (format-only validation, no published check
+ * digit algorithm).
+ */
+const tin: Validator = {
+  name: "Anguilla Tax Identification Number",
+  localName: "Tax Identification Number",
+  abbreviation: "TIN",
+  aliases: ["TIN"] as const,
+  candidatePattern: "\\d{11}",
+  country: "AI",
+  entityType: "any",
+  lengths: [10] as const,
+  examples: ["1234567890", "2345678901"] as const,
+  compact,
+  format,
+  validate,
+  description:
+    "Anguilla tax number issued by the Inland Revenue Department",
+  sourceUrl:
+    "https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Anguilla-TIN.pdf",
+  generate,
+};
+
+export default tin;
+export { compact, format, validate, generate };

package/src/al/mod.ts

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

package/src/al/nipt.ts

@@ -0,0 +1,78 @@
+/** Generate a random valid Albanian NIPT. */
+const generate = (): string => {
+  const first = String.fromCodePoint(65 + randomInt(0, 12)); // A-M
+  const digits = randomDigits(8);
+  const last = String.fromCodePoint(65 + randomInt(0, 25)); // A-Z
+  return `${first}${digits}${last}`;
+};
+
+/**
+ * NIPT (Numri i Identifikimit për Personin e Tatueshëm,
+ * Albanian tax number).
+ *
+ * 10 characters: a letter (A-M) indicating the decade or
+ * birth decade, 8 digits encoding year/month/day/serial,
+ * and a trailing check letter. The check digit algorithm
+ * is undocumented.
+ *
+ * @see https://www.tatime.gov.al/eng/c/4/103/business-lifecycle
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+
+const NIPT_RE = /^[A-M]\d{8}[A-Z]$/;
+
+const compact = (value: string): string => {
+  let v = clean(value, " ").toUpperCase().trim();
+  if (v.startsWith("(AL)")) {
+    v = v.slice(4);
+  } else if (v.startsWith("AL")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Albanian NIPT must be 10 characters",
+    );
+  }
+  if (!NIPT_RE.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Albanian NIPT must be letter + 8 digits + letter" +
+        " (first letter A-M)",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Albanian NIPT (tax identification number). */
+const nipt: Validator = {
+  name: "Albanian Tax Number",
+  localName:
+    "Numri i Identifikimit për Personin e Tatueshëm",
+  abbreviation: "NIPT",
+  aliases: ["NIPT", "NUIS"] as const,
+  candidatePattern: "[A-Z]\\d{8}[A-Z]",
+  country: "AL",
+  entityType: "any",
+  sourceUrl: "https://www.tatime.gov.al/",
+  examples: ["J91402501L", "K22218003V"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default nipt;
+export { compact, format, validate, generate };

package/src/am/mod.ts

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

package/src/am/tin.ts

@@ -0,0 +1,73 @@
+/** Generate a random valid Armenian TIN. */
+const generate = (): string => randomDigits(8);
+
+/**
+ * TIN (Tax Identification Number, ՀԾՀ).
+ *
+ * Armenian taxpayer identification number issued by the
+ * State Revenue Committee (SRC). 8 digits; the 8th digit
+ * is a check digit calculated from the first 7. The
+ * checksum algorithm is not publicly documented, so only
+ * format validation is performed.
+ *
+ * Issued to both individuals and entities.
+ *
+ * @see https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Armenia-TIN.pdf
+ * @see https://www.src.am/en/taxpayerSearchSystemPage/112
+ */
+
+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, " -").trim();
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 8) {
+    return err(
+      "INVALID_LENGTH",
+      "Armenian TIN must be 8 digits",
+    );
+  }
+
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Armenian TIN must contain only digits",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Armenian Tax Identification Number. */
+const tin: Validator = {
+  name: "Armenian Tax ID",
+  localName: "Հարկ վճարողի հաշվառման համար",
+  abbreviation: "TIN",
+  aliases: ["ՀՎՀՀ", "TIN"] as const,
+  candidatePattern: "\\d{8}",
+  country: "AM",
+  entityType: "any",
+  lengths: [8] as const,
+  examples: ["01234561", "10048376"] as const,
+  compact,
+  format,
+  validate,
+  sourceUrl:
+    "https://www.oecd.org/tax/automatic-exchange/" +
+    "crs-implementation-and-assistance/" +
+    "tax-identification-numbers/Armenia-TIN.pdf",
+  generate,
+};
+
+export default tin;
+export { compact, format, validate, generate };

package/src/ar/cbu.ts

@@ -0,0 +1,106 @@
+/**
+ * CBU (Clave Bancaria Uniforme).
+ *
+ * Argentine bank account number used for electronic
+ * transfers. 22 digits: 3-digit bank + 4-digit branch
+ * + 1 check digit + 13-digit account + 1 check digit.
+ *
+ * @see https://es.wikipedia.org/wiki/Clave_bancaria_uniforme
+ */
+
+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_BLOCK1 = [7, 1, 3, 9, 7, 1, 3];
+const WEIGHTS_BLOCK2 = [
+  3, 9, 7, 1, 3, 9, 7, 1, 3, 9, 7, 1, 3,
+];
+
+const compact = (value: string): string =>
+  clean(value, " -").trim();
+
+const calcCheck = (
+  digits: string,
+  weights: readonly number[],
+): number => {
+  let sum = 0;
+  for (let i = 0; i < digits.length; i++) {
+    sum += Number(digits[i]) * weights[i]!;
+  }
+  return (10 - (sum % 10)) % 10;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 22) {
+    return err("INVALID_LENGTH", "CBU must be 22 digits");
+  }
+
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "CBU must contain only digits",
+    );
+  }
+
+  // First block: digits 0-6, check digit at 7
+  const check1 = calcCheck(v.slice(0, 7), WEIGHTS_BLOCK1);
+  if (check1 !== Number(v[7])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "CBU first check digit mismatch",
+    );
+  }
+
+  // Second block: digits 8-20, check digit at 21
+  const check2 = calcCheck(v.slice(8, 21), WEIGHTS_BLOCK2);
+  if (check2 !== Number(v[21])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "CBU second check digit mismatch",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 8)} ${v.slice(8)}`;
+};
+
+/** Generate a random valid CBU. */
+const generate = (): string => {
+  const block1 = randomDigits(7);
+  const check1 = calcCheck(block1, WEIGHTS_BLOCK1);
+  const block2 = randomDigits(13);
+  const check2 = calcCheck(block2, WEIGHTS_BLOCK2);
+  return block1 + String(check1) + block2 + String(check2);
+};
+
+/** Argentine Uniform Bank Key. */
+const cbu: Validator = {
+  name: "Argentine Bank Account Number",
+  localName: "Clave Bancaria Uniforme",
+  abbreviation: "CBU",
+  aliases: ["CBU", "Clave Bancaria Uniforme"] as const,
+  candidatePattern: "\\d{22}",
+  country: "AR",
+  entityType: "any",
+  sourceUrl:
+    "https://es.wikipedia.org/wiki/Clave_bancaria_uniforme",
+  lengths: [22] as const,
+  examples: ["2850590940090418135201"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default cbu;
+export { compact, format, validate, generate };

package/src/ar/cuit.ts

@@ -0,0 +1,137 @@
+/**
+ * CUIT (Clave Única de Identificación Tributaria).
+ *
+ * Argentine tax identification number assigned by AFIP
+ * (Administración Federal de Ingresos Públicos). The
+ * number consists of 11 digits: a 2-digit type code,
+ * an 8-digit DNI number, and a single check digit
+ * computed using a weighted modulo 11 algorithm.
+ *
+ * Type codes: 20/23/24/27 = person, 30/33/34 = company,
+ * 50/51/55 = international.
+ *
+ * Format: XX-XXXXXXXX-X (11 digits).
+ *
+ * @see https://www.afip.gob.ar/
+ * @see https://en.wikipedia.org/wiki/CUIT_(Argentina)
+ */
+
+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 VALID_TYPES = new Set([
+  "20",
+  "23",
+  "24",
+  "27",
+  "30",
+  "33",
+  "34",
+  "50",
+  "51",
+  "55",
+]);
+
+const WEIGHTS = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+
+const compact = (value: string): string =>
+  clean(value, " -.").trim();
+
+/**
+ * Compute the CUIT check digit using weighted sum
+ * mod 11. Weights: [5, 4, 3, 2, 7, 6, 5, 4, 3, 2].
+ *
+ * check = 11 - (sum % 11); if 11 -> 0, if 10 -> 9.
+ */
+const calcCheckDigit = (body: string): number => {
+  let sum = 0;
+  for (let i = 0; i < 10; i++) {
+    sum += Number(body[i]) * WEIGHTS[i]!;
+  }
+  const remainder = 11 - (sum % 11);
+  if (remainder === 11) return 0;
+  if (remainder === 10) return 9;
+  return remainder;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 11) {
+    return err("INVALID_LENGTH", "CUIT must be 11 digits");
+  }
+
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "CUIT must contain only digits",
+    );
+  }
+
+  const typeCode = v.slice(0, 2);
+  if (!VALID_TYPES.has(typeCode)) {
+    return err(
+      "INVALID_COMPONENT",
+      "CUIT has an invalid type code",
+    );
+  }
+
+  const expected = calcCheckDigit(v.slice(0, 10));
+  if (Number(v[10]) !== expected) {
+    return err(
+      "INVALID_CHECKSUM",
+      "CUIT check digit does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 2)}-${v.slice(2, 10)}-${v.slice(10)}`;
+};
+
+/** Generate a random valid CUIT. */
+const generate = (): string => {
+  const types = ["20", "23", "24", "27", "30", "33", "34"];
+  const type =
+    types[Math.floor(Math.random() * types.length)]!;
+  const body = type + randomDigits(8);
+  const check = calcCheckDigit(body);
+  return body + String(check);
+};
+
+/**
+ * Argentine CUIT (tax identification number).
+ *
+ * Examples sourced from python-stdnum test suite
+ * (ar.cuit module).
+ */
+const cuit: Validator = {
+  name: "Argentine Tax ID",
+  localName: "Clave Única de Identificación Tributaria",
+  abbreviation: "CUIT",
+  aliases: [
+    "CUIT",
+    "CUIL",
+    "Clave Única de Identificación Tributaria",
+  ] as const,
+  candidatePattern: "\\d{2}-?\\d{8}-?\\d",
+  country: "AR",
+  entityType: "any",
+  compact,
+  format,
+  validate,
+  sourceUrl: "https://www.afip.gob.ar/",
+  lengths: [11] as const,
+  examples: ["20267565393", "20055361682"] as const,
+  generate,
+};
+
+export default cuit;
+export { compact, format, validate, generate };

package/src/ar/dni.ts

@@ -0,0 +1,79 @@
+/** Generate a random valid Argentine DNI. */
+const generate = (): string => randomDigits(8);
+
+/**
+ * DNI (Documento Nacional de Identidad).
+ *
+ * Argentine national identity card number. The DNI is
+ * a 7 or 8-digit number assigned to all Argentine
+ * citizens and permanent residents. No check digit.
+ *
+ * @see https://en.wikipedia.org/wiki/Documento_Nacional_de_Identidad_(Argentina)
+ */
+
+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, " -.").trim();
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length < 7 || v.length > 8) {
+    return err(
+      "INVALID_LENGTH",
+      "DNI must be 7 or 8 digits",
+    );
+  }
+
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "DNI must contain only digits",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  if (v.length === 8) {
+    return `${v.slice(0, 2)}.${v.slice(2, 5)}.${v.slice(5)}`;
+  }
+  if (v.length === 7) {
+    return `${v.slice(0, 1)}.${v.slice(1, 4)}.${v.slice(4)}`;
+  }
+  return v;
+};
+
+/** Argentine National Identity Document. */
+const dni: Validator = {
+  name: "Argentine Identity Card",
+  localName: "Documento Nacional de Identidad",
+  abbreviation: "DNI",
+  aliases: [
+    "DNI",
+    "Documento Nacional de Identidad",
+    "Documento de Identidad",
+  ] as const,
+  candidatePattern: "\\d{1,2}\\.?\\d{3}\\.?\\d{3}",
+  country: "AR",
+  entityType: "person",
+  sourceUrl:
+    "https://en.wikipedia.org/wiki/Documento_Nacional_de_Identidad_(Argentina)",
+  lengths: [7, 8] as const,
+  examples: ["20123456", "12345678"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default dni;
+export { compact, format, validate, generate };

package/src/ar/mod.ts

@@ -0,0 +1,3 @@
+export { default as cbu } from "./cbu";
+export { default as cuit } from "./cuit";
+export { default as dni } from "./dni";

package/src/at/businessid.ts

@@ -0,0 +1,74 @@
+/** Generate a random valid Austrian Firmenbuchnummer. */
+const generate = (): string => {
+  const digits = randomDigits(randomInt(5, 6));
+  const letter = String.fromCodePoint(
+    97 + randomInt(0, 25),
+  ); // a-z (compact lowercases)
+  return `${digits}${letter}`;
+};
+
+/**
+ * Firmenbuchnummer (Austrian company register number).
+ *
+ * Digits followed by a single trailing letter.
+ * Optional "FN" prefix. No checksum.
+ *
+ * @see https://www.justiz.gv.at/
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+
+const FN_RE = /^\d+[a-z]$/i;
+
+const compact = (value: string): string => {
+  let v = clean(value, " -/.");
+  if (v.slice(0, 2).toUpperCase() === "FN") {
+    v = v.slice(2);
+  }
+  return v.toLowerCase();
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length < 2) {
+    return err(
+      "INVALID_LENGTH",
+      "Austrian Firmenbuchnummer is too short",
+    );
+  }
+  if (!FN_RE.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Austrian Firmenbuchnummer must be digits" +
+        " followed by a letter",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `FN ${compact(value)}`;
+
+/** Austrian Company Register Number. */
+const businessid: Validator = {
+  name: "Austrian Company Register Number",
+  localName: "Firmenbuchnummer",
+  abbreviation: "FN",
+  aliases: ["Firmenbuchnummer", "FN", "FBN"] as const,
+  candidatePattern: "FN\\s?\\d{5,6}[a-z]?",
+  country: "AT",
+  entityType: "company",
+  sourceUrl: "https://www.justiz.gv.at/",
+  examples: ["122119m"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default businessid;
+export { compact, format, validate, generate };

package/src/at/mod.ts

@@ -0,0 +1,4 @@
+export { default as businessid } from "./businessid";
+export { default as tin } from "./tin";
+export { default as uid } from "./uid";
+export { default as vnr } from "./vnr";