@hubstr/kit 0.1.0

package/tts/src/core/data/voiceList.ts

@@ -0,0 +1,149 @@
+export default {
+  'ar-SA-HamedNeural': 'حامد',
+  'ar-SA-ZariyahNeural': 'زارية',
+  'de-DE-AmalaNeural': 'Amala',
+  'de-DE-BerndNeural': 'Bernd',
+  'de-DE-ChristophNeural': 'Christoph',
+  'de-DE-ConradNeural': 'Conrad',
+  'de-DE-ElkeNeural': 'Elke',
+  'de-DE-GiselaNeural': 'Gisela',
+  'de-DE-KasperNeural': 'Kasper',
+  'de-DE-KatjaNeural': 'Katja',
+  'de-DE-KillianNeural': 'Killian',
+  'de-DE-KlarissaNeural': 'Klarissa',
+  'de-DE-KlausNeural': 'Klaus',
+  'de-DE-LouisaNeural': 'Louisa',
+  'de-DE-MajaNeural': 'Maja',
+  'de-DE-RalfNeural': 'Ralf',
+  'de-DE-TanjaNeural': 'Tanja',
+  'en-US-AIGenerate1Neural': 'AIGenerate1',
+  'en-US-AIGenerate2Neural': 'AIGenerate2',
+  'en-US-AmberNeural': 'Amber',
+  'en-US-AnaNeural': 'Ana',
+  'en-US-AndrewNeural': 'Andrew',
+  'en-US-AriaNeural': 'Aria',
+  'en-US-AshleyNeural': 'Ashley',
+  'en-US-BlueNeural': 'Blue',
+  'en-US-BrandonNeural': 'Brandon',
+  'en-US-BrianNeural': 'Brian',
+  'en-US-ChristopherNeural': 'Christopher',
+  'en-US-CoraNeural': 'Cora',
+  'en-US-DavisNeural': 'Davis',
+  'en-US-ElizabethNeural': 'Elizabeth',
+  'en-US-EmmaNeural': 'Emma',
+  'en-US-EricNeural': 'Eric',
+  'en-US-GuyNeural': 'Guy',
+  'en-US-JacobNeural': 'Jacob',
+  'en-US-JaneNeural': 'Jane',
+  'en-US-JasonNeural': 'Jason',
+  'en-US-JennyMultilingualNeural': 'Jenny Multilingual',
+  'en-US-JennyMultilingualV2Neural': 'Jenny Multilingual V2',
+  'en-US-JennyNeural': 'Jenny',
+  'en-US-MichelleNeural': 'Michelle',
+  'en-US-MonicaNeural': 'Monica',
+  'en-US-NancyNeural': 'Nancy',
+  'en-US-RogerNeural': 'Roger',
+  'en-US-RyanMultilingualNeural': 'Ryan Multilingual',
+  'en-US-SaraNeural': 'Sara',
+  'en-US-SteffanNeural': 'Steffan',
+  'en-US-TonyNeural': 'Tony',
+  'es-ES-AbrilNeural': 'Abril',
+  'es-ES-AlvaroNeural': 'Álvaro',
+  'es-ES-ArnauNeural': 'Arnau',
+  'es-ES-DarioNeural': 'Dario',
+  'es-ES-EliasNeural': 'Elias',
+  'es-ES-ElviraNeural': 'Elvira',
+  'es-ES-EstrellaNeural': 'Estrella',
+  'es-ES-IreneNeural': 'Irene',
+  'es-ES-LaiaNeural': 'Laia',
+  'es-ES-LiaNeural': 'Lia',
+  'es-ES-NilNeural': 'Nil',
+  'es-ES-SaulNeural': 'Saul',
+  'es-ES-TeoNeural': 'Teo',
+  'es-ES-TrianaNeural': 'Triana',
+  'es-ES-VeraNeural': 'Vera',
+  'fr-FR-AlainNeural': 'Alain',
+  'fr-FR-BrigitteNeural': 'Brigitte',
+  'fr-FR-CelesteNeural': 'Celeste',
+  'fr-FR-ClaudeNeural': 'Claude',
+  'fr-FR-CoralieNeural': 'Coralie',
+  'fr-FR-DeniseNeural': 'Denise',
+  'fr-FR-EloiseNeural': 'Eloise',
+  'fr-FR-HenriNeural': 'Henri',
+  'fr-FR-JacquelineNeural': 'Jacqueline',
+  'fr-FR-JeromeNeural': 'Jerome',
+  'fr-FR-JosephineNeural': 'Josephine',
+  'fr-FR-MauriceNeural': 'Maurice',
+  'fr-FR-YvesNeural': 'Yves',
+  'fr-FR-YvetteNeural': 'Yvette',
+  'ja-JP-AoiNeural': '碧衣',
+  'ja-JP-DaichiNeural': '大智',
+  'ja-JP-KeitaNeural': '圭太',
+  'ja-JP-MayuNeural': '真夕',
+  'ja-JP-NanamiNeural': '七海',
+  'ja-JP-NaokiNeural': '直紀',
+  'ja-JP-ShioriNeural': '志織',
+  'ko-KR-BongJinNeural': '봉진',
+  'ko-KR-GookMinNeural': '국민',
+  'ko-KR-InJoonNeural': '인준',
+  'ko-KR-JiMinNeural': '지민',
+  'ko-KR-SeoHyeonNeural': '서현',
+  'ko-KR-SoonBokNeural': '순복',
+  'ko-KR-SunHiNeural': '선히',
+  'ko-KR-YuJinNeural': '유진',
+  'pt-BR-AntonioNeural': 'Antônio',
+  'pt-BR-BrendaNeural': 'Brenda',
+  'pt-BR-DonatoNeural': 'Donato',
+  'pt-BR-ElzaNeural': 'Elza',
+  'pt-BR-FabioNeural': 'Fabio',
+  'pt-BR-FranciscaNeural': 'Francisca',
+  'pt-BR-GiovannaNeural': 'Giovanna',
+  'pt-BR-HumbertoNeural': 'Humberto',
+  'pt-BR-JulioNeural': 'Julio',
+  'pt-BR-LeilaNeural': 'Leila',
+  'pt-BR-LeticiaNeural': 'Leticia',
+  'pt-BR-ManuelaNeural': 'Manuela',
+  'pt-BR-NicolauNeural': 'Nicolau',
+  'pt-BR-ValerioNeural': 'Valerio',
+  'pt-BR-YaraNeural': 'Yara',
+  'ru-RU-DariyaNeural': 'Дария',
+  'ru-RU-DmitryNeural': 'Дмитрий',
+  'ru-RU-SvetlanaNeural': 'Светлана',
+  'wuu-CN-XiaotongNeural': '晓彤',
+  'wuu-CN-YunzheNeural': '云哲',
+  'yue-CN-XiaoMinNeural': '晓敏',
+  'yue-CN-YunSongNeural': '云松',
+  'zh-CN-XiaochenNeural': '晓辰',
+  'zh-CN-XiaohanNeural': '晓涵',
+  'zh-CN-XiaomengNeural': '晓梦',
+  'zh-CN-XiaomoNeural': '晓墨',
+  'zh-CN-XiaoqiuNeural': '晓秋',
+  'zh-CN-XiaorouNeural': '晓柔',
+  'zh-CN-XiaoruiNeural': '晓睿',
+  'zh-CN-XiaoshuangNeural': '晓双',
+  'zh-CN-XiaoxiaoNeural': '晓晓',
+  'zh-CN-XiaoxuanNeural': '晓萱',
+  'zh-CN-XiaoyanNeural': '晓颜',
+  'zh-CN-XiaoyiNeural': '晓伊',
+  'zh-CN-XiaoyouNeural': '晓悠',
+  'zh-CN-XiaozhenNeural': '晓甄',
+  'zh-CN-YunfengNeural': '云枫',
+  'zh-CN-YunhaoNeural': '云皓',
+  'zh-CN-YunjianNeural': '云健',
+  'zh-CN-YunjieNeural': '云杰',
+  'zh-CN-YunxiNeural': '云希',
+  'zh-CN-YunxiaNeural': '云夏',
+  'zh-CN-YunyangNeural': '云扬',
+  'zh-CN-YunyeNeural': '云野',
+  'zh-CN-YunzeNeural': '云泽',
+  'zh-CN-guangxi-YunqiNeural': '云奇',
+  'zh-CN-henan-YundengNeural': '云登',
+  'zh-CN-liaoning-XiaobeiNeural': '晓北',
+  'zh-CN-liaoning-YunbiaoNeural': '云彪',
+  'zh-CN-shaanxi-XiaoniNeural': '晓妮',
+  'zh-CN-shandong-YunxiangNeural': '云翔',
+  'zh-CN-sichuan-YunxiNeural': '云希',
+  'zh-TW-HsiaoChenNeural': '曉臻',
+  'zh-TW-HsiaoYuNeural': '曉雨',
+  'zh-TW-YunJheNeural': '雲哲',
+} as any;

package/tts/src/core/index.ts

@@ -0,0 +1,17 @@
+export { type EdgeSpeechAPI, type EdgeSpeechPayload, EdgeSpeechTTS } from '@/core/EdgeSpeechTTS';
+export {
+  type MicrosoftSpeechAPI,
+  type MicrosoftSpeechPayload,
+  MicrosoftSpeechTTS,
+} from '@/core/MicrosoftSpeechTTS';
+export { OpenaiSTT, type OpenAISTTAPI, type OpenAISTTPayload } from '@/core/OpenAISTT';
+export {
+  OpenAITTS,
+  type OpenAITTSAPI,
+  type OpenAITTSPayload,
+  type OpenaiVoice,
+} from '@/core/OpenAITTS';
+export { SpeechSynthesisTTS } from '@/core/SpeechSynthesisTTS';
+export { cleanContent } from '@/core/utils/cleanContent';
+export { getRecordMineType, type RecordMineType } from '@/core/utils/getRecordMineType';
+export { VoiceList } from '@/core/VoiceList';

package/tts/src/core/utils/arrayBufferConvert.ts

@@ -0,0 +1,4 @@
+export const arrayBufferConvert = async (arrayBuffer: ArrayBuffer): Promise<AudioBuffer> => {
+  const audioContext = new AudioContext();
+  return await audioContext.decodeAudioData(arrayBuffer);
+};

package/tts/src/core/utils/audioBufferToBlob.ts

@@ -0,0 +1,96 @@
+const audioBufferToWav = async (buffer: AudioBuffer) => {
+  const numOfChan = buffer.numberOfChannels;
+  const length = buffer.length * numOfChan * 2 + 44;
+  const bufferOut = new ArrayBuffer(length);
+  const view = new DataView(bufferOut);
+  const channels = [];
+  let sample;
+  let offset = 0;
+  let pos = 0;
+
+  const setUint16 = (data: number) => {
+    view.setUint16(pos, data, true);
+    pos += 2;
+  };
+
+  const setUint32 = (data: number) => {
+    view.setUint32(pos, data, true);
+    pos += 4;
+  };
+
+  // 写入 WAV 头部信息
+  setUint32(0x46_46_49_52); // "RIFF"
+  setUint32(length - 8); // 文件长度 - 8
+  setUint32(0x45_56_41_57); // "WAVE"
+
+  // 写入 fmt 子块
+  setUint32(0x20_74_6D_66); // "fmt " 字符串
+  setUint32(16); // 子块的大小（16对于PCM格式是固定的）
+  setUint16(1); // 音频格式（1表示PCM - 线性量化）
+  setUint16(numOfChan);
+  setUint32(buffer.sampleRate);
+  setUint32(buffer.sampleRate * 2 * numOfChan); // 字节率
+  setUint16(numOfChan * 2); // 块对齐
+  setUint16(16); // 比特数（对于PCM格式这意味着位深）
+
+  // 写入 data 子块
+  setUint32(0x61_74_61_64); // "data" 字符串
+  setUint32(length - pos - 4); // 子块的大小（即实际音频数据的大小）
+
+  // 函数用于以小端序写入数值
+
+  // 分别写入每个通道的音频数据
+  for (let i = 0; i < buffer.numberOfChannels; i++) {
+    channels.push(buffer.getChannelData(i));
+  }
+
+  // 写入交错的音频数据
+  while (offset < buffer.length) {
+    for (let i = 0; i < numOfChan; i++) {
+      sample = Math.max(-1, Math.min(1, channels[i][offset])); // 音频剪切
+      sample = Math.trunc(0.5 + sample < 0 ? sample * 32_768 : sample * 32_767); // 转换为 16 位
+      view.setInt16(pos, sample, true);
+      pos += 2;
+    }
+    offset++;
+  }
+
+  return bufferOut;
+};
+export const audioBufferToBlob = async (audioBuffer: AudioBuffer) => {
+  const wavArrayBuffer = await audioBufferToWav(audioBuffer);
+  return new Blob([wavArrayBuffer], { type: 'audio/wav' });
+};
+
+export const mergeAudioBuffers = async (audioBuffers: AudioBuffer[]): Promise<AudioBuffer> => {
+  const audioContext = new AudioContext();
+  // 计算所有AudioBuffer的总长度
+  const totalLength = audioBuffers.reduce((acc, curr) => acc + curr.length, 0);
+
+  // 创建一个新的AudioBuffer
+  const outputBuffer = audioContext.createBuffer(
+    audioBuffers[0].numberOfChannels,
+    totalLength,
+    audioBuffers[0].sampleRate,
+  );
+
+  // 用于追踪新AudioBuffer的当前位置
+  let offset = 0;
+
+  // 遍历AudioBuffers数组，并将它们依次拷贝到新的AudioBuffer中
+  audioBuffers.forEach((buffer) => {
+    // 对于每个通道
+    for (let i = 0; i < buffer.numberOfChannels; i++) {
+      // 获取当前AudioBuffer的通道数据
+      const inputData = buffer.getChannelData(i);
+      // 获取输出AudioBuffer的通道数据
+      const outputData = outputBuffer.getChannelData(i);
+      // 将当前AudioBuffer的数据拷贝到输出AudioBuffer的正确位置
+      outputData.set(inputData, offset);
+    }
+    // 更新偏移量
+    offset += buffer.length;
+  });
+
+  return outputBuffer;
+};

package/tts/src/core/utils/cleanContent.ts

@@ -0,0 +1,23 @@
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+import { visit } from 'unist-util-visit';
+
+// @ts-ignore
+const convertMarkdownToMdast = async (md: string) => {
+  // @ts-ignore
+  return unified().use(remarkParse).use(remarkGfm).parse(md.trim());
+};
+
+export const cleanContent = async (content: string) => {
+  try {
+    const mdast = await convertMarkdownToMdast(content.trim());
+    const newContent: string[] = [];
+    visit(mdast, 'text', (node: any) => {
+      if (node?.value) newContent.push(node.value.trim());
+    });
+    return newContent.join('');
+  } catch {
+    return content.trim();
+  }
+};

package/tts/src/core/utils/genSSML.ts

@@ -0,0 +1,45 @@
+export type StyleName =
+  | 'affectionate'
+  | 'angry'
+  | 'calm'
+  | 'cheerful'
+  | 'disgruntled'
+  | 'embarrassed'
+  | 'fearful'
+  | 'general'
+  | 'gentle'
+  | 'sad'
+  | 'serious';
+
+export interface SsmlOptions {
+  pitch?: number;
+  rate?: number;
+  style?: StyleName;
+  voice: string;
+}
+
+const voiceTemplate = (input: string, { voice }: Pick<SsmlOptions, 'voice'>) =>
+  `<voice name="${voice}">${input}</voice>`;
+
+const styleTemplate = (input: string, { style }: Pick<SsmlOptions, 'style'>) => {
+  if (!style) return input;
+  return `<mstts:express-as style="${style}">${input}</mstts:express-as>`;
+};
+
+const prosodyTemplate = (input: string, { pitch, rate }: Pick<SsmlOptions, 'pitch' | 'rate'>) => {
+  if (!pitch && !rate) return input;
+  return `<prosody pitch="${Math.floor((pitch || 1) * 100)}%" rate="${Math.floor(
+    (rate || 1) * 100,
+  )}%">${input}</prosody>`;
+};
+const speackTemplate = (input: string) =>
+  `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">${input}</speak>`;
+
+export const genSSML = (input: string, options: SsmlOptions) => {
+  let ssml = prosodyTemplate(input, options);
+  ssml = styleTemplate(ssml, options);
+  ssml = voiceTemplate(ssml, options);
+  ssml = speackTemplate(ssml);
+
+  return ssml;
+};

package/tts/src/core/utils/genSendContent.ts

@@ -0,0 +1,8 @@
+export const genSendContent = (header: { [key: string]: string }, data: string) => {
+  const content = [];
+  for (const [key, value] of Object.entries(header)) {
+    content.push(`${key}:${value}`);
+  }
+  content.push('', data);
+  return content.join('\r\n');
+};

package/tts/src/core/utils/getHeadersAndData.ts

@@ -0,0 +1,8 @@
+export const getHeadersAndData = (data: string) => {
+  const headers: { [key: string]: string } = {};
+  for (const line of data.slice(0, data.indexOf('\r\n\r\n')).split('\r\n')) {
+    const [key, value] = line.split(':', 2);
+    headers[key] = value;
+  }
+  return { data: data.slice(data.indexOf('\r\n\r\n') + 4), headers };
+};

package/tts/src/core/utils/getRecordMineType.ts

@@ -0,0 +1,23 @@
+export interface RecordMineType {
+  extension: 'webm' | 'mp4';
+  mineType: 'audio/webm' | 'audio/mp4';
+}
+
+export const getRecordMineType = (): RecordMineType => {
+  try {
+    return MediaRecorder.isTypeSupported('audio/webm')
+      ? {
+          extension: 'webm',
+          mineType: 'audio/webm',
+        }
+      : {
+          extension: 'mp4',
+          mineType: 'audio/mp4',
+        };
+  } catch {
+    return {
+      extension: 'webm',
+      mineType: 'audio/webm',
+    };
+  }
+};

package/tts/src/core/utils/getSHA256.ts

@@ -0,0 +1,112 @@
+const uint8Array = Uint8Array;
+const uint32Array = Uint32Array;
+const pow = Math.pow;
+
+const DEFAULT_STATE = new uint32Array(8);
+const ROUND_CONSTANTS: number[] = [];
+const LittleEndian = !!new uint8Array(new uint32Array([1]).buffer)[0];
+const encoder = new TextEncoder();
+
+function convertEndian(word: number) {
+    return LittleEndian ? (
+        (word >>> 24) | (((word >>> 16) & 0xFF) << 8) | ((word & 0xFF_00) << 8) | (word << 24)
+    ) : word;
+}
+
+function rightRotate(word: number, bits: number) {
+    return (word >>> bits) | (word << (32 - bits));
+}
+
+function sha256(data: Uint8Array): Uint8Array {
+    const STATE = [...DEFAULT_STATE];
+    const legth = data.length;
+    const bitLength = legth * 8;
+    const newBitLength = 512 - ((bitLength + 64) % 512) - 1 + bitLength + 65;
+    const bytes = new uint8Array(newBitLength / 8);
+    const words = new uint32Array(bytes.buffer);
+
+    bytes.set(data, 0);
+    bytes[legth] = 0b1000_0000;
+    words[words.length - 1] = convertEndian(bitLength);
+
+    const M = new uint32Array(64); // Move M here
+
+    for (let block = 0; block < newBitLength / 32; block += 16) {
+        const workingState = [...STATE];
+
+        for (let round = 0; round < 64; round++) {
+            let MRound;
+            if (round < 16) {
+                MRound = convertEndian(words[block + round]);
+            } else {
+                const gamma0x = M[round - 15];
+                const gamma1x = M[round - 2];
+                MRound =
+                    M[round - 7] +
+                    M[round - 16] +
+                    (rightRotate(gamma0x, 7) ^ rightRotate(gamma0x, 18) ^ (gamma0x >>> 3)) +
+                    (rightRotate(gamma1x, 17) ^ rightRotate(gamma1x, 19) ^ (gamma1x >>> 10));
+            }
+
+            M[round] = MRound = Math.trunc(MRound);
+
+            const t1 =
+                (rightRotate(workingState[4], 6) ^
+                    rightRotate(workingState[4], 11) ^
+                    rightRotate(workingState[4], 25)) +
+                ((workingState[4] & workingState[5]) ^ (~workingState[4] & workingState[6])) +
+                workingState[7] +
+                MRound +
+                ROUND_CONSTANTS[round];
+            const t2 =
+                (rightRotate(workingState[0], 2) ^
+                    rightRotate(workingState[0], 13) ^
+                    rightRotate(workingState[0], 22)) +
+                ((workingState[0] & workingState[1]) ^
+                    (workingState[2] & (workingState[0] ^ workingState[1])));
+            for (let i = 7; i > 0; i--) {
+                workingState[i] = workingState[i - 1];
+            }
+            workingState[0] = Math.trunc(t1 + t2);
+            workingState[4] = Math.trunc(workingState[4] + t1);
+        }
+
+        for (let round = 0; round < 8; round++) {
+            STATE[round] = Math.trunc(STATE[round] + workingState[round]);
+        }
+    }
+
+    return new uint8Array(new uint32Array(STATE.map(convertEndian)).buffer);
+}
+
+export function hex(bin: Uint8Array): string {
+  return [...bin]
+      .map(val => ('00' + val.toString(16)).slice(-2))
+      .join('');
+}
+
+export function hash(str: string): string {
+    return hex(sha256(encoder.encode(str)));
+}
+
+(function initialize() {
+    let n = 2;
+    let nPrime = 0;
+    while (nPrime < 64) {
+        let isPrime = true;
+        for (let factor = 2; factor <= n / 2; factor++) {
+            if (n % factor === 0) {
+                isPrime = false;
+            }
+        }
+        if (isPrime) {
+            const getFractionalBits = (n: number) => Math.trunc((n - (Math.trunc(n))) * pow(2, 32));
+            if (nPrime < 8) {
+                DEFAULT_STATE[nPrime] = getFractionalBits(pow(n, 1 / 2));
+            }
+            ROUND_CONSTANTS[nPrime] = getFractionalBits(pow(n, 1 / 3));
+            nPrime++;
+        }
+        n++;
+    }
+})();

package/tts/src/core/utils/getVoiceList.ts

@@ -0,0 +1,7 @@
+import { SelectProps } from 'antd';
+
+import voiceLocale from '@/core/data/locales';
+
+export const getVoiceLocaleOptions = (): SelectProps['options'] => {
+  return Object.entries(voiceLocale).map(([value, label]) => ({ label, value }));
+};

package/tts/src/core/utils/playAudioBlob.ts

@@ -0,0 +1,8 @@
+export const playAudioBlob = (blob: Blob) => {
+  const url = URL.createObjectURL(blob);
+  const audio = new Audio(url);
+  return {
+    audio,
+    url,
+  };
+};

package/tts/src/core/utils/secondsToMinutesAndSeconds.ts

@@ -0,0 +1,10 @@
+export const secondsToMinutesAndSeconds = (seconds: number): string => {
+  if (seconds < 0) return `--:--`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.floor(seconds % 60);
+
+  const minutesStr = minutes.toString().padStart(2, '0');
+  const secondsStr = remainingSeconds.toString().padStart(2, '0');
+
+  return `${minutesStr}:${secondsStr}`;
+};

package/tts/src/core/utils/splitTextIntoSegments.ts

@@ -0,0 +1,65 @@
+import { markdownToTxt } from 'markdown-to-txt';
+
+const toHalfWidthAndCleanSpace = (str: string): string => {
+  return markdownToTxt(str)
+    .replaceAll(/[\uFF01-\uFF5E]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 0xFE_E0))
+    .replaceAll('\u3000', ' ')
+    .replaceAll('。', '.')
+    .replaceAll('，', ',')
+    .replaceAll('！', '!')
+    .replaceAll('？', '?')
+    .replaceAll('；', ';')
+    .replaceAll('：', ':')
+    .replaceAll('（', '(')
+    .replaceAll('）', ')')
+    .replaceAll('【', '[')
+    .replaceAll('】', ']')
+    .replaceAll('《', '<')
+    .replaceAll('》', '>')
+    .replaceAll('“', '"')
+    .replaceAll('”', '"')
+    .replaceAll('‘', "'")
+    .replaceAll('’', "'")
+    .replaceAll('\n', '. ')
+    .replaceAll(/\s+/g, ' ');
+};
+
+export const splitTextIntoSegments = (text: string, chunkSize: number = 100): string[] => {
+  text = toHalfWidthAndCleanSpace(text);
+
+  const chunks: string[] = [];
+  const paragraphs = text.split('\n');
+  let currentChunk = '';
+
+  function addChunk(chunk: string) {
+    if (chunk.trim()) {
+      chunks.push(chunk.trim());
+    }
+  }
+
+  for (const paragraph of paragraphs) {
+    if (currentChunk.length + paragraph.length + 1 > chunkSize && currentChunk.length > 0) {
+      addChunk(currentChunk);
+      currentChunk = '';
+    }
+
+    if (paragraph.length > chunkSize) {
+      const sentences = paragraph.match(/[^!.?]+[!.?]+/g) || [paragraph];
+      for (const sentence of sentences) {
+        if (currentChunk.length + sentence.length + 1 > chunkSize && currentChunk.length > 0) {
+          addChunk(currentChunk);
+          currentChunk = '';
+        }
+        currentChunk += (currentChunk ? ' ' : '') + sentence.trim();
+      }
+    } else {
+      currentChunk += (currentChunk ? '\n' : '') + paragraph;
+    }
+  }
+
+  if (currentChunk) {
+    addChunk(currentChunk);
+  }
+
+  return chunks;
+};

package/tts/src/index.ts

@@ -0,0 +1 @@
+export * from './core';

package/tts/src/react/AudioPlayer/demos/index.tsx

@@ -0,0 +1,31 @@
+import { AudioPlayer, useAudioPlayer } from '@hubstr/kit/tts/react';
+import { StoryBook, useControls, useCreateStore } from '@hubstr/kit/ui/storybook';
+
+export default () => {
+  const store = useCreateStore();
+
+  const { url, ...options }: any = useControls(
+    {
+      allowPause: false,
+      showSlider: true,
+      timeRender: {
+        options: ['text', 'tag'],
+        value: 'text',
+      },
+      timeType: {
+        options: ['left', 'current', 'combine'],
+        value: 'left',
+      },
+      url: 'https://gw.alipayobjects.com/os/kitchen/lnOJK2yZ0K/sound.mp3',
+    },
+    { store },
+  );
+
+  const { isLoading, ...audio } = useAudioPlayer({ src: url });
+
+  return (
+    <StoryBook levaStore={store}>
+      <AudioPlayer audio={audio} autoplay isLoading={isLoading} {...options} />
+    </StoryBook>
+  );
+};

package/tts/src/react/AudioPlayer/index.md

@@ -0,0 +1,11 @@
+---
+nav: Components
+group: UI
+title: AudioPlayer
+apiHeader:
+  pkg: '@hubstr/tts/react'
+---
+
+## Default
+
+<code src="./demos/index.tsx" nopadding></code>