@axa-fr/oidc-client 7.22.18 → 7.22.19

package/src/initWorkerOption.ts

@@ -1,133 +1,140 @@
-import {ServiceWorkerActivate} from "./types";
+import { ServiceWorkerActivate } from './types';
 
-export const excludeOs = (operatingSystem) => {
-    if (operatingSystem.os === 'iOS' && operatingSystem.osVersion.startsWith('12')) {
-        return true;
-    }
-    if (operatingSystem.os === 'Mac OS X' && operatingSystem.osVersion.startsWith('10_15_6')) {
-        return true;
-    }
-    return false;
+export const excludeOs = operatingSystem => {
+  if (operatingSystem.os === 'iOS' && operatingSystem.osVersion.startsWith('12')) {
+    return true;
+  }
+  if (operatingSystem.os === 'Mac OS X' && operatingSystem.osVersion.startsWith('10_15_6')) {
+    return true;
+  }
+  return false;
 };
-export const getOperatingSystem = (navigator) => {
-    const nVer = navigator.appVersion;
-    const nAgt = navigator.userAgent;
-    const unknown = '-';
-    // system
-    let os = unknown;
-    const clientStrings = [
-        { s: 'Windows 10', r: /(Windows 10.0|Windows NT 10.0)/ },
-        { s: 'Windows 8.1', r: /(Windows 8.1|Windows NT 6.3)/ },
-        { s: 'Windows 8', r: /(Windows 8|Windows NT 6.2)/ },
-        { s: 'Windows 7', r: /(Windows 7|Windows NT 6.1)/ },
-        { s: 'Windows Vista', r: /Windows NT 6.0/ },
-        { s: 'Windows Server 2003', r: /Windows NT 5.2/ },
-        { s: 'Windows XP', r: /(Windows NT 5.1|Windows XP)/ },
-        { s: 'Windows 2000', r: /(Windows NT 5.0|Windows 2000)/ },
-        { s: 'Windows ME', r: /(Win 9x 4.90|Windows ME)/ },
-        { s: 'Windows 98', r: /(Windows 98|Win98)/ },
-        { s: 'Windows 95', r: /(Windows 95|Win95|Windows_95)/ },
-        { s: 'Windows NT 4.0', r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },
-        { s: 'Windows CE', r: /Windows CE/ },
-        { s: 'Windows 3.11', r: /Win16/ },
-        { s: 'Android', r: /Android/ },
-        { s: 'Open BSD', r: /OpenBSD/ },
-        { s: 'Sun OS', r: /SunOS/ },
-        { s: 'Chrome OS', r: /CrOS/ },
-        { s: 'Linux', r: /(Linux|X11(?!.*CrOS))/ },
-        { s: 'iOS', r: /(iPhone|iPad|iPod)/ },
-        { s: 'Mac OS X', r: /Mac OS X/ },
-        { s: 'Mac OS', r: /(Mac OS|MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },
-        { s: 'QNX', r: /QNX/ },
-        { s: 'UNIX', r: /UNIX/ },
-        { s: 'BeOS', r: /BeOS/ },
-        { s: 'OS/2', r: /OS\/2/ },
-        { s: 'Search Bot', r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/ },
-    ];
-    for (const id in clientStrings) {
-        const cs = clientStrings[id];
-        if (cs.r.test(nAgt)) {
-            os = cs.s;
-            break;
-        }
+export const getOperatingSystem = navigator => {
+  const nVer = navigator.appVersion;
+  const nAgt = navigator.userAgent;
+  const unknown = '-';
+  // system
+  let os = unknown;
+  const clientStrings = [
+    { s: 'Windows 10', r: /(Windows 10.0|Windows NT 10.0)/ },
+    { s: 'Windows 8.1', r: /(Windows 8.1|Windows NT 6.3)/ },
+    { s: 'Windows 8', r: /(Windows 8|Windows NT 6.2)/ },
+    { s: 'Windows 7', r: /(Windows 7|Windows NT 6.1)/ },
+    { s: 'Windows Vista', r: /Windows NT 6.0/ },
+    { s: 'Windows Server 2003', r: /Windows NT 5.2/ },
+    { s: 'Windows XP', r: /(Windows NT 5.1|Windows XP)/ },
+    { s: 'Windows 2000', r: /(Windows NT 5.0|Windows 2000)/ },
+    { s: 'Windows ME', r: /(Win 9x 4.90|Windows ME)/ },
+    { s: 'Windows 98', r: /(Windows 98|Win98)/ },
+    { s: 'Windows 95', r: /(Windows 95|Win95|Windows_95)/ },
+    { s: 'Windows NT 4.0', r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },
+    { s: 'Windows CE', r: /Windows CE/ },
+    { s: 'Windows 3.11', r: /Win16/ },
+    { s: 'Android', r: /Android/ },
+    { s: 'Open BSD', r: /OpenBSD/ },
+    { s: 'Sun OS', r: /SunOS/ },
+    { s: 'Chrome OS', r: /CrOS/ },
+    { s: 'Linux', r: /(Linux|X11(?!.*CrOS))/ },
+    { s: 'iOS', r: /(iPhone|iPad|iPod)/ },
+    { s: 'Mac OS X', r: /Mac OS X/ },
+    { s: 'Mac OS', r: /(Mac OS|MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },
+    { s: 'QNX', r: /QNX/ },
+    { s: 'UNIX', r: /UNIX/ },
+    { s: 'BeOS', r: /BeOS/ },
+    { s: 'OS/2', r: /OS\/2/ },
+    {
+      s: 'Search Bot',
+      r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/,
+    },
+  ];
+  for (const id in clientStrings) {
+    const cs = clientStrings[id];
+    if (cs.r.test(nAgt)) {
+      os = cs.s;
+      break;
     }
+  }
 
-    let osVersion = unknown;
+  let osVersion = unknown;
 
-    if (/Windows/.test(os)) {
-        osVersion = /Windows (.*)/.exec(os)[1];
-        os = 'Windows';
-    }
+  if (/Windows/.test(os)) {
+    osVersion = /Windows (.*)/.exec(os)[1];
+    os = 'Windows';
+  }
 
-    switch (os) {
-        case 'Mac OS':
-        case 'Mac OS X':
-        case 'Android':
-            osVersion = /(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([._\d]+)/.exec(nAgt)[1];
-            break;
+  switch (os) {
+    case 'Mac OS':
+    case 'Mac OS X':
+    case 'Android':
+      osVersion =
+        /(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([._\d]+)/.exec(nAgt)[1];
+      break;
 
-        case 'iOS': {
-            const osVersionArray = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer);
-            if(osVersionArray !=null && osVersionArray.length > 2) {
-                osVersion = osVersionArray[1] + '.' + osVersionArray[2] + '.' + (parseInt(osVersionArray[3]) | 0);
-            }
-            break;
-        }
+    case 'iOS': {
+      const osVersionArray = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer);
+      if (osVersionArray != null && osVersionArray.length > 2) {
+        osVersion =
+          osVersionArray[1] + '.' + osVersionArray[2] + '.' + (parseInt(osVersionArray[3]) | 0);
+      }
+      break;
     }
-    return {
-        os,
-        osVersion,
-    };
+  }
+  return {
+    os,
+    osVersion,
+  };
 };
 
 function getBrowser() {
-    const ua = navigator.userAgent; let tem;
-    let M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
-    if (/trident/i.test(M[1])) {
-        tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
-        return { name: 'ie', version: (tem[1] || '') };
-    }
-    if (M[1] === 'Chrome') {
-        tem = ua.match(/\bOPR|Edge\/(\d+)/);
-
-        if (tem != null) {
-            let version = tem[1];
-            if (!version) {
-                const splits = ua.split(tem[0] + '/');
-                if (splits.length > 1) {
-                    version = splits[1];
-                }
-            }
+  const ua = navigator.userAgent;
+  let tem;
+  let M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+  if (/trident/i.test(M[1])) {
+    tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
+    return { name: 'ie', version: tem[1] || '' };
+  }
+  if (M[1] === 'Chrome') {
+    tem = ua.match(/\bOPR|Edge\/(\d+)/);
 
-            return { name: 'opera', version };
+    if (tem != null) {
+      let version = tem[1];
+      if (!version) {
+        const splits = ua.split(tem[0] + '/');
+        if (splits.length > 1) {
+          version = splits[1];
         }
+      }
+
+      return { name: 'opera', version };
     }
-    M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
-    if ((tem = ua.match(/version\/(\d+)/i)) != null) { M.splice(1, 1, tem[1]); }
-    return {
-        name: M[0].toLowerCase(),
-        version: M[1],
-    };
+  }
+  M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
+  if ((tem = ua.match(/version\/(\d+)/i)) != null) {
+    M.splice(1, 1, tem[1]);
+  }
+  return {
+    name: M[0].toLowerCase(),
+    version: M[1],
+  };
 }
 
-export const activateServiceWorker : ServiceWorkerActivate = () : boolean =>{
-    const { name, version } = getBrowser();
-    if (name === 'chrome' && parseInt(version) <= 70) {
-        return false;
-    }
-    if (name === 'opera') {
-        if (!version) {
-            return false;
-        }
-        if (parseInt(version.split('.')[0]) < 80) {
-            return false;
-        }
+export const activateServiceWorker: ServiceWorkerActivate = (): boolean => {
+  const { name, version } = getBrowser();
+  if (name === 'chrome' && parseInt(version) <= 70) {
+    return false;
+  }
+  if (name === 'opera') {
+    if (!version) {
+      return false;
     }
-    if (name === 'ie') {
-        return false;
+    if (parseInt(version.split('.')[0]) < 80) {
+      return false;
     }
+  }
+  if (name === 'ie') {
+    return false;
+  }
 
-    const operatingSystem = getOperatingSystem(navigator);
-    return !excludeOs(operatingSystem);
-    
-}
+  const operatingSystem = getOperatingSystem(navigator);
+  return !excludeOs(operatingSystem);
+};

package/src/jwt.ts

@@ -4,10 +4,10 @@
 //
 // because... JavaScript, Strings, and Buffers
 // @ts-ignore
-import {DemonstratingProofOfPossessionConfiguration} from "./types";
+import { DemonstratingProofOfPossessionConfiguration } from './types';
 
 function strToUint8(str) {
-    return new TextEncoder().encode(str);
+  return new TextEncoder().encode(str);
 }
 
 // Binary String to URL-Safe Base64
@@ -15,10 +15,7 @@ function strToUint8(str) {
 // btoa (Binary-to-Ascii) means "binary string" to base64
 // @ts-ignore
 function binToUrlBase64(bin) {
-    return btoa(bin)
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_')
-        .replace(/=+/g, '');
+  return btoa(bin).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+/g, '');
 }
 
 // UTF-8 to Binary String
@@ -27,53 +24,61 @@ function binToUrlBase64(bin) {
 // https://coolaj86.com/articles/base64-unicode-utf-8-javascript-and-you/
 // @ts-ignore
 function utf8ToBinaryString(str) {
-    const escstr = encodeURIComponent(str);
-    // replaces any uri escape sequence, such as %0A,
-    // with binary escape, such as 0x0A
-    return escstr.replace(/%([0-9A-F]{2})/g, function (match, p1) {
-        return String.fromCharCode(parseInt(p1, 16));
-    });
+  const escstr = encodeURIComponent(str);
+  // replaces any uri escape sequence, such as %0A,
+  // with binary escape, such as 0x0A
+  return escstr.replace(/%([0-9A-F]{2})/g, function (match, p1) {
+    return String.fromCharCode(parseInt(p1, 16));
+  });
 }
 
 // Uint8Array to URL Safe Base64
 //
 // the shortest distant between two encodings... binary string
 // @ts-ignore
-export const uint8ToUrlBase64 =(uint8: Uint8Array) => {
-    let bin = '';
-    // @ts-ignore
-    uint8.forEach(function(code) {
-        bin += String.fromCharCode(code);
-    });
-    return binToUrlBase64(bin);
-}
+export const uint8ToUrlBase64 = (uint8: Uint8Array) => {
+  let bin = '';
+  // @ts-ignore
+  uint8.forEach(function (code) {
+    bin += String.fromCharCode(code);
+  });
+  return binToUrlBase64(bin);
+};
 
 // UCS-2 String to URL-Safe Base64
 //
 // btoa doesn't work on UTF-8 strings
 // @ts-ignore
 function strToUrlBase64(str) {
-    return binToUrlBase64(utf8ToBinaryString(str));
+  return binToUrlBase64(utf8ToBinaryString(str));
 }
 
-export const defaultDemonstratingProofOfPossessionConfiguration: DemonstratingProofOfPossessionConfiguration ={
+export const defaultDemonstratingProofOfPossessionConfiguration: DemonstratingProofOfPossessionConfiguration =
+  {
     importKeyAlgorithm: {
-        name: 'ECDSA',
-        namedCurve: 'P-256',
-        hash: {name: 'ES256'}
+      name: 'ECDSA',
+      namedCurve: 'P-256',
+      hash: { name: 'ES256' },
     },
-    signAlgorithm: {name: 'ECDSA', hash: {name: 'SHA-256'}},
+    signAlgorithm: { name: 'ECDSA', hash: { name: 'SHA-256' } },
     generateKeyAlgorithm: {
-        name: 'ECDSA',
-        namedCurve: 'P-256'
+      name: 'ECDSA',
+      namedCurve: 'P-256',
     },
     digestAlgorithm: { name: 'SHA-256' },
-    jwtHeaderAlgorithm : 'ES256' 
-}
-
+    jwtHeaderAlgorithm: 'ES256',
+  };
 
 // @ts-ignore
-const sign = (w:any) => async (jwk, headers, claims, demonstratingProofOfPossessionConfiguration: DemonstratingProofOfPossessionConfiguration, jwtHeaderType= 'dpop+jwt') => {
+const sign =
+  (w: any) =>
+  async (
+    jwk,
+    headers,
+    claims,
+    demonstratingProofOfPossessionConfiguration: DemonstratingProofOfPossessionConfiguration,
+    jwtHeaderType = 'dpop+jwt',
+  ) => {
     // Make a shallow copy of the key
     // (to set ext if it wasn't already set)
     jwk = Object.assign({}, jwk);
@@ -82,25 +87,25 @@ const sign = (w:any) => async (jwk, headers, claims, demonstratingProofOfPossess
     headers.typ = jwtHeaderType;
     headers.alg = demonstratingProofOfPossessionConfiguration.jwtHeaderAlgorithm;
     switch (headers.alg) {
-        case 'ES256': //if (!headers.kid) {
-            // alternate: see thumbprint function below
-            headers.jwk = {kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y};
-            //}
-            break;
-        case 'RS256':
-            headers.jwk = {kty: jwk.kty, n: jwk.n, e: jwk.e, kid: headers.kid};
-            break;
-        default:
-            throw new Error('Unknown or not implemented JWS algorithm');
+      case 'ES256': //if (!headers.kid) {
+        // alternate: see thumbprint function below
+        headers.jwk = { kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y };
+        //}
+        break;
+      case 'RS256':
+        headers.jwk = { kty: jwk.kty, n: jwk.n, e: jwk.e, kid: headers.kid };
+        break;
+      default:
+        throw new Error('Unknown or not implemented JWS algorithm');
     }
 
     const jws = {
-        // @ts-ignore
-        // JWT "headers" really means JWS "protected headers"
-        protected: strToUrlBase64(JSON.stringify(headers)),
-        // @ts-ignore
-        // JWT "claims" are really a JSON-defined JWS "payload"
-        payload: strToUrlBase64(JSON.stringify(claims))
+      // @ts-ignore
+      // JWT "headers" really means JWS "protected headers"
+      protected: strToUrlBase64(JSON.stringify(headers)),
+      // @ts-ignore
+      // JWT "claims" are really a JSON-defined JWS "payload"
+      payload: strToUrlBase64(JSON.stringify(claims)),
     };
 
     // To import as EC (ECDSA, P-256, SHA-256, ES256)
@@ -131,13 +136,13 @@ const sign = (w:any) => async (jwk, headers, claims, demonstratingProofOfPossess
     // JWT is just a "compressed", "protected" JWS
     // @ts-ignore
     return `${jws.protected}.${jws.payload}.${jws.signature}`;
-};
-
-export var JWT = {sign};
+  };
 
+export const JWT = { sign };
 
 // @ts-ignore
-const generate = (w:any) => async (generateKeyAlgorithm: RsaHashedKeyGenParams | EcKeyGenParams) => {
+const generate =
+  (w: any) => async (generateKeyAlgorithm: RsaHashedKeyGenParams | EcKeyGenParams) => {
     const keyType = generateKeyAlgorithm;
     const exportable = true;
     const privileges = ['sign', 'verify'];
@@ -146,119 +151,128 @@ const generate = (w:any) => async (generateKeyAlgorithm: RsaHashedKeyGenParams |
     // returns an abstract and opaque WebCrypto object,
     // which in most cases you'll want to export as JSON to be able to save
     return await w.crypto.subtle.exportKey('jwk', key.privateKey);
-};
+  };
 
 // Create a Public Key from a Private Key
 //
 // chops off the private parts
 // @ts-ignore
 const neuter = jwk => {
-    const copy = Object.assign({}, jwk);
-    delete copy.d;
-    copy.key_ops = ['verify'];
-    return copy;
+  const copy = Object.assign({}, jwk);
+  delete copy.d;
+  copy.key_ops = ['verify'];
+  return copy;
 };
 
 const EC = {
-    generate,
-    neuter
+  generate,
+  neuter,
 };
 // @ts-ignore
-const thumbprint = (w:any) => async (jwk, digestAlgorithm: AlgorithmIdentifier) => {
-    let sortedPub;
-    // lexigraphically sorted, no spaces
-    switch (jwk.kty) {
-        case 'EC':
-            sortedPub = '{"crv":"CRV","kty":"EC","x":"X","y":"Y"}'
-                .replace('CRV', jwk.crv)
-                .replace('X', jwk.x)
-                .replace('Y', jwk.y);
-            break;
-        case 'RSA':
-            sortedPub = '{"e":"E","kty":"RSA","n":"N"}'
-                .replace('E', jwk.e)
-                .replace('N', jwk.n);
-            break;
-        default:
-            throw new Error('Unknown or not implemented JWK type');
-    }
-    // The hash should match the size of the key,
-    // but we're only dealing with P-256
-    const hash = await w.crypto.subtle.digest(digestAlgorithm, strToUint8(sortedPub));
-    return uint8ToUrlBase64(new Uint8Array(hash));
-}
+const thumbprint = (w: any) => async (jwk, digestAlgorithm: AlgorithmIdentifier) => {
+  let sortedPub;
+  // lexigraphically sorted, no spaces
+  switch (jwk.kty) {
+    case 'EC':
+      sortedPub = '{"crv":"CRV","kty":"EC","x":"X","y":"Y"}'
+        .replace('CRV', jwk.crv)
+        .replace('X', jwk.x)
+        .replace('Y', jwk.y);
+      break;
+    case 'RSA':
+      sortedPub = '{"e":"E","kty":"RSA","n":"N"}'.replace('E', jwk.e).replace('N', jwk.n);
+      break;
+    default:
+      throw new Error('Unknown or not implemented JWK type');
+  }
+  // The hash should match the size of the key,
+  // but we're only dealing with P-256
+  const hash = await w.crypto.subtle.digest(digestAlgorithm, strToUint8(sortedPub));
+  return uint8ToUrlBase64(new Uint8Array(hash));
+};
 
-export var JWK = {thumbprint};
+export const JWK = { thumbprint };
 
-export const generateJwkAsync = (w:any) => async (generateKeyAlgorithm: RsaHashedKeyGenParams | EcKeyGenParams) => {
+export const generateJwkAsync =
+  (w: any) => async (generateKeyAlgorithm: RsaHashedKeyGenParams | EcKeyGenParams) => {
     // @ts-ignore
     const jwk = await EC.generate(w)(generateKeyAlgorithm);
     // console.info('Private Key:', JSON.stringify(jwk));
     // @ts-ignore
     // console.info('Public Key:', JSON.stringify(EC.neuter(jwk)));
     return jwk;
-}
-
-export const generateJwtDemonstratingProofOfPossessionAsync = (w:any) => (demonstratingProofOfPossessionConfiguration: DemonstratingProofOfPossessionConfiguration) => async (jwk, method = 'POST', url: string, extrasClaims={}) => {
+  };
 
+export const generateJwtDemonstratingProofOfPossessionAsync =
+  (w: any) =>
+  (demonstratingProofOfPossessionConfiguration: DemonstratingProofOfPossessionConfiguration) =>
+  async (jwk, method = 'POST', url: string, extrasClaims = {}) => {
     const claims = {
-        // https://www.rfc-editor.org/rfc/rfc9449.html#name-concept
-        jti: btoa(guid()),
-        htm: method,
-        htu: url,
-        iat: Math.round(Date.now() / 1000),
-        ...extrasClaims,
+      // https://www.rfc-editor.org/rfc/rfc9449.html#name-concept
+      jti: btoa(guid()),
+      htm: method,
+      htu: url,
+      iat: Math.round(Date.now() / 1000),
+      ...extrasClaims,
     };
     // @ts-ignore
-    const kid = await JWK.thumbprint(w)(jwk, demonstratingProofOfPossessionConfiguration.digestAlgorithm);
+    const kid = await JWK.thumbprint(w)(
+      jwk,
+      demonstratingProofOfPossessionConfiguration.digestAlgorithm,
+    );
     // @ts-ignore
-    const jwt = await JWT.sign(w)(jwk, { kid: kid }, claims, demonstratingProofOfPossessionConfiguration)
+    const jwt = await JWT.sign(w)(
+      jwk,
+      { kid: kid },
+      claims,
+      demonstratingProofOfPossessionConfiguration,
+    );
     // console.info('JWT:', jwt);
     return jwt;
-}
+  };
 
 const guid = () => {
-    // RFC4122: The version 4 UUID is meant for generating UUIDs from truly-random or
-    // pseudo-random numbers.
-    // The algorithm is as follows:
-    //     Set the two most significant bits (bits 6 and 7) of the
-    //        clock_seq_hi_and_reserved to zero and one, respectively.
-    //     Set the four most significant bits (bits 12 through 15) of the
-    //        time_hi_and_version field to the 4-bit version number from
-    //        Section 4.1.3. Version4 
-    //     Set all the other bits to randomly (or pseudo-randomly) chosen
-    //     values.
-    // UUID                   = time-low "-" time-mid "-"time-high-and-version "-"clock-seq-reserved and low(2hexOctet)"-" node
-    // time-low               = 4hexOctet
-    // time-mid               = 2hexOctet
-    // time-high-and-version  = 2hexOctet
-    // clock-seq-and-reserved = hexOctet: 
-    // clock-seq-low          = hexOctet
-    // node                   = 6hexOctet
-    // Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
-    // y could be 1000, 1001, 1010, 1011 since most significant two bits needs to be 10
-    // y values are 8, 9, A, B
-    const guidHolder = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-    const hex = '0123456789abcdef';
-    let r = 0;
-    let guidResponse = "";
-    for (let i = 0; i < 36; i++) {
-        if (guidHolder[i] !== '-' && guidHolder[i] !== '4') {
-            // each x and y needs to be random
-            r = Math.random() * 16 | 0;
-        }
+  // RFC4122: The version 4 UUID is meant for generating UUIDs from truly-random or
+  // pseudo-random numbers.
+  // The algorithm is as follows:
+  //     Set the two most significant bits (bits 6 and 7) of the
+  //        clock_seq_hi_and_reserved to zero and one, respectively.
+  //     Set the four most significant bits (bits 12 through 15) of the
+  //        time_hi_and_version field to the 4-bit version number from
+  //        Section 4.1.3. Version4
+  //     Set all the other bits to randomly (or pseudo-randomly) chosen
+  //     values.
+  // UUID                   = time-low "-" time-mid "-"time-high-and-version "-"clock-seq-reserved and low(2hexOctet)"-" node
+  // time-low               = 4hexOctet
+  // time-mid               = 2hexOctet
+  // time-high-and-version  = 2hexOctet
+  // clock-seq-and-reserved = hexOctet:
+  // clock-seq-low          = hexOctet
+  // node                   = 6hexOctet
+  // Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+  // y could be 1000, 1001, 1010, 1011 since most significant two bits needs to be 10
+  // y values are 8, 9, A, B
+  const guidHolder = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+  const hex = '0123456789abcdef';
+  let r = 0;
+  let guidResponse = '';
+  for (let i = 0; i < 36; i++) {
+    if (guidHolder[i] !== '-' && guidHolder[i] !== '4') {
+      // each x and y needs to be random
+      r = (Math.random() * 16) | 0;
+    }
 
-        if (guidHolder[i] === 'x') {
-            guidResponse += hex[r];
-        } else if (guidHolder[i] === 'y') {
-            // clock-seq-and-reserved first hex is filtered and remaining hex values are random
-            r &= 0x3; // bit and with 0011 to set pos 2 to zero ?0??
-            r |= 0x8; // set pos 3 to 1 as 1???
-            guidResponse += hex[r];
-        } else {
-            guidResponse += guidHolder[i];
-        }
+    if (guidHolder[i] === 'x') {
+      guidResponse += hex[r];
+    } else if (guidHolder[i] === 'y') {
+      // clock-seq-and-reserved first hex is filtered and remaining hex values are random
+      r &= 0x3; // bit and with 0011 to set pos 2 to zero ?0??
+      r |= 0x8; // set pos 3 to 1 as 1???
+      guidResponse += hex[r];
+    } else {
+      guidResponse += guidHolder[i];
     }
+  }
 
-    return guidResponse;
+  return guidResponse;
 };