hazo_chat 2.0.10 → 2.0.12

package/README.md

@@ -83,19 +83,56 @@ export default function RootLayout({ children }) {
 
 ### Required Tailwind Configuration
 
-Your `tailwind.config.ts` must include hazo_chat package paths in content:
+Your `tailwind.config.ts` must include hazo_chat package paths in the `content` array. This ensures that Tailwind CSS scans the component library files and includes all utility classes in your final CSS bundle.
+
+**Complete Configuration Example:**
 
 ```typescript
-export default {
+import type { Config } from 'tailwindcss';
+
+const config: Config = {
   content: [
-    // ... your existing paths
-    './node_modules/hazo_chat/dist/**/*.{js,ts,jsx,tsx}',
+    // Your application's content paths
+    './src/pages/**/*.{js,ts,jsx,tsx,mdx}',
+    './src/components/**/*.{js,ts,jsx,tsx,mdx}',
+    './src/app/**/*.{js,ts,jsx,tsx,mdx}',
+    
+    // Add this line to scan the hazo_chat package
+    './node_modules/hazo_chat/dist/**/*.js',
   ],
-  // ... rest of config
+  theme: {
+    extend: {
+      // Your theme extensions
+    },
+  },
+  plugins: [],
 };
+
+export default config;
 ```
 
-**Important:** Without this configuration, Tailwind classes used by hazo_chat components may not be compiled, causing styling issues.
+**Why This Is Required:**
+
+The `hazo_chat` component library uses Tailwind CSS utility classes (e.g., `flex`, `h-full`, `bg-background`, `p-4`) for all styling. These classes are not compiled into CSS by default. By adding the package path to your Tailwind `content` array, Tailwind will:
+
+1. Scan all JavaScript files in the `hazo_chat` package
+2. Extract all Tailwind utility classes used in the components
+3. Include them in your application's final CSS bundle
+4. Ensure the component styles are correctly applied at runtime
+
+**Important:** Without this configuration, Tailwind classes used by hazo_chat components will not be compiled, causing styling issues such as:
+- Missing styles (components appear unstyled)
+- Broken layouts
+- Incorrect spacing and colors
+- Non-functional responsive breakpoints
+
+**Troubleshooting:**
+
+If you're experiencing styling issues after adding the configuration:
+1. Restart your development server
+2. Clear your Next.js cache: `rm -rf .next`
+3. Verify the path matches your `node_modules` location
+4. Check that `tailwindcss` is installed: `npm list tailwindcss`
 
 ### Required CSS Variables
 
@@ -344,6 +381,7 @@ hazo_chat requires these API endpoints:
 |----------|--------|-------------|
 | `/api/hazo_chat/messages` | GET | Fetch chat messages |
 | `/api/hazo_chat/messages` | POST | Send a new message |
+| `/api/hazo_chat/unread_count` | GET | Get unread message counts by reference_id (optional) |
 | `/api/hazo_auth/me` | GET | Get current authenticated user |
 | `/api/hazo_auth/profiles` | POST | Fetch user profiles by IDs |
 
@@ -372,6 +410,157 @@ export { GET, POST };
 
 If you need more control, implement the endpoints manually. See [SETUP_CHECKLIST.md](./SETUP_CHECKLIST.md) for detailed examples.
 
+## Library Functions
+
+hazo_chat provides server-side library functions that can be used in API routes, server components, or server actions.
+
+### hazo_chat_get_unread_count
+
+Get unread message counts grouped by reference_id for a receiver user.
+
+**Purpose:** Returns an array of reference IDs with the count of unread messages (where `read_at` is `null`) for a given receiver user ID. Useful for displaying unread message badges or notifications.
+
+**Usage:**
+
+```typescript
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+// Create the function using the factory
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+// Use the function
+const unreadCounts = await hazo_chat_get_unread_count('receiver-user-id-123');
+// Returns: [
+//   { reference_id: 'ref-1', count: 5 },
+//   { reference_id: 'ref-2', count: 3 },
+//   { reference_id: '', count: 1 }  // Empty reference_id for general messages
+// ]
+```
+
+**Return Type:**
+
+```typescript
+interface UnreadCountResult {
+  reference_id: string;  // The reference ID (empty string for messages without reference)
+  count: number;         // Number of unread messages for this reference
+}
+```
+
+**Function Behavior:**
+- Only counts messages where `read_at` is `null` and `deleted_at` is `null`
+- Groups results by `reference_id`
+- Sorts results by count (descending - most unread first)
+- Returns empty array if no unread messages found
+- Returns empty array on errors (doesn't throw)
+
+**Example: API Route Implementation**
+
+```typescript
+// app/api/hazo_chat/unread_count/route.ts
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+import { NextRequest, NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const receiver_user_id = searchParams.get('receiver_user_id');
+
+    if (!receiver_user_id) {
+      return NextResponse.json(
+        { 
+          success: false, 
+          error: 'receiver_user_id is required',
+          unread_counts: []
+        },
+        { status: 400 }
+      );
+    }
+
+    const unread_counts = await hazo_chat_get_unread_count(receiver_user_id);
+
+    return NextResponse.json({
+      success: true,
+      receiver_user_id,
+      unread_counts,
+      total_references: unread_counts.length,
+      total_unread: unread_counts.reduce((sum, item) => sum + item.count, 0)
+    });
+  } catch (error) {
+    const error_message = error instanceof Error ? error.message : 'Unknown error';
+    return NextResponse.json(
+      { 
+        success: false, 
+        error: error_message,
+        unread_counts: []
+      },
+      { status: 500 }
+    );
+  }
+}
+```
+
+**Example: Server Component Usage**
+
+```typescript
+// app/chat/unread-badge.tsx
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export default async function UnreadBadge({ 
+  receiver_user_id 
+}: { 
+  receiver_user_id: string 
+}) {
+  const unread_counts = await hazo_chat_get_unread_count(receiver_user_id);
+  const total_unread = unread_counts.reduce((sum, item) => sum + item.count, 0);
+
+  if (total_unread === 0) return null;
+
+  return (
+    <div className="flex gap-2">
+      {unread_counts.map((item) => (
+        <div key={item.reference_id || 'general'}>
+          <span>{item.reference_id || 'General'}: {item.count}</span>
+        </div>
+      ))}
+      <span>Total: {total_unread}</span>
+    </div>
+  );
+}
+```
+
+**Example: Server Action Usage**
+
+```typescript
+// app/actions/chat.ts
+'use server';
+
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export async function getUnreadCounts(receiver_user_id: string) {
+  return await hazo_chat_get_unread_count(receiver_user_id);
+}
+```
+
 ## Props Reference
 
 ### HazoChatProps
@@ -390,6 +579,9 @@ If you need more control, implement the endpoints manually. See [SETUP_CHECKLIST
 | `title` | `string` | ❌ | - | Chat header title |
 | `subtitle` | `string` | ❌ | - | Chat header subtitle |
 | `on_close` | `() => void` | ❌ | - | Close button callback |
+| `show_sidebar_toggle` | `boolean` | ❌ | `false` | Show sidebar toggle button (hamburger menu) |
+| `show_delete_button` | `boolean` | ❌ | `true` | Show delete button on chat bubbles |
+| `bubble_radius` | `'default' \| 'full'` | ❌ | `'default'` | Bubble border radius style: `'default'` (rounded with tail) or `'full'` (fully round) |
 | `className` | `string` | ❌ | - | Additional CSS classes |
 
 ### Example with All Props
@@ -413,6 +605,186 @@ If you need more control, implement the endpoints manually. See [SETUP_CHECKLIST
 />
 ```
 
+## Customization
+
+hazo_chat provides props to customize component appearance and behavior without needing CSS overrides. This eliminates the need for extensive CSS customizations in consuming projects.
+
+### Common Customizations
+
+#### Hide Sidebar Toggle Button (Hamburger Menu)
+
+By default, the sidebar toggle button is hidden (`show_sidebar_toggle={false}`). To show it:
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  show_sidebar_toggle={true}  // Show hamburger menu button
+/>
+```
+
+#### Hide Delete Button on Chat Bubbles
+
+To hide the delete button on chat bubbles:
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  show_delete_button={false}  // Hide delete button
+/>
+```
+
+#### Make Chat Bubbles Fully Round
+
+To make all chat bubbles fully round (instead of the default style with a tail):
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  bubble_radius="full"  // Fully round all corners
+/>
+```
+
+### Customization Props Summary
+
+| Prop | Default | Options | Description |
+|------|--------|---------|------------|
+| `show_sidebar_toggle` | `false` | `boolean` | Show/hide the hamburger menu button |
+| `show_delete_button` | `true` | `boolean` | Show/hide delete button on chat bubbles |
+| `bubble_radius` | `'default'` | `'default' \| 'full'` | Bubble border radius style |
+
+### Example: Full Customization
+
+```tsx
+<HazoChat
+  receiver_user_id="user-123"
+  reference_id="project-456"
+  show_sidebar_toggle={false}    // Hide hamburger menu
+  show_delete_button={false}     // Hide delete buttons
+  bubble_radius="full"            // Fully round bubbles
+  title="Project Chat"
+  className="h-[600px]"
+/>
+```
+
+### Why Use Props Instead of CSS?
+
+Using props instead of CSS overrides provides:
+- **Type safety**: TypeScript will catch invalid values
+- **Consistency**: Ensures all instances use the same styling
+- **Maintainability**: Easier to update across the codebase
+- **No CSS conflicts**: Avoids specificity issues with Tailwind utilities
+
+If you need more advanced styling that isn't covered by props, you can still use CSS overrides, but props should cover most common customization needs.
+
+## Checking for Messages
+
+If you need to check whether messages exist for a given reference (without loading all messages), you can call the messages API endpoint directly. This is useful for showing indicators or badges.
+
+**Important:** The API requires `receiver_user_id` as a query parameter and returns an object response, not a direct array.
+
+### Correct API Usage Pattern
+
+```typescript
+// ✅ CORRECT: Include receiver_user_id and handle object response
+async function checkMessagesExist(
+  recipient_user_id: string,
+  reference_id: string,
+  reference_type?: string
+): Promise<boolean> {
+  const params = new URLSearchParams({
+    receiver_user_id: recipient_user_id,  // ✅ Required parameter
+    reference_id,
+    ...(reference_type && { reference_type }),
+  });
+
+  const response = await fetch(`/api/hazo_chat/messages?${params.toString()}`, {
+    credentials: 'include'
+  });
+
+  if (!response.ok) {
+    return false;
+  }
+
+  const data = await response.json();
+  
+  // ✅ Handle object response format: { success: true, messages: [], current_user_id }
+  const messages = data.messages || data;  // Handle both object and array responses
+  const has_messages_result = Array.isArray(messages) && messages.length > 0;
+  
+  return has_messages_result;
+}
+```
+
+### Common Mistakes to Avoid
+
+```typescript
+// ❌ WRONG: Missing receiver_user_id parameter
+const params = new URLSearchParams({
+  reference_id,
+  ...(reference_type && { reference_type }),
+});
+// This will return a 400 error: "receiver_user_id is required"
+
+// ❌ WRONG: Expecting direct array response
+const data = await response.json();
+const has_messages_result = Array.isArray(data) && data.length > 0;
+// This fails because API returns: { success: true, messages: [], current_user_id }
+```
+
+### Example: Custom Hook Implementation
+
+```typescript
+'use client';
+
+import { useState, useEffect } from 'react';
+
+function useChatMessagesCheck(
+  recipient_user_id: string,
+  reference_id: string,
+  reference_type?: string
+) {
+  const [has_messages, set_has_messages] = useState(false);
+  const [is_checking, set_is_checking] = useState(true);
+
+  useEffect(() => {
+    async function check() {
+      if (!recipient_user_id || !reference_id) {
+        set_is_checking(false);
+        return;
+      }
+
+      try {
+        const params = new URLSearchParams({
+          receiver_user_id: recipient_user_id,  // ✅ Required
+          reference_id,
+          ...(reference_type && { reference_type }),
+        });
+
+        const response = await fetch(
+          `/api/hazo_chat/messages?${params.toString()}`,
+          { credentials: 'include' }
+        );
+
+        if (response.ok) {
+          const data = await response.json();
+          const messages = data.messages || data;  // ✅ Handle object response
+          set_has_messages(Array.isArray(messages) && messages.length > 0);
+        }
+      } catch (error) {
+        console.error('[useChatMessagesCheck] Error:', error);
+        set_has_messages(false);
+      } finally {
+        set_is_checking(false);
+      }
+    }
+
+    check();
+  }, [recipient_user_id, reference_id, reference_type]);
+
+  return { has_messages, is_checking };
+}
+```
+
 ## Hooks
 
 ### useChatMessages
@@ -707,7 +1079,7 @@ npm run build:test-app
 import { HazoChat, useChatMessages, useChatReferences, useFileUpload } from 'hazo_chat';
 
 // API handlers (for server-side routes)
-import { createMessagesHandler } from 'hazo_chat/api';
+import { createMessagesHandler, createUnreadCountFunction } from 'hazo_chat/api';
 
 // Components only
 import { HazoChat, ChatBubble } from 'hazo_chat/components';

package/SETUP_CHECKLIST.md

@@ -233,11 +233,101 @@ export async function POST(request: NextRequest) {
 }
 ```
 
+### Step 4.4: Unread Count API (Optional - For Unread Badges)
+
+**File: `src/app/api/hazo_chat/unread_count/route.ts`**
+
+This endpoint is optional but useful for displaying unread message counts or badges in your UI.
+
+```typescript
+/**
+ * API route to get unread message counts grouped by reference_id
+ * Uses the exportable library function from hazo_chat
+ */
+
+export const dynamic = 'force-dynamic';
+
+import { createUnreadCountFunction } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+import { NextRequest, NextResponse } from 'next/server';
+
+// Create the unread count function using the factory
+const hazo_chat_get_unread_count = createUnreadCountFunction({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const receiver_user_id = searchParams.get('receiver_user_id');
+
+    if (!receiver_user_id) {
+      return NextResponse.json(
+        { 
+          success: false, 
+          error: 'receiver_user_id is required',
+          unread_counts: []
+        },
+        { status: 400 }
+      );
+    }
+
+    // Call the library function
+    const unread_counts = await hazo_chat_get_unread_count(receiver_user_id);
+
+    return NextResponse.json({
+      success: true,
+      receiver_user_id,
+      unread_counts,
+      total_references: unread_counts.length,
+      total_unread: unread_counts.reduce((sum, item) => sum + item.count, 0)
+    });
+  } catch (error) {
+    const error_message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('[hazo_chat/unread_count] Error:', error_message, error);
+    
+    return NextResponse.json(
+      { 
+        success: false, 
+        error: error_message,
+        unread_counts: []
+      },
+      { status: 500 }
+    );
+  }
+}
+```
+
+**What this endpoint does:**
+- Takes `receiver_user_id` as a query parameter
+- Returns an array of objects with `reference_id` and `count` of unread messages
+- Only counts messages where `read_at` is `null` and `deleted_at` is `null`
+- Groups results by `reference_id`
+- Sorts by count (descending - most unread first)
+
+**Response format:**
+```json
+{
+  "success": true,
+  "receiver_user_id": "user-123",
+  "unread_counts": [
+    { "reference_id": "ref-1", "count": 5 },
+    { "reference_id": "ref-2", "count": 3 },
+    { "reference_id": "", "count": 1 }
+  ],
+  "total_references": 3,
+  "total_unread": 9
+}
+```
+
+**Note:** This endpoint is optional. Only create it if you need to display unread message counts in your UI.
+
 ### API Routes Summary
 
 | Endpoint | Method | File | Purpose |
 |----------|--------|------|---------|
 | `/api/hazo_chat/messages` | GET, POST | `api/hazo_chat/messages/route.ts` | Message CRUD |
+| `/api/hazo_chat/unread_count` | GET | `api/hazo_chat/unread_count/route.ts` | Get unread counts (optional) |
 | `/api/hazo_auth/me` | GET | `api/hazo_auth/me/route.ts` | Get current user |
 | `/api/hazo_auth/profiles` | POST | `api/hazo_auth/profiles/route.ts` | Get user profiles |
 
@@ -246,6 +336,7 @@ export async function POST(request: NextRequest) {
 - [ ] `GET /api/hazo_auth/me` returns user data when logged in
 - [ ] `POST /api/hazo_auth/profiles` returns profiles for given IDs
 - [ ] `GET /api/hazo_chat/messages?receiver_user_id=xxx` works
+- [ ] `GET /api/hazo_chat/unread_count?receiver_user_id=xxx` returns unread counts (if implemented)
 
 ---
 
@@ -735,6 +826,9 @@ curl -X POST http://localhost:3000/api/hazo_auth/profiles \
 
 # Test messages endpoint
 curl "http://localhost:3000/api/hazo_chat/messages?receiver_user_id=user-id"
+
+# Test unread count endpoint (if implemented)
+curl "http://localhost:3000/api/hazo_chat/unread_count?receiver_user_id=user-id"
 ```
 
 ### UI Verification & Responsive Behavior
@@ -912,6 +1006,7 @@ npm install hazo_chat hazo_connect
 
 # 2. Create API routes
 mkdir -p src/app/api/hazo_chat/messages
+mkdir -p src/app/api/hazo_chat/unread_count  # Optional: for unread counts
 mkdir -p src/app/api/hazo_auth/me
 mkdir -p src/app/api/hazo_auth/profiles
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_chat",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "Chat interface for 1-1 communication with API-first architecture",
   "type": "module",
   "main": "./dist/index.js",
@@ -64,6 +64,7 @@
   "homepage": "https://github.com/pub12/hazo_chat#readme",
   "dependencies": {
     "@radix-ui/react-avatar": "^1.1.0",
+    "@radix-ui/react-hover-card": "^1.1.15",
     "@radix-ui/react-scroll-area": "^1.1.0",
     "@radix-ui/react-separator": "^1.1.0",
     "@radix-ui/react-slot": "^1.1.0",
@@ -90,7 +91,8 @@
     "hazo_connect": "^2.3.1",
     "next": ">=14.0.0",
     "react": "^18.0.0",
-    "react-dom": "^18.0.0"
+    "react-dom": "^18.0.0",
+    "tailwindcss": ">=3.0.0"
   },
   "peerDependenciesMeta": {
     "hazo_connect": {

package/dist/api/index.d.ts

@@ -1,24 +0,0 @@
-/**
- * hazo_chat API Module
- *
- * Provides exportable API route handlers for Next.js applications.
- * These handlers can be imported and re-exported in your API routes.
- *
- * @example
- * ```typescript
- * // app/api/hazo_chat/messages/route.ts
- * import { createMessagesHandler } from 'hazo_chat/api';
- * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
- *
- * export const dynamic = 'force-dynamic';
- *
- * const { GET, POST } = createMessagesHandler({
- *   getHazoConnect: () => getHazoConnectSingleton()
- * });
- *
- * export { GET, POST };
- * ```
- */
-export { createMessagesHandler } from './messages.js';
-export type { MessagesHandlerOptions, ChatMessageInput, ChatMessageRecord } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAGtD,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,YAAY,CAAC"}

package/dist/api/index.js

@@ -1,24 +0,0 @@
-/**
- * hazo_chat API Module
- *
- * Provides exportable API route handlers for Next.js applications.
- * These handlers can be imported and re-exported in your API routes.
- *
- * @example
- * ```typescript
- * // app/api/hazo_chat/messages/route.ts
- * import { createMessagesHandler } from 'hazo_chat/api';
- * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
- *
- * export const dynamic = 'force-dynamic';
- *
- * const { GET, POST } = createMessagesHandler({
- *   getHazoConnect: () => getHazoConnectSingleton()
- * });
- *
- * export { GET, POST };
- * ```
- */
-// Export handler factories
-export { createMessagesHandler } from './messages.js';
-//# sourceMappingURL=index.js.map

package/dist/api/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,2BAA2B;AAC3B,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC"}

package/dist/api/messages.d.ts

@@ -1,34 +0,0 @@
-/**
- * Messages API Handler Factory
- *
- * Creates GET and POST handlers for the /api/hazo_chat/messages endpoint.
- * These handlers should be used in a Next.js API route.
- *
- * @example
- * ```typescript
- * // app/api/hazo_chat/messages/route.ts
- * import { createMessagesHandler } from 'hazo_chat/api';
- * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
- *
- * export const dynamic = 'force-dynamic';
- *
- * const { GET, POST } = createMessagesHandler({
- *   getHazoConnect: () => getHazoConnectSingleton()
- * });
- *
- * export { GET, POST };
- * ```
- */
-import { NextRequest, NextResponse } from 'next/server';
-import type { MessagesHandlerOptions } from './types.js';
-/**
- * Creates GET and POST handlers for chat messages
- *
- * @param options - Configuration options
- * @returns Object with GET and POST handlers
- */
-export declare function createMessagesHandler(options: MessagesHandlerOptions): {
-    GET: (request: NextRequest) => Promise<NextResponse>;
-    POST: (request: NextRequest) => Promise<NextResponse>;
-};
-//# sourceMappingURL=messages.d.ts.map

package/dist/api/messages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/api/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,OAAO,KAAK,EAAE,sBAAsB,EAAuC,MAAM,YAAY,CAAC;AAmB9F;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB;mBAWvC,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;oBA+FlC,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;EA0GjE"}