osense-vad 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Agent Voice Response
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 THE
+AUTHORS OR COPYRIGHT HOLDERS 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.

package/README.md

@@ -0,0 +1,403 @@
+# Agent Voice Response - AVR VAD - Silero Voice Activity Detection for Node.js 
+
+[![Discord](https://img.shields.io/discord/1347239846632226998?label=Discord&logo=discord)](https://discord.gg/DFTU69Hg74)
+[![GitHub Repo stars](https://img.shields.io/github/stars/agentvoiceresponse/avr-vad?style=social)](https://github.com/agentvoiceresponse/avr-vad)
+[![npm version](https://img.shields.io/npm/v/avr-vad.svg)](https://www.npmjs.com/package/avr-vad)
+[![npm downloads](https://img.shields.io/npm/dm/avr-vad.svg)](https://www.npmjs.com/package/avr-vad)
+[![Ko-fi](https://img.shields.io/badge/Support%20us%20on-Ko--fi-ff5e5b.svg)](https://ko-fi.com/agentvoiceresponse)
+
+🎤 A Node.js library for Voice Activity Detection using the Silero VAD model.
+
+## ✨ Features
+
+- 🚀 **Based on Silero VAD**: Uses the pre-trained Silero ONNX model (v5 and legacy versions) for accurate results
+- 🎯 **Real-time processing**: Supports real-time frame-by-frame processing
+- ⚡ **Non-real-time processing**: Batch processing for audio files and streams
+- 🔧 **Configurable**: Customizable thresholds and parameters for different needs
+- 🎵 **Audio processing**: Includes utilities for resampling and audio manipulation
+- 📊 **Multiple models**: Support for both Silero VAD v5 and legacy models
+- 💾 **Bundled models**: Models are included in the package, no external downloads required
+- 📝 **TypeScript**: Fully typed with TypeScript
+
+## 🚀 Installation
+
+```bash
+npm install avr-vad
+```
+
+## 📖 Quick Start
+
+### Real-time Processing
+
+```typescript
+import { RealTimeVAD } from 'avr-vad';
+
+// Initialize the VAD with default options (Silero v5 model)
+const vad = await RealTimeVAD.new({
+  model: 'v5', // or 'legacy'
+  positiveSpeechThreshold: 0.5,
+  negativeSpeechThreshold: 0.35,
+  preSpeechPadFrames: 1,
+  redemptionFrames: 8,
+  frameSamples: 1536,
+  minSpeechFrames: 3
+});
+
+// Process audio frames in real-time
+const audioFrame = getAudioFrameFromMicrophone(); // Float32Array of 1536 samples at 16kHz
+const result = await vad.processFrame(audioFrame);
+
+console.log(`Speech probability: ${result.probability}`);
+console.log(`Speech detected: ${result.msg === 'SPEECH_START' || result.msg === 'SPEECH_CONTINUE'}`);
+
+// Clean up when done
+vad.destroy();
+```
+
+### Non-Real-time Processing
+
+```typescript
+import { NonRealTimeVAD } from 'avr-vad';
+
+// Initialize for batch processing
+const vad = await NonRealTimeVAD.new({
+  model: 'v5',
+  positiveSpeechThreshold: 0.5,
+  negativeSpeechThreshold: 0.35
+});
+
+// Process entire audio buffer
+const audioData = loadAudioData(); // Float32Array at 16kHz
+const results = await vad.processAudio(audioData);
+
+// Get speech segments
+const speechSegments = vad.getSpeechSegments(results);
+console.log(`Found ${speechSegments.length} speech segments`);
+
+speechSegments.forEach((segment, i) => {
+  console.log(`Segment ${i + 1}: ${segment.start}ms - ${segment.end}ms`);
+});
+
+// Clean up
+vad.destroy();
+```
+
+## ⚙️ Configuration
+
+### Real-time VAD Options
+
+```typescript
+interface RealTimeVADOptions {
+  /** Model version to use ('v5' | 'legacy') */
+  model?: 'v5' | 'legacy';
+  
+  /** Threshold for detecting speech start */
+  positiveSpeechThreshold?: number;
+  
+  /** Threshold for detecting speech end */
+  negativeSpeechThreshold?: number;
+  
+  /** Frames to include before speech detection */
+  preSpeechPadFrames?: number;
+  
+  /** Frames to wait before ending speech */
+  redemptionFrames?: number;
+  
+  /** Number of samples per frame (usually 1536 for 16kHz) */
+  frameSamples?: number;
+  
+  /** Minimum frames for valid speech */
+  minSpeechFrames?: number;
+}
+```
+
+### Non-Real-time VAD Options
+
+```typescript
+interface NonRealTimeVADOptions {
+  /** Model version to use ('v5' | 'legacy') */
+  model?: 'v5' | 'legacy';
+  
+  /** Threshold for detecting speech start */
+  positiveSpeechThreshold?: number;
+  
+  /** Threshold for detecting speech end */
+  negativeSpeechThreshold?: number;
+}
+```
+
+### Default Values
+
+```typescript
+// Real-time VAD defaults
+const defaultRealTimeOptions = {
+  model: 'v5',
+  positiveSpeechThreshold: 0.5,
+  negativeSpeechThreshold: 0.35,
+  preSpeechPadFrames: 1,
+  redemptionFrames: 8,
+  frameSamples: 1536,
+  minSpeechFrames: 3
+};
+
+// Non-real-time VAD defaults
+const defaultNonRealTimeOptions = {
+  model: 'v5',
+  positiveSpeechThreshold: 0.5,
+  negativeSpeechThreshold: 0.35
+};
+```
+
+## 📊 Results and Messages
+
+### VAD Messages
+
+The VAD returns different message types to indicate speech state changes:
+
+```typescript
+enum Message {
+  ERROR = 'ERROR',
+  SPEECH_START = 'SPEECH_START',
+  SPEECH_CONTINUE = 'SPEECH_CONTINUE', 
+  SPEECH_END = 'SPEECH_END',
+  SILENCE = 'SILENCE'
+}
+```
+
+### Processing Results
+
+```typescript
+interface VADResult {
+  /** Speech probability (0.0 - 1.0) */
+  probability: number;
+  
+  /** Message indicating speech state */
+  msg: Message;
+  
+  /** Audio data if speech segment ended */
+  audio?: Float32Array;
+}
+```
+
+### Speech Segments
+
+```typescript
+interface SpeechSegment {
+  /** Start time in milliseconds */
+  start: number;
+  
+  /** End time in milliseconds */
+  end: number;
+  
+  /** Speech probability for this segment */
+  probability: number;
+}
+```
+
+## 🔧 Audio Utilities
+
+The library includes various audio processing utilities:
+
+```typescript
+import { utils, Resampler } from 'avr-vad';
+
+// Resample audio to 16kHz (required for VAD)
+const resampler = new Resampler({
+  nativeSampleRate: 44100,
+  targetSampleRate: 16000,
+  targetFrameSize: 1536
+});
+
+const resampledFrame = resampler.process(audioFrame);
+
+// Other utilities
+const frameSize = utils.frameSize; // Get frame size for current sample rate
+const audioBuffer = utils.concatArrays([frame1, frame2]); // Concatenate audio arrays
+```
+
+## 🎯 Advanced Examples
+
+### Real-time Speech Detection with Callbacks
+
+```typescript
+import { RealTimeVAD, Message } from 'avr-vad';
+
+class SpeechDetector {
+  private vad: RealTimeVAD;
+  private onSpeechStart?: (audio: Float32Array) => void;
+  private onSpeechEnd?: (audio: Float32Array) => void;
+
+  constructor(callbacks: {
+    onSpeechStart?: (audio: Float32Array) => void;
+    onSpeechEnd?: (audio: Float32Array) => void;
+  }) {
+    this.onSpeechStart = callbacks.onSpeechStart;
+    this.onSpeechEnd = callbacks.onSpeechEnd;
+  }
+
+  async initialize() {
+    this.vad = await RealTimeVAD.new({
+      positiveSpeechThreshold: 0.5,
+      negativeSpeechThreshold: 0.35
+      onSpeechStart: this.onSpeechStart,
+      onSpeechEnd: this.onSpeechEnd
+    });
+  }
+
+  async processFrame(audioFrame: Float32Array) {
+    const result = await this.vad.processFrame(audioFrame);
+    return result;
+  }
+
+  destroy() {
+    this.vad?.destroy();
+  }
+}
+
+// Usage
+const detector = new SpeechDetector({
+  onSpeechStart: (audio) => console.log(`Speech started with ${audio.length} samples`),
+  onSpeechEnd: (audio) => console.log(`Speech ended with ${audio.length} samples`)
+});
+
+await detector.initialize();
+```
+
+### Batch Processing Audio File
+
+```typescript
+import { NonRealTimeVAD, utils } from 'avr-vad';
+import * as fs from 'fs';
+
+async function processAudioFile(filePath: string) {
+  // Load audio data (you'll need your own audio loading logic)
+  const audioData = loadWavFile(filePath); // Float32Array at 16kHz
+  
+  const vad = await NonRealTimeVAD.new({
+    model: 'v5',
+    positiveSpeechThreshold: 0.6,
+    negativeSpeechThreshold: 0.4
+  });
+
+  const results = await vad.processAudio(audioData);
+  const segments = vad.getSpeechSegments(results);
+
+  console.log(`Processing ${filePath}:`);
+  console.log(`Total audio duration: ${(audioData.length / 16000).toFixed(2)}s`);
+  console.log(`Speech segments found: ${segments.length}`);
+  
+  segments.forEach((segment, i) => {
+    const duration = ((segment.end - segment.start) / 1000).toFixed(2);
+    console.log(`  Segment ${i + 1}: ${segment.start}ms - ${segment.end}ms (${duration}s)`);
+  });
+
+  vad.destroy();
+  return segments;
+}
+```
+
+## 📝 Development
+
+### Requirements
+
+- Node.js >= 16.0.0
+- TypeScript >= 5.0.0
+
+### Build
+
+```bash
+npm run build
+```
+
+### Test
+
+```bash
+npm test
+```
+
+### Scripts
+
+```bash
+npm run lint      # Run ESLint
+npm run clean     # Clean build directory
+npm run prepare   # Build before npm install (automatically run)
+```
+
+## 📁 Project Structure
+
+```
+avr-vad/
+├── src/
+│   ├── index.ts                    # Main exports
+│   ├── real-time-vad.ts           # Real-time VAD implementation  
+│   └── common/
+│       ├── index.ts               # Common exports
+│       ├── frame-processor.ts     # Core ONNX processing
+│       ├── non-real-time-vad.ts  # Batch processing VAD
+│       ├── utils.ts               # Utility functions
+│       ├── resampler.ts           # Audio resampling
+├── dist/                          # Compiled JavaScript
+├── test/                          # Test files
+├── silero_vad_v5.onnx            # Silero VAD v5 model
+├── silero_vad_legacy.onnx        # Silero VAD legacy model
+└── package.json
+```
+
+## 🔧 Troubleshooting
+
+### Audio Format Requirements
+
+The Silero VAD model requires:
+- **Sample rate**: 16kHz
+- **Channels**: Mono (single channel)
+- **Format**: Float32Array with values between -1.0 and 1.0
+- **Frame size**: 1536 samples (96ms at 16kHz)
+
+### Model Selection
+
+- **v5 model**: Latest version with improved accuracy
+- **legacy model**: Original model for compatibility
+
+Use the `Resampler` utility to convert audio to the required format:
+
+```typescript
+import { Resampler } from 'avr-vad';
+
+const resampler = new Resampler({
+  nativeSampleRate: 44100,    // Your audio sample rate
+  targetSampleRate: 16000,    // Required by VAD
+  targetFrameSize: 1536       // Required frame size
+});
+```
+
+### Performance Tips
+
+- Use appropriate thresholds for your use case
+- Consider using the legacy model for lower resource usage
+- For real-time applications, ensure your audio processing pipeline can handle 16kHz/1536 samples per frame
+- Use `redemptionFrames` to avoid choppy speech detection
+
+## Acknowledgments
+
+- [Silero Models](https://github.com/snakers4/silero-vad) for the excellent VAD model
+- [ONNX Runtime](https://onnxruntime.ai/) for model inference
+- The open source community for supporting libraries 
+
+## Support & Community
+
+*   **Website:** [https://agentvoiceresponse.com](https://agentvoiceresponse.com) - Official website.
+*   **GitHub:** [https://github.com/agentvoiceresponse](https://github.com/agentvoiceresponse) - Report issues, contribute code.
+*   **Discord:** [https://discord.gg/DFTU69Hg74](https://discord.gg/DFTU69Hg74) - Join the community discussion.
+*   **Docker Hub:** [https://hub.docker.com/u/agentvoiceresponse](https://hub.docker.com/u/agentvoiceresponse) - Find Docker images.
+*   **NPM:** [https://www.npmjs.com/~agentvoiceresponse](https://www.npmjs.com/~agentvoiceresponse) - Browse our packages.
+*   **Wiki:** [https://wiki.agentvoiceresponse.com/en/home](https://wiki.agentvoiceresponse.com/en/home) - Project documentation and guides.
+
+## Support AVR
+
+AVR is free and open-source. If you find it valuable, consider supporting its development:
+
+<a href="https://ko-fi.com/agentvoiceresponse" target="_blank"><img src="https://ko-fi.com/img/githubbutton_sm.svg" alt="Support us on Ko-fi"></a>
+
+## License
+
+MIT License - see the [LICENSE.md](LICENSE.md) file for details.

package/dist/common/asset-path.d.ts

@@ -0,0 +1,2 @@
+export declare const baseAssetPath: string;
+//# sourceMappingURL=asset-path.d.ts.map

package/dist/common/asset-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-path.d.ts","sourceRoot":"","sources":["../../src/common/asset-path.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,aAAa,QAAW,CAAC"}

package/dist/common/asset-path.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseAssetPath = void 0;
+// nextjs@14 bundler may attempt to execute this during SSR and crash
+const isWeb = typeof window !== "undefined" && typeof window.document !== "undefined";
+const currentScript = isWeb
+    ? window.document.currentScript
+    : null;
+let basePath = "/";
+if (currentScript) {
+    basePath = currentScript.src
+        .replace(/#.*$/, "")
+        .replace(/\?.*$/, "")
+        .replace(/\/[^/]+$/, "/");
+}
+exports.baseAssetPath = basePath;
+//# sourceMappingURL=asset-path.js.map

package/dist/common/asset-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-path.js","sourceRoot":"","sources":["../../src/common/asset-path.ts"],"names":[],"mappings":";;;AAAA,qEAAqE;AACrE,MAAM,KAAK,GACV,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,WAAW,CAAC;AACzE,MAAM,aAAa,GAAG,KAAK;IAC1B,CAAC,CAAE,MAAM,CAAC,QAAQ,CAAC,aAAmC;IACtD,CAAC,CAAC,IAAI,CAAC;AAER,IAAI,QAAQ,GAAG,GAAG,CAAC;AACnB,IAAI,aAAa,EAAE,CAAC;IACnB,QAAQ,GAAG,aAAa,CAAC,GAAG;SAC1B,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;SACnB,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;SACpB,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;AAC5B,CAAC;AAEY,QAAA,aAAa,GAAG,QAAQ,CAAC"}

package/dist/common/default-model-fetcher.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultModelFetcher: (path: string) => Promise<ArrayBuffer>;
+//# sourceMappingURL=default-model-fetcher.d.ts.map

package/dist/common/default-model-fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-model-fetcher.d.ts","sourceRoot":"","sources":["../../src/common/default-model-fetcher.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,yBAE/C,CAAC"}

package/dist/common/default-model-fetcher.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultModelFetcher = void 0;
+const defaultModelFetcher = (path) => {
+    return fetch(path).then((model) => model.arrayBuffer());
+};
+exports.defaultModelFetcher = defaultModelFetcher;
+//# sourceMappingURL=default-model-fetcher.js.map

package/dist/common/default-model-fetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-model-fetcher.js","sourceRoot":"","sources":["../../src/common/default-model-fetcher.ts"],"names":[],"mappings":";;;AAAO,MAAM,mBAAmB,GAAG,CAAC,IAAY,EAAE,EAAE;IAClD,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;AAC1D,CAAC,CAAC;AAFW,QAAA,mBAAmB,uBAE9B"}

package/dist/common/frame-processor.d.ts

@@ -0,0 +1,86 @@
+import { Message } from "./messages";
+import type { SpeechProbabilities } from "./models";
+export interface FrameProcessorOptions {
+    /** Threshold over which values returned by the Silero VAD model will be considered as positively indicating speech.
+     * The Silero VAD model is run on each frame. This number should be between 0 and 1.
+     */
+    positiveSpeechThreshold: number;
+    /** Threshold under which values returned by the Silero VAD model will be considered as indicating an absence of speech.
+     * Note that the creators of the Silero VAD have historically set this number at 0.15 less than `positiveSpeechThreshold`.
+     */
+    negativeSpeechThreshold: number;
+    /** After a VAD value under the `negativeSpeechThreshold` is observed, the algorithm will wait `redemptionFrames` frames
+     * before running `onSpeechEnd`. If the model returns a value over `positiveSpeechThreshold` during this grace period, then
+     * the algorithm will consider the previously-detected "speech end" as having been a false negative.
+     */
+    redemptionFrames: number;
+    /** Number of audio samples (under a sample rate of 16000) to comprise one "frame" to feed to the Silero VAD model.
+     * The `frame` serves as a unit of measurement of lengths of audio segments and many other parameters are defined in terms of
+     * frames. The authors of the Silero VAD model offer the following warning:
+     * > WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000 sample rate and 256, 512, 768 samples for 8000 sample rate.
+     * > Values other than these may affect model perfomance!!
+     * In this context, audio fed to the VAD model always has sample rate 16000. It is probably a good idea to leave this at 1536.
+     */
+    frameSamples: number;
+    /** Number of frames to prepend to the audio segment that will be passed to `onSpeechEnd`. */
+    preSpeechPadFrames: number;
+    /** If an audio segment is detected as a speech segment according to initial algorithm but it has fewer than `minSpeechFrames`,
+     * it will be discarded and `onVADMisfire` will be run instead of `onSpeechEnd`.
+     */
+    minSpeechFrames: number;
+    /**
+     * If true, when the user pauses the VAD, it may trigger `onSpeechEnd`.
+     */
+    submitUserSpeechOnPause: boolean;
+}
+export declare const defaultLegacyFrameProcessorOptions: FrameProcessorOptions;
+export declare const defaultV5FrameProcessorOptions: FrameProcessorOptions;
+/**
+ * Default options for Silero VAD v6.2
+ * Optimized for telephony and lower quality audio
+ */
+export declare const defaultV6FrameProcessorOptions: FrameProcessorOptions;
+export declare function validateOptions(options: FrameProcessorOptions): void;
+export interface FrameProcessorInterface {
+    resume: () => void;
+    process: (arr: Float32Array, handleEvent: (event: FrameProcessorEvent) => any) => Promise<any>;
+    endSegment: (handleEvent: (event: FrameProcessorEvent) => any) => {
+        msg?: Message;
+        audio?: Float32Array;
+    };
+}
+export declare class FrameProcessor implements FrameProcessorInterface {
+    modelProcessFunc: (frame: Float32Array) => Promise<SpeechProbabilities>;
+    modelResetFunc: () => any;
+    options: FrameProcessorOptions;
+    speaking: boolean;
+    audioBuffer: {
+        frame: Float32Array;
+        isSpeech: boolean;
+    }[];
+    redemptionCounter: number;
+    speechFrameCount: number;
+    active: boolean;
+    speechRealStartFired: boolean;
+    constructor(modelProcessFunc: (frame: Float32Array) => Promise<SpeechProbabilities>, modelResetFunc: () => any, options: FrameProcessorOptions);
+    reset: () => void;
+    pause: (handleEvent: (event: FrameProcessorEvent) => any) => void;
+    resume: () => void;
+    endSegment: (handleEvent: (event: FrameProcessorEvent) => any) => {};
+    process: (frame: Float32Array, handleEvent: (event: FrameProcessorEvent) => any) => Promise<void>;
+}
+export type FrameProcessorEvent = {
+    msg: Message.VADMisfire;
+} | {
+    msg: Message.SpeechStart;
+} | {
+    msg: Message.SpeechRealStart;
+} | {
+    msg: Message.SpeechEnd;
+    audio: Float32Array;
+} | {
+    msg: Message.FrameProcessed;
+    probs: SpeechProbabilities;
+    frame: Float32Array;
+};
+//# sourceMappingURL=frame-processor.d.ts.map

package/dist/common/frame-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-processor.d.ts","sourceRoot":"","sources":["../../src/common/frame-processor.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAIpD,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAEhC;;OAEG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAEhC;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,6FAA6F;IAC7F,kBAAkB,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED,eAAO,MAAM,kCAAkC,EAAE,qBAQhD,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,qBAQ5C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,8BAA8B,EAAE,qBAQ5C,CAAC;AAEF,wBAAgB,eAAe,CAAC,OAAO,EAAE,qBAAqB,QAwB7D;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,OAAO,EAAE,CACP,GAAG,EAAE,YAAY,EACjB,WAAW,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,GAAG,KAC7C,OAAO,CAAC,GAAG,CAAC,CAAC;IAClB,UAAU,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,GAAG,KAAK;QAChE,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,KAAK,CAAC,EAAE,YAAY,CAAC;KACtB,CAAC;CACH;AAkBD,qBAAa,cAAe,YAAW,uBAAuB;IASnD,gBAAgB,EAAE,CACvB,KAAK,EAAE,YAAY,KAChB,OAAO,CAAC,mBAAmB,CAAC;IAC1B,cAAc,EAAE,MAAM,GAAG;IACzB,OAAO,EAAE,qBAAqB;IAZvC,QAAQ,UAAS;IACjB,WAAW,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IAC1D,iBAAiB,SAAK;IACtB,gBAAgB,SAAK;IACrB,MAAM,UAAS;IACf,oBAAoB,UAAS;gBAGpB,gBAAgB,EAAE,CACvB,KAAK,EAAE,YAAY,KAChB,OAAO,CAAC,mBAAmB,CAAC,EAC1B,cAAc,EAAE,MAAM,GAAG,EACzB,OAAO,EAAE,qBAAqB;IAMvC,KAAK,aAOH;IAEF,KAAK,GAAI,aAAa,CAAC,KAAK,EAAE,mBAAmB,KAAK,GAAG,UAOvD;IAEF,MAAM,aAEJ;IAEF,UAAU,GAAI,aAAa,CAAC,KAAK,EAAE,mBAAmB,KAAK,GAAG,QAkB5D;IAEF,OAAO,GACL,OAAO,YAAY,EACnB,aAAa,CAAC,KAAK,EAAE,mBAAmB,KAAK,GAAG,mBAiEhD;CACH;AAED,MAAM,MAAM,mBAAmB,GAC3B;IACE,GAAG,EAAE,OAAO,CAAC,UAAU,CAAC;CACzB,GACD;IACE,GAAG,EAAE,OAAO,CAAC,WAAW,CAAC;CAC1B,GACD;IACE,GAAG,EAAE,OAAO,CAAC,eAAe,CAAC;CAC9B,GACD;IACE,GAAG,EAAE,OAAO,CAAC,SAAS,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;CACrB,GACD;IACE,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,EAAE,mBAAmB,CAAC;IAC3B,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC"}