antarctic 0.2.0 → 0.4.0

package/dist/client.d.ts

@@ -5,7 +5,7 @@ export declare class OAuth2Client {
     private redirectURI;
     constructor(clientId: string, clientPassword: string | null, redirectURI: string | null);
     createAuthorizationURL(authorizationEndpoint: string, state: string, scopes: string[]): URL;
-    createAuthorizationURLWithPKCE(authorizationEndpoint: string, state: string, codeChallengeMethod: CodeChallengeMethod, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURLWithPKCE(authorizationEndpoint: string, state: string, codeChallengeMethod: CodeChallengeMethod, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(tokenEndpoint: string, code: string, codeVerifier: string | null): Promise<OAuth2Tokens>;
     refreshAccessToken(tokenEndpoint: string, refreshToken: string, scopes: string[]): Promise<OAuth2Tokens>;
     revokeToken(tokenRevocationEndpoint: string, token: string): Promise<void>;

package/dist/client.js

@@ -23,7 +23,7 @@ export class OAuth2Client {
         }
         return url;
     }
-    createAuthorizationURLWithPKCE(authorizationEndpoint, state, codeChallengeMethod, codeVerifier, scopes) {
+    async createAuthorizationURLWithPKCE(authorizationEndpoint, state, codeChallengeMethod, codeVerifier, scopes) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("response_type", "code");
         url.searchParams.set("client_id", this.clientId);
@@ -32,7 +32,7 @@ export class OAuth2Client {
         }
         url.searchParams.set("state", state);
         if (codeChallengeMethod === CodeChallengeMethod.S256) {
-            const codeChallenge = createS256CodeChallenge(codeVerifier);
+            const codeChallenge = await createS256CodeChallenge(codeVerifier);
             url.searchParams.set("code_challenge_method", "S256");
             url.searchParams.set("code_challenge", codeChallenge);
         }

package/dist/encoding.d.ts

@@ -0,0 +1,3 @@
+export declare function encodeBase64(bytes: Uint8Array): string;
+export declare function encodeBase64urlNoPadding(bytes: Uint8Array): string;
+export declare function decodeBase64urlIgnorePadding(encoded: string): Uint8Array;

package/dist/encoding.js

@@ -0,0 +1,39 @@
+const base64urlAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function encodeBinaryString(bytes) {
+    let binary = "";
+    // Chunked to stay well under the argument limit for large inputs.
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    }
+    return binary;
+}
+export function encodeBase64(bytes) {
+    return btoa(encodeBinaryString(bytes));
+}
+export function encodeBase64urlNoPadding(bytes) {
+    let result = "";
+    for (let i = 0; i < bytes.length; i += 3) {
+        let buffer = 0;
+        let bits = 0;
+        for (let j = 0; j < 3 && i + j < bytes.length; j++) {
+            buffer = (buffer << 8) | bytes[i + j];
+            bits += 8;
+        }
+        for (let j = 0; j < 4 && bits > 0; j++) {
+            bits -= 6;
+            const index = bits >= 0 ? (buffer >> bits) & 0x3f : (buffer << -bits) & 0x3f;
+            result += base64urlAlphabet[index];
+        }
+    }
+    return result;
+}
+export function decodeBase64urlIgnorePadding(encoded) {
+    const normalized = encoded.replaceAll("-", "+").replaceAll("_", "/").replaceAll("=", "");
+    const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}

package/dist/jwt.d.ts

@@ -0,0 +1,3 @@
+export declare function decodeJWT(jwt: string): object;
+export declare function createJWTSignatureMessage(headerJSON: string, payloadJSON: string): Uint8Array;
+export declare function encodeJWT(headerJSON: string, payloadJSON: string, signature: Uint8Array): string;

package/dist/jwt.js

@@ -0,0 +1,38 @@
+import { decodeBase64urlIgnorePadding, encodeBase64urlNoPadding } from "./encoding.js";
+export function decodeJWT(jwt) {
+    const parts = jwt.split(".");
+    if (parts.length !== 3) {
+        throw new Error("Invalid JWT");
+    }
+    let jsonPayload;
+    try {
+        jsonPayload = new TextDecoder().decode(decodeBase64urlIgnorePadding(parts[1]));
+    }
+    catch {
+        throw new Error("Invalid JWT: Invalid base64url encoding");
+    }
+    let payload;
+    try {
+        payload = JSON.parse(jsonPayload);
+    }
+    catch {
+        throw new Error("Invalid JWT: Invalid JSON encoding");
+    }
+    if (typeof payload !== "object" || payload === null) {
+        throw new Error("Invalid JWT: Invalid payload");
+    }
+    return payload;
+}
+export function createJWTSignatureMessage(headerJSON, payloadJSON) {
+    const encoder = new TextEncoder();
+    const encodedHeader = encodeBase64urlNoPadding(encoder.encode(headerJSON));
+    const encodedPayload = encodeBase64urlNoPadding(encoder.encode(payloadJSON));
+    return encoder.encode(encodedHeader + "." + encodedPayload);
+}
+export function encodeJWT(headerJSON, payloadJSON, signature) {
+    const encoder = new TextEncoder();
+    const encodedHeader = encodeBase64urlNoPadding(encoder.encode(headerJSON));
+    const encodedPayload = encodeBase64urlNoPadding(encoder.encode(payloadJSON));
+    const encodedSignature = encodeBase64urlNoPadding(signature);
+    return encodedHeader + "." + encodedPayload + "." + encodedSignature;
+}

package/dist/oauth2.d.ts

@@ -11,6 +11,6 @@ export declare class OAuth2Tokens {
     scopes(): string[];
     idToken(): string;
 }
-export declare function createS256CodeChallenge(codeVerifier: string): string;
+export declare function createS256CodeChallenge(codeVerifier: string): Promise<string>;
 export declare function generateCodeVerifier(): string;
 export declare function generateState(): string;

package/dist/oauth2.js

@@ -1,5 +1,4 @@
-import * as encoding from "@oslojs/encoding";
-import * as sha2 from "@oslojs/crypto/sha2";
+import { encodeBase64urlNoPadding } from "./encoding.js";
 export class OAuth2Tokens {
     data;
     constructor(data) {
@@ -51,17 +50,18 @@ export class OAuth2Tokens {
         throw new Error("Missing or invalid field 'id_token'");
     }
 }
-export function createS256CodeChallenge(codeVerifier) {
-    const codeChallengeBytes = sha2.sha256(new TextEncoder().encode(codeVerifier));
-    return encoding.encodeBase64urlNoPadding(codeChallengeBytes);
+export async function createS256CodeChallenge(codeVerifier) {
+    const data = new TextEncoder().encode(codeVerifier);
+    const digest = await crypto.subtle.digest("SHA-256", data);
+    return encodeBase64urlNoPadding(new Uint8Array(digest));
 }
 export function generateCodeVerifier() {
     const randomValues = new Uint8Array(32);
     crypto.getRandomValues(randomValues);
-    return encoding.encodeBase64urlNoPadding(randomValues);
+    return encodeBase64urlNoPadding(randomValues);
 }
 export function generateState() {
     const randomValues = new Uint8Array(32);
     crypto.getRandomValues(randomValues);
-    return encoding.encodeBase64urlNoPadding(randomValues);
+    return encodeBase64urlNoPadding(randomValues);
 }

package/dist/oidc.js

@@ -1,7 +1,7 @@
-import * as jwt from "@oslojs/jwt";
+import { decodeJWT } from "./jwt.js";
 export function decodeIdToken(idToken) {
     try {
-        return jwt.decodeJWT(idToken);
+        return decodeJWT(idToken);
     }
     catch (e) {
         throw new Error("Invalid ID token", {

package/dist/providers/amazon-cognito.d.ts

@@ -12,7 +12,7 @@ export declare class AmazonCognito {
     private auth;
     constructor(options: AmazonCognitoOptions);
     constructor(domain: string, clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string, scopes: string[]): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/amazon-cognito.js

@@ -26,8 +26,8 @@ export class AmazonCognito {
         this.tokenRevocationEndpoint = `https://${domain}/oauth2/revoke`;
         this.userinfoEndpoint = `https://${domain}/oauth2/userInfo`;
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -45,7 +45,7 @@ export class AmazonCognito {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/apple.js

@@ -1,4 +1,4 @@
-import * as jwt from "@oslojs/jwt";
+import { createJWTSignatureMessage, encodeJWT } from "../jwt.js";
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
 import { decodeIdToken } from "../oidc.js";
 import { consumeOAuthState, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
@@ -99,8 +99,8 @@ export class Apple {
         const signature = new Uint8Array(await crypto.subtle.sign({
             name: "ECDSA",
             hash: "SHA-256"
-        }, privateKey, jwt.createJWTSignatureMessage(headerJSON, payloadJSON)));
-        const token = jwt.encodeJWT(headerJSON, payloadJSON, signature);
+        }, privateKey, createJWTSignatureMessage(headerJSON, payloadJSON)));
+        const token = encodeJWT(headerJSON, payloadJSON, signature);
         return token;
     }
 }

package/dist/providers/auth0.d.ts

@@ -12,7 +12,7 @@ export declare class Auth0 {
     private auth;
     constructor(options: Auth0Options);
     constructor(domain: string, clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string | null): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/auth0.js

@@ -26,10 +26,10 @@ export class Auth0 {
         this.tokenRevocationEndpoint = `https://${domain}/oauth/revoke`;
         this.userinfoEndpoint = `https://${domain}/userinfo`;
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         let url;
         if (codeVerifier !== null) {
-            url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+            url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         }
         else {
             url = this.client.createAuthorizationURL(this.authorizationEndpoint, state, scopes);
@@ -51,7 +51,7 @@ export class Auth0 {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/authentik.d.ts

@@ -12,7 +12,7 @@ export declare class Authentik {
     private auth;
     constructor(options: AuthentikOptions);
     constructor(baseURL: string, clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/authentik.js

@@ -27,8 +27,8 @@ export class Authentik {
         this.tokenRevocationEndpoint = joinURIAndPath(baseURL, "/application/o/revoke/");
         this.userinfoEndpoint = joinURIAndPath(baseURL, "/application/o/userinfo/");
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -46,7 +46,7 @@ export class Authentik {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/autodesk.d.ts

@@ -7,7 +7,7 @@ export declare class Autodesk {
     private auth;
     constructor(options: AutodeskOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/autodesk.js

@@ -18,8 +18,8 @@ export class Autodesk {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -37,7 +37,7 @@ export class Autodesk {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/discord.d.ts

@@ -7,7 +7,7 @@ export declare class Discord {
     private auth;
     constructor(options: DiscordOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string | null): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/discord.js

@@ -18,10 +18,10 @@ export class Discord {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         let url;
         if (codeVerifier !== null) {
-            url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+            url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         }
         else {
             url = this.client.createAuthorizationURL(authorizationEndpoint, state, scopes);
@@ -43,7 +43,7 @@ export class Discord {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/etsy.d.ts

@@ -7,7 +7,7 @@ export declare class Etsy {
     private auth;
     constructor(options: EtsyOptions);
     constructor(clientId: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<URL>;

package/dist/providers/etsy.js

@@ -18,8 +18,8 @@ export class Etsy {
             this.client = new OAuth2Client(clientIdOrOptions, null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -34,7 +34,7 @@ export class Etsy {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/gitea.d.ts

@@ -11,7 +11,7 @@ export declare class Gitea {
     private auth;
     constructor(options: GiteaOptions);
     constructor(baseURL: string, clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<URL>;

package/dist/providers/gitea.js

@@ -22,8 +22,8 @@ export class Gitea {
         this.authorizationEndpoint = joinURIAndPath(this.baseURL, "/login/oauth/authorize");
         this.tokenEndpoint = joinURIAndPath(this.baseURL, "/login/oauth/access_token");
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -38,7 +38,7 @@ export class Gitea {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/google.d.ts

@@ -7,7 +7,7 @@ export declare class Google {
     private auth;
     constructor(options: GoogleOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/google.js

@@ -22,8 +22,8 @@ export class Google {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -41,7 +41,7 @@ export class Google {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/keycloak.d.ts

@@ -12,7 +12,7 @@ export declare class KeyCloak {
     private auth;
     constructor(options: KeyCloakOptions);
     constructor(realmURL: string, clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/keycloak.js

@@ -26,8 +26,8 @@ export class KeyCloak {
         this.tokenRevocationEndpoint = realmURL + "/protocol/openid-connect/revoke";
         this.userinfoEndpoint = realmURL + "/protocol/openid-connect/userinfo";
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -45,7 +45,7 @@ export class KeyCloak {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/kick.d.ts

@@ -9,7 +9,7 @@ export declare class Kick {
     private auth;
     constructor(options: KickOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/kick.js

@@ -28,7 +28,7 @@ export class Kick {
             this.redirectURI = redirectURI ?? "";
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("client_id", this.clientId);
         url.searchParams.set("response_type", "code");
@@ -37,7 +37,7 @@ export class Kick {
         if (scopes.length > 0) {
             url.searchParams.set("scope", scopes.join(" "));
         }
-        const codeChallenge = createS256CodeChallenge(codeVerifier);
+        const codeChallenge = await createS256CodeChallenge(codeVerifier);
         url.searchParams.set("code_challenge", codeChallenge);
         url.searchParams.set("code_challenge_method", "S256");
         return url;
@@ -74,7 +74,7 @@ export class Kick {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/lichess.d.ts

@@ -7,7 +7,7 @@ export declare class Lichess {
     private auth;
     constructor(options: LichessOptions);
     constructor(clientId: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<URL>;
     getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;

package/dist/providers/lichess.js

@@ -18,8 +18,8 @@ export class Lichess {
             this.client = new OAuth2Client(clientIdOrOptions, null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -30,7 +30,7 @@ export class Lichess {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/line.d.ts

@@ -9,7 +9,7 @@ export declare class Line {
     private auth;
     constructor(options: LineOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<URL>;

package/dist/providers/line.js

@@ -28,7 +28,7 @@ export class Line {
             this.redirectURI = redirectURI ?? "";
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("response_type", "code");
         url.searchParams.set("client_id", this.clientId);
@@ -37,7 +37,7 @@ export class Line {
             url.searchParams.set("scope", scopes.join(" "));
         }
         url.searchParams.set("redirect_uri", this.redirectURI);
-        const codeChallenge = createS256CodeChallenge(codeVerifier);
+        const codeChallenge = await createS256CodeChallenge(codeVerifier);
         url.searchParams.set("code_challenge_method", "S256");
         url.searchParams.set("code_challenge", codeChallenge);
         return url;
@@ -68,7 +68,7 @@ export class Line {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/mastodon.d.ts

@@ -12,7 +12,7 @@ export declare class Mastodon {
     private auth;
     constructor(options: MastodonOptions);
     constructor(baseURL: string, clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;
     getAuthorizationURL(scopes?: string[]): Promise<URL>;

package/dist/providers/mastodon.js

@@ -29,8 +29,8 @@ export class Mastodon {
         this.tokenRevocationEndpoint = joinURIAndPath(baseURL, "/api/v1/oauth/revoke");
         this.userEndpoint = joinURIAndPath(baseURL, "/api/v1/accounts/verify_credentials");
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -44,7 +44,7 @@ export class Mastodon {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/mercadolibre.d.ts

@@ -9,7 +9,7 @@ export declare class MercadoLibre {
     private auth;
     constructor(options: MercadoLibreOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string): URL;
+    createAuthorizationURL(state: string, codeVerifier: string): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<URL>;

package/dist/providers/mercadolibre.js

@@ -27,13 +27,13 @@ export class MercadoLibre {
         }
     }
     // `scopes` not required since they are defined in the application settings
-    createAuthorizationURL(state, codeVerifier) {
+    async createAuthorizationURL(state, codeVerifier) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("response_type", "code");
         url.searchParams.set("client_id", this.clientId);
         url.searchParams.set("redirect_uri", this.redirectURI);
         url.searchParams.set("state", state);
-        const codeChallenge = createS256CodeChallenge(codeVerifier);
+        const codeChallenge = await createS256CodeChallenge(codeVerifier);
         url.searchParams.set("code_challenge_method", "S256");
         url.searchParams.set("code_challenge", codeChallenge);
         return url;
@@ -65,7 +65,7 @@ export class MercadoLibre {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier);
+        const url = await this.createAuthorizationURL(state, codeVerifier);
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/mercadopago.d.ts

@@ -9,7 +9,7 @@ export declare class MercadoPago {
     private auth;
     constructor(options: MercadoPagoOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string): URL;
+    createAuthorizationURL(state: string, codeVerifier: string): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<URL>;

package/dist/providers/mercadopago.js

@@ -27,13 +27,13 @@ export class MercadoPago {
         }
     }
     // `scopes` not required since they are defined in the application settings
-    createAuthorizationURL(state, codeVerifier) {
+    async createAuthorizationURL(state, codeVerifier) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("response_type", "code");
         url.searchParams.set("client_id", this.clientId);
         url.searchParams.set("redirect_uri", this.redirectURI);
         url.searchParams.set("state", state);
-        const codeChallenge = createS256CodeChallenge(codeVerifier);
+        const codeChallenge = await createS256CodeChallenge(codeVerifier);
         url.searchParams.set("code_challenge_method", "S256");
         url.searchParams.set("code_challenge", codeChallenge);
         return url;
@@ -65,7 +65,7 @@ export class MercadoPago {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier);
+        const url = await this.createAuthorizationURL(state, codeVerifier);
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/microsoft-entra-id.d.ts

@@ -12,7 +12,7 @@ export declare class MicrosoftEntraId {
     private auth;
     constructor(options: MicrosoftEntraIdOptions);
     constructor(tenant: string, clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string, scopes: string[]): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<URL>;

package/dist/providers/microsoft-entra-id.js

@@ -30,13 +30,13 @@ export class MicrosoftEntraId {
         this.authorizationEndpoint = joinURIAndPath("https://login.microsoftonline.com", tenant, "/oauth2/v2.0/authorize");
         this.tokenEndpoint = joinURIAndPath("https://login.microsoftonline.com", tenant, "/oauth2/v2.0/token");
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         const url = new URL(this.authorizationEndpoint);
         url.searchParams.set("response_type", "code");
         url.searchParams.set("client_id", this.clientId);
         url.searchParams.set("redirect_uri", this.redirectURI);
         url.searchParams.set("state", state);
-        const codeChallenge = createS256CodeChallenge(codeVerifier);
+        const codeChallenge = await createS256CodeChallenge(codeVerifier);
         url.searchParams.set("code_challenge_method", "S256");
         url.searchParams.set("code_challenge", codeChallenge);
         if (scopes.length > 0) {
@@ -91,7 +91,7 @@ export class MicrosoftEntraId {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/myanimelist.d.ts

@@ -7,7 +7,7 @@ export declare class MyAnimeList {
     private auth;
     constructor(options: MyAnimeListOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string | null);
-    createAuthorizationURL(state: string, codeVerifier: string): URL;
+    createAuthorizationURL(state: string, codeVerifier: string): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<URL>;

package/dist/providers/myanimelist.js

@@ -16,8 +16,8 @@ export class MyAnimeList {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.Plain, codeVerifier, []);
+    async createAuthorizationURL(state, codeVerifier) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.Plain, codeVerifier, []);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -33,7 +33,7 @@ export class MyAnimeList {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier);
+        const url = await this.createAuthorizationURL(state, codeVerifier);
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/okta.d.ts

@@ -13,7 +13,7 @@ export declare class Okta {
     private auth;
     constructor(options: OktaOptions);
     constructor(domain: string, authorizationServerId: string | null, clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string, scopes: string[]): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/okta.js

@@ -37,8 +37,8 @@ export class Okta {
         this.tokenRevocationEndpoint = joinURIAndPath(baseURL, "/v1/revoke");
         this.userinfoEndpoint = joinURIAndPath(baseURL, "/v1/userinfo");
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -56,7 +56,7 @@ export class Okta {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/polar.d.ts

@@ -9,7 +9,7 @@ export declare class Polar {
     private auth;
     constructor(options: PolarOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/polar.js

@@ -26,7 +26,7 @@ export class Polar {
             this.redirectURI = redirectURI ?? "";
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("client_id", this.clientId);
         url.searchParams.set("response_type", "code");
@@ -35,7 +35,7 @@ export class Polar {
         if (scopes.length > 0) {
             url.searchParams.set("scope", scopes.join(" "));
         }
-        const codeChallenge = createS256CodeChallenge(codeVerifier);
+        const codeChallenge = await createS256CodeChallenge(codeVerifier);
         url.searchParams.set("code_challenge", codeChallenge);
         url.searchParams.set("code_challenge_method", "S256");
         return url;
@@ -76,7 +76,7 @@ export class Polar {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/roblox.d.ts

@@ -7,7 +7,7 @@ export declare class Roblox {
     private auth;
     constructor(options: RobloxOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/roblox.js

@@ -19,8 +19,8 @@ export class Roblox {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -38,7 +38,7 @@ export class Roblox {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/salesforce.d.ts

@@ -12,7 +12,7 @@ export declare class Salesforce {
     private auth;
     constructor(options: SalesforceOptions);
     constructor(domain: string, clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/salesforce.js

@@ -26,8 +26,8 @@ export class Salesforce {
         this.tokenRevocationEndpoint = `https://${domain}/services/oauth2/revoke`;
         this.userinfoEndpoint = `https://${domain}/services/oauth2/userinfo`;
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -45,7 +45,7 @@ export class Salesforce {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/spotify.d.ts

@@ -7,7 +7,7 @@ export declare class Spotify {
     private auth;
     constructor(options: SpotifyOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string | null): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<URL>;

package/dist/providers/spotify.js

@@ -17,10 +17,10 @@ export class Spotify {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? "");
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         let url;
         if (codeVerifier !== null) {
-            url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+            url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         }
         else {
             url = this.client.createAuthorizationURL(authorizationEndpoint, state, scopes);
@@ -39,7 +39,7 @@ export class Spotify {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/synology.d.ts

@@ -4,6 +4,6 @@ export declare class Synology {
     private tokenEndpoint;
     private client;
     constructor(baseURL: string, applicationId: string, applicationSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
 }

package/dist/providers/synology.js

@@ -9,8 +9,8 @@ export class Synology {
         this.tokenEndpoint = joinURIAndPath(baseURL, "/webman/sso/SSOAccessToken.cgi");
         this.client = new OAuth2Client(applicationId, applicationSecret, redirectURI);
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(this.authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {

package/dist/providers/tiktok.d.ts

@@ -9,7 +9,7 @@ export declare class TikTok {
     private auth;
     constructor(options: TikTokOptions);
     constructor(clientKey: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/tiktok.js

@@ -28,12 +28,12 @@ export class TikTok {
             this.redirectURI = redirectURI ?? "";
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
+    async createAuthorizationURL(state, codeVerifier, scopes) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("response_type", "code");
         url.searchParams.set("client_key", this.clientKey);
         url.searchParams.set("state", state);
-        const codeChallenge = createS256CodeChallenge(codeVerifier);
+        const codeChallenge = await createS256CodeChallenge(codeVerifier);
         url.searchParams.set("code_challenge_method", "S256");
         url.searchParams.set("code_challenge", codeChallenge);
         if (scopes.length > 0) {
@@ -76,7 +76,7 @@ export class TikTok {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/twitter.d.ts

@@ -7,7 +7,7 @@ export declare class Twitter {
     private auth;
     constructor(options: TwitterOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/twitter.js

@@ -18,8 +18,8 @@ export class Twitter {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -37,7 +37,7 @@ export class Twitter {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/workos.d.ts

@@ -9,7 +9,7 @@ export declare class WorkOS {
     private auth;
     constructor(options: WorkOSOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string | null): URL;
+    createAuthorizationURL(state: string, codeVerifier: string | null): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string | null): Promise<OAuth2Tokens>;
     getAuthorizationURL(): Promise<URL>;
     getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;

package/dist/providers/workos.js

@@ -23,14 +23,14 @@ export class WorkOS {
             this.redirectURI = redirectURI ?? "";
         }
     }
-    createAuthorizationURL(state, codeVerifier) {
+    async createAuthorizationURL(state, codeVerifier) {
         const url = new URL(authorizationEndpoint);
         url.searchParams.set("response_type", "code");
         url.searchParams.set("client_id", this.clientId);
         url.searchParams.set("state", state);
         url.searchParams.set("redirect_uri", this.redirectURI);
         if (codeVerifier !== null) {
-            const codeChallenge = createS256CodeChallenge(codeVerifier);
+            const codeChallenge = await createS256CodeChallenge(codeVerifier);
             url.searchParams.set("code_challenge_method", "S256");
             url.searchParams.set("code_challenge", codeChallenge);
         }
@@ -56,7 +56,7 @@ export class WorkOS {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier);
+        const url = await this.createAuthorizationURL(state, codeVerifier);
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/providers/zoom.d.ts

@@ -7,7 +7,7 @@ export declare class Zoom {
     private auth;
     constructor(options: ZoomOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
-    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): URL;
+    createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;

package/dist/providers/zoom.js

@@ -21,8 +21,8 @@ export class Zoom {
             this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? "", redirectURI ?? "");
         }
     }
-    createAuthorizationURL(state, codeVerifier, scopes) {
-        const url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+    async createAuthorizationURL(state, codeVerifier, scopes) {
+        const url = await this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
         return url;
     }
     async validateAuthorizationCode(code, codeVerifier) {
@@ -40,7 +40,7 @@ export class Zoom {
         const auth = requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
-        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         await saveOAuthState(auth.store, state, { codeVerifier });
         return url;
     }

package/dist/request.js

@@ -1,4 +1,4 @@
-import * as encoding from "@oslojs/encoding";
+import { encodeBase64 } from "./encoding.js";
 import { OAuth2Tokens } from "./oauth2.js";
 import { trimLeft, trimRight } from "./utils.js";
 export function joinURIAndPath(base, ...path) {
@@ -24,7 +24,7 @@ export function createOAuth2Request(endpoint, body) {
 }
 export function encodeBasicCredentials(username, password) {
     const bytes = new TextEncoder().encode(`${username}:${password}`);
-    return encoding.encodeBase64(bytes);
+    return encodeBase64(bytes);
 }
 export async function sendTokenRequest(request) {
     let response;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "antarctic",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"description": "High-level OAuth 2.0 clients for popular providers, forked from Arctic",
 	"type": "module",
 	"main": "dist/index.js",
@@ -33,10 +33,5 @@
 		"prettier": "^3.0.3",
 		"typescript": "^5.2.2",
 		"vitest": "1.6.0"
-	},
-	"dependencies": {
-		"@oslojs/crypto": "1.0.1",
-		"@oslojs/encoding": "1.1.0",
-		"@oslojs/jwt": "0.2.0"
 	}
 }

package/{README.md → readme.md}

@@ -57,7 +57,7 @@ Sessions, cookies, and your user database remain your responsibility: take the r
 
 ## Low-level API
 
-The original Arctic API is unchanged and remains available on the same objects, including the positional constructors:
+Arctic's low level API remains available on the same objects, including the positional constructors. It is unchanged except that PKCE providers build the URL asynchronously, so `createAuthorizationURL()` returns a promise for them:
 
 ```ts
 import * as arctic from "antarctic";