@myazahq/kyc-sdk-react-native 2.0.2 → 2.1.0

package/src/config/business.ts

@@ -0,0 +1,179 @@
+// ---------------------------------------------------------------------------
+// Business (KYB) product catalogue + flow helpers.
+//
+// Mirrors the server's `business-products.ts` for DISPLAY only — labels and
+// input hints. The server stays the source of truth: an unknown or unoffered
+// product is rejected at POST /verify with `product_unsupported`, so nothing
+// here needs to be authoritative, only honest about what to type.
+// ---------------------------------------------------------------------------
+
+import type {
+  CompanyInfoField,
+  CompanyInfoMode,
+  KeyPersonRole,
+  SubjectType,
+  WorkflowBusinessConfig,
+} from '../types/business';
+import { regionCountryName } from './regions';
+
+export interface BusinessProductDef {
+  key: string;
+  label: string;
+  /** What the user types — drives the input label/placeholder. */
+  inputLabel: string;
+  placeholder: string;
+  /** Countries offering this product; absent = every supported country. */
+  countries?: string[];
+}
+
+export const DEFAULT_BUSINESS_PRODUCT = 'business';
+
+export const BUSINESS_PRODUCTS: readonly BusinessProductDef[] = [
+  {
+    key: 'business',
+    label: 'Business verification',
+    inputLabel: 'Registration number',
+    placeholder: 'e.g. RC0000000',
+  },
+  {
+    key: 'business-tax',
+    label: 'Business + Tax ID',
+    inputLabel: 'Registration number',
+    placeholder: 'e.g. RC0000000',
+    countries: ['NG'],
+  },
+  {
+    key: 'business-taxid',
+    label: 'Tax ID',
+    inputLabel: 'Registration number',
+    placeholder: 'e.g. RC0000000',
+    countries: ['NG'],
+  },
+  {
+    // A TIN is NOT the Tax ID product — different number, different endpoint.
+    key: 'business-tin',
+    label: 'TIN',
+    inputLabel: 'TIN',
+    placeholder: 'e.g. 01234567-0001',
+    countries: ['NG'],
+  },
+];
+
+/** Display definition for a product key (unknown keys get a generic fallback). */
+export function getBusinessProductDef(key: string): BusinessProductDef {
+  return (
+    BUSINESS_PRODUCTS.find((p) => p.key === key) ?? {
+      key,
+      label: key,
+      inputLabel: 'Registration number',
+      placeholder: 'Enter your registration number',
+    }
+  );
+}
+
+/** The product keys a business workflow offers (the default when unset). */
+export function businessProductsFor(business: WorkflowBusinessConfig | undefined): string[] {
+  const products = business?.products;
+  return products && products.length > 0 ? products : [DEFAULT_BUSINESS_PRODUCT];
+}
+
+/**
+ * The products offered for ONE picked country — the configured list narrowed by
+ * each product's availability, with the global default as the backstop.
+ *
+ * The narrowing matters: TIN is Nigeria-only, so offering it after the visitor
+ * picks Ghana produces a submission the server refuses.
+ */
+export function businessProductsForCountry(
+  business: WorkflowBusinessConfig | undefined,
+  country: string,
+): string[] {
+  const offered = businessProductsFor(business).filter((key) => {
+    const def = BUSINESS_PRODUCTS.find((p) => p.key === key);
+    return !def?.countries || def.countries.includes(country);
+  });
+  return offered.length > 0 ? offered : [DEFAULT_BUSINESS_PRODUCT];
+}
+
+/** Registry countries the visitor may pick (primary always included, first). */
+export function businessCountriesFor(business: WorkflowBusinessConfig | undefined): string[] {
+  if (!business) return [];
+  if (business.countries && business.countries.length > 0) {
+    return business.countries.includes(business.country)
+      ? business.countries
+      : [business.country, ...business.countries];
+  }
+  return [business.country];
+}
+
+/** English country name for an ISO-2 code (falls back to the code itself). */
+export const businessCountryName = regionCountryName;
+
+/**
+ * Whether the resolved config runs the business (KYB) flow.
+ *
+ * Both halves are required: `subjectType` alone would send a submission with no
+ * registry country, which the server rejects. Single source of truth for the
+ * gate — the step order, consent routing and submission all read it.
+ */
+export function isBusinessFlow(config: {
+  subjectType?: SubjectType;
+  business?: WorkflowBusinessConfig;
+}): boolean {
+  return config.subjectType === 'business' && !!config.business;
+}
+
+/** All key-person roles — the in-scope set when `keyPeople.roles` is unset. */
+const KEY_PERSON_ROLES: KeyPersonRole[] = [
+  'director',
+  'beneficial_owner',
+  'signatory',
+  'shareholder',
+];
+
+/**
+ * Whether the business-details step should collect a contact email.
+ *
+ * Only when invites actually go out by email AND at least one in-scope role
+ * needs full KYC — asking for an address the flow will never write to is a
+ * field the user fills in for nothing.
+ */
+export function keyPeopleNeedsContactEmail(business: WorkflowBusinessConfig | undefined): boolean {
+  const keyPeople = business?.keyPeople;
+  if (!keyPeople?.enabled || keyPeople.invite?.channel !== 'email') return false;
+  const roles = keyPeople.roles && keyPeople.roles.length > 0 ? keyPeople.roles : KEY_PERSON_ROLES;
+  return roles.some(
+    (role) => (keyPeople.perRole?.[role] ?? keyPeople.level ?? 'screening_only') === 'full_kyc',
+  );
+}
+
+/**
+ * Effective per-field company-profile mode.
+ *
+ * `collectCompanyInfo: false` turns the whole section off; an unlisted field is
+ * 'optional'. Mirrors the server's resolution exactly — a mismatch here means
+ * either a field the user cannot fill or a 422 they cannot act on.
+ */
+export function companyInfoFieldModes(
+  business: WorkflowBusinessConfig | undefined,
+): Record<CompanyInfoField, CompanyInfoMode> {
+  const off = business?.collectCompanyInfo === false;
+  const modes = business?.companyInfo ?? {};
+  return {
+    address: off ? 'off' : (modes.address ?? 'optional'),
+    email: off ? 'off' : (modes.email ?? 'optional'),
+    phone: off ? 'off' : (modes.phone ?? 'optional'),
+    website: off ? 'off' : (modes.website ?? 'optional'),
+  };
+}
+
+/** Company-profile fields still missing that the workflow marks required. */
+export function missingRequiredCompanyInfo(
+  business: WorkflowBusinessConfig | undefined,
+  values: Partial<Record<CompanyInfoField, string>>,
+): CompanyInfoField[] {
+  const modes = companyInfoFieldModes(business);
+  return (Object.keys(modes) as CompanyInfoField[]).filter(
+    (field) => modes[field] === 'required' && (values[field] ?? '').trim() === '',
+  );
+}

package/src/config/businessSteps.ts

@@ -0,0 +1,105 @@
+// ---------------------------------------------------------------------------
+// Business (KYB) APPLICATION step gates.
+//
+// Which steps a KYB workflow adds beyond the registration details: key-people
+// collection, supporting documents, and applicant identity verification. Single
+// source of truth for what is in the flow and in what order — the step order,
+// the progress bar, and each step's navigation all read these.
+//
+// Mirrors the web SDK's `lib/business-application.ts` (the sequencing half; the
+// row-validation/payload half lands with the KYB step itself).
+// ---------------------------------------------------------------------------
+
+import type { BusinessDocumentKey, WorkflowBusinessConfig } from '../types/business';
+import type { KYCStep } from '../types/config';
+
+/** Default display labels per document key (server contract). */
+export const BUSINESS_DOCUMENT_LABELS: Record<BusinessDocumentKey, string> = {
+  incorporation_certificate: 'Certificate of incorporation',
+  memart: 'MEMART / articles of association',
+  proof_of_address: 'Proof of business address',
+  tax_document: 'Tax document',
+  regulatory_license: 'Regulatory license',
+  board_resolution: 'Board resolution',
+  other: 'Other document',
+};
+
+/** Whether the flow collects key people from the applicant. */
+export function hasKeyPeopleCollection(business: WorkflowBusinessConfig | undefined): boolean {
+  return business?.keyPeople?.enabled === true && business.keyPeople.collect === true;
+}
+
+/** Whether the flow collects supporting business documents. */
+export function hasBusinessDocumentsStep(business: WorkflowBusinessConfig | undefined): boolean {
+  return business?.documents?.enabled === true;
+}
+
+/** Whether the applicant verifies their own identity in-flow. */
+export function hasApplicantVerification(business: WorkflowBusinessConfig | undefined): boolean {
+  return business?.applicant?.verification === true;
+}
+
+export interface ResolvedBusinessDocumentType {
+  key: BusinessDocumentKey;
+  label: string;
+  required: boolean;
+}
+
+/**
+ * The document slots the flow renders. Enabled with absent/empty `types`
+ * defaults to just a required incorporation certificate (server contract).
+ */
+export function resolveBusinessDocumentTypes(
+  business: WorkflowBusinessConfig | undefined,
+): ResolvedBusinessDocumentType[] {
+  if (!hasBusinessDocumentsStep(business)) return [];
+  const types = business?.documents?.types;
+  if (!types || types.length === 0) {
+    return [
+      {
+        key: 'incorporation_certificate',
+        label: BUSINESS_DOCUMENT_LABELS.incorporation_certificate,
+        required: true,
+      },
+    ];
+  }
+  return types.map((t) => ({
+    key: t.key,
+    label: t.label ?? BUSINESS_DOCUMENT_LABELS[t.key] ?? t.key,
+    required: t.required === true,
+  }));
+}
+
+/** Minimum applicant-listed people the workflow demands (0 = skippable). */
+export function keyPeopleMinEntries(business: WorkflowBusinessConfig | undefined): number {
+  const kp = business?.keyPeople;
+  if (!kp?.enabled || !kp.collect) return 0;
+  return kp.minEntries ?? 0;
+}
+
+export type BusinessSectionStep =
+  | 'business-details'
+  | 'business-key-people'
+  | 'business-documents'
+  | 'applicant-role';
+
+/** The ordered business-application steps this workflow configures. */
+export function businessSectionSteps(
+  business: WorkflowBusinessConfig | undefined,
+): BusinessSectionStep[] {
+  const steps: BusinessSectionStep[] = ['business-details'];
+  if (hasKeyPeopleCollection(business)) steps.push('business-key-people');
+  if (hasBusinessDocumentsStep(business)) steps.push('business-documents');
+  if (hasApplicantVerification(business)) steps.push('applicant-role');
+  return steps;
+}
+
+/** Type guard so the step order can be walked without casting. */
+export function isBusinessSectionStep(step: KYCStep): step is BusinessSectionStep {
+  return (
+    step === 'business-details' ||
+    step === 'business-key-people' ||
+    step === 'business-documents' ||
+    step === 'applicant-role'
+  );
+}

package/src/config/contact.ts

@@ -0,0 +1,159 @@
+// ---------------------------------------------------------------------------
+// Contact verification (email / phone OTP) — the pure half.
+//
+// Possession checks that sit right after consent, before any capture or
+// registry spend. A passing check yields a single-use proof token that rides
+// the /verify submission; the server is what actually enforces it, so
+// everything here is about not wasting the user's time on a round trip that
+// will obviously fail.
+// ---------------------------------------------------------------------------
+
+import type { EmailVerificationConfig, PhoneVerificationConfig } from '../types/workflow';
+
+/**
+ * What a contact step is currently doing, published to the store so the SHEET
+ * HEADER can describe it — the header is rendered by the shell, which cannot
+ * see the step's local state.
+ *
+ * `channel` is what makes it safe to leave behind: a header only trusts state
+ * raised by the step it is titling, so a leftover email entry can never caption
+ * the phone step.
+ */
+export interface ContactChallenge {
+  channel: 'email' | 'phone';
+  /** Delivery channel the code will go out on, or went out on (phone only). */
+  via?: 'sms' | 'whatsapp';
+  /**
+   * Set once a code is actually out. Its presence is what turns the header from
+   * a promise ("we'll send a code") into an instruction ("enter the code we
+   * sent to …").
+   */
+  destination?: string;
+}
+
+/** Server-clamped bounds; mirrored so the UI renders the right number of slots. */
+export const MIN_CODE_LENGTH = 4;
+export const MAX_CODE_LENGTH = 8;
+export const DEFAULT_CODE_LENGTH = 6;
+
+export function hasEmailVerificationStep(cfg: EmailVerificationConfig | undefined | null): boolean {
+  return cfg?.enabled === true;
+}
+
+export function hasPhoneVerificationStep(cfg: PhoneVerificationConfig | undefined | null): boolean {
+  return cfg?.enabled === true;
+}
+
+/**
+ * Whether the user may skip this check.
+ *
+ * Required defaults TRUE when the step is enabled: a workflow that adds an OTP
+ * step and says nothing about `required` meant to require it. Only an explicit
+ * `required: false` offers the skip.
+ */
+export function contactIsRequired(
+  cfg: EmailVerificationConfig | PhoneVerificationConfig | undefined,
+): boolean {
+  return cfg?.required !== false;
+}
+
+/** Code length, clamped to what the server will accept. */
+export function contactCodeLength(
+  cfg: EmailVerificationConfig | PhoneVerificationConfig | undefined,
+): number {
+  const raw = cfg?.codeLength ?? DEFAULT_CODE_LENGTH;
+  return Math.min(MAX_CODE_LENGTH, Math.max(MIN_CODE_LENGTH, Math.round(raw)));
+}
+
+/**
+ * Header title/description for a contact step, read by stepHeaderMeta.
+ *
+ * Wording matches the web SDK exactly, including the way the description turns
+ * from a promise ("we'll send a code…") into an instruction ("enter the code we
+ * sent to…") once a code is out. The shell renders the header, so the step
+ * publishes its outstanding challenge to the store for this to read.
+ *
+ * A challenge raised for the OTHER channel is ignored: both steps are the same
+ * component, and a leftover email challenge must never caption the phone step.
+ */
+export function contactMeta(
+  channel: 'email' | 'phone',
+  ctx?: { codeLength?: number; challenge?: ContactChallenge | null },
+): { title: string; description: string } {
+  const isEmail = channel === 'email';
+  const title = isEmail ? 'Verify your email' : 'Verify your phone number';
+  const live = ctx?.challenge?.channel === channel ? ctx.challenge : null;
+  const by = !isEmail && live?.via ? ` by ${CHANNEL_LABELS[live.via]}` : '';
+
+  if (live?.destination) {
+    const length = ctx?.codeLength ?? DEFAULT_CODE_LENGTH;
+    return {
+      title,
+      description: `Enter the ${length}-digit code we sent to ${live.destination}${by}.`,
+    };
+  }
+
+  return {
+    title,
+    description: isEmail
+      ? "We'll send a one-time code to confirm this email belongs to you."
+      : `We'll send a one-time code${by} to confirm this number belongs to you.`,
+  };
+}
+
+export type PhoneOtpChannel = 'sms' | 'whatsapp';
+
+const KNOWN_CHANNELS: PhoneOtpChannel[] = ['sms', 'whatsapp'];
+
+export const CHANNEL_LABELS: Record<PhoneOtpChannel, string> = {
+  sms: 'SMS',
+  whatsapp: 'WhatsApp',
+};
+
+/**
+ * The delivery channels a phone step offers, normalised.
+ *
+ * Never empty: an unset, empty or entirely-unrecognised list falls back to SMS,
+ * which is what the server defaults to when `via` is omitted. Unknown values are
+ * dropped so a channel added server-side cannot render as an unlabelled option
+ * in an older build. Order is the workflow's, so its first entry is the default.
+ */
+export function offeredPhoneChannels(channels?: string[] | null): PhoneOtpChannel[] {
+  const known = (channels ?? []).filter((c): c is PhoneOtpChannel =>
+    KNOWN_CHANNELS.includes(c as PhoneOtpChannel),
+  );
+  const deduped = Array.from(new Set(known));
+  return deduped.length > 0 ? deduped : ['sms'];
+}
+
+/**
+ * Email shape check.
+ *
+ * Deliberately permissive — the real proof of an address is that a code sent to
+ * it arrives, and a strict pattern rejects valid addresses (new TLDs, plus
+ * addressing, unicode local parts) far more often than it catches a typo.
+ */
+export function isValidContactEmail(value: string): boolean {
+  const trimmed = value.trim();
+  if (trimmed.length < 5 || trimmed.length > 254) return false;
+  if (/\s/.test(trimmed)) return false;
+  const at = trimmed.indexOf('@');
+  if (at <= 0 || at !== trimmed.lastIndexOf('@')) return false;
+  const domain = trimmed.slice(at + 1);
+  return domain.includes('.') && !domain.startsWith('.') && !domain.endsWith('.');
+}
+
+/**
+ * Phone shape check against E.164: a leading `+`, then 8–15 digits.
+ *
+ * Only the format is checked here. Whether the number is reachable is the OTP's
+ * job, and whether the country is plausible is the server's.
+ */
+export function isValidContactPhone(value: string): boolean {
+  return /^\+[1-9]\d{7,14}$/.test(value.replace(/[\s()-]/g, ''));
+}
+
+/** Strips formatting so the submitted number is E.164. */
+export function normalizeContactPhone(value: string): string {
+  return value.replace(/[\s()-]/g, '');
+}

package/src/config/countryNames.g.ts

@@ -0,0 +1,254 @@
+// GENERATED — do not edit by hand.
+//
+// ISO-3166 alpha-2 country names, generated FROM the Flutter SDK's
+// country_names.g.dart so both SDKs label a country identically by
+// construction rather than by two runtimes happening to agree.
+//
+// This exists because `Intl.DisplayNames` is not dependable here: Hermes may
+// ship without the region data, and when it does every row in the picker reads
+// as a bare ISO code ("NG" instead of "Nigeria"). A table is a few KB and it
+// always works.
+
+export const COUNTRY_NAMES: Record<string, string> = {
+  DZ: 'Algeria',
+  AO: 'Angola',
+  BJ: 'Benin',
+  BW: 'Botswana',
+  BF: 'Burkina Faso',
+  BI: 'Burundi',
+  CV: 'Cape Verde',
+  CM: 'Cameroon',
+  CF: 'Central African Republic',
+  TD: 'Chad',
+  KM: 'Comoros',
+  CG: 'Congo - Brazzaville',
+  CD: 'Congo - Kinshasa',
+  CI: 'Côte d’Ivoire',
+  DJ: 'Djibouti',
+  EG: 'Egypt',
+  GQ: 'Equatorial Guinea',
+  ER: 'Eritrea',
+  SZ: 'Eswatini',
+  ET: 'Ethiopia',
+  GA: 'Gabon',
+  GM: 'Gambia',
+  GH: 'Ghana',
+  GN: 'Guinea',
+  GW: 'Guinea-Bissau',
+  KE: 'Kenya',
+  LS: 'Lesotho',
+  LR: 'Liberia',
+  LY: 'Libya',
+  MG: 'Madagascar',
+  MW: 'Malawi',
+  ML: 'Mali',
+  MR: 'Mauritania',
+  MU: 'Mauritius',
+  YT: 'Mayotte',
+  MA: 'Morocco',
+  MZ: 'Mozambique',
+  NA: 'Namibia',
+  NE: 'Niger',
+  NG: 'Nigeria',
+  RE: 'Réunion',
+  RW: 'Rwanda',
+  SH: 'St. Helena',
+  ST: 'São Tomé & Príncipe',
+  SN: 'Senegal',
+  SC: 'Seychelles',
+  SL: 'Sierra Leone',
+  SO: 'Somalia',
+  ZA: 'South Africa',
+  SS: 'South Sudan',
+  SD: 'Sudan',
+  TZ: 'Tanzania',
+  TG: 'Togo',
+  TN: 'Tunisia',
+  UG: 'Uganda',
+  EH: 'Western Sahara',
+  ZM: 'Zambia',
+  ZW: 'Zimbabwe',
+  AE: 'United Arab Emirates',
+  BH: 'Bahrain',
+  IL: 'Israel',
+  IQ: 'Iraq',
+  IR: 'Iran',
+  JO: 'Jordan',
+  KW: 'Kuwait',
+  LB: 'Lebanon',
+  OM: 'Oman',
+  PS: 'Palestinian Territories',
+  QA: 'Qatar',
+  SA: 'Saudi Arabia',
+  SY: 'Syria',
+  TR: 'Türkiye',
+  YE: 'Yemen',
+  AD: 'Andorra',
+  AL: 'Albania',
+  AT: 'Austria',
+  AX: 'Åland Islands',
+  BA: 'Bosnia & Herzegovina',
+  BE: 'Belgium',
+  BG: 'Bulgaria',
+  BY: 'Belarus',
+  CH: 'Switzerland',
+  CY: 'Cyprus',
+  CZ: 'Czechia',
+  DE: 'Germany',
+  DK: 'Denmark',
+  EE: 'Estonia',
+  ES: 'Spain',
+  FI: 'Finland',
+  FO: 'Faroe Islands',
+  FR: 'France',
+  GB: 'United Kingdom',
+  GG: 'Guernsey',
+  GI: 'Gibraltar',
+  GR: 'Greece',
+  HR: 'Croatia',
+  HU: 'Hungary',
+  IE: 'Ireland',
+  IM: 'Isle of Man',
+  IS: 'Iceland',
+  IT: 'Italy',
+  JE: 'Jersey',
+  LI: 'Liechtenstein',
+  LT: 'Lithuania',
+  LU: 'Luxembourg',
+  LV: 'Latvia',
+  MC: 'Monaco',
+  MD: 'Moldova',
+  ME: 'Montenegro',
+  MK: 'North Macedonia',
+  MT: 'Malta',
+  NL: 'Netherlands',
+  NO: 'Norway',
+  PL: 'Poland',
+  PT: 'Portugal',
+  RO: 'Romania',
+  RS: 'Serbia',
+  RU: 'Russia',
+  SE: 'Sweden',
+  SI: 'Slovenia',
+  SJ: 'Svalbard & Jan Mayen',
+  SK: 'Slovakia',
+  SM: 'San Marino',
+  UA: 'Ukraine',
+  VA: 'Vatican City',
+  XK: 'Kosovo',
+  AG: 'Antigua & Barbuda',
+  AI: 'Anguilla',
+  AR: 'Argentina',
+  AW: 'Aruba',
+  BB: 'Barbados',
+  BL: 'St. Barthélemy',
+  BM: 'Bermuda',
+  BO: 'Bolivia',
+  BQ: 'Caribbean Netherlands',
+  BR: 'Brazil',
+  BS: 'Bahamas',
+  BZ: 'Belize',
+  CA: 'Canada',
+  CL: 'Chile',
+  CO: 'Colombia',
+  CR: 'Costa Rica',
+  CU: 'Cuba',
+  CW: 'Curaçao',
+  DM: 'Dominica',
+  DO: 'Dominican Republic',
+  EC: 'Ecuador',
+  FK: 'Falkland Islands',
+  GD: 'Grenada',
+  GF: 'French Guiana',
+  GL: 'Greenland',
+  GP: 'Guadeloupe',
+  GT: 'Guatemala',
+  GY: 'Guyana',
+  HN: 'Honduras',
+  HT: 'Haiti',
+  JM: 'Jamaica',
+  KN: 'St. Kitts & Nevis',
+  KY: 'Cayman Islands',
+  LC: 'St. Lucia',
+  MF: 'St. Martin',
+  MQ: 'Martinique',
+  MS: 'Montserrat',
+  MX: 'Mexico',
+  NI: 'Nicaragua',
+  PA: 'Panama',
+  PE: 'Peru',
+  PM: 'St. Pierre & Miquelon',
+  PR: 'Puerto Rico',
+  PY: 'Paraguay',
+  SR: 'Suriname',
+  SV: 'El Salvador',
+  SX: 'Sint Maarten',
+  TC: 'Turks & Caicos Islands',
+  TT: 'Trinidad & Tobago',
+  US: 'United States',
+  UY: 'Uruguay',
+  VC: 'St. Vincent & Grenadines',
+  VE: 'Venezuela',
+  VG: 'British Virgin Islands',
+  VI: 'U.S. Virgin Islands',
+  AF: 'Afghanistan',
+  AM: 'Armenia',
+  AS: 'American Samoa',
+  AU: 'Australia',
+  AZ: 'Azerbaijan',
+  BD: 'Bangladesh',
+  BN: 'Brunei',
+  BT: 'Bhutan',
+  CK: 'Cook Islands',
+  CN: 'China',
+  FJ: 'Fiji',
+  FM: 'Micronesia',
+  GE: 'Georgia',
+  GU: 'Guam',
+  HK: 'Hong Kong SAR China',
+  ID: 'Indonesia',
+  IN: 'India',
+  JP: 'Japan',
+  KG: 'Kyrgyzstan',
+  KH: 'Cambodia',
+  KI: 'Kiribati',
+  KP: 'North Korea',
+  KR: 'South Korea',
+  KZ: 'Kazakhstan',
+  LA: 'Laos',
+  LK: 'Sri Lanka',
+  MH: 'Marshall Islands',
+  MM: 'Myanmar (Burma)',
+  MN: 'Mongolia',
+  MO: 'Macao SAR China',
+  MP: 'Northern Mariana Islands',
+  MV: 'Maldives',
+  MY: 'Malaysia',
+  NC: 'New Caledonia',
+  NF: 'Norfolk Island',
+  NP: 'Nepal',
+  NR: 'Nauru',
+  NU: 'Niue',
+  NZ: 'New Zealand',
+  PF: 'French Polynesia',
+  PG: 'Papua New Guinea',
+  PH: 'Philippines',
+  PK: 'Pakistan',
+  PN: 'Pitcairn Islands',
+  PW: 'Palau',
+  SB: 'Solomon Islands',
+  SG: 'Singapore',
+  TH: 'Thailand',
+  TJ: 'Tajikistan',
+  TK: 'Tokelau',
+  TL: 'Timor-Leste',
+  TM: 'Turkmenistan',
+  TO: 'Tonga',
+  TV: 'Tuvalu',
+  TW: 'Taiwan',
+  UZ: 'Uzbekistan',
+  VN: 'Vietnam',
+  VU: 'Vanuatu',
+  WF: 'Wallis & Futuna',
+  WS: 'Samoa',
+};