echogarden 1.2.1 → 1.3.1

package/src/alignment/TextAlignment.ts

@@ -0,0 +1,96 @@
+import { type PreTrainedModel, type PreTrainedTokenizer } from '@echogarden/transformers-nodejs-lite'
+import { Logger } from '../utilities/Logger.js'
+import { loadPackage } from '../utilities/PackageManager.js'
+
+export async function alignText(text1: string, text2: string) {
+	const logger = new Logger()
+
+	text1 = text1.replaceAll(/(\r?\n)+/g, ' ')
+	text2 = text2.replaceAll(/(\r?\n)+/g, ' ')
+
+	const modelPath = await loadPackage(`xenova-multilingual-e5-small-quantized`)
+
+	const embeddingModel = new E5TextEmbedding(modelPath)
+
+	logger.start(`Initialize E5 embedding model`)
+	await embeddingModel.initializeIfNeeded()
+
+	logger.start(`Tokenize text 1`)
+	const inputs1 = await embeddingModel.tokenizeToModelInputs(text1)
+
+	logger.start(`Infer embeddings for text 1`)
+	const embeddings1 = await embeddingModel.inferTokenEmbeddings(inputs1)
+
+	logger.start(`Tokenize text 2`)
+	const inputs2 = await embeddingModel.tokenizeToModelInputs(text2)
+
+	logger.start(`Infer embeddings for text 2`)
+	const embeddings2 = await embeddingModel.inferTokenEmbeddings(inputs1)
+
+	logger.end()
+
+	logger.log(embeddings1)
+}
+
+export class E5TextEmbedding {
+	tokenizer?: PreTrainedTokenizer
+	model?: PreTrainedModel
+
+	constructor(public readonly modelPath: string) {
+	}
+
+	async tokenizeToModelInputs(text: string) {
+		await this.initializeIfNeeded()
+
+		const inputs = await this.tokenizer!(text)
+
+		return inputs
+	}
+
+	async inferTokenEmbeddings(inputs: any) {
+		await this.initializeIfNeeded()
+
+		const tokensText = this.tokenizer!.model.convert_ids_to_tokens(Array.from(inputs.input_ids.data))
+
+		const result = await this.model!(inputs)
+
+		const lastHiddenState = result.last_hidden_state
+
+		const tokenCount = lastHiddenState.dims[1]
+		const embeddingSize = lastHiddenState.dims[2]
+
+		const tokenEmbeddings: TokenEmbeddingData[] = []
+
+		for (let i = 0; i < tokenCount; i++) {
+			const tokenEmbeddingVector = lastHiddenState.data.slice(i * embeddingSize, (i + 1) * embeddingSize)
+
+			const tokenId = Number(inputs.input_ids.data[i])
+			const tokenText = tokensText[i]
+
+			tokenEmbeddings.push({
+				id: tokenId,
+				text: tokenText,
+				embeddingVector: tokenEmbeddingVector
+			})
+		}
+
+		return tokenEmbeddings
+	}
+
+	async initializeIfNeeded() {
+		if (this.tokenizer && this.model) {
+			return
+		}
+
+		const { AutoTokenizer, AutoModel } = await import('@echogarden/transformers-nodejs-lite')
+
+		this.tokenizer = await AutoTokenizer.from_pretrained(this.modelPath)
+		this.model = await AutoModel.from_pretrained(this.modelPath)
+	}
+}
+
+export interface TokenEmbeddingData {
+	id: number
+	text: string
+	embeddingVector: Float32Array
+}

package/src/api/Alignment.ts

@@ -6,17 +6,22 @@ import { Logger } from '../utilities/Logger.js'
 
 import * as API from './API.js'
 import { Timeline, addTimeOffsetToTimeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
-import { formatLanguageCodeWithName, getDefaultDialectForLanguageCodeIfPossible, getShortLanguageCode, normalizeLanguageCode } from '../utilities/Locale.js'
+import { formatLanguageCodeWithName, getDefaultDialectForLanguageCodeIfPossible, getShortLanguageCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { type WhisperAlignmentOptions } from '../recognition/WhisperSTT.js'
 import chalk from 'chalk'
 import { DtwGranularity, createAlignmentReferenceUsingEspeak } from '../alignment/SpeechAlignment.js'
 import { type SubtitlesConfig } from '../subtitles/Subtitles.js'
 import { type EspeakOptions, defaultEspeakOptions } from '../synthesis/EspeakTTS.js'
 import { isWord } from '../nlp/Segmentation.js'
+import { alignText } from '../alignment/TextAlignment.js'
+import { translateText } from '../text-translation/NLLBTextTranslation.js'
 
 const log = logToStderr
 
 export async function align(input: AudioSourceParam, transcript: string, options: AlignmentOptions): Promise<AlignmentResult> {
+	//await alignText(transcript, transcript)
+	//await translateText(transcript, 'en', 'de')
+
 	const logger = new Logger()
 
 	const startTimestamp = logger.getTimestamp()
@@ -38,8 +43,10 @@ export async function align(input: AudioSourceParam, transcript: string, options
 		logger.end()
 		logger.log(``)
 
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1)
 	} else {
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
 	}
 
@@ -52,7 +59,7 @@ export async function align(input: AudioSourceParam, transcript: string, options
 		logger.end()
 	}
 
-	logger.start('Prepare for alignment')
+	logger.start('Normalize and trim audio')
 
 	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
@@ -69,17 +76,25 @@ export async function align(input: AudioSourceParam, transcript: string, options
 		}
 	}
 
+	logger.end()
+
 	let language: string
 
 	if (options.language) {
-		language = normalizeLanguageCode(options.language!)
+		const languageData = await parseLangIdentifier(options.language)
+
+		language = languageData.Name
+
+		logger.logTitledMessage('Language specified', formatLanguageCodeWithName(language))
 	} else {
 		logger.start('No language specified. Detecting language')
 		const { detectedLanguage } = await API.detectTextLanguage(transcript, options.languageDetection || {})
+
 		language = detectedLanguage
 
 		logger.end()
-		logger.logTitledMessage('Language detected', formatLanguageCodeWithName(detectedLanguage))
+
+		logger.logTitledMessage('Language detected', formatLanguageCodeWithName(language))
 	}
 
 	language = getDefaultDialectForLanguageCodeIfPossible(language)

package/src/api/Denoising.ts

@@ -14,8 +14,6 @@ export async function denoise(input: AudioSourceParam, options: DenoisingOptions
 	const logger = new Logger()
 	const startTime = logger.getTimestamp()
 
-	logger.start('Prepare for denoising')
-
 	options = extendDeep(defaultDenoisingOptions, options)
 
 	const inputRawAudio = await ensureRawAudio(input)

package/src/api/LanguageDetection.ts

@@ -28,6 +28,7 @@ export async function detectSpeechLanguage(input: AudioSourceParam, options: Spe
 
 	const inputRawAudio = await ensureRawAudio(input)
 
+	logger.start(`Resample audio to 16kHz mono`)
 	let sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
 	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
@@ -39,13 +40,11 @@ export async function detectSpeechLanguage(input: AudioSourceParam, options: Spe
 		logger.end()
 	}
 
-	logger.start('Prepare for speech language detection')
+	logger.start(`Initialize ${options.engine} module`)
 
 	const defaultLanguage = options.defaultLanguage!
 	const fallbackThresholdProbability = options.fallbackThresholdProbability!
 
-	logger.start(`Initialize ${options.engine} module`)
-
 	let detectedLanguageProbabilities: LanguageDetectionResults
 
 	switch (options.engine) {

package/src/api/Recognition.ts

@@ -6,7 +6,7 @@ import { Logger } from '../utilities/Logger.js'
 
 import * as API from './API.js'
 import { Timeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
-import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode } from '../utilities/Locale.js'
+import { formatLanguageCodeWithName, parseLangIdentifier } from '../utilities/Locale.js'
 import { loadPackage } from '../utilities/PackageManager.js'
 import chalk from 'chalk'
 
@@ -41,8 +41,10 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 		logger.end()
 		logger.log(``)
 
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1)
 	} else {
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
 	}
 
@@ -55,31 +57,34 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 		logger.end()
 	}
 
-	logger.start('Prepare for recognition')
+	logger.start('Normalize and trim audio')
 
 	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
 
 	const engine = options.engine!
 
-	if (!options.language) { // && options.engine != 'whisper') {
-		logger.start('No language specified. Detecting speech language')
-		const { detectedLanguage } = await API.detectSpeechLanguage(sourceRawAudio, options.languageDetection!)
+	if (options.language) {
+		const languageData = await parseLangIdentifier(options.language)
 
-		logger.end()
-		logger.logTitledMessage('Language detected', formatLanguageCodeWithName(detectedLanguage))
+		options.language = languageData.Name
 
-		options.language = detectedLanguage
-	} else {
 		logger.end()
+		logger.logTitledMessage('Language specified', formatLanguageCodeWithName(options.language))
+	} else {
+		logger.start('No language specified. Detecting speech language')
+		const { detectedLanguage } = await API.detectSpeechLanguage(sourceRawAudio, options.languageDetection!)
 
-		const specifiedLanguageFormatted = formatLanguageCodeWithName(getShortLanguageCode(normalizeLanguageCode(options.language)))
+		options.language = detectedLanguage
 
-		logger.logTitledMessage('Language specified', specifiedLanguageFormatted)
+		logger.end()
+		logger.logTitledMessage('Language detected', formatLanguageCodeWithName(detectedLanguage))
 	}
 
-	const languageCode = normalizeLanguageCode(options.language)
-	const shortLanguageCode = getShortLanguageCode(languageCode)
+	const languageData = await parseLangIdentifier(options.language)
+
+	const languageCode = languageData.Name
+	const shortLanguageCode = languageData.TwoLetterISOLanguageName
 
 	let transcript: string
 	let timeline: Timeline | undefined

package/src/api/Synthesis.ts

@@ -15,7 +15,7 @@ import { loadLexiconsForLanguage } from '../nlp/Lexicon.js'
 import * as API from './API.js'
 import { Timeline, TimelineEntry, addTimeOffsetToTimeline, multiplyTimelineByFactor } from '../utilities/Timeline.js'
 import { getAppDataDir, ensureDir, existsSync, isFileIsUpToDate, readAndParseJsonFile, writeFileSafe } from '../utilities/FileSystem.js'
-import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode, defaultDialectForLanguageCode } from '../utilities/Locale.js'
+import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode, defaultDialectForLanguageCode, parseLangIdentifier, normalizeIdentifierToLangaugeCode } from '../utilities/Locale.js'
 import { loadPackage } from '../utilities/PackageManager.js'
 import { EngineMetadata, appName } from './Common.js'
 import { shouldCancelCurrentTask } from '../server/Worker.js'
@@ -301,7 +301,7 @@ async function synthesizeSegment(text: string, options: SynthesisOptions) {
 
 	const startTimestamp = logger.getTimestamp()
 
-	logger.start('Prepare for synthesis')
+	logger.start('Prepare text for synthesis')
 
 	const simplifiedText = simplifyPunctuationCharacters(text)
 
@@ -328,7 +328,15 @@ async function synthesizeSegment(text: string, options: SynthesisOptions) {
 	logger.start(`Initialize ${engine} module`)
 
 	const voice = selectedVoice.name
-	const language = options.language ? normalizeLanguageCode(options.language) : selectedVoice.languages[0]
+
+	let language: string
+
+	if (options.language) {
+		language = await normalizeIdentifierToLangaugeCode(options.language)
+	} else {
+		language = selectedVoice.languages[0]
+	}
+
 	const voiceGender = selectedVoice.gender
 
 	const speed = clip(options.speed!, 0.1, 10.0)
@@ -1548,7 +1556,7 @@ export async function requestVoiceList(options: VoiceListRequestOptions): Promis
 		voiceList = await loadVoiceList()
 	}
 
-	const languageCode = normalizeLanguageCode(options.language || '')
+	const languageCode = await normalizeIdentifierToLangaugeCode(options.language || '')
 
 	if (languageCode) {
 		let filteredVoiceList = voiceList.filter(voice => voice.languages.includes(languageCode))
@@ -1611,7 +1619,7 @@ export interface RequestVoiceListResult {
 }
 
 export async function selectBestOfflineEngineForLanguage(language: string): Promise<SynthesisEngine> {
-	language = normalizeLanguageCode(language)
+	language = await normalizeIdentifierToLangaugeCode(language)
 
 	const VitsTTS = await import('../synthesis/VitsTTS.js')
 
@@ -1621,22 +1629,6 @@ export async function selectBestOfflineEngineForLanguage(language: string): Prom
 		return 'vits'
 	}
 
-	const FliteTTS = await import('../synthesis/FliteTTS.js')
-
-	const fliteLanguages = getAllLangCodesFromVoiceList(FliteTTS.voiceList)
-
-	if (fliteLanguages.includes(language)) {
-		return 'flite'
-	}
-
-	const SvoxPicoTTS = await import('../synthesis/SvoxPicoTTS.js')
-
-	const picoLanguages = getAllLangCodesFromVoiceList(SvoxPicoTTS.voiceList)
-
-	if (picoLanguages.includes(language)) {
-		return 'pico'
-	}
-
 	return 'espeak'
 }
 

package/src/api/Translation.ts

@@ -6,7 +6,7 @@ import { Logger } from '../utilities/Logger.js'
 
 import { Timeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
 import { type WhisperOptions } from '../recognition/WhisperSTT.js'
-import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode } from '../utilities/Locale.js'
+import { formatLanguageCodeWithName, getShortLanguageCode, normalizeIdentifierToLangaugeCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { EngineMetadata } from './Common.js'
 import { type SpeechLanguageDetectionOptions, detectSpeechLanguage } from './API.js'
 import chalk from 'chalk'
@@ -43,8 +43,10 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 		logger.end()
 		logger.log(``)
 
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1)
 	} else {
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
 	}
 
@@ -57,33 +59,36 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 		logger.end()
 	}
 
-	logger.start('Prepare for speech translation')
+	logger.start('Normalize and trim audio')
 
 	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
 
-	if (!options.sourceLanguage) {
-		logger.start('No source language specified. Detecting speech language')
-		const { detectedLanguage } = await detectSpeechLanguage(sourceRawAudio, options.languageDetection || {})
+	if (options.sourceLanguage) {
+		const languageData = await parseLangIdentifier(options.sourceLanguage)
 
-		logger.end()
-		logger.logTitledMessage('Source language detected', formatLanguageCodeWithName(detectedLanguage))
+		options.sourceLanguage = languageData.Name
 
-		options.sourceLanguage = detectedLanguage
-	} else {
 		logger.end()
+		logger.logTitledMessage('Source language specified', formatLanguageCodeWithName(options.sourceLanguage))
+	} else {
+		logger.start('No source language specified. Detecting speech language')
+		const { detectedLanguage } = await detectSpeechLanguage(sourceRawAudio, options.languageDetection || {})
 
-		const specifiedLanguageFormatted = formatLanguageCodeWithName(getShortLanguageCode(normalizeLanguageCode(options.sourceLanguage)))
+		options.sourceLanguage = detectedLanguage
 
-		logger.logTitledMessage('Source language', specifiedLanguageFormatted)
+		logger.end()
+		logger.logTitledMessage('Source language detected', formatLanguageCodeWithName(detectedLanguage))
 	}
 
-	logger.logTitledMessage('Target language', formatLanguageCodeWithName(getShortLanguageCode(normalizeLanguageCode(options.targetLanguage!))))
+	options.targetLanguage = await normalizeIdentifierToLangaugeCode(options.targetLanguage!)
+
+	logger.logTitledMessage('Target language', formatLanguageCodeWithName(options.targetLanguage))
 
 	logger.start('Preprocess audio for translation')
 
 	const engine = options.engine!
-	const sourceLanguage = normalizeLanguageCode(options.sourceLanguage!)
+	const sourceLanguage = options.sourceLanguage!
 	const targetLanguage = options.targetLanguage!
 
 	let transcript: string
@@ -119,10 +124,6 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 
 			({ transcript, timeline: wordTimeline } = await WhisperSTT.recognize(sourceRawAudio, modelName, modelDir, 'translate', sourceLanguage, whisperOptions))
 
-			addWordTextOffsetsToTimeline(wordTimeline, transcript);
-
-			({ segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, targetLanguage, 'single', 'preserve'))
-
 			break
 		}
 
@@ -155,9 +156,7 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 				modelName,
 				modelPath,
 				whisperCppOptions,
-			));
-
-			({ segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, targetLanguage, 'single', 'preserve'))
+			))
 
 			break
 		}
@@ -194,13 +193,21 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 
 	// If the audio was cropped before recognition, map the timestamps back to the original audio
 	if (sourceUncropTimeline && sourceUncropTimeline.length > 0) {
-		API.convertCroppedToUncroppedTimeline(segmentTimeline, sourceUncropTimeline)
-
 		if (wordTimeline) {
 			API.convertCroppedToUncroppedTimeline(wordTimeline, sourceUncropTimeline)
+		} else if (segmentTimeline) {
+			API.convertCroppedToUncroppedTimeline(segmentTimeline, sourceUncropTimeline)
 		}
 	}
 
+	if (wordTimeline) {
+		addWordTextOffsetsToTimeline(wordTimeline, transcript)
+	}
+
+	if (!segmentTimeline) {
+		({ segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline!, transcript, targetLanguage, 'single', 'preserve'))
+	}
+
 	logger.log('')
 	logger.logDuration(`Total speech translation time`, startTimestamp, chalk.magentaBright)
 

package/src/api/TranslationAlignment.ts

@@ -6,7 +6,7 @@ import { Logger } from '../utilities/Logger.js'
 
 import * as API from './API.js'
 import { Timeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
-import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode } from '../utilities/Locale.js'
+import { formatLanguageCodeWithName, getShortLanguageCode, normalizeIdentifierToLangaugeCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { type WhisperAlignmentOptions } from '../recognition/WhisperSTT.js'
 import chalk from 'chalk'
 import { type SubtitlesConfig } from '../subtitles/Subtitles.js'
@@ -35,8 +35,10 @@ export async function alignTranslation(input: AudioSourceParam, transcript: stri
 		logger.end()
 		logger.log(``)
 
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1)
 	} else {
+		logger.start(`Resample audio to 16kHz mono`)
 		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
 	}
 
@@ -49,26 +51,35 @@ export async function alignTranslation(input: AudioSourceParam, transcript: stri
 		logger.end()
 	}
 
-	logger.start('Prepare for alignment')
+	logger.start('Normalize and trim audio')
 
 	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
 
+	logger.end()
+
 	let sourceLanguage: string
 
 	if (options.sourceLanguage) {
-		sourceLanguage = normalizeLanguageCode(options.sourceLanguage!)
+		const languageData = await parseLangIdentifier(options.sourceLanguage)
+
+		sourceLanguage = languageData.Name
+
+		logger.end()
+		logger.logTitledMessage('Source language specified', formatLanguageCodeWithName(sourceLanguage))
 	} else {
 		logger.start('No source language specified. Detecting speech language')
 		const { detectedLanguage } = await API.detectSpeechLanguage(sourceRawAudio, options.languageDetection || {})
 
+		sourceLanguage = detectedLanguage
+
 		logger.end()
 		logger.logTitledMessage('Source language detected', formatLanguageCodeWithName(detectedLanguage))
-
-		sourceLanguage = detectedLanguage
 	}
 
-	const targetLanguage = normalizeLanguageCode(options.targetLanguage!)
+	const targetLanguage = await normalizeIdentifierToLangaugeCode(options.targetLanguage!)
+
+	logger.logTitledMessage('Target language', formatLanguageCodeWithName(targetLanguage))
 
 	let mappedTimeline: Timeline
 

package/src/api/VoiceActivityDetection.ts

@@ -1,6 +1,6 @@
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
-import { logToStderr } from '../utilities/Utilities.js'
+import { logToStderr, roundToDigits } from '../utilities/Utilities.js'
 import { AudioSourceParam, RawAudio, cropToTimeline, ensureRawAudio, } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
@@ -20,16 +20,15 @@ export async function detectVoiceActivity(input: AudioSourceParam, options: VADO
 
 	const startTimestamp = logger.getTimestamp()
 
-	logger.start('Prepare for voice activity detection')
-
 	const inputRawAudio = await ensureRawAudio(input)
 
+	logger.start(`Resample audio to 16kHz mono`)
 	let sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
 
-	options = extendDeep(defaultVADOptions, options)
-
 	logger.start(`Detect voice activity with ${options.engine}`)
 
+	options = extendDeep(defaultVADOptions, options)
+
 	const activityThreshold = options.activityThreshold!
 
 	let verboseTimeline: Timeline
@@ -191,38 +190,73 @@ function frameProbabilitiesToTimeline(frameProbabilities: number[], frameDuratio
 }
 
 export function convertCroppedToUncroppedTimeline(timeline: Timeline, uncropTimeline: Timeline) {
+	if (timeline.length === 0) {
+		return
+	}
+
 	for (const entry of timeline) {
-		entry.startTime = mapTimestampUsingUncropTimeline(entry.startTime, uncropTimeline).time
-		entry.endTime = mapTimestampUsingUncropTimeline(entry.endTime, uncropTimeline).time
+		const {
+			mappedStartTime,
+			mappedEndTime
+		} = mapUsingUncropTimeline(entry.startTime, entry.endTime, uncropTimeline)
+
+		const mapSubTimeline = (subTimeline: Timeline | undefined) => {
+			if (!subTimeline) {
+				return
+			}
+
+			for (const subEntry of subTimeline) {
+				subEntry.startTime = Math.min(mappedStartTime + (subEntry.startTime - entry.startTime), mappedEndTime)
+				subEntry.endTime = Math.min(mappedStartTime + (subEntry.endTime - entry.startTime), mappedEndTime)
 
-		if (entry.timeline) {
-			convertCroppedToUncroppedTimeline(entry.timeline, uncropTimeline)
+				mapSubTimeline(subEntry.timeline)
+			}
 		}
+
+		mapSubTimeline(entry.timeline)
+
+		entry.startTime = mappedStartTime
+		entry.endTime = mappedEndTime
 	}
 }
 
-export function mapTimestampUsingUncropTimeline(timeInCroppedAudio: number, uncropTimeline: Timeline) {
+function mapUsingUncropTimeline(startTimeInCroppedAudio: number, endTimeInCroppedAudio: number, uncropTimeline: Timeline) {
 	let offsetInCroppedAudio = 0
 
-	for (let i = 0; i < uncropTimeline.length; i++) {
-		const entry = uncropTimeline[i]
+	if (endTimeInCroppedAudio < startTimeInCroppedAudio) {
+		endTimeInCroppedAudio = startTimeInCroppedAudio
+	}
 
-		const entryDuration = entry.endTime - entry.startTime
+	let bestOverlapDuration = -1
+	let mappedStartTime = -1
+	let mappedEndTime = -1
 
-		const endOffset = offsetInCroppedAudio + entryDuration
+	for (const uncropEntry of uncropTimeline) {
+		const uncropEntryDuration = uncropEntry.endTime - uncropEntry.startTime
 
-		if ((i === uncropTimeline.length - 1) ||
-			(timeInCroppedAudio >= offsetInCroppedAudio && timeInCroppedAudio < endOffset)) {
-			return {
-				time: entry.startTime + (timeInCroppedAudio - offsetInCroppedAudio),
-				entryIndex: i
-			}
+		const overlapStartTime = Math.max(startTimeInCroppedAudio, offsetInCroppedAudio)
+		const overlapEndTime = Math.min(endTimeInCroppedAudio, offsetInCroppedAudio + uncropEntryDuration)
+
+		const overlapDuration = overlapEndTime - overlapStartTime
+
+		if (overlapDuration >= 0 && overlapDuration > bestOverlapDuration) {
+			bestOverlapDuration = overlapDuration
+
+			mappedStartTime = uncropEntry.startTime + (overlapStartTime - offsetInCroppedAudio)
+			mappedEndTime = uncropEntry.startTime + (overlapEndTime - offsetInCroppedAudio)
 		}
 
-		offsetInCroppedAudio += entryDuration
+		offsetInCroppedAudio += uncropEntryDuration
+	}
+
+	if (bestOverlapDuration === -1) {
+		throw new Error(`No match found in uncrop timeline (should not occur)`)
 	}
 
-	throw new Error(`Should not be reached`)
+	return {
+		mappedStartTime,
+		mappedEndTime
+	}
 }
 
 export interface VADResult {

package/src/audio/AudioUtilities.ts

@@ -11,8 +11,8 @@ export function encodeRawAudioToWave(rawAudio: RawAudio, bitDepth: BitDepth = 16
 	return encodeWave(rawAudio, bitDepth, sampleFormat, speakerPositionMask)
 }
 
-export function decodeWaveToRawAudio(waveFileBuffer: Buffer, ignoreTruncatedChunks = false) {
-	return decodeWave(waveFileBuffer, ignoreTruncatedChunks)
+export function decodeWaveToRawAudio(waveFileBuffer: Buffer, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
+	return decodeWave(waveFileBuffer, ignoreTruncatedChunks, ignoreOverflowingDataChunks)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////

package/src/cli/CLILauncher.ts

@@ -12,9 +12,8 @@ const scriptArgs = process.argv.slice(2)
 const cliScriptPath = resolveToModuleRootDir('dist/cli/CLIStarter.js')
 
 const args = [
-	'--no-warnings',
-	'--no-experimental-fetch',
 	'--experimental-wasi-unstable-preview1',
+	'--no-warnings',
 	cliScriptPath,
 	...scriptArgs
 ]

package/src/codecs/FFMpegTranscoder.ts

@@ -37,7 +37,11 @@ export async function decodeToChannels(input: string | Buffer, outSampleRate?: n
 
 	const waveAudio = await transcode(input, outputOptions)
 
-	const { rawAudio } = decodeWaveToRawAudio(waveAudio, true)
+	const logger = new Logger()
+
+	logger.start(`Convert wave buffer to raw audio`)
+	const { rawAudio } = decodeWaveToRawAudio(waveAudio)
+	logger.end()
 
 	return rawAudio
 }