@openai-oauth/core 2.0.0-beta.0

package/dist/runtime.js

@@ -0,0 +1,423 @@
+import { withoutTrailingSlash } from "@ai-sdk/provider-utils";
+import { CodexResponsesState } from "./state.js";
+export { collectCompletedResponseFromSse, iterateServerSentEvents, } from "./sse.js";
+export { CodexResponsesState, } from "./state.js";
+import { collectCompletedResponseFromSse } from "./sse.js";
+export const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+export const DEFAULT_OPENAI_COMPATIBLE_BASE_URL = "https://openai-oauth.local/v1";
+export const DEFAULT_OPENAI_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+export const DEFAULT_OPENAI_OAUTH_ISSUER = "https://auth.openai.com";
+export const DEFAULT_OPENAI_OAUTH_SCOPE = "openid profile email offline_access";
+const DEFAULT_CODEX_INSTRUCTIONS = "";
+const textEncoder = new TextEncoder();
+const bytesToBase64Url = (bytes) => {
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary)
+        .replaceAll("+", "-")
+        .replaceAll("/", "_")
+        .replace(/=+$/, "");
+};
+const randomURLSafeString = (byteLength) => {
+    const bytes = new Uint8Array(byteLength);
+    globalThis.crypto.getRandomValues(bytes);
+    return bytesToBase64Url(bytes);
+};
+const createCodeChallenge = async (codeVerifier) => {
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", textEncoder.encode(codeVerifier));
+    return bytesToBase64Url(new Uint8Array(digest));
+};
+const trimTrailingSlash = (value) => value.replace(/\/$/, "");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const usesServerReplayState = (value) => {
+    if (typeof value.previous_response_id === "string") {
+        return true;
+    }
+    if (!Array.isArray(value.input)) {
+        return false;
+    }
+    return value.input.some((item) => isRecord(item) &&
+        item.type === "item_reference" &&
+        typeof item.id === "string");
+};
+const decodeBase64Url = (value) => {
+    try {
+        const padded = value + "=".repeat(((-value.length % 4) + 4) % 4);
+        const binary = atob(padded.replaceAll("-", "+").replaceAll("_", "/"));
+        const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const parseJwtClaims = (token) => {
+    if (typeof token !== "string" || !token.includes(".")) {
+        return undefined;
+    }
+    const parts = token.split(".");
+    if (parts.length !== 3 || parts[1] === undefined) {
+        return undefined;
+    }
+    const payload = decodeBase64Url(parts[1]);
+    if (typeof payload !== "string") {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(payload);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const deriveAccountId = (idToken) => {
+    const claims = parseJwtClaims(idToken);
+    if (!claims) {
+        return undefined;
+    }
+    const authClaim = claims["https://api.openai.com/auth"];
+    if (isRecord(authClaim)) {
+        const accountId = authClaim.chatgpt_account_id;
+        if (typeof accountId === "string" && accountId.length > 0) {
+            return accountId;
+        }
+    }
+    const topLevelAccountId = claims.chatgpt_account_id;
+    if (typeof topLevelAccountId === "string" && topLevelAccountId.length > 0) {
+        return topLevelAccountId;
+    }
+    const organizations = claims.organizations;
+    if (Array.isArray(organizations)) {
+        const first = organizations[0];
+        if (isRecord(first) &&
+            typeof first.id === "string" &&
+            first.id.length > 0) {
+            return first.id;
+        }
+    }
+    return undefined;
+};
+const resolveTokenUrl = (issuer, tokenUrl) => tokenUrl ?? `${trimTrailingSlash(issuer)}/oauth/token`;
+const toTokenResponse = (payload) => {
+    if (!isRecord(payload)) {
+        throw new Error("OpenAI OAuth token response must be a JSON object.");
+    }
+    const accessToken = typeof payload.access_token === "string" ? payload.access_token : undefined;
+    if (!accessToken) {
+        throw new Error("OpenAI OAuth token response did not include access_token.");
+    }
+    const refreshToken = typeof payload.refresh_token === "string"
+        ? payload.refresh_token
+        : undefined;
+    const idToken = typeof payload.id_token === "string" ? payload.id_token : undefined;
+    const expiresIn = typeof payload.expires_in === "number" ? payload.expires_in : undefined;
+    return {
+        accessToken,
+        refreshToken,
+        idToken,
+        expiresIn,
+        accountId: deriveAccountId(idToken) ?? deriveAccountId(accessToken),
+        raw: payload,
+    };
+};
+const requestOpenAIOAuthTokens = async (options) => {
+    const issuer = options.issuer ?? DEFAULT_OPENAI_OAUTH_ISSUER;
+    const response = await pickFetch(options.fetch)(resolveTokenUrl(issuer, options.tokenUrl), {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(options.body),
+        signal: options.signal,
+    });
+    if (!response.ok) {
+        throw new Error(`OpenAI OAuth token request failed with HTTP ${response.status}.`);
+    }
+    return toTokenResponse(await response.json());
+};
+export const createOpenAIOAuthRequest = async (options) => {
+    const state = options.state ?? randomURLSafeString(24);
+    const codeVerifier = options.codeVerifier ?? randomURLSafeString(48);
+    const codeChallenge = await createCodeChallenge(codeVerifier);
+    const issuer = trimTrailingSlash(options.issuer ?? DEFAULT_OPENAI_OAUTH_ISSUER);
+    const authorizationUrl = new URL(`${issuer}/oauth/authorize`);
+    authorizationUrl.searchParams.set("response_type", "code");
+    authorizationUrl.searchParams.set("client_id", options.clientId ?? DEFAULT_OPENAI_OAUTH_CLIENT_ID);
+    authorizationUrl.searchParams.set("redirect_uri", options.redirectUri);
+    authorizationUrl.searchParams.set("scope", options.scope ?? DEFAULT_OPENAI_OAUTH_SCOPE);
+    authorizationUrl.searchParams.set("state", state);
+    authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+    authorizationUrl.searchParams.set("code_challenge_method", "S256");
+    if (options.idTokenAddOrganizations ?? true) {
+        authorizationUrl.searchParams.set("id_token_add_organizations", "true");
+    }
+    if (options.simplifiedFlow ?? true) {
+        authorizationUrl.searchParams.set("codex_cli_simplified_flow", "true");
+    }
+    for (const [key, value] of Object.entries(options.extraParams ?? {})) {
+        if (value !== undefined && key !== "originator") {
+            authorizationUrl.searchParams.set(key, String(value));
+        }
+    }
+    return {
+        authorizationUrl: authorizationUrl.toString(),
+        state,
+        codeVerifier,
+        codeChallenge,
+        redirectUri: options.redirectUri,
+    };
+};
+export const exchangeOpenAIOAuthCode = (options) => requestOpenAIOAuthTokens({
+    issuer: options.issuer,
+    tokenUrl: options.tokenUrl,
+    fetch: options.fetch,
+    signal: options.signal,
+    body: {
+        grant_type: "authorization_code",
+        code: options.code,
+        redirect_uri: options.redirectUri,
+        client_id: options.clientId ?? DEFAULT_OPENAI_OAUTH_CLIENT_ID,
+        code_verifier: options.codeVerifier,
+    },
+});
+export const refreshOpenAIOAuthTokens = (options) => requestOpenAIOAuthTokens({
+    issuer: options.issuer,
+    tokenUrl: options.tokenUrl,
+    fetch: options.fetch,
+    signal: options.signal,
+    body: {
+        grant_type: "refresh_token",
+        refresh_token: options.refreshToken,
+        client_id: options.clientId ?? DEFAULT_OPENAI_OAUTH_CLIENT_ID,
+        scope: DEFAULT_OPENAI_OAUTH_SCOPE,
+    },
+});
+const pickFetch = (customFetch) => {
+    if (typeof customFetch === "function") {
+        return customFetch;
+    }
+    if (typeof globalThis.fetch === "function") {
+        return globalThis.fetch.bind(globalThis);
+    }
+    throw new Error("A fetch implementation is required for OpenAI OAuth.");
+};
+const resolveBaseURL = (baseURL) => withoutTrailingSlash(baseURL) ?? DEFAULT_CODEX_BASE_URL;
+const resolveOpenAIBaseURL = (baseURL) => withoutTrailingSlash(baseURL) ?? DEFAULT_OPENAI_COMPATIBLE_BASE_URL;
+const resolveTargetUrl = (input, baseURL) => {
+    const base = new URL(baseURL);
+    const parsed = /^https?:\/\//.test(input)
+        ? new URL(input)
+        : new URL(input, "https://codex.invalid");
+    let pathname = parsed.pathname;
+    const basePath = withoutTrailingSlash(base.pathname) ?? "";
+    if (pathname === basePath) {
+        pathname = "/";
+    }
+    else if (basePath.length > 0 && pathname.startsWith(`${basePath}/`)) {
+        pathname = pathname.slice(basePath.length);
+    }
+    if (pathname === "/v1") {
+        pathname = "/";
+    }
+    else if (pathname.startsWith("/v1/")) {
+        pathname = pathname.slice(3);
+    }
+    return `${base.origin}${basePath}${pathname}${parsed.search}`;
+};
+const readRequestParts = async (input, init) => {
+    if (input instanceof Request) {
+        const headers = new Headers(input.headers);
+        if (init?.headers) {
+            new Headers(init.headers).forEach((value, key) => {
+                headers.set(key, value);
+            });
+        }
+        return {
+            url: input.url,
+            method: init?.method ?? input.method,
+            headers,
+            body: init?.body ??
+                (input.body == null ? undefined : await input.clone().text()),
+            signal: init?.signal ?? input.signal,
+        };
+    }
+    return {
+        url: String(input),
+        method: init?.method,
+        headers: new Headers(init?.headers),
+        body: init?.body,
+        signal: init?.signal,
+    };
+};
+const decodeBody = async (body) => {
+    if (body == null) {
+        return undefined;
+    }
+    if (typeof body === "string") {
+        return body;
+    }
+    if (body instanceof URLSearchParams || body instanceof FormData) {
+        return undefined;
+    }
+    if (body instanceof ReadableStream) {
+        return undefined;
+    }
+    if (body instanceof Blob) {
+        return body.text();
+    }
+    if (body instanceof ArrayBuffer) {
+        return new TextDecoder().decode(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+        return new TextDecoder().decode(body);
+    }
+    return undefined;
+};
+export const getDefaultCodexInstructions = () => DEFAULT_CODEX_INSTRUCTIONS;
+export const normalizeCodexResponsesBody = (body, options = {}) => {
+    const normalized = { ...body };
+    const instructions = typeof normalized.instructions === "string"
+        ? normalized.instructions
+        : (options.instructions ?? getDefaultCodexInstructions());
+    normalized.instructions = instructions;
+    if (normalized.store === undefined) {
+        normalized.store = options.storeResponses ?? false;
+    }
+    if (options.forceStream) {
+        normalized.stream = true;
+    }
+    delete normalized.max_output_tokens;
+    return normalized;
+};
+const prepareResponsesRequestBody = async (pathname, headers, body, settings, state) => {
+    if (!pathname.endsWith("/responses")) {
+        return { body };
+    }
+    const contentType = headers.get("content-type");
+    if (contentType && !contentType.includes("application/json")) {
+        return { body };
+    }
+    const bodyText = await decodeBody(body);
+    if (typeof bodyText !== "string") {
+        return { body };
+    }
+    try {
+        const parsed = JSON.parse(bodyText);
+        if (typeof parsed !== "object" ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            return { body };
+        }
+        const normalized = normalizeCodexResponsesBody(parsed, {
+            instructions: settings.instructions,
+            storeResponses: settings.storeResponses,
+        });
+        if (state?.requiresCachedState(normalized)) {
+            await state.waitForPendingCaptures();
+        }
+        const expanded = state?.expandRequestBody(normalized) ?? normalized;
+        return {
+            body: JSON.stringify(expanded),
+            requestBody: expanded,
+        };
+    }
+    catch {
+        return { body };
+    }
+};
+const captureResponsesState = (response, requestBody, state) => {
+    if (state == null ||
+        requestBody == null ||
+        !response.ok ||
+        response.body == null) {
+        return response;
+    }
+    const [returnedBody, cachedBody] = response.body.tee();
+    const capturePromise = collectCompletedResponseFromSse(cachedBody)
+        .then((completedResponse) => {
+        state.rememberResponse(completedResponse, requestBody);
+    })
+        .catch(() => undefined);
+    state.trackPendingCapture(capturePromise);
+    return new Response(returnedBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Headers(response.headers),
+    });
+};
+const resolveAuth = async (source) => {
+    const auth = typeof source === "function" ? await source() : source;
+    if (!auth) {
+        throw new Error("OpenAI OAuth session not found.");
+    }
+    return auth;
+};
+export const createCodexOAuthFetch = (settings) => {
+    const fetch = pickFetch(settings.fetch);
+    const baseURL = resolveBaseURL(settings.baseURL);
+    const responsesState = settings.responsesState === false
+        ? undefined
+        : (settings.responsesState ?? new CodexResponsesState());
+    return async (input, init) => {
+        const request = await readRequestParts(input, init);
+        const targetUrl = resolveTargetUrl(request.url, baseURL);
+        const target = new URL(targetUrl);
+        const auth = await resolveAuth(settings.auth);
+        const headers = new Headers(settings.headers);
+        request.headers.forEach((value, key) => {
+            headers.set(key, value);
+        });
+        headers.delete("authorization");
+        headers.delete("chatgpt-account-id");
+        headers.delete("openai-beta");
+        headers.set("Authorization", `Bearer ${auth.accessToken}`);
+        headers.set("chatgpt-account-id", auth.accountId);
+        headers.set("OpenAI-Beta", "responses=experimental");
+        const preparedBody = await prepareResponsesRequestBody(target.pathname, headers, request.body, settings, responsesState);
+        const response = await fetch(target.toString(), {
+            method: request.method ?? init?.method,
+            headers,
+            body: preparedBody.body,
+            signal: request.signal ?? undefined,
+        });
+        return captureResponsesState(response, preparedBody.requestBody, responsesState);
+    };
+};
+const resolveOpenAICompatibleUrl = (path, baseURL) => {
+    if (/^https?:\/\//.test(path)) {
+        return path;
+    }
+    const normalizedPath = path.startsWith("/v1/")
+        ? path.slice("/v1/".length)
+        : path.replace(/^\//, "");
+    return new URL(normalizedPath, `${baseURL}/`).toString();
+};
+export const createCodexOAuthClient = (settings) => {
+    const baseURL = resolveBaseURL(settings.baseURL);
+    const fetch = createCodexOAuthFetch(settings);
+    return {
+        baseURL,
+        fetch,
+        request: (path, init) => fetch(new URL(path, `${baseURL}/`).toString(), init),
+    };
+};
+export const createOpenAIOAuthTransport = (settings) => {
+    const baseURL = resolveOpenAIBaseURL(settings.openAIBaseURL);
+    const fetch = createCodexOAuthFetch(settings);
+    return {
+        kind: "openai-compatible",
+        provider: "chatgpt-codex",
+        baseURL,
+        fetch,
+        request: (path, init) => fetch(resolveOpenAICompatibleUrl(path, baseURL), init),
+        capabilities: {
+            responses: true,
+            chatCompletions: true,
+            models: true,
+            streaming: true,
+        },
+    };
+};

package/dist/sse.d.ts

@@ -0,0 +1,7 @@
+export type ServerSentEvent = {
+    event?: string;
+    data?: string;
+};
+export declare function iterateServerSentEvents(stream: ReadableStream<Uint8Array>): AsyncGenerator<ServerSentEvent>;
+export declare const collectCompletedResponseFromSse: (stream: ReadableStream<Uint8Array>) => Promise<Record<string, unknown>>;
+//# sourceMappingURL=sse.d.ts.map

package/dist/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../src/sse.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,eAAe,GAAG;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAwBD,wBAAuB,uBAAuB,CAC7C,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAChC,cAAc,CAAC,eAAe,CAAC,CAkCjC;AAuDD,eAAO,MAAM,+BAA+B,GAC3C,QAAQ,cAAc,CAAC,UAAU,CAAC,KAChC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmEjC,CAAA"}

package/dist/sse.js

@@ -0,0 +1,144 @@
+const SSE_SEPARATOR = /\r?\n\r?\n/;
+const parseEventBlock = (block) => {
+    const event = {};
+    const dataLines = [];
+    for (const line of block.split(/\r?\n/)) {
+        if (line.startsWith("event:")) {
+            event.event = line.slice(6).trim();
+            continue;
+        }
+        if (line.startsWith("data:")) {
+            dataLines.push(line.slice(5).trimStart());
+        }
+    }
+    if (dataLines.length > 0) {
+        event.data = dataLines.join("\n");
+    }
+    return event;
+};
+export async function* iterateServerSentEvents(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let reachedEnd = false;
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+                reachedEnd = true;
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const blocks = buffer.split(SSE_SEPARATOR);
+            buffer = blocks.pop() ?? "";
+            for (const block of blocks) {
+                if (block.trim().length > 0) {
+                    yield parseEventBlock(block);
+                }
+            }
+        }
+        if (buffer.trim().length > 0) {
+            yield parseEventBlock(buffer);
+        }
+    }
+    finally {
+        if (!reachedEnd) {
+            void reader.cancel().catch(() => undefined);
+        }
+        reader.releaseLock();
+    }
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const terminalServerSentEvents = new Set([
+    "error",
+    "response.completed",
+    "response.failed",
+    "response.cancelled",
+    "response.canceled",
+    "response.incomplete",
+]);
+const terminalResponseStatuses = new Set([
+    "completed",
+    "failed",
+    "cancelled",
+    "canceled",
+    "incomplete",
+]);
+const isTerminalPayload = (data) => {
+    if (data === "[DONE]") {
+        return true;
+    }
+    try {
+        const parsed = JSON.parse(data);
+        if (!isRecord(parsed)) {
+            return false;
+        }
+        const type = parsed.type;
+        if (typeof type === "string" && terminalServerSentEvents.has(type)) {
+            return true;
+        }
+        const response = parsed.response;
+        if (!isRecord(response)) {
+            return false;
+        }
+        const responseType = response.type;
+        const status = response.status;
+        return ((typeof responseType === "string" &&
+            terminalServerSentEvents.has(responseType)) ||
+            (typeof status === "string" && terminalResponseStatuses.has(status)));
+    }
+    catch {
+        return false;
+    }
+};
+export const collectCompletedResponseFromSse = async (stream) => {
+    let latestResponse;
+    let latestError;
+    const outputItems = new Map();
+    const withCollectedOutput = (response) => {
+        const output = Array.isArray(response.output) ? response.output : [];
+        if (output.length > 0 || outputItems.size === 0) {
+            return response;
+        }
+        return {
+            ...response,
+            output: [...outputItems.values()],
+        };
+    };
+    for await (const event of iterateServerSentEvents(stream)) {
+        if (typeof event.data !== "string" || event.data.length === 0) {
+            continue;
+        }
+        const terminal = Boolean((event.event && terminalServerSentEvents.has(event.event)) ||
+            isTerminalPayload(event.data));
+        try {
+            const parsed = JSON.parse(event.data);
+            if (!isRecord(parsed)) {
+                continue;
+            }
+            if (event.event === "error") {
+                latestError = parsed;
+                continue;
+            }
+            const item = parsed.item;
+            if (isRecord(item) && typeof item.id === "string") {
+                outputItems.set(item.id, item);
+            }
+            const response = parsed.response;
+            if (isRecord(response)) {
+                latestResponse = response;
+            }
+            if (terminal && latestResponse) {
+                return withCollectedOutput(latestResponse);
+            }
+        }
+        catch { }
+        if (terminal && latestResponse) {
+            return withCollectedOutput(latestResponse);
+        }
+    }
+    if (latestResponse) {
+        return withCollectedOutput(latestResponse);
+    }
+    throw new Error(`No completed response found in SSE stream.${latestError ? ` Last error: ${JSON.stringify(latestError)}` : ""}`);
+};

package/dist/state.d.ts

@@ -0,0 +1,33 @@
+type JsonRecord = Record<string, unknown>;
+export type CodexResponsesStateSnapshot = {
+    items: Array<{
+        id: string;
+        item: JsonRecord;
+    }>;
+    responses: Array<{
+        id: string;
+        input: unknown[];
+        output: JsonRecord[];
+    }>;
+};
+export type CodexResponsesStateOptions = {
+    snapshot?: CodexResponsesStateSnapshot;
+    onChange?: (snapshot: CodexResponsesStateSnapshot) => void;
+};
+export declare class CodexResponsesState {
+    private readonly items;
+    private readonly responses;
+    private readonly pendingCaptures;
+    private readonly onChange?;
+    constructor(options?: CodexResponsesStateOptions);
+    waitForPendingCaptures(): Promise<void>;
+    trackPendingCapture(promise: Promise<void>): void;
+    requiresCachedState(body: JsonRecord): boolean;
+    expandRequestBody(body: JsonRecord): JsonRecord;
+    rememberResponse(response: unknown, requestBody?: JsonRecord): void;
+    snapshot(): CodexResponsesStateSnapshot;
+    private expandInput;
+    private emitChange;
+}
+export {};
+//# sourceMappingURL=state.d.ts.map

package/dist/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAOzC,MAAM,MAAM,2BAA2B,GAAG;IACzC,KAAK,EAAE,KAAK,CAAC;QACZ,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,UAAU,CAAA;KAChB,CAAC,CAAA;IACF,SAAS,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,MAAM,CAAA;QACV,KAAK,EAAE,OAAO,EAAE,CAAA;QAChB,MAAM,EAAE,UAAU,EAAE,CAAA;KACpB,CAAC,CAAA;CACF,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACxC,QAAQ,CAAC,EAAE,2BAA2B,CAAA;IACtC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,2BAA2B,KAAK,IAAI,CAAA;CAC1D,CAAA;AAwBD,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyC;IACnE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA2B;IAC3D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAiD;gBAE/D,OAAO,GAAE,0BAA+B;IA0B9C,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ7C,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAOjD,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAiB9C,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;IA+B/C,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,UAAU,GAAG,IAAI;IAiDnE,QAAQ,IAAI,2BAA2B;IAcvC,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,UAAU;CAGlB"}