stdnum 1.10.0 → 1.10.1

package/src/de/passport.ts

@@ -0,0 +1,86 @@
+/**
+ * Passport (German passport number).
+ *
+ *
+ * Source
+ *   https://learn.microsoft.com/en-us/microsoft-365/compliance/sit-defn-germany-passport-number?view=o365-worldwide
+ *   https://en.wikipedia.org/wiki/German_passport
+ *   https://www.bmi.bund.de/SharedDocs/downloads/DE/veroeffentlichungen/themen/moderne-verwaltung/ausweise/personalausweis-seriennummer.pdf?__blob=publicationFile&v=15
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -./,');
+}
+
+const idRegexp = /([CFGHJK][0-9CFGHJKLMNPRTVWXYZ]{8})([0-9]?)[A-Z]?/;
+
+const impl: Validator = {
+  name: 'German Passport Number',
+  localName: 'Ausweisen',
+  abbreviation: 'Passport',
+
+  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 > 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    const match = value.match(idRegexp);
+    if (!match) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    // Checksum is optional -- present in the matchine readable form, not in the human
+    if (match[2] !== '') {
+      const [issue, issueCheck] = [match[1], match[2]];
+
+      const issueSum = weightedSum(issue, {
+        weights: [7, 3, 1],
+        modulus: 10,
+      });
+
+      if (String(issueSum) !== issueCheck) {
+        return {
+          isValid: false,
+          error: new exceptions.InvalidChecksum('issue.checksum'),
+        };
+      }
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/de/pwnr.spec.ts

@@ -0,0 +1,62 @@
+import { validate, format } from './pwnr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('de/pwnr', () => {
+  it('format:T22000129364081252010315D4', () => {
+    const result = format('T22000129364081252010315D4');
+
+    expect(result).toEqual('T220001293 6408125 2010315 D 4');
+  });
+
+  it('format:1220001297D640812517103198', () => {
+    const result = format('1220001297D640812517103198');
+
+    expect(result).toEqual('1220001297 6408125 1710319 D 8');
+  });
+
+  test.each([
+    '240605568468102030705109D6',
+    '2406055684-6810203-0705109-D-6',
+    'T22000129364081252010315D4',
+    '1220001297D640812517103198',
+    '1220001297D640812517103198',
+    '1220001297D 6408125 1710319 8',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  test.each([
+    '2406055684',
+    '2406055684d',
+    '2406055684D',
+    'T220001293D',
+    'T220001293',
+    'L01X00T471',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:T220001293 6408125 2010315D 4', () => {
+    const result = validate('T220001293 6408125 2010315D 4');
+
+    expect(result.isValid && result.compact).toEqual(
+      'T22000129364081252010315D4',
+    );
+  });
+
+  it('validate:T22000129364081252010315D', () => {
+    const result = validate('T22000129364081252010315D');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:T22000129364081252010315D9', () => {
+    const result = validate('T22000129364081252010315D9');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/de/pwnr.ts

@@ -0,0 +1,190 @@
+/**
+ * PwNr (Personalausweisnummer, German personal identity card number).
+ *
+ * The identity card of the Federal Republic of Germany is an official document as proof of
+ * identity for German nationals. In principle, the identity card authority responsible for
+ * the main residence assigns it at the request of the citizen.
+ *
+ * Source
+ *   https://de.wikipedia.org/wiki/Personalausweis_(Deutschland)
+ *   http://www.pruefziffernberechnung.de/P/Personalausweis-DE.shtml
+ *   https://learn.microsoft.com/en-us/microsoft-365/compliance/sit-defn-germany-identity-card-number?view=o365-worldwide
+ *   http://www.pruefziffernberechnung.de/Begleitdokumente/BKZ.shtml
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, isValidDateCompactYYMMDD, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const oldRegex = /^([0-9CFGHJKLMNPRTVWXYZ]{9})([0-9])[A-Z]?$/;
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -./,');
+
+  if (err) {
+    return [value, err];
+  }
+
+  // Old format IDs had the national code at position 11 new format has them at 24
+  if (value.length >= 25 && /[A-Z]/.test(value[10])) {
+    const [p1, p2, p3, p4] = strings.splitAt(value, 10, 11, 25);
+
+    return [p1 + p3 + p2 + p4, err];
+  }
+
+  return [value, err];
+}
+
+export function validateIssue(value: string): ValidateReturn {
+  const match = value.match(oldRegex);
+  if (!match) {
+    return { isValid: false, error: new exceptions.InvalidFormat() };
+  }
+
+  const [issue, issueCheck] = [match[1], match[2]];
+
+  const issueSum = weightedSum(issue, {
+    weights: [7, 3, 1],
+    modulus: 10,
+  });
+
+  if (String(issueSum) !== issueCheck) {
+    return {
+      isValid: false,
+      error: new exceptions.InvalidChecksum('issue.checksum'),
+    };
+  }
+
+  return {
+    isValid: true,
+    compact: value,
+    isIndividual: true,
+    isCompany: false,
+  };
+}
+
+export function validateNew(value: string): ValidateReturn {
+  if (
+    !/^[0-9CFGHJKLMNPRTVWXYZ][0-9CFGHJKLMNPRTVWXYZ]+[A-Z][0-9]$/.test(value)
+  ) {
+    return { isValid: false, error: new exceptions.InvalidFormat() };
+  }
+
+  const [
+    issue,
+    issueCheck,
+    birth,
+    birthCheck,
+    expiry,
+    expiryCheck,
+    nationality,
+    checksum,
+  ] = strings.splitAt(value, 9, 10, 16, 17, 23, 24, 25);
+
+  if (!isValidDateCompactYYMMDD(birth, true)) {
+    return {
+      isValid: false,
+      error: new exceptions.InvalidComponent('birthdate'),
+    };
+  }
+  if (!isValidDateCompactYYMMDD(expiry)) {
+    return {
+      isValid: false,
+      error: new exceptions.InvalidComponent('expiry'),
+    };
+  }
+  if (!/^[A-Z]$/.test(nationality)) {
+    return {
+      isValid: false,
+      error: new exceptions.InvalidComponent('nationality'),
+    };
+  }
+
+  // The hope is that the issue information grows better
+  // checks over time and should be a shared function
+  const res = validateIssue(issue + issueCheck);
+  if (res.isValid === false) {
+    return res;
+  }
+
+  const birthSum = weightedSum(birth, {
+    weights: [7, 3, 1],
+    modulus: 10,
+  });
+  const expirySum = weightedSum(expiry, {
+    weights: [7, 3, 1],
+    modulus: 10,
+  });
+  if (String(birthSum) !== birthCheck) {
+    return {
+      isValid: false,
+      error: new exceptions.InvalidChecksum('birth.checksum'),
+    };
+  }
+
+  if (String(expirySum) !== expiryCheck) {
+    return {
+      isValid: false,
+      error: new exceptions.InvalidChecksum('expiry.checksum'),
+    };
+  }
+
+  const sum = weightedSum(value.substring(0, 24), {
+    weights: [7, 3, 1],
+    modulus: 10,
+  });
+  if (String(sum) !== checksum) {
+    return {
+      isValid: false,
+      error: new exceptions.InvalidChecksum('checksum'),
+    };
+  }
+
+  return {
+    isValid: true,
+    compact: value,
+    isIndividual: true,
+    isCompany: false,
+  };
+}
+
+const impl: Validator = {
+  name: 'German Personalausweisnummer',
+  localName: 'Personalausweisnummer',
+  abbreviation: 'PwNr',
+  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, 10, 17, 24, 25).join(' ');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length === 26) {
+      return validateNew(value);
+    } else if (value.length === 10 || value.length === 11) {
+      return validateIssue(value);
+    } else {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/de/stnr.spec.ts

@@ -0,0 +1,85 @@
+import { validate, format } from './stnr';
+import { InvalidComponent, InvalidFormat, InvalidLength } from '../exceptions';
+
+describe('de/stnr', () => {
+  it('format:18181508155', () => {
+    const result = format('18181508155');
+
+    expect(result).toEqual('181/815/0815 5');
+  });
+
+  it('validate:10863924976', () => {
+    const result = validate('10863924976');
+
+    expect(result.isValid && result.compact).toEqual('10863924976');
+  });
+
+  it('validate:36574261809', () => {
+    const result = validate('36574261809');
+
+    expect(result.isValid && result.compact).toEqual('36574261809');
+  });
+
+  it('validate:136695978', () => {
+    const result = validate('136695978');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:121/5752/5373', () => {
+    const result = validate('121/5752/5373');
+
+    expect(result.isValid && result.compact).toEqual('12157525373');
+  });
+
+  it('validate:14/203/31601', () => {
+    const result = validate('14/203/31601');
+
+    expect(result.isValid && result.compact).toEqual('1420331601');
+  });
+
+  // it('validate:36574261808', () => {
+  //   const result = validate('36574261808');
+
+  //   expect(result.error).toBeInstanceOf(InvalidChecksum);
+  // });
+
+  it('validate:1234567890', () => {
+    const result = validate('1234567890');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:0472480661811', () => {
+    const result = validate('0472480661811');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  // Test coverage from
+  //  https://de.wikipedia.org/wiki/Steuernummer
+  //  -- Turns out these are not valid numbers
+
+  // test.each([
+  //   '93815/08152',
+  //   '181/815/08155',
+  //   '21/815/08150',
+  //   '48/815/08155',
+  //   '75 815 08152',
+  //   '02/815/08156',
+  //   '013 815 08153',
+  //   '79/815/08151',
+  //   '24/815/08151',
+  //   '133/8150/8159',
+  //   '22/815/08154',
+  //   '10/815/08182',
+  //   '201/123/12340',
+  //   '101/815/08154',
+  //   '29/815/08158	',
+  //   '151/815/08156',
+  // ])('stnr(%s)', num => {
+  //   const result = validate(num);
+
+  //   expect(result.isValid).toEqual(true);
+  // });
+});

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);
+    });
+  });
+});