solid-ui 2.4.27-9d7e618e → 2.4.27-9f7a01da

package/dist/solid-ui.js

@@ -2655,7 +2655,7 @@ var ChatChannel = /*#__PURE__*/function () {
         var oldMsg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
         var deleteIt = arguments.length > 2 ? arguments[2] : undefined;
         return /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-          var sts, now, timestamp, dateStamp, chatDocument, message, me, msg, oldMsgMaker, errMsg, privateKey, _errMsg;
+          var sts, now, timestamp, dateStamp, chatDocument, message, me, msg, oldMsgMaker, errMsg, privateKey, pubKey, sig, _errMsg;
           return _regenerator["default"].wrap(function _callee2$(_context2) {
             while (1) switch (_context2.prev = _context2.next) {
               case 0:
@@ -2666,8 +2666,8 @@ var ChatChannel = /*#__PURE__*/function () {
                 chatDocument = oldMsg ? oldMsg.doc() : _this.dateFolder.leafDocumentFromDate(now);
                 message = _solidLogic.store.sym(chatDocument.uri + '#' + 'Msg' + timestamp); // const content = store.literal(text)
                 me = _solidLogic.authn.currentUser(); // If already logged on
-                msg = _signature.getBlankMsg;
-                msg.id = message;
+                msg = (0, _signature.getBlankMsg)();
+                msg.id = message.uri;
                 if (!oldMsg) {
                   _context2.next = 22;
                   break;
@@ -2682,7 +2682,7 @@ var ChatChannel = /*#__PURE__*/function () {
                 if (deleteIt) {
                   // we need to add a specific signature, else anyone can delete a msg ?
                   sts.push($rdf.st(message, ns.schema('dateDeleted'), dateStamp, chatDocument));
-                  msg.dateDeleted = dateStamp;
+                  // msg.dateDeleted = dateStamp
                 }
                 _context2.next = 20;
                 break;
@@ -2701,40 +2701,48 @@ var ChatChannel = /*#__PURE__*/function () {
                 sts.push($rdf.st(message, ns.sioc('content'), _solidLogic.store.literal(text), chatDocument));
                 msg.content = text;
                 sts.push($rdf.st(message, ns.dct('created'), dateStamp, chatDocument));
-                msg.created = dateStamp;
+                msg.created = dateStamp.value;
                 if (!me) {
-                  _context2.next = 34;
+                  _context2.next = 36;
                   break;
                 }
                 sts.push($rdf.st(message, ns.foaf('maker'), me, chatDocument));
-                msg.maker = me;
-                // privateKey the cached private key of me, cache should be deleted after a certain time
+                msg.maker = me.uri;
+                // privateKey the cached private key of me, cached in store
                 _context2.next = 32;
-                return (0, _keys.getPrivateKey)(me);
+                return (0, _keys.getPrivateKey)(me.uri);
               case 32:
                 privateKey = _context2.sent;
-                sts.push($rdf.st(message, $rdf.sym("".concat(_signature.SEC, "Proof")), $rdf.sym((0, _signature.signMsg)(msg, privateKey), chatDocument)));
-              case 34:
-                _context2.prev = 34;
-                _context2.next = 37;
+                // const privateKey0 = 'a11bc5d2eee6cdb3b37f5473a712cad905ccfb13fb2ccdbf1be0a1ac4fdc7d2a'
+                // const pubKey0 = '023a9da707bee1302f66083c9d95673ff969b41607a66f52686fa774d64ceb87'
+                pubKey = (0, _keys.getPublicKey)(me.uri);
+                sig = (0, _signature.signMsg)(msg, privateKey);
+                /* const verify = verifySignature(sig, msg, pubKey) // alain to remove
+                debug.warn('sig ' + sig)
+                debug.warn('verifySign ' + verify)
+                debug.warn(msg) */
+                sts.push($rdf.st(message, $rdf.sym("".concat(_signature.SEC, "Proof")), $rdf.lit(sig), chatDocument));
+              case 36:
+                _context2.prev = 36;
+                _context2.next = 39;
                 return _solidLogic.store.updater.update([], sts);
-              case 37:
-                _context2.next = 45;
-                break;
               case 39:
-                _context2.prev = 39;
-                _context2.t0 = _context2["catch"](34);
+                _context2.next = 47;
+                break;
+              case 41:
+                _context2.prev = 41;
+                _context2.t0 = _context2["catch"](36);
                 _errMsg = 'Error saving chat message: ' + _context2.t0;
                 debug.warn(_errMsg);
                 alert(_errMsg);
                 throw new Error(_errMsg);
-              case 45:
+              case 47:
                 return _context2.abrupt("return", message);
-              case 46:
+              case 48:
               case "end":
                 return _context2.stop();
             }
-          }, _callee2, null, [[34, 39]]);
+          }, _callee2, null, [[36, 41]]);
         })();
       });
       function updateMessage(_x2) {
@@ -4045,107 +4053,156 @@ function generatePublicKey(privateKey) {
 }
 function getPublicKey(webId) {
   var publicKey = publicKeyExists(webId);
-  return publicKey === null || publicKey === void 0 ? void 0 : publicKey.uri;
+  return publicKey;
 }
-function publicKeyExists(webId) {
-  // find publickey
+var pubKeyUrl = function pubKeyUrl(webId) {
   var url = new URL(webId);
-  url.hash = '';
-  _solidLogic.store.fetcher.load(url.href);
-  var publicKey = _solidLogic.store.any(_solidLogic.store.sym(webId), _solidLogic.store.sym(_signature.CERT + 'publicKey'));
-  return publicKey;
+  var publicKeyUrl = url.origin + '/profile/keys/publicKey.ttl';
+  return publicKeyUrl;
+};
+function publicKeyExists(_x) {
+  return _publicKeyExists.apply(this, arguments);
 }
-function privateKeyExists(_x) {
+function _publicKeyExists() {
+  _publicKeyExists = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(webId) {
+    var publicKey;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return _solidLogic.store.fetcher.load(pubKeyUrl(webId));
+        case 2:
+          // url.href)
+          publicKey = _solidLogic.store.any(_solidLogic.store.sym(webId), _solidLogic.store.sym(_signature.CERT + 'PublicKey'));
+          return _context.abrupt("return", publicKey === null || publicKey === void 0 ? void 0 : publicKey.value);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _publicKeyExists.apply(this, arguments);
+}
+var privKeyUrl = function privKeyUrl(webId) {
+  var url = new URL(webId);
+  var privateKeyUrl = url.origin + '/profile/keys/privateKey.ttl';
+  return privateKeyUrl;
+};
+function privateKeyExists(_x2) {
   return _privateKeyExists.apply(this, arguments);
 }
 function _privateKeyExists() {
-  _privateKeyExists = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(webId) {
-    var url, privateKeyUrl, privateKey, _err$response, data, contentType, response;
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
+  _privateKeyExists = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(webId) {
+    var privateKeyUrl, privateKey, _err$response, data, contentType, response;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
         case 0:
-          url = new URL(webId);
-          privateKeyUrl = url.hostname + '/profile/privateKey.ttl';
-          _context.prev = 2;
-          _solidLogic.store.fetcher.load(privateKeyUrl);
-          privateKey = _solidLogic.store.any(_solidLogic.store.sym(webId), _solidLogic.store.sym(_signature.CERT + 'privateKey'));
-          return _context.abrupt("return", privateKey);
+          /* const url = new URL(webId)
+          const privateKeyUrl = url.protocol + '//' + url.host + '/profile/privateKey.ttl' */
+          privateKeyUrl = privKeyUrl(webId);
+          /* debug.warn('Alain privateKeyExists')
+          debug.warn(webId)
+          debug.warn(privateKeyUrl) */
+          _context2.prev = 1;
+          _context2.next = 4;
+          return _solidLogic.store.fetcher.load(privateKeyUrl);
+        case 4:
+          privateKey = _solidLogic.store.any(_solidLogic.store.sym(webId), _solidLogic.store.sym(_signature.CERT + 'PrivateKey'));
+          return _context2.abrupt("return", privateKey === null || privateKey === void 0 ? void 0 : privateKey.value);
         case 8:
-          _context.prev = 8;
-          _context.t0 = _context["catch"](2);
-          if (!((_context.t0 === null || _context.t0 === void 0 ? void 0 : (_err$response = _context.t0.response) === null || _err$response === void 0 ? void 0 : _err$response.status) === 404)) {
-            _context.next = 25;
+          _context2.prev = 8;
+          _context2.t0 = _context2["catch"](1);
+          if (!((_context2.t0 === null || _context2.t0 === void 0 ? void 0 : (_err$response = _context2.t0.response) === null || _err$response === void 0 ? void 0 : _err$response.status) === 404)) {
+            _context2.next = 25;
             break;
           }
-          _context.prev = 11;
+          _context2.prev = 11;
           // create privateKey resource
           data = '';
           contentType = 'text/ttl';
-          _context.next = 16;
+          _context2.next = 16;
           return _solidLogic.store.fetcher.webOperation('PUT', privateKeyUrl, {
             data: data,
             contentType: contentType
           });
         case 16:
-          response = _context.sent;
-          _context.next = 23;
+          response = _context2.sent;
+          _context2.next = 23;
           break;
         case 19:
-          _context.prev = 19;
-          _context.t1 = _context["catch"](11);
-          debug.log('createIfNotExists doc FAILED: ' + privateKeyUrl + ': ' + _context.t1);
-          throw _context.t1;
+          _context2.prev = 19;
+          _context2.t1 = _context2["catch"](11);
+          debug.log('createIfNotExists doc FAILED: ' + privateKeyUrl + ': ' + _context2.t1);
+          throw _context2.t1;
         case 23:
           delete _solidLogic.store.fetcher.requested[privateKeyUrl]; // delete cached 404 error
-          return _context.abrupt("return", undefined);
+          return _context2.abrupt("return", undefined);
         case 25:
-          debug.log('createIfNotExists doc FAILED: ' + privateKeyUrl + ': ' + _context.t0);
-          throw _context.t0;
+          debug.log('createIfNotExists doc FAILED: ' + privateKeyUrl + ': ' + _context2.t0);
+          throw _context2.t0;
         case 27:
         case "end":
-          return _context.stop();
+          return _context2.stop();
       }
-    }, _callee, null, [[2, 8], [11, 19]]);
+    }, _callee2, null, [[1, 8], [11, 19]]);
   }));
   return _privateKeyExists.apply(this, arguments);
 }
-function getPrivateKey(_x2) {
+function getPrivateKey(_x3) {
   return _getPrivateKey.apply(this, arguments);
 }
 function _getPrivateKey() {
-  _getPrivateKey = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(webId) {
-    var url, privateKeyUrl, publicKey, privateKey, del, add;
-    return _regenerator["default"].wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
+  _getPrivateKey = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(webId) {
+    var publicKeyUrl, privateKeyUrl, publicKey, privateKey, del, add;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
         case 0:
-          url = new URL(webId);
-          privateKeyUrl = url.hostname + '/profile/privateKey.ttl'; // find publickey
-          publicKey = publicKeyExists(webId); // find privateKey
-          _context2.next = 5;
+          /* const url = new URL(webId)
+          url.hash = '' */
+          /* const privateKeyUrl = url.protocol + '//' + url.host + '/profile/privateKey.ttl' */
+          publicKeyUrl = pubKeyUrl(webId);
+          privateKeyUrl = privKeyUrl(webId); // find publickey
+          _context3.next = 4;
+          return publicKeyExists(webId);
+        case 4:
+          publicKey = _context3.sent;
+          _context3.next = 7;
           return privateKeyExists(webId);
-        case 5:
-          privateKey = _context2.sent;
+        case 7:
+          privateKey = _context3.sent;
+          // debug.warn('privateKey ' + privateKey)
+          if (privateKey && publicKey !== generatePublicKey(privateKey)) debug.warn('publicKey is not valid');
+
+          // simulate new key pair
+          /* const newPrivateKey = generatePrivateKey()
+          const newPublicKey = generatePublicKey(newPrivateKey)
+          debug.log('newPrivateKey ' + newPrivateKey)
+          debug.log('newPublicKey ' + newPublicKey) */
+
+          // create key pair
           if (!(!privateKey || !publicKey)) {
-            _context2.next = 17;
+            _context3.next = 20;
             break;
           }
           del = [];
           add = [];
-          if (privateKey) del.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'privateKey'), privateKey, $rdf.sym(privateKeyUrl)));
-          if (publicKey) del.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'publicKey'), publicKey, $rdf.sym(url.href)));
-          privateKey = _solidLogic.store.sym(generatePrivateKey());
-          publicKey = _solidLogic.store.sym(generatePublicKey(privateKey.uri));
-          add.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'privateKey'), $rdf.literal(privateKey.uri), $rdf.sym(privateKeyUrl)));
-          add.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'publicKey'), $rdf.literal(publicKey.uri), $rdf.sym(url.href)));
-          _context2.next = 17;
+          if (privateKey) del.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'PrivateKey'), $rdf.lit(privateKey), $rdf.sym(privateKeyUrl)));
+          if (publicKey) del.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'PublicKey'), $rdf.lit(publicKey), $rdf.sym(publicKeyUrl)));
+          privateKey = generatePrivateKey();
+          publicKey = generatePublicKey(privateKey);
+          /* debug.log('newPrivateKey-1 ' + privateKey)
+          debug.log('newPublicKey-1 ' + publicKey) */
+          add.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'PrivateKey'), $rdf.literal(privateKey), $rdf.sym(privateKeyUrl)));
+          add.push($rdf.st($rdf.sym(webId), $rdf.sym(_signature.CERT + 'PublicKey'), $rdf.literal(publicKey), $rdf.sym(publicKeyUrl)));
+          _context3.next = 20;
           return _solidLogic.store.updater.updateMany(del, add);
-        case 17:
-          return _context2.abrupt("return", privateKey.uri);
-        case 18:
+        case 20:
+          return _context3.abrupt("return", privateKey);
+        case 21:
         case "end":
-          return _context2.stop();
+          return _context3.stop();
       }
-    }, _callee2);
+    }, _callee3);
   }));
   return _getPrivateKey.apply(this, arguments);
 }
@@ -4277,21 +4334,46 @@ function renderMessageRow(channelObject, message, fresh, options, userContext) {
   var creator = _solidLogic.store.any(message, ns.foaf('maker'));
   var date = _solidLogic.store.any(message, ns.dct('created'));
   var latestVersion = (0, _chatLogic.mostRecentVersion)(message);
-  var content = _solidLogic.store.any(latestVersion, ns.sioc('content'));
-  var signature = _solidLogic.store.any(message, $rdf.sym("".concat(_signature.SEC, "Proof")));
+  var latestVersionCreator = _solidLogic.store.any(latestVersion, ns.foaf('maker'));
+  // use latest content if same owner, else use original
+  var msgId = creator.uri === latestVersionCreator.uri ? latestVersion : message;
+  var content = _solidLogic.store.any(msgId, ns.sioc('content'));
+  var signature = _solidLogic.store.any(msgId, $rdf.sym("".concat(_signature.SEC, "Proof")));
+  debug.log('alain ' + (signature === null || signature === void 0 ? void 0 : signature.value));
 
   // verify signature
   var msg = (0, _signature.getBlankMsg)();
-  msg.id = message;
-  msg.created = date;
-  // this is not correct.
-  // If the message has been edited/deleted we must verify the latest message and may be the intermediate ones
-  msg.content = content;
-  msg.maker = creator;
-
-  // pubKey could be store in a cache for all makers
-  var pubKey = (0, _keys.getPublicKey)(creator); // alain no
-  if (!(0, _signature.verifySignature)(signature, msg, pubKey)) throw new Error();
+  msg.id = msgId.uri;
+  msg.created = _solidLogic.store.any(msgId, ns.dct('created')).value;
+  msg.content = content.value;
+  msg.maker = creator.uri;
+  try {
+    var publicKey = function publicKey(webId) {
+      var pubKey;
+      (0, _keys.getPublicKey)(webId).then(function (publicKey) {
+        debug.log('alain publicKey ' + publicKey);
+        pubKey = publicKey;
+      });
+      return pubKey;
+    };
+    var pubKey = publicKey(creator.uri); // await getPublicKey(creator.uri)
+    debug.log('alain pubKey ' + pubKey);
+    debug.log(creator.uri);
+  } catch (err) {
+    debug.warn(err);
+  }
+  try {
+    // pubKey could be store in a cache for all makers
+    /* const pubKey0 = '023a9da707bee1302f66083c9d95673ff969b41607a66f52686fa774d64ceb87'
+    debug.warn('publicKeys\n' + pubKey0 + '\n' + pubKey)
+    const privKey0 = getPrivateKey(creator.uri) // alain to remove
+    // unsigned messages should be signaled as unsecured
+    debug.warn(msg)
+    debug.warn(signature?.value) */
+    if (signature !== null && signature !== void 0 && signature.value && !(0, _signature.verifySignature)(signature.value, msg, pubKey)) throw new Error('invalid signature');
+  } catch (err) {
+    debug.log(err);
+  }
   var originalMessage = (0, _chatLogic.originalVersion)(message);
   var edited = !message.sameTerm(originalMessage);
   var sortDate = _solidLogic.store.the(originalMessage, ns.dct('created'), null, originalMessage.doc()); // In message
@@ -5105,7 +5187,7 @@ var utf8Encoder = new TextEncoder();
 exports.utf8Encoder = utf8Encoder;
 var SEC = 'https://w3id.org/security#'; // Proof, VerificationMethod
 exports.SEC = SEC;
-var CERT = 'http://www.w3.org/ns/auth/cert#'; // PrivatKey, PublicKey
+var CERT = 'http://www.w3.org/ns/auth/cert#'; // PrivateKey, PublicKey
 
 /* eslint-disable no-unused-vars */
 /* export enum Kind {
@@ -13238,8 +13320,8 @@ Object.defineProperty(exports, "__esModule", ({
 }));
 exports.versionInfo = void 0;
 var versionInfo = {
-  buildTime: '2023-04-19T18:00:23Z',
-  commit: '9d7e618ee7fcecf32422bd474b50a9bd5f142647',
+  buildTime: '2023-04-25T08:53:43Z',
+  commit: '9f7a01da36a7e5e6b71dafcecf7bc9393366980e',
   npmInfo: {
     'solid-ui': '2.4.27',
     npm: '8.19.4',
@@ -25402,6 +25484,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _inrupt_oidc_client__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @inrupt/oidc-client */ "./node_modules/@inrupt/oidc-client/lib/oidc-client.min.js");
 /* harmony import */ var _inrupt_oidc_client__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_inrupt_oidc_client__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _inrupt_solid_client_authn_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @inrupt/solid-client-authn-core */ "./node_modules/@inrupt/solid-client-authn-core/dist/index.mjs");
+/* harmony import */ var _inrupt_universal_fetch__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @inrupt/universal-fetch */ "./node_modules/@inrupt/universal-fetch/dist/index-browser.mjs");
+
 
 
 
@@ -25555,7 +25639,7 @@ async function getTokens(issuer, client, data, dpop) {
         headers,
         body: new URLSearchParams(requestBody).toString(),
     };
-    const rawTokenResponse = await await fetch(issuer.tokenEndpoint, tokenRequestInit);
+    const rawTokenResponse = await (0,_inrupt_universal_fetch__WEBPACK_IMPORTED_MODULE_2__.fetch)(issuer.tokenEndpoint, tokenRequestInit);
     const jsonTokenResponse = (await rawTokenResponse.json());
     const tokenResponse = validateTokenEndpointResponse(jsonTokenResponse, dpop);
     const webId = await (0,_inrupt_solid_client_authn_core__WEBPACK_IMPORTED_MODULE_1__.getWebidFromTokenPayload)(tokenResponse.id_token, issuer.jwksUri, issuer.issuer, client.clientId);
@@ -25639,7 +25723,7 @@ async function refresh(refreshToken, issuer, client, dpopKey) {
     else if (isValidUrl(client.clientId)) {
         requestBody.client_id = client.clientId;
     }
-    const rawResponse = await fetch(issuer.tokenEndpoint, {
+    const rawResponse = await (0,_inrupt_universal_fetch__WEBPACK_IMPORTED_MODULE_2__.fetch)(issuer.tokenEndpoint, {
         method: "POST",
         body: new URLSearchParams(requestBody).toString(),
         headers: {
@@ -25754,8 +25838,9 @@ e.read=function(t,e,r,n,i){var o,s,a=8*i-n-1,u=(1<<a)-1,c=u>>1,h=-7,l=r?i-1:0,f=
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const solid_client_authn_core_1 = __webpack_require__(/*! @inrupt/solid-client-authn-core */ "./node_modules/@inrupt/solid-client-authn-core/dist/index.js");
+const universal_fetch_1 = __webpack_require__(/*! @inrupt/universal-fetch */ "./node_modules/@inrupt/universal-fetch/dist/index-browser.js");
 const oidc_client_ext_1 = __webpack_require__(/*! @inrupt/oidc-client-ext */ "./node_modules/@inrupt/oidc-client-ext/dist/index.es.js");
-const globalFetch = (request, init) => window.fetch(request, init);
+const globalFetch = (request, init) => (0, universal_fetch_1.fetch)(request, init);
 class ClientAuthentication {
     constructor(loginHandler, redirectHandler, logoutHandler, sessionInfoManager, issuerConfigFetcher) {
         this.loginHandler = loginHandler;
@@ -26249,6 +26334,7 @@ exports["default"] = ClientRegistrar;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.WELL_KNOWN_OPENID_CONFIG = void 0;
 const solid_client_authn_core_1 = __webpack_require__(/*! @inrupt/solid-client-authn-core */ "./node_modules/@inrupt/solid-client-authn-core/dist/index.js");
+const universal_fetch_1 = __webpack_require__(/*! @inrupt/universal-fetch */ "./node_modules/@inrupt/universal-fetch/dist/index-browser.js");
 exports.WELL_KNOWN_OPENID_CONFIG = ".well-known/openid-configuration";
 const issuerConfigKeyMap = {
     issuer: {
@@ -26355,7 +26441,7 @@ class IssuerConfigFetcher {
     async fetchConfig(issuer) {
         let issuerConfig;
         const openIdConfigUrl = new URL(exports.WELL_KNOWN_OPENID_CONFIG, issuer.endsWith("/") ? issuer : `${issuer}/`).href;
-        const issuerConfigRequestBody = await window.fetch(openIdConfigUrl);
+        const issuerConfigRequestBody = await (0, universal_fetch_1.fetch)(openIdConfigUrl);
         try {
             issuerConfig = processConfig(await issuerConfigRequestBody.json());
         }
@@ -26458,6 +26544,7 @@ exports["default"] = Redirector;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AuthCodeRedirectHandler = void 0;
+const universal_fetch_1 = __webpack_require__(/*! @inrupt/universal-fetch */ "./node_modules/@inrupt/universal-fetch/dist/index-browser.js");
 const solid_client_authn_core_1 = __webpack_require__(/*! @inrupt/solid-client-authn-core */ "./node_modules/@inrupt/solid-client-authn-core/dist/index.js");
 const oidc_client_ext_1 = __webpack_require__(/*! @inrupt/oidc-client-ext */ "./node_modules/@inrupt/oidc-client-ext/dist/index.es.js");
 class AuthCodeRedirectHandler {
@@ -26521,7 +26608,7 @@ class AuthCodeRedirectHandler {
                 tokenRefresher: this.tokerRefresher,
             };
         }
-        const authFetch = await (0, solid_client_authn_core_1.buildAuthenticatedFetch)(fetch, tokens.accessToken, {
+        const authFetch = await (0, solid_client_authn_core_1.buildAuthenticatedFetch)(universal_fetch_1.fetch, tokens.accessToken, {
             dpopKey: tokens.dpopKey,
             refreshOptions,
             eventEmitter,
@@ -26759,11 +26846,12 @@ exports.SessionInfoManager = exports.clear = exports.getUnauthenticatedSession =
 const solid_client_authn_core_1 = __webpack_require__(/*! @inrupt/solid-client-authn-core */ "./node_modules/@inrupt/solid-client-authn-core/dist/index.js");
 const uuid_1 = __webpack_require__(/*! uuid */ "./node_modules/@inrupt/solid-client-authn-browser/node_modules/uuid/dist/commonjs-browser/index.js");
 const oidc_client_ext_1 = __webpack_require__(/*! @inrupt/oidc-client-ext */ "./node_modules/@inrupt/oidc-client-ext/dist/index.es.js");
+const universal_fetch_1 = __webpack_require__(/*! @inrupt/universal-fetch */ "./node_modules/@inrupt/universal-fetch/dist/index-browser.js");
 function getUnauthenticatedSession() {
     return {
         isLoggedIn: false,
         sessionId: (0, uuid_1.v4)(),
-        fetch,
+        fetch: universal_fetch_1.fetch,
     };
 }
 exports.getUnauthenticatedSession = getUnauthenticatedSession;
@@ -27916,513 +28004,513 @@ exports["default"] = _default;
 
 
 var events = __webpack_require__(/*! events */ "./node_modules/events/events.js");
-var crossFetch = __webpack_require__(/*! cross-fetch */ "./node_modules/cross-fetch/dist/browser-ponyfill.js");
+var universalFetch = __webpack_require__(/*! @inrupt/universal-fetch */ "./node_modules/@inrupt/universal-fetch/dist/index-browser.js");
 var jose = __webpack_require__(/*! jose */ "./node_modules/jose/dist/browser/index.js");
 var uuid = __webpack_require__(/*! uuid */ "./node_modules/@inrupt/solid-client-authn-core/node_modules/uuid/dist/commonjs-browser/index.js");
 
-const SOLID_CLIENT_AUTHN_KEY_PREFIX = "solidClientAuthn:";
-const PREFERRED_SIGNING_ALG = ["ES256", "RS256"];
-const EVENTS = {
-    ERROR: "error",
-    LOGIN: "login",
-    LOGOUT: "logout",
-    NEW_REFRESH_TOKEN: "newRefreshToken",
-    SESSION_EXPIRED: "sessionExpired",
-    SESSION_EXTENDED: "sessionExtended",
-    SESSION_RESTORED: "sessionRestore",
-    TIMEOUT_SET: "timeoutSet",
-};
-const REFRESH_BEFORE_EXPIRATION_SECONDS = 5;
-const SCOPE_OPENID = "openid";
-const SCOPE_OFFLINE = "offline_access";
-const SCOPE_WEBID = "webid";
+const SOLID_CLIENT_AUTHN_KEY_PREFIX = "solidClientAuthn:";
+const PREFERRED_SIGNING_ALG = ["ES256", "RS256"];
+const EVENTS = {
+    ERROR: "error",
+    LOGIN: "login",
+    LOGOUT: "logout",
+    NEW_REFRESH_TOKEN: "newRefreshToken",
+    SESSION_EXPIRED: "sessionExpired",
+    SESSION_EXTENDED: "sessionExtended",
+    SESSION_RESTORED: "sessionRestore",
+    TIMEOUT_SET: "timeoutSet",
+};
+const REFRESH_BEFORE_EXPIRATION_SECONDS = 5;
+const SCOPE_OPENID = "openid";
+const SCOPE_OFFLINE = "offline_access";
+const SCOPE_WEBID = "webid";
 const DEFAULT_SCOPES = [SCOPE_OPENID, SCOPE_OFFLINE, SCOPE_WEBID].join(" ");
 
-const buildProxyHandler = (toExclude, errorMessage) => ({
-    get(target, prop, receiver) {
-        if (!Object.getOwnPropertyNames(events.EventEmitter).includes(prop) &&
-            Object.getOwnPropertyNames(toExclude).includes(prop)) {
-            throw new Error(`${errorMessage}: [${prop}] is not supported`);
-        }
-        return Reflect.get(target, prop, receiver);
-    },
+const buildProxyHandler = (toExclude, errorMessage) => ({
+    get(target, prop, receiver) {
+        if (!Object.getOwnPropertyNames(events.EventEmitter).includes(prop) &&
+            Object.getOwnPropertyNames(toExclude).includes(prop)) {
+            throw new Error(`${errorMessage}: [${prop}] is not supported`);
+        }
+        return Reflect.get(target, prop, receiver);
+    },
 });
 
-class AggregateHandler {
-    constructor(handleables) {
-        this.handleables = handleables;
-    }
-    async getProperHandler(params) {
-        const canHandleList = await Promise.all(this.handleables.map((handleable) => handleable.canHandle(...params)));
-        for (let i = 0; i < canHandleList.length; i += 1) {
-            if (canHandleList[i]) {
-                return this.handleables[i];
-            }
-        }
-        return null;
-    }
-    async canHandle(...params) {
-        return (await this.getProperHandler(params)) !== null;
-    }
-    async handle(...params) {
-        const handler = await this.getProperHandler(params);
-        if (handler) {
-            return handler.handle(...params);
-        }
-        throw new Error(`[${this.constructor.name}] cannot find a suitable handler for: ${params
-            .map((param) => {
-            try {
-                return JSON.stringify(param);
-            }
-            catch (err) {
-                return param.toString();
-            }
-        })
-            .join(", ")}`);
-    }
+class AggregateHandler {
+    constructor(handleables) {
+        this.handleables = handleables;
+    }
+    async getProperHandler(params) {
+        const canHandleList = await Promise.all(this.handleables.map((handleable) => handleable.canHandle(...params)));
+        for (let i = 0; i < canHandleList.length; i += 1) {
+            if (canHandleList[i]) {
+                return this.handleables[i];
+            }
+        }
+        return null;
+    }
+    async canHandle(...params) {
+        return (await this.getProperHandler(params)) !== null;
+    }
+    async handle(...params) {
+        const handler = await this.getProperHandler(params);
+        if (handler) {
+            return handler.handle(...params);
+        }
+        throw new Error(`[${this.constructor.name}] cannot find a suitable handler for: ${params
+            .map((param) => {
+            try {
+                return JSON.stringify(param);
+            }
+            catch (err) {
+                return param.toString();
+            }
+        })
+            .join(", ")}`);
+    }
 }
 
-async function fetchJwks(jwksIri, issuerIri) {
-    const jwksResponse = await crossFetch.fetch(jwksIri);
-    if (jwksResponse.status !== 200) {
-        throw new Error(`Could not fetch JWKS for [${issuerIri}] at [${jwksIri}]: ${jwksResponse.status} ${jwksResponse.statusText}`);
-    }
-    let jwk;
-    try {
-        jwk = (await jwksResponse.json()).keys[0];
-    }
-    catch (e) {
-        throw new Error(`Malformed JWKS for [${issuerIri}] at [${jwksIri}]: ${e.message}`);
-    }
-    return jwk;
-}
-async function getWebidFromTokenPayload(idToken, jwksIri, issuerIri, clientId) {
-    const jwk = await fetchJwks(jwksIri, issuerIri);
-    let payload;
-    try {
-        const { payload: verifiedPayload } = await jose.jwtVerify(idToken, await jose.importJWK(jwk), {
-            issuer: issuerIri,
-            audience: clientId,
-        });
-        payload = verifiedPayload;
-    }
-    catch (e) {
-        throw new Error(`Token verification failed: ${e.stack}`);
-    }
-    if (typeof payload.webid === "string") {
-        return payload.webid;
-    }
-    if (typeof payload.sub !== "string") {
-        throw new Error(`The token ${JSON.stringify(payload)} is invalid: it has no 'webid' claim and no 'sub' claim.`);
-    }
-    try {
-        new URL(payload.sub);
-        return payload.sub;
-    }
-    catch (e) {
-        throw new Error(`The token has no 'webid' claim, and its 'sub' claim of [${payload.sub}] is invalid as a URL - error [${e}].`);
-    }
+async function fetchJwks(jwksIri, issuerIri) {
+    const jwksResponse = await universalFetch.fetch(jwksIri);
+    if (jwksResponse.status !== 200) {
+        throw new Error(`Could not fetch JWKS for [${issuerIri}] at [${jwksIri}]: ${jwksResponse.status} ${jwksResponse.statusText}`);
+    }
+    let jwk;
+    try {
+        jwk = (await jwksResponse.json()).keys[0];
+    }
+    catch (e) {
+        throw new Error(`Malformed JWKS for [${issuerIri}] at [${jwksIri}]: ${e.message}`);
+    }
+    return jwk;
+}
+async function getWebidFromTokenPayload(idToken, jwksIri, issuerIri, clientId) {
+    const jwk = await fetchJwks(jwksIri, issuerIri);
+    let payload;
+    try {
+        const { payload: verifiedPayload } = await jose.jwtVerify(idToken, await jose.importJWK(jwk), {
+            issuer: issuerIri,
+            audience: clientId,
+        });
+        payload = verifiedPayload;
+    }
+    catch (e) {
+        throw new Error(`Token verification failed: ${e.stack}`);
+    }
+    if (typeof payload.webid === "string") {
+        return payload.webid;
+    }
+    if (typeof payload.sub !== "string") {
+        throw new Error(`The token ${JSON.stringify(payload)} is invalid: it has no 'webid' claim and no 'sub' claim.`);
+    }
+    try {
+        new URL(payload.sub);
+        return payload.sub;
+    }
+    catch (e) {
+        throw new Error(`The token has no 'webid' claim, and its 'sub' claim of [${payload.sub}] is invalid as a URL - error [${e}].`);
+    }
 }
 
-function isValidRedirectUrl(redirectUrl) {
-    try {
-        const urlObject = new URL(redirectUrl);
-        return urlObject.hash === "";
-    }
-    catch (e) {
-        return false;
-    }
+function isValidRedirectUrl(redirectUrl) {
+    try {
+        const urlObject = new URL(redirectUrl);
+        return urlObject.hash === "";
+    }
+    catch (e) {
+        return false;
+    }
 }
 
-function isSupportedTokenType(token) {
-    return typeof token === "string" && ["DPoP", "Bearer"].includes(token);
+function isSupportedTokenType(token) {
+    return typeof token === "string" && ["DPoP", "Bearer"].includes(token);
 }
 
 const USER_SESSION_PREFIX = "solidClientAuthenticationUser";
 
-function isValidUrl(url) {
-    try {
-        new URL(url);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-function determineSigningAlg(supported, preferred) {
-    var _a;
-    return ((_a = preferred.find((signingAlg) => {
-        return supported.includes(signingAlg);
-    })) !== null && _a !== void 0 ? _a : null);
-}
-function determineClientType(options, issuerConfig) {
-    if (options.clientId !== undefined && !isValidUrl(options.clientId)) {
-        return "static";
-    }
-    if (issuerConfig.scopesSupported.includes("webid") &&
-        options.clientId !== undefined &&
-        isValidUrl(options.clientId)) {
-        return "solid-oidc";
-    }
-    return "dynamic";
-}
-async function handleRegistration(options, issuerConfig, storageUtility, clientRegistrar) {
-    const clientType = determineClientType(options, issuerConfig);
-    if (clientType === "dynamic") {
-        return clientRegistrar.getClient({
-            sessionId: options.sessionId,
-            clientName: options.clientName,
-            redirectUrl: options.redirectUrl,
-        }, issuerConfig);
-    }
-    await storageUtility.setForUser(options.sessionId, {
-        clientId: options.clientId,
-    });
-    if (options.clientSecret) {
-        await storageUtility.setForUser(options.sessionId, {
-            clientSecret: options.clientSecret,
-        });
-    }
-    if (options.clientName) {
-        await storageUtility.setForUser(options.sessionId, {
-            clientName: options.clientName,
-        });
-    }
-    return {
-        clientId: options.clientId,
-        clientSecret: options.clientSecret,
-        clientName: options.clientName,
-        clientType,
-    };
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function determineSigningAlg(supported, preferred) {
+    var _a;
+    return ((_a = preferred.find((signingAlg) => {
+        return supported.includes(signingAlg);
+    })) !== null && _a !== void 0 ? _a : null);
+}
+function determineClientType(options, issuerConfig) {
+    if (options.clientId !== undefined && !isValidUrl(options.clientId)) {
+        return "static";
+    }
+    if (issuerConfig.scopesSupported.includes("webid") &&
+        options.clientId !== undefined &&
+        isValidUrl(options.clientId)) {
+        return "solid-oidc";
+    }
+    return "dynamic";
+}
+async function handleRegistration(options, issuerConfig, storageUtility, clientRegistrar) {
+    const clientType = determineClientType(options, issuerConfig);
+    if (clientType === "dynamic") {
+        return clientRegistrar.getClient({
+            sessionId: options.sessionId,
+            clientName: options.clientName,
+            redirectUrl: options.redirectUrl,
+        }, issuerConfig);
+    }
+    await storageUtility.setForUser(options.sessionId, {
+        clientId: options.clientId,
+    });
+    if (options.clientSecret) {
+        await storageUtility.setForUser(options.sessionId, {
+            clientSecret: options.clientSecret,
+        });
+    }
+    if (options.clientName) {
+        await storageUtility.setForUser(options.sessionId, {
+            clientName: options.clientName,
+        });
+    }
+    return {
+        clientId: options.clientId,
+        clientSecret: options.clientSecret,
+        clientName: options.clientName,
+        clientType,
+    };
 }
 
-async function getSessionIdFromOauthState(storageUtility, oauthState) {
-    return storageUtility.getForUser(oauthState, "sessionId");
-}
-async function loadOidcContextFromStorage(sessionId, storageUtility, configFetcher) {
-    try {
-        const [issuerIri, codeVerifier, storedRedirectIri, dpop] = await Promise.all([
-            storageUtility.getForUser(sessionId, "issuer", {
-                errorIfNull: true,
-            }),
-            storageUtility.getForUser(sessionId, "codeVerifier"),
-            storageUtility.getForUser(sessionId, "redirectUrl"),
-            storageUtility.getForUser(sessionId, "dpop", { errorIfNull: true }),
-        ]);
-        await storageUtility.deleteForUser(sessionId, "codeVerifier");
-        const issuerConfig = await configFetcher.fetchConfig(issuerIri);
-        return {
-            codeVerifier,
-            redirectUrl: storedRedirectIri,
-            issuerConfig,
-            dpop: dpop === "true",
-        };
-    }
-    catch (e) {
-        throw new Error(`Failed to retrieve OIDC context from storage associated with session [${sessionId}]: ${e}`);
-    }
-}
-async function saveSessionInfoToStorage(storageUtility, sessionId, webId, isLoggedIn, refreshToken, secure, dpopKey) {
-    if (refreshToken !== undefined) {
-        await storageUtility.setForUser(sessionId, { refreshToken }, { secure });
-    }
-    if (webId !== undefined) {
-        await storageUtility.setForUser(sessionId, { webId }, { secure });
-    }
-    if (isLoggedIn !== undefined) {
-        await storageUtility.setForUser(sessionId, { isLoggedIn }, { secure });
-    }
-    if (dpopKey !== undefined) {
-        await storageUtility.setForUser(sessionId, {
-            publicKey: JSON.stringify(dpopKey.publicKey),
-            privateKey: JSON.stringify(await jose.exportJWK(dpopKey.privateKey)),
-        }, { secure });
-    }
-}
-class StorageUtility {
-    constructor(secureStorage, insecureStorage) {
-        this.secureStorage = secureStorage;
-        this.insecureStorage = insecureStorage;
-    }
-    getKey(userId) {
-        return `solidClientAuthenticationUser:${userId}`;
-    }
-    async getUserData(userId, secure) {
-        const stored = await (secure
-            ? this.secureStorage
-            : this.insecureStorage).get(this.getKey(userId));
-        if (stored === undefined) {
-            return {};
-        }
-        try {
-            return JSON.parse(stored);
-        }
-        catch (err) {
-            throw new Error(`Data for user [${userId}] in [${secure ? "secure" : "unsecure"}] storage is corrupted - expected valid JSON, but got: ${stored}`);
-        }
-    }
-    async setUserData(userId, data, secure) {
-        await (secure ? this.secureStorage : this.insecureStorage).set(this.getKey(userId), JSON.stringify(data));
-    }
-    async get(key, options) {
-        const value = await ((options === null || options === void 0 ? void 0 : options.secure)
-            ? this.secureStorage
-            : this.insecureStorage).get(key);
-        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
-            throw new Error(`[${key}] is not stored`);
-        }
-        return value;
-    }
-    async set(key, value, options) {
-        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).set(key, value);
-    }
-    async delete(key, options) {
-        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(key);
-    }
-    async getForUser(userId, key, options) {
-        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
-        let value;
-        if (!userData || !userData[key]) {
-            value = undefined;
-        }
-        value = userData[key];
-        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
-            throw new Error(`Field [${key}] for user [${userId}] is not stored`);
-        }
-        return value || undefined;
-    }
-    async setForUser(userId, values, options) {
-        let userData;
-        try {
-            userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
-        }
-        catch (_a) {
-            userData = {};
-        }
-        await this.setUserData(userId, { ...userData, ...values }, options === null || options === void 0 ? void 0 : options.secure);
-    }
-    async deleteForUser(userId, key, options) {
-        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
-        delete userData[key];
-        await this.setUserData(userId, userData, options === null || options === void 0 ? void 0 : options.secure);
-    }
-    async deleteAllUserData(userId, options) {
-        await ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(this.getKey(userId));
-    }
+async function getSessionIdFromOauthState(storageUtility, oauthState) {
+    return storageUtility.getForUser(oauthState, "sessionId");
+}
+async function loadOidcContextFromStorage(sessionId, storageUtility, configFetcher) {
+    try {
+        const [issuerIri, codeVerifier, storedRedirectIri, dpop] = await Promise.all([
+            storageUtility.getForUser(sessionId, "issuer", {
+                errorIfNull: true,
+            }),
+            storageUtility.getForUser(sessionId, "codeVerifier"),
+            storageUtility.getForUser(sessionId, "redirectUrl"),
+            storageUtility.getForUser(sessionId, "dpop", { errorIfNull: true }),
+        ]);
+        await storageUtility.deleteForUser(sessionId, "codeVerifier");
+        const issuerConfig = await configFetcher.fetchConfig(issuerIri);
+        return {
+            codeVerifier,
+            redirectUrl: storedRedirectIri,
+            issuerConfig,
+            dpop: dpop === "true",
+        };
+    }
+    catch (e) {
+        throw new Error(`Failed to retrieve OIDC context from storage associated with session [${sessionId}]: ${e}`);
+    }
+}
+async function saveSessionInfoToStorage(storageUtility, sessionId, webId, isLoggedIn, refreshToken, secure, dpopKey) {
+    if (refreshToken !== undefined) {
+        await storageUtility.setForUser(sessionId, { refreshToken }, { secure });
+    }
+    if (webId !== undefined) {
+        await storageUtility.setForUser(sessionId, { webId }, { secure });
+    }
+    if (isLoggedIn !== undefined) {
+        await storageUtility.setForUser(sessionId, { isLoggedIn }, { secure });
+    }
+    if (dpopKey !== undefined) {
+        await storageUtility.setForUser(sessionId, {
+            publicKey: JSON.stringify(dpopKey.publicKey),
+            privateKey: JSON.stringify(await jose.exportJWK(dpopKey.privateKey)),
+        }, { secure });
+    }
+}
+class StorageUtility {
+    constructor(secureStorage, insecureStorage) {
+        this.secureStorage = secureStorage;
+        this.insecureStorage = insecureStorage;
+    }
+    getKey(userId) {
+        return `solidClientAuthenticationUser:${userId}`;
+    }
+    async getUserData(userId, secure) {
+        const stored = await (secure
+            ? this.secureStorage
+            : this.insecureStorage).get(this.getKey(userId));
+        if (stored === undefined) {
+            return {};
+        }
+        try {
+            return JSON.parse(stored);
+        }
+        catch (err) {
+            throw new Error(`Data for user [${userId}] in [${secure ? "secure" : "unsecure"}] storage is corrupted - expected valid JSON, but got: ${stored}`);
+        }
+    }
+    async setUserData(userId, data, secure) {
+        await (secure ? this.secureStorage : this.insecureStorage).set(this.getKey(userId), JSON.stringify(data));
+    }
+    async get(key, options) {
+        const value = await ((options === null || options === void 0 ? void 0 : options.secure)
+            ? this.secureStorage
+            : this.insecureStorage).get(key);
+        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
+            throw new Error(`[${key}] is not stored`);
+        }
+        return value;
+    }
+    async set(key, value, options) {
+        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).set(key, value);
+    }
+    async delete(key, options) {
+        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(key);
+    }
+    async getForUser(userId, key, options) {
+        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
+        let value;
+        if (!userData || !userData[key]) {
+            value = undefined;
+        }
+        value = userData[key];
+        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
+            throw new Error(`Field [${key}] for user [${userId}] is not stored`);
+        }
+        return value || undefined;
+    }
+    async setForUser(userId, values, options) {
+        let userData;
+        try {
+            userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
+        }
+        catch (_a) {
+            userData = {};
+        }
+        await this.setUserData(userId, { ...userData, ...values }, options === null || options === void 0 ? void 0 : options.secure);
+    }
+    async deleteForUser(userId, key, options) {
+        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
+        delete userData[key];
+        await this.setUserData(userId, userData, options === null || options === void 0 ? void 0 : options.secure);
+    }
+    async deleteAllUserData(userId, options) {
+        await ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(this.getKey(userId));
+    }
 }
 
-class InMemoryStorage {
-    constructor() {
-        this.map = {};
-    }
-    async get(key) {
-        return this.map[key] || undefined;
-    }
-    async set(key, value) {
-        this.map[key] = value;
-    }
-    async delete(key) {
-        delete this.map[key];
-    }
+class InMemoryStorage {
+    constructor() {
+        this.map = {};
+    }
+    async get(key) {
+        return this.map[key] || undefined;
+    }
+    async set(key, value) {
+        this.map[key] = value;
+    }
+    async delete(key) {
+        delete this.map[key];
+    }
 }
 
-class ConfigurationError extends Error {
-    constructor(message) {
-        super(message);
-    }
+class ConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+    }
 }
 
-class NotImplementedError extends Error {
-    constructor(methodName) {
-        super(`[${methodName}] is not implemented`);
-    }
+class NotImplementedError extends Error {
+    constructor(methodName) {
+        super(`[${methodName}] is not implemented`);
+    }
 }
 
-class InvalidResponseError extends Error {
-    constructor(missingFields) {
-        super(`Invalid response from OIDC provider: missing fields ${missingFields}`);
-        this.missingFields = missingFields;
-    }
+class InvalidResponseError extends Error {
+    constructor(missingFields) {
+        super(`Invalid response from OIDC provider: missing fields ${missingFields}`);
+        this.missingFields = missingFields;
+    }
 }
 
-class OidcProviderError extends Error {
-    constructor(message, error, errorDescription) {
-        super(message);
-        this.error = error;
-        this.errorDescription = errorDescription;
-    }
+class OidcProviderError extends Error {
+    constructor(message, error, errorDescription) {
+        super(message);
+        this.error = error;
+        this.errorDescription = errorDescription;
+    }
 }
 
-function normalizeHTU(audience) {
-    const audienceUrl = new URL(audience);
-    return new URL(audienceUrl.pathname, audienceUrl.origin).toString();
-}
-async function createDpopHeader(audience, method, dpopKey) {
-    return new jose.SignJWT({
-        htu: normalizeHTU(audience),
-        htm: method.toUpperCase(),
-        jti: uuid.v4(),
-    })
-        .setProtectedHeader({
-        alg: PREFERRED_SIGNING_ALG[0],
-        jwk: dpopKey.publicKey,
-        typ: "dpop+jwt",
-    })
-        .setIssuedAt()
-        .sign(dpopKey.privateKey, {});
-}
-async function generateDpopKeyPair() {
-    const { privateKey, publicKey } = await jose.generateKeyPair(PREFERRED_SIGNING_ALG[0]);
-    const dpopKeyPair = {
-        privateKey,
-        publicKey: await jose.exportJWK(publicKey),
-    };
-    [dpopKeyPair.publicKey.alg] = PREFERRED_SIGNING_ALG;
-    return dpopKeyPair;
+function normalizeHTU(audience) {
+    const audienceUrl = new URL(audience);
+    return new URL(audienceUrl.pathname, audienceUrl.origin).toString();
+}
+async function createDpopHeader(audience, method, dpopKey) {
+    return new jose.SignJWT({
+        htu: normalizeHTU(audience),
+        htm: method.toUpperCase(),
+        jti: uuid.v4(),
+    })
+        .setProtectedHeader({
+        alg: PREFERRED_SIGNING_ALG[0],
+        jwk: dpopKey.publicKey,
+        typ: "dpop+jwt",
+    })
+        .setIssuedAt()
+        .sign(dpopKey.privateKey, {});
+}
+async function generateDpopKeyPair() {
+    const { privateKey, publicKey } = await jose.generateKeyPair(PREFERRED_SIGNING_ALG[0]);
+    const dpopKeyPair = {
+        privateKey,
+        publicKey: await jose.exportJWK(publicKey),
+    };
+    [dpopKeyPair.publicKey.alg] = PREFERRED_SIGNING_ALG;
+    return dpopKeyPair;
 }
 
-const DEFAULT_EXPIRATION_TIME_SECONDS = 600;
-function isExpectedAuthError(statusCode) {
-    return [401, 403].includes(statusCode);
-}
-async function buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions) {
-    var _a;
-    const headers = new crossFetch.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
-    headers.set("Authorization", `DPoP ${authToken}`);
-    headers.set("DPoP", await createDpopHeader(targetUrl, (_a = defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.method) !== null && _a !== void 0 ? _a : "get", dpopKey));
-    return {
-        ...defaultOptions,
-        headers,
-    };
-}
-async function buildAuthenticatedHeaders(targetUrl, authToken, dpopKey, defaultOptions) {
-    if (dpopKey !== undefined) {
-        return buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions);
-    }
-    const headers = new crossFetch.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
-    headers.set("Authorization", `Bearer ${authToken}`);
-    return {
-        ...defaultOptions,
-        headers,
-    };
-}
-async function makeAuthenticatedRequest(unauthFetch, accessToken, url, defaultRequestInit, dpopKey) {
-    return unauthFetch(url, await buildAuthenticatedHeaders(url.toString(), accessToken, dpopKey, defaultRequestInit));
-}
-async function refreshAccessToken(refreshOptions, dpopKey, eventEmitter) {
-    var _a;
-    const tokenSet = await refreshOptions.tokenRefresher.refresh(refreshOptions.sessionId, refreshOptions.refreshToken, dpopKey);
-    eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.SESSION_EXTENDED, (_a = tokenSet.expiresIn) !== null && _a !== void 0 ? _a : DEFAULT_EXPIRATION_TIME_SECONDS);
-    if (typeof tokenSet.refreshToken === "string") {
-        eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.NEW_REFRESH_TOKEN, tokenSet.refreshToken);
-    }
-    return {
-        accessToken: tokenSet.accessToken,
-        refreshToken: tokenSet.refreshToken,
-        expiresIn: tokenSet.expiresIn,
-    };
-}
-const computeRefreshDelay = (expiresIn) => {
-    if (expiresIn !== undefined) {
-        return expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS > 0
-            ?
-                expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS
-            : expiresIn;
-    }
-    return DEFAULT_EXPIRATION_TIME_SECONDS;
-};
-async function buildAuthenticatedFetch(unauthFetch, accessToken, options) {
-    var _a;
-    let currentAccessToken = accessToken;
-    let latestTimeout;
-    const currentRefreshOptions = options === null || options === void 0 ? void 0 : options.refreshOptions;
-    if (currentRefreshOptions !== undefined) {
-        const proactivelyRefreshToken = async () => {
-            var _a, _b, _c, _d;
-            try {
-                const { accessToken: refreshedAccessToken, refreshToken, expiresIn, } = await refreshAccessToken(currentRefreshOptions, options.dpopKey, options.eventEmitter);
-                currentAccessToken = refreshedAccessToken;
-                if (refreshToken !== undefined) {
-                    currentRefreshOptions.refreshToken = refreshToken;
-                }
-                clearTimeout(latestTimeout);
-                latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(expiresIn) * 1000);
-                (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
-            }
-            catch (e) {
-                if (e instanceof OidcProviderError) {
-                    (_b = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _b === void 0 ? void 0 : _b.emit(EVENTS.ERROR, e.error, e.errorDescription);
-                    (_c = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _c === void 0 ? void 0 : _c.emit(EVENTS.SESSION_EXPIRED);
-                }
-                if (e instanceof InvalidResponseError &&
-                    e.missingFields.includes("access_token")) {
-                    (_d = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _d === void 0 ? void 0 : _d.emit(EVENTS.SESSION_EXPIRED);
-                }
-            }
-        };
-        latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(options.expiresIn) * 1000);
-        (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
-    }
-    else if (options !== undefined && options.eventEmitter !== undefined) {
-        const expirationTimeout = setTimeout(() => {
-            options.eventEmitter.emit(EVENTS.SESSION_EXPIRED);
-        }, computeRefreshDelay(options.expiresIn) * 1000);
-        options.eventEmitter.emit(EVENTS.TIMEOUT_SET, expirationTimeout);
-    }
-    return async (url, requestInit) => {
-        let response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, url, requestInit, options === null || options === void 0 ? void 0 : options.dpopKey);
-        const failedButNotExpectedAuthError = !response.ok && !isExpectedAuthError(response.status);
-        if (response.ok || failedButNotExpectedAuthError) {
-            return response;
-        }
-        const hasBeenRedirected = response.url !== url;
-        if (hasBeenRedirected && (options === null || options === void 0 ? void 0 : options.dpopKey) !== undefined) {
-            response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, response.url, requestInit, options.dpopKey);
-        }
-        return response;
-    };
+const DEFAULT_EXPIRATION_TIME_SECONDS = 600;
+function isExpectedAuthError(statusCode) {
+    return [401, 403].includes(statusCode);
+}
+async function buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions) {
+    var _a;
+    const headers = new universalFetch.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
+    headers.set("Authorization", `DPoP ${authToken}`);
+    headers.set("DPoP", await createDpopHeader(targetUrl, (_a = defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.method) !== null && _a !== void 0 ? _a : "get", dpopKey));
+    return {
+        ...defaultOptions,
+        headers,
+    };
+}
+async function buildAuthenticatedHeaders(targetUrl, authToken, dpopKey, defaultOptions) {
+    if (dpopKey !== undefined) {
+        return buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions);
+    }
+    const headers = new universalFetch.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
+    headers.set("Authorization", `Bearer ${authToken}`);
+    return {
+        ...defaultOptions,
+        headers,
+    };
+}
+async function makeAuthenticatedRequest(unauthFetch, accessToken, url, defaultRequestInit, dpopKey) {
+    return unauthFetch(url, await buildAuthenticatedHeaders(url.toString(), accessToken, dpopKey, defaultRequestInit));
+}
+async function refreshAccessToken(refreshOptions, dpopKey, eventEmitter) {
+    var _a;
+    const tokenSet = await refreshOptions.tokenRefresher.refresh(refreshOptions.sessionId, refreshOptions.refreshToken, dpopKey);
+    eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.SESSION_EXTENDED, (_a = tokenSet.expiresIn) !== null && _a !== void 0 ? _a : DEFAULT_EXPIRATION_TIME_SECONDS);
+    if (typeof tokenSet.refreshToken === "string") {
+        eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.NEW_REFRESH_TOKEN, tokenSet.refreshToken);
+    }
+    return {
+        accessToken: tokenSet.accessToken,
+        refreshToken: tokenSet.refreshToken,
+        expiresIn: tokenSet.expiresIn,
+    };
+}
+const computeRefreshDelay = (expiresIn) => {
+    if (expiresIn !== undefined) {
+        return expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS > 0
+            ?
+                expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS
+            : expiresIn;
+    }
+    return DEFAULT_EXPIRATION_TIME_SECONDS;
+};
+async function buildAuthenticatedFetch(unauthFetch, accessToken, options) {
+    var _a;
+    let currentAccessToken = accessToken;
+    let latestTimeout;
+    const currentRefreshOptions = options === null || options === void 0 ? void 0 : options.refreshOptions;
+    if (currentRefreshOptions !== undefined) {
+        const proactivelyRefreshToken = async () => {
+            var _a, _b, _c, _d;
+            try {
+                const { accessToken: refreshedAccessToken, refreshToken, expiresIn, } = await refreshAccessToken(currentRefreshOptions, options.dpopKey, options.eventEmitter);
+                currentAccessToken = refreshedAccessToken;
+                if (refreshToken !== undefined) {
+                    currentRefreshOptions.refreshToken = refreshToken;
+                }
+                clearTimeout(latestTimeout);
+                latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(expiresIn) * 1000);
+                (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
+            }
+            catch (e) {
+                if (e instanceof OidcProviderError) {
+                    (_b = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _b === void 0 ? void 0 : _b.emit(EVENTS.ERROR, e.error, e.errorDescription);
+                    (_c = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _c === void 0 ? void 0 : _c.emit(EVENTS.SESSION_EXPIRED);
+                }
+                if (e instanceof InvalidResponseError &&
+                    e.missingFields.includes("access_token")) {
+                    (_d = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _d === void 0 ? void 0 : _d.emit(EVENTS.SESSION_EXPIRED);
+                }
+            }
+        };
+        latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(options.expiresIn) * 1000);
+        (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
+    }
+    else if (options !== undefined && options.eventEmitter !== undefined) {
+        const expirationTimeout = setTimeout(() => {
+            options.eventEmitter.emit(EVENTS.SESSION_EXPIRED);
+        }, computeRefreshDelay(options.expiresIn) * 1000);
+        options.eventEmitter.emit(EVENTS.TIMEOUT_SET, expirationTimeout);
+    }
+    return async (url, requestInit) => {
+        let response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, url, requestInit, options === null || options === void 0 ? void 0 : options.dpopKey);
+        const failedButNotExpectedAuthError = !response.ok && !isExpectedAuthError(response.status);
+        if (response.ok || failedButNotExpectedAuthError) {
+            return response;
+        }
+        const hasBeenRedirected = response.url !== url;
+        if (hasBeenRedirected && (options === null || options === void 0 ? void 0 : options.dpopKey) !== undefined) {
+            response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, response.url, requestInit, options.dpopKey);
+        }
+        return response;
+    };
 }
 
-const StorageUtilityGetResponse = "getResponse";
-const StorageUtilityMock = {
-    get: async (key, options) => StorageUtilityGetResponse,
-    set: async (key, value) => {
-    },
-    delete: async (key) => {
-    },
-    getForUser: async (userId, key, options) => StorageUtilityGetResponse,
-    setForUser: async (userId, values, options) => {
-    },
-    deleteForUser: async (userId, key, options) => {
-    },
-    deleteAllUserData: async (userId, options) => {
-    },
-};
-const mockStorage = (stored) => {
-    const store = stored;
-    return {
-        get: async (key) => {
-            if (store[key] === undefined) {
-                return undefined;
-            }
-            if (typeof store[key] === "string") {
-                return store[key];
-            }
-            return JSON.stringify(store[key]);
-        },
-        set: async (key, value) => {
-            store[key] = value;
-        },
-        delete: async (key) => {
-            delete store[key];
-        },
-    };
-};
-const mockStorageUtility = (stored, isSecure = false) => {
-    if (isSecure) {
-        return new StorageUtility(mockStorage(stored), mockStorage({}));
-    }
-    return new StorageUtility(mockStorage({}), mockStorage(stored));
+const StorageUtilityGetResponse = "getResponse";
+const StorageUtilityMock = {
+    get: async (key, options) => StorageUtilityGetResponse,
+    set: async (key, value) => {
+    },
+    delete: async (key) => {
+    },
+    getForUser: async (userId, key, options) => StorageUtilityGetResponse,
+    setForUser: async (userId, values, options) => {
+    },
+    deleteForUser: async (userId, key, options) => {
+    },
+    deleteAllUserData: async (userId, options) => {
+    },
+};
+const mockStorage = (stored) => {
+    const store = stored;
+    return {
+        get: async (key) => {
+            if (store[key] === undefined) {
+                return undefined;
+            }
+            if (typeof store[key] === "string") {
+                return store[key];
+            }
+            return JSON.stringify(store[key]);
+        },
+        set: async (key, value) => {
+            store[key] = value;
+        },
+        delete: async (key) => {
+            delete store[key];
+        },
+    };
+};
+const mockStorageUtility = (stored, isSecure = false) => {
+    if (isSecure) {
+        return new StorageUtility(mockStorage(stored), mockStorage({}));
+    }
+    return new StorageUtility(mockStorage({}), mockStorage(stored));
 };
 
 exports.AggregateHandler = AggregateHandler;
@@ -29646,6 +29734,29 @@ function validate(uuid) {
 
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (validate);
 
+/***/ }),
+
+/***/ "./node_modules/@inrupt/universal-fetch/dist/index-browser.js":
+/*!********************************************************************!*\
+  !*** ./node_modules/@inrupt/universal-fetch/dist/index-browser.js ***!
+  \********************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+var indexBrowser = globalThis.fetch;
+const { fetch, Response, Request, Headers } = globalThis;
+
+exports.Headers = Headers;
+exports.Request = Request;
+exports.Response = Response;
+exports["default"] = indexBrowser;
+exports.fetch = fetch;
+
+
 /***/ }),
 
 /***/ "./node_modules/@noble/curves/_shortw_utils.js":
@@ -60290,518 +60401,541 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "saveSessionInfoToStorage": () => (/* binding */ saveSessionInfoToStorage)
 /* harmony export */ });
 /* harmony import */ var events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! events */ "./node_modules/events/events.js");
-/* harmony import */ var cross_fetch__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! cross-fetch */ "./node_modules/cross-fetch/dist/browser-ponyfill.js");
-/* harmony import */ var jose__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! jose */ "./node_modules/jose/dist/browser/index.js");
+/* harmony import */ var _inrupt_universal_fetch__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @inrupt/universal-fetch */ "./node_modules/@inrupt/universal-fetch/dist/index-browser.mjs");
+/* harmony import */ var jose__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! jose */ "./node_modules/jose/dist/browser/index.js");
 /* harmony import */ var uuid__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! uuid */ "./node_modules/@inrupt/solid-client-authn-core/node_modules/uuid/dist/esm-browser/v4.js");
 
 
 
 
 
-const SOLID_CLIENT_AUTHN_KEY_PREFIX = "solidClientAuthn:";
-const PREFERRED_SIGNING_ALG = ["ES256", "RS256"];
-const EVENTS = {
-    ERROR: "error",
-    LOGIN: "login",
-    LOGOUT: "logout",
-    NEW_REFRESH_TOKEN: "newRefreshToken",
-    SESSION_EXPIRED: "sessionExpired",
-    SESSION_EXTENDED: "sessionExtended",
-    SESSION_RESTORED: "sessionRestore",
-    TIMEOUT_SET: "timeoutSet",
-};
-const REFRESH_BEFORE_EXPIRATION_SECONDS = 5;
-const SCOPE_OPENID = "openid";
-const SCOPE_OFFLINE = "offline_access";
-const SCOPE_WEBID = "webid";
+const SOLID_CLIENT_AUTHN_KEY_PREFIX = "solidClientAuthn:";
+const PREFERRED_SIGNING_ALG = ["ES256", "RS256"];
+const EVENTS = {
+    ERROR: "error",
+    LOGIN: "login",
+    LOGOUT: "logout",
+    NEW_REFRESH_TOKEN: "newRefreshToken",
+    SESSION_EXPIRED: "sessionExpired",
+    SESSION_EXTENDED: "sessionExtended",
+    SESSION_RESTORED: "sessionRestore",
+    TIMEOUT_SET: "timeoutSet",
+};
+const REFRESH_BEFORE_EXPIRATION_SECONDS = 5;
+const SCOPE_OPENID = "openid";
+const SCOPE_OFFLINE = "offline_access";
+const SCOPE_WEBID = "webid";
 const DEFAULT_SCOPES = [SCOPE_OPENID, SCOPE_OFFLINE, SCOPE_WEBID].join(" ");
 
-const buildProxyHandler = (toExclude, errorMessage) => ({
-    get(target, prop, receiver) {
-        if (!Object.getOwnPropertyNames(events__WEBPACK_IMPORTED_MODULE_0__.EventEmitter).includes(prop) &&
-            Object.getOwnPropertyNames(toExclude).includes(prop)) {
-            throw new Error(`${errorMessage}: [${prop}] is not supported`);
-        }
-        return Reflect.get(target, prop, receiver);
-    },
+const buildProxyHandler = (toExclude, errorMessage) => ({
+    get(target, prop, receiver) {
+        if (!Object.getOwnPropertyNames(events__WEBPACK_IMPORTED_MODULE_0__.EventEmitter).includes(prop) &&
+            Object.getOwnPropertyNames(toExclude).includes(prop)) {
+            throw new Error(`${errorMessage}: [${prop}] is not supported`);
+        }
+        return Reflect.get(target, prop, receiver);
+    },
 });
 
-class AggregateHandler {
-    constructor(handleables) {
-        this.handleables = handleables;
-    }
-    async getProperHandler(params) {
-        const canHandleList = await Promise.all(this.handleables.map((handleable) => handleable.canHandle(...params)));
-        for (let i = 0; i < canHandleList.length; i += 1) {
-            if (canHandleList[i]) {
-                return this.handleables[i];
-            }
-        }
-        return null;
-    }
-    async canHandle(...params) {
-        return (await this.getProperHandler(params)) !== null;
-    }
-    async handle(...params) {
-        const handler = await this.getProperHandler(params);
-        if (handler) {
-            return handler.handle(...params);
-        }
-        throw new Error(`[${this.constructor.name}] cannot find a suitable handler for: ${params
-            .map((param) => {
-            try {
-                return JSON.stringify(param);
-            }
-            catch (err) {
-                return param.toString();
-            }
-        })
-            .join(", ")}`);
-    }
+class AggregateHandler {
+    constructor(handleables) {
+        this.handleables = handleables;
+    }
+    async getProperHandler(params) {
+        const canHandleList = await Promise.all(this.handleables.map((handleable) => handleable.canHandle(...params)));
+        for (let i = 0; i < canHandleList.length; i += 1) {
+            if (canHandleList[i]) {
+                return this.handleables[i];
+            }
+        }
+        return null;
+    }
+    async canHandle(...params) {
+        return (await this.getProperHandler(params)) !== null;
+    }
+    async handle(...params) {
+        const handler = await this.getProperHandler(params);
+        if (handler) {
+            return handler.handle(...params);
+        }
+        throw new Error(`[${this.constructor.name}] cannot find a suitable handler for: ${params
+            .map((param) => {
+            try {
+                return JSON.stringify(param);
+            }
+            catch (err) {
+                return param.toString();
+            }
+        })
+            .join(", ")}`);
+    }
 }
 
-async function fetchJwks(jwksIri, issuerIri) {
-    const jwksResponse = await (0,cross_fetch__WEBPACK_IMPORTED_MODULE_1__.fetch)(jwksIri);
-    if (jwksResponse.status !== 200) {
-        throw new Error(`Could not fetch JWKS for [${issuerIri}] at [${jwksIri}]: ${jwksResponse.status} ${jwksResponse.statusText}`);
-    }
-    let jwk;
-    try {
-        jwk = (await jwksResponse.json()).keys[0];
-    }
-    catch (e) {
-        throw new Error(`Malformed JWKS for [${issuerIri}] at [${jwksIri}]: ${e.message}`);
-    }
-    return jwk;
-}
-async function getWebidFromTokenPayload(idToken, jwksIri, issuerIri, clientId) {
-    const jwk = await fetchJwks(jwksIri, issuerIri);
-    let payload;
-    try {
-        const { payload: verifiedPayload } = await (0,jose__WEBPACK_IMPORTED_MODULE_2__.jwtVerify)(idToken, await (0,jose__WEBPACK_IMPORTED_MODULE_2__.importJWK)(jwk), {
-            issuer: issuerIri,
-            audience: clientId,
-        });
-        payload = verifiedPayload;
-    }
-    catch (e) {
-        throw new Error(`Token verification failed: ${e.stack}`);
-    }
-    if (typeof payload.webid === "string") {
-        return payload.webid;
-    }
-    if (typeof payload.sub !== "string") {
-        throw new Error(`The token ${JSON.stringify(payload)} is invalid: it has no 'webid' claim and no 'sub' claim.`);
-    }
-    try {
-        new URL(payload.sub);
-        return payload.sub;
-    }
-    catch (e) {
-        throw new Error(`The token has no 'webid' claim, and its 'sub' claim of [${payload.sub}] is invalid as a URL - error [${e}].`);
-    }
+async function fetchJwks(jwksIri, issuerIri) {
+    const jwksResponse = await (0,_inrupt_universal_fetch__WEBPACK_IMPORTED_MODULE_2__.fetch)(jwksIri);
+    if (jwksResponse.status !== 200) {
+        throw new Error(`Could not fetch JWKS for [${issuerIri}] at [${jwksIri}]: ${jwksResponse.status} ${jwksResponse.statusText}`);
+    }
+    let jwk;
+    try {
+        jwk = (await jwksResponse.json()).keys[0];
+    }
+    catch (e) {
+        throw new Error(`Malformed JWKS for [${issuerIri}] at [${jwksIri}]: ${e.message}`);
+    }
+    return jwk;
+}
+async function getWebidFromTokenPayload(idToken, jwksIri, issuerIri, clientId) {
+    const jwk = await fetchJwks(jwksIri, issuerIri);
+    let payload;
+    try {
+        const { payload: verifiedPayload } = await (0,jose__WEBPACK_IMPORTED_MODULE_1__.jwtVerify)(idToken, await (0,jose__WEBPACK_IMPORTED_MODULE_1__.importJWK)(jwk), {
+            issuer: issuerIri,
+            audience: clientId,
+        });
+        payload = verifiedPayload;
+    }
+    catch (e) {
+        throw new Error(`Token verification failed: ${e.stack}`);
+    }
+    if (typeof payload.webid === "string") {
+        return payload.webid;
+    }
+    if (typeof payload.sub !== "string") {
+        throw new Error(`The token ${JSON.stringify(payload)} is invalid: it has no 'webid' claim and no 'sub' claim.`);
+    }
+    try {
+        new URL(payload.sub);
+        return payload.sub;
+    }
+    catch (e) {
+        throw new Error(`The token has no 'webid' claim, and its 'sub' claim of [${payload.sub}] is invalid as a URL - error [${e}].`);
+    }
 }
 
-function isValidRedirectUrl(redirectUrl) {
-    try {
-        const urlObject = new URL(redirectUrl);
-        return urlObject.hash === "";
-    }
-    catch (e) {
-        return false;
-    }
+function isValidRedirectUrl(redirectUrl) {
+    try {
+        const urlObject = new URL(redirectUrl);
+        return urlObject.hash === "";
+    }
+    catch (e) {
+        return false;
+    }
 }
 
-function isSupportedTokenType(token) {
-    return typeof token === "string" && ["DPoP", "Bearer"].includes(token);
+function isSupportedTokenType(token) {
+    return typeof token === "string" && ["DPoP", "Bearer"].includes(token);
 }
 
 const USER_SESSION_PREFIX = "solidClientAuthenticationUser";
 
-function isValidUrl(url) {
-    try {
-        new URL(url);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-function determineSigningAlg(supported, preferred) {
-    var _a;
-    return ((_a = preferred.find((signingAlg) => {
-        return supported.includes(signingAlg);
-    })) !== null && _a !== void 0 ? _a : null);
-}
-function determineClientType(options, issuerConfig) {
-    if (options.clientId !== undefined && !isValidUrl(options.clientId)) {
-        return "static";
-    }
-    if (issuerConfig.scopesSupported.includes("webid") &&
-        options.clientId !== undefined &&
-        isValidUrl(options.clientId)) {
-        return "solid-oidc";
-    }
-    return "dynamic";
-}
-async function handleRegistration(options, issuerConfig, storageUtility, clientRegistrar) {
-    const clientType = determineClientType(options, issuerConfig);
-    if (clientType === "dynamic") {
-        return clientRegistrar.getClient({
-            sessionId: options.sessionId,
-            clientName: options.clientName,
-            redirectUrl: options.redirectUrl,
-        }, issuerConfig);
-    }
-    await storageUtility.setForUser(options.sessionId, {
-        clientId: options.clientId,
-    });
-    if (options.clientSecret) {
-        await storageUtility.setForUser(options.sessionId, {
-            clientSecret: options.clientSecret,
-        });
-    }
-    if (options.clientName) {
-        await storageUtility.setForUser(options.sessionId, {
-            clientName: options.clientName,
-        });
-    }
-    return {
-        clientId: options.clientId,
-        clientSecret: options.clientSecret,
-        clientName: options.clientName,
-        clientType,
-    };
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function determineSigningAlg(supported, preferred) {
+    var _a;
+    return ((_a = preferred.find((signingAlg) => {
+        return supported.includes(signingAlg);
+    })) !== null && _a !== void 0 ? _a : null);
+}
+function determineClientType(options, issuerConfig) {
+    if (options.clientId !== undefined && !isValidUrl(options.clientId)) {
+        return "static";
+    }
+    if (issuerConfig.scopesSupported.includes("webid") &&
+        options.clientId !== undefined &&
+        isValidUrl(options.clientId)) {
+        return "solid-oidc";
+    }
+    return "dynamic";
+}
+async function handleRegistration(options, issuerConfig, storageUtility, clientRegistrar) {
+    const clientType = determineClientType(options, issuerConfig);
+    if (clientType === "dynamic") {
+        return clientRegistrar.getClient({
+            sessionId: options.sessionId,
+            clientName: options.clientName,
+            redirectUrl: options.redirectUrl,
+        }, issuerConfig);
+    }
+    await storageUtility.setForUser(options.sessionId, {
+        clientId: options.clientId,
+    });
+    if (options.clientSecret) {
+        await storageUtility.setForUser(options.sessionId, {
+            clientSecret: options.clientSecret,
+        });
+    }
+    if (options.clientName) {
+        await storageUtility.setForUser(options.sessionId, {
+            clientName: options.clientName,
+        });
+    }
+    return {
+        clientId: options.clientId,
+        clientSecret: options.clientSecret,
+        clientName: options.clientName,
+        clientType,
+    };
 }
 
-async function getSessionIdFromOauthState(storageUtility, oauthState) {
-    return storageUtility.getForUser(oauthState, "sessionId");
-}
-async function loadOidcContextFromStorage(sessionId, storageUtility, configFetcher) {
-    try {
-        const [issuerIri, codeVerifier, storedRedirectIri, dpop] = await Promise.all([
-            storageUtility.getForUser(sessionId, "issuer", {
-                errorIfNull: true,
-            }),
-            storageUtility.getForUser(sessionId, "codeVerifier"),
-            storageUtility.getForUser(sessionId, "redirectUrl"),
-            storageUtility.getForUser(sessionId, "dpop", { errorIfNull: true }),
-        ]);
-        await storageUtility.deleteForUser(sessionId, "codeVerifier");
-        const issuerConfig = await configFetcher.fetchConfig(issuerIri);
-        return {
-            codeVerifier,
-            redirectUrl: storedRedirectIri,
-            issuerConfig,
-            dpop: dpop === "true",
-        };
-    }
-    catch (e) {
-        throw new Error(`Failed to retrieve OIDC context from storage associated with session [${sessionId}]: ${e}`);
-    }
-}
-async function saveSessionInfoToStorage(storageUtility, sessionId, webId, isLoggedIn, refreshToken, secure, dpopKey) {
-    if (refreshToken !== undefined) {
-        await storageUtility.setForUser(sessionId, { refreshToken }, { secure });
-    }
-    if (webId !== undefined) {
-        await storageUtility.setForUser(sessionId, { webId }, { secure });
-    }
-    if (isLoggedIn !== undefined) {
-        await storageUtility.setForUser(sessionId, { isLoggedIn }, { secure });
-    }
-    if (dpopKey !== undefined) {
-        await storageUtility.setForUser(sessionId, {
-            publicKey: JSON.stringify(dpopKey.publicKey),
-            privateKey: JSON.stringify(await (0,jose__WEBPACK_IMPORTED_MODULE_2__.exportJWK)(dpopKey.privateKey)),
-        }, { secure });
-    }
-}
-class StorageUtility {
-    constructor(secureStorage, insecureStorage) {
-        this.secureStorage = secureStorage;
-        this.insecureStorage = insecureStorage;
-    }
-    getKey(userId) {
-        return `solidClientAuthenticationUser:${userId}`;
-    }
-    async getUserData(userId, secure) {
-        const stored = await (secure
-            ? this.secureStorage
-            : this.insecureStorage).get(this.getKey(userId));
-        if (stored === undefined) {
-            return {};
-        }
-        try {
-            return JSON.parse(stored);
-        }
-        catch (err) {
-            throw new Error(`Data for user [${userId}] in [${secure ? "secure" : "unsecure"}] storage is corrupted - expected valid JSON, but got: ${stored}`);
-        }
-    }
-    async setUserData(userId, data, secure) {
-        await (secure ? this.secureStorage : this.insecureStorage).set(this.getKey(userId), JSON.stringify(data));
-    }
-    async get(key, options) {
-        const value = await ((options === null || options === void 0 ? void 0 : options.secure)
-            ? this.secureStorage
-            : this.insecureStorage).get(key);
-        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
-            throw new Error(`[${key}] is not stored`);
-        }
-        return value;
-    }
-    async set(key, value, options) {
-        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).set(key, value);
-    }
-    async delete(key, options) {
-        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(key);
-    }
-    async getForUser(userId, key, options) {
-        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
-        let value;
-        if (!userData || !userData[key]) {
-            value = undefined;
-        }
-        value = userData[key];
-        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
-            throw new Error(`Field [${key}] for user [${userId}] is not stored`);
-        }
-        return value || undefined;
-    }
-    async setForUser(userId, values, options) {
-        let userData;
-        try {
-            userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
-        }
-        catch (_a) {
-            userData = {};
-        }
-        await this.setUserData(userId, { ...userData, ...values }, options === null || options === void 0 ? void 0 : options.secure);
-    }
-    async deleteForUser(userId, key, options) {
-        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
-        delete userData[key];
-        await this.setUserData(userId, userData, options === null || options === void 0 ? void 0 : options.secure);
-    }
-    async deleteAllUserData(userId, options) {
-        await ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(this.getKey(userId));
-    }
+async function getSessionIdFromOauthState(storageUtility, oauthState) {
+    return storageUtility.getForUser(oauthState, "sessionId");
+}
+async function loadOidcContextFromStorage(sessionId, storageUtility, configFetcher) {
+    try {
+        const [issuerIri, codeVerifier, storedRedirectIri, dpop] = await Promise.all([
+            storageUtility.getForUser(sessionId, "issuer", {
+                errorIfNull: true,
+            }),
+            storageUtility.getForUser(sessionId, "codeVerifier"),
+            storageUtility.getForUser(sessionId, "redirectUrl"),
+            storageUtility.getForUser(sessionId, "dpop", { errorIfNull: true }),
+        ]);
+        await storageUtility.deleteForUser(sessionId, "codeVerifier");
+        const issuerConfig = await configFetcher.fetchConfig(issuerIri);
+        return {
+            codeVerifier,
+            redirectUrl: storedRedirectIri,
+            issuerConfig,
+            dpop: dpop === "true",
+        };
+    }
+    catch (e) {
+        throw new Error(`Failed to retrieve OIDC context from storage associated with session [${sessionId}]: ${e}`);
+    }
+}
+async function saveSessionInfoToStorage(storageUtility, sessionId, webId, isLoggedIn, refreshToken, secure, dpopKey) {
+    if (refreshToken !== undefined) {
+        await storageUtility.setForUser(sessionId, { refreshToken }, { secure });
+    }
+    if (webId !== undefined) {
+        await storageUtility.setForUser(sessionId, { webId }, { secure });
+    }
+    if (isLoggedIn !== undefined) {
+        await storageUtility.setForUser(sessionId, { isLoggedIn }, { secure });
+    }
+    if (dpopKey !== undefined) {
+        await storageUtility.setForUser(sessionId, {
+            publicKey: JSON.stringify(dpopKey.publicKey),
+            privateKey: JSON.stringify(await (0,jose__WEBPACK_IMPORTED_MODULE_1__.exportJWK)(dpopKey.privateKey)),
+        }, { secure });
+    }
+}
+class StorageUtility {
+    constructor(secureStorage, insecureStorage) {
+        this.secureStorage = secureStorage;
+        this.insecureStorage = insecureStorage;
+    }
+    getKey(userId) {
+        return `solidClientAuthenticationUser:${userId}`;
+    }
+    async getUserData(userId, secure) {
+        const stored = await (secure
+            ? this.secureStorage
+            : this.insecureStorage).get(this.getKey(userId));
+        if (stored === undefined) {
+            return {};
+        }
+        try {
+            return JSON.parse(stored);
+        }
+        catch (err) {
+            throw new Error(`Data for user [${userId}] in [${secure ? "secure" : "unsecure"}] storage is corrupted - expected valid JSON, but got: ${stored}`);
+        }
+    }
+    async setUserData(userId, data, secure) {
+        await (secure ? this.secureStorage : this.insecureStorage).set(this.getKey(userId), JSON.stringify(data));
+    }
+    async get(key, options) {
+        const value = await ((options === null || options === void 0 ? void 0 : options.secure)
+            ? this.secureStorage
+            : this.insecureStorage).get(key);
+        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
+            throw new Error(`[${key}] is not stored`);
+        }
+        return value;
+    }
+    async set(key, value, options) {
+        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).set(key, value);
+    }
+    async delete(key, options) {
+        return ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(key);
+    }
+    async getForUser(userId, key, options) {
+        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
+        let value;
+        if (!userData || !userData[key]) {
+            value = undefined;
+        }
+        value = userData[key];
+        if (value === undefined && (options === null || options === void 0 ? void 0 : options.errorIfNull)) {
+            throw new Error(`Field [${key}] for user [${userId}] is not stored`);
+        }
+        return value || undefined;
+    }
+    async setForUser(userId, values, options) {
+        let userData;
+        try {
+            userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
+        }
+        catch (_a) {
+            userData = {};
+        }
+        await this.setUserData(userId, { ...userData, ...values }, options === null || options === void 0 ? void 0 : options.secure);
+    }
+    async deleteForUser(userId, key, options) {
+        const userData = await this.getUserData(userId, options === null || options === void 0 ? void 0 : options.secure);
+        delete userData[key];
+        await this.setUserData(userId, userData, options === null || options === void 0 ? void 0 : options.secure);
+    }
+    async deleteAllUserData(userId, options) {
+        await ((options === null || options === void 0 ? void 0 : options.secure) ? this.secureStorage : this.insecureStorage).delete(this.getKey(userId));
+    }
 }
 
-class InMemoryStorage {
-    constructor() {
-        this.map = {};
-    }
-    async get(key) {
-        return this.map[key] || undefined;
-    }
-    async set(key, value) {
-        this.map[key] = value;
-    }
-    async delete(key) {
-        delete this.map[key];
-    }
+class InMemoryStorage {
+    constructor() {
+        this.map = {};
+    }
+    async get(key) {
+        return this.map[key] || undefined;
+    }
+    async set(key, value) {
+        this.map[key] = value;
+    }
+    async delete(key) {
+        delete this.map[key];
+    }
 }
 
-class ConfigurationError extends Error {
-    constructor(message) {
-        super(message);
-    }
+class ConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+    }
 }
 
-class NotImplementedError extends Error {
-    constructor(methodName) {
-        super(`[${methodName}] is not implemented`);
-    }
+class NotImplementedError extends Error {
+    constructor(methodName) {
+        super(`[${methodName}] is not implemented`);
+    }
 }
 
-class InvalidResponseError extends Error {
-    constructor(missingFields) {
-        super(`Invalid response from OIDC provider: missing fields ${missingFields}`);
-        this.missingFields = missingFields;
-    }
+class InvalidResponseError extends Error {
+    constructor(missingFields) {
+        super(`Invalid response from OIDC provider: missing fields ${missingFields}`);
+        this.missingFields = missingFields;
+    }
 }
 
-class OidcProviderError extends Error {
-    constructor(message, error, errorDescription) {
-        super(message);
-        this.error = error;
-        this.errorDescription = errorDescription;
-    }
+class OidcProviderError extends Error {
+    constructor(message, error, errorDescription) {
+        super(message);
+        this.error = error;
+        this.errorDescription = errorDescription;
+    }
 }
 
-function normalizeHTU(audience) {
-    const audienceUrl = new URL(audience);
-    return new URL(audienceUrl.pathname, audienceUrl.origin).toString();
-}
-async function createDpopHeader(audience, method, dpopKey) {
-    return new jose__WEBPACK_IMPORTED_MODULE_2__.SignJWT({
-        htu: normalizeHTU(audience),
-        htm: method.toUpperCase(),
-        jti: (0,uuid__WEBPACK_IMPORTED_MODULE_3__["default"])(),
-    })
-        .setProtectedHeader({
-        alg: PREFERRED_SIGNING_ALG[0],
-        jwk: dpopKey.publicKey,
-        typ: "dpop+jwt",
-    })
-        .setIssuedAt()
-        .sign(dpopKey.privateKey, {});
-}
-async function generateDpopKeyPair() {
-    const { privateKey, publicKey } = await (0,jose__WEBPACK_IMPORTED_MODULE_2__.generateKeyPair)(PREFERRED_SIGNING_ALG[0]);
-    const dpopKeyPair = {
-        privateKey,
-        publicKey: await (0,jose__WEBPACK_IMPORTED_MODULE_2__.exportJWK)(publicKey),
-    };
-    [dpopKeyPair.publicKey.alg] = PREFERRED_SIGNING_ALG;
-    return dpopKeyPair;
+function normalizeHTU(audience) {
+    const audienceUrl = new URL(audience);
+    return new URL(audienceUrl.pathname, audienceUrl.origin).toString();
+}
+async function createDpopHeader(audience, method, dpopKey) {
+    return new jose__WEBPACK_IMPORTED_MODULE_1__.SignJWT({
+        htu: normalizeHTU(audience),
+        htm: method.toUpperCase(),
+        jti: (0,uuid__WEBPACK_IMPORTED_MODULE_3__["default"])(),
+    })
+        .setProtectedHeader({
+        alg: PREFERRED_SIGNING_ALG[0],
+        jwk: dpopKey.publicKey,
+        typ: "dpop+jwt",
+    })
+        .setIssuedAt()
+        .sign(dpopKey.privateKey, {});
+}
+async function generateDpopKeyPair() {
+    const { privateKey, publicKey } = await (0,jose__WEBPACK_IMPORTED_MODULE_1__.generateKeyPair)(PREFERRED_SIGNING_ALG[0]);
+    const dpopKeyPair = {
+        privateKey,
+        publicKey: await (0,jose__WEBPACK_IMPORTED_MODULE_1__.exportJWK)(publicKey),
+    };
+    [dpopKeyPair.publicKey.alg] = PREFERRED_SIGNING_ALG;
+    return dpopKeyPair;
 }
 
-const DEFAULT_EXPIRATION_TIME_SECONDS = 600;
-function isExpectedAuthError(statusCode) {
-    return [401, 403].includes(statusCode);
-}
-async function buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions) {
-    var _a;
-    const headers = new cross_fetch__WEBPACK_IMPORTED_MODULE_1__.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
-    headers.set("Authorization", `DPoP ${authToken}`);
-    headers.set("DPoP", await createDpopHeader(targetUrl, (_a = defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.method) !== null && _a !== void 0 ? _a : "get", dpopKey));
-    return {
-        ...defaultOptions,
-        headers,
-    };
-}
-async function buildAuthenticatedHeaders(targetUrl, authToken, dpopKey, defaultOptions) {
-    if (dpopKey !== undefined) {
-        return buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions);
-    }
-    const headers = new cross_fetch__WEBPACK_IMPORTED_MODULE_1__.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
-    headers.set("Authorization", `Bearer ${authToken}`);
-    return {
-        ...defaultOptions,
-        headers,
-    };
-}
-async function makeAuthenticatedRequest(unauthFetch, accessToken, url, defaultRequestInit, dpopKey) {
-    return unauthFetch(url, await buildAuthenticatedHeaders(url.toString(), accessToken, dpopKey, defaultRequestInit));
-}
-async function refreshAccessToken(refreshOptions, dpopKey, eventEmitter) {
-    var _a;
-    const tokenSet = await refreshOptions.tokenRefresher.refresh(refreshOptions.sessionId, refreshOptions.refreshToken, dpopKey);
-    eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.SESSION_EXTENDED, (_a = tokenSet.expiresIn) !== null && _a !== void 0 ? _a : DEFAULT_EXPIRATION_TIME_SECONDS);
-    if (typeof tokenSet.refreshToken === "string") {
-        eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.NEW_REFRESH_TOKEN, tokenSet.refreshToken);
-    }
-    return {
-        accessToken: tokenSet.accessToken,
-        refreshToken: tokenSet.refreshToken,
-        expiresIn: tokenSet.expiresIn,
-    };
-}
-const computeRefreshDelay = (expiresIn) => {
-    if (expiresIn !== undefined) {
-        return expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS > 0
-            ?
-                expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS
-            : expiresIn;
-    }
-    return DEFAULT_EXPIRATION_TIME_SECONDS;
-};
-async function buildAuthenticatedFetch(unauthFetch, accessToken, options) {
-    var _a;
-    let currentAccessToken = accessToken;
-    let latestTimeout;
-    const currentRefreshOptions = options === null || options === void 0 ? void 0 : options.refreshOptions;
-    if (currentRefreshOptions !== undefined) {
-        const proactivelyRefreshToken = async () => {
-            var _a, _b, _c, _d;
-            try {
-                const { accessToken: refreshedAccessToken, refreshToken, expiresIn, } = await refreshAccessToken(currentRefreshOptions, options.dpopKey, options.eventEmitter);
-                currentAccessToken = refreshedAccessToken;
-                if (refreshToken !== undefined) {
-                    currentRefreshOptions.refreshToken = refreshToken;
-                }
-                clearTimeout(latestTimeout);
-                latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(expiresIn) * 1000);
-                (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
-            }
-            catch (e) {
-                if (e instanceof OidcProviderError) {
-                    (_b = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _b === void 0 ? void 0 : _b.emit(EVENTS.ERROR, e.error, e.errorDescription);
-                    (_c = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _c === void 0 ? void 0 : _c.emit(EVENTS.SESSION_EXPIRED);
-                }
-                if (e instanceof InvalidResponseError &&
-                    e.missingFields.includes("access_token")) {
-                    (_d = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _d === void 0 ? void 0 : _d.emit(EVENTS.SESSION_EXPIRED);
-                }
-            }
-        };
-        latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(options.expiresIn) * 1000);
-        (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
-    }
-    else if (options !== undefined && options.eventEmitter !== undefined) {
-        const expirationTimeout = setTimeout(() => {
-            options.eventEmitter.emit(EVENTS.SESSION_EXPIRED);
-        }, computeRefreshDelay(options.expiresIn) * 1000);
-        options.eventEmitter.emit(EVENTS.TIMEOUT_SET, expirationTimeout);
-    }
-    return async (url, requestInit) => {
-        let response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, url, requestInit, options === null || options === void 0 ? void 0 : options.dpopKey);
-        const failedButNotExpectedAuthError = !response.ok && !isExpectedAuthError(response.status);
-        if (response.ok || failedButNotExpectedAuthError) {
-            return response;
-        }
-        const hasBeenRedirected = response.url !== url;
-        if (hasBeenRedirected && (options === null || options === void 0 ? void 0 : options.dpopKey) !== undefined) {
-            response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, response.url, requestInit, options.dpopKey);
-        }
-        return response;
-    };
+const DEFAULT_EXPIRATION_TIME_SECONDS = 600;
+function isExpectedAuthError(statusCode) {
+    return [401, 403].includes(statusCode);
+}
+async function buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions) {
+    var _a;
+    const headers = new _inrupt_universal_fetch__WEBPACK_IMPORTED_MODULE_2__.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
+    headers.set("Authorization", `DPoP ${authToken}`);
+    headers.set("DPoP", await createDpopHeader(targetUrl, (_a = defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.method) !== null && _a !== void 0 ? _a : "get", dpopKey));
+    return {
+        ...defaultOptions,
+        headers,
+    };
+}
+async function buildAuthenticatedHeaders(targetUrl, authToken, dpopKey, defaultOptions) {
+    if (dpopKey !== undefined) {
+        return buildDpopFetchOptions(targetUrl, authToken, dpopKey, defaultOptions);
+    }
+    const headers = new _inrupt_universal_fetch__WEBPACK_IMPORTED_MODULE_2__.Headers(defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.headers);
+    headers.set("Authorization", `Bearer ${authToken}`);
+    return {
+        ...defaultOptions,
+        headers,
+    };
+}
+async function makeAuthenticatedRequest(unauthFetch, accessToken, url, defaultRequestInit, dpopKey) {
+    return unauthFetch(url, await buildAuthenticatedHeaders(url.toString(), accessToken, dpopKey, defaultRequestInit));
+}
+async function refreshAccessToken(refreshOptions, dpopKey, eventEmitter) {
+    var _a;
+    const tokenSet = await refreshOptions.tokenRefresher.refresh(refreshOptions.sessionId, refreshOptions.refreshToken, dpopKey);
+    eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.SESSION_EXTENDED, (_a = tokenSet.expiresIn) !== null && _a !== void 0 ? _a : DEFAULT_EXPIRATION_TIME_SECONDS);
+    if (typeof tokenSet.refreshToken === "string") {
+        eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.emit(EVENTS.NEW_REFRESH_TOKEN, tokenSet.refreshToken);
+    }
+    return {
+        accessToken: tokenSet.accessToken,
+        refreshToken: tokenSet.refreshToken,
+        expiresIn: tokenSet.expiresIn,
+    };
+}
+const computeRefreshDelay = (expiresIn) => {
+    if (expiresIn !== undefined) {
+        return expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS > 0
+            ?
+                expiresIn - REFRESH_BEFORE_EXPIRATION_SECONDS
+            : expiresIn;
+    }
+    return DEFAULT_EXPIRATION_TIME_SECONDS;
+};
+async function buildAuthenticatedFetch(unauthFetch, accessToken, options) {
+    var _a;
+    let currentAccessToken = accessToken;
+    let latestTimeout;
+    const currentRefreshOptions = options === null || options === void 0 ? void 0 : options.refreshOptions;
+    if (currentRefreshOptions !== undefined) {
+        const proactivelyRefreshToken = async () => {
+            var _a, _b, _c, _d;
+            try {
+                const { accessToken: refreshedAccessToken, refreshToken, expiresIn, } = await refreshAccessToken(currentRefreshOptions, options.dpopKey, options.eventEmitter);
+                currentAccessToken = refreshedAccessToken;
+                if (refreshToken !== undefined) {
+                    currentRefreshOptions.refreshToken = refreshToken;
+                }
+                clearTimeout(latestTimeout);
+                latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(expiresIn) * 1000);
+                (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
+            }
+            catch (e) {
+                if (e instanceof OidcProviderError) {
+                    (_b = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _b === void 0 ? void 0 : _b.emit(EVENTS.ERROR, e.error, e.errorDescription);
+                    (_c = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _c === void 0 ? void 0 : _c.emit(EVENTS.SESSION_EXPIRED);
+                }
+                if (e instanceof InvalidResponseError &&
+                    e.missingFields.includes("access_token")) {
+                    (_d = options === null || options === void 0 ? void 0 : options.eventEmitter) === null || _d === void 0 ? void 0 : _d.emit(EVENTS.SESSION_EXPIRED);
+                }
+            }
+        };
+        latestTimeout = setTimeout(proactivelyRefreshToken, computeRefreshDelay(options.expiresIn) * 1000);
+        (_a = options.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit(EVENTS.TIMEOUT_SET, latestTimeout);
+    }
+    else if (options !== undefined && options.eventEmitter !== undefined) {
+        const expirationTimeout = setTimeout(() => {
+            options.eventEmitter.emit(EVENTS.SESSION_EXPIRED);
+        }, computeRefreshDelay(options.expiresIn) * 1000);
+        options.eventEmitter.emit(EVENTS.TIMEOUT_SET, expirationTimeout);
+    }
+    return async (url, requestInit) => {
+        let response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, url, requestInit, options === null || options === void 0 ? void 0 : options.dpopKey);
+        const failedButNotExpectedAuthError = !response.ok && !isExpectedAuthError(response.status);
+        if (response.ok || failedButNotExpectedAuthError) {
+            return response;
+        }
+        const hasBeenRedirected = response.url !== url;
+        if (hasBeenRedirected && (options === null || options === void 0 ? void 0 : options.dpopKey) !== undefined) {
+            response = await makeAuthenticatedRequest(unauthFetch, currentAccessToken, response.url, requestInit, options.dpopKey);
+        }
+        return response;
+    };
 }
 
-const StorageUtilityGetResponse = "getResponse";
-const StorageUtilityMock = {
-    get: async (key, options) => StorageUtilityGetResponse,
-    set: async (key, value) => {
-    },
-    delete: async (key) => {
-    },
-    getForUser: async (userId, key, options) => StorageUtilityGetResponse,
-    setForUser: async (userId, values, options) => {
-    },
-    deleteForUser: async (userId, key, options) => {
-    },
-    deleteAllUserData: async (userId, options) => {
-    },
-};
-const mockStorage = (stored) => {
-    const store = stored;
-    return {
-        get: async (key) => {
-            if (store[key] === undefined) {
-                return undefined;
-            }
-            if (typeof store[key] === "string") {
-                return store[key];
-            }
-            return JSON.stringify(store[key]);
-        },
-        set: async (key, value) => {
-            store[key] = value;
-        },
-        delete: async (key) => {
-            delete store[key];
-        },
-    };
-};
-const mockStorageUtility = (stored, isSecure = false) => {
-    if (isSecure) {
-        return new StorageUtility(mockStorage(stored), mockStorage({}));
-    }
-    return new StorageUtility(mockStorage({}), mockStorage(stored));
+const StorageUtilityGetResponse = "getResponse";
+const StorageUtilityMock = {
+    get: async (key, options) => StorageUtilityGetResponse,
+    set: async (key, value) => {
+    },
+    delete: async (key) => {
+    },
+    getForUser: async (userId, key, options) => StorageUtilityGetResponse,
+    setForUser: async (userId, values, options) => {
+    },
+    deleteForUser: async (userId, key, options) => {
+    },
+    deleteAllUserData: async (userId, options) => {
+    },
 };
+const mockStorage = (stored) => {
+    const store = stored;
+    return {
+        get: async (key) => {
+            if (store[key] === undefined) {
+                return undefined;
+            }
+            if (typeof store[key] === "string") {
+                return store[key];
+            }
+            return JSON.stringify(store[key]);
+        },
+        set: async (key, value) => {
+            store[key] = value;
+        },
+        delete: async (key) => {
+            delete store[key];
+        },
+    };
+};
+const mockStorageUtility = (stored, isSecure = false) => {
+    if (isSecure) {
+        return new StorageUtility(mockStorage(stored), mockStorage({}));
+    }
+    return new StorageUtility(mockStorage({}), mockStorage(stored));
+};
+
+
+
+
+/***/ }),
+
+/***/ "./node_modules/@inrupt/universal-fetch/dist/index-browser.mjs":
+/*!*********************************************************************!*\
+  !*** ./node_modules/@inrupt/universal-fetch/dist/index-browser.mjs ***!
+  \*********************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Headers": () => (/* binding */ Headers),
+/* harmony export */   "Request": () => (/* binding */ Request),
+/* harmony export */   "Response": () => (/* binding */ Response),
+/* harmony export */   "default": () => (/* binding */ indexBrowser),
+/* harmony export */   "fetch": () => (/* binding */ fetch)
+/* harmony export */ });
+var indexBrowser = globalThis.fetch;
+const { fetch, Response, Request, Headers } = globalThis;