stdnum 1.10.0 → 1.10.2

package/src/ec/ci.ts

@@ -0,0 +1,92 @@
+/**
+ * CI (Cédula de identidad, Ecuadorian personal identity code).
+ *
+ * The CI is a 10 digit number used to identify Ecuadorian citizens.
+ *
+ * Source
+ *
+ * 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, ' -');
+}
+
+export function validPrefix(value: string): boolean {
+  const prefix = parseInt(value.substr(0, 2), 10);
+  if (prefix === 0 || prefix > 24 || prefix === 30 || prefix === 50) {
+    // Invalid province
+    return false;
+  }
+
+  return true;
+}
+
+const impl: Validator = {
+  name: 'Ecuadorian Personal Identity Code',
+  localName: 'Cédula de Identidad',
+  abbreviation: 'CI',
+  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, 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)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!validPrefix(value)) {
+      // Invalid province
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (parseInt(value[2], 10) > 6) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const digit =
+      value
+        .split('')
+        .map(v => parseInt(v, 10))
+        .map((v, idx) => (idx % 2 === 0 ? v * 2 : v))
+        .map(v => (v > 9 ? v - 9 : v))
+        .reduce((acc, v) => acc + v) % 10;
+
+    if (digit !== 0) {
+      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/ec/index.ts

@@ -0,0 +1,2 @@
+export * as ci from './ci';
+export * as ruc from './ruc';

package/src/ec/ruc.spec.ts

@@ -0,0 +1,37 @@
+import { validate, format } from './ruc';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ec/ruc', () => {
+  it('format:1792060346001', () => {
+    const result = format('1792060346001');
+
+    expect(result).toEqual('1792060346-001');
+  });
+
+  it('validate:1792060346-001', () => {
+    const result = validate('1792060346-001');
+
+    expect(result.isValid && result.compact).toEqual('1792060346001');
+  });
+
+  test.each(['0101016905001', '0962467429001', '1803557964001'])(
+    'validate:%s',
+    value => {
+      const result = validate(value);
+
+      expect(result.isValid).toEqual(true);
+    },
+  );
+
+  it('validate:1792060346-00', () => {
+    const result = validate('1792060346-00');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1792060347-001', () => {
+    const result = validate('1792060347-001');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ec/ruc.ts

@@ -0,0 +1,117 @@
+/**
+ * RUC (Registro Único de Contribuyentes, Ecuadorian company tax number).
+ *
+ * The RUC is a tax identification number for legal entities. It has 13 digits
+ * where the third digit is a number denoting the type of entity.
+ *
+ * Source
+ *
+ *
+ * TAX/VAT
+ */
+
+import * as exceptions from '../exceptions';
+import * as ci from './ci';
+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: 'Ecuadorian Company Tax Number',
+  localName: 'Registro Único de Contribuyentes',
+  abbreviation: 'RUC',
+  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 !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!ci.validPrefix(value)) {
+      // Invalid province
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (parseInt(value[2], 10) < 6) {
+      //  Natural RUC: CI plus establishment number
+      const [front, end] = strings.splitAt(value, 10);
+      if (end === '000') {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+
+      return ci.validate(front);
+    }
+
+    if (value[2] === '6') {
+      // Public RUC
+      const [front, end] = strings.splitAt(value, 9);
+      if (end === '0000') {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+
+      if (
+        weightedSum(front, {
+          weights: [3, 2, 7, 6, 5, 4, 3, 2, 1],
+          modulus: 11,
+        }) !== 0
+      ) {
+        // If it's not a public, try natural
+        if (end.endsWith('000')) {
+          return { isValid: false, error: new exceptions.InvalidComponent() };
+        }
+
+        return ci.validate(value.substring(0, 10));
+      }
+    } else if (value[2] === '9') {
+      // Juridical RUC
+      const [front, end] = strings.splitAt(value, 10);
+      if (end === '000') {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (
+        weightedSum(front, {
+          weights: [4, 3, 2, 7, 6, 5, 4, 3, 2, 1],
+          modulus: 11,
+        }) !== 0
+      ) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ee/ik.spec.ts

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

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