echogarden 0.12.2 → 1.0.0

package/dist/cli/CLI.js

@@ -1,19 +1,19 @@
 import * as API from '../api/API.js';
 import { parseCLIArguments } from './CLIParser.js';
-import { convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements, getWithDefault, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from "../utilities/Utilities.js";
-import { getOptionTypeFromSchema } from "./CLIOptionsSchema.js";
-import { parseConfigFile, parseJSONConfigFile } from "./CLIConfigFile.js";
+import { convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements, getWithDefault, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from '../utilities/Utilities.js';
+import { getOptionTypeFromSchema } from './CLIOptionsSchema.js';
+import { parseConfigFile, parseJSONConfigFile } from './CLIConfigFile.js';
 import chalk from 'chalk';
-import { applyGainDecibels, encodeWaveBuffer, getEmptyRawAudio, getRawAudioDuration, normalizeAudioLevel, sliceRawAudioByTime } from "../audio/AudioUtilities.js";
-import { subtitlesToText, subtitlesToTimeline, timelineToSubtitles } from "../subtitles/Subtitles.js";
-import { Logger, resetActiveLogger } from "../utilities/Logger.js";
+import { applyGainDecibels, encodeRawAudioToWave, getEmptyRawAudio, getRawAudioDuration, normalizeAudioLevel, sliceRawAudioByTime } from '../audio/AudioUtilities.js';
+import { subtitlesToText, subtitlesToTimeline, timelineToSubtitles } from '../subtitles/Subtitles.js';
+import { Logger, resetActiveLogger } from '../utilities/Logger.js';
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { encodeFromChannels, getDefaultFFMpegOptionsForSpeech } from "../codecs/FFMpegTranscoder.js";
-import path, { parse as parsePath } from "node:path";
-import { splitToParagraphs, splitToWords, wordCharacterPattern } from "../nlp/Segmentation.js";
-import { playAudioSamples, playAudioWithWordTimeline } from "../audio/AudioPlayer.js";
-import { extendDeep } from "../utilities/ObjectUtilities.js";
-import { addTimeOffsetToTimeline, addWordTextOffsetsToTimeline, roundTimelineProperties } from "../utilities/Timeline.js";
+import { encodeFromChannels, getDefaultFFMpegOptionsForSpeech } from '../codecs/FFMpegTranscoder.js';
+import path, { parse as parsePath } from 'node:path';
+import { splitToParagraphs, splitToWords, wordCharacterPattern } from '../nlp/Segmentation.js';
+import { playAudioSamples, playAudioWithWordTimeline } from '../audio/AudioPlayer.js';
+import { extendDeep } from '../utilities/ObjectUtilities.js';
+import { addTimeOffsetToTimeline, addWordTextOffsetsToTimeline, roundTimelineProperties } from '../utilities/Timeline.js';
 import { ensureDir, existsSync, readAndParseJsonFile, readFile, readdir, writeFileSafe } from '../utilities/FileSystem.js';
 import { formatLanguageCodeWithName, getShortLanguageCode } from '../utilities/Locale.js';
 import { ensureAndGetPackagesDir, getVersionTagFromPackageName, loadPackage, resolveVersionTagForUnversionedPackageName } from '../utilities/PackageManager.js';
@@ -30,7 +30,7 @@ async function startIfInWorkerThread() {
     }
     setupUnhandledExceptionListeners();
     const initOpenPromise = new OpenPromise();
-    parentPort.once("message", (message) => {
+    parentPort.once('message', (message) => {
         if (message.name == 'init') {
             process.stderr.isTTY = message.stdErrIsTTY;
             process.stderr.hasColors = () => message.hasColors;
@@ -48,44 +48,44 @@ export async function start(processArgs) {
     const logger = new Logger();
     let args;
     try {
-        const packageData = await readAndParseJsonFile(resolveToModuleRootDir("package.json"));
+        const packageData = await readAndParseJsonFile(resolveToModuleRootDir('package.json'));
         logger.log(chalk.magentaBright(`Echogarden v${packageData.version}\n`));
         const command = processArgs[0];
-        if (!command || command == "help") {
-            logger.log(`Supported operations:\n\n${commandHelp.join("\n")}`);
+        if (!command || command == 'help') {
+            logger.log(`Supported operations:\n\n${commandHelp.join('\n')}`);
             process.exit(0);
         }
-        if (command == "--help") {
+        if (command == '--help') {
             logger.log(`There's no command called '--help'. Did you mean to run 'echogarden help'?`);
             process.exit(0);
         }
         args = parseCLIArguments(command, processArgs.slice(1));
-        if (!args.options.has("config")) {
+        if (!args.options.has('config')) {
             const defaultConfigFile = `./${appName}.config`;
-            const defaultJsonConfigFile = defaultConfigFile + ".json";
+            const defaultJsonConfigFile = defaultConfigFile + '.json';
             if (existsSync(defaultConfigFile)) {
-                args.options.set("config", defaultConfigFile);
+                args.options.set('config', defaultConfigFile);
             }
             else if (existsSync(defaultJsonConfigFile)) {
-                args.options.set("config", defaultJsonConfigFile);
+                args.options.set('config', defaultJsonConfigFile);
             }
         }
-        if (args.options.has("config")) {
-            const configFilePath = args.options.get("config");
-            args.options.delete("config");
+        if (args.options.has('config')) {
+            const configFilePath = args.options.get('config');
+            args.options.delete('config');
             let parsedOptionFile;
-            if (configFilePath.endsWith(".config")) {
+            if (configFilePath.endsWith('.config')) {
                 parsedOptionFile = await parseConfigFile(configFilePath);
             }
-            else if (configFilePath.endsWith(".config.json")) {
+            else if (configFilePath.endsWith('.config.json')) {
                 parsedOptionFile = await parseJSONConfigFile(configFilePath);
             }
             else {
                 throw new Error(`Specified config file '${configFilePath}' doesn't have a supported extension. Should be either '.config' or '.config.json'`);
             }
             let sectionName = args.command;
-            if (sectionName.startsWith("speak-")) {
-                sectionName = "speak";
+            if (sectionName.startsWith('speak-')) {
+                sectionName = 'speak';
             }
             const newOptions = parsedOptionFile.get(sectionName) || new Map();
             for (const [key, value] of args.options) {
@@ -142,7 +142,9 @@ const commandHelp = [
     `${executableName} ${chalk.magentaBright('detect-voice-activity')} audioFile [output files...] [options...]`,
     `    Detect voice activity in audio file\n`,
     `${executableName} ${chalk.magentaBright('denoise')} audioFile [output files...] [options...]`,
-    `    Denoise audio file\n`,
+    `    Apply speech denoising to audio file\n`,
+    `${executableName} ${chalk.magentaBright('isolate')} audioFile [output files...] [options...]`,
+    `    Extract isolated voice track from an audio file\n`,
     `${executableName} ${chalk.magentaBright('list-engines')} operation`,
     `    List available engines for the specified operation\n`,
     `${executableName} ${chalk.magentaBright('list-voices')} tts-engine [output files...] [options...]`,
@@ -181,15 +183,15 @@ async function startWithArgs(parsedArgs) {
             break;
         }
         case 'detect-language': {
-            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, "auto");
+            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, 'auto');
             break;
         }
         case 'detect-speech-language': {
-            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, "speech");
+            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, 'speech');
             break;
         }
         case 'detect-text-language': {
-            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, "text");
+            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, 'text');
             break;
         }
         case 'detect-voice-activity': {
@@ -200,6 +202,10 @@ async function startWithArgs(parsedArgs) {
             await denoise(parsedArgs.commandArgs, parsedArgs.options);
             break;
         }
+        case 'isolate': {
+            await isolate(parsedArgs.commandArgs, parsedArgs.options);
+            break;
+        }
         case 'list-engines': {
             await listEngines(parsedArgs.commandArgs, parsedArgs.options);
             break;
@@ -235,16 +241,16 @@ async function speak(command, commandArgs, cliOptions) {
     const mainArg = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (mainArg == undefined) {
-        if (command == "speak") {
+        if (command == 'speak') {
             throw new Error(`'speak' requires an argument containing the text to speak.`);
         }
-        else if (command == "speak-file") {
+        else if (command == 'speak-file') {
             throw new Error(`'speak-file' requires an argument containing the file to speak.`);
         }
-        else if (command == "speak-url") {
+        else if (command == 'speak-url') {
             throw new Error(`'speak-url' requires an argument containing the url to speak.`);
         }
-        else if (command == "speak-wikipedia") {
+        else if (command == 'speak-wikipedia') {
             throw new Error(`'speak-wikipedia' requires an argument containing the name of the Wikipedia article to speak.`);
         }
         return;
@@ -255,14 +261,14 @@ async function speak(command, commandArgs, cliOptions) {
     if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
         cliOptions.set('play', `${outputFilenames.length == 0}`);
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "SynthesisOptions", additionalOptionsSchema);
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'SynthesisOptions', additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
-    const { includesPartPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
+    const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
     let plainText = undefined;
     let textSegments;
     const plainTextParagraphBreaks = options.plainText?.paragraphBreaks || API.defaultSynthesisOptions.plainText.paragraphBreaks;
     const plainTextWhitespace = options.plainText?.whitespace || API.defaultSynthesisOptions.plainText.whitespace;
-    if (command == "speak") {
+    if (command == 'speak') {
         if (options.ssml) {
             textSegments = [mainArg];
         }
@@ -271,29 +277,29 @@ async function speak(command, commandArgs, cliOptions) {
         }
         plainText = mainArg;
     }
-    else if (command == "speak-file") {
+    else if (command == 'speak-file') {
         const sourceFile = mainArg;
         if (!existsSync(sourceFile)) {
             throw new Error(`The given source file '${sourceFile}' was not found.`);
         }
         const sourceFileExtension = getLowercaseFileExtension(sourceFile);
         const fileContent = await readFile(sourceFile, { encoding: 'utf-8' });
-        if (options.ssml && sourceFileExtension != "xml" && sourceFileExtension != "ssml") {
+        if (options.ssml && sourceFileExtension != 'xml' && sourceFileExtension != 'ssml') {
             throw new Error(`SSML option is set, but source file doesn't have an 'xml' or 'ssml' extension.`);
         }
-        if (sourceFileExtension == "txt") {
+        if (sourceFileExtension == 'txt') {
             textSegments = splitToParagraphs(fileContent, plainTextParagraphBreaks, plainTextWhitespace);
             plainText = fileContent;
         }
-        else if (sourceFileExtension == "html" || sourceFileExtension == "htm") {
+        else if (sourceFileExtension == 'html' || sourceFileExtension == 'htm') {
             const textContent = await convertHtmlToText(fileContent);
             textSegments = splitToParagraphs(textContent, 'single', 'preserve');
         }
-        else if (sourceFileExtension == "srt" || sourceFileExtension == "vtt") {
+        else if (sourceFileExtension == 'srt' || sourceFileExtension == 'vtt') {
             const fileContent = await readFile(sourceFile, { encoding: 'utf-8' });
             textSegments = subtitlesToTimeline(fileContent).map(entry => entry.text);
         }
-        else if (sourceFileExtension == "xml" || sourceFileExtension == "ssml") {
+        else if (sourceFileExtension == 'xml' || sourceFileExtension == 'ssml') {
             options.ssml = true;
             textSegments = [fileContent];
         }
@@ -301,34 +307,34 @@ async function speak(command, commandArgs, cliOptions) {
             throw new Error(`'speak-file' only supports inputs with extensions 'txt', 'html', 'htm', 'xml', 'ssml', 'srt', 'vtt'`);
         }
     }
-    else if (command == "speak-url") {
+    else if (command == 'speak-url') {
         if (options.ssml) {
             throw new Error(`speak-url doesn't provide SSML inputs`);
         }
         const url = mainArg;
-        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
             throw new Error(`'${url}' is not a valid URL. Only 'http://' and 'https://' protocols are supported`);
         }
-        const { fetchDocumentText } = await import("../utilities/WebReader.js");
+        const { fetchDocumentText } = await import('../utilities/WebReader.js');
         const textContent = await fetchDocumentText(url);
         textSegments = splitToParagraphs(textContent, 'single', 'preserve');
     }
-    else if (command == "speak-wikipedia") {
+    else if (command == 'speak-wikipedia') {
         if (options.ssml) {
             throw new Error(`speak-wikipedia doesn't provide SSML inputs`);
         }
-        const { parseWikipediaArticle } = await import("../utilities/WikipediaReader.js");
+        const { parseWikipediaArticle } = await import('../utilities/WikipediaReader.js');
         if (!options.language) {
-            options.language = "en";
+            options.language = 'en';
         }
         textSegments = await parseWikipediaArticle(mainArg, getShortLanguageCode(options.language));
     }
     else {
-        throw new Error("Invalid command");
+        throw new Error('Invalid command');
     }
     async function onSegment(segmentData) {
-        if (includesPartPattern) {
-            logger.start("Writing output files for segment");
+        if (includesPlaceholderPattern) {
+            logger.start('Write output files for segment');
         }
         await writeOutputFilesForSegment(outputFilenames, segmentData.index, segmentData.total, segmentData.audio, segmentData.timeline, segmentData.transcript, segmentData.language, allowOverwrite);
         logger.end();
@@ -348,15 +354,15 @@ async function speak(command, commandArgs, cliOptions) {
         addWordTextOffsetsToTimeline(timeline, plainText);
     }
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
+        logger.start('\nWrite output files');
     }
-    for (const outputFile of outputFilenames) {
-        const partPatternMatch = outputFile.match(segmentFilenamePattern);
-        if (partPatternMatch) {
+    for (const outputFilename of outputFilenames) {
+        const placeholderPatternMatch = outputFilename.match(filenamePlaceholderPattern);
+        if (placeholderPatternMatch) {
             continue;
         }
-        const fileSaver = getFileSaver(outputFile, allowOverwrite);
-        await fileSaver(synthesizedAudio, timeline, textSegments.join("\n\n"), options.subtitles);
+        const fileSaver = getFileSaver(outputFilename, allowOverwrite);
+        await fileSaver(synthesizedAudio, timeline, textSegments.join('\n\n'), options.subtitles);
     }
     logger.end();
 }
@@ -376,25 +382,33 @@ async function transcribe(commandArgs, cliOptions) {
     if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
         cliOptions.set('play', `${outputFilenames.length == 0}`);
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "RecognitionOptions", additionalOptionsSchema);
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'RecognitionOptions', additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
-    const { includesPartPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
-    const { transcript, timeline, wordTimeline, inputRawAudio, language } = await API.recognize(sourceFilename, options);
+    const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
+    const { transcript, timeline, wordTimeline, language, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.recognize(sourceFilename, options);
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
+        logger.start('\nWrite output files');
     }
-    for (const outputFile of outputFilenames) {
-        const partPatternMatch = outputFile.match(segmentFilenamePattern);
+    for (const outputFilename of outputFilenames) {
+        const partPatternMatch = outputFilename.match(filenamePlaceholderPattern);
         if (partPatternMatch) {
             continue;
         }
-        const fileSaver = getFileSaver(outputFile, allowOverwrite);
+        const fileSaver = getFileSaver(outputFilename, allowOverwrite);
         await fileSaver(inputRawAudio, timeline, transcript, options.subtitles);
+        await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true);
     }
     logger.end();
     if (options.play) {
-        const normalizedAudio = normalizeAudioLevel(inputRawAudio);
-        await playAudioWithWordTimeline(normalizedAudio, wordTimeline, transcript);
+        let audioToPlay;
+        if (isolatedRawAudio) {
+            audioToPlay = isolatedRawAudio;
+        }
+        else {
+            audioToPlay = inputRawAudio;
+        }
+        const normalizedAudioToPlay = normalizeAudioLevel(audioToPlay);
+        await playAudioWithWordTimeline(normalizedAudioToPlay, wordTimeline, transcript);
     }
 }
 async function align(commandArgs, cliOptions) {
@@ -417,13 +431,13 @@ async function align(commandArgs, cliOptions) {
     const referenceFileExtension = getLowercaseFileExtension(alignmentReferenceFile);
     const fileContent = await readFile(alignmentReferenceFile, { encoding: 'utf-8' });
     let text;
-    if (referenceFileExtension == "txt") {
+    if (referenceFileExtension == 'txt') {
         text = fileContent;
     }
-    else if (referenceFileExtension == "html" || referenceFileExtension == "htm") {
+    else if (referenceFileExtension == 'html' || referenceFileExtension == 'htm') {
         text = await convertHtmlToText(fileContent);
     }
-    else if (referenceFileExtension == "srt" || referenceFileExtension == "vtt") {
+    else if (referenceFileExtension == 'srt' || referenceFileExtension == 'vtt') {
         text = subtitlesToText(fileContent);
     }
     else {
@@ -435,14 +449,14 @@ async function align(commandArgs, cliOptions) {
     if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
         cliOptions.set('play', `${outputFilenames.length == 0}`);
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "AlignmentOptions", additionalOptionsSchema);
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'AlignmentOptions', additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
-    const { includesPartPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
-    const { timeline, wordTimeline, transcript, language, inputRawAudio } = await API.align(audioFilename, text, options);
+    const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
+    const { timeline, wordTimeline, transcript, language, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.align(audioFilename, text, options);
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
+        logger.start('\nWrite output files');
     }
-    if (includesPartPattern) {
+    if (includesPlaceholderPattern) {
         for (let segmentIndex = 0; segmentIndex < timeline.length; segmentIndex++) {
             const segmentEntry = timeline[segmentIndex];
             const segmentAudio = sliceRawAudioByTime(inputRawAudio, segmentEntry.startTime, segmentEntry.endTime);
@@ -450,18 +464,26 @@ async function align(commandArgs, cliOptions) {
             await writeOutputFilesForSegment(outputFilenames, segmentIndex, timeline.length, segmentAudio, sentenceTimeline, segmentEntry.text, language, allowOverwrite);
         }
     }
-    for (const outputFile of outputFilenames) {
-        const partPatternMatch = outputFile.match(segmentFilenamePattern);
+    for (const outputFilename of outputFilenames) {
+        const partPatternMatch = outputFilename.match(filenamePlaceholderPattern);
         if (partPatternMatch) {
             continue;
         }
-        const fileSaver = getFileSaver(outputFile, allowOverwrite);
+        const fileSaver = getFileSaver(outputFilename, allowOverwrite);
         await fileSaver(inputRawAudio, timeline, transcript, options.subtitles);
+        await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true);
     }
     logger.end();
     if (options.play) {
-        const normalizedAudio = normalizeAudioLevel(inputRawAudio);
-        await playAudioWithWordTimeline(normalizedAudio, wordTimeline, transcript);
+        let audioToPlay;
+        if (isolatedRawAudio) {
+            audioToPlay = isolatedRawAudio;
+        }
+        else {
+            audioToPlay = inputRawAudio;
+        }
+        const normalizedAudioToPlay = normalizeAudioLevel(audioToPlay);
+        await playAudioWithWordTimeline(normalizedAudioToPlay, wordTimeline, transcript);
     }
 }
 async function translateSpeech(commandArgs, cliOptions) {
@@ -480,25 +502,53 @@ async function translateSpeech(commandArgs, cliOptions) {
     if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
         cliOptions.set('play', `${outputFilenames.length == 0}`);
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "SpeechTranslationOptions", additionalOptionsSchema);
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'SpeechTranslationOptions', additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, true, true);
-    const { transcript, timeline, wordTimeline, sourceLanguage, targetLanguage, inputRawAudio } = await API.translateSpeech(inputFilename, options);
+    const { transcript, timeline, wordTimeline, sourceLanguage, targetLanguage, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.translateSpeech(inputFilename, options);
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
+        logger.start('\nWrite output files');
     }
-    for (const outputFile of outputFilenames) {
-        const partPatternMatch = outputFile.match(segmentFilenamePattern);
+    for (const outputFilename of outputFilenames) {
+        const partPatternMatch = outputFilename.match(filenamePlaceholderPattern);
         if (partPatternMatch) {
             continue;
         }
-        const fileSaver = getFileSaver(outputFile, allowOverwrite);
+        const fileSaver = getFileSaver(outputFilename, allowOverwrite);
         await fileSaver(inputRawAudio, timeline, transcript, options.subtitles);
+        await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true);
     }
     logger.end();
     if (options.play) {
-        const normalizedAudio = normalizeAudioLevel(inputRawAudio);
-        await playAudioWithWordTimeline(normalizedAudio, wordTimeline, transcript);
+        let audioToPlay;
+        if (isolatedRawAudio) {
+            audioToPlay = isolatedRawAudio;
+        }
+        else {
+            audioToPlay = inputRawAudio;
+        }
+        const normalizedAudioToPlay = normalizeAudioLevel(audioToPlay);
+        let transcriptToPlay;
+        let timelineToPlay;
+        if (wordTimeline) {
+            transcriptToPlay = transcript;
+            timelineToPlay = wordTimeline;
+        }
+        else {
+            timelineToPlay = timeline.map(entry => ({
+                type: 'word',
+                text: entry.text.trim(),
+                startTime: entry.startTime,
+                endTime: entry.endTime
+            }));
+            transcriptToPlay = '';
+            for (const entry of timelineToPlay) {
+                transcriptToPlay += entry.text;
+                transcriptToPlay += ' ';
+            }
+            transcriptToPlay = transcriptToPlay.trim();
+        }
+        await playAudioWithWordTimeline(normalizedAudioToPlay, timelineToPlay, transcriptToPlay);
     }
 }
 async function detectLanguage(commandArgs, cliOptions, mode) {
@@ -511,21 +561,21 @@ async function detectLanguage(commandArgs, cliOptions, mode) {
     const additionalOptionsSchema = new Map();
     additionalOptionsSchema.set('overwrite', { type: 'boolean' });
     const inputFileExtension = getLowercaseFileExtension(inputFilePath);
-    const supportedInputTextFormats = ["txt", "srt", "vtt"];
+    const supportedInputTextFormats = ['txt', 'srt', 'vtt'];
     let results;
     let allowOverwrite;
-    if (mode == "text" || (mode == "auto" && supportedInputTextFormats.includes(inputFileExtension))) {
+    if (mode == 'text' || (mode == 'auto' && supportedInputTextFormats.includes(inputFileExtension))) {
         if (inputFilePath == undefined) {
             throw new Error(`detect-text-language requires an argument containing the input file path.`);
         }
         if (!supportedInputTextFormats.includes(inputFileExtension)) {
             throw new Error(`'detect-text-language' doesn't support input file extension '${inputFileExtension}'`);
         }
-        const options = await cliOptionsMapToOptionsObject(cliOptions, "TextLanguageDetectionOptions", additionalOptionsSchema);
+        const options = await cliOptionsMapToOptionsObject(cliOptions, 'TextLanguageDetectionOptions', additionalOptionsSchema);
         allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
         await checkOutputFilenames(outputFilenames, false, true, false);
-        let text = await readFile(inputFilePath, { encoding: "utf-8" });
-        if (inputFileExtension == "srt" || inputFileExtension == "vtt") {
+        let text = await readFile(inputFilePath, { encoding: 'utf-8' });
+        if (inputFileExtension == 'srt' || inputFileExtension == 'vtt') {
             text = subtitlesToText(text);
         }
         const { detectedLanguage, detectedLanguageProbabilities } = await API.detectTextLanguage(text, options);
@@ -535,23 +585,23 @@ async function detectLanguage(commandArgs, cliOptions, mode) {
         if (inputFilePath == undefined) {
             throw new Error(`detect-speech-language requires an argument containing the input audio file path.`);
         }
-        const options = await cliOptionsMapToOptionsObject(cliOptions, "SpeechLanguageDetectionOptions", additionalOptionsSchema);
+        const options = await cliOptionsMapToOptionsObject(cliOptions, 'SpeechLanguageDetectionOptions', additionalOptionsSchema);
         allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
         await checkOutputFilenames(outputFilenames, false, true, false);
         const { detectedLanguage, detectedLanguageProbabilities } = await API.detectSpeechLanguage(inputFilePath, options);
         results = detectedLanguageProbabilities;
     }
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
-        const resultsAsText = results.map(result => `${formatLanguageCodeWithName(result.language)}: ${result.probability.toFixed(5)}`).join("\n");
-        for (const outputFile of outputFilenames) {
-            const fileSaver = getFileSaver(outputFile, allowOverwrite);
+        logger.start('\nWrite output files');
+        const resultsAsText = results.map(result => `${formatLanguageCodeWithName(result.language)}: ${result.probability.toFixed(5)}`).join('\n');
+        for (const outputFilename of outputFilenames) {
+            const fileSaver = getFileSaver(outputFilename, allowOverwrite);
             await fileSaver(getEmptyRawAudio(0, 0), results, resultsAsText);
         }
     }
     else {
-        const resultsAsText = results.slice(0, 10).map(result => `${formatLanguageCodeWithName(result.language)}: ${result.probability.toFixed(5)}`).join("\n");
-        logger.log("");
+        const resultsAsText = results.slice(0, 10).map(result => `${formatLanguageCodeWithName(result.language)}: ${result.probability.toFixed(5)}`).join('\n');
+        logger.log('');
         logger.log(resultsAsText);
     }
     logger.end();
@@ -572,26 +622,33 @@ async function detectVoiceActivity(commandArgs, cliOptions) {
     if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
         cliOptions.set('play', `${outputFilenames.length == 0}`);
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "VADOptions", additionalOptionsSchema);
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'VADOptions', additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
-    await checkOutputFilenames(outputFilenames, true, true, false);
-    const { timeline, inputRawAudio } = await API.detectVoiceActivity(audioFilename, options);
+    await checkOutputFilenames(outputFilenames, true, true, true);
+    let { timeline, verboseTimeline, inputRawAudio, croppedRawAudio } = await API.detectVoiceActivity(audioFilename, options);
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
+        logger.start('\nWrite output files');
     }
-    for (const outputFile of outputFilenames) {
-        const partPatternMatch = outputFile.match(segmentFilenamePattern);
+    for (const outputFilename of outputFilenames) {
+        const partPatternMatch = outputFilename.match(filenamePlaceholderPattern);
         if (partPatternMatch) {
             continue;
         }
-        const fileSaver = getFileSaver(outputFile, allowOverwrite);
-        await fileSaver(inputRawAudio, timeline, "");
+        const fileSaver = getFileSaver(outputFilename, allowOverwrite);
+        await fileSaver(inputRawAudio, timeline, '', { maxAddedDuration: 0 });
+        const fileExtension = getLowercaseFileExtension(outputFilename);
+        if (supportedOutputMediaFileExtensions.includes(fileExtension)) {
+            const pathWithoutExtension = outputFilename.substring(0, outputFilename.lastIndexOf('.'));
+            const isolatedOutputFilePath = `${pathWithoutExtension}.cropped.${fileExtension}`;
+            const fileSaver = getFileSaver(isolatedOutputFilePath, allowOverwrite);
+            await fileSaver(croppedRawAudio, [], '');
+        }
     }
     logger.end();
     if (options.play) {
         const normalizedAudio = normalizeAudioLevel(inputRawAudio);
-        const timelineToPlay = timeline.map(entry => {
-            return { ...entry, type: "word" };
+        const timelineToPlay = verboseTimeline.map(entry => {
+            return { ...entry, type: 'word' };
         });
         await playAudioWithWordTimeline(normalizedAudio, timelineToPlay);
     }
@@ -612,22 +669,53 @@ async function denoise(commandArgs, cliOptions) {
     if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
         cliOptions.set('play', `${outputFilenames.length == 0}`);
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "DenoisingOptions", additionalOptionsSchema);
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'DenoisingOptions', additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, false, false);
     const { denoisedAudio } = await API.denoise(audioFilename, options);
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
+        logger.start('\nWrite output files');
     }
-    for (const filename of outputFilenames) {
-        const fileSaver = getFileSaver(filename, allowOverwrite);
-        await fileSaver(denoisedAudio, [], "");
+    for (const outputFilename of outputFilenames) {
+        const fileSaver = getFileSaver(outputFilename, allowOverwrite);
+        await fileSaver(denoisedAudio, [], '');
     }
     logger.end();
     if (options.play) {
         await playAudioSamples(denoisedAudio);
     }
 }
+async function isolate(commandArgs, cliOptions) {
+    const logger = new Logger();
+    const audioFilename = commandArgs[0];
+    const outputFilenames = commandArgs.slice(1);
+    if (audioFilename == undefined) {
+        throw new Error(`'isolate' requires an argument containing the audio file path.`);
+    }
+    if (!existsSync(audioFilename)) {
+        throw new Error(`The given source audio file '${audioFilename}' was not found.`);
+    }
+    const additionalOptionsSchema = new Map();
+    additionalOptionsSchema.set('play', { type: 'boolean' });
+    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
+    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
+        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    }
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'SourceSeparationOptions', additionalOptionsSchema);
+    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    await checkOutputFilenames(outputFilenames, true, false, false);
+    const { inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.isolate(audioFilename, options);
+    if (outputFilenames.length > 0) {
+        logger.start('\nWrite output files');
+    }
+    for (let outputFilename of outputFilenames) {
+        await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, false);
+    }
+    logger.end();
+    if (options.play) {
+        await playAudioSamples(isolatedRawAudio);
+    }
+}
 async function listEngines(commandArgs, cliOptions) {
     const logger = new Logger();
     const targetOperation = commandArgs[0];
@@ -643,6 +731,10 @@ async function listEngines(commandArgs, cliOptions) {
             engines = API.synthesisEngines;
             break;
         }
+        case 'list-voices': {
+            engines = API.synthesisEngines;
+            break;
+        }
         case 'transcribe': {
             engines = API.recognitionEngines;
             break;
@@ -675,8 +767,8 @@ async function listEngines(commandArgs, cliOptions) {
             engines = API.denoisingEngines;
             break;
         }
-        case 'list-voices': {
-            engines = API.synthesisEngines;
+        case 'isolate': {
+            engines = API.sourceSeparationEngines;
             break;
         }
         case 'list-engines':
@@ -695,7 +787,7 @@ async function listEngines(commandArgs, cliOptions) {
         logger.logTitledMessage('Description', engine.description);
         logger.logTitledMessage('Type', engine.type);
         if (index < engines.length - 1) {
-            logger.log("");
+            logger.log('');
         }
     }
 }
@@ -705,19 +797,19 @@ async function listTTSVoices(commandArgs, cliOptions) {
     const outputFilenames = commandArgs.slice(1);
     if (!targetEngine) {
         const optionsSchema = await getOptionsSchema();
-        const { enum: ttsEnginesEnum } = getOptionTypeFromSchema(["VoiceListRequestOptions", "engine"], optionsSchema);
-        throw new Error(`list-voices requires an argument specifying one of these supported engines:\n${ttsEnginesEnum.join(", ")}`);
+        const { enum: ttsEnginesEnum } = getOptionTypeFromSchema(['VoiceListRequestOptions', 'engine'], optionsSchema);
+        throw new Error(`list-voices requires an argument specifying one of these supported engines:\n${ttsEnginesEnum.join(', ')}`);
     }
     const additionalOptionsSchema = new Map();
     additionalOptionsSchema.set('overwrite', { type: 'boolean' });
     cliOptions.set('engine', targetEngine);
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "VoiceListRequestOptions", additionalOptionsSchema);
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'VoiceListRequestOptions', additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, false, true, false);
     const { voiceList } = await API.requestVoiceList(options);
     const voiceListText = voiceList.map(entry => {
         const nameText = entry.name;
-        const languagesNamesText = entry.languages.map(language => formatLanguageCodeWithName(language)).join(", ");
+        const languagesNamesText = entry.languages.map(language => formatLanguageCodeWithName(language)).join(', ');
         const genderText = entry.gender;
         let entryText = `${chalk.cyanBright('Identifier')}: ${chalk.magentaBright(nameText)}\n${chalk.cyanBright('Languages')}: ${languagesNamesText}\n${chalk.cyanBright('Gender')}: ${genderText}`;
         const speakerCount = entry.speakerCount;
@@ -725,9 +817,9 @@ async function listTTSVoices(commandArgs, cliOptions) {
             entryText += `\n${chalk.cyanBright('Speaker count')}: ${speakerCount}`;
         }
         return entryText;
-    }).join("\n\n");
+    }).join('\n\n');
     if (outputFilenames.length > 0) {
-        logger.start("\nWriting output files");
+        logger.start('\nWrite output files');
         for (const filename of outputFilenames) {
             const fileSaver = getFileSaver(filename, allowOverwrite);
             const { default: stripAnsi } = await import('strip-ansi');
@@ -743,7 +835,7 @@ async function listTTSVoices(commandArgs, cliOptions) {
 async function installPackages(commandArgs, cliOptions) {
     const logger = new Logger();
     if (commandArgs.length == 0) {
-        throw new Error("No package names specified");
+        throw new Error('No package names specified');
     }
     const failedPackageNames = [];
     for (const packageName of commandArgs) {
@@ -768,7 +860,7 @@ async function installPackages(commandArgs, cliOptions) {
 async function uninstallPackages(commandArgs, cliOptions) {
     const logger = new Logger();
     if (commandArgs.length == 0) {
-        throw new Error("No package names specified");
+        throw new Error('No package names specified');
     }
     const failedPackageNames = [];
     for (const packageName of commandArgs) {
@@ -805,16 +897,33 @@ async function listPackages(commandArgs, cliOptions) {
     });
     installedPackageNamesFormatted.sort();
     logger.log(`Total of ${installedPackageNamesFormatted.length} packages installed in '${packagesDir}'\n`);
-    logger.log(installedPackageNamesFormatted.join("\n"));
+    logger.log(installedPackageNamesFormatted.join('\n'));
 }
 async function serve(commandArgs, cliOptions) {
-    const options = await cliOptionsMapToOptionsObject(cliOptions, "ServerOptions");
+    const options = await cliOptionsMapToOptionsObject(cliOptions, 'ServerOptions');
     async function onServerStarted(serverOptions) {
         // Run a test routine (early development)
         //await runClientWebSocketTest(serverOptions.port!, serverOptions.secure!)
     }
     await startServer(options, onServerStarted);
 }
+async function writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, prefixIsolated) {
+    // Write source separation output if needed
+    const fileExtension = getLowercaseFileExtension(outputFilename);
+    if (isolatedRawAudio && backgroundRawAudio && supportedOutputMediaFileExtensions.includes(fileExtension)) {
+        const pathWithoutExtension = outputFilename.substring(0, outputFilename.lastIndexOf('.'));
+        {
+            const isolatedOutputFilePath = prefixIsolated ? `${pathWithoutExtension}.isolated.${fileExtension}` : outputFilename;
+            const fileSaver = getFileSaver(isolatedOutputFilePath, allowOverwrite);
+            await fileSaver(isolatedRawAudio, [], '');
+        }
+        {
+            const backgroundOutputFilePath = `${pathWithoutExtension}.background.${fileExtension}`;
+            const fileSaver = getFileSaver(backgroundOutputFilePath, allowOverwrite);
+            await fileSaver(backgroundRawAudio, [], '');
+        }
+    }
+}
 async function cliOptionsMapToOptionsObject(cliOptionsMap, optionsRoot, additionalOptionsSchema) {
     const optionsSchema = await getOptionsSchema();
     const resultingObj = {};
@@ -835,14 +944,14 @@ async function cliOptionsMapToOptionsObject(cliOptionsMap, optionsRoot, addition
     }
     for (let [key, value] of cliOptionsMap) {
         let isNegated = false;
-        if (key.startsWith("no-")) {
+        if (key.startsWith('no-')) {
             isNegated = true;
             key = key.slice(3);
             if (value) {
                 throw new Error(`The negated property '${key}' cannot have a value.`);
             }
         }
-        const path = key.split(".");
+        const path = key.split('.');
         let optionType;
         let optionEnum;
         let optionIsUnion;
@@ -908,7 +1017,7 @@ async function cliOptionsMapToOptionsObject(cliOptionsMap, optionsRoot, addition
             parsedValue = value;
         }
         if (optionEnum && !optionEnum.includes(parsedValue)) {
-            throw new Error(`The property '${key}' must be one of ${optionEnum.join(", ")}`);
+            throw new Error(`The property '${key}' must be one of ${optionEnum.join(', ')}`);
         }
         setValueAtPath(path, parsedValue);
     }
@@ -917,7 +1026,7 @@ async function cliOptionsMapToOptionsObject(cliOptionsMap, optionsRoot, addition
 let cachedOptionsSchema;
 export async function getOptionsSchema() {
     if (!cachedOptionsSchema) {
-        cachedOptionsSchema = await readAndParseJsonFile(resolveToModuleRootDir("data/schemas/options.json"));
+        cachedOptionsSchema = await readAndParseJsonFile(resolveToModuleRootDir('data/schemas/options.json'));
     }
     return cachedOptionsSchema;
 }
@@ -932,11 +1041,11 @@ export async function checkOutputFilenames(outputFilenames, acceptMediaOutputs,
     if (acceptSubtitleOutputs) {
         supportedFileExtensions.push(...supportedSubtitleFileExtensions);
     }
-    let includesPartPattern = false;
+    let includesPlaceholderPattern = false;
     for (const outputFilename of outputFilenames) {
         const fileExtension = getLowercaseFileExtension(outputFilename);
         if (!supportedFileExtensions.includes(fileExtension)) {
-            let errorText = "";
+            let errorText = '';
             errorText += `\nThe specified output path '${outputFilename}' doesn't have a supported file extension.\n`;
             errorText += `\nSupported extensions are:\n`;
             if (acceptMediaOutputs) {
@@ -945,50 +1054,50 @@ export async function checkOutputFilenames(outputFilenames, acceptMediaOutputs,
             if (acceptMetadataOutputs) {
                 errorText += `${formatListWithQuotedElements(supportedMetadataFileExtensions)} for metadata output files.\n`;
             }
-            if (acceptMetadataOutputs) {
+            if (acceptSubtitleOutputs) {
                 errorText += `${formatListWithQuotedElements(supportedSubtitleFileExtensions)} for subtitle output files.\n`;
             }
             throw new Error(errorText);
         }
-        const partPatternMatch = outputFilename.match(segmentFilenamePattern);
-        if (partPatternMatch) {
-            if (partPatternMatch[1] != "segment") {
-                throw new Error(`Invalid square bracket pattern: '${partPatternMatch[1]}'. Square bracket output filename pattern currently only supports the value 'segment'. For example: '/segment/[segment].wav'`);
+        const placeholderPatternMatch = outputFilename.match(filenamePlaceholderPattern);
+        if (placeholderPatternMatch) {
+            if (placeholderPatternMatch[1] != 'segment') {
+                throw new Error(`Invalid placeholder pattern: '${placeholderPatternMatch[1]}'. Placeholder output filename pattern currently only supports 'segment'. For example: '/out/[segment].wav'`);
             }
-            includesPartPattern = true;
+            includesPlaceholderPattern = true;
         }
     }
-    return { includesPartPattern };
+    return { includesPlaceholderPattern };
 }
 export async function writeOutputFilesForSegment(outputFilenames, index, total, audio, timeline, text, language, allowOverwrite) {
     const digitCount = Math.max((total + 1).toString().length, 2);
     const segmentWords = (await splitToWords(text, language)).filter(text => wordCharacterPattern.test(text));
-    const segmentJoinedWords = segmentWords.join(" ").trim();
+    const segmentJoinedWords = segmentWords.join(' ').trim();
     let initialText;
     const maxLength = 50;
     if (segmentJoinedWords.length < maxLength) {
         initialText = segmentJoinedWords.substring(0, maxLength).trim();
     }
     else {
-        initialText = segmentJoinedWords.substring(0, maxLength - 4).trim() + ".. ";
+        initialText = segmentJoinedWords.substring(0, maxLength - 4).trim() + '.. ';
     }
     for (const outputFilename of outputFilenames) {
-        const partPatternMatch = outputFilename.match(segmentFilenamePattern);
-        if (!partPatternMatch) {
+        const placeholderPatternMatch = outputFilename.match(filenamePlaceholderPattern);
+        if (!placeholderPatternMatch) {
             continue;
         }
-        const segmentFilename = outputFilename.replace(segmentFilenamePattern, `${formatIntegerWithLeadingZeros(index + 1, digitCount)} - ${initialText}.$2`);
+        const segmentFilename = outputFilename.replace(filenamePlaceholderPattern, `${formatIntegerWithLeadingZeros(index + 1, digitCount)} - ${initialText}.$2`);
         const fileSaver = getFileSaver(segmentFilename, allowOverwrite);
         await fileSaver(audio, timeline, text);
     }
 }
 function getFileSaver(outputFilePath, allowOverwrite) {
     const parsedPath = parsePath(outputFilePath);
-    const fileDir = parsedPath.dir || "./";
+    const fileDir = parsedPath.dir || './';
     if (!allowOverwrite) {
         const filenameParts = splitFilenameOnExtendedExtension(parsedPath.base);
         for (let i = 1; existsSync(outputFilePath); i++) {
-            outputFilePath = path.join(parsedPath.dir, `${filenameParts[0]} (${i})`);
+            outputFilePath = path.join(parsedPath.dir, `${filenameParts[0]}_${formatIntegerWithLeadingZeros(i, 3)}`);
             if (filenameParts[1]) {
                 outputFilePath += `.${filenameParts[1]}`;
             }
@@ -996,24 +1105,24 @@ function getFileSaver(outputFilePath, allowOverwrite) {
     }
     const fileExtension = getLowercaseFileExtension(outputFilePath);
     let fileSaver;
-    if (fileExtension == "txt") {
+    if (fileExtension == 'txt') {
         fileSaver = async (audio, timeline, text) => {
             await ensureDir(fileDir);
-            return writeFileSafe(outputFilePath, text, { encoding: "utf-8" });
+            return writeFileSafe(outputFilePath, text, { encoding: 'utf-8' });
         };
     }
-    else if (fileExtension == "json") {
+    else if (fileExtension == 'json') {
         fileSaver = async (audio, timeline, text) => {
             await ensureDir(fileDir);
             const roundedTimeline = roundTimelineProperties(timeline);
             return writeFileSafe(outputFilePath, stringifyAndFormatJson(roundedTimeline));
         };
     }
-    else if (fileExtension == "srt") {
+    else if (fileExtension == 'srt') {
         fileSaver = async (audio, timeline, text, subtitlesConfig) => {
             await ensureDir(fileDir);
             const extraSubtitleConfigOptions = {
-                format: "srt",
+                format: 'srt',
                 originalText: text,
                 totalDuration: getRawAudioDuration(audio)
             };
@@ -1022,11 +1131,11 @@ function getFileSaver(outputFilePath, allowOverwrite) {
             return writeFileSafe(outputFilePath, subtitles);
         };
     }
-    else if (fileExtension == "vtt") {
+    else if (fileExtension == 'vtt') {
         fileSaver = async (audio, timeline, text, subtitlesConfig) => {
             await ensureDir(fileDir);
             const extraSubtitleConfigOptions = {
-                format: "webvtt",
+                format: 'webvtt',
                 originalText: text,
                 totalDuration: getRawAudioDuration(audio)
             };
@@ -1035,10 +1144,10 @@ function getFileSaver(outputFilePath, allowOverwrite) {
             return writeFileSafe(outputFilePath, subtitles);
         };
     }
-    else if (fileExtension == "wav") {
+    else if (fileExtension == 'wav') {
         fileSaver = async (audio) => {
             await ensureDir(fileDir);
-            return writeFileSafe(outputFilePath, encodeWaveBuffer(audio));
+            return writeFileSafe(outputFilePath, encodeRawAudioToWave(audio));
         };
     }
     else if (supportedOutputMediaFileExtensions.includes(fileExtension)) {
@@ -1051,14 +1160,14 @@ function getFileSaver(outputFilePath, allowOverwrite) {
         };
     }
     else {
-        throw new Error("Unsupported file extension");
+        throw new Error('Unsupported output file extension');
     }
     return fileSaver;
 }
 const supportedMetadataFileExtensions = ['txt', 'json'];
 const supportedSubtitleFileExtensions = ['srt', 'vtt'];
-const supportedOutputMediaFileExtensions = ["wav", "mp3", "opus", "m4a", "ogg", "flac"];
-const segmentFilenamePattern = /\[(.*)\]\.(.*)$/;
+const supportedOutputMediaFileExtensions = ['wav', 'mp3', 'opus', 'm4a', 'ogg', 'flac'];
+const filenamePlaceholderPattern = /\[(.*)\]\.(.*)$/;
 const overwriteByDefault = false;
 startIfInWorkerThread();
 //# sourceMappingURL=CLI.js.map