@segnavia/voice 0.2.0 → 0.4.0

package/dist/captions.d.ts

@@ -0,0 +1,4 @@
+import { Word } from "@segnavia/format";
+//#region src/captions.d.ts
+export declare function splitWords(text: string): string[];
+//#endregion

package/dist/captions.js

@@ -0,0 +1,13 @@
+//#region src/captions.ts
+function splitWords(text) {
+	return text.split(/\s+/).filter(Boolean);
+}
+function remapCaptionWords(words, script) {
+	const scriptWords = splitWords(script);
+	return words.length === scriptWords.length ? words.map((word, index) => ({
+		...word,
+		text: scriptWords[index] ?? word.text
+	})) : words;
+}
+//#endregion
+export { remapCaptionWords, splitWords };

package/dist/elevenlabs-lexicon.d.ts

@@ -0,0 +1,12 @@
+import { PronunciationDictionary } from "./index.js";
+import { Lexicon } from "@segnavia/format";
+//#region src/elevenlabs-lexicon.d.ts
+export declare function publishElevenLabsLexicon(options: {
+  apiKey: () => string;
+  lexicon: Lexicon;
+  name: string;
+  description?: string;
+  dictionaryId?: string;
+  phonemes?: boolean;
+}): Promise<PronunciationDictionary | null>;
+//#endregion

package/dist/elevenlabs-lexicon.js

@@ -0,0 +1,40 @@
+//#region src/elevenlabs-lexicon.ts
+async function publishElevenLabsLexicon(options) {
+	if (options.lexicon.entries.length === 0 && options.dictionaryId === void 0) return null;
+	const rules = options.lexicon.entries.map((entry) => options.phonemes === true && entry.ipa !== void 0 ? {
+		type: "phoneme",
+		string_to_replace: entry.term,
+		phoneme: entry.ipa,
+		alphabet: "ipa",
+		case_sensitive: true,
+		word_boundaries: true
+	} : {
+		type: "alias",
+		string_to_replace: entry.term,
+		alias: entry.say,
+		case_sensitive: true,
+		word_boundaries: true
+	});
+	const updating = options.dictionaryId !== void 0;
+	const path = updating ? `pronunciation-dictionaries/${encodeURIComponent(options.dictionaryId ?? "")}/set-rules` : "pronunciation-dictionaries/add-from-rules";
+	const response = await fetch(`https://api.elevenlabs.io/v1/${path}`, {
+		method: "POST",
+		headers: {
+			"xi-api-key": options.apiKey(),
+			"content-type": "application/json"
+		},
+		body: JSON.stringify(updating ? { rules } : {
+			name: options.name,
+			...options.description === void 0 ? {} : { description: options.description },
+			rules
+		})
+	});
+	if (!response.ok) throw new Error(`ElevenLabs refused the pronunciation dictionary: ${response.status} ${await response.text()}`);
+	const body = await response.json();
+	return {
+		id: body.id,
+		versionId: body.version_id
+	};
+}
+//#endregion
+export { publishElevenLabsLexicon };

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+import { splitWords } from "./captions.js";
+import { publishElevenLabsLexicon } from "./elevenlabs-lexicon.js";
+import { lexiconProvider } from "./lexicon-provider.js";
 import { Word } from "@segnavia/format";
 //#region src/index.d.ts
 export interface Speech {
@@ -12,7 +15,10 @@ export interface VoiceProvider {
   id: string;
   synthesize(text: string, voice?: string): Promise<Speech>;
 }
-export declare function splitWords(text: string): string[];
+export interface PronunciationDictionary {
+  id: string;
+  versionId?: string;
+}
 export declare function wordsFromCharacters(characters: string[], startsSec: number[], endsSec: number[]): Word[];
 export declare function pacedProvider(options?: {
   wordsPerMinute?: number;
@@ -21,6 +27,7 @@ export declare function elevenLabsProvider(options: {
   apiKey: () => string;
   voice: string;
   model?: string;
+  pronunciationDictionaries?: readonly PronunciationDictionary[];
 }): VoiceProvider;
 export declare function alignedProvider(options: {
   id: string;
@@ -40,4 +47,5 @@ export declare function narrate(provider: VoiceProvider, text: string, options:
   cacheDirectory: string;
   voice?: string;
 }): Promise<Narrated>;
-//#endregion
+//#endregion
+export { lexiconProvider, publishElevenLabsLexicon, splitWords };

package/dist/index.js

@@ -1,10 +1,10 @@
+import { remapCaptionWords, splitWords } from "./captions.js";
+import { publishElevenLabsLexicon } from "./elevenlabs-lexicon.js";
+import { lexiconProvider } from "./lexicon-provider.js";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 //#region src/index.ts
-function splitWords(text) {
-	return text.split(/\s+/).filter(Boolean);
-}
 function wordsFromCharacters(characters, startsSec, endsSec) {
 	const words = [];
 	let current = null;
@@ -54,8 +54,13 @@ function pacedProvider(options = {}) {
 	};
 }
 function elevenLabsProvider(options) {
+	const locators = (options.pronunciationDictionaries ?? []).map(({ id, versionId }) => ({
+		pronunciation_dictionary_id: id,
+		...versionId === void 0 ? {} : { version_id: versionId }
+	}));
+	if (locators.length > 3) throw new Error(`ElevenLabs accepts at most 3 pronunciation dictionaries; received ${locators.length}.`);
 	return {
-		id: `elevenlabs-${options.model ?? "eleven_multilingual_v2"}-${options.voice}`,
+		id: `${`elevenlabs-${options.model ?? "eleven_multilingual_v2"}-${options.voice}`}${locators.length > 0 ? `-${JSON.stringify(locators)}` : ""}`,
 		async synthesize(text, voice = options.voice) {
 			const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voice}/with-timestamps`, {
 				method: "POST",
@@ -65,14 +70,16 @@ function elevenLabsProvider(options) {
 				},
 				body: JSON.stringify({
 					text,
-					model_id: options.model ?? "eleven_multilingual_v2"
+					model_id: options.model ?? "eleven_multilingual_v2",
+					...locators.length > 0 ? { pronunciation_dictionary_locators: locators } : {}
 				})
 			});
 			if (!response.ok) throw new Error(`ElevenLabs refused the synthesis: ${response.status} ${await response.text()}`);
 			const body = await response.json();
 			const { characters, character_start_times_seconds: starts, character_end_times_seconds: ends } = body.alignment;
+			const words = wordsFromCharacters(characters, starts, ends);
 			return {
-				words: wordsFromCharacters(characters, starts, ends),
+				words: remapCaptionWords(words, text),
 				durationMs: Math.round((ends.at(-1) ?? 0) * 1e3) + 300,
 				audio: {
 					bytes: Buffer.from(body.audio_base64, "base64"),
@@ -125,4 +132,4 @@ async function narrate(provider, text, options) {
 	return narrated;
 }
 //#endregion
-export { alignedProvider, elevenLabsProvider, narrate, pacedProvider, splitWords, wordsFromCharacters };
+export { alignedProvider, elevenLabsProvider, lexiconProvider, narrate, pacedProvider, publishElevenLabsLexicon, splitWords, wordsFromCharacters };

package/dist/lexicon-provider.d.ts

@@ -0,0 +1,5 @@
+import { VoiceProvider } from "./index.js";
+import { Lexicon } from "@segnavia/format";
+//#region src/lexicon-provider.d.ts
+export declare function lexiconProvider(inner: VoiceProvider, lexicon: Lexicon): VoiceProvider;
+//#endregion

package/dist/lexicon-provider.js

@@ -0,0 +1,29 @@
+import { remapCaptionWords } from "./captions.js";
+import { lexiconVersion } from "@segnavia/format";
+//#region src/lexicon-provider.ts
+const WORD_CHARACTER = "[\\p{L}\\p{N}\\p{M}_]";
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function respell(text, lexicon) {
+	if (lexicon.entries.length === 0) return text;
+	const replacements = new Map(lexicon.entries.map((entry) => [entry.term, entry.say]));
+	const alternatives = [...replacements.keys()].sort((left, right) => right.length - left.length).map(escapeRegExp).join("|");
+	const terms = new RegExp(`(?<!${WORD_CHARACTER})(?:${alternatives})(?!${WORD_CHARACTER})`, "gu");
+	return text.replace(terms, (term) => replacements.get(term) ?? term);
+}
+function lexiconProvider(inner, lexicon) {
+	const fixedLexicon = { entries: lexicon.entries.map((entry) => ({ ...entry })) };
+	return {
+		id: `${inner.id}-lexicon-${lexiconVersion(fixedLexicon)}`,
+		async synthesize(text, voice) {
+			const speech = await inner.synthesize(respell(text, fixedLexicon), voice);
+			return {
+				...speech,
+				words: remapCaptionWords(speech.words, text)
+			};
+		}
+	};
+}
+//#endregion
+export { lexiconProvider };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/voice",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.2.0"
+    "@segnavia/format": "0.4.0"
   }
 }