stdnum 1.10.0 → 1.10.2

package/src/at/tin.ts

@@ -0,0 +1,140 @@
+/**
+ *
+ * Abgabenkontonummer (Austrian tax identification number).
+ *
+ * The Austrian tax identification number (Abgabenkontonummer) consists of 2
+ * digits for the issuing tax office (Finanzamtsnummer) and 7 digits for the
+ * subject and a check digit (Steuernummer).
+ *
+ *
+ * Sources:
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Austria-TIN.pdf
+ *    https://de.wikipedia.org/wiki/Abgabenkontonummer
+ *    https://service.bmf.gv.at/Service/Anwend/Behoerden/show_mast.asp
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+// List of Finanzamtsnummern was manually generated from
+// https://de.wikipedia.org/wiki/Abgabenkontonummer
+const faOffices: Record<string, { office: string; region: string }> = {
+  '03': { office: 'Wien 3/6/7/11/15 Schwechat Gerasdorf', region: 'Wien' },
+  '04': { office: 'Wien 4/5/10', region: 'Wien' },
+  '06': { office: 'Wien 8/16/17', region: 'Wien' },
+  '07': { office: 'Wien 9/18/19 Klosterneuburg', region: 'Wien' },
+  '08': { office: 'Wien 12/13/14 Purkersdorf', region: 'Wien' },
+  '09': { office: 'Wien 1/23', region: 'Wien' },
+  '10': { office: 'für Gebühren, Verkehrsteuern und Glücksspiel', region: '' },
+  '12': { office: 'Wien 2/20/21/22', region: 'Wien' },
+  '15': { office: 'Amstetten Melk Scheibbs', region: 'Niederösterreich' },
+  '16': { office: 'Baden Mödling', region: 'Niederösterreich' },
+  '18': { office: 'Gänserndorf Mistelbach', region: 'Niederösterreich' },
+  '22': { office: 'Hollabrunn Korneuburg Tulln', region: 'Niederösterreich' },
+  '23': { office: 'Waldviertel', region: 'Niederösterreich' },
+  '29': { office: 'Lilienfeld St. Pölten', region: 'Niederösterreich' },
+  '33': { office: 'Neunkirchen Wr. Neustadt', region: 'Niederösterreich' },
+  '38': {
+    office: 'Bruck Eisenstadt Oberwart',
+    region: 'Burgenland, Niederösterreich',
+  },
+  '41': { office: 'Braunau Ried Schärding', region: 'Oberösterreich' },
+  '46': { office: 'Linz', region: 'Oberösterreich' },
+  '51': { office: 'Kirchdorf Perg Steyr', region: 'Oberösterreich' },
+  '52': { office: 'Freistadt Rohrbach Urfahr', region: 'Oberösterreich' },
+  '53': { office: 'Gmunden Vöcklabruck', region: 'Oberösterreich' },
+  '54': { office: 'Grieskirchen Wels', region: 'Oberösterreich' },
+  '57': { office: 'Klagenfurt', region: 'Kärnten' },
+  '59': { office: 'St. Veit Wolfsberg', region: 'Kärnten' },
+  '61': { office: 'Spittal Villach', region: 'Kärnten' },
+  '65': { office: 'Bruck Leoben Mürzzuschlag', region: 'Steiermark' },
+  '67': { office: 'Oststeiermark', region: 'Steiermark' },
+  '68': { office: 'Graz-Stadt', region: 'Steiermark' },
+  '69': { office: 'Graz-Umgebung', region: 'Steiermark' },
+  '71': { office: 'Judenburg Liezen', region: 'Steiermark' },
+  '72': { office: 'Deutschlandsberg Leibnitz Voitsberg', region: 'Steiermark' },
+  '81': { office: 'Innsbruck', region: 'Tirol' },
+  '82': { office: 'Kitzbühel Lienz', region: 'Tirol' },
+  '83': { office: 'Kufstein Schwaz', region: 'Tirol' },
+  '84': { office: 'Landeck Reutte', region: 'Tirol' },
+  '90': { office: 'St. Johann Tamsweg Zell am See', region: 'Salzburg' },
+  '91': { office: 'Salzburg-Stadt', region: 'Salzburg' },
+  '93': { office: 'Salzburg-Land', region: 'Salzburg' },
+  '97': { office: 'Bregenz', region: 'Vorarlberg' },
+  '98': { office: 'Feldkirch', region: 'Vorarlberg' },
+};
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -./,');
+}
+
+const impl: Validator = {
+  name: 'Austrian Tax Identification Number',
+  localName: 'Abgabenkontonummer',
+  abbreviation: 'TIN',
+  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] = strings.splitAt(value, 2, 5);
+
+    return `${a}-${b}/${c}`;
+  },
+
+  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.InvalidComponent() };
+    }
+
+    const [office, front, check] = strings.splitAt(value, 2, 8);
+
+    if (faOffices[office] === undefined) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = `${office}${front}`
+      .split('')
+      .map(x => parseInt(x, 10))
+      .reduce(
+        (acc, digit, idx) =>
+          acc + (idx % 2 === 1 ? [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][digit] : digit),
+        0,
+      );
+
+    const digit = String((10 - (sum % 10)) % 10);
+
+    if (check !== digit) {
+      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/at/uid.spec.ts

@@ -0,0 +1,44 @@
+import { validate, format } from './uid';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('at/uid', () => {
+  it('format:AT U13585627', () => {
+    const result = format('AT U13585627');
+
+    expect(result).toEqual('U13585627');
+  });
+
+  it('validate:AT U13585627', () => {
+    const result = validate('AT U13585627');
+
+    expect(result.isValid && result.compact).toEqual('U13585627');
+  });
+
+  it('validate:U13585627', () => {
+    const result = validate('U13585627');
+
+    expect(result.isValid && result.compact).toEqual('U13585627');
+  });
+
+  it('validate:X13585626', () => {
+    const result = validate('X13585626');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:U1358562', () => {
+    const result = validate('U1358562');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:U13585626', () => {
+    const result = validate('U13585626');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/at/uid.ts

@@ -0,0 +1,84 @@
+/**
+ *
+ * UID (Umsatzsteuer-Identifikationsnummer, Austrian VAT number).
+ *
+ * The Austrian UID is a 9-digit number that starts with a U (optionally
+ * preceded with AT). The last digit is a check digit.
+ *
+ * Sources:
+ *   https://www.ruc.com.py/
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumValue } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -./');
+
+  if (err) {
+    return [value, err];
+  }
+  if (value.startsWith('AT')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Austrian VAT Number',
+  localName: 'Umsatzsteuer-Identifikationsnummer',
+  abbreviation: 'UID',
+
+  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 (!value.startsWith('U') || !strings.isdigits(value.substr(1))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [, front, check] = strings.splitAt(value, 1, 8);
+
+    const digit = String((16 - luhnChecksumValue(front)) % 10);
+
+    if (check !== digit) {
+      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/at/vnr.spec.ts

@@ -0,0 +1,38 @@
+import { validate, format } from './vnr';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('at/vnr', () => {
+  it('format:1237010180', () => {
+    const result = format('1237010180');
+
+    expect(result).toEqual('1237 010180');
+  });
+
+  it('validate:1237 010180', () => {
+    const result = validate('1237 010180');
+
+    expect(result.isValid && result.compact).toEqual('1237010180');
+  });
+
+  it('validate:2237 010180', () => {
+    const result = validate('2237 010180');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:1237 01018', () => {
+    const result = validate('1237 01018');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1237 410180', () => {
+    const result = validate('1237 410180');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/at/vnr.ts

@@ -0,0 +1,84 @@
+/**
+ *
+ * VNR, SVNR, VSNR (Versicherungsnummer, Austrian social security number).
+ *
+ * The Austian Versicherungsnummer is a personal identification number used for
+ * social security. The number is 10 digits long and consists of a 3 digit
+ * serial, a check digit and 6 digits that usually specify the person's birth
+ * date.
+ *
+ * Sources:
+ *   https://de.wikipedia.org/wiki/Sozialversicherungsnummer#Österreich
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDateCompactDDMMYY, strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Austrian Social Security Number',
+  localName: 'Versicherungsnummer',
+  abbreviation: 'VSNR',
+  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, 4).join(' ');
+  },
+
+  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.InvalidComponent() };
+    }
+
+    const [front, check, dob] = strings.splitAt(value, 3, 4);
+
+    if (!isValidDateCompactDDMMYY(dob, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = weightedSum(`${front}${dob}`, {
+      weights: [3, 7, 9, 5, 8, 4, 2, 1, 6],
+      modulus: 11,
+    });
+
+    const digit = String(sum % 11);
+
+    if (check !== digit) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: parseInt(front, 10) < 80000000,
+      isCompany: front.length === 8 && parseInt(front, 10) > 80000000,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/au/abn.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './abn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('au/abn', () => {
+  it('format:83 914 571 673', () => {
+    const result = format('83 914 571 673');
+
+    expect(result).toEqual('83 914 571 673');
+  });
+
+  it('validate:83 914 571 673', () => {
+    const result = validate('83 914 571 673');
+
+    expect(result.isValid && result.compact).toEqual('83914571673');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:99 999 999 999', () => {
+    const result = validate('99 999 999 999');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/au/abn.ts

@@ -0,0 +1,78 @@
+/**
+ * ABN (Australian Business Number).
+ *
+ * The Australian Business Number (ABN) is an identifier issued to entities
+ * registered in the Australian Business Register (ABR). The number consists of
+ * 11 digits of which the first two are check digits.
+ *
+ * Source
+ *   https://en.wikipedia.org/wiki/Australian_Business_Number
+ *   https://abr.business.gov.au/
+ *
+ * ENTITY
+ */
+
+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: 'Australian Business Number',
+  localName: 'Business Number',
+  abbreviation: 'ABN',
+  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() };
+    }
+
+    const [check, rest] = strings.splitAt(value, 2);
+
+    const sum = weightedSum(rest, {
+      weights: [3, 5, 7, 9, 11, 13, 15, 17, 19],
+      modulus: 89,
+    });
+
+    if (check !== String(11 + ((177 - sum) % 89))) {
+      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/au/acn.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './acn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('au/acn', () => {
+  it('format:004085616', () => {
+    const result = format('004085616');
+
+    expect(result).toEqual('004 085 616');
+  });
+
+  it('validate:004 085 616', () => {
+    const result = validate('004 085 616');
+
+    expect(result.isValid && result.compact).toEqual('004085616');
+  });
+
+  it('validate:010 499 966', () => {
+    const result = validate('010 499 966');
+
+    expect(result.isValid && result.compact).toEqual('010499966');
+  });
+
+  it('validate:0040856169', () => {
+    const result = validate('0040856169');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:999 999 999 ', () => {
+    const result = validate('999 999 999');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/au/acn.ts

@@ -0,0 +1,76 @@
+/**
+ * ACN (Australian Company Number).
+ *
+ * The Australian Company Number (ACN) is a company identifier issued by the
+ * Australian Securities and Investments Commission.
+ *
+ * Source:
+ *    https://en.wikipedia.org/wiki/Australian_Company_Number
+ *
+ * ENTITY
+ */
+
+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: 'Australian Company Number',
+  localName: 'Company Number',
+  abbreviation: 'ACN',
+  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, 3, 6).join(' ');
+  },
+
+  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() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      weights: [-8, -7, -6, -5, -4, -3, -2, -1],
+      modulus: 10,
+    });
+
+    if (String(sum) !== 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/au/index.ts

@@ -0,0 +1,3 @@
+export * as abn from './abn';
+export * as acn from './acn';
+export * as tfn from './tfn';

package/src/au/tfn.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './tfn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('au/tfn', () => {
+  it('format:123456782', () => {
+    const result = format('123456782');
+
+    expect(result).toEqual('123 456 782');
+  });
+
+  it('validate:123 456 782', () => {
+    const result = validate('123 456 782');
+
+    expect(result.isValid && result.compact).toEqual('123456782');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:999 999 999', () => {
+    const result = validate('999 999 999');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});