@inrupt/solid-client-authn-browser 1.17.5 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inrupt/solid-client-authn-browser",
-  "version": "1.17.5",
+  "version": "2.0.0",
   "license": "MIT",
   "types": "dist/index.d.ts",
   "browser": "dist/index.js",
@@ -25,19 +25,18 @@
     "build-docs-preview-site": "npm run build-api-docs; cd docs/api; make html"
   },
   "devDependencies": {
-    "@types/node": "^20.6.0",
+    "@types/node": "^20.10.3",
     "@types/uuid": "^9.0.4"
   },
   "dependencies": {
-    "@inrupt/oidc-client-ext": "^1.17.5",
-    "@inrupt/solid-client-authn-core": "^1.17.5",
-    "@inrupt/universal-fetch": "^1.0.2",
+    "@inrupt/oidc-client-ext": "^2.0.0",
+    "@inrupt/solid-client-authn-core": "^2.0.0",
     "events": "^3.3.0",
-    "jose": "^4.15.4",
+    "jose": "^5.1.3",
     "uuid": "^9.0.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a34357598cc218be116e38f66a983e391dc1d6b2"
+  "gitHead": "80d9c4b81829762cabbd5ffc1564636efe45000c"
 }

package/rollup.config.mjs

@@ -1,16 +1,30 @@
-// The following is only possible from Node 18 onwards
-// import pkg from "./package.json" assert { type: "json" };
+//
+// Copyright Inrupt Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+// Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
 
-// Until we only support Node 18+, this should be used instead
-// (see https://rollupjs.org/guide/en/#importing-packagejson)
-import { createRequire } from "node:module";
-import { nodeResolve } from '@rollup/plugin-node-resolve';
-import commonjs from '@rollup/plugin-commonjs';
-import terser from '@rollup/plugin-terser';
-import createConfig, { createSharedConfig } from '@inrupt/base-rollup-config';
-
-const require = createRequire(import.meta.url);
-const pkg = require("./package.json");
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import terser from "@rollup/plugin-terser";
+import createConfig, { createSharedConfig } from "@inrupt/base-rollup-config";
+// eslint-disable-next-line import/extensions
+import pkg from "./package.json" assert { type: "json" };
 
 export default [
   ...createConfig(pkg),
@@ -35,12 +49,12 @@ export default [
         browser: true,
         // Bundles in the events library from the node_modules
         // rather than trying to use the node events library
-        preferBuiltins: false
+        preferBuiltins: false,
       }),
       // Adds support for importing cjs libraries such as the 'events' library
       commonjs(),
       // Minifies the browser bundle
       terser(),
-    ]
+    ],
   },
 ];

package/src/ClientAuthentication.spec.ts

@@ -37,9 +37,6 @@ import {
   mockLogoutHandler,
 } from "@inrupt/solid-client-authn-core/mocks";
 
-import { fetch } from "@inrupt/universal-fetch";
-import type * as UniversalFetch from "@inrupt/universal-fetch";
-
 import { mockLoginHandler } from "./login/__mocks__/LoginHandler";
 import {
   mockSessionInfoManager,
@@ -48,15 +45,7 @@ import {
 import ClientAuthentication from "./ClientAuthentication";
 import { mockDefaultIssuerConfigFetcher } from "./login/oidc/__mocks__/IssuerConfigFetcher";
 
-jest.mock("@inrupt/universal-fetch", () => {
-  const fetchModule = jest.requireActual(
-    "@inrupt/universal-fetch",
-  ) as typeof UniversalFetch;
-  return {
-    ...fetchModule,
-    fetch: jest.fn<typeof fetch>(),
-  };
-});
+jest.spyOn(globalThis, "fetch").mockResolvedValue(new Response());
 
 jest.mock("@inrupt/solid-client-authn-core", () => {
   const actualCoreModule = jest.requireActual(

package/src/Session.spec.ts

@@ -27,8 +27,7 @@ import {
   USER_SESSION_PREFIX,
 } from "@inrupt/solid-client-authn-core";
 import { mockStorage } from "@inrupt/solid-client-authn-core/mocks";
-import { fetch } from "@inrupt/universal-fetch";
-import type * as UniversalFetch from "@inrupt/universal-fetch";
+import { EventEmitter } from "stream";
 import { mockClientAuthentication } from "./__mocks__/ClientAuthentication";
 import { Session } from "./Session";
 import { LocalStorageMock } from "./storage/__mocks__/LocalStorage";
@@ -38,15 +37,7 @@ import type ClientAuthentication from "./ClientAuthentication";
 
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 
-jest.mock("@inrupt/universal-fetch", () => {
-  const fetchModule = jest.requireActual(
-    "@inrupt/universal-fetch",
-  ) as typeof UniversalFetch;
-  return {
-    ...fetchModule,
-    fetch: jest.fn<typeof fetch>(),
-  };
-});
+jest.spyOn(globalThis, "fetch").mockResolvedValue(new Response());
 
 const mockLocalStorage = (stored: Record<string, string>) => {
   Object.defineProperty(window, "localStorage", {
@@ -164,7 +155,7 @@ describe("Session", () => {
         expect.objectContaining({
           tokenType: "Bearer",
         }),
-        mySession,
+        mySession.events,
       );
     });
 
@@ -254,7 +245,7 @@ describe("Session", () => {
       await mySession.handleIncomingRedirect();
       expect(incomingRedirectHandler).toHaveBeenCalledWith(
         "https://some.url",
-        mySession,
+        mySession.events,
       );
     });
 
@@ -344,7 +335,10 @@ describe("Session", () => {
       const mySession = new Session({ clientAuthentication });
       await mySession.handleIncomingRedirect("https://some.url");
       expect(mySession.info.expirationDate).toBe(MOCK_TIMESTAMP + 1337);
-      mySession.emit(EVENTS.SESSION_EXTENDED, 1337 * 2);
+      (mySession.events as EventEmitter).emit(
+        EVENTS.SESSION_EXTENDED,
+        1337 * 2,
+      );
       expect(mySession.info.expirationDate).toBe(
         MOCK_TIMESTAMP + 1337 * 2 * 1000,
       );
@@ -578,10 +572,10 @@ describe("Session", () => {
         },
         expect.anything(),
       );
-      // Check that second parameter is of type session
+      // Check that second parameter is an event emitter
       expect(
         (clientAuthentication.login as any).mock.calls[0][1],
-      ).toBeInstanceOf(Session);
+      ).toBeInstanceOf(EventEmitter);
     });
 
     it("resolves handleIncomingRedirect if silent authentication could not be started", async () => {
@@ -763,154 +757,12 @@ describe("Session", () => {
       });
 
       const mySession = new Session({ clientAuthentication });
-      mySession.emit(EVENTS.SESSION_EXPIRED);
+      (mySession.events as EventEmitter).emit(EVENTS.SESSION_EXPIRED);
       // The local storage should have been cleared by the auth error
       expect(window.localStorage.getItem(KEY_CURRENT_SESSION)).toBeNull();
     });
   });
 
-  describe("legacy events handlers", () => {
-    describe("onError", () => {
-      it("calls the registered callback on error", async () => {
-        const onErrorCallback = jest.fn();
-        const mySession = new Session();
-        mySession.onError(onErrorCallback);
-        mySession.emit(EVENTS.ERROR, "error", "error_description");
-        expect(onErrorCallback).toHaveBeenCalledWith(
-          "error",
-          "error_description",
-        );
-      });
-    });
-
-    describe("onLogin", () => {
-      it("calls the registered callback on login", async () => {
-        const myCallback = jest.fn();
-        const clientAuthentication = mockClientAuthentication();
-        clientAuthentication.handleIncomingRedirect = (
-          jest.fn() as any
-        ).mockResolvedValue({
-          isLoggedIn: true,
-          sessionId: "a session ID",
-          webId: "https://some.webid#them",
-        });
-        mockLocalStorage({});
-        const mySession = new Session({ clientAuthentication });
-        mySession.onLogin(myCallback);
-        await mySession.handleIncomingRedirect("https://some.url");
-        expect(myCallback).toHaveBeenCalled();
-      });
-
-      it("does not call the registered callback if login isn't successful", async () => {
-        const failCallback = (): void => {
-          throw new Error(
-            "Should *NOT* call callback - this means test has failed!",
-          );
-        };
-        const clientAuthentication = mockClientAuthentication();
-        clientAuthentication.handleIncomingRedirect = jest.fn(
-          async (_url: string) => {
-            return {
-              isLoggedIn: false,
-              sessionId: "a session ID",
-              webId: "https://some.webid#them",
-            };
-          },
-        );
-        const mySession = new Session({ clientAuthentication });
-        mySession.onLogin(failCallback);
-        await expect(
-          mySession.handleIncomingRedirect("https://some.url"),
-        ).resolves.not.toThrow();
-      });
-
-      it("sets the appropriate information before calling the callback", async () => {
-        const clientAuthentication = mockClientAuthentication();
-        clientAuthentication.handleIncomingRedirect = jest.fn(
-          async (_url: string) => {
-            return {
-              isLoggedIn: true,
-              sessionId: "a session ID",
-              webId: "https://some.webid#them",
-            };
-          },
-        );
-        const mySession = new Session({ clientAuthentication });
-        const myCallback = jest.fn((): void => {
-          expect(mySession.info.webId).toBe("https://some.webid#them");
-        });
-        mySession.onLogin(myCallback);
-        await mySession.handleIncomingRedirect("https://some.url");
-        expect(myCallback).toHaveBeenCalled();
-        // Verify that the conditional assertion has been called
-        expect.assertions(2);
-      });
-    });
-
-    describe("onLogout", () => {
-      it("calls the registered callback on logout", async () => {
-        const myCallback = jest.fn();
-        const mySession = new Session({
-          clientAuthentication: mockClientAuthentication(),
-        });
-
-        mySession.onLogout(myCallback);
-        await mySession.logout();
-        expect(myCallback).toHaveBeenCalled();
-      });
-    });
-
-    describe("onSessionRestore", () => {
-      it("calls the registered callback on session restore", async () => {
-        // Set our window's location to our test value.
-        const defaultLocation = "https://coolSite.com/resource";
-        const currentLocation = "https://coolSite.com/redirect";
-
-        // This pretends we have previously triggered silent authentication and stored
-        // the location.
-        mockLocalStorage({
-          [KEY_CURRENT_URL]: defaultLocation,
-        });
-        // This acts as the URL the user has been redirected to.
-        mockLocation(currentLocation);
-        // This pretends the login is successful.
-        const clientAuthentication = mockClientAuthentication();
-        clientAuthentication.handleIncomingRedirect = (
-          jest.fn() as any
-        ).mockResolvedValue({
-          isLoggedIn: true,
-          sessionId: "a session ID",
-          webId: "https://some.webid#them",
-        });
-
-        const mySession = new Session({
-          clientAuthentication,
-        });
-        const myCallback = (urlBeforeRestore: string): void => {
-          expect(urlBeforeRestore).toEqual(defaultLocation);
-        };
-
-        mySession.onSessionRestore(myCallback);
-        await mySession.handleIncomingRedirect(currentLocation);
-
-        // This verifies that the callback has been called
-        expect.assertions(1);
-      });
-    });
-
-    describe("onSessionExpiration", () => {
-      it("calls the provided callback when receiving the appropriate event", async () => {
-        const myCallback = jest.fn();
-        const mySession = new Session({
-          clientAuthentication: mockClientAuthentication(),
-        });
-        mySession.onSessionExpiration(myCallback);
-        mySession.emit(EVENTS.SESSION_EXPIRED);
-        expect(myCallback).toHaveBeenCalled();
-      });
-    });
-  });
-
   describe("events.on", () => {
     describe("login", () => {
       it("calls the registered callback on login", async () => {
@@ -1017,23 +869,4 @@ describe("Session", () => {
       });
     });
   });
-
-  describe("proxies events to the session", () => {
-    // This describe block is only required as long as Session extends the EventEmitter
-    // class.
-    it("proxies the EventEmitter calls from events to the session object", () => {
-      const mySession = new Session();
-      const spiedOn = jest.spyOn(mySession, "on");
-      mySession.events.on("login", jest.fn());
-      expect(spiedOn).toHaveBeenCalled();
-    });
-
-    it("throws on calls from events which aren't part of the EventEmitter interface", () => {
-      const mySession = new Session();
-      // @ts-expect-error onLogin is a function on Session, and not SessionEventEmitter
-      expect(() => mySession.events.onLogin(jest.fn())).toThrow(
-        "[onLogin] is not supported",
-      );
-    });
-  });
 });

package/src/Session.ts

@@ -30,8 +30,7 @@ import type {
   ISessionEventListener,
   ILogoutOptions,
 } from "@inrupt/solid-client-authn-core";
-import { EVENTS, buildProxyHandler } from "@inrupt/solid-client-authn-core";
-import type { fetch } from "@inrupt/universal-fetch";
+import { EVENTS } from "@inrupt/solid-client-authn-core";
 import { v4 } from "uuid";
 import EventEmitter from "events";
 import type ClientAuthentication from "./ClientAuthentication";
@@ -66,29 +65,11 @@ export interface IHandleIncomingRedirectOptions {
    * If your app's access has not expired yet and re-activation completed
    * successfully, a `sessionRestore` event will be fired with the URL the user
    * was at before they were redirected to their Solid Identity Provider.
-   * {@see onSessionRestore}
+   * See {@link ISessionEventListener}: a callback can be registered to
+   * `session.events.on(EVENTS.SESSION_RESTORED, callback)`.
    */
   restorePreviousSession?: boolean;
 
-  /**
-   * Inrupt's Enterprise Solid Server can set a cookie to allow the browser to
-   * access private resources on a Pod. In order to mitigate the logout-on-refresh
-   * issue on the short term, the server also implemented a session endpoint
-   * enabling the client app to know whether the cookie is set. When a user
-   * logs in to a server that has that capability enabled, applications that set
-   * this option to `true` will be able to make use of it.
-   *
-   * If your app supports the newest session restore approach, and `restorePreviousSession`
-   * is set to true, this option is automatically set to false, but your app will
-   * not be logged out when reloaded.
-   *
-   * `useEssSession` defaults to false and will be removed in the future; to
-   * preserve sessions across page reloads, use of `restorePreviousSession` is
-   * recommended.
-   *
-   * @deprecated unreleased
-   */
-  useEssSession?: boolean;
   /**
    * The URL of the page handling the redirect, including the query
    * parameters — these contain the information to process the login.
@@ -136,7 +117,7 @@ function isLoggedIn(
 /**
  * A {@link Session} object represents a user's session on an application. The session holds state, as it stores information enabling acces to private resources after login for instance.
  */
-export class Session extends EventEmitter implements IHasSessionEventListener {
+export class Session implements IHasSessionEventListener {
   /**
    * Information regarding the current session.
    */
@@ -172,18 +153,7 @@ export class Session extends EventEmitter implements IHasSessionEventListener {
     sessionOptions: Partial<ISessionOptions> = {},
     sessionId: string | undefined = undefined,
   ) {
-    super();
-    // Until Session no longer implements EventEmitter, this.events is just a proxy
-    // to this (with some interface filtering). When we make the breaking change,
-    // this.events will be a regular EventEmitter (implementing ISessionEventEmitter):
-    // this.events = new EventEmitter();
-    this.events = new Proxy(
-      this,
-      buildProxyHandler(
-        Session.prototype,
-        "events only implements ISessionEventListener",
-      ),
-    );
+    this.events = new EventEmitter();
     if (sessionOptions.clientAuthentication) {
       this.clientAuthentication = sessionOptions.clientAuthentication;
     } else if (sessionOptions.secureStorage && sessionOptions.insecureStorage) {
@@ -321,7 +291,7 @@ export class Session extends EventEmitter implements IHasSessionEventListener {
    * Completes the login process by processing the information provided by the
    * Solid identity provider through redirect.
    *
-   * @param options See {@see IHandleIncomingRedirectOptions}.
+   * @param options See {@link IHandleIncomingRedirectOptions}.
    */
   handleIncomingRedirect = async (
     inputOptions: string | IHandleIncomingRedirectOptions = {},
@@ -384,68 +354,6 @@ export class Session extends EventEmitter implements IHasSessionEventListener {
     return sessionInfo;
   };
 
-  /**
-   * Register a callback function to be called when a user completes login.
-   *
-   * The callback is called when {@link handleIncomingRedirect} completes successfully.
-   *
-   * @param callback The function called when a user completes login.
-   * @deprecated Prefer session.events.on(EVENTS.LOGIN, callback)
-   */
-  onLogin(callback: () => unknown): void {
-    this.events.on(EVENTS.LOGIN, callback);
-  }
-
-  /**
-   * Register a callback function to be called when a user logs out:
-   *
-   * @param callback The function called when a user completes logout.
-   * @deprecated Prefer session.events.on(EVENTS.LOGOUT, callback)
-   */
-  onLogout(callback: () => unknown): void {
-    this.events.on(EVENTS.LOGOUT, callback);
-  }
-
-  /**
-   * Register a callback function to be called when a user logs out:
-   *
-   * @param callback The function called when an error occurs.
-   * @since 1.11.0
-   * @deprecated Prefer session.events.on(EVENTS.ERROR, callback)
-   */
-  onError(
-    callback: (
-      error: string | null,
-      errorDescription?: string | null,
-    ) => unknown,
-  ): void {
-    this.events.on(EVENTS.ERROR, callback);
-  }
-
-  /**
-   * Register a callback function to be called when a session is restored.
-   *
-   * Note: the callback will be called with the saved value of the 'current URL'
-   * at the time the session was restored.
-   *
-   * @param callback The function called when a user's already logged-in session is restored, e.g., after a silent authentication is completed after a page refresh.
-   * @deprecated Prefer session.events.on(EVENTS.SESSION_RESTORED, callback)
-   */
-  onSessionRestore(callback: (currentUrl: string) => unknown): void {
-    this.events.on(EVENTS.SESSION_RESTORED, callback);
-  }
-
-  /**
-   * Register a callback that runs when the session expires and can no longer
-   * make authenticated requests, but following a user logout.
-   * @param callback The function that runs on session expiration.
-   * @since 1.11.0
-   * @deprecated Prefer session.events.on(EVENTS.SESSION_EXPIRED, callback)
-   */
-  onSessionExpiration(callback: () => unknown): void {
-    this.events.on(EVENTS.SESSION_EXPIRED, callback);
-  }
-
   private setSessionInfo(
     sessionInfo: ISessionInfo & { isLoggedIn: true },
   ): void {

package/src/defaultSession.spec.ts

@@ -27,9 +27,6 @@ import {
   handleIncomingRedirect,
   login,
   logout,
-  onLogin,
-  onSessionRestore,
-  onLogout,
   events,
 } from "./defaultSession";
 import * as SessionModule from "./Session";
@@ -72,9 +69,6 @@ it("all functions pass on their arguments to the default session", () => {
   const handleIncomingRedirectSpy = jest.fn();
   defaultSession.handleIncomingRedirect =
     handleIncomingRedirectSpy as typeof defaultSession.handleIncomingRedirect;
-  const onLoginSpy = jest.spyOn(defaultSession, "onLogin");
-  const onLogoutSpy = jest.spyOn(defaultSession, "onLogout");
-  const onSessionRestoreSpy = jest.spyOn(defaultSession, "onSessionRestore");
   const eventsOnSpy = jest.spyOn(defaultSession.events, "on");
 
   expect(fetchSpy).not.toHaveBeenCalled();
@@ -102,16 +96,4 @@ it("all functions pass on their arguments to the default session", () => {
   expect(eventsOnSpy).not.toHaveBeenCalled();
   events().on(EVENTS.LOGIN, jest.fn());
   expect(eventsOnSpy).toHaveBeenCalledTimes(1);
-
-  expect(onLoginSpy).not.toHaveBeenCalled();
-  onLogin(jest.fn());
-  expect(onLoginSpy).toHaveBeenCalledTimes(1);
-
-  expect(onSessionRestoreSpy).not.toHaveBeenCalled();
-  onSessionRestore(jest.fn());
-  expect(onSessionRestoreSpy).toHaveBeenCalledTimes(1);
-
-  expect(onLogoutSpy).not.toHaveBeenCalled();
-  onLogout(jest.fn());
-  expect(onLogoutSpy).toHaveBeenCalledTimes(1);
 });

package/src/defaultSession.ts

@@ -93,46 +93,6 @@ export const handleIncomingRedirect: Session["handleIncomingRedirect"] = (
   return session.handleIncomingRedirect(...args);
 };
 
-/**
- * Register a callback function to be called when a user completes login.
- *
- * The callback is called when {@link handleIncomingRedirect} completes successfully.
- * @since 1.3.0
- *
- * @param callback The function called when a user completes login.
- * @deprecated Prefer events.on(EVENTS.LOGIN, callback)
-
- */
-export const onLogin: Session["onLogin"] = (...args) => {
-  const session = getDefaultSession();
-  return session.onLogin(...args);
-};
-
-/**
- * Register a callback function to be called when a user logs out:
- *
- * @param callback The function called when a user completes logout.
- * @since 1.3.0
- * @deprecated Prefer events.on(EVENTS.LOGOUT, callback)
- *
- */
-export const onLogout: Session["onLogout"] = (...args) => {
-  const session = getDefaultSession();
-  return session.onLogout(...args);
-};
-
-/**
- * Register a callback function to be called when a session is restored:
- *
- * @param callback The function called when a session is restored.
- * @since 1.3.0
- * @deprecated Prefer events.on(EVENTS.SESSION_RESTORED, callback)
- */
-export const onSessionRestore: Session["onSessionRestore"] = (...args) => {
-  const session = getDefaultSession();
-  return session.onSessionRestore(...args);
-};
-
 /**
  * {@link SessionEventEmitter} instance to subscribe to events by the default session.
  *

package/src/dependencies.ts

@@ -48,9 +48,8 @@ import { ErrorOidcHandler } from "./login/oidc/incomingRedirectHandler/ErrorOidc
 import TokenRefresher from "./login/oidc/refresh/TokenRefresher";
 
 /**
- *
  * @param dependencies
- * @deprecated This function will be removed from the external API in an upcoming release.
+ * @hidden
  */
 export function getClientAuthenticationWithDependencies(dependencies: {
   secureStorage?: IStorage;

package/src/index.spec.ts

@@ -21,9 +21,8 @@
 
 import { it, expect } from "@jest/globals";
 
-import { Session, getClientAuthenticationWithDependencies } from "./index";
+import { Session } from "./index";
 
 it("exports the public API from the entrypoint", () => {
   expect(Session).toBeDefined();
-  expect(getClientAuthenticationWithDependencies).toBeDefined();
 });

package/src/index.ts

@@ -19,9 +19,11 @@
 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-export { Session, ISessionOptions } from "./Session";
-
-export { getClientAuthenticationWithDependencies } from "./dependencies";
+export {
+  Session,
+  ISessionOptions,
+  IHandleIncomingRedirectOptions,
+} from "./Session";
 
 export * from "./defaultSession";
 
@@ -34,5 +36,9 @@ export {
   NotImplementedError,
   ConfigurationError,
   InMemoryStorage,
+  IHasSessionEventListener,
+  ISessionEventListener,
+  IEndSessionOptions,
+  ILogoutOptions,
   EVENTS,
 } from "@inrupt/solid-client-authn-core";