antarctic 0.2.0

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Antarctic is a fork of Arctic (https://github.com/pilcrowonpaper/arctic).
+
+Copyright (c) 2023 pilcrowOnPaper
+Copyright (c) 2026 Francisco Presencia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,155 @@
+# Antarctic
+
+Antarctic is a fork of [Arctic](https://arcticjs.dev) by [pilcrowOnPaper](https://github.com/pilcrowOnPaper), adding a high level auth layer on top of its OAuth 2.0 clients. Only the authorization code flow is supported. Built on top of the Fetch API, it's light weight, fully-typed, and runtime-agnostic.
+
+All of the OAuth 2.0 clients and provider coverage are Arctic's work. If you only need those, use [Arctic](https://arcticjs.dev) directly. See [credits](#credits).
+
+```
+npm install antarctic
+```
+
+## High-level API
+
+Construct a provider with an options object and get two methods that handle the whole flow: `getAuthorizationURL()` and `getUser()`. State and PKCE values are generated for you and kept in a [polystore](https://polystore.dev) compatible key-value store.
+
+```ts
+import * as auth from "antarctic";
+import kv from "polystore";
+
+const store = kv(new Map());
+const scopes = ["read:user", "user:email"];
+
+const github = new auth.GitHub({ store, scopes });
+
+// Redirect the user here to sign in.
+const url = await github.getAuthorizationURL();
+
+// In the OAuth callback route:
+const user = await github.getUser(request.url);
+// { id: "1", name: "The Octocat", email: "octocat@github.com", image: "https://..." }
+```
+
+`getUser()` accepts the callback query as a full URL, a query string, a `URLSearchParams`, or a plain object. It validates the `state`, exchanges the code (with PKCE where the provider supports it), fetches the profile, deletes the consumed state, and returns a normalized user: `{ id, name, email, image }`.
+
+Options resolve as `explicit > environment > provider default`. Every option except `store` can come from the environment, named after the provider:
+
+```
+GITHUB_CLIENT_ID
+GITHUB_CLIENT_SECRET
+GITHUB_REDIRECT_URI
+GITHUB_SCOPES
+
+GOOGLE_CLIENT_ID
+...
+```
+
+`GITHUB_SCOPES` takes a list separated by commas, whitespace, or both. Scopes resolve as `argument > constructor > environment > provider default`, where the provider default is the minimal set that yields a full profile:
+
+```ts
+await github.getAuthorizationURL(["repo"]); // overrides the constructor and the environment
+```
+
+The environment is read when the provider is constructed, so load your `.env` file first. See the [documentation](https://documentation.page/github/franciscop/antarctic/) for the details.
+
+Errors thrown by the high-level layer: `InvalidOAuthStateError`, `InvalidOAuthCallbackError`, `OAuthConfigurationError`, and `OAuthProviderError`.
+
+Sessions, cookies, and your user database remain your responsibility: take the returned user and plug it into your framework of choice.
+
+## Low-level API
+
+The original Arctic API is unchanged and remains available on the same objects, including the positional constructors:
+
+```ts
+import * as arctic from "antarctic";
+
+const github = new arctic.GitHub(clientId, clientSecret, redirectURI);
+
+const state = arctic.generateState();
+const scopes = ["user:email"];
+const authorizationURL = github.createAuthorizationURL(state, scopes);
+
+// ...
+
+const tokens = await github.validateAuthorizationCode(code);
+const accessToken = tokens.accessToken();
+```
+
+> Antarctic only supports providers that follow the OAuth 2.0 spec (including PKCE and token revocation).
+
+## Credits
+
+Antarctic is a fork of [Arctic](https://github.com/pilcrowonpaper/arctic), created and maintained by [pilcrowOnPaper](https://github.com/pilcrowOnPaper). The OAuth 2.0 clients, the provider implementations, the docs those pages grew from, and the design that makes all of it consistent are their work. Antarctic adds one layer on top: `getAuthorizationURL()`, `getUser()`, and the option resolution around them.
+
+Arctic is MIT licensed. Antarctic keeps that license and the original copyright notice, and adds its own for the new work. See [LICENSE](./LICENSE).
+
+If you only need the OAuth 2.0 clients without the high level layer, use [Arctic](https://arcticjs.dev) directly. Please report provider issues that are not specific to Antarctic's additions upstream, where they benefit everyone.
+
+## Semver
+
+Antarctic does not strictly follow semantic versioning. While we aim to only introduce breaking changes in major versions, we may introduce them in a minor update if a provider updates their API in a non-backward compatible way. However, they will never be introduced in a patch update.
+
+## Supported providers
+
+- 42 School
+- Amazon Cognito
+- AniList
+- Apple
+- Atlassian
+- Auth0
+- Authentik
+- Autodesk Platform Services
+- Battle.net
+- Bitbucket
+- Box
+- Bungie
+- Coinbase
+- Discord
+- DonationAlerts
+- Dribbble
+- Dropbox
+- Etsy
+- Epic Games
+- Facebook
+- Figma
+- Gitea
+- GitHub
+- GitLab
+- Google
+- Intuit
+- Kakao
+- KeyCloak
+- Kick
+- Lichess
+- Line
+- Linear
+- LinkedIn
+- Mastodon
+- MercadoLibre
+- MercadoPago
+- Microsoft Entra ID
+- MyAnimeList
+- Naver
+- Notion
+- Okta
+- osu!
+- Patreon
+- Polar
+- Reddit
+- Roblox
+- Salesforce
+- Shikimori
+- Slack
+- Spotify
+- Start.gg
+- Strava
+- Synology
+- TikTok
+- Tiltify
+- Tumblr
+- Twitch
+- Twitter
+- VK
+- WorkOS
+- Yahoo
+- Yandex
+- Zoom

package/dist/auth.d.ts

@@ -0,0 +1,63 @@
+export interface OAuthUser {
+    id: string;
+    name?: string | null;
+    email?: string | null;
+    image?: string | null;
+}
+export interface OAuthStateStore {
+    get: (key: string) => Promise<any>;
+    set: (key: string, value: any, options?: {
+        expires?: number | string;
+    }) => Promise<any>;
+    del: (key: string) => Promise<any>;
+}
+export interface ProviderOptions {
+    clientId?: string;
+    clientSecret?: string;
+    redirectURI?: string;
+    scopes?: string[];
+    store: OAuthStateStore;
+}
+export declare class OAuthConfigurationError extends Error {
+}
+export declare class InvalidOAuthCallbackError extends Error {
+}
+export declare class InvalidOAuthStateError extends Error {
+    constructor();
+}
+export declare class OAuthProviderError extends Error {
+    code: string | null;
+    constructor(message: string, code?: string | null);
+}
+export interface AuthConfig {
+    clientId: string;
+    clientSecret: string | null;
+    redirectURI: string | null;
+    scopes: string[] | null;
+    store: OAuthStateStore;
+}
+export declare function resolveProviderOption(explicit: string | undefined, envPrefix: string, envSuffix: string): string | null;
+export declare function requireProviderOption(explicit: string | undefined, envPrefix: string, envSuffix: string, optionName: string): string;
+export declare function resolveAuthConfig(envPrefix: string, options: ProviderOptions, requirements: {
+    clientSecret?: boolean;
+    redirectURI?: boolean;
+}): AuthConfig;
+export declare function requireAuthConfig(auth: AuthConfig | null): AuthConfig;
+export declare function resolveScopes(argument: string[] | undefined, auth: AuthConfig, defaultScopes: string[]): string[];
+export interface StoredOAuthState {
+    codeVerifier?: string;
+    nonce?: string;
+    scopes?: string[];
+}
+export declare function saveOAuthState(store: OAuthStateStore, state: string, payload: StoredOAuthState): Promise<void>;
+export declare function consumeOAuthState(store: OAuthStateStore, state: string): Promise<StoredOAuthState>;
+export type OAuthCallbackQuery = string | URL | URLSearchParams | Record<string, string | string[] | undefined | null>;
+export declare function parseCallbackQuery(query: OAuthCallbackQuery): {
+    code: string;
+    state: string;
+};
+export declare function generateOAuthState(): string;
+export declare function generateOAuthCodeVerifier(): string;
+export declare function fetchUserProfile(url: string | URL, accessToken: string, headers?: Record<string, string>): Promise<Record<string, unknown>>;
+export declare function profileString(value: unknown): string | null;
+export declare function profileId(value: unknown): string;

package/dist/auth.js

@@ -0,0 +1,191 @@
+import { generateCodeVerifier, generateState } from "./oauth2.js";
+export class OAuthConfigurationError extends Error {
+}
+export class InvalidOAuthCallbackError extends Error {
+}
+export class InvalidOAuthStateError extends Error {
+    constructor() {
+        super("Unknown or expired OAuth state");
+    }
+}
+export class OAuthProviderError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code ?? null;
+    }
+}
+function readEnvironment(name) {
+    const env = globalThis.process
+        ?.env;
+    const value = env?.[name];
+    if (value === undefined || value === "") {
+        return null;
+    }
+    return value;
+}
+export function resolveProviderOption(explicit, envPrefix, envSuffix) {
+    return explicit ?? readEnvironment(`${envPrefix}_${envSuffix}`);
+}
+export function requireProviderOption(explicit, envPrefix, envSuffix, optionName) {
+    const value = resolveProviderOption(explicit, envPrefix, envSuffix);
+    if (value === null) {
+        throw new OAuthConfigurationError(`Missing '${optionName}': pass it in the constructor options or set ${envPrefix}_${envSuffix}`);
+    }
+    return value;
+}
+export function resolveAuthConfig(envPrefix, options, requirements) {
+    const clientId = requireProviderOption(options.clientId, envPrefix, "CLIENT_ID", "clientId");
+    let clientSecret;
+    if (requirements.clientSecret === true) {
+        clientSecret = requireProviderOption(options.clientSecret, envPrefix, "CLIENT_SECRET", "clientSecret");
+    }
+    else {
+        clientSecret = resolveProviderOption(options.clientSecret, envPrefix, "CLIENT_SECRET");
+    }
+    let redirectURI;
+    if (requirements.redirectURI === true) {
+        redirectURI = requireProviderOption(options.redirectURI, envPrefix, "REDIRECT_URI", "redirectURI");
+    }
+    else {
+        redirectURI = resolveProviderOption(options.redirectURI, envPrefix, "REDIRECT_URI");
+    }
+    let scopes = options.scopes ?? null;
+    if (scopes === null) {
+        const envScopes = readEnvironment(`${envPrefix}_SCOPES`);
+        if (envScopes !== null) {
+            scopes = envScopes.split(/[\s,]+/).filter((scope) => scope !== "");
+        }
+    }
+    if (options.store === undefined) {
+        throw new OAuthConfigurationError("Missing 'store': pass a polystore-compatible store");
+    }
+    return {
+        clientId,
+        clientSecret,
+        redirectURI,
+        scopes,
+        store: options.store
+    };
+}
+export function requireAuthConfig(auth) {
+    if (auth === null) {
+        throw new OAuthConfigurationError("getAuthorizationURL() and getUser() require the options constructor with a 'store'");
+    }
+    return auth;
+}
+export function resolveScopes(argument, auth, defaultScopes) {
+    return argument ?? auth.scopes ?? defaultScopes;
+}
+const stateKeyPrefix = "arctic:state:";
+const stateExpiresSeconds = 60 * 10;
+export async function saveOAuthState(store, state, payload) {
+    await store.set(stateKeyPrefix + state, payload, { expires: stateExpiresSeconds });
+}
+export async function consumeOAuthState(store, state) {
+    const key = stateKeyPrefix + state;
+    const payload = await store.get(key);
+    if (typeof payload !== "object" || payload === null) {
+        throw new InvalidOAuthStateError();
+    }
+    await store.del(key);
+    return payload;
+}
+export function parseCallbackQuery(query) {
+    let params;
+    if (typeof query === "string") {
+        if (query.startsWith("http://") || query.startsWith("https://")) {
+            params = new URL(query).searchParams;
+        }
+        else {
+            params = new URLSearchParams(query.startsWith("?") ? query.slice(1) : query);
+        }
+    }
+    else if (query instanceof URL) {
+        params = query.searchParams;
+    }
+    else if (query instanceof URLSearchParams) {
+        params = query;
+    }
+    else if (typeof query === "object" && query !== null) {
+        params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (typeof value === "string") {
+                params.set(key, value);
+            }
+            else if (Array.isArray(value) && typeof value[0] === "string") {
+                params.set(key, value[0]);
+            }
+        }
+    }
+    else {
+        throw new InvalidOAuthCallbackError("Invalid callback query");
+    }
+    const error = params.get("error");
+    if (error !== null) {
+        const description = params.get("error_description");
+        throw new OAuthProviderError(`OAuth callback error: ${error}${description !== null ? `: ${description}` : ""}`, error);
+    }
+    const code = params.get("code");
+    const state = params.get("state");
+    if (code === null || code === "" || state === null || state === "") {
+        throw new InvalidOAuthCallbackError("Missing 'code' or 'state' in callback query");
+    }
+    return { code, state };
+}
+export function generateOAuthState() {
+    return generateState();
+}
+export function generateOAuthCodeVerifier() {
+    return generateCodeVerifier();
+}
+export async function fetchUserProfile(url, accessToken, headers) {
+    const request = new Request(url, { method: "GET" });
+    request.headers.set("Authorization", `Bearer ${accessToken}`);
+    request.headers.set("Accept", "application/json");
+    request.headers.set("User-Agent", "arctic");
+    if (headers !== undefined) {
+        for (const [name, value] of Object.entries(headers)) {
+            request.headers.set(name, value);
+        }
+    }
+    let response;
+    try {
+        response = await fetch(request);
+    }
+    catch {
+        throw new OAuthProviderError("Failed to fetch user profile");
+    }
+    if (!response.ok) {
+        if (response.body !== null) {
+            await response.body.cancel();
+        }
+        throw new OAuthProviderError(`User profile request failed with status ${response.status}`);
+    }
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch {
+        throw new OAuthProviderError("User profile response was not valid JSON");
+    }
+    if (typeof data !== "object" || data === null) {
+        throw new OAuthProviderError("Unexpected user profile response body");
+    }
+    return data;
+}
+export function profileString(value) {
+    if (typeof value === "string" && value !== "") {
+        return value;
+    }
+    return null;
+}
+export function profileId(value) {
+    if (typeof value === "string" && value !== "") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return value.toString();
+    }
+    throw new OAuthProviderError("User profile is missing an id");
+}

package/dist/client.d.ts

@@ -0,0 +1,16 @@
+import type { OAuth2Tokens } from "./oauth2.js";
+export declare class OAuth2Client {
+    clientId: string;
+    private clientPassword;
+    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;
+    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>;
+}
+export declare enum CodeChallengeMethod {
+    S256 = 0,
+    Plain = 1
+}

package/dist/client.js

@@ -0,0 +1,105 @@
+import { encodeBasicCredentials, sendTokenRevocationRequest } from "./request.js";
+import { createS256CodeChallenge } from "./oauth2.js";
+import { createOAuth2Request, sendTokenRequest } from "./request.js";
+export class OAuth2Client {
+    clientId;
+    clientPassword;
+    redirectURI;
+    constructor(clientId, clientPassword, redirectURI) {
+        this.clientId = clientId;
+        this.clientPassword = clientPassword;
+        this.redirectURI = redirectURI;
+    }
+    createAuthorizationURL(authorizationEndpoint, state, scopes) {
+        const url = new URL(authorizationEndpoint);
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("client_id", this.clientId);
+        if (this.redirectURI !== null) {
+            url.searchParams.set("redirect_uri", this.redirectURI);
+        }
+        url.searchParams.set("state", state);
+        if (scopes.length > 0) {
+            url.searchParams.set("scope", scopes.join(" "));
+        }
+        return url;
+    }
+    createAuthorizationURLWithPKCE(authorizationEndpoint, state, codeChallengeMethod, codeVerifier, scopes) {
+        const url = new URL(authorizationEndpoint);
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("client_id", this.clientId);
+        if (this.redirectURI !== null) {
+            url.searchParams.set("redirect_uri", this.redirectURI);
+        }
+        url.searchParams.set("state", state);
+        if (codeChallengeMethod === CodeChallengeMethod.S256) {
+            const codeChallenge = createS256CodeChallenge(codeVerifier);
+            url.searchParams.set("code_challenge_method", "S256");
+            url.searchParams.set("code_challenge", codeChallenge);
+        }
+        else if (codeChallengeMethod === CodeChallengeMethod.Plain) {
+            url.searchParams.set("code_challenge_method", "plain");
+            url.searchParams.set("code_challenge", codeVerifier);
+        }
+        if (scopes.length > 0) {
+            url.searchParams.set("scope", scopes.join(" "));
+        }
+        return url;
+    }
+    async validateAuthorizationCode(tokenEndpoint, code, codeVerifier) {
+        const body = new URLSearchParams();
+        body.set("grant_type", "authorization_code");
+        body.set("code", code);
+        if (this.redirectURI !== null) {
+            body.set("redirect_uri", this.redirectURI);
+        }
+        if (codeVerifier !== null) {
+            body.set("code_verifier", codeVerifier);
+        }
+        if (this.clientPassword === null) {
+            body.set("client_id", this.clientId);
+        }
+        const request = createOAuth2Request(tokenEndpoint, body);
+        if (this.clientPassword !== null) {
+            const encodedCredentials = encodeBasicCredentials(this.clientId, this.clientPassword);
+            request.headers.set("Authorization", `Basic ${encodedCredentials}`);
+        }
+        const tokens = await sendTokenRequest(request);
+        return tokens;
+    }
+    async refreshAccessToken(tokenEndpoint, refreshToken, scopes) {
+        const body = new URLSearchParams();
+        body.set("grant_type", "refresh_token");
+        body.set("refresh_token", refreshToken);
+        if (this.clientPassword === null) {
+            body.set("client_id", this.clientId);
+        }
+        if (scopes.length > 0) {
+            body.set("scope", scopes.join(" "));
+        }
+        const request = createOAuth2Request(tokenEndpoint, body);
+        if (this.clientPassword !== null) {
+            const encodedCredentials = encodeBasicCredentials(this.clientId, this.clientPassword);
+            request.headers.set("Authorization", `Basic ${encodedCredentials}`);
+        }
+        const tokens = await sendTokenRequest(request);
+        return tokens;
+    }
+    async revokeToken(tokenRevocationEndpoint, token) {
+        const body = new URLSearchParams();
+        body.set("token", token);
+        if (this.clientPassword === null) {
+            body.set("client_id", this.clientId);
+        }
+        const request = createOAuth2Request(tokenRevocationEndpoint, body);
+        if (this.clientPassword !== null) {
+            const encodedCredentials = encodeBasicCredentials(this.clientId, this.clientPassword);
+            request.headers.set("Authorization", `Basic ${encodedCredentials}`);
+        }
+        await sendTokenRevocationRequest(request);
+    }
+}
+export var CodeChallengeMethod;
+(function (CodeChallengeMethod) {
+    CodeChallengeMethod[CodeChallengeMethod["S256"] = 0] = "S256";
+    CodeChallengeMethod[CodeChallengeMethod["Plain"] = 1] = "Plain";
+})(CodeChallengeMethod || (CodeChallengeMethod = {}));

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+export { AmazonCognito } from "./providers/amazon-cognito.js";
+export { AniList } from "./providers/anilist.js";
+export { Apple } from "./providers/apple.js";
+export { Atlassian } from "./providers/atlassian.js";
+export { Auth0 } from "./providers/auth0.js";
+export { Authentik } from "./providers/authentik.js";
+export { Autodesk } from "./providers/autodesk.js";
+export { BattleNet } from "./providers/battlenet.js";
+export { Bitbucket } from "./providers/bitbucket.js";
+export { Box } from "./providers/box.js";
+export { Bungie } from "./providers/bungie.js";
+export { Coinbase } from "./providers/coinbase.js";
+export { Discord } from "./providers/discord.js";
+export { DonationAlerts } from "./providers/donation-alerts.js";
+export { Dribbble } from "./providers/dribbble.js";
+export { Dropbox } from "./providers/dropbox.js";
+export { Etsy } from "./providers/etsy.js";
+export { EpicGames } from "./providers/epicgames.js";
+export { Facebook } from "./providers/facebook.js";
+export { Figma } from "./providers/figma.js";
+export { Gitea } from "./providers/gitea.js";
+export { GitHub } from "./providers/github.js";
+export { GitLab } from "./providers/gitlab.js";
+export { Google } from "./providers/google.js";
+export { Intuit } from "./providers/intuit.js";
+export { Kakao } from "./providers/kakao.js";
+export { Kick } from "./providers/kick.js";
+export { KeyCloak } from "./providers/keycloak.js";
+export { Lichess } from "./providers/lichess.js";
+export { Line } from "./providers/line.js";
+export { Linear } from "./providers/linear.js";
+export { LinkedIn } from "./providers/linkedin.js";
+export { Mastodon } from "./providers/mastodon.js";
+export { MercadoLibre } from "./providers/mercadolibre.js";
+export { MercadoPago } from "./providers/mercadopago.js";
+export { MicrosoftEntraId } from "./providers/microsoft-entra-id.js";
+export { MyAnimeList } from "./providers/myanimelist.js";
+export { Naver } from "./providers/naver.js";
+export { Notion } from "./providers/notion.js";
+export { Okta } from "./providers/okta.js";
+export { Osu } from "./providers/osu.js";
+export { Patreon } from "./providers/patreon.js";
+export { Polar } from "./providers/polar.js";
+export { Reddit } from "./providers/reddit.js";
+export { Roblox } from "./providers/roblox.js";
+export { Salesforce } from "./providers/salesforce.js";
+export { Shikimori } from "./providers/shikimori.js";
+export { Slack } from "./providers/slack.js";
+export { Spotify } from "./providers/spotify.js";
+export { StartGG } from "./providers/startgg.js";
+export { Strava } from "./providers/strava.js";
+export { Synology } from "./providers/synology.js";
+export { TikTok } from "./providers/tiktok.js";
+export { Tiltify } from "./providers/tiltify.js";
+export { Tumblr } from "./providers/tumblr.js";
+export { Twitch } from "./providers/twitch.js";
+export { Twitter } from "./providers/twitter.js";
+export { VK } from "./providers/vk.js";
+export { Withings } from "./providers/withings.js";
+export { WorkOS } from "./providers/workos.js";
+export { Yahoo } from "./providers/yahoo.js";
+export { Yandex } from "./providers/yandex.js";
+export { Zoom } from "./providers/zoom.js";
+export { FortyTwo } from "./providers/42.js";
+export { OAuth2Client, CodeChallengeMethod } from "./client.js";
+export { OAuth2Tokens, generateCodeVerifier, generateState } from "./oauth2.js";
+export { OAuth2RequestError, ArcticFetchError, UnexpectedErrorResponseBodyError, UnexpectedResponseError } from "./request.js";
+export { decodeIdToken } from "./oidc.js";
+export { InvalidOAuthCallbackError, InvalidOAuthStateError, OAuthConfigurationError, OAuthProviderError } from "./auth.js";
+export type { OAuthCallbackQuery, OAuthStateStore, OAuthUser, ProviderOptions } from "./auth.js";