stdnum 1.10.0 → 1.10.2

package/src/ca/qst.ts

@@ -0,0 +1,88 @@
+/**
+ * QST (Quebec Sales Tax Number).
+ *
+ * DESCRIPTION
+ *   10 digits - Business number to identify the business. It is the Bussines Number.
+ *   2 alpha - QT / TQ (unclear)
+ *   4 digits - Serial number
+ *
+ * Source
+ *    https://www5.services.mrq.gouv.qc.ca/mrqanonyme/g1/g1c/g1c1a_I_ValidationNoTVQ/PageIdentificationNoTVQ.aspx
+ *    https://wiki.scn.sap.com/wiki/display/CRM/Canada
+ *
+ * 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 validRe = /^\d{10}[a-z]{2}\d{4}$/i;
+
+// const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'Quebec Sales Tax Number',
+  localName: '',
+  abbreviation: 'QST',
+
+  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 !== 16) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!validRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check, , serial] = strings.splitAt(value, 9, 10, 12);
+    if (serial === '0000') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = weightedSum(front, {
+      weights: [4, 3, 2, 7, 6, 5, 4, 3, 2],
+      modulus: 11,
+    });
+
+    if (String((11 - sum) % 10) !== 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/ca/sin.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './sin';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('ca/sin', () => {
+  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:12345678Z', () => {
+    const result = validate('12345678Z');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:999-999-999', () => {
+    const result = validate('999-999-999');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ca/sin.ts

@@ -0,0 +1,72 @@
+/**
+ * SIN (Canadian Social Insurance Number).
+ *
+ * The Social Insurance Number (SIN) is a 9-digit identifier issued to
+ * individuals for various government programs. SINs that begin with a 9 are
+ * issued to temporary workers who are neither Canadian citizens nor permanent
+ * residents.
+ *
+ * Source:
+ *    https://www.canada.ca/en/employment-social-development/services/sin.html
+ *    https://en.wikipedia.org/wiki/Social_Insurance_Number
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumValidate } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Canadian Social Insurance Number',
+  localName: 'Social Insurance Number',
+  abbreviation: 'SIN',
+  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() };
+    }
+
+    if (!luhnChecksumValidate(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/ch/index.ts

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

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