stdnum 1.10.0 → 1.10.1

package/src/ee/ik.ts

@@ -0,0 +1,114 @@
+/**
+ * Isikukood (Estonian Personal ID number).
+ *
+ * The number consists of 11 digits: the first indicates the gender and century
+ * the person was born in, the following 6 digits the birth date, followed by a
+ * 3 digit serial and a check digit.
+ *
+ * Source
+ *    https://www.riigiteataja.ee/akt/106032012004
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDateCompactYYYYMMDD, 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, ' ');
+}
+
+export function ikCheck(value: string): boolean {
+  const [front, check] = strings.splitAt(value, -1);
+
+  let sum = weightedSum(front, {
+    modulus: 11,
+    weights: [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6],
+  });
+  if (sum === 10) {
+    sum = weightedSum(front, {
+      modulus: 11,
+      weights: [3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    });
+  }
+
+  return String(sum % 10) === check;
+}
+
+export function ikCheckDate(value: string): boolean {
+  let century;
+
+  switch (value[0]) {
+    case '1':
+    case '2':
+      century = '18';
+      break;
+    case '3':
+    case '4':
+      century = '19';
+      break;
+    case '5':
+    case '6':
+      century = '20';
+      break;
+    case '7':
+    case '8':
+      century = '21';
+      break;
+    default:
+      return false;
+  }
+
+  return isValidDateCompactYYYYMMDD(`${century}${value.substr(1, 6)}`, true);
+}
+
+const impl: Validator = {
+  name: 'Estonian Personal ID Number',
+  localName: 'Isikukood',
+  abbreviation: 'IK',
+  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() };
+    }
+
+    if (!ikCheck(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/ee/index.ts

@@ -0,0 +1,3 @@
+export * as ik from './ik';
+export * as kmkr from './kmkr';
+export * as registrikood from './registrikood';

package/src/ee/kmkr.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './kmkr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ee/kmkr', () => {
+  it('format:EE 100 931 558', () => {
+    const result = format('EE 100 931 558');
+
+    expect(result).toEqual('100931558');
+  });
+
+  it('validate:100594102', () => {
+    const result = validate('100594102');
+
+    expect(result.isValid && result.compact).toEqual('100594102');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:100594103', () => {
+    const result = validate('100594103');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ee/kmkr.ts

@@ -0,0 +1,76 @@
+/**
+ * KMKR (Käibemaksukohuslase, Estonian VAT number).
+ *
+ */
+
+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> {
+  const [value, err] = strings.cleanUnicode(input, ' ');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('EE')) {
+    return [value.substr(2), null];
+  }
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Estronian VAT Number',
+  localName: 'Käibemaksukohuslase',
+  abbreviation: 'KMKR',
+  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 !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      modulus: 10,
+      weights: [3, 7, 1],
+    });
+
+    if (String((10 - 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/ee/registrikood.spec.ts

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

package/src/ee/registrikood.ts

@@ -0,0 +1,80 @@
+/**
+ * Registrikood (Estonian organisation registration code).
+ *
+ * All organisations are assigned a unique tax identification code from the
+ * commercial register, from the state register or from the non-profit
+ * associations and foundations register. The code consists of 8 digits.
+ *
+ * Commercial company numbers start with a 1, schools and government numbers
+ * with a 7, non-profit organisations with an 8 and foundations with a 9. The
+ * number uses the same check digit algorithm as the Isikukood although that
+ * fact is undocumented.
+ *
+ * Source
+ *  https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Estonia-TIN.pdf
+ *   https://ariregister.rik.ee/
+ *   https://mtr.mkm.ee/
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { ikCheck } from './ik';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -/');
+}
+
+const impl: Validator = {
+  name: 'Estonian Organisation Registration Code',
+  localName: 'Registrikood',
+  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 !== 8) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!['1', '7', '8', '9'].includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!ikCheck(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/eg/index.ts

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

package/src/eg/tn.spec.ts

@@ -0,0 +1,44 @@
+import { validate, format } from './tn';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('eg/tn', () => {
+  it('format:100531385', () => {
+    const result = format('100531385');
+
+    expect(result).toEqual('100-531-385');
+  });
+
+  it('fvalidate:100-531-385', () => {
+    const result = validate('100-531-385');
+
+    expect(result.isValid && result.compact).toEqual('100531385');
+  });
+
+  test.each([
+    '100-531-385',
+    '٣٣١-١٠٥-٢٦٨',
+    '421 – 159 – 723',
+    '431-134-189',
+    '432-600-132',
+    '455-466-138',
+    '455273677',
+    '٩٤٦-١٤٩-٢٠٠',
+    '۹٤۹-۸۹۱-۲۰٤',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:VV3456789', () => {
+    const result = validate('VV3456789');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:12345', () => {
+    const result = validate('12345');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/eg/tn.ts

@@ -0,0 +1,96 @@
+/**
+ * Tax Registration Number (الرقم الضريبي, Egypt tax number).
+ *
+ * This number consists of 9 digits, usually separated into three groups
+ * using hyphens to make it easier to read, like XXX-XXX-XXX.
+ *
+ * Source
+ *   https://emsp.mts.gov.eg:8181/EMDB-web/faces/authoritiesandcompanies/authority/website/SearchAuthority.xhtml?lang=en
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const ARABIC_NUMBERS_MAP: Record<string, string> = {
+  // Arabic-indic digits.
+  '٠': '0',
+  '١': '1',
+  '٢': '2',
+  '٣': '3',
+  '٤': '4',
+  '٥': '5',
+  '٦': '6',
+  '٧': '7',
+  '٨': '8',
+  '٩': '9',
+  // Extended arabic-indic digits.
+  '۰': '0',
+  '۱': '1',
+  '۲': '2',
+  '۳': '3',
+  '۴': '4',
+  '۵': '5',
+  '۶': '6',
+  '۷': '7',
+  '۸': '8',
+  '۹': '9',
+};
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  // Normalize the arabic characters to ascii digits
+  const norm = input
+    .split('')
+    .map(c => ARABIC_NUMBERS_MAP[c] ?? c)
+    .join('');
+  return strings.cleanUnicode(norm, ' -/');
+}
+
+const impl: Validator = {
+  name: 'Tax Registration Number',
+  localName: 'الرقم الضريبي',
+  abbreviation: 'TN',
+
+  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() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/es/cif.spec.ts

@@ -0,0 +1,43 @@
+import { validate, format } from './cif';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('es/cif', () => {
+  it('format:J99216582', () => {
+    const result = format('J99216582');
+
+    expect(result).toEqual('J-9921658-2');
+  });
+
+  it.each(['J99216582', 'B86670460', 'Q2876031B', 'N0112768G', 'W8265365J'])(
+    'validate:%s',
+    (cif: string) => {
+      const result = validate(cif);
+
+      expect(result.isValid && result.compact).toEqual(cif);
+    },
+  );
+
+  it('validate:X13585626', () => {
+    const result = validate('X13585626');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:J992165831', () => {
+    const result = validate('J992165831');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:M-1234567-L', () => {
+    const result = validate('M-1234567-L');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:O-1234567-L', () => {
+    const result = validate('O-1234567-L');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/es/cif.ts

@@ -0,0 +1,84 @@
+/**
+ * CIF (Código de Identificación Fiscal, Spanish company tax number).
+ *
+ * The CIF is a tax identification number for legal entities. It has 9 digits
+ * where the first digit is a letter (denoting the type of entity) and the
+ * last is a check digit (which may also be a letter).
+ *
+ * Sources:
+ *   https://es.wikipedia.org/wiki/Código_de_identificación_fiscal
+ *
+ * TAX/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumDigit } from '../util/checksum';
+
+const entityTypes = 'ABCDEFGHJNPQRSUVW';
+const letterCheckDigits = 'JABCDEFGHI';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Spanish Company Tax Number',
+  localName: 'Código de Identificación Fiscal',
+  abbreviation: 'CIF',
+  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, 8).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() };
+    }
+
+    const [first, body, check] = strings.splitAt(value, 1, 8);
+
+    if (
+      !strings.isdigits(body) ||
+      !entityTypes.includes(first) ||
+      !(strings.isdigits(check) || letterCheckDigits.includes(check))
+    ) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const cs = parseInt(luhnChecksumDigit(body), 10);
+    // Two systems of check digits
+    const possibleCheckDigits = letterCheckDigits[cs] + String(cs);
+
+    if (!possibleCheckDigits.includes(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/es/dni.spec.ts

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