@andresaya/edge-tts 1.8.3 → 1.9.1

package/dist/services/EdgeTTS.js

@@ -8,95 +8,53 @@ const ws_1 = __importDefault(require("ws"));
 const constants_1 = require("../config/constants");
 const promises_1 = require("fs/promises");
 const buffer_1 = require("buffer");
+const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
-function ensureBuffer(data) {
-    if (buffer_1.Buffer.isBuffer(data)) {
-        return data;
-    }
-    if (data instanceof ArrayBuffer) {
-        return buffer_1.Buffer.from(data);
-    }
-    if (Array.isArray(data)) {
-        return buffer_1.Buffer.concat(data);
+const crypto_1 = require("crypto");
+const base_1 = require("../core/base");
+const clock_1 = require("../core/clock");
+const crypto_2 = require("../core/crypto");
+const errors_1 = require("../core/errors");
+const protocol_1 = require("../core/protocol");
+// NOTE: Node 18 has no global crypto.
+if (!globalThis.crypto)
+    (0, crypto_2.setWebCrypto)(crypto_1.webcrypto);
+class EdgeTTS extends base_1.EdgeTTSCore {
+    defaultVoice = 'en-US-AnaNeural';
+    ws;
+    constructor(options = {}) {
+        super(options);
     }
-    if (typeof data === 'string') {
-        return buffer_1.Buffer.from(data, 'utf-8');
+    generateSecMsGec = async (trustedClientToken) => {
+        return (0, protocol_1.generateSecMsGec)(trustedClientToken, (0, clock_1.now)());
+    };
+    async generate(text, voice, options) {
+        const result = await super.generate(text, voice, options);
+        return { ...result, audio: buffer_1.Buffer.from(result.audio.buffer, result.audio.byteOffset, result.audio.byteLength) };
     }
-    throw new Error(`Unsupported RawData type: ${typeof data}`);
-}
-class EdgeTTS {
-    audio_stream = [];
-    audio_format = 'mp3';
-    output_format = 'audio-24khz-48kbitrate-mono-mp3';
-    word_boundaries = [];
-    ws;
-    async normalizeVoices(data) {
-        const out = [];
-        for (const v of data || []) {
-            const short = v?.ShortName || "";
-            const locale = v?.Locale || "";
-            // base: remove locale prefix and Neural/NeuralHD suffix
-            let base = short.replace(/^[a-z]{2}-[A-Z]{2}-/, "");
-            base = base.replace(/NeuralHD$/, "").replace(/Neural$/, "").trim();
-            // VoiceType: if NeuralHD/Neural in Name or ShortName
-            const mix = `${v?.Name || ""} ${short}`;
-            const voiceType = v?.VoiceType || (/NeuralHD/i.test(mix) ? "NeuralHD" : "Neural");
-            // LocaleName: prefer LocaleName -> LanguageName -> locale
-            const localeName = v?.LocaleName || (locale || null);
-            // DisplayName: prefer DisplayName -> FriendlyName -> base -> short
-            let display = v?.DisplayName || v?.FriendlyName || base || short;
-            display = display.replace(/^Microsoft\s+/i, "");
-            display = display.split(" - ")[0].trim();
-            display = display.replace(/\s*Online\s*\(Natural\)\s*/i, " ");
-            display = display.replace(/\s*Online\s*/i, " ");
-            display = display.replace(/\s+/g, " ").trim();
-            // VoiceTag parsing
-            const tag = (v?.VoiceTag && typeof v.VoiceTag === "object") ? v.VoiceTag : {};
-            const tailored = Array.isArray(tag.TailoredScenarios)
-                ? tag.TailoredScenarios
-                : (Array.isArray(tag.ContentCategories) ? tag.ContentCategories : []);
-            const personalities = Array.isArray(tag.VoicePersonalities)
-                ? tag.VoicePersonalities
-                : [];
-            out.push({
-                Name: short || (v?.Name || ""),
-                DisplayName: display,
-                LocalName: display,
-                ShortName: short || (v?.Name || ""),
-                Gender: v?.Gender ?? null,
-                Locale: locale || null,
-                LocaleName: localeName,
-                SecondaryLocaleList: Array.isArray(v?.SecondaryLocaleList) ? v.SecondaryLocaleList : [],
-                VoiceType: voiceType,
-                VoiceTag: {
-                    TailoredScenarios: tailored,
-                    VoicePersonalities: personalities,
-                },
-                FriendlyName: `${display} (${voiceType}) - ${localeName}`,
-            });
-        }
-        return out;
+    openSocket(url) {
+        this.ws = new ws_1.default(url, {
+            headers: { ...constants_1.Constants.getBaseHeaders(), ...constants_1.Constants.WSS_HEADERS, ...this.options.headers }
+        });
+        return this.ws;
     }
-    async getVoices() {
-        const secMsGEC = await this.generateSecMsGec(constants_1.Constants.TRUSTED_CLIENT_TOKEN);
-        const url = `${constants_1.Constants.VOICES_URL}` +
-            `?TrustedClientToken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}` +
-            `&Sec-MS-GEC=${secMsGEC}` +
-            `&Sec-MS-GEC-Version=${constants_1.Constants.VERSION_MS_GEC}`;
+    requestVoices(url) {
         const headers = {
             ...constants_1.Constants.getBaseHeaders(),
             ...constants_1.Constants.VOICE_HEADERS,
+            ...this.options.headers,
             "Accept-Encoding": "identity", // evita gzip/br/zstd
         };
-        const voicesRaw = await new Promise((resolve, reject) => {
-            const req = https_1.default.request(url, { method: "GET", headers }, (res) => {
+        const client = url.startsWith('http:') ? http_1.default : https_1.default;
+        return new Promise((resolve, reject) => {
+            const req = client.request(url, { method: "GET", headers }, (res) => {
                 const chunks = [];
                 res.on("data", (chunk) => chunks.push(buffer_1.Buffer.isBuffer(chunk) ? chunk : buffer_1.Buffer.from(chunk)));
                 res.on("error", reject);
                 res.on("end", () => {
                     const body = buffer_1.Buffer.concat(chunks).toString("utf8");
                     if (res.statusCode !== 200) {
-                        reject(new Error(`Voice list request failed with status ${res.statusCode}`));
+                        reject(new errors_1.EdgeTTSError(`Voice list request failed with status ${res.statusCode}`, 'VOICES', { status: res.statusCode }));
                         return;
                     }
                     try {
@@ -108,28 +66,47 @@ class EdgeTTS {
                         resolve(Array.isArray(voices) ? voices : []);
                     }
                     catch (e) {
-                        reject(new Error("Invalid voice list JSON: " + (e?.message || String(e))));
+                        reject(new errors_1.EdgeTTSError("Invalid voice list JSON: " + (e?.message || String(e)), 'VOICES', { cause: e }));
                     }
                 });
             });
             req.on("error", reject);
             req.end();
         });
-        return this.normalizeVoices(voicesRaw);
     }
-    async getVoicesByLanguage(locale) {
-        const voices = await this.getVoices();
-        return voices.filter(voice => voice.Locale.startsWith(locale));
-    }
-    async getVoicesByGender(gender) {
-        const voices = await this.getVoices();
-        return voices.filter(voice => voice.Gender === gender);
-    }
-    generateUUID() {
-        return 'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            const r = Math.random() * 16 | 0;
-            const v = c === 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
+    buildSSML(text, voice, options) {
+        const pitch = this.validatePitch(options.pitch ?? 0);
+        const rate = this.validateRate(options.rate ?? 0);
+        const volume = this.validateVolume(options.volume ?? 0);
+        return (0, protocol_1.buildSSML)(text, voice, pitch, rate, volume);
+    }
+    timestamp() {
+        return this.nowRFC1123();
+    }
+    socketError(event, opened) {
+        const { error, message } = event;
+        const cause = error instanceof Error ? error : new Error(message || 'WebSocket error');
+        if (opened || cause.code !== undefined)
+            return cause;
+        const status = /Unexpected server response: (\d{3})/.exec(cause.message)?.[1];
+        return new errors_1.EdgeTTSError(cause.message, 'HANDSHAKE', { status: status ? Number(status) : undefined, cause });
+    }
+    async recoverHandshake() {
+        const serverTime = await this.serverTime();
+        return serverTime !== undefined && (0, clock_1.adjustClock)(serverTime);
+    }
+    serverTime() {
+        const origin = new URL((this.options.wssUrl ?? constants_1.Constants.WSS_URL).replace(/^ws/, 'http')).origin + '/';
+        const client = origin.startsWith('http:') ? http_1.default : https_1.default;
+        return new Promise(resolve => {
+            const req = client.request(origin, { method: 'HEAD', timeout: 10_000 }, (res) => {
+                res.resume();
+                const date = Date.parse(res.headers.date ?? '');
+                resolve(Number.isNaN(date) ? undefined : date);
+            });
+            req.on('timeout', () => req.destroy());
+            req.on('error', () => resolve(undefined));
+            req.end();
         });
     }
     validatePitch(pitch) {
@@ -137,7 +114,7 @@ class EdgeTTS {
             return (pitch >= 0 ? `+${pitch}Hz` : `${pitch}Hz`);
         }
         if (!/^[+-]?\d{1,3}(?:\.\d+)?Hz$/.test(pitch)) {
-            throw new Error("Invalid pitch format. Expected format: '-100Hz to +100Hz' or a number.");
+            throw new errors_1.EdgeTTSError("Invalid pitch format. Expected format: '-100Hz to +100Hz' or a number.", 'INVALID_OPTION');
         }
         return pitch;
     }
@@ -146,7 +123,7 @@ class EdgeTTS {
         if (typeof rate === 'string') {
             rateValue = parseFloat(rate.replace('%', ''));
             if (isNaN(rateValue))
-                throw new Error("Invalid rate format.");
+                throw new errors_1.EdgeTTSError("Invalid rate format.", 'INVALID_OPTION');
         }
         else {
             rateValue = rate;
@@ -161,90 +138,16 @@ class EdgeTTS {
         if (typeof volume === 'string') {
             volumeValue = parseInt(volume.replace('%', ''), 10);
             if (isNaN(volumeValue))
-                throw new Error("Invalid volume format.");
+                throw new errors_1.EdgeTTSError("Invalid volume format.", 'INVALID_OPTION');
         }
         else {
             volumeValue = volume;
         }
         if (volumeValue < -100 || volumeValue > 100) {
-            throw new Error("Invalid volume. Expected a value from -100% to 100%.");
+            throw new errors_1.EdgeTTSError("Invalid volume. Expected a value from -100% to 100%.", 'INVALID_OPTION');
         }
         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 = [];
-            this.word_boundaries = [];
-            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: { ...constants_1.Constants.getBaseHeaders(), ...constants_1.Constants.WSS_HEADERS }
-            });
-            const SSML_text = this.getSSML(text, voice, options);
-            const outputFormat = options.outputFormat || 'audio-24khz-48kbitrate-mono-mp3';
-            this.output_format = outputFormat;
-            let timedOut = false;
-            let inactivityTimeout;
-            const resetInactivityTimeout = () => {
-                clearTimeout(inactivityTimeout);
-                inactivityTimeout = setTimeout(() => {
-                    timedOut = true;
-                    if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                        this.ws.close();
-                    }
-                    reject(new Error("WebSocket inactivity timeout - no response from server"));
-                }, 30000); // 30 seconds of inactivity
-            };
-            this.ws.on('open', () => {
-                resetInactivityTimeout(); // start the inactivity timeout
-                const message = this.buildTTSConfigMessage(outputFormat);
-                this.ws.send(message);
-                const timestamp = this.nowRFC1123();
-                const speechMessage = `X-RequestId:${reqId}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${timestamp}\r\nPath:ssml\r\n\r\n${SSML_text}`;
-                this.ws.send(speechMessage);
-            });
-            this.ws.on('message', (data) => {
-                resetInactivityTimeout(); // restart inactivity timeout
-                this.processAudioData(data);
-            });
-            this.ws.on('error', (err) => {
-                clearTimeout(inactivityTimeout);
-                if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                    this.ws.close();
-                }
-                reject(err);
-            });
-            this.ws.on('close', () => {
-                clearTimeout(inactivityTimeout);
-                if (!timedOut) {
-                    resolve();
-                }
-            });
-        });
-    }
-    escapeXML(text) {
-        return text
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&apos;');
-    }
-    getSSML(content, voice, options = {}) {
-        const pitch = this.validatePitch(options.pitch ?? 0);
-        const rate = this.validateRate(options.rate ?? 0);
-        const volume = this.validateVolume(options.volume ?? 0);
-        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>
-        `;
-    }
     nowRFC1123(timeZone = 'UTC') {
         const now = new Date();
         const options = {
@@ -260,223 +163,28 @@ class EdgeTTS {
         };
         return now.toLocaleString('en-US', options);
     }
-    parseRFC1123(rfcStr) {
-        return new Date(rfcStr);
-    }
-    buildTTSConfigMessage(outputFormat = 'audio-24khz-48kbitrate-mono-mp3') {
-        const timestamp = this.nowRFC1123();
-        return `X-Timestamp:${timestamp}\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
-            `{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},"outputFormat":"${outputFormat}"}}}}`;
-    }
-    async *synthesizeStream(text, voice = 'en-US-AnaNeural', options = {}) {
-        this.audio_stream = [];
-        this.word_boundaries = [];
-        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: { ...constants_1.Constants.getBaseHeaders(), ...constants_1.Constants.WSS_HEADERS }
-        });
-        const SSML_text = this.getSSML(text, voice, options);
-        const outputFormat = options.outputFormat || 'audio-24khz-48kbitrate-mono-mp3';
-        this.output_format = outputFormat;
-        const queue = [];
-        let done = false;
-        let error = null;
-        let notify = null;
-        const push = (chunk) => {
-            queue.push(chunk);
-            if (notify) {
-                notify();
-                notify = null;
-            }
-        };
-        let timedOut = false;
-        let inactivityTimeout;
-        const resetInactivityTimeout = () => {
-            clearTimeout(inactivityTimeout);
-            inactivityTimeout = setTimeout(() => {
-                timedOut = true;
-                error = new Error("WebSocket inactivity timeout - no response from server");
-                done = true;
-                if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                    this.ws.close();
-                }
-                if (notify) {
-                    notify();
-                    notify = null;
-                }
-            }, 30000); // 30 seconds of inactivity
-        };
-        this.ws.on('open', () => {
-            resetInactivityTimeout(); // start the inactivity timeout
-            const message = this.buildTTSConfigMessage(outputFormat);
-            this.ws.send(message);
-            const timestamp = this.nowRFC1123();
-            const speechMessage = `X-RequestId:${reqId}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${timestamp}\r\nPath:ssml\r\n\r\n${SSML_text}`;
-            this.ws.send(speechMessage);
-        });
-        this.ws.on('message', (data) => {
-            resetInactivityTimeout(); // restart inactivity timeout
-            const buffer = ensureBuffer(data);
-            const needle = buffer_1.Buffer.from('Path:audio\r\n');
-            const audioStartIndex = buffer.indexOf(new Uint8Array(needle));
-            if (audioStartIndex !== -1) {
-                const audioChunk = buffer.subarray(audioStartIndex + needle.length);
-                const chunk = new Uint8Array(audioChunk);
-                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();
-            }
-        });
-        this.ws.on('error', (err) => {
-            clearTimeout(inactivityTimeout);
-            error = err;
-            done = true;
-            if (notify) {
-                notify();
-                notify = null;
-            }
-        });
-        this.ws.on('close', () => {
-            clearTimeout(inactivityTimeout);
-            done = true;
-            if (notify) {
-                notify();
-                notify = null;
-            }
-        });
-        while (!done || queue.length > 0) {
-            if (queue.length === 0) {
-                await new Promise(resolve => (notify = resolve));
-                continue;
-            }
-            const chunk = queue.shift();
-            if (chunk) {
-                yield chunk;
-            }
-        }
-        if (error) {
-            throw error;
-        }
-    }
-    processAudioData(data) {
-        const buffer = ensureBuffer(data);
-        const needle = buffer_1.Buffer.from("Path:audio\r\n");
-        const audioStartIndex = buffer.indexOf(new Uint8Array(needle));
-        if (audioStartIndex !== -1) {
-            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;
-    }
-    generateSecMsGec = async (trustedClientToken) => {
-        const now = this.nowRFC1123();
-        const fixedDate = this.parseRFC1123(now);
-        const ticks = Math.floor(fixedDate.getTime() / 1000) + 11644473600;
-        const rounded = ticks - (ticks % 300);
-        const windowsTicks = rounded * 10_000_000;
-        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");
+            throw new errors_1.EdgeTTSError("No audio data available", 'NO_AUDIO');
         }
-        // NOTE: MP3 is CBR; formats without a bitrate (opus) assume 48 kbit/s.
-        const bufferSize = this.toBuffer().length;
-        const kbps = Number(/(\d+)kbitrate/.exec(this.output_format)?.[1] ?? 48);
-        return (bufferSize * 8) / (kbps * 1000);
-    }
-    getFileExtension(format) {
-        if (format.includes('mp3'))
-            return 'mp3';
-        if (format.includes('opus') && format.includes('webm'))
-            return 'webm';
-        if (format.includes('opus') && format.includes('ogg'))
-            return 'ogg';
-        if (format.includes('wav') || format.includes('riff'))
-            return 'wav';
-        if (format.includes('pcm') && format.includes('raw'))
-            return 'pcm';
-        if (format.includes('alaw'))
-            return 'alaw';
-        if (format.includes('mulaw'))
-            return 'mulaw';
-        if (format.includes('truesilk'))
-            return 'silk';
-        if (format.includes('g722'))
-            return 'g722';
-        if (format.includes('amr'))
-            return 'amr';
-        return 'audio';
+        return (0, protocol_1.estimateDuration)(this.toBuffer().length, this.output_format);
     }
     getAudioInfo() {
         const buffer = this.toBuffer();
         return {
             size: buffer.length,
-            format: this.getFileExtension(this.output_format),
+            format: (0, protocol_1.fileExtension)(this.output_format),
             estimatedDuration: this.getDuration()
         };
     }
     async toFile(outputPath, format) {
         if (!format) {
-            format = this.getFileExtension(this.output_format);
+            format = (0, protocol_1.fileExtension)(this.output_format);
         }
         const audioBuffer = this.toBuffer();
-        const finalPath = `${outputPath}.${format}`;
+        const finalPath = outputPath.toLowerCase().endsWith(`.${format.toLowerCase()}`)
+            ? outputPath
+            : `${outputPath}.${format}`;
         await (0, promises_1.writeFile)(finalPath, new Uint8Array(audioBuffer));
         return finalPath;
     }
@@ -488,16 +196,14 @@ class EdgeTTS {
     }
     toBuffer() {
         if (this.audio_stream.length === 0) {
-            throw new Error("No audio data available. Did you run synthesize() first?");
+            throw new errors_1.EdgeTTSError("No audio data available. Did you run synthesize() first?", 'NO_AUDIO');
         }
         // When the service cannot speak the text it answers with a single empty
         // chunk, so the stream is not empty but the audio is. Checking the byte
         // count rather than the chunk count is what catches that.
         const buffer = buffer_1.Buffer.concat(this.audio_stream);
         if (buffer.length === 0) {
-            throw new Error("The service returned no audio. Voices are locale specific, so a voice cannot " +
-                "read text written in another script. Check that the voice matches the language " +
-                "of the text.");
+            throw new errors_1.EdgeTTSError((0, base_1.noAudioMessage)(this.output_format), 'NO_AUDIO');
         }
         return buffer;
     }
@@ -508,8 +214,5 @@ class EdgeTTS {
         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,6 +1,6 @@
 {
   "name": "@andresaya/edge-tts",
-  "version": "1.8.3",
+  "version": "1.9.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",
   "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "url": "https://github.com/andresayac/edge-tts/issues"
   },
   "devDependencies": {
-    "@types/bun": "latest",
+    "@types/bun": "^1.3.3",
     "@types/ws": "^8.18.1",
     "esbuild": "^0.25.12",
     "typescript": "^5.6.2"
@@ -42,6 +42,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "test": "bun test",
     "build:bin": "bun scripts/build.ts",
     "build:browser": "bun scripts/build-browser.ts"
   }