@stll/stdnum 0.0.1

package/src/lv/vat.ts

@@ -0,0 +1,139 @@
+/**
+ * PVN (Latvian VAT number).
+ *
+ * 11 digits. Legal entities (first digit > 3):
+ * weights [9,1,4,8,3,10,2,5,7,6,1], sum % 11 === 3.
+ * Personal (first digit <= 3): 11-digit format only.
+ *
+ * @see https://www.vatify.eu/latvia-vat-number.html
+ * @see https://www.vid.gov.lv/en
+ */
+
+import { weightedSum } from "#checksums/weighted-sum";
+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 WEIGHTS = [9, 1, 4, 8, 3, 10, 2, 5, 7, 6, 1];
+
+const compact = (value: string): string => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("LV") || v.startsWith("lv")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const PERS_WEIGHTS = [10, 5, 8, 4, 2, 1, 6, 3, 7, 9];
+
+const checkPersonal = (v: string): boolean => {
+  // Initial sum = 1 (not 0), so can't use
+  // weightedSum directly
+  let sum = 1;
+  for (let i = 0; i < 10; i++) {
+    // SAFETY: both arrays are length 10+
+    // eslint-disable-next-line no-non-null-assertion
+    sum += PERS_WEIGHTS[i]! * Number(v[i]);
+  }
+  return (sum % 11) % 10 === Number(v[10]);
+};
+
+const validateBirthDate = (v: string): boolean => {
+  const day = Number(v.slice(0, 2));
+  const month = Number(v.slice(2, 4));
+  const year2 = Number(v.slice(4, 6));
+  const century = Number(v[6]);
+  const fullYear = 1800 + century * 100 + year2;
+  const date = new Date(fullYear, month - 1, day);
+  return (
+    date.getFullYear() === fullYear &&
+    date.getMonth() === month - 1 &&
+    date.getDate() === day
+  );
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 11) {
+    return err(
+      "INVALID_LENGTH",
+      "Latvian VAT number must be 11 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Latvian VAT number must contain only digits",
+    );
+  }
+  const first = Number(v[0]);
+  // Legal entity: first digit > 3
+  if (first > 3) {
+    const sum = weightedSum(v, WEIGHTS, 11);
+    if (sum !== 3) {
+      return err(
+        "INVALID_CHECKSUM",
+        "Latvian VAT number check digit mismatch",
+      );
+    }
+  } else if (v.startsWith("32")) {
+    // New-format personal code (from July 2017),
+    // no birth date; checksum only
+    if (!checkPersonal(v)) {
+      return err(
+        "INVALID_CHECKSUM",
+        "Latvian personal code check digit mismatch",
+      );
+    }
+  } else {
+    // Old-format personal code: first 6 digits encode
+    // birth date as DDMMYY, digit 7 encodes century
+    if (!validateBirthDate(v)) {
+      return err(
+        "INVALID_COMPONENT",
+        "Latvian personal code has invalid birth date",
+      );
+    }
+    if (!checkPersonal(v)) {
+      return err(
+        "INVALID_CHECKSUM",
+        "Latvian personal code check digit mismatch",
+      );
+    }
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `LV${compact(value)}`;
+
+/** Generate a random valid Latvian VAT number. */
+const generate = (): string => {
+  for (;;) {
+    const c = String(randomInt(4, 9)) + randomDigits(10);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Latvian VAT Number. */
+const vat: Validator = {
+  name: "Latvian VAT Number",
+  localName: "PVN reģistrācijas numurs",
+  abbreviation: "PVN",
+  aliases: ["PVN reģistrācijas numurs", "PVN"] as const,
+  candidatePattern: "LV\\d{11}",
+  country: "LV",
+  entityType: "any",
+  sourceUrl: "https://www.vid.gov.lv/en",
+  examples: ["40003521600"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/ma/ice.ts

@@ -0,0 +1,79 @@
+/**
+ * ICE (Identifiant Commun de l'Entreprise).
+ *
+ * Moroccan company identification number. 15 digits:
+ * 9 enterprise digits + 4 establishment digits +
+ * 2 check digits. Uses Mod 97-10 checksum
+ * (full number mod 97 must equal 0).
+ *
+ * @see https://www.ice.gov.ma/
+ */
+
+import { mod97 } from "#checksums/mod97";
+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 !== 15) {
+    return err(
+      "INVALID_LENGTH",
+      "Moroccan ICE must be exactly 15 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Moroccan ICE must contain only digits",
+    );
+  }
+  if (mod97(v) !== 0) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Moroccan ICE check digits mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid Moroccan ICE. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(15);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Moroccan Company Identification Number. */
+const ice: Validator = {
+  name: "Moroccan Company Identification Number",
+  localName: "Identifiant Commun de l'Entreprise",
+  abbreviation: "ICE",
+  aliases: [
+    "ICE",
+    "Identifiant Commun de l'Entreprise",
+  ] as const,
+  candidatePattern: "\\d{15}",
+  country: "MA",
+  entityType: "company",
+  compact,
+  format,
+  validate,
+  description: "Moroccan common enterprise identifier",
+  sourceUrl: "https://www.ice.gov.ma/",
+  lengths: [15] as const,
+  examples: ["001561191000066", "002136093000040"] as const,
+  generate,
+};
+
+export default ice;
+export { compact, format, validate, generate };

package/src/ma/mod.ts

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

package/src/mc/mod.ts

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

package/src/mc/tva.ts

@@ -0,0 +1,74 @@
+/**
+ * n° TVA (taxe sur la valeur ajoutée, Monacan VAT).
+ *
+ * For VAT purposes Monaco is treated as French
+ * territory. The number follows the French TVA
+ * format but the SIREN part starts with "000"
+ * (not a real SIREN). The compact form is
+ * prefixed with "FR".
+ *
+ * @see https://www.economie.gouv.fr/
+ */
+
+import { randomDigits } from "#util/generate";
+import { err } from "#util/result";
+
+import {
+  compact as frCompact,
+  validate as frValidate,
+} from "../fr/tva";
+import type { ValidateResult, Validator } from "../types";
+
+const compact = (value: string): string => {
+  const v = frCompact(value);
+  return `FR${v}`;
+};
+
+const validate = (value: string): ValidateResult => {
+  const frResult = frValidate(value);
+  if (!frResult.valid) {
+    return frResult;
+  }
+
+  // Monaco SIREN part must start with "000"
+  const siren = frResult.compact.slice(2);
+  if (!siren.startsWith("000")) {
+    return err(
+      "INVALID_COMPONENT",
+      "Monacan TVA SIREN part must start with 000",
+    );
+  }
+
+  return { valid: true, compact: `FR${frResult.compact}` };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid Monacan TVA number. */
+const generate = (): string => {
+  const siren = "000" + randomDigits(6);
+  const prefix = String(
+    (12 + 3 * (Number(siren) % 97)) % 97,
+  ).padStart(2, "0");
+  return "FR" + prefix + siren;
+};
+
+/** Monacan VAT Number. */
+const tva: Validator = {
+  name: "Monacan VAT Number",
+  localName: "Numéro de TVA",
+  abbreviation: "TVA",
+  aliases: ["numéro de TVA", "TVA"] as const,
+  candidatePattern: "FR\\d{11}",
+  country: "MC",
+  entityType: "company",
+  sourceUrl: "https://www.economie.gouv.fr/",
+  examples: ["FR53000004605"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default tva;
+export { compact, format, validate, generate };

package/src/md/idno.ts

@@ -0,0 +1,86 @@
+/**
+ * IDNO (Moldavian company identification number).
+ *
+ * 13 digits: first digit identifies the registry,
+ * next three are the assignment year, followed by
+ * five identifier digits and a check digit.
+ * Checksum uses weights [7, 3, 1] repeated.
+ *
+ * @see https://www.idno.md
+ */
+
+import { clean } from "#util/clean";
+import { err } from "#util/result";
+import { isdigits } from "#util/strings";
+
+import type { ValidateResult, Validator } from "../types";
+
+const WEIGHTS = [
+  7, 3, 1, 7, 3, 1, 7, 3, 1, 7, 3, 1,
+] as const;
+
+const calcCheckDigit = (number: string): number => {
+  let sum = 0;
+  for (let i = 0; i < 12; i++) {
+    sum += (WEIGHTS[i] ?? 0) * Number(number[i]);
+  }
+  return sum % 10;
+};
+
+const compact = (value: string): string =>
+  clean(value, " ");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Moldavian IDNO must contain only digits",
+    );
+  }
+  if (v.length !== 13) {
+    return err(
+      "INVALID_LENGTH",
+      "Moldavian IDNO must be 13 digits",
+    );
+  }
+  const expected = calcCheckDigit(v);
+  if (expected !== Number(v[12])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Moldavian IDNO check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+const generate = (): string => {
+  let digits = "";
+  for (let i = 0; i < 12; i++) {
+    digits += String(Math.floor(Math.random() * 10));
+  }
+  return digits + String(calcCheckDigit(digits));
+};
+
+/** Moldavian Company Identification Number. */
+const idno: Validator = {
+  name: "Moldavian Company Identification Number",
+  localName: "IDNO",
+  abbreviation: "IDNO",
+  aliases: ["IDNO", "cod de identificare"] as const,
+  candidatePattern: "\\d{13}",
+  country: "MD",
+  entityType: "company",
+  lengths: [13] as const,
+  sourceUrl: "https://www.idno.md/",
+  examples: ["1008600038413"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default idno;
+export { compact, format, validate };

package/src/md/mod.ts

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

package/src/me/mod.ts

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

package/src/me/pib.ts

@@ -0,0 +1,79 @@
+/**
+ * PIB (Poreski identifikacioni broj).
+ *
+ * Montenegrin tax identification number. 8 digits with
+ * a weighted mod 11 checksum.
+ *
+ * @see https://github.com/arthurdejong/python-stdnum/blob/master/stdnum/me/pib.py
+ * @see https://www.tax.gov.me/
+ */
+
+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 = [8, 7, 6, 5, 4, 3, 2] as const;
+
+const compact = (value: string): string =>
+  clean(value, " -");
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 8) {
+    return err(
+      "INVALID_LENGTH",
+      "PIB must be exactly 8 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "PIB must contain only digits",
+    );
+  }
+
+  const total = weightedSum(v.slice(0, 7), WEIGHTS, 11);
+  const check = ((11 - total) % 11) % 10;
+  if (check !== Number(v[7])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "PIB check digit mismatch",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid Montenegrin PIB. */
+const generate = (): string => {
+  const payload = randomDigits(7);
+  const total = weightedSum(payload, WEIGHTS, 11);
+  return payload + String(((11 - total) % 11) % 10);
+};
+
+/** Montenegrin Tax Identification Number. */
+const pib: Validator = {
+  name: "Montenegrin Tax ID",
+  localName: "Poreski identifikacioni broj",
+  abbreviation: "PIB",
+  aliases: ["PIB"] as const,
+  candidatePattern: "\\d{8}",
+  country: "ME",
+  entityType: "any",
+  lengths: [8] as const,
+  sourceUrl: "https://www.tax.gov.me/",
+  examples: ["02655284"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default pib;
+export { compact, format, validate, generate };

package/src/mk/edb.ts

@@ -0,0 +1,91 @@
+/**
+ * EDB (Edinstven danocen broj).
+ *
+ * North Macedonian tax identification number. 13 digits
+ * with a weighted mod 11 checksum. May be prefixed with
+ * "MK" (Latin) or "МК" (Cyrillic).
+ *
+ * @see https://github.com/arthurdejong/python-stdnum/blob/master/stdnum/mk/edb.py
+ * @see https://www.ujp.gov.mk/
+ */
+
+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 = [
+  7, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2,
+] as const;
+
+const compact = (value: string): string => {
+  let v = clean(value, " -");
+  if (v.startsWith("MK") || v.startsWith("\u041C\u041A")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 13) {
+    return err(
+      "INVALID_LENGTH",
+      "EDB must be exactly 13 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "EDB must contain only digits",
+    );
+  }
+
+  const total = weightedSum(v.slice(0, 12), WEIGHTS, 11);
+  const check = ((11 - total) % 11) % 10;
+  if (check !== Number(v[12])) {
+    return err(
+      "INVALID_CHECKSUM",
+      "EDB check digit mismatch",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => compact(value);
+
+/** Generate a random valid Macedonian EDB. */
+const generate = (): string => {
+  const payload = randomDigits(12);
+  const total = weightedSum(payload, WEIGHTS, 11);
+  return payload + String(((11 - total) % 11) % 10);
+};
+
+/** North Macedonian Tax Identification Number. */
+const edb: Validator = {
+  name: "North Macedonian Tax ID",
+  localName: "Edinstven danocen broj",
+  abbreviation: "EDB",
+  aliases: [
+    "ЕДБ",
+    "единствен даночен број",
+    "EDB",
+  ] as const,
+  candidatePattern: "MK\\d{13}",
+  country: "MK",
+  entityType: "any",
+  lengths: [13] as const,
+  sourceUrl: "https://www.ujp.gov.mk/",
+  examples: ["4002012527974"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default edb;
+export { compact, format, validate, generate };

package/src/mk/mod.ts

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

package/src/mt/mod.ts

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

package/src/mt/vat.ts

@@ -0,0 +1,88 @@
+/**
+ * VAT (Maltese VAT number).
+ *
+ * 8 digits, no leading 0.
+ * Weights [3,4,6,7,8,9,10,1], sum % 37 === 0.
+ *
+ * @see https://www.vatify.eu/malta-vat-number.html
+ * @see https://www.oecd.org/content/dam/oecd/en/topics/policy-issue-focus/aeoi/malta-tin.pdf
+ */
+
+import { weightedSum } from "#checksums/weighted-sum";
+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 WEIGHTS = [3, 4, 6, 7, 8, 9, 10, 1];
+
+const compact = (value: string): string => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("MT") || v.startsWith("mt")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 8) {
+    return err(
+      "INVALID_LENGTH",
+      "Maltese VAT number must be 8 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Maltese VAT number must contain only digits",
+    );
+  }
+  if (v[0] === "0") {
+    return err(
+      "INVALID_COMPONENT",
+      "Maltese VAT number cannot start with 0",
+    );
+  }
+  const sum = weightedSum(v, WEIGHTS, 37);
+  if (sum !== 0) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Maltese VAT number check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `MT${compact(value)}`;
+
+/** Generate a random valid Maltese VAT number. */
+const generate = (): string => {
+  for (;;) {
+    const c = String(randomInt(1, 9)) + randomDigits(7);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Maltese VAT Number. */
+const vat: Validator = {
+  name: "Maltese VAT Number",
+  localName: "VAT Registration Number",
+  abbreviation: "VAT",
+  aliases: ["VAT number MT"] as const,
+  candidatePattern: "MT\\d{8}",
+  country: "MT",
+  entityType: "company",
+  sourceUrl: "https://cfr.gov.mt/",
+  examples: ["11679112"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };