saltfish 0.1.0

package/LICENSE

@@ -0,0 +1,34 @@
+SALTFISH PROPRIETARY LICENSE
+
+Copyright (c) 2025 Saltfish. All rights reserved.
+
+NOTICE: This software and associated documentation files (the "Software") are 
+proprietary and confidential information of Saltfish. 
+
+RESTRICTIONS:
+1. The Software is licensed, not sold, to authorized customers only.
+2. Unauthorized copying, distribution, modification, public display, or use is 
+   strictly prohibited.
+3. Commercial use is permitted only by authorized licensees with valid commercial 
+   licenses from Saltfish.
+4. Reverse engineering, decompilation, or disassembly is prohibited.
+5. The Software may not be redistributed or sublicensed without explicit written 
+   permission from Saltfish.
+
+PERMITTED USE:
+- Licensed customers may use the Software solely for their internal business 
+  purposes as specified in their commercial agreement with Saltfish.
+- Evaluation use is permitted for up to 30 days for potential customers.
+
+WARRANTY DISCLAIMER:
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+SALTFISH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For licensing inquiries, contact: licensing@saltfish.ai
+
+This license is effective as of the date of first use and remains in effect 
+until terminated by Saltfish or upon breach of these terms. 

package/README.md

@@ -0,0 +1,633 @@
+# Saltfish Player
+
+## Overview
+
+Saltfish Player is an interactive, video-guided tour system designed to provide engaging walkthroughs and feature introductions within web applications. It utilizes a core player component that manages video playback, user interactions, state, and transitions between steps defined in a playlist manifest. The player is designed to be embedded via a script tag and controlled through a simple JavaScript API.
+
+## Features
+
+* **playlist-Based Guidance:** Delivers interactive tours defined by JSON manifests, outlining steps, videos, and transitions
+* **Video Playback:** Manages loading, playing, pausing, and seeking videos for each step
+* **Interactive Elements:** Supports overlay buttons and interactions with existing DOM elements to guide users
+* **State Management:** Uses Zustand for managing player state (playing, paused, minimized, etc.) and playlist progress
+* **Shadow DOM Encapsulation:** Renders the player UI within a Shadow DOM to prevent style conflicts with the host application
+* **Drag & Minimize:** Allows users to reposition the player via dragging (if enabled) and minimize it
+* **Analytics:** Includes an `AnalyticsManager` for tracking events like playlist start/complete, step views, interactions, and errors.
+* **Transitions:** Manages transitions between steps based on timeouts, DOM clicks, URL path changes, or other interactions
+
+## Technology Stack
+
+* **Language:** TypeScript
+* **Bundler:** Vite
+* **State Management:** Zustand
+* **Testing:**
+    * Unit/Integration: Jest
+    * E2E: Playwright
+* **Build:** Node.js script (`scripts/build.js`)
+
+## Project Structure
+
+```
+.
+├── e2e/              # End-to-end tests 
+├── scripts/          # Build scripts 
+├── src/
+│   ├── core/         # Core player logic and state management 
+│   ├── managers/     # Manages specific functionalities (Video, UI, State, etc.) 
+│   ├── styles/       # CSS styles
+│   ├── tests/        # Unit and integration tests 
+│   ├── types/        # TypeScript type definitions 
+│   ├── utils/        # Utility functions (logger, mocks) 
+│   └── index.ts      # Main entry point, exposes public API 
+├── .gitignore
+├── index.html        # Development environment HTML 
+├── jest.config.js    # Jest configuration 
+├── package.json      # Project dependencies and scripts 
+├── playwright.config.ts # Playwright configuration 
+├── tsconfig.json     # TypeScript configuration 
+├── vite.config.ts    # Vite configuration for main build 
+└── vite.test.config.ts # Vite configuration for test server
+```
+
+## Core Components
+
+* **`SaltfishPlayer` (`src/core/SaltfishPlayer.ts`)**: The main orchestrator class. Initializes managers, handles state changes, and manages the player lifecycle.
+* **`saltfishStore` (`src/core/store.ts`)**: Zustand-based store for managing global player state.
+* **`ShadowDOMManager` (`src/managers/ShadowDOMManager.ts`)**: Creates and manages the Shadow DOM container for UI encapsulation.
+* **`VideoManager` (`src/managers/VideoManager.ts`)**: Handles video loading, playback control (play, pause, seek), progress tracking, and completion policies.
+* **`TransitionManager` (`src/managers/TransitionManager.ts`)**: Manages the logic for transitioning between steps based on defined conditions (e.g., DOM clicks, timeouts).
+* **`InteractionManager` (`src/managers/InteractionManager.ts`)**: Handles the creation and events for interactive overlay buttons and DOM interaction listeners defined in steps.
+* **`CursorManager` (`src/managers/CursorManager.ts`)**: Manages the display and animation of a virtual cursor to guide the user.
+* **`ButtonManager` (`src/managers/ButtonManager.ts`)**: Manages the visibility and state of core player controls like play/pause buttons.
+* **`PlaylistManager` (`src/managers/PlaylistManager.ts`)**: Handles playlist-related functionality including tracking playlist progress, updating watched status, and managing playlist state in the backend.
+* **`AnalyticsManager` (`src/managers/AnalyticsManager.ts`)**: Handles queueing and sending analytics events.
+
+## Getting Started
+
+### Prerequisites
+
+* Node.js and npm
+
+### Setup
+
+1.  Clone the repository.
+2.  Install dependencies:
+    ```bash
+    npm install
+    ```
+
+### Build
+
+To create a production build (outputs to `dist/` directory):
+```bash
+npm run build
+```
+This script cleans the dist folder, compiles TypeScript, bundles with Vite, and generates CDN-ready player.js and player.min.js files.   
+
+### Development
+
+#### Main Dev Server
+Runs Vite dev server for index.html.
+
+```bash
+npm run dev
+```
+Access at http://localhost:3000.
+
+#### Test Dev Server
+Runs Vite dev server specifically for the E2E test environment (e2e/test.html).
+
+```bash
+npm run dev:test
+```
+Access at http://localhost:3010.
+
+## Usage (API)
+
+The Saltfish Player is exposed via the global `saltfish` object.
+
+## Installation
+
+### Option 1: npm Package (Recommended)
+
+Install the package using npm:
+
+```bash
+npm install saltfish-playlist-player
+```
+
+Then import and use in your application:
+
+```javascript
+// ES modules
+import saltfish from 'saltfish-playlist-player';
+
+// CommonJS
+const saltfish = require('saltfish-playlist-player');
+
+// Initialize and use
+saltfish.init('YOUR_API_TOKEN');
+saltfish.startPlaylist('your_playlist_id');
+```
+
+### Option 2: CDN/Script Tag
+
+Add the built player.js script to your HTML:
+
+```html
+<!-- Production version (minified) -->
+<script src="https://unpkg.com/saltfish-playlist-player@latest/dist/player.min.js"></script>
+
+<!-- Or development version -->
+<script src="https://unpkg.com/saltfish-playlist-player@latest/dist/player.js"></script>
+
+<!-- Or from your own hosting -->
+<script src="/path/to/dist/player.js"></script>
+```
+
+### Include the script
+Add the built player.js script to your HTML.
+
+```html
+<script src="/path/to/dist/player.js"></script>
+```
+
+### Simplified API (No Await Required)
+
+The Saltfish API now features an improved design that eliminates the need to use `await` keywords with its asynchronous methods. The API internally manages the sequencing of operations, making your code cleaner and more straightforward.
+
+#### Key Benefits:
+- Call methods directly in sequence without `await`
+- No need for async functions or promise chains
+- Methods still return promises for backward compatibility
+- Built-in command queueing handles proper execution order
+- Error handling is maintained
+
+### Initialize
+
+```javascript
+// Basic initialization with token - no await needed!
+saltfish.init('YOUR_API_TOKEN');
+
+// Or with configuration object
+saltfish.init({
+  token: 'YOUR_API_TOKEN',
+  persistence: true,
+  sessionRecording: false,
+  enableAnalytics: true // Default: true, set to false to disable analytics in development
+});
+
+// Disable analytics for development/testing environments
+saltfish.init({
+  token: 'YOUR_API_TOKEN',
+  enableAnalytics: false // No analytics events will be sent
+});
+```
+
+#### Configuration Options
+
+- **`token`** (string, required): Your Saltfish API token for authentication
+- **`persistence`** (boolean, optional): Whether to persist user progress between sessions (default: `false`)
+- **`sessionRecording`** (boolean, optional): Whether to enable session recording for analytics (default: `false`). When enabled, records one continuous session using sessionId and userId only, independent of playlist runs.
+- **`enableAnalytics`** (boolean, optional): Whether to collect and send analytics data (default: `true`). Set to `false` in development environments to avoid noisy data
+
+### Identify User (Optional)
+
+```javascript
+saltfish.identify('user-123', { email: 'user@example.com', name: 'Test User' });
+```
+
+### Start a playlist
+
+```javascript
+// No need to use await - call startPlaylist directly after init
+saltfish.init('YOUR_API_TOKEN');
+saltfish.startPlaylist('your_playlist_id');
+
+// Or use events to know when initialization is complete
+saltfish.on('initialized', () => {
+  console.log('Saltfish player is ready');
+  saltfish.startPlaylist('your_playlist_id');
+});
+saltfish.init('YOUR_API_TOKEN');
+
+// For those who prefer async/await, this still works too
+async function startPlayer() {
+  await saltfish.init('YOUR_API_TOKEN');
+  await saltfish.startPlaylist('your_playlist_id');
+}
+```
+
+The player will attempt to fetch the manifest for your_playlist_id from /api/manifests/your_playlist_id. If it fails or if window.demoManifest is set, it will use a mock manifest.
+
+#### Playlist Options
+
+The `startPlaylist` method accepts an optional second parameter for configuration:
+
+```javascript
+saltfish.startPlaylist('your_playlist_id', {
+  position: 'top-left',      // Player position: 'top-left', 'top-right', 'bottom-left', 'bottom-right', 'center'
+  allowDrag: false,          // Whether the player can be dragged (default: true)
+  startNodeId: 'step_2',     // Start from a specific step instead of the default
+  once: true                 // Only play if user hasn't watched this playlist before
+});
+```
+
+##### Once Option
+
+The `once: true` option ensures a playlist only plays if the user hasn't completed it before. This is useful for onboarding flows or important announcements that should only be shown once:
+
+```javascript
+// User identification is required when using the once option
+saltfish.identify('user-123', { email: 'user@example.com' });
+
+// This will only play if the user hasn't completed 'onboarding_tutorial' before
+saltfish.startPlaylist('onboarding_tutorial', { once: true });
+```
+
+**Requirements for `once` option:**
+- User must be identified using `saltfish.identify()` before starting the playlist
+- User data (including watch history) must be loaded from the backend
+- The playlist will be blocked if the user has already completed it
+
+**Behavior:**
+- ✅ First time: Playlist plays normally
+- ❌ Subsequent times: Playlist is blocked and an error is thrown
+- 🔄 Without `once` option: Playlist always plays regardless of watch history
+
+### How It Works
+
+The Saltfish API implements a command queuing system that:
+
+1. Tracks the initialization state of the player
+2. Automatically queues commands called before initialization completes
+3. Processes the queue in the correct order after initialization
+4. Handles errors appropriately
+
+This means you can call methods like `init()` and `startPlaylist()` in sequence without worrying about their asynchronous nature. The API handles the complexity for you.
+
+### Event Subscription
+
+As an alternative to promises, you can use the event system to respond to player state changes:
+
+```javascript
+// Subscribe to initialization completion
+saltfish.on('initialized', () => {
+  console.log('Player initialized');
+  saltfish.startPlaylist('your_playlist_id');
+});
+
+// Subscribe to other events
+const playlistEndedListener = event => {
+  console.log(`Playlist ${event.playlist.id} ended at ${new Date(event.timestamp)}`);
+  // Perform actions when playlist ends
+};
+saltfish.on('playlistEnded', playlistEndedListener);
+
+// Unsubscribe when no longer needed
+saltfish.off('playlistEnded', playlistEndedListener);
+```
+
+See [Event Documentation](./docs/events.md) for a complete list of events and payload structures.
+
+### Destroy
+
+```javascript
+saltfish.destroy();
+```
+
+## Manifest Example
+
+A manifest is a JSON object that defines the structure and content of a playlist. It specifies the steps, videos, interactive elements (buttons, DOM interactions, cursor animations), and transitions between steps.
+
+Here's an example from the mock data used in the project (src/utils/mockManifest.ts):   
+
+```json
+{
+  "id": "realistic_mock_playlist",
+  "name": "Feature Walkthrough Tour",
+  "version": "1.0.0",
+  "position": "bottom-right",
+  "startStep": "intro",
+  "steps": [
+    {
+      "id": "intro",
+      "videoUrl": "https://storage.saltfish.ai/videos/QSWY4Wc8pcBVYHNQM12P.mp4",
+      "transitions": [
+        {
+          "type": "timeout",
+          "timeout": 30000,
+          "nextStep": "dashboard_overview"
+        }
+      ]
+    },
+    {
+      "id": "dashboard_overview",
+      "videoUrl": "https://storage.saltfish.ai/videos/rEWoNbKLAUQSvLmzHGmv.mp4",
+      "cursorAnimations": [
+        {
+          "duration": 3000,
+          "easing": "ease-out",
+          "targetSelector": ".container > div:nth-of-type(1)"
+        }
+      ],
+      "domInteractions": [
+        {
+          "selector": "#feature-chart",
+          "action": "hover",
+          "waitFor": false
+        }
+      ],
+      "buttons": [
+        {
+          "id": "skip_button",
+          "text": "Skip",
+          "position": { "x": 50, "y": 140 },
+          "size": { "width": 70, "height": 30 },
+          "action": { "type": "goto", "target": "user_settings" }
+        }
+      ],
+      "transitions": [
+        {
+          "type": "timeout",
+          "timeout": 18000,
+          "nextStep": "user_settings"
+        }
+      ]
+    },
+    {
+      "id": "user_settings",
+      "videoUrl": "https://storage.saltfish.ai/codeformer/oNcN4ZoQXFFnMmaOwEC3/result.mp4",
+      "buttons": [
+        {
+          "id": "finish_button",
+          "text": "Finish Tour",
+          "position": { "x": 220, "y": 140 },
+          "size": { "width": 120, "height": 40 },
+          "action": { "type": "goto", "target": "conclusion" }
+        }
+      ],
+      "transitions": [
+        {
+          "type": "dom-click",
+          "target": ".container > div:nth-of-type(1)", 
+          "nextStep": "conclusion"
+        },
+        {
+          "type": "url-path",
+          "target": "/settings/profile",
+          "nextStep": "profile_settings"
+        }
+      ]
+    },
+    {
+      "id": "profile_settings",
+      "videoUrl": "https://storage.saltfish.ai/videos/profile_settings_demo.mp4",
+      "transitions": [
+        {
+          "type": "timeout",
+          "timeout": 15000,
+          "nextStep": "conclusion"
+        }
+      ]
+    },
+    {
+      "id": "conclusion",
+      "videoUrl": "https://storage.saltfish.ai/memo/5z5IDHYzuGDjx41hpvSo/result.mp4",
+      "buttons": [
+        {
+          "id": "close_button",
+          "text": "Close Tour",
+          "position": { "x": 220, "y": 140 },
+          "size": { "width": 120, "height": 40 },
+          "action": { "type": "next", "target": "" }
+        }
+      ],
+      "transitions": []
+    }
+  ]
+}
+```
+
+## Testing
+
+The project includes unit, integration, and end-to-end tests.
+
+### Run all Jest tests (unit/integration)
+```bash
+npm test
+```
+
+### Run Jest tests in watch mode
+```bash
+npm run test:watch
+```
+
+### Run Jest tests with coverage
+```bash
+npm run test:coverage
+```
+
+### Run Playwright E2E tests
+Ensure the test dev server is not running separately.
+Install browser binaries if needed: `npx playwright install`
+```bash
+npm run test:e2e
+```
+
+### Run Playwright E2E tests in UI mode
+```bash
+npm run test:e2e:ui
+```
+
+See src/tests/README.md for more details on the testing strategy.
+
+## React Dashboard
+
+A React-based dashboard has been added to the project for easier testing and demonstration of the Saltfish playlist Player. The dashboard provides a user-friendly interface with multiple routes to trigger and manage different workplaylists.
+
+### Features
+
+- Multiple routes with React Router
+- Dashboard for overview statistics
+- Workplaylists page to trigger different interactive guides
+- Settings page to configure the Saltfish player
+- Integration with Saltfish playlist Player
+
+### Running the Dashboard
+
+1. Navigate to the app directory:
+   ```bash
+   cd app
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Start the development server:
+   ```bash
+   npm run dev
+   ```
+
+4. Open your browser and navigate to:
+   ```
+   http://localhost:3000
+   ```
+
+The dashboard will automatically load and integrate with the Saltfish playlist Player. You can use the interface to initialize the player, identify users, and trigger different workplaylists.
+
+### Transition Types
+
+The Saltfish player supports multiple types of transitions between steps:
+
+#### Timeout Transitions
+Automatic transitions after a specified duration.
+
+```json
+{
+  "type": "timeout",
+  "timeout": 5000, // milliseconds
+  "nextStep": "next_step_id"
+}
+```
+
+#### DOM Click Transitions
+Transitions triggered when the user clicks a specific element in the DOM.
+
+```json
+{
+  "type": "dom-click",
+  "target": ".some-element-selector",
+  "nextStep": "next_step_id"
+}
+```
+
+#### URL Path Transitions
+Transitions triggered when the URL path matches a specified pattern. This is useful for playlists that span multiple pages or routes in a single-page application.
+
+```json
+{
+  "type": "url-path",
+  "target": "/dashboard", // Will match when URL path is exactly "/dashboard"
+  "nextStep": "dashboard_step"
+}
+```
+
+```json
+{
+  "type": "url-path",
+  "target": "^/settings/.*", // Regex pattern matching any URL starting with "/settings/"
+  "nextStep": "settings_step"
+}
+```
+
+When a URL path transition is specified:
+1. The player monitors URL changes in the application
+2. When the URL changes to match the pattern, the player automatically transitions to the next step
+3. This allows seamless continuation of playlists across different pages or routes
+
+## Build Options
+
+The project supports two types of builds:
+
+### Production Build
+
+The production build removes all console.log statements to reduce the bundle size. This is the default build type.
+
+```bash
+npm run build
+# or
+npm run build:prod
+```
+
+### Test Build
+
+The test build preserves all console.log statements for easier debugging. This creates a slightly larger bundle but makes troubleshooting much easier.
+
+```bash
+npm run build:test
+```
+
+The test build will generate files with the `-test` suffix to distinguish them from production files.
+
+### Size Comparison
+
+- Production build: Optimized for performance and smaller file size
+- Test build: Includes debugging information and console logs
+
+## State Management
+
+The player implements a state machine to manage transitions between different states. The main states include:
+
+* **idle**: Initial state before the player is used
+* **loading**: Loading a playlist or video
+* **playing**: Video is actively playing
+* **paused**: Video is paused by user action
+* **waitingForInteraction**: Video has ended and waiting for user interaction or transition trigger
+* **autoplayBlocked**: Player requires user interaction for autoplay to continue
+* **minimized**: Player is minimized
+* **error**: An error has occurred
+* **completed**: Playlist has finished playing
+
+The `completed` state is triggered when the last video in a playlist finishes playing and there are no transitions defined, or when the `completePlaylist` method is called. This state signals that the player should be destroyed after showing a completion message.
+
+### State Transitions
+
+State transitions occur based on various events:
+- User actions (play, pause, minimize)
+- Video completion
+- Transitions based on URL changes, DOM interactions, or timeouts
+- Automatically when a step completes (via `VIDEO_ENDED` event)
+
+The player ensures transitions work smoothly by only setting up DOM and URL-based transitions after the video has ended, preventing premature transitions while the video is still playing.
+
+## Progress Bar and Video Playback
+
+The player features a sophisticated progress bar system that smoothly updates during video playback:
+
+* **Transition Handling**: The progress bar applies different CSS transitions based on the current video state (playing, paused, seeking, ended) to ensure smooth animations without jumps.
+
+* **Forced Reflow**: To prevent visual glitches, the player uses forced reflow techniques to ensure CSS changes are applied in the correct sequence.
+
+* **Play/Pause Optimization**: When playing or pausing, the progress bar updates immediately to prevent jumpy behavior, especially during rapid state changes.
+
+* **Seeking Support**: Special handlers for seeking events ensure the progress bar updates correctly during user-initiated seeking.
+
+* **End-of-Video Transition**: A smooth ease-out transition is applied when the video reaches the end, creating a professional finishing effect.
+
+These improvements ensure a highly polished user experience with fluid progress tracking during all phases of video playback.
+
+## Transitions Between Steps
+
+Transitions control how the player moves from one step to the next in a playlist. The player supports several types of transitions:
+
+* **timeout**: Automatically transitions after a specified time
+* **dom-click**: Transitions when a user clicks on a specified DOM element
+* **url-path**: Transitions when the URL path changes to match a specified pattern
+* **dom-element-visible**: Transitions when a specified DOM element becomes visible
+* **interaction**: Transitions based on user interactions with overlay buttons
+
+### Delayed Transition Setup
+
+To improve the user experience, DOM-based transitions (dom-click, url-path, dom-element-visible) are only set up after the video has finished playing. This prevents transitions from being triggered prematurely while the user is watching the video.
+
+The process works as follows:
+
+1. When a step begins, the video starts playing
+2. The player waits for the video to complete (`ended` event)
+3. After the video ends, transitions are set up based on the step's configuration
+4. The player enters the `waitingForInteraction` state if interaction-based transitions are present
+5. When a transition is triggered, the player moves to the next step
+
+This delayed setup ensures users can watch the entire instructional video before needing to interact with the interface or having URL-based transitions occur.
+
+### Handling Completion
+
+When a step has no transitions defined, or when the last step in a playlist is reached, the player automatically transitions to the `completed` state. This can happen in two ways:
+
+1. Auto-completion when no transitions are defined for a step
+2. Manual completion via the `completePlaylist` method
+
+The player then displays a completion message and is automatically destroyed after a short delay.

package/dist/components/buttons/ExitButton.d.ts

@@ -0,0 +1,9 @@
+export declare class ExitButton {
+    private button;
+    private playerElement;
+    constructor(playerElement: HTMLElement);
+    private handleClick;
+    updateVisibility(isMinimized: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=ExitButton.d.ts.map

package/dist/components/buttons/ExitButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExitButton.d.ts","sourceRoot":"","sources":["../../../src/components/buttons/ExitButton.ts"],"names":[],"mappings":"AAGA,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,aAAa,CAAc;gBAEvB,aAAa,EAAE,WAAW;IAYtC,OAAO,CAAC,WAAW;IAsBZ,gBAAgB,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI;IAS5C,OAAO,IAAI,IAAI;CAIvB"}

package/dist/components/buttons/MinimizeButton.d.ts

@@ -0,0 +1,11 @@
+export declare class MinimizeButton {
+    private button;
+    private playerElement;
+    constructor(playerElement: HTMLElement);
+    private handleClick;
+    minimize(): void;
+    maximize(): void;
+    updateVisibility(isMinimized: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=MinimizeButton.d.ts.map

package/dist/components/buttons/MinimizeButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinimizeButton.d.ts","sourceRoot":"","sources":["../../../src/components/buttons/MinimizeButton.ts"],"names":[],"mappings":"AAEA,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,aAAa,CAAc;gBAEvB,aAAa,EAAE,WAAW;IAYtC,OAAO,CAAC,WAAW;IAqBZ,QAAQ,IAAI,IAAI;IAIhB,QAAQ,IAAI,IAAI;IAIhB,gBAAgB,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI;IAS5C,OAAO,IAAI,IAAI;CAIvB"}