stdnum 1.10.0 → 1.10.2

package/src/au/tfn.ts

@@ -0,0 +1,79 @@
+/**
+ * TFN (Australian Tax File Number).
+ *
+ * The Tax File Number (TFN) is issued by the Australian Taxation Office (ATO)
+ * to taxpaying individuals and organisations. A business has both a TFN and an
+ * Australian Business Number (ABN).
+ *
+ * The number consists of 8 (older numbers) or 9 digits and includes a check
+ * digit but otherwise without structure.
+ *
+ * More information:
+ *   https://en.wikipedia.org/wiki/Tax_file_number
+ *   https://www.ato.gov.au/Individuals/Tax-file-number/
+ *
+ * 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, ' ');
+}
+
+const impl: Validator = {
+  name: 'Australian Tax File Number',
+  localName: 'Tax File Number',
+  abbreviation: 'TFN',
+  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, 3, 6).join(' ');
+  },
+
+  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)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = weightedSum(value, {
+      modulus: 11,
+      weights: [1, 4, 3, 7, 5, 8, 6, 9, 10],
+    });
+
+    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/az/index.ts

@@ -0,0 +1,2 @@
+export * as pin from './pin';
+export * as tin from './tin';

package/src/az/pin.spec.ts

@@ -0,0 +1,16 @@
+import { validate, format } from './pin';
+import { InvalidLength } from '../exceptions';
+
+describe('az/pin', () => {
+  it('format:123 123 3', () => {
+    const result = format('123 123 3');
+
+    expect(result).toEqual('1231233');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/az/pin.ts

@@ -0,0 +1,61 @@
+/**
+ *  PIN - Fərdi İdentifikasiya Nömrəsidir (Azerbaijani Personal Identification Number).
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Azerbaijan-TIN.pdf
+ *
+ * PERSON
+ */
+
+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: 'Azerbaijani Personal Identification Number',
+  localName: 'Fərdi İdentifikasiya Nömrəsidir',
+  abbreviation: 'PIN',
+  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() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/az/tin.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './tin';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('az/tin', () => {
+  it('format:123-123-123-1', () => {
+    const result = format('123-123-123-1');
+
+    expect(result).toEqual('1231231231');
+  });
+
+  it('validate:1231231231', () => {
+    const result = validate('1231231231');
+
+    expect(result.isValid && result.compact).toEqual('1231231231');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1231231233', () => {
+    const result = validate('1231231233');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});

package/src/az/tin.ts

@@ -0,0 +1,64 @@
+/**
+ * Vergi identifikasiya nömrəsi (VÖEN) - Azerbaijani Tax Identification Number
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Azerbaijan-TIN.pdf
+ *   https://www.currentschoolnews.com/az/articles/tax-identification-number-application/
+ *
+ * PERSON/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: 'Azerbaijani Tax Identification Number',
+  localName: 'Vergi Identifikasiya Nömrəsi',
+  abbreviation: 'VÖEN',
+  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() };
+    }
+
+    const last = value[9];
+    if (!['1', '2'].includes(last)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: last === '2',
+      isCompany: last === '1',
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ba/index.ts

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

package/src/ba/jmbg.spec.ts

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

package/src/ba/jmbg.ts

@@ -0,0 +1,85 @@
+/**
+ * JMBG (Bosnia and Herzegovina Unique Master Citizen Number).
+ *
+ * Source
+ *    https://en.wikipedia.org/wiki/Unique_Master_Citizen_Number#
+ *
+ * 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: 'Bosnia Unique Master Citizen Number',
+  localName: 'Jedinstveni matični broj građana',
+  abbreviation: 'JMBG',
+  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 !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    // Question the format starts with this according to SI/EMSO
+    //  -- DDMMYYY (year < 800 ? year+=2000 : year+=1000)
+    // Is this universal?
+    const [dd, mm, yyy] = strings.splitAt(value, 2, 4, 7);
+    const yyyy = `${parseInt(yyy, 10) < 800 ? '2' : '1'}${yyy}`;
+
+    if (!isValidDate(yyyy, mm, dd, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, 12);
+
+    const sum =
+      11 -
+      weightedSum(front, {
+        modulus: 11,
+        weights: [7, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2],
+      });
+
+    if (String((sum % 11) % 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/be/bis.spec.ts

@@ -0,0 +1,184 @@
+import { validate, format } from './bis';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('be/bis', () => {
+  it('format:88 22 29-999.70', () => {
+    const result = format('88 02 29-999.70');
+
+    expect(result).toEqual('88022999970');
+  });
+
+  it('validate:1', () => {
+    const result = validate('1');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:88022999990', () => {
+    // A number that validates for NN, should be invalid
+    const result = validate('88022999990');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:88222999936', () => {
+    // A number with an offset of 20, should be valid assuming 19xx
+    const result = validate('88222999936');
+
+    expect(result.isValid && result.compact).toEqual('88222999936');
+  });
+
+  it('validate:08222999934', () => {
+    // A number with an offset of 20, should be valid assuming 20xx
+    const result = validate('08222999934');
+
+    expect(result.isValid && result.compact).toEqual('08222999934');
+  });
+
+  it('validate:88422999979', () => {
+    // A number with an offset of 40, should be valid assuming 19xx
+    const result = validate('88422999979');
+
+    expect(result.isValid && result.compact).toEqual('88422999979');
+  });
+
+  it('validate:08422999977', () => {
+    // A number with an offset of 40, should be valid assuming 20xx
+    const result = validate('08422999977');
+
+    expect(result.isValid && result.compact).toEqual('08422999977');
+  });
+
+  it('validate:96331699989', () => {
+    // A number with an offset of 20, should be invalid due to invalid month
+    const result = validate('96331699989');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:08222999935', () => {
+    // A number with an offset of 20, should be invalid due to invalid checksum
+    const result = validate('08222999935');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:96531699935', () => {
+    // A number with an offset of 40, should be invalid due to invalid month
+    const result = validate('96531699935');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:08451799971', () => {
+    // A number with an offset of 40, should be invalid due to invalid checksum
+    const result = validate('08451799971');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:92612099915', () => {
+    // A number with an offset of 60, should be invalid due to invalid month
+    const result = validate('92612099915');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:99200199926', () => {
+    // A number with an unknown dob offset by 20, should be valid assuming 19xx
+    const result = validate('99200199926');
+
+    expect(result.isValid && result.compact).toEqual('99200199926');
+  });
+
+  it('validate:01200199934', () => {
+    // A number with an unknown dob offset by 20, should be valid assuming 20xx
+    const result = validate('01200199934');
+
+    expect(result.isValid && result.compact).toEqual('01200199934');
+  });
+
+  it('validate:01200199935', () => {
+    // A number with an unknown dob offset by 20, should be invalid by checksum
+    const result = validate('01200199935');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:99400199969', () => {
+    // A number with an unknown dob offset by 40, should be valid assuming 19xx
+    const result = validate('99400199969');
+
+    expect(result.isValid && result.compact).toEqual('99400199969');
+  });
+
+  it('validate:01451599980', () => {
+    // A number with an unknown dob offset by 40, should be valid assuming 20xx
+    const result = validate('01451599980');
+
+    expect(result.isValid && result.compact).toEqual('01451599980');
+  });
+
+  it('validate:01400199977', () => {
+    // A number with an unknown dob offset by 40, should be valid assuming 20xx
+    const result = validate('01400199977');
+
+    expect(result.isValid && result.compact).toEqual('01400199977');
+  });
+
+  it('validate:01400199981', () => {
+    // A number with an unknown dob offset by 40, should be invalid by checksum
+    const result = validate('01400199981');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:00290199976', () => {
+    // A number that starts with 00 can be valid
+    const result = validate('00290199976');
+
+    expect(result.isValid && result.compact).toEqual('00290199976');
+  });
+
+  it('validate:(unspecified date in current year, offset of 20)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}2000999`, 10);
+    const twoPrefixedBaseNumber = parseInt(`${2}${baseNum}`, 10);
+    const checksum = 97 - (twoPrefixedBaseNumber % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+
+  it('validate:(unspecified date in current year, offset of 40)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}4000999`, 10);
+    const twoPrefixedBaseNumber = parseInt(`${2}${baseNum}`, 10);
+    const checksum = 97 - (twoPrefixedBaseNumber % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+
+  it('validate:(unspecified date 100 years ago, offset of 20)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}2000999`, 10);
+    const checksum = 97 - (baseNum % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+
+  it('validate:(unspecified date 100 years ago, offset of 40)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}4000999`, 10);
+    const checksum = 97 - (baseNum % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+});

package/src/be/bis.ts

@@ -0,0 +1,85 @@
+/**
+ * The BIS (Belgian Number for Foreigners) is an identifier for individuals such
+ * as cross-border workers who do not have a Belgian National Number. It has the
+ * same format as the Belgian National Number, but the month digits are increased
+ * by 40 if the sex of the person was known when the number was assigned and by
+ * 20 if not.
+ *
+ * Source
+ *  https://fr.wikipedia.org/wiki/Numéro_de_registre_national (Numéro de sécurité sociale)
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import {
+  validStructure,
+  validChecksum,
+  toDateArray,
+} from './personIdentifierHelpers';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+function toDob(firstSix: string): string {
+  const [y, m, d] = toDateArray(firstSix).map(s => parseInt(s, 10));
+  const adjustedDateArrays = [
+    [y, m - 20, d],
+    [y, m - 40, d],
+  ];
+  // Allow 0 because a 0 month indicates an unknown DOB.
+  const dobArray =
+    adjustedDateArrays.find(ada => ada[1] >= 0 && ada[1] <= 12) || [];
+  return dobArray.map(n => `${n}`.padStart(2, '0')).join('');
+}
+
+const impl: Validator = {
+  name: 'Belgian Number for Foreigners',
+  localName: 'Numéro BIS',
+  abbreviation: 'BIS',
+  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 number = impl.compact(input);
+
+    if (!strings.isdigits(number) || parseInt(number, 10) <= 0) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (number.length !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!validStructure(number, toDob)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!validChecksum(number, toDob)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: number,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/be/index.ts

@@ -0,0 +1,4 @@
+export * as bis from './bis';
+export * as insz from './insz';
+export * as nn from './nn';
+export * as vat from './vat';

package/src/be/insz.spec.ts

@@ -0,0 +1,51 @@
+import { validate, format } from './insz';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('be/insz', () => {
+  it('format:88 02 29-999.90', () => {
+    const result = format('88 02 29-999.90');
+
+    expect(result).toEqual('88022999990');
+  });
+
+  it('validate:1', () => {
+    const result = validate('1');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:88022999990', () => {
+    // Valid only for NN, returns true
+    const result = validate('88022999990');
+
+    expect(result.isValid && result.compact).toEqual('88022999990');
+  });
+
+  it('validate:88222999936', () => {
+    // Valid only for BIS, returns true
+    const result = validate('88222999936');
+
+    expect(result.isValid && result.compact).toEqual('88222999936');
+  });
+
+  it('validate:88150199951', () => {
+    // Invalid Format for both
+    const result = validate('88150199951');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:08222999935', () => {
+    // Invalid format for NN (month + 20), Invalid checksum for BIS
+    const result = validate('08222999935');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:20070199952', () => {
+    // Invalid checksum for NN, Invalid format for BIS
+    const result = validate('20070199952');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});