@muze-nl/metro-oidc 0.3.2 → 0.3.4

package/dist/browser.js

@@ -80,7 +80,7 @@
       }
       let index = middlewares.findIndex((m) => typeof m != "function");
       if (index >= 0) {
-        throw metroError("metro.client: middlewares must be a function or an array of functions " + metroURL + "client/invalid-middlewares-value/", middlewares[index]);
+        throw metroError("metro.client: middlewares must be a function or an array of functions " + metroURL + "client/invalid-middlewares/", middlewares[index]);
       }
       if (!Array.isArray(this.#options.middlewares)) {
         this.#options.middlewares = [];
@@ -97,13 +97,13 @@
     fetch(req, options) {
       req = request(req, options);
       if (!req.url) {
-        throw metroError("metro.client." + req.method.toLowerCase() + ": Missing url parameter " + metroURL + "client/missing-url-param/", req);
+        throw metroError("metro.client." + req.method.toLowerCase() + ": Missing url parameter " + metroURL + "client/fetch-missing-url/", req);
       }
       if (!options) {
         options = {};
       }
-      if (!(typeof options === "object") || Array.isArray(options) || options instanceof String) {
-        throw metroError("metro.client.fetch: Options is not an object");
+      if (!(typeof options === "object") || options instanceof String) {
+        throw metroError("metro.client.fetch: Invalid options parameter " + metroURL + "client/fetch-invalid-options/", options);
       }
       const metrofetch = async function browserFetch(req2) {
         if (req2[Symbol.metroProxy]) {
@@ -210,13 +210,16 @@
         Object.assign(requestParams, getRequestParams(option, requestParams));
       }
     }
+    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))) {
-        requestParams.body = JSON.stringify(data);
+        if (typeof data.toString == "function") {
+          requestParams.body = data.toString({ headers: r.headers });
+          r = new Request(requestParams.url, requestParams);
+        }
       }
     }
-    let r = new Request(requestParams.url, requestParams);
     Object.freeze(r);
     return new Proxy(r, {
       get(target, prop, receiver) {
@@ -235,8 +238,6 @@
               return request(target, ...options2);
             };
             break;
-          case "body":
-            break;
           case "data":
             return data;
             break;
@@ -297,6 +298,9 @@
     if (responseParams.body) {
       data = responseParams.body;
     }
+    if ([101, 204, 205, 304].includes(responseParams.status)) {
+      responseParams.body = null;
+    }
     let r = new Response(responseParams.body, responseParams);
     Object.freeze(r);
     return new Proxy(r, {
@@ -361,27 +365,31 @@
         appendSearchParams(u, option);
       } else if (option && typeof option == "object") {
         for (let param in option) {
-          if (param == "search") {
-            if (typeof option.search == "function") {
-              option.search(u.search, u);
-            } else {
-              u.search = new URLSearchParams(option.search);
-            }
-          } else if (param == "searchParams") {
-            appendSearchParams(u, option.searchParams);
-          } else {
-            if (!validParams.includes(param)) {
-              throw metroError("metro.url: unknown url parameter " + metroURL + "url/unknown-param-name/", param);
-            }
-            if (typeof option[param] == "function") {
-              option[param](u[param], u);
-            } else if (typeof option[param] == "string" || option[param] instanceof String || typeof option[param] == "number" || option[param] instanceof Number || typeof option[param] == "boolean" || option[param] instanceof Boolean) {
-              u[param] = "" + option[param];
-            } else if (typeof option[param] == "object" && option[param].toString) {
-              u[param] = option[param].toString();
-            } else {
-              throw metroError("metro.url: unsupported value for " + param + " " + metroURL + "url/unsupported-param-value/", options[param]);
-            }
+          switch (param) {
+            case "search":
+              if (typeof option.search == "function") {
+                option.search(u.search, u);
+              } else {
+                u.search = new URLSearchParams(option.search);
+              }
+              break;
+            case "searchParams":
+              appendSearchParams(u, option.searchParams);
+              break;
+            default:
+              if (!validParams.includes(param)) {
+                throw metroError("metro.url: unknown url parameter " + metroURL + "url/unknown-param-name/", param);
+              }
+              if (typeof option[param] == "function") {
+                option[param](u[param], u);
+              } else if (typeof option[param] == "string" || option[param] instanceof String || typeof option[param] == "number" || option[param] instanceof Number || typeof option[param] == "boolean" || option[param] instanceof Boolean) {
+                u[param] = "" + option[param];
+              } else if (typeof option[param] == "object" && option[param].toString) {
+                u[param] = option[param].toString();
+              } else {
+                throw metroError("metro.url: unsupported value for " + param + " " + metroURL + "url/unsupported-param-value/", options[param]);
+              }
+              break;
           }
         }
       } else {
@@ -403,6 +411,12 @@
               return url(target, ...options2);
             };
             break;
+          case "filename":
+            return target.pathname.split("/").pop();
+            break;
+          case "folderpath":
+            return target.pathname.substring(0, target.pathname.lastIndexOf("\\") + 1);
+            break;
         }
         if (target[prop] instanceof Function) {
           return target[prop].bind(target);
@@ -414,6 +428,9 @@
   function formdata(...options) {
     var params2 = 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]);
@@ -429,7 +446,7 @@
           }
         }
       } else {
-        throw new metroError("metro.formdata: unknown option type, only FormData or Object supported", option);
+        throw new metroError("metro.formdata: unknown option type " + metroURL + "formdata/unknown-option-value/", option);
       }
     }
     Object.freeze(params2);
@@ -442,6 +459,9 @@
           case Symbol.metroSource:
             return target;
             break;
+          //TODO: add toString() that can check
+          //headers param: toString({headers:request.headers})
+          //for the content-type
           case "with":
             return function(...options2) {
               return formdata(target, ...options2);
@@ -599,131 +619,210 @@
   // node_modules/@muze-nl/metro-oauth2/src/oauth2.mjs
   var oauth2_exports = {};
   __export(oauth2_exports, {
-    authorizePopup: () => authorizePopup,
     base64url_encode: () => base64url_encode,
     createState: () => createState,
     default: () => oauth2mw,
     generateCodeChallenge: () => generateCodeChallenge,
     generateCodeVerifier: () => generateCodeVerifier,
     getExpires: () => getExpires,
+    isAuthorized: () => isAuthorized,
     isExpired: () => isExpired,
     isRedirected: () => isRedirected
   });
 
-  // node_modules/@muze-nl/metro-oauth2/node_modules/@muze-nl/assert/src/assert.mjs
+  // node_modules/@muze-nl/assert/src/assert.mjs
   globalThis.assertEnabled = false;
-  var assert = (source, test) => {
+  function assert(source, test) {
     if (globalThis.assertEnabled) {
       let problems = fails(source, test);
       if (problems) {
-        throw new assertError("Assertions failed", problems, source);
+        console.error("\u{1F170}\uFE0F  Assertions failed because of:", problems, "in this source:", source);
+        throw new Error("Assertions failed", {
+          cause: { problems, source }
+        });
       }
     }
-  };
-  var Optional = (pattern) => (data) => data == null || typeof data == "undefined" ? false : fails(data, pattern);
-  var Required = (pattern) => (data) => fails(data, pattern);
-  var Recommended = (pattern) => (data) => data == null || typeof data == "undefined" ? (() => {
-    console.warning("data does not contain recommended value", data, pattern);
-    return false;
-  })() : fails(data, pattern);
-  var oneOf = (...patterns) => (data) => {
-    for (let pattern of patterns) {
-      if (!fails(data, pattern)) {
+  }
+  function Optional(pattern) {
+    return function _Optional(data, root, path) {
+      if (typeof data != "undefined" && data != null && typeof pattern != "undefined") {
+        return fails(data, pattern, root, path);
+      }
+    };
+  }
+  function Required(pattern) {
+    return function _Required(data, root, path) {
+      if (data == null || typeof data == "undefined") {
+        return error2("data is required", data, pattern || "any value", path);
+      } else if (typeof pattern != "undefined") {
+        return fails(data, pattern, root, path);
+      } else {
         return false;
       }
-    }
-    return error("data does not match oneOf patterns", data, patterns);
-  };
-  var anyOf = (...patterns) => (data) => {
-    if (!Array.isArray(data)) {
-      return error("data is not an array", data, "anyOf");
-    }
-    for (let value of data) {
-      if (oneOf(...patterns)(value)) {
-        return error("data does not match anyOf patterns", value, patterns);
+    };
+  }
+  function Recommended(pattern) {
+    return function _Recommended(data, root, path) {
+      if (data == null || typeof data == "undefined") {
+        console.warn("data does not contain recommended value", data, pattern, path);
+        return false;
+      } else {
+        return fails(data, pattern, root, path);
       }
-    }
-    return false;
-  };
-  function validURL(data) {
+    };
+  }
+  function oneOf(...patterns) {
+    return function _oneOf(data, root, path) {
+      for (let pattern of patterns) {
+        if (!fails(data, pattern, root, path)) {
+          return false;
+        }
+      }
+      return error2("data does not match oneOf patterns", data, patterns, path);
+    };
+  }
+  function anyOf(...patterns) {
+    return function _anyOf(data, root, path) {
+      if (!Array.isArray(data)) {
+        return error2("data is not an array", data, "anyOf", path);
+      }
+      for (let value of data) {
+        if (oneOf(...patterns)(value)) {
+          return error2("data does not match anyOf patterns", value, patterns, path);
+        }
+      }
+      return false;
+    };
+  }
+  function allOf(...patterns) {
+    return function _allOf(data, root, path) {
+      let problems = [];
+      for (let pattern of patterns) {
+        problems = problems.concat(fails(data, pattern, root, path));
+      }
+      problems = problems.filter(Boolean);
+      if (problems.length) {
+        return error2("data does not match all given patterns", data, patterns, path, problems);
+      }
+    };
+  }
+  function validURL(data, root, path) {
     try {
       if (data instanceof URL) {
         data = data.href;
       }
       let url2 = new URL(data);
       if (url2.href != data) {
-        return error("data is not a valid url", data, "validURL");
+        if (!(url2.href + "/" == data || url2.href == data + "/")) {
+          return error2("data is not a valid url", data, "validURL", path);
+        }
       }
     } catch (e) {
-      return error("data is not a valid url", data, "validURL");
+      return error2("data is not a valid url", data, "validURL", path);
+    }
+  }
+  function validEmail(data, root, path) {
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(data)) {
+      return error2("data is not a valid email", data, "validEmail", path);
     }
-    return false;
   }
-  function fails(data, pattern, root) {
+  function instanceOf(constructor) {
+    return function _instanceOf(data, root, path) {
+      if (!(data instanceof constructor)) {
+        return error2("data is not an instanceof pattern", data, constructor, path);
+      }
+    };
+  }
+  function not(pattern) {
+    return function _not(data, root, path) {
+      if (!fails(data, pattern, root, path)) {
+        return error2("data matches pattern, when required not to", data, pattern, path);
+      }
+    };
+  }
+  function fails(data, pattern, root, path = "") {
     if (!root) {
       root = data;
     }
     let problems = [];
     if (pattern === Boolean) {
-      if (typeof data != "boolean") {
-        problems.push(error("data is not a boolean", data, pattern));
+      if (typeof data != "boolean" && !(data instanceof Boolean)) {
+        problems.push(error2("data is not a boolean", data, pattern, path));
       }
     } else if (pattern === Number) {
-      if (typeof data != "number") {
-        problems.push(error("data is not a number", data, pattern));
+      if (typeof data != "number" && !(data instanceof Number)) {
+        problems.push(error2("data is not a number", data, pattern, path));
+      }
+    } else if (pattern === String) {
+      if (typeof data != "string" && !(data instanceof String)) {
+        problems.push(error2("data is not a string", data, pattern, path));
+      }
+      if (data == "") {
+        problems.push(error2("data is an empty string, which is not allowed", data, pattern, path));
       }
     } else if (pattern instanceof RegExp) {
       if (Array.isArray(data)) {
-        let index = data.findIndex((element) => fails(element, pattern, root));
+        let index = data.findIndex((element, index2) => fails(element, pattern, root, path + "[" + index2 + "]"));
         if (index > -1) {
-          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern));
+          problems.push(error2("data[" + index + "] does not match pattern", data[index], pattern, path + "[" + index + "]"));
         }
+      } else if (typeof data == "undefined") {
+        problems.push(error2("data is undefined, should match pattern", data, pattern, path));
       } else if (!pattern.test(data)) {
-        problems.push(error("data does not match pattern", data, pattern));
+        problems.push(error2("data does not match pattern", data, pattern, path));
       }
     } else if (pattern instanceof Function) {
-      if (pattern(data, root)) {
-        problems.push(error("data does not match function", data, pattern));
+      let problem = pattern(data, root, path);
+      if (problem) {
+        if (Array.isArray(problem)) {
+          problems = problems.concat(problem);
+        } else {
+          problems.push(problem);
+        }
       }
     } else if (Array.isArray(pattern)) {
       if (!Array.isArray(data)) {
-        problems.push(error("data is not an array", data, []));
+        problems.push(error2("data is not an array", data, [], path));
       }
-      for (p of pattern) {
-        let problem = fails(data, p, root);
-        if (Array.isArray(problem)) {
-          problems.concat(problem);
-        } else if (problem) {
-          problems.push(problem);
+      for (let p of pattern) {
+        for (let index of data.keys()) {
+          let problem = fails(data[index], p, root, path + "[" + index + "]");
+          if (Array.isArray(problem)) {
+            problems = problems.concat(problem);
+          } else if (problem) {
+            problems.push(problem);
+          }
         }
       }
     } else if (pattern && typeof pattern == "object") {
       if (Array.isArray(data)) {
-        let index = data.findIndex((element) => fails(element, pattern, root));
+        let index = data.findIndex((element, index2) => fails(element, pattern, root, path + "[" + index2 + "]"));
         if (index > -1) {
-          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern));
+          problems.push(error2("data[" + index + "] does not match pattern", data[index], pattern, path + "[" + index + "]"));
         }
       } else if (!data || typeof data != "object") {
-        problems.push(error("data is not an object, pattern is", data, pattern));
+        problems.push(error2("data is not an object, pattern is", data, pattern, path));
       } else {
         if (data instanceof URLSearchParams) {
           data = Object.fromEntries(data);
         }
-        let p2 = problems[problems.length - 1];
-        for (const [wKey, wVal] of Object.entries(pattern)) {
-          let result = fails(data[wKey], wVal, root);
+        if (pattern instanceof Function) {
+          let result = fails(data, pattern, root, path);
           if (result) {
-            if (!p2 || typeof p2 == "string") {
-              p2 = {};
-              problems.push(error(p2, data[wKey], wVal));
+            problems = problems.concat(result);
+          }
+        } else {
+          for (const [wKey, wVal] of Object.entries(pattern)) {
+            let result = fails(data[wKey], wVal, root, path + "." + wKey);
+            if (result) {
+              problems = problems.concat(result);
             }
-            p2[wKey] = result.problems;
           }
         }
       }
     } else {
       if (pattern != data) {
-        problems.push(error("data and pattern are not equal", data, pattern));
+        problems.push(error2("data and pattern are not equal", data, pattern, path));
       }
     }
     if (problems.length) {
@@ -731,19 +830,17 @@
     }
     return false;
   }
-  var assertError = class extends Error {
-    constructor(message, problems, ...details) {
-      super(message);
-      this.problems = problems;
-      this.details = details;
-    }
-  };
-  function error(message, found, expected) {
-    return {
+  function error2(message, found, expected, path, problems) {
+    let result = {
       message,
       found,
-      expected
+      expected,
+      path
     };
+    if (problems) {
+      result.problems = problems;
+    }
+    return result;
   }
 
   // node_modules/@muze-nl/metro-oauth2/src/tokenstore.mjs
@@ -1108,13 +1205,19 @@
     }
     return true;
   }
-  async function authorizePopup(authorizationCodeURL) {
-    return new Promise((resolve, reject) => {
-      addEventListener("oauth2authorized", (evt) => {
-        resolve(event.authorization_code);
-      }, { once: true });
-      window.open(authorizationCodeURL);
-    });
+  function isAuthorized(tokens) {
+    if (typeof tokens == "string") {
+      tokens = tokenStore(tokens).tokens;
+    }
+    let accessToken = tokens.get("access_token");
+    if (accessToken && !isExpired(accessToken)) {
+      return true;
+    }
+    let refreshToken = tokens.get("refresh_token");
+    if (refreshToken) {
+      return true;
+    }
+    return false;
   }
 
   // node_modules/@muze-nl/metro-oauth2/src/oauth2.mockserver.mjs
@@ -1142,7 +1245,7 @@
       })
     };
   };
-  var error2;
+  var error3;
   var pkce = {};
   function oauth2mockserver(options = {}) {
     const defaultOptions = {
@@ -1154,12 +1257,12 @@
       let url2 = everything_default.url(req.url);
       switch (url2.pathname) {
         case "/authorize/":
-          if (error2 = fails(url2.searchParams, {
+          if (error3 = fails(url2.searchParams, {
             response_type: "code",
             client_id: "mockClientId",
             state: Optional(/.*/)
           })) {
-            return everything_default.response(badRequest(error2));
+            return everything_default.response(badRequest(error3));
           }
           if (url2.searchParams.has("code_challenge")) {
             if (!url2.searchParams.has("code_challenge_method")) {
@@ -1181,17 +1284,17 @@
             req.data.forEach((value, key) => body[key] = value);
             req = req.with({ body });
           }
-          if (error2 = fails(req, {
+          if (error3 = fails(req, {
             method: "POST",
             data: {
               grant_type: oneOf("refresh_token", "authorization_code")
             }
           })) {
-            return everything_default.response(badRequest(error2));
+            return everything_default.response(badRequest(error3));
           }
           switch (req.data.grant_type) {
             case "refresh_token":
-              if (error2 = fails(req.data, oneOf({
+              if (error3 = fails(req.data, oneOf({
                 refresh_token: "mockRefreshToken",
                 client_id: "mockClientId",
                 client_secret: "mockClientSecret"
@@ -1200,11 +1303,11 @@
                 client_id: "mockClientId",
                 code_verifier: /.+/
               }))) {
-                return everything_default.response(badRequest(error2));
+                return everything_default.response(badRequest(error3));
               }
               break;
             case "access_token":
-              if (error2 = fails(req.data, oneOf({
+              if (error3 = fails(req.data, oneOf({
                 client_id: "mockClientId",
                 client_secret: "mockClientSecret"
               }, {
@@ -1213,7 +1316,7 @@
                 //FIXME: check that this matches code_verifier
                 code_challenge_method: "S256"
               }))) {
-                return everything_default.response(badRequest(error2));
+                return everything_default.response(badRequest(error3));
               }
               break;
           }
@@ -1329,6 +1432,43 @@
     throw everything_default.metroError("metro.oidcmw: Error while fetching " + issuer + ".wellknown/oauth_authorization_server", res);
   }
 
+  // node_modules/@muze-nl/metro-oauth2/src/oauth2.popup.mjs
+  function handleRedirect() {
+    let params2 = new URLSearchParams(window.location.search);
+    if (!params2.has("code") && window.location.hash) {
+      let query = window.location.hash.substr(1);
+      params2 = new URLSearchParams("?" + query);
+    }
+    let parent = window.parent ? window.parent : window.opener;
+    if (params2.has("code")) {
+      parent.postMessage({
+        authorization_code: params2.get("code")
+      }, window.location.origin);
+    } else if (params2.has("error")) {
+      parent.postMessage({
+        error
+      }, window.location.origin);
+    } else {
+      parent.postMessage({
+        error: "Could not find an authorization_code"
+      }, window.location.origin);
+    }
+  }
+  function authorizePopup(authorizationCodeURL) {
+    return new Promise((resolve, reject) => {
+      addEventListener("message", (evt) => {
+        if (event.data.authorization_code) {
+          resolve(event.data.authorization_code);
+        } else if (event.data.error) {
+          reject(event.data.error);
+        } else {
+          reject("Unknown authorization error");
+        }
+      }, { once: true });
+      window.open(authorizationCodeURL);
+    });
+  }
+
   // node_modules/@muze-nl/metro-oauth2/src/keysstore.mjs
   function keysStore() {
     return new Promise((resolve, reject) => {
@@ -1638,237 +1778,26 @@
     discover: oauth2_discovery_exports,
     tokenstore: tokenStore,
     dpopmw,
-    keysstore: keysStore
+    keysstore: keysStore,
+    authorizePopup,
+    popupHandleRedirect: handleRedirect
   });
   if (!globalThis.metro.oauth2) {
     globalThis.metro.oauth2 = oauth2;
   }
 
-  // node_modules/@muze-nl/assert/src/assert.mjs
-  globalThis.assertEnabled = false;
-  function assert2(source, test) {
-    if (globalThis.assertEnabled) {
-      let problems = fails2(source, test);
-      if (problems) {
-        console.error("\u{1F170}\uFE0F  Assertions failed because of:", problems, "in this source:", source);
-        throw new Error("Assertions failed", {
-          cause: { problems, source }
-        });
-      }
-    }
-  }
-  function Optional2(pattern) {
-    return function _Optional(data, root, path) {
-      if (typeof data != "undefined" && data != null && typeof pattern != "undefined") {
-        return fails2(data, pattern, root, path);
-      }
-    };
-  }
-  function Required2(pattern) {
-    return function _Required(data, root, path) {
-      if (data == null || typeof data == "undefined") {
-        return error3("data is required", data, pattern || "any value", path);
-      } else if (typeof pattern != "undefined") {
-        return fails2(data, pattern, root, path);
-      } else {
-        return false;
-      }
-    };
-  }
-  function Recommended2(pattern) {
-    return function _Recommended(data, root, path) {
-      if (data == null || typeof data == "undefined") {
-        console.warn("data does not contain recommended value", data, pattern, path);
-        return false;
-      } else {
-        return fails2(data, pattern, root, path);
-      }
-    };
-  }
-  function oneOf2(...patterns) {
-    return function _oneOf(data, root, path) {
-      for (let pattern of patterns) {
-        if (!fails2(data, pattern, root, path)) {
-          return false;
-        }
-      }
-      return error3("data does not match oneOf patterns", data, patterns, path);
-    };
-  }
-  function anyOf2(...patterns) {
-    return function _anyOf(data, root, path) {
-      if (!Array.isArray(data)) {
-        return error3("data is not an array", data, "anyOf", path);
-      }
-      for (let value of data) {
-        if (oneOf2(...patterns)(value)) {
-          return error3("data does not match anyOf patterns", value, patterns, path);
-        }
-      }
-      return false;
-    };
-  }
-  function allOf(...patterns) {
-    return function _allOf(data, root, path) {
-      let problems = [];
-      for (let pattern of patterns) {
-        problems = problems.concat(fails2(data, pattern, root, path));
-      }
-      problems = problems.filter(Boolean);
-      if (problems.length) {
-        return error3("data does not match all given patterns", data, patterns, path, problems);
-      }
-    };
-  }
-  function validURL2(data, root, path) {
-    try {
-      if (data instanceof URL) {
-        data = data.href;
-      }
-      let url2 = new URL(data);
-      if (url2.href != data) {
-        if (!(url2.href + "/" == data || url2.href == data + "/")) {
-          return error3("data is not a valid url", data, "validURL", path);
-        }
-      }
-    } catch (e) {
-      return error3("data is not a valid url", data, "validURL", path);
-    }
-  }
-  function validEmail(data, root, path) {
-    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(data)) {
-      return error3("data is not a valid email", data, "validEmail", path);
-    }
-  }
-  function instanceOf(constructor) {
-    return function _instanceOf(data, root, path) {
-      if (!(data instanceof constructor)) {
-        return error3("data is not an instanceof pattern", data, constructor, path);
-      }
-    };
-  }
-  function not(pattern) {
-    return function _not(data, root, path) {
-      if (!fails2(data, pattern, root, path)) {
-        return error3("data matches pattern, when required not to", data, pattern, path);
-      }
-    };
-  }
-  function fails2(data, pattern, root, path = "") {
-    if (!root) {
-      root = data;
-    }
-    let problems = [];
-    if (pattern === Boolean) {
-      if (typeof data != "boolean" && !(data instanceof Boolean)) {
-        problems.push(error3("data is not a boolean", data, pattern, path));
-      }
-    } else if (pattern === Number) {
-      if (typeof data != "number" && !(data instanceof Number)) {
-        problems.push(error3("data is not a number", data, pattern, path));
-      }
-    } else if (pattern === String) {
-      if (typeof data != "string" && !(data instanceof String)) {
-        problems.push(error3("data is not a string", data, pattern, path));
-      }
-      if (data == "") {
-        problems.push(error3("data is an empty string, which is not allowed", data, pattern, path));
-      }
-    } else if (pattern instanceof RegExp) {
-      if (Array.isArray(data)) {
-        let index = data.findIndex((element, index2) => fails2(element, pattern, root, path + "[" + index2 + "]"));
-        if (index > -1) {
-          problems.push(error3("data[" + index + "] does not match pattern", data[index], pattern, path + "[" + index + "]"));
-        }
-      } else if (typeof data == "undefined") {
-        problems.push(error3("data is undefined, should match pattern", data, pattern, path));
-      } else if (!pattern.test(data)) {
-        problems.push(error3("data does not match pattern", data, pattern, path));
-      }
-    } else if (pattern instanceof Function) {
-      let problem = pattern(data, root, path);
-      if (problem) {
-        if (Array.isArray(problem)) {
-          problems = problems.concat(problem);
-        } else {
-          problems.push(problem);
-        }
-      }
-    } else if (Array.isArray(pattern)) {
-      if (!Array.isArray(data)) {
-        problems.push(error3("data is not an array", data, [], path));
-      }
-      for (let p2 of pattern) {
-        for (let index of data.keys()) {
-          let problem = fails2(data[index], p2, root, path + "[" + index + "]");
-          if (Array.isArray(problem)) {
-            problems = problems.concat(problem);
-          } else if (problem) {
-            problems.push(problem);
-          }
-        }
-      }
-    } else if (pattern && typeof pattern == "object") {
-      if (Array.isArray(data)) {
-        let index = data.findIndex((element, index2) => fails2(element, pattern, root, path + "[" + index2 + "]"));
-        if (index > -1) {
-          problems.push(error3("data[" + index + "] does not match pattern", data[index], pattern, path + "[" + index + "]"));
-        }
-      } else if (!data || typeof data != "object") {
-        problems.push(error3("data is not an object, pattern is", data, pattern, path));
-      } else {
-        if (data instanceof URLSearchParams) {
-          data = Object.fromEntries(data);
-        }
-        if (pattern instanceof Function) {
-          let result = fails2(data, pattern, root, path);
-          if (result) {
-            problems = problems.concat(result);
-          }
-        } else {
-          for (const [wKey, wVal] of Object.entries(pattern)) {
-            let result = fails2(data[wKey], wVal, root, path + "." + wKey);
-            if (result) {
-              problems = problems.concat(result);
-            }
-          }
-        }
-      }
-    } else {
-      if (pattern != data) {
-        problems.push(error3("data and pattern are not equal", data, pattern, path));
-      }
-    }
-    if (problems.length) {
-      return problems;
-    }
-    return false;
-  }
-  function error3(message, found, expected, path, problems) {
-    let result = {
-      message,
-      found,
-      expected,
-      path
-    };
-    if (problems) {
-      result.problems = problems;
-    }
-    return result;
-  }
-
   // src/oidc.util.mjs
   var MustHave = (...options) => (value, root) => {
     if (options.filter((o) => root.hasOwnKey(o)).length > 0) {
       return false;
     }
-    return error3("root data must have all of", root, options);
+    return error2("root data must have all of", root, options);
   };
   var MustInclude = (...options) => (value) => {
     if (Array.isArray(value) && options.filter((o) => !value.includes(o)).length == 0) {
       return false;
     } else {
-      return error3("data must be an array which includes", value, options);
+      return error2("data must be an array which includes", value, options);
     }
   };
   var validJWA = [
@@ -1891,9 +1820,9 @@
 
   // src/oidc.discovery.mjs
   async function oidcDiscovery(options = {}) {
-    assert2(options, {
-      client: Optional2(instanceOf(everything_default.client().constructor)),
-      issuer: Required2(validURL2)
+    assert(options, {
+      client: Optional(instanceOf(everything_default.client().constructor)),
+      issuer: Required(validURL)
     });
     const defaultOptions = {
       client: everything_default.client().with(thrower()).with(jsonmw()),
@@ -1905,42 +1834,42 @@
       return TestSucceeded;
     }
     const openid_provider_metadata = {
-      issuer: Required2(allOf(options.issuer, MustUseHTTPS)),
-      authorization_endpoint: Required2(validURL2),
-      token_endpoint: Required2(validURL2),
-      userinfo_endpoint: Recommended2(validURL2),
+      issuer: Required(allOf(options.issuer, MustUseHTTPS)),
+      authorization_endpoint: Required(validURL),
+      token_endpoint: Required(validURL),
+      userinfo_endpoint: Recommended(validURL),
       // todo: test for https protocol
-      jwks_uri: Required2(validURL2),
-      registration_endpoint: options.requireDynamicRegistration ? Required2(validURL2) : Recommended2(validURL2),
-      scopes_supported: Recommended2(MustInclude("openid")),
-      response_types_supported: options.requireDynamicRegistration ? Required2(MustInclude("code", "id_token", "id_token token")) : Required2([]),
-      response_modes_supported: Optional2([]),
-      grant_types_supported: options.requireDynamicRegistration ? Optional2(MustInclude("authorization_code")) : Optional2([]),
-      acr_values_supported: Optional2([]),
-      subject_types_supported: Required2([]),
-      id_token_signing_alg_values_supported: Required2(MustInclude("RS256")),
-      id_token_encryption_alg_values_supported: Optional2([]),
-      id_token_encryption_enc_values_supported: Optional2([]),
-      userinfo_signing_alg_values_supported: Optional2([]),
-      userinfo_encryption_alg_values_supported: Optional2([]),
-      userinfo_encryption_enc_values_supported: Optional2([]),
-      request_object_signing_alg_values_supported: Optional2(MustInclude("RS256")),
+      jwks_uri: Required(validURL),
+      registration_endpoint: options.requireDynamicRegistration ? Required(validURL) : Recommended(validURL),
+      scopes_supported: Recommended(MustInclude("openid")),
+      response_types_supported: options.requireDynamicRegistration ? Required(MustInclude("code", "id_token", "id_token token")) : Required([]),
+      response_modes_supported: Optional([]),
+      grant_types_supported: options.requireDynamicRegistration ? Optional(MustInclude("authorization_code")) : Optional([]),
+      acr_values_supported: Optional([]),
+      subject_types_supported: Required([]),
+      id_token_signing_alg_values_supported: Required(MustInclude("RS256")),
+      id_token_encryption_alg_values_supported: Optional([]),
+      id_token_encryption_enc_values_supported: Optional([]),
+      userinfo_signing_alg_values_supported: Optional([]),
+      userinfo_encryption_alg_values_supported: Optional([]),
+      userinfo_encryption_enc_values_supported: Optional([]),
+      request_object_signing_alg_values_supported: Optional(MustInclude("RS256")),
       // not testing for 'none'
-      request_object_encryption_alg_values_supported: Optional2([]),
-      request_object_encryption_enc_values_supported: Optional2([]),
-      token_endpoint_auth_methods_supported: Optional2(anyOf2(...validAuthMethods2)),
-      token_endpoint_auth_signing_alg_values_supported: Optional2(MustInclude("RS256"), not(MustInclude("none"))),
-      display_values_supported: Optional2(anyOf2("page", "popup", "touch", "wap")),
-      claim_types_supported: Optional2(anyOf2("normal", "aggregated", "distributed")),
-      claims_supported: Recommended2([]),
-      service_documentation: Optional2(validURL2),
-      claims_locales_supported: Optional2([]),
-      ui_locales_supported: Optional2([]),
-      claims_parameter_supported: Optional2(Boolean),
-      request_parameter_supported: Optional2(Boolean),
-      request_uri_parameter_supported: Optional2(Boolean),
-      op_policy_uri: Optional2(validURL2),
-      op_tos_uri: Optional2(validURL2)
+      request_object_encryption_alg_values_supported: Optional([]),
+      request_object_encryption_enc_values_supported: Optional([]),
+      token_endpoint_auth_methods_supported: Optional(anyOf(...validAuthMethods2)),
+      token_endpoint_auth_signing_alg_values_supported: Optional(MustInclude("RS256"), not(MustInclude("none"))),
+      display_values_supported: Optional(anyOf("page", "popup", "touch", "wap")),
+      claim_types_supported: Optional(anyOf("normal", "aggregated", "distributed")),
+      claims_supported: Recommended([]),
+      service_documentation: Optional(validURL),
+      claims_locales_supported: Optional([]),
+      ui_locales_supported: Optional([]),
+      claims_parameter_supported: Optional(Boolean),
+      request_parameter_supported: Optional(Boolean),
+      request_uri_parameter_supported: Optional(Boolean),
+      op_policy_uri: Optional(validURL),
+      op_tos_uri: Optional(validURL)
     };
     const configURL = everything_default.url(options.issuer, ".well-known/openid-configuration");
     const response2 = await options.client.get(
@@ -1949,49 +1878,49 @@
       configURL
     );
     const openid_config = response2.data;
-    assert2(openid_config, openid_provider_metadata);
-    assert2(openid_config.issuer, options.issuer);
+    assert(openid_config, openid_provider_metadata);
+    assert(openid_config.issuer, options.issuer);
     return openid_config;
   }
 
   // src/oidc.register.mjs
   async function register(options) {
     const openid_client_metadata = {
-      redirect_uris: Required2([validURL2]),
-      response_types: Optional2([]),
-      grant_types: Optional2(anyOf2("authorization_code", "refresh_token")),
+      redirect_uris: Required([validURL]),
+      response_types: Optional([]),
+      grant_types: Optional(anyOf("authorization_code", "refresh_token")),
       //TODO: match response_types with grant_types
-      application_type: Optional2(oneOf2("native", "web")),
-      contacts: Optional2([validEmail]),
-      client_name: Optional2(String),
-      logo_uri: Optional2(validURL2),
-      client_uri: Optional2(validURL2),
-      policy_uri: Optional2(validURL2),
-      tos_uri: Optional2(validURL2),
-      jwks_uri: Optional2(validURL2, not(MustHave("jwks"))),
-      jwks: Optional2(validURL2, not(MustHave("jwks_uri"))),
-      sector_identifier_uri: Optional2(validURL2),
-      subject_type: Optional2(String),
-      id_token_signed_response_alg: Optional2(oneOf2(...validJWA)),
-      id_token_encrypted_response_alg: Optional2(oneOf2(...validJWA)),
-      id_token_encrypted_response_enc: Optional2(oneOf2(...validJWA), MustHave("id_token_encrypted_response_alg")),
-      userinfo_signed_response_alg: Optional2(oneOf2(...validJWA)),
-      userinfo_encrypted_response_alg: Optional2(oneOf2(...validJWA)),
-      userinfo_encrypted_response_enc: Optional2(oneOf2(...validJWA), MustHave("userinfo_encrypted_response_alg")),
-      request_object_signing_alg: Optional2(oneOf2(...validJWA)),
-      request_object_encryption_alg: Optional2(oneOf2(...validJWA)),
-      request_object_encryption_enc: Optional2(oneOf2(...validJWA)),
-      token_endpoint_auth_method: Optional2(oneOf2(...validAuthMethods2)),
-      token_endpoint_auth_signing_alg: Optional2(oneOf2(...validJWA)),
-      default_max_age: Optional2(Number),
-      require_auth_time: Optional2(Boolean),
-      default_acr_values: Optional2([String]),
-      initiate_login_uri: Optional2([validURL2]),
-      request_uris: Optional2([validURL2])
+      application_type: Optional(oneOf("native", "web")),
+      contacts: Optional([validEmail]),
+      client_name: Optional(String),
+      logo_uri: Optional(validURL),
+      client_uri: Optional(validURL),
+      policy_uri: Optional(validURL),
+      tos_uri: Optional(validURL),
+      jwks_uri: Optional(validURL, not(MustHave("jwks"))),
+      jwks: Optional(validURL, not(MustHave("jwks_uri"))),
+      sector_identifier_uri: Optional(validURL),
+      subject_type: Optional(String),
+      id_token_signed_response_alg: Optional(oneOf(...validJWA)),
+      id_token_encrypted_response_alg: Optional(oneOf(...validJWA)),
+      id_token_encrypted_response_enc: Optional(oneOf(...validJWA), MustHave("id_token_encrypted_response_alg")),
+      userinfo_signed_response_alg: Optional(oneOf(...validJWA)),
+      userinfo_encrypted_response_alg: Optional(oneOf(...validJWA)),
+      userinfo_encrypted_response_enc: Optional(oneOf(...validJWA), MustHave("userinfo_encrypted_response_alg")),
+      request_object_signing_alg: Optional(oneOf(...validJWA)),
+      request_object_encryption_alg: Optional(oneOf(...validJWA)),
+      request_object_encryption_enc: Optional(oneOf(...validJWA)),
+      token_endpoint_auth_method: Optional(oneOf(...validAuthMethods2)),
+      token_endpoint_auth_signing_alg: Optional(oneOf(...validJWA)),
+      default_max_age: Optional(Number),
+      require_auth_time: Optional(Boolean),
+      default_acr_values: Optional([String]),
+      initiate_login_uri: Optional([validURL]),
+      request_uris: Optional([validURL])
     };
-    assert2(options, {
-      client: Optional2(instanceOf(everything_default.client().constructor)),
-      registration_endpoint: validURL2,
+    assert(options, {
+      client: Optional(instanceOf(everything_default.client().constructor)),
+      registration_endpoint: validURL,
       client_info: openid_client_metadata
     });
     const defaultOptions = {
@@ -2043,13 +1972,13 @@
       }
     };
     options = Object.assign({}, defaultOptions, options);
-    assert2(options, {
-      client: Required2(instanceOf(client().constructor)),
+    assert(options, {
+      client: Required(instanceOf(client().constructor)),
       // required because it is set in defaultOptions
-      client_info: Required2(),
-      issuer: Required2(validURL2),
-      oauth2: Optional2({}),
-      openid_configuration: Optional2()
+      client_info: Required(),
+      issuer: Required(validURL),
+      oauth2: Optional({}),
+      openid_configuration: Optional()
     });
     if (!options.store) {
       options.store = oidcStore(options.issuer);
@@ -2081,7 +2010,7 @@
         options.store.set("openid_configuration", options.openid_configuration);
       }
       if (!options.client_info?.client_id) {
-        assert2(options.client_info?.client_name, Required2());
+        assert(options.client_info?.client_name, Required());
         if (!options.openid_configuration.registration_endpoint) {
           throw metroError("metro.oidcmw: Error: issuer " + options.issuer + " does not support dynamic client registration, but you haven't specified a client_id");
         }
@@ -2155,6 +2084,12 @@
     return isRedirected();
   }
   function idToken(options) {
+    if (!options.store) {
+      if (!options.issuer) {
+        throw metroError("Must supply options.issuer or options.store to get the id_token");
+      }
+      options.store = oidcStore(options.issuer);
+    }
     return options.store.get("id_token");
   }