@stll/stdnum 0.0.1

package/src/nl/vat.ts

@@ -0,0 +1,146 @@
+/**
+ * BTW (Dutch VAT number).
+ *
+ * 12 characters: 9 digits + "B" + 2 digits.
+ * Mod 97 check: convert "NL" + number to numeric
+ * (N=23, L=21, B=11), mod 97 === 1.
+ *
+ * @see https://www.vatify.eu/netherlands-vat-number.html
+ * @see https://business.gov.nl/regulations/using-checking-vat-numbers/
+ */
+
+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("NL") || v.startsWith("nl")) {
+    v = v.slice(2);
+  }
+  v = v.toUpperCase();
+  // Zero-pad numeric part to 9 digits if B is found
+  const bIdx = v.indexOf("B");
+  if (bIdx > 0 && bIdx < 9) {
+    v = v.slice(0, bIdx).padStart(9, "0") + v.slice(bIdx);
+  }
+  return v;
+};
+
+/**
+ * Compute mod 97 of a string containing digits and
+ * uppercase letters (A=10, B=11, ..., Z=35).
+ */
+const mod97 = (value: string): number => {
+  let remainder = 0;
+  for (const ch of value) {
+    const code = ch.charCodeAt(0);
+    if (code >= 48 && code <= 57) {
+      // Digit
+      remainder = (remainder * 10 + (code - 48)) % 97;
+    } else if (code >= 65 && code <= 90) {
+      // Letter: two decimal digits (A=10, ..., Z=35)
+      const num = code - 55;
+      remainder = (remainder * 100 + num) % 97;
+    }
+  }
+  return remainder;
+};
+
+/**
+ * Check if a 9-digit string is a valid BSN (Dutch citizen
+ * identification number). Weights [9,8,7,6,5,4,3,2,-1],
+ * sum % 11 === 0.
+ */
+const bsnValid = (num: string): boolean => {
+  if (!isdigits(num) || num.length !== 9) return false;
+  if (Number.parseInt(num, 10) <= 0) return false;
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += (9 - i) * Number(num[i]);
+  }
+  sum -= Number(num[8]);
+  return sum % 11 === 0;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "Dutch VAT number must be 12 characters",
+    );
+  }
+  if (!isdigits(v.slice(0, 9))) {
+    return err(
+      "INVALID_FORMAT",
+      "Dutch VAT number must start with 9 digits",
+    );
+  }
+  if (v[9] !== "B") {
+    return err(
+      "INVALID_COMPONENT",
+      "Dutch VAT number digit 10 must be B",
+    );
+  }
+  if (!isdigits(v.slice(10, 12))) {
+    return err(
+      "INVALID_FORMAT",
+      "Dutch VAT number must end with 2 digits",
+    );
+  }
+  if (Number.parseInt(v.slice(0, 9), 10) <= 0) {
+    return err(
+      "INVALID_FORMAT",
+      "Dutch VAT number first 9 digits must be > 0",
+    );
+  }
+  if (Number.parseInt(v.slice(10, 12), 10) <= 0) {
+    return err(
+      "INVALID_FORMAT",
+      "Dutch VAT number last 2 digits must be > 0",
+    );
+  }
+  // Valid if BSN check passes OR mod 97 check passes
+  if (!bsnValid(v.slice(0, 9)) && mod97(`NL${v}`) !== 1) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Dutch VAT number checksum failed",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `NL${compact(value)}`;
+
+/** Generate a random valid Dutch VAT number. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(9) + "B" + randomDigits(2);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Dutch VAT Number. */
+const vat: Validator = {
+  name: "Dutch VAT Number",
+  localName: "BTW-identificatienummer",
+  abbreviation: "BTW",
+  aliases: ["BTW-nummer", "BTW-id"] as const,
+  candidatePattern: "NL\\d{9}B\\d{2}",
+  country: "NL",
+  entityType: "company",
+  sourceUrl: "https://www.belastingdienst.nl/",
+  examples: ["123456789B13"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/no/fodselsnummer.ts

@@ -0,0 +1,192 @@
+/**
+ * Fødselsnummer (Norwegian birth number).
+ *
+ * 11 digits: DDMMYY + 3-digit individual number + 2
+ * check digits. Supports D-numbers (day + 40) and
+ * H-numbers (month + 40).
+ *
+ * @see https://www.skatteetaten.no/
+ */
+
+import { clean } from "#util/clean";
+import { isValidDate } from "#util/date";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type {
+  ParsedPersonId,
+  ValidateResult,
+  Validator,
+} from "../types";
+
+const WEIGHTS_D1 = [3, 7, 6, 1, 8, 9, 4, 5, 2] as const;
+const WEIGHTS_D2 = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] as const;
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const getCentury = (
+  yy: number,
+  individual: number,
+): number | undefined => {
+  if (individual >= 0 && individual <= 499) return 1900;
+  if (individual >= 500 && individual <= 749 && yy >= 54) {
+    return 1800;
+  }
+  if (individual >= 500 && individual <= 999 && yy < 40) {
+    return 2000;
+  }
+  if (individual >= 900 && individual <= 999 && yy >= 40) {
+    return 1900;
+  }
+  return undefined;
+};
+
+const checkDigit = (
+  v: string,
+  weights: readonly number[],
+): number | undefined => {
+  let sum = 0;
+  for (let i = 0; i < weights.length; i++) {
+    sum += Number(v.charAt(i)) * (weights[i] ?? 0);
+  }
+  const remainder = (11 - (sum % 11)) % 11;
+  if (remainder === 10) return undefined;
+  return remainder;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 11) {
+    return err(
+      "INVALID_LENGTH",
+      "Norwegian birth number must be 11 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Norwegian birth number must contain only digits",
+    );
+  }
+
+  // Check digits
+  const d1 = checkDigit(v, WEIGHTS_D1);
+  if (d1 === undefined || d1 !== Number(v[9])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Norwegian birth number check digit 1 mismatch",
+    );
+  }
+  const d2 = checkDigit(v, WEIGHTS_D2);
+  if (d2 === undefined || d2 !== Number(v[10])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Norwegian birth number check digit 2 mismatch",
+    );
+  }
+
+  // Parse date components
+  let dd = Number(v.slice(0, 2));
+  let mm = Number(v.slice(2, 4));
+  const yy = Number(v.slice(4, 6));
+  const individual = Number(v.slice(6, 9));
+
+  // D-number: day > 40
+  if (dd > 40) dd -= 40;
+  // H-number: month > 40
+  if (mm > 40) mm -= 40;
+
+  const century = getCentury(yy, individual);
+  if (century === undefined) {
+    return err(
+      "INVALID_COMPONENT",
+      "Norwegian birth number has invalid individual/century combination",
+    );
+  }
+
+  const year = century + yy;
+  if (!isValidDate(year, mm, dd)) {
+    return err(
+      "INVALID_COMPONENT",
+      "Norwegian birth number contains an invalid date",
+    );
+  }
+
+  // Reject future birth dates
+  if (new Date(year, mm - 1, dd) > new Date()) {
+    return err(
+      "INVALID_COMPONENT",
+      "Birth date is in the future",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, 6)} ${v.slice(6)}`;
+};
+
+/**
+ * Extract birth date and gender from a Norwegian
+ * birth number. 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;
+  let dd = Number(v.slice(0, 2));
+  let mm = Number(v.slice(2, 4));
+  const yy = Number(v.slice(4, 6));
+  const individual = Number(v.slice(6, 9));
+
+  if (dd > 40) dd -= 40;
+  if (mm > 40) mm -= 40;
+
+  const century = getCentury(yy, individual);
+  if (century === undefined) return null;
+
+  const year = century + yy;
+
+  return {
+    birthDate: new Date(year, mm - 1, dd),
+    gender: individual % 2 === 0 ? "female" : "male",
+  };
+};
+
+/** Generate a random valid Norwegian birth number. */
+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 ind = String(randomInt(0, 499)).padStart(3, "0");
+    const c = dd + mm + yy + ind + randomDigits(2);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Norwegian Birth Number. */
+const fodselsnummer: Validator = {
+  name: "Norwegian Birth Number",
+  localName: "Fødselsnummer",
+  abbreviation: "Fødselsnr",
+  aliases: ["fødselsnummer", "personnummer"] as const,
+  candidatePattern: "\\d{11}",
+  country: "NO",
+  entityType: "person",
+  sourceUrl: "https://www.skatteetaten.no/",
+  examples: ["15108695088"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default fodselsnummer;
+export { compact, format, parse, validate, generate };

package/src/no/mod.ts

@@ -0,0 +1,3 @@
+export { default as orgnr } from "./orgnr";
+export { default as mva } from "./mva";
+export { default as fodselsnummer } from "./fodselsnummer";

package/src/no/mva.ts

@@ -0,0 +1,73 @@
+/**
+ * MVA (Merverdiavgift, Norwegian VAT number).
+ *
+ * Format: optional "NO" prefix + 9 digits + "MVA" suffix.
+ * The 9-digit part is validated as an Organisasjonsnummer.
+ *
+ * @see https://www.skatteetaten.no/
+ */
+
+import { clean } from "#util/clean";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+import {
+  validate as validateOrgnr,
+  generate as generateOrgnr,
+} from "./orgnr";
+
+const compact = (value: string): string => {
+  let v = clean(value, " -").toUpperCase();
+  if (v.startsWith("NO")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (!v.endsWith("MVA")) {
+    return err(
+      "INVALID_FORMAT",
+      "Norwegian VAT must end with MVA",
+    );
+  }
+
+  const digits = v.slice(0, -3);
+  const orgnrResult = validateOrgnr(digits);
+  if (!orgnrResult.valid) {
+    return orgnrResult;
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  const digits = v.endsWith("MVA") ? v.slice(0, -3) : v;
+  return `NO ${digits.slice(0, 3)} ${digits.slice(3, 6)} ${digits.slice(6)} MVA`;
+};
+
+/** Generate a random valid Norwegian VAT number. */
+const generate = (): string => generateOrgnr() + "MVA";
+
+/** Norwegian VAT Number. */
+const mva: Validator = {
+  name: "Norwegian VAT Number",
+  localName: "Merverdiavgift",
+  abbreviation: "MVA",
+  aliases: ["MVA-nummer", "organisasjonsnummer"] as const,
+  candidatePattern: "NO\\d{9}MVA",
+  country: "NO",
+  entityType: "company",
+  sourceUrl: "https://www.skatteetaten.no/",
+  examples: ["995525828MVA"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default mva;
+export { compact, format, validate, generate };

package/src/no/orgnr.ts

@@ -0,0 +1,79 @@
+/**
+ * Organisasjonsnummer (Norwegian organization number).
+ *
+ * 9 digits. Weights [3,2,7,6,5,4,3,2,1], sum % 11 === 0.
+ *
+ * @see https://www.brreg.no/
+ */
+
+import { weightedSum } from "#checksums/weighted-sum";
+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 = [3, 2, 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 (v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "Norwegian org number must be 9 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Norwegian org number must contain only digits",
+    );
+  }
+
+  const sum = weightedSum(v, WEIGHTS, 11);
+  if (sum !== 0) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Norwegian org number check digit mismatch",
+    );
+  }
+
+  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)}`;
+};
+
+/** Generate a random valid Norwegian org number. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(9);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Norwegian Organization Number. */
+const orgnr: Validator = {
+  name: "Norwegian Organization Number",
+  localName: "Organisasjonsnummer",
+  abbreviation: "Orgnr",
+  aliases: ["organisasjonsnummer", "org.nr"] as const,
+  candidatePattern: "\\d{9}",
+  country: "NO",
+  entityType: "company",
+  sourceUrl: "https://www.brreg.no/",
+  examples: ["923609016"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default orgnr;
+export { compact, format, validate, generate };

package/src/nz/ird.ts

@@ -0,0 +1,128 @@
+/**
+ * IRD number (New Zealand Inland Revenue Department
+ * number, Te Tari Take).
+ *
+ * 8 or 9 digit number with a weighted checksum.
+ * Uses primary weights, falling back to secondary
+ * weights if the primary check yields 10.
+ *
+ * @see https://www.ird.govt.nz/
+ */
+
+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 PRIMARY_WEIGHTS = [3, 2, 7, 6, 5, 4, 3, 2] as const;
+
+const SECONDARY_WEIGHTS = [7, 4, 3, 2, 5, 2, 7, 6] as const;
+
+/**
+ * Calculate the check digit for an IRD number.
+ * The input should be the number without the check
+ * digit, zero-padded to 8 digits.
+ */
+const calcCheckDigit = (payload: string): number | null => {
+  const padded = payload.padStart(8, "0");
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += PRIMARY_WEIGHTS[i]! * Number(padded[i]);
+  }
+  let remainder = ((-sum % 11) + 11) % 11;
+  if (remainder !== 10) return remainder;
+
+  sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += SECONDARY_WEIGHTS[i]! * Number(padded[i]);
+  }
+  remainder = ((-sum % 11) + 11) % 11;
+  if (remainder === 10) return null;
+  return remainder;
+};
+
+const compact = (value: string): string => {
+  let v = clean(value, " -").toUpperCase();
+  if (v.startsWith("NZ")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 8 && v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "IRD number must be 8 or 9 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "IRD number must contain only digits",
+    );
+  }
+  const num = Number(v);
+  if (num < 10_000_000 || num >= 150_000_000) {
+    return err(
+      "INVALID_COMPONENT",
+      "IRD number out of valid range",
+    );
+  }
+  const payload = v.slice(0, -1);
+  const expected = calcCheckDigit(payload);
+  if (expected === null) {
+    return err(
+      "INVALID_COMPONENT",
+      "IRD number cannot have a valid check digit",
+    );
+  }
+  if (expected !== Number(v[v.length - 1])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "IRD check digit does not match",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  const last6 = v.slice(-6);
+  const prefix = v.slice(0, -6);
+  return `${prefix}-${last6.slice(0, 3)}-${last6.slice(3)}`;
+};
+
+/** Generate a random valid NZ IRD number. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(9);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** New Zealand IRD Number. */
+const ird: Validator = {
+  name: "IRD Number",
+  localName: "IRD Number",
+  abbreviation: "IRD",
+  aliases: ["IRD number", "tax number NZ"] as const,
+  candidatePattern: "\\d{8,9}",
+  country: "NZ",
+  entityType: "any",
+  compact,
+  format,
+  validate,
+  description:
+    "New Zealand Inland Revenue Department number",
+  sourceUrl: "https://www.ird.govt.nz/",
+  lengths: [8, 9] as const,
+  examples: ["49091850", "136410132"] as const,
+  generate,
+};
+
+export default ird;
+export { compact, format, validate, generate };

package/src/nz/mod.ts

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

package/src/pa/mod.ts

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