stdnum 1.10.0 → 1.10.1

package/src/kr/brn.ts

@@ -0,0 +1,91 @@
+/**
+ * BRN (사업자 등록 번호, South Korea Business Registration Number).
+ *
+ * The Business Registration Number is issued by the district tax office in the
+ * local jurisdiction for tax purposes. The number consists of 10 digits and
+ * contain the tax office number (3 digits), the type of business (2 digits), a
+ * serially assigned value (4 digits) and a single check digit.
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Korea-TIN.pdf
+ *
+ * ENTITY
+ */
+
+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: 'South Korean Business Registration Number',
+  localName: '사업자 등록 번호',
+  abbreviation: 'BRN',
+  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, 5).join('-');
+  },
+
+  /**
+   * BRN (사업자 등록 번호, South Korea Business Registration Number).
+   */
+  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() };
+    }
+
+    const [head, mid, end, check] = strings.splitAt(value, 3, 5, 9);
+
+    if (parseInt(head, 10) < 101) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (mid === '00') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (end === '0000') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = weightedSum(value.substr(0, 9), {
+      modulus: 10,
+      weights: [1, 3, 7, 1, 3, 7, 1, 3, 5],
+    });
+    const extra = Math.floor((parseInt(end[3], 10) * 5) / 10);
+    if (String((10 - ((sum + extra) % 10)) % 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/kr/index.ts

@@ -0,0 +1,2 @@
+export * as brn from './brn';
+export * as rrn from './rrn';

package/src/kr/rrn.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './rrn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('kr/rrn', () => {
+  it('format:9710139019902', () => {
+    const result = format('9710139019902');
+
+    expect(result).toEqual('971013-9019902');
+  });
+
+  it('validate:971013-9019902', () => {
+    const result = validate('971013-9019902');
+
+    expect(result.isValid && result.compact).toEqual('9710139019902');
+  });
+
+  it('validate:850126-6401473', () => {
+    const result = validate('8501266401473');
+
+    expect(result.isValid && result.compact).toEqual('8501266401473');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:971013-9019903', () => {
+    const result = validate('971013-9019903');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/kr/rrn.ts

@@ -0,0 +1,104 @@
+/**
+ * RRN (South Korean resident registration number).
+ *
+ * The RRN (resident registration number, 주민등록번호) is a 13-digit number
+ * issued to all residents of the Republic of Korea. Foreigners residing in the
+ * Republic of Korea receive an alien registration number (ARN) which follows
+ * the same encoding pattern.
+ *
+ * The first six digits code the date of birth. The seventh digit encodes the
+ * century and gender. The next four digits encode the place of birth for
+ * Koreans or the issuing agency for foreigners, followed by two digits for the
+ * community center number, one serial number and a check digit.
+ *
+ * Source:
+ *   http://www.law.go.kr/lsSc.do?tabMenuId=tab18&p1=&subMenu=1&nwYn=1&section=&tabNo=&query=개인정보+보호법
+ *   https://en.wikipedia.org/wiki/Resident_registration_number
+ *   https://techscience.org/a/2015092901/
+ *
+ * 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, ' -/');
+}
+
+const centuryPrefix: Record<string, number> = {
+  0: 18,
+  1: 19,
+  2: 19,
+  3: 20,
+  4: 20,
+  5: 19,
+  6: 19,
+  7: 20,
+  8: 20,
+  9: 18,
+};
+
+const impl: Validator = {
+  name: 'South Korean Resident Registration Number',
+  localName: '주민등록번호',
+  abbreviation: 'RRN',
+  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, 6).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 [dob, century, place, , check] = strings.splitAt(value, 6, 7, 9, 12);
+
+    if (!isValidDateCompactYYYYMMDD(`${centuryPrefix[century]}${dob}`, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (parseInt(place, 10) > 96) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = weightedSum(value.substr(0, 12), {
+      modulus: 11,
+      weights: [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5],
+    });
+    if (String((11 - sum) % 10) !== 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/li/index.ts

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

package/src/li/peid.spec.ts

@@ -0,0 +1,22 @@
+import { validate, format } from './peid';
+import { InvalidLength } from '../exceptions';
+
+describe('li/peid', () => {
+  it('format:1234567', () => {
+    const result = format('1234567');
+
+    expect(result).toEqual('1234567');
+  });
+
+  it('validate:00001234567', () => {
+    const result = validate('00001234567');
+
+    expect(result.isValid && result.compact).toEqual('1234567');
+  });
+
+  it('validate:00001234568913454545', () => {
+    const result = validate('00001234568913454545');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/li/peid.ts

@@ -0,0 +1,71 @@
+/**
+ * PEID (Liechtenstein tax code for individuals and entities).
+ *
+ * The Personenidentifikationsnummer (PEID) is an numeric code up to 12 digits
+ * used to identify entities and individuals residing in Liechtenstein.
+ *
+ * Source:
+ *    https://www.oera.li/
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/LIECHTENSTEIN%20TIN.pdf
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, error] = strings.cleanUnicode(input, ' .');
+
+  if (error) {
+    return [value, error];
+  }
+
+  return [value.replace(/^0+/, ''), null];
+}
+
+const impl: Validator = {
+  name: 'Liechtenstein Tax Code',
+  localName: 'Personenidentifikationsnummer',
+  abbreviation: 'PEID',
+  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 < 4 || value.length > 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/lt/asmens.spec.ts

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

package/src/lt/asmens.ts

@@ -0,0 +1,73 @@
+/**
+ * Asmens kodas (Lithuanian, personal numbers).
+ *
+ * The Asmens kodas consists of 11 digits. The first digits denotes the gender
+ * and birth century, the second through seventh denotes the birth date,
+ * followed by a three-digit serial and a check digit.
+ *
+ * Source:
+ *   https://lt.wikipedia.org/wiki/Asmens_kodas
+ *   https://en.wikipedia.org/wiki/National_identification_number#Lithuania
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { ikCheck, ikCheckDate } from '../ee/ik';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -/');
+}
+
+const impl: Validator = {
+  name: 'Lithuanian Personal Code',
+  localName: 'Asmens Kodas',
+  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 (value[0] !== '9' && !ikCheckDate(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    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/lt/index.ts

@@ -0,0 +1,2 @@
+export * as asmens from './asmens';
+export * as pvm from './pvm';

package/src/lt/pvm.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './pvm';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('lt/pvm', () => {
+  it('format:119511515', () => {
+    const result = format('119511515');
+
+    expect(result).toEqual('119511515');
+  });
+
+  it('validate:119511515', () => {
+    const result = validate('119511515');
+
+    expect(result.isValid && result.compact).toEqual('119511515');
+  });
+
+  it('validate:LT 100001919017', () => {
+    const result = validate('LT 100001919017');
+
+    expect(result.isValid && result.compact).toEqual('100001919017');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:100001919018', () => {
+    const result = validate('100001919018');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/lt/pvm.ts

@@ -0,0 +1,75 @@
+/**
+ * PVM (Pridėtinės vertės mokestis mokėtojo kodas, Lithuanian VAT number).
+ *
+ * The PVM is used for VAT purposes in Lithuania. It is 9 digits (for legal
+ * entities) or 12 digits long (for temporarily registered taxpayers). This
+ * module does not check the format of Lithuanian personal codes (Asmens
+ * kodas).
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { ikCheck } from '../ee/ik';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -', 'LT');
+}
+
+const impl: Validator = {
+  name: 'Lithuanian VAT Number',
+  localName: 'Pridėtinės Vertės Mokestis Mokėtojo Kodas',
+  abbreviation: 'PVM Kodas',
+  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 && value.length !== 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length === 9 && value[7] !== '1') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (value.length === 12 && value[10] !== '1') {
+      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/lu/index.ts

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

package/src/lu/tva.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './tva';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('lu/tva', () => {
+  it('format:LU 150 274 42', () => {
+    const result = format('15027442');
+
+    expect(result).toEqual('150 274 42');
+  });
+
+  it('validate:LU 150 274 42', () => {
+    const result = validate('LU 150 274 42');
+
+    expect(result.isValid && result.compact).toEqual('15027442');
+  });
+
+  it('validate:123456789', () => {
+    const result = validate('123456789');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:LU 150 274 43', () => {
+    const result = validate('LU 150 274 43');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/lu/tva.ts

@@ -0,0 +1,70 @@
+/**
+ * TVA (taxe sur la valeur ajoutée, Luxembourgian VAT number).
+ *
+ * The n° TVA (Numéro d'identification à la taxe sur la valeur ajoutée) is
+ * used for tax purposes in Luxembourg. The number consists of 8 digits of
+ * which the last two are check digits.
+ *
+ * Source
+ *
+ * ENTITY
+ */
+
+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, ' :-.', 'LU');
+}
+
+const impl: Validator = {
+  name: 'Luxembourgian VAT Number',
+  localName: "Numéro d'Identification à la Taxe sur la Valeur Ajoutée",
+  abbreviation: 'n° TVA',
+  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 !== 8) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -2);
+
+    if (parseInt(front, 10) % 89 !== parseInt(check, 10)) {
+      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/lv/index.ts

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