stdnum 1.9.16 → 1.10.1

package/src/do/ncf.ts

@@ -0,0 +1,133 @@
+/**
+ * NCF (Números de Comprobante Fiscal, Dominican Republic receipt number).
+ *
+ * The NCF is used to number invoices and other documents for the purpose of tax
+ * filing. The e-CF (Comprobante Fiscal Electrónico) is used together with a
+ * digital certificate for the same purpose. The number is either 19, 11 or 13
+ * (e-CF) digits long.
+ *
+ * The 19 digit number starts wit a letter (A or P) to indicate that the number
+ * was assigned by the taxpayer or the DGII, followed a 2-digit business unit
+ * number, a 3-digit location number, a 3-digit mechanism identifier, a 2-digit
+ * document type and a 8-digit serial number.
+ *
+ * The 11 digit number always starts with a B followed a 2-digit document type
+ * and a 7-digit serial number.
+ *
+ * The 13 digit e-CF starts with an E followed a 2-digit document type and an
+ * 8-digit serial number.
+ *
+ * Source
+ *    https://www.dgii.gov.do/
+ *    https://dgii.gov.do/workshopProveedoresTI-eCE/Documents/Norma05-19.pdf
+ *    https://dgii.gov.do/cicloContribuyente/facturacion/comprobantesFiscales/Paginas/tiposComprobantes.aspx
+ *
+ * VAT ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const ncfTypes = [
+  '01', // invoices for fiscal declaration (or tax reporting)
+  '02', // invoices for final consumer
+  '03', // debit note
+  '04', // credit note (refunds)
+  '11', // informal supplier invoices (purchases)
+  '12', // single income invoices
+  '13', // minor expenses invoices (purchases)
+  '14', // invoices for special customers (tourists, free zones)
+  '15', // invoices for the government
+  '16', // invoices for export
+  '17', // invoices for payments abroad
+];
+
+const ecfTypes = [
+  '31', // invoices for fiscal declaration (or tax reporting)
+  '32', // invoices for final consumer
+  '33', // debit note
+  '34', // credit note (refunds)
+  '41', // supplier invoices (purchases)
+  '43', // minor expenses invoices (purchases)
+  '44', // invoices for special customers (tourists, free zones)
+  '45', // invoices for the government
+  '46', // invoices for exports
+  '47', // invoices for foreign payments
+];
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const impl: Validator = {
+  name: 'Dominican Republic Receipt Number',
+  localName: 'Números de Comprobante Fiscal',
+  abbreviation: 'NCF',
+  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) {
+      if (!value.startsWith('E')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(value.substr(1))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!ecfTypes.includes(value.substr(1, 2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else if (value.length === 11) {
+      if (!value.startsWith('B')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(value.substr(1))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!ncfTypes.includes(value.substr(1, 2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else if (value.length === 19) {
+      if (!value.startsWith('AP')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(value.substr(2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!ncfTypes.includes(value.substr(9, 2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/do/rnc.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './rnc';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('do/rnc', () => {
+  it('format:101850043', () => {
+    const result = format('101850043');
+
+    expect(result).toEqual('1-01-85004-3');
+  });
+
+  it('validate:1-01-85004-3', () => {
+    const result = validate('1-01-85004-3');
+
+    expect(result.isValid && result.compact).toEqual('101850043');
+  });
+
+  it('validate:401505967', () => {
+    const result = validate('401505967');
+
+    expect(result.isValid && result.compact).toEqual('401505967');
+  });
+
+  it('validate:1018A0043', () => {
+    const result = validate('1018A0043');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:10185004', () => {
+    const result = validate('10185004');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:101850042', () => {
+    const result = validate('101850042');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/do/rnc.ts

@@ -0,0 +1,74 @@
+/**
+ * RNC (Registro Nacional del Contribuyente, Dominican Republic tax number).
+ *
+ * The RNC is the Dominican Republic taxpayer registration number for
+ * institutions. The number consists of 9 digits.
+ *
+ * Source
+ *
+ * TAX ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+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: 'Dominican Republic Tax Number',
+  localName: 'Registro Nacional del Contribuyente',
+  abbreviation: 'RNC',
+  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, 3, -1).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() };
+    }
+
+    const [front, check] = strings.splitAt(value, 8);
+
+    const sum = weightedSum(front, {
+      weights: [7, 9, 8, 6, 5, 4, 3, 2],
+      modulus: 11,
+    });
+
+    if (String(((10 - sum) % 9) + 1) !== 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/dz/index.ts

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

package/src/dz/nif.spec.ts

@@ -0,0 +1,39 @@
+import { validate, format } from './nif';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('dz/nif', () => {
+  it('format:000 216 001 808 337 13010', () => {
+    const result = format('000 216 001 808 337 13010');
+
+    expect(result).toEqual('00021600180833713010');
+  });
+
+  it('fvalidate:000 216 001 808 337 13010', () => {
+    const result = validate('000 216 001 808 337 13010');
+
+    expect(result.isValid && result.compact).toEqual('00021600180833713010');
+  });
+
+  test.each([
+    '416001000000007',
+    '408 020 000 150 039',
+    '41201600000606600001',
+    '000 216 001 808 337 13010',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:X1600100000000V', () => {
+    const result = validate('X1600100000000V');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:41600100000000', () => {
+    const result = validate('41600100000000');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/dz/nif.ts

@@ -0,0 +1,80 @@
+/**
+ * NIF, sometimes N.I.F. (Numéro d'Identification Fiscale, Algeria tax number).
+ *
+ * The NIF was adopted by the Algerian tax authorities on 2006, replacing the NIS
+ * number.
+ *
+ * The NIF applies to physical persons, legal persons, legal entities,
+ * administrative entities, local branches for foreign companies, associations,
+ * professional organisations, etc.
+ *
+ * The NIF consists of 15 digits, but sometimes it can be 20 digits long in order
+ * to represent branches or secondary establishments.
+ *
+ * Source
+ *   http://www.jecreemonentreprise.dz/index.php?option=com_content&view=article&id=612&Itemid=463&lang=fr
+ *   https://www.mf.gov.dz/index.php/fr/fiscalite
+ *   https://cnrcinfo.cnrc.dz/numero-didentification-fiscale-nif/
+ *   https://nifenligne.mfdgi.gov.dz/
+ *   http://nif.mfdgi.gov.dz/nif.asp
+ *
+ * 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 = /^[PCGQV]{1}00[A-Z0-9]{8}$/;
+
+// const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'Algeria tax number',
+  localName: "Numéro d'Identification Fiscale",
+  abbreviation: 'NIF',
+
+  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 !== 15 && value.length !== 20) {
+      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/ec/ci.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './ci';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ec/ci', () => {
+  it('format:1714307103', () => {
+    const result = format('1714307103');
+
+    expect(result).toEqual('171430710-3');
+  });
+
+  it('validate:171430710-3', () => {
+    const result = validate('171430710-3');
+
+    expect(result.isValid && result.compact).toEqual('1714307103');
+  });
+
+  it('validate:171430710', () => {
+    const result = validate('171430710');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1714307104', () => {
+    const result = validate('1714307104');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

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