stdnum 1.10.0 → 1.10.2

package/src/be/vat.ts

@@ -0,0 +1,84 @@
+/**
+ * BTW, TVA, NWSt, ondernemingsnummer (Belgian enterprise number).
+ *
+ * The enterprise number (ondernemingsnummer) is a unique identifier of
+ * companies within the Belgian administrative services. It was previously
+ * the VAT ID number. The number consists of 10 digits.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  // eslint-disable-next-line prefer-const
+  let [value, err] = strings.cleanUnicode(input, ' -.');
+
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('BE')) {
+    value = value.substr(2);
+  }
+  if (value.startsWith('(0)')) {
+    value = `0${value.substr(3)}`;
+  }
+  if (value.length === 9) {
+    value = `0${value}`;
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Belgian VAT Number',
+  localName: 'Ondernemingsnummer',
+  abbreviation: 'BTW, NWSt',
+  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 [front, sum] = strings.splitAt(value, -2);
+
+    if (97 - (parseInt(front, 10) % 97) !== parseInt(sum, 10)) {
+      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/bg/egn.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './egn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('bg/egn', () => {
+  it('format:752316 926 3', () => {
+    const result = format('752316 926 3');
+
+    expect(result).toEqual('7523169263');
+  });
+
+  it('validate:8032056031', () => {
+    const result = validate('8032056031');
+
+    expect(result.isValid && result.compact).toEqual('8032056031');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:8032056032', () => {
+    const result = validate('8032056032');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/bg/egn.ts

@@ -0,0 +1,75 @@
+/**
+ * EGN (ЕГН, Единен граждански номер, Bulgarian personal identity codes).
+ *
+ * It is a 10-digit number of which the first 6 digits denote the person's
+ * birth date, the next three digits represent a birth order number from
+ * which the person's gender can be determined and the last digit is a check
+ * digit.
+ *
+ * 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> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+const impl: Validator = {
+  name: 'Bulgarian Personal Identity Codes',
+  localName: 'Единен граждански номер',
+  abbreviation: 'ЕГН (EGN)',
+  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 [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      modulus: 11,
+      weights: [2, 4, 8, 5, 10, 9, 7, 3, 6],
+    });
+
+    if (String(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/bg/index.ts

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

package/src/bg/pnf.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './pnf';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('bg/pnf', () => {
+  it('format:7111 042 925', () => {
+    const result = format('7111 042 925');
+
+    expect(result).toEqual('7111042925');
+  });
+
+  it('validate:7111 042 925', () => {
+    const result = validate('7111 042 925');
+
+    expect(result.isValid && result.compact).toEqual('7111042925');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:7111 042 926', () => {
+    const result = validate('7111 042 926');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/bg/pnf.ts

@@ -0,0 +1,73 @@
+/**
+ * PNF (ЛНЧ, Личен номер на чужденец, Bulgarian number of a foreigner).
+ *
+ * The personal number of a foreigner is a 10-digit number where the last digit
+ * is the result of a weighted checksum.
+ *
+ * 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> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+const impl: Validator = {
+  name: 'Bulgarian Number of a Foreigner',
+  localName: 'Личен номер на чужденец',
+  abbreviation: 'PNF (ЛНЧ)',
+  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 [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      weights: [21, 19, 17, 13, 11, 9, 7, 3, 1],
+      modulus: 10,
+    });
+
+    if (String(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;

package/src/bg/vat.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('bg/vat', () => {
+  it('format:BG 175 074 752', () => {
+    const result = format('BG 175 074 752');
+
+    expect(result).toEqual('175074752');
+  });
+
+  it('validate:BG 175 074 752', () => {
+    const result = validate('BG 175 074 752');
+
+    expect(result.isValid && result.compact).toEqual('175074752');
+  });
+
+  it('validate:175 074 752', () => {
+    const result = validate('175 074 752');
+
+    expect(result.isValid && result.compact).toEqual('175074752');
+  });
+
+  it('validate:BG 175 074 75', () => {
+    const result = validate('BG 175 074 75');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:BG 175 074 754', () => {
+    const result = validate('BG 175 074 754');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/bg/vat.ts

@@ -0,0 +1,120 @@
+/**
+ * VAT (Идентификационен номер по ДДС, Bulgarian VAT number).
+ *
+ * The Bulgarian VAT (Данък върху добавената стойност) number is either 9
+ * (for legal entities) or 10 digits (for physical persons, foreigners and
+ * others) long. Each type of number has its own check digit algorithm.
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import * as egn from './egn';
+import * as pnf from './pnf';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { weightedSum } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -/');
+
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('BG')) {
+    return [value.substr(2), null];
+  }
+  return [value, err];
+}
+
+function checkLegal(value: string): boolean {
+  const [front, check] = strings.splitAt(value, -1);
+
+  let sum = weightedSum(front, {
+    modulus: 11,
+    weights: [1, 2, 3, 4, 5, 6, 7, 8],
+  });
+
+  if (sum === 10) {
+    sum = weightedSum(front, {
+      modulus: 11,
+      weights: [3, 4, 5, 6, 7, 8, 9, 10],
+    });
+  }
+
+  return String(sum % 10) === check;
+}
+
+function checkOther(value: string): boolean {
+  const [front, check] = strings.splitAt(value, -1);
+
+  const sum =
+    11 -
+    weightedSum(front, {
+      modulus: 11,
+      weights: [4, 3, 2, 7, 6, 5, 4, 3, 2],
+    });
+
+  return String(sum % 10) !== check;
+}
+
+const impl: Validator = {
+  name: 'Bulgarian VAT Number',
+  localName: 'Идентификационен номер по ДДС',
+  abbreviation: 'ДДС номер',
+  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 !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!['0', '1', '2', '3', '9'].includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length === 9) {
+      if (!checkLegal(value)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else if (
+      !egn.validate(value).isValid &&
+      !pnf.validate(value).isValid &&
+      !checkOther(value)
+    ) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: value.length === 10,
+      isCompany: value.length === 9,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/br/cnpj.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cnpj';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('br/cnpj', () => {
+  it('format:16727230000197', () => {
+    const result = format('16727230000197');
+
+    expect(result).toEqual('16.727.230/0001-97');
+  });
+
+  it('validate:16.727.230/0001-97', () => {
+    const result = validate('16.727.230/0001-97');
+
+    expect(result.isValid && result.compact).toEqual('16727230000197');
+  });
+
+  it('validate:660-3', () => {
+    const result = validate('660-3');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:16.727.230.0001-98', () => {
+    const result = validate('16.727.230.0001-98');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:16.727.230/0001=9', () => {
+    const result = validate('16.727.230/0001=9');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});

package/src/br/cnpj.ts

@@ -0,0 +1,89 @@
+/**
+ * CNPJ (Cadastro Nacional da Pessoa Jurídica, Brazilian company identifier).
+ *
+ * Numbers from the national register of legal entities have 14 digits. The
+ * first 8 digits identify the company, the following 4 digits identify a
+ * business unit and the last 2 digits are check digits.
+ *
+ * Sources:
+ *
+ * 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, ' -./');
+}
+
+function computeDigit(input: string): number {
+  const mlen = input.length + 7;
+
+  const value =
+    11 -
+    (input
+      .split('')
+      .map((v, idx) => parseInt(v, 10) * (((mlen - idx) % 8) + 2))
+      .reduce((acc, v) => acc + v) %
+      11);
+
+  return value > 9 ? 0 : value;
+}
+
+const impl: Validator = {
+  name: 'Brazilian Company Identifier',
+  localName: 'Cadastro Nacional da Pessoa Jurídica',
+  abbreviation: 'CNPJ',
+  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] = strings.splitAt(value, 2, 5, 8, 12);
+
+    return `${a}.${b}.${c}/${d}-${e}`;
+  },
+
+  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 (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, c1, c2] = strings.splitAt(value, 12, 13);
+
+    const d1 = String(computeDigit(front));
+    const d2 = String(computeDigit(value.substr(0, 13)));
+
+    if (d1 !== c1 || d2 !== c2) {
+      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/br/cpf.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cpf';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('br/cpf', () => {
+  it('format:23100299900', () => {
+    const result = format('23100299900');
+
+    expect(result).toEqual('231.002.999-00');
+  });
+
+  it('validate:390.533.447-05', () => {
+    const result = validate('390.533.447-05');
+
+    expect(result.isValid && result.compact).toEqual('39053344705');
+  });
+
+  it('validate:660-3', () => {
+    const result = validate('660-3');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:231.002.999-00', () => {
+    const result = validate('231.002.999-00');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:390.533.447=0', () => {
+    const result = validate('390.533.447=0');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});

package/src/br/cpf.ts

@@ -0,0 +1,87 @@
+/**
+ * CPF (Cadastro de Pessoas Físicas, Brazilian national identifier).
+ *
+ * The Cadastro de Pessoas Físicas is the Brazilian identification number
+ * assigned to individuals for tax purposes. The number consists of 11 digits
+ * and includes two check digits.
+ *
+ * Source
+ *     https://en.wikipedia.org/wiki/Cadastro_de_Pessoas_Físicas
+ *
+ * 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, ' -.');
+}
+
+function computeDigit(input: string): number {
+  const mlen = input.length + 1;
+
+  const value = input
+    .split('')
+    .map((v, idx) => parseInt(v, 10) * (mlen - idx))
+    .reduce((acc, v) => (acc + v) % 11);
+
+  return value < 2 ? 0 : 11 - value;
+}
+
+const impl: Validator = {
+  name: 'Brazilian National Identifier',
+  localName: 'Cadastro de Pessoas Físicas',
+  abbreviation: 'CPF',
+  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] = strings.splitAt(value, 3, 6, input.length - 2);
+
+    return `${a}.${b}.${c}-${d}`;
+  },
+
+  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 [front, c1, c2] = strings.splitAt(value, 9, 10);
+
+    const d1 = String(computeDigit(front));
+    const d2 = String(computeDigit(value.substr(0, 10)));
+
+    if (d1 !== c1 || d2 !== c2) {
+      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/br/index.ts

@@ -0,0 +1,2 @@
+export * as cnpj from './cnpj';
+export * as cpf from './cpf';

package/src/by/index.ts

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