echogarden 2.6.0 → 2.8.0

package/src/synthesis/SvoxPicoTTS.ts

@@ -1,13 +1,13 @@
 import { SynthesisVoice } from '../api/API.js'
-import { decodeToChannels } from '../audio/AudioBufferConversion.js'
-import { SampleFormat } from '../codecs/WaveCodec.js'
+import { decodeToChannels, SampleFormat } from '../audio/AudioBufferConversion.js'
 import { bandwidthToQFactor } from '../dsp/BiquadFilter.js'
 import { Logger } from '../utilities/Logger.js'
-import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 import { RawAudio } from '../audio/AudioUtilities.js'
 import { readFileAsBinary } from '../utilities/FileSystem.js'
 import { concatUint8Arrays } from '../utilities/Utilities.js'
 
+import { wrapEmscriptenModuleHeap } from 'wasm-heap-manager'
+
 let svoxPicoInstance: any
 
 export async function synthesize(text: string, textAnalysisFilePath: string, signalGenerationFilePath: string, postprocessOutput = true) {
@@ -18,7 +18,7 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 
 	logger.start('Initialize pico engine')
 
-	const wasmMemory = new WasmMemoryManager(m)
+	const wasmHeap = wrapEmscriptenModuleHeap(m)
 
 	const pico_initialize = m._pico_initialize
 	const picoext_setTraceLevel = m._picoext_setTraceLevel
@@ -38,11 +38,11 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 	const pico_unloadResource = m._pico_unloadResource
 
 	const picoMemSize = 2500000
-	const picoMemAreaRef = wasmMemory.allocUint8Array(picoMemSize)
+	const picoMemAreaRef = wasmHeap.allocUint8Array(picoMemSize)
 
-	const systemPtrRef = wasmMemory.allocPointer()
+	const systemPtrRef = wasmHeap.allocPointer32()
 
-	let resultCode = pico_initialize(picoMemAreaRef.address, picoMemAreaRef.length, systemPtrRef.address)
+	let resultCode = pico_initialize(picoMemAreaRef.address, picoMemAreaRef.allocatedByteCount, systemPtrRef.address)
 	const systemPtr = systemPtrRef.value
 
 	throwErrorIfFailed(resultCode, 'Failed Pico initialization.')
@@ -55,8 +55,8 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 		const fileData = await readFileAsBinary(localFilePath)
 		m.FS.writeFile(virtualFilePath, fileData)
 
-		const virtualFilePathRef = wasmMemory.allocNullTerminatedUtf8String(virtualFilePath)
-		const resourcePtrRef = wasmMemory.allocPointer()
+		const virtualFilePathRef = wasmHeap.allocNullTerminatedUtf8String(virtualFilePath)
+		const resourcePtrRef = wasmHeap.allocPointer32()
 
 		resultCode = pico_loadResource(systemPtr, virtualFilePathRef.address, resourcePtrRef.address)
 		const resourcePtr = resourcePtrRef.value
@@ -70,12 +70,12 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 	const { resourcePtr: signalGenerationResourcePtr, resourcePtrRef: signalGenerationResourcePtrRef } = await loadResource(signalGenerationFilePath)
 
 	function getResourceName(resourcePtr: number) {
-		const resourceNameRef = wasmMemory.allocUint8Array(32)
+		const resourceNameRef = wasmHeap.allocNullTerminatedUtf8String(32)
 		resultCode = pico_getResourceName(systemPtr, resourcePtr, resourceNameRef.address)
 
 		throwErrorIfFailed(resultCode, `Failed getting Pico resource name.`)
 
-		const resourceName = resourceNameRef.readAsNullTerminatedUtf8String()
+		const resourceName = resourceNameRef.value
 
 		return { resourceName, resourceNameRef }
 	}
@@ -83,7 +83,7 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 	const { resourceName: textAnalysisResourceName, resourceNameRef: textAnalysisResourceNameRef } = getResourceName(textAnalysisResourcePtr)
 	const { resourceName: signalGenerationResourceName, resourceNameRef: signalGenerationResourceNameRef } = getResourceName(signalGenerationResourcePtr)
 
-	const voiceNameRef = wasmMemory.allocNullTerminatedUtf8String('PicoVoice')
+	const voiceNameRef = wasmHeap.allocNullTerminatedUtf8String('PicoVoice')
 
 	resultCode = pico_createVoiceDefinition(systemPtr, voiceNameRef.address)
 
@@ -96,7 +96,7 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 	addResourceToVoiceDefinition(textAnalysisResourceNameRef.address)
 	addResourceToVoiceDefinition(signalGenerationResourceNameRef.address)
 
-	const enginePtrRef = wasmMemory.allocPointer()
+	const enginePtrRef = wasmHeap.allocPointer32()
 	resultCode = pico_newEngine(systemPtr, voiceNameRef.address, enginePtrRef.address)
 
 	throwErrorIfFailed(resultCode, `Failed creating new engine.`)
@@ -105,15 +105,17 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 
 	logger.start('Synthesize with pico')
 
-	const textRef = wasmMemory.allocNullTerminatedUtf8String(text)
+	const textRef = wasmHeap.allocNullTerminatedUtf8String(text)
 
-	const bytesWrittenRef = wasmMemory.allocInt32()
+	const bytesWrittenRef = wasmHeap.allocInt32()
 
 	const audioParts: Uint8Array[] = []
 
-	for (let textByteOffset = 0; textByteOffset < textRef.length;) {
+	const textRefEncodedByteCountIncludingTerminator = textRef.encodedByteCount + 1
+
+	for (let textByteOffset = 0; textByteOffset < textRefEncodedByteCountIncludingTerminator;) {
 		bytesWrittenRef.value = 0
-		resultCode = pico_putTextUtf8(enginePtr, textRef.address + textByteOffset, textRef.length - textByteOffset, bytesWrittenRef.address)
+		resultCode = pico_putTextUtf8(enginePtr, textRef.address + textByteOffset, textRefEncodedByteCountIncludingTerminator - textByteOffset, bytesWrittenRef.address)
 		const bytesWritten = bytesWrittenRef.value
 
 		throwErrorIfFailed(resultCode, `Failed writing text to engine.`)
@@ -130,13 +132,13 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 		const outBuffers: Uint8Array[] = []
 
 		const outBufferLength = 16384
-		const outBufferRef = wasmMemory.allocUint8Array(outBufferLength)
+		const outBufferRef = wasmHeap.allocUint8Array(outBufferLength)
 
-		const outByteCountRef = wasmMemory.allocInt16()
-		const outDataTypeRef = wasmMemory.allocInt16()
+		const outByteCountRef = wasmHeap.allocInt16()
+		const outDataTypeRef = wasmHeap.allocInt16()
 
 		while (true) {
-			resultCode = pico_getData(enginePtr, outBufferRef.address, outBufferRef.length, outByteCountRef.address, outDataTypeRef.address)
+			resultCode = pico_getData(enginePtr, outBufferRef.address, outBufferRef.allocatedByteCount, outByteCountRef.address, outDataTypeRef.address)
 
 			throwErrorIfFailed(resultCode, `Failed getting audio data from engine.`, [200, 201])
 
@@ -148,7 +150,7 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 			}
 
 			if (outByteCount > 0) {
-				outBuffers.push(outBufferRef.slice(0, outByteCount) as Uint8Array)
+				outBuffers.push(outBufferRef.view.slice(0, outByteCount))
 			}
 		}
 
@@ -180,7 +182,7 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 
 		pico_terminate(systemPtrRef.address)
 
-		wasmMemory.freeAll()
+		wasmHeap.freeAll()
 	}
 
 	function throwErrorIfFailed(resultCode: number, title: string, successCodes = [0]) {
@@ -188,9 +190,9 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 			return
 		}
 
-		const picoErrorMessageRef = wasmMemory.allocUint8Array(200)
+		const picoErrorMessageRef = wasmHeap.allocNullTerminatedUtf8String(200)
 		pico_getSystemStatusMessage(systemPtr, resultCode, picoErrorMessageRef)
-		const picoErrorMessage = picoErrorMessageRef.readAsNullTerminatedUtf8String()
+		const picoErrorMessage = picoErrorMessageRef.value
 
 		dispose()
 		throw new Error(`${title} ${picoErrorMessage}`)

package/src/text-translation/DeepLTextTranslation.ts

@@ -1,6 +1,6 @@
 import { request } from "gaxios"
 import { Logger } from "../utilities/Logger.js"
-import { splitToSentences } from "../nlp/Segmentation.js"
+import { parseText } from "../nlp/Segmentation.js"
 import { TranslationPair } from "../api/TextTranslation.js"
 import { getChromeOnWindowsHeaders } from "../utilities/BrowserRequestHeaders.js"
 
@@ -9,7 +9,8 @@ export async function translateText(text: string, sourceLanguage: string, target
 
 	logger.start(`Prepare request`)
 
-	const textSentences = splitToSentences(text, sourceLanguage)
+	const segmentedText = await parseText(text, sourceLanguage)
+	const sentences = segmentedText.sentences
 
 	const requestBodyObject = {
 		jsonrpc: '2.0',
@@ -20,7 +21,7 @@ export async function translateText(text: string, sourceLanguage: string, target
 					kind: 'default',
 					sentences: [
 						{
-							text: textSentences[0],
+							text: sentences[0].text,
 							id: 1,
 							prefix: '',
 						}

package/src/text-translation/NLLBTextTranslation.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk'
 import { TranslationPair } from '../api/TextTranslation.js'
-import { splitToSentences } from '../nlp/Segmentation.js'
+import { parseText } from '../nlp/Segmentation.js'
 import { Logger } from '../utilities/Logger.js'
 import { loadPackage } from '../utilities/PackageManager.js'
 
@@ -30,19 +30,21 @@ export async function translateText(sourceText: string, sourceLanguage: string,
 		tgt_lang: 'eng_Latn'
 	}
 
-	const sentences = splitToSentences(sourceText, sourceLanguage)
+	const segmentedText = await parseText(sourceText, sourceLanguage)
+
+	const sentences = segmentedText.sentences
 
 	logger.end()
 
 	const translationPairs: TranslationPair[] = []
 
 	for (let i = 0; i < sentences.length; i++) {
-		const sentence = sentences[i]
+		const sentenceText = sentences[i].text
 
-		logger.logTitledMessage(`Translate sentence ${i + 1}/${sentences.length}`, `"${sentence.trim()}"`, chalk.magentaBright)
+		logger.logTitledMessage(`Translate sentence ${i + 1}/${sentences.length}`, `"${sentenceText.trim()}"`, chalk.magentaBright)
 
 		logger.start(`Tokenize sentence`)
-		const inputs = (tokenizer as any)._build_translation_inputs(sentence, {
+		const inputs = (tokenizer as any)._build_translation_inputs(sentenceText, {
 			padding: true,
 			truncation: true,
 		}, config)
@@ -67,7 +69,7 @@ export async function translateText(sourceText: string, sourceLanguage: string,
 			.trim()
 
 		translationPairs.push({
-			sourceText: sentence,
+			sourceText: sentenceText,
 			translatedText
 		})
 

package/src/typings/Fillers.d.ts

@@ -1,5 +1,3 @@
-declare module 'moving-median'
-
 declare module 'html-to-text' {
 	export function htmlToText(html: string, options: {
 		wordwrap: boolean | number
@@ -7,20 +5,6 @@ declare module 'html-to-text' {
 	})
 }
 
-declare module 'cldr-segmentation' {
-	export function sentenceSplit(text: string, suppressions: any)
-	export function wordSplit(text: string, suppressions: any)
-	export const suppressions: Record<string, Suppressions>
-
-	export class Suppressions {
-		constructor(forwardTrie: any, backwardTrie: any, list: string)
-
-		merge(other: Suppressions)
-
-		static create(list: string[]): Suppressions
-	}
-}
-
 declare module 'winax'
 
 declare module 'tinyld' {

package/src/utilities/StringUtilities.ts

@@ -52,7 +52,7 @@ export function formatListWithQuotedElements(strings: string[], quoteSymbol = `'
 
 export function getUTF32Chars(str: string) {
 	const utf32chars: string[] = []
-	const mapping: number[] = []
+	const utf16To32Mapping: number[] = []
 
 	let utf32Index = 0
 
@@ -60,15 +60,15 @@ export function getUTF32Chars(str: string) {
 		utf32chars.push(utf32char)
 
 		for (let i = 0; i < utf32char.length; i++) {
-			mapping.push(utf32Index)
+			utf16To32Mapping.push(utf32Index)
 		}
 
 		utf32Index += 1
 	}
 
-	mapping.push(utf32Index)
+	utf16To32Mapping.push(utf32Index)
 
-	return { utf32chars, mapping }
+	return { utf32chars, utf16To32Mapping }
 }
 
 export function containsInvalidCodepoint(str: string) {
@@ -81,10 +81,9 @@ export function containsInvalidCodepoint(str: string) {
 	return false
 }
 
-
 export function splitAndPreserveSeparators(text: string, separatorRegex: RegExp): string[] {
 	if (!separatorRegex.flags.includes('g')) {
-		throw new Error('RegExp must be global')
+		throw new Error('Separator regular expression must have a global flag')
 	}
 
 	// Use the match method to find all matches for the separators

package/src/utilities/Timeline.ts

@@ -1,7 +1,8 @@
+import { addMissingPunctuationWordsToWordSequence, segmentWordSequence, WordSequence } from '@echogarden/text-segmentation'
 import { ParagraphBreakType, WhitespaceProcessing } from '../api/Common.js'
-import { applyWhitespaceProcessing, isWord, isWordOrSymbolWord, splitToParagraphs, splitToSentences, splitToWords } from '../nlp/Segmentation.js'
+import { isWord, isWordOrSymbolWord, splitToParagraphs, splitToWords } from '../nlp/Segmentation.js'
 import { deepClone } from './ObjectUtilities.js'
-import { getUTF32Chars, splitAndPreserveSeparators } from './StringUtilities.js'
+import { getUTF32Chars } from './StringUtilities.js'
 import { roundToDigits } from './Utilities.js'
 
 export function addTimeOffsetToTimeline(targetTimeline: Timeline, timeOffset: number) {
@@ -62,199 +63,155 @@ export function roundTimelineProperties(targetTimeline: Timeline, decimalDigits
 	return roundedTimeline
 }
 
-export async function wordTimelineToSegmentSentenceTimeline(wordTimeline: Timeline, transcript: string, language: string, paragraphBreaks: ParagraphBreakType = 'double', whitespace: WhitespaceProcessing = 'collapse') {
-	let segments: string[][] = []
+export async function wordTimelineToSegmentSentenceTimeline(wordTimelineWithOffsets: Timeline, transcript: string, language: string, paragraphBreaks: ParagraphBreakType = 'double', whitespace: WhitespaceProcessing = 'collapse') {
+	const wordSequence = new WordSequence()
 
-	{
-		// Ensure word entries with words that include potential sentence ending characters,
-		// like '.', '?' or '!', aren't causing the sentence segmentation
-		// to identify them as sentence breaks.
-		const maskedTranscript = replaceSentenceEndersWithinWordsWithMaskingCharacter(transcript, wordTimeline, '_')
-
-		// Split to segments and sentences, based on the masked transcript,
-		// don't apply any whitespace processing yet.
-		let paragraphs: string[]
-
-		if (paragraphBreaks === 'single') {
-			paragraphs = splitAndPreserveSeparators(maskedTranscript, /(\r?\n)+/g)
-		} else if (paragraphBreaks === 'double') {
-			paragraphs = splitAndPreserveSeparators(maskedTranscript, /(\r?\n)(\r?\n)+/g)
-		} else {
-			throw new Error(`Invalid paragraph break type: '${paragraphBreaks}'`)
-		}
-
-		const maskedSegments = paragraphs.map(paragraph => splitToSentences(paragraph, language))
-
-		// Restore the sentence text the original text, using the original transcript,
-		// and apply whitespace processing to each sentence.
-		let offset = 0
+	for (const wordEntry of wordTimelineWithOffsets) {
+		const wordStartOffset = wordEntry.startOffsetUtf16!
+		const wordEndOffset = wordEntry.endOffsetUtf16!
 
-		for (const segment of maskedSegments) {
-			const newSegment: string[] = []
+		const isPunctuation = !isWordOrSymbolWord(wordEntry.text)
 
-			for (let sentenceIndex = 0; sentenceIndex < segment.length; sentenceIndex++) {
-				const sentence = segment[sentenceIndex]
-				const sentenceLength = sentence.length
-
-				const restoredSentence = transcript.substring(offset, offset + sentenceLength)
-				const restoredAndProcessedSentence = applyWhitespaceProcessing(restoredSentence, whitespace).trim()
+		wordSequence.addWord(wordEntry.text, wordStartOffset, isPunctuation)
+	}
 
-				if (restoredAndProcessedSentence.length > 0) {
-					newSegment.push(restoredAndProcessedSentence)
-				}
+	const { wordSequenceWithPunctuation, originalWordsReverseMapping } = addMissingPunctuationWordsToWordSequence(wordSequence, transcript)
 
-				offset += sentenceLength
-			}
+	const segmentedWordSequence = await segmentWordSequence(wordSequenceWithPunctuation)
 
-			segments.push(newSegment)
-		}
+	const paragraphs = splitToParagraphs(transcript, paragraphBreaks, whitespace)
+	const sentenceIndexesForParagraph = paragraphs.map(_ => [] as number[])
 
-		segments = segments.filter(segment => segment.length > 0)
-	}
+	{
+		let sentenceIndex = 0
+		let charOffset = 0
 
-	// Create a new text based on the processed sentences, new segment and sentence timeline,
-	// and store mapping between character indexes and the corresponding sentence they belong to.
-	let text = ''
-	const charIndexToSentenceEntryMapping: TimelineEntry[] = []
+		for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex++) {
+			const paragraph = paragraphs[paragraphIndex]
 
-	const segmentTimeline: Timeline = []
+			const paragraphStartOffset = charOffset
+			const paragraphEndOffset = paragraphStartOffset + paragraph.length
 
-	for (const segment of segments) {
-		const sentencesInSegment: Timeline = []
+			while (sentenceIndex < segmentedWordSequence.sentences.length) {
+				const sentenceEntry = segmentedWordSequence.sentences[sentenceIndex]
+				const sentenceStartOffset = sentenceEntry.charRange.start
+				const sentenceEndOffset = sentenceEntry.charRange.end
 
-		const segmentEntry: TimelineEntry = {
-			type: 'segment',
-			text: '',
-			startTime: -1,
-			endTime: -1,
-			timeline: sentencesInSegment
-		}
-
-		for (const sentence of segment) {
-			const sentenceEntry: TimelineEntry = {
-				type: 'sentence',
-				text: sentence,
-				startTime: -1,
-				endTime: -1,
-				timeline: []
+				if (sentenceStartOffset < paragraphEndOffset) {
+					sentenceIndexesForParagraph[paragraphIndex].push(sentenceIndex)
+					sentenceIndex++
+				} else {
+					break
+				}
 			}
 
-			for (const char of sentence + ' ') {
-				text += char
-				charIndexToSentenceEntryMapping.push(sentenceEntry)
+			if (sentenceIndex === segmentedWordSequence.sentences.length) {
+				break
 			}
 
-			sentencesInSegment.push(sentenceEntry)
+			charOffset += paragraph.length
 		}
-
-		segmentTimeline.push(segmentEntry)
 	}
 
-	// Add the word entries to their corresponding sentence timelines
-	{
-		let wordSearchStartOffset = 0
-
-		for (let wordIndex = 0; wordIndex < wordTimeline.length; wordIndex++) {
-			const wordEntry = wordTimeline[wordIndex]
-			const wordText = wordEntry.text
-
-			if (!isWordOrSymbolWord(wordText)) {
-				continue
-			}
-
-			const indexOfWordInText = text.indexOf(wordText, wordSearchStartOffset)
-
-			if (indexOfWordInText == -1) {
-				throw new Error(`Couldn't find the word '${wordText}' in the text at start position ${wordSearchStartOffset}`)
-			}
+	const segmentTimeline: Timeline = []
+	let wordIndex = 0
 
-			const targetSentenceEntry = charIndexToSentenceEntryMapping[indexOfWordInText]
-			targetSentenceEntry.timeline!.push(deepClone(wordEntry))
+	for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex++) {
+		const paragraph = paragraphs[paragraphIndex]
+		const sentencesIndexes = sentenceIndexesForParagraph[paragraphIndex]
+		const sentenceEntries = sentencesIndexes.map(index => segmentedWordSequence.sentences[index])
 
-			wordSearchStartOffset = indexOfWordInText + wordText.length
-		}
-	}
+		const sentenceTimeline: Timeline = []
 
-	// Produce a new segment/sentence timeline with rewritten entries,
-	// that match the assigned words.
-	const newSegmentTimeline: Timeline = []
+		for (const sentenceEntry of sentenceEntries) {
+			const wordTimeline: Timeline = []
 
-	for (const segmentEntry of segmentTimeline) {
-		const oldSentenceTimeline = segmentEntry.timeline!
+			for (const _ of sentenceEntry.words.entries) {
+				const originalWordIndex = originalWordsReverseMapping.get(wordIndex)
 
-		const newSentenceTimeline: Timeline = []
+				if (originalWordIndex !== undefined) {
+					const wordTimelineEntry = wordTimelineWithOffsets[originalWordIndex]
 
-		for (const sentenceEntry of oldSentenceTimeline) {
-			const wordTimeline = sentenceEntry.timeline
+					wordTimeline.push(wordTimelineEntry)
+				}
 
-			if (!wordTimeline || wordTimeline.length === 0) {
-				continue
+				wordIndex += 1
 			}
 
-			sentenceEntry.startTime = wordTimeline[0].startTime
-			sentenceEntry.endTime = wordTimeline[wordTimeline.length - 1].endTime
+			const sentenceTimelineEntry: TimelineEntry = {
+				type: 'sentence',
+				text: sentenceEntry.text,
+				startTime: wordTimeline[0].startTime,
+				endTime: wordTimeline[wordTimeline.length - 1].endTime,
 
-			newSentenceTimeline.push(sentenceEntry)
-		}
+				timeline: wordTimeline,
+			}
 
-		if (newSentenceTimeline.length === 0) {
-			continue
+			sentenceTimeline.push(sentenceTimelineEntry)
 		}
 
-		segmentEntry.text = newSentenceTimeline.map(sentenceEntry => sentenceEntry.text).join(' ')
+		const segmentTimelineEntry: TimelineEntry = {
+			type: 'segment',
+			text: paragraph,
+			startTime: sentenceTimeline[0].startTime,
+			endTime: sentenceTimeline[sentenceTimeline.length - 1].endTime,
 
-		segmentEntry.startTime = newSentenceTimeline[0].startTime
-		segmentEntry.endTime = newSentenceTimeline[newSentenceTimeline.length - 1].endTime
+			timeline: sentenceTimeline,
+		}
 
-		newSegmentTimeline.push(segmentEntry)
+		segmentTimeline.push(segmentTimelineEntry)
 	}
 
-	return { segmentTimeline: newSegmentTimeline }
+	return { segmentTimeline }
 }
 
-export function addWordTextOffsetsToTimeline(timeline: Timeline, text: string, currentOffset = 0) {
-	const { mapping } = getUTF32Chars(text)
+export function addWordTextOffsetsToTimelineInPlace(timeline: Timeline, text: string) {
+	const { utf16To32Mapping } = getUTF32Chars(text)
 
-	for (const entry of timeline) {
-		if (entry.type == 'word') {
-			let word = entry.text
+	let currentOffset = 0
 
-			word = word.trim().replaceAll(/\s+/g, ' ')
+	function processTimeline(timeline: Timeline) {
+		for (const entry of timeline) {
+			if (entry.type === 'word') {
+				let word = entry.text
 
-			const wordParts = word.split(' ')
+				word = word.trim().replaceAll(/\s+/g, ' ')
 
-			let startOffset: number | undefined
-			let endOffset: number | undefined
+				const wordParts = word.split(' ')
 
-			for (let i = 0; i < wordParts.length; i++) {
-				let wordPart = wordParts[i]
+				let startOffset: number | undefined
+				let endOffset: number | undefined
 
-				let wordPartOffset = text.indexOf(wordPart, currentOffset)
+				for (let i = 0; i < wordParts.length; i++) {
+					const wordPart = wordParts[i]
 
-				if (wordPartOffset == -1) {
-					continue
-				}
+					const wordPartOffset = text.indexOf(wordPart, currentOffset)
 
-				currentOffset = wordPartOffset + wordParts[i].length
+					if (wordPartOffset === -1) {
+						continue
+					}
 
-				if (i == 0) {
-					startOffset = wordPartOffset
-				}
+					currentOffset = wordPartOffset + wordParts[i].length
 
-				endOffset = currentOffset
-			}
+					if (i === 0) {
+						startOffset = wordPartOffset
+					}
 
-			entry.startOffsetUtf16 = startOffset
-			entry.endOffsetUtf16 = endOffset
+					endOffset = currentOffset
+				}
 
-			entry.startOffsetUtf32 = startOffset != undefined ? mapping[startOffset] : undefined
-			entry.endOffsetUtf32 = endOffset != undefined ? mapping[endOffset] : undefined
-		} else if (entry.timeline) {
-			currentOffset = addWordTextOffsetsToTimeline(entry.timeline, text, currentOffset)
+				entry.startOffsetUtf16 = startOffset
+				entry.endOffsetUtf16 = endOffset
+
+				entry.startOffsetUtf32 = startOffset !== undefined ? utf16To32Mapping[startOffset] : undefined
+				entry.endOffsetUtf32 = endOffset !== undefined ? utf16To32Mapping[endOffset] : undefined
+			} else if (entry.timeline) {
+				processTimeline(entry.timeline)
+			}
 		}
 	}
 
-	return currentOffset
+	return processTimeline(timeline)
 }
 
 function replaceSentenceEndersWithinWordsWithMaskingCharacter(transcript: string, wordTimeline: Timeline, maskingCharacter: string) {
@@ -344,30 +301,3 @@ export type TimelineEntry = {
 }
 
 export type Timeline = TimelineEntry[]
-
-////
-
-export async function testTimelineFix() {
-	let transcript = 'Hello world how are you? Do you want to play chess?'
-	const words = (await splitToWords(transcript, 'en')).filter(word => word.trim() !== '')
-
-	let wordTimeline: Timeline = words.map(wordText => ({
-		type: 'word',
-
-		text: wordText,
-
-		startTime: 0,
-		endTime: 0,
-	}))
-
-	addWordTextOffsetsToTimeline(wordTimeline, transcript)
-
-	wordTimeline[1].text = 'wor.d'
-	wordTimeline[8].text = 'wa.t'
-
-	transcript = transcript.replace('world', 'wor.d').replace('want', 'wa.t')
-
-	const result = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, 'en')
-
-	const x = 1
-}

package/src/utilities/WikipediaReader.ts

@@ -1,4 +1,4 @@
-import { splitToParagraphs, wordCharacterPattern } from '../nlp/Segmentation.js'
+import { splitToParagraphs, wordCharacterRegExp } from '../nlp/Segmentation.js'
 import { Logger } from './Logger.js'
 
 export async function parseWikipediaArticle(articleName: string, language: string) {
@@ -20,7 +20,7 @@ export async function parseWikipediaArticle(articleName: string, language: strin
 	for (const section of sections) {
 		const sectionTitle = section.title()
 
-		if (wordCharacterPattern.test(sectionTitle)) {
+		if (wordCharacterRegExp.test(sectionTitle)) {
 			sectionsText.push(sectionTitle)
 		}
 
@@ -29,7 +29,7 @@ export async function parseWikipediaArticle(articleName: string, language: strin
 		for (const paragraph of sectionParagraphs) {
 			const paragraphText = paragraph
 
-			if (wordCharacterPattern.test(paragraphText)) {
+			if (wordCharacterRegExp.test(paragraphText)) {
 				sectionsText.push(paragraphText)
 			}
 		}