@stll/stdnum 2.1.0 → 2.1.2

package/src/mx/rfc.ts

@@ -1,179 +0,0 @@
-/**
- * RFC (Registro Federal de Contribuyentes).
- *
- * Mexican tax identification number issued by the SAT
- * (Servicio de Administración Tributaria). The number is
- * 13 characters for individuals (4 letters + 6 digits
- * YYMMDD + 3 alphanumeric) or 12 characters for
- * companies (3 letters + 6 digits YYMMDD + 3
- * alphanumeric). The last character is a check digit
- * computed with a mod 11 algorithm over a specific
- * alphabet mapping.
- *
- * Format: AAAA######XXX (persons, 13 chars)
- *         AAA######XXX  (companies, 12 chars)
- *
- * @see https://en.wikipedia.org/wiki/Tax_Identification_Number_(Mexico)
- */
-
-import type {
-  ValidateResult,
-  CountryValidator,
-} from "../types";
-
-import { clean } from "#util/clean";
-import { isValidDate } from "#util/date";
-import { randomInt } from "#util/generate";
-import { err } from "#util/result";
-
-/** Alphabet for RFC check digit computation. */
-const ALPHABET = "0123456789ABCDEFGHIJKLMN&OPQRSTUVWXYZ Ñ";
-
-const CHAR_MAP = new Map<string, number>();
-for (const [i, ch] of ALPHABET.split("").entries()) {
-  CHAR_MAP.set(ch, i);
-}
-
-const compact = (value: string): string =>
-  clean(value, " -.").trim().toUpperCase();
-
-/**
- * Compute the RFC check digit using mod 11 with
- * the SAT alphabet mapping.
- *
- * Each character is mapped to its position in the
- * ALPHABET, then multiplied by a weight that starts
- * at (len + 1) and decreases by 1. The check digit
- * is (11 - sum % 11) % 11, mapped to 0-9 or "A".
- */
-const calcCheckDigit = (value: string): string => {
-  // Pad 12-char company RFCs with a leading space
-  // to align weights with the 13-char algorithm.
-  const padded = value.length === 11 ? ` ${value}` : value;
-  let sum = 0;
-  for (let i = 0; i < 12; i++) {
-    const ch = padded[i];
-    if (ch === undefined) continue;
-    const v = CHAR_MAP.get(ch) ?? 0;
-    sum += v * (13 - i);
-  }
-  const remainder = sum % 11;
-  if (remainder === 0) return "0";
-  const digit = 11 - remainder;
-  return digit === 10 ? "A" : String(digit);
-};
-
-const PERSON_RE = /^[A-ZÑ&]{4}\d{6}[A-Z\d]{3}$/;
-const COMPANY_RE = /^[A-ZÑ&]{3}\d{6}[A-Z\d]{3}$/;
-const PREFIX_ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZÑ&";
-const RFC_ALNUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-
-  if (v.length !== 12 && v.length !== 13) {
-    return err(
-      "INVALID_LENGTH",
-      "RFC must be 12 or 13 characters",
-    );
-  }
-
-  const isPerson = v.length === 13;
-  const re = isPerson ? PERSON_RE : COMPANY_RE;
-  if (!re.test(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "RFC has an invalid format",
-    );
-  }
-
-  // Validate the embedded date (YYMMDD).
-  const dateOffset = isPerson ? 4 : 3;
-  const yy = Number(v.slice(dateOffset, dateOffset + 2));
-  const mm = Number(
-    v.slice(dateOffset + 2, dateOffset + 4),
-  );
-  const dd = Number(
-    v.slice(dateOffset + 4, dateOffset + 6),
-  );
-
-  // RFC dates use 2-digit years; use 2000 century for
-  // date validation (any valid calendar date is accepted).
-  const year = 2000 + yy;
-  if (!isValidDate(year, mm, dd)) {
-    return err(
-      "INVALID_COMPONENT",
-      "RFC contains an invalid date",
-    );
-  }
-
-  // Verify check digit (last character).
-  const body = v.slice(0, -1);
-  const expected = calcCheckDigit(body);
-  if (v.at(-1) !== expected) {
-    return err(
-      "INVALID_CHECKSUM",
-      "RFC check digit does not match",
-    );
-  }
-
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => compact(value);
-
-const randomCharFrom = (chars: string): string =>
-  chars.charAt(randomInt(0, chars.length - 1));
-
-/** Generate a random valid RFC. */
-const generate = (): string => {
-  const isPerson = Math.random() < 0.5;
-  const prefixLength = isPerson ? 4 : 3;
-  let prefix = "";
-  for (let i = 0; i < prefixLength; i++) {
-    prefix += randomCharFrom(PREFIX_ALPHA);
-  }
-
-  const year = randomInt(2000, 2099);
-  const month = String(randomInt(1, 12)).padStart(2, "0");
-  const day = String(randomInt(1, 28)).padStart(2, "0");
-  let homoclave = "";
-  for (let i = 0; i < 2; i++) {
-    homoclave += randomCharFrom(RFC_ALNUM);
-  }
-
-  const body =
-    `${prefix}${String(year % 100).padStart(2, "0")}` +
-    `${month}${day}${homoclave}`;
-  return `${body}${calcCheckDigit(body)}`;
-};
-
-/**
- * Mexican RFC (tax identification number).
- *
- * Examples sourced from python-stdnum test suite.
- */
-const rfc: CountryValidator<"MX"> = {
-  name: "Mexican Tax ID",
-  localName: "Registro Federal de Contribuyentes",
-  abbreviation: "RFC",
-  aliases: [
-    "RFC",
-    "Registro Federal de Contribuyentes",
-  ] as const,
-  candidatePattern: "[A-ZÑ&]{3,4}\\d{6}[A-Z\\d]{3}",
-  scope: "country",
-  country: "MX",
-  entityType: "any",
-  lengths: [12, 13] as const,
-  examples: ["GODE561231GR8", "MAB9307148T4"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-  sourceUrl:
-    "https://en.wikipedia.org/wiki/Tax_Identification_Number_(Mexico)",
-};
-
-export default rfc;
-export { compact, format, generate, validate };

package/src/my/mod.ts

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

package/src/my/nric.ts

@@ -1,260 +0,0 @@
-/**
- * NRIC (Malaysian National Registration Identity
- * Card Number, Nombor Kad Pengenalan).
- *
- * 12 digits: YYMMDD (birth date) + PB (place of
- * birth, 2 digits) + SSS (serial) + G (gender:
- * odd = male, even = female).
- *
- * No checksum; validation is structural (valid date
- * and valid place-of-birth code).
- *
- * @see https://en.wikipedia.org/wiki/Malaysian_identity_card
- */
-
-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";
-
-/**
- * Valid place-of-birth codes (2-digit).
- * Codes 01-16 are states, 21-59 are pre-2000
- * state codes, 60-68 born outside (ASEAN),
- * 71-72/74-79 foreign nationals, 82-93 regions,
- * 98-99 legacy.
- */
-const VALID_PB_CODES = new Set([
-  "01",
-  "02",
-  "03",
-  "04",
-  "05",
-  "06",
-  "07",
-  "08",
-  "09",
-  "10",
-  "11",
-  "12",
-  "13",
-  "14",
-  "15",
-  "16",
-  "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",
-  "53",
-  "54",
-  "55",
-  "56",
-  "57",
-  "58",
-  "59",
-  "60",
-  "61",
-  "62",
-  "63",
-  "64",
-  "65",
-  "66",
-  "67",
-  "68",
-  "71",
-  "72",
-  "74",
-  "75",
-  "76",
-  "77",
-  "78",
-  "79",
-  "82",
-  "83",
-  "84",
-  "85",
-  "86",
-  "87",
-  "88",
-  "89",
-  "90",
-  "91",
-  "92",
-  "93",
-  "98",
-  "99",
-]);
-
-const compact = (value: string): string =>
-  clean(value, " -");
-
-/**
- * Resolve the birth year from a 2-digit year.
- * Years after the reference year are assumed to be
- * in the previous century. Accepts an explicit
- * reference year to avoid multiple clock reads.
- */
-const resolveYear = (
-  yy: number,
-  referenceYear: number,
-): number => {
-  const century = Math.floor(referenceYear / 100);
-  const year = century * 100 + yy;
-  return year > referenceYear ? year - 100 : year;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length !== 12) {
-    return err(
-      "INVALID_LENGTH",
-      "NRIC must be exactly 12 digits",
-    );
-  }
-  if (!isdigits(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "NRIC must contain only digits",
-    );
-  }
-
-  // Validate birth date (YYMMDD)
-  const yy = Number(v.slice(0, 2));
-  const mm = Number(v.slice(2, 4));
-  const dd = Number(v.slice(4, 6));
-
-  const now = new Date().getFullYear();
-  const year = resolveYear(yy, now);
-
-  if (!isValidDate(year, mm, dd)) {
-    return err(
-      "INVALID_COMPONENT",
-      "NRIC contains an invalid birth date",
-    );
-  }
-
-  // Validate place-of-birth code
-  const pb = v.slice(6, 8);
-  if (!VALID_PB_CODES.has(pb)) {
-    return err(
-      "INVALID_COMPONENT",
-      "Invalid place-of-birth code: " + pb,
-    );
-  }
-
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => {
-  const v = compact(value);
-  return (
-    v.slice(0, 6) + "-" + v.slice(6, 8) + "-" + v.slice(8)
-  );
-};
-
-/**
- * Extract birth date and gender from an NRIC.
- * 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 now = new Date().getFullYear();
-  const year = resolveYear(yy, now);
-
-  // Last digit: odd = male, even = female
-  const lastDigit = Number(v[11]);
-  const gender = lastDigit % 2 === 1 ? "male" : "female";
-
-  return {
-    birthDate: new Date(year, mm - 1, dd),
-    gender,
-  };
-};
-
-const PB_CODES = [...VALID_PB_CODES];
-
-/** Generate a random valid Malaysian NRIC. */
-const generate = (): string => {
-  const year = randomInt(1950, 2024);
-  const month = String(randomInt(1, 12)).padStart(2, "0");
-  const day = String(randomInt(1, 28)).padStart(2, "0");
-  const pb =
-    PB_CODES[randomInt(0, PB_CODES.length - 1)] ?? "01";
-  const serial = String(randomInt(0, 999)).padStart(3, "0");
-  const isMale = Math.random() < 0.5;
-  const lastDigit = isMale
-    ? String(randomInt(0, 4) * 2 + 1)
-    : String(randomInt(0, 4) * 2);
-
-  return (
-    `${String(year % 100).padStart(2, "0")}` +
-    `${month}${day}${pb}${serial}${lastDigit}`
-  );
-};
-
-/** Malaysian National Registration Identity Card. */
-const nric: CountryValidator<"MY", ParsedPersonId> = {
-  name: "Malaysian National Registration Identity Card Number",
-  localName: "Nombor Kad Pengenalan",
-  abbreviation: "NRIC",
-  aliases: ["NRIC", "MyKad", "kad pengenalan"] as const,
-  candidatePattern: "\\d{6}-?\\d{2}-?\\d{4}",
-  scope: "country",
-  country: "MY",
-  entityType: "person",
-  description:
-    "12-digit identity card number encoding birth date, place of birth, and gender",
-  sourceUrl:
-    "https://en.wikipedia.org/wiki/Malaysian_identity_card",
-  lengths: [12] as const,
-  examples: ["770305021234", "880715141234"] as const,
-  compact,
-  format,
-  parse,
-  validate,
-  generate,
-};
-
-export default nric;
-export { compact, format, generate, parse, validate };

package/src/ng/mod.ts

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

package/src/ng/nin.ts

@@ -1,76 +0,0 @@
-/** Generate a random valid Nigerian NIN. */
-const generate = (): string => randomDigits(11);
-
-/**
- * NIN (National Identification Number, Nigeria).
- *
- * 11-digit number randomly assigned by NIMC (National
- * Identity Management Commission). No checksum; the
- * digits are non-intelligible and carry no embedded
- * meaning. Once assigned, a NIN is permanent and
- * cannot be reassigned.
- *
- * @see https://nimc.gov.ng/about-nin/
- */
-
-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 compact = (value: string): string =>
-  clean(value, " -");
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length !== 11) {
-    return err(
-      "INVALID_LENGTH",
-      "Nigerian NIN must be 11 digits",
-    );
-  }
-  if (!isdigits(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "Nigerian NIN must contain only digits",
-    );
-  }
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => {
-  const v = compact(value);
-  return `${v.slice(0, 3)} ${v.slice(3, 7)} ${v.slice(7)}`;
-};
-
-/** Nigerian National Identification Number. */
-const nin: CountryValidator<"NG"> = {
-  name: "National Identification Number",
-  localName: "National Identification Number",
-  abbreviation: "NIN",
-  aliases: [
-    "NIN",
-    "National Identification Number",
-  ] as const,
-  candidatePattern: "\\d{11}",
-  scope: "country",
-  country: "NG",
-  entityType: "person",
-  lengths: [11] as const,
-  examples: ["13478900989", "70123456789"] as const,
-  description:
-    "11-digit national identity number issued by NIMC",
-  sourceUrl: "https://nimc.gov.ng/about-nin/",
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default nin;
-export { compact, format, validate, generate };

package/src/ni/mod.ts

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

package/src/ni/ruc.ts

@@ -1,180 +0,0 @@
-/**
- * RUC (Registro Único de Contribuyente, Nicaragua
- * tax number).
- *
- * For natural persons the RUC is the cédula de
- * identidad: 14 characters structured as
- * MMM-DDMMYY-NNNNL where:
- *   - MMM  = municipality code (001–999)
- *   - DDMMYY = birth date
- *   - NNNN = sequential number
- *   - L = check letter (mod 23, ISO 7064)
- *
- * For legal entities (Personas Jurídicas) the RUC
- * starts with "J" followed by 13 digits. No public
- * check-digit algorithm is documented for the "J"
- * format, so validation is format-only.
- *
- * The check letter for natural persons uses modulo 23
- * with a 23-letter alphabet that excludes I, O, and Z
- * to avoid confusion with digits.
- *
- * @see https://www.dgi.gob.ni/
- */
-
-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";
-
-/**
- * Check letter alphabet (mod 23). Excludes I, O, Z
- * to prevent transcription errors.
- */
-const CHECK_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXY";
-
-/**
- * Compact: strip spaces, hyphens, and uppercase.
- */
-const compact = (value: string): string =>
-  clean(value, " -").trim().toUpperCase();
-
-/**
- * Validate a birth date encoded as DDMMYY.
- * Returns true if the date components are plausible.
- */
-const isValidDate = (ddmmyy: string): boolean => {
-  const day = Number(ddmmyy.slice(0, 2));
-  const month = Number(ddmmyy.slice(2, 4));
-
-  if (month < 1 || month > 12) return false;
-  if (day < 1 || day > 31) return false;
-
-  return true;
-};
-
-/**
- * Calculate the check letter for a 13-digit body
- * using modulo 23.
- */
-const calcCheckLetter = (body: string): string => {
-  let n = 0n;
-  for (const ch of body) {
-    n = n * 10n + BigInt(ch);
-  }
-  const idx = Number(n % 23n);
-  // SAFETY: idx is always 0–22 (mod 23), and
-  // CHECK_ALPHABET has exactly 23 characters.
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  return CHECK_ALPHABET[idx]!;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-
-  if (v.length !== 14) {
-    return err(
-      "INVALID_LENGTH",
-      "Nicaragua RUC must be 14 characters",
-    );
-  }
-
-  // Legal entity: starts with J + 13 digits
-  if (v[0] === "J") {
-    if (!isdigits(v.slice(1))) {
-      return err(
-        "INVALID_FORMAT",
-        "Nicaragua legal entity RUC must be " +
-          "J followed by 13 digits",
-      );
-    }
-    return { valid: true, compact: v };
-  }
-
-  // Natural person: 13 digits + 1 letter
-  const body = v.slice(0, 13);
-  // SAFETY: length is validated as exactly 14 above.
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const check = v[13]!;
-
-  if (!isdigits(body)) {
-    return err(
-      "INVALID_FORMAT",
-      "Nicaragua RUC body must contain only digits",
-    );
-  }
-
-  if (!CHECK_ALPHABET.includes(check)) {
-    return err(
-      "INVALID_FORMAT",
-      "Nicaragua RUC check letter is invalid",
-    );
-  }
-
-  // Validate date portion (positions 3–8: DDMMYY)
-  const datePart = body.slice(3, 9);
-  if (!isValidDate(datePart)) {
-    return err(
-      "INVALID_COMPONENT",
-      "Nicaragua RUC contains an invalid " + "birth date",
-    );
-  }
-
-  // Verify check letter
-  const expected = calcCheckLetter(body);
-  if (check !== expected) {
-    return err(
-      "INVALID_CHECKSUM",
-      "Nicaragua RUC check letter does not match",
-    );
-  }
-
-  return { valid: true, compact: v };
-};
-
-/**
- * Format: insert hyphens as MMM-DDMMYY-NNNNL
- * for natural persons. Legal entities are returned
- * in compact form (JNNNNNNNNNNNNN); no documented
- * segmentation exists for the J-prefix format.
- */
-const format = (value: string): string => {
-  const v = compact(value);
-  if (v[0] === "J") {
-    return `J-${v.slice(1)}`;
-  }
-  return (
-    `${v.slice(0, 3)}-${v.slice(3, 9)}` + `-${v.slice(9)}`
-  );
-};
-
-/** Generate a random valid Nicaraguan RUC (legal entity). */
-const generate = (): string => "J" + randomDigits(13);
-
-/** Nicaragua tax identification number. */
-const ruc: CountryValidator<"NI"> = {
-  name: "Tax Identification Number",
-  localName: "Registro Único de Contribuyente",
-  abbreviation: "RUC",
-  aliases: ["RUC"] as const,
-  candidatePattern: "[JKME]\\d{13}",
-  scope: "country",
-  country: "NI",
-  entityType: "any",
-  description: "Tax identifier issued by Nicaragua's DGI",
-  sourceUrl: "https://www.dgi.gob.ni/",
-  lengths: [14] as const,
-  examples: ["6071904680001F", "2811505850012D"] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default ruc;
-export { compact, format, validate, generate };