stdnum 1.9.16 → 1.10.1

package/src/cu/ni.ts

@@ -0,0 +1,74 @@
+/**
+ * NI (Número de identidad, Cuban identity card numbers).
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const impl: Validator = {
+  name: 'Cuban Identity Card Number',
+  localName: 'Número de Identidad',
+  abbreviation: 'NI',
+  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 !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [yy, mm, dd, cen] = strings.splitAt(value, 2, 4, 6, 7);
+    let year;
+    if ('012345'.includes(cen)) {
+      year = `19${yy}`;
+    } else if ('678'.includes(cen)) {
+      year = `20${yy}`;
+    } else if (cen === '9') {
+      year = `18${yy}`;
+    } else {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!isValidDate(year, mm, dd, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cy/index.ts

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

package/src/cy/vat.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('cy/vat', () => {
+  it('format:CY-10259033P', () => {
+    const result = format('CY-10259033P');
+
+    expect(result).toEqual('10259033P');
+  });
+
+  it('validate:CY-10259033P', () => {
+    const result = validate('CY-10259033P');
+
+    expect(result.isValid && result.compact).toEqual('10259033P');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:CY-10259033Z', () => {
+    const result = validate('CY-10259033Z');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/cy/vat.ts

@@ -0,0 +1,98 @@
+/**
+ * Αριθμός Εγγραφής Φ.Π.Α. (Cypriot VAT number).
+ *
+ * The Cypriot Αριθμός Εγγραφής Φ.Π.Α. (VAT) number consists of 9 digits
+ * where the last one is a is a letter and functions as a check digit.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const weights: Record<string, number> = {
+  '0': 1,
+  '1': 0,
+  '2': 5,
+  '3': 7,
+  '4': 9,
+  '5': 13,
+  '6': 15,
+  '7': 17,
+  '8': 19,
+  '9': 21,
+};
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('CY')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Cypriot 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) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    const [front, check] = strings.splitAt(value, -1);
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!alphabet.includes(check)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = front
+      .split('')
+      .map(v => parseInt(v, 10))
+      .reduce((acc, v, idx) => acc + (idx % 2 === 0 ? weights[v] : v), 0);
+
+    if (alphabet[sum % 26] !== 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/cz/dic.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './dic';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('cz/dic', () => {
+  it('format:CZ 25123891', () => {
+    const result = format('CZ 25123891');
+
+    expect(result).toEqual('25123891');
+  });
+
+  it('validate:CZ 25123891', () => {
+    const result = validate('CZ 25123891');
+
+    expect(result.isValid && result.compact).toEqual('25123891');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:25123890', () => {
+    const result = validate('25123890');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/cz/dic.ts

@@ -0,0 +1,127 @@
+/**
+ * DIČ (Daňové identifikační číslo, Czech VAT number).
+ *
+ * The number is an 8, 9 or 10 digit code that includes a check digit and is
+ * used to uniquely identify taxpayers for VAT (DPH in Czech). The number can
+ * refer to legal entities (8 digit numbers), individuals with a RČ (the 9 or
+ * 10 digit Czech birth number) or individuals without a RČ (9 digit numbers
+ * that begin with a 6).
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as rcValidate } from './rc';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('CZ')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+function checkLegal(value: string): boolean {
+  const [front, check] = strings.splitAt(value, -1);
+
+  const sum = weightedSum(front, {
+    modulus: 11,
+    weights: [8, 7, 6, 5, 4, 3, 2, 1],
+  });
+
+  const v = (11 - sum) % 11;
+
+  return (v === 0 ? '1' : String(v % 10)) === check;
+}
+
+function checkSpecial(value: string): boolean {
+  // check = sum((8 - i) * int(n) for i, n in enumerate(number)) % 11
+
+  // return str((8 - (10 - check) % 11) % 10)
+
+  const [front, check] = strings.splitAt(value, -1);
+
+  const sum = weightedSum(front, {
+    modulus: 11,
+    weights: [8, 7, 6, 5, 4, 3, 2, 1],
+  });
+  const digit = String((8 - ((10 - sum) % 11)) % 10);
+
+  return digit === check;
+}
+
+const impl: Validator = {
+  name: 'Czech VAT Number',
+  localName: 'Daňové identifikační číslo',
+  abbreviation: 'DIČ',
+
+  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 (![8, 9, 10].includes(value.length)) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length === 8) {
+      if (value.startsWith('9')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+
+      if (!checkLegal(value)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+
+      return {
+        isValid: true,
+        compact: value,
+        isIndividual: false,
+        isCompany: true,
+      };
+    }
+    if (value.length === 9 && value.startsWith('6')) {
+      if (!checkSpecial(value)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+
+      return {
+        isValid: true,
+        compact: value,
+        isIndividual: false,
+        isCompany: true,
+      };
+    }
+
+    return rcValidate(value);
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cz/index.ts

@@ -0,0 +1,2 @@
+export * as dic from './dic';
+export * as rc from './rc';

package/src/cz/rc.spec.ts

@@ -0,0 +1,44 @@
+import { validate, format } from './rc';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('cz/rc', () => {
+  it('format:7103192745', () => {
+    const result = format('7103192745');
+
+    expect(result).toEqual('710319/2745');
+  });
+
+  it('validate:710319/2745', () => {
+    const result = validate('710319/2745');
+
+    expect(result.isValid && result.compact).toEqual('7103192745');
+  });
+
+  it('validate:991231123', () => {
+    const result = validate('991231123');
+
+    expect(result.isValid && result.compact).toEqual('991231123');
+  });
+
+  it('validate:1103492745', () => {
+    const result = validate('1103492745');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:590312/12', () => {
+    const result = validate('590312/12');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:7103192746', () => {
+    const result = validate('7103192746');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/cz/rc.ts

@@ -0,0 +1,95 @@
+/**
+ * RČ (Rodné číslo, the Czech birth number).
+ *
+ * The birth number (RČ, Rodné číslo) is the Czech national identifier. The
+ * number can be 9 or 10 digits long. Numbers given out after January 1st
+ * 1954 should have 10 digits. The number includes the birth date of the
+ * person and their gender.
+ *
+ * This number is identical to the Slovak counterpart.
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' /');
+}
+
+const impl: Validator = {
+  name: 'Czech Birth Number',
+  localName: 'Rodné číslo',
+  abbreviation: 'RČ',
+  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, 6).join('/');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 10 && value.length !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [yy, mm, dd] = strings.splitAt(value, 2, 4, 6);
+    // Gender encode in month, Y2K incoded as well
+    const mon = (parseInt(mm, 10) % 50) % 20;
+    let year = parseInt(yy, 10) + 1900;
+    if (value.length === 9) {
+      if (year > 1980) {
+        year -= 100;
+      }
+      if (year > 1953) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else if (year < 1954) {
+      year += 100;
+    }
+    if (!isValidDate(String(year), String(mon), dd, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    // 9 digit numbers were used until 1954
+    // only 10 digit numbers have check digits
+    if (value.length === 10) {
+      const [front, check] = strings.splitAt(value, -1);
+
+      const sum = (parseInt(front, 10) % 11) % (year < 1985 ? 10 : 11);
+
+      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/de/idnr.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './idnr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('de/idnr', () => {
+  it('format:36574261809', () => {
+    const result = format('36574261809');
+
+    expect(result).toEqual('36 574 261 809');
+  });
+
+  test.each(['36574261809'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid && result.compact).toEqual(value);
+  });
+
+  it('validate:36 574 261 809', () => {
+    const result = validate('36 574 261 809');
+
+    expect(result.isValid && result.compact).toEqual('36574261809');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:36574261808', () => {
+    const result = validate('36574261808');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/de/idnr.ts

@@ -0,0 +1,91 @@
+/**
+ * IdNr (Steuerliche Identifikationsnummer, German personal tax number).
+ *
+ * The IdNr (or Steuer-IdNr) is a personal identification number that is
+ * assigned to individuals in Germany for tax purposes and is meant to replace
+ * the Steuernummer. The number consists of 11 digits and does not embed any
+ * personal information.
+ *
+ * Source
+ *   https://de.wikipedia.org/wiki/Steuerliche_Identifikationsnummer
+ *   http://www.identifikationsmerkmal.de/
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { iso7064mod10x11validate } from '../util/iso7064';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -./,');
+}
+
+const impl: Validator = {
+  name: 'German Personal Tax Number',
+  localName: 'Steuerliche Identifikationsnummer',
+  abbreviation: 'IdNr',
+  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, 2, 5, 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() };
+    }
+    if (value[0] === '0') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    // In the first 10 digits exactly one digit must be repeated two or
+    // three times and other digits can appear only once.
+    const counter: Record<number, number> = {};
+
+    value
+      .substr(0, 10)
+      .split('')
+      .map(v => parseInt(v, 10))
+      .forEach(v => {
+        counter[v] = (counter[v] ?? 0) + 1;
+      });
+    const more = Object.values(counter).filter(v => v > 1);
+    if (more.length !== 1 && [2, 3].includes(more[0])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!iso7064mod10x11validate(value)) {
+      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/de/index.ts

@@ -0,0 +1,6 @@
+export * as idnr from './idnr';
+export * as pwnr from './pwnr';
+export * as stnr from './stnr';
+export * as svnr from './svnr';
+export * as vat from './vat';
+export * as passport from './passport';

package/src/de/passport.spec.ts

@@ -0,0 +1,31 @@
+import { validate, format } from './passport';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('de/idnr', () => {
+  it('format:C01X00T47', () => {
+    const result = format('C01X00T47');
+
+    expect(result).toEqual('C01X00T47');
+  });
+
+  test.each(['C01X00T47', 'C01X00T478', 'CZ6311T472D'])(
+    'validate:%s',
+    value => {
+      const result = validate(value);
+
+      expect(result.isValid).toBeTruthy();
+    },
+  );
+
+  test.each(['C01X00T47999', 'C01X00T4'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:C01X00T479', () => {
+    const result = validate('C01X00T479');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});