echogarden 1.2.1 → 1.3.1

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/recognition/WhisperSTT.ts

@@ -13,7 +13,7 @@ import { getRawAudioDuration, RawAudio, sliceRawAudio } from '../audio/AudioUtil
 import { readFile } from '../utilities/FileSystem.js'
 import path from 'path'
 import type { LanguageDetectionResults } from '../api/API.js'
-import { getShortLanguageCode, languageCodeToName } from '../utilities/Locale.js'
+import { formatLanguageCodeWithName, getShortLanguageCode, languageCodeToName } from '../utilities/Locale.js'
 import { loadPackage } from '../utilities/PackageManager.js'
 import chalk from 'chalk'
 import { XorShift32RNG } from '../utilities/RandomGenerator.js'
@@ -41,7 +41,7 @@ export async function recognize(
 	sourceLanguage = getShortLanguageCode(sourceLanguage)
 
 	if (!(sourceLanguage in languageIdLookup)) {
-		throw new Error(`The language ${languageCodeToName(sourceLanguage)} is not supported by the Whisper engine.`)
+		throw new Error(`The language ${formatLanguageCodeWithName(sourceLanguage)} is not supported by the Whisper engine.`)
 	}
 
 	if (isEnglishOnlyModel(modelName) && sourceLanguage != 'en') {
@@ -93,7 +93,7 @@ export async function align(
 	sourceLanguage = getShortLanguageCode(sourceLanguage)
 
 	if (!(sourceLanguage in languageIdLookup)) {
-		throw new Error(`The language ${languageCodeToName(sourceLanguage)} is not supported by the Whisper engine.`)
+		throw new Error(`The language ${formatLanguageCodeWithName(sourceLanguage)} is not supported by the Whisper engine.`)
 	}
 
 	if (isEnglishOnlyModel(modelName) && sourceLanguage != 'en') {
@@ -134,7 +134,7 @@ export async function alignEnglishTranslation(
 	sourceLanguage = getShortLanguageCode(sourceLanguage)
 
 	if (!(sourceLanguage in languageIdLookup)) {
-		throw new Error(`The source language ${languageCodeToName(sourceLanguage)} is not supported by the Whisper engine.`)
+		throw new Error(`The source language ${formatLanguageCodeWithName(sourceLanguage)} is not supported by the Whisper engine.`)
 	}
 
 	if (isEnglishOnlyModel(modelName)) {

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/Locale.ts

@@ -22,6 +22,39 @@ export function formatLanguageCodeWithName(languageCode: string, styleId: 1 | 2
 	}
 }
 
+export async function normalizeIdentifierToLangaugeCode(langIdentifier: string) {
+	const result = await parseLangIdentifier(langIdentifier)
+
+	return result.Name
+}
+
+export async function normalizeIdentifierToShortLanguageCode(langIdentifier: string) {
+	const result = await parseLangIdentifier(langIdentifier)
+
+	return result.TwoLetterISOLanguageName
+}
+
+export async function parseLangIdentifier(langIdentifier: string) {
+	if (!langIdentifier) {
+		return emptyLangInfoEntry
+	}
+
+	await loadLangInfoEntriesIfNeeded()
+
+	langIdentifier = langIdentifier.trim().toLowerCase()
+
+	for (const entry of langInfoEntries) {
+		if (langIdentifier === entry.NameLowerCase ||
+			langIdentifier === entry.ThreeLetterISOLanguageName ||
+			langIdentifier === entry.EnglishNameLowerCase) {
+
+			return entry
+		}
+	}
+
+	throw new Error(`Couldn't parse language identifier '${langIdentifier}'.`)
+}
+
 export function getShortLanguageCode(langCode: string) {
 	const dashIndex = langCode.indexOf('-')
 
@@ -48,7 +81,7 @@ export function normalizeLanguageCode(langCode: string) {
 
 const isoToLcidLookup = new Map<string, number>()
 const lcidToIsoLookup = new Map<number, string[]>()
-const lcidEntries: LCIDEntry[] = []
+let langInfoEntries: LangInfoEntry[] = []
 
 export async function isoToLcidLanguageCode(iso: string) {
 	await loadLcidLookupIfNeeded()
@@ -63,19 +96,13 @@ export async function lcidToIsoLanguageCode(lcid: number) {
 }
 
 async function loadLcidLookupIfNeeded() {
-	if (lcidEntries.length > 0) {
-		return lcidEntries
-	}
-
-	const lcidLookup: LCIDLookup = await readAndParseJsonFile(resolveToModuleRootDir('data/tables/lcid-table.json'))
-
-	for (const isoName in lcidLookup) {
-		const lcidEntry = lcidLookup[isoName]
-		lcidEntries.push(lcidEntry)
+	await loadLangInfoEntriesIfNeeded()
 
+	for (const lcidEntry of langInfoEntries) {
+		const name = lcidEntry.Name
 		const lcidValue = lcidEntry.LCID
 
-		isoToLcidLookup.set(isoName, lcidValue)
+		isoToLcidLookup.set(name, lcidValue)
 
 		let entry = lcidToIsoLookup.get(lcidValue)
 
@@ -84,10 +111,25 @@ async function loadLcidLookupIfNeeded() {
 			lcidToIsoLookup.set(lcidValue, entry)
 		}
 
-		entry.push(isoName)
+		entry.push(name)
 	}
 
-	return lcidEntries
+	return langInfoEntries
+}
+
+async function loadLangInfoEntriesIfNeeded() {
+	if (langInfoEntries.length > 0) {
+		return
+	}
+
+	const entries = await readAndParseJsonFile(resolveToModuleRootDir('data/tables/lcid-table.json')) as LangInfoEntry[]
+
+	for (const entry of entries) {
+		entry.NameLowerCase = entry.Name.toLowerCase()
+		entry.EnglishNameLowerCase = entry.EnglishName.toLowerCase()
+
+		langInfoEntries.push(entry)
+	}
 }
 
 export function getDefaultDialectForLanguageCodeIfPossible(langCode: string) {
@@ -107,14 +149,34 @@ export const defaultDialectForLanguageCode: { [lang: string]: string } = {
 	'nl': 'nl-NL'
 }
 
-type LCIDLookup = { [isoLangCode: string]: LCIDEntry }
+export interface LangInfoEntry {
+	LCID: number
+
+	Name: string
+	NameLowerCase: string
+
+	TwoLetterISOLanguageName: string
+	ThreeLetterISOLanguageName: string
+	ThreeLetterWindowsLanguageName: string
+
+	EnglishName: string
+	EnglishNameLowerCase: string
+
+	ANSICodePage: string
+}
+
+export const emptyLangInfoEntry: LangInfoEntry = {
+	LCID: -1,
+
+	Name: '',
+	NameLowerCase: '',
+
+	TwoLetterISOLanguageName: '',
+	ThreeLetterISOLanguageName: '',
+	ThreeLetterWindowsLanguageName: '',
+
+	EnglishName: 'Empty',
+	EnglishNameLowerCase: 'empty',
 
-export interface LCIDEntry {
-	'LCID': number
-	'Name': string
-	'TwoLetterISOLanguageName': string,
-	'ThreeLetterISOLanguageName': string,
-	'ThreeLetterWindowsLanguageName': string,
-	'EnglishName': string
-	'ANSICodePage': string
+	ANSICodePage: ''
 }

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',
 }