@stll/stdnum 2.1.0 → 2.1.2

package/src/es/vat.ts

@@ -1,186 +0,0 @@
-/**
- * NIF/CIF (Spanish VAT number).
- *
- * 9 characters with 4 subtypes: DNI, NIE, CIF,
- * and K/L/M personal numbers.
- *
- * @see https://www.vatify.eu/spain-vat-number.html
- * @see https://www.agenciatributaria.es/
- */
-
-import type {
-  ValidateResult,
-  CountryValidator,
-} from "../types";
-
-import { clean } from "#util/clean";
-import { randomDigits } from "#util/generate";
-import { err } from "#util/result";
-import { isdigits } from "#util/strings";
-
-const DNI_LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE";
-const CIF_LETTERS = "JABCDEFGHI";
-
-const compact = (value: string): string => {
-  let v = clean(value, " -/.");
-  if (v.startsWith("ES") || v.startsWith("es")) {
-    v = v.slice(2);
-  }
-  return v.toUpperCase();
-};
-
-const cifChecksum = (digits: string): number => {
-  let even = 0;
-  let odd = 0;
-  for (let i = 0; i < 7; i++) {
-    const d = Number(digits.charAt(i));
-    if (i % 2 === 0) {
-      // Odd positions (1-indexed): double and sum digits
-      const doubled = d * 2;
-      odd += Math.floor(doubled / 10) + (doubled % 10);
-    } else {
-      even += d;
-    }
-  }
-  return (10 - ((even + odd) % 10)) % 10;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length !== 9) {
-    return err(
-      "INVALID_LENGTH",
-      "Spanish VAT number must be 9 characters",
-    );
-  }
-
-  const first = v.charAt(0);
-  const last = v.charAt(8);
-
-  // DNI: 8 digits + letter
-  if (isdigits(v.slice(0, 8))) {
-    const expected = DNI_LETTERS.charAt(
-      Number.parseInt(v.slice(0, 8), 10) % 23,
-    );
-    if (last !== expected) {
-      return err(
-        "INVALID_CHECKSUM",
-        "Spanish DNI check letter mismatch",
-      );
-    }
-    return { valid: true, compact: v };
-  }
-
-  // NIE: X/Y/Z + 7 digits + letter
-  if (first === "X" || first === "Y" || first === "Z") {
-    let prefix = "2";
-    if (first === "X") {
-      prefix = "0";
-    } else if (first === "Y") {
-      prefix = "1";
-    }
-    const digits = prefix + v.slice(1, 8);
-    if (!isdigits(digits) || !isdigits(v.slice(1, 8))) {
-      return err(
-        "INVALID_FORMAT",
-        "Spanish NIE must have 7 digits after prefix",
-      );
-    }
-    const expected = DNI_LETTERS.charAt(
-      Number.parseInt(digits, 10) % 23,
-    );
-    if (last !== expected) {
-      return err(
-        "INVALID_CHECKSUM",
-        "Spanish NIE check letter mismatch",
-      );
-    }
-    return { valid: true, compact: v };
-  }
-
-  // K, L, M: personal number, letter + 7 digits +
-  // check letter
-  if (first === "K" || first === "L" || first === "M") {
-    if (!isdigits(v.slice(1, 8))) {
-      return err(
-        "INVALID_FORMAT",
-        "Spanish K/L/M number must have 7 digits",
-      );
-    }
-    const expected = DNI_LETTERS.charAt(
-      Number.parseInt(v.slice(1, 8), 10) % 23,
-    );
-    if (last !== expected) {
-      return err(
-        "INVALID_CHECKSUM",
-        "Spanish K/L/M check letter mismatch",
-      );
-    }
-    return { valid: true, compact: v };
-  }
-
-  // CIF: letter + 7 digits + check digit/letter
-  const CIF_PREFIXES = "ABCDEFGHJNPQRSUVW";
-  if (CIF_PREFIXES.includes(first)) {
-    if (!isdigits(v.slice(1, 8))) {
-      return err(
-        "INVALID_FORMAT",
-        "Spanish CIF must have 7 digits after prefix",
-      );
-    }
-    const check = cifChecksum(v.slice(1, 8));
-    // Accept either numeric or alphabetic check digit
-    // for all CIF prefixes (sources conflict on which
-    // prefixes require which type)
-    if (
-      last !== String(check) &&
-      last !== CIF_LETTERS.charAt(check)
-    ) {
-      return err(
-        "INVALID_CHECKSUM",
-        "Spanish CIF check digit/letter mismatch",
-      );
-    }
-    return { valid: true, compact: v };
-  }
-
-  return err(
-    "INVALID_FORMAT",
-    "Spanish VAT number has invalid format",
-  );
-};
-
-const format = (value: string): string =>
-  `ES${compact(value)}`;
-
-/** Generate a random valid Spanish VAT (DNI form). */
-const generate = (): string => {
-  const letters = "TRWAGMYFPDXBNJZSQVHLCKE";
-  const num = randomDigits(8);
-  return num + letters.charAt(Number(num) % 23);
-};
-
-/** Spanish VAT Number. */
-const vat: CountryValidator<"ES"> = {
-  name: "Spanish VAT Number",
-  localName: "Número de Identificación Fiscal",
-  abbreviation: "NIF",
-  aliases: [
-    "NIF",
-    "CIF",
-    "número de identificación fiscal",
-  ] as const,
-  candidatePattern: "ES[A-Z]\\d{7}[A-Z\\d]",
-  scope: "country",
-  country: "ES",
-  entityType: "any",
-  sourceUrl: "https://www.agenciatributaria.es/",
-  examples: ["12345678Z", "A78304516"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default vat;
-export { cifChecksum, compact, format, validate, generate };

package/src/eu/mod.ts

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

package/src/eu/vat.ts

@@ -1,220 +0,0 @@
-/**
- * EU VAT (European Union VAT Number).
- *
- * Dispatcher that routes to per-country VAT
- * validators. Extracts the 2-letter country prefix
- * and delegates to the matching country module.
- *
- * Special cases:
- *   - EL → Greece (gr.vat)
- *   - XI → Northern Ireland (gb.vat)
- *
- * @see https://ec.europa.eu/taxation_customs/vies/
- */
-
-import atUid from "../at/uid";
-import beVat from "../be/vat";
-import bgVat from "../bg/vat";
-import cyVat from "../cy/vat";
-import czDic from "../cz/dic";
-import deVat from "../de/vat";
-import dkVat from "../dk/vat";
-import eeVat from "../ee/vat";
-import esVat from "../es/vat";
-import fiVat from "../fi/vat";
-import frTva from "../fr/tva";
-import gbVat from "../gb/vat";
-import grVat from "../gr/vat";
-import hrVat from "../hr/vat";
-import huVat from "../hu/vat";
-import ieVat from "../ie/vat";
-import itIva from "../it/iva";
-import ltVat from "../lt/vat";
-import luVat from "../lu/vat";
-import lvVat from "../lv/vat";
-import mtVat from "../mt/vat";
-import nlVat from "../nl/vat";
-import plNip from "../pl/nip";
-import ptVat from "../pt/vat";
-import roVat from "../ro/vat";
-import seVat from "../se/vat";
-import siVat from "../si/vat";
-import skDic from "../sk/dic";
-import type {
-  GlobalValidator,
-  ValidateResult,
-} from "../types";
-
-import { clean } from "#util/clean";
-import { randomInt } from "#util/generate";
-import { err } from "#util/result";
-
-type CountryValidator = {
-  compact: (value: string) => string;
-  validate: (value: string) => ValidateResult;
-  format: (value: string) => string;
-};
-
-/**
- * Map of EU VAT country prefixes to their
- * country-specific validators.
- */
-const VALIDATORS: Record<string, CountryValidator> = {
-  AT: atUid,
-  BE: beVat,
-  BG: bgVat,
-  CY: cyVat,
-  CZ: czDic,
-  DE: deVat,
-  DK: dkVat,
-  EE: eeVat,
-  EL: grVat, // Greece uses EL prefix in EU VAT
-  ES: esVat,
-  FI: fiVat,
-  FR: frTva,
-  GR: grVat,
-  HR: hrVat,
-  HU: huVat,
-  IE: ieVat,
-  IT: itIva,
-  LT: ltVat,
-  LU: luVat,
-  LV: lvVat,
-  MT: mtVat,
-  NL: nlVat,
-  PL: plNip,
-  PT: ptVat,
-  RO: roVat,
-  SE: seVat,
-  SI: siVat,
-  SK: skDic,
-  XI: gbVat, // Northern Ireland
-};
-
-/**
- * Extract the 2-letter country prefix and the
- * remaining number from an EU VAT string.
- */
-const splitPrefix = (
-  value: string,
-): { cc: string; rest: string } | undefined => {
-  const v = clean(value, " -").toUpperCase();
-  if (v.length < 3) return undefined;
-  const cc = v.slice(0, 2);
-  if (!/^[A-Z]{2}$/.test(cc)) return undefined;
-  return { cc, rest: v.slice(2) };
-};
-
-const compact = (value: string): string => {
-  const parts = splitPrefix(value);
-  if (parts === undefined) {
-    return clean(value, " -").toUpperCase();
-  }
-  const validator = VALIDATORS[parts.cc];
-  if (validator === undefined) {
-    return clean(value, " -").toUpperCase();
-  }
-  return `${parts.cc}${validator.compact(parts.rest)}`;
-};
-
-const validate = (value: string): ValidateResult => {
-  const parts = splitPrefix(value);
-  if (parts === undefined) {
-    return err(
-      "INVALID_FORMAT",
-      "EU VAT must start with a 2-letter country code",
-    );
-  }
-  const validator = VALIDATORS[parts.cc];
-  if (validator === undefined) {
-    return err(
-      "INVALID_COMPONENT",
-      `Unsupported EU VAT country: ${parts.cc}`,
-    );
-  }
-  const result = validator.validate(parts.rest);
-  if (!result.valid) return result;
-  return {
-    valid: true,
-    compact: `${parts.cc}${result.compact}`,
-  };
-};
-
-/**
- * Format returns the compact EU VAT form:
- * `CC` + country-compacted number. Equivalent to
- * compact() because country format() methods
- * prepend their own prefix (e.g., AT UID format
- * returns "ATU..."), which would cause double-
- * prefixing if used here.
- */
-const format = (value: string): string => {
-  const parts = splitPrefix(value);
-  if (parts === undefined) return value;
-  const validator = VALIDATORS[parts.cc];
-  if (validator === undefined) return value;
-  return `${parts.cc}${validator.compact(parts.rest)}`;
-};
-
-const GENERATORS = [
-  ["AT", atUid],
-  ["BE", beVat],
-  ["BG", bgVat],
-  ["CY", cyVat],
-  ["CZ", czDic],
-  ["DE", deVat],
-  ["DK", dkVat],
-  ["EE", eeVat],
-  ["ES", esVat],
-  ["FI", fiVat],
-  ["FR", frTva],
-  ["GR", grVat],
-  ["HR", hrVat],
-  ["HU", huVat],
-  ["IE", ieVat],
-  ["IT", itIva],
-  ["LT", ltVat],
-  ["LU", luVat],
-  ["LV", lvVat],
-  ["MT", mtVat],
-  ["NL", nlVat],
-  ["PL", plNip],
-  ["PT", ptVat],
-  ["RO", roVat],
-  ["SE", seVat],
-  ["SI", siVat],
-  ["SK", skDic],
-] as const;
-
-/** Generate a random EU VAT number from a member validator. */
-const generate = (): string => {
-  for (;;) {
-    const candidate =
-      GENERATORS[randomInt(0, GENERATORS.length - 1)];
-    if (!candidate) continue;
-
-    const [prefix, validator] = candidate;
-    if (validator.generate === undefined) continue;
-    return `${prefix}${validator.generate()}`;
-  }
-};
-
-/** European Union VAT Number. */
-const euVat: GlobalValidator = {
-  scope: "global",
-  name: "EU VAT Number",
-  localName: "EU VAT Number",
-  abbreviation: "EU VAT",
-  aliases: ["EU VAT", "VAT identification number"] as const,
-  candidatePattern: "[A-Z]{2}\\d{8,12}",
-  entityType: "company",
-  sourceUrl: "https://ec.europa.eu/taxation_customs/vies/",
-  examples: ["ATU13585627", "DE136695976"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default euVat;
-export { compact, format, generate, validate };

package/src/fi/hetu.ts

@@ -1,200 +0,0 @@
-/**
- * HETU (Henkilötunnus).
- *
- * Finnish personal identity code. 11 characters in
- * format DDMMYY+CCC+X where the separator indicates
- * the century and X is a check character.
- *
- * @see https://dvv.fi/en/personal-identity-code
- */
-
-import type {
-  ParsedPersonId,
-  ValidateResult,
-  CountryValidator,
-} from "../types";
-
-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";
-
-const CHECK_CHARS = "0123456789ABCDEFHJKLMNPRSTUVWXY";
-
-const SEPARATORS_1800 = new Set(["+"]);
-const SEPARATORS_1900 = new Set([
-  "-",
-  "Y",
-  "X",
-  "W",
-  "V",
-  "U",
-]);
-const SEPARATORS_2000 = new Set([
-  "A",
-  "B",
-  "C",
-  "D",
-  "E",
-  "F",
-]);
-
-const compact = (value: string): string =>
-  clean(value, " ").toUpperCase();
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length !== 11) {
-    return err(
-      "INVALID_LENGTH",
-      "HETU must be exactly 11 characters",
-    );
-  }
-
-  const dd = v.slice(0, 2);
-  const mm = v.slice(2, 4);
-  const yy = v.slice(4, 6);
-  const separator = v.charAt(6);
-  const serial = v.slice(7, 10);
-  const checkChar = v.charAt(10);
-
-  if (!isdigits(dd) || !isdigits(mm) || !isdigits(yy)) {
-    return err(
-      "INVALID_FORMAT",
-      "HETU date part must be digits",
-    );
-  }
-  if (!isdigits(serial)) {
-    return err(
-      "INVALID_FORMAT",
-      "HETU serial must be digits",
-    );
-  }
-
-  let century: number;
-  if (SEPARATORS_1800.has(separator)) {
-    century = 1800;
-  } else if (SEPARATORS_1900.has(separator)) {
-    century = 1900;
-  } else if (SEPARATORS_2000.has(separator)) {
-    century = 2000;
-  } else {
-    return err(
-      "INVALID_COMPONENT",
-      "HETU separator is invalid",
-    );
-  }
-
-  const year = century + Number(yy);
-  const month = Number(mm);
-  const day = Number(dd);
-
-  if (!isValidDate(year, month, day)) {
-    return err(
-      "INVALID_COMPONENT",
-      "HETU contains an invalid date",
-    );
-  }
-
-  // Individual number must be >= 002
-  const serialNum = Number(serial);
-  if (serialNum < 2) {
-    return err(
-      "INVALID_COMPONENT",
-      "HETU individual number must be >= 002",
-    );
-  }
-  // Temporary range 900-999 is not valid
-  if (serialNum >= 900) {
-    return err(
-      "INVALID_COMPONENT",
-      "HETU temporary individual range 900-999",
-    );
-  }
-
-  const checkNum = Number(`${dd}${mm}${yy}${serial}`);
-  const expected = CHECK_CHARS.charAt(checkNum % 31);
-  if (checkChar !== expected) {
-    return err(
-      "INVALID_CHECKSUM",
-      "HETU check character does not match",
-    );
-  }
-
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => compact(value);
-
-/**
- * Extract birth date and gender from a HETU.
- * 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 dd = Number(v.slice(0, 2));
-  const mm = Number(v.slice(2, 4));
-  const yy = Number(v.slice(4, 6));
-  const separator = v.charAt(6);
-  const serial = Number(v.slice(7, 10));
-
-  let century: number;
-  if (SEPARATORS_1800.has(separator)) {
-    century = 1800;
-  } else if (SEPARATORS_1900.has(separator)) {
-    century = 1900;
-  } else {
-    century = 2000;
-  }
-
-  const year = century + yy;
-
-  return {
-    birthDate: new Date(year, mm - 1, dd),
-    gender: serial % 2 === 0 ? "female" : "male",
-  };
-};
-
-/** Generate a random valid HETU. */
-const generate = (): string => {
-  const year = randomInt(1900, 2024);
-  const month = String(randomInt(1, 12)).padStart(2, "0");
-  const day = String(randomInt(1, 28)).padStart(2, "0");
-  const yy = String(year % 100).padStart(2, "0");
-  const separator = year >= 2000 ? "A" : "-";
-  const serial = String(randomInt(2, 899)).padStart(3, "0");
-  const checkNum = Number(`${day}${month}${yy}${serial}`);
-  const checkChar = CHECK_CHARS.charAt(checkNum % 31);
-  return `${day}${month}${yy}${separator}${serial}${checkChar}`;
-};
-
-/** Finnish Personal Identity Code. */
-const hetu: CountryValidator<"FI", ParsedPersonId> = {
-  name: "Finnish Personal ID",
-  localName: "Henkilötunnus",
-  abbreviation: "HETU",
-  aliases: [
-    "henkilötunnus",
-    "HETU",
-    "sosiaaliturvatunnus",
-  ] as const,
-  candidatePattern: "\\d{6}[-+A]\\d{3}[\\dA-Z]",
-  scope: "country",
-  country: "FI",
-  entityType: "person",
-  sourceUrl: "https://dvv.fi/en/personal-identity-code",
-  lengths: [11] as const,
-  examples: ["131052-308T"] as const,
-  compact,
-  format,
-  parse,
-  validate,
-  generate,
-};
-
-export default hetu;
-export { compact, format, generate, parse, validate };

package/src/fi/mod.ts

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

package/src/fi/vat.ts

@@ -1,87 +0,0 @@
-/**
- * ALV nro (Finnish VAT number).
- *
- * 8 digits. Weights [7,9,10,5,8,4,2,1],
- * sum % 11 === 0.
- *
- * @see https://www.vatify.eu/finland-vat-number.html
- * @see https://www.ytj.fi/en/index/businessid.html
- */
-
-import type {
-  ValidateResult,
-  CountryValidator,
-} from "../types";
-
-import { weightedSum } from "#checksums/weighted-sum";
-import { clean } from "#util/clean";
-import { randomDigits } from "#util/generate";
-import { err } from "#util/result";
-import { isdigits } from "#util/strings";
-
-const WEIGHTS = [7, 9, 10, 5, 8, 4, 2, 1];
-
-const compact = (value: string): string => {
-  let v = clean(value, " -/.");
-  if (v.startsWith("FI") || v.startsWith("fi")) {
-    v = v.slice(2);
-  }
-  return v;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length !== 8) {
-    return err(
-      "INVALID_LENGTH",
-      "Finnish VAT number must be 8 digits",
-    );
-  }
-  if (!isdigits(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "Finnish VAT number must contain only digits",
-    );
-  }
-  const sum = weightedSum(v, WEIGHTS, 11);
-  if (sum !== 0) {
-    return err(
-      "INVALID_CHECKSUM",
-      "Finnish VAT number check digit mismatch",
-    );
-  }
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string =>
-  `FI${compact(value)}`;
-
-/** Generate a random valid Finnish VAT number. */
-const generate = (): string => {
-  for (;;) {
-    const c = randomDigits(8);
-    if (validate(c).valid) return c;
-  }
-};
-
-/** Finnish VAT Number. */
-const vat: CountryValidator<"FI"> = {
-  name: "Finnish VAT Number",
-  localName: "Arvonlisäveronumero",
-  abbreviation: "ALV nro",
-  aliases: ["ALV-numero", "Y-tunnus"] as const,
-  candidatePattern: "FI\\d{8}",
-  scope: "country",
-  country: "FI",
-  entityType: "company",
-  sourceUrl: "https://www.ytj.fi/en/index/businessid.html",
-  lengths: [8] as const,
-  examples: ["20774740"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default vat;
-export { compact, format, validate, generate };