echogarden 0.12.2 → 1.0.0

package/src/alignment/SpeechAlignment.ts

@@ -1,16 +1,25 @@
-import { clip } from "../utilities/Utilities.js"
+import { clip } from '../utilities/Utilities.js'
+
+import * as API from '../api/API.js'
+
+import { computeMFCCs, extendDefaultMfccOptions, MfccOptions } from '../dsp/MFCC.js'
+import { alignMFCC_DTW, getCostMatrixMemorySizeMB } from './DTWMfccSequenceAlignment.js'
+import { Logger } from '../utilities/Logger.js'
+import { Timeline, TimelineEntry } from '../utilities/Timeline.js'
+import { downmixToMonoAndNormalize, getEndingSilentSampleCount, getRawAudioDuration, getStartingSilentSampleCount, RawAudio } from '../audio/AudioUtilities.js'
+import chalk from 'chalk'
+import { synthesize } from '../api/API.js'
+import { resampleAudioSpeex } from '../dsp/SpeexResampler.js'
+import { deepClone } from '../utilities/ObjectUtilities.js'
+import { zeroIfNaN } from '../math/VectorMath.js'
+
+export async function alignUsingDtw(
+	sourceRawAudio: RawAudio,
+	referenceRawAudio: RawAudio,
+	referenceTimeline: Timeline,
+	granularities: DtwGranularity[],
+	windowDurations: number[]) {
 
-import * as API from "../api/API.js"
-
-import { computeMFCCs, extendDefaultMfccOptions, MfccOptions } from "../dsp/MFCC.js"
-import { alignMFCC_DTW, getCostMatrixMemorySizeMB } from "./DTWMfccSequenceAlignment.js"
-import { Logger } from "../utilities/Logger.js"
-import { Timeline, TimelineEntry } from "../utilities/Timeline.js"
-import { getEndingSilentSampleCount, getRawAudioDuration, getStartingSilentSampleCount, RawAudio } from "../audio/AudioUtilities.js"
-import { type EspeakOptions } from "../synthesis/EspeakTTS.js"
-import chalk from "chalk"
-
-export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio: RawAudio, referenceTimeline: Timeline, granularities: DtwGranularity[], windowDurations: number[]) {
 	const logger = new Logger()
 
 	if (windowDurations.length == 0) {
@@ -38,11 +47,11 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 		framesPerSecond = 1 / mfccOptions.hopDuration!
 
 		// Compute reference MFCCs
-		logger.start("Compute reference MFCC features")
+		logger.start('Compute reference MFCC features')
 		const referenceMfccs = await computeMFCCs(referenceRawAudio, mfccOptions)
 
 		// Compute source MFCCs
-		logger.start("Compute source MFCC features")
+		logger.start('Compute source MFCC features')
 		const sourceMfccs = await computeMFCCs(sourceRawAudio, mfccOptions)
 		logger.end()
 
@@ -52,12 +61,12 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 		if (passIndex == 0) {
 			const minRecommendedWindowDuration = 0.2 * rawAudioDuration
 
-			if (windowDuration < minRecommendedWindowDuration ) {
+			if (windowDuration < minRecommendedWindowDuration) {
 				logger.logTitledMessage('Warning', `Maximum DTW window duration is set to ${windowDuration.toFixed(1)}s, which is smaller than 20% of the source audio duration of ${rawAudioDuration.toFixed(1)}s. This may lead to suboptimal results in some cases. Consider increasing window duration if needed.`, chalk.yellowBright)
 			}
 		}
 
-		logger.start("Align MFCC features using DTW")
+		logger.start('Align MFCC features using DTW')
 		const dtwWindowLength = Math.floor(windowDuration * framesPerSecond)
 
 		let centerIndexes: number[] | undefined
@@ -85,18 +94,18 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 		logger.end()
 	}
 
-	logger.start("\nConvert path to timeline")
+	logger.start('\nConvert path to timeline')
 
 	function getMappedTimelineEntry(timelineEntry: TimelineEntry, recurse = true): TimelineEntry {
 		const referenceStartFrameIndex = Math.floor(timelineEntry.startTime * framesPerSecond)
 		const referenceEndFrameIndex = Math.floor(timelineEntry.endTime * framesPerSecond)
 
 		if (referenceStartFrameIndex < 0 || referenceEndFrameIndex < 0) {
-			throw new Error("Unexpected: encountered a negative timestamp in timeline")
+			throw new Error('Unexpected: encountered a negative timestamp in timeline')
 		}
 
-		const mappedStartFrameIndex = getMappedFrameIndexForPath(referenceStartFrameIndex, compactedPath, "first")
-		const mappedEndFrameIndex = getMappedFrameIndexForPath(referenceEndFrameIndex, compactedPath, "first")
+		const mappedStartFrameIndex = getMappedFrameIndexForPath(referenceStartFrameIndex, compactedPath, 'first')
+		const mappedEndFrameIndex = getMappedFrameIndexForPath(referenceEndFrameIndex, compactedPath, 'first')
 
 		let innerTimeline: Timeline | undefined
 
@@ -141,7 +150,17 @@ export async function alignUsingDtw(sourceRawAudio: RawAudio, referenceRawAudio:
 	return mappedTimeline
 }
 
-export async function alignUsingDtwWithRecognition(sourceRawAudio: RawAudio, referenceRawAudio: RawAudio, referenceTimeline: Timeline, recognitionTimeline: Timeline, granularities: DtwGranularity[], windowDurations: number[], espeakOptions: EspeakOptions, phoneAlignmentMethod: API.PhoneAlignmentMethod = "interpolation") {
+export async function alignUsingDtwWithRecognition(
+	sourceRawAudio: RawAudio,
+	referenceRawAudio: RawAudio,
+	referenceTimeline: Timeline,
+	recognitionTimeline: Timeline,
+	synthesizedRecognizedTranscriptRawAudio: RawAudio,
+	synthesizedRecognitionTimeline: Timeline,
+	granularities: DtwGranularity[],
+	windowDurations: number[],
+	phoneAlignmentMethod: API.PhoneAlignmentMethod = 'interpolation') {
+
 	const logger = new Logger()
 
 	if (recognitionTimeline.length == 0) {
@@ -163,100 +182,109 @@ export async function alignUsingDtwWithRecognition(sourceRawAudio: RawAudio, ref
 		return interpolatedTimeline
 	}
 
-	// Synthesize the recognized transcript and get its timeline
-	logger.start("Synthesize recognized transcript with eSpeak")
-	const recognizedWords = recognitionTimeline.map(entry => entry.text)
-
-	const { rawAudio: synthesizedRecognizedTranscriptRawAudio, timeline: synthesizedRecognitionTimeline } = await createAlignmentReferenceUsingEspeakForFragments(recognizedWords, espeakOptions)
-
 	let recognitionTimelineWithPhones: Timeline
 
-	if (phoneAlignmentMethod == "interpolation") {
+	if (phoneAlignmentMethod == 'interpolation') {
 		// Add phone timelines by interpolating from reference words
-		logger.start("Interpolate phone timing")
+		logger.start('Interpolate phone timing')
 
 		recognitionTimelineWithPhones = await interpolatePhoneTimelines(recognitionTimeline, synthesizedRecognitionTimeline)
-	} else if (phoneAlignmentMethod == "dtw") {
-		logger.start("Align phone timing")
+	} else if (phoneAlignmentMethod == 'dtw') {
+		logger.start('Align phone timing')
 
 		// Add phone timelines by aligning each individual recognized word with the corresponding word
 		// in the reference timeline
-		recognitionTimelineWithPhones = await alignPhoneTimelines(sourceRawAudio, recognitionTimeline, synthesizedRecognizedTranscriptRawAudio, synthesizedRecognitionTimeline)
-	} else if (phoneAlignmentMethod == "dtw-knn") {
-		logger.start("Align phone timing")
-		throw new Error("Not implemented")
+		recognitionTimelineWithPhones = await alignPhoneTimelines(
+			sourceRawAudio,
+			recognitionTimeline,
+			synthesizedRecognizedTranscriptRawAudio,
+			synthesizedRecognitionTimeline,
+			60)
 	} else {
 		throw new Error(`Unknown phone alignment method: ${phoneAlignmentMethod}`)
 	}
 
-	logger.start("Map from the synthesized recognized timeline to the recognized timeline")
 	// Create a mapping from the synthesized recognized timeline to the recognized timeline
+	logger.start('Map from the synthesized recognized timeline to the recognized timeline')
+
+	type SynthesizedToRecognizedTimeMappingEntry = {
+		synthesized: number
+		recognized: number
+	}
+
 	type SynthesizedToRecognizedTimeMapping = SynthesizedToRecognizedTimeMappingEntry[]
-	type SynthesizedToRecognizedTimeMappingEntry = { synthesized: number, recognized: number }
 
 	const synthesizedToRecognizedTimeMapping: SynthesizedToRecognizedTimeMapping = []
 
-	for (let i = 0; i < synthesizedRecognitionTimeline.length; i++) {
-		const synthesizedTimelineEntry = synthesizedRecognitionTimeline[i]
-		const recognitionTimelineEntry = recognitionTimelineWithPhones[i]
+	for (let wordEntryIndex = 0; wordEntryIndex < synthesizedRecognitionTimeline.length; wordEntryIndex++) {
+		const synthesizedWordTimelineEntry = synthesizedRecognitionTimeline[wordEntryIndex]
+		const recognitionWordTimelineEntry = recognitionTimelineWithPhones[wordEntryIndex]
+
+		for (let tokenEntryIndex = 0; tokenEntryIndex < synthesizedWordTimelineEntry.timeline!.length; tokenEntryIndex++) {
+			const synthesizedTokenTimelineEntry = synthesizedWordTimelineEntry.timeline![tokenEntryIndex]
+			const recognitionTokenTimelineEntry = recognitionWordTimelineEntry.timeline![tokenEntryIndex]
 
-		synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedTimelineEntry.startTime, recognized: recognitionTimelineEntry.startTime })
+			for (let phoneEntryIndex = 0; phoneEntryIndex < synthesizedTokenTimelineEntry.timeline!.length; phoneEntryIndex++) {
+				const synthesizedPhoneTimelineEntry = synthesizedTokenTimelineEntry.timeline![phoneEntryIndex]
+				const recognitionPhoneTimelineEntry = recognitionTokenTimelineEntry.timeline![phoneEntryIndex]
 
-		if (synthesizedTimelineEntry.timeline) {
-			for (let j = 0; j < synthesizedTimelineEntry.timeline.length; j++) {
-				const synthesizedPhoneTimelineEntry = synthesizedTimelineEntry.timeline[j]
-				const recognitionPhoneTimelineEntry = recognitionTimelineEntry.timeline![j]
+				synthesizedToRecognizedTimeMapping.push({
+					synthesized: synthesizedPhoneTimelineEntry.startTime,
+					recognized: recognitionPhoneTimelineEntry.startTime
+				})
 
-				synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedPhoneTimelineEntry.startTime, recognized: recognitionPhoneTimelineEntry.startTime })
-				synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedPhoneTimelineEntry.endTime, recognized: recognitionPhoneTimelineEntry.endTime })
+				synthesizedToRecognizedTimeMapping.push({
+					synthesized: synthesizedPhoneTimelineEntry.endTime,
+					recognized: recognitionPhoneTimelineEntry.endTime
+				})
 			}
 		}
-
-		synthesizedToRecognizedTimeMapping.push({ synthesized: synthesizedTimelineEntry.endTime, recognized: recognitionTimelineEntry.endTime })
 	}
 
-	logger.start("Align the synthesized recognized transcript with the synthesized ground-truth transcript")
+	logger.start('Align the synthesized recognized transcript with the synthesized ground-truth transcript')
 	// Align the synthesized recognized transcript to the synthesized reference transcript
-	const alignedSynthesizedRecognitionTimeline = await alignUsingDtw(synthesizedRecognizedTranscriptRawAudio, referenceRawAudio, referenceTimeline, granularities, windowDurations)
+	const alignedSynthesizedRecognitionTimeline = await alignUsingDtw(
+		synthesizedRecognizedTranscriptRawAudio,
+		referenceRawAudio,
+		referenceTimeline,
+		granularities,
+		windowDurations)
 
-	let currentSynthesizedToRecognizedMappingIndex = 0
+	function mapTimeline(timeline: Timeline) {
+		function mapSynthesizedToRecognizedTime(synthesizedTime: number) {
+			for (let mappingIndex = 0; ; mappingIndex += 1) {
+				const left = synthesizedToRecognizedTimeMapping[mappingIndex].synthesized
 
-	function mapSynthesizedToRecognizedTimeAndAdvance(synthesizedTime: number) {
-		for (; ; currentSynthesizedToRecognizedMappingIndex += 1) {
-			const left = synthesizedToRecognizedTimeMapping[currentSynthesizedToRecognizedMappingIndex].synthesized
+				let right: number
 
-			let right: number
+				if (mappingIndex < synthesizedToRecognizedTimeMapping.length - 1) {
+					right = synthesizedToRecognizedTimeMapping[mappingIndex + 1].synthesized
+				} else {
+					right = Infinity
+				}
 
-			if (currentSynthesizedToRecognizedMappingIndex < synthesizedToRecognizedTimeMapping.length - 1) {
-				right = synthesizedToRecognizedTimeMapping[currentSynthesizedToRecognizedMappingIndex + 1].synthesized
-			} else {
-				right = Infinity
-			}
+				if (left > right) {
+					throw new Error('Left is greater than right!')
+				}
 
-			if (left > right) {
-				throw new Error("left is larger than right!")
-			}
-
-			if (Math.abs(synthesizedTime - left) < Math.abs(synthesizedTime - right)) {
-				return synthesizedToRecognizedTimeMapping[currentSynthesizedToRecognizedMappingIndex].recognized
+				if (Math.abs(synthesizedTime - left) < Math.abs(synthesizedTime - right)) {
+					return synthesizedToRecognizedTimeMapping[mappingIndex].recognized
+				}
 			}
 		}
-	}
 
-	function mapTimeline(timeline: Timeline) {
 		const mappedTimeline: Timeline = []
 
 		for (const entry of timeline) {
-			const mappedEntry = { ...entry }
+			const mappedEntry = deepClone(entry)
 
-			mappedEntry.startTime = mapSynthesizedToRecognizedTimeAndAdvance(entry.startTime)
+			mappedEntry.startTime = mapSynthesizedToRecognizedTime(entry.startTime)
+			mappedEntry.endTime = mapSynthesizedToRecognizedTime(entry.endTime)
 
 			if (entry.timeline) {
 				mappedEntry.timeline = mapTimeline(entry.timeline)
 			}
 
-			mappedEntry.endTime = mapSynthesizedToRecognizedTimeAndAdvance(entry.endTime)
-
 			mappedTimeline.push(mappedEntry)
 		}
 
@@ -276,41 +304,66 @@ export async function interpolatePhoneTimelines(sourceTimeline: Timeline, refere
 	for (let i = 0; i < sourceTimeline.length; i++) {
 		const referenceEntry = referenceTimeline[i]
 
-		const interpolatedEntry = { ...sourceTimeline[i] }
+		const interpolatedEntry = deepClone(sourceTimeline[i])
 		interpolatedTimeline.push(interpolatedEntry)
 
-		if (interpolatedEntry.type != "word") {
+		if (interpolatedEntry.type != 'word') {
 			continue
 		}
 
 		const interpolatedEntryDuration = interpolatedEntry.endTime - interpolatedEntry.startTime
 		const synthesisEntryDuration = referenceEntry.endTime - referenceEntry.startTime
 
-		interpolatedEntry.timeline = []
+		function mapEntry(targetEntry: TimelineEntry): TimelineEntry {
+			const targetStartTimePercentageRelativeToWord =
+				(targetEntry.startTime - referenceEntry.startTime) / synthesisEntryDuration
 
-		for (const phoneEntry of referenceEntry.timeline!) {
-			const phoneStartTimePercentageRelativeToWord =
-				(phoneEntry.startTime - referenceEntry.startTime) / synthesisEntryDuration
+			const targetEndTimePercentageRelativeToWord =
+				(targetEntry.endTime - referenceEntry.startTime) / synthesisEntryDuration
 
-			const phoneEndTimePercentageRelativeToWord =
-				(phoneEntry.endTime - referenceEntry.startTime) / synthesisEntryDuration
+			const interpolatedStartTime =
+				interpolatedEntry.startTime + (zeroIfNaN(targetStartTimePercentageRelativeToWord) * interpolatedEntryDuration)
 
-			const interpolatedPhoneStartTime = interpolatedEntry.startTime + (phoneStartTimePercentageRelativeToWord * interpolatedEntryDuration)
-			const interpolatedPhoneEndTime = interpolatedEntry.startTime + (phoneEndTimePercentageRelativeToWord * interpolatedEntryDuration)
+			const interpolatedEndTime =
+				interpolatedEntry.startTime + (zeroIfNaN(targetEndTimePercentageRelativeToWord) * interpolatedEntryDuration)
 
-			interpolatedEntry.timeline.push({
-				...phoneEntry,
+			return {
+				...targetEntry,
 
-				startTime: interpolatedPhoneStartTime,
-				endTime: interpolatedPhoneEndTime
-			})
+				startTime: interpolatedStartTime,
+				endTime: interpolatedEndTime
+			}
 		}
+
+		const interpolatedTokenEntries: Timeline = []
+
+		for (const tokenEntry of (referenceEntry.timeline || [])!) {
+			const interpolatedTokenEntry = mapEntry(tokenEntry)
+
+			const interpolatedPhoneEntries: Timeline = []
+
+			for (const phoneEntry of (tokenEntry.timeline || [])) {
+				interpolatedPhoneEntries.push(mapEntry(phoneEntry))
+			}
+
+			interpolatedTokenEntry.timeline = interpolatedPhoneEntries
+
+			interpolatedTokenEntries.push(interpolatedTokenEntry)
+		}
+
+		interpolatedEntry.timeline = interpolatedTokenEntries
 	}
 
 	return interpolatedTimeline
 }
 
-export async function alignPhoneTimelines(sourceRawAudio: RawAudio, sourceWordTimeline: Timeline, referenceRawAudio: RawAudio, referenceTimeline: Timeline) {
+export async function alignPhoneTimelines(
+	sourceRawAudio: RawAudio,
+	sourceWordTimeline: Timeline,
+	referenceRawAudio: RawAudio,
+	referenceTimeline: Timeline,
+	windowDuration: number) {
+
 	const mfccOptions: MfccOptions = extendDefaultMfccOptions({ zeroFirstCoefficient: true })
 
 	const framesPerSecond = 1 / mfccOptions.hopDuration!
@@ -323,10 +376,9 @@ export async function alignPhoneTimelines(sourceRawAudio: RawAudio, sourceWordTi
 	for (let i = 0; i < referenceTimeline.length; i++) {
 		const referenceWordEntry = referenceTimeline[i]
 
-		const alignedWordEntry = { ...sourceWordTimeline[i] }
-		alignedWordTimeline.push(alignedWordEntry)
+		const alignedWordEntry = deepClone(sourceWordTimeline[i])
 
-		if (alignedWordEntry.type != "word") {
+		if (alignedWordEntry.type != 'word') {
 			continue
 		}
 
@@ -351,51 +403,84 @@ export async function alignPhoneTimelines(sourceRawAudio: RawAudio, sourceWordTi
 		const sourceWordMfccs = sourceMfccs.slice(alignedWordStartFrameIndex, alignedWordEndFrameIndex)
 
 		// Compute DTW path
-		const rawPath = await alignMFCC_DTW(referenceWordMfccs, sourceWordMfccs, 60)
+		const rawPath = await alignMFCC_DTW(referenceWordMfccs, sourceWordMfccs, windowDuration * framesPerSecond)
 		const compactedPath = compactPath(rawPath)
 
+		function mapEntry(referenceEntry: TimelineEntry): TimelineEntry {
+			const referenceStartFrameOffset = Math.floor((referenceEntry.startTime - referenceWordEntry.startTime) * framesPerSecond)
+			const alignedStartFrameOffset = getMappedFrameIndexForPath(referenceStartFrameOffset, compactedPath)
+			const alignedStartTime = alignedWordEntry.startTime + (alignedStartFrameOffset / framesPerSecond)
+
+			const referenceEndFrameOffset = Math.floor((referenceEntry.endTime - referenceWordEntry.startTime) * framesPerSecond)
+			const alignedEndFrameOffset = getMappedFrameIndexForPath(referenceEndFrameOffset, compactedPath)
+			const alignedEndTime = alignedWordEntry.startTime + (alignedEndFrameOffset / framesPerSecond)
+
+			return {
+				...referenceEntry,
+
+				startTime: alignedStartTime,
+				endTime: alignedEndTime
+			}
+		}
+
 		// Add phone timeline using the mapped time information
-		alignedWordEntry.timeline = []
+		const alignedTokenTimeline: Timeline = []
+
+		for (const referenceTokenEntry of (referenceWordEntry.timeline || [])) {
+			const alignedPhoneTimeline: Timeline = []
 
-		for (const referencePhoneEntry of referenceWordEntry.timeline!) {
-			const referencePhoneStartFrameOffset = Math.floor((referencePhoneEntry.startTime - referenceWordEntry.startTime) * framesPerSecond)
-			const alignedPhoneStartFrameOffset = getMappedFrameIndexForPath(referencePhoneStartFrameOffset, compactedPath)
-			const alignedPhoneStartTime = alignedWordEntry.startTime + (alignedPhoneStartFrameOffset / framesPerSecond)
+			for (const referencePhoneEntry of (referenceTokenEntry.timeline || [])) {
+				alignedPhoneTimeline.push(mapEntry(referencePhoneEntry))
+			}
 
-			const referencePhoneEndFrameOffset = Math.floor((referencePhoneEntry.endTime - referenceWordEntry.startTime) * framesPerSecond)
-			const alignedPhoneEndFrameOffset = getMappedFrameIndexForPath(referencePhoneEndFrameOffset, compactedPath)
-			const alignedPhoneEndTime = alignedWordEntry.startTime + (alignedPhoneEndFrameOffset / framesPerSecond)
+			alignedTokenTimeline.push({
+				...mapEntry(referenceTokenEntry),
 
-			alignedWordEntry.timeline.push({
-				...referencePhoneEntry,
-				startTime: alignedPhoneStartTime,
-				endTime: alignedPhoneEndTime
+				timeline: alignedPhoneTimeline
 			})
 		}
+
+		alignedWordEntry.timeline = alignedTokenTimeline
+
+		alignedWordTimeline.push(alignedWordEntry)
 	}
 
 	return alignedWordTimeline
 }
 
-export async function createAlignmentReferenceUsingEspeakForFragments(fragments: string[], espeakOptions: EspeakOptions, insertSeparators = true) {
-	const progressLogger = new Logger()
-
-	progressLogger.start("Load espeak module")
-	const Espeak = await import("../synthesis/EspeakTTS.js")
+export async function createAlignmentReferenceUsingEspeak(transcript: string, language: string, plaintextOptions?: API.PlainTextOptions, customLexiconPaths?: string[], insertSeparators?: boolean) {
+	const logger = new Logger()
 
-	progressLogger.start("Create alignment reference with eSpeak")
+	logger.start('Create alignment reference with eSpeak')
 
-	const result = await Espeak.synthesizeFragments(fragments, espeakOptions, insertSeparators)
+	const synthesisOptions: API.SynthesisOptions = {
+		engine: 'espeak',
+		language,
 
-	result.timeline = result.timeline.flatMap(clause => clause.timeline!)
+		plainText: plaintextOptions,
+		customLexiconPaths: customLexiconPaths,
 
-	for (const wordEntry of result.timeline) {
-		wordEntry.timeline = wordEntry.timeline!.flatMap(tokenEntry => tokenEntry.timeline!)
+		espeak: {
+			useKlatt: false,
+			insertSeparators,
+		}
 	}
 
-	progressLogger.end()
+	let {
+		audio: referenceRawAudio,
+		timeline: segmentTimeline,
+		voice: espeakVoice
+	} = await synthesize(transcript, synthesisOptions)
 
-	return result
+	const sentenceTimeline = segmentTimeline.flatMap(entry => entry.timeline!)
+	const wordTimeline = sentenceTimeline.flatMap(entry => entry.timeline!)
+
+	referenceRawAudio = await resampleAudioSpeex(referenceRawAudio as RawAudio, 16000)
+	referenceRawAudio = downmixToMonoAndNormalize(referenceRawAudio)
+
+	logger.end()
+
+	return { referenceRawAudio, referenceTimeline: wordTimeline, espeakVoice }
 }
 
 function compactPath(path: AlignmentPath) {
@@ -414,7 +499,7 @@ function compactPath(path: AlignmentPath) {
 	return compactedPath
 }
 
-function getMappedFrameIndexForPath(referenceFrameIndex: number, compactedPath: CompactedPath, mappingKind: "first" | "last" = "first") {
+function getMappedFrameIndexForPath(referenceFrameIndex: number, compactedPath: CompactedPath, mappingKind: 'first' | 'last' = 'first') {
 	if (compactedPath.length == 0) {
 		return 0
 	}
@@ -425,7 +510,7 @@ function getMappedFrameIndexForPath(referenceFrameIndex: number, compactedPath:
 
 	let mappedFrameIndex: number
 
-	if (mappingKind == "first") {
+	if (mappingKind == 'first') {
 		mappedFrameIndex = compactedPathEntry.first
 	} else {
 		mappedFrameIndex = compactedPathEntry.last

package/src/api/API.ts

@@ -1,14 +1,15 @@
-/// <reference path="../typings/Fillers.d.ts" />
+/// <reference path='../typings/Fillers.d.ts' />
 
-export * from "./Common.js"
-export * from "./GlobalOptions.js"
-export * from "./Synthesis.js"
-export * from "./Recognition.js"
-export * from "./Alignment.js"
-export * from "./Translation.js"
-export * from "./LanguageDetection.js"
-export * from "./Vad.js"
-export * from "./Denoising.js"
-export * from "../server/Server.js"
-export * from "../server/Client.js"
-export { timelineToSubtitles, subtitlesToTimeline } from "../subtitles/Subtitles.js"
+export * from './Common.js'
+export * from './GlobalOptions.js'
+export * from './Synthesis.js'
+export * from './Recognition.js'
+export * from './Alignment.js'
+export * from './Translation.js'
+export * from './LanguageDetection.js'
+export * from './Vad.js'
+export * from './Denoising.js'
+export * from './SourceSeparation.js'
+export * from '../server/Server.js'
+export * from '../server/Client.js'
+export { timelineToSubtitles, subtitlesToTimeline } from '../subtitles/Subtitles.js'

package/src/api/APIOptions.ts

@@ -1,15 +1,16 @@
-import * as API from "./API.js"
-import type { ServerOptions } from "../server/Server.js"
+import * as API from './API.js'
+import type { ServerOptions } from '../server/Server.js'
 
-export type APIOptions = {
-	VoiceListRequestOptions: API.VoiceListRequestOptions,
-	SynthesisOptions: API.SynthesisOptions,
-	RecognitionOptions: API.RecognitionOptions,
-	AlignmentOptions: API.AlignmentOptions,
+export interface APIOptions {
+	VoiceListRequestOptions: API.VoiceListRequestOptions
+	SynthesisOptions: API.SynthesisOptions
+	RecognitionOptions: API.RecognitionOptions
+	AlignmentOptions: API.AlignmentOptions
 	SpeechTranslationOptions: API.SpeechTranslationOptions
-	SpeechLanguageDetectionOptions: API.SpeechLanguageDetectionOptions,
-	TextLanguageDetectionOptions: API.TextLanguageDetectionOptions,
-	VADOptions: API.VADOptions,
-	DenoisingOptions: API.DenoisingOptions,
+	SpeechLanguageDetectionOptions: API.SpeechLanguageDetectionOptions
+	TextLanguageDetectionOptions: API.TextLanguageDetectionOptions
+	VADOptions: API.VADOptions
+	DenoisingOptions: API.DenoisingOptions
+	SourceSeparationOptions: API.SourceSeparationOptions
 	ServerOptions: ServerOptions
 }