@trendify/cli 0.1.4

package/dist/modules/auth/auth-service.js

@@ -0,0 +1,288 @@
+import { createClient, } from '@supabase/supabase-js';
+import { TRENDIFY_AUTH_STORAGE_FILE } from '../../config/app-paths.js';
+import { getCliEnvValidationResult } from '../../config/env.js';
+import { FileStorage } from './auth-storage.js';
+const AUTH_STORAGE_KEY = 'trendify.auth.token';
+function toAuthErrorMessage(error, fallbackMessage) {
+    if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string') {
+        return error.message;
+    }
+    return fallbackMessage;
+}
+export class AuthService {
+    client;
+    storageFilePath;
+    static create(env) {
+        const storage = new FileStorage(TRENDIFY_AUTH_STORAGE_FILE);
+        const client = createClient(env.supabaseUrl, env.supabasePublishableDefaultKey, {
+            auth: {
+                autoRefreshToken: true,
+                detectSessionInUrl: false,
+                persistSession: true,
+                storage,
+                storageKey: AUTH_STORAGE_KEY,
+            },
+        });
+        return new AuthService(client, TRENDIFY_AUTH_STORAGE_FILE);
+    }
+    constructor(client, storageFilePath) {
+        this.client = client;
+        this.storageFilePath = storageFilePath;
+    }
+    getSessionStorageFilePath() {
+        return this.storageFilePath;
+    }
+    onAuthStateChange(listener) {
+        return this.client.auth.onAuthStateChange((_event, session) => {
+            listener({
+                session,
+                user: session?.user ?? null,
+            });
+        });
+    }
+    async restoreSession() {
+        try {
+            const { data: { session }, error: sessionError, } = await this.client.auth.getSession();
+            if (sessionError) {
+                return {
+                    data: null,
+                    error: sessionError.message,
+                    errorCode: sessionError.code ?? null,
+                };
+            }
+            if (!session) {
+                return {
+                    data: {
+                        session: null,
+                        user: null,
+                    },
+                    error: null,
+                    errorCode: null,
+                };
+            }
+            const { data: { user }, error: userError, } = await this.client.auth.getUser();
+            if (userError || !user) {
+                await this.client.auth.signOut({ scope: 'local' });
+                return {
+                    data: {
+                        session: null,
+                        user: null,
+                    },
+                    error: userError?.message ?? 'Sua sessao expirou. Faca login novamente.',
+                    errorCode: userError?.code ?? null,
+                };
+            }
+            return {
+                data: {
+                    session,
+                    user,
+                },
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel restaurar a sessao atual.'),
+                errorCode: null,
+            };
+        }
+    }
+    async signInWithPassword(email, password) {
+        try {
+            const { data, error } = await this.client.auth.signInWithPassword({
+                email,
+                password,
+            });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            if (!data.session || !data.user) {
+                return {
+                    data: null,
+                    error: 'O Supabase nao retornou uma sessao valida para este usuario.',
+                    errorCode: null,
+                };
+            }
+            return {
+                data: {
+                    session: data.session,
+                    user: data.user,
+                },
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel concluir o login agora.'),
+                errorCode: null,
+            };
+        }
+    }
+    async signOut() {
+        try {
+            const { error } = await this.client.auth.signOut({ scope: 'local' });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            return {
+                data: null,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel encerrar a sessao atual.'),
+                errorCode: null,
+            };
+        }
+    }
+    async updateDisplayName(displayName) {
+        try {
+            const { data: { user: currentUser }, error: currentUserError, } = await this.client.auth.getUser();
+            if (currentUserError) {
+                return {
+                    data: null,
+                    error: currentUserError.message,
+                    errorCode: currentUserError.code ?? null,
+                };
+            }
+            if (!currentUser) {
+                return {
+                    data: null,
+                    error: 'Nao existe um usuario autenticado para atualizar o profile.',
+                    errorCode: null,
+                };
+            }
+            const currentMetadata = currentUser.user_metadata &&
+                typeof currentUser.user_metadata === 'object' &&
+                !Array.isArray(currentUser.user_metadata)
+                ? currentUser.user_metadata
+                : {};
+            const { data, error } = await this.client.auth.updateUser({
+                data: {
+                    ...currentMetadata,
+                    display_name: displayName,
+                },
+            });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            if (!data.user) {
+                return {
+                    data: null,
+                    error: 'O Supabase nao retornou o usuario atualizado.',
+                    errorCode: null,
+                };
+            }
+            return {
+                data: data.user,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel atualizar o display name agora.'),
+                errorCode: null,
+            };
+        }
+    }
+    async sendPasswordReauthenticationCode() {
+        try {
+            const { error } = await this.client.auth.reauthenticate();
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            return {
+                data: null,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel solicitar o codigo de verificacao.'),
+                errorCode: null,
+            };
+        }
+    }
+    async updatePassword(password, nonce) {
+        try {
+            const { data, error } = await this.client.auth.updateUser(nonce
+                ? {
+                    nonce,
+                    password,
+                }
+                : {
+                    password,
+                });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            if (!data.user) {
+                return {
+                    data: null,
+                    error: 'O Supabase nao retornou o usuario atualizado apos trocar a senha.',
+                    errorCode: null,
+                };
+            }
+            return {
+                data: data.user,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel atualizar a senha agora.'),
+                errorCode: null,
+            };
+        }
+    }
+}
+let cachedAuthBootstrap = null;
+export function getAuthBootstrapResult() {
+    if (cachedAuthBootstrap) {
+        return cachedAuthBootstrap;
+    }
+    const envValidation = getCliEnvValidationResult();
+    if (!envValidation.ok) {
+        cachedAuthBootstrap = envValidation;
+        return cachedAuthBootstrap;
+    }
+    cachedAuthBootstrap = {
+        ok: true,
+        env: envValidation.env,
+        authService: AuthService.create(envValidation.env),
+    };
+    return cachedAuthBootstrap;
+}

package/dist/modules/auth/auth-storage.d.ts

@@ -0,0 +1,11 @@
+import { type SupportedStorage } from '@supabase/supabase-js';
+export declare class FileStorage implements SupportedStorage {
+    private readonly filePath;
+    private queue;
+    constructor(filePath: string);
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, value: string): Promise<void>;
+    private runExclusive;
+}
+//# sourceMappingURL=auth-storage.d.ts.map

package/dist/modules/auth/auth-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-storage.d.ts","sourceRoot":"","sources":["../../../src/modules/auth/auth-storage.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AA0C9D,qBAAa,WAAY,YAAW,gBAAgB;IAG/B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF5C,OAAO,CAAC,KAAK,CAAuC;gBAEhB,QAAQ,EAAE,MAAM;IAEvC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQ5C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAatC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/D,OAAO,CAAC,YAAY;CAUrB"}

package/dist/modules/auth/auth-storage.js

@@ -0,0 +1,65 @@
+import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+async function ensureParentDirectory(filePath) {
+    await mkdir(dirname(filePath), { recursive: true });
+}
+async function readStorageMap(filePath) {
+    try {
+        const fileContents = await readFile(filePath, 'utf8');
+        const parsedContents = JSON.parse(fileContents);
+        if (!parsedContents || typeof parsedContents !== 'object' || Array.isArray(parsedContents)) {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(parsedContents).filter((entry) => typeof entry[1] === 'string'));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return {};
+        }
+        return {};
+    }
+}
+async function writeStorageMap(filePath, data) {
+    await ensureParentDirectory(filePath);
+    const tempFilePath = `${filePath}.tmp`;
+    await writeFile(tempFilePath, JSON.stringify(data, null, 2), 'utf8');
+    await rename(tempFilePath, filePath);
+    if (process.platform !== 'win32') {
+        await chmod(filePath, 0o600).catch(() => undefined);
+    }
+}
+export class FileStorage {
+    filePath;
+    queue = Promise.resolve();
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async getItem(key) {
+        return this.runExclusive(async () => {
+            const data = await readStorageMap(this.filePath);
+            return data[key] ?? null;
+        });
+    }
+    async removeItem(key) {
+        await this.runExclusive(async () => {
+            const data = await readStorageMap(this.filePath);
+            if (!(key in data)) {
+                return;
+            }
+            delete data[key];
+            await writeStorageMap(this.filePath, data);
+        });
+    }
+    async setItem(key, value) {
+        await this.runExclusive(async () => {
+            const data = await readStorageMap(this.filePath);
+            data[key] = value;
+            await writeStorageMap(this.filePath, data);
+        });
+    }
+    runExclusive(operation) {
+        const nextOperation = this.queue.then(operation, operation);
+        this.queue = nextOperation.then(() => undefined, () => undefined);
+        return nextOperation;
+    }
+}

package/dist/modules/auth/auth-user.d.ts

@@ -0,0 +1,3 @@
+import { type AuthUser } from '@supabase/supabase-js';
+export declare function getUserDisplayName(user: Pick<AuthUser, 'user_metadata'> | null | undefined): string | null;
+//# sourceMappingURL=auth-user.d.ts.map

package/dist/modules/auth/auth-user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-user.d.ts","sourceRoot":"","sources":["../../../src/modules/auth/auth-user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAa1G"}

package/dist/modules/auth/auth-user.js

@@ -0,0 +1,10 @@
+export function getUserDisplayName(user) {
+    const value = user && user.user_metadata && typeof user.user_metadata === 'object' && !Array.isArray(user.user_metadata)
+        ? user.user_metadata.display_name
+        : null;
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmedValue = value.trim();
+    return trimmedValue ? trimmedValue : null;
+}

package/dist/modules/auth/page/login-page.d.ts

@@ -0,0 +1,12 @@
+type LoginPageProps = {
+    readonly busy: boolean;
+    readonly email: string;
+    readonly onEmailChange: (value: string) => void;
+    readonly onPasswordChange: (value: string) => void;
+    readonly onSubmit: () => void;
+    readonly password: string;
+    readonly sessionStorageFilePath: string;
+};
+export declare function LoginPage({ busy, email, onEmailChange, onPasswordChange, onSubmit, password, sessionStorageFilePath, }: LoginPageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=login-page.d.ts.map

package/dist/modules/auth/page/login-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login-page.d.ts","sourceRoot":"","sources":["../../../../src/modules/auth/page/login-page.tsx"],"names":[],"mappings":"AAIA,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,QAAQ,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;CACzC,CAAC;AAIF,wBAAgB,SAAS,CAAC,EACxB,IAAI,EACJ,KAAK,EACL,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,QAAQ,EACR,sBAAsB,GACvB,EAAE,cAAc,2CAqDhB"}

package/dist/modules/auth/page/login-page.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { useState } from 'react';
+import { TextField } from '../../../shared/components/text-field.js';
+export function LoginPage({ busy, email, onEmailChange, onPasswordChange, onSubmit, password, sessionStorageFilePath, }) {
+    const [focusField, setFocusField] = useState('email');
+    useInput((_input, key) => {
+        if (busy) {
+            return;
+        }
+        if (key.tab || key.downArrow || key.upArrow) {
+            setFocusField((current) => (current === 'email' ? 'password' : 'email'));
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Entre com um usuario ja cadastrado no Supabase para liberar os comandos internos." }), _jsx(Text, { dimColor: true, children: "Cadastro nao esta habilitado nesta CLI." }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: focusField === 'email' ? 'greenBright' : 'white', children: "Email" }), _jsx(TextField, { focus: focusField === 'email', placeholder: "voce@empresa.com", value: email, onChange: onEmailChange, onSubmit: (value) => {
+                            if (value.trim()) {
+                                setFocusField('password');
+                            }
+                        } })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: focusField === 'password' ? 'greenBright' : 'white', children: "Senha" }), _jsx(TextField, { focus: focusField === 'password', mask: "*", placeholder: "Sua senha", value: password, onChange: onPasswordChange, onSubmit: () => {
+                            onSubmit();
+                        } })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "Enter faz login. Tab ou setas alternam o campo ativo." }), _jsxs(Text, { dimColor: true, children: ["Sessao persistida localmente em: ", sessionStorageFilePath] })] })] }));
+}

package/dist/modules/discovery/components/discovery-step-header.d.ts

@@ -0,0 +1,7 @@
+type DiscoveryStepHeaderProps = {
+    readonly subtitle: string;
+    readonly title: string;
+};
+export declare function DiscoveryStepHeader({ subtitle, title }: DiscoveryStepHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=discovery-step-header.d.ts.map

package/dist/modules/discovery/components/discovery-step-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-step-header.d.ts","sourceRoot":"","sources":["../../../../src/modules/discovery/components/discovery-step-header.tsx"],"names":[],"mappings":"AAEA,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,wBAAwB,2CAOhF"}

package/dist/modules/discovery/components/discovery-step-header.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function DiscoveryStepHeader({ subtitle, title }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "yellow", children: title }), _jsx(Text, { dimColor: true, children: subtitle })] }));
+}

package/dist/modules/discovery/page/discovery-page.d.ts

@@ -0,0 +1,11 @@
+type DiscoveryScope = 'amplo' | 'restrito';
+type DiscoveryPageProps = {
+    readonly onCancel: () => void;
+    readonly onComplete: (result: {
+        scope: DiscoveryScope;
+        theme: string;
+    }) => void;
+};
+export declare function DiscoveryPage({ onCancel, onComplete }: DiscoveryPageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=discovery-page.d.ts.map

package/dist/modules/discovery/page/discovery-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-page.d.ts","sourceRoot":"","sources":["../../../../src/modules/discovery/page/discovery-page.tsx"],"names":[],"mappings":"AAOA,KAAK,cAAc,GAAG,OAAO,GAAG,UAAU,CAAC;AAE3C,KAAK,kBAAkB,GAAG;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CACjF,CAAC;AAeF,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,kBAAkB,2CAsEzE"}

package/dist/modules/discovery/page/discovery-page.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { ActionMenuPage } from '../../../shared/components/action-menu-page.js';
+import { StepHeader } from '../../../shared/components/step-header.js';
+import { TextField } from '../../../shared/components/text-field.js';
+const SCOPE_OPTIONS = [
+    {
+        value: 'amplo',
+        label: 'Mais ampla',
+        description: 'Busca caminhos mais abrangentes em torno do tema informado.',
+    },
+    {
+        value: 'restrito',
+        label: 'Mais restrita',
+        description: 'Foca em recortes mais especificos e direcionados do tema.',
+    },
+];
+export function DiscoveryPage({ onCancel, onComplete }) {
+    const [step, setStep] = useState('theme');
+    const [theme, setTheme] = useState('');
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (step !== 'scope') {
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex((current) => current === 0 ? SCOPE_OPTIONS.length - 1 : current - 1);
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIndex((current) => current === SCOPE_OPTIONS.length - 1 ? 0 : current + 1);
+            return;
+        }
+        if (key.return) {
+            const option = SCOPE_OPTIONS[selectedIndex];
+            if (option) {
+                onComplete({
+                    scope: option.value,
+                    theme: theme.trim(),
+                });
+            }
+        }
+    });
+    if (step === 'theme') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StepHeader, { title: "Qual e o tema da descoberta?", subtitle: "Digite o tema e pressione Enter para continuar." }), _jsx(TextField, { placeholder: "Ex.: IA generativa", value: theme, onChange: setTheme, onSubmit: (value) => {
+                        if (value.trim()) {
+                            setTheme(value);
+                            setStep('scope');
+                        }
+                    } }), _jsx(Text, { dimColor: true, children: "Esc volta para o menu inicial." })] }));
+    }
+    return (_jsx(ActionMenuPage, { title: "Como voce quer seguir com esse tema?", subtitle: `Tema selecionado: "${theme.trim()}". Escolha o tipo de exploracao.`, options: SCOPE_OPTIONS, selectedIndex: selectedIndex, hintText: "Use as setas para navegar. Enter confirma. Esc volta ao menu." }));
+}

package/dist/modules/profile/page/profile-page.d.ts

@@ -0,0 +1,12 @@
+import { type AuthUser } from '@supabase/supabase-js';
+import { type AuthService } from '../../auth/auth-service.js';
+type NotificationTone = 'error' | 'info' | 'success';
+type ProfilePageProps = {
+    readonly authService: AuthService;
+    readonly onBack: () => void;
+    readonly onNotificationChange: (notification: string | null, tone?: NotificationTone) => void;
+    readonly user: AuthUser;
+};
+export declare function ProfilePage({ authService, onBack, onNotificationChange, user }: ProfilePageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=profile-page.d.ts.map

package/dist/modules/profile/page/profile-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-page.d.ts","sourceRoot":"","sources":["../../../../src/modules/profile/page/profile-page.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAM9D,KAAK,gBAAgB,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAKrD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,oBAAoB,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC9F,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB,CAAC;AAwBF,wBAAgB,WAAW,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,oBAAoB,EAAE,IAAI,EAAE,EAAE,gBAAgB,2CAwQhG"}