@stll/stdnum 0.0.1

package/src/iq/nid.ts

@@ -0,0 +1,71 @@
+/** Generate a random valid Iraqi NID. */
+const generate = (): string => randomDigits(12);
+
+/**
+ * NID (Iraqi National ID, البطاقة الوطنية الموحدة).
+ *
+ * 12-digit personal identification number on the
+ * Iraqi National Card (Unified National Card), issued
+ * by the Ministry of Interior since 2016.
+ *
+ * No public checksum algorithm is documented.
+ * Validation is limited to format: exactly 12 decimal
+ * digits. Accepts both Arabic-Indic (U+066x) and
+ * Extended Arabic-Indic (U+06Fx) digits.
+ *
+ * @see https://mofa.gov.iq/the-civil-status-id/
+ */
+
+import { normalizeArabicDigits } from "#util/arabic";
+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 =>
+  normalizeArabicDigits(clean(value, " -./"));
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "Iraqi NID must be exactly 12 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Iraqi NID must contain only digits",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+/** Iraqi NIDs are displayed without separators. */
+const format = (value: string): string => compact(value);
+
+/** Iraqi National Identification Number. */
+const nid: Validator = {
+  name: "Iraqi National ID",
+  localName: "البطاقة الوطنية الموحدة",
+  abbreviation: "NID",
+  aliases: ["NID", "البطاقة الوطنية الموحدة"] as const,
+  candidatePattern: "\\d{12}",
+  country: "IQ",
+  entityType: "person",
+  sourceUrl: "https://mofa.gov.iq/the-civil-status-id/",
+  description:
+    "Iraqi personal identification number (National Card)",
+  lengths: [12] as const,
+  examples: ["012345678901"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default nid;
+export { compact, format, validate, generate };

package/src/ir/mod.ts

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

package/src/ir/nid.ts

@@ -0,0 +1,120 @@
+/**
+ * NID (Iranian National ID, کد ملی, Code Melli).
+ *
+ * 10-digit personal identification number assigned to
+ * every Iranian citizen. Digits 1-3 encode the province,
+ * digits 4-9 are a sequential identifier, and digit 10
+ * is a check digit.
+ *
+ * Check digit algorithm (mod 11):
+ *   sum = Σ(digit[i] × (10 − i)) for i = 0..8
+ *   r   = sum mod 11
+ *   if r < 2: check digit = r
+ *   if r ≥ 2: check digit = 11 − r
+ *
+ * Numbers where all digits are identical (e.g.
+ * 0000000000, 1111111111) are rejected.
+ *
+ * Accepts both Persian (Extended Arabic-Indic, U+06Fx)
+ * and Arabic-Indic (U+066x) digits.
+ *
+ * @see https://www.sabteahval.ir/
+ * @see https://persian-tools.js.org/functions/verifyIranianNationalId.html
+ */
+
+import { normalizeArabicDigits } from "#util/arabic";
+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";
+
+/** All-same-digit patterns (0000000000 .. 9999999999). */
+const ALL_SAME = new Set(
+  Array.from({ length: 10 }, (_, i) =>
+    String(i).repeat(10),
+  ),
+);
+
+const compact = (value: string): string =>
+  normalizeArabicDigits(clean(value, " -./"));
+
+/**
+ * Calculate the check digit from the first 9 digits.
+ */
+const calcCheckDigit = (number: string): number => {
+  let sum = 0;
+  for (let i = 0; i < 9; i++) {
+    sum += Number(number[i]) * (10 - i);
+  }
+  const r = sum % 11;
+  return r < 2 ? r : 11 - r;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Iranian NID must be exactly 10 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Iranian NID must contain only digits",
+    );
+  }
+  if (ALL_SAME.has(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Iranian NID must not have all identical digits",
+    );
+  }
+  if (calcCheckDigit(v) !== Number(v[9])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Iranian NID check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+/** Iranian NIDs are displayed without separators. */
+const format = (value: string): string => compact(value);
+
+/**
+ * Generate a random valid Iranian NID.
+ * NOT cryptographically secure.
+ */
+const generate = (): string => {
+  const base = randomDigits(9);
+  const check = calcCheckDigit(base);
+  const result = `${base}${check}`;
+  if (ALL_SAME.has(result)) return generate();
+  return result;
+};
+
+/** Iranian National Identification Number. */
+const nid: Validator = {
+  name: "Iranian National ID",
+  localName: "کد ملی",
+  abbreviation: "NID",
+  aliases: ["NID", "کد ملی", "national code"] as const,
+  candidatePattern: "\\d{10}",
+  country: "IR",
+  entityType: "person",
+  sourceUrl: "https://www.sabteahval.ir/",
+  description:
+    "Iranian personal identification number (Code Melli)",
+  lengths: [10] as const,
+  examples: ["0932833810"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default nid;
+export { compact, format, validate, generate };

package/src/is/kennitala.ts

@@ -0,0 +1,125 @@
+/**
+ * Kennitala (Icelandic identification number).
+ *
+ * 10 digits: DDMMYY + 2 random + 1 check + 1 century.
+ * Weights [3,2,7,6,5,4,3,2] on first 8 digits,
+ * check digit at position 9, century at position 10
+ * (weight 0, does not participate in checksum).
+ * Organizations use day + 40. Century digit: 9 = 1900s,
+ * 0 = 2000s.
+ *
+ * @see https://www.skra.is/
+ */
+
+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 type { ValidateResult, Validator } from "../types";
+
+const WEIGHTS = [3, 2, 7, 6, 5, 4, 3, 2, 0, 0] as const;
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Kennitala must be 10 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Kennitala must contain only digits",
+    );
+  }
+
+  // Checksum: weights on first 8 digits, check is 9th
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += Number(v.charAt(i)) * (WEIGHTS[i] ?? 0);
+  }
+  const remainder = (11 - (sum % 11)) % 11;
+  if (remainder === 10 || remainder !== Number(v[8])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Kennitala check digit mismatch",
+    );
+  }
+
+  // Parse date
+  let dd = Number(v.slice(0, 2));
+  const mm = Number(v.slice(2, 4));
+  const yy = Number(v.slice(4, 6));
+  const centuryDigit = Number(v[9]);
+
+  // Organizations use day + 40
+  if (dd > 40) dd -= 40;
+
+  let century: number;
+  if (centuryDigit === 9) {
+    century = 1900;
+  } else if (centuryDigit === 0) {
+    century = 2000;
+  } else {
+    return err(
+      "INVALID_COMPONENT",
+      "Kennitala century digit must be 0 or 9",
+    );
+  }
+
+  const year = century + yy;
+  if (!isValidDate(year, mm, dd)) {
+    return err(
+      "INVALID_COMPONENT",
+      "Kennitala contains an invalid date",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 6)}-${v.slice(6)}`;
+};
+
+/** Generate a random valid Icelandic kennitala. */
+const generate = (): string => {
+  for (;;) {
+    const dd = String(randomInt(1, 28)).padStart(2, "0");
+    const mm = String(randomInt(1, 12)).padStart(2, "0");
+    const yy = String(randomInt(50, 99)).padStart(2, "0");
+    const rr = String(randomInt(20, 99)).padStart(2, "0");
+    const partial = dd + mm + yy + rr;
+    for (let d = 0; d <= 9; d++) {
+      const c = partial + String(d) + "9";
+      if (validate(c).valid) return c;
+    }
+  }
+};
+
+/** Icelandic Identification Number. */
+const kennitala: Validator = {
+  name: "Icelandic ID Number",
+  localName: "Kennitala",
+  abbreviation: "kt.",
+  aliases: ["kennitala", "kt."] as const,
+  candidatePattern: "\\d{6}-?\\d{4}",
+  country: "IS",
+  entityType: "any",
+  sourceUrl: "https://www.skra.is/",
+  examples: ["4504013150", "1201743399"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default kennitala;
+export { compact, format, validate, generate };

package/src/is/mod.ts

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

package/src/is/vsk.ts

@@ -0,0 +1,63 @@
+/** Generate a random valid Icelandic VSK. */
+const generate = (): string => {
+  const len = randomInt(5, 6);
+  return randomDigits(len);
+};
+
+/**
+ * VSK (Virðisaukaskattur, Icelandic VAT number).
+ *
+ * 5 or 6 digits. Format-only validation, no checksum.
+ *
+ * @see https://www.rsk.is/
+ */
+
+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 !== 5 && v.length !== 6) {
+    return err(
+      "INVALID_LENGTH",
+      "Icelandic VAT must be 5 or 6 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Icelandic VAT must contain only digits",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Icelandic VAT Number. */
+const vsk: Validator = {
+  name: "Icelandic VAT Number",
+  localName: "Virðisaukaskattur",
+  abbreviation: "VSK",
+  aliases: ["VSK-númer", "virðisaukaskattur"] as const,
+  candidatePattern: "IS\\d{5,6}",
+  country: "IS",
+  entityType: "company",
+  sourceUrl: "https://www.rsk.is/",
+  examples: ["00621", "123456"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vsk;
+export { compact, format, validate, generate };

package/src/isin.ts

@@ -0,0 +1,114 @@
+/**
+ * ISIN (International Securities Identification
+ * Number).
+ *
+ * ISO 6166. 12-character alphanumeric code:
+ * [A-Z]{2} (country) + [0-9A-Z]{9} (identifier) +
+ * [0-9]{1} (check digit). Validated using the Luhn
+ * algorithm on the alpha-numeric expansion.
+ *
+ * @see https://www.isin.org/
+ */
+
+import { luhnChecksum } from "#checksums/luhn";
+import { clean } from "#util/clean";
+import { randomInt } from "#util/generate";
+import { err } from "#util/result";
+import { charValue, isalnum } from "#util/strings";
+
+import type { ValidateResult, Validator } from "./types";
+
+const ISIN_RE = /^[A-Z]{2}[0-9A-Z]{9}[0-9]$/;
+
+const compact = (value: string): string =>
+  clean(value, " -").toUpperCase();
+
+/**
+ * Expand each character to its numeric value
+ * (A=10..Z=35, digits unchanged) and concatenate.
+ */
+const expand = (value: string): string => {
+  let result = "";
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch !== undefined) {
+      result += String(charValue(ch));
+    }
+  }
+  return result;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "ISIN must be exactly 12 characters",
+    );
+  }
+  if (!isalnum(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "ISIN must contain only letters and digits",
+    );
+  }
+  if (!ISIN_RE.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "ISIN must match [A-Z]{2}[0-9A-Z]{9}[0-9]",
+    );
+  }
+  const expanded = expand(v);
+  if (luhnChecksum(expanded) !== 0) {
+    return err(
+      "INVALID_CHECKSUM",
+      "ISIN check digit is incorrect",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 2)} ${v.slice(2, 6)} ${v.slice(6, 10)} ${v.slice(10)}`;
+};
+
+/** Generate a random valid ISIN. */
+const generate = (): string => {
+  const countries = ["US", "GB", "DE", "FR", "JP"];
+  for (;;) {
+    const cc =
+      countries[randomInt(0, countries.length - 1)]!;
+    let nsin = "";
+    for (let i = 0; i < 9; i++)
+      nsin += String(randomInt(0, 9));
+    const base = cc + nsin;
+    for (let d = 0; d <= 9; d++) {
+      const c = base + String(d);
+      if (validate(c).valid) return c;
+    }
+  }
+};
+
+/** International Securities Identification Number. */
+const isin: Validator = {
+  name: "International Securities Identification Number",
+  localName:
+    "International Securities Identification Number",
+  abbreviation: "ISIN",
+  aliases: [
+    "ISIN",
+    "International Securities Identification Number",
+  ] as const,
+  candidatePattern: "[A-Z]{2}[A-Z0-9]{9}\\d",
+  entityType: "any",
+  sourceUrl: "https://www.isin.org/",
+  examples: ["US0378331005", "GB0002634946"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default isin;
+export { compact, format, validate, generate };