react-native-executorch 0.5.1-rc.0 → 0.5.2

package/src/utils/ResourceFetcherUtils.ts

@@ -53,17 +53,16 @@ export namespace ResourceFetcherUtils {
       return SourceType.OBJECT;
     } else if (typeof source === 'number') {
       const uri = Asset.fromModule(source).uri;
-      if (!uri.includes('://')) {
-        return SourceType.RELEASE_MODE_FILE;
+      if (uri.startsWith('http')) {
+        return SourceType.DEV_MODE_FILE;
       }
-      return SourceType.DEV_MODE_FILE;
-    } else {
-      // typeof source == 'string'
-      if (source.startsWith('file://')) {
-        return SourceType.LOCAL_FILE;
-      }
-      return SourceType.REMOTE_FILE;
+      return SourceType.RELEASE_MODE_FILE;
+    }
+    // typeof source == 'string'
+    if (source.startsWith('file://')) {
+      return SourceType.LOCAL_FILE;
     }
+    return SourceType.REMOTE_FILE;
   }
 
   export async function getFilesSizes(sources: ResourceSource[]) {
@@ -78,9 +77,8 @@ export namespace ResourceFetcherUtils {
     for (const source of sources) {
       const type = await ResourceFetcherUtils.getType(source);
       let length = 0;
-
-      if (type === SourceType.REMOTE_FILE && typeof source === 'string') {
-        try {
+      try {
+        if (type === SourceType.REMOTE_FILE && typeof source === 'string') {
           const response = await fetch(source, { method: 'HEAD' });
           if (!response.ok) {
             Logger.warn(
@@ -97,14 +95,14 @@ export namespace ResourceFetcherUtils {
           length = contentLength ? parseInt(contentLength, 10) : 0;
           previousFilesTotalLength = totalLength;
           totalLength += length;
-        } catch (error) {
-          Logger.warn(`Error fetching HEAD for ${source}:`, error);
-          continue;
         }
+      } catch (error) {
+        Logger.warn(`Error fetching HEAD for ${source}:`, error);
+        continue;
+      } finally {
+        results.push({ source, type, length, previousFilesTotalLength });
       }
-      results.push({ source, type, length, previousFilesTotalLength });
     }
-
     return { results, totalLength };
   }
 

package/src/utils/SpeechToTextModule/ASR.ts

@@ -0,0 +1,303 @@
+// NOTE: This will be implemented in C++
+
+import { TokenizerModule } from '../../modules/natural_language_processing/TokenizerModule';
+import {
+  DecodingOptions,
+  Segment,
+  SpeechToTextModelConfig,
+  WordObject,
+  WordTuple,
+} from '../../types/stt';
+import { ResourceFetcher } from '../ResourceFetcher';
+
+export class ASR {
+  private nativeModule: any;
+  private tokenizerModule: TokenizerModule = new TokenizerModule();
+
+  private timePrecision: number = 0.02; // Whisper timestamp precision
+  private maxDecodeLength: number = 128;
+  private chunkSize: number = 30; // 30 seconds
+  private minChunkSamples: number = 1 * 16000; // 1 second
+  private samplingRate: number = 16000;
+
+  private startOfTranscriptToken!: number;
+  private endOfTextToken!: number;
+  private timestampBeginToken!: number;
+
+  public async load(
+    model: SpeechToTextModelConfig,
+    onDownloadProgressCallback: (progress: number) => void
+  ) {
+    const tokenizerLoadPromise = this.tokenizerModule.load(model);
+    const encoderDecoderPromise = ResourceFetcher.fetch(
+      onDownloadProgressCallback,
+      model.encoderSource,
+      model.decoderSource
+    );
+    const [_, encoderDecoderResults] = await Promise.all([
+      tokenizerLoadPromise,
+      encoderDecoderPromise,
+    ]);
+    const encoderSource = encoderDecoderResults?.[0];
+    const decoderSource = encoderDecoderResults?.[1];
+    if (!encoderSource || !decoderSource) {
+      throw new Error('Download interrupted.');
+    }
+    this.nativeModule = await global.loadSpeechToText(
+      encoderSource,
+      decoderSource,
+      'whisper'
+    );
+
+    this.startOfTranscriptToken = await this.tokenizerModule.tokenToId(
+      '<|startoftranscript|>'
+    );
+    this.endOfTextToken = await this.tokenizerModule.tokenToId('<|endoftext|>');
+    this.timestampBeginToken = await this.tokenizerModule.tokenToId('<|0.00|>');
+  }
+
+  private async getInitialSequence(
+    options: DecodingOptions
+  ): Promise<number[]> {
+    const initialSequence: number[] = [this.startOfTranscriptToken];
+    if (options.language) {
+      const languageToken = await this.tokenizerModule.tokenToId(
+        `<|${options.language}|>`
+      );
+      const taskToken = await this.tokenizerModule.tokenToId('<|transcribe|>');
+      initialSequence.push(languageToken);
+      initialSequence.push(taskToken);
+    }
+    initialSequence.push(this.timestampBeginToken);
+    return initialSequence;
+  }
+
+  private async generate(
+    audio: number[],
+    temperature: number,
+    options: DecodingOptions
+  ): Promise<{
+    sequencesIds: number[];
+    scores: number[];
+  }> {
+    await this.encode(new Float32Array(audio));
+    const initialSequence = await this.getInitialSequence(options);
+    const sequencesIds = [...initialSequence];
+    const scores: number[] = [];
+
+    while (sequencesIds.length <= this.maxDecodeLength) {
+      const logits = this.softmaxWithTemperature(
+        Array.from(await this.decode(sequencesIds)),
+        temperature === 0 ? 1 : temperature
+      );
+      const nextTokenId =
+        temperature === 0
+          ? logits.indexOf(Math.max(...logits))
+          : this.sampleFromDistribution(logits);
+      const nextTokenProb = logits[nextTokenId]!;
+      sequencesIds.push(nextTokenId);
+      scores.push(nextTokenProb);
+      if (nextTokenId === this.endOfTextToken) {
+        break;
+      }
+    }
+
+    return {
+      sequencesIds: sequencesIds.slice(initialSequence.length),
+      scores: scores.slice(initialSequence.length),
+    };
+  }
+
+  private softmaxWithTemperature(logits: number[], temperature = 1.0) {
+    const max = Math.max(...logits);
+    const exps = logits.map((logit) => Math.exp((logit - max) / temperature));
+    const sum = exps.reduce((a, b) => a + b, 0);
+    return exps.map((exp) => exp / sum);
+  }
+
+  private sampleFromDistribution(probs: number[]): number {
+    const r = Math.random();
+    let cumulative = 0;
+    for (let i = 0; i < probs.length; i++) {
+      cumulative += probs[i]!;
+      if (r < cumulative) {
+        return i;
+      }
+    }
+    return probs.length - 1;
+  }
+
+  private async generateWithFallback(
+    audio: number[],
+    options: DecodingOptions
+  ) {
+    const temperatures = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0];
+    let generatedTokens: number[] = [];
+
+    for (const temperature of temperatures) {
+      const result = await this.generate(audio, temperature, options);
+      const tokens = result.sequencesIds;
+      const scores = result.scores;
+
+      const seqLen = tokens.length;
+      const cumLogProb = scores.reduce(
+        (acc, score) => acc + Math.log(score),
+        0
+      );
+      const avgLogProb = cumLogProb / seqLen;
+
+      if (avgLogProb >= -1.0) {
+        generatedTokens = tokens;
+        break;
+      }
+    }
+
+    return this.calculateWordLevelTimestamps(generatedTokens, audio);
+  }
+
+  private async calculateWordLevelTimestamps(
+    generatedTokens: number[],
+    audio: number[]
+  ): Promise<Segment[]> {
+    const segments: Segment[] = [];
+
+    let tokens: number[] = [];
+    let prevTimestamp = this.timestampBeginToken;
+    for (let i = 0; i < generatedTokens.length; i++) {
+      if (generatedTokens[i]! < this.timestampBeginToken) {
+        tokens.push(generatedTokens[i]!);
+      }
+
+      if (
+        i > 0 &&
+        generatedTokens[i - 1]! >= this.timestampBeginToken &&
+        generatedTokens[i]! >= this.timestampBeginToken
+      ) {
+        const start = prevTimestamp;
+        const end = generatedTokens[i - 1]!;
+        const wordObjects = await this.estimateWordTimestampsLinear(
+          tokens,
+          start,
+          end
+        );
+        segments.push({
+          words: wordObjects,
+        });
+        tokens = [];
+        prevTimestamp = generatedTokens[i]!;
+      }
+    }
+
+    const start = prevTimestamp;
+    const end = generatedTokens.at(-2)!;
+    const wordObjects = await this.estimateWordTimestampsLinear(
+      tokens,
+      start,
+      end
+    );
+    segments.push({
+      words: wordObjects,
+    });
+
+    const scalingFactor =
+      audio.length /
+      this.samplingRate /
+      ((end - this.timestampBeginToken) * this.timePrecision);
+    if (scalingFactor < 1) {
+      for (const segment of segments) {
+        for (const word of segment.words) {
+          word.start *= scalingFactor;
+          word.end *= scalingFactor;
+        }
+      }
+    }
+
+    return segments;
+  }
+
+  private async estimateWordTimestampsLinear(
+    tokens: number[],
+    start: number,
+    end: number
+  ): Promise<WordObject[]> {
+    const duration = (end - start) * this.timePrecision;
+    const segmentText = (
+      (await this.tokenizerModule.decode(tokens)) as string
+    ).trim();
+
+    const words = segmentText.split(' ').map((w) => ` ${w}`);
+    const numOfCharacters = words.reduce(
+      (acc: number, word: string) => acc + word.length,
+      0
+    );
+
+    const timePerCharacter = duration / numOfCharacters;
+
+    const wordObjects: WordObject[] = [];
+    const startTimeOffset =
+      (start - this.timestampBeginToken) * this.timePrecision;
+
+    let prevCharNum = 0;
+    for (let j = 0; j < words.length; j++) {
+      const word = words[j]!;
+      const start = startTimeOffset + prevCharNum * timePerCharacter;
+      const end = start + timePerCharacter * word.length;
+      wordObjects.push({ word, start, end });
+      prevCharNum += word.length;
+    }
+
+    return wordObjects;
+  }
+
+  public async transcribe(
+    audio: number[],
+    options: DecodingOptions
+  ): Promise<Segment[]> {
+    let seek = 0;
+    const allSegments: Segment[] = [];
+
+    while (seek * this.samplingRate < audio.length) {
+      const chunk = audio.slice(
+        seek * this.samplingRate,
+        (seek + this.chunkSize) * this.samplingRate
+      );
+      if (chunk.length < this.minChunkSamples) {
+        return allSegments;
+      }
+      const segments = await this.generateWithFallback(chunk, options);
+      for (const segment of segments) {
+        for (const word of segment.words) {
+          word.start += seek;
+          word.end += seek;
+        }
+      }
+      allSegments.push(...segments);
+      const lastTimeStamp = segments.at(-1)!.words.at(-1)!.end;
+      seek = lastTimeStamp;
+    }
+
+    return allSegments;
+  }
+
+  public tsWords(segments: Segment[]): WordTuple[] {
+    const o: WordTuple[] = [];
+    for (const segment of segments) {
+      for (const word of segment.words) {
+        o.push([word.start, word.end, word.word]);
+      }
+    }
+    return o;
+  }
+
+  public segmentsEndTs(res: Segment[]) {
+    return res.map((segment) => segment.words.at(-1)!.end);
+  }
+
+  public async encode(waveform: Float32Array): Promise<void> {
+    await this.nativeModule.encode(waveform);
+  }
+
+  public async decode(tokens: number[]): Promise<Float32Array> {
+    return new Float32Array(await this.nativeModule.decode(tokens));
+  }
+}

package/src/utils/SpeechToTextModule/OnlineProcessor.ts

@@ -0,0 +1,87 @@
+// NOTE: This will be implemented in C++
+
+import { WordTuple, DecodingOptions, Segment } from '../../types/stt';
+import { ASR } from './ASR';
+import { HypothesisBuffer } from './hypothesisBuffer';
+
+export class OnlineASRProcessor {
+  private asr: ASR;
+
+  private samplingRate: number = 16000;
+  public audioBuffer: number[] = [];
+  private transcriptBuffer: HypothesisBuffer = new HypothesisBuffer();
+  private bufferTimeOffset: number = 0;
+  private committed: WordTuple[] = [];
+
+  constructor(asr: ASR) {
+    this.asr = asr;
+  }
+
+  public insertAudioChunk(audio: number[]) {
+    this.audioBuffer.push(...audio);
+  }
+
+  public async processIter(options: DecodingOptions) {
+    const res = await this.asr.transcribe(this.audioBuffer, options);
+    const tsw = this.asr.tsWords(res);
+    this.transcriptBuffer.insert(tsw, this.bufferTimeOffset);
+    const o = this.transcriptBuffer.flush();
+    this.committed.push(...o);
+
+    const s = 15;
+    if (this.audioBuffer.length / this.samplingRate > s) {
+      this.chunkCompletedSegment(res);
+    }
+
+    const committed = this.toFlush(o)[2];
+    const nonCommitted = this.transcriptBuffer
+      .complete()
+      .map((x) => x[2])
+      .join('');
+    return { committed, nonCommitted };
+  }
+
+  private chunkCompletedSegment(res: Segment[]) {
+    if (this.committed.length === 0) {
+      return;
+    }
+
+    const ends = this.asr.segmentsEndTs(res);
+    const t = this.committed.at(-1)![1];
+
+    if (ends.length > 1) {
+      let e = ends.at(-2)! + this.bufferTimeOffset;
+      while (ends.length > 2 && e > t) {
+        ends.pop();
+        e = ends.at(-2)! + this.bufferTimeOffset;
+      }
+
+      if (e <= t) {
+        this.chunkAt(e);
+      }
+    }
+  }
+
+  private chunkAt(time: number) {
+    this.transcriptBuffer.popCommitted(time);
+    const cutSeconds = time - this.bufferTimeOffset;
+    this.audioBuffer = this.audioBuffer.slice(
+      Math.floor(cutSeconds * this.samplingRate)
+    );
+    this.bufferTimeOffset = time;
+  }
+
+  public async finish() {
+    const o = this.transcriptBuffer.complete();
+    const f = this.toFlush(o);
+    this.bufferTimeOffset += this.audioBuffer.length / this.samplingRate;
+    return { committed: f[2] };
+  }
+
+  private toFlush(words: WordTuple[]): [number | null, number | null, string] {
+    const t = words.map((s) => s[2]).join(' ');
+    const b = words.length === 0 ? null : words[0]![0];
+    const e = words.length === 0 ? null : words.at(-1)![1];
+    return [b, e, t];
+  }
+}

package/src/utils/SpeechToTextModule/hypothesisBuffer.ts

@@ -0,0 +1,79 @@
+// NOTE: This will be implemented in C++
+
+import { WordTuple } from '../../types/stt';
+
+export class HypothesisBuffer {
+  private committedInBuffer: WordTuple[] = [];
+  private buffer: WordTuple[] = [];
+  private new: WordTuple[] = [];
+
+  private lastCommittedTime: number = 0;
+  public lastCommittedWord: string | null = null;
+
+  public insert(newWords: WordTuple[], offset: number) {
+    const newWordsOffset: WordTuple[] = newWords.map(([a, b, t]) => [
+      a + offset,
+      b + offset,
+      t,
+    ]);
+    this.new = newWordsOffset.filter(
+      ([a, _b, _t]) => a > this.lastCommittedTime - 0.5
+    );
+
+    if (this.new.length > 0) {
+      const [a, _b, _t] = this.new[0]!;
+      if (
+        Math.abs(a - this.lastCommittedTime) < 1 &&
+        this.committedInBuffer.length > 0
+      ) {
+        const cn = this.committedInBuffer.length;
+        const nn = this.new.length;
+
+        for (let i = 1; i <= Math.min(cn, nn, 5); i++) {
+          const c = this.committedInBuffer
+            .slice(-i)
+            .map((w) => w[2])
+            .join(' ');
+          const tail = this.new
+            .slice(0, i)
+            .map((w) => w[2])
+            .join(' ');
+          if (c === tail) {
+            for (let j = 0; j < i; j++) {
+              this.new.shift();
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  public flush(): WordTuple[] {
+    const commit: WordTuple[] = [];
+    while (this.new.length > 0 && this.buffer.length > 0) {
+      if (this.new[0]![2] !== this.buffer[0]![2]) {
+        break;
+      }
+      commit.push(this.new[0]!);
+      this.lastCommittedWord = this.new[0]![2];
+      this.lastCommittedTime = this.new[0]![1];
+      this.buffer.shift();
+      this.new.shift();
+    }
+    this.buffer = this.new;
+    this.new = [];
+    this.committedInBuffer.push(...commit);
+    return commit;
+  }
+
+  public popCommitted(time: number) {
+    this.committedInBuffer = this.committedInBuffer.filter(
+      ([_a, b, _t]) => b > time
+    );
+  }
+
+  public complete(): WordTuple[] {
+    return this.buffer;
+  }
+}

package/common/rnexecutorch/models/speech_to_text/MoonshineStrategy.cpp

@@ -1,31 +0,0 @@
-#include "MoonshineStrategy.h"
-#include "executorch/runtime/core/exec_aten/exec_aten.h"
-#include <executorch/extension/tensor/tensor_ptr_maker.h>
-#include <executorch/runtime/core/portable_type/scalar_type.h>
-
-namespace rnexecutorch {
-
-using namespace ::executorch::extension;
-using namespace ::executorch::aten;
-
-TensorPtr MoonshineStrategy::prepareAudioInput(std::span<float> waveform) {
-  std::vector<int32_t> inputShape = {1, static_cast<int32_t>(waveform.size())};
-  return make_tensor_ptr(std::move(inputShape), waveform.data(),
-                         ScalarType::Float);
-}
-
-TensorPtr
-MoonshineStrategy::prepareTokenInput(const std::vector<int64_t> &prevTokens) {
-  std::vector<int32_t> tensorSizes = {1,
-                                      static_cast<int32_t>(prevTokens.size())};
-  // prevTokens gets copied!!
-  return make_tensor_ptr(std::move(tensorSizes), prevTokens);
-}
-
-int64_t MoonshineStrategy::extractOutputToken(const void *outputPtr,
-                                              size_t innerDim) const {
-  const auto *data = static_cast<const int64_t *>(outputPtr);
-  return data[innerDim - 1];
-}
-
-} // namespace rnexecutorch

package/common/rnexecutorch/models/speech_to_text/MoonshineStrategy.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "SpeechToTextStrategy.h"
-#include <span>
-#include <vector>
-
-namespace rnexecutorch {
-
-class MoonshineStrategy final : public SpeechToTextStrategy {
-public:
-  TensorPtr prepareAudioInput(std::span<float> waveform) override;
-
-  TensorPtr prepareTokenInput(const std::vector<int64_t> &prevTokens) override;
-
-  std::string getDecoderMethod() const override { return "forward_cached"; }
-
-  int64_t extractOutputToken(const void *outputPtr,
-                             size_t innerDim) const override;
-};
-
-} // namespace rnexecutorch

package/lib/module/constants/sttDefaults.js

@@ -1,74 +0,0 @@
-"use strict";
-
-import { MOONSHINE_TINY, WHISPER_TINY, WHISPER_TINY_MULTILINGUAL } from './modelUrls';
-import { AvailableModels } from '../types/stt';
-export const SAMPLE_RATE = 16_000;
-export const SECOND = SAMPLE_RATE;
-export const HAMMING_DIST_THRESHOLD = 1;
-const whisperTinyModelConfig = {
-  sources: {
-    encoder: WHISPER_TINY.encoderSource,
-    decoder: WHISPER_TINY.decoderSource
-  },
-  tokenizer: {
-    source: WHISPER_TINY.tokenizerSource,
-    bos: 50257,
-    // FIXME: this is a placeholder and needs to be changed
-    eos: 50256 // FIXME: this is a placeholder and needs to be changed
-  },
-  isMultilingual: false
-};
-const moonshineTinyModelConfig = {
-  sources: {
-    encoder: MOONSHINE_TINY.encoderSource,
-    decoder: MOONSHINE_TINY.decoderSource
-  },
-  tokenizer: {
-    source: MOONSHINE_TINY.tokenizerSource,
-    bos: 1,
-    // FIXME: this is a placeholder and needs to be changed
-    eos: 2 // FIXME: this is a placeholder and needs to be changed
-  },
-  isMultilingual: false
-};
-const whisperTinyMultilingualModelConfig = {
-  sources: {
-    encoder: WHISPER_TINY_MULTILINGUAL.encoderSource,
-    decoder: WHISPER_TINY_MULTILINGUAL.decoderSource
-  },
-  tokenizer: {
-    source: WHISPER_TINY_MULTILINGUAL.tokenizerSource,
-    bos: 50258,
-    // FIXME: this is a placeholder and needs to be changed
-    eos: 50257 // FIXME: this is a placeholder and needs to be changed
-  },
-  isMultilingual: true
-};
-export const MODEL_CONFIGS = {
-  moonshine: moonshineTinyModelConfig,
-  whisper: whisperTinyModelConfig,
-  whisperMultilingual: whisperTinyMultilingualModelConfig
-};
-export const MODES = {
-  fast: {
-    windowSize: 5,
-    overlapSeconds: 1.2
-  },
-  balanced: {
-    windowSize: 12,
-    overlapSeconds: 2
-  },
-  quality: {
-    windowSize: 24,
-    overlapSeconds: 3
-  }
-};
-export const NUM_TOKENS_TO_TRIM = 3;
-export let STREAMING_ACTION = /*#__PURE__*/function (STREAMING_ACTION) {
-  STREAMING_ACTION[STREAMING_ACTION["START"] = 0] = "START";
-  STREAMING_ACTION[STREAMING_ACTION["DATA"] = 1] = "DATA";
-  STREAMING_ACTION[STREAMING_ACTION["STOP"] = 2] = "STOP";
-  return STREAMING_ACTION;
-}({});
-export { AvailableModels };
-//# sourceMappingURL=sttDefaults.js.map

package/lib/module/constants/sttDefaults.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["MOONSHINE_TINY","WHISPER_TINY","WHISPER_TINY_MULTILINGUAL","AvailableModels","SAMPLE_RATE","SECOND","HAMMING_DIST_THRESHOLD","whisperTinyModelConfig","sources","encoder","encoderSource","decoder","decoderSource","tokenizer","source","tokenizerSource","bos","eos","isMultilingual","moonshineTinyModelConfig","whisperTinyMultilingualModelConfig","MODEL_CONFIGS","moonshine","whisper","whisperMultilingual","MODES","fast","windowSize","overlapSeconds","balanced","quality","NUM_TOKENS_TO_TRIM","STREAMING_ACTION"],"sourceRoot":"../../../src","sources":["constants/sttDefaults.ts"],"mappings":";;AAAA,SACEA,cAAc,EACdC,YAAY,EACZC,yBAAyB,QACpB,aAAa;AACpB,SAASC,eAAe,QAAqB,cAAc;AAE3D,OAAO,MAAMC,WAAW,GAAG,MAAM;AACjC,OAAO,MAAMC,MAAM,GAAGD,WAAW;AACjC,OAAO,MAAME,sBAAsB,GAAG,CAAC;AAEvC,MAAMC,sBAAsB,GAAG;EAC7BC,OAAO,EAAE;IACPC,OAAO,EAAER,YAAY,CAACS,aAAa;IACnCC,OAAO,EAAEV,YAAY,CAACW;EACxB,CAAC;EACDC,SAAS,EAAE;IACTC,MAAM,EAAEb,YAAY,CAACc,eAAe;IACpCC,GAAG,EAAE,KAAK;IAAE;IACZC,GAAG,EAAE,KAAK,CAAE;EACd,CAAC;EACDC,cAAc,EAAE;AAClB,CAAC;AAED,MAAMC,wBAAwB,GAAG;EAC/BX,OAAO,EAAE;IACPC,OAAO,EAAET,cAAc,CAACU,aAAa;IACrCC,OAAO,EAAEX,cAAc,CAACY;EAC1B,CAAC;EACDC,SAAS,EAAE;IACTC,MAAM,EAAEd,cAAc,CAACe,eAAe;IACtCC,GAAG,EAAE,CAAC;IAAE;IACRC,GAAG,EAAE,CAAC,CAAE;EACV,CAAC;EACDC,cAAc,EAAE;AAClB,CAAC;AAED,MAAME,kCAAkC,GAAG;EACzCZ,OAAO,EAAE;IACPC,OAAO,EAAEP,yBAAyB,CAACQ,aAAa;IAChDC,OAAO,EAAET,yBAAyB,CAACU;EACrC,CAAC;EACDC,SAAS,EAAE;IACTC,MAAM,EAAEZ,yBAAyB,CAACa,eAAe;IACjDC,GAAG,EAAE,KAAK;IAAE;IACZC,GAAG,EAAE,KAAK,CAAE;EACd,CAAC;EACDC,cAAc,EAAE;AAClB,CAAC;AAED,OAAO,MAAMG,aAEZ,GAAG;EACFC,SAAS,EAAEH,wBAAwB;EACnCI,OAAO,EAAEhB,sBAAsB;EAC/BiB,mBAAmB,EAAEJ;AACvB,CAAC;AAED,OAAO,MAAMK,KAAK,GAAG;EACnBC,IAAI,EAAE;IACJC,UAAU,EAAE,CAAC;IACbC,cAAc,EAAE;EAClB,CAAC;EACDC,QAAQ,EAAE;IACRF,UAAU,EAAE,EAAE;IACdC,cAAc,EAAE;EAClB,CAAC;EACDE,OAAO,EAAE;IACPH,UAAU,EAAE,EAAE;IACdC,cAAc,EAAE;EAClB;AACF,CAAC;AAED,OAAO,MAAMG,kBAAkB,GAAG,CAAC;AAEnC,WAAYC,gBAAgB,0BAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAA,OAAhBA,gBAAgB;AAAA;AAM5B,SAAS7B,eAAe","ignoreList":[]}