@muze-nl/metro-oidc 0.5.4 → 0.5.6

package/dist/browser.js

@@ -27,7 +27,7 @@
   }
   var Client = class _Client {
     clientOptions = {
-      url: typeof window != "undefined" ? window.location : "https://localhost",
+      url: typeof window != "undefined" ? url(window.location) : url("https://localhost"),
       verbs: ["get", "post", "put", "delete", "patch", "head", "options", "query"]
     };
     static tracers = {};
@@ -44,13 +44,17 @@
     constructor(...options) {
       for (let option of options) {
         if (typeof option == "string" || option instanceof String) {
-          this.clientOptions.url = "" + option;
+          this.clientOptions.url = url(this.clientOptions.url.href, option);
+        } else if (option instanceof _Client) {
+          Object.assign(this.clientOptions, option.clientOptions);
         } else if (option instanceof Function) {
           this.#addMiddlewares([option]);
         } else if (option && typeof option == "object") {
           for (let param in option) {
             if (param == "middlewares") {
               this.#addMiddlewares(option[param]);
+            } else if (param == "url") {
+              this.clientOptions.url = url(this.clientOptions.url.href, option[param]);
             } else if (typeof option[param] == "function") {
               this.clientOptions[param] = option[param](this.clientOptions[param], this.clientOptions);
             } else {
@@ -135,14 +139,17 @@
     with(...options) {
       return new _Client(deepClone(this.clientOptions), ...options);
     }
+    get location() {
+      return this.clientOptions.url;
+    }
   };
   function client(...options) {
     return new Client(...deepClone(options));
   }
   function getRequestParams(req, current) {
-    let params2 = current || {};
-    if (!params2.url && current.url) {
-      params2.url = current.url;
+    let params = current || {};
+    if (!params.url && current.url) {
+      params.url = current.url;
     }
     for (let prop of [
       "method",
@@ -168,31 +175,31 @@
         value = value[Symbol.metroSource];
       }
       if (typeof value == "function") {
-        params2[prop] = value(params2[prop], params2);
+        params[prop] = value(params[prop], params);
       } else {
         if (prop == "url") {
-          params2.url = url(params2.url, value);
+          params.url = url(params.url, value);
         } else if (prop == "headers") {
-          params2.headers = new Headers(current.headers);
+          params.headers = new Headers(current.headers);
           if (!(value instanceof Headers)) {
             value = new Headers(req.headers);
           }
           for (let [key, val] of value.entries()) {
-            params2.headers.set(key, val);
+            params.headers.set(key, val);
           }
         } else {
-          params2[prop] = value;
+          params[prop] = value;
         }
       }
     }
     if (req instanceof Request && req.data) {
-      params2.body = req.data;
+      params.body = req.data;
     }
-    return params2;
+    return params;
   }
   function request(...options) {
     let requestParams = {
-      url: typeof window != "undefined" ? window.location : "https://localhost/",
+      url: typeof window != "undefined" ? url(window.location) : url("https://localhost/"),
       duplex: "half"
       // required when setting body to ReadableStream, just set it here by default already
     };
@@ -208,7 +215,7 @@
     let r = new Request(requestParams.url, requestParams);
     let data = requestParams.body;
     if (data) {
-      if (typeof data == "object" && !(data instanceof String) && !(data instanceof ReadableStream) && !(data instanceof Blob) && !(data instanceof ArrayBuffer) && !(data instanceof DataView) && !(data instanceof FormData) && !(data instanceof URLSearchParams) && (typeof TypedArray == "undefined" || !(data instanceof TypedArray))) {
+      if (typeof data == "object" && !(data instanceof String) && !(data instanceof ReadableStream) && !(data instanceof Blob) && !(data instanceof ArrayBuffer) && !(data instanceof DataView) && !(data instanceof FormData) && !(data instanceof URLSearchParams) && (typeof globalThis.TypedArray == "undefined" || !(data instanceof globalThis.TypedArray))) {
         if (typeof data.toString == "function") {
           requestParams.body = data.toString({ headers: r.headers });
           r = new Request(requestParams.url, requestParams);
@@ -217,16 +224,17 @@
     }
     Object.freeze(r);
     return new Proxy(r, {
-      get(target, prop, receiver) {
+      get(target, prop) {
+        let result;
         switch (prop) {
           case Symbol.metroSource:
-            return target;
+            result = target;
             break;
           case Symbol.metroProxy:
-            return true;
+            result = true;
             break;
           case "with":
-            return function(...options2) {
+            result = function(...options2) {
               if (data) {
                 options2.unshift({ body: data });
               }
@@ -234,22 +242,26 @@
             };
             break;
           case "data":
-            return data;
+            result = data;
+            break;
+          default:
+            if (target[prop] instanceof Function) {
+              if (prop === "clone") {
+              }
+              result = target[prop].bind(target);
+            } else {
+              result = target[prop];
+            }
             break;
         }
-        if (target[prop] instanceof Function) {
-          if (prop === "clone") {
-          }
-          return target[prop].bind(target);
-        }
-        return target[prop];
+        return result;
       }
     });
   }
   function getResponseParams(res, current) {
-    let params2 = current || {};
-    if (!params2.url && current.url) {
-      params2.url = current.url;
+    let params = current || {};
+    if (!params.url && current.url) {
+      params.url = current.url;
     }
     for (let prop of ["status", "statusText", "headers", "body", "url", "type", "redirected"]) {
       let value = res[prop];
@@ -260,19 +272,19 @@
         value = value[Symbol.metroSource];
       }
       if (typeof value == "function") {
-        params2[prop] = value(params2[prop], params2);
+        params[prop] = value(params[prop], params);
       } else {
         if (prop == "url") {
-          params2.url = new URL(value, params2.url || "https://localhost/");
+          params.url = new URL(value, params.url || "https://localhost/");
         } else {
-          params2[prop] = value;
+          params[prop] = value;
         }
       }
     }
     if (res instanceof Response && res.data) {
-      params2.body = res.data;
+      params.body = res.data;
     }
-    return params2;
+    return params;
   }
   function response(...options) {
     let responseParams = {};
@@ -282,7 +294,7 @@
       } else if (option instanceof Response) {
         Object.assign(responseParams, getResponseParams(option, responseParams));
       } else if (option && typeof option == "object") {
-        if (option instanceof FormData || option instanceof Blob || option instanceof ArrayBuffer || option instanceof DataView || option instanceof ReadableStream || option instanceof URLSearchParams || option instanceof String || typeof TypedArray != "undefined" && option instanceof TypedArray) {
+        if (option instanceof FormData || option instanceof Blob || option instanceof ArrayBuffer || option instanceof DataView || option instanceof ReadableStream || option instanceof URLSearchParams || option instanceof String || typeof globalThis.TypedArray != "undefined" && option instanceof globalThis.TypedArray) {
           responseParams.body = option;
         } else {
           Object.assign(responseParams, getResponseParams(option, responseParams));
@@ -299,39 +311,44 @@
     let r = new Response(responseParams.body, responseParams);
     Object.freeze(r);
     return new Proxy(r, {
-      get(target, prop, receiver) {
+      get(target, prop) {
+        let result;
         switch (prop) {
           case Symbol.metroProxy:
-            return true;
+            result = true;
             break;
           case Symbol.metroSource:
-            return target;
+            result = target;
             break;
           case "with":
-            return function(...options2) {
+            result = function(...options2) {
               return response(target, ...options2);
             };
             break;
           case "data":
-            return data;
+            result = data;
             break;
           case "ok":
-            return target.status >= 200 && target.status < 400;
+            result = target.status >= 200 && target.status < 400;
+            break;
+          default:
+            if (typeof target[prop] == "function") {
+              result = target[prop].bind(target);
+            } else {
+              result = target[prop];
+            }
             break;
         }
-        if (typeof target[prop] == "function") {
-          return target[prop].bind(target);
-        }
-        return target[prop];
+        return result;
       }
     });
   }
-  function appendSearchParams(url2, params2) {
-    if (typeof params2 == "function") {
-      params2(url2.searchParams, url2);
+  function appendSearchParams(url2, params) {
+    if (typeof params == "function") {
+      params(url2.searchParams, url2);
     } else {
-      params2 = new URLSearchParams(params2);
-      params2.forEach((value, key) => {
+      params = new URLSearchParams(params);
+      params.forEach((value, key) => {
         url2.searchParams.append(key, value);
       });
     }
@@ -393,25 +410,25 @@
     }
     Object.freeze(u);
     return new Proxy(u, {
-      get(target, prop, receiver) {
+      get(target, prop) {
         let result;
         switch (prop) {
           case Symbol.metroProxy:
-            return true;
+            result = true;
             break;
           case Symbol.metroSource:
-            return target;
+            result = target;
             break;
           case "with":
-            return function(...options2) {
+            result = function(...options2) {
               return url(target, ...options2);
             };
             break;
           case "filename":
-            return target.pathname.split("/").pop();
+            result = target.pathname.split("/").pop();
             break;
           case "folderpath":
-            return target.pathname.substring(0, target.pathname.lastIndexOf("\\") + 1);
+            result = target.pathname.substring(0, target.pathname.lastIndexOf("\\") + 1);
             break;
           case "authority":
             result = target.username ?? "";
@@ -421,78 +438,86 @@
             result += target.port ? ":" + target.port : "";
             result += "/";
             result = target.protocol + "//" + result;
-            return result;
             break;
           case "origin":
             result = target.protocol + "//" + target.hostname;
             result += target.port ? ":" + target.port : "";
             result += "/";
-            return result;
             break;
           case "fragment":
-            return target.hash.substring(1);
+            result = target.hash.substring(1);
             break;
           case "scheme":
             if (target.protocol) {
-              return target.protocol.substring(0, target.protocol.length - 1);
+              result = target.protocol.substring(0, target.protocol.length - 1);
+            } else {
+              result = "";
+            }
+            break;
+          default:
+            if (target[prop] instanceof Function) {
+              result = target[prop].bind(target);
+            } else {
+              result = target[prop];
             }
-            return "";
             break;
         }
-        if (target[prop] instanceof Function) {
-          return target[prop].bind(target);
-        }
-        return target[prop];
+        return result;
       }
     });
   }
   function formdata(...options) {
-    var params2 = new FormData();
+    var params = new FormData();
     for (let option of options) {
       if (option instanceof HTMLFormElement) {
         option = new FormData(option);
       }
       if (option instanceof FormData) {
         for (let entry of option.entries()) {
-          params2.append(entry[0], entry[1]);
+          params.append(entry[0], entry[1]);
         }
       } else if (option && typeof option == "object") {
         for (let entry of Object.entries(option)) {
           if (Array.isArray(entry[1])) {
             for (let value of entry[1]) {
-              params2.append(entry[0], value);
+              params.append(entry[0], value);
             }
           } else {
-            params2.append(entry[0], entry[1]);
+            params.append(entry[0], entry[1]);
           }
         }
       } else {
         throw new metroError("metro.formdata: unknown option type " + metroURL + "formdata/unknown-option-value/", option);
       }
     }
-    Object.freeze(params2);
-    return new Proxy(params2, {
-      get: (target, prop, receiver) => {
+    Object.freeze(params);
+    return new Proxy(params, {
+      get(target, prop) {
+        let result;
         switch (prop) {
           case Symbol.metroProxy:
-            return true;
+            result = true;
             break;
           case Symbol.metroSource:
-            return target;
+            result = target;
             break;
           //TODO: add toString() that can check
           //headers param: toString({headers:request.headers})
           //for the content-type
           case "with":
-            return function(...options2) {
+            result = function(...options2) {
               return formdata(target, ...options2);
             };
             break;
+          default:
+            if (target[prop] instanceof Function) {
+              result = target[prop].bind(target);
+            } else {
+              result = target[prop];
+            }
+            break;
         }
-        if (target[prop] instanceof Function) {
-          return target[prop].bind(target);
-        }
-        return target[prop];
+        return result;
       }
     });
   }
@@ -578,35 +603,38 @@
   // node_modules/@muze-nl/metro/src/mw/json.mjs
   function jsonmw(options) {
     options = Object.assign({
-      mimetype: "application/json",
+      contentType: "application/json",
       reviver: null,
       replacer: null,
       space: ""
     }, options);
     return async function json(req, next) {
-      if (!isJSON(req.headers.get("Accept"))) {
+      if (!req.headers.get("Accept")) {
         req = req.with({
           headers: {
-            "Accept": options.mimetype
+            "Accept": options.accept ?? options.contentType
           }
         });
       }
-      if (["POST", "PUT", "PATCH", "QUERY"].includes(req.method)) {
+      if (req.method !== "GET" && req.method !== "HEAD") {
         if (req.data && typeof req.data == "object" && !(req.data instanceof ReadableStream)) {
-          if (!isJSON(req.headers.get("content-type"))) {
+          const contentType = req.headers.get("Content-Type");
+          if (!contentType || isPlainText(contentType)) {
             req = req.with({
               headers: {
-                "Content-Type": options.mimetype
+                "Content-Type": options.contentType
               }
             });
           }
-          req = req.with({
-            body: JSON.stringify(req.data, options.replacer, options.space)
-          });
+          if (isJSON(req.headers.get("Content-Type"))) {
+            req = req.with({
+              body: JSON.stringify(req.data, options.replacer, options.space)
+            });
+          }
         }
       }
       let res = await next(req);
-      if (isJSON(res.headers.get("content-type"))) {
+      if (res && isJSON(res.headers?.get("Content-Type"))) {
         let tempRes = res.clone();
         let body = await tempRes.text();
         try {
@@ -624,6 +652,9 @@
   function isJSON(contentType) {
     return jsonRE.exec(contentType);
   }
+  function isPlainText(contentType) {
+    return /^text\/plain\b/.exec(contentType);
+  }
 
   // node_modules/@muze-nl/metro/src/mw/thrower.mjs
   function throwermw(options) {
@@ -642,12 +673,64 @@
     };
   }
 
+  // node_modules/@muze-nl/metro/src/mw/getdata.mjs
+  function getdatamw() {
+    return async function getdata(req, next) {
+      let res = await next(req);
+      if (res.ok && res.data) {
+        return res.data;
+      }
+      return res;
+    };
+  }
+
+  // node_modules/@muze-nl/metro/src/api.mjs
+  var API = class extends Client {
+    constructor(base, methods, bind = null) {
+      if (base instanceof Client) {
+        super(base.clientOptions, throwermw(), getdatamw());
+      } else {
+        super(base, throwermw(), getdatamw());
+      }
+      if (!bind) {
+        bind = this;
+      }
+      for (const methodName in methods) {
+        if (typeof methods[methodName] == "function") {
+          this[methodName] = methods[methodName].bind(bind);
+        } else if (methods[methodName] && typeof methods[methodName] == "object") {
+          this[methodName] = new this.constructor(base, methods[methodName], bind);
+        } else {
+          this[methodName] = methods[methodName];
+        }
+      }
+    }
+  };
+  var JsonAPI = class extends API {
+    constructor(base, methods, bind = null) {
+      if (base instanceof Client) {
+        super(base.with(jsonmw()), methods, bind);
+      } else {
+        super(client(base, jsonmw()), methods, bind);
+      }
+    }
+  };
+  function api(...options) {
+    return new API(...deepClone(options));
+  }
+  function jsonApi(...options) {
+    return new JsonAPI(...deepClone(options));
+  }
+
   // node_modules/@muze-nl/metro/src/everything.mjs
   var metro = Object.assign({}, metro_exports, {
     mw: {
-      jsonmw,
-      thrower: throwermw
-    }
+      json: jsonmw,
+      thrower: throwermw,
+      getdata: getdatamw
+    },
+    api,
+    jsonApi
   });
   if (!globalThis.metro) {
     globalThis.metro = metro;
@@ -656,6 +739,12 @@
 
   // node_modules/@muze-nl/assert/src/assert.mjs
   globalThis.assertEnabled = false;
+  function enable() {
+    globalThis.assertEnabled = true;
+  }
+  function disable() {
+    globalThis.assertEnabled = false;
+  }
   function assert(source, test) {
     if (globalThis.assertEnabled) {
       let problems = fails(source, test);
@@ -869,6 +958,24 @@
   function warn(message, data, pattern, path) {
     console.warn("\u{1F170}\uFE0F  Assert: " + path, message, pattern, data);
   }
+  globalThis.assert = {
+    warn,
+    error,
+    assert,
+    enable,
+    disable,
+    Required,
+    Recommended,
+    Optional,
+    oneOf,
+    anyOf,
+    allOf,
+    validURL,
+    validEmail,
+    instanceOf,
+    not,
+    fails
+  };
 
   // node_modules/@muze-nl/metro-oauth2/src/tokenstore.mjs
   function tokenStore(site) {
@@ -962,7 +1069,7 @@
           return res;
         }
       } catch (err) {
-        switch (res.status) {
+        switch (res?.status) {
           case 400:
           // Oauth2.1 RFC 3.2.4
           case 401:
@@ -1019,20 +1126,20 @@
     function getTokensFromLocation() {
       if (typeof window !== "undefined" && window?.location) {
         let url2 = url(window.location);
-        let code, state, params2;
+        let code, state, params;
         if (url2.searchParams.has("code")) {
-          params2 = url2.searchParams;
+          params = url2.searchParams;
           url2 = url2.with({ search: "" });
           history.pushState({}, "", url2.href);
         } else if (url2.hash) {
           let query = url2.hash.substr(1);
-          params2 = new URLSearchParams("?" + query);
+          params = new URLSearchParams("?" + query);
           url2 = url2.with({ hash: "" });
           history.pushState({}, "", url2.href);
         }
-        if (params2) {
-          code = params2.get("code");
-          state = params2.get("state");
+        if (params) {
+          code = params.get("code");
+          state = params.get("state");
           let storedState = options.state.get("metro/state");
           if (!state || state !== storedState) {
             return;
@@ -1060,7 +1167,7 @@
       let response2 = await options.client.post(tokenReq);
       if (!response2.ok) {
         let msg = await response2.text();
-        throw metroError("OAuth2mw: fetch access_token: " + response2.status + ": " + response2.statusText, { cause: tokenReq });
+        throw metroError("OAuth2mw: fetch access_token: " + response2.status + ": " + response2.statusText + " (" + msg + ")", { cause: tokenReq });
       }
       let data = await response2.json();
       options.tokens.set("access_token", {
@@ -1151,36 +1258,35 @@
         throw metroError("oauth2mw: Missing options.endpoints.token url");
       }
       let url2 = url(oauth2.token_endpoint, { hash: "" });
-      let params2 = {
+      let params = {
         grant_type: grant_type || oauth2.grant_type,
         client_id: oauth2.client_id
       };
       if (oauth2.client_secret) {
-        params2.client_secret = oauth2.client_secret;
+        params.client_secret = oauth2.client_secret;
       }
       if (oauth2.scope) {
-        params2.scope = oauth2.scope;
+        params.scope = oauth2.scope;
       }
-      switch (params2.grant_type) {
+      switch (params.grant_type) {
         case "authorization_code":
-          params2.redirect_uri = oauth2.redirect_uri;
-          params2.code = options.tokens.get("authorization_code");
+          params.redirect_uri = oauth2.redirect_uri;
+          params.code = options.tokens.get("authorization_code");
           const code_verifier = options.tokens.get("code_verifier");
           if (code_verifier) {
-            params2.code_verifier = code_verifier;
+            params.code_verifier = code_verifier;
           }
           break;
         case "client_credentials":
           break;
         case "refresh_token":
-          const refreshToken = options.tokens.get("refresh_token");
-          params2.refresh_token = refreshToken.value;
+          params.refresh_token = options.tokens.get("refresh_token");
           break;
         default:
           throw new Error("Unknown grant_type: ".oauth2.grant_type);
           break;
       }
-      return request(url2, { method: "POST", body: new URLSearchParams(params2) });
+      return request(url2, { method: "POST", body: new URLSearchParams(params) });
     }
   }
   function isExpired(token) {
@@ -1232,7 +1338,7 @@
     if (!url2.searchParams.has("code")) {
       if (url2.hash) {
         let query = url2.hash.substr(1);
-        params = new URLSearchParams("?" + query);
+        const params = new URLSearchParams("?" + query);
         if (params.has("code")) {
           return true;
         }
@@ -1333,35 +1439,44 @@
     const signature = b64u(await crypto.subtle.sign(subtleAlgorithm(key), key, buf(input)));
     return `${input}.${signature}`;
   }
-  var CHUNK_SIZE = 32768;
-  function encodeBase64Url(input) {
-    if (input instanceof ArrayBuffer) {
-      input = new Uint8Array(input);
-    }
-    const arr = [];
-    for (let i = 0; i < input.byteLength; i += CHUNK_SIZE) {
-      arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
-    }
-    return btoa(arr.join("")).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  var encodeBase64Url;
+  if (Uint8Array.prototype.toBase64) {
+    encodeBase64Url = (input) => {
+      if (input instanceof ArrayBuffer) {
+        input = new Uint8Array(input);
+      }
+      return input.toBase64({ alphabet: "base64url", omitPadding: true });
+    };
+  } else {
+    const CHUNK_SIZE = 32768;
+    encodeBase64Url = (input) => {
+      if (input instanceof ArrayBuffer) {
+        input = new Uint8Array(input);
+      }
+      const arr = [];
+      for (let i = 0; i < input.byteLength; i += CHUNK_SIZE) {
+        arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
+      }
+      return btoa(arr.join("")).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+    };
   }
   function b64u(input) {
     return encodeBase64Url(input);
   }
-  function randomBytes() {
-    return b64u(crypto.getRandomValues(new Uint8Array(32)));
-  }
   var UnsupportedOperationError = class extends Error {
     constructor(message) {
-      super(message ?? "operation not supported");
+      var _a;
+      super(message !== null && message !== void 0 ? message : "operation not supported");
       this.name = this.constructor.name;
-      Error.captureStackTrace?.(this, this.constructor);
+      (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
     }
   };
   var OperationProcessingError = class extends Error {
     constructor(message) {
+      var _a;
       super(message);
       this.name = this.constructor.name;
-      Error.captureStackTrace?.(this, this.constructor);
+      (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
     }
   };
   function psAlg(key) {
@@ -1397,7 +1512,7 @@
       case "ECDSA":
         return esAlg(key);
       case "Ed25519":
-        return "EdDSA";
+        return "Ed25519";
       default:
         throw new UnsupportedOperationError("unsupported CryptoKey algorithm name");
     }
@@ -1414,9 +1529,9 @@
   function epochTime() {
     return Math.floor(Date.now() / 1e3);
   }
-  async function DPoP(keypair, htu, htm, nonce, accessToken, additional) {
-    const privateKey = keypair?.privateKey;
-    const publicKey = keypair?.publicKey;
+  async function generateProof(keypair, htu, htm, nonce, accessToken, additional) {
+    const privateKey = keypair === null || keypair === void 0 ? void 0 : keypair.privateKey;
+    const publicKey = keypair === null || keypair === void 0 ? void 0 : keypair.publicKey;
     if (!isPrivateKey(privateKey)) {
       throw new TypeError('"keypair.privateKey" must be a private CryptoKey');
     }
@@ -1445,21 +1560,21 @@
       alg: determineJWSAlgorithm(privateKey),
       typ: "dpop+jwt",
       jwk: await publicJwk(publicKey)
-    }, {
-      ...additional,
+    }, Object.assign(Object.assign({}, additional), {
       iat: epochTime(),
-      jti: randomBytes(),
+      jti: crypto.randomUUID(),
       htm,
       nonce,
       htu,
       ath: accessToken ? b64u(await crypto.subtle.digest("SHA-256", buf(accessToken))) : void 0
-    }, privateKey);
+    }), privateKey);
   }
   async function publicJwk(key) {
     const { kty, e, n, x, y, crv } = await crypto.subtle.exportKey("jwk", key);
     return { kty, crv, e, n, x, y };
   }
   async function generateKeyPair(alg, options) {
+    var _a;
     let algorithm;
     if (typeof alg !== "string" || alg.length === 0) {
       throw new TypeError('"alg" must be a non-empty string');
@@ -1469,7 +1584,7 @@
         algorithm = {
           name: "RSA-PSS",
           hash: "SHA-256",
-          modulusLength: options?.modulusLength ?? 2048,
+          modulusLength: 2048,
           publicExponent: new Uint8Array([1, 0, 1])
         };
         break;
@@ -1477,20 +1592,20 @@
         algorithm = {
           name: "RSASSA-PKCS1-v1_5",
           hash: "SHA-256",
-          modulusLength: options?.modulusLength ?? 2048,
+          modulusLength: 2048,
           publicExponent: new Uint8Array([1, 0, 1])
         };
         break;
       case "ES256":
         algorithm = { name: "ECDSA", namedCurve: "P-256" };
         break;
-      case "EdDSA":
+      case "Ed25519":
         algorithm = { name: "Ed25519" };
         break;
       default:
         throw new UnsupportedOperationError();
     }
-    return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, ["sign", "verify"]);
+    return crypto.subtle.generateKey(algorithm, (_a = options === null || options === void 0 ? void 0 : options.extractable) !== null && _a !== void 0 ? _a : false, ["sign", "verify"]);
   }
 
   // node_modules/@muze-nl/metro-oauth2/src/oauth2.dpop.mjs
@@ -1512,14 +1627,14 @@
       }
       const url2 = everything_default.url(req.url);
       if (req.url.startsWith(options.authorization_endpoint)) {
-        let params2 = req.body;
-        if (params2 instanceof URLSearchParams || params2 instanceof FormData) {
-          params2.set("dpop_jkt", keyInfo.keyPair.publicKey);
+        let params = req.body;
+        if (params instanceof URLSearchParams || params instanceof FormData) {
+          params.set("dpop_jkt", keyInfo.keyPair.publicKey);
         } else {
-          params2.dpop_jkt = keyInfo.keyPair.publicKey;
+          params.dpop_jkt = keyInfo.keyPair.publicKey;
         }
       } else if (req.url.startsWith(options.token_endpoint)) {
-        const dpopHeader = await DPoP(keyInfo.keyPair, req.url, req.method);
+        const dpopHeader = await generateProof(keyInfo.keyPair, req.url, req.method);
         req = req.with({
           headers: {
             "DPoP": dpopHeader
@@ -1528,7 +1643,7 @@
       } else if (req.headers.has("Authorization")) {
         const nonce = localStorage.getItem(url2.host + ":nonce") || void 0;
         const accessToken = req.headers.get("Authorization").split(" ")[1];
-        const dpopHeader = await DPoP(keyInfo.keyPair, req.url, req.method, nonce, accessToken);
+        const dpopHeader = await generateProof(keyInfo.keyPair, req.url, req.method, nonce, accessToken);
         req = req.with({
           headers: {
             "Authorization": "DPoP " + accessToken,