stdnum 1.10.0 → 1.10.1

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';

package/src/by/unp.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './unp';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('by/unp', () => {
+  it('format:200988541', () => {
+    const result = format('200988541');
+
+    expect(result).toEqual('200988541');
+  });
+
+  it('validate:200988541', () => {
+    const result = validate('200988541');
+
+    expect(result.isValid && result.compact).toEqual('200988541');
+  });
+
+  it('validate:УНП MA1953684', () => {
+    const result = validate('УНП MA1953684');
+
+    expect(result.isValid && result.compact).toEqual('MA1953684');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:200988542', () => {
+    const result = validate('200988542');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/by/unp.ts

@@ -0,0 +1,108 @@
+/**
+ * УНП, UNP (Учетный номер плательщика, the Belarus VAT number).
+ *
+ * The УНП (UNP) or Учетный номер плательщика (Uchetniy nomer platel'shika,
+ * Payer account number) is issued to organisations and individuals for tax
+ * purposes. The number consists of 9 digits (numeric for organisations,
+ * alphanumeric for individuals) and contains a region identifier, a serial per
+ * region and a check digit.
+ *
+ * Source
+ *   https://be.wikipedia.org/wiki/Уліковы_нумар_плацельшчыка
+ *   http://pravo.levonevsky.org/bazaby09/sbor37/text37892/index3.htm
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { weightedSum } from '../util/checksum';
+
+const PREFIX = ['УНП', 'УНП', 'UNP', 'UNP'];
+const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -/');
+
+  if (err !== null) {
+    return [value, err];
+  }
+
+  const v2 = PREFIX.reduce(
+    (acc: string | null, p) =>
+      acc || (!value.startsWith(p) ? acc : value.substr(p.length)),
+    null,
+  );
+
+  return [v2 ?? value, null];
+}
+
+const impl: Validator = {
+  name: 'Belarus VAT Number',
+  localName: 'Учетный номер плательщика',
+  abbreviation: 'УНП (UNP)',
+  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.substr(2))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!strings.isdigits(value[0]) && !'1234567ABCEHKM'.includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!strings.isdigits(value[1]) && !'ABCEHKMOPT'.includes(value[1])) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    let frontClean = front;
+    if (!strings.isdigits(front.substr(0, 2))) {
+      const vv = String('ABCEHKMOPT'.indexOf(front[1]));
+      frontClean = `${front[0]}${vv}${front.substr(2)}`;
+    }
+
+    const sum = weightedSum(frontClean, {
+      modulus: 11,
+      weights: [29, 23, 19, 17, 13, 7, 5, 3],
+      alphabet,
+    });
+
+    if (sum === 10 || String(sum) !== check) {
+      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/bz/index.ts

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

package/src/bz/tin.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './tin';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('bz/tin', () => {
+  it('format:00000510', () => {
+    const result = format('00000510');
+
+    expect(result).toEqual('000005-10');
+  });
+
+  it('validate:00000510', () => {
+    const result = validate('00000510');
+
+    expect(result.isValid && result.compact).toEqual('00000510');
+  });
+
+  it('validate:0000051', () => {
+    const result = validate('0000051');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:00000520', () => {
+    const result = validate('00000520');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});