Skip to content

GitLab

Commit 033f82a9 authored by guobj's avatar guobj
Browse files

init 

2025/04/10 15:55:52
parent ef72564b
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 10064 additions and 0 deletions
kokoro.js/demo/package-lock.json 0 → 100644
View file @ 033f82a9
This diff is collapsed.
kokoro.js/demo/package.json 0 → 100644
View file @ 033f82a9
{
"name": "kokoro-web",
"private": true,
"version": "0.0.0",
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build",
"lint": "eslint .",
"preview": "vite preview"
},
"dependencies": {
"kokoro-js": "file:..",
"motion": "^11.12.0",
"react": "^18.3.1",
"react-dom": "^18.3.1"
},
"devDependencies": {
"@eslint/js": "^9.15.0",
"@types/react": "^18.3.12",
"@types/react-dom": "^18.3.1",
"@vitejs/plugin-react": "^4.3.4",
"autoprefixer": "^10.4.20",
"eslint": "^9.15.0",
"eslint-plugin-react": "^7.37.2",
"eslint-plugin-react-hooks": "^5.0.0",
"eslint-plugin-react-refresh": "^0.4.14",
"globals": "^15.12.0",
"postcss": "^8.4.49",
"tailwindcss": "^3.4.15",
"vite": "^6.0.1"
}
}
kokoro.js/demo/postcss.config.js 0 → 100644
View file @ 033f82a9
export default {
plugins: {
tailwindcss: {},
autoprefixer: {},
},
};
kokoro.js/demo/public/hf-logo.svg 0 → 100644
View file @ 033f82a9
This diff is collapsed.
kokoro.js/demo/public/wave.svg 0 → 100644
View file @ 033f82a9
<svg xmlns="http://www.w3.org/2000/svg" width="1600" height="198">
<defs>
<linearGradient id="a" x1="50%" x2="50%" y1="-10.959%" y2="100%">
<stop stop-color="#57BBC1" stop-opacity=".25" offset="0%"/>
<stop stop-color="#015871" offset="100%"/>
</linearGradient>
</defs>
<path fill="url(#a)" fill-rule="evenodd" d="M.005 121C311 121 409.898-.25 811 0c400 0 500 121 789 121v77H0s.005-48 .005-77z" transform="matrix(-1 0 0 1 1600 0)"/>
</svg>
kokoro.js/demo/src/App.jsx 0 → 100644
View file @ 033f82a9
import { useRef, useState, useEffect } from "react";
import { motion } from "motion/react";
export default function App() {
// Create a reference to the worker object.
const worker = useRef(null);
const [inputText, setInputText] = useState("Life is like a box of chocolates. You never know what you're gonna get.");
const [selectedSpeaker, setSelectedSpeaker] = useState("af_heart");
const [voices, setVoices] = useState([]);
const [status, setStatus] = useState(null);
const [error, setError] = useState(null);
const [loadingMessage, setLoadingMessage] = useState("Loading...");
const [results, setResults] = useState([]);
// We use the `useEffect` hook to setup the worker as soon as the `App` component is mounted.
useEffect(() => {
// Create the worker if it does not yet exist.
worker.current ??= new Worker(new URL("./worker.js", import.meta.url), {
type: "module",
});
// Create a callback function for messages from the worker thread.
const onMessageReceived = (e) => {
switch (e.data.status) {
case "device":
setLoadingMessage(`Loading model (device="${e.data.device}")`);
break;
case "ready":
setStatus("ready");
setVoices(e.data.voices);
break;
case "error":
setError(e.data.data);
break;
case "complete":
const { audio, text } = e.data;
// Generation complete: re-enable the "Generate" button
setResults((prev) => [{ text, src: audio }, ...prev]);
setStatus("ready");
break;
}
};
const onErrorReceived = (e) => {
console.error("Worker error:", e);
setError(e.message);
};
// Attach the callback function as an event listener.
worker.current.addEventListener("message", onMessageReceived);
worker.current.addEventListener("error", onErrorReceived);
// Define a cleanup function for when the component is unmounted.
return () => {
worker.current.removeEventListener("message", onMessageReceived);
worker.current.removeEventListener("error", onErrorReceived);
};
}, []);
const handleSubmit = (e) => {
e.preventDefault();
setStatus("running");
worker.current.postMessage({
type: "generate",
text: inputText.trim(),
voice: selectedSpeaker,
});
};
return (
<div className="relative w-full min-h-screen bg-gradient-to-br from-gray-900 to-gray-700 flex flex-col items-center justify-center p-4 relative overflow-hidden font-sans">
<motion.div initial={{ opacity: 1 }} animate={{ opacity: status === null ? 1 : 0 }} transition={{ duration: 0.5 }} className="absolute w-screen h-screen justify-center flex flex-col items-center z-10 bg-gray-800/95 backdrop-blur-md" style={{ pointerEvents: status === null ? "auto" : "none" }}>
<div className="w-[250px] h-[250px] border-4 border-white shadow-[0_0_0_5px_#4973ff] rounded-full overflow-hidden">
<div className="loading-wave"></div>
</div>
<p className={`text-3xl my-5 text-center ${error ? "text-red-500" : "text-white"}`}>{error ?? loadingMessage}</p>
</motion.div>
<div className="max-w-3xl w-full space-y-8 relative z-[2]">
<div className="text-center">
<h1 className="text-5xl font-extrabold text-gray-100 mb-2 drop-shadow-lg font-heading">Kokoro Text-to-Speech</h1>
<p className="text-2xl text-gray-300 font-semibold font-subheading">
Powered by&nbsp;
<a href="https://github.com/hexgrad/kokoro" target="_blank" rel="noreferrer" className="underline">
Kokoro
</a>
&nbsp;and&nbsp;
<a href="https://huggingface.co/docs/transformers.js" target="_blank" rel="noreferrer" className="underline">
<img width="40" src="hf-logo.svg" className="inline translate-y-[-2px] me-1"></img>Transformers.js
</a>
</p>
</div>
<div className="bg-gray-800/50 backdrop-blur-sm border border-gray-700 rounded-lg p-6">
<form onSubmit={handleSubmit} className="space-y-4">
<textarea placeholder="Enter text..." value={inputText} onChange={(e) => setInputText(e.target.value)} className="w-full min-h-[100px] max-h-[300px] bg-gray-700/50 backdrop-blur-sm border-2 border-gray-600 rounded-xl resize-y text-gray-100 placeholder-gray-400 px-3 py-2 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent" rows={Math.min(8, inputText.split("\n").length)} />
<div className="flex flex-col items-center space-y-4">
<select value={selectedSpeaker} onChange={(e) => setSelectedSpeaker(e.target.value)} className="w-full bg-gray-700/50 backdrop-blur-sm border-2 border-gray-600 rounded-xl text-gray-100 px-3 py-2 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent">
{Object.entries(voices).map(([id, voice]) => (
<option key={id} value={id}>
{voice.name} ({voice.language === "en-us" ? "American" : "British"} {voice.gender})
</option>
))}
</select>
<button type="submit" className="inline-flex justify-center items-center px-6 py-2 text-lg font-semibold bg-gradient-to-t from-blue-600 to-purple-600 hover:from-blue-700 hover:to-purple-700 transition-colors duration-300 rounded-xl text-white disabled:opacity-50" disabled={status === "running" || inputText.trim() === ""}>
{status === "running" ? "Generating..." : "Generate"}
</button>
</div>
</form>
</div>
{results.length > 0 && (
<motion.div initial={{ y: 50, opacity: 0 }} animate={{ y: 0, opacity: 1 }} transition={{ duration: 0.5 }} className="max-h-[250px] overflow-y-auto px-2 mt-4 space-y-6 relative z-[2]">
{results.map((result, i) => (
<div key={i}>
<div className="text-white bg-gray-800/70 backdrop-blur-sm border border-gray-700 rounded-lg p-4 z-10">
<span className="absolute right-5 font-bold">#{results.length - i}</span>
<p className="mb-3 max-w-[95%]">{result.text}</p>
<audio controls src={result.src} className="w-full">
Your browser does not support the audio element.
</audio>
</div>
</div>
))}
</motion.div>
)}
</div>
<div className="bg-[#015871] pointer-events-none absolute left-0 w-full h-[5%] bottom-[-50px]">
<div className="wave"></div>
<div className="wave"></div>
</div>
</div>
);
}
kokoro.js/demo/src/index.css 0 → 100644
View file @ 033f82a9
@tailwind base;
@tailwind components;
@tailwind utilities;
/*
* Wave animations adapted from the following two demos:
* - https://codepen.io/upasanaasopa/pen/poObEWZ
* - https://codepen.io/breakstorm00/pen/qBJZQNB
*/
*,
*:before,
*:after {
margin: 0;
padding: 0;
box-sizing: border-box;
}
.loading-wave {
position: relative;
top: 0;
width: 100%;
height: 100%;
background: #2c74b3;
border-radius: 50%;
box-shadow: inset 0 0 50px 0 rgba(0, 0, 0, 0.5);
}
.loading-wave:before,
.loading-wave:after {
content: "";
position: absolute;
top: 0;
left: 50%;
width: 200%;
height: 200%;
background: black;
transform: translate(-50%, -75%);
}
.loading-wave:before {
border-radius: 45%;
background: rgba(255, 255, 255, 1);
animation: animate 5s linear infinite;
}
.loading-wave:after {
border-radius: 40%;
background: rgba(255, 255, 255, 0.5);
animation: animate 10s linear infinite;
}
.wave {
background: url(/wave.svg) repeat-x;
position: absolute;
top: -198px;
width: 6400px;
height: 198px;
animation: wave 7s cubic-bezier(0.36, 0.45, 0.63, 0.53) infinite;
transform: translate3d(0, 0, 0);
}
.wave:nth-of-type(2) {
top: -175px;
animation:
wave 7s cubic-bezier(0.36, 0.45, 0.63, 0.53) -0.125s infinite,
swell 7s ease -1.25s infinite;
opacity: 1;
}
@keyframes wave {
0% {
margin-left: 0;
}
100% {
margin-left: -1600px;
}
}
@keyframes swell {
0%,
100% {
transform: translate3d(0, -25px, 0);
}
50% {
transform: translate3d(0, 5px, 0);
}
}
@keyframes animate {
0% {
transform: translate(-50%, -75%) rotate(0deg);
}
100% {
transform: translate(-50%, -75%) rotate(360deg);
}
}
kokoro.js/demo/src/main.jsx 0 → 100644
View file @ 033f82a9
import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import "./index.css";
import App from "./App.jsx";
createRoot(document.getElementById("root")).render(
<StrictMode>
<App />
</StrictMode>,
);
kokoro.js/demo/src/utils.js 0 → 100644
View file @ 033f82a9
export async function detectWebGPU() {
try {
const adapter = await navigator.gpu.requestAdapter();
return !!adapter;
} catch (e) {
return false;
}
}
kokoro.js/demo/src/worker.js 0 → 100644
View file @ 033f82a9
import { KokoroTTS } from "kokoro-js";
import { detectWebGPU } from "./utils.js";
// Device detection
const device = (await detectWebGPU()) ? "webgpu" : "wasm";
self.postMessage({ status: "device", device });
// Load the model
const model_id = "onnx-community/Kokoro-82M-v1.0-ONNX";
const tts = await KokoroTTS.from_pretrained(model_id, {
dtype: device === "wasm" ? "q8" : "fp32",
device,
}).catch((e) => {
self.postMessage({ status: "error", error: e.message });
throw e;
});
self.postMessage({ status: "ready", voices: tts.voices, device });
// Listen for messages from the main thread
self.addEventListener("message", async (e) => {
const { text, voice } = e.data;
// Generate speech
const audio = await tts.generate(text, { voice });
// Send the audio file back to the main thread
const blob = audio.toBlob();
self.postMessage({ status: "complete", audio: URL.createObjectURL(blob), text });
});
kokoro.js/demo/tailwind.config.js 0 → 100644
View file @ 033f82a9
/** @type {import('tailwindcss').Config} */
export default {
content: ["./index.html", "./src/**/*.{js,ts,jsx,tsx}"],
theme: {
extend: {},
},
plugins: [],
};
kokoro.js/demo/vite.config.js 0 → 100644
View file @ 033f82a9
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
// https://vite.dev/config/
export default defineConfig({
plugins: [react()],
worker: { format: "es" },
build: {
target: "esnext",
},
logLevel: process.env.NODE_ENV === "development" ? "error" : "info",
});
kokoro.js/package-lock.json 0 → 100644
View file @ 033f82a9
This diff is collapsed.
kokoro.js/package.json 0 → 100644
View file @ 033f82a9
{
"name": "kokoro-js",
"version": "1.2.0",
"type": "module",
"exports": {
"types": "./types/kokoro.d.ts",
"node": {
"import": "./dist/kokoro.js",
"require": "./dist/kokoro.cjs"
},
"default": "./dist/kokoro.web.js"
},
"scripts": {
"build": "rm -rf dist types && rollup -c && tsc && cp ../LICENSE LICENSE",
"format": "prettier --write . --print-width 1000",
"test": "vitest run"
},
"keywords": [
"kokoro",
"tts",
"text-to-speech"
],
"author": {
"name": "hexgrad",
"email": "hello@hexgrad.com"
},
"browser": {
"path": false,
"fs/promises": false
},
"contributors": [
"Xenova"
],
"license": "Apache-2.0",
"description": "High-quality text-to-speech for the web",
"dependencies": {
"@huggingface/transformers": "^3.3.3",
"phonemizer": "^1.2.1"
},
"devDependencies": {
"@rollup/plugin-node-resolve": "^16.0.0",
"@rollup/plugin-terser": "^0.4.4",
"prettier": "3.4.2",
"rollup": "^4.30.1",
"typescript": "^5.7.3",
"vitest": "^2.1.8"
},
"files": [
"types",
"dist",
"voices",
"README.md",
"LICENSE"
],
"homepage": "https://github.com/hexgrad/kokoro",
"repository": {
"type": "git",
"url": "git+https://github.com/hexgrad/kokoro.git"
},
"publishConfig": {
"access": "public"
},
"jsdelivr": "./dist/kokoro.web.js",
"unpkg": "./dist/kokoro.web.js"
}
kokoro.js/rollup.config.js 0 → 100644
View file @ 033f82a9
import terser from "@rollup/plugin-terser";
import { nodeResolve } from "@rollup/plugin-node-resolve";
const plugins = (browser) => [nodeResolve({ browser }), terser({ format: { comments: false } })];
const OUTPUT_CONFIGS = [
// Node versions
{
file: "./dist/kokoro.cjs",
format: "cjs",
},
{
file: "./dist/kokoro.js",
format: "esm",
},
// Web version
{
file: "./dist/kokoro.web.js",
format: "esm",
},
];
const WEB_SPECIFIC_CONFIG = {
onwarn: (warning, warn) => {
if (!warning.message.includes("@huggingface/transformers")) warn(warning);
},
};
const NODE_SPECIFIC_CONFIG = {
external: ["@huggingface/transformers", "phonemizer"],
};
export default OUTPUT_CONFIGS.map((output) => {
const web = output.file.endsWith(".web.js");
return {
input: "./src/kokoro.js",
output,
plugins: plugins(web),
...(web ? WEB_SPECIFIC_CONFIG : NODE_SPECIFIC_CONFIG),
};
});
kokoro.js/src/kokoro.js 0 → 100644
View file @ 033f82a9
import { StyleTextToSpeech2Model, AutoTokenizer, Tensor, RawAudio } from "@huggingface/transformers";
import { phonemize } from "./phonemize.js";
import { TextSplitterStream } from "./splitter.js";
import { getVoiceData, VOICES } from "./voices.js";
const STYLE_DIM = 256;
const SAMPLE_RATE = 24000;
/**
* @typedef {Object} GenerateOptions
* @property {keyof typeof VOICES} [voice="af_heart"] The voice
* @property {number} [speed=1] The speaking speed
*/
/**
* @typedef {Object} StreamProperties
* @property {RegExp} [split_pattern] The pattern to split the input text. If unset, the default sentence splitter will be used.
* @typedef {GenerateOptions & StreamProperties} StreamGenerateOptions
*/
export class KokoroTTS {
/**
* Create a new KokoroTTS instance.
* @param {import('@huggingface/transformers').StyleTextToSpeech2Model} model The model
* @param {import('@huggingface/transformers').PreTrainedTokenizer} tokenizer The tokenizer
*/
constructor(model, tokenizer) {
this.model = model;
this.tokenizer = tokenizer;
}
/**
* Load a KokoroTTS model from the Hugging Face Hub.
* @param {string} model_id The model id
* @param {Object} options Additional options
* @param {"fp32"|"fp16"|"q8"|"q4"|"q4f16"} [options.dtype="fp32"] The data type to use.
* @param {"wasm"|"webgpu"|"cpu"|null} [options.device=null] The device to run the model on.
* @param {import("@huggingface/transformers").ProgressCallback} [options.progress_callback=null] A callback function that is called with progress information.
* @returns {Promise<KokoroTTS>} The loaded model
*/
static async from_pretrained(model_id, { dtype = "fp32", device = null, progress_callback = null } = {}) {
const model = StyleTextToSpeech2Model.from_pretrained(model_id, { progress_callback, dtype, device });
const tokenizer = AutoTokenizer.from_pretrained(model_id, { progress_callback });
const info = await Promise.all([model, tokenizer]);
return new KokoroTTS(...info);
}
get voices() {
return VOICES;
}
list_voices() {
console.table(VOICES);
}
_validate_voice(voice) {
if (!VOICES.hasOwnProperty(voice)) {
console.error(`Voice "${voice}" not found. Available voices:`);
console.table(VOICES);
throw new Error(`Voice "${voice}" not found. Should be one of: ${Object.keys(VOICES).join(", ")}.`);
}
const language = /** @type {"a"|"b"} */ (voice.at(0)); // "a" or "b"
return language;
}
/**
* Generate audio from text.
*
* @param {string} text The input text
* @param {GenerateOptions} options Additional options
* @returns {Promise<RawAudio>} The generated audio
*/
async generate(text, { voice = "af_heart", speed = 1 } = {}) {
const language = this._validate_voice(voice);
const phonemes = await phonemize(text, language);
const { input_ids } = this.tokenizer(phonemes, {
truncation: true,
});
return this.generate_from_ids(input_ids, { voice, speed });
}
/**
* Generate audio from input ids.
* @param {Tensor} input_ids The input ids
* @param {GenerateOptions} options Additional options
* @returns {Promise<RawAudio>} The generated audio
*/
async generate_from_ids(input_ids, { voice = "af_heart", speed = 1 } = {}) {
// Select voice style based on number of input tokens
const num_tokens = Math.min(Math.max(input_ids.dims.at(-1) - 2, 0), 509);
// Load voice style
const data = await getVoiceData(voice);
const offset = num_tokens * STYLE_DIM;
const voiceData = data.slice(offset, offset + STYLE_DIM);
// Prepare model inputs
const inputs = {
input_ids,
style: new Tensor("float32", voiceData, [1, STYLE_DIM]),
speed: new Tensor("float32", [speed], [1]),
};
// Generate audio
const { waveform } = await this.model(inputs);
return new RawAudio(waveform.data, SAMPLE_RATE);
}
/**
* Generate audio from text in a streaming fashion.
* @param {string|TextSplitterStream} text The input text
* @param {StreamGenerateOptions} options Additional options
* @returns {AsyncGenerator<{text: string, phonemes: string, audio: RawAudio}, void, void>}
*/
async *stream(text, { voice = "af_heart", speed = 1, split_pattern = null } = {}) {
const language = this._validate_voice(voice);
/** @type {TextSplitterStream} */
let splitter;
if (text instanceof TextSplitterStream) {
splitter = text;
} else if (typeof text === "string") {
splitter = new TextSplitterStream();
const chunks = split_pattern
? text
.split(split_pattern)
.map((chunk) => chunk.trim())
.filter((chunk) => chunk.length > 0)
: [text];
splitter.push(...chunks);
} else {
throw new Error("Invalid input type. Expected string or TextSplitterStream.");
}
for await (const sentence of splitter) {
const phonemes = await phonemize(sentence, language);
const { input_ids } = this.tokenizer(phonemes, {
truncation: true,
});
// TODO: There may be some cases where - even with splitting - the text is too long.
// In that case, we should split the text into smaller chunks and process them separately.
// For now, we just truncate these exceptionally long chunks
const audio = await this.generate_from_ids(input_ids, { voice, speed });
yield { text: sentence, phonemes, audio };
}
}
}
export { TextSplitterStream };
kokoro.js/src/phonemize.js 0 → 100644
View file @ 033f82a9
import { phonemize as espeakng } from "phonemizer";
/**
* Helper function to split a string on a regex, but keep the delimiters.
* This is required, because the JavaScript `.split()` method does not keep the delimiters,
* and wrapping in a capturing group causes issues with existing capturing groups (due to nesting).
* @param {string} text The text to split.
* @param {RegExp} regex The regex to split on.
* @returns {{match: boolean; text: string}[]} The split string.
*/
function split(text, regex) {
const result = [];
let prev = 0;
for (const match of text.matchAll(regex)) {
const fullMatch = match[0];
if (prev < match.index) {
result.push({ match: false, text: text.slice(prev, match.index) });
}
if (fullMatch.length > 0) {
result.push({ match: true, text: fullMatch });
}
prev = match.index + fullMatch.length;
}
if (prev < text.length) {
result.push({ match: false, text: text.slice(prev) });
}
return result;
}
/**
* Helper function to split numbers into phonetic equivalents
* @param {string} match The matched number
* @returns {string} The phonetic equivalent
*/
function split_num(match) {
if (match.includes(".")) {
return match;
} else if (match.includes(":")) {
let [h, m] = match.split(":").map(Number);
if (m === 0) {
return `${h} o'clock`;
} else if (m < 10) {
return `${h} oh ${m}`;
}
return `${h} ${m}`;
}
let year = parseInt(match.slice(0, 4), 10);
if (year < 1100 || year % 1000 < 10) {
return match;
}
let left = match.slice(0, 2);
let right = parseInt(match.slice(2, 4), 10);
let suffix = match.endsWith("s") ? "s" : "";
if (year % 1000 >= 100 && year % 1000 <= 999) {
if (right === 0) {
return `${left} hundred${suffix}`;
} else if (right < 10) {
return `${left} oh ${right}${suffix}`;
}
}
return `${left} ${right}${suffix}`;
}
/**
* Helper function to format monetary values
* @param {string} match The matched currency
* @returns {string} The formatted currency
*/
function flip_money(match) {
const bill = match[0] === "$" ? "dollar" : "pound";
if (isNaN(Number(match.slice(1)))) {
return `${match.slice(1)} ${bill}s`;
} else if (!match.includes(".")) {
let suffix = match.slice(1) === "1" ? "" : "s";
return `${match.slice(1)} ${bill}${suffix}`;
}
const [b, c] = match.slice(1).split(".");
const d = parseInt(c.padEnd(2, "0"), 10);
let coins = match[0] === "$" ? (d === 1 ? "cent" : "cents") : d === 1 ? "penny" : "pence";
return `${b} ${bill}${b === "1" ? "" : "s"} and ${d} ${coins}`;
}
/**
* Helper function to process decimal numbers
* @param {string} match The matched number
* @returns {string} The formatted number
*/
function point_num(match) {
let [a, b] = match.split(".");
return `${a} point ${b.split("").join(" ")}`;
}
/**
* Normalize text for phonemization
* @param {string} text The text to normalize
* @returns {string} The normalized text
*/
function normalize_text(text) {
return (
text
// 1. Handle quotes and brackets
.replace(/[‘’]/g, "'")
.replace(/«/g, "“")
.replace(/»/g, "”")
.replace(/[“”]/g, '"')
.replace(/\(/g, "«")
.replace(/\)/g, "»")
// 2. Replace uncommon punctuation marks
.replace(/、/g, ", ")
.replace(/。/g, ". ")
.replace(/！/g, "! ")
.replace(/，/g, ", ")
.replace(/：/g, ": ")
.replace(/；/g, "; ")
.replace(/？/g, "? ")
// 3. Whitespace normalization
.replace(/[^\S \n]/g, " ")
.replace(/ +/, " ")
.replace(/(?<=\n) +(?=\n)/g, "")
// 4. Abbreviations
.replace(/\bD[Rr]\.(?= [A-Z])/g, "Doctor")
.replace(/\b(?:Mr\.|MR\.(?= [A-Z]))/g, "Mister")
.replace(/\b(?:Ms\.|MS\.(?= [A-Z]))/g, "Miss")
.replace(/\b(?:Mrs\.|MRS\.(?= [A-Z]))/g, "Mrs")
.replace(/\betc\.(?! [A-Z])/gi, "etc")
// 5. Normalize casual words
.replace(/\b(y)eah?\b/gi, "$1e'a")
// 5. Handle numbers and currencies
.replace(/\d*\.\d+|\b\d{4}s?\b|(?<!:)\b(?:[1-9]|1[0-2]):[0-5]\d\b(?!:)/g, split_num)
.replace(/(?<=\d),(?=\d)/g, "")
.replace(/[$£]\d+(?:\.\d+)?(?: hundred| thousand| (?:[bm]|tr)illion)*\b|[$£]\d+\.\d\d?\b/gi, flip_money)
.replace(/\d*\.\d+/g, point_num)
.replace(/(?<=\d)-(?=\d)/g, " to ")
.replace(/(?<=\d)S/g, " S")
// 6. Handle possessives
.replace(/(?<=[BCDFGHJ-NP-TV-Z])'?s\b/g, "'S")
.replace(/(?<=X')S\b/g, "s")
// 7. Handle hyphenated words/letters
.replace(/(?:[A-Za-z]\.){2,} [a-z]/g, (m) => m.replace(/\./g, "-"))
.replace(/(?<=[A-Z])\.(?=[A-Z])/gi, "-")
// 8. Strip leading and trailing whitespace
.trim()
);
}
/**
* Escapes regular expression special characters from a string by replacing them with their escaped counterparts.
*
* @param {string} string The string to escape.
* @returns {string} The escaped string.
*/
function escapeRegExp(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}
const PUNCTUATION = ';:,.!?¡¿—…"«»“”(){}[]';
const PUNCTUATION_PATTERN = new RegExp(`(\\s*[${escapeRegExp(PUNCTUATION)}]+\\s*)+`, "g");
/**
* Phonemize text using the eSpeak-NG phonemizer
* @param {string} text The text to phonemize
* @param {"a"|"b"} language The language to use
* @param {boolean} norm Whether to normalize the text
* @returns {Promise<string>} The phonemized text
*/
export async function phonemize(text, language = "a", norm = true) {
// 1. Normalize text
if (norm) {
text = normalize_text(text);
}
// 2. Split into chunks, to ensure we preserve punctuation
const sections = split(text, PUNCTUATION_PATTERN);
// 3. Convert each section to phonemes
const lang = language === "a" ? "en-us" : "en";
const ps = (await Promise.all(sections.map(async ({ match, text }) => (match ? text : (await espeakng(text, lang)).join(" "))))).join("");
// 4. Post-process phonemes
let processed = ps
// https://en.wiktionary.org/wiki/kokoro#English
.replace(/kəkˈoːɹoʊ/g, "kˈoʊkəɹoʊ")
.replace(/kəkˈɔːɹəʊ/g, "kˈəʊkəɹəʊ")
.replace(/ʲ/g, "j")
.replace(/r/g, "ɹ")
.replace(/x/g, "k")
.replace(/ɬ/g, "l")
.replace(/(?<=[a-zɹː])(?=hˈʌndɹɪd)/g, " ")
.replace(/ z(?=[;:,.!?¡¿—…"«»“” ]|$)/g, "z");
// 5. Additional post-processing for American English
if (language === "a") {
processed = processed.replace(/(?<=nˈaɪn)ti(?!ː)/g, "di");
}
return processed.trim();
}
kokoro.js/src/splitter.js 0 → 100644
View file @ 033f82a9
/**
* Returns true if the character is considered a sentence terminator.
* This includes ASCII (".", "!", "?") and common Unicode terminators.
* NOTE: We also include newlines here, as this is favourable for text-to-speech systems.
* @param {string} c The character to test.
* @param {boolean} [includeNewlines=true] Whether to treat newlines as terminators.
* @returns {boolean}
*/
function isSentenceTerminator(c, includeNewlines = true) {
return ".!?…。？！".includes(c) || (includeNewlines && c === "\n");
}
/**
* Returns true if the character should be attached to the sentence terminator,
* such as closing quotes or brackets.
* @param {string} c The character to test.
* @returns {boolean}
*/
function isTrailingChar(c) {
return "\"')]}」』".includes(c);
}
/**
* Extracts a token (a contiguous sequence of non–whitespace characters)
* from the buffer starting at the given index.
* @param {string} buffer The input text.
* @param {number} start The starting index.
* @returns {string} The extracted token.
*/
function getTokenFromBuffer(buffer, start) {
let end = start;
while (end < buffer.length && !/\s/.test(buffer[end])) {
++end;
}
return buffer.substring(start, end);
}
// List of common abbreviations. Note that strings with single letters joined by periods
// (e.g., "i.e", "e.g", "u.s.a", "u.s") are handled separately.
const ABBREVIATIONS = new Set(["mr", "mrs", "ms", "dr", "prof", "sr", "jr", "sgt", "col", "gen", "rep", "sen", "gov", "lt", "maj", "capt", "st", "mt", "etc", "co", "inc", "ltd", "dept", "vs", "p", "pg", "jan", "feb", "mar", "apr", "jun", "jul", "aug", "sep", "sept", "oct", "nov", "dec", "sun", "mon", "tu", "tue", "tues", "wed", "th", "thu", "thur", "thurs", "fri", "sat"]);
/**
* Determines if the given token (or series of initials) is a known abbreviation.
* @param {string} token The token to check.
* @returns {boolean}
*/
function isAbbreviation(token) {
// Remove possessive endings and trailing periods.
token = token.replace(/['’]s$/i, "").replace(/\.+$/, "");
return ABBREVIATIONS.has(token.toLowerCase());
}
// Map of closing punctuation to their corresponding opening punctuation.
const MATCHING = new Map([
[")", "("],
["]", "["],
["}", "{"],
["》", "《"],
["〉", "〈"],
["›", "‹"],
["»", "«"],
["〉", "〈"],
["」", "「"],
["』", "『"],
["〕", "〔"],
["】", "【"],
]);
// Set of opening punctuation characters.
const OPENING = new Set(MATCHING.values());
/**
* Updates the nesting stack to track quotes and paired punctuation.
* This supports both standard (", ', (), [], {}) and Japanese quotes (「」「』『』).
* (An apostrophe between letters is ignored so that contractions remain intact.)
* @param {string} c The current character.
* @param {string[]} stack The current nesting stack.
* @param {number} i The index of the character in the buffer.
* @param {string} buffer The full text being processed.
*/
function updateStack(c, stack, i, buffer) {
// Handle standard quotes.
if (c === '"' || c === "'") {
// Ignore an apostrophe if it's between letters (e.g., in contractions).
if (c === "'" && i > 0 && i < buffer.length - 1 && /[A-Za-z]/.test(buffer[i - 1]) && /[A-Za-z]/.test(buffer[i + 1])) {
return;
}
if (stack.length && stack.at(-1) === c) {
stack.pop();
} else {
stack.push(c);
}
return;
}
// Handle opening punctuation.
if (OPENING.has(c)) {
stack.push(c);
return;
}
// Handle closing punctuation.
const expectedOpening = MATCHING.get(c);
if (expectedOpening && stack.length && stack.at(-1) === expectedOpening) {
stack.pop();
}
}
/**
* A simple stream-based text splitter that emits complete sentences.
*/
export class TextSplitterStream {
constructor() {
this._buffer = "";
this._sentences = [];
this._resolver = null;
this._closed = false;
}
/**
* Push one or more text chunks into the stream.
* @param {...string} texts Text fragments to process.
*/
push(...texts) {
for (const txt of texts) {
this._buffer += txt;
this._process();
}
}
/**
* Closes the stream, signaling that no more text will be pushed.
* This will flush any remaining text in the buffer as a sentence
* and allow the consuming process to finish processing the stream.
*/
close() {
if (this._closed) {
throw new Error("Stream is already closed.");
}
this._closed = true;
this.flush();
}
/**
* Flushes any remaining text in the buffer as a sentence.
*/
flush() {
const remainder = this._buffer.trim();
if (remainder.length > 0) {
this._sentences.push(remainder);
}
this._buffer = "";
this._resolve();
}
/**
* Resolve the pending promise to signal that sentences are available.
* @private
*/
_resolve() {
if (this._resolver) {
this._resolver();
this._resolver = null;
}
}
/**
* Processes the internal buffer to extract complete sentences.
* If the potential sentence boundary is at the end of the current buffer,
* it waits for more text before splitting.
* @private
*/
_process() {
let sentenceStart = 0;
const buffer = this._buffer;
const len = buffer.length;
let i = 0;
let stack = [];
// Helper to scan from the current index over trailing terminators and punctuation.
const scanBoundary = (idx) => {
let end = idx;
// Consume contiguous sentence terminators (excluding newlines).
while (end + 1 < len && isSentenceTerminator(buffer[end + 1], false)) {
++end;
}
// Consume trailing characters (e.g., closing quotes/brackets).
while (end + 1 < len && isTrailingChar(buffer[end + 1])) {
++end;
}
let nextNonSpace = end + 1;
while (nextNonSpace < len && /\s/.test(buffer[nextNonSpace])) {
++nextNonSpace;
}
return { end, nextNonSpace };
};
while (i < len) {
const c = buffer[i];
updateStack(c, stack, i, buffer);
// Only consider splitting if we're not inside any nested structure.
if (stack.length === 0 && isSentenceTerminator(c)) {
const currentSegment = buffer.slice(sentenceStart, i);
// Skip splitting for likely numbered lists (e.g., "1." or "\n2.").
if (/(^|\n)\d+$/.test(currentSegment)) {
++i;
continue;
}
const { end: boundaryEnd, nextNonSpace } = scanBoundary(i);
// If the terminator is not a newline and there's no extra whitespace,
// we might be in the middle of a token (e.g., "$9.99"), so skip splitting.
if (i === nextNonSpace - 1 && c !== "\n") {
++i;
continue;
}
// Wait for more text if there's no non-whitespace character yet.
if (nextNonSpace === len) {
break;
}
// Determine the token immediately preceding the terminator.
let tokenStart = i - 1;
while (tokenStart >= 0 && /\S/.test(buffer[tokenStart])) {
tokenStart--;
}
tokenStart = Math.max(sentenceStart, tokenStart + 1);
const token = getTokenFromBuffer(buffer, tokenStart);
if (!token) {
++i;
continue;
}
// --- URL/email protection ---
// If the token appears to be a URL or email (contains "://" or "@")
// and does not already end with a terminator, skip splitting.
if ((/https?[,:]\/\//.test(token) || token.includes("@")) && !isSentenceTerminator(token.at(-1))) {
i = tokenStart + token.length;
continue;
}
// --- Abbreviation protection ---
if (isAbbreviation(token)) {
++i;
continue;
}
// --- Middle initials heuristic ---
// If the token is a series of single-letter initials (each ending in a period)
// and is followed by a capitalized word, assume it's part of a name.
if (/^([A-Za-z]\.)+$/.test(token) && nextNonSpace < len && /[A-Z]/.test(buffer[nextNonSpace])) {
++i;
continue;
}
// --- Lookahead heuristic ---
// If the terminator is a period and the next non–whitespace character is lowercase,
// assume it is not the end of a sentence.
if (c === "." && nextNonSpace < len && /[a-z]/.test(buffer[nextNonSpace])) {
++i;
continue;
}
// Special case: ellipsis that stands alone should be merged with the following sentence.
const sentence = buffer.substring(sentenceStart, boundaryEnd + 1).trim();
if (sentence === "..." || sentence === "…") {
++i;
continue;
}
// Accept the sentence boundary.
if (sentence) {
this._sentences.push(sentence);
}
// Move to the next sentence.
i = sentenceStart = boundaryEnd + 1;
continue;
}
++i;
}
// Remove the processed portion of the buffer.
this._buffer = buffer.substring(sentenceStart);
// Resolve any pending promise if sentences are available.
if (this._sentences.length > 0) {
this._resolve();
}
}
/**
* Async iterator to yield sentences as they become available.
* @returns {AsyncGenerator<string, void, void>}
*/
async *[Symbol.asyncIterator]() {
if (this._resolver) {
throw new Error("Another iterator is already active.");
}
while (true) {
if (this._sentences.length > 0) {
yield this._sentences.shift();
} else if (this._closed) {
// No more text will be pushed.
break;
} else {
// Wait for more text.
await new Promise((resolve) => {
this._resolver = resolve;
});
}
}
}
/**
* Synchronous iterator that flushes the buffer and returns all sentences.
* @returns {Iterator<string>}
*/
[Symbol.iterator]() {
this.flush();
const iterator = this._sentences[Symbol.iterator]();
this._sentences = [];
return iterator;
}
/**
* Returns the array of sentences currently available.
* @type {string[]} The array of sentences.
* @readonly
*/
get sentences() {
return this._sentences;
}
}
/**
* Splits the input text into an array of sentences.
* @param {string} text The text to split.
* @returns {string[]} An array of sentences.
*/
export function split(text) {
const splitter = new TextSplitterStream();
splitter.push(text);
return [...splitter];
}
kokoro.js/src/voices.js 0 → 100644
View file @ 033f82a9
import path from "path";
import fs from "fs/promises";
export const VOICES = Object.freeze({
af_heart: {
name: "Heart",
language: "en-us",
gender: "Female",
traits: "❤️",
targetQuality: "A",
overallGrade: "A",
},
af_alloy: {
name: "Alloy",
language: "en-us",
gender: "Female",
targetQuality: "B",
overallGrade: "C",
},
af_aoede: {
name: "Aoede",
language: "en-us",
gender: "Female",
targetQuality: "B",
overallGrade: "C+",
},
af_bella: {
name: "Bella",
language: "en-us",
gender: "Female",
traits: "🔥",
targetQuality: "A",
overallGrade: "A-",
},
af_jessica: {
name: "Jessica",
language: "en-us",
gender: "Female",
targetQuality: "C",
overallGrade: "D",
},
af_kore: {
name: "Kore",
language: "en-us",
gender: "Female",
targetQuality: "B",
overallGrade: "C+",
},
af_nicole: {
name: "Nicole",
language: "en-us",
gender: "Female",
traits: "🎧",
targetQuality: "B",
overallGrade: "B-",
},
af_nova: {
name: "Nova",
language: "en-us",
gender: "Female",
targetQuality: "B",
overallGrade: "C",
},
af_river: {
name: "River",
language: "en-us",
gender: "Female",
targetQuality: "C",
overallGrade: "D",
},
af_sarah: {
name: "Sarah",
language: "en-us",
gender: "Female",
targetQuality: "B",
overallGrade: "C+",
},
af_sky: {
name: "Sky",
language: "en-us",
gender: "Female",
targetQuality: "B",
overallGrade: "C-",
},
am_adam: {
name: "Adam",
language: "en-us",
gender: "Male",
targetQuality: "D",
overallGrade: "F+",
},
am_echo: {
name: "Echo",
language: "en-us",
gender: "Male",
targetQuality: "C",
overallGrade: "D",
},
am_eric: {
name: "Eric",
language: "en-us",
gender: "Male",
targetQuality: "C",
overallGrade: "D",
},
am_fenrir: {
name: "Fenrir",
language: "en-us",
gender: "Male",
targetQuality: "B",
overallGrade: "C+",
},
am_liam: {
name: "Liam",
language: "en-us",
gender: "Male",
targetQuality: "C",
overallGrade: "D",
},
am_michael: {
name: "Michael",
language: "en-us",
gender: "Male",
targetQuality: "B",
overallGrade: "C+",
},
am_onyx: {
name: "Onyx",
language: "en-us",
gender: "Male",
targetQuality: "C",
overallGrade: "D",
},
am_puck: {
name: "Puck",
language: "en-us",
gender: "Male",
targetQuality: "B",
overallGrade: "C+",
},
am_santa: {
name: "Santa",
language: "en-us",
gender: "Male",
targetQuality: "C",
overallGrade: "D-",
},
bf_emma: {
name: "Emma",
language: "en-gb",
gender: "Female",
traits: "🚺",
targetQuality: "B",
overallGrade: "B-",
},
bf_isabella: {
name: "Isabella",
language: "en-gb",
gender: "Female",
targetQuality: "B",
overallGrade: "C",
},
bm_george: {
name: "George",
language: "en-gb",
gender: "Male",
targetQuality: "B",
overallGrade: "C",
},
bm_lewis: {
name: "Lewis",
language: "en-gb",
gender: "Male",
targetQuality: "C",
overallGrade: "D+",
},
bf_alice: {
name: "Alice",
language: "en-gb",
gender: "Female",
traits: "🚺",
targetQuality: "C",
overallGrade: "D",
},
bf_lily: {
name: "Lily",
language: "en-gb",
gender: "Female",
traits: "🚺",
targetQuality: "C",
overallGrade: "D",
},
bm_daniel: {
name: "Daniel",
language: "en-gb",
gender: "Male",
traits: "🚹",
targetQuality: "C",
overallGrade: "D",
},
bm_fable: {
name: "Fable",
language: "en-gb",
gender: "Male",
traits: "🚹",
targetQuality: "B",
overallGrade: "C",
},
// TODO: Add support for other languages:
// jf_alpha: {
// name: "alpha",
// language: "ja",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "C+",
// },
// jf_gongitsune: {
// name: "gongitsune",
// language: "ja",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "C",
// },
// jf_nezumi: {
// name: "nezumi",
// language: "ja",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "C-",
// },
// jf_tebukuro: {
// name: "tebukuro",
// language: "ja",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "C",
// },
// jm_kumo: {
// name: "kumo",
// language: "ja",
// gender: "Male",
// traits: "🚹",
// targetQuality: "B",
// overallGrade: "C-",
// },
// zf_xiaobei: {
// name: "xiaobei",
// language: "zh",
// gender: "Female",
// traits: "🚺",
// targetQuality: "C",
// overallGrade: "D",
// },
// zf_xiaoni: {
// name: "xiaoni",
// language: "zh",
// gender: "Female",
// traits: "🚺",
// targetQuality: "C",
// overallGrade: "D",
// },
// zf_xiaoxiao: {
// name: "xiaoxiao",
// language: "zh",
// gender: "Female",
// traits: "🚺",
// targetQuality: "C",
// overallGrade: "D",
// },
// zf_xiaoyi: {
// name: "xiaoyi",
// language: "zh",
// gender: "Female",
// traits: "🚺",
// targetQuality: "C",
// overallGrade: "D",
// },
// zm_yunjian: {
// name: "yunjian",
// language: "zh",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
// zm_yunxi: {
// name: "yunxi",
// language: "zh",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
// zm_yunxia: {
// name: "yunxia",
// language: "zh",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
// zm_yunyang: {
// name: "yunyang",
// language: "zh",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
// ef_dora: {
// name: "dora",
// language: "es",
// gender: "Female",
// traits: "🚺",
// targetQuality: "C",
// overallGrade: "D",
// },
// em_alex: {
// name: "alex",
// language: "es",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
// em_santa: {
// name: "santa",
// language: "es",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
// ff_siwis: {
// name: "siwis",
// language: "es",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "B-",
// },
// hf_alpha: {
// name: "alpha",
// language: "hi",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "C",
// },
// hf_beta: {
// name: "beta",
// language: "hi",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "C",
// },
// hm_omega: {
// name: "omega",
// language: "hi",
// gender: "Male",
// traits: "🚹",
// targetQuality: "B",
// overallGrade: "C",
// },
// hm_psi: {
// name: "psi",
// language: "hi",
// gender: "Male",
// traits: "🚹",
// targetQuality: "B",
// overallGrade: "C",
// },
// if_sara: {
// name: "sara",
// language: "it",
// gender: "Female",
// traits: "🚺",
// targetQuality: "B",
// overallGrade: "C",
// },
// im_nicola: {
// name: "nicola",
// language: "it",
// gender: "Male",
// traits: "🚹",
// targetQuality: "B",
// overallGrade: "C",
// },
// pf_dora: {
// name: "dora",
// language: "pt-br",
// gender: "Female",
// traits: "🚺",
// targetQuality: "C",
// overallGrade: "D",
// },
// pm_alex: {
// name: "alex",
// language: "pt-br",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
// pm_santa: {
// name: "santa",
// language: "pt-br",
// gender: "Male",
// traits: "🚹",
// targetQuality: "C",
// overallGrade: "D",
// },
});
const VOICE_DATA_URL = "https://huggingface.co/onnx-community/Kokoro-82M-v1.0-ONNX/resolve/main/voices";
/**
*
* @param {keyof typeof VOICES} id
* @returns {Promise<ArrayBufferLike>}
*/
async function getVoiceFile(id) {
if (fs?.readFile) {
const dirname = typeof __dirname !== "undefined" ? __dirname : import.meta.dirname;
const file = path.resolve(dirname, `../voices/${id}.bin`);
const { buffer } = await fs.readFile(file);
return buffer;
}
const url = `${VOICE_DATA_URL}/${id}.bin`;
let cache;
try {
cache = await caches.open("kokoro-voices");
const cachedResponse = await cache.match(url);
if (cachedResponse) {
return await cachedResponse.arrayBuffer();
}
} catch (e) {
console.warn("Unable to open cache", e);
}
// No cache, or cache failed to open. Fetch the file.
const response = await fetch(url);
const buffer = await response.arrayBuffer();
if (cache) {
try {
// NOTE: We use `new Response(buffer, ...)` instead of `response.clone()` to handle LFS files
await cache.put(
url,
new Response(buffer, {
headers: response.headers,
}),
);
} catch (e) {
console.warn("Unable to cache file", e);
}
}
return buffer;
}
const VOICE_CACHE = new Map();
export async function getVoiceData(voice) {
if (VOICE_CACHE.has(voice)) {
return VOICE_CACHE.get(voice);
}
const buffer = new Float32Array(await getVoiceFile(voice));
VOICE_CACHE.set(voice, buffer);
return buffer;
}
kokoro.js/tests/phonemize.test.js 0 → 100644
View file @ 033f82a9
import { describe, test, expect } from "vitest";
import { phonemize } from "../src/phonemize.js";
const A_TEST_CASES = new Map([
["‘Hello’", "həlˈoʊ"],
["‘Test’ and ‘Example’", "tˈɛst ænd ɛɡzˈæmpəl"],
["«Bonjour»", '"bɔːnʒˈʊɹ"'],
["«Test «nested» quotes»", '"tˈɛst "nˈɛstᵻd" kwˈoʊts"'],
["(Hello)", "«həlˈoʊ»"],
["(Nested (Parentheses))", "«nˈɛstᵻd «pɚɹˈɛnθəsˌiːz»»"],
["こんにちは、世界！", "dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ, tʃˈaɪniːzlˌɛɾɚ tʃˈaɪniːzlˌɛɾɚ!"],
["これはテストです：はい？", "dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ: dʒˈæpəniːzlˌɛɾɚ dʒˈæpəniːzlˌɛɾɚ?"],
["Hello World", "həlˈoʊ wˈɜːld"],
["Hello World", "həlˈoʊ wˈɜːld"],
["Hello\n \nWorld", "həlˈoʊ wˈɜːld"],
["Dr. Smith", "dˈɑːktɚ smˈɪθ"],
["DR. Brown", "dˈɑːktɚ bɹˈaʊn"],
["Mr. Smith", "mˈɪstɚ smˈɪθ"],
["MR. Anderson", "mˈɪstɚɹ ˈændɚsən"],
["Ms. Taylor", "mˈɪs tˈeɪlɚ"],
["MS. Carter", "mˈɪs kˈɑːɹɾɚ"],
["Mrs. Johnson", "mˈɪsɪz dʒˈɑːnsən"],
["MRS. Wilson", "mˈɪsɪz wˈɪlsən"],
["Apples, oranges, etc.", "ˈæpəlz, ˈɔɹɪndʒᵻz, ɛtsˈɛtɹə"],
["Apples, etc. Pears.", "ˈæpəlz, ɛtsˈɛtɹə. pˈɛɹz."],
["Yeah", "jˈɛə"],
["yeah", "jˈɛə"],
["1990", "nˈaɪntiːn nˈaɪndi"],
["12:34", "twˈɛlv θˈɜːɾi fˈoːɹ"],
["2022s", "twˈɛnti twˈɛnti tˈuːz"],
["1,000", "wˈʌn θˈaʊzənd"],
["12,345,678", "twˈɛlv mˈɪliən θɹˈiː hˈʌndɹɪd fˈoːɹɾi fˈaɪv θˈaʊzənd sˈɪks hˈʌndɹɪd sˈɛvənti ˈeɪt"],
["$100", "wˈʌn hˈʌndɹɪd dˈɑːlɚz"],
["£1.50", "wˈʌn pˈaʊnd ænd fˈɪfti pˈɛns"],
["12.34", "twˈɛlv pˈɔɪnt θɹˈiː fˈoːɹ"],
["0.01", "zˈiəɹoʊ pˈɔɪnt zˈiəɹoʊ wˈʌn"],
["10-20", "tˈɛn tə twˈɛnti"],
["5-10", "fˈaɪv tə tˈɛn"],
["10S", "tˈɛn ˈɛs"],
["5S", "fˈaɪv ˈɛs"],
["Cat's tail", "kˈæts tˈeɪl"],
["X's mark", "ˈɛksᵻz mˈɑːɹk"],
["U.S.A.", "jˈuːˈɛsˈeɪ."],
["A.B.C", "ˈeɪbˈiːsˈiː"],
]);
const B_TEST_CASES = new Map([
["‘Hello’", "həlˈəʊ"],
["‘Test’ and ‘Example’", "tˈɛst and ɛɡzˈampəl"],
["«Bonjour»", '"bɔːnʒˈʊə"'],
["«Test «nested» quotes»", '"tˈɛst "nˈɛstɪd" kwˈəʊts"'],
["(Hello)", "«həlˈəʊ»"],
["(Nested (Parentheses))", "«nˈɛstɪd «pəɹˈɛnθəsˌiːz»»"],
["こんにちは、世界！", "dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə, tʃˈaɪniːzlˌɛtə tʃˈaɪniːzlˌɛtə!"],
["これはテストです：はい？", "dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə: dʒˈapəniːzlˌɛtə dʒˈapəniːzlˌɛtə?"],
["Hello World", "həlˈəʊ wˈɜːld"],
["Hello World", "həlˈəʊ wˈɜːld"],
["Hello\n \nWorld", "həlˈəʊ wˈɜːld"],
["Dr. Smith", "dˈɒktə smˈɪθ"],
["DR. Brown", "dˈɒktə bɹˈaʊn"],
["Mr. Smith", "mˈɪstə smˈɪθ"],
["MR. Anderson", "mˈɪstəɹ ˈandəsən"],
["Ms. Taylor", "mˈɪs tˈeɪlə"],
["MS. Carter", "mˈɪs kˈɑːtə"],
["Mrs. Johnson", "mˈɪsɪz dʒˈɒnsən"],
["Apples, oranges, etc.", "ˈapəlz, ˈɒɹɪndʒɪz, ɛtsˈɛtɹə"],
["Apples, etc. Pears.", "ˈapəlz, ɛtsˈɛtɹə. pˈeəz."],
["1990", "nˈaɪntiːn nˈaɪnti"],
["12:34", "twˈɛlv θˈɜːti fˈɔː"],
["1,000", "wˈɒn θˈaʊzənd"],
["12,345,678", "twˈɛlv mˈɪliən θɹˈiː hˈʌndɹɪdən fˈɔːti fˈaɪv θˈaʊzənd sˈɪks hˈʌndɹɪdən sˈɛvənti ˈeɪt"],
["$100", "wˈɒn hˈʌndɹɪd dˈɒləz"],
["£1.50", "wˈɒn pˈaʊnd and fˈɪfti pˈɛns"],
["12.34", "twˈɛlv pˈɔɪnt θɹˈiː fˈɔː"],
["0.01", "zˈiəɹəʊ pˈɔɪnt zˈiəɹəʊ wˈɒn"],
["Cat's tail", "kˈats tˈeɪl"],
["X's mark", "ˈɛksɪz mˈɑːk"],
]);
describe("phonemize", () => {
describe("en-us", () => {
for (const [input, expected] of A_TEST_CASES) {
test(`phonemize("${input}")`, async () => {
expect(await phonemize(input)).toEqual(expected);
});
}
});
describe("en-gb", () => {
for (const [input, expected] of B_TEST_CASES) {
test(`phonemize("${input}")`, async () => {
expect(await phonemize(input, "b")).toEqual(expected);
});
}
});
});
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment