echogarden 1.4.3 → 1.5.0

package/docs/Options.md

@@ -271,7 +271,8 @@ Applies to CLI operation: `align-translation`, API method: `alignTranslation`
 
 **General**:
 * `engine`: alignment algorithm to use, can only be `whisper`. Defaults to `whisper`
-* `language`: language code for the source audio ([ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)), like `en`, `fr`, `zh`, etc. Auto-detected from audio if not set
+* `sourceLanguage`: language code for the source audio ([ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)), like `en`, `fr`, `zh`, etc. Auto-detected from audio if not set
+* `targetLanguage`: language code for the translated transcript. Can only be `en` for now. Defaults to `en`
 * `crop`: crop to active parts using voice activity detection before starting. Defaults to `true`
 * `isolate`: apply source separation to isolate voice before starting alignment. Defaults to `false`
 * `subtitles`: prefix to provide options for subtitles. Options detailed in section for subtitles
@@ -284,6 +285,37 @@ Applies to CLI operation: `align-translation`, API method: `alignTranslation`
 * `whisper.encoderProvider`: encoder ONNX execution provider. See details in recognition section above
 * `whisper.decoderProvider`: decoder ONNX execution provider. See details in recognition section above
 
+## Speech-to-transcript-and-translation alignment
+
+Applies to CLI operation: `align-transcript-and-translation`, API method: `alignTranscriptAndTranslation`
+
+**General**:
+* `engine`: can only be `two-stage`. Defaults to `two-stage`
+* `sourceLanguage`: language code for the source audio ([ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)), like `en`, `fr`, `zh`, etc. Auto-detected from audio if not set
+* `targetLanguage`: language code for the translated transcript. Can only be `en` for now. Defaults to `en`
+* `crop`: crop to active parts using voice activity detection before starting. Defaults to `true`
+* `isolate`: apply source separation to isolate voice before starting alignment. Defaults to `false`
+* `alignment`: prefix to provide options for alignment. Options detailed in section for alignment
+* `timelineAlignment`: prefix to provide options for timeline alignment. Options detailed in section for timeline alignment
+* `vad`: prefix to provide options for voice activity detection when `crop` is set to `true`. Options detailed in section for voice activity detection
+* `sourceSeparation`: prefix to provide options for source separation when `isolate` is set to `true`. Options detailed in section for source separation
+* `subtitles`: prefix to provide options for subtitles. Options detailed in section for subtitles
+
+## Timeline-to-translated-text alignment
+
+Applies to CLI operation: `align-timeline-translation`, API method: `alignTimelineTranslation`
+
+**General**:
+* `engine`: alignment engine to use. Can only be `e5`. Defaults to `e5`
+* `sourceLanguage`: language code for the source timeline. Auto-detected from timeline if not set
+* `targetLanguage`: language code for the translated transcript. Auto-detected if not set
+* `audio`: spoken audio to play when previewing the result in the CLI (not required or used by the alignment itself). Optional
+* `languageDetection`: prefix to provide options for language detection. Options detailed in section for text language detection
+* `subtitles`: prefix to provide options for subtitles. Options detailed in section for subtitles
+
+**E5**:
+* `e5.model`: E5 model to use. Defaults to `e5-small-fp16` (support for additional models will be added in the future)
+
 ## Language detection
 
 ### Speech language detection

package/docs/Tasklist.md

@@ -5,7 +5,6 @@
 ### Alignment / DTW-RA
 
 * In DTW-RA, a recognized transcript including something like "Question 2.What does Juan", where "2.What" has a point in the middle, is breaking playback of the timeline
-* DTW-RA will not work correctly with Polish language texts, due to issues with the eSpeak engine pronouncing `|` characters, which are intended to be used as separators and ignored by all other eSpeak languages
 
 ### Synthesis
 
@@ -159,6 +158,10 @@
 
 ### Alignment
 
+### Alignment / DTW
+* Accept percentages like `20%` in the `windowDuration` option
+* For the `granularity` option, add more granularities like `xxx-low` and `xxxx-low` (should the naming be changed? Maybe transition to a new naming scheme?)
+
 ### Alignment / DTW-RA
 
 ### Alignment / Whisper

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "echogarden",
-	"version": "1.4.3",
+	"version": "1.5.0",
 	"description": "An easy-to-use speech toolset. Includes tools for synthesis, recognition, alignment, speech translation, language detection, source separation and more.",
 	"author": "Rotem Dan",
 	"license": "GPL-3.0",
@@ -55,8 +55,8 @@
 		"echogarden": "./dist/cli/CLILauncher.js"
 	},
 	"dependencies": {
-		"@aws-sdk/client-polly": "^3.574.0",
-		"@aws-sdk/client-transcribe-streaming": "^3.574.0",
+		"@aws-sdk/client-polly": "^3.583.0",
+		"@aws-sdk/client-transcribe-streaming": "^3.583.0",
 		"@echogarden/espeak-ng-emscripten": "^0.1.2",
 		"@echogarden/fasttext-wasm": "^0.1.0",
 		"@echogarden/flite-wasi": "^0.1.1",
@@ -76,24 +76,24 @@
 		"command-exists": "^1.2.9",
 		"compromise": "^14.13.0",
 		"fs-extra": "^11.2.0",
-		"gaxios": "^6.5.0",
+		"gaxios": "^6.6.0",
 		"graceful-fs": "^4.2.11",
 		"html-escaper": "^3.0.3",
 		"html-to-text": "^9.0.5",
 		"import-meta-resolve": "^4.1.0",
-		"jieba-wasm": "^0.0.2",
-		"jsdom": "^24.0.0",
+		"jieba-wasm": "^1.0.0",
+		"jsdom": "^24.1.0",
 		"json5": "^2.2.3",
 		"kuromoji": "^0.1.2",
 		"microsoft-cognitiveservices-speech-sdk": "^1.36.0",
 		"moving-median": "^1.0.0",
 		"msgpack-lite": "^0.1.26",
-		"onnxruntime-node": "^1.17.3",
-		"openai": "^4.45.0",
+		"onnxruntime-node": "^1.18.0",
+		"openai": "^4.47.1",
 		"sam-js": "^0.2.1",
 		"strip-ansi": "^7.1.0",
 		"tar": "^7.1.0",
-		"tiktoken": "^1.0.14",
+		"tiktoken": "^1.0.15",
 		"tinyld": "^1.3.4",
 		"ws": "^8.17.0",
 		"wtf_wikipedia": "^10.3.1"
@@ -120,11 +120,11 @@
 		"@types/graceful-fs": "^4.1.9",
 		"@types/jsdom": "^21.1.6",
 		"@types/msgpack-lite": "^0.1.11",
-		"@types/node": "^20.12.11",
+		"@types/node": "^20.12.12",
 		"@types/recursive-readdir": "^2.2.4",
 		"@types/tar": "^6.1.13",
 		"@types/ws": "^8.5.10",
-		"ts-json-schema-generator": "^2.1.2-next.1",
+		"ts-json-schema-generator": "^2.2.0",
 		"typescript": "^5.4.5"
 	}
 }

package/src/alignment/DTWMfccSequenceAlignment.ts

@@ -1,21 +1,27 @@
-import { cosineDistancePrecomputedMagnitudes, createVectorForIntegerRange, euclidianDistance, magnitude } from '../math/VectorMath.js'
+import { cosineDistancePrecomputedMagnitudes, createVectorForIntegerRange, euclidianDistance, euclidianDistance13Dim, magnitude } from '../math/VectorMath.js'
 import { logToStderr } from '../utilities/Utilities.js'
 import { alignDTWWindowed } from './DTWSequenceAlignmentWindowed.js'
 
 const log = logToStderr
 
-export async function alignMFCC_DTW(mfccFrames1: number[][], mfccFrames2: number[][], windowLength: number, distanceFunction: 'euclidian' | 'cosine' = 'euclidian', centerIndexes?: number[]) {
-	if (distanceFunction == 'euclidian') {
+export async function alignMFCC_DTW(mfccFrames1: number[][], mfccFrames2: number[][], windowLength: number, distanceFunctionKind: 'euclidian' | 'cosine' = 'euclidian', centerIndexes?: number[]) {
+	if (distanceFunctionKind == 'euclidian') {
+		let distanceFunction = euclidianDistance
+
+		if (mfccFrames1.length > 0 && mfccFrames1[0].length === 13) {
+			distanceFunction = euclidianDistance13Dim
+		}
+
 		const { path } = alignDTWWindowed(
 			mfccFrames1,
 			mfccFrames2,
-			euclidianDistance,
+			distanceFunction,
 			windowLength,
 			centerIndexes
 		)
 
 		return path
-	} else if (distanceFunction == 'cosine') {
+	} else if (distanceFunctionKind == 'cosine') {
 		const indexes1 = createVectorForIntegerRange(0, mfccFrames1.length)
 		const indexes2 = createVectorForIntegerRange(0, mfccFrames2.length)
 

package/src/alignment/DTWSequenceAlignmentWindowed.ts

@@ -93,7 +93,7 @@ function computeAccumulatedCostMatrixTransposed<T, U>(sequence1: T[], sequence2:
 		// and left column's window offset
 		const windowOffsetDelta = windowStartOffset - windowStartOffsets[columnIndex - 1]
 
-		// Iterate over all rows in the window
+		// Compute the accumulated cost for all rows in the window
 		for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
 			// Compute the cost for current cell
 			const cost = costFunction(targetSequence1Value, sequence2[windowStartOffset + rowIndex])
@@ -167,7 +167,7 @@ function computeBestPathTransposed(accumulatedCostMatrixTransposed: Float32Array
 		let upCost = Infinity
 
 		if (upRowIndex >= 0) {
-			upCost = accumulatedCostMatrixTransposed[columnIndex][upRowIndex] // insertion
+			upCost = accumulatedCostMatrixTransposed[columnIndex][upRowIndex]
 		}
 
 		// Retrieve the cost for the 'left' (deletion) neighbor
@@ -176,7 +176,7 @@ function computeBestPathTransposed(accumulatedCostMatrixTransposed: Float32Array
 		let leftCost = Infinity
 
 		if (leftColumnIndex >= 0 && leftRowIndex < rowCount) {
-			leftCost = accumulatedCostMatrixTransposed[leftColumnIndex][leftRowIndex] // deletion
+			leftCost = accumulatedCostMatrixTransposed[leftColumnIndex][leftRowIndex]
 		}
 
 		// Retrieve the cost for the 'up and left' (match) neighbor
@@ -185,7 +185,7 @@ function computeBestPathTransposed(accumulatedCostMatrixTransposed: Float32Array
 		let upAndLeftCost = Infinity
 
 		if (upAndLeftColumnIndex >= 0 && upAndLeftRowIndex >= 0 && upAndLeftRowIndex < rowCount) {
-			upAndLeftCost = accumulatedCostMatrixTransposed[upAndLeftColumnIndex][upAndLeftRowIndex] // match
+			upAndLeftCost = accumulatedCostMatrixTransposed[upAndLeftColumnIndex][upAndLeftRowIndex]
 		}
 
 		// If all neighbors have a cost of infinity, it means

package/src/alignment/SemanticTextAlignment.ts

@@ -0,0 +1,467 @@
+import { type PreTrainedModel, type PreTrainedTokenizer } from '@echogarden/transformers-nodejs-lite'
+import { Logger } from '../utilities/Logger.js'
+import { loadPackage } from '../utilities/PackageManager.js'
+import { alignDTWWindowed } from './DTWSequenceAlignmentWindowed.js'
+import { cosineDistance } from '../math/VectorMath.js'
+import { isPunctuation, isWord, splitToSentences, splitToWords } from '../nlp/Segmentation.js'
+import { Timeline, extractEntries } from '../utilities/Timeline.js'
+
+export async function alignTimelineToTextSemantically(timeline: Timeline, text: string, textLangCode: string) {
+	const logger = new Logger()
+
+	logger.start(`Prepare text for semantic alignment`)
+
+	const timelineSentenceEntries = extractEntries(timeline, entry => entry.type === 'sentence')
+
+	const timelineWordEntryGroups: Timeline[] = []
+	const timelineWordGroups: string[][] = []
+
+	for (const sentenceEntry of timelineSentenceEntries) {
+		const wordEntryGroup = sentenceEntry.timeline!
+			.filter(wordEntry => isWord(wordEntry.text))
+
+		timelineWordEntryGroups.push(wordEntryGroup)
+		timelineWordGroups.push(wordEntryGroup.map(wordEntry => wordEntry.text))
+	}
+
+	const timelineWordEntriesFiltered = timelineWordEntryGroups.flat()
+
+	const textSentences = splitToSentences(text, textLangCode)
+
+	const textWordGroups: string[][] = []
+
+	for (const sentenceText of textSentences) {
+		let wordGroup = await splitToWords(sentenceText, textLangCode)
+		wordGroup = wordGroup.filter(word => isWord(word))
+
+		textWordGroups.push(wordGroup)
+	}
+
+	const textWords = textWordGroups.flat()
+
+	logger.end()
+
+	const wordMappingEntries = await alignWordsToWordsSemantically(timelineWordGroups, textWordGroups)
+
+	logger.start(`Build timeline for translation`)
+
+	const mappingGroups = new Map<number, number[]>()
+
+	for (const wordMappingEntry of wordMappingEntries) {
+		const wordIndex1 = wordMappingEntry.wordIndex1
+		const wordIndex2 = wordMappingEntry.wordIndex2
+
+		let group = mappingGroups.get(wordIndex1)
+
+		if (!group) {
+			group = []
+			mappingGroups.set(wordIndex1, group)
+		}
+
+		if (!group.includes(wordIndex2)) {
+			group.push(wordIndex2)
+		}
+	}
+
+	type TimeSlice = { startTime: number, endTime: number }
+
+	const timeSlicesLookup = new Map<number, TimeSlice[]>()
+
+	for (const [wordIndex1, mappedWordIndexes] of mappingGroups) {
+		if (mappedWordIndexes.length === 0) {
+			continue
+		}
+
+		const startTime = timelineWordEntriesFiltered[wordIndex1].startTime
+		const endTime = timelineWordEntriesFiltered[wordIndex1].endTime
+
+		const splitCount = mappedWordIndexes.length
+
+		const sliceDuration = (endTime - startTime) / splitCount
+
+		let timeOffset = 0
+
+		for (let i = 0; i < splitCount; i++) {
+			const timeSlice: TimeSlice = {
+				startTime: startTime + timeOffset,
+				endTime: startTime + timeOffset + sliceDuration
+			}
+
+			const wordIndex2 = mappedWordIndexes[i]
+
+			let timeSlicesForTargetWord = timeSlicesLookup.get(wordIndex2)
+
+			if (!timeSlicesForTargetWord) {
+				timeSlicesForTargetWord = []
+				timeSlicesLookup.set(wordIndex2, timeSlicesForTargetWord)
+			}
+
+			timeSlicesForTargetWord.push(timeSlice)
+
+			timeOffset += sliceDuration
+		}
+	}
+
+	const resultTimeline: Timeline = []
+
+	for (const [key, value] of timeSlicesLookup) {
+		resultTimeline.push({
+			type: 'word',
+			text: textWords[key],
+			startTime: value[0].startTime,
+			endTime: value[value.length - 1].endTime
+		})
+	}
+
+	logger.end()
+
+	return resultTimeline
+}
+
+export async function alignWordsToWordsSemantically(wordsGroups1: string[][], wordsGroups2: string[][], windowTokenCount = 1000 * 1000) {
+	const logger = new Logger()
+
+	// Load embedding model
+	const modelPath = await loadPackage(`xenova-multilingual-e5-small-fp16`)
+
+	const embeddingModel = new E5TextEmbedding(modelPath)
+
+	logger.start(`Initialize E5 embedding model`)
+	await embeddingModel.initializeIfNeeded()
+
+	async function extractEmbeddingsFromWordGroups(wordGroups: string[][]) {
+		const logger = new Logger()
+
+		const maxTokensPerFragment = 512
+		const { Tensor } = await import('@echogarden/transformers-nodejs-lite')
+
+		const words: string[] = []
+
+		const embeddings: TokenEmbeddingData[] = []
+		const tokenToWordIndexMapping: number[] = []
+
+		for (const wordGroup of wordGroups) {
+			const { joinedText: joinedTextForGroup, offsets: offsetsForGroup } = joinAndGetOffsets(wordGroup)
+
+			logger.start(`Tokenize text`)
+			const inputsForGroup = await embeddingModel.tokenizeToModelInputs(joinedTextForGroup)
+
+			logger.start(`Infer embeddings for text`)
+
+			const allTokenIds = inputsForGroup['input_ids'].data
+			const allAttentionMask = inputsForGroup['attention_mask'].data
+
+			let embeddingsForGroup: TokenEmbeddingData[] = []
+
+			for (let tokenStart = 0; tokenStart < allTokenIds.length; tokenStart += maxTokensPerFragment) {
+				const tokenEnd = Math.min(tokenStart + maxTokensPerFragment, allTokenIds.length)
+				const fragmentTokenCount = tokenEnd - tokenStart
+
+				const fragmentInputIdsTensor = new Tensor('int64', allTokenIds.slice(tokenStart, tokenEnd), [1, fragmentTokenCount])
+				const fragmentAttentionMaskTensor = new Tensor('int64', allAttentionMask.slice(tokenStart, tokenEnd), [1, fragmentTokenCount])
+
+				const inputsForFragment = { input_ids: fragmentInputIdsTensor, attention_mask: fragmentAttentionMaskTensor }
+
+				const embeddingsForFragment = await embeddingModel.inferTokenEmbeddings(inputsForFragment)
+
+				embeddingsForGroup.push(...embeddingsForFragment)
+			}
+
+			logger.start(`Compute token to word mapping for text`)
+			const filteredEmbeddingsForGroup = embeddingsForGroup.filter((embedding) => embedding.text !== '▁' && embedding.text !== '<s>' && embedding.text !== '</s>')
+			const tokenToWordIndexMappingForGroup = mapTokenEmbeddingsToWordIndexes(filteredEmbeddingsForGroup, joinedTextForGroup, offsetsForGroup)
+			const tokenToWordIndexMappingForGroupWithOffset = tokenToWordIndexMappingForGroup.map(value => words.length + value)
+
+			embeddings.push(...filteredEmbeddingsForGroup)
+			tokenToWordIndexMapping.push(...tokenToWordIndexMappingForGroupWithOffset)
+
+			words.push(...wordGroup)
+		}
+
+		return { words, embeddings, tokenToWordIndexMapping }
+	}
+
+	logger.start(`Extract embeddings from source 1`)
+	const {
+		words: words1,
+		embeddings: embeddings1,
+		tokenToWordIndexMapping: tokenToWordIndexMapping1
+	} = await extractEmbeddingsFromWordGroups(wordsGroups1)
+
+	logger.start(`Extract embeddings from source 2`)
+	const {
+		words: words2,
+		embeddings: embeddings2,
+		tokenToWordIndexMapping: tokenToWordIndexMapping2
+	} = await extractEmbeddingsFromWordGroups(wordsGroups2)
+
+	// Align
+	function costFunction(a: TokenEmbeddingData, b: TokenEmbeddingData) {
+		const aIsPunctuation = isPunctuation(a.text)
+		const bIsPunctuation = isPunctuation(b.text)
+
+		if (aIsPunctuation === bIsPunctuation) {
+			return cosineDistance(a.embeddingVector, b.embeddingVector)
+		} else {
+			return 1.0
+		}
+	}
+
+	logger.start(`Align token embedding vectors using DTW`)
+
+	const { path } = alignDTWWindowed(embeddings1, embeddings2, costFunction, windowTokenCount)
+
+	// Use alignment path to words to words
+	logger.start(`Map tokens to words`)
+
+	const wordMapping: WordMapping[] = []
+
+	for (let i = 0; i < path.length; i++) {
+		const pathEntry = path[i]
+
+		const sourceTokenIndex = pathEntry.source
+		const destTokenIndex = pathEntry.dest
+
+		const mappedWordIndex1 = tokenToWordIndexMapping1[sourceTokenIndex]
+		const mappedWordIndex2 = tokenToWordIndexMapping2[destTokenIndex]
+
+		wordMapping.push({
+			wordIndex1: mappedWordIndex1,
+			word1: words1[mappedWordIndex1],
+			wordIndex2: mappedWordIndex2,
+			word2: words2[mappedWordIndex2],
+		})
+	}
+
+	logger.end()
+
+	return wordMapping
+}
+
+function mapTokenEmbeddingsToWordIndexes(embeddings: TokenEmbeddingData[], text: string, textWordOffsets: number[]) {
+	const tokenToWordIndex: number[] = []
+
+	let currentTextOffset = 0
+
+	for (let i = 0; i < embeddings.length; i++) {
+		const embedding = embeddings[i]
+		let tokenText = embedding.text
+
+		if (tokenText === '<s>' || tokenText === '</s>') {
+			tokenToWordIndex.push(-1)
+
+			continue
+		}
+
+		if (tokenText.startsWith('▁')) {
+			tokenText = tokenText.substring(1)
+		}
+
+		const matchPosition = text.indexOf(tokenText, currentTextOffset)
+
+		if (matchPosition === -1) {
+			throw new Error(`Token '${tokenText}' not found in text`)
+		}
+
+		currentTextOffset = matchPosition + tokenText.length
+
+		let tokenMatchingWordIndex = textWordOffsets.findIndex((index) => index > matchPosition)
+
+		if (tokenMatchingWordIndex === -1) {
+			throw new Error(`Token '${tokenText}' not found in text`)
+		} else {
+			tokenMatchingWordIndex = Math.max(tokenMatchingWordIndex - 1, 0)
+		}
+
+		tokenToWordIndex.push(tokenMatchingWordIndex)
+	}
+
+	return tokenToWordIndex
+}
+
+function joinAndGetOffsets(words: string[]) {
+	let joinedText = ''
+	const offsets: number[] = []
+
+	let offset = 0
+
+	for (const word of words) {
+		const extendedWord = `${word} `
+		joinedText += extendedWord
+
+		offsets.push(offset)
+
+		offset += extendedWord.length
+	}
+
+	offsets.push(joinedText.length)
+
+	return { joinedText, offsets }
+}
+
+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
+}
+
+export interface WordMapping {
+	wordIndex1: number
+	word1: string
+
+	wordIndex2: number
+	word2: string
+}
+
+export const e5SupportedLanguages: string[] = [
+	'af', // Afrikaans
+	'am', // Amharic
+	'ar', // Arabic
+	'as', // Assamese
+	'az', // Azerbaijani
+	'be', // Belarusian
+	'bg', // Bulgarian
+	'bn', // Bengali
+	'br', // Breton
+	'bs', // Bosnian
+	'ca', // Catalan
+	'cs', // Czech
+	'cy', // Welsh
+	'da', // Danish
+	'de', // German
+	'el', // Greek
+	'en', // English
+	'eo', // Esperanto
+	'es', // Spanish
+	'et', // Estonian
+	'eu', // Basque
+	'fa', // Persian
+	'fi', // Finnish
+	'fr', // French
+	'fy', // Western Frisian
+	'ga', // Irish
+	'gd', // Scottish Gaelic
+	'gl', // Galician
+	'gu', // Gujarati
+	'ha', // Hausa
+	'he', // Hebrew
+	'hi', // Hindi
+	'hr', // Croatian
+	'hu', // Hungarian
+	'hy', // Armenian
+	'id', // Indonesian
+	'is', // Icelandic
+	'it', // Italian
+	'ja', // Japanese
+	'jv', // Javanese
+	'ka', // Georgian
+	'kk', // Kazakh
+	'km', // Khmer
+	'kn', // Kannada
+	'ko', // Korean
+	'ku', // Kurdish
+	'ky', // Kyrgyz
+	'la', // Latin
+	'lo', // Lao
+	'lt', // Lithuanian
+	'lv', // Latvian
+	'mg', // Malagasy
+	'mk', // Macedonian
+	'ml', // Malayalam
+	'mn', // Mongolian
+	'mr', // Marathi
+	'ms', // Malay
+	'my', // Burmese
+	'ne', // Nepali
+	'nl', // Dutch
+	'no', // Norwegian
+	'om', // Oromo
+	'or', // Oriya
+	'pa', // Panjabi
+	'pl', // Polish
+	'ps', // Pashto
+	'pt', // Portuguese
+	'ro', // Romanian
+	'ru', // Russian
+	'sa', // Sanskrit
+	'sd', // Sindhi
+	'si', // Sinhala
+	'sk', // Slovak
+	'sl', // Slovenian
+	'so', // Somali
+	'sq', // Albanian
+	'sr', // Serbian
+	'su', // Sundanese
+	'sv', // Swedish
+	'sw', // Swahili
+	'ta', // Tamil
+	'te', // Telugu
+	'th', // Thai
+	'tl', // Tagalog
+	'tr', // Turkish
+	'ug', // Uyghur
+	'uk', // Ukrainian
+	'ur', // Urdu
+	'uz', // Uzbek
+	'vi', // Vietnamese
+	'xh', // Xhosa
+	'yi', // Yiddish
+	'zh', // Chinese
+]