@barekey/sdk 0.1.0

package/dist/internal/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/internal/http.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,cAAc,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC,CAAC;AAUF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAqFD,wBAAsB,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE;IAC/C,OAAO,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B,GAAG,OAAO,CAAC,SAAS,CAAC,CAKrB;AAED,wBAAsB,OAAO,CAAC,SAAS,EAAE,KAAK,EAAE;IAC9C,OAAO,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B,GAAG,OAAO,CAAC,SAAS,CAAC,CAKrB"}

package/dist/internal/http.js

@@ -0,0 +1,92 @@
+import { NetworkError, UnauthorizedError, createBarekeyErrorFromCode } from "../errors.js";
+async function parseJsonResponse(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/$/, "");
+}
+async function requestJson(input) {
+    const makeRequest = async (accessToken) => input.fetchFn(`${normalizeBaseUrl(input.baseUrl)}${input.path}`, {
+        method: input.method,
+        headers: {
+            ...(input.method === "POST"
+                ? {
+                    "content-type": "application/json",
+                }
+                : {}),
+            ...(accessToken
+                ? {
+                    authorization: `Bearer ${accessToken}`,
+                }
+                : {}),
+        },
+        ...(input.method === "POST"
+            ? {
+                body: JSON.stringify(input.payload),
+            }
+            : {}),
+    });
+    const accessToken = input.auth ? await input.auth.getAccessToken() : undefined;
+    let response;
+    try {
+        response = await makeRequest(accessToken);
+    }
+    catch (error) {
+        throw new NetworkError({
+            message: error instanceof Error ? error.message : "A Barekey network request failed.",
+            cause: error,
+        });
+    }
+    if (response.status === 401 && input.auth?.onUnauthorized) {
+        await input.auth.onUnauthorized();
+        const retryAccessToken = await input.auth.getAccessToken();
+        try {
+            response = await makeRequest(retryAccessToken);
+        }
+        catch (error) {
+            throw new NetworkError({
+                message: error instanceof Error ? error.message : "A Barekey network request failed.",
+                cause: error,
+            });
+        }
+    }
+    const parsed = (await parseJsonResponse(response));
+    if (!response.ok) {
+        const parsedError = parsed;
+        const code = parsedError?.error?.code ?? (response.status === 401 ? "UNAUTHORIZED" : "UNKNOWN_ERROR");
+        const message = parsedError?.error?.message ??
+            (response.status === 401
+                ? "The provided Barekey credentials were rejected."
+                : `Barekey request failed with status ${response.status}.`);
+        if (response.status === 401 && code === "UNAUTHORIZED" && !parsedError?.error?.message) {
+            throw new UnauthorizedError({
+                requestId: parsedError?.error?.requestId ?? null,
+                status: response.status,
+            });
+        }
+        throw createBarekeyErrorFromCode({
+            code,
+            message,
+            requestId: parsedError?.error?.requestId ?? null,
+            status: response.status,
+        });
+    }
+    return parsed;
+}
+export async function postJson(input) {
+    return await requestJson({
+        ...input,
+        method: "POST",
+    });
+}
+export async function getJson(input) {
+    return await requestJson({
+        ...input,
+        method: "GET",
+    });
+}

package/dist/internal/node-runtime.d.ts

@@ -0,0 +1,19 @@
+export declare function isFilesystemAvailable(): Promise<boolean>;
+export declare function loadBarekeyJsonConfig(): Promise<{
+    path: string;
+    json: Record<string, unknown>;
+} | null>;
+export declare function loadCliSessionAuthResolver(fetchFn: typeof globalThis.fetch): Promise<{
+    baseUrl: string;
+    getAccessToken(): Promise<string>;
+    onUnauthorized(): Promise<void>;
+} | null>;
+type InstalledSdkTypegenTarget = {
+    packageRoot: string;
+    generatedTypesPath: string;
+};
+export declare function resolveInstalledSdkTypegenTarget(): Promise<InstalledSdkTypegenTarget | null>;
+export declare function readTextFile(filePath: string): Promise<string | null>;
+export declare function writeTextFileAtomic(filePath: string, value: string): Promise<void>;
+export {};
+//# sourceMappingURL=node-runtime.d.ts.map

package/dist/internal/node-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-runtime.d.ts","sourceRoot":"","sources":["../../src/internal/node-runtime.ts"],"names":[],"mappings":"AA4VA,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAE9D;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GAAG,IAAI,CAAC,CAwCR;AAED,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,OAAO,UAAU,CAAC,KAAK,GAAG,OAAO,CAAC;IAC1F,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC,GAAG,IAAI,CAAC,CAoER;AAOD,KAAK,yBAAyB,GAAG;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAsB,gCAAgC,IAAI,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC,CAsDlG;AAED,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkB3E;AAED,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBxF"}

package/dist/internal/node-runtime.js

@@ -0,0 +1,422 @@
+import { InvalidConfigurationProvidedError, InvalidCredentialsProvidedError, NoCredentialsProvidedError, SdkModuleNotFoundError, TypegenReadFailedError, TypegenUnsupportedSdkError, TypegenWriteFailedError, } from "../errors.js";
+import { postJson } from "./http.js";
+const CLI_SERVICE_NAME = "barekey-cli";
+function isNodeRuntime() {
+    return (typeof process !== "undefined" &&
+        typeof process.versions === "object" &&
+        process.versions !== null &&
+        typeof process.versions.node === "string");
+}
+async function loadNodeRuntime() {
+    if (!isNodeRuntime()) {
+        return null;
+    }
+    try {
+        const [childProcess, fs, moduleApi, os, path] = await Promise.all([
+            import("node:child_process"),
+            import("node:fs/promises"),
+            import("node:module"),
+            import("node:os"),
+            import("node:path"),
+        ]);
+        return {
+            childProcess,
+            fs,
+            moduleApi,
+            os,
+            path,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function runCommand(runtime, command, args, input) {
+    return await new Promise((resolve) => {
+        const child = runtime.childProcess.spawn(command, args, {
+            stdio: "pipe",
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.stdin.on("error", () => {
+            // Ignore EPIPE if the child exits before consuming stdin.
+        });
+        child.on("error", () => {
+            resolve({
+                stdout: "",
+                stderr: "",
+                code: 127,
+            });
+        });
+        child.on("close", (code) => {
+            resolve({
+                stdout,
+                stderr,
+                code: code ?? 1,
+            });
+        });
+        if (input !== undefined) {
+            child.stdin.write(input);
+        }
+        child.stdin.end();
+    });
+}
+async function readJsonFile(runtime, filePath) {
+    try {
+        const value = await runtime.fs.readFile(filePath, "utf8");
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function isCliConfig(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.baseUrl === "string" &&
+        typeof value.activeAccountId === "string");
+}
+function isCliCredentials(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.accessToken === "string" &&
+        typeof candidate.refreshToken === "string" &&
+        typeof candidate.accessTokenExpiresAtMs === "number" &&
+        typeof candidate.refreshTokenExpiresAtMs === "number" &&
+        typeof candidate.clerkUserId === "string" &&
+        typeof candidate.orgId === "string" &&
+        typeof candidate.orgSlug === "string");
+}
+async function getFromKeychain(runtime, account) {
+    if (process.platform === "darwin") {
+        const result = await runCommand(runtime, "security", [
+            "find-generic-password",
+            "-s",
+            CLI_SERVICE_NAME,
+            "-a",
+            account,
+            "-w",
+        ]);
+        if (result.code !== 0) {
+            return null;
+        }
+        const value = result.stdout.trim();
+        return value.length > 0 ? value : null;
+    }
+    if (process.platform === "linux") {
+        const result = await runCommand(runtime, "secret-tool", [
+            "lookup",
+            "service",
+            CLI_SERVICE_NAME,
+            "account",
+            account,
+        ]);
+        if (result.code !== 0) {
+            return null;
+        }
+        const value = result.stdout.trim();
+        return value.length > 0 ? value : null;
+    }
+    return null;
+}
+async function setInKeychain(runtime, account, value) {
+    if (process.platform === "darwin") {
+        const result = await runCommand(runtime, "security", [
+            "add-generic-password",
+            "-U",
+            "-s",
+            CLI_SERVICE_NAME,
+            "-a",
+            account,
+            "-w",
+            value,
+        ]);
+        return result.code === 0;
+    }
+    if (process.platform === "linux") {
+        const result = await runCommand(runtime, "secret-tool", ["store", `--label=${CLI_SERVICE_NAME}`, "service", CLI_SERVICE_NAME, "account", account], value);
+        return result.code === 0;
+    }
+    return false;
+}
+function getConfigPaths(runtime) {
+    const configDir = runtime.path.join(runtime.os.homedir(), ".config", "barekey");
+    return {
+        configPath: runtime.path.join(configDir, "config.json"),
+        credentialsDir: runtime.path.join(configDir, "credentials"),
+    };
+}
+function credentialsPathForAccount(runtime, credentialsDir, accountId) {
+    return runtime.path.join(credentialsDir, `${encodeURIComponent(accountId)}.json`);
+}
+async function saveCliCredentials(runtime, accountId, credentials) {
+    const serialized = JSON.stringify(credentials);
+    if (await setInKeychain(runtime, accountId, serialized)) {
+        return;
+    }
+    const { credentialsDir } = getConfigPaths(runtime);
+    await runtime.fs.mkdir(credentialsDir, {
+        recursive: true,
+        mode: 0o700,
+    });
+    await runtime.fs.writeFile(credentialsPathForAccount(runtime, credentialsDir, accountId), serialized, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+}
+async function readCliSessionWithSource(runtime) {
+    const { configPath, credentialsDir } = getConfigPaths(runtime);
+    const rawConfig = await readJsonFile(runtime, configPath);
+    if (rawConfig === null) {
+        return null;
+    }
+    if (!isCliConfig(rawConfig)) {
+        throw new InvalidCredentialsProvidedError({
+            message: "Stored Barekey CLI config is malformed.",
+        });
+    }
+    const fromKeychain = await getFromKeychain(runtime, rawConfig.activeAccountId);
+    if (fromKeychain !== null) {
+        try {
+            const parsed = JSON.parse(fromKeychain);
+            if (!isCliCredentials(parsed)) {
+                throw new InvalidCredentialsProvidedError({
+                    message: "Stored Barekey CLI credentials are malformed.",
+                });
+            }
+            return {
+                baseUrl: rawConfig.baseUrl,
+                activeAccountId: rawConfig.activeAccountId,
+                credentials: parsed,
+                source: "keychain",
+            };
+        }
+        catch (error) {
+            if (error instanceof InvalidCredentialsProvidedError) {
+                throw error;
+            }
+            throw new InvalidCredentialsProvidedError({
+                message: "Stored Barekey CLI credentials are malformed.",
+                cause: error,
+            });
+        }
+    }
+    const fromFile = await readJsonFile(runtime, credentialsPathForAccount(runtime, credentialsDir, rawConfig.activeAccountId));
+    if (fromFile === null) {
+        return null;
+    }
+    if (!isCliCredentials(fromFile)) {
+        throw new InvalidCredentialsProvidedError({
+            message: "Stored Barekey CLI credentials are malformed.",
+        });
+    }
+    return {
+        baseUrl: rawConfig.baseUrl,
+        activeAccountId: rawConfig.activeAccountId,
+        credentials: fromFile,
+        source: "file",
+    };
+}
+export async function isFilesystemAvailable() {
+    return (await loadNodeRuntime()) !== null;
+}
+export async function loadBarekeyJsonConfig() {
+    const runtime = await loadNodeRuntime();
+    if (runtime === null) {
+        return null;
+    }
+    let current = runtime.path.resolve(process.cwd());
+    while (true) {
+        const candidate = runtime.path.join(current, "barekey.json");
+        try {
+            const raw = await runtime.fs.readFile(candidate, "utf8");
+            try {
+                return {
+                    path: candidate,
+                    json: JSON.parse(raw),
+                };
+            }
+            catch (error) {
+                throw new InvalidConfigurationProvidedError({
+                    message: `The barekey.json file at ${candidate} is not valid JSON.`,
+                    cause: error,
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof InvalidConfigurationProvidedError) {
+                throw error;
+            }
+            const nodeError = error;
+            if (nodeError?.code && nodeError.code !== "ENOENT") {
+                throw new InvalidConfigurationProvidedError({
+                    message: `The barekey.json file at ${candidate} could not be read.`,
+                    cause: error,
+                });
+            }
+            const parent = runtime.path.dirname(current);
+            if (parent === current) {
+                return null;
+            }
+            current = parent;
+        }
+    }
+}
+export async function loadCliSessionAuthResolver(fetchFn) {
+    const runtime = await loadNodeRuntime();
+    if (runtime === null) {
+        return null;
+    }
+    let cachedSession = await readCliSessionWithSource(runtime);
+    if (cachedSession === null) {
+        return null;
+    }
+    let forceRefresh = false;
+    const refreshCredentials = async () => {
+        const currentSession = cachedSession;
+        if (currentSession === null) {
+            throw new NoCredentialsProvidedError();
+        }
+        if (!forceRefresh && currentSession.credentials.accessTokenExpiresAtMs > Date.now() + 10_000) {
+            return currentSession.credentials.accessToken;
+        }
+        const refreshed = await postJson({
+            fetchFn,
+            baseUrl: currentSession.baseUrl,
+            path: "/v1/cli/token/refresh",
+            payload: {
+                refreshToken: currentSession.credentials.refreshToken,
+            },
+        });
+        const nextCredentials = {
+            accessToken: refreshed.accessToken,
+            refreshToken: refreshed.refreshToken,
+            accessTokenExpiresAtMs: refreshed.accessTokenExpiresAtMs,
+            refreshTokenExpiresAtMs: refreshed.refreshTokenExpiresAtMs,
+            clerkUserId: refreshed.clerkUserId,
+            orgId: refreshed.orgId,
+            orgSlug: refreshed.orgSlug,
+        };
+        await saveCliCredentials(runtime, currentSession.activeAccountId, nextCredentials);
+        cachedSession = {
+            ...currentSession,
+            credentials: nextCredentials,
+        };
+        forceRefresh = false;
+        return nextCredentials.accessToken;
+    };
+    return {
+        baseUrl: cachedSession.baseUrl,
+        async getAccessToken() {
+            return await refreshCredentials();
+        },
+        async onUnauthorized() {
+            forceRefresh = true;
+        },
+    };
+}
+function isMissingModuleError(error) {
+    const nodeError = error;
+    return nodeError?.code === "MODULE_NOT_FOUND" || nodeError?.code === "ERR_MODULE_NOT_FOUND";
+}
+export async function resolveInstalledSdkTypegenTarget() {
+    const runtime = await loadNodeRuntime();
+    if (runtime === null) {
+        return null;
+    }
+    const require = runtime.moduleApi.createRequire(runtime.path.join(process.cwd(), "__barekey_typegen__.cjs"));
+    let resolvedEntrypoint;
+    try {
+        resolvedEntrypoint = require.resolve("@barekey/sdk/package.json");
+    }
+    catch (error) {
+        if (isMissingModuleError(error)) {
+            throw new SdkModuleNotFoundError();
+        }
+        throw new SdkModuleNotFoundError({
+            message: "The installed @barekey/sdk module could not be resolved from the current project.",
+            cause: error,
+        });
+    }
+    let current = runtime.path.dirname(await runtime.fs.realpath(resolvedEntrypoint));
+    while (true) {
+        const candidatePackageJson = runtime.path.join(current, "package.json");
+        const rawPackageJson = await readJsonFile(runtime, candidatePackageJson);
+        if (rawPackageJson !== null && rawPackageJson.name === "@barekey/sdk") {
+            const generatedTypesPath = runtime.path.join(current, "generated.d.ts");
+            try {
+                await runtime.fs.access(generatedTypesPath);
+            }
+            catch (error) {
+                throw new TypegenUnsupportedSdkError({
+                    message: `The installed @barekey/sdk module at ${current} does not include generated.d.ts.`,
+                    cause: error,
+                });
+            }
+            return {
+                packageRoot: current,
+                generatedTypesPath,
+            };
+        }
+        const parent = runtime.path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    throw new TypegenUnsupportedSdkError({
+        message: "The installed @barekey/sdk module could not be mapped to a supported package root.",
+    });
+}
+export async function readTextFile(filePath) {
+    const runtime = await loadNodeRuntime();
+    if (runtime === null) {
+        return null;
+    }
+    try {
+        return await runtime.fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError?.code === "ENOENT") {
+            return null;
+        }
+        throw new TypegenReadFailedError({
+            message: `Barekey could not read ${filePath} while updating generated SDK types.`,
+            cause: error,
+        });
+    }
+}
+export async function writeTextFileAtomic(filePath, value) {
+    const runtime = await loadNodeRuntime();
+    if (runtime === null) {
+        throw new TypegenWriteFailedError({
+            message: "Barekey could not update generated SDK types because filesystem access is unavailable.",
+        });
+    }
+    const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        await runtime.fs.writeFile(temporaryPath, value, "utf8");
+        await runtime.fs.rename(temporaryPath, filePath);
+    }
+    catch (error) {
+        try {
+            await runtime.fs.unlink(temporaryPath);
+        }
+        catch {
+            // Best effort cleanup only.
+        }
+        throw new TypegenWriteFailedError({
+            message: `Barekey could not write ${filePath}.`,
+            cause: error,
+        });
+    }
+}

package/dist/internal/requirements.d.ts

@@ -0,0 +1,3 @@
+import type { BarekeyStandardSchemaV1 } from "../types.js";
+export declare function validateRequirements(requirements: BarekeyStandardSchemaV1, value: unknown): Promise<void>;
+//# sourceMappingURL=requirements.d.ts.map

package/dist/internal/requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirements.d.ts","sourceRoot":"","sources":["../../src/internal/requirements.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAiBrB,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,uBAAuB,EACrC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/dist/internal/requirements.js

@@ -0,0 +1,40 @@
+import { InvalidConfigurationProvidedError, RequirementsValidationFailedError } from "../errors.js";
+function isStandardSchemaResult(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    return "value" in value || "issues" in value;
+}
+function formatPathSegment(segment) {
+    if (typeof segment === "object" && segment !== null && "key" in segment) {
+        return String(segment.key);
+    }
+    return String(segment);
+}
+export async function validateRequirements(requirements, value) {
+    const standard = requirements["~standard"];
+    if (standard === undefined ||
+        typeof standard !== "object" ||
+        standard === null ||
+        typeof standard.validate !== "function") {
+        throw new InvalidConfigurationProvidedError({
+            message: "requirements must implement Standard Schema v1.",
+        });
+    }
+    const result = await standard.validate(value);
+    if (!isStandardSchemaResult(result)) {
+        throw new InvalidConfigurationProvidedError({
+            message: "requirements returned an invalid Standard Schema result.",
+        });
+    }
+    if ("issues" in result && Array.isArray(result.issues) && result.issues.length > 0) {
+        const firstIssue = result.issues[0];
+        const issuePath = firstIssue?.path && firstIssue.path.length > 0
+            ? ` at ${firstIssue.path.map(formatPathSegment).join(".")}`
+            : "";
+        const issueMessage = firstIssue?.message ?? "Validation failed.";
+        throw new RequirementsValidationFailedError({
+            message: `Barekey requirements validation failed${issuePath}: ${issueMessage}`,
+        });
+    }
+}

package/dist/internal/runtime.d.ts

@@ -0,0 +1,15 @@
+import type { BarekeyClientOptions, BarekeyStandardSchemaV1 } from "../types.js";
+import { type InternalAuthResolver } from "./http.js";
+type BarekeyResolvedScope = {
+    organization: string;
+    project: string;
+    environment: string;
+};
+export type BarekeyRuntimeContext = BarekeyResolvedScope & {
+    baseUrl: string;
+    auth: InternalAuthResolver;
+    requirements?: BarekeyStandardSchemaV1;
+};
+export declare function resolveRuntimeContext(options: BarekeyClientOptions, fetchFn: typeof globalThis.fetch): Promise<BarekeyRuntimeContext>;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/internal/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/internal/runtime.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,oBAAoB,EAAqB,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACpG,OAAO,EAAE,KAAK,oBAAoB,EAAoB,MAAM,WAAW,CAAC;AASxE,KAAK,oBAAoB,GAAG;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,oBAAoB,GAAG;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,YAAY,CAAC,EAAE,uBAAuB,CAAC;CACxC,CAAC;AA8JF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,OAAO,UAAU,CAAC,KAAK,GAC/B,OAAO,CAAC,qBAAqB,CAAC,CAQhC"}