@stll/stdnum 0.0.1

package/src/se/orgnr.ts

@@ -0,0 +1,81 @@
+/**
+ * Organisationsnummer (Swedish organization number).
+ *
+ * 10 digits. Standard Luhn checksum.
+ * Display format: NNNNNN-NNNN.
+ *
+ * @see https://www.skatteverket.se/
+ */
+
+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, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "Swedish Organisationsnummer must be 10 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Swedish Organisationsnummer must contain only digits",
+    );
+  }
+  if (!luhnValidate(v)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Swedish Organisationsnummer Luhn check failed",
+    );
+  }
+  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 Swedish org number. */
+const generate = (): string => {
+  const p = randomDigits(9);
+  const cs = luhnChecksum(p + "0");
+  return p + String((10 - cs) % 10);
+};
+
+/** Swedish Organization Number. */
+const orgnr: Validator = {
+  name: "Swedish Organization Number",
+  localName: "Organisationsnummer",
+  abbreviation: "Orgnr",
+  aliases: [
+    "organisationsnummer",
+    "org.nr",
+    "org nr",
+  ] as const,
+  candidatePattern: "\\d{6}-\\d{4}",
+  country: "SE",
+  entityType: "company",
+  sourceUrl: "https://www.skatteverket.se/",
+  examples: ["1234567897"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default orgnr;
+export { compact, format, validate, generate };

package/src/se/personnummer.ts

@@ -0,0 +1,180 @@
+/**
+ * Personnummer (Personal Identity Number).
+ *
+ * Swedish personal identification number. 10 digits
+ * in compact form (YYMMDDNNNC) with a Luhn checksum
+ * on all 10 digits.
+ *
+ * @see https://www.skatteverket.se/privat/folkbokforing/personnummer.4.3810a01c150939e893f18c29.html
+ */
+
+import {
+  luhnValidate,
+  luhnChecksum,
+} from "#checksums/luhn";
+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 {
+  ParsedPersonId,
+  ValidateResult,
+  Validator,
+} from "../types";
+
+/**
+ * Match python-stdnum's compact: preserve the '-' or '+'
+ * separator at position -5, and strip any others.
+ */
+const compact = (value: string): string => {
+  let v = clean(value, " :");
+  if (
+    (v.length === 10 || v.length === 12) &&
+    v[v.length - 5] !== "-" &&
+    v[v.length - 5] !== "+"
+  ) {
+    v = `${v.slice(0, -4)}-${v.slice(-4)}`;
+  }
+  const prefix = v
+    .slice(0, -5)
+    .replace(/-/g, "")
+    .replace(/\+/g, "");
+  return `${prefix}${v.slice(-5)}`;
+};
+
+/**
+ * Extract the birth date from the compacted number.
+ * Matches python-stdnum's get_birth_date.
+ */
+const getBirthDate = (
+  v: string,
+): { year: number; month: number; day: number } | null => {
+  let year: number;
+  let month: number;
+  let day: number;
+
+  if (v.length === 13) {
+    year = Number(v.slice(0, 4));
+    month = Number(v.slice(4, 6));
+    day = Number(v.slice(6, 8));
+  } else {
+    const currentYear = new Date().getFullYear();
+    let century = Math.floor(currentYear / 100);
+    const yy = Number(v.slice(0, 2));
+    if (yy > currentYear % 100) century -= 1;
+    if (v[v.length - 5] === "+") century -= 1;
+    year = century * 100 + yy;
+    month = Number(v.slice(2, 4));
+    day = Number(v.slice(4, 6));
+  }
+
+  if (!isValidDate(year, month, day)) return null;
+  return { year, month, day };
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 11 && v.length !== 13) {
+    return err(
+      "INVALID_LENGTH",
+      "Personnummer must be 10 or 12 digits",
+    );
+  }
+
+  const digits = v.slice(0, -5) + v.slice(-4);
+  const sep = v[v.length - 5];
+  if ((sep !== "-" && sep !== "+") || !isdigits(digits)) {
+    return err(
+      "INVALID_FORMAT",
+      "Personnummer has invalid format",
+    );
+  }
+
+  if (getBirthDate(v) === null) {
+    return err(
+      "INVALID_COMPONENT",
+      "Personnummer contains an invalid date",
+    );
+  }
+
+  if (!luhnValidate(digits.slice(-10))) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Personnummer Luhn check does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/**
+ * Extract birth date and gender from a Personnummer.
+ * 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 birthDate = getBirthDate(v);
+  if (birthDate === null) return null;
+
+  const genderDigit = Number(v[v.length - 2]);
+
+  return {
+    birthDate: new Date(
+      birthDate.year,
+      birthDate.month - 1,
+      birthDate.day,
+    ),
+    gender: genderDigit % 2 === 0 ? "female" : "male",
+  };
+};
+
+/** Generate a random valid Swedish personnummer. */
+const generate = (): string => {
+  for (;;) {
+    const yy = String(randomInt(50, 99)).padStart(2, "0");
+    const mm = String(randomInt(1, 12)).padStart(2, "0");
+    const dd = String(randomInt(1, 28)).padStart(2, "0");
+    const serial = String(randomInt(0, 999)).padStart(
+      3,
+      "0",
+    );
+    const payload = yy + mm + dd + serial;
+    const cs = luhnChecksum(payload + "0");
+    const c = payload + String((10 - cs) % 10);
+    const result = validate(c);
+    if (result.valid) return result.compact;
+  }
+};
+
+/** Swedish Personal Identity Number. */
+const personnummer: Validator = {
+  name: "Swedish Personal ID",
+  localName: "Personnummer",
+  abbreviation: "PN",
+  aliases: [
+    "personnummer",
+    "personnr",
+    "pers.nr",
+    "personal identity number",
+  ] as const,
+  candidatePattern: "\\d{6,8}-\\d{4}",
+  country: "SE",
+  entityType: "person",
+  sourceUrl:
+    "https://www.skatteverket.se/privat/folkbokforing/personnummer.4.3810a01c150939e893f18c29.html",
+  examples: ["880320-0016"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default personnummer;
+export { compact, format, parse, validate, generate };

package/src/se/vat.ts

@@ -0,0 +1,92 @@
+/**
+ * Momsnr. (Swedish VAT number).
+ *
+ * 12 digits, last 2 must be "01".
+ * Luhn check on first 10 digits.
+ *
+ * @see https://www.vatify.eu/sweden-vat-number.html
+ * @see https://www.skatteverket.se/
+ */
+
+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 => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("SE") || v.startsWith("se")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 12) {
+    return err(
+      "INVALID_LENGTH",
+      "Swedish VAT number must be 12 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Swedish VAT number must contain only digits",
+    );
+  }
+  if (v.slice(10, 12) !== "01") {
+    return err(
+      "INVALID_COMPONENT",
+      "Swedish VAT number must end with 01",
+    );
+  }
+  if (!luhnValidate(v.slice(0, 10))) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Swedish VAT number Luhn check failed",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `SE${compact(value)}`;
+
+/** Generate a random valid Swedish VAT number. */
+const generate = (): string => {
+  const p = randomDigits(9);
+  const cs = luhnChecksum(p + "0");
+  return p + String((10 - cs) % 10) + "01";
+};
+
+/** Swedish VAT Number. */
+const vat: Validator = {
+  name: "Swedish VAT Number",
+  localName: "Momsregistreringsnummer",
+  abbreviation: "Momsnr.",
+  aliases: [
+    "Momsnr.",
+    "Momsregistreringsnummer",
+    "Swedish VAT Number",
+    "SE VAT",
+  ] as const,
+  candidatePattern: "SE\\s?\\d{10}01",
+  country: "SE",
+  entityType: "company",
+  sourceUrl: "https://www.skatteverket.se/",
+  examples: ["556188840401"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/sg/mod.ts

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

package/src/sg/uen.ts

@@ -0,0 +1,267 @@
+/**
+ * UEN (Singapore Unique Entity Number).
+ *
+ * 9 or 10 characters identifying businesses and
+ * entities registered in Singapore. Three formats:
+ *
+ * - Business (ROB): 8 digits + 1 check letter
+ * - Local company (ROC): 4-digit year + 5 digits
+ *   + 1 check letter
+ * - Other entities: R/S/T + 2-digit year + 2-letter
+ *   entity type + 4 digits + 1 check letter
+ *
+ * @see https://www.uen.gov.sg/
+ * @see https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Singapore-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";
+
+/** Check letter alphabet for "Other" format. */
+const OTHER_ALPHA = "ABCDEFGHJKLMNPQRSTUVWX0123456789";
+
+const ENTITY_TYPES = new Set([
+  "CC",
+  "CD",
+  "CH",
+  "CL",
+  "CM",
+  "CP",
+  "CS",
+  "CX",
+  "DP",
+  "FB",
+  "FC",
+  "FM",
+  "FN",
+  "GA",
+  "GB",
+  "GS",
+  "HS",
+  "LL",
+  "LP",
+  "MB",
+  "MC",
+  "MD",
+  "MH",
+  "MM",
+  "MQ",
+  "NB",
+  "NR",
+  "PA",
+  "PB",
+  "PF",
+  "RF",
+  "RP",
+  "SM",
+  "SS",
+  "TC",
+  "TU",
+  "VH",
+  "XL",
+]);
+
+const compact = (value: string): string =>
+  clean(value, " -").toUpperCase();
+
+/**
+ * Validate Business (ROB) UEN (9 chars):
+ * 8 digits + 1 check letter.
+ */
+const validateBusiness = (v: string): ValidateResult => {
+  if (!isdigits(v.slice(0, 8))) {
+    return err(
+      "INVALID_FORMAT",
+      "Business UEN must start with 8 digits",
+    );
+  }
+  if (!/^[A-Z]$/.test(v[8]!)) {
+    return err(
+      "INVALID_FORMAT",
+      "Business UEN must end with a letter",
+    );
+  }
+
+  const weights = [10, 4, 9, 3, 8, 2, 7, 1];
+  const checkAlpha = "XMKECAWLJDB";
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += Number(v[i]) * weights[i]!;
+  }
+  const expected = checkAlpha[sum % 11];
+  if (v[8] !== expected) {
+    return err(
+      "INVALID_CHECKSUM",
+      "UEN check letter does not match",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+/**
+ * Validate Local Company (ROC) UEN (10 chars):
+ * 9 digits (year prefix) + 1 check letter.
+ */
+const validateLocalCompany = (
+  v: string,
+): ValidateResult => {
+  if (!isdigits(v.slice(0, 9))) {
+    return err(
+      "INVALID_FORMAT",
+      "Company UEN must have 9 digits",
+    );
+  }
+  if (!/^[A-Z]$/.test(v[9]!)) {
+    return err(
+      "INVALID_FORMAT",
+      "Company UEN must end with a letter",
+    );
+  }
+
+  const weights = [10, 8, 6, 4, 9, 7, 5, 3, 1];
+  const checkAlpha = "ZKCMDNERGWH";
+  let sum = 0;
+  for (let i = 0; i < 9; i++) {
+    sum += Number(v[i]) * weights[i]!;
+  }
+  const expected = checkAlpha[sum % 11];
+  if (v[9] !== expected) {
+    return err(
+      "INVALID_CHECKSUM",
+      "UEN check letter does not match",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+/**
+ * Validate Other entity UEN (10 chars):
+ * R/S/T + 2 digits + 2-letter type + 4 digits
+ * + 1 check letter.
+ */
+const validateOther = (v: string): ValidateResult => {
+  const prefix = v[0]!;
+  if (prefix !== "R" && prefix !== "S" && prefix !== "T") {
+    return err(
+      "INVALID_COMPONENT",
+      "Other UEN must start with R, S, or T",
+    );
+  }
+  if (!isdigits(v.slice(1, 3))) {
+    return err(
+      "INVALID_FORMAT",
+      "Other UEN positions 2-3 must be digits",
+    );
+  }
+  const entityType = v.slice(3, 5);
+  if (!ENTITY_TYPES.has(entityType)) {
+    return err(
+      "INVALID_COMPONENT",
+      "Unknown entity type: " + entityType,
+    );
+  }
+  if (!isdigits(v.slice(5, 9))) {
+    return err(
+      "INVALID_FORMAT",
+      "Other UEN positions 6-9 must be digits",
+    );
+  }
+
+  const weights = [4, 3, 5, 3, 10, 2, 2, 5, 7];
+  let sum = 0;
+  for (let i = 0; i < 9; i++) {
+    const idx = OTHER_ALPHA.indexOf(v[i]!);
+    if (idx === -1) {
+      return err(
+        "INVALID_FORMAT",
+        `Unexpected character at position ${i + 1}: ${v[i]}`,
+      );
+    }
+    sum += idx * weights[i]!;
+  }
+  const expected =
+    OTHER_ALPHA[(((sum - 5) % 11) + 11) % 11];
+  if (v[9] !== expected) {
+    return err(
+      "INVALID_CHECKSUM",
+      "UEN check letter does not match",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length !== 9 && v.length !== 10) {
+    return err(
+      "INVALID_LENGTH",
+      "UEN must be 9 or 10 characters",
+    );
+  }
+
+  if (!/^[A-Z0-9]+$/.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "UEN must contain only digits and letters",
+    );
+  }
+
+  // 9 chars: business (ROB)
+  if (v.length === 9) {
+    return validateBusiness(v);
+  }
+
+  // 10 chars: first char digit => local company,
+  // otherwise "other" entity
+  if (isdigits(v[0]!)) {
+    return validateLocalCompany(v);
+  }
+  return validateOther(v);
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid Singapore UEN (business format). */
+const generate = (): string => {
+  const weights = [10, 4, 9, 3, 8, 2, 7, 1];
+  const checkAlpha = "XMKECAWLJDB";
+  const body = randomDigits(8);
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    sum += Number(body[i]) * weights[i]!;
+  }
+  const check = checkAlpha[sum % 11]!;
+  return body + check;
+};
+
+/** Singapore Unique Entity Number. */
+const uen: Validator = {
+  name: "Singapore Unique Entity Number",
+  localName: "Unique Entity Number",
+  abbreviation: "UEN",
+  aliases: ["UEN", "Unique Entity Number"] as const,
+  candidatePattern: "[\\dSTR]\\d{7}[A-Z]",
+  country: "SG",
+  entityType: "company",
+  description:
+    "9 or 10-character business identifier issued by ACRA",
+  sourceUrl: "https://www.uen.gov.sg/",
+  lengths: [9, 10] as const,
+  examples: [
+    "00192200M",
+    "197401143C",
+    "S16FC0121D",
+  ] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default uen;
+export { compact, format, validate, generate };