@mongrov/db 0.2.0

package/README.md

@@ -0,0 +1,332 @@
+# @mongrov/db
+
+Database utilities for `@mongrov` apps:
+
+- **KVStore** — Unified async key-value storage (MMKV + SecureStore)
+- **RxDB** — Document database with reactive queries and offline-first support
+
+## Installation
+
+```bash
+pnpm add @mongrov/db react-native-mmkv
+
+# For secure storage (optional)
+npx expo install expo-secure-store
+
+# For RxDB document database (optional)
+pnpm add rxdb rxdb-premium
+```
+
+## KVStore
+
+Unified async API over MMKV (fast) and SecureStore (secure).
+
+### Basic Usage
+
+```typescript
+import { createKVStore } from '@mongrov/db'
+
+// Default MMKV store for preferences
+const prefs = createKVStore()
+await prefs.set('theme', 'dark')
+const theme = await prefs.get('theme') // 'dark'
+
+// Store objects (JSON serialized)
+await prefs.setObject('user', { id: 1, name: 'Alice' })
+const user = await prefs.getObject<User>('user')
+```
+
+### Secure Storage
+
+Use for tokens, secrets, and sensitive data:
+
+```typescript
+const tokens = createKVStore({ secure: true })
+await tokens.set('accessToken', 'jwt...')
+await tokens.set('refreshToken', 'refresh...')
+```
+
+### Instance Isolation
+
+Create isolated stores with custom instance IDs:
+
+```typescript
+const cache = createKVStore({ instanceId: 'api-cache' })
+const settings = createKVStore({ instanceId: 'user-settings' })
+
+// These don't interfere with each other
+await cache.set('data', 'cached')
+await settings.set('data', 'settings')
+```
+
+### API
+
+```typescript
+interface KVStore {
+  // String operations
+  get(key: string): Promise<string | null>
+  set(key: string, value: string): Promise<void>
+  delete(key: string): Promise<void>
+
+  // Object operations (JSON serialization)
+  getObject<T>(key: string): Promise<T | null>
+  setObject<T>(key: string, value: T): Promise<void>
+
+  // Utility
+  clear(): Promise<void>
+  getAllKeys(): Promise<string[]>
+}
+
+interface KVStoreConfig {
+  secure?: boolean    // Use SecureStore (default: false)
+  instanceId?: string // MMKV instance ID (default: 'mongrov-kv')
+}
+```
+
+## Configuration Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `secure` | `false` | Use expo-secure-store instead of MMKV |
+| `instanceId` | `'mongrov-kv'` | MMKV instance ID for isolation (ignored when secure=true) |
+
+## When to Use Each Backend
+
+| Backend | Use For | Characteristics |
+|---------|---------|-----------------|
+| **MMKV** (default) | Preferences, theme, caches, flags | Fast, synchronous, large capacity |
+| **SecureStore** | Tokens, secrets, credentials | Encrypted, platform keychain, 2KB limit per value |
+
+## Auth Integration
+
+Use `createTokenStore` to integrate with `@mongrov/auth`:
+
+```typescript
+import { createKVStore, createTokenStore } from '@mongrov/db'
+import { createAuthClient } from '@mongrov/auth'
+
+// Create secure KVStore for tokens
+const secureStore = createKVStore({ secure: true })
+
+// Bridge to auth's TokenStore interface
+const tokenStore = createTokenStore(secureStore)
+
+// Use with auth client
+const authClient = createAuthClient({
+  adapter: myAdapter,
+  tokenStore, // Tokens now stored via KVStore
+})
+```
+
+The `createTokenStore` function wraps a `KVStore` to implement auth's `TokenStore` interface:
+
+```typescript
+interface TokenStore {
+  getAccessToken(): Promise<string | null>
+  setAccessToken(token: string): Promise<void>
+  getRefreshToken(): Promise<string | null>
+  setRefreshToken(token: string): Promise<void>
+  clear(): Promise<void>
+}
+```
+
+## RxDB Database
+
+Create offline-first document databases with reactive queries.
+
+### Creating a Database
+
+```typescript
+import { createDatabase } from '@mongrov/db'
+import { getRxStorageSQLite } from 'rxdb-premium/plugins/storage-sqlite'
+
+// Define your schema
+const messageSchema = {
+  version: 0,
+  primaryKey: 'id',
+  type: 'object',
+  properties: {
+    id: { type: 'string', maxLength: 100 },
+    content: { type: 'string' },
+    conversationId: { type: 'string' },
+    createdAt: { type: 'number' },
+  },
+  required: ['id', 'content', 'conversationId'],
+  indexes: ['conversationId', 'createdAt'],
+}
+
+// Create the database
+const db = await createDatabase({
+  name: 'myapp',
+  storage: getRxStorageSQLite(),
+  collections: [
+    { name: 'messages', schema: messageSchema },
+    { name: 'conversations', schema: conversationSchema },
+  ],
+  logger: console, // Optional: log database operations
+})
+```
+
+### React Integration
+
+Use the `DatabaseProvider` and hooks for reactive data access:
+
+```tsx
+import {
+  DatabaseProvider,
+  useDatabase,
+  useCollection,
+  useQuery,
+  useDocument,
+} from '@mongrov/db'
+
+// Wrap your app with the provider
+function App() {
+  const [db, setDb] = useState(null)
+
+  useEffect(() => {
+    createDatabase(config).then(setDb)
+    return () => db?.destroy()
+  }, [])
+
+  return (
+    <DatabaseProvider database={db}>
+      <MyApp />
+    </DatabaseProvider>
+  )
+}
+
+// Access database and collections
+function MessageList({ conversationId }) {
+  const { db, isReady } = useDatabase()
+  const messages = useCollection('messages')
+
+  // Reactive query with automatic updates
+  const { data, isLoading, error } = useQuery('messages', {
+    selector: { conversationId },
+    sort: [{ createdAt: 'desc' }],
+    limit: 50,
+  })
+
+  if (isLoading) return <Loading />
+  if (error) return <Error message={error.message} />
+
+  return <FlatList data={data} renderItem={renderMessage} />
+}
+
+// Fetch single document by ID
+function MessageDetail({ messageId }) {
+  const { data: message, isLoading } = useDocument('messages', messageId)
+
+  if (isLoading) return <Loading />
+  if (!message) return <NotFound />
+
+  return <MessageView message={message} />
+}
+```
+
+### Schema Migrations
+
+Handle schema upgrades with migration strategies:
+
+```typescript
+const collections = [
+  {
+    name: 'messages',
+    schema: messageSchemaV2, // version: 2
+    migrationStrategies: {
+      1: (oldDoc) => ({ ...oldDoc, readStatus: 'unread' }),
+      2: (oldDoc) => ({ ...oldDoc, reactions: [] }),
+    },
+  },
+]
+```
+
+### API Reference
+
+```typescript
+// Database factory
+createDatabase(config: DatabaseConfig): Promise<RxDatabase>
+destroyDatabase(db: RxDatabase): Promise<void>
+
+// React hooks
+useDatabase(): { db: RxDatabase | null, isReady: boolean }
+useCollection<T>(name: string): RxCollection<T> | null
+useQuery<T>(collection: string, query?: MangoQuery): QueryResult<T>
+useDocument<T>(collection: string, id: string | null): DocumentResult<T>
+
+// Result types
+interface QueryResult<T> {
+  data: T[]
+  isLoading: boolean
+  error: Error | null
+  refetch: () => void
+}
+
+interface DocumentResult<T> {
+  data: T | null
+  isLoading: boolean
+  error: Error | null
+  refetch: () => void
+}
+```
+
+### Replication
+
+Sync collections with remote backends using push/pull handlers:
+
+```typescript
+import { createReplicationState, cancelReplication } from '@mongrov/db'
+
+// Create replication with push/pull handlers
+const replication = createReplicationState({
+  replicationIdentifier: 'messages-sync',
+  collection: db.messages,
+
+  // Push local changes to remote
+  push: {
+    handler: async (docs) => {
+      await api.sendMessages(docs)
+    },
+    batchSize: 50,
+  },
+
+  // Pull remote changes
+  pull: {
+    handler: async (checkpoint, batchSize) => {
+      const result = await api.getMessages({ since: checkpoint, limit: batchSize })
+      return {
+        documents: result.messages,
+        checkpoint: result.lastTimestamp,
+      }
+    },
+    batchSize: 100,
+  },
+
+  live: true, // Enable real-time sync
+  logger: console,
+})
+
+// Listen for errors
+replication.error$.subscribe((error) => {
+  console.error('Sync error:', error)
+})
+
+// Trigger manual sync
+await replication.reSync()
+
+// Stop replication when done
+await cancelReplication(replication)
+```
+
+The replication helper is a thin wrapper over RxDB's replication plugin. Your push/pull handlers connect to your backend (REST API, WebSocket, or @mongrov/collab adapter).
+
+## Peer Dependencies
+
+- `react-native-mmkv` (required for KVStore)
+- `expo-secure-store` (optional — only if using `secure: true`)
+- `rxdb` (optional — only if using database features)
+
+## License
+
+MIT

package/dist/database.d.ts

@@ -0,0 +1,42 @@
+/**
+ * RxDB Database Factory
+ *
+ * Creates a configured RxDB database instance with collections.
+ * App provides storage adapter (e.g., getRxStorageSQLite()).
+ */
+import type { DatabaseConfig, RxDatabaseType } from './types';
+/**
+ * Creates an RxDB database instance with configured collections.
+ *
+ * @param config - Database configuration
+ * @returns Promise resolving to the RxDB database instance
+ *
+ * @example
+ * ```typescript
+ * import { createDatabase } from '@mongrov/db'
+ * import { getRxStorageSQLite } from 'rxdb-premium/plugins/storage-sqlite'
+ *
+ * const db = await createDatabase({
+ *   name: 'myapp',
+ *   storage: getRxStorageSQLite(),
+ *   collections: [
+ *     {
+ *       name: 'messages',
+ *       schema: messageSchema,
+ *       migrationStrategies: {
+ *         1: (oldDoc) => ({ ...oldDoc, newField: 'default' })
+ *       }
+ *     }
+ *   ],
+ *   logger: console,
+ * })
+ * ```
+ */
+export declare function createDatabase(config: DatabaseConfig): Promise<RxDatabaseType>;
+/**
+ * Destroys an RxDB database instance and cleans up resources.
+ *
+ * @param db - The database instance to destroy
+ */
+export declare function destroyDatabase(db: RxDatabaseType): Promise<void>;
+//# sourceMappingURL=database.d.ts.map

package/dist/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EAEf,MAAM,SAAS,CAAA;AAehB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAuCpF;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvE"}

package/dist/database.js

@@ -0,0 +1,83 @@
+/**
+ * RxDB Database Factory
+ *
+ * Creates a configured RxDB database instance with collections.
+ * App provides storage adapter (e.g., getRxStorageSQLite()).
+ */
+import { createRxDatabase, addRxPlugin } from 'rxdb';
+import { RxDBMigrationSchemaPlugin } from 'rxdb/plugins/migration-schema';
+// Add migration plugin for schema upgrades
+addRxPlugin(RxDBMigrationSchemaPlugin);
+/**
+ * Default no-op logger for when none is provided.
+ */
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+/**
+ * Creates an RxDB database instance with configured collections.
+ *
+ * @param config - Database configuration
+ * @returns Promise resolving to the RxDB database instance
+ *
+ * @example
+ * ```typescript
+ * import { createDatabase } from '@mongrov/db'
+ * import { getRxStorageSQLite } from 'rxdb-premium/plugins/storage-sqlite'
+ *
+ * const db = await createDatabase({
+ *   name: 'myapp',
+ *   storage: getRxStorageSQLite(),
+ *   collections: [
+ *     {
+ *       name: 'messages',
+ *       schema: messageSchema,
+ *       migrationStrategies: {
+ *         1: (oldDoc) => ({ ...oldDoc, newField: 'default' })
+ *       }
+ *     }
+ *   ],
+ *   logger: console,
+ * })
+ * ```
+ */
+export async function createDatabase(config) {
+    const { name, storage, collections, logger = noopLogger, multiInstance = false, ignoreDuplicate = true, } = config;
+    logger.info('Creating database', { name, collectionCount: collections.length });
+    // Create the database
+    const db = await createRxDatabase({
+        name,
+        storage,
+        multiInstance,
+        ignoreDuplicate,
+    });
+    logger.debug('Database created', { name });
+    // Add collections
+    if (collections.length > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const collectionConfigs = {};
+        for (const col of collections) {
+            collectionConfigs[col.name] = {
+                schema: col.schema,
+                ...(col.migrationStrategies && { migrationStrategies: col.migrationStrategies }),
+            };
+        }
+        await db.addCollections(collectionConfigs);
+        logger.info('Collections added', { names: collections.map(c => c.name) });
+    }
+    return db;
+}
+/**
+ * Destroys an RxDB database instance and cleans up resources.
+ *
+ * @param db - The database instance to destroy
+ */
+export async function destroyDatabase(db) {
+    if (db && typeof db.destroy === 'function') {
+        await db.destroy();
+    }
+}
+//# sourceMappingURL=database.js.map

package/dist/database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.js","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,MAAM,CAAA;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAQzE,2CAA2C;AAC3C,WAAW,CAAC,yBAAyB,CAAC,CAAA;AAEtC;;GAEG;AACH,MAAM,UAAU,GAAa;IAC3B,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;IACf,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC;IACd,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC;IACd,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;CAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,MAAsB;IACzD,MAAM,EACJ,IAAI,EACJ,OAAO,EACP,WAAW,EACX,MAAM,GAAG,UAAU,EACnB,aAAa,GAAG,KAAK,EACrB,eAAe,GAAG,IAAI,GACvB,GAAG,MAAM,CAAA;IAEV,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAA;IAE/E,sBAAsB;IACtB,MAAM,EAAE,GAAG,MAAM,gBAAgB,CAAC;QAChC,IAAI;QACJ,OAAO;QACP,aAAa;QACb,eAAe;KAChB,CAAC,CAAA;IAEF,MAAM,CAAC,KAAK,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;IAE1C,kBAAkB;IAClB,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3B,8DAA8D;QAC9D,MAAM,iBAAiB,GAAwB,EAAE,CAAA;QAEjD,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;YAC9B,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG;gBAC5B,MAAM,EAAE,GAAG,CAAC,MAAM;gBAClB,GAAG,CAAC,GAAG,CAAC,mBAAmB,IAAI,EAAE,mBAAmB,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAC;aACjF,CAAA;QACH,CAAC;QAED,MAAM,EAAE,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAA;QAC1C,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IAC3E,CAAC;IAED,OAAO,EAAE,CAAA;AACX,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,EAAkB;IACtD,IAAI,EAAE,IAAI,OAAO,EAAE,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QAC3C,MAAM,EAAE,CAAC,OAAO,EAAE,CAAA;IACpB,CAAC;AACH,CAAC"}

package/dist/hooks.d.ts

@@ -0,0 +1,136 @@
+/**
+ * React hooks for RxDB database access
+ *
+ * Provides context-based database injection and reactive query hooks.
+ */
+import { type ReactNode } from 'react';
+import type { RxDatabaseType, RxCollectionType, RxDocumentType, MangoQueryType } from './types';
+interface DatabaseContextValue {
+    db: RxDatabaseType | null;
+    isReady: boolean;
+}
+export interface DatabaseProviderProps {
+    /** The RxDB database instance (can be null during initialization) */
+    database: RxDatabaseType | null;
+    /** Child components */
+    children: ReactNode;
+}
+/**
+ * Provides database context to child components.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const [db, setDb] = useState<RxDatabase | null>(null)
+ *
+ *   useEffect(() => {
+ *     createDatabase(config).then(setDb)
+ *   }, [])
+ *
+ *   return (
+ *     <DatabaseProvider database={db}>
+ *       <MyApp />
+ *     </DatabaseProvider>
+ *   )
+ * }
+ * ```
+ */
+export declare function DatabaseProvider({ database, children }: DatabaseProviderProps): ReactNode;
+/**
+ * Hook to access the database context.
+ *
+ * @returns The database context value
+ * @throws If used outside of DatabaseProvider
+ */
+export declare function useDatabase(): DatabaseContextValue;
+/**
+ * Hook to access a specific collection.
+ *
+ * @param name - Collection name
+ * @returns The collection instance or null if not ready
+ *
+ * @example
+ * ```tsx
+ * function MessageList() {
+ *   const messages = useCollection('messages')
+ *
+ *   if (!messages) return <Loading />
+ *
+ *   // Use messages collection...
+ * }
+ * ```
+ */
+export declare function useCollection<T = RxCollectionType>(name: string): T | null;
+/**
+ * Query result state.
+ */
+export interface QueryResult<T> {
+    /** The query results (empty array while loading) */
+    data: T[];
+    /** Whether the query is currently loading */
+    isLoading: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** Re-execute the query */
+    refetch: () => void;
+}
+/**
+ * Hook to execute a reactive query on a collection.
+ *
+ * @param collectionName - Name of the collection to query
+ * @param query - RxDB/Mango query selector
+ * @returns Query result with reactive updates
+ *
+ * @example
+ * ```tsx
+ * function RecentMessages() {
+ *   const { data, isLoading, error } = useQuery('messages', {
+ *     selector: { createdAt: { $gt: Date.now() - 86400000 } },
+ *     sort: [{ createdAt: 'desc' }],
+ *     limit: 50,
+ *   })
+ *
+ *   if (isLoading) return <Loading />
+ *   if (error) return <Error message={error.message} />
+ *
+ *   return <MessageList messages={data} />
+ * }
+ * ```
+ */
+export declare function useQuery<T = RxDocumentType>(collectionName: string, query?: MangoQueryType): QueryResult<T>;
+/**
+ * Document result state.
+ */
+export interface DocumentResult<T> {
+    /** The document data or null if not found */
+    data: T | null;
+    /** Whether the document is currently loading */
+    isLoading: boolean;
+    /** Error if the fetch failed */
+    error: Error | null;
+    /** Re-fetch the document */
+    refetch: () => void;
+}
+/**
+ * Hook to fetch and subscribe to a single document by ID.
+ *
+ * @param collectionName - Name of the collection
+ * @param id - Document primary key
+ * @returns Document result with reactive updates
+ *
+ * @example
+ * ```tsx
+ * function MessageDetail({ messageId }: { messageId: string }) {
+ *   const { data: message, isLoading, error } = useDocument('messages', messageId)
+ *
+ *   if (isLoading) return <Loading />
+ *   if (error) return <Error message={error.message} />
+ *   if (!message) return <NotFound />
+ *
+ *   return <MessageView message={message} />
+ * }
+ * ```
+ */
+export declare function useDocument<T = RxDocumentType>(collectionName: string, id: string | null | undefined): DocumentResult<T>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAA;AAEd,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,cAAc,EACf,MAAM,SAAS,CAAA;AAIhB,UAAU,oBAAoB;IAC5B,EAAE,EAAE,cAAc,GAAG,IAAI,CAAA;IACzB,OAAO,EAAE,OAAO,CAAA;CACjB;AAMD,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAA;IAC/B,uBAAuB;IACvB,QAAQ,EAAE,SAAS,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,qBAAqB,GAAG,SAAS,CAUzF;AAID;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,oBAAoB,CAmBlD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAQ1E;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,oDAAoD;IACpD,IAAI,EAAE,CAAC,EAAE,CAAA;IACT,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAA;IAClB,gCAAgC;IAChC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,cAAc,EACzC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,cAAmB,GACzB,WAAW,CAAC,CAAC,CAAC,CAuDhB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,6CAA6C;IAC7C,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACd,gDAAgD;IAChD,SAAS,EAAE,OAAO,CAAA;IAClB,gCAAgC;IAChC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,cAAc,EAC5C,cAAc,EAAE,MAAM,EACtB,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC5B,cAAc,CAAC,CAAC,CAAC,CAoDnB"}