stdnum 1.10.0 → 1.10.1

package/src/uy/rut.ts

@@ -0,0 +1,99 @@
+/**
+ * RUT (Registro Único Tributario, Uruguay tax number).
+ *
+ * The Registro Único Tributario (RUT) is an identifier of legal entities for
+ * tax purposes.
+ *
+ * This number consists of 12 digits, the first two indicate the registration
+ * number, followed by a 6 digit sequence number, followed by 001 and a check
+ * digit.
+ *
+ * Source
+ *    https://www.agesic.gub.uy/innovaportal/file/1634/1/modelo_de_datos.pdf (page 71)
+ *    https://servicios.dgi.gub.uy/ServiciosEnLinea/dgi--servicios-en-linea--consulta-de-certifcado-unico
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { pymod } from '../util/pymod';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+  if (err) {
+    return [value, err];
+  }
+  if (value.startsWith('UY')) {
+    return [value.substr(2), null];
+  }
+  return [value, err];
+}
+
+const impl: Validator = {
+  name: 'Uruguayan Tax Number',
+  localName: 'Registro Ú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);
+
+    return strings.splitAt(value, 2, -4, -1).join('-');
+  },
+
+  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)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (parseInt(value.substr(0, 2), 10) > 21 || value.substr(0, 2) === '00') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (value.substr(2, 6) === '000000') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (value.substr(8, 3) !== '001') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, 11);
+
+    const sum = weightedSum(front, {
+      weights: [4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2],
+      modulus: 11,
+    });
+
+    const digit = String(pymod(-sum, 11));
+
+    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/ve/index.ts

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

package/src/ve/rif.spec.ts

@@ -0,0 +1,38 @@
+import { validate, format } from './rif';
+import {
+  InvalidLength,
+  InvalidComponent,
+  InvalidChecksum,
+} from '../exceptions';
+
+describe('ve/rif', () => {
+  it('format:V114702834', () => {
+    const result = format('V114702834');
+
+    expect(result).toEqual('V-11470283-4');
+  });
+
+  it('validate:V-11470283-4', () => {
+    const result = validate('V-11470283-4');
+
+    expect(result.isValid && result.compact).toEqual('V114702834');
+  });
+
+  it('validate:O-11470283-3', () => {
+    const result = validate('O-11470283-3');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:V-11470283-3', () => {
+    const result = validate('V-11470283-3');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ve/rif.ts

@@ -0,0 +1,92 @@
+/**
+ * RIF (Registro Único de Información Fiscal, Venezuelan VAT number).
+ *
+ * The Registro Único de Información Fiscal  (RIF) is the Venezuelan fiscal
+ * registration number. The number consists of 10 digits where the first digit
+ * denotes the type of number (person, company or government) and the last digit
+ * is a check digit.
+ *
+ * Source
+ * https://wiki.scn.sap.com/wiki/display/CRM/Venezuela
+ * VAT
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+//  Known number types and their corresponding value in the check
+//  digit calculation
+const companyTypes: Record<string, number> = {
+  V: 4, // natural person born in Venezuela
+  E: 8, // foreign natural person
+  J: 12, // company
+  P: 16, // passport
+  G: 20, // government
+};
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Venezuelan VAT Number',
+  localName: 'Registro Único de Información Fiscal',
+  abbreviation: 'RIF',
+  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, 1, 9).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.substr(1))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    const [ctype, body, check] = strings.splitAt(value, 1, 9);
+    const first = companyTypes[ctype];
+    if (first === undefined) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const digit =
+      (first +
+        weightedSum(body, {
+          weights: [3, 2, 7, 6, 5, 4, 3, 2],
+          modulus: 11,
+        })) %
+      11;
+
+    if ('00987654321'[digit] !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: ['V', 'E'].includes(ctype),
+      isCompany: ['J', 'G', 'P'].includes(ctype),
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/vn/index.ts

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

package/src/vn/mst.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './mst';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('va/mst', () => {
+  it('format:01.00.112.437', () => {
+    const result = format('01.00.112.437');
+
+    expect(result).toEqual('0100112437');
+  });
+
+  it('format:0312 68 78 78 - 001', () => {
+    const result = format('0312 68 78 78 - 001');
+
+    expect(result).toEqual('0312687878-001');
+  });
+
+  it('validate:0100233488', () => {
+    const result = validate('0100233488');
+
+    expect(result.isValid && result.compact).toEqual('0100233488');
+  });
+
+  it('validate:0314409058-002', () => {
+    const result = validate('0314409058-002');
+
+    expect(result.isValid && result.compact).toEqual('0314409058002');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:0100233480', () => {
+    const result = validate('0100233480');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/vn/mst.ts

@@ -0,0 +1,100 @@
+/**
+ * MST (Mã số thuế, Vietnam tax number).
+ *
+ * This number consists of 10 digits. Branches have a 13 digit number,
+ * where the first ten digits are the same as the parent company's.
+ *
+ * The first two digits is the province code where the business was
+ * established. If an enterprise relocates its head office from one
+ * province to another, ths MST will remain unchanged.
+ *
+ * The following seven digits are a sequential number from 0000001 to
+ * 9999999.
+ *
+ * The tenth digit is the check digit for the first nine digits, which is
+ * used to verify the number was correctly typed.
+ *
+ * The last optional three digits are a sequence from 001 to 999
+ * indicating branches of the enterprise. These digits are usually
+ * separated from the first ten digits using a dash (-)
+ *
+ * Source
+ *   https://vi.wikipedia.org/wiki/Thuế_Việt_Nam#Mã_số_thuế_(MST)_của_doanh_nghiệp
+ *   https://easyinvoice.vn/ma-so-thue/
+ *   https://ub.com.vn/threads/huong-dan-tra-cuu-ma-so-thue-doanh-nghiep-moi-nhat.261393/
+ *
+ * /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: 'Vietnamese Tax Number',
+  localName: 'Mã số thuế',
+  abbreviation: 'MST',
+  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).join('-');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 10 && value.length !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    const [province, sequence, check, suffix] = strings.splitAt(
+      value,
+      2,
+      9,
+      10,
+    );
+
+    if (sequence === '0000000' || suffix === '000' || province === '00') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = weightedSum(value.substr(0, 9), {
+      modulus: 11,
+      weights: [31, 29, 23, 19, 17, 13, 7, 5, 3],
+    });
+
+    if (check !== String(10 - sum)) {
+      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/za/idnr.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './idnr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('za/idnr', () => {
+  it('format:7503305044089', () => {
+    const result = format('7503305044089');
+
+    expect(result).toEqual('7503305044089');
+  });
+
+  it('validate:7503305044089', () => {
+    const result = validate('7503305044089');
+
+    expect(result.isValid && result.compact).toEqual('7503305044089');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:8503305044089', () => {
+    const result = validate('8503305044089');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/za/idnr.ts

@@ -0,0 +1,84 @@
+/**
+ * ID number (South African Identity Document number).
+ *
+ * The South African ID number is issued to individuals within South Africa. The
+ * number consists of 13 digits and contains information about a person's date
+ * of birth, gender and whether the person is a citizen or permanent resident.
+ *
+ * Source
+ *   https://en.wikipedia.org/wiki/South_African_identity_card
+ *   http://www.dha.gov.za/index.php/identity-documents2
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, isValidDateCompactYYMMDD } 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: 'South African Identity Document Number',
+  localName: 'Identity Document Number',
+  abbreviation: 'IDNR',
+  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 !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [bdate, gender, , citizen] = strings.splitAt(value, 6, 7, 10, 11);
+
+    if (!'01'.includes(citizen)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(gender)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!isValidDateCompactYYMMDD(bdate, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    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/za/index.ts

@@ -0,0 +1,2 @@
+export * as tin from './tin';
+export * as idnr from './idnr';

package/src/za/tin.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './tin';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('za/tin', () => {
+  it('format:2449/494-16-0', () => {
+    const result = format('2449/494-16-0');
+
+    expect(result).toEqual('2449494160');
+  });
+
+  it('validate:0001339050', () => {
+    const result = validate('0001339050');
+
+    expect(result.isValid && result.compact).toEqual('0001339050');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:2449/494/16/0', () => {
+    const result = validate('2449/494/16/0');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/za/tin.ts

@@ -0,0 +1,75 @@
+/**
+ * TIN (South African Tax Identification Number).
+ *
+ * The South African Tax Identification Number (TIN or Tax Reference Number) is
+ * issued to individuals and legal entities for tax purposes. The number
+ * consists of 10 digits.
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/South-Africa-TIN.pdf
+ *   https://www.sars.gov.za/
+ *
+ * PERSON/ENTITY
+ */
+
+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: 'South African Tax Identification Number',
+  localName: 'Tax Identification Number',
+  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);
+
+    return value;
+  },
+
+  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 (!'01239'.includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!luhnChecksumValidate(value)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true, // TIN can be either. cannot determine
+      isCompany: true, // TIN can be either. cannot determine
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;