stdnum 1.10.0 → 1.10.2

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

package/src/cn/uscc.ts

@@ -0,0 +1,110 @@
+/**
+ * USCC (Unified Social Credit Code, 统一社会信用代码, China tax number).
+ *
+ * This number consists of 18 digits or uppercase English letters (excluding the
+ * letters I, O, Z, S, V). The number is comprised of several parts:
+ *
+ *   Digit 1 represents the registering authority,
+ *   Digit 2 represents the registered entity type,
+ *   Digits 3 through 8 represent the registering region code,
+ *   Digits 9 through 17 represent the organisation code,
+ *   Digit 18 is a check digit (either a number or letter).
+ *
+ * The registering authority digit most often is a 9, which represents the State
+ * Administration for Industry and Commerce (SAIC) as the registering authority.
+ *
+ * The registered entity type indicates the type of business (or entity). The
+ * most common entity types in China are:
+ *
+ *   Wholly Foreign-Owned Enterprises (WFOE): 外商独资企业
+ *   Joint Ventures (JV): 合资
+ *   Representative Office: 代表处
+ *   State-Owned Enterprise (SOE): 国有企业
+ *   Private Enterprise: 民营企业
+ *   Individually-Owned: 个体户
+ *
+ * The registering region code, sometimes referred to as the "administrative
+ * division code", is a string of six numbers that indicates where the company
+ * is registered. It roughly follows the organisation of the official Chinese
+ * regions.
+ *
+ * The organisation code comes directly from the China Organization Code
+ * certificate, an alternative document to the China Business License. It can
+ * contain letters or digits.
+ *
+ * SOURCES
+ *    https://zh.wikipedia.org/wiki/统一社会信用代码
+ *    https://zh.wikipedia.org/wiki/校验码
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/China-TIN.pdf
+ *
+ * ENTITY
+ */
+
+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 alphabet = '0123456789ABCDEFGHJKLMNPQRTUWXY';
+
+const impl: Validator = {
+  name: 'Chinese Unified Social Credit Code',
+  localName: '统一社会信用代码',
+  abbreviation: 'USCC',
+  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, back, check] = strings.splitAt(value, 8, 17);
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (back.split('').some(v => !alphabet.includes(v))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const digit = weightedSum(value.substr(0, 17), {
+      weights: [1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28],
+      modulus: 31,
+      alphabet,
+    });
+
+    if (alphabet[31 - digit] !== 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/co/index.ts

@@ -0,0 +1 @@
+export * as nit from './nit';

package/src/co/nit.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './nit';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('co/nit', () => {
+  it('format:213.123.4321', () => {
+    const result = format('213.123.4321');
+
+    expect(result).toEqual('213.123.432-1');
+  });
+
+  it('validate:213.123.432-1', () => {
+    const result = validate('213.123.432-1');
+
+    expect(result.isValid && result.compact).toEqual('2131234321');
+  });
+
+  it('validate:10184648519', () => {
+    const result = validate('10184648519');
+
+    expect(result.isValid && result.compact).toEqual('10184648519');
+  });
+
+  it('validate:900544472-2', () => {
+    const result = validate('900544472-2');
+
+    expect(result.isValid && result.compact).toEqual('9005444722');
+  });
+
+  it('validate:21312', () => {
+    const result = validate('21312');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:2131234325', () => {
+    const result = validate('2131234325');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/co/nit.ts

@@ -0,0 +1,85 @@
+/**
+ *
+ * Columbian Número de Identificación Tributaria
+ *
+ * The Tax Identification Number (NIT) is a unique Colombian number, assigned by the DIAN (Dirección
+ * de Impuestos y Aduanas Nacionales de Colombia) when the entity is registered in the
+ * RUT (Registro Único Tributario).
+ *
+ * Sources:
+ *   https://es.wikipedia.org/wiki/N%C3%BAmero_de_Identificaci%C3%B3n_Tributaria
+ *
+ * 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> {
+  return strings.cleanUnicode(input, ',.- ');
+}
+
+const impl: Validator = {
+  name: 'Colombian Tax Identification Number',
+  localName: 'Número de Identificación Tributaria',
+  abbreviation: 'NIT',
+
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value.toLocaleUpperCase();
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    const [p1, p2, p3, p4] = strings.splitAt(value, 3, 6, 9);
+
+    return `${p1}.${p2}.${p3}-${p4}`;
+  },
+
+  /**
+   * 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 > 16) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+    const sum = weightedSum(front, {
+      weights: [3, 7, 13, 17, 19, 23, 29, 37, 41, 43, 47, 53, 59, 67, 71],
+      reverse: true,
+      modulus: 11,
+    });
+
+    const digit = '01987654321'[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/cr/cpf.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cpf';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('cr/cpf', () => {
+  it('format:701610395', () => {
+    const result = format('701610395');
+
+    expect(result).toEqual('07-0161-0395');
+  });
+
+  it('format:1-613-584', () => {
+    const result = format('1-613-584');
+
+    expect(result).toEqual('01-0613-0584');
+  });
+
+  it('validate:3-0455-0175', () => {
+    const result = validate('3-0455-0175');
+
+    expect(result.isValid && result.compact).toEqual('0304550175');
+  });
+
+  it('validate:30-1234-1234', () => {
+    const result = validate('30-1234-1234');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/cr/cpf.ts

@@ -0,0 +1,93 @@
+/**
+ * CPF (Cédula de Persona Física, Costa Rica physical person ID number).
+ *
+ * The Cédula de Persona Física (CPF), also known as Cédula de Identidad is an
+ * identifier of physical persons.
+ *
+ * The number consists of 10 digits in the form 0P-TTTT-AAAA where P represents
+ * the province, TTTT represents the volume (tomo) padded with zeroes on the
+ * left, and AAAA represents the entry (asiento) also padded with zeroes on the
+ * left.
+ *
+ * It seems to be usual for the leading zeroes in each of the three parts to be
+ * omitted.
+ *
+ * Source
+ *    https://www.hacienda.go.cr/consultapagos/ayuda_cedulas.htm
+ *    https://www.procomer.com/downloads/quiero/guia_solicitud_vuce.pdf (page 11)
+ *    https://www.hacienda.go.cr/ATV/frmConsultaSituTributaria.aspx
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' ');
+  if (err) {
+    return [value, err];
+  }
+  const parts = value.split('-');
+  if (parts.length === 3) {
+    parts[0] = parts[0].padStart(2, '0');
+    parts[1] = parts[1].padStart(4, '0');
+    parts[2] = parts[2].padStart(4, '0');
+  }
+  const number = parts.join('');
+
+  if (number.length !== 10 && number.length !== 9) {
+    return ['', new exceptions.InvalidLength()];
+  }
+
+  return [number.padStart(10, '0'), err];
+}
+
+const impl: Validator = {
+  name: 'Costa Rica Physical Person ID Number',
+  localName: 'Cédula de Persona Física',
+  abbreviation: 'CPF',
+  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, 6).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.InvalidFormat() };
+    }
+    if (value[0] !== '0') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cr/cpj.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './cpj';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('cr/cpj', () => {
+  it('format:4 000 042138', () => {
+    const result = format('4 000 042138');
+
+    expect(result).toEqual('4-000-042138');
+  });
+
+  it('validate:3-101-999999', () => {
+    const result = validate('3-101-999999');
+
+    expect(result.isValid && result.compact).toEqual('3101999999');
+  });
+
+  it('validate:310132541', () => {
+    const result = validate('310132541');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:3-534-123559', () => {
+    const result = validate('3-534-123559');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});