stdnum 1.10.0 → 1.10.2

package/src/mx/rfc.ts

@@ -0,0 +1,193 @@
+/**
+ * RFC (Registro Federal de Contribuyentes, Mexican tax number).
+ *
+ * This number is used to identify individuals and companies for tax purposes.
+ *
+ * The company number is 12 digits where the first 3 letters or digits are
+ * derived from the name of the company, the following 6 contain the date of
+ * incorporation, followed by 3 check digits.
+ *
+ * Personal numbers consist of 13 digits where the first 4 characters from the
+ * person's name, followed by their birth date and 3 check digits.
+ *
+ * The first two check digits are calculated based on the person's or company's
+ * full name. The last check digit is calculated over all the preceding digits
+ * in the number. However, it seems a lot of numbers (estimated at around 1.5%
+ * of all numbers) are in use with invalid check digits so this test is disabled
+ * by default.
+ *
+ * More information:
+ *
+ * https://www.infomex.org.mx/jspsi/documentos/2005/seguimiento/06101/0610100162005_065.doc
+ * https://es.wikipedia.org/wiki/Registro_Federal_de_Contribuyentes_(M%C3%A9xico)
+ *
+ * An online validation service is available at:
+ *
+ * https://portalsat.plataforma.sat.gob.mx/ConsultaRFC/
+ *
+ * VAT  PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDateCompactYYMMDD, strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, '-_ ');
+}
+
+const nameBlacklist = new Set([
+  'BUEI',
+  'BUEY',
+  'CACA',
+  'CACO',
+  'CAGA',
+  'CAGO',
+  'CAKA',
+  'CAKO',
+  'COGE',
+  'COJA',
+  'COJE',
+  'COJI',
+  'COJO',
+  'CULO',
+  'FETO',
+  'GUEY',
+  'JOTO',
+  'KACA',
+  'KACO',
+  'KAGA',
+  'KAGO',
+  'KAKA',
+  'KOGE',
+  'KOJO',
+  'KULO',
+  'MAME',
+  'MAMO',
+  'MEAR',
+  'MEAS',
+  'MEON',
+  'MION',
+  'MOCO',
+  'MULA',
+  'PEDA',
+  'PEDO',
+  'PENE',
+  'PUTA',
+  'PUTO',
+  'QULO',
+  'RATA',
+  'RUIN',
+]);
+
+const checkAlphabet = '0123456789ABCDEFGHIJKLMN&OPQRSTUVWXYZ Ñ';
+// const checkAlphabetDict: Record<string, number> = checkAlphabet
+//   .split('')
+//   .reduce((acc, c, idx) => ({ ...acc, [c]: idx }), {});
+
+const impl: Validator = {
+  name: 'Mexican Tax Number',
+  localName: 'Registro Federal de Contribuyentes',
+  abbreviation: 'RFC',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value.toLocaleUpperCase();
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    if (value.length === 12) {
+      return strings.splitAt(value, 3, 9).join(' ');
+    }
+    if (value.length === 13) {
+      return strings.splitAt(value, 4, 10).join(' ');
+    }
+    return strings.splitAt(value, 4).join(' ');
+  },
+
+  /**
+   * Check if the number is a valid RFC 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 === 10 || value.length === 13) {
+      if (!/^[A-Z&Ñ]{4}[0-9]{6}([0-9A-Z]{3})?$/.test(value)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (nameBlacklist.has(value.substr(0, 4))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!isValidDateCompactYYMMDD(value.substr(4, 6), true)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else if (value.length === 12) {
+      if (!/^[A-Z&Ñ]{3}[0-9]{6}[0-9A-Z]{3}$/.test(value)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!isValidDateCompactYYMMDD(value.substr(3, 6))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (value.length >= 12) {
+      if (!/[1-9A-V][1-9A-Z][0-9A]$/.test(value)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+
+      const [front, check] = strings.splitAt(value, -1);
+
+      const sum = weightedSum(front.padStart(12, ' '), {
+        modulus: 11,
+        alphabet: checkAlphabet,
+        weights: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
+        reverse: true,
+      });
+
+      // const sum = value
+      //   .substr(0, value.length - 1)
+      //   .padStart(12, ' ')
+      //   .split('')
+      //   .reduce(
+      //     (acc, c, idx) => acc + (checkAlphabetDict[c] ?? 0) * (13 - idx),
+      //     0,
+      //   );
+      const mod = 11 - (sum % 11);
+      let val;
+      if (mod === 11) {
+        val = '0';
+      } else if (mod === 10) {
+        val = 'A';
+      } else {
+        val = String(mod);
+      }
+
+      if (check !== val) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: value.length !== 12,
+      isCompany: value.length === 12,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/my/index.ts

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

package/src/my/nric.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './nric';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('my/nric', () => {
+  it('format:770305021234', () => {
+    const result = format('770305021234');
+
+    expect(result).toEqual('770305-02-1234');
+  });
+
+  it('validate:770305-02-1234', () => {
+    const result = validate('770305-02-1234');
+
+    expect(result.isValid && result.compact).toEqual('770305021234');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:770305-17-1234', () => {
+    const result = validate('771305-17-1234');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:771305-02-1234', () => {
+    const result = validate('771305-02-1234');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  // it('validate:2449/494/16/0', () => {
+  //   const result = validate('2449/494/16/0');
+
+  //   expect(result.error).toBeInstanceOf(InvalidChecksum);
+  // });
+});

package/src/my/nric.ts

@@ -0,0 +1,91 @@
+/**
+ * NRIC No. (Malaysian National Registration Identity Card Number).
+ *
+ * The NRIC No. is the unique identifier for issued to Malaysian citizens and
+ * permanent residents.
+ *
+ * The number consist of 12 digits in three sections. The first 6 digits
+ * represent the birth date, followed by two digits represeting the birth
+ * place and finally four digits. The gender of a person can be derived from
+ * the last digit: odd numbers for males and even numbers for females.
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDateCompactYYMMDD, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -*');
+}
+
+const UNASSIGNED = [
+  '00',
+  '17',
+  '18',
+  '19',
+  '20',
+  '69',
+  '73',
+  '80',
+  '81',
+  '94',
+  '95',
+  '96',
+  '97',
+];
+
+const impl: Validator = {
+  name: 'Malaysian National Registration Identity Card Number',
+  localName: 'National Registration Identity Card Number',
+  abbreviation: 'NRIC 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 strings.splitAt(value, 6, 8).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() };
+    }
+
+    const [bdate, place] = strings.splitAt(value, 6, 8);
+
+    if (!isValidDateCompactYYMMDD(bdate, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (UNASSIGNED.includes(place)) {
+      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/nl/bsn.spec.ts

@@ -0,0 +1,68 @@
+import { validate, format } from './bsn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('nl/bsn', () => {
+  it('format:111222333', () => {
+    const result = format('111222333');
+
+    expect(result).toEqual('1112.22.333');
+  });
+
+  test.each([
+    '001855013', // RSIN
+    '1112.22.333', // BSN
+  ])('isValid', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:1112.22.333', () => {
+    const result = validate('1112.22.333');
+
+    expect(result.isValid && result.compact).toEqual('111222333');
+  });
+
+  it('validate:002455799', () => {
+    const result = validate('002455799');
+
+    // expect(result.isValid && result.compact).toEqual('002455799');
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:12345678912', () => {
+    const result = validate('12345678912');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1112.52.333', () => {
+    const result = validate('1112.52.333');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:123456782', () => {
+    const result = validate('123456782');
+
+    expect(result.isValid && result.compact).toEqual('123456782');
+  });
+
+  it('validate:40645678', () => {
+    const result = validate('40645678');
+
+    expect(result.isValid && result.compact).toEqual('40645678');
+  });
+
+  it('validate:1', () => {
+    const result = validate('1');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/nl/bsn.ts

@@ -0,0 +1,81 @@
+/**
+ * BSN (Burgerservicenummer, the Dutch citizen identification number).
+ *
+ * The BSN is a unique personal identifier and has been introduced as the
+ * successor to the sofinummer. It is issued to each Dutch national. The number
+ * consists of up to nine digits (the leading zeros are commonly omitted) and
+ * contains a simple checksum.
+ *
+ * Source:
+ *   https://en.wikipedia.org/wiki/National_identification_number#Netherlands
+ *   https://nl.wikipedia.org/wiki/Burgerservicenummer
+ *   http://www.burgerservicenummer.nl/
+ *
+ * PERSON
+ */
+
+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, ' -.');
+}
+
+function checksum(value: string): boolean {
+  const nineCharValue = value.padStart(9, '0');
+  const sum = weightedSum(nineCharValue, {
+    weights: [9, 8, 7, 6, 5, 4, 3, 2, -1],
+    modulus: 11,
+  });
+  return sum === 0;
+}
+
+const impl: Validator = {
+  name: 'Dutch Citizen Identification Number',
+  localName: 'Burgerservicenummer',
+  abbreviation: 'BSN',
+  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, 6).join('.');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (![8, 9].includes(value.length)) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!checksum(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/nl/btw.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './btw';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('nl/btw', () => {
+  it('format:004495445B01', () => {
+    const result = format('004495445B01');
+
+    expect(result).toEqual('004495445B01');
+  });
+
+  it('validate:004495445B01', () => {
+    const result = validate('004495445B01');
+
+    expect(result.isValid && result.compact).toEqual('004495445B01');
+  });
+
+  it('validate:NL4495445B01', () => {
+    const result = validate('NL4495445B01');
+
+    expect(result.isValid && result.compact).toEqual('004495445B01');
+  });
+
+  it('validate:NL002455799B11', () => {
+    const result = validate('NL002455799B11');
+
+    expect(result.isValid && result.compact).toEqual('002455799B11');
+  });
+
+  it('validate:123456789012345', () => {
+    const result = validate('123456789012345');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:123456789B90', () => {
+    const result = validate('123456789B90');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/nl/btw.ts

@@ -0,0 +1,95 @@
+/**
+ * Btw-identificatienummer (Omzetbelastingnummer, the Dutch VAT number).
+ *
+ * The btw-identificatienummer (previously the btw-nummer) is the Dutch number
+ * for identifying parties in a transaction for which VAT is due. The btw-nummer
+ * is used in communication with the tax agency while the
+ * btw-identificatienummer (EORI-nummer) can be used when dealing with other
+ * companies though they are used interchangeably.
+ *
+ * The btw-nummer consists of a RSIN or BSN followed by the letter B and two
+ * digits that identify the number of the company created. The
+ * btw-identificatienummer has a similar format but different checksum and does
+ * not contain the BSN.
+ *
+ * Source
+ *   https://en.wikipedia.org/wiki/VAT_identification_number
+ *   https://nl.wikipedia.org/wiki/Btw-nummer_(Nederland)
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { mod97base10Validate, weightedSum } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -.', 'NL');
+
+  if (err) {
+    return [value, err];
+  }
+
+  const [a, b] = strings.splitAt(value, -3);
+
+  return [`${a.padStart(9, '0')}${b}`, null];
+}
+
+const impl: Validator = {
+  name: 'Dutch VAT Number',
+  localName: 'Btw-identificatienummer',
+  abbreviation: 'Btw-nr.',
+  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 !== 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    const [a, b, c] = strings.splitAt(value, 9, 10);
+    if (!strings.isdigits(a) || !strings.isdigits(c)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (b !== 'B') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = weightedSum(a, {
+      weights: [9, 8, 7, 6, 5, 4, 3, 2, -1],
+      modulus: 11,
+    });
+
+    if (sum % 11 !== 0 && !mod97base10Validate(`NL${a}${b}${c}`)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: `${a}${b}${c}`,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/nl/index.ts

@@ -0,0 +1,3 @@
+export * as bsn from './bsn';
+export * as btw from './btw';
+export * as onderwijsnummer from './onderwijsnummer';

package/src/nl/onderwijsnummer.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './onderwijsnummer';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('nl/onderwijsnummer', () => {
+  it('format:1012.22.331', () => {
+    const result = format('1012.22.331');
+
+    expect(result).toEqual('1012.22.331');
+  });
+
+  it('validate:1012.22.331', () => {
+    const result = validate('1012.22.331');
+
+    expect(result.isValid && result.compact).toEqual('101222331');
+  });
+
+  it('validate:1234567812', () => {
+    const result = validate('12345678012');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:100252333', () => {
+    const result = validate('100252333');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:1', () => {
+    const result = validate('1');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});