stdnum 1.10.0 → 1.10.2

package/src/it/aic.ts

@@ -0,0 +1,97 @@
+/**
+ * AIC (Italian code for identification of drugs).
+ *
+ * AIC codes are used to identify drugs allowed to be sold in Italy. Codes are
+ * issued by the Italian Drugs Agency (AIFA, Agenzia Italiana del Farmaco), the
+ * government authority responsible for drugs regulation in Italy.
+ * The number consists of 9 digits and includes a check digit.
+ *
+ * More information:
+ *   https://www.gazzettaufficiale.it/do/atto/serie_generale/caricaPdf?cdimg=14A0566800100010110001&dgu=2014-07-18&art.dataPubblicazioneGazzetta=2014-07-18&art.codiceRedazionale=14A05668&art.num=1&art.tiposerie=SG
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const alphabet = '0123456789BCDFGHJKLMNPQRSTUVWXYZ';
+
+const impl: Validator = {
+  name: 'Italian Code for Identification of Drugs',
+  localName: 'Autorizzazione all’Immissione in Commercio',
+  abbreviation: 'AIC',
+  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 !== 6 && value.length !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    let base10 = value;
+    if (value.length === 6) {
+      // Base32 version
+      const chars = value.split('');
+      if (!chars.every(v => alphabet.includes(v))) {
+        return { isValid: false, error: new exceptions.InvalidFormat() };
+      }
+      base10 = String(
+        chars
+          .reverse()
+          .reduce((acc, v, idx) => acc + alphabet.indexOf(v) * 32 ** idx, 0),
+      ).padStart(9, '0');
+    }
+
+    // Base10 version
+    if (!strings.isdigits(base10)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, end] = strings.splitAt(base10, -1);
+
+    const sum = front
+      .split('')
+      .map(v => parseInt(v, 10))
+      .reduce((acc, v, idx) => {
+        const vv = v * ((idx % 2) + 1);
+
+        return acc + Math.floor(vv / 10) + (vv % 10);
+      }, 0);
+
+    if (String(sum % 10) !== end) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/it/codicefiscale.spec.ts

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

package/src/it/codicefiscale.ts

@@ -0,0 +1,167 @@
+/**
+ * Codice Fiscale (Italian tax code for individuals).
+ *
+ * The Codice Fiscale is an alphanumeric code of 16 characters used to identify
+ * individuals residing in Italy or 11 digits for non-individuals in which case
+ * it matches the Imposta sul valore aggiunto.
+ *
+ * The 16 digit number consists of three characters derived from the person's
+ * last name, three from the person's first name, five that hold information on
+ * the person's gender and birth date, four that represent the person's place of
+ * birth and one check digit.
+ *
+ * Source
+ *   https://it.m.wikipedia.org/wiki/Codice_fiscale
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const checkRe =
+  /^[A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST]{1}[0-9LMNPQRSTUV]{2}[A-Z]{1}[0-9LMNPQRSTUV]{3}[A-Z]{1}$/;
+
+const CHECK_CODE_ODD: Record<string, number> = {
+  0: 1,
+  1: 0,
+  2: 5,
+  3: 7,
+  4: 9,
+  5: 13,
+  6: 15,
+  7: 17,
+  8: 19,
+  9: 21,
+  A: 1,
+  B: 0,
+  C: 5,
+  D: 7,
+  E: 9,
+  F: 13,
+  G: 15,
+  H: 17,
+  I: 19,
+  J: 21,
+  K: 2,
+  L: 4,
+  M: 18,
+  N: 20,
+  O: 11,
+  P: 3,
+  Q: 6,
+  R: 8,
+  S: 12,
+  T: 14,
+  U: 16,
+  V: 10,
+  W: 22,
+  X: 25,
+  Y: 24,
+  Z: 23,
+};
+
+const CHECK_CODE_EVEN: Record<string, number> = {
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  8: 8,
+  9: 9,
+  A: 0,
+  B: 1,
+  C: 2,
+  D: 3,
+  E: 4,
+  F: 5,
+  G: 6,
+  H: 7,
+  I: 8,
+  J: 9,
+  K: 10,
+  L: 11,
+  M: 12,
+  N: 13,
+  O: 14,
+  P: 15,
+  Q: 16,
+  R: 17,
+  S: 18,
+  T: 19,
+  U: 20,
+  V: 21,
+  W: 22,
+  X: 23,
+  Y: 24,
+  Z: 25,
+};
+
+const CHECK_CODE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -:');
+}
+
+const impl: Validator = {
+  name: 'Italian Tax Code',
+  localName: 'Codice Fiscale',
+  abbreviation: 'CF',
+  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 (!checkRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = front
+      .split('')
+      .reduce(
+        (acc, v, idx) =>
+          (acc + (idx % 2 === 1 ? CHECK_CODE_EVEN[v] : CHECK_CODE_ODD[v])) % 26,
+        0,
+      );
+
+    if (CHECK_CODE_CHARS[sum] !== check) {
+      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/it/index.ts

@@ -0,0 +1,3 @@
+export * as aic from './aic';
+export * as codicefiscale from './codicefiscale';
+export * as iva from './iva';

package/src/it/iva.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './iva';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('it/iva', () => {
+  it('format:IT 00743110157', () => {
+    const result = format('IT 00743110157');
+
+    expect(result).toEqual('00743110157');
+  });
+
+  it('validate:IT 00743110157', () => {
+    const result = validate('IT 00743110157');
+
+    expect(result.isValid && result.compact).toEqual('00743110157');
+  });
+
+  it('validate:IT 0074311015', () => {
+    const result = validate('IT 0074311015');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:IT 00743110158', () => {
+    const result = validate('IT 00743110158');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/it/iva.ts

@@ -0,0 +1,65 @@
+/**
+ *
+ */
+
+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, ' -:', 'IT');
+}
+
+const impl: Validator = {
+  name: 'Italian VAT Number',
+  localName: 'Partita Imposta sul Valore Aggiunto',
+  abbreviation: 'P.IVA',
+  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 !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    const code = parseInt(value.substr(7, 3), 10);
+    if (!(code >= 1 && code <= 100) && ![120, 121, 888, 999].includes(code)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!luhnChecksumValidate(value)) {
+      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/jp/cn.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './cn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('jp/cn', () => {
+  it('format:5835678256246', () => {
+    const result = format('5835678256246');
+
+    expect(result).toEqual('5-8356-7825-6246');
+  });
+
+  it('validate:5-8356-7825-6246', () => {
+    const result = validate('5-8356-7825-6246');
+
+    expect(result.isValid && result.compact).toEqual('5835678256246');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:2-8356-7825-6246', () => {
+    const result = validate('2-8356-7825-6246');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/jp/cn.ts

@@ -0,0 +1,77 @@
+/**
+ * CN (法人番号, hōjin bangō, Japanese Corporate Number).
+ *
+ * The Corporate Number is assigned by the Japanese National Tax Agency to
+ * identify government organs, public entities, registered corporations and
+ * other organisations. The number consists of 13 digits where the first digit
+ * is a non-zero check digit.
+ *
+ * More information:
+ * https://en.wikipedia.org/wiki/Corporate_Number
+ * https://www.nta.go.jp/taxes/tetsuzuki/mynumberinfo/houjinbangou/
+ */
+
+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: 'Japanese Corporate Number',
+  localName: '法人番号 (hōjin bangō)',
+  abbreviation: 'CN',
+  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, 5, 9).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() };
+    }
+    const [check, rest] = strings.splitAt(value, 1);
+
+    const sum = weightedSum(rest, {
+      modulus: 9,
+      reverse: true,
+      weights: [1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2],
+    });
+
+    if (String(9 - sum) !== 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/jp/index.ts

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

package/src/ke/index.ts

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

package/src/ke/pin.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './pin';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('ke/pin', () => {
+  it('format:P051365947M', () => {
+    const result = format('P051365947M');
+
+    expect(result).toEqual('P051365947M');
+  });
+
+  it('fvalidate:P051365947M', () => {
+    const result = validate('P051365947M');
+
+    expect(result.isValid && result.compact).toEqual('P051365947M');
+  });
+
+  test.each(['P051365947M', 'P051365947M'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:P051365947', () => {
+    const result = validate('P051365947');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:P05136594M7', () => {
+    const result = validate('P05136594M7');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});

package/src/ke/pin.ts

@@ -0,0 +1,77 @@
+/**
+ * PIN (Personal Identification Number, Kenya tax number).
+ *
+ * The Personal Identification Number (KRA PIN) is an 11 digit unique number that
+ * is issued by Kenya Revenue Authority (KRA) for purposes of transacting business
+ * with KRA, other Government agencies and service providers. It can be issued for
+ * individuals and non-individuals like companies, schools, organisations, etc.
+ *
+ * The number consists of 11 characters, where the first one is an A (for
+ * individuals) or a P (for non-individuals), the last one is a letter, and the
+ * rest are digits.
+ *
+ * DESCRIPTION
+ *
+ * Source
+ *   https://www.kra.go.ke/individual/individual-pin-registration/learn-about-pin/about-pin
+ *   https://itax.kra.go.ke/KRA-Portal/pinChecker.htm
+ *
+ * ENTITY/PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const validRe = /^[A|P]{1}[0-9]{9}[A-Z]{1}$/i;
+
+const impl: Validator = {
+  name: 'Personal Identification Number',
+  localName: '',
+  abbreviation: 'PIN',
+
+  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 !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!validRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: value[0] === 'A',
+      isCompany: value[0] === 'P',
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/kr/brn.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './brn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('kr/brn', () => {
+  it('format:1168200276', () => {
+    const result = format('1168200276');
+
+    expect(result).toEqual('116-82-00276');
+  });
+
+  it('validate:116-82-00276', () => {
+    const result = validate('116-82-00276');
+
+    expect(result.isValid && result.compact).toEqual('1168200276');
+  });
+
+  it('validate:123456789', () => {
+    const result = validate('123456789');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:116-82-00278', () => {
+    const result = validate('116-82-00278');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});