stdnum 1.9.16 → 1.10.1

package/src/ro/cnp.ts

@@ -0,0 +1,158 @@
+/**
+ * CNP (Cod Numeric Personal, Romanian Numerical Personal Code).
+ *
+ * The CNP is a 13 digit number that includes information on the person's
+ * gender, birth date and country zone.
+ *
+ * Source:
+ * https://ro.wikipedia.org/wiki/Cod_numeric_personal
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDateCompactYYYYMMDD, strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const century: Record<string, string> = {
+  '0': '19', // shouldn't happen,
+  '1': '19',
+  '2': '19',
+  '3': '18',
+  '4': '18',
+  '5': '20',
+  '6': '20',
+  '7': '19',
+  '8': '19',
+  '9': '19',
+};
+
+// The Romanian counties
+const COUNTIES: Record<string, string> = {
+  '01': 'Alba',
+  '02': 'Arad',
+  '03': 'Arges',
+  '04': 'Bacau',
+  '05': 'Bihor',
+  '06': 'Bistrita-Nasaud',
+  '07': 'Botosani',
+  '08': 'Brasov',
+  '09': 'Braila',
+  '10': 'Buzau',
+  '11': 'Caras-Severin',
+  '12': 'Cluj',
+  '13': 'Constanta',
+  '14': 'Covasna',
+  '15': 'Dambovita',
+  '16': 'Dolj',
+  '17': 'Galati',
+  '18': 'Gorj',
+  '19': 'Harghita',
+  '20': 'Hunedoara',
+  '21': 'Ialomita',
+  '22': 'Iasi',
+  '23': 'Ilfov',
+  '24': 'Maramures',
+  '25': 'Mehedinti',
+  '26': 'Mures',
+  '27': 'Neamt',
+  '28': 'Olt',
+  '29': 'Prahova',
+  '30': 'Satu Mare',
+  '31': 'Salaj',
+  '32': 'Sibiu',
+  '33': 'Suceava',
+  '34': 'Teleorman',
+  '35': 'Timis',
+  '36': 'Tulcea',
+  '37': 'Vaslui',
+  '38': 'Valcea',
+  '39': 'Vrancea',
+  '40': 'Bucuresti',
+  '41': 'Bucuresti - Sector 1',
+  '42': 'Bucuresti - Sector 2',
+  '43': 'Bucuresti - Sector 3',
+  '44': 'Bucuresti - Sector 4',
+  '45': 'Bucuresti - Sector 5',
+  '46': 'Bucuresti - Sector 6',
+  '47': 'Bucuresti - Sector 7 (desfiintat)',
+  '48': 'Bucuresti - Sector 8 (desfiintat)',
+  '51': 'Calarasi',
+  '52': 'Giurgiu',
+};
+
+const VALID_COUNTIES = Object.keys(COUNTIES);
+
+const impl: Validator = {
+  name: 'Romanian Numerical Personal Code',
+  localName: 'Cod Numeric Personal',
+  abbreviation: 'CNP',
+  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) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value[0] === '0') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [first, dvalue, county] = strings.splitAt(value, 1, 7, 9);
+
+    if (!isValidDateCompactYYYYMMDD(`${century[first]}${dvalue}`, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!VALID_COUNTIES.includes(county)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+    const sum = weightedSum(front, {
+      weights: [2, 7, 9, 1, 4, 6, 3, 5, 8, 2, 7, 9],
+      modulus: 11,
+    });
+
+    const digit = sum === 10 ? '1' : String(sum);
+
+    if (check !== digit) {
+      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/ro/cui.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './cui';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ro/cui', () => {
+  it('format:18547290', () => {
+    const result = format('18547290');
+
+    expect(result).toEqual('185 472 90');
+  });
+
+  it('validate:185 472 90', () => {
+    const result = validate('185 472 90');
+
+    expect(result.isValid && result.compact).toEqual('18547290');
+  });
+
+  it('validate:123456789012', () => {
+    const result = validate('123456789012');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:185 472 91', () => {
+    const result = validate('185 472 91');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ro/cui.ts

@@ -0,0 +1,83 @@
+/**
+ * CUI or CIF (Codul Unic de Înregistrare, Romanian company identifier).
+ *
+ * The CUI (Codul Unic de Înregistrare) is assigned to companies that are
+ * required to register with the Romanian Trade Register. The CIF (Codul de
+ * identificare fiscală) is identical but assigned to entities that have no such
+ * requirement. The names seem to be used interchangeably and some sources
+ * suggest that CIF is the new name for CUI.
+ *
+ * This number can change under some conditions. The number can be prefixed with
+ * RO to indicate that the entity has been registered for VAT.
+ *
+ * Source:
+ *     https://ro.wikipedia.org/wiki/Cod_de_identificare_fiscală
+ *
+ * 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, ' -', 'RO');
+}
+
+const impl: Validator = {
+  name: 'Romanian Company Identifier',
+  localName: 'Codul Unic de Înregistrare',
+  abbreviation: 'CUI',
+  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 < 2 || value.length > 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value) || value[0] === '0') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value.padStart(9, '0'), -1);
+
+    const sum =
+      10 *
+      weightedSum(front, {
+        weights: [7, 5, 3, 2, 1, 7, 5, 3, 2],
+        modulus: 11,
+      });
+
+    if (String(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/ro/index.ts

@@ -0,0 +1,4 @@
+export * as cif from './cif';
+export * as cnp from './cnp';
+export * as cui from './cui';
+export * as onrc from './onrc';

package/src/ro/onrc.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './onrc';
+import { InvalidComponent } from '../exceptions';
+
+describe('ro/onrc', () => {
+  it('format:J52/750/2012', () => {
+    const result = format('J52/750/2012');
+
+    expect(result).toEqual('J52/750/2012');
+  });
+
+  it('validate:J52/750/2012', () => {
+    const result = validate('J52/750/2012');
+
+    expect(result.isValid && result.compact).toEqual('J52/750/2012');
+  });
+
+  it('validate:J52/750/03.07.2012', () => {
+    const result = validate('J52/750/03.07.2012');
+
+    expect(result.isValid && result.compact).toEqual('J52/750/2012');
+  });
+
+  it('validate:X52/750/2012', () => {
+    const result = validate('X52/750/2012');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/ro/onrc.ts

@@ -0,0 +1,109 @@
+/**
+ * NRC (Ordine din Registrul Comerţului, Romanian Trade Register identifier).
+ *
+ * All businesses in Romania have the to register with the National Trade
+ * Register Office to receive a registration number. The number contains
+ * information about the type of company, county, a sequence number and
+ * registration year. This number can change when registration information
+ * changes.
+ *
+ * Source
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const checkRe = /[A-Z]\d+\/\d{1,5}\/\d+/;
+
+function* genit() {
+  for (let i = 0; i <= 41; i += 1) {
+    yield i;
+  }
+
+  yield 51;
+  yield 52;
+}
+
+const counties = new Set(genit());
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, '');
+
+  if (err !== null) {
+    return [value, err];
+  }
+
+  const better = value
+    // Convert delimiters to '/'
+    .replace(/[ /\\-]+/g, '/')
+    // remove optional slash between first letter and county digits
+    .replace(/^([A-Z])\//, '$1')
+    // normalize country to 2 digits
+    .replace(/([A-Z])(\d)\//, '$10$2')
+    // clean full dates
+    .replace(/\/\d{2}[.]\d{2}[.](\d{4})$/, '/$1');
+
+  return [better, null];
+}
+
+const impl: Validator = {
+  name: 'Romanian Trade Register Identifier',
+  localName: 'Ordine din Registrul Comerţului',
+  abbreviation: 'NRC',
+  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 (!checkRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!'JFC'.includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [county, serial, year] = value.substr(1).split('/');
+
+    if (!counties.has(parseInt(county, 10))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (serial.length > 5) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (year.length !== 4) {
+      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/rs/index.ts

@@ -0,0 +1,2 @@
+export * as pib from './pib';
+export * as jmbg from './jmbg';

package/src/rs/jmbg.ts

@@ -0,0 +1,16 @@
+/**
+ * Serbian JMBG
+ * https://en.wikipedia.org/wiki/Unique_Master_Citizen_Number
+ */
+import { Validator } from '../types';
+import * as jmbg from '../ba/jmbg';
+
+const impl: Validator = {
+  ...jmbg,
+  name: 'Serbian Unique Master Citizen Number',
+  localName: 'Јединствени матични број грађана',
+  abbreviation: 'ЈМБГ',
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/rs/pib.spec.ts

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

package/src/rs/pib.ts

@@ -0,0 +1,69 @@
+/**
+ * PIB (Poreski Identifikacioni Broj, Serbian tax identification number).
+ *
+ * The Serbian tax identification number consists of 9 digits where the last
+ * digit is a check digit.
+ *
+ * Source
+ *    https://en.wikipedia.org/wiki/VAT_identification_number
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { mod11mod10Validate } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.', 'RS');
+}
+
+const impl: Validator = {
+  name: 'Serbian Tax Identification Number',
+  localName: 'Poreski Identifikacioni Broj',
+  abbreviation: 'PIB',
+  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() };
+    }
+
+    if (!mod11mod10Validate(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/ru/index.ts

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

package/src/ru/inn.spec.ts

@@ -0,0 +1,32 @@
+import { validate } from './inn';
+import { InvalidChecksum } from '../exceptions';
+
+describe('ru/inn', () => {
+  it('validate:123456789047', () => {
+    const result = validate('123456789047');
+
+    expect(result.isValid && result.compact).toEqual('123456789047');
+  });
+
+  it('validate:1234567894', () => {
+    const result = validate('1234567894');
+
+    expect(result.isValid && result.compact).toEqual('1234567894');
+  });
+
+  it('validate:366220664163', () => {
+    const result = validate('366220664163');
+
+    expect(result.isValid && result.compact).toEqual('366220664163');
+  });
+
+  it('validate:123456789037', () => {
+    const result = validate('123456789037');
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('format:1234567895', () => {
+    const result = validate('1234567895');
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ru/inn.ts

@@ -0,0 +1,106 @@
+/**
+ * ИНН (Идентификационный номер налогоплательщика, Russian tax identifier). (aka INN)
+ *
+ * The Indentifikatzionny nomer nalogoplatel'shchika is a Russian tax
+ * identification number that consists 10 digits for companies and 12 digits for
+ * persons.
+ *
+ * More information:
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/RussianFederation-TIN.pdf
+ *
+ * INN == VAT PERSON/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: 'Russian Tax Identifier',
+  localName: 'Идентификационный номер налогоплательщика',
+  abbreviation: 'ИНН',
+
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value.toLocaleUpperCase();
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  /**
+   * Check if the number is a valid INN 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 !== 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    let digit: string;
+    const [front, check] = strings.splitAt(
+      value,
+      value.length === 10 ? -1 : -2,
+    );
+
+    if (value.length === 10) {
+      digit = String(
+        weightedSum(front, {
+          weights: [2, 4, 10, 3, 5, 9, 4, 6, 8],
+          modulus: 11,
+        }) % 10,
+      );
+    } else {
+      const d1 = String(
+        weightedSum(front, {
+          weights: [7, 2, 4, 10, 3, 5, 9, 4, 6, 8],
+          modulus: 11,
+        }) % 10,
+      );
+      const d2 = String(
+        weightedSum(front + d1, {
+          weights: [3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8],
+          modulus: 11,
+        }) % 10,
+      );
+
+      digit = `${d1}${d2}`;
+    }
+
+    if (digit !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: value.length === 12,
+      isCompany: value.length === 10,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/se/index.ts

@@ -0,0 +1,3 @@
+export * as orgnr from './orgnr';
+export * as personnummer from './personnummer';
+export * as vat from './vat';