stdnum 1.10.0 → 1.10.2

package/src/pe/ruc.ts

@@ -0,0 +1,84 @@
+/**
+ * RUC (Registro Único de Contribuyentes, Peruvian company tax number).
+ *
+ * The RUC (Registro Único de Contribuyentes) is the tax number of Peru assigned
+ * to legal and natural persons. The number consists of 11 digits, the first two
+ * indicate the kind of number, for personal numbers it is followed by the DNI
+ * and a check digit.
+ *
+ * Source
+ *    http://www.sunat.gob.pe/legislacion/ruc/
+ *    https://consultarelruc.pe/
+ *
+ * ENTITY TAX
+ */
+
+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 impl: Validator = {
+  name: 'Peruvian Company Tax Number',
+  localName: 'Registro Único de Contribuyentes',
+  abbreviation: 'RUC',
+
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    if (value.length === 9) {
+      return strings.splitAt(value, 8).join('-');
+    }
+    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 (!['10', '15', '16', '17', '20'].includes(value.substr(0, 2))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, 10);
+    const sum = weightedSum(front, {
+      weights: [5, 4, 3, 2, 7, 6, 5, 4, 3, 2],
+      modulus: 11,
+    });
+
+    if (String((11 - sum) % 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/pk/cnic.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cnic';
+import { InvalidComponent, InvalidLength } from '../exceptions';
+
+describe('pk/cnic', () => {
+  it('format:5410498905786', () => {
+    const result = format('5410498905786');
+
+    expect(result).toEqual('54104-9890578-6');
+  });
+
+  test.each(['54104-9890578-6', '34201-0891231-8'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate_compact:54104-9890578-6', () => {
+    const result = validate('54104-9890578-6');
+
+    expect(result.isValid && result.compact).toEqual('5410498905786');
+  });
+
+  test.each(['34201-0891231-0', '94201-0891231-8'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:54104-9890578', () => {
+    const result = validate('54104-9890578');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/pk/cnic.ts

@@ -0,0 +1,97 @@
+/**
+ * CNIC (Pakistan Computerize National Identiy Card)
+ *
+ * Pakastan National Identification Number (CNIC) is issued to individuals and legal entities for
+ * tax purposes. The number consists of 13 digits.
+ *
+ * The CNIC (Computerised National Identity Card, قومی شناختی کارڈ) or SNIC
+ * (Smart National Identity Card) is issued by by Pakistan's NADRA (National
+ * Database and Registration Authority) to citizens of 18 years or older.
+ * The number consists of 13 digits and encodes the person's locality (5
+ * digits), followed by 7 digit serial number an a single digit indicating
+ * gender.
+ *
+ * Sources
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Pakistan-TIN.pdf
+ *   https://en.wikipedia.org/wiki/CNIC_(Pakistan)
+ *   https://www.nadra.gov.pk/identity/identity-cnic/
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const PROVINCES = {
+  '1': 'Khyber Pakhtunkhwa',
+  '2': 'FATA',
+  '3': 'Punjab',
+  '4': 'Sindh',
+  '5': 'Balochistan',
+  '6': 'Islamabad',
+  '7': 'Gilgit-Baltistan',
+};
+const VALID_PROVINCES = Object.keys(PROVINCES);
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Pakistani Computerized National Identification Number',
+  localName: 'Computerized National Identification Number',
+  abbreviation: 'CNIC',
+
+  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, 5, 12).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() };
+    }
+
+    // Invalid Gender (male = 13579, female = 2468)
+    if (value[12] === '0') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!VALID_PROVINCES.includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    // if (value[12] === '0') {
+    //   return { isValid: false, error: new exceptions.InvalidComponent() };
+    // }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/pk/index.ts

@@ -0,0 +1,2 @@
+export * as cnic from './cnic';
+export * as ntn from './ntn';

package/src/pk/ntn.spec.ts

@@ -0,0 +1,22 @@
+import { validate, format } from './ntn';
+import { InvalidLength } from '../exceptions';
+
+describe('pk/ntn', () => {
+  it('format:1234567', () => {
+    const result = format('1234567');
+
+    expect(result).toEqual('1234567');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.isValid && result.compact).toEqual('1234567');
+  });
+
+  it('validate:123456', () => {
+    const result = validate('123456');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/pk/ntn.ts

@@ -0,0 +1,65 @@
+/**
+ * NTN (Pakistan Tax Identification Number)
+ *
+ * Pakastan National Identification Number (CNIC) is issued to individuals and legal entities for
+ * tax purposes. The number consists of 11 digits.
+ *
+ * Source
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Pakistan-TIN.pdf
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Pakistani National Tax Number',
+  localName: 'National Tax Number',
+  abbreviation: 'NTN',
+
+  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 !== 7) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/pl/index.ts

@@ -0,0 +1,3 @@
+export * as nip from './nip';
+export * as pesel from './pesel';
+export * as regon from './regon';

package/src/pl/nip.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './nip';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('pl/nip', () => {
+  it('format:PL 8567346215', () => {
+    const result = format('PL 8567346215');
+
+    expect(result).toEqual('8567346215');
+  });
+
+  it('validate:PL 8567346215', () => {
+    const result = validate('PL 8567346215');
+
+    expect(result.isValid && result.compact).toEqual('8567346215');
+  });
+
+  it('validate:0000002000', () => {
+    const result = validate('0000002000');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:PL 8567346216', () => {
+    const result = validate('PL 8567346216');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/pl/nip.ts

@@ -0,0 +1,74 @@
+/**
+ * NIP (Numer Identyfikacji Podatkowej, Polish VAT number).
+ *
+ * The NIP (Numer Identyfikacji Podatkowej) number consists of 10 digit with
+ * a straightforward weighted checksum.
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Poland-TIN.pdf
+ *
+ * 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, ' -', 'PL');
+}
+
+const impl: Validator = {
+  name: 'Polish VAT Number',
+  localName: 'Numer Identyfikacji Podatkowej',
+  abbreviation: 'NIP',
+  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 !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = weightedSum(value, {
+      weights: [6, 5, 7, 2, 3, 4, 5, 6, 7, -1],
+      modulus: 11,
+    });
+
+    if (sum !== 0) {
+      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/pl/pesel.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './pesel';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('pl/pesel', () => {
+  it('format:44051401359', () => {
+    const result = format('44051401359');
+
+    expect(result).toEqual('44051401359');
+  });
+
+  test.each(['09222509560', '44051401359'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('cvalidate:44051401359', () => {
+    const result = validate('44051401359');
+
+    expect(result.isValid && result.compact).toEqual('44051401359');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:44051401358', () => {
+    const result = validate('44051401358');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/pl/pesel.ts

@@ -0,0 +1,97 @@
+/**
+ * PESEL (Polish national identification number).
+ *
+ * The Powszechny Elektroniczny System Ewidencji Ludności (PESEL, Universal
+ * Electronic System for Registration of the Population) is a 11-digit Polish
+ * national identification number. The number consists of the date of birth,
+ * a serial number, the person's gender and a check digit.
+ *
+ * Source
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, 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 impl: Validator = {
+  name: 'Polish National Identification Number',
+  localName: 'Powszechny Elektroniczny System Ewidencji Ludności',
+  abbreviation: 'PESEL',
+  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 [yy, mm, dd] = strings.splitAt(value, 2, 4, 6);
+    const month = parseInt(mm, 10);
+
+    let century;
+    if (month >= 80) {
+      century = '18';
+    } else if (month >= 60) {
+      century = '22';
+    } else if (month >= 40) {
+      century = '21';
+    } else if (month >= 20) {
+      century = '20';
+    } else {
+      century = '19';
+    }
+
+    if (!isValidDate(`${century}${yy}`, String(month % 20), dd, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      weights: [1, 3, 7, 9, 1, 3, 7, 9, 1, 3],
+      modulus: 10,
+    });
+
+    if (String((10 - sum) % 10) !== 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/pl/regon.spec.ts

@@ -0,0 +1,52 @@
+import { validate, format } from './regon';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('pl/regon', () => {
+  it('format:123456785', () => {
+    const result = format('123456785');
+
+    expect(result).toEqual('123456785');
+  });
+
+  it('validate:192598184', () => {
+    const result = validate('192598184');
+
+    expect(result.isValid && result.compact).toEqual('192598184');
+  });
+
+  it('validate:123456785', () => {
+    const result = validate('123456785');
+
+    expect(result.isValid && result.compact).toEqual('123456785');
+  });
+
+  it('validate:12345678512347', () => {
+    const result = validate('12345678512347');
+
+    expect(result.isValid && result.compact).toEqual('12345678512347');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:192598183', () => {
+    const result = validate('192598183');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:12345678612342', () => {
+    const result = validate('12345678612342');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:12345678512348', () => {
+    const result = validate('12345678512348');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/pl/regon.ts

@@ -0,0 +1,88 @@
+/**
+ * REGON (Rejestr Gospodarki Narodowej, Polish register of economic units).
+ *
+ * The REGON (Rejestr Gospodarki Narodowej) is a statistical identification
+ * number for businesses. National entities are assigned a 9-digit number, while
+ * local units append 5 digits to form a 14-digit number.
+ *
+ * Source:
+ *    https://bip.stat.gov.pl/en/regon/
+ *    https://wyszukiwarkaregon.stat.gov.pl/appBIR/index.aspx
+ *
+ * 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, ' -');
+}
+
+const impl: Validator = {
+  name: 'Polish Statistical Identificaiton Number',
+  localName: 'Rejestr Gospodarki Narodowej',
+  abbreviation: 'REGON',
+
+  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 && value.length !== 14) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check, , check2] = strings.splitAt(value, 8, 9, -1);
+    const sum = weightedSum(front, {
+      weights: [8, 9, 2, 3, 4, 5, 6, 7],
+      modulus: 11,
+    });
+
+    if (String(sum % 10) !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    if (value.length === 14) {
+      const sum2 = weightedSum(value.substring(0, 13), {
+        weights: [2, 4, 8, 5, 0, 9, 7, 3, 6, 1, 2, 4, 8],
+        modulus: 11,
+      });
+      if (String(sum2 % 10) !== check2) {
+        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;