@stll/stdnum 0.0.1

package/src/ie/vat.ts

@@ -0,0 +1,138 @@
+/**
+ * VAT (Irish VAT number).
+ *
+ * 8-9 characters, complex format with old and new
+ * styles.
+ *
+ * @see https://www.vatify.eu/ireland-vat-number.html
+ * @see https://www.revenue.ie/
+ */
+
+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 ALPHABET = "WABCDEFGHIJKLMNOPQRSTUV";
+
+const compact = (value: string): string => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("IE") || v.startsWith("ie")) {
+    v = v.slice(2);
+  }
+  return v.toUpperCase();
+};
+
+const checkNew = (v: string): boolean => {
+  // New format: 7 digits + check letter + optional
+  // trailing letter (W or A-Z)
+  const trailing = v.length === 9 ? v.charAt(8) : "W";
+  let sum = 0;
+  for (let i = 0; i < 7; i++) {
+    sum += (8 - i) * Number(v.charAt(i));
+  }
+  sum += 9 * ALPHABET.indexOf(trailing);
+  const expected = ALPHABET.charAt(sum % 23);
+  return v.charAt(7) === expected;
+};
+
+const checkOld = (v: string): boolean => {
+  // Old format: digit + letter + 5 digits +
+  // check letter (8 chars total).
+  // Rearrange to 7-digit new-style layout:
+  // 0 + d[2..6] + d[0]
+  const rearranged = `0${v.slice(2, 7)}${v.charAt(0)}`;
+  let sum = 0;
+  for (let i = 0; i < 7; i++) {
+    sum += (8 - i) * Number(rearranged.charAt(i));
+  }
+  const expected = ALPHABET.charAt(sum % 23);
+  return v.charAt(7) === expected;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 8 && v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "Irish VAT number must be 8 or 9 characters",
+    );
+  }
+
+  // New format: 7 digits + letter [+ letter]
+  if (
+    isdigits(v.slice(0, 7)) &&
+    /^[A-Z]$/.test(v.charAt(7))
+  ) {
+    if (v.length === 9 && !/^[A-Z+*]$/.test(v.charAt(8))) {
+      return err(
+        "INVALID_FORMAT",
+        "Irish VAT trailing character must be a letter",
+      );
+    }
+    if (!checkNew(v)) {
+      return err(
+        "INVALID_CHECKSUM",
+        "Irish VAT number check letter mismatch",
+      );
+    }
+    return { valid: true, compact: v };
+  }
+
+  // Old format: digit + letter + 5 digits + letter
+  if (
+    v.length === 8 &&
+    /^\d$/.test(v.charAt(0)) &&
+    /^[A-Z+*]$/.test(v.charAt(1)) &&
+    isdigits(v.slice(2, 7)) &&
+    /^[A-Z]$/.test(v.charAt(7))
+  ) {
+    if (!checkOld(v)) {
+      return err(
+        "INVALID_CHECKSUM",
+        "Irish VAT number check letter mismatch",
+      );
+    }
+    return { valid: true, compact: v };
+  }
+
+  return err(
+    "INVALID_FORMAT",
+    "Irish VAT number has invalid format",
+  );
+};
+
+const format = (value: string): string =>
+  `IE${compact(value)}`;
+
+/** Generate a random valid Irish VAT number. */
+const generate = (): string => {
+  for (;;) {
+    for (let c = 65; c <= 90; c++) {
+      const cand = randomDigits(7) + String.fromCharCode(c);
+      if (validate(cand).valid) return compact(cand);
+    }
+  }
+};
+
+/** Irish VAT Number. */
+const vat: Validator = {
+  name: "Irish VAT Number",
+  localName: "Value Added Tax Number",
+  abbreviation: "VAT",
+  aliases: ["VAT number IE"] as const,
+  candidatePattern: "IE\\d[A-Z+*]\\d{5}[A-Z]",
+  country: "IE",
+  entityType: "any",
+  sourceUrl: "https://www.revenue.ie/",
+  examples: ["6433435F", "8D79739I"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/il/idnr.ts

@@ -0,0 +1,87 @@
+/**
+ * Identity Number (Mispar Zehut, מספר זהות).
+ *
+ * Israeli personal identity number. 9 digits
+ * (zero-padded) with a Luhn checksum.
+ *
+ * @see https://en.wikipedia.org/wiki/Israeli_identity_card
+ */
+
+import {
+  luhnValidate,
+  luhnChecksum,
+} from "#checksums/luhn";
+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, " -").padStart(9, "0");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length > 9) {
+    return err(
+      "INVALID_LENGTH",
+      "Israeli ID must be at most 9 digits",
+    );
+  }
+  if (!isdigits(v) || Number(v) === 0) {
+    return err(
+      "INVALID_FORMAT",
+      "Israeli ID must contain only digits" +
+        " and not be zero",
+    );
+  }
+  if (!luhnValidate(v)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Israeli ID Luhn check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, -1)}-${v.slice(-1)}`;
+};
+
+/** Generate a random valid Israeli ID number. */
+const generate = (): string => {
+  const payload = randomDigits(8);
+  const cs = luhnChecksum(payload + "0");
+  return payload + String((10 - cs) % 10);
+};
+
+/** Israeli Identity Number (Mispar Zehut). */
+const idnr: Validator = {
+  name: "Israeli Identity Number",
+  localName: "מספר זהות",
+  abbreviation: "ת.ז.",
+  aliases: [
+    "תעודת זהות",
+    "Teudat Zehut",
+    "ID number",
+  ] as const,
+  candidatePattern: "\\d{9}",
+  country: "IL",
+  entityType: "person",
+  compact,
+  format,
+  validate,
+  description:
+    "Israeli personal identification number" +
+    " (Mispar Zehut)",
+  sourceUrl:
+    "https://en.wikipedia.org/wiki/Israeli_identity_card",
+  lengths: [9] as const,
+  examples: ["039337423", "000000018"] as const,
+  generate,
+};
+
+export default idnr;
+export { compact, format, validate, generate };

package/src/il/mod.ts

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

package/src/in/aadhaar.ts

@@ -0,0 +1,96 @@
+/**
+ * Aadhaar (Indian unique identity number).
+ *
+ * 12 digits with Verhoeff checksum (last digit).
+ * Cannot start with 0 or 1.
+ * Issued by the Unique Identification Authority
+ * of India (UIDAI).
+ *
+ * @see https://en.wikipedia.org/wiki/Aadhaar
+ * @see https://uidai.gov.in/
+ */
+
+import {
+  verhoeffValidate,
+  verhoeffCheckDigit,
+} from "#checksums/verhoeff";
+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 compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "Aadhaar must be 12 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Aadhaar must contain only digits",
+    );
+  }
+  if (v[0] === "0" || v[0] === "1") {
+    return err(
+      "INVALID_COMPONENT",
+      "Aadhaar cannot start with 0 or 1",
+    );
+  }
+  // Aadhaar cannot be a palindrome
+  if (v === v.split("").reverse().join("")) {
+    return err(
+      "INVALID_FORMAT",
+      "Aadhaar cannot be a palindrome",
+    );
+  }
+  if (!verhoeffValidate(v)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Aadhaar check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 4)} ${v.slice(4, 8)} ${v.slice(8)}`;
+};
+
+/** Generate a random valid Aadhaar number. */
+const generate = (): string => {
+  const first = String(randomInt(2, 9));
+  const payload = first + randomDigits(10);
+  return payload + String(verhoeffCheckDigit(payload));
+};
+
+/** Indian Unique Identity Number. */
+const aadhaar: Validator = {
+  name: "Indian Unique Identity Number",
+  localName: "Aadhaar",
+  abbreviation: "Aadhaar",
+  aliases: ["Aadhaar", "आधार"] as const,
+  candidatePattern: "\\d{4}\\s?\\d{4}\\s?\\d{4}",
+  country: "IN",
+  entityType: "person",
+  lengths: [12],
+  examples: ["234123412346", "295274982189"],
+  description:
+    "12-digit unique identity number issued by UIDAI",
+  sourceUrl: "https://uidai.gov.in/",
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default aadhaar;
+export { compact, format, validate, generate };

package/src/in/gstin.ts

@@ -0,0 +1,169 @@
+/**
+ * GSTIN (Goods and Services Tax Identification
+ * Number, India).
+ *
+ * 15 characters: 2-digit state code + 10-char PAN +
+ * 1 entity number (1-9, A-Z) + "Z" + 1 check digit.
+ * Check digit uses the Luhn mod 36 algorithm.
+ *
+ * @see https://en.wikipedia.org/wiki/Goods_and_Services_Tax_Identification_Number
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+import { charValue } from "#util/strings";
+
+import type { ValidateResult, Validator } from "../types";
+
+const GSTIN_RE =
+  /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z][0-9A-Z]Z[0-9A-Z]$/;
+
+/** Valid Indian state/UT codes: 01-37. */
+const VALID_STATE_CODES = new Set([
+  "01",
+  "02",
+  "03",
+  "04",
+  "05",
+  "06",
+  "07",
+  "08",
+  "09",
+  "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",
+]);
+
+const BASE = 36;
+
+/**
+ * Luhn mod 36 checksum over the full GSTIN.
+ * Returns 0 for a valid number.
+ */
+const luhn36Checksum = (value: string): number => {
+  let sum = 0;
+  let double = false;
+  for (let i = value.length - 1; i >= 0; i--) {
+    let v = charValue(value[i]!);
+    if (double) {
+      v *= 2;
+      sum += Math.floor(v / BASE) + (v % BASE);
+    } else {
+      sum += v;
+    }
+    double = !double;
+  }
+  return sum % BASE;
+};
+
+const compact = (value: string): string =>
+  clean(value, " -").toUpperCase();
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 15) {
+    return err(
+      "INVALID_LENGTH",
+      "GSTIN must be 15 characters",
+    );
+  }
+  if (!GSTIN_RE.test(v)) {
+    return err("INVALID_FORMAT", "GSTIN format is invalid");
+  }
+  const stateCode = v.slice(0, 2);
+  if (!VALID_STATE_CODES.has(stateCode)) {
+    return err(
+      "INVALID_COMPONENT",
+      "GSTIN state code is invalid",
+    );
+  }
+  if (v[12] === "0") {
+    return err(
+      "INVALID_COMPONENT",
+      "GSTIN entity number cannot be 0",
+    );
+  }
+  if (luhn36Checksum(v) !== 0) {
+    return err(
+      "INVALID_CHECKSUM",
+      "GSTIN check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid GSTIN. */
+const generate = (): string => {
+  for (;;) {
+    const state = String(randomInt(1, 37)).padStart(2, "0");
+    let pan = "";
+    for (let i = 0; i < 5; i++)
+      pan += String.fromCharCode(65 + randomInt(0, 25));
+    pan +=
+      randomDigits(4) +
+      String.fromCharCode(65 + randomInt(0, 25));
+    const entity = String(randomInt(1, 9));
+    const partial = state + pan + entity + "Z";
+    for (let d = 0; d <= 9; d++) {
+      const c = partial + String(d);
+      if (validate(c).valid) return c;
+    }
+    for (let c = 65; c <= 90; c++) {
+      const cand = partial + String.fromCharCode(c);
+      if (validate(cand).valid) return cand;
+    }
+  }
+};
+
+/** Indian Goods and Services Tax ID. */
+const gstin: Validator = {
+  name: "Indian Goods and Services Tax ID",
+  localName: "Goods and Services Tax Identification Number",
+  abbreviation: "GSTIN",
+  aliases: ["GSTIN", "GST number"] as const,
+  candidatePattern:
+    "\\d{2}[A-Z]{5}\\d{4}[A-Z][A-Z\\d][Z][A-Z\\d]",
+  country: "IN",
+  entityType: "company",
+  lengths: [15],
+  examples: ["27AAPFU0939F1ZV", "29AAGCB7383J1Z4"],
+  description:
+    "15-character tax identifier for GST-registered businesses",
+  sourceUrl:
+    "https://en.wikipedia.org/wiki/Goods_and_Services_Tax_Identification_Number",
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default gstin;
+export { compact, format, validate, generate };

package/src/in/mod.ts

@@ -0,0 +1,3 @@
+export { default as aadhaar } from "./aadhaar";
+export { default as gstin } from "./gstin";
+export { default as pan } from "./pan";

package/src/in/pan.ts

@@ -0,0 +1,88 @@
+/** Generate a random valid Indian PAN. */
+const generate = (): string => {
+  const randomLetter = (): string =>
+    String.fromCodePoint(65 + randomInt(0, 25));
+  const first3 =
+    randomLetter() + randomLetter() + randomLetter();
+  const holderType =
+    HOLDER_TYPES[randomInt(0, HOLDER_TYPES.length - 1)]!;
+  const fifth = randomLetter();
+  const digits = randomDigits(4);
+  const last = randomLetter();
+  return `${first3}${holderType}${fifth}${digits}${last}`;
+};
+
+/**
+ * PAN (Permanent Account Number, Indian tax ID).
+ *
+ * 10 characters: 5 letters + 4 digits + 1 letter.
+ * The 4th letter encodes the holder type
+ * (P=person, C=company, H=HUF, A=AOP, B=BOI,
+ * G=government, J=AJP, L=local authority, F=FOP,
+ * T=trust). The 5th letter is the first letter
+ * of the surname or entity name.
+ * No checksum; format validation only.
+ *
+ * @see https://en.wikipedia.org/wiki/Permanent_account_number
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+
+const PAN_RE = /^[A-Z]{5}\d{4}[A-Z]$/;
+
+const HOLDER_TYPES = "ABCFGHJLPT";
+
+const compact = (value: string): string =>
+  clean(value, " -").toUpperCase();
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "PAN must be 10 characters",
+    );
+  }
+  if (!PAN_RE.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "PAN must be 5 letters + 4 digits + 1 letter",
+    );
+  }
+  if (!HOLDER_TYPES.includes(v[3]!)) {
+    return err(
+      "INVALID_COMPONENT",
+      "PAN 4th character must be a valid holder type",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Indian Permanent Account Number. */
+const pan: Validator = {
+  name: "Indian Permanent Account Number",
+  localName: "Permanent Account Number",
+  abbreviation: "PAN",
+  aliases: ["PAN", "Permanent Account Number"] as const,
+  candidatePattern: "[A-Z]{5}\\d{4}[A-Z]",
+  country: "IN",
+  entityType: "any",
+  lengths: [10],
+  examples: ["ABCPP1234C", "AAACR5055K"],
+  description: "10-character alphanumeric tax identifier",
+  sourceUrl:
+    "https://en.wikipedia.org/wiki/Permanent_account_number",
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default pan;
+export { compact, format, validate, generate };

package/src/index.ts

@@ -0,0 +1,116 @@
+export type {
+  CountryCode,
+  ErrorCode,
+  ParsedPersonId,
+  StdnumError,
+  ValidateResult,
+  Validator,
+} from "./types";
+export { default as bic } from "./bic";
+export {
+  default as creditcard,
+  detectNetwork,
+} from "./creditcard";
+export type { CardNetwork } from "./creditcard";
+export { default as iban } from "./iban";
+export { default as isin } from "./isin";
+export { default as lei } from "./lei";
+export { default as luhn } from "./luhn";
+
+export * as ad from "./ad/mod";
+export * as ae from "./ae/mod";
+export * as ai from "./ai/mod";
+export * as al from "./al/mod";
+export * as am from "./am/mod";
+export * as ar from "./ar/mod";
+export * as at from "./at/mod";
+export * as au from "./au/mod";
+export * as az from "./az/mod";
+export * as ba from "./ba/mod";
+export * as bd from "./bd/mod";
+export * as be from "./be/mod";
+export * as bg from "./bg/mod";
+export * as bh from "./bh/mod";
+export * as br from "./br/mod";
+export * as by from "./by/mod";
+export * as bz from "./bz/mod";
+export * as ca from "./ca/mod";
+export * as ch from "./ch/mod";
+export * as cl from "./cl/mod";
+export * as cn from "./cn/mod";
+export * as co from "./co/mod";
+export * as cr from "./cr/mod";
+export * as cu from "./cu/mod";
+export * as cy from "./cy/mod";
+export * as cz from "./cz/mod";
+export * as de from "./de/mod";
+export * as dk from "./dk/mod";
+export * as do_ from "./do/mod";
+export * as ec from "./ec/mod";
+export * as ee from "./ee/mod";
+export * as eg from "./eg/mod";
+export * as es from "./es/mod";
+export * as eu from "./eu/mod";
+export * as fi from "./fi/mod";
+export * as fr from "./fr/mod";
+export * as gb from "./gb/mod";
+export * as ge from "./ge/mod";
+export * as gh from "./gh/mod";
+export * as gr from "./gr/mod";
+export * as gt from "./gt/mod";
+export * as hk from "./hk/mod";
+export * as hr from "./hr/mod";
+export * as hu from "./hu/mod";
+export * as id from "./id/mod";
+export * as ie from "./ie/mod";
+export * as il from "./il/mod";
+export * as in_ from "./in/mod";
+export * as iq from "./iq/mod";
+export * as ir from "./ir/mod";
+export * as is_ from "./is/mod";
+export * as it from "./it/mod";
+export * as jp from "./jp/mod";
+export * as kr from "./kr/mod";
+export * as kw from "./kw/mod";
+export * as kz from "./kz/mod";
+export * as li from "./li/mod";
+export * as lk from "./lk/mod";
+export * as lt from "./lt/mod";
+export * as lu from "./lu/mod";
+export * as lv from "./lv/mod";
+export * as ma from "./ma/mod";
+export * as mc from "./mc/mod";
+export * as md from "./md/mod";
+export * as me from "./me/mod";
+export * as mk from "./mk/mod";
+export * as mt from "./mt/mod";
+export * as mu from "./mu/mod";
+export * as mx from "./mx/mod";
+export * as my from "./my/mod";
+export * as ng from "./ng/mod";
+export * as ni from "./ni/mod";
+export * as nl from "./nl/mod";
+export * as no from "./no/mod";
+export * as nz from "./nz/mod";
+export * as pa from "./pa/mod";
+export * as pe from "./pe/mod";
+export * as ph from "./ph/mod";
+export * as pk from "./pk/mod";
+export * as pl from "./pl/mod";
+export * as pt from "./pt/mod";
+export * as ro from "./ro/mod";
+export * as rs from "./rs/mod";
+export * as ru from "./ru/mod";
+export * as se from "./se/mod";
+export * as sg from "./sg/mod";
+export * as si from "./si/mod";
+export * as sk from "./sk/mod";
+export * as th from "./th/mod";
+export * as tr from "./tr/mod";
+export * as tw from "./tw/mod";
+export * as ua from "./ua/mod";
+export * as us from "./us/mod";
+export * as uy from "./uy/mod";
+export * as ve from "./ve/mod";
+export * as vn from "./vn/mod";
+export * as za from "./za/mod";

package/src/iq/mod.ts

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