@ama-sdk/core 11.0.0-next.0 → 11.0.0-next.1

package/esm2015/utils/crypto.js

@@ -122,7 +122,7 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { promisifyMsCrypto } from "./ie11";
+import { promisifyMsCrypto } from './ie11';
 /**
  * Converts an ArrayBuffer to a string.
  * @param buf ArrayBuffer to convert
@@ -143,25 +143,25 @@ import { promisifyMsCrypto } from "./ie11";
 /**
  * Generates a 256 bytes AES-GCM key to be used as the ContentEncrytionKey
  */ export function generateContentEncryptionKey() {
-    if (typeof window.msCrypto !== "undefined") {
+    if (typeof window.msCrypto !== 'undefined') {
         return promisifyMsCrypto(window.msCrypto.subtle.generateKey({
-            name: "AES-GCM",
+            name: 'AES-GCM',
             length: 256
         }, true, [
-            "encrypt"
+            'encrypt'
         ]));
     }
     return window.crypto.subtle.generateKey({
-        name: "AES-GCM",
+        name: 'AES-GCM',
         length: 256
     }, true, [
-        "encrypt"
+        'encrypt'
     ]);
 }
 /**
  * Generates an Initialization Vector of 96 bytes
  */ export function generateIV() {
-    if (typeof window.msCrypto !== "undefined") {
+    if (typeof window.msCrypto !== 'undefined') {
         return window.msCrypto.getRandomValues(new Uint8Array(12));
     }
     return window.crypto.getRandomValues(new Uint8Array(12));
@@ -179,13 +179,13 @@ function _wrapContentEncryptionKey() {
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    if (!(typeof window.msCrypto !== "undefined")) return [
+                    if (!(typeof window.msCrypto !== 'undefined')) return [
                         3,
                         2
                     ];
                     return [
                         4,
-                        promisifyMsCrypto(window.msCrypto.subtle.exportKey("raw", contentEncryptionKey))
+                        promisifyMsCrypto(window.msCrypto.subtle.exportKey('raw', contentEncryptionKey))
                     ];
                 case 1:
                     bufferCek = _state.sent();
@@ -193,15 +193,15 @@ function _wrapContentEncryptionKey() {
                     return [
                         2,
                         promisifyMsCrypto(window.msCrypto.subtle.encrypt({
-                            name: "RSA-OAEP",
-                            hash: "SHA-256"
+                            name: 'RSA-OAEP',
+                            hash: 'SHA-256'
                         }, publicKey, new Uint8Array(bufferCek)))
                     ];
                 case 2:
                     return [
                         2,
-                        window.crypto.subtle.wrapKey("raw", contentEncryptionKey, publicKey, {
-                            name: "RSA-OAEP"
+                        window.crypto.subtle.wrapKey('raw', contentEncryptionKey, publicKey, {
+                            name: 'RSA-OAEP'
                         })
                     ];
             }
@@ -226,14 +226,14 @@ function _encryptPayload() {
             switch(_state.label){
                 case 0:
                     aesParams = {
-                        name: "AES-GCM",
+                        name: 'AES-GCM',
                         iv: iv,
                         tagLength: authenticationTagLength
                     };
                     if (additionalAuthenticatedData) {
                         aesParams.additionalData = additionalAuthenticatedData;
                     }
-                    if (!(typeof window.msCrypto !== "undefined")) return [
+                    if (!(typeof window.msCrypto !== 'undefined')) return [
                         3,
                         2
                     ];

package/esm2015/utils/generic-api.js

@@ -0,0 +1,245 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { ApiTypes } from '../fwk';
+/**
+ * Generic request to the API
+ */ export var GenericApi = /*#__PURE__*/ function() {
+    "use strict";
+    function GenericApi(apiClient) {
+        _class_call_check(this, GenericApi);
+        /** @inheritDoc */ _define_property(this, "apiName", GenericApi.apiName);
+        /** @inheritDoc */ _define_property(this, "client", void 0);
+        this.client = apiClient;
+    }
+    _create_class(GenericApi, [
+        {
+            key: "request",
+            value: /**
+   * Process to request to the API in the context of the SDK
+   * @param requestOptions Option to provide to process to the call
+   */ function request(requestOptions) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _requestOptions_metadata, _requestOptions_metadata1, metadataHeaderAccept, headers, requestParameters, options, _tmp, url, ret;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                metadataHeaderAccept = ((_requestOptions_metadata = requestOptions.metadata) === null || _requestOptions_metadata === void 0 ? void 0 : _requestOptions_metadata.headerAccept) || 'application/json';
+                                headers = _object_spread({
+                                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                                    'Content-Type': ((_requestOptions_metadata1 = requestOptions.metadata) === null || _requestOptions_metadata1 === void 0 ? void 0 : _requestOptions_metadata1.headerContentType) || 'application/json'
+                                }, metadataHeaderAccept ? {
+                                    'Accept': metadataHeaderAccept
+                                } : {});
+                                requestParameters = _object_spread({
+                                    api: _this,
+                                    headers: headers
+                                }, requestOptions);
+                                if (!_this.client.getRequestOptions) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    _this.client.getRequestOptions(requestParameters)
+                                ];
+                            case 1:
+                                _tmp = _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 2:
+                                return [
+                                    4,
+                                    _this.client.prepareOptions(requestParameters.basePath, requestParameters.method, requestParameters.queryParams || {}, requestParameters.headers)
+                                ];
+                            case 3:
+                                _tmp = _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                options = _tmp;
+                                url = _this.client.prepareUrl(options.basePath, options.queryParams);
+                                ret = _this.client.processCall(url, options, ApiTypes.DEFAULT, requestOptions.api.apiName, requestOptions.revivers, requestOptions.operationId);
+                                return [
+                                    2,
+                                    ret
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return GenericApi;
+}();
+/** API name */ _define_property(GenericApi, "apiName", 'GenericApi');

package/esm2015/utils/index.js

@@ -1,5 +1,6 @@
-export * from "./crypto";
-export * from "./encoder";
-export * from "./ie11";
-export * from "./json-token";
-export * from "./mime-types";
+export * from './crypto';
+export * from './encoder';
+export * from './ie11';
+export * from './json-token';
+export * from './mime-types';
+export * from './generic-api';

package/esm2015/utils/json-token.js

@@ -122,8 +122,8 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { ab2str, encryptPayload, generateContentEncryptionKey, generateIV, wrapContentEncryptionKey } from "./crypto";
-import { Encoder } from "./encoder";
+import { ab2str, encryptPayload, generateContentEncryptionKey, generateIV, wrapContentEncryptionKey } from './crypto';
+import { Encoder } from './encoder';
 /**
  * Encode a Unicode string in base64
  * @param str String to convert
@@ -133,11 +133,11 @@ import { Encoder } from "./encoder";
     // encodeURI escape all non-ASCII characters but we don't want to escape latin non-ascii characters
     // (charCode between 128 and 255).
     return window.btoa(encodeURI(str).replace(/%C2%([89AB][0-9A-F])/g, function(_match, p1) {
-        return String.fromCharCode(parseInt("0x" + p1, 16));
+        return String.fromCharCode(parseInt('0x' + p1, 16));
     }).replace(/%C3%([89AB][0-9A-F])/g, function(_match, p1) {
-        return String.fromCharCode(parseInt("0xc0", 16) + parseInt("0x" + p1, 16) - parseInt("0x80", 16));
+        return String.fromCharCode(parseInt('0xc0', 16) + parseInt('0x' + p1, 16) - parseInt('0x80', 16));
     }).replace(/%([0-9A-F]{2})/g, function(_match, p1) {
-        return String.fromCharCode(parseInt("0x" + p1, 16));
+        return String.fromCharCode(parseInt('0x' + p1, 16));
     }));
 }
 /**
@@ -147,7 +147,7 @@ import { Encoder } from "./encoder";
     // Once the provided string is decoded from based64, we convert each character in its hexadecimal
     // value prefixed with the % character to make it URI compatible.
     var hexString = window.atob(str).replace(/./g, function(match) {
-        return "%" + match.charCodeAt(0).toString(16);
+        return '%' + match.charCodeAt(0).toString(16);
     });
     return decodeURI(hexString);
 }
@@ -157,7 +157,7 @@ import { Encoder } from "./encoder";
  * characters are removed
  * @param str the encoded string
  */ export function base64EncodeUrl(str) {
-    return str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 }
 /**
  * Recreate a Base64 encoded string that was made URL friendly
@@ -165,84 +165,84 @@ import { Encoder } from "./encoder";
  * @param str the encoded string
  */ export function base64DecodeUrl(str) {
     // Pad out with standard base64 required padding characters
-    str = (str + "===").slice(0, str.length + str.length % 4);
-    return str.replace(/-/g, "+").replace(/_/g, "/");
+    str = (str + '===').slice(0, str.length + str.length % 4);
+    return str.replace(/-/g, '+').replace(/_/g, '/');
 }
 /**
  * Creates a base64 encoding function depending on whether the plugin is run from a browser or from NodeJS.
  */ export function createBase64Encoder() {
     // Web browsers
-    if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
         return function(data) {
             return base64EncodeUnicode(data);
         };
     }
     // NodeJS
-    if (typeof Buffer === "function") {
+    if (typeof Buffer === 'function') {
         return function(data) {
-            return Buffer.from(data).toString("base64");
+            return Buffer.from(data).toString('base64');
         };
     }
-    throw new Error("Cannot convert string to base64, both btoa and Buffer are undefined.");
+    throw new Error('Cannot convert string to base64, both btoa and Buffer are undefined.');
 }
 /**
  * Creates a base64 decoding function depending on whether the plugin is run from a browser or from NodeJS.
  */ export function createBase64Decoder() {
     // Web browsers
-    if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
         return function(data) {
             return base64DecodeUnicode(data);
         };
     }
     // NodeJS
-    if (typeof Buffer === "function") {
+    if (typeof Buffer === 'function') {
         return function(data) {
-            return Buffer.from(data, "base64").toString();
+            return Buffer.from(data, 'base64').toString();
         };
     }
-    throw new Error("Cannot convert base64 to string, both atob and Buffer are undefined.");
+    throw new Error('Cannot convert base64 to string, both atob and Buffer are undefined.');
 }
 /**
  * Creates a base64Url encoding function depending on whether the plugin is run from a browser or from NodeJS.
  */ export function createBase64UrlEncoder() {
     // Web browsers
-    if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
         return function(data) {
             return base64EncodeUrl(base64EncodeUnicode(data));
         };
     }
     // NodeJS
-    if (typeof Buffer === "function") {
+    if (typeof Buffer === 'function') {
         return function(data) {
-            return base64EncodeUrl(Buffer.from(data).toString("base64"));
+            return base64EncodeUrl(Buffer.from(data).toString('base64'));
         };
     }
-    throw new Error("Cannot convert string to base64, both btoa and Buffer are undefined.");
+    throw new Error('Cannot convert string to base64, both btoa and Buffer are undefined.');
 }
 /**
  * Creates a base64Url decoding function depending on whether the plugin is run from a browser or from NodeJS.
  */ export function createBase64UrlDecoder() {
     // Web browsers
-    if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
         return function(data) {
             return base64DecodeUnicode(base64DecodeUrl(data));
         };
     }
     // NodeJS
-    if (typeof Buffer === "function") {
+    if (typeof Buffer === 'function') {
         return function(data) {
-            return Buffer.from(base64DecodeUrl(data), "base64").toString();
+            return Buffer.from(base64DecodeUrl(data), 'base64').toString();
         };
     }
-    throw new Error("Cannot convert base64 to string, both atob and Buffer are undefined.");
+    throw new Error('Cannot convert base64 to string, both atob and Buffer are undefined.');
 }
 /**
  * Creates a JWT encoding function which transforms the provided payload as a unsecured JWT format https://tools.ietf.org/html/rfc7519#section-6
  */ export function createJwtEncoder() {
     var encoder = createBase64UrlEncoder();
     var jwtHeader = {
-        alg: "none",
-        typ: "JWT"
+        alg: 'none',
+        typ: 'JWT'
     };
     return function(jwtPayload) {
         return "".concat(encoder(JSON.stringify(jwtHeader)), ".").concat(encoder(JSON.stringify(jwtPayload)), ".");
@@ -257,7 +257,7 @@ import { Encoder } from "./encoder";
  */ export function createJweEncoder() {
     var aesTagLengthInBits = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 128, useHeaderAsAAD = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
     var base64Encoder = createBase64UrlEncoder();
-    var stringEncoder = typeof window.TextEncoder !== "undefined" ? new TextEncoder() : new Encoder();
+    var stringEncoder = typeof window.TextEncoder !== 'undefined' ? new TextEncoder() : new Encoder();
     return function() {
         var _ref = _async_to_generator(function(param, jwePayload, publicProperties) {
             var publicKey, keyId, jweHeader, cek, wrappedCek, iv, serializedHeader, _ref, ciphertext, authenticationTag;
@@ -266,9 +266,9 @@ import { Encoder } from "./encoder";
                     case 0:
                         publicKey = param.publicKey, keyId = param.keyId;
                         jweHeader = {
-                            alg: "RSA-OAEP-256",
-                            enc: "A256GCM",
-                            typ: "JWE",
+                            alg: 'RSA-OAEP-256',
+                            enc: 'A256GCM',
+                            typ: 'JWE',
                             kid: keyId
                         };
                         publicProperties.forEach(function(property) {
@@ -306,7 +306,7 @@ import { Encoder } from "./encoder";
                         _ref = _state.sent(), ciphertext = _ref.ciphertext, authenticationTag = _ref.authenticationTag;
                         return [
                             2,
-                            serializedHeader + "." + base64Encoder(ab2str(wrappedCek)) + "." + base64Encoder(ab2str(iv.buffer)) + "." + base64Encoder(ab2str(ciphertext)) + "." + base64Encoder(ab2str(authenticationTag))
+                            serializedHeader + '.' + base64Encoder(ab2str(wrappedCek)) + '.' + base64Encoder(ab2str(iv.buffer)) + '.' + base64Encoder(ab2str(ciphertext)) + '.' + base64Encoder(ab2str(authenticationTag))
                         ];
                 }
             });

package/esm2015/utils/json-token.spec.js

@@ -168,28 +168,28 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-var crypto = require("node:crypto");
-import { base64DecodeUrl, createBase64Decoder, createBase64Encoder, createBase64UrlDecoder, createBase64UrlEncoder, createJweEncoder } from "./json-token";
-describe("JSON token utils", function() {
-    it("should encode and decode in base64 properly a string that contains characters occupying more than 1 byte", function() {
+var crypto = require('node:crypto');
+import { base64DecodeUrl, createBase64Decoder, createBase64Encoder, createBase64UrlDecoder, createBase64UrlEncoder, createJweEncoder } from './json-token';
+describe('JSON token utils', function() {
+    it('should encode and decode in base64 properly a string that contains characters occupying more than 1 byte', function() {
         var base64Encoder = createBase64Encoder();
         var base64Decoder = createBase64Decoder();
-        var myString = "☸☹☺☻☼☾☿";
+        var myString = '☸☹☺☻☼☾☿';
         var converted = base64Encoder(myString);
         var original = base64Decoder(converted);
         expect(original).toEqual(myString);
     });
-    it("should encode and decode in base64Url properly a string that contains characters occupying more than 1 byte", function() {
+    it('should encode and decode in base64Url properly a string that contains characters occupying more than 1 byte', function() {
         var base64UrlEncoder = createBase64UrlEncoder();
         var base64UrlDecoder = createBase64UrlDecoder();
-        var myString = "☸☹☺☻☼☾☿";
+        var myString = '☸☹☺☻☼☾☿';
         var converted = base64UrlEncoder(myString);
         var original = base64UrlDecoder(converted);
         expect(original).toEqual(myString);
     });
 });
-describe("JSON Web Encryption Token", function() {
-    it("should generate a proper JWE Token", /*#__PURE__*/ _async_to_generator(function() {
+describe('JSON Web Encryption Token', function() {
+    it('should generate a proper JWE Token', /*#__PURE__*/ _async_to_generator(function() {
         var expectedJwePayload, expectedJweHeader, expectedIv, cek, expectedJweEncryptedKey, outputAesGcm, jweToken, _jweToken_split, jweHeader, jweEncryptedKey, iv, cipherContent, authenticationTag, decipher, decrypted;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -197,20 +197,20 @@ describe("JSON Web Encryption Token", function() {
                     /* eslint-disable @typescript-eslint/naming-convention */ expectedJwePayload = {
                         iat: 0,
                         exp: 3600,
-                        iss: "DEMO_JWE",
-                        sub: "pii",
-                        "ama-tokens": {
-                            "{orderId}": "RG287F",
-                            "{lastName}": "Doe"
+                        iss: 'DEMO_JWE',
+                        sub: 'pii',
+                        'ama-tokens': {
+                            '{orderId}': 'RG287F',
+                            '{lastName}': 'Doe'
                         }
                     };
                     /* eslint-enable @typescript-eslint/naming-convention */ expectedJweHeader = {
-                        alg: "RSA-OAEP-256",
-                        enc: "A256GCM",
-                        typ: "JWE",
-                        kid: "TEST",
-                        iss: "DEMO_JWE",
-                        sub: "pii"
+                        alg: 'RSA-OAEP-256',
+                        enc: 'A256GCM',
+                        typ: 'JWE',
+                        kid: 'TEST',
+                        iss: 'DEMO_JWE',
+                        sub: 'pii'
                     };
                     expectedIv = new Uint8Array([
                         21,
@@ -640,7 +640,7 @@ describe("JSON Web Encryption Token", function() {
                     ]);
                     global.window = {
                         btoa: function(data) {
-                            return Buffer.from(data, "ascii").toString("base64");
+                            return Buffer.from(data, 'ascii').toString('base64');
                         },
                         crypto: {
                             getRandomValues: jest.fn().mockReturnValue(expectedIv),
@@ -654,25 +654,25 @@ describe("JSON Web Encryption Token", function() {
                     return [
                         4,
                         createJweEncoder(96)({
-                            publicKey: "myPublicKey",
-                            keyId: "TEST"
+                            publicKey: 'myPublicKey',
+                            keyId: 'TEST'
                         }, expectedJwePayload, [
-                            "iss",
-                            "sub"
+                            'iss',
+                            'sub'
                         ])
                     ];
                 case 1:
                     jweToken = _state.sent();
                     global.window = undefined;
-                    _jweToken_split = _sliced_to_array(jweToken.split("."), 5), jweHeader = _jweToken_split[0], jweEncryptedKey = _jweToken_split[1], iv = _jweToken_split[2], cipherContent = _jweToken_split[3], authenticationTag = _jweToken_split[4];
-                    expect(decodeURI(Buffer.from(base64DecodeUrl(jweHeader), "base64").toString())).toEqual(JSON.stringify(expectedJweHeader));
-                    expect(Buffer.from(base64DecodeUrl(jweEncryptedKey), "base64")).toEqual(Buffer.from(expectedJweEncryptedKey));
-                    expect(Buffer.from(base64DecodeUrl(iv), "base64")).toEqual(Buffer.from(expectedIv));
-                    decipher = crypto.createDecipheriv("aes-256-gcm", cek, Buffer.from(base64DecodeUrl(iv), "base64"), {
+                    _jweToken_split = _sliced_to_array(jweToken.split('.'), 5), jweHeader = _jweToken_split[0], jweEncryptedKey = _jweToken_split[1], iv = _jweToken_split[2], cipherContent = _jweToken_split[3], authenticationTag = _jweToken_split[4];
+                    expect(decodeURI(Buffer.from(base64DecodeUrl(jweHeader), 'base64').toString())).toEqual(JSON.stringify(expectedJweHeader));
+                    expect(Buffer.from(base64DecodeUrl(jweEncryptedKey), 'base64')).toEqual(Buffer.from(expectedJweEncryptedKey));
+                    expect(Buffer.from(base64DecodeUrl(iv), 'base64')).toEqual(Buffer.from(expectedIv));
+                    decipher = crypto.createDecipheriv('aes-256-gcm', cek, Buffer.from(base64DecodeUrl(iv), 'base64'), {
                         authTagLength: 12
                     });
-                    decipher.setAuthTag(Buffer.from(base64DecodeUrl(authenticationTag), "base64"));
-                    decrypted = decipher.update(Buffer.from(base64DecodeUrl(cipherContent), "base64"));
+                    decipher.setAuthTag(Buffer.from(base64DecodeUrl(authenticationTag), 'base64'));
+                    decrypted = decipher.update(Buffer.from(base64DecodeUrl(cipherContent), 'base64'));
                     decrypted += decipher.final();
                     expect(decrypted.toString()).toEqual(JSON.stringify(expectedJwePayload));
                     return [