stdnum 1.10.0 → 1.10.1

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

package/src/id/npwp.ts

@@ -0,0 +1,116 @@
+/**
+ * NPWP (Nomor Pokok Wajib Pajak, Indonesian VAT Number).
+ *
+ * The Nomor Pokok Wajib Pajak (NPWP) is assigned to organisations and
+ * individuals (families) by the Indonesian Tax Office after registration by the
+ * tax payers.
+ *
+ * The number consists of 15 digits of which the first 2 denote the type of
+ * entity, 6 digits to identify the tax payer, a check digit over the first 8
+ * digits followed by 3 digits to identify the local tax office and 3 digits for
+ * branch code.
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Indonesia-TIN.pdf
+ *   https://metacpan.org/pod/Business::ID::NPWP
+ *   https://wiki.scn.sap.com/wiki/display/CRM/Indonesia
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { 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 NPWP_TAX_IDENTITIES = [
+  '01',
+  '02',
+  '21',
+  '31',
+  '00',
+  '20',
+  '04',
+  '05',
+  '06',
+  '07',
+  '08',
+  '09',
+  '24',
+  '25',
+  '26',
+  '31',
+  '34',
+  '35',
+  '36',
+  '47',
+  '48',
+  '49',
+  '57',
+  '58',
+  '67',
+  '77',
+  '78',
+  '79',
+  '87',
+  '88',
+  '89',
+  '97',
+];
+
+const impl: Validator = {
+  name: 'Indonesian VAT Number',
+  localName: 'Nomor Pokok Wajib Pajak',
+  abbreviation: 'NPWP',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    const [a, b, c, d, e, f] = strings.splitAt(value, 2, 5, 8, 9, 12);
+
+    return `${a}.${b}.${c}.${d}-${e}.${f}`;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 15) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!NPWP_TAX_IDENTITIES.includes(value.substr(0, 2))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!luhnChecksumValidate(value.substr(0, 9))) {
+      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/ie/index.ts

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

package/src/ie/pps.spec.ts

@@ -0,0 +1,58 @@
+import { validate, format } from './pps';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ie/pps', () => {
+  it('format:6433435F', () => {
+    const result = format('6433435F');
+
+    expect(result).toEqual('6433435F');
+  });
+
+  it('validate:6433435F', () => {
+    const result = validate('6433435F');
+
+    expect(result.isValid && result.compact).toEqual('6433435F');
+  });
+
+  it('validate:6433435FT', () => {
+    const result = validate('6433435FT');
+
+    expect(result.isValid && result.compact).toEqual('6433435FT');
+  });
+
+  it('validate:6433435FW', () => {
+    const result = validate('6433435FW');
+
+    expect(result.isValid && result.compact).toEqual('6433435FW');
+  });
+
+  it('validate:6433435OA', () => {
+    const result = validate('6433435OA');
+
+    expect(result.isValid && result.compact).toEqual('6433435OA');
+  });
+
+  it('validate:6433435IH', () => {
+    const result = validate('6433435IH');
+
+    expect(result.isValid && result.compact).toEqual('6433435IH');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('1234567891');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:6433435VH', () => {
+    const result = validate('6433435VH');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:6433435E', () => {
+    const result = validate('6433435VH');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ie/pps.ts

@@ -0,0 +1,81 @@
+/**
+ * PPS No (Personal Public Service Number, Irish personal number).
+ *
+ * The Personal Public Service number consists of 7 digits, and one or
+ * two letters. The first letter is a check character.
+ * When present (which should be the case for new numbers as of 2013),
+ * the second letter can be 'A' (for individuals) or 'H' (for
+ * non-individuals, such as limited companies, trusts, partnerships
+ * and unincorporated bodies). Pre-2013 values may have 'W', 'T',
+ * or 'X' as the second letter ; it is ignored by the check.
+ *
+ * Source
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { calcCheckDigit } from './vat';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const ppsRe = /^\d{7}[A-W][AHWTX]?$/;
+
+const impl: Validator = {
+  name: 'Irish Personal Number',
+  localName: 'Personal Public Service Number',
+  abbreviation: 'PPS',
+  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 (!ppsRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length === 9 && 'AH'.includes(value[8])) {
+      if (
+        value[7] !== calcCheckDigit(`${value.substr(0, 7)}${value.substr(8)}`)
+      ) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else if (value[7] !== calcCheckDigit(value.substr(0, 7))) {
+      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/ie/vat.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ie/vat', () => {
+  it('format:IE 6433435OA', () => {
+    const result = format('IE 6433435OA');
+
+    expect(result).toEqual('6433435OA');
+  });
+
+  it('validate:IE 6433435F', () => {
+    const result = validate('IE 6433435F');
+
+    expect(result.isValid && result.compact).toEqual('6433435F');
+  });
+
+  it('validate:IE 6433435OA', () => {
+    const result = validate('IE 6433435OA');
+
+    expect(result.isValid && result.compact).toEqual('6433435OA');
+  });
+
+  it('validate:8D79739I', () => {
+    const result = validate('8D79739I');
+
+    expect(result.isValid && result.compact).toEqual('8D79739I');
+  });
+
+  it('validate:1234567890', () => {
+    const result = validate('1234567890');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:6433435E', () => {
+    const result = validate('6433435E');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ie/vat.ts

@@ -0,0 +1,99 @@
+/**
+ * VAT (Irish tax reference number).
+ *
+ * The Irish VAT number consists of 8 or 9 digits. The number is either 7 digits
+ * and 1 letter (optionally followed by a W for married women), 7 digits and 2
+ * letters, or 6 digits and 2 letters or symbols (in second and last position).
+ *
+ * Source
+ *
+ * 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, ' ', 'IE');
+}
+
+const ALPHABET = 'WABCDEFGHIJKLMNOPQRSTUV';
+
+export function calcCheckDigit(valueIn: string): string {
+  const value = valueIn.padStart(7, '0');
+  const d1 = value
+    .substr(0, 7)
+    .split('')
+    .reduce((acc, vv, idx) => {
+      const v = Number.parseInt(vv, 10);
+
+      return acc + (8 - idx) * v;
+    }, 0);
+
+  const d2 = value.length === 8 ? 9 * ALPHABET.indexOf(value[7]) : 0;
+
+  return ALPHABET[(d1 + d2) % 23];
+}
+
+const impl: Validator = {
+  name: 'Irish VAT Number',
+  localName: 'Cáin Bhreisluacha',
+  abbreviation: 'CBL',
+  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 (!strings.isdigits(value[0]) || !strings.isdigits(value.substr(2, 5))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    const [front, end] = strings.splitAt(value, 7);
+    if (!end.split('').every(v => ALPHABET.includes(v))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (strings.isdigits(front)) {
+      // 7 digits followed by 1 or 2 letters
+      if (value[7] !== calcCheckDigit(`${front}${value.substr(8)}`)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else if ('ABCDEFGHIJKLMNOPQRSTUVWXYZ+*'.includes(value[1])) {
+      // old system, second character is number
+      if (value[7] !== calcCheckDigit(`${value.substr(2, 5)}${value[0]}`)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else {
+      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/il/hp.spec.ts

@@ -0,0 +1,38 @@
+import { validate, format } from './hp';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('th/idnr', () => {
+  it('format:5161-79157', () => {
+    const result = format('5161-79157');
+
+    expect(result).toEqual('516179157');
+  });
+
+  it('validate:516179157', () => {
+    const result = validate('516179157');
+
+    expect(result.isValid && result.compact).toEqual('516179157');
+  });
+
+  it('validate:4161791589', () => {
+    const result = validate('4161791589');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:416179158', () => {
+    const result = validate('416179158');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:516179158', () => {
+    const result = validate('516179158');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});