stdnum 1.9.16 → 1.10.1

package/src/lv/pvn.spec.ts

@@ -0,0 +1,44 @@
+import { validate, format } from './pvn';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('lv/pvn', () => {
+  it('format:LV 4000 3521 600', () => {
+    const result = format('LV 4000 3521 600');
+
+    expect(result).toEqual('4000 3521 600');
+  });
+
+  it('validate:LV 4000 3521 600', () => {
+    const result = validate('LV 4000 3521 600');
+
+    expect(result.isValid && result.compact).toEqual('40003521600');
+  });
+
+  it('validate:161175-19997', () => {
+    const result = validate('161175-19997');
+
+    expect(result.isValid && result.compact).toEqual('16117519997');
+  });
+
+  it('validate:161375-19997', () => {
+    const result = validate('161375-19997');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:40003521601', () => {
+    const result = validate('40003521601');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/lv/pvn.ts

@@ -0,0 +1,102 @@
+/**
+ * VN (Pievienotās vērtības nodokļa, Latvian VAT number).
+ *
+ * The PVN is a 11-digit number that can either be a reference to a legal
+ * entity (in which case the first digit > 3) or a natural person (in which
+ * case it should be the same as the personal code (personas kods)). Personal
+ * codes start with 6 digits to denote the birth date in the form ddmmyy.
+ *
+ * Source
+ *
+ * PERSON/ENTITY
+ */
+
+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, ' -', 'LV');
+}
+
+const impl: Validator = {
+  name: 'Latvian VAT Number',
+  localName: 'Pievienotās Vērtības Nodokļa',
+  abbreviation: 'PVN',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    if ('0123'.includes(value[0])) {
+      return strings.splitAt(value, 6).join('-');
+    }
+
+    return strings.splitAt(value, 4, 8).join(' ');
+  },
+
+  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 isIndividual = '0123'.includes(value[0]);
+
+    if (isIndividual) {
+      const [dd, mm, yy, century] = strings.splitAt(value, 2, 4, 6, 7);
+
+      if (!isValidDate(`${18 + parseInt(century, 10)}${yy}`, mm, dd, true)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+
+      const [front, check] = strings.splitAt(value, -1);
+
+      const sum =
+        1 +
+        weightedSum(front, {
+          weights: [10, 5, 8, 4, 2, 1, 6, 3, 7, 9],
+          modulus: 11,
+        });
+
+      if (String((sum % 11) % 10) !== check) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else {
+      const sum = weightedSum(value, {
+        weights: [9, 1, 4, 8, 3, 10, 2, 5, 7, 6, 1],
+        modulus: 11,
+      });
+
+      if (sum !== 3) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual,
+      isCompany: !isIndividual,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ma/ice.spec.ts

@@ -0,0 +1,39 @@
+import { validate, format } from './ice';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('ma/ice', () => {
+  it('format:0015 1257 2000078', () => {
+    const result = format('0015 1257 2000078');
+
+    expect(result).toEqual('001512572000078');
+  });
+
+  it('validate:00151257200007 8', () => {
+    const result = validate('00151257200007 8');
+
+    expect(result.isValid && result.compact).toEqual('001512572000078');
+  });
+
+  test.each([
+    '001561191000066',
+    '001512572000078',
+    '002410367000010',
+    '002614910000044',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:MA0015125720000', () => {
+    const result = validate('MA0015125720000');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});

package/src/ma/ice.ts

@@ -0,0 +1,72 @@
+/**
+ * ICE (a Moroccan company establishment identification number).
+ *
+ * The ICE (Identifiant Commun de l'Entreprises)
+ * is a 15 (9 positions for the company, 4 positions for the establishment and 2 control digits), digit number used to identify Moroccan companies' establishments
+ * and facilities. The validation checksum is unknown
+ *
+ * Sources
+ *   https://www.ice.gov.ma/
+ *   https://www.ice.gov.ma/ICE/Depliant_ICE.pdf
+ *   https://www.ice.gov.ma/ICE/Guide_ICE.pdf
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, mod97base10Validate } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -/');
+}
+
+const impl: Validator = {
+  name: 'Moroccan Company Establishment Identification Number',
+  localName: "Identifiant Commun de l'Entreprises",
+  abbreviation: 'ICE',
+  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 !== 15) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!mod97base10Validate(value, 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/ma/ice9.spec.ts

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

package/src/ma/ice9.ts

@@ -0,0 +1,62 @@
+/**
+ * ICE (a Moroccan company establishment identification number).
+ *
+ * The ICE (Identifiant Commun de l'Entreprise)
+ * is a 15 (9 positions for the company, 4 positions for the establishment and 2 control digits), digit number used to identify Moroccan companies' establishments
+ * and facilities. The validation checksum is unknown
+ *
+ *
+ * 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: 'Moroccan Company Number',
+  localName: "Numero d'Entreprise",
+  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) {
+      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/ma/index.ts

@@ -0,0 +1,2 @@
+export * as ice from './ice';
+export * as ice9 from './ice9';

package/src/mc/index.ts

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

package/src/mc/tva.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './tva';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('mc/tva', () => {
+  it('format:53 0000 04605', () => {
+    const result = format('53 0000 04605');
+
+    expect(result).toEqual('53000004605');
+  });
+
+  it('validate:53 0000 04605', () => {
+    const result = validate('53 0000 04605');
+
+    expect(result.isValid && result.compact).toEqual('53000004605');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:FR 61 954 506 077', () => {
+    const result = validate('FR 61 954 506 077');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/mc/tva.ts

@@ -0,0 +1,67 @@
+/**
+ * n° TVA (taxe sur la valeur ajoutée, Monacan VAT number).
+ *
+ * For VAT purposes Monaco is treated as territory of France. The number is
+ * also validated the same as the French TVA, except that it is not based on
+ * a French SIREN.
+ *
+ * Source
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as frValidate } from '../fr/tva';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ', 'FR');
+}
+
+const impl: Validator = {
+  name: 'Monacan VAT Number',
+  localName: "Numéro d'Identification à la Taxe sur la Valeur Ajoutée",
+  abbreviation: 'n° TVA',
+  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 };
+    }
+
+    const r = frValidate(value);
+    if (!r.isValid) {
+      return r;
+    }
+    if (value.substr(2, 3) !== '000') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/md/idno.spec.ts

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

package/src/md/idno.ts

@@ -0,0 +1,78 @@
+/**
+ * IDNO (Moldavian company identification number).
+ *
+ * The IDNO is used in Moldavia as unique identifier for legal entities. The
+ * number consists of 13 digits. The first digit identifies the registry,
+ * followed by three digits for the year the code was assigned. The number ends
+ * with five identifier digits and a check digit.
+ *
+ * Source
+ *    https://www.idno.md
+ *    https://kls.md/paves-the-way-for-an-eventual-merger/
+ *
+ * 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: 'Moldavian Company Identification Number',
+  localName: 'Unique State Identification Number',
+  abbreviation: 'IDNO',
+  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() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      weights: [7, 3, 1, 7, 3, 1, 7, 3, 1, 7, 3, 1],
+      modulus: 10,
+    });
+    if (String(sum) !== 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/md/index.ts

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

package/src/me/index.ts

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

package/src/me/jmbg.ts

@@ -0,0 +1,17 @@
+/**
+ * Montenegrin 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: 'Montenegrin Unique Master Citizen Number',
+  localName: ' Јединствени матични број грађана',
+  abbreviation: 'ЈМБГ',
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;