stdnum 1.10.0 → 1.10.1

package/src/gr/amka.ts

@@ -0,0 +1,76 @@
+/**
+ * AMKA (Αριθμός Μητρώου Κοινωνικής Ασφάλισης, Greek social security number).
+ *
+ * The Αριθμός Μητρώου Κοινωνικής Ασφάλισης (AMKA or Arithmos Mitroou Koinonikis
+ * Asfalisis) is the personal identifier that is used for social security
+ * purposes in Greece. The number consists of 11 digits and includes the
+ * person's date of birth and gender.
+ *
+ * Source
+ *    https://www.amka.gr/tieinai_en.html
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumValidate } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Greek Social Security Number',
+  localName: 'Αριθμός Μητρώου Κοινωνικής Ασφάλισης',
+  abbreviation: 'AMKA',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [dd, mm, yy] = strings.splitAt(value, 2, 4, 6);
+
+    if (!isValidDate(yy, mm, dd)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!luhnChecksumValidate(value)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/gr/index.ts

@@ -0,0 +1,2 @@
+export * as amka from './amka';
+export * as vat from './vat';

package/src/gr/vat.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('gr/vat', () => {
+  it('format:GR 23456783', () => {
+    const result = format('GR 23456783');
+
+    expect(result).toEqual('023456783');
+  });
+
+  it('validate:GR 23456780', () => {
+    const result = validate('GR 23456780');
+
+    expect(result.isValid && result.compact).toEqual('023456780');
+  });
+
+  it('validate:EL 094259216', () => {
+    const result = validate('EL 094259216');
+
+    expect(result.isValid && result.compact).toEqual('094259216');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:123456781', () => {
+    const result = validate('123456781');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/gr/vat.ts

@@ -0,0 +1,84 @@
+/**
+ * FPA, ΦΠΑ, ΑΦΜ (Αριθμός Φορολογικού Μητρώου, the Greek VAT number).
+ *
+ * The FPA is a 9-digit number with a simple checksum.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' ');
+  if (err !== null) {
+    return [value, err];
+  }
+  let num = value;
+  if (value.startsWith('GR') || value.startsWith('EL')) {
+    num = value.substr(2);
+  }
+
+  // Old format was 8 digits
+  if (num.length === 8) {
+    return [`0${num}`, null];
+  }
+  return [num, null];
+}
+
+const impl: Validator = {
+  name: 'Greek VAT Number',
+  localName: 'Αριθμός Φορολογικού Μητρώου',
+  abbreviation: 'ΑΦΜ',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = front
+      .split('')
+      .map(v => parseInt(v, 10))
+      .reduce((acc, v) => acc * 2 + v, 0);
+
+    if (String(((sum * 2) % 11) % 10) !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/gt/cui.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cui';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('gt/cui', () => {
+  it('format:2415751810000', () => {
+    const result = format('2415751810000');
+
+    expect(result).toEqual('2415-75181-0000');
+  });
+
+  it('validate:1587564440904', () => {
+    const result = validate('1587564440904');
+
+    expect(result.isValid && result.compact).toEqual('1587564440904');
+  });
+
+  it('validate:1580352240101', () => {
+    const result = validate('1580352240101');
+
+    expect(result.isValid && result.compact).toEqual('1580352240101');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1680352240101', () => {
+    const result = validate('1680352240101');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/gt/cui.ts

@@ -0,0 +1,110 @@
+/**
+ * CUI (Código Único de Identificación, Guatemala identity number).
+ *
+ * The Código Único de Identificación (CUI) is an identifier for persons
+ * that appears on the Documento Nacional de Identidad (DNI).
+ *
+ *
+ * Source
+ *    https://knowledge.sayari.com/hc/en-us/articles/360033290312-Guatemala-Interpreting-Guatemalan-National-ID-Numbers
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const citiesPerRegion: Record<string, number> = {
+  /* Guatemala */ '01': 17,
+  /* El Progreso */ '02': 8,
+  /* Sacatepéquez */ '03': 16,
+  /* Chimaltenango */ '04': 16,
+  /* Escuintla */ '05': 13,
+  /* Santa Rosa */ '06': 14,
+  /* Sololá */ '07': 19,
+  /* Totonicapán */ '08': 8,
+  /* Quetzaltenango */ '09': 24,
+  /* Suchitepéquez */ '10': 21,
+  /* Retalhuleu */ '11': 9,
+  /* San Marcos */ '12': 30,
+  /* Huehuetenango */ '13': 32,
+  /* Quiché */ '14': 21,
+  /* Baja Verapaz */ '15': 8,
+  /* Alta Verapaz */ '16': 17,
+  /* Petén */ '17': 14,
+  /* Izabal */ '18': 5,
+  /* Zacapa */ '19': 11,
+  /* Chiquimula */ '20': 11,
+  /* Jalapa */ '21': 7,
+  /* Jutiapa */ '22': 17,
+};
+
+const impl: Validator = {
+  name: 'Guatemala Identity Number',
+  localName: 'Código Único de Identificación',
+  abbreviation: 'CUI',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return strings.splitAt(value, 4, 9).join('-');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    const [front, check, region, city] = strings.splitAt(value, 8, 9, 11);
+
+    const cities = citiesPerRegion[region];
+    if (!cities) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (parseInt(city, 10) > cities) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const digit = String(
+      weightedSum(front, {
+        weights: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+        modulus: 11,
+      }) % 10,
+    );
+
+    if (check !== digit) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/gt/index.ts

@@ -0,0 +1,2 @@
+export * as cui from './cui';
+export * as nit from './nit';

package/src/gt/nit.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './nit';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('gt/nit', () => {
+  it('format:39525503', () => {
+    const result = format('39525503');
+
+    expect(result).toEqual('3952550-3');
+  });
+
+  it('validate:576937-K', () => {
+    const result = validate('576937-K');
+
+    expect(result.isValid && result.compact).toEqual('576937K');
+  });
+
+  it('validate:7108-0', () => {
+    const result = validate('7108-0');
+
+    expect(result.isValid && result.compact).toEqual('71080');
+  });
+
+  it('validate:1234567890123', () => {
+    const result = validate('1234567890123');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:8977112-0', () => {
+    const result = validate('8977112-0');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/gt/nit.ts

@@ -0,0 +1,86 @@
+/**
+ * NIT (Número de Identificación Tributaria, Guatemala tax number).
+ *
+ * The Número de Identificación Tributaria (NIT) is an identifier of legal
+ * entities for tax purposes in Guatemala.
+ * The number consists of 2 to 12 characters, where the last one is the check
+ * digit (a digit or the letter K) and the rest are digits. Leading zeroes are
+ * usually omitted. Digits and check digit are usually separated with a hyphen.
+ *
+ * Source
+ *    https://portal.sat.gob.gt/portal/descarga/6524/factura-electronica-fel/25542/fel-reglas-y-validaciones.pdf (page 58)
+ *    https://portal.sat.gob.gt/portal/consulta-cui-nit/
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const checkDigit = '0123456789K';
+
+const impl: Validator = {
+  name: 'Guatemala Tax Number',
+  localName: 'Número de Identificación Tributaria',
+  abbreviation: 'NIT',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return strings.splitAt(value, -1).join('-');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length < 2 || value.length > 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    const [front, check] = strings.splitAt(value, -1);
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!checkDigit.includes(check)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum =
+      (11 -
+        weightedSum(front, {
+          reverse: true,
+          weights: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
+          modulus: 11,
+        })) %
+      11;
+    if (check !== checkDigit[sum]) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/hk/hkid.spec.ts

@@ -0,0 +1,52 @@
+import { validate, format } from './hkid';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('hk/hkid', () => {
+  it('format:AB987654(3)', () => {
+    const result = format('AB9876543');
+
+    expect(result).toEqual('AB9876543');
+  });
+
+  it('validate:G123456A', () => {
+    const result = validate('G123456A');
+
+    expect(result.isValid && result.compact).toEqual('G123456A');
+  });
+
+  it('validate:A5555550', () => {
+    const result = validate('A5555550');
+
+    expect(result.isValid && result.compact).toEqual('A5555550');
+  });
+
+  it('validate:C5678909', () => {
+    const result = validate('C5678909');
+
+    expect(result.isValid && result.compact).toEqual('C5678909');
+  });
+
+  it('validate:AB9876543', () => {
+    const result = validate('AB9876543');
+
+    expect(result.isValid && result.compact).toEqual('AB9876543');
+  });
+
+  it('validate:WX1234569', () => {
+    const result = validate('WX1234569');
+
+    expect(result.isValid && result.compact).toEqual('WX1234569');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:C5678908', () => {
+    const result = validate('C5678908');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/hk/hkid.ts

@@ -0,0 +1,90 @@
+/**
+ * HKID (Hong Kong Identity Card).
+ *
+ * The standard format of HKID number is @ 123456(#).
+ *   (a) @ represents any one or two capital letters of the alphabet.
+ *   (b) # is the check digit which has 11 possible values from 0 to 9 and A.
+ *
+ * All the letters and numerals of the HKID number, including the check digit without the bracket, are used
+ * as the identifier equivalent to TIN for individuals.
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Hong-Kong-TIN.pdf
+ *   http://www.immd.gov.hk/eng/services/hkid/general_info.html
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { weightedSum } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -()');
+}
+
+const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+const impl: Validator = {
+  name: 'Hong Kong Identity Card Number',
+  localName: '香港身份證',
+  abbreviation: 'HKID',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 8 && value.length !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!/^[A-NP-Z]{1,2}[0-9]{6}[0-9A]$/.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum =
+      (weightedSum(front, {
+        modulus: 11,
+        weights:
+          front.length === 7
+            ? [8, 7, 6, 5, 4, 3, 2, 1]
+            : [9, 8, 7, 6, 5, 4, 3, 2, 1],
+        alphabet,
+      }) +
+        (front.length === 7 ? 5 : 0)) %
+      11;
+
+    if (alphabet[(11 - sum) % 11] !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/hk/index.ts

@@ -0,0 +1 @@
+export * as hkid from './hkid';

package/src/hr/index.ts

@@ -0,0 +1 @@
+export * as oib from './oib';

package/src/hr/oib.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './oib';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('hr/oib', () => {
+  it('format:HR 33392005961', () => {
+    const result = format('HR 33392005961');
+
+    expect(result).toEqual('33392005961');
+  });
+
+  it('validate:HR 33392005961', () => {
+    const result = validate('HR 33392005961');
+
+    expect(result.isValid && result.compact).toEqual('33392005961');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:33392005962', () => {
+    const result = validate('33392005962');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});