@stll/stdnum 0.0.1

package/src/lk/nic.ts

@@ -0,0 +1,210 @@
+/**
+ * NIC (National Identity Card, ජාතික හැඳුනුම්පත).
+ *
+ * Sri Lankan personal identity number. Two formats:
+ *   Old (pre-2016): 9 digits + V or X (10 chars)
+ *   New (2016+):    12 digits
+ *
+ * Both encode birth date (day-of-year), gender, a
+ * serial number, and a check digit.
+ *
+ * @see https://en.wikipedia.org/wiki/National_identification_number#Sri_Lanka
+ * @see https://drp.gov.lk/Templates/Artical%20-%20English%20new%20number.html
+ */
+
+import { clean } from "#util/clean";
+import { isValidDate } from "#util/date";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type {
+  ParsedPersonId,
+  ValidateResult,
+  Validator,
+} from "../types";
+
+/** Old format: 9 digits + V or X (case-insensitive). */
+const OLD_RE = /^\d{9}[VvXx]$/;
+
+/** New format: exactly 12 digits. */
+const NEW_RE = /^\d{12}$/;
+
+const compact = (value: string): string =>
+  clean(value, " -").toUpperCase();
+
+/**
+ * Convert an old-format NIC to the 12-digit new
+ * format for uniform validation.
+ *
+ * Old: YY DDD SSS C V/X  (10 chars)
+ * New: 19YY DDD 0SSS C   (12 digits)
+ */
+const toNewFormat = (v: string): string => {
+  const yy = v.slice(0, 2);
+  const ddd = v.slice(2, 5);
+  const sss = v.slice(5, 8);
+  const check = v[8];
+  return `19${yy}${ddd}0${sss}${check}`;
+};
+
+/**
+ * Checksum weights for the first 11 digits.
+ * Algorithm: weighted sum mod 11, then mod 10
+ * if >= 10.
+ */
+const CHECK_WEIGHTS = [
+  8, 4, 3, 2, 7, 6, 5, 7, 4, 3, 2,
+] as const;
+
+const checkDigit = (digits: string): number => {
+  let sum = 0;
+  for (let i = 0; i < 11; i++) {
+    sum +=
+      (CHECK_WEIGHTS[i] ?? 0) * Number(digits.charAt(i));
+  }
+  const d = 11 - (sum % 11);
+  return d > 9 ? d % 10 : d;
+};
+
+/**
+ * Resolve birth date and gender from the 12-digit
+ * normalised form (YYYY DDD ...).
+ *
+ * Day-of-year encoding:
+ *   Male:   1–366
+ *   Female: 501–866 (subtract 500)
+ */
+const resolveBirthInfo = (
+  v: string,
+): {
+  year: number;
+  month: number;
+  day: number;
+  gender: "male" | "female";
+} | null => {
+  const year = Number(v.slice(0, 4));
+  let days = Number(v.slice(4, 7));
+
+  const gender: "male" | "female" =
+    days > 500 ? "female" : "male";
+  if (days > 500) days -= 500;
+
+  if (days < 1 || days > 366) return null;
+
+  // Convert day-of-year to month/day via Date
+  const d = new Date(year, 0, days);
+  const month = d.getMonth() + 1;
+  const dayOfMonth = d.getDate();
+
+  if (!isValidDate(year, month, dayOfMonth)) {
+    return null;
+  }
+
+  // Guard against day 366 in non-leap years
+  if (d.getFullYear() !== year) return null;
+
+  return { year, month, day: dayOfMonth, gender };
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  const isOld = OLD_RE.test(v);
+  const isNew = NEW_RE.test(v);
+
+  if (!isOld && !isNew) {
+    if (v.length !== 10 && v.length !== 12) {
+      return err(
+        "INVALID_LENGTH",
+        "NIC must be 10 (old) or 12 (new) characters",
+      );
+    }
+    return err(
+      "INVALID_FORMAT",
+      "NIC must be 9 digits + V/X (old) or" +
+        " 12 digits (new)",
+    );
+  }
+
+  const normalized = isOld ? toNewFormat(v) : v;
+
+  if (!isdigits(normalized)) {
+    return err(
+      "INVALID_FORMAT",
+      "NIC contains invalid characters",
+    );
+  }
+
+  if (resolveBirthInfo(normalized) === null) {
+    return err(
+      "INVALID_COMPONENT",
+      "NIC contains an invalid date of birth",
+    );
+  }
+
+  const expected = checkDigit(normalized.slice(0, 11));
+  if (expected !== Number(normalized[11])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "NIC check digit does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  // Old format: YYDDDSSSXV → no standard separator
+  // New format: YYYYDDDSSSSC → no standard separator
+  return v;
+};
+
+/**
+ * Extract birth date and gender from an NIC.
+ * 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 isOld = OLD_RE.test(v);
+  const normalized = isOld ? toNewFormat(v) : v;
+
+  const info = resolveBirthInfo(normalized);
+  if (info === null) return null;
+
+  return {
+    birthDate: new Date(
+      info.year,
+      info.month - 1,
+      info.day,
+    ),
+    gender: info.gender,
+  };
+};
+
+/** Sri Lankan National Identity Card. */
+const nic: Validator = {
+  name: "National Identity Card",
+  localName: "ජාතික හැඳුනුම්පත",
+  abbreviation: "NIC",
+  aliases: ["NIC", "ජාතික හැඳුනුම්පත"] as const,
+  candidatePattern: "\\d{9}[VXvx]|\\d{12}",
+  country: "LK",
+  entityType: "person",
+  description:
+    "Sri Lankan personal identity number issued to" +
+    " all citizens",
+  sourceUrl:
+    "https://en.wikipedia.org/wiki/" +
+    "National_identification_number#Sri_Lanka",
+  lengths: [10, 12] as const,
+  examples: ["197819202757", "862348753V"] as const,
+  compact,
+  format,
+  validate,
+};
+
+export default nic;
+export { compact, format, parse, validate };

package/src/lt/asmens.ts

@@ -0,0 +1,120 @@
+/**
+ * Asmens kodas (Personal Code).
+ *
+ * Lithuanian personal identification number. 11 digits
+ * with the same structure as the Estonian Isikukood:
+ * gender/century digit, YYMMDD, 3-digit serial, and
+ * a two-pass weighted checksum.
+ *
+ * @see https://www.oecd.org/content/dam/oecd/en/topics/policy-issue-focus/aeoi/lithuania-tin.pdf
+ * @see https://www.registrucentras.lt/
+ */
+
+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";
+
+import { twoPassCheck } from "../ee/ik";
+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 !== 11) {
+    return err(
+      "INVALID_LENGTH",
+      "Asmens kodas must be exactly 11 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Asmens kodas must contain only digits",
+    );
+  }
+
+  const g = Number(v[0]);
+  if (g < 1 || g > 9) {
+    return err(
+      "INVALID_COMPONENT",
+      "Asmens kodas gender/century digit is invalid",
+    );
+  }
+
+  // Digit 9 indicates a special case where the birth
+  // date is not encoded; skip date validation.
+  if (g !== 9) {
+    const centuryMap: Record<number, number> = {
+      1: 1800,
+      2: 1800,
+      3: 1900,
+      4: 1900,
+      5: 2000,
+      6: 2000,
+      7: 2100,
+      8: 2100,
+    };
+    const century = centuryMap[g] ?? 1900;
+    const yy = Number(v.slice(1, 3));
+    const mm = Number(v.slice(3, 5));
+    const dd = Number(v.slice(5, 7));
+    const year = century + yy;
+
+    if (!isValidDate(year, mm, dd)) {
+      return err(
+        "INVALID_COMPONENT",
+        "Asmens kodas contains an invalid date",
+      );
+    }
+  }
+
+  const check = twoPassCheck(v.slice(0, 10));
+  if (check !== Number(v[10])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Asmens kodas check digit does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid Lithuanian personal code. */
+const generate = (): string => {
+  for (;;) {
+    const g = String(randomInt(3, 6));
+    const yy = String(randomInt(0, 99)).padStart(2, "0");
+    const mm = String(randomInt(1, 12)).padStart(2, "0");
+    const dd = String(randomInt(1, 28)).padStart(2, "0");
+    const s = String(randomInt(0, 999)).padStart(3, "0");
+    const payload = g + yy + mm + dd + s;
+    const c = payload + String(twoPassCheck(payload));
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Lithuanian Personal Code. */
+const asmens: Validator = {
+  name: "Lithuanian Personal ID",
+  localName: "Asmens kodas",
+  abbreviation: "AK",
+  aliases: ["asmens kodas", "AK"] as const,
+  candidatePattern: "[3-6]\\d{10}",
+  country: "LT",
+  entityType: "person",
+  sourceUrl: "https://www.registrucentras.lt/",
+  examples: ["33309240064"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default asmens;
+export { compact, format, validate, generate };

package/src/lt/mod.ts

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

package/src/lt/vat.ts

@@ -0,0 +1,109 @@
+/**
+ * PVM kodas (Lithuanian VAT number).
+ *
+ * 9 or 12 digits. 9-digit: d[7] must be 1.
+ * 12-digit: d[10] must be 1. Weighted checksum
+ * with fallback weights.
+ *
+ * @see https://www.vatify.eu/lithuania-vat-number.html
+ * @see https://www.vmi.lt/
+ */
+
+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 => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("LT") || v.startsWith("lt")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const checksum = (v: string): boolean => {
+  const n = v.length;
+  let check = 0;
+  for (let i = 0; i < n - 1; i++) {
+    check += (1 + (i % 9)) * Number(v[i]);
+  }
+  check %= 11;
+  if (check === 10) {
+    check = 0;
+    for (let i = 0; i < n - 1; i++) {
+      check += (1 + ((i + 2) % 9)) * Number(v[i]);
+    }
+    check %= 11;
+  }
+  return check % 10 === Number(v[n - 1]);
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 9 && v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "Lithuanian VAT number must be 9 or 12 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Lithuanian VAT number must contain only digits",
+    );
+  }
+  // Check the marker digit
+  if (v.length === 9 && v[7] !== "1") {
+    return err(
+      "INVALID_COMPONENT",
+      "Lithuanian 9-digit VAT: digit 8 must be 1",
+    );
+  }
+  if (v.length === 12 && v[10] !== "1") {
+    return err(
+      "INVALID_COMPONENT",
+      "Lithuanian 12-digit VAT: digit 11 must be 1",
+    );
+  }
+  if (!checksum(v)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Lithuanian VAT number check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `LT${compact(value)}`;
+
+/** Generate a random valid Lithuanian VAT number. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(9);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Lithuanian VAT Number. */
+const vat: Validator = {
+  name: "Lithuanian VAT Number",
+  localName: "PVM mokėtojo kodas",
+  abbreviation: "PVM kodas",
+  aliases: ["PVM mokėtojo kodas", "PVM"] as const,
+  candidatePattern: "LT\\d{9,12}",
+  country: "LT",
+  entityType: "any",
+  sourceUrl: "https://www.vmi.lt/",
+  examples: ["119511515", "100001919017"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/lu/mod.ts

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

package/src/lu/vat.ts

@@ -0,0 +1,80 @@
+/**
+ * TVA (Luxembourg VAT number).
+ *
+ * 8 digits. First 6 digits mod 89 === last 2 digits.
+ *
+ * @see https://www.vatify.eu/luxembourg-vat-number.html
+ * @see https://www.oecd.org/content/dam/oecd/en/topics/policy-issue-focus/aeoi/luxembourg-tin.pdf
+ */
+
+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 => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("LU") || v.startsWith("lu")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 8) {
+    return err(
+      "INVALID_LENGTH",
+      "Luxembourg VAT number must be 8 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Luxembourg VAT number must contain only digits",
+    );
+  }
+  const front = Number.parseInt(v.slice(0, 6), 10);
+  const check = Number.parseInt(v.slice(6, 8), 10);
+  if (front % 89 !== check) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Luxembourg VAT number check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `LU${compact(value)}`;
+
+/** Generate a random valid Luxembourg VAT number. */
+const generate = (): string => {
+  const body = randomDigits(6);
+  return (
+    body +
+    String(Number.parseInt(body, 10) % 89).padStart(2, "0")
+  );
+};
+
+/** Luxembourg VAT Number. */
+const vat: Validator = {
+  name: "Luxembourg VAT Number",
+  localName: "Numéro de TVA",
+  abbreviation: "TVA",
+  aliases: ["TVA", "numéro d'identification TVA"] as const,
+  candidatePattern: "LU\\d{8}",
+  country: "LU",
+  entityType: "company",
+  sourceUrl: "https://pfi.public.lu/",
+  examples: ["15027442"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/luhn.ts

@@ -0,0 +1,72 @@
+/**
+ * Generic Luhn checksum validation.
+ *
+ * Validates any digit string using the Luhn
+ * algorithm (ISO/IEC 7812-1). No length
+ * restriction. For credit card validation
+ * (13-19 digits), use `creditcard` instead.
+ */
+
+import {
+  luhnChecksum,
+  luhnValidate,
+} 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, " -.");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length < 1) {
+    return err("INVALID_LENGTH", "Value must not be empty");
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Value must contain only digits",
+    );
+  }
+  if (!luhnValidate(v)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Luhn check digit does not match",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/**
+ * Generate a random Luhn-valid number of the
+ * given length (default 16).
+ */
+const generate = (length = 16): string => {
+  const payload = randomDigits(length - 1);
+  const partial = `${payload}0`;
+  const remainder = luhnChecksum(partial);
+  const check = (10 - remainder) % 10;
+  return `${payload}${String(check)}`;
+};
+
+/** Generic Luhn Validator. */
+const luhn: Validator = {
+  name: "Luhn",
+  localName: "Luhn",
+  abbreviation: "Luhn",
+  entityType: "any",
+  examples: ["4111111111111111", "18"] as const,
+  compact,
+  format,
+  validate,
+  generate: () => generate(),
+};
+
+export default luhn;
+export { compact, format, generate, validate };

package/src/lv/mod.ts

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