stdnum 1.9.16 → 1.10.1

package/src/tw/ui.ts

@@ -0,0 +1,107 @@
+/**
+ * UI Number
+ *
+ * The UI Number is shown on the “R.O.C. (Taiwan) Resident Certificate,” “Exit &
+ * Entry Permit Taiwan Republic of China,” or the “R.O.C. (Taiwan) UI No. Basic
+ * Information Form.”
+ *
+ * The UI Number issued by January 1, 2021 was a ten-digit code with
+ * two alphabetic letters followed by an eight-digit numeric string.
+ * The first alphabetic letter is the area code of the
+ * municipality/county/city by which the UI Number was issued. The
+ * second alphabetic letter represents gender: “A” or “C” for males,
+ * and “B” or “D” for females. The last number is a check digit. This
+ * kind of UI Number will be invalidated from January 1, 2031. The UI
+ * Number issued from January 2, 2021 is a ten-digit code with the
+ * first an alphabetic letter followed by a nine-digit numeric string.
+ * The alphabetic letter is the area code of the municipality/county/city
+ * by which the UI Number was issued. The leading number represents
+ * gender: “8” for males and “9” for females. The last number is a
+ * check digit.
+ *
+ * Sources:
+ *   https://www.mof.gov.tw/Eng/download/16968
+ *   https://en.wikipedia.org/wiki/National_identification_card_(Taiwan)
+ *
+ * PERSON
+ */
+
+import { ValidateReturn } from '../types';
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { ALPHABET } from './natid';
+
+function clean(input: string) {
+  return strings.cleanUnicode(input, ' -');
+}
+
+// const OLD_FMT = /^[A-Z][ABCD]\d{8}$/;
+// const NEW_FMT = /^[A-Z][89]\d{8}$/;
+
+const impl = {
+  name: 'UI Number',
+  localName: '中華民國國民身分證',
+  abbreviation: 'UI',
+
+  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 !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    const [issuer, gender, code, check] = strings.splitAt(value, 1, 2, 9);
+
+    if (!strings.isalpha(issuer)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!['A', 'B', 'C', 'D', '8', '9'].includes(gender)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(code)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(check)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = weightedSum(value, {
+      weights: [1, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+      alphabet: ALPHABET,
+      modulus: 10,
+    });
+    if (sum % 10 !== 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;
+export default impl;

package/src/types.ts

@@ -0,0 +1,82 @@
+import { ValidationError } from './exceptions';
+
+interface ValidateSuccess {
+  /**
+   * ID Is Valid
+   */
+  isValid: true;
+
+  /**
+   * Compact version of the ID
+   */
+  compact: string;
+
+  /**
+   * This ID identifies an individual
+   *
+   * Note: An ID may not positivily identify an individual or entity
+   */
+  isIndividual: boolean;
+
+  /**
+   * This ID identifies an entity
+   *
+   * Note: An ID may not positivily identify an individual or entity
+   */
+  isCompany: boolean;
+}
+
+interface ValidateFail {
+  /**
+   * TIN is not valid
+   */
+  isValid: false;
+
+  /**
+   * The validation error
+   */
+  error: ValidationError;
+}
+
+export type ValidateReturn = { error?: ValidationError } & (
+  | ValidateSuccess
+  | ValidateFail
+);
+
+export interface Validator {
+  /**
+   * The type of validation: ID, tin, vat, bank,
+   */
+
+  /**
+   * The validator name, or ID's expansion name in English
+   */
+  name: string;
+
+  /**
+   * The validator name, or ID's expansion name its local name
+   */
+  localName: string;
+
+  /**
+   * The short/acronym or abbreviation of the validator
+   */
+  abbreviation?: string;
+
+  /**
+   * Convert the number to the minimal representation.
+   * This strips the number of any valid separators and removes surrounding
+   * whitespace.
+   */
+  compact(value: string): string;
+
+  /**
+   * Reformat the number to the standard presentation format.
+   */
+  format(value: string): string;
+
+  /**
+   * Validate with error throws subclass of ValidationError
+   */
+  validate(value: string): ValidateReturn;
+}

package/src/ua/edrpou.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './edrpou';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ua/edrpou', () => {
+  it('format:32855961', () => {
+    const result = format('32855961');
+
+    expect(result).toEqual('32855961');
+  });
+
+  it('validate:32855961', () => {
+    const result = validate('32855961');
+
+    expect(result.isValid && result.compact).toEqual('32855961');
+  });
+
+  it('validate:12345', () => {
+    const result = validate('12345');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:32855968', () => {
+    const result = validate('32855968');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ua/edrpou.ts

@@ -0,0 +1,88 @@
+/**
+ * ЄДРПОУ, EDRPOU (Identifier for enterprises and organizations in Ukraine).
+ *
+ * The ЄДРПОУ (Єдиного державного реєстру підприємств та організацій України,
+ * Unified State Register of Enterprises and Organizations of Ukraine) is a
+ * unique identification number of a legal entities in Ukraine. Th number
+ * consists of 8 digits, the last being a check digit.
+ *
+ * Source:
+ *   https://uk.wikipedia.org/wiki/Код_ЄДРПОУ
+ *   https://1cinfo.com.ua/Articles/Proverka_koda_po_EDRPOU.aspx
+ *
+ * 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: 'Ukrainian Unified State Register of Enterprises and Organizations',
+  localName: 'Єдиного державного реєстру підприємств та організацій України',
+  abbreviation: 'ЄДРПОУ',
+  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() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const weights = '345'.includes(front[0])
+      ? [7, 1, 2, 3, 4, 5, 6]
+      : [1, 2, 3, 4, 5, 6, 7];
+
+    let sum = weightedSum(front, {
+      weights,
+      modulus: 11,
+    });
+
+    if (sum === 10) {
+      sum = weightedSum(front, {
+        weights: weights.map(v => v + 2),
+        modulus: 11,
+      });
+    }
+    if (String(sum) !== 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/ua/index.ts

@@ -0,0 +1,2 @@
+export * as edrpou from './edrpou';
+export * as rntrc from './rntrc';

package/src/ua/rntrc.spec.ts

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

package/src/ua/rntrc.ts

@@ -0,0 +1,77 @@
+/**
+ * РНОКПП, RNTRC (Individual taxpayer registration number in Ukraine).
+ *
+ * The РНОКПП (Реєстраційний номер облікової картки платника податків,
+ * registration number of the taxpayer's registration card) is a unique
+ * identification number that is provided to individuals within Ukraine. The
+ * number consists of 10 digits, the last being a check digit.
+ *
+ * More information:
+ *    https://uk.wikipedia.org/wiki/РНОКПП
+ *
+ * PERSON
+ */
+
+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: "Ukrainian Registration Number of the Taxpayer's Registration Card",
+  localName: 'Реєстраційний номер облікової картки платника податків',
+  abbreviation: 'РНОКПП',
+  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 !== 10) {
+      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, {
+      weights: [-1, 5, 7, 9, 4, 6, 10, 5, 7],
+      modulus: 11,
+    });
+
+    if (String(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/us/ein.spec.ts

@@ -0,0 +1,28 @@
+import { InvalidComponent, InvalidLength } from '../exceptions';
+import { validate, format } from './ein';
+
+describe('us/tin', () => {
+  it('format:536904399', () => {
+    const result = format('536904399');
+
+    expect(result).toEqual('53-6904399');
+  });
+
+  it('validate:123-45-6789', () => {
+    const result = validate('123-45-6789');
+
+    expect(result.isValid && result.compact).toEqual('123456789');
+  });
+
+  it('validate:1234567890123', () => {
+    const result = validate('1234567890123');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:00-3456789', () => {
+    const result = validate('00-3456789');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/us/ein.ts

@@ -0,0 +1,179 @@
+/**
+ * EIN (U.S. Employer Identification Number).
+ *
+ * The Employer Identification Number, also known as Federal Employer
+ * Identification Number (FEIN), is used to identify a business entity in the
+ * United States. It is issued to anyone that has to pay withholding taxes on
+ * employees.
+ *
+ * Sources:
+ *    https://en.wikipedia.org/wiki/Social_Security_number
+ *    https://www.ssa.gov/employer/verifySSN.htm
+ *
+ * INDIVIDUAL
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+// https://www.irs.gov/businesses/small-businesses-self-employed/how-eins-are-assigned-and-valid-ein-prefixes
+
+const prefixes = [
+  // Brookhaven
+  '01',
+  '02',
+  '03',
+  '04',
+  '05',
+  '06',
+  '11',
+  '13',
+  '14',
+  '16',
+  '21',
+  '22',
+  '23',
+  '25',
+  '34',
+  '51',
+  '52',
+  '54',
+  '55',
+  '56',
+  '57',
+  '58',
+  '59',
+  '65',
+  // Andover
+  '10',
+  '12',
+  // Fresno"
+  '15',
+  '24',
+  // Internet
+  '20',
+  '26',
+  '27',
+  '45',
+  '46',
+  '47',
+  '81',
+  '82',
+  '83',
+  '84',
+  // Cincinnati
+  '30',
+  '32',
+  '35',
+  '36',
+  '37',
+  '38',
+  '61',
+  // Small Business Administration (SBA)
+  '31',
+  // Philadelphia
+  '33',
+  '39',
+  '41',
+  '42',
+  '43',
+  '46',
+  '48',
+  '62',
+  '63',
+  '64',
+  '66',
+  '68',
+  '71',
+  '72',
+  '73',
+  '74',
+  '75',
+  '76',
+  '77',
+  '85',
+  '86',
+  '87',
+  '88',
+  '91',
+  '92',
+  '93',
+  '98',
+  '99',
+  // Kansas City
+  '40',
+  '44',
+  // Austin
+  '50',
+  '53',
+  // Atlanta
+  '60',
+  '67',
+  // Ogden
+  '80',
+  '90',
+  // Memphis
+  '94',
+  '95',
+];
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, '- ');
+}
+
+const impl: Validator = {
+  name: 'U.S. Employer Identification Number',
+  localName: 'Employer Identification Number',
+  abbreviation: 'EIN',
+  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, 2).join('-');
+  },
+
+  /**
+   * Check if the number is a valid EIN 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 !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    // if (invalidSSN.includes(value)) {
+    //   return { isValid: false, error: new exceptions.InvalidComponent() };
+    // }
+    if (!prefixes.includes(value.substr(0, 2))) {
+      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/us/index.ts

@@ -0,0 +1,2 @@
+export * as ein from './ein';
+export * as ssn from './ssn';

package/src/us/ssn.spec.ts

@@ -0,0 +1,28 @@
+import { InvalidComponent, InvalidLength } from '../exceptions';
+import { validate, format } from './ssn';
+
+describe('us/ssn', () => {
+  it('format:536904399', () => {
+    const result = format('536904399');
+
+    expect(result).toEqual('536-90-4399');
+  });
+
+  it('validate:536-90-4399', () => {
+    const result = validate('536-90-4399');
+
+    expect(result.isValid && result.compact).toEqual('536904399');
+  });
+
+  it('validate:1234567890123', () => {
+    const result = validate('1234567890123');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:189092294', () => {
+    const result = validate('189092294');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});