@andresaya/edge-tts 1.3.1 → 1.4.0

package/README.md

@@ -1,4 +1,5 @@
 # Edge TTS
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/andresayac/edge-tts)
 
 **Edge TTS** is a powerful Text-to-Speech (TTS) package that leverages Microsoft's Edge capabilities. This package allows you to synthesize speech from text and manage voice options easily through a command-line interface (CLI).
 
@@ -10,8 +11,10 @@
 - **Audio Information**: Get detailed information about generated audio (size, duration, format).
 - **Audio Export Options**: Export synthesized audio in different formats (raw, base64, or directly to a file).
 - **Streaming Support**: Stream audio data in real-time for better performance.
+- **Word Boundaries Metadata**: Get word boundary information with precise timestamps.
 - **Command-Line Interface**: Use a simple CLI for easy access to functionality.
 - **Easy Integration**: Modular structure allows for easy inclusion in existing projects.
+- **SSML Custom**: 🥳🥳 Edge TTS accepts raw SSML with all characteristics of Azure AI Speech.  
 
 ## Installation
 
@@ -39,6 +42,11 @@ To synthesize speech from text:
 edge-tts synthesize -t "Hello, world!" -o hello_world_audio
 ```
 
+From file in format SSML:
+```bash
+edge-tts synthesize -f ssml.txt --ssml -o salida
+```
+
 To list available voices:
 ```bash
 edge-tts voice-list
@@ -83,6 +91,49 @@ const maleVoices = await tts.getVoicesByGender('Male');
 
 ### Text Synthesis
 
+#### Custom SSML (Advanced)
+Edge TTS accepts raw SSML so you can control prosody, styles, pauses, pronunciations, and more. You can pass SSML from code or the CLI. By default the library auto-detects if your input is SSML; you can also force the mode.
+
+More information
+[Azure AI Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-synthesis-markup-structure)
+
+### SSML-builder 
+[@andresaya/ssml-builder](https://www.npmjs.com/package/@andresaya/ssml-builder) A powerful, type-safe TypeScript library for building Speech Synthesis Markup Language (SSML) documents. Create expressive text-to-speech applications with Azure Speech Service and other SSML-compliant engines.
+
+#### What the library does for you
+
+- Auto-detect / force mode: options.inputType may be 'auto' | 'ssml' | 'text' (default: auto).
+- Validation: Throws helpful errors if SSML is malformed (e.g., missing <speak>, <voice>, or the synthesis namespace).
+- Voice injection: If your SSML lacks <voice>, it injects one with the voice you passed.
+- Text wrapping: If you pass plain text (or inputType: 'text'), it wraps it in a valid SSML envelope using your rate, pitch, and volume.
+
+```js
+import { EdgeTTS } from '@andresaya/edge-tts';
+
+const tts = new EdgeTTS();
+
+const ssml = `
+<speak version="1.0"
+       xmlns="http://www.w3.org/2001/10/synthesis"
+       xmlns:mstts="https://www.w3.org/2001/mstts"
+       xml:lang="es-CO">
+  <voice name="es-CO-GonzaloNeural">
+    <mstts:express-as style="narration-professional">
+      <prosody rate="+5%" pitch="+10Hz" volume="+0%">
+        Hola, este es un ejemplo de <emphasis>SSML</emphasis>.
+        <break time="400ms" />
+        El número es <say-as interpret-as="cardinal">2025</say-as>.
+        La palabra se pronuncia
+        <phoneme alphabet="ipa" ph="ˈxola">hola</phoneme>.
+      </prosody>
+    </mstts:express-as>
+  </voice>
+</speak>`.trim();
+
+// Auto-detects SSML, or force it with inputType: 'ssml'
+await tts.synthesize(ssml, 'es-CO-GonzaloNeural', { inputType: 'ssml' });
+```
+
 #### Basic Synthesis
 ```js
 // Simple synthesis with default voice
@@ -150,6 +201,17 @@ console.log(`Audio saved to: ${filePath}`);
 // Creates: output_audio.mp3
 ```
 
+### Word Boundaries Metadata
+
+```php
+// Get word boundaries with timestamps
+$boundaries = $tts->getWordBoundaries();
+
+// Save metadata to file
+$tts->saveMetadata('metadata.json');
+```
+
+
 ## Examples
 
 ### Complete Example with Voice Selection

package/dist/cli/edge-tts.js

@@ -6,7 +6,7 @@ const VoiceListCommand_1 = require("../commands/VoiceListCommand");
 const commander_1 = require("commander");
 const program = new commander_1.Command();
 program
-    .version('1.3.0')
+    .version('1.4.0')
     .addCommand(SynthesizeCommand_1.SynthesizeCommand)
     .addCommand(VoiceListCommand_1.VoiceListCommand);
 try {

package/dist/commands/SynthesizeCommand.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SynthesizeCommand = void 0;
 const commander_1 = require("commander");
 const EdgeTTS_1 = require("../services/EdgeTTS");
+const promises_1 = require("fs/promises");
 exports.SynthesizeCommand = new commander_1.Command('synthesize')
     .description('Edge TTS: synthesize text to audio')
     .option('-t, --text <text>', 'Text to convert to audio')
@@ -11,14 +12,36 @@ exports.SynthesizeCommand = new commander_1.Command('synthesize')
     .option('-l, --volume [volume]', 'Volume of speech', '0%')
     .option('-p, --pitch [pitch]', 'Pitch of speech', '0Hz')
     .option('-o, --output [output]', 'Output file name', `output_${Date.now()}`)
+    .option('-f, --file [file]', 'Input file (text or SSML)')
+    .option('--ssml', 'Force interpret input as SSML (auto-detect by default)')
     .action(async (options) => {
-    const { text, voice, pitch, rate, volume, output } = options;
-    if (!text) {
-        console.error('Text is required');
+    const { text, voice, pitch, rate, volume, output, file, ssml: forceSSML } = options;
+    if (!text && !file) {
+        console.error('Error: Text (-t) or file (-f) is required');
         process.exit(1);
     }
+    if (text && file) {
+        console.error('Error: Cannot use both text (-t) and file (-f) options');
+        process.exit(1);
+    }
+    let content = text;
+    if (file) {
+        try {
+            content = await (0, promises_1.readFile)(file, 'utf-8');
+            console.log(`Reading from file: ${file}`);
+        }
+        catch (error) {
+            console.error(`Error reading file: ${error}`);
+            process.exit(1);
+        }
+    }
     const tts = new EdgeTTS_1.EdgeTTS();
-    await tts.synthesize(text, voice, { pitch, rate, volume });
-    await tts.toFile(`${output}`);
-    console.log(`Audio file generated: ${output}.mp3`);
+    await tts.synthesize(content, voice, {
+        pitch,
+        rate,
+        volume,
+        inputType: forceSSML ? 'ssml' : 'auto'
+    });
+    const savedPath = await tts.toFile(output);
+    console.log(`Audio file generated: ${savedPath}`);
 });

package/dist/config/constants.d.ts

@@ -2,4 +2,6 @@ export declare const Constants: {
     TRUSTED_CLIENT_TOKEN: string;
     WSS_URL: string;
     VOICES_URL: string;
+    USER_AGENT: string;
+    VERSION_MS_GEC: string;
 };

package/dist/config/constants.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Constants = void 0;
 exports.Constants = {
     TRUSTED_CLIENT_TOKEN: '6A5AA1D4EAFF4E9FB37E23D68491D6F4',
-    WSS_URL: 'wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1',
-    VOICES_URL: 'https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list',
+    WSS_URL: 'wss://api.msedgeservices.com/tts/cognitiveservices/websocket/v1',
+    VOICES_URL: 'https://api.msedgeservices.com/tts/cognitiveservices/voices/list',
+    USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0',
+    VERSION_MS_GEC: '1-140.0.3485.14'
 };

package/dist/services/EdgeTTS.d.ts

@@ -5,15 +5,24 @@ export interface Voice {
     Gender: string;
     Locale: string;
     FriendlyName: string;
+    LocalName: string;
 }
 export interface SynthesisOptions {
     pitch?: string | number;
     rate?: string | number;
     volume?: string | number;
+    inputType?: 'auto' | 'ssml' | 'text';
+}
+export interface WordBoundary {
+    type: "WordBoundary";
+    offset: number;
+    duration: number;
+    text: string;
 }
 export declare class EdgeTTS {
     private audio_stream;
     private audio_format;
+    private word_boundaries;
     private ws;
     getVoices(): Promise<Voice[]>;
     getVoicesByLanguage(locale: string): Promise<Voice[]>;
@@ -23,10 +32,14 @@ export declare class EdgeTTS {
     private validateRate;
     private validateVolume;
     synthesize(text: string, voice?: string, options?: SynthesisOptions): Promise<void>;
+    private detectSSML;
+    private escapeXML;
     private getSSML;
     private buildTTSConfigMessage;
     synthesizeStream(text: string, voice?: string, options?: SynthesisOptions): AsyncGenerator<Uint8Array, void, unknown>;
     private processAudioData;
+    private parseMetadata;
+    private generateSecMsGec;
     getDuration(): number;
     getAudioInfo(): {
         size: number;
@@ -37,4 +50,6 @@ export declare class EdgeTTS {
     toRaw(): string;
     toBase64(): string;
     toBuffer(): Buffer;
+    saveMetadata(outputPath: string): Promise<void>;
+    getWordBoundaries(): WordBoundary[];
 }

package/dist/services/EdgeTTS.js

@@ -26,13 +26,19 @@ function ensureBuffer(data) {
 class EdgeTTS {
     audio_stream = [];
     audio_format = 'mp3';
+    word_boundaries = [];
     ws;
     async getVoices() {
-        const response = await fetch(`${constants_1.Constants.VOICES_URL}?trustedclienttoken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}`);
+        const secMsGEC = await this.generateSecMsGec(constants_1.Constants.TRUSTED_CLIENT_TOKEN);
+        const response = await fetch(`${constants_1.Constants.VOICES_URL}?Ocp-Apim-Subscription-Key=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${constants_1.Constants.VERSION_MS_GEC}`, {
+            headers: {
+                "User-Agent": constants_1.Constants.USER_AGENT
+            },
+        });
         const data = await response.json();
         return data.map((voice) => {
-            delete voice.VoiceTag;
-            delete voice.SuggestedCodec;
+            voice.FriendlyName = voice.FriendlyName || voice.LocalName;
+            delete voice.SampleRateHertz;
             delete voice.Status;
             return voice;
         });
@@ -92,10 +98,16 @@ class EdgeTTS {
         return `${volumeValue}%`;
     }
     async synthesize(text, voice = 'en-US-AnaNeural', options = {}) {
+        const secMsGEC = await this.generateSecMsGec(constants_1.Constants.TRUSTED_CLIENT_TOKEN);
         return new Promise((resolve, reject) => {
             this.audio_stream = [];
-            const req_id = this.generateUUID();
-            this.ws = new ws_1.default(`${constants_1.Constants.WSS_URL}?trustedclienttoken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&ConnectionId=${req_id}`);
+            const reqId = this.generateUUID();
+            const url = `${constants_1.Constants.WSS_URL}?Ocp-Apim-Subscription-Key=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${constants_1.Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
+            this.ws = new ws_1.default(url, {
+                headers: {
+                    "User-Agent": constants_1.Constants.USER_AGENT
+                }
+            });
             const SSML_text = this.getSSML(text, voice, options);
             const timeout = setTimeout(() => {
                 if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
@@ -106,7 +118,7 @@ class EdgeTTS {
             this.ws.on('open', () => {
                 const message = this.buildTTSConfigMessage();
                 this.ws.send(message);
-                const speechMessage = `X-RequestId:${req_id}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${new Date().toISOString()}Z\r\nPath:ssml\r\n\r\n${SSML_text}`;
+                const speechMessage = `X-RequestId:${reqId}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${new Date().toISOString()}Z\r\nPath:ssml\r\n\r\n${SSML_text}`;
                 this.ws.send(speechMessage);
             });
             this.ws.on('message', (data) => {
@@ -125,14 +137,83 @@ class EdgeTTS {
             });
         });
     }
-    getSSML(text, voice, options = {}) {
-        if (typeof options.pitch === 'string') {
-            options.pitch = options.pitch.replace('hz', 'Hz');
+    detectSSML(content) {
+        const trimmedContent = content.trim();
+        const looksLikeSSML = /^<\?xml|^<speak/i.test(trimmedContent);
+        if (!looksLikeSSML) {
+            return { isValid: true, isSSML: false };
+        }
+        const errors = [];
+        const hasSpeakTag = /<speak\b[^>]*>[\s\S]*<\/speak>/i.test(trimmedContent);
+        const hasVoiceTag = /<voice\b[^>]*>[\s\S]*<\/voice>/i.test(trimmedContent);
+        if (!hasSpeakTag) {
+            throw new Error('Invalid SSML: Missing <speak> tag');
+        }
+        if (!hasVoiceTag) {
+            throw new Error('Invalid SSML: Missing <voice> tag');
+        }
+        const hasCorrectNamespace = /xmlns="http:\/\/www\.w3\.org\/2001\/10\/synthesis"/i.test(trimmedContent);
+        if (!hasCorrectNamespace && hasSpeakTag) {
+            throw new Error('Invalid SSML: Missing or incorrect namespace declaration');
+        }
+        return {
+            isValid: errors.length === 0,
+            isSSML: hasSpeakTag || hasVoiceTag,
+            errors: errors.length > 0 ? errors : undefined
+        };
+    }
+    escapeXML(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    getSSML(content, voice, options = {}) {
+        const inputType = options.inputType || 'auto';
+        let treatAsSSML = false;
+        if (inputType === 'ssml') {
+            treatAsSSML = true;
+        }
+        else if (inputType === 'text') {
+            treatAsSSML = false;
+        }
+        else { // 'auto'
+            const detection = this.detectSSML(content);
+            treatAsSSML = detection.isSSML;
+            if (detection.isSSML) {
+                console.log('→ Detected SSML input');
+                if (!detection.isValid) {
+                    console.warn('⚠ SSML validation warnings:', detection.errors);
+                }
+            }
+            else {
+                console.log('→ Detected plain text input');
+            }
+        }
+        if (treatAsSSML) {
+            let ssml = content.trim();
+            if (!ssml.includes('xmlns=')) {
+                ssml = ssml.replace(/<speak([^>]*)>/i, '<speak$1 xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts">');
+            }
+            if (!/<voice\b[^>]*>/i.test(ssml) && voice) {
+                ssml = ssml.replace(/(<speak[^>]*>)([\s\S]*?)(<\/speak>)/i, `$1<voice name="${voice}">$2</voice>$3`);
+            }
+            return ssml;
         }
         const pitch = this.validatePitch(options.pitch ?? 0);
         const rate = this.validateRate(options.rate ?? 0);
         const volume = this.validateVolume(options.volume ?? 0);
-        return `<speak version='1.0' xml:lang='en-US'><voice name='${voice}'><prosody pitch='${pitch}' rate='${rate}' volume='${volume}'>${text}</prosody></voice></speak>`;
+        const escapedText = this.escapeXML(content);
+        return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">
+                    <voice name="${voice}">
+                        <prosody pitch="${pitch}" rate="${rate}" volume="${volume}">
+                            ${escapedText}
+                        </prosody>
+                    </voice>
+                </speak>
+        `;
     }
     buildTTSConfigMessage() {
         return `X-Timestamp:${new Date().toISOString()}Z\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
@@ -140,8 +221,14 @@ class EdgeTTS {
     }
     async *synthesizeStream(text, voice = 'en-US-AnaNeural', options = {}) {
         this.audio_stream = [];
-        const req_id = this.generateUUID();
-        this.ws = new ws_1.default(`${constants_1.Constants.WSS_URL}?trustedclienttoken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&ConnectionId=${req_id}`);
+        const reqId = this.generateUUID();
+        const secMsGEC = await this.generateSecMsGec(constants_1.Constants.TRUSTED_CLIENT_TOKEN);
+        const url = `${constants_1.Constants.WSS_URL}?Ocp-Apim-Subscription-Key=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${constants_1.Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
+        this.ws = new ws_1.default(url, {
+            headers: {
+                "User-Agent": constants_1.Constants.USER_AGENT
+            }
+        });
         const SSML_text = this.getSSML(text, voice, options);
         const queue = [];
         let done = false;
@@ -162,7 +249,7 @@ class EdgeTTS {
         this.ws.on('open', () => {
             const message = this.buildTTSConfigMessage();
             this.ws.send(message);
-            const speechMessage = `X-RequestId:${req_id}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${new Date().toISOString()}Z\r\nPath:ssml\r\n\r\n${SSML_text}`;
+            const speechMessage = `X-RequestId:${reqId}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${new Date().toISOString()}Z\r\nPath:ssml\r\n\r\n${SSML_text}`;
             this.ws.send(speechMessage);
         });
         this.ws.on('message', (data) => {
@@ -175,6 +262,15 @@ class EdgeTTS {
                 this.audio_stream.push(chunk);
                 push(chunk);
             }
+            if (buffer.toString().includes("Path:audio.metadata")) {
+                const metadataStart = buffer.indexOf("\r\n\r\n") + 4;
+                const metadataJson = buffer.toString().substring(metadataStart);
+                const meta = this.parseMetadata(metadataJson);
+                if (meta !== null) {
+                    this.word_boundaries.push(meta);
+                }
+                return;
+            }
             if (buffer.toString().includes('Path:turn.end')) {
                 this.ws?.close();
             }
@@ -217,10 +313,56 @@ class EdgeTTS {
             const audioChunk = buffer.subarray(audioStartIndex + needle.length);
             this.audio_stream.push(new Uint8Array(audioChunk));
         }
+        if (buffer.toString().includes("Path:audio.metadata")) {
+            const metadataStart = buffer.indexOf("\r\n\r\n") + 4;
+            const metadataJson = buffer.toString().substring(metadataStart);
+            const meta = this.parseMetadata(metadataJson);
+            if (meta !== null) {
+                this.word_boundaries.push(meta);
+            }
+            return;
+        }
         if (buffer.toString().includes("Path:turn.end")) {
             this.ws?.close();
         }
     }
+    parseMetadata(data, offsetCompensation = 0) {
+        let metadata;
+        try {
+            metadata = JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+        if (!metadata.Metadata) {
+            return null;
+        }
+        for (const metaObj of metadata.Metadata) {
+            if (metaObj.Type === "WordBoundary") {
+                const currentOffset = metaObj.Data.Offset + offsetCompensation;
+                const currentDuration = metaObj.Data.Duration;
+                return {
+                    type: "WordBoundary",
+                    offset: currentOffset,
+                    duration: currentDuration,
+                    text: metaObj.Data.text?.Text,
+                };
+            }
+        }
+        return null;
+    }
+    async generateSecMsGec(trustedClientToken) {
+        const ticks = Math.floor(Date.now() / 1000) + 11644473600;
+        const rounded = ticks - (ticks % 300);
+        const windowsTicks = rounded * 10000000;
+        const encoder = new TextEncoder();
+        const data = encoder.encode(`${windowsTicks}${trustedClientToken}`);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        return Array.from(new Uint8Array(hashBuffer))
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join('')
+            .toUpperCase();
+    }
     getDuration() {
         if (this.audio_stream.length === 0) {
             throw new Error("No audio data available");
@@ -258,5 +400,15 @@ class EdgeTTS {
         }
         return buffer_1.Buffer.concat(this.audio_stream);
     }
+    async saveMetadata(outputPath) {
+        if (this.word_boundaries.length === 0) {
+            throw new Error("No metadata available to save.");
+        }
+        const json = JSON.stringify(this.word_boundaries, null, 4);
+        await (0, promises_1.writeFile)(outputPath, json);
+    }
+    getWordBoundaries() {
+        return this.word_boundaries;
+    }
 }
 exports.EdgeTTS = EdgeTTS;

package/package.json

@@ -1,48 +1,48 @@
-{
-  "name": "@andresaya/edge-tts",
-  "version": "1.3.1",
-  "description": "Edge TTS is a package that allows access to the online text-to-speech service used by Microsoft Edge without the need for Microsoft Edge, Windows, or an API key.",
-  "main": "dist/index.js",
-  "keywords": [
-    "edge",
-    "tts",
-    "text-to-speech",
-    "microsoft",
-    "microsoft edge",
-    "speech-synthesis"
-  ],
-  "author": "Andres Aya",
-  "license": "GPL-3.0-only",
-  "homepage": "https://github.com/andresayac/edge-tts",
-  "bugs": {
-    "url": "https://github.com/andresayac/edge-tts/issues"
-  },
-  "scripts": {
-    "build": "tsc",
-    "build:bin": "bun scripts/build.ts"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.6.2"
-  },
-  "dependencies": {
-    "@types/uuid": "^10.0.0",
-    "commander": "^12.1.0",
-    "events": "^3.3.0",
-    "fs": "^0.0.1-security",
-    "ws": "^8.18.0"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "files": [
-    "dist"
-  ],
-  "bin": {
-    "edge-tts": "./dist/cli/edge-tts.js"
-  },
-  "engines": {
-    "bun": ">=0.5.0"
-  }
-}
+{
+  "name": "@andresaya/edge-tts",
+  "version": "1.4.0",
+  "description": "Edge TTS is a package that allows access to the online text-to-speech service used by Microsoft Edge without the need for Microsoft Edge, Windows, or an API key.",
+  "main": "dist/index.js",
+  "keywords": [
+    "edge",
+    "tts",
+    "text-to-speech",
+    "microsoft",
+    "microsoft edge",
+    "speech-synthesis"
+  ],
+  "author": "Andres Aya",
+  "license": "GPL-3.0-only",
+  "homepage": "https://github.com/andresayac/edge-tts",
+  "bugs": {
+    "url": "https://github.com/andresayac/edge-tts/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:bin": "bun scripts/build.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.6.2"
+  },
+  "dependencies": {
+    "@types/uuid": "^10.0.0",
+    "commander": "^12.1.0",
+    "events": "^3.3.0",
+    "fs": "^0.0.1-security",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "edge-tts": "./dist/cli/edge-tts.js"
+  },
+  "engines": {
+    "bun": ">=0.5.0"
+  }
+}