@stll/stdnum 0.0.1

package/src/at/tin.ts

@@ -0,0 +1,90 @@
+/**
+ * TIN (Abgabenkontonummer).
+ *
+ * Austrian tax identification number. 9 digits:
+ * 2-digit tax office code (Finanzamtsnummer) +
+ * 6-digit subject number + 1 check digit.
+ * Uses a variant of the Luhn algorithm.
+ *
+ * @see https://de.wikipedia.org/wiki/Abgabenkontonummer
+ * @see https://service.bmf.gv.at/Service/Anwend/Behoerden/show_mast.asp
+ */
+
+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";
+
+/** Luhn-variant doubling table: position-dependent. */
+const DOUBLE = "0246813579";
+
+const compact = (value: string): string =>
+  clean(value, " -./,");
+
+const calcCheckDigit = (number: string): string => {
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    const d = Number(number[i]);
+    // Even positions (0-indexed) add digit as-is;
+    // odd positions use the doubling table
+    sum += i % 2 === 0 ? d : Number(DOUBLE[d]);
+  }
+  return String((10 - (sum % 10)) % 10);
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "Austrian TIN must be exactly 9 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Austrian TIN must contain only digits",
+    );
+  }
+  if (calcCheckDigit(v) !== v[8]) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Austrian TIN 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, 8)}/${v.slice(8)}`;
+};
+
+/** Generate a random valid Austrian TIN. */
+const generate = (): string => {
+  const payload = randomDigits(8);
+  return payload + calcCheckDigit(payload);
+};
+
+/** Austrian Tax Identification Number. */
+const tin: Validator = {
+  name: "Austrian Tax Identification Number",
+  localName: "Abgabenkontonummer",
+  abbreviation: "TIN",
+  aliases: ["Steuernummer", "St.Nr.", "TIN"] as const,
+  candidatePattern: "\\d{2}-?\\d{3}/\\d{4}",
+  country: "AT",
+  entityType: "any",
+  sourceUrl:
+    "https://de.wikipedia.org/wiki/Abgabenkontonummer",
+  examples: ["591199013"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default tin;
+export { compact, format, validate, generate };

package/src/at/uid.ts

@@ -0,0 +1,92 @@
+/**
+ * UID (Umsatzsteuer-Identifikationsnummer).
+ *
+ * Austrian VAT identification number. Format:
+ * "U" + 7 digits + 1 check digit. Uses a
+ * modified Luhn algorithm.
+ *
+ * @see https://www.bmf.gv.at/
+ */
+
+import { 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 => {
+  let v = clean(value, " -/");
+  if (v.startsWith("AT") || v.startsWith("at")) {
+    v = v.slice(2);
+  }
+  return v.toUpperCase();
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "Austrian UID must be U + 8 digits",
+    );
+  }
+  if (v[0] !== "U") {
+    return err(
+      "INVALID_COMPONENT",
+      "Austrian UID must start with U",
+    );
+  }
+  const digits = v.slice(1);
+  if (!isdigits(digits)) {
+    return err(
+      "INVALID_FORMAT",
+      "Austrian UID must be U + 8 digits",
+    );
+  }
+  const cs = luhnChecksum(digits.slice(0, 7));
+  const check = (((6 - cs) % 10) + 10) % 10;
+  if (check < 0 || check !== Number(digits[7])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Austrian UID check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `AT${compact(value)}`;
+
+/** Generate a random valid Austrian UID. */
+const generate = (): string => {
+  const payload = randomDigits(7);
+  const cs = luhnChecksum(payload);
+  const check = (((6 - cs) % 10) + 10) % 10;
+  return "U" + payload + String(check);
+};
+
+/** Austrian VAT Identification Number. */
+const uid: Validator = {
+  name: "Austrian VAT Number",
+  localName: "Umsatzsteuer-Identifikationsnummer",
+  abbreviation: "UID",
+  aliases: [
+    "UID",
+    "Umsatzsteuer-Identifikationsnummer",
+    "ATU",
+  ] as const,
+  candidatePattern: "ATU\\d{8}",
+  country: "AT",
+  entityType: "company",
+  sourceUrl: "https://www.bmf.gv.at/",
+  examples: ["U13585627"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default uid;
+export { compact, format, validate, generate };

package/src/at/vnr.ts

@@ -0,0 +1,111 @@
+/**
+ * VNR (Versicherungsnummer).
+ *
+ * Austrian social insurance number. 10 digits: 3-digit
+ * serial + 1 check digit + 6-digit birth date (DDMMYY).
+ * The check digit is computed using a weighted sum
+ * mod 11 over the 9 non-check digits.
+ *
+ * @see https://de.wikipedia.org/wiki/Sozialversicherungsnummer#%C3%96sterreich
+ * @see https://www.sozialversicherung.at/
+ */
+
+import { clean } from "#util/clean";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type { ValidateResult, Validator } from "../types";
+
+/**
+ * Weights for the 9 non-check digits (positions
+ * 0,1,2, then 4,5,6,7,8,9). Check digit is at
+ * position 3 and equals the weighted sum mod 11.
+ */
+const WEIGHTS = [3, 7, 9, 5, 8, 4, 2, 1, 6];
+
+const compact = (value: string): string =>
+  clean(value, " -/").trim();
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Austrian VNR must be 10 digits",
+    );
+  }
+
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Austrian VNR must contain only digits",
+    );
+  }
+
+  // Validate birth date (DDMMYY in positions 4-9)
+  const day = Number(v.slice(4, 6));
+  const month = Number(v.slice(6, 8));
+  if (day < 1 || day > 31 || month < 1 || month > 12) {
+    return err(
+      "INVALID_COMPONENT",
+      "Austrian VNR contains an invalid birth date",
+    );
+  }
+
+  // Check digit at position 3: weighted sum of the
+  // other 9 digits mod 11. If remainder is 10 the
+  // number is invalid.
+  const digits = v.slice(0, 3) + v.slice(4);
+  let sum = 0;
+  for (let i = 0; i < 9; i++) {
+    sum += Number(digits[i]) * WEIGHTS[i]!;
+  }
+  const check = sum % 11;
+  if (check === 10) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Austrian VNR check digit is invalid (mod 11 " +
+        "remainder is 10)",
+    );
+  }
+  if (check !== Number(v[3])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Austrian VNR 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, 6)}${v.slice(6, 8)}${v.slice(8)}`;
+};
+
+/** Austrian Social Insurance Number. */
+const vnr: Validator = {
+  name: "Austrian Social Insurance Number",
+  localName: "Versicherungsnummer",
+  abbreviation: "VNR",
+  aliases: [
+    "VNR",
+    "SVNR",
+    "Versicherungsnummer",
+    "Sozialversicherungsnummer",
+  ] as const,
+  candidatePattern: "\\d{4}\\s?\\d{6}",
+  country: "AT",
+  entityType: "person",
+  sourceUrl:
+    "https://de.wikipedia.org/wiki/Sozialversicherungsnummer",
+  lengths: [10] as const,
+  examples: ["1237010180"] as const,
+  compact,
+  format,
+  validate,
+};
+
+export default vnr;
+export { compact, format, validate };

package/src/au/abn.ts

@@ -0,0 +1,85 @@
+/**
+ * ABN (Australian Business Number).
+ *
+ * 11-digit identifier. Subtract 1 from the first
+ * digit, then apply weights [10,1,3,5,7,9,11,13,
+ * 15,17,19]; sum mod 89 must equal 0.
+ *
+ * @see https://en.wikipedia.org/wiki/Australian_Business_Number
+ * @see https://abr.business.gov.au/
+ */
+
+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 WEIGHTS = [
+  10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19,
+] as const;
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "ABN must contain only digits",
+    );
+  }
+  if (v.length !== 11) {
+    return err("INVALID_LENGTH", "ABN must be 11 digits");
+  }
+
+  let sum = 0;
+  for (let i = 0; i < 11; i++) {
+    let d = Number(v.charAt(i));
+    if (i === 0) d -= 1;
+    sum += d * (WEIGHTS[i] ?? 0);
+  }
+  if (sum % 89 !== 0) {
+    return err("INVALID_CHECKSUM", "ABN checksum mismatch");
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  if (v.length === 11) {
+    return `${v.slice(0, 2)} ${v.slice(2, 5)} ${v.slice(5, 8)} ${v.slice(8)}`;
+  }
+  return v;
+};
+
+/** Generate a random valid ABN. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(11);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Australian Business Number. */
+const abn: Validator = {
+  name: "Australian Business Number",
+  localName: "Australian Business Number",
+  abbreviation: "ABN",
+  aliases: ["ABN", "Australian Business Number"] as const,
+  candidatePattern: "\\d{2}\\s?\\d{3}\\s?\\d{3}\\s?\\d{3}",
+  country: "AU",
+  entityType: "company",
+  sourceUrl: "https://abr.business.gov.au/",
+  examples: ["83914571673", "51824753556"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default abn;
+export { compact, format, validate, generate };

package/src/au/acn.ts

@@ -0,0 +1,86 @@
+/**
+ * ACN (Australian Company Number).
+ *
+ * 9-digit identifier. Weights [8,7,6,5,4,3,2,1]
+ * applied to the first 8 digits; check digit is
+ * (10 - sum % 10) % 10.
+ *
+ * @see https://en.wikipedia.org/wiki/Australian_Company_Number
+ * @see https://asic.gov.au/
+ */
+
+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 WEIGHTS = [8, 7, 6, 5, 4, 3, 2, 1] as const;
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "ACN must contain only digits",
+    );
+  }
+  if (v.length !== 9) {
+    return err("INVALID_LENGTH", "ACN must be 9 digits");
+  }
+
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += Number(v.charAt(i)) * (WEIGHTS[i] ?? 0);
+  }
+  const check = (10 - (sum % 10)) % 10;
+  if (check !== Number(v.charAt(8))) {
+    return err(
+      "INVALID_CHECKSUM",
+      "ACN check digit mismatch",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  if (v.length === 9) {
+    return `${v.slice(0, 3)} ${v.slice(3, 6)} ${v.slice(6)}`;
+  }
+  return v;
+};
+
+/** Generate a random valid ACN. */
+const generate = (): string => {
+  const payload = randomDigits(8);
+  let sum = 0;
+  for (let i = 0; i < 8; i++)
+    sum += Number(payload.charAt(i)) * (WEIGHTS[i] ?? 0);
+  return payload + String((10 - (sum % 10)) % 10);
+};
+
+/** Australian Company Number. */
+const acn: Validator = {
+  name: "Australian Company Number",
+  localName: "Australian Company Number",
+  abbreviation: "ACN",
+  aliases: ["ACN", "Australian Company Number"] as const,
+  candidatePattern: "\\d{3}\\s?\\d{3}\\s?\\d{3}",
+  country: "AU",
+  entityType: "company",
+  sourceUrl: "https://asic.gov.au/",
+  examples: ["004085616", "010499966"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default acn;
+export { compact, format, validate, generate };

package/src/au/mod.ts

@@ -0,0 +1,3 @@
+export { default as abn } from "./abn";
+export { default as acn } from "./acn";
+export { default as tfn } from "./tfn";

package/src/au/tfn.ts

@@ -0,0 +1,85 @@
+/**
+ * TFN (Australian Tax File Number).
+ *
+ * 8 or 9 digit identifier. Weighted checksum with
+ * weights [1,4,3,7,5,8,6,9,10]; sum mod 11
+ * must equal 0.
+ *
+ * @see https://en.wikipedia.org/wiki/Tax_file_number
+ * @see https://www.ato.gov.au/Individuals/Tax-file-number/
+ */
+
+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 WEIGHTS = [1, 4, 3, 7, 5, 8, 6, 9, 10] as const;
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "TFN must contain only digits",
+    );
+  }
+  if (v.length !== 8 && v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "TFN must be 8 or 9 digits",
+    );
+  }
+
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    sum += Number(v.charAt(i)) * (WEIGHTS[i] ?? 0);
+  }
+  if (sum % 11 !== 0) {
+    return err("INVALID_CHECKSUM", "TFN checksum mismatch");
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  if (v.length === 8 || v.length === 9) {
+    return `${v.slice(0, 3)} ${v.slice(3, 6)} ${v.slice(6)}`;
+  }
+  return v;
+};
+
+/** Generate a random valid TFN. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(9);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Australian Tax File Number. */
+const tfn: Validator = {
+  name: "Tax File Number",
+  localName: "Tax File Number",
+  abbreviation: "TFN",
+  aliases: ["TFN", "Tax File Number"] as const,
+  candidatePattern: "\\d{8,9}",
+  country: "AU",
+  entityType: "person",
+  sourceUrl:
+    "https://www.ato.gov.au/individuals-and-families/tax-file-number",
+  examples: ["87650006", "123456782"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default tfn;
+export { compact, format, validate, generate };

package/src/az/mod.ts

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

package/src/az/voen.ts

@@ -0,0 +1,125 @@
+/**
+ * VÖEN (Vergi Ödəyicisinin Eyniləşdirmə Nömrəsi,
+ * Azerbaijani tax identification number).
+ *
+ * 10 digits: TTSSSSSSCD where:
+ *   - TT = territorial unit code
+ *   - SSSSSS = serial number
+ *   - C = check digit (weighted sum mod 11)
+ *   - D = legal status (1=legal person, 2=natural person)
+ *
+ * Ported from python-stdnum az.voen module.
+ *
+ * @see https://www.taxes.gov.az/
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits } from "#util/generate";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+
+/** Weights for check digit computation (positions 0-7). */
+const WEIGHTS = [4, 1, 8, 6, 2, 7, 5, 3] as const;
+
+/**
+ * Compact: strip spaces, prepend '0' if 9 digits.
+ */
+const compact = (value: string): string => {
+  let number = clean(value, " ").trim();
+  if (number.length === 9) {
+    number = "0" + number;
+  }
+  return number;
+};
+
+/**
+ * Calculate the check digit (position 8) using
+ * weighted sum of the first 8 digits mod 11.
+ */
+const calcCheckDigit = (value: string): string | null => {
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += (WEIGHTS[i] ?? 0) * Number(value.charAt(i));
+  }
+  const result = sum % 11;
+  return result === 10 ? null : String(result);
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Azerbaijani VÖEN must be 10 digits",
+    );
+  }
+
+  if (!/^\d{10}$/.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Azerbaijani VÖEN must contain only digits",
+    );
+  }
+
+  const lastDigit = v[9]!;
+  if (lastDigit !== "1" && lastDigit !== "2") {
+    return err(
+      "INVALID_COMPONENT",
+      "VÖEN last digit must be 1 or 2",
+    );
+  }
+
+  const expected = calcCheckDigit(v);
+  if (expected === null || v[8] !== expected) {
+    return err(
+      "INVALID_CHECKSUM",
+      "VÖEN check digit does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 3)} ${v.slice(3, 6)} ${v.slice(6, 10)}`;
+};
+
+/** Generate a random valid VOEN. */
+const generate = (): string => {
+  for (let i = 0; i < 100; i++) {
+    const payload = randomDigits(8);
+    const check = calcCheckDigit(payload);
+    if (check === null) continue;
+    const status = Math.random() < 0.5 ? "1" : "2";
+    return payload + check + status;
+  }
+  throw new Error("Failed to generate valid VOEN");
+};
+
+/**
+ * Azerbaijani tax identification number (VÖEN).
+ *
+ * Examples sourced from python-stdnum test suite.
+ */
+const voen: Validator = {
+  name: "Azerbaijani Tax ID",
+  localName: "Vergi Ödəyicisinin Eyniləşdirmə Nömrəsi",
+  abbreviation: "VÖEN",
+  aliases: ["VÖEN"] as const,
+  candidatePattern: "\\d{10}",
+  country: "AZ",
+  entityType: "any",
+  lengths: [10] as const,
+  examples: ["1401555071", "1400057421"] as const,
+  compact,
+  format,
+  validate,
+  sourceUrl: "https://www.taxes.gov.az/",
+  generate,
+};
+
+export default voen;
+export { compact, format, validate, generate };