echogarden 1.3.0 → 1.3.1

package/src/api/VoiceActivityDetection.ts

@@ -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
@@ -224,6 +223,10 @@ export function convertCroppedToUncroppedTimeline(timeline: Timeline, uncropTime
 function mapUsingUncropTimeline(startTimeInCroppedAudio: number, endTimeInCroppedAudio: number, uncropTimeline: Timeline) {
 	let offsetInCroppedAudio = 0
 
+	if (endTimeInCroppedAudio < startTimeInCroppedAudio) {
+		endTimeInCroppedAudio = startTimeInCroppedAudio
+	}
+
 	let bestOverlapDuration = -1
 	let mappedStartTime = -1
 	let mappedEndTime = -1

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
 }

package/src/codecs/WaveCodec.ts

@@ -18,18 +18,20 @@ export function encodeWave(rawAudio: RawAudio, bitDepth: BitDepth = 16, sampleFo
 
 	const dataSubChunkBuffer = Buffer.alloc(4 + 4 + audioDataLength)
 	dataSubChunkBuffer.write('data', 0, 'ascii')
-	dataSubChunkBuffer.writeUint32LE(audioDataLength, 4)
+	const dataChunkLength = Math.min(audioDataLength, 4294967295) // Ensure large data chunk length is clipped to max
+	dataSubChunkBuffer.writeUint32LE(dataChunkLength, 4)
 	dataSubChunkBuffer.set(audioBuffer, 8)
 
 	const riffChunkHeaderBuffer = Buffer.alloc(12)
 	riffChunkHeaderBuffer.write('RIFF', 0, 'ascii')
-	riffChunkHeaderBuffer.writeUint32LE(4 + formatSubChunkBuffer.length + dataSubChunkBuffer.length, 4)
+	const riffChunkLength = Math.min(4 + formatSubChunkBuffer.length + dataSubChunkBuffer.length, 4294967295) // Ensure large RIFF chunk length is clipped to max
+	riffChunkHeaderBuffer.writeUint32LE(riffChunkLength, 4)
 	riffChunkHeaderBuffer.write('WAVE', 8, 'ascii')
 
 	return Buffer.concat([riffChunkHeaderBuffer, formatSubChunkBuffer, dataSubChunkBuffer])
 }
 
-export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
+export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
 	let readOffset = 0
 
 	const riffId = waveData.subarray(readOffset, readOffset + 4).toString('ascii')
@@ -40,7 +42,7 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 
 	readOffset += 4
 
-	const riffChunkSize = waveData.readUInt32LE(readOffset)
+	let riffChunkSize = waveData.readUInt32LE(readOffset)
 
 	readOffset += 4
 
@@ -50,6 +52,10 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 		throw new Error('Not a valid wave file. No WAVE id found at offset 8.')
 	}
 
+	if (ignoreOverflowingDataChunks && riffChunkSize === 4294967295) {
+		riffChunkSize = waveData.length - 8
+	}
+
 	if (riffChunkSize < waveData.length - 8) {
 		throw new Error(`RIFF chunk length ${riffChunkSize} is smaller than the remaining size of the buffer (${waveData.length - 8})`)
 	}
@@ -67,7 +73,7 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 		const subChunkIdentifier = waveData.subarray(readOffset, readOffset + 4).toString('ascii')
 		readOffset += 4
 
-		const subChunkSize = waveData.readUInt32LE(readOffset)
+		let subChunkSize = waveData.readUInt32LE(readOffset)
 		readOffset += 4
 
 		if (!ignoreTruncatedChunks && subChunkSize > waveData.length - readOffset) {
@@ -81,6 +87,10 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 				throw new Error('A data subchunk was encountered before a format subchunk')
 			}
 
+			if (ignoreOverflowingDataChunks && subChunkSize === 4294967295) {
+				subChunkSize = waveData.length - readOffset
+			}
+
 			// If the data chunk is truncated, but truncations are ignored,
 			// it would be read up to the end of the buffer
 			dataBuffers.push(waveData.subarray(readOffset, readOffset + subChunkSize))

package/src/dsp/SpeexResampler.ts

@@ -1,16 +1,27 @@
 import { RawAudio, cloneRawAudio } from '../audio/AudioUtilities.js'
+import { concatFloat32Arrays } from '../utilities/Utilities.js'
 import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 
 let speexResamplerInstance: any
 
-export async function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: number, quality = 0) {
+export async function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: number, quality = 0): Promise<RawAudio> {
 	const channelCount = rawAudio.audioChannels.length
 	const inSampleRate = rawAudio.sampleRate
 
-	if (inSampleRate == outSampleRate) {
+	const totalSampleCount = rawAudio.audioChannels[0].length
+	const sampleRateRatio = outSampleRate / inSampleRate
+
+	if (inSampleRate === outSampleRate) {
 		return cloneRawAudio(rawAudio)
 	}
 
+	if (totalSampleCount === 0) {
+		return {
+			...cloneRawAudio(rawAudio),
+			sampleRate: outSampleRate
+		} as RawAudio
+	}
+
 	const m = await getSpeexResamplerInstance()
 	const wasmMemory = new WasmMemoryManager(m)
 
@@ -23,48 +34,76 @@ export async function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: numb
 	}
 
 	const initErrRef = wasmMemory.allocInt32()
-	const resamplerState = m._speex_resampler_init(channelCount, inSampleRate, outSampleRate, quality, initErrRef.address)
+	const resamplerStateAddress = m._speex_resampler_init(channelCount, inSampleRate, outSampleRate, quality, initErrRef.address)
 	let resultCode = initErrRef.value
 
 	if (resultCode != 0) {
 		throw new Error(`Speex resampler failed while initializing with code ${resultCode}: ${speexResultCodeToString(resultCode)}`)
 	}
 
-	const resampledAudio: RawAudio = { audioChannels: [], sampleRate: outSampleRate }
+	const inputLatency = m._speex_resampler_get_input_latency(resamplerStateAddress)
+	const outputLatency = m._speex_resampler_get_output_latency(resamplerStateAddress)
+
+	const maxChunkSize = 2 ** 20
+
+	const inputChunkSampleCountRef = wasmMemory.allocInt32()
+	const outputChunkSampleCountRef = wasmMemory.allocInt32()
+
+	const inputChunkSamplesRef = wasmMemory.allocFloat32Array(maxChunkSize * 2)
+	const outputChunkSamplesRef = wasmMemory.allocFloat32Array(Math.floor(maxChunkSize * sampleRateRatio) * 2)
+
+	const resampledAudioChunksForChannels: Float32Array[][] = []
+
+	for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+		resampledAudioChunksForChannels.push([])
+	}
 
 	for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
-		const channelSamples = rawAudio.audioChannels[channelIndex]
+		for (let readOffset = 0; readOffset < totalSampleCount;) {
+			const isLastChunk = readOffset + maxChunkSize >= totalSampleCount
 
-		const inputLatency = m._speex_resampler_get_input_latency(resamplerState)
-		const outputLatency = m._speex_resampler_get_output_latency(resamplerState)
+			const inputPaddingSize = isLastChunk ? inputLatency : 0
+			const maxSamplesToRead = Math.min(maxChunkSize, totalSampleCount - readOffset) + inputPaddingSize
 
-		const inSampleCount = channelSamples.length
-		const inSampleCountRef = wasmMemory.allocInt32()
-		inSampleCountRef.value = inSampleCount + inputLatency
+			const maxSamplesToWrite = outputChunkSamplesRef.length
 
-		const inSamplesRef = wasmMemory.allocFloat32Array(inSampleCountRef.value)
-		inSamplesRef.view.set(channelSamples)
+			const inputChunkSamplesForChannel = rawAudio.audioChannels[channelIndex].slice(readOffset, readOffset + maxSamplesToRead)
 
-		const outSampleCount = Math.floor((inSampleCount / inSampleRate) * outSampleRate)
-		const outSampleCountRef = wasmMemory.allocInt32()
-		outSampleCountRef.value = outSampleCount + outputLatency
+			inputChunkSampleCountRef.value = maxSamplesToRead
+			outputChunkSampleCountRef.value = maxSamplesToWrite
 
-		const outSamplesRef = wasmMemory.allocFloat32Array(outSampleCountRef.value)
+			inputChunkSamplesRef.view.set(inputChunkSamplesForChannel)
+			resultCode = m._speex_resampler_process_float(resamplerStateAddress, channelIndex, inputChunkSamplesRef.address, inputChunkSampleCountRef.address, outputChunkSamplesRef.address, outputChunkSampleCountRef.address)
 
-		resultCode = m._speex_resampler_process_float(resamplerState, channelIndex, inSamplesRef.address, inSampleCountRef.address, outSamplesRef.address, outSampleCountRef.address)
+			if (resultCode != 0) {
+				throw new Error(`Speex resampler failed while resampling with code ${resultCode}: ${speexResultCodeToString(resultCode)}`)
+			}
 
-		if (resultCode != 0) {
-			throw new Error(`Speex resampler failed while resampling with code ${resultCode}: ${speexResultCodeToString(resultCode)}`)
-		}
+			const samplesReadCount = inputChunkSampleCountRef.value
+			const samplesWrittenCount = outputChunkSampleCountRef.value
+
+			const resampledChannelAudio = outputChunkSamplesRef.view.slice(0, samplesWrittenCount)
 
-		const resampledChannelAudio = outSamplesRef.view.slice(outputLatency)
+			resampledAudioChunksForChannels[channelIndex].push(resampledChannelAudio)
 
-		resampledAudio.audioChannels.push(resampledChannelAudio)
+			readOffset += samplesReadCount
+		}
 	}
 
-	m._speex_resampler_destroy(resamplerState)
+	m._speex_resampler_destroy(resamplerStateAddress)
 	wasmMemory.freeAll()
 
+	const resampledAudio: RawAudio = {
+		audioChannels: [],
+		sampleRate: outSampleRate
+	}
+
+	for (let i = 0; i < channelCount; i++) {
+		resampledAudioChunksForChannels[i][0] = resampledAudioChunksForChannels[i][0].slice(outputLatency)
+
+		resampledAudio.audioChannels.push(concatFloat32Arrays(resampledAudioChunksForChannels[i]))
+	}
+
 	return resampledAudio
 }
 

package/src/synthesis/CoquiServerTTS.ts

@@ -21,7 +21,7 @@ export async function synthesize(text: string, speakerId: string | null, serverU
 
 	const waveData = Buffer.from(response.data)
 
-	const rawAudio = decodeWaveToRawAudio(waveData).rawAudio
+	const { rawAudio } = decodeWaveToRawAudio(waveData)
 
 	logger.end()
 

package/src/synthesis/VitsTTS.ts

@@ -52,7 +52,7 @@ export class VitsTTS {
 
 		await this.initializeIfNeeded()
 
-		await logger.startAsync('Prepare for synthesis')
+		await logger.startAsync('Prepare for VITS synthesis')
 
 		const metadata = this.metadata
 		const phonemeMap = this.phonemeMap!
@@ -78,7 +78,7 @@ export class VitsTTS {
 			voice: espeakVoice,
 			useKlatt: false
 		}
-		
+
 		const { referenceSynthesizedAudio, referenceTimeline, fragments, phonemizedFragmentsSubstitutions, phonemizedSentence } = await Espeak.preprocessAndSynthesize(sentence, languageCode, espeakOptions, lexicons)
 
 		if (phonemizedSentence.length == 0) {

package/src/text-translation/NLLBTextTranslation.ts

@@ -0,0 +1,252 @@
+import { Logger } from '../utilities/Logger.js'
+import { loadPackage } from '../utilities/PackageManager.js'
+
+export async function translateText(sourceText: string, sourceLanguage: string, targetLanguage: string) {
+	const logger = new Logger()
+
+	const { AutoTokenizer,  M2M100ForConditionalGeneration } = await import('@echogarden/transformers-nodejs-lite')
+
+	const modelPath = await loadPackage(`xenova-nllb-200-distilled-600M-quantized`)
+
+	const tokenizer = await AutoTokenizer.from_pretrained(modelPath)
+	const model = await M2M100ForConditionalGeneration.from_pretrained(modelPath)
+
+	const config = {
+		src_lang: 'eng_Latn',
+		tgt_lang: 'fra_Latn'
+	}
+
+	const inputs = (tokenizer as any)._build_translation_inputs(sourceText, {
+		padding: true,
+		truncation: true,
+	}, config)
+
+	const result = await model.generate(inputs.input_ids, config)
+
+	logger.log(tokenizer.model.convert_ids_to_tokens(result[0]))
+
+	const inputTokens = tokenizer.model.convert_ids_to_tokens(Array.from(inputs.input_ids.data))
+	const embeddingResult = await model(inputs)
+
+	const lastHiddenState = embeddingResult.last_hidden_state
+
+	const tokenCount = lastHiddenState.dims[1]
+	const embeddingSize = lastHiddenState.dims[2]
+
+	for (let i = 0; i < tokenCount; i++) {
+		const tokenEmbedding = lastHiddenState.data.slice(i * embeddingSize, (i + 1) * embeddingSize)
+
+		const tokenId = inputTokens[i]
+
+		logger.log(`Token ${i} (${tokenId}):`, tokenEmbedding);
+	}
+
+	logger.log(inputTokens)
+}
+
+const languageNameToNLLBCode: Record<string, string> = {
+	'Acehnese (Arabic script)': 'ace_Arab',
+	'Acehnese (Latin script)': 'ace_Latn',
+	'Afrikaans': 'afr_Latn',
+	'Akan': 'aka_Latn',
+	'Amharic': 'amh_Ethi',
+	'Armenian': 'hye_Armn',
+	'Assamese': 'asm_Beng',
+	'Asturian': 'ast_Latn',
+	'Awadhi': 'awa_Deva',
+	'Ayacucho Quechua': 'quy_Latn',
+	'Balinese': 'ban_Latn',
+	'Bambara': 'bam_Latn',
+	'Banjar (Arabic script)': 'bjn_Arab',
+	'Banjar (Latin script)': 'bjn_Latn',
+	'Bashkir': 'bak_Cyrl',
+	'Basque': 'eus_Latn',
+	'Belarusian': 'bel_Cyrl',
+	'Bemba': 'bem_Latn',
+	'Bengali': 'ben_Beng',
+	'Bhojpuri': 'bho_Deva',
+	'Bosnian': 'bos_Latn',
+	'Buginese': 'bug_Latn',
+	'Bulgarian': 'bul_Cyrl',
+	'Burmese': 'mya_Mymr',
+	'Catalan': 'cat_Latn',
+	'Cebuano': 'ceb_Latn',
+	'Central Atlas Tamazight': 'tzm_Tfng',
+	'Central Aymara': 'ayr_Latn',
+	'Central Kanuri (Arabic script)': 'knc_Arab',
+	'Central Kanuri (Latin script)': 'knc_Latn',
+	'Central Kurdish': 'ckb_Arab',
+	'Chhattisgarhi': 'hne_Deva',
+	'Chinese (Simplified)': 'zho_Hans',
+	'Chinese (Traditional)': 'zho_Hant',
+	'Chokwe': 'cjk_Latn',
+	'Crimean Tatar': 'crh_Latn',
+	'Croatian': 'hrv_Latn',
+	'Czech': 'ces_Latn',
+	'Danish': 'dan_Latn',
+	'Dari': 'prs_Arab',
+	'Dutch': 'nld_Latn',
+	'Dyula': 'dyu_Latn',
+	'Dzongkha': 'dzo_Tibt',
+	'Eastern Panjabi': 'pan_Guru',
+	'Eastern Yiddish': 'ydd_Hebr',
+	'Egyptian Arabic': 'arz_Arab',
+	'English': 'eng_Latn',
+	'Esperanto': 'epo_Latn',
+	'Estonian': 'est_Latn',
+	'Ewe': 'ewe_Latn',
+	'Faroese': 'fao_Latn',
+	'Fijian': 'fij_Latn',
+	'Finnish': 'fin_Latn',
+	'Fon': 'fon_Latn',
+	'French': 'fra_Latn',
+	'Friulian': 'fur_Latn',
+	'Galician': 'glg_Latn',
+	'Ganda': 'lug_Latn',
+	'Georgian': 'kat_Geor',
+	'German': 'deu_Latn',
+	'Greek': 'ell_Grek',
+	'Guarani': 'grn_Latn',
+	'Gujarati': 'guj_Gujr',
+	'Haitian Creole': 'hat_Latn',
+	'Halh Mongolian': 'khk_Cyrl',
+	'Hausa': 'hau_Latn',
+	'Hebrew': 'heb_Hebr',
+	'Hindi': 'hin_Deva',
+	'Hungarian': 'hun_Latn',
+	'Icelandic': 'isl_Latn',
+	'Igbo': 'ibo_Latn',
+	'Ilocano': 'ilo_Latn',
+	'Indonesian': 'ind_Latn',
+	'Irish': 'gle_Latn',
+	'Italian': 'ita_Latn',
+	'Japanese': 'jpn_Jpan',
+	'Javanese': 'jav_Latn',
+	'Jingpho': 'kac_Latn',
+	'Kabiyè': 'kbp_Latn',
+	'Kabuverdianu': 'kea_Latn',
+	'Kabyle': 'kab_Latn',
+	'Kamba': 'kam_Latn',
+	'Kannada': 'kan_Knda',
+	'Kashmiri (Arabic script)': 'kas_Arab',
+	'Kashmiri (Devanagari script)': 'kas_Deva',
+	'Kazakh': 'kaz_Cyrl',
+	'Khmer': 'khm_Khmr',
+	'Kikongo': 'kon_Latn',
+	'Kikuyu': 'kik_Latn',
+	'Kimbundu': 'kmb_Latn',
+	'Kinyarwanda': 'kin_Latn',
+	'Korean': 'kor_Hang',
+	'Kyrgyz': 'kir_Cyrl',
+	'Lao': 'lao_Laoo',
+	'Latgalian': 'ltg_Latn',
+	'Ligurian': 'lij_Latn',
+	'Limburgish': 'lim_Latn',
+	'Lingala': 'lin_Latn',
+	'Lithuanian': 'lit_Latn',
+	'Lombard': 'lmo_Latn',
+	'Luba-Kasai': 'lua_Latn',
+	'Luo': 'luo_Latn',
+	'Luxembourgish': 'ltz_Latn',
+	'Macedonian': 'mkd_Cyrl',
+	'Magahi': 'mag_Deva',
+	'Maithili': 'mai_Deva',
+	'Malayalam': 'mal_Mlym',
+	'Maltese': 'mlt_Latn',
+	'Maori': 'mri_Latn',
+	'Marathi': 'mar_Deva',
+	'Meitei (Bengali script)': 'mni_Beng',
+	'Mesopotamian Arabic': 'acm_Arab',
+	'Minangkabau (Arabic script)': 'min_Arab',
+	'Minangkabau (Latin script)': 'min_Latn',
+	'Mizo': 'lus_Latn',
+	'Modern Standard Arabic (Romanized)': 'arb_Latn',
+	'Modern Standard Arabic': 'arb_Arab',
+	'Moroccan Arabic': 'ary_Arab',
+	'Mossi': 'mos_Latn',
+	'Najdi Arabic': 'ars_Arab',
+	'Nepali': 'npi_Deva',
+	'Nigerian Fulfulde': 'fuv_Latn',
+	'North Azerbaijani': 'azj_Latn',
+	'North Levantine Arabic': 'apc_Arab',
+	'Northern Kurdish': 'kmr_Latn',
+	'Northern Sotho': 'nso_Latn',
+	'Northern Uzbek': 'uzn_Latn',
+	'Norwegian Bokmål': 'nob_Latn',
+	'Norwegian Nynorsk': 'nno_Latn',
+	'Nuer': 'nus_Latn',
+	'Nyanja': 'nya_Latn',
+	'Occitan': 'oci_Latn',
+	'Odia': 'ory_Orya',
+	'Pangasinan': 'pag_Latn',
+	'Papiamento': 'pap_Latn',
+	'Plateau Malagasy': 'plt_Latn',
+	'Polish': 'pol_Latn',
+	'Portuguese': 'por_Latn',
+	'Romanian': 'ron_Latn',
+	'Rundi': 'run_Latn',
+	'Russian': 'rus_Cyrl',
+	'Samoan': 'smo_Latn',
+	'Sango': 'sag_Latn',
+	'Sanskrit': 'san_Deva',
+	'Santali': 'sat_Olck',
+	'Sardinian': 'srd_Latn',
+	'Scottish Gaelic': 'gla_Latn',
+	'Serbian': 'srp_Cyrl',
+	'Shan': 'shn_Mymr',
+	'Shona': 'sna_Latn',
+	'Sicilian': 'scn_Latn',
+	'Silesian': 'szl_Latn',
+	'Sindhi': 'snd_Arab',
+	'Sinhala': 'sin_Sinh',
+	'Slovak': 'slk_Latn',
+	'Slovenian': 'slv_Latn',
+	'Somali': 'som_Latn',
+	'South Azerbaijani': 'azb_Arab',
+	'South Levantine Arabic': 'ajp_Arab',
+	'Southern Pashto': 'pbt_Arab',
+	'Southern Sotho': 'sot_Latn',
+	'Southwestern Dinka': 'dik_Latn',
+	'Spanish': 'spa_Latn',
+	'Standard Latvian': 'lvs_Latn',
+	'Standard Malay': 'zsm_Latn',
+	'Standard Tibetan': 'bod_Tibt',
+	'Sundanese': 'sun_Latn',
+	'Swahili': 'swh_Latn',
+	'Swati': 'ssw_Latn',
+	'Swedish': 'swe_Latn',
+	'Tagalog': 'tgl_Latn',
+	'Tajik': 'tgk_Cyrl',
+	'Tamasheq (Latin script)': 'taq_Latn',
+	'Tamasheq (Tifinagh script)': 'taq_Tfng',
+	'Tamil': 'tam_Taml',
+	'Tatar': 'tat_Cyrl',
+	'Ta’izzi-Adeni Arabic': 'acq_Arab',
+	'Telugu': 'tel_Telu',
+	'Thai': 'tha_Thai',
+	'Tigrinya': 'tir_Ethi',
+	'Tok Pisin': 'tpi_Latn',
+	'Tosk Albanian': 'als_Latn',
+	'Tsonga': 'tso_Latn',
+	'Tswana': 'tsn_Latn',
+	'Tumbuka': 'tum_Latn',
+	'Tunisian Arabic': 'aeb_Arab',
+	'Turkish': 'tur_Latn',
+	'Turkmen': 'tuk_Latn',
+	'Twi': 'twi_Latn',
+	'Ukrainian': 'ukr_Cyrl',
+	'Umbundu': 'umb_Latn',
+	'Urdu': 'urd_Arab',
+	'Uyghur': 'uig_Arab',
+	'Venetian': 'vec_Latn',
+	'Vietnamese': 'vie_Latn',
+	'Waray': 'war_Latn',
+	'Welsh': 'cym_Latn',
+	'West Central Oromo': 'gaz_Latn',
+	'Western Persian': 'pes_Arab',
+	'Wolof': 'wol_Latn',
+	'Xhosa': 'xho_Latn',
+	'Yoruba': 'yor_Latn',
+	'Yue Chinese': 'yue_Hant',
+	'Zulu': 'zul_Latn',
+}

package/src/utilities/PackageManager.ts

@@ -182,4 +182,7 @@ const packageVersionTagResolutionLookup: { [packageName: string]: string } = {
 
 	'whisper.cpp-binaries-windows-x64-cublas-12.4.0-latest-patched': '20240409',
 	'whisper.cpp-binaries-windows-x64-cublas-11.8.0-latest-patched': '20240409',
+
+	'xenova-multilingual-e5-small-quantized': '20240504',
+	'xenova-nllb-200-distilled-600M-quantized': '20240505',
 }