stdnum 1.10.0 → 1.10.2

package/src/me/pib.spec.ts

@@ -0,0 +1,158 @@
+import { InvalidChecksum, InvalidLength } from '../exceptions';
+import { validate, format } from './pib';
+
+describe('me/pib', () => {
+  it('format:02000989', () => {
+    const result = format('02000989');
+
+    expect(result).toEqual('02000989');
+  });
+
+  test.each([
+    '02000989',
+    '02005115',
+    '02005328',
+    '02007479',
+    '02008599',
+    '02015099',
+    '02017105',
+    '02018560',
+    '02026325',
+    '02033143',
+    '02033356',
+    '02044188',
+    '02046954',
+    '02047403',
+    '02051664',
+    '02052822',
+    '02082390',
+    '02085020',
+    '02087723',
+    '02094754',
+    '02096064',
+    '02096099',
+    '02106183',
+    '02118912',
+    '02126265',
+    '02131013',
+    '02132419',
+    '02160102',
+    '02171058',
+    '02194007',
+    '02196727',
+    '02216078',
+    '02219603',
+    '02241102',
+    '02259974',
+    '02264811',
+    '02265435',
+    '02272296',
+    '02291266',
+    '02293099',
+    '02303213',
+    '02305054',
+    '02305623',
+    '02309084',
+    '02310783',
+    '02313987',
+    '02335450',
+    '02355388',
+    '02357950',
+    '02383136',
+    '02384337',
+    '02385040',
+    '02389231',
+    '02395673',
+    '02404281',
+    '02407515',
+    '02436159',
+    '02437643',
+    '02440768',
+    '02448076',
+    '02454190',
+    '02455455',
+    '02462494',
+    '02465787',
+    '02467593',
+    '02628988',
+    '02630419',
+    '02653753',
+    '02656515',
+    '02671930',
+    '02694638',
+    '02697904',
+    '02702967',
+    '02705001',
+    '02707942',
+    '02709392',
+    '02717557',
+    '02739500',
+    '02751372',
+    '02759519',
+    '02766515',
+    '02769336',
+    '02783746',
+    '02865971',
+    '02868474',
+    '02880474',
+    '02894998',
+    '02896753',
+    '02904870',
+    '02908433',
+    '02952165',
+    '02959801',
+    '02983303',
+    '03016480',
+    '03022480',
+    '03037002',
+    '03099873',
+    '03183246',
+    '03313468',
+    '03328139',
+    '03350479',
+    '03350487',
+    '03350495',
+    '03350509',
+    '03350517',
+    '03350525',
+    '03350533',
+    '03350541',
+    '03350550',
+    '03350568',
+    '03350576',
+    '03350584',
+    '03350592',
+    '03350606',
+    '03350614',
+    '03350622',
+    '03350665',
+    '03350673',
+    '03350681',
+    '03350690',
+    '03350703',
+    '03350789',
+    '03351483',
+    '03352480',
+    '03353486',
+    '03354482',
+    '03355489',
+    '03356485',
+    '03357481',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:0335348', () => {
+    const result = validate('0335348');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:03353487', () => {
+    const result = validate('03353487');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/me/pib.ts

@@ -0,0 +1,77 @@
+/**
+ * PIB (Poreski Identifikacioni Broj, Montenegro tax number).
+ *
+ * This number consists of 8 digits.
+ *
+ * Source
+ *   http://www.pretraga.crps.me:8083/
+ *   https://www.vatify.eu/montenegro-vat-number.html
+ *
+ * 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: 'Montenegro tax number',
+  localName: 'Poreski Identifikacioni Broj',
+  abbreviation: 'PIB',
+
+  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 [front, check] = strings.splitAt(value, 7);
+
+    const sum = weightedSum(front, {
+      weights: [8, 7, 6, 5, 4, 3, 2],
+      modulus: 11,
+    });
+
+    if (String(((11 - sum) % 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/mk/edb.spec.ts

@@ -0,0 +1,50 @@
+import { validate, format } from './edb';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('mk/edb', () => {
+  it('format:МК 4020990116747', () => {
+    const result = format('МК 4020990116747');
+
+    expect(result).toEqual('4020990116747');
+  });
+
+  it('format:MK4057009501106', () => {
+    const result = format('MK4057009501106');
+
+    expect(result).toEqual('4057009501106');
+  });
+
+  it('fvalidate:MK4030000375897', () => {
+    const result = validate('MK4030000375897');
+
+    expect(result.isValid && result.compact).toEqual('4030000375897');
+  });
+
+  test.each([
+    'МК 4020990116747',
+    'MK4057009501106',
+    '4057018541765',
+    '4057019547848',
+    '4061018502090',
+    '4064012500591',
+    '4065015500653',
+    '4069011500670',
+    '4071016500495',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:405701954784', () => {
+    const result = validate('405701954784');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:4057019547840', () => {
+    const result = validate('4057019547840');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/mk/edb.ts

@@ -0,0 +1,88 @@
+/**
+ * ЕДБ (Едниствен Даночен Број, North Macedonia tax number).
+ *
+ * This number consists of 13 digits, sometimes with an additional "MK" prefix.
+ *
+ * Source
+ *   http://www.ujp.gov.mk/en
+ *
+ * ENTITY/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> {
+  // ASCII and Cyrillic prefixes
+  return strings.cleanUnicode(input, ' -', ['MK', 'МК']);
+}
+
+// const validRe = /^[PCGQV]{1}00[A-Z0-9]{8}$/;
+
+// const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'NAME',
+  localName: 'NAME',
+  abbreviation: 'EDB',
+
+  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() };
+    }
+    // if (!validRe.test(value)) {
+    //   return { isValid: false, error: new exceptions.InvalidFormat() };
+    // }
+
+    const [front, check] = strings.splitAt(value, 12);
+
+    const sum =
+      (11 -
+        weightedSum(front, {
+          weights: [7, 6, 5, 4, 3, 2],
+          modulus: 11,
+        })) %
+      11;
+
+    if (String(sum % 10) !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/mk/index.ts

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

package/src/mk/jmbg.ts

@@ -0,0 +1,17 @@
+/**
+ * Macedonian JMBG
+ * https://en.wikipedia.org/wiki/Unique_Master_Citizen_Number
+ */
+
+import { Validator } from '../types';
+import * as jmbg from '../ba/jmbg';
+
+const impl: Validator = {
+  ...jmbg,
+  name: 'Macedonian Unique Master Citizen Number',
+  localName: 'Единствен матичен број на граѓанинот',
+  abbreviation: 'ЕМБГ',
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/mt/index.ts

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

package/src/mt/vat.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('mt/vat', () => {
+  it('format:MT 1167-9112', () => {
+    const result = format('MT 1167-9112');
+
+    expect(result).toEqual('1167-9112');
+  });
+
+  it('validate:MT 1167-9112', () => {
+    const result = validate('MT 1167-9112');
+
+    expect(result.isValid && result.compact).toEqual('11679112');
+  });
+
+  it('validate:123456789', () => {
+    const result = validate('123456789');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:MT 1167-9113', () => {
+    const result = validate('MT 1167-9113');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/mt/vat.ts

@@ -0,0 +1,69 @@
+/**
+ * Maltese VAT Number
+ *
+ * https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Malta-TIN.pdf
+ * https://assets.publishing.service.gov.uk/government/uploads/system/uploads/attachment_data/file/395616/ESL-Foreign-Language-Letter-Malta.pdf
+ *
+ */
+
+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, ' -', 'MT');
+}
+
+const impl: Validator = {
+  name: 'Maltese VAT Number',
+  localName: 'Vat Reg. No.',
+  abbreviation: 'Vat No.',
+  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).join('-');
+  },
+
+  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, {
+      weights: [3, 4, 6, 7, 8, 9, 10, 1],
+      modulus: 37,
+    });
+    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/mu/index.ts

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

package/src/mu/nid.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './nid';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('mu/nid', () => {
+  it('format:M090497290349B', () => {
+    const result = format('M090497290349B');
+
+    expect(result).toEqual('M090497290349B');
+  });
+
+  it('validate:M090497290349B', () => {
+    const result = validate('M090497290349B');
+
+    expect(result.isValid && result.compact).toEqual('M090497290349B');
+  });
+
+  it('validate:L2207971502833', () => {
+    const result = validate('L2207971502833');
+
+    expect(result.isValid && result.compact).toEqual('L2207971502833');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:M090497290348B', () => {
+    const result = validate('M090497290348B');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/mu/nid.ts

@@ -0,0 +1,89 @@
+/**
+ * ID number (Mauritian national identifier).
+ *
+ * The Mauritian national ID number is a unique 14 alphanumeric identifier
+ * assigned at birth to identify individuals. It is displayed on the National
+ * Identity Card.
+ *
+ * The number consists of one alphabetic character and thirteen digits:
+ *  - the first character of the person's surname at birth
+ *  - 2 digits for day of birth
+ *  - 2 digits for month of birth
+ *  - 2 digits for year of birth
+ *  - 6 digit unique id
+ *  - a check digit
+ *
+ * Source
+ *     https://mnis.govmu.org/English/ID%20Card/Pages/default.aspx
+ *
+ * PERSONENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { weightedSum } from '../util/checksum';
+
+const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+const nidRe = /^[A-Z][0-9]+[0-9A-Z]$/;
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const impl: Validator = {
+  name: 'Mauritian National Identifier',
+  localName: 'National Identifier',
+  abbreviation: 'NID',
+  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 !== 14) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!nidRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+    const sum = weightedSum(front, {
+      weights: [14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+      alphabet: ALPHABET,
+      modulus: 17,
+    });
+
+    if (ALPHABET[17 - sum] !== 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;