@flowerforce/flowerbase-client 0.1.1-beta.0

package/dist/app.js

@@ -0,0 +1,461 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const functions_1 = require("./functions");
+const http_1 = require("./http");
+const session_1 = require("./session");
+const credentials_1 = require("./credentials");
+const user_1 = require("./user");
+const API_PREFIX = '/api/client/v2.0';
+class App {
+    constructor(idOrConfig) {
+        this.usersById = new Map();
+        this.sessionsByUserId = new Map();
+        this.usersOrder = [];
+        this.profilesByUserId = new Map();
+        this.listeners = new Set();
+        const config = typeof idOrConfig === 'string' ? { id: idOrConfig } : idOrConfig;
+        this.id = config.id;
+        this.baseUrl = (config.baseUrl ?? '').replace(/\/$/, '');
+        this.timeout = config.timeout ?? 10000;
+        this.sessionManager = new session_1.SessionManager(this.id);
+        const persistedSessionsByUser = this.sessionManager.getSessionsByUser();
+        for (const [userId, session] of Object.entries(persistedSessionsByUser)) {
+            this.sessionsByUserId.set(userId, session);
+        }
+        this.usersOrder = this.sessionManager.getUsersOrder();
+        for (const userId of this.sessionsByUserId.keys()) {
+            if (!this.usersOrder.includes(userId)) {
+                this.usersOrder.push(userId);
+            }
+        }
+        for (const userId of this.usersOrder) {
+            this.getOrCreateUser(userId);
+        }
+        const currentSession = this.sessionManager.get();
+        if (currentSession?.userId) {
+            this.sessionsByUserId.set(currentSession.userId, currentSession);
+            this.getOrCreateUser(currentSession.userId);
+            this.touchUser(currentSession.userId);
+            this.persistSessionsByUser();
+        }
+        else {
+            this.setCurrentSessionFromOrder();
+        }
+        this.sessionBootstrapPromise = this.bootstrapSessionOnLoad();
+        this.emailPasswordAuth = {
+            registerUser: ({ email, password }) => this.postProvider('/local-userpass/register', { email, password }),
+            confirmUser: ({ token, tokenId }) => this.postProvider('/local-userpass/confirm', { token, tokenId }),
+            resendConfirmationEmail: ({ email }) => this.postProvider('/local-userpass/confirm/send', { email }),
+            retryCustomConfirmation: ({ email }) => this.postProvider('/local-userpass/confirm/call', { email }),
+            sendResetPasswordEmail: (input) => this.postProvider('/local-userpass/reset/send', {
+                email: typeof input === 'string' ? input : input.email
+            }),
+            callResetPasswordFunction: (input, passwordOrArg, ...args) => {
+                if (typeof input === 'string') {
+                    return this.postProvider('/local-userpass/reset/call', {
+                        email: input,
+                        password: passwordOrArg,
+                        arguments: args
+                    });
+                }
+                return this.postProvider('/local-userpass/reset/call', {
+                    email: input.email,
+                    password: input.password,
+                    arguments: [passwordOrArg, ...args].filter((value) => value !== undefined)
+                });
+            },
+            resetPassword: ({ token, tokenId, password }) => this.postProvider('/local-userpass/reset', { token, tokenId, password })
+        };
+    }
+    static getApp(appIdOrConfig) {
+        const appId = typeof appIdOrConfig === 'string' ? appIdOrConfig : appIdOrConfig.id;
+        if (appId in App.appCache) {
+            return App.appCache[appId];
+        }
+        const app = new App(appIdOrConfig);
+        App.appCache[appId] = app;
+        return app;
+    }
+    get currentUser() {
+        for (const userId of this.usersOrder) {
+            const user = this.usersById.get(userId);
+            if (user?.state === 'active') {
+                return user;
+            }
+        }
+        return null;
+    }
+    get allUsers() {
+        const activeUsers = [];
+        const loggedOutUsers = [];
+        for (const userId of this.usersOrder) {
+            const user = this.usersById.get(userId);
+            if (!user)
+                continue;
+            if (user.state === 'active') {
+                activeUsers.push(userId);
+            }
+            else if (user.state === 'logged-out') {
+                loggedOutUsers.push(userId);
+            }
+        }
+        const users = Object.fromEntries([...activeUsers, ...loggedOutUsers].map((userId) => [userId, this.usersById.get(userId)]));
+        return users;
+    }
+    persistSessionsByUser() {
+        this.sessionManager.setSessionsByUser(Object.fromEntries(this.sessionsByUserId.entries()));
+    }
+    persistUsersOrder() {
+        this.sessionManager.setUsersOrder(this.usersOrder);
+    }
+    touchUser(userId) {
+        this.usersOrder = [userId, ...this.usersOrder.filter((id) => id !== userId)];
+        this.persistUsersOrder();
+    }
+    removeUserFromOrder(userId) {
+        this.usersOrder = this.usersOrder.filter((id) => id !== userId);
+        this.persistUsersOrder();
+    }
+    setSessionForUser(session) {
+        this.sessionsByUserId.set(session.userId, session);
+        this.sessionManager.set(session);
+        this.persistSessionsByUser();
+    }
+    clearSessionForUser(userId) {
+        this.sessionsByUserId.delete(userId);
+        this.persistSessionsByUser();
+    }
+    setCurrentSessionFromOrder() {
+        for (const userId of this.usersOrder) {
+            const session = this.sessionsByUserId.get(userId);
+            if (session) {
+                this.sessionManager.set(session);
+                return;
+            }
+        }
+        this.sessionManager.clear();
+    }
+    notifyListeners(userId) {
+        for (const callback of Array.from(this.listeners)) {
+            try {
+                callback();
+            }
+            catch {
+                // Listener failures should not break auth/session lifecycle.
+            }
+        }
+        if (userId) {
+            this.usersById.get(userId)?.notifyListeners();
+        }
+    }
+    providerUrl(path) {
+        return `${this.baseUrl}${API_PREFIX}/app/${this.id}/auth/providers${path}`;
+    }
+    authUrl(path) {
+        return `${this.baseUrl}${API_PREFIX}/auth${path}`;
+    }
+    functionsUrl(path = '/call') {
+        return `${this.baseUrl}${API_PREFIX}/app/${this.id}/functions${path}`;
+    }
+    async createSession(refreshToken) {
+        return (0, http_1.requestJson)({
+            url: this.authUrl('/session'),
+            method: 'POST',
+            bearerToken: refreshToken,
+            timeout: this.timeout
+        });
+    }
+    async bootstrapSessionOnLoad() {
+        const session = this.sessionManager.get();
+        if (!session || typeof localStorage === 'undefined') {
+            return;
+        }
+        try {
+            const result = await this.createSession(session.refreshToken);
+            this.setSessionForUser({
+                ...session,
+                accessToken: result.access_token
+            });
+        }
+        catch {
+            this.clearSessionForUser(session.userId);
+            this.setCurrentSessionFromOrder();
+        }
+    }
+    async ensureSessionBootstrapped() {
+        await this.sessionBootstrapPromise;
+    }
+    async setLoggedInUser(data, providerType, profileEmail) {
+        const sessionResult = await this.createSession(data.refresh_token);
+        const session = {
+            accessToken: sessionResult.access_token,
+            refreshToken: data.refresh_token,
+            userId: data.user_id
+        };
+        this.setSessionForUser(session);
+        const user = this.getOrCreateUser(data.user_id);
+        user.setProviderType(providerType);
+        this.touchUser(data.user_id);
+        if (profileEmail) {
+            user.profile = { email: profileEmail };
+        }
+        this.notifyListeners(data.user_id);
+        return user;
+    }
+    getOrCreateUser(userId) {
+        const existing = this.usersById.get(userId);
+        if (existing) {
+            return existing;
+        }
+        const user = new user_1.User(this, userId);
+        this.usersById.set(userId, user);
+        return user;
+    }
+    async logIn(credentials) {
+        if (credentials.provider === 'local-userpass') {
+            const result = await this.postProvider('/local-userpass/login', {
+                username: credentials.email,
+                password: credentials.password
+            });
+            return this.setLoggedInUser(result, 'local-userpass', credentials.email);
+        }
+        if (credentials.provider === 'anon-user') {
+            const result = await this.postProvider('/anon-user/login', {});
+            return this.setLoggedInUser(result, 'anon-user');
+        }
+        if (credentials.provider === 'custom-function') {
+            const result = await this.postProvider('/custom-function/login', credentials.payload);
+            return this.setLoggedInUser(result, 'custom-function');
+        }
+        if (credentials.provider === 'custom-token') {
+            const result = await this.postProvider('/custom-token/login', { token: credentials.token });
+            return this.setLoggedInUser(result, 'custom-token');
+        }
+        const unsupportedProvider = credentials;
+        throw new Error(`Unsupported credentials provider: ${JSON.stringify(unsupportedProvider)}`);
+    }
+    switchUser(nextUser) {
+        const knownUser = this.usersById.get(nextUser.id);
+        if (!knownUser) {
+            throw new Error('The user was never logged into this app');
+        }
+        this.touchUser(nextUser.id);
+        const session = this.sessionsByUserId.get(nextUser.id);
+        if (session) {
+            this.sessionManager.set(session);
+        }
+        this.notifyListeners(nextUser.id);
+    }
+    async removeUser(user) {
+        const knownUser = this.usersById.get(user.id);
+        if (!knownUser) {
+            throw new Error('The user was never logged into this app');
+        }
+        if (this.sessionsByUserId.has(user.id)) {
+            await this.logoutUser(user.id);
+        }
+        this.usersById.delete(user.id);
+        this.removeUserFromOrder(user.id);
+        this.profilesByUserId.delete(user.id);
+        this.clearSessionForUser(user.id);
+        this.setCurrentSessionFromOrder();
+        this.notifyListeners(user.id);
+    }
+    async deleteUser(user) {
+        await this.requestWithAccessToken((accessToken) => (0, http_1.requestJson)({
+            url: this.authUrl('/delete'),
+            method: 'DELETE',
+            bearerToken: accessToken,
+            timeout: this.timeout
+        }), user.id);
+        await this.removeUser(user);
+    }
+    getSessionOrThrow(userId) {
+        const targetUserId = userId ?? this.currentUser?.id;
+        const session = targetUserId ? this.sessionsByUserId.get(targetUserId) : this.sessionManager.get();
+        if (!session) {
+            throw new Error('User is not authenticated');
+        }
+        return session;
+    }
+    getSession(userId) {
+        if (userId) {
+            return this.sessionsByUserId.get(userId) ?? null;
+        }
+        return this.sessionManager.get();
+    }
+    hasUser(userId) {
+        return this.usersById.has(userId);
+    }
+    getProfileSnapshot(userId) {
+        return this.profilesByUserId.get(userId);
+    }
+    async postProvider(path, body) {
+        return (0, http_1.requestJson)({
+            url: this.providerUrl(path),
+            method: 'POST',
+            body,
+            timeout: this.timeout
+        });
+    }
+    async requestWithAccessToken(operation, userId) {
+        const firstSession = this.getSessionOrThrow(userId);
+        try {
+            return await operation(firstSession.accessToken);
+        }
+        catch (error) {
+            if (!(error instanceof http_1.FlowerbaseHttpError) || error.status !== 401) {
+                throw error;
+            }
+            await this.refreshAccessToken(userId);
+            const refreshedSession = this.getSessionOrThrow(userId);
+            return operation(refreshedSession.accessToken);
+        }
+    }
+    async callFunction(name, args, userId) {
+        await this.ensureSessionBootstrapped();
+        const payload = {
+            name,
+            arguments: args
+        };
+        const result = await this.requestWithAccessToken((accessToken) => (0, http_1.requestJson)({
+            url: this.functionsUrl('/call'),
+            method: 'POST',
+            body: payload,
+            bearerToken: accessToken,
+            timeout: this.timeout
+        }), userId);
+        return (0, functions_1.normalizeFunctionResponse)(result);
+    }
+    async callFunctionStreaming(name, args, userId) {
+        await this.ensureSessionBootstrapped();
+        const payload = {
+            name,
+            arguments: args
+        };
+        const resolveSession = () => this.getSessionOrThrow(userId);
+        const refreshSession = () => this.refreshAccessToken(userId);
+        const timeout = this.timeout;
+        const url = this.functionsUrl('/call');
+        return {
+            async *[Symbol.asyncIterator]() {
+                let didRefresh = false;
+                while (true) {
+                    const session = resolveSession();
+                    let stream;
+                    try {
+                        stream = await (0, http_1.requestStream)({
+                            url,
+                            method: 'POST',
+                            body: payload,
+                            bearerToken: session.accessToken,
+                            timeout
+                        });
+                    }
+                    catch (error) {
+                        if (!didRefresh && error instanceof http_1.FlowerbaseHttpError && error.status === 401) {
+                            await refreshSession();
+                            didRefresh = true;
+                            continue;
+                        }
+                        throw error;
+                    }
+                    try {
+                        for await (const chunk of stream) {
+                            yield chunk;
+                        }
+                        return;
+                    }
+                    catch (error) {
+                        if (!didRefresh && error instanceof http_1.FlowerbaseHttpError && error.status === 401) {
+                            await refreshSession();
+                            didRefresh = true;
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+        };
+    }
+    async callService(name, args, service = 'mongodb-atlas', userId) {
+        await this.ensureSessionBootstrapped();
+        const payload = {
+            name,
+            service,
+            arguments: args
+        };
+        return this.requestWithAccessToken((accessToken) => (0, http_1.requestJson)({
+            url: this.functionsUrl('/call'),
+            method: 'POST',
+            body: payload,
+            bearerToken: accessToken,
+            timeout: this.timeout
+        }), userId);
+    }
+    async getProfile(userId) {
+        await this.ensureSessionBootstrapped();
+        const profile = await this.requestWithAccessToken((accessToken) => (0, http_1.requestJson)({
+            url: this.authUrl('/profile'),
+            method: 'GET',
+            bearerToken: accessToken,
+            timeout: this.timeout
+        }), userId);
+        const session = this.getSessionOrThrow(userId);
+        this.profilesByUserId.set(session.userId, profile);
+        return profile;
+    }
+    async refreshAccessToken(userId) {
+        await this.ensureSessionBootstrapped();
+        const session = this.getSessionOrThrow(userId);
+        try {
+            const result = await this.createSession(session.refreshToken);
+            this.setSessionForUser({
+                ...session,
+                accessToken: result.access_token
+            });
+            this.touchUser(session.userId);
+            this.notifyListeners(session.userId);
+            return result.access_token;
+        }
+        catch (error) {
+            this.clearSessionForUser(session.userId);
+            this.setCurrentSessionFromOrder();
+            this.notifyListeners(session.userId);
+            throw error;
+        }
+    }
+    async logoutUser(userId) {
+        const session = this.getSession(userId ?? this.currentUser?.id);
+        try {
+            if (session) {
+                await (0, http_1.requestJson)({
+                    url: this.authUrl('/session'),
+                    method: 'DELETE',
+                    bearerToken: session.refreshToken,
+                    timeout: this.timeout
+                });
+            }
+        }
+        finally {
+            if (session) {
+                this.clearSessionForUser(session.userId);
+                this.notifyListeners(session.userId);
+            }
+            this.setCurrentSessionFromOrder();
+        }
+    }
+    addListener(callback) {
+        this.listeners.add(callback);
+    }
+    removeListener(callback) {
+        this.listeners.delete(callback);
+    }
+    removeAllListeners() {
+        this.listeners.clear();
+    }
+}
+exports.App = App;
+App.appCache = {};
+App.Credentials = credentials_1.Credentials;

package/dist/bson.d.ts

@@ -0,0 +1,8 @@
+import { EJSON, ObjectId, BSON as RawBSON } from 'bson';
+declare const ObjectID: typeof ObjectId;
+declare const BSON: typeof RawBSON & {
+    ObjectId: typeof ObjectId;
+    ObjectID: typeof ObjectId;
+};
+export { BSON, EJSON, ObjectId, ObjectID };
+//# sourceMappingURL=bson.d.ts.map

package/dist/bson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bson.d.ts","sourceRoot":"","sources":["../src/bson.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,MAAM,CAAA;AAEvD,QAAA,MAAM,QAAQ,iBAAW,CAAA;AACzB,QAAA,MAAM,IAAI;;;CAAqD,CAAA;AAE/D,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA"}

package/dist/bson.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectID = exports.ObjectId = exports.EJSON = exports.BSON = void 0;
+const bson_1 = require("bson");
+Object.defineProperty(exports, "EJSON", { enumerable: true, get: function () { return bson_1.EJSON; } });
+Object.defineProperty(exports, "ObjectId", { enumerable: true, get: function () { return bson_1.ObjectId; } });
+const ObjectID = bson_1.ObjectId;
+exports.ObjectID = ObjectID;
+const BSON = Object.assign({}, bson_1.BSON, { ObjectId: bson_1.ObjectId, ObjectID });
+exports.BSON = BSON;

package/dist/credentials.d.ts

@@ -0,0 +1,8 @@
+import { CredentialsLike } from './types';
+export declare class Credentials {
+    static emailPassword(email: string, password: string): CredentialsLike;
+    static anonymous(): CredentialsLike;
+    static function(payload: Record<string, unknown>): CredentialsLike;
+    static jwt(token: string): CredentialsLike;
+}
+//# sourceMappingURL=credentials.d.ts.map

package/dist/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../src/credentials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEzC,qBAAa,WAAW;IACtB,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,eAAe;IAQtE,MAAM,CAAC,SAAS,IAAI,eAAe;IAMnC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe;IAOlE,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe;CAM3C"}

package/dist/credentials.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credentials = void 0;
+class Credentials {
+    static emailPassword(email, password) {
+        return {
+            provider: 'local-userpass',
+            email,
+            password
+        };
+    }
+    static anonymous() {
+        return {
+            provider: 'anon-user'
+        };
+    }
+    static function(payload) {
+        return {
+            provider: 'custom-function',
+            payload
+        };
+    }
+    static jwt(token) {
+        return {
+            provider: 'custom-token',
+            token
+        };
+    }
+}
+exports.Credentials = Credentials;

package/dist/functions.d.ts

@@ -0,0 +1,6 @@
+export declare const normalizeFunctionResponse: (value: unknown) => any;
+export declare const createFunctionsProxy: (callFunction: (name: string, args: unknown[]) => Promise<unknown>, callFunctionStreaming: (name: string, args: unknown[]) => Promise<AsyncIterable<Uint8Array>>) => Record<string, (...args: unknown[]) => Promise<unknown>> & {
+    callFunction: (name: string, ...args: unknown[]) => Promise<unknown>;
+    callFunctionStreaming: (name: string, ...args: unknown[]) => Promise<AsyncIterable<Uint8Array>>;
+};
+//# sourceMappingURL=functions.d.ts.map

package/dist/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,yBAAyB,UAAW,OAAO,QAWvD,CAAA;AAED,eAAO,MAAM,oBAAoB,iBACjB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,OAAO,CAAC,yBAC1C,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,cAAc,UAAU,CAAC,CAAC,KAC3F,OAAO,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,OAAO,CAAC,CAAC,GAAG;IAC5D,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,OAAO,CAAC,CAAA;IACpE,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,cAAc,UAAU,CAAC,CAAC,CAAA;CAoB9F,CAAA"}

package/dist/functions.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFunctionsProxy = exports.normalizeFunctionResponse = void 0;
+const bson_1 = require("./bson");
+const RESERVED_PROXY_KEYS = new Set([
+    'toJSON',
+    'then',
+    'catch',
+    'finally',
+    'constructor',
+    '__proto__',
+    'prototype'
+]);
+const deserialize = (value) => {
+    if (!value || typeof value !== 'object')
+        return value;
+    return bson_1.EJSON.deserialize(value);
+};
+const normalizeFunctionResponse = (value) => {
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return deserialize(parsed);
+        }
+        catch {
+            return value;
+        }
+    }
+    return deserialize(value);
+};
+exports.normalizeFunctionResponse = normalizeFunctionResponse;
+const createFunctionsProxy = (callFunction, callFunctionStreaming) => new Proxy({}, {
+    get: (_, key) => {
+        if (typeof key !== 'string')
+            return undefined;
+        if (RESERVED_PROXY_KEYS.has(key))
+            return undefined;
+        if (key === 'callFunction') {
+            return (name, ...args) => callFunction(name, args);
+        }
+        if (key === 'callFunctionStreaming') {
+            return (name, ...args) => callFunctionStreaming(name, args);
+        }
+        return (...args) => callFunction(key, args);
+    }
+});
+exports.createFunctionsProxy = createFunctionsProxy;

package/dist/http.d.ts

@@ -0,0 +1,35 @@
+export declare class MongoDBRealmError extends Error {
+    readonly method: string;
+    readonly url: string;
+    readonly statusCode: number;
+    readonly statusText: string;
+    readonly error: string | undefined;
+    readonly errorCode: string | undefined;
+    readonly link: string | undefined;
+    readonly payload?: unknown;
+    constructor(params: {
+        method: string;
+        url: string;
+        statusCode: number;
+        statusText: string;
+        error?: string;
+        errorCode?: string;
+        link?: string;
+        payload?: unknown;
+    });
+}
+export declare class FlowerbaseHttpError extends MongoDBRealmError {
+    readonly status: number;
+    constructor(params: ConstructorParameters<typeof MongoDBRealmError>[0]);
+}
+type RequestParams = {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: unknown;
+    bearerToken?: string;
+    timeout?: number;
+};
+export declare const requestJson: <T = unknown>({ url, method, body, bearerToken, timeout }: RequestParams) => Promise<T>;
+export declare const requestStream: ({ url, method, body, bearerToken, timeout }: RequestParams) => Promise<AsyncIterable<Uint8Array>>;
+export {};
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAmDA,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;gBAEd,MAAM,EAAE;QAClB,MAAM,EAAE,MAAM,CAAA;QACd,GAAG,EAAE,MAAM,CAAA;QACX,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,MAAM,CAAA;QAClB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,OAAO,CAAC,EAAE,OAAO,CAAA;KAClB;CAYF;AAED,qBAAa,mBAAoB,SAAQ,iBAAiB;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;gBAEX,MAAM,EAAE,qBAAqB,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC;CAKvE;AAED,KAAK,aAAa,GAAG;IACnB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAA;IACpD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAsBD,eAAO,MAAM,WAAW,6DAMrB,aAAa,KAAG,QAAQ,CAAC,CAkC3B,CAAA;AAED,eAAO,MAAM,aAAa,gDAMvB,aAAa,KAAG,QAAQ,cAAc,UAAU,CAAC,CAkDnD,CAAA"}