@meframe/core 0.0.1

package/dist/plugins/types.d.ts

@@ -0,0 +1,60 @@
+import { Meframe } from '../Meframe';
+import { CompositionModel } from '../model/CompositionModel';
+
+export interface Plugin {
+    /** Plugin name */
+    name: string;
+    /** Plugin version */
+    version: string;
+    /** Plugin description */
+    description?: string;
+    /** Dependencies on other plugins */
+    dependencies?: string[];
+    /** Install the plugin */
+    install(core: Meframe): void | Promise<void>;
+    /** Uninstall the plugin */
+    uninstall?(core: Meframe): void | Promise<void>;
+}
+export type PluginHook = 'beforeInit' | 'afterInit' | 'beforeDestroy' | 'afterDestroy' | 'beforeSetTree' | 'afterSetTree' | 'beforeApplyPatch' | 'afterApplyPatch' | 'beforePlay' | 'afterPlay' | 'beforePause' | 'afterPause' | 'beforeSeek' | 'afterSeek' | 'beforeExport' | 'afterExport' | 'exportProgress' | 'beforeDecode' | 'afterDecode' | 'beforeCompose' | 'afterCompose' | 'beforeEncode' | 'afterEncode' | 'cacheHit' | 'cacheMiss' | 'cacheEvict' | 'error' | 'warning';
+export interface HookContext {
+    /** Hook name */
+    hook: PluginHook;
+    /** Timestamp */
+    timestamp: number;
+    /** Hook-specific data */
+    data?: unknown;
+    /** Cancel the operation (for 'before' hooks) */
+    cancel?: () => void;
+    /** Modify the data (for 'before' hooks) */
+    modify?: (newData: unknown) => void;
+}
+export interface PluginAPI {
+    /** Register a hook handler */
+    on(hook: PluginHook, handler: HookHandler): void;
+    /** Unregister a hook handler */
+    off(hook: PluginHook, handler: HookHandler): void;
+    /** Emit a custom event */
+    emit(event: string, data?: unknown): void;
+    /** Get core state */
+    getState(): unknown;
+    /** Get composition model */
+    getCompositionTree(): CompositionModel | null;
+    /** Get cache statistics */
+    getCacheStats(): unknown;
+    /** Log a message */
+    log(level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: unknown): void;
+}
+export type HookHandler = (context: HookContext) => void | Promise<void>;
+export interface PluginManager {
+    /** Register a plugin */
+    register(plugin: Plugin): void;
+    /** Unregister a plugin */
+    unregister(name: string): void;
+    /** Get registered plugins */
+    getPlugins(): Plugin[];
+    /** Check if a plugin is registered */
+    hasPlugin(name: string): boolean;
+    /** Execute hooks */
+    executeHook(hook: PluginHook, context: Partial<HookContext>): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plugins/types.ts"],"names":[],"mappings":"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"}

package/dist/stages/compose/AudioDucker.d.ts

@@ -0,0 +1,59 @@
+import { DuckingConfig, MixRequest } from './types';
+
+/**
+ * AudioDucker - Automatic volume ducking for background music
+ *
+ * Ducking: Audio engineering technique where the volume of one audio source
+ * is automatically reduced when another audio source is present.
+ *
+ * Common use case: Reduce background music volume when voice/narration plays
+ * to improve speech intelligibility without completely muting the music.
+ *
+ * Key parameters:
+ * - Threshold: Level at which ducking triggers
+ * - Ratio: How much to reduce volume (e.g., 3:1 means reduce by 1/3)
+ * - Attack: How quickly volume reduces (typically 10-50ms)
+ * - Release: How quickly volume returns to normal (typically 100-500ms)
+ * - Hold: Time to maintain ducking after trigger ends
+ */
+export declare class AudioDucker {
+    private config;
+    private sampleRate;
+    constructor(sampleRate: number);
+    configure(config: DuckingConfig): void;
+    /**
+     * Analyze trigger tracks (voice) and generate ducking envelope
+     * Returns gain values (0-1) to apply to target tracks (BGM)
+     */
+    generateDuckingEnvelope(tracks: MixRequest['tracks'], frameCount: number): Promise<Float32Array>;
+    /**
+     * Voice Activity Detection (VAD)
+     * Simple energy-based detection with smoothing
+     * More sophisticated implementations could use:
+     * - Zero-crossing rate (ZCR) for speech/music discrimination
+     * - Spectral centroid for voice frequency detection
+     * - Machine learning models for robust VAD
+     */
+    private detectVoiceActivity;
+    /**
+     * Smooth voice activity detection to avoid choppy ducking
+     * Uses a simple moving average filter
+     */
+    private smoothActivityDetection;
+    /**
+     * Apply ducking based on voice activity
+     * Implements attack/release envelope shaping
+     */
+    private applyDuckingToEnvelope;
+    /**
+     * Apply ducking envelope to audio buffer
+     * This modulates the volume over time according to the envelope
+     */
+    applyEnvelopeToVolume(baseVolume: number, envelope: Float32Array): Float32Array;
+    /**
+     * Calculate dynamic range to avoid over-compression
+     * Returns the difference between peak and RMS levels in dB
+     */
+    calculateDynamicRange(envelope: Float32Array): number;
+}
+//# sourceMappingURL=AudioDucker.d.ts.map

package/dist/stages/compose/AudioDucker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioDucker.d.ts","sourceRoot":"","sources":["../../../src/stages/compose/AudioDucker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,UAAU,CAAS;gBAEf,UAAU,EAAE,MAAM;IAI9B,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAItC;;;OAGG;IACG,uBAAuB,CAC3B,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,EAC5B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,YAAY,CAAC;IAyBxB;;;;;;;OAOG;YACW,mBAAmB;IAwDjC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IA4B/B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAyC9B;;;OAGG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,YAAY;IAQ/E;;;OAGG;IACH,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM;CAiBtD"}

package/dist/stages/compose/AudioDucker.js

@@ -0,0 +1,161 @@
+class AudioDucker {
+  config = null;
+  sampleRate;
+  constructor(sampleRate) {
+    this.sampleRate = sampleRate;
+  }
+  configure(config) {
+    this.config = config;
+  }
+  /**
+   * Analyze trigger tracks (voice) and generate ducking envelope
+   * Returns gain values (0-1) to apply to target tracks (BGM)
+   */
+  async generateDuckingEnvelope(tracks, frameCount) {
+    if (!this.config?.enabled) {
+      return new Float32Array(frameCount).fill(1);
+    }
+    const envelope = new Float32Array(frameCount);
+    envelope.fill(1);
+    const triggerTracks = tracks.filter((t) => this.config.triggerTracks.includes(t.trackId));
+    if (triggerTracks.length === 0) {
+      return envelope;
+    }
+    for (const track of triggerTracks) {
+      const voiceActivity = await this.detectVoiceActivity(track.audioData);
+      this.applyDuckingToEnvelope(envelope, voiceActivity);
+    }
+    return envelope;
+  }
+  /**
+   * Voice Activity Detection (VAD)
+   * Simple energy-based detection with smoothing
+   * More sophisticated implementations could use:
+   * - Zero-crossing rate (ZCR) for speech/music discrimination
+   * - Spectral centroid for voice frequency detection
+   * - Machine learning models for robust VAD
+   */
+  async detectVoiceActivity(audioData) {
+    const frameCount = audioData.numberOfFrames;
+    const activity = new Float32Array(frameCount);
+    const monoData = new Float32Array(frameCount);
+    const channelData = new Float32Array(frameCount);
+    for (let ch = 0; ch < audioData.numberOfChannels; ch++) {
+      audioData.copyTo(channelData, {
+        planeIndex: ch,
+        format: "f32-planar"
+      });
+      for (let i = 0; i < frameCount; i++) {
+        if (monoData && channelData) {
+          monoData[i] = (monoData[i] || 0) + (channelData[i] || 0) / audioData.numberOfChannels;
+        }
+      }
+    }
+    const windowSize = Math.floor(this.sampleRate * 0.02);
+    const hopSize = Math.floor(windowSize / 2);
+    for (let i = 0; i < frameCount; i += hopSize) {
+      const end = Math.min(i + windowSize, frameCount);
+      let energy = 0;
+      for (let j = i; j < end; j++) {
+        if (monoData && monoData[j] !== void 0) {
+          const sample = monoData[j];
+          if (sample !== void 0) {
+            energy += sample * sample;
+          }
+        }
+      }
+      energy = Math.sqrt(energy / (end - i));
+      const threshold = 0.01;
+      const isVoice = energy > threshold;
+      for (let j = i; j < end; j++) {
+        activity[j] = isVoice ? 1 : 0;
+      }
+    }
+    return this.smoothActivityDetection(activity);
+  }
+  /**
+   * Smooth voice activity detection to avoid choppy ducking
+   * Uses a simple moving average filter
+   */
+  smoothActivityDetection(activity) {
+    const smoothed = new Float32Array(activity.length);
+    const smoothWindow = Math.floor(this.sampleRate * 0.05);
+    for (let i = 0; i < activity.length; i++) {
+      let sum = 0;
+      let count = 0;
+      for (let j = Math.max(0, i - smoothWindow); j <= Math.min(activity.length - 1, i + smoothWindow); j++) {
+        if (activity && activity[j] !== void 0) {
+          const val = activity[j];
+          if (val !== void 0) {
+            sum += val;
+          }
+        }
+        count++;
+      }
+      smoothed[i] = sum / count;
+    }
+    return smoothed;
+  }
+  /**
+   * Apply ducking based on voice activity
+   * Implements attack/release envelope shaping
+   */
+  applyDuckingToEnvelope(envelope, voiceActivity) {
+    if (!this.config) return;
+    const duckingLevel = 1 - this.config.duckingLevel;
+    const attackSamples = Math.floor(this.config.attackTimeMs / 1e3 * this.sampleRate);
+    const releaseSamples = Math.floor(this.config.releaseTimeMs / 1e3 * this.sampleRate);
+    const lookAheadSamples = this.config.lookAheadMs ? Math.floor(this.config.lookAheadMs / 1e3 * this.sampleRate) : 0;
+    let currentGain = 1;
+    let releaseCounter = 0;
+    for (let i = 0; i < envelope.length; i++) {
+      const lookAheadIndex = Math.min(i + lookAheadSamples, voiceActivity.length - 1);
+      const activity = voiceActivity[lookAheadIndex];
+      if (activity !== void 0 && activity > 0.5) {
+        if (currentGain > duckingLevel) {
+          currentGain = Math.max(duckingLevel, currentGain - (1 - duckingLevel) / attackSamples);
+        } else {
+          currentGain = duckingLevel;
+        }
+        releaseCounter = 0;
+      } else if (currentGain < 1) {
+        releaseCounter++;
+        if (releaseCounter > releaseSamples * 0.1) {
+          currentGain = Math.min(1, currentGain + (1 - duckingLevel) / releaseSamples);
+        }
+      }
+      envelope[i] = Math.min(envelope[i] || 1, currentGain);
+    }
+  }
+  /**
+   * Apply ducking envelope to audio buffer
+   * This modulates the volume over time according to the envelope
+   */
+  applyEnvelopeToVolume(baseVolume, envelope) {
+    const result = new Float32Array(envelope.length);
+    for (let i = 0; i < envelope.length; i++) {
+      result[i] = baseVolume * (envelope[i] || 1);
+    }
+    return result;
+  }
+  /**
+   * Calculate dynamic range to avoid over-compression
+   * Returns the difference between peak and RMS levels in dB
+   */
+  calculateDynamicRange(envelope) {
+    let peak = 0;
+    let sumSquares = 0;
+    for (const value of envelope) {
+      peak = Math.max(peak, value);
+      sumSquares += value * value;
+    }
+    const rms = Math.sqrt(sumSquares / envelope.length);
+    const peakDb = 20 * Math.log10(peak);
+    const rmsDb = 20 * Math.log10(rms);
+    return peakDb - rmsDb;
+  }
+}
+export {
+  AudioDucker
+};
+//# sourceMappingURL=AudioDucker.js.map

package/dist/stages/compose/AudioDucker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioDucker.js","sources":["../../../src/stages/compose/AudioDucker.ts"],"sourcesContent":["import type { DuckingConfig, MixRequest } from './types';\n\n/**\n * AudioDucker - Automatic volume ducking for background music\n *\n * Ducking: Audio engineering technique where the volume of one audio source\n * is automatically reduced when another audio source is present.\n *\n * Common use case: Reduce background music volume when voice/narration plays\n * to improve speech intelligibility without completely muting the music.\n *\n * Key parameters:\n * - Threshold: Level at which ducking triggers\n * - Ratio: How much to reduce volume (e.g., 3:1 means reduce by 1/3)\n * - Attack: How quickly volume reduces (typically 10-50ms)\n * - Release: How quickly volume returns to normal (typically 100-500ms)\n * - Hold: Time to maintain ducking after trigger ends\n */\nexport class AudioDucker {\n  private config: DuckingConfig | null = null;\n  private sampleRate: number;\n\n  constructor(sampleRate: number) {\n    this.sampleRate = sampleRate;\n  }\n\n  configure(config: DuckingConfig): void {\n    this.config = config;\n  }\n\n  /**\n   * Analyze trigger tracks (voice) and generate ducking envelope\n   * Returns gain values (0-1) to apply to target tracks (BGM)\n   */\n  async generateDuckingEnvelope(\n    tracks: MixRequest['tracks'],\n    frameCount: number\n  ): Promise<Float32Array> {\n    if (!this.config?.enabled) {\n      return new Float32Array(frameCount).fill(1.0);\n    }\n\n    // Initialize envelope with no ducking (gain = 1.0)\n    const envelope = new Float32Array(frameCount);\n    envelope.fill(1.0);\n\n    // Find trigger tracks (typically voice/narration)\n    const triggerTracks = tracks.filter((t) => this.config!.triggerTracks.includes(t.trackId));\n\n    if (triggerTracks.length === 0) {\n      return envelope;\n    }\n\n    // Analyze each trigger track for voice activity\n    for (const track of triggerTracks) {\n      const voiceActivity = await this.detectVoiceActivity(track.audioData);\n      this.applyDuckingToEnvelope(envelope, voiceActivity);\n    }\n\n    return envelope;\n  }\n\n  /**\n   * Voice Activity Detection (VAD)\n   * Simple energy-based detection with smoothing\n   * More sophisticated implementations could use:\n   * - Zero-crossing rate (ZCR) for speech/music discrimination\n   * - Spectral centroid for voice frequency detection\n   * - Machine learning models for robust VAD\n   */\n  private async detectVoiceActivity(audioData: AudioData): Promise<Float32Array> {\n    const frameCount = audioData.numberOfFrames;\n    const activity = new Float32Array(frameCount);\n\n    // Convert to mono for analysis\n    const monoData = new Float32Array(frameCount);\n    const channelData = new Float32Array(frameCount);\n\n    for (let ch = 0; ch < audioData.numberOfChannels; ch++) {\n      audioData.copyTo(channelData, {\n        planeIndex: ch,\n        format: 'f32-planar' as const,\n      });\n\n      for (let i = 0; i < frameCount; i++) {\n        if (monoData && channelData) {\n          monoData[i] = (monoData[i] || 0) + (channelData[i] || 0) / audioData.numberOfChannels;\n        }\n      }\n    }\n\n    // Energy calculation with windowing\n    // Window size: 20ms is typical for speech analysis\n    const windowSize = Math.floor(this.sampleRate * 0.02);\n    const hopSize = Math.floor(windowSize / 2); // 50% overlap\n\n    for (let i = 0; i < frameCount; i += hopSize) {\n      const end = Math.min(i + windowSize, frameCount);\n\n      // Calculate RMS energy in window\n      let energy = 0;\n      for (let j = i; j < end; j++) {\n        if (monoData && monoData[j] !== undefined) {\n          const sample = monoData[j];\n          if (sample !== undefined) {\n            energy += sample * sample;\n          }\n        }\n      }\n      energy = Math.sqrt(energy / (end - i));\n\n      // Simple threshold-based VAD\n      // Typical speech energy threshold: -40dB to -30dB\n      const threshold = 0.01; // Approximately -40dB\n      const isVoice = energy > threshold;\n\n      // Fill activity array for this window\n      for (let j = i; j < end; j++) {\n        activity[j] = isVoice ? 1.0 : 0.0;\n      }\n    }\n\n    // Smooth activity detection to avoid rapid changes\n    return this.smoothActivityDetection(activity);\n  }\n\n  /**\n   * Smooth voice activity detection to avoid choppy ducking\n   * Uses a simple moving average filter\n   */\n  private smoothActivityDetection(activity: Float32Array): Float32Array {\n    const smoothed = new Float32Array(activity.length);\n    const smoothWindow = Math.floor(this.sampleRate * 0.05); // 50ms smoothing\n\n    for (let i = 0; i < activity.length; i++) {\n      let sum = 0;\n      let count = 0;\n\n      for (\n        let j = Math.max(0, i - smoothWindow);\n        j <= Math.min(activity.length - 1, i + smoothWindow);\n        j++\n      ) {\n        if (activity && activity[j] !== undefined) {\n          const val = activity[j];\n          if (val !== undefined) {\n            sum += val;\n          }\n        }\n        count++;\n      }\n\n      smoothed[i] = sum / count;\n    }\n\n    return smoothed;\n  }\n\n  /**\n   * Apply ducking based on voice activity\n   * Implements attack/release envelope shaping\n   */\n  private applyDuckingToEnvelope(envelope: Float32Array, voiceActivity: Float32Array): void {\n    if (!this.config) return;\n\n    const duckingLevel = 1.0 - this.config.duckingLevel;\n    const attackSamples = Math.floor((this.config.attackTimeMs / 1000) * this.sampleRate);\n    const releaseSamples = Math.floor((this.config.releaseTimeMs / 1000) * this.sampleRate);\n    const lookAheadSamples = this.config.lookAheadMs\n      ? Math.floor((this.config.lookAheadMs / 1000) * this.sampleRate)\n      : 0;\n\n    let currentGain = 1.0;\n    let releaseCounter = 0;\n\n    for (let i = 0; i < envelope.length; i++) {\n      // Look ahead for upcoming voice activity\n      const lookAheadIndex = Math.min(i + lookAheadSamples, voiceActivity.length - 1);\n      const activity = voiceActivity[lookAheadIndex];\n\n      if (activity !== undefined && activity > 0.5) {\n        // Voice detected - apply ducking with attack curve\n        if (currentGain > duckingLevel) {\n          // Attack phase - reduce gain\n          currentGain = Math.max(duckingLevel, currentGain - (1.0 - duckingLevel) / attackSamples);\n        } else {\n          currentGain = duckingLevel;\n        }\n        releaseCounter = 0;\n      } else if (currentGain < 1.0) {\n        // No voice - apply release curve\n        releaseCounter++;\n        if (releaseCounter > releaseSamples * 0.1) {\n          // Small hold time\n          currentGain = Math.min(1.0, currentGain + (1.0 - duckingLevel) / releaseSamples);\n        }\n      }\n\n      // Apply the calculated gain\n      envelope[i] = Math.min(envelope[i] || 1, currentGain);\n    }\n  }\n\n  /**\n   * Apply ducking envelope to audio buffer\n   * This modulates the volume over time according to the envelope\n   */\n  applyEnvelopeToVolume(baseVolume: number, envelope: Float32Array): Float32Array {\n    const result = new Float32Array(envelope.length);\n    for (let i = 0; i < envelope.length; i++) {\n      result[i] = baseVolume * (envelope[i] || 1);\n    }\n    return result;\n  }\n\n  /**\n   * Calculate dynamic range to avoid over-compression\n   * Returns the difference between peak and RMS levels in dB\n   */\n  calculateDynamicRange(envelope: Float32Array): number {\n    let peak = 0;\n    let sumSquares = 0;\n\n    for (const value of envelope) {\n      peak = Math.max(peak, value);\n      sumSquares += value * value;\n    }\n\n    const rms = Math.sqrt(sumSquares / envelope.length);\n\n    // Convert to dB (20 * log10(ratio))\n    const peakDb = 20 * Math.log10(peak);\n    const rmsDb = 20 * Math.log10(rms);\n\n    return peakDb - rmsDb;\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/stages/compose/AudioMixer.d.ts

@@ -0,0 +1,29 @@
+import { AudioComposeConfig, AudioTrack, AudioTrackConfig, MixRequest, MixResult } from './types';
+import { AudioDucker } from './AudioDucker';
+
+export declare class AudioMixer {
+    config: AudioComposeConfig;
+    private tracksMap;
+    constructor(config: AudioComposeConfig);
+    getConfig(): AudioComposeConfig;
+    updateConfig(update: Partial<AudioComposeConfig>): void;
+    get tracks(): AudioTrack[];
+    createMixStream(ducker?: AudioDucker): TransformStream<MixRequest, MixResult>;
+    mixTracks(request: MixRequest, precomputedFrameCount?: number): Promise<MixResult>;
+    addTrack(track: AudioTrack): void;
+    removeTrack(trackId: string): void;
+    updateTrack(trackId: string, patch: Partial<AudioTrack> & {
+        config?: Partial<AudioTrackConfig>;
+    }): void;
+    private mixTrackIntoOutput;
+    private buildGainEnvelope;
+    private extractChannels;
+    private limitAndMeasure;
+    private createAudioData;
+    private getFrameCount;
+    private getFadeSampleCount;
+    private getClipSampleCount;
+    private computeTrackStartFrame;
+    private getCurveValue;
+}
+//# sourceMappingURL=AudioMixer.d.ts.map

package/dist/stages/compose/AudioMixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioMixer.d.ts","sourceRoot":"","sources":["../../../src/stages/compose/AudioMixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,UAAU,EACV,gBAAgB,EAEhB,UAAU,EACV,SAAS,EACV,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,qBAAa,UAAU;IACrB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,CAAC,SAAS,CAAiC;gBAEtC,MAAM,EAAE,kBAAkB;IAItC,SAAS,IAAI,kBAAkB;IAI/B,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI;IAIvD,IAAI,MAAM,IAAI,UAAU,EAAE,CAEzB;IAED,eAAe,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,eAAe,CAAC,UAAU,EAAE,SAAS,CAAC;IA+BvE,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,qBAAqB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IA0DxF,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAIjC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIlC,WAAW,CACT,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;KAAE,GAClE,IAAI;IAaP,OAAO,CAAC,kBAAkB;IAsF1B,OAAO,CAAC,iBAAiB;IAiDzB,OAAO,CAAC,eAAe;IAsFvB,OAAO,CAAC,eAAe;IAkCvB,OAAO,CAAC,eAAe;IAoCvB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,aAAa;CActB"}