@passflow/node 0.0.0-bootstrap.0

package/dist/index.cjs

@@ -0,0 +1,558 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_evaluate = require("./evaluate-C20MecTf.cjs");
+let jose = require("jose");
+// src/header.ts
+const ALLOWED_ALGORITHMS = ["RS256", "ES256"];
+const UTF8 = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+const BASE64URL$1 = /^[A-Za-z0-9_-]+$/;
+function decodeProtectedHeader(segment) {
+	if (!BASE64URL$1.test(segment) || segment.length % 4 === 1) return;
+	try {
+		const decoded = JSON.parse(UTF8.decode(jose.base64url.decode(segment)));
+		return typeof decoded === "object" && decoded !== null && !Array.isArray(decoded) ? decoded : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Header inspection, in the order Go and the corpus pin, before any key lookup: malformed, alg, crit,
+* kid. It has to run before jose, which reports a standard parameter in `crit` with the same code as a
+* malformed token. Throws `PassflowAuthError` with `invalid_token` and the reason.
+*/
+function inspectHeader(token) {
+	const segments = token.split(".");
+	const protectedSegment = segments[0];
+	if (segments.length !== 3 || protectedSegment === void 0) throw new require_evaluate.PassflowAuthError("invalid_token", "malformed");
+	const header = decodeProtectedHeader(protectedSegment);
+	if (header === void 0) throw new require_evaluate.PassflowAuthError("invalid_token", "malformed");
+	if (typeof header.alg !== "string" || !ALLOWED_ALGORITHMS.includes(header.alg)) throw new require_evaluate.PassflowAuthError("invalid_token", "alg");
+	if (Object.hasOwn(header, "crit")) throw new require_evaluate.PassflowAuthError("invalid_token", "crit");
+	if (typeof header.kid !== "string" || header.kid === "") throw new require_evaluate.PassflowAuthError("invalid_token", "kid_missing");
+}
+// src/jwks.ts
+/** One failed reload attempt. Internal, and deliberately holds no URL and no underlying error. */
+var JWKSFetchError = class extends Error {
+	stage;
+	constructor(stage) {
+		super(`[passflow] key set reload failed at the ${stage} stage`);
+		this.name = "JWKSFetchError";
+		this.stage = stage;
+	}
+};
+/** No key set can be used right now: the verifier answers 503. */
+var JWKSUnavailableError = class extends Error {
+	constructor(options) {
+		super("[passflow] key set unavailable", options);
+		this.name = "JWKSUnavailableError";
+	}
+};
+/** The key set was reachable and the token's key is not in it: the verifier answers 401. */
+var KeyUnknownError = class extends Error {
+	constructor() {
+		super("[passflow] no key for the token");
+		this.name = "KeyUnknownError";
+	}
+};
+const ACCEPT = "application/json, application/jwk-set+json";
+const ALG_FOR_KTY = {
+	RSA: "RS256",
+	EC: "ES256"
+};
+const PRIVATE_MEMBERS = [
+	"d",
+	"p",
+	"q",
+	"dp",
+	"dq",
+	"qi",
+	"oth"
+];
+const BASE64URL = /^[A-Za-z0-9_-]+$/;
+const MIN_RSA_MODULUS_BITS = 2048;
+const MIN_RSA_EXPONENT = 3;
+const MAX_RSA_EXPONENT = 2147483647;
+const MAX_RSA_EXPONENT_BYTES = 4;
+const P256_COORDINATE_BYTES = 32;
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Go decodes `key_ops` into `[]string`, where a wrong member type is an error and a JSON null is an empty string. */
+function isKeyOperation(value) {
+	return typeof value === "string" || value === null;
+}
+/**
+* Usability is metadata alone and never fails a reload: a key rule 3 could never select is skipped.
+*/
+function isUsableKey(jwk) {
+	const { kty, use, key_ops: keyOps, alg, kid } = jwk;
+	if (typeof kty !== "string" || !Object.hasOwn(ALG_FOR_KTY, kty)) return false;
+	if (use !== void 0 && use !== "sig") return false;
+	if (keyOps !== void 0 && !(Array.isArray(keyOps) && keyOps.every(isKeyOperation) && keyOps.includes("verify"))) return false;
+	if (alg !== void 0 && alg !== ALG_FOR_KTY[kty]) return false;
+	return typeof kid === "string" && kid !== "";
+}
+/**
+* One key member, decoded strictly. WebCrypto's import is no check here: it imports a modulus that is
+* not base64url with length 0, and reads a modulus with a stray trailing character as a longer one.
+*/
+function decodeMember(value) {
+	if (typeof value !== "string" || !BASE64URL.test(value) || value.length % 4 === 1) throw new JWKSFetchError("key");
+	const decoded = jose.base64url.decode(value);
+	if (decoded.length === 0 || jose.base64url.encode(decoded) !== value) throw new JWKSFetchError("key");
+	return decoded;
+}
+/**
+* Big-endian, odd and within [3, 2^31 - 1], as Go's `acceptRSA` requires. WebCrypto imports `e=1` and a
+* token then verifies with no private key. Only significant bytes count, and there are few enough of
+* them that a long `e` is refused before it could lose precision.
+*/
+function isValidExponent(bytes) {
+	const first = bytes.findIndex((byte) => byte !== 0);
+	if (first === -1 || bytes.length - first > MAX_RSA_EXPONENT_BYTES) return false;
+	let exponent = 0;
+	for (const byte of bytes.subarray(first)) exponent = exponent * 256 + byte;
+	return exponent % 2 === 1 && exponent >= MIN_RSA_EXPONENT && exponent <= MAX_RSA_EXPONENT;
+}
+/**
+* The public members of a usable key and nothing else. jose receives this form, so its own usability
+* filter cannot disagree with ours over members such as `ext` or a duplicated `key_ops` entry.
+*/
+function publicMembers(jwk) {
+	const { kty, kid } = jwk;
+	if (kty === "RSA") {
+		const { n, e } = jwk;
+		decodeMember(n);
+		if (!isValidExponent(decodeMember(e))) throw new JWKSFetchError("key");
+		return {
+			kty,
+			kid,
+			n,
+			e
+		};
+	}
+	const { crv, x, y } = jwk;
+	if (crv !== "P-256" || decodeMember(x).length !== P256_COORDINATE_BYTES || decodeMember(y).length !== P256_COORDINATE_BYTES) throw new JWKSFetchError("key");
+	return {
+		kty,
+		kid,
+		crv,
+		x,
+		y
+	};
+}
+/**
+* Acceptance is key material, and one failure fails the whole reload. jose's local set imports lazily
+* at resolution, so without this a malformed or private key would replace a working set and surface
+* as a token defect. A publisher leaking private key material is not trusted at all: keeping the stale
+* set and then answering 503 is the fail-closed response.
+*/
+async function acceptKeys(keys) {
+	const usable = keys.filter(isUsableKey);
+	if (usable.length === 0) throw new JWKSFetchError("key");
+	const accepted = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const jwk of usable) {
+		if (PRIVATE_MEMBERS.some((member) => Object.hasOwn(jwk, member))) throw new JWKSFetchError("key");
+		const members = publicMembers(jwk);
+		const key = await (0, jose.importJWK)(members, ALG_FOR_KTY[members.kty]);
+		if (key instanceof Uint8Array || key.type !== "public") throw new JWKSFetchError("key");
+		if (members.kty === "RSA") {
+			const { modulusLength } = key.algorithm;
+			if (!(modulusLength >= MIN_RSA_MODULUS_BITS)) throw new JWKSFetchError("key");
+		} else if (key.algorithm.namedCurve !== "P-256") throw new JWKSFetchError("key");
+		if (seen.has(members.kid)) throw new JWKSFetchError("key");
+		seen.add(members.kid);
+		accepted.push(members);
+	}
+	return accepted;
+}
+function failureStage(error, fallback) {
+	if (error instanceof JWKSFetchError) return error;
+	const name = error?.name;
+	return new JWKSFetchError(name === "TimeoutError" || name === "AbortError" ? "timeout" : fallback);
+}
+/**
+* Cleanup is best effort and never awaited: a stream whose cancel does not settle must not hold an attempt,
+* and with it the single in-flight reload, open past the failure it is cleaning up after.
+*/
+function cancelQuietly(stream) {
+	try {
+		stream?.cancel().catch(() => void 0);
+	} catch {}
+}
+/** A read that failed or lost to the deadline: the source is told to stop, and the body is not left locked. */
+function abandonReader(reader) {
+	cancelQuietly(reader);
+	try {
+		reader.releaseLock();
+	} catch {}
+}
+async function readBody(response, maxBytes, abort) {
+	const declared = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > maxBytes) {
+		cancelQuietly(response.body);
+		throw new JWKSFetchError("body");
+	}
+	if (response.body === null) return /* @__PURE__ */ new Uint8Array();
+	const reader = response.body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		for (;;) {
+			const { done, value } = await Promise.race([reader.read(), abort]);
+			if (done) break;
+			total += value.byteLength;
+			if (total > maxBytes) throw new JWKSFetchError("body");
+			chunks.push(value);
+		}
+	} catch (error) {
+		abandonReader(reader);
+		throw error;
+	}
+	const body = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return body;
+}
+function parseKeySet(body) {
+	let parsed;
+	try {
+		parsed = JSON.parse(new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		}).decode(body));
+	} catch {
+		throw new JWKSFetchError("parse");
+	}
+	const keys = isPlainObject(parsed) ? parsed.keys : void 0;
+	if (!Array.isArray(keys) || !keys.every(isPlainObject)) throw new JWKSFetchError("parse");
+	return keys;
+}
+/**
+* The fetch and cache half of a verifier, a port of the Go package's rules 1 to 6 over the injected or
+* global `fetch` and the verifier's clock. jose owns the keys and the signature; it never touches the
+* network. `createRemoteJWKSet` is not used: it reports retrieval failures with the same code as token
+* defects, counts success where a wrapper cannot see it, and clocks its cache with `Date.now()`.
+*/
+function createKeySet(options) {
+	const { url, now, maxAge, minRefreshInterval, maxStale, maxBytes, timeout } = options;
+	let local;
+	let lastSuccess;
+	let lastAttempt;
+	let lastAttemptFailed = false;
+	let lastFailure;
+	let inflight;
+	const unavailable = () => new JWKSUnavailableError(lastFailure === void 0 ? void 0 : { cause: lastFailure });
+	const resolver = (protectedHeader, token) => {
+		if (local === void 0) throw new JWKSUnavailableError();
+		return local(protectedHeader, token);
+	};
+	async function retrieve() {
+		const doFetch = options.fetch ?? globalThis.fetch;
+		let response;
+		let abort;
+		let fetched;
+		try {
+			const signal = AbortSignal.timeout(timeout);
+			abort = new Promise((_, reject) => {
+				signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+			});
+			abort.catch(() => void 0);
+			fetched = doFetch(url, {
+				method: "GET",
+				redirect: "manual",
+				signal,
+				headers: { accept: ACCEPT }
+			});
+			response = await Promise.race([fetched, abort]);
+		} catch (error) {
+			fetched?.then((late) => cancelQuietly(late.body), () => void 0);
+			throw failureStage(error, "network");
+		}
+		if (response.status !== 200) {
+			cancelQuietly(response.body);
+			throw new JWKSFetchError("status");
+		}
+		let body;
+		try {
+			body = await readBody(response, maxBytes, abort);
+		} catch (error) {
+			throw failureStage(error, "body");
+		}
+		const keys = parseKeySet(body);
+		try {
+			return (0, jose.createLocalJWKSet)({ keys: await acceptKeys(keys) });
+		} catch (error) {
+			throw error instanceof JWKSFetchError ? error : new JWKSFetchError("key");
+		}
+	}
+	async function attempt() {
+		try {
+			const next = await retrieve();
+			const at = now();
+			local = next;
+			lastSuccess = at;
+			lastAttempt = at;
+			lastAttemptFailed = false;
+			lastFailure = void 0;
+		} catch (error) {
+			lastAttempt = now();
+			lastAttemptFailed = true;
+			lastFailure = failureStage(error, "network");
+			throw lastFailure;
+		}
+	}
+	function reload() {
+		if (inflight === void 0) inflight = attempt().finally(() => {
+			inflight = void 0;
+		});
+		return inflight;
+	}
+	const gateOpen = (at) => lastAttempt === void 0 || at - lastAttempt >= minRefreshInterval;
+	/**
+	* Rules 1 and 2: have a set that may be used, or say why not. `pending` is the reload this call waited
+	* for or left running in the background, which is the one fetch this verification may cost.
+	*/
+	async function prepare() {
+		const at = now();
+		if (local === void 0) {
+			if (inflight === void 0 && !gateOpen(at)) throw unavailable();
+			const pending = reload();
+			await pending.catch(() => {
+				throw unavailable();
+			});
+			return { pending };
+		}
+		const age = at - lastSuccess;
+		if (maxAge !== 0 && !(age > maxAge)) return inflight === void 0 ? {} : { pending: inflight };
+		if (age > maxStale) {
+			if (inflight === void 0 && lastAttemptFailed && !gateOpen(at)) throw unavailable();
+			const pending = reload();
+			await pending.catch(() => void 0);
+			if (now() - lastSuccess > maxStale) throw unavailable();
+			return { pending };
+		}
+		const pending = inflight ?? (gateOpen(at) ? reload() : void 0);
+		pending?.catch(() => void 0);
+		return pending === void 0 ? {} : { pending };
+	}
+	/** Rule 4: returns when a reload succeeded, so the lookup is worth one retry. */
+	async function reloadForMissingKey() {
+		if (inflight === void 0 && !gateOpen(now())) {
+			if (lastAttemptFailed) throw unavailable();
+			throw new KeyUnknownError();
+		}
+		await reload().catch(() => {
+			throw unavailable();
+		});
+	}
+	const isNoMatchingKey = (error) => error instanceof jose.errors.JWKSNoMatchingKey;
+	return {
+		async withKeys(verify) {
+			const { pending } = await prepare();
+			const searched = local;
+			try {
+				return await verify(resolver);
+			} catch (error) {
+				if (!isNoMatchingKey(error)) throw error;
+			}
+			if (pending !== void 0) await pending.catch(() => {
+				throw unavailable();
+			});
+			else if (local === searched) await reloadForMissingKey();
+			try {
+				return await verify(resolver);
+			} catch (error) {
+				if (isNoMatchingKey(error)) throw new KeyUnknownError();
+				throw error;
+			}
+		},
+		async refresh() {
+			if (inflight !== void 0) await inflight.catch(() => void 0);
+			await reload().catch(() => {
+				throw unavailable();
+			});
+		}
+	};
+}
+// src/verifier.ts
+const DEFAULT_LEEWAY_SECONDS = 30;
+const DEFAULT_MAX_AGE = 6e5;
+const DEFAULT_MIN_REFRESH_INTERVAL = 3e4;
+const DEFAULT_MAX_STALE = 36e5;
+const DEFAULT_MAX_BYTES = 1048576;
+const DEFAULT_TIMEOUT = 5e3;
+const MAX_TIMER_MS = 2147483647;
+function isNonEmptyString(value) {
+	return typeof value === "string" && value !== "";
+}
+function requireIssuer(issuer) {
+	if (!isNonEmptyString(issuer)) throw new TypeError("[passflow] issuer must be a non-empty string");
+	return issuer;
+}
+function requireAudiences(audience) {
+	const audiences = typeof audience === "string" ? [audience] : audience;
+	if (!Array.isArray(audiences) || audiences.length === 0 || !audiences.every(isNonEmptyString)) throw new TypeError("[passflow] audience must name one or more non-empty audiences");
+	return [...audiences];
+}
+/** The host of an `http://` URL as written, without userinfo or port. A URL spelled any other way has none. */
+const WRITTEN_HOST = /^http:\/\/(?:[^/?#\\\s]*@)?(\[[^\]]*\]|[^/?#:@\\%\s]*)(?::\d*)?(?:[/?#]|$)/i;
+const LOOPBACK_IPV4 = /^127(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+/**
+* Loopback by the host as written, the rule Go applies. WHATWG normalization would turn `127.1`, `2130706433`
+* and `0x7f.1` into `127.0.0.1`, so a config that starts here would fail to start a Go API. An IPv6 literal
+* takes the normalized form, which gives each address one spelling. A name that merely contains "localhost"
+* is not loopback.
+*/
+function isLoopbackHost(raw, url) {
+	const host = WRITTEN_HOST.exec(raw)?.[1]?.toLowerCase();
+	if (host === void 0) return false;
+	if (host.startsWith("[")) return url.hostname === "[::1]";
+	return host === "localhost" || host.endsWith(".localhost") || LOOPBACK_IPV4.test(host);
+}
+/** The key set is the root of trust. The error names the rule, never the URL. */
+function requireJwksUrl(config, issuer) {
+	const raw = config.jwksUrl ?? `${issuer.replace(/\/+$/, "")}/.well-known/jwks.json`;
+	if (typeof raw !== "string") throw new TypeError("[passflow] jwksUrl must be a URL string");
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new TypeError("[passflow] jwksUrl must be a valid URL");
+	}
+	if (url.protocol === "https:") return raw;
+	if (url.protocol === "http:" && (config.allowInsecureJwksUrl === true || isLoopbackHost(raw, url))) return raw;
+	throw new TypeError("[passflow] jwksUrl must use https unless the host is loopback or allowInsecureJwksUrl is set");
+}
+function requireTokenTypes(tokenTypes) {
+	if (tokenTypes === void 0) return ["access"];
+	if (!Array.isArray(tokenTypes) || tokenTypes.length === 0 || !tokenTypes.every(isNonEmptyString)) throw new TypeError("[passflow] tokenTypes must name one or more token types");
+	return [...tokenTypes];
+}
+/** `undefined` means the default. Anything else must be a finite number within `min`, or a TypeError naming the option. */
+function requireNumber(name, value, fallback, min) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < min) throw new TypeError(`[passflow] ${name} must be a finite number no less than ${String(min)}`);
+	return value;
+}
+function requireJwksOptions(jwks) {
+	if (jwks !== void 0 && (typeof jwks !== "object" || jwks === null)) throw new TypeError("[passflow] jwks must be an object");
+	const maxAge = requireNumber("jwks.maxAge", jwks?.maxAge, DEFAULT_MAX_AGE, 0);
+	const minRefreshInterval = requireNumber("jwks.minRefreshInterval", jwks?.minRefreshInterval, DEFAULT_MIN_REFRESH_INTERVAL, 0);
+	const maxStale = requireNumber("jwks.maxStale", jwks?.maxStale, DEFAULT_MAX_STALE, 0);
+	if (maxStale < maxAge) throw new TypeError("[passflow] jwks.maxStale must not be below jwks.maxAge");
+	const maxBytes = requireNumber("jwks.maxBytes", jwks?.maxBytes, DEFAULT_MAX_BYTES, 1);
+	const timeout = jwks?.timeout === void 0 ? DEFAULT_TIMEOUT : jwks.timeout;
+	if (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > MAX_TIMER_MS) throw new TypeError(`[passflow] jwks.timeout must be an integer between 1 and ${String(MAX_TIMER_MS)}`);
+	if (jwks?.fetch !== void 0 && typeof jwks.fetch !== "function") throw new TypeError("[passflow] jwks.fetch must be a function");
+	return {
+		maxAge,
+		minRefreshInterval,
+		maxStale,
+		maxBytes,
+		timeout,
+		fetch: jwks?.fetch
+	};
+}
+function claimFailureReason(claim) {
+	switch (claim) {
+		case "nbf": return "not_yet_valid";
+		case "iss": return "issuer";
+		case "exp": return "exp_missing";
+		default: return "malformed";
+	}
+}
+/**
+* Only token defects may become a 401. Nothing jose throws here can mean "service down", because jose no
+* longer talks to the network; `ERR_JWKS_INVALID` at resolution and any non-jose error say nothing about
+* the token, so they are key set or runtime defects and answer 503.
+*/
+function toAuthError(error) {
+	if (error instanceof require_evaluate.PassflowAuthError) return error;
+	if (error instanceof KeyUnknownError) return new require_evaluate.PassflowAuthError("invalid_token", "key_unknown");
+	if (error instanceof JWKSUnavailableError) return new require_evaluate.PassflowAuthError("jwks_unavailable", void 0, { cause: error.cause });
+	if (error instanceof jose.errors.JWSSignatureVerificationFailed) return new require_evaluate.PassflowAuthError("invalid_token", "signature");
+	if (error instanceof jose.errors.JWTExpired) return new require_evaluate.PassflowAuthError("invalid_token", "expired");
+	if (error instanceof jose.errors.JWTClaimValidationFailed) return new require_evaluate.PassflowAuthError("invalid_token", claimFailureReason(error.claim));
+	if (error instanceof jose.errors.JWKSMultipleMatchingKeys) return new require_evaluate.PassflowAuthError("invalid_token", "key_unknown");
+	if (error instanceof jose.errors.JWKSInvalid || !(error instanceof jose.errors.JOSEError)) return new require_evaluate.PassflowAuthError("jwks_unavailable");
+	return new require_evaluate.PassflowAuthError("invalid_token", "malformed");
+}
+/**
+* Builds a verifier from a validated configuration and touches no network: the key set loads on the first
+* `verify`, or on `refresh`. Build one per trust policy, at startup: each owns a key cache, and a verifier
+* built per request would defeat it.
+*/
+function createVerifier(config) {
+	if (typeof config !== "object" || config === null) throw new TypeError("[passflow] config must be an object");
+	const issuer = requireIssuer(config.issuer);
+	const audiences = requireAudiences(config.audience);
+	const url = requireJwksUrl(config, issuer);
+	const clockTolerance = requireNumber("leewaySeconds", config.leewaySeconds, DEFAULT_LEEWAY_SECONDS, 0);
+	const tokenTypes = requireTokenTypes(config.tokenTypes);
+	if (config.now !== void 0 && typeof config.now !== "function") throw new TypeError("[passflow] now must be a function");
+	const now = config.now ?? (() => /* @__PURE__ */ new Date());
+	const keySet = createKeySet({
+		url,
+		now: () => now().getTime(),
+		...requireJwksOptions(config.jwks)
+	});
+	const verifier = {
+		async verify(token) {
+			try {
+				if (typeof token !== "string") throw new require_evaluate.PassflowAuthError("invalid_token", "malformed");
+				inspectHeader(token);
+				const { payload } = await keySet.withKeys((resolver) => (0, jose.jwtVerify)(token, resolver, {
+					algorithms: [...ALLOWED_ALGORITHMS],
+					issuer,
+					requiredClaims: ["exp"],
+					clockTolerance,
+					currentDate: now()
+				}));
+				if (payload.iat !== void 0 && !Number.isFinite(payload.iat)) throw new require_evaluate.PassflowAuthError("invalid_token", "malformed");
+				if (!Number.isFinite(payload.exp)) throw new require_evaluate.PassflowAuthError("invalid_token", "exp_missing");
+				const presented = typeof payload.aud === "string" ? [payload.aud] : payload.aud ?? [];
+				if (!Array.isArray(presented) || !presented.every((aud) => typeof aud === "string") || !presented.some((aud) => audiences.includes(aud))) throw new require_evaluate.PassflowAuthError("invalid_token", "audience");
+				if (typeof payload.type !== "string" || !tokenTypes.includes(payload.type)) throw new require_evaluate.PassflowAuthError("invalid_token", "type");
+				const claims = require_evaluate.extractClaims(payload, Math.floor(now().getTime() / 1e3));
+				require_evaluate.recordProvenance(claims, verifier);
+				return claims;
+			} catch (error) {
+				throw toAuthError(error);
+			}
+		},
+		async refresh() {
+			try {
+				await keySet.refresh();
+			} catch (error) {
+				throw toAuthError(error);
+			}
+		}
+	};
+	return verifier;
+}
+exports.AAL1 = require_evaluate.AAL1;
+exports.AAL2 = require_evaluate.AAL2;
+exports.AAL3 = require_evaluate.AAL3;
+exports.ACR_NONE = require_evaluate.ACR_NONE;
+exports.CHALLENGE_HEADER = require_evaluate.CHALLENGE_HEADER;
+exports.CORS_EXPOSED_HEADERS = require_evaluate.CORS_EXPOSED_HEADERS;
+exports.PassflowAuthError = require_evaluate.PassflowAuthError;
+exports.PassflowUsageError = require_evaluate.PassflowUsageError;
+exports.acrLevel = require_evaluate.acrLevel;
+exports.acrSatisfies = require_evaluate.acrSatisfies;
+exports.assertMaxAge = require_evaluate.assertMaxAge;
+exports.authenticate = require_evaluate.authenticate;
+exports.createVerifier = createVerifier;
+exports.evaluate = require_evaluate.evaluate;
+exports.extractBearer = require_evaluate.extractBearer;
+exports.formatChallenge = require_evaluate.formatChallenge;
+exports.isPassflowAuthError = require_evaluate.isPassflowAuthError;
+exports.rolesOf = require_evaluate.rolesOf;
+exports.verifiedBy = require_evaluate.verifiedBy;