@stll/stdnum 0.0.1

package/src/gt/nit.ts

@@ -0,0 +1,116 @@
+/**
+ * NIT (Número de Identificación Tributaria,
+ * Guatemala tax number).
+ *
+ * 2–12 characters: body digits followed by a check
+ * character. The check character is computed via a
+ * weighted sum mod 11; remainder 10 maps to 'K'.
+ *
+ * Ported from python-stdnum gt.nit module.
+ *
+ * @see https://portal.sat.gob.gt/portal/
+ */
+
+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";
+
+/**
+ * Compact: strip spaces, hyphens, leading zeros,
+ * and uppercase.
+ */
+const compact = (value: string): string => {
+  const v = clean(value, " -").trim().toUpperCase();
+  return v.replace(/^0+/, "");
+};
+
+/**
+ * Calculate the check character for a body string.
+ * Weighted sum mod 11; remainder 10 yields 'K'.
+ */
+const calcCheckChar = (body: string): string => {
+  let sum = 0;
+  const len = body.length;
+  for (let i = 0; i < len; i++) {
+    sum += (len - i + 1) * Number(body[i]);
+  }
+  const remainder = ((-sum % 11) + 11) % 11;
+  return remainder === 10 ? "K" : String(remainder);
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+
+  if (v.length < 2 || v.length > 12) {
+    return err(
+      "INVALID_LENGTH",
+      "Guatemala NIT must be 2–12 characters",
+    );
+  }
+
+  const body = v.slice(0, -1);
+  const check = v.slice(-1);
+
+  if (!isdigits(body)) {
+    return err(
+      "INVALID_FORMAT",
+      "Guatemala NIT body must contain only digits",
+    );
+  }
+
+  if (check !== "K" && !/^\d$/.test(check)) {
+    return err(
+      "INVALID_FORMAT",
+      "Guatemala NIT check character must be a digit or K",
+    );
+  }
+
+  if (check !== calcCheckChar(body)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Guatemala NIT check character does not match",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+/**
+ * Format: insert a hyphen before the check character.
+ */
+const format = (value: string): string => {
+  const v = compact(value);
+  return `${v.slice(0, -1)}-${v.slice(-1)}`;
+};
+
+/** Generate a random valid NIT (7 body digits). */
+const generate = (): string => {
+  const body = randomDigits(7);
+  const check = calcCheckChar(body);
+  return `${body}${check}`;
+};
+
+/** Guatemala tax identification number. */
+const nit: Validator = {
+  name: "Tax Identification Number",
+  localName: "Número de Identificación Tributaria",
+  abbreviation: "NIT",
+  aliases: ["NIT"] as const,
+  candidatePattern: "\\d{7,8}-?\\d",
+  country: "GT",
+  entityType: "any",
+  description: "Tax identifier issued by Guatemala's SAT",
+  sourceUrl: "https://portal.sat.gob.gt/portal/",
+  lengths: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] as const,
+  examples: ["576937K", "39525503", "71080"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default nit;
+export { compact, format, generate, validate };

package/src/hk/hkid.ts

@@ -0,0 +1,131 @@
+/**
+ * HKID (Hong Kong Identity Card number).
+ *
+ * 1-2 letters + 6 digits + check digit in parentheses.
+ * The check digit is computed via a weighted sum mod 11,
+ * where letters have values A=10, B=11, ..., Z=35.
+ * A remainder of 10 yields check digit 'A'.
+ *
+ * @see https://en.wikipedia.org/wiki/Hong_Kong_identity_card
+ */
+
+import { clean } from "#util/clean";
+import { randomDigits, randomInt } from "#util/generate";
+import { err } from "#util/result";
+
+import type { ValidateResult, Validator } from "../types";
+
+/** Strip spaces, parentheses, and dashes. */
+const compact = (value: string): string =>
+  clean(value, " -()").toUpperCase();
+
+/**
+ * Compute the weighted check character.
+ *
+ * For a two-letter prefix the weights are 9,8,7,6,5,4,3,2
+ * over the 8 characters (2 letters + 6 digits). For a
+ * single-letter prefix, a space (value 36) is prepended
+ * so the weights stay the same.
+ */
+const computeCheck = (body: string): string => {
+  const padded = body.length === 7 ? ` ${body}` : body;
+
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    const ch = padded[i]!;
+    let val: number;
+    if (ch === " ") {
+      val = 36;
+    } else if (ch >= "A" && ch <= "Z") {
+      val = ch.charCodeAt(0) - 55; // A=10
+    } else {
+      val = Number(ch);
+    }
+    sum += val * (9 - i);
+  }
+
+  const remainder = sum % 11;
+  if (remainder === 0) return "0";
+  if (remainder === 1) return "A";
+  return String(11 - remainder);
+};
+
+const HKID_RE = /^[A-Z]{1,2}\d{6}[0-9A]$/;
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 8 && v.length !== 9) {
+    return err(
+      "INVALID_LENGTH",
+      "HKID must be 8 or 9 characters",
+    );
+  }
+  if (!HKID_RE.test(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "HKID must be 1-2 letters, 6 digits, " +
+        "and a check character",
+    );
+  }
+
+  const body = v.slice(0, -1);
+  const check = v.slice(-1);
+  if (computeCheck(body) !== check) {
+    return err(
+      "INVALID_CHECKSUM",
+      "HKID check digit mismatch",
+    );
+  }
+
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string => {
+  const v = compact(value);
+  const prefix = v.slice(0, -7);
+  const digits = v.slice(-7, -1);
+  const check = v.slice(-1);
+  return `${prefix}${digits}(${check})`;
+};
+
+/** Generate a random valid HKID. */
+const generate = (): string => {
+  for (;;) {
+    const letter = String.fromCharCode(
+      65 + randomInt(0, 25),
+    );
+    const digits = randomDigits(6);
+    for (let d = 0; d <= 9; d++) {
+      const c = letter + digits + String(d);
+      if (validate(c).valid) return compact(c);
+    }
+    const cA = letter + digits + "A";
+    if (validate(cA).valid) return compact(cA);
+  }
+};
+
+/** Hong Kong Identity Card number. */
+const hkid: Validator = {
+  name: "Hong Kong Identity Card Number",
+  localName: "Hong Kong Identity Card Number",
+  abbreviation: "HKID",
+  aliases: ["HKID", "香港身份證"] as const,
+  candidatePattern: "[A-Z]{1,2}\\d{6}[\\dA]",
+  country: "HK",
+  entityType: "person",
+  lengths: [8, 9],
+  examples: ["G123456A", "AB9876543"],
+  description:
+    "Identity card number issued by the Hong Kong " +
+    "Immigration Department",
+  sourceUrl:
+    "https://en.wikipedia.org/wiki/" +
+    "Hong_Kong_identity_card",
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default hkid;
+export { compact, format, validate, generate };

package/src/hk/mod.ts

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

package/src/hr/mod.ts

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

package/src/hr/vat.ts

@@ -0,0 +1,79 @@
+/**
+ * OIB (Croatian VAT number).
+ *
+ * 11 digits. ISO 7064 Mod 11,10 checksum.
+ *
+ * @see https://www.vatify.eu/croatia-vat-number.html
+ * @see https://www.porezna-uprava.hr/
+ */
+
+import {
+  mod1110validate,
+  mod1110checkDigit,
+} from "#checksums/mod1110";
+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("HR") || v.startsWith("hr")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 11) {
+    return err(
+      "INVALID_LENGTH",
+      "Croatian VAT number must be 11 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Croatian VAT number must contain only digits",
+    );
+  }
+  if (!mod1110validate(v)) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Croatian VAT number check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `HR${compact(value)}`;
+
+/** Generate a random valid Croatian OIB. */
+const generate = (): string => {
+  const payload = randomDigits(10);
+  return payload + String(mod1110checkDigit(payload));
+};
+
+/** Croatian VAT Number. */
+const vat: Validator = {
+  name: "Croatian VAT Number",
+  localName: "Osobni identifikacijski broj",
+  abbreviation: "OIB",
+  aliases: ["OIB", "osobni identifikacijski broj"] as const,
+  candidatePattern: "HR\\d{11}",
+  country: "HR",
+  entityType: "any",
+  sourceUrl: "https://www.porezna-uprava.hr/",
+  examples: ["33392005961"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };

package/src/hu/mod.ts

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

package/src/hu/vat.ts

@@ -0,0 +1,82 @@
+/**
+ * ANUM (Hungarian VAT number).
+ *
+ * 8 digits. Weights [9,7,3,1,9,7,3,1],
+ * sum % 10 === 0.
+ *
+ * @see https://www.vatify.eu/hungary-vat-number.html
+ * @see https://www.oecd.org/content/dam/oecd/en/topics/policy-issue-focus/aeoi/hungary-tin.pdf
+ */
+
+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 = [9, 7, 3, 1, 9, 7, 3, 1];
+
+const compact = (value: string): string => {
+  let v = clean(value, " -/.");
+  if (v.startsWith("HU") || v.startsWith("hu")) {
+    v = v.slice(2);
+  }
+  return v;
+};
+
+const validate = (value: string): ValidateResult => {
+  const v = compact(value);
+  if (v.length !== 8) {
+    return err(
+      "INVALID_LENGTH",
+      "Hungarian VAT number must be 8 digits",
+    );
+  }
+  if (!isdigits(v)) {
+    return err(
+      "INVALID_FORMAT",
+      "Hungarian VAT number must contain only digits",
+    );
+  }
+  const sum = weightedSum(v, WEIGHTS, 10);
+  if (sum !== 0) {
+    return err(
+      "INVALID_CHECKSUM",
+      "Hungarian VAT number check digit mismatch",
+    );
+  }
+  return { valid: true, compact: v };
+};
+
+const format = (value: string): string =>
+  `HU${compact(value)}`;
+
+/** Generate a random valid Hungarian VAT number. */
+const generate = (): string => {
+  for (;;) {
+    const c = randomDigits(8);
+    if (validate(c).valid) return c;
+  }
+};
+
+/** Hungarian VAT Number. */
+const vat: Validator = {
+  name: "Hungarian VAT Number",
+  localName: "Adószám",
+  abbreviation: "ANUM",
+  aliases: ["adószám", "adóazonosító jel"] as const,
+  candidatePattern: "\\d{8}-\\d-\\d{2}",
+  country: "HU",
+  entityType: "company",
+  sourceUrl: "https://nav.gov.hu/",
+  examples: ["12892312"] as const,
+  compact,
+  format,
+  validate,
+  generate,
+};
+
+export default vat;
+export { compact, format, validate, generate };