stdnum 1.10.0 → 1.10.1

package/src/ch/ssn.spec.ts

@@ -0,0 +1,50 @@
+import { validate, format } from './ssn';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('ch/ssn', () => {
+  it('format:7569217076985', () => {
+    const result = format('7569217076985');
+
+    expect(result).toEqual('756.9217.0769.85');
+  });
+
+  it('validate:756.9217.0769.85', () => {
+    const result = validate('756.9217.0769.85');
+
+    expect(result.isValid && result.compact).toEqual('7569217076985');
+  });
+
+  it('validate:7569217076985', () => {
+    const result = validate('7569217076985');
+
+    expect(result.isValid && result.compact).toEqual('7569217076985');
+  });
+
+  test.each(['756.9203.3850.60', '75692170769 85'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:123.4567.8910.19', () => {
+    const result = validate('123.4567.8910.19');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:756.9217.0769.84', () => {
+    const result = validate('756.9217.0769.84');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ch/ssn.ts

@@ -0,0 +1,74 @@
+/**
+ * Swiss social security number ("Sozialversicherungsnummer").
+ *
+ * Also known as "Neue AHV Nummer". The Swiss Sozialversicherungsnummer is used
+ * to identify individuals for taxation and pension purposes.
+ * The number is validated using EAN-13, though dashes are substituted for dots.
+ *
+ * Source
+ *   https://en.wikipedia.org/wiki/National_identification_number#Switzerland
+ *   https://de.wikipedia.org/wiki/Sozialversicherungsnummer#Versichertennummer
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { ean } from '../gen';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+const impl: Validator = {
+  name: 'Swiss Social Security Number',
+  localName: 'Sozialversicherungsnummer',
+  abbreviation: 'SSN',
+  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, 7, 11).join('.');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!value.startsWith('756')) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!ean.validate(value).isValid) {
+      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/ch/uid.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './uid';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ch/uid', () => {
+  it('format:CHE100155212', () => {
+    const result = format('CHE100155212');
+
+    expect(result).toEqual('CHE-100.155.212');
+  });
+
+  it('validate:CHE109910570', () => {
+    const result = validate('CHE109910570');
+
+    expect(result.isValid && result.compact).toEqual('CHE109910570');
+  });
+
+  it('validate:CHE-100.155.212', () => {
+    const result = validate('CHE-100.155.212');
+
+    expect(result.isValid && result.compact).toEqual('CHE100155212');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:CHE-100.155.212', () => {
+    const result = validate('CHE-100.155.211');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ch/uid.ts

@@ -0,0 +1,82 @@
+/**
+ * UID (Unternehmens-Identifikationsnummer, Swiss business identifier).
+ *
+ * The Swiss UID is used to uniquely identify businesses for taxation purposes.
+ * The number consists of a fixed "CHE" prefix, followed by 9 digits that are
+ * protected with a simple checksum.
+ * This module only supports the "new" format that was introduced in 2011 which
+ * completely replaced the "old" 6-digit format in 2014.
+ *
+ * Source
+ *   https://www.uid.admin.ch/
+ *   https://de.wikipedia.org/wiki/Unternehmens-Identifikationsnummer
+ *
+ * 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: 'Swiss Business Identifier',
+  localName: 'Unternehmens-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);
+
+    const [a, b, c, d] = strings.splitAt(value, 3, 6, 9);
+
+    return `${a}-${b}.${c}.${d}`;
+  },
+
+  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.isdigits(value.substr(3)) || !value.startsWith('CHE')) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [, front, check] = strings.splitAt(value, 3, -1);
+
+    const sum = weightedSum(front, {
+      modulus: 11,
+      weights: [5, 4, 3, 2, 7, 6, 5, 4],
+    });
+
+    if (String((11 - sum) % 11) !== 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/ch/vat.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ch/vat', () => {
+  it('format:CHE107787577IVA', () => {
+    const result = format('CHE107787577IVA');
+
+    expect(result).toEqual('CHE-107.787.577 IVA');
+  });
+
+  it('validate:CHE-107.787.577 IVA', () => {
+    const result = validate('CHE-107.787.577 IVA');
+
+    expect(result.isValid && result.compact).toEqual('CHE107787577IVA');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:CHE-107.787.578 IVA', () => {
+    const result = validate('CHE-107.787.578 IVA');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ch/vat.ts

@@ -0,0 +1,83 @@
+/**
+ * VAT, MWST, TVA, IVA, TPV (Mehrwertsteuernummer, the Swiss VAT number).
+ *
+ * The Swiss VAT number is based on the UID but is followed by either "MWST"
+ *
+ * (Mehrwertsteuer, the German abbreviation for VAT), "TVA" (Taxe sur la valeur
+ * ajoutée in French), "IVA" (Imposta sul valore aggiunto in Italian) or "TPV"
+ * (Taglia sin la plivalur in Romanian).
+ *
+ * This module only supports the "new" format that was introduced in 2011 which
+ * completely replaced the "old" 6-digit format in 2014.
+ *
+ * More information:
+ *   https://www.ch.ch/en/value-added-tax-number-und-business-identification-number/
+ *   https://www.uid.admin.ch/
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as uidValidate } from './uid';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+const impl: Validator = {
+  name: 'Swiss VAT Number',
+  localName: 'Mehrwertsteuernummer',
+  abbreviation: 'MWST/TVA/IVA',
+
+  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, 3, 6, 9, 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 !== 15 && value.length !== 16) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    const [front, sufix] = strings.splitAt(value, 12);
+    if (!['MWST', 'TVA', 'IVA', 'TPV'].includes(sufix)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const result = uidValidate(front);
+
+    if (!result.isValid && result.error) {
+      return { isValid: false, error: result.error };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cl/index.ts

@@ -0,0 +1,2 @@
+export * as run from './run';
+export * as rut from './rut';

package/src/cl/run.ts

@@ -0,0 +1,13 @@
+import * as rut from './rut';
+
+import { Validator } from '../types';
+
+const impl: Validator = {
+  ...rut,
+  name: 'Chilean National Identification Number',
+  localName: 'Rol Único Nacional ',
+  abbreviation: 'RUN',
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cl/rut.spec.ts

@@ -0,0 +1,50 @@
+import { validate, format } from './rut';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('cl/rut', () => {
+  it('format:800280610', () => {
+    const result = format('125319092');
+
+    expect(result).toEqual('12.531.909-2');
+  });
+
+  it('validate:76086428-5', () => {
+    const result = validate('76086428-5');
+
+    expect(result.isValid && result.compact).toEqual('760864285');
+  });
+
+  it('validate:CL 12531909-2', () => {
+    const result = validate('CL 12531909-2');
+
+    expect(result.isValid && result.compact).toEqual('125319092');
+  });
+
+  it('validate:12531909-3', () => {
+    const result = validate('12531909-3');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:76086A28-5', () => {
+    const result = validate('76086A28-5');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:76628-5', () => {
+    const result = validate('76628-5');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:2660-4', () => {
+    const result = validate('2660-4');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/cl/rut.ts

@@ -0,0 +1,97 @@
+/**
+ *
+ * Chile RUT/RUN numbers
+ *
+ * RUT number (Rol Unico Tributario).
+ *
+ * The RUT, the Chilean national tax number is the same as the RUN (Rol Único
+ * Nacional) the Chilean national identification number. The number consists of
+ * 8 digits, followed by a check digit.
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [v, err] = strings.cleanUnicode(input, ' -');
+
+  if (err) {
+    return ['', err];
+  }
+
+  if (v.startsWith('CL')) {
+    return [v.substr(2), null];
+  }
+
+  return [v, null];
+}
+
+const impl: Validator = {
+  name: 'Chilean National Tax Number',
+  localName: 'Rol Único Tributario ',
+  abbreviation: 'RUT',
+  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, 2, 5, 8);
+
+    return `${a}.${b}.${c}-${d}`;
+  },
+
+  /**
+   * Check if the number is a valid RUT number.
+   * This checks the length, formatting and other contraints. It does not check
+   * for control letter.
+   */
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 8 && value.length !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    const [front, check] = strings.splitAt(value, value.length - 1);
+
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = weightedSum(front, {
+      reverse: true,
+      weights: [9, 8, 7, 6, 5, 4, 9, 8, 7],
+      modulus: 11,
+    });
+
+    const digit = '0123456789K'[sum];
+
+    if (check !== digit) {
+      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/cn/index.ts

@@ -0,0 +1,2 @@
+export * as ric from './ric';
+export * as uscc from './uscc';

package/src/cn/ric.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './ric';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('cn/ric', () => {
+  it('format:360426199101010071', () => {
+    const result = format('360426199101010071');
+
+    expect(result).toEqual('360426199101010071');
+  });
+
+  it('validate:360426199101010071', () => {
+    const result = validate('360426199101010071');
+
+    expect(result.isValid && result.compact).toEqual('360426199101010071');
+  });
+
+  it('validate:120103198806018241', () => {
+    const result = validate('120103198806018241');
+
+    expect(result.isValid && result.compact).toEqual('120103198806018241');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:360426199101010072', () => {
+    const result = validate('360426199101010072');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/cn/ric.ts

@@ -0,0 +1,86 @@
+/**
+ * RIC No. (Chinese Resident Identity Card Number).
+ *
+ * The RIC No. is the unique identifier for issued to China (PRC) residents.
+ *
+ * The number consist of 18 digits in four sections. The first 6 digits refers to
+ * the resident's location, followed by 8 digits represeting the resident's birth
+ * day in the form YYYY-MM-DD. The next 3 digits is the order code which is the
+ * code used to disambiguate people with the same date of birth and address code.
+ * Men are assigned to odd numbers, women assigned to even numbers. The final
+ * digit is the checksum.
+ *
+ * Source
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { isValidDateCompactYYYYMMDD } from '../util/isValidDate';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const impl: Validator = {
+  name: 'Chinese Resident Identity Card Number',
+  localName: '居民身份证',
+  abbreviation: 'RIC No',
+  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 !== 18) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    const [front, check] = strings.splitAt(value, 17);
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!isValidDateCompactYYYYMMDD(front.substring(6, 14), true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const checkValue = weightedSum(front, {
+      weights: [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2],
+      modulus: 11,
+    });
+
+    const digit = '10X98765432'[checkValue];
+
+    if (check !== digit) {
+      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/cn/uscc.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './uscc';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('cn/uscc', () => {
+  it('format:91110000600037341L', () => {
+    const result = format('91110000600037341L');
+
+    expect(result).toEqual('91110000600037341L');
+  });
+
+  it('validate:91110000600037341L', () => {
+    const result = validate('91110000600037341L');
+
+    expect(result.isValid && result.compact).toEqual('91110000600037341L');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:A1110000600037341L', () => {
+    const result = validate('A1110000600037341L');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:91110000600037342L', () => {
+    const result = validate('91110000600037342L');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});