stdnum 1.10.0 → 1.10.2

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);
+  });
+});

package/src/hr/oib.ts

@@ -0,0 +1,67 @@
+/**
+ * OIB (Osobni identifikacijski broj, Croatian identification number).
+ *
+ * The personal identification number is used to identify persons and legal
+ * entities in Croatia. It has 11 digits (sometimes prefixed by HR), contains
+ * no personal information and uses the ISO 7064 Mod 11, 10 checksum algorithm.
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { iso7064mod10x11validate } from '../util/iso7064';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -', 'HR');
+}
+
+const impl: Validator = {
+  name: 'Croatian Personal Identification Number',
+  localName: 'Osobni Identifikacijski Broj',
+  abbreviation: 'OIB',
+  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() };
+    }
+
+    if (!iso7064mod10x11validate(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/hu/anum.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './anum';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('hu/anum', () => {
+  it('format:HU-12892312', () => {
+    const result = format('HU-12892312');
+
+    expect(result).toEqual('12892312');
+  });
+
+  it('validate:HU-12892312', () => {
+    const result = validate('HU-12892312');
+
+    expect(result.isValid && result.compact).toEqual('12892312');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:HU-12892313', () => {
+    const result = validate('HU-12892313');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/hu/anum.ts

@@ -0,0 +1,71 @@
+/**
+ * ANUM (Közösségi adószám, Hungarian VAT number).
+ *
+ * The ANUM is the Hungarian VAT (Közösségi adószám) number. It is an 8-digit
+ * taxpayer registration number that includes a weighted checksum.
+ *
+ * PERSON/ENTITY
+ */
+
+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, ' -', 'HU');
+}
+
+const impl: Validator = {
+  name: 'Hugarian VAT Number',
+  localName: 'Közösségi Adószám',
+  abbreviation: 'ANUM',
+  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) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = weightedSum(value, {
+      modulus: 10,
+      weights: [9, 7, 3, 1, 9, 7, 3, 1],
+    });
+
+    if (sum !== 0) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/hu/index.ts

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

package/src/id/index.ts

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

package/src/id/npwp.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './npwp';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('id/npwp', () => {
+  it('format:013000666091000', () => {
+    const result = format('013000666091000');
+
+    expect(result).toEqual('01.300.066.6-091.000');
+  });
+
+  it('validate:01.312.166.0-091.000', () => {
+    const result = validate('01.312.166.0-091.000');
+
+    expect(result.isValid && result.compact).toEqual('013121660091000');
+  });
+
+  it('validate:016090524017000', () => {
+    const result = validate('016090524017000');
+
+    expect(result.isValid && result.compact).toEqual('016090524017000');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:216090524017001', () => {
+    const result = validate('216090524017001');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});