@stll/stdnum 2.1.0 → 2.1.2

package/src/cz/rc.ts

@@ -1,222 +0,0 @@
-/**
- * RČ (Rodné číslo).
- *
- * Czech and Slovak national identifier (birth
- * number). 9 or 10 digits encoding date of birth
- * and gender. 10-digit numbers (post-1954) must
- * be divisible by 11.
- *
- * Women have 50 added to the month. For modern
- * 10-digit numbers, an additional +20 offset may
- * be used when the daily serial range is exhausted
- * (+70 for women).
- *
- * Canonical source:
- * - Czech Ministry of the Interior guidance on rodne
- *   cislo, with the modern overflow-month rules
- *
- * We use this to keep the 9-digit historical form
- * valid while rejecting modern +20/+70 month offsets
- * on 9-digit numbers. Those overflow offsets are a
- * modern rule for 10-digit values.
- *
- * @see https://www.mvcr.cz/mvcren/docDetail.aspx?docid=21975362&doctype=ART
- * @see Law 133/2000 Sb.
- */
-
-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 compact = (value: string): string =>
-  clean(value, " /");
-
-const decodeMonth = (
-  rawMonth: number,
-  year: number,
-  length: number,
-): number | null => {
-  const candidates =
-    length === 10 && year >= 2004
-      ? [0, 50, 20, 70]
-      : [0, 50];
-  for (const offset of candidates) {
-    const month = rawMonth - offset;
-    if (month >= 1 && month <= 12) {
-      return month;
-    }
-  }
-  return null;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length !== 9 && v.length !== 10) {
-    return err(
-      "INVALID_LENGTH",
-      "Birth number must be 9 or 10 digits",
-    );
-  }
-  if (!isdigits(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "Birth number must contain only digits",
-    );
-  }
-
-  const yy = Number(v.slice(0, 2));
-  const mm = Number(v.slice(2, 4));
-  const dd = Number(v.slice(4, 6));
-
-  // Resolve full year
-  let year = yy + 1900;
-  if (v.length === 9) {
-    // 9-digit: pre-1954 only
-    if (year >= 1980) year -= 100;
-    if (year > 1953) {
-      return err(
-        "INVALID_COMPONENT",
-        "9-digit birth numbers are pre-1954 only",
-      );
-    }
-  } else {
-    // 10-digit: if year < 1954, it's 2000s
-    if (year < 1954) year += 100;
-  }
-
-  const month = decodeMonth(mm, year, v.length);
-  if (month === null) {
-    return err(
-      "INVALID_COMPONENT",
-      "Birth number contains an invalid month",
-    );
-  }
-
-  if (dd < 1 || dd > 31) {
-    return err(
-      "INVALID_COMPONENT",
-      "Birth number contains an invalid day",
-    );
-  }
-
-  // Validate the actual date
-  if (!isValidDate(year, month, dd)) {
-    return err(
-      "INVALID_COMPONENT",
-      "Birth number contains an invalid date",
-    );
-  }
-
-  // 10-digit: check digit is first 9 digits
-  // mod 11 mod 10
-  if (v.length === 10) {
-    const front = Number(v.slice(0, 9));
-    const check = (front % 11) % 10;
-    if (String(check) !== v[9]) {
-      return err(
-        "INVALID_CHECKSUM",
-        "Birth number is not divisible by 11",
-      );
-    }
-  }
-
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => {
-  const v = compact(value);
-  return `${v.slice(0, 6)}/${v.slice(6)}`;
-};
-
-/**
- * Extract birth date and gender from a birth number.
- * 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 yy = Number(v.slice(0, 2));
-  const mm = Number(v.slice(2, 4));
-  const dd = Number(v.slice(4, 6));
-
-  const gender = mm >= 50 ? "female" : "male";
-  let year = yy + 1900;
-  if (v.length === 10 && year < 1954) year += 100;
-  if (v.length === 9 && year >= 1980) year -= 100;
-
-  const month = decodeMonth(mm, year, v.length);
-  if (month === null) {
-    return null;
-  }
-
-  return {
-    birthDate: new Date(year, month - 1, dd),
-    gender,
-  };
-};
-
-/**
- * Generate a random valid 10-digit birth number.
- * Uses a random date between 1954 and 2024.
- */
-const generate = (): string => {
-  const year = randomInt(1954, 2024);
-  const month = randomInt(1, 12);
-  const day = randomInt(1, 28);
-  const isFemale = Math.random() < 0.5;
-  const mm = isFemale ? month + 50 : month;
-
-  const yy = String(year % 100).padStart(2, "0");
-  const mmStr = String(mm).padStart(2, "0");
-  const dd = String(day).padStart(2, "0");
-
-  const datePart = `${yy}${mmStr}${dd}`;
-  for (let seq = 0; seq < 1000; seq++) {
-    const seqStr = String(seq).padStart(3, "0");
-    const front = `${datePart}${seqStr}`;
-    const num = Number(front);
-    const check = (num % 11) % 10;
-    const result = `${front}${String(check)}`;
-    if (validate(result).valid) {
-      return result;
-    }
-  }
-
-  throw new Error("Failed to generate valid birth number");
-};
-
-/** Czech/Slovak Birth Number. */
-const rc: CountryValidator<"CZ", ParsedPersonId> = {
-  name: "Czech Birth Number",
-  localName: "Rodné číslo",
-  abbreviation: "RČ",
-  aliases: ["rodné číslo", "RČ", "birth number"] as const,
-  candidatePattern: "\\d{6}/\\d{3,4}",
-  scope: "country",
-  country: "CZ",
-  entityType: "person",
-  description:
-    "Czech/Slovak national identifier encoding birth date and gender",
-  sourceUrl:
-    "https://www.mvcr.cz/mvcren/docDetail.aspx?docid=21975362&doctype=ART",
-  lengths: [9, 10] as const,
-  examples: ["7103192745"] as const,
-  compact,
-  format,
-  parse,
-  validate,
-  generate,
-};
-
-export default rc;
-export { compact, format, generate, parse, validate };

package/src/de/handelsreg.ts

@@ -1,122 +0,0 @@
-const GENERATE_TYPES = [
-  "HRA",
-  "HRB",
-  "GNR",
-  "PR",
-  "VR",
-] as const;
-
-/** Generate a random valid Handelsregisternummer. */
-const generate = (): string => {
-  const type = randomPick(GENERATE_TYPES);
-  const number = randomDigits(5);
-  return `${type} ${number}`;
-};
-
-/**
- * Handelsregisternummer (German Company Register Number).
- *
- * German commercial register number assigned by the
- * local court (Amtsgericht). Format: register type
- * (HRA, HRB, GnR, PR, VR) + number.
- *
- * HRA = Handelsregister Abteilung A (partnerships,
- * sole proprietors). HRB = Abteilung B (corporations).
- * GnR = Genossenschaftsregister.
- * PR = Partnerschaftsregister.
- * VR = Vereinsregister.
- *
- * No check digit; validation is structural only.
- *
- * @see https://de.wikipedia.org/wiki/Handelsregister_(Deutschland)
- */
-
-import type {
-  ValidateResult,
-  CountryValidator,
-} from "../types";
-
-import { clean } from "#util/clean";
-import { randomDigits, randomPick } from "#util/generate";
-import { err } from "#util/result";
-
-const REGISTER_TYPES = new Set([
-  "HRA",
-  "HRB",
-  "GNR",
-  "PR",
-  "VR",
-]);
-
-/**
- * Strip separators and normalize to canonical form.
- * Accepts "HRB 12345", "HRB12345", "hrb 12345".
- */
-const compact = (value: string): string => {
-  const v = clean(value, " -.").trim().toUpperCase();
-  const match = v.match(/^(HRA|HRB|GNR|PR|VR)(\d{1,7})$/);
-  if (!match) return v;
-  return `${match[1]} ${match[2]}`;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = clean(value, " -.").trim().toUpperCase();
-
-  const match = v.match(/^([A-Z]{2,3})(\d{1,7})$/);
-  if (!match) {
-    return err(
-      "INVALID_FORMAT",
-      "Handelsregisternummer must be a register type " +
-        "(HRA, HRB, GnR, PR, VR) followed by " +
-        "1-7 digits",
-    );
-  }
-
-  // SAFETY: both capture groups are required, so a
-  // successful match always populates [1] and [2].
-  // eslint-disable-next-line no-non-null-assertion
-  const type = match[1]!;
-  // eslint-disable-next-line no-non-null-assertion
-  const number = match[2]!;
-
-  if (!REGISTER_TYPES.has(type)) {
-    return err(
-      "INVALID_COMPONENT",
-      `Unrecognised register type "${type}"`,
-    );
-  }
-
-  return {
-    valid: true,
-    compact: `${type} ${number}`,
-  };
-};
-
-const format = (value: string): string => compact(value);
-
-/** German Company Register Number. */
-const handelsreg: CountryValidator<"DE"> = {
-  name: "German Company Register Number",
-  localName: "Handelsregisternummer",
-  abbreviation: "HReg",
-  aliases: [
-    "Handelsregisternummer",
-    "Handelsregister",
-    "HRB",
-    "HRA",
-  ] as const,
-  candidatePattern: "(?:HRA|HRB|GnR|PR|VR)\\s*\\d{1,7}",
-  scope: "country",
-  country: "DE",
-  entityType: "company",
-  sourceUrl:
-    "https://de.wikipedia.org/wiki/Handelsregister_(Deutschland)",
-  examples: ["HRB 12345"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default handelsreg;
-export { compact, format, validate, generate };

package/src/de/idnr.ts

@@ -1,147 +0,0 @@
-/**
- * IdNr (Steuerliche Identifikationsnummer).
- *
- * German personal tax identification number.
- * 11 digits; the last digit is a check digit
- * (ISO 7064 Mod 11,10). Exactly one digit
- * appears twice or three times; the rest are
- * unique. The first digit cannot be 0.
- *
- * @see https://www.bzst.de/DE/Privatpersonen/SteuerlicheIdentifikationsnummer/steuerlicheidentifikationsnummer_node.html
- */
-
-import type {
-  ValidateResult,
-  CountryValidator,
-} from "../types";
-
-import {
-  mod1110validate,
-  mod1110checkDigit,
-} from "#checksums/mod1110";
-import { clean } from "#util/clean";
-import { randomInt } from "#util/generate";
-import { err } from "#util/result";
-import { isdigits } from "#util/strings";
-
-const compact = (value: string): string =>
-  clean(value, " -/");
-
-/**
- * Validate digit distribution: in the first 10
- * digits, exactly one digit appears 2 or 3
- * times; all others appear exactly once.
- */
-const validDistribution = (value: string): boolean => {
-  const counts = Array.from<number>({ length: 10 }).fill(0);
-  for (let i = 0; i < 10; i++) {
-    const idx = Number(value.charAt(i));
-    const prev = counts[idx];
-    if (prev !== undefined) counts[idx] = prev + 1;
-  }
-  let doubles = 0;
-  let triples = 0;
-  for (const c of counts) {
-    if (c === 2) doubles++;
-    if (c === 3) triples++;
-    if (c > 3) return false;
-  }
-  // Exactly one digit repeated (2 or 3 times)
-  return (
-    (doubles === 1 && triples === 0) ||
-    (doubles === 0 && triples === 1)
-  );
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length !== 11) {
-    return err(
-      "INVALID_LENGTH",
-      "German IdNr must be 11 digits",
-    );
-  }
-  if (!isdigits(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "German IdNr must contain only digits",
-    );
-  }
-  if (v[0] === "0") {
-    return err(
-      "INVALID_COMPONENT",
-      "German IdNr cannot start with 0",
-    );
-  }
-  if (!validDistribution(v)) {
-    return err(
-      "INVALID_COMPONENT",
-      "German IdNr digit distribution invalid",
-    );
-  }
-  if (!mod1110validate(v)) {
-    return err(
-      "INVALID_CHECKSUM",
-      "German IdNr check digit mismatch",
-    );
-  }
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => {
-  const v = compact(value);
-  return `${v.slice(0, 2)} ${v.slice(2, 5)} ${v.slice(5, 8)} ${v.slice(8)}`;
-};
-
-/** Generate a random valid German IdNr. */
-const generate = (): string => {
-  for (;;) {
-    const repeated = randomInt(0, 9);
-    const times = Math.random() < 0.8 ? 2 : 3;
-    const pool: number[] = [];
-    for (let d = 0; d < 10; d++) {
-      const count = d === repeated ? times : 1;
-      for (let t = 0; t < count; t++) pool.push(d);
-    }
-    while (pool.length < 10) pool.push(randomInt(0, 9));
-    for (let i = pool.length - 1; i > 0; i--) {
-      const j = randomInt(0, i);
-      // SAFETY: i and j are valid indices of `pool`
-      // (i > 0, j ∈ [0, i]).
-      // eslint-disable-next-line no-non-null-assertion
-      [pool[i], pool[j]] = [pool[j]!, pool[i]!];
-    }
-    if (pool[0] === 0) continue;
-    const payload = pool.slice(0, 10).join("");
-    if (!validDistribution(payload)) continue;
-    const check = mod1110checkDigit(payload);
-    const c = payload + String(check);
-    if (validate(c).valid) return c;
-  }
-};
-
-/** German Personal Tax ID. */
-const idnr: CountryValidator<"DE"> = {
-  name: "German Tax ID",
-  localName: "Steuerliche Identifikationsnummer",
-  abbreviation: "IdNr",
-  aliases: [
-    "Steuerliche Identifikationsnummer",
-    "IdNr",
-    "Steuer-ID",
-  ] as const,
-  candidatePattern: "\\d{2}\\s?\\d{3}\\s?\\d{3}\\s?\\d{3}",
-  scope: "country",
-  country: "DE",
-  entityType: "person",
-  sourceUrl:
-    "https://www.bzst.de/DE/Privatpersonen/SteuerlicheIdentifikationsnummer/steuerlicheidentifikationsnummer_node.html",
-  examples: ["36574261809"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default idnr;
-export { compact, format, validate, generate };

package/src/de/mod.ts

@@ -1,5 +0,0 @@
-export { default as handelsreg } from "./handelsreg";
-export { default as idnr } from "./idnr";
-export { default as stnr } from "./stnr";
-export { default as svnr } from "./svnr";
-export { default as vat } from "./vat";

package/src/de/stnr.ts

@@ -1,222 +0,0 @@
-/**
- * Generate a random valid Steuernummer.
- * Uses Berlin regional format (FFBBBUUUUP, 10 digits).
- */
-const generate = (): string => {
-  const ff = randomDigits(2);
-  const bbb = randomDigits(3);
-  const uuuu = randomDigits(4);
-  const p = randomDigits(1);
-  return `${ff}${bbb}${uuuu}${p}`;
-};
-
-/**
- * StNr (Steuernummer).
- *
- * German tax number assigned by the local tax office.
- * Regional format: 10 or 11 digits. Unified federal
- * format: 13 digits (prefixed with a 2–4 digit BUFA
- * code). Structure varies by federal state.
- *
- * The number encodes: BUFA (Bundesfinanzamtsnummer),
- * district code, serial number, and check digit. No
- * algorithmic check digit validation is standardised
- * across all states; validation is format-only.
- *
- * @see https://de.wikipedia.org/wiki/Steuernummer
- */
-
-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";
-
-/**
- * Format patterns per federal state.
- * [0] = regional format, [1] = unified (federal) format.
- *
- * Legend: F = finance office, B = district,
- *         U = serial, P = check digit,
- *         leading digits are literal.
- */
-const STATES = {
-  "Baden-Württemberg": ["FFBBBUUUUP", "28FF0BBBUUUUP"],
-  Bayern: ["FFFBBBUUUUP", "9FFF0BBBUUUUP"],
-  Berlin: ["FFBBBUUUUP", "11FF0BBBUUUUP"],
-  Brandenburg: ["0FFBBBUUUUP", "30FF0BBBUUUUP"],
-  Bremen: ["FFBBBUUUUP", "24FF0BBBUUUUP"],
-  Hamburg: ["FFBBBUUUUP", "22FF0BBBUUUUP"],
-  Hessen: ["0FFBBBUUUUP", "26FF0BBBUUUUP"],
-  "Mecklenburg-Vorpommern": [
-    "0FFBBBUUUUP",
-    "40FF0BBBUUUUP",
-  ],
-  Niedersachsen: ["FFBBBUUUUP", "23FF0BBBUUUUP"],
-  "Nordrhein-Westfalen": ["FFFBBBBUUUP", "5FFF0BBBBUUUP"],
-  "Rheinland-Pfalz": ["FFBBBUUUUP", "27FF0BBBUUUUP"],
-  Saarland: ["0FFBBBUUUUP", "10FF0BBBUUUUP"],
-  Sachsen: ["2FFBBBUUUUP", "32FF0BBBUUUUP"],
-  "Sachsen-Anhalt": ["1FFBBBUUUUP", "31FF0BBBUUUUP"],
-  "Schleswig-Holstein": ["FFBBBUUUUP", "21FF0BBBUUUUP"],
-  Thüringen: ["1FFBBBUUUUP", "41FF0BBBUUUUP"],
-} as const;
-
-type StateName = keyof typeof STATES;
-
-/**
- * Convert a format pattern to a regex.
- * Literal digits match themselves; F/B/U match any
- * digit; P (check digit) matches any digit.
- */
-const patternToRegex = (pattern: string): RegExp => {
-  let re = "^";
-  for (const ch of pattern) {
-    if (ch >= "0" && ch <= "9") {
-      re += ch;
-    } else {
-      re += "\\d";
-    }
-  }
-  re += "$";
-  return new RegExp(re);
-};
-
-/** Pre-compiled regexes for each state + format. */
-const COMPILED: Array<{
-  state: StateName;
-  regional: RegExp;
-  regionalFmt: string;
-  federal: RegExp;
-  federalFmt: string;
-}> = (
-  Object.entries(STATES) as Array<
-    [StateName, readonly [string, string]]
-  >
-).map(([state, [regionalFmt, federalFmt]]) => ({
-  state,
-  regional: patternToRegex(regionalFmt),
-  regionalFmt,
-  federal: patternToRegex(federalFmt),
-  federalFmt,
-}));
-
-const compact = (value: string): string =>
-  clean(value, " -/.");
-
-const matchesAnyPattern = (v: string): boolean => {
-  for (const { regional, federal } of COMPILED) {
-    if (regional.test(v) || federal.test(v)) return true;
-  }
-  return false;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-
-  if (!isdigits(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "German Steuernummer must contain only digits",
-    );
-  }
-
-  if (
-    v.length !== 10 &&
-    v.length !== 11 &&
-    v.length !== 13
-  ) {
-    return err(
-      "INVALID_LENGTH",
-      "German Steuernummer must be 10, 11, or 13 digits",
-    );
-  }
-
-  if (!matchesAnyPattern(v)) {
-    return err(
-      "INVALID_COMPONENT",
-      "German Steuernummer does not match any " +
-        "known state format",
-    );
-  }
-
-  return { valid: true, compact: v };
-};
-
-/**
- * Format with slashes at segment boundaries.
- * Uses the first matching state pattern to determine
- * segment positions.
- */
-const format = (value: string): string => {
-  const v = compact(value);
-
-  for (const entry of COMPILED) {
-    const pattern =
-      v.length === 13 ? entry.federal : entry.regional;
-    if (!pattern.test(v)) continue;
-
-    const fmt =
-      v.length === 13
-        ? entry.federalFmt
-        : entry.regionalFmt;
-
-    // Group by consecutive runs of the same letter
-    // category: literal digits, F, B, U, P
-    const segments: string[] = [];
-    let segStart = 0;
-    // SAFETY: fmt is a non-empty literal from COMPILED.
-    // eslint-disable-next-line no-non-null-assertion
-    let prevCat = charCat(fmt[0]!);
-
-    for (let i = 1; i < fmt.length; i++) {
-      // SAFETY: i < fmt.length.
-      // eslint-disable-next-line no-non-null-assertion
-      const cat = charCat(fmt[i]!);
-      if (cat !== prevCat) {
-        segments.push(v.slice(segStart, i));
-        segStart = i;
-        prevCat = cat;
-      }
-    }
-    segments.push(v.slice(segStart));
-
-    return segments.join("/");
-  }
-
-  return v;
-};
-
-const charCat = (ch: string): string => {
-  if (ch >= "0" && ch <= "9") return "L"; // literal
-  return ch; // F, B, U, P
-};
-
-/** German Tax Number (Steuernummer). */
-const stnr: CountryValidator<"DE"> = {
-  name: "German Tax Number",
-  localName: "Steuernummer",
-  abbreviation: "StNr",
-  aliases: ["Steuernummer", "St.Nr."] as const,
-  candidatePattern: "\\d{2,4}/\\d{3,4}/\\d{4,5}",
-  scope: "country",
-  country: "DE",
-  entityType: "any",
-  description:
-    "German tax number assigned by the local " +
-    "tax office, varies by federal state",
-  sourceUrl: "https://de.wikipedia.org/wiki/Steuernummer",
-  lengths: [10, 11, 13] as const,
-  examples: ["2181508150", "18181508155"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default stnr;
-export { compact, format, validate, generate };