stdnum 1.10.0 → 1.10.2

package/src/de/stnr.ts

@@ -0,0 +1,193 @@
+/**
+ * St.-Nr. (Steuernummer, German tax number).
+ *
+ * The Steuernummer (St.-Nr.) is a tax number assigned by regional tax offices
+ * to taxable individuals and organisations. The number is being replaced by the
+ * Steuerliche Identifikationsnummer (IdNr).
+ * The number has 10 or 11 digits for the regional form (per Bundesland) and 13
+ * digits for the number that is unique within Germany. The number consists of
+ * (part of) the Bundesfinanzamtsnummer (BUFA-Nr.), a district number, a serial
+ * number and a check digit.
+ *
+ * Source
+ *    https://de.wikipedia.org/wiki/Steuernummer
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+// import { mod11mod10Validate } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -./,');
+}
+
+type Match =
+  | { match: false }
+  | {
+      match: true;
+      f: string;
+      b: string;
+      u: string;
+      p: string;
+    };
+
+type MFunc = (v: string) => Match;
+
+function buildMatch(fmt: string): MFunc {
+  const pattern = fmt.replace(/([FBUP])\1*/g, m => {
+    return `(\\d{${m.length}})`;
+  });
+  const matcher = new RegExp(`^${pattern}$`);
+
+  return (value: string): Match => {
+    const m = matcher.exec(value);
+
+    if (!m) {
+      return { match: false };
+    }
+
+    return {
+      match: true,
+      f: m[1] ?? '',
+      b: m[2] ?? '',
+      u: m[3] ?? '',
+      p: m[4] ?? '',
+    };
+  };
+}
+
+function buildMatcher(
+  rfmt: string,
+  cfmt: string,
+): {
+  region: MFunc;
+  country: MFunc;
+} {
+  return {
+    region: buildMatch(rfmt),
+    country: buildMatch(cfmt),
+  };
+}
+
+const REGION_FORMATS = {
+  'DE-BW': buildMatcher('FFBBBUUUUP', '28FF0BBBUUUUP'),
+  'DE-BY': buildMatcher('FFFBBBUUUUP', '9FFF0BBBUUUUP'),
+  'DE-BE': buildMatcher('FFBBBUUUUP', '11FF0BBBUUUUP'),
+  'DE-BB': buildMatcher('0FFBBBUUUUP', '30FF0BBBUUUUP'),
+  'DE-HB': buildMatcher('FFBBBUUUUP', '24FF0BBBUUUUP'),
+  'DE-HH': buildMatcher('FFBBBUUUUP', '22FF0BBBUUUUP'),
+  'DE-HE': buildMatcher('0FFBBBUUUUP', '26FF0BBBUUUUP'),
+  'DE-MV': buildMatcher('0FFBBBUUUUP', '40FF0BBBUUUUP'),
+  'DE-NI': buildMatcher('FFBBBUUUUP', '23FF0BBBUUUUP'),
+  'DE-NW': buildMatcher('FFFBBBBUUUP', '5FFF0BBBBUUUP'),
+  'DE-RP': buildMatcher('FFBBBUUUUP', '27FF0BBBUUUUP'),
+  'DE-SL': buildMatcher('0FFBBBUUUUP', '10FF0BBBUUUUP'),
+  'DE-SN': buildMatcher('2FFBBBUUUUP', '32FF0BBBUUUUP'),
+  'DE-ST': buildMatcher('1FFBBBUUUUP', '31FF0BBBUUUUP'),
+  'DE-SH': buildMatcher('FFBBBUUUUP', '21FF0BBBUUUUP'),
+  'DE-TH': buildMatcher('1FFBBBUUUUP', '41FF0BBBUUUUP'),
+};
+
+function findMatch(value: string): Match | null {
+  let result: Match | null = null;
+
+  Object.values(REGION_FORMATS).some(({ region, country }) => {
+    const rResult = region(value);
+    if (rResult.match) {
+      result = rResult;
+
+      return true;
+    }
+    const cResult = country(value);
+    if (cResult.match) {
+      result = cResult;
+
+      return true;
+    }
+
+    return false;
+  });
+
+  return result;
+}
+
+const impl: Validator = {
+  name: 'German Tax Number',
+  localName: 'Steuernummer',
+  abbreviation: ' St.-Nr.',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    const match = findMatch(input);
+
+    if (!match || !match.match) {
+      return value;
+    }
+
+    return `${match.f}/${match.b}/${match.u} ${match.p}`;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (![10, 11, 13].includes(value.length)) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    // Make sure it's the same as a region
+    if (findMatch(value) === null) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    // In the first 10 digits exactly one digit must be repeated two or
+    // three times and other digits can appear only once.
+    // Starting at 2017, the rule is, that within the first ten digits one number has to
+    // appear exactly twice or thrice.
+    const counter: Record<string, number> = {};
+
+    value
+      .substring(0, 10)
+      .split('')
+      .forEach(v => {
+        counter[v] = (counter[v] ?? 0) + 1;
+      });
+    const more = Object.values(counter); // .filter(v => v > 1);
+    if (!more.some(v => v === 2 || v === 3)) {
+      // if (more.length !== 1 && [2, 3].includes(more[0])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    // if (!mod11mod10Validate(value)) {
+    //   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/de/svnr.spec.ts

@@ -0,0 +1,56 @@
+import { validate, format } from './svnr';
+import {
+  InvalidLength,
+  InvalidComponent,
+  InvalidChecksum,
+} from '../exceptions';
+
+describe('de/svnr', () => {
+  it('format:15070649C103', () => {
+    const result = format('15070649C103');
+    expect(result).toEqual('15 070649 C 103');
+  });
+
+  it('validate:15 070649 C 103', () => {
+    const result = validate('15 070649 C 103');
+    expect(result.isValid && result.compact).toEqual('15070649C103');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+  // // Invalid Area Code
+  it('validate:01070649C103', () => {
+    const result = validate('01070649C103');
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+  // Invalid Birth month (13)
+  it('validate:15071349C103', () => {
+    const result = validate('15071349C103');
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+  // Invalid Checksum
+  it('validate:15070649C102', () => {
+    const result = validate('15070649C102');
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+  describe('invalid component cases', () => {
+    it('validate:15JU0649C102', () => {
+      const result = validate('15JU0649C102');
+      expect(result.error).toBeInstanceOf(InvalidComponent);
+    });
+    it('validate:1507064CC102', () => {
+      const result = validate('1507064CC102');
+      expect(result.error).toBeInstanceOf(InvalidComponent);
+    });
+    it('validate:150706499102', () => {
+      const result = validate('150706499102');
+      expect(result.error).toBeInstanceOf(InvalidComponent);
+    });
+    it('validate:15070649CC03', () => {
+      const result = validate('15070649CC03');
+      expect(result.error).toBeInstanceOf(InvalidComponent);
+    });
+  });
+});

package/src/de/svnr.ts

@@ -0,0 +1,158 @@
+/**
+ * SVNR or RVNR (Sozialversicherungsnummer, German social security / pension insurance number).
+ *
+ * The SVNR (or RVNR) is the German social security / pension insurance number.
+ * It's also called a social insuarance number. The number consists of 12 digits.
+ *
+ * Source
+ *   https://de.wikipedia.org/wiki/Versicherungsnummer
+ *   https://allaboutberlin.com/guides/german-versicherungsnummer
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { weightedSum } from '../util/checksum';
+import { Validator, ValidateReturn } from '../types';
+
+const AREA_NUMBER_OPTIONS = [
+  '02',
+  '03',
+  '04',
+  '08',
+  '09',
+  '10',
+  '11',
+  '12',
+  '13',
+  '14',
+  '15',
+  '16',
+  '17',
+  '18',
+  '19',
+  '20',
+  '21',
+  '23',
+  '24',
+  '25',
+  '26',
+  '28',
+  '29',
+  '38',
+  '39',
+  '40',
+  '80',
+  '81',
+  '82',
+  '89',
+].concat([...Array(79 - 42 + 1).keys()].map(x => (x + 42).toString())); // '42'-'79'
+
+const BIRTH_MONTH_OPTIONS = [
+  '01',
+  '02',
+  '03',
+  '04',
+  '05',
+  '06',
+  '07',
+  '08',
+  '09',
+  '10',
+  '11',
+  '12',
+];
+
+const checkAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const checkAlphabetDict: Record<string, number> = checkAlphabet
+  .split('')
+  .reduce(
+    (acc, c, idx) => ({
+      ...acc,
+      [c]: String(idx + 1).padStart(2, '0'),
+    }),
+    {},
+  );
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -./,');
+}
+
+const impl: Validator = {
+  name: 'German Pension Insurance Number',
+  localName: 'Sozialversicherungsnummer',
+  abbreviation: 'SVNR',
+  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, 8, 9).join(' ');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isalphanumeric(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!AREA_NUMBER_OPTIONS.includes(value.substring(0, 2))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(value.substring(2, 4))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!BIRTH_MONTH_OPTIONS.includes(value.substring(4, 6))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(value.substring(6, 8))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isalpha(value[8])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(value.substring(9, 11))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [frontWithAlpha, check] = strings.splitAt(value, 11);
+    const front = frontWithAlpha
+      .split('')
+      .map(c => checkAlphabetDict[c] ?? c)
+      .join('');
+    const sum = weightedSum(front, {
+      weights: [2, 1, 2, 5, 7, 1, 2, 1, 2, 1, 2, 1],
+      modulus: 10,
+      sumByDigit: true,
+    });
+
+    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/de/vat.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('de/vat', () => {
+  it('format:DE 136,695 976', () => {
+    const result = format('DE 136,695 976');
+
+    expect(result).toEqual('136695976');
+  });
+
+  it('validate:DE136695976', () => {
+    const result = validate('DE136695976');
+
+    expect(result.isValid && result.compact).toEqual('136695976');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:136695978', () => {
+    const result = validate('136695978');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/de/vat.ts

@@ -0,0 +1,74 @@
+/**
+ * Ust ID Nr. (Umsatzsteuer Identifikationsnummer, German VAT number).
+ *
+ * The number is 10 digits long and uses the ISO 7064 Mod 11, 10 check digit
+ * algorithm.
+ *
+ * ENTITY
+ */
+
+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> {
+  const [value, err] = strings.cleanUnicode(input, ' -./,');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('DE')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'German VAT Number',
+  localName: 'Umsatzsteuer Identifikationsnummer',
+  abbreviation: 'USt ID Nr.',
+  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() };
+    }
+
+    if (!iso7064mod10x11validate(value)) {
+      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/dk/cpr.spec.ts

@@ -0,0 +1,34 @@
+import { InvalidComponent } from '../exceptions';
+import { format, getBirthDate, validate } from './cpr';
+
+describe('dk/cpr', () => {
+  it('format:2110625629', () => {
+    const result = format('2110625629');
+
+    expect(result).toEqual('211062-5629');
+  });
+
+  it('getBirthDate("511062-0629")', () => {
+    expect(() => {
+      getBirthDate('511062-0629');
+    }).toThrow(InvalidComponent);
+  });
+
+  it('getBirthDate("010180-1234")', () => {
+    const result = validate('010180-1234');
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate wrong date', () => {
+    const result = validate('511062-5629');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate future date', () => {
+    const result = validate('2110525629');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/dk/cpr.ts

@@ -0,0 +1,129 @@
+/**
+ * CPR (personnummer, the Danish citizen number).
+ *
+ * The CPR is the national number to identify Danish citizens and is stored in
+ * the Det Centrale Personregister (Civil Registration System). The number
+ * consists of 10 digits in the format DDMMYY-SSSS where the first part
+ * represents the birth date and the second a sequence number. The first digit
+ * of the sequence number indicates the century.
+ *
+ * The numbers used to validate using a checksum but since the sequence numbers
+ * ran out this was abandoned in 2007. It is also not possible to use the
+ * checksum only for numbers that have a birth date before that because the
+ * numbers are also assigned to immigrants.
+ *
+ * More information:
+ *
+ * https://en.wikipedia.org/wiki/Personal_identification_number_(Denmark)
+ * https://da.wikipedia.org/wiki/CPR-nummer
+ * https://cpr.dk/
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, buildDate, validBirthdate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+export function getBirthDate(value: string): Date {
+  const [dob] = strings.splitAt(value, 6);
+  const [day, month, yearStr] = strings.splitAt(dob, 2, 4);
+
+  let year = parseInt(yearStr);
+
+  if ('5678'.includes(value[6]) && year >= 58) {
+    year += 1800;
+  } else if (
+    '0123'.includes(value[6]) ||
+    ('49'.includes(value[6]) && year >= 37)
+  ) {
+    year += 1900;
+  } else {
+    year += 2000;
+  }
+
+  const d = buildDate(String(year), month, day);
+
+  if (d === null || !isValidDate(String(year), month, day)) {
+    throw new exceptions.InvalidComponent(
+      'The number does not contain valid birth date information.',
+    );
+  }
+
+  return d;
+}
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+  if (err !== null) {
+    return [value, err];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Danish Citizen Number',
+  localName: 'Personnummer',
+  abbreviation: 'CPR',
+  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 (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (value.length !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    try {
+      const date = getBirthDate(value);
+      if (!validBirthdate(date)) {
+        return {
+          isValid: false,
+          error: new exceptions.InvalidComponent(
+            'The birth date information is valid, but this person has not been born yet.',
+          ),
+        };
+      }
+    } catch (err) {
+      if (err instanceof exceptions.ValidationError) {
+        return {
+          isValid: false,
+          error: err,
+        };
+      }
+      return {
+        isValid: false,
+        error: new exceptions.InvalidComponent(String(err)),
+      };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/dk/cvr.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './cvr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('dk/cvr', () => {
+  it('format:DK 13585628', () => {
+    const result = format('DK 13585628');
+
+    expect(result).toEqual('13585628');
+  });
+
+  it('validate:DK 13585628', () => {
+    const result = validate('DK 13585628');
+
+    expect(result.isValid && result.compact).toEqual('13585628');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:DK 13585627', () => {
+    const result = validate('DK 13585627');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});