@andresaya/edge-tts 1.8.3 → 1.9.1

package/dist/browser/edge-tts.esm.js

@@ -2,6 +2,14 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/core/crypto.ts
+var impl;
+function webCrypto() {
+  const crypto = impl ?? globalThis.crypto;
+  if (!crypto) throw new Error("Web Crypto is not available in this environment");
+  return crypto;
+}
+
 // src/config/constants.ts
 var Constants = {
   TRUSTED_CLIENT_TOKEN: "6A5AA1D4EAFF4E9FB37E23D68491D6F4",
@@ -14,7 +22,7 @@ var Constants = {
   VERSION_MS_GEC: "1-155.0.4283.45",
   token32() {
     const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
+    webCrypto().getRandomValues(bytes);
     return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
   },
   getBaseHeaders() {
@@ -48,74 +56,497 @@ var Constants = {
   }
 };
 
-// src/browser/EdgeTTS.browser.ts
-var EdgeTTS = class {
-  constructor() {
+// src/core/clock.ts
+var skewMs = 0;
+function now() {
+  return Date.now() + skewMs;
+}
+
+// src/core/errors.ts
+var EdgeTTSError = class extends Error {
+  constructor(message, code, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    __publicField(this, "code");
+    __publicField(this, "status");
+    this.name = "EdgeTTSError";
+    this.code = code;
+    if (options.status !== void 0) this.status = options.status;
+  }
+};
+
+// src/core/protocol.ts
+var DEFAULT_OUTPUT_FORMAT = "audio-24khz-48kbitrate-mono-mp3";
+var decoder = new TextDecoder();
+function buildSynthesisUrl(base, token, secMsGec, version, connectionId) {
+  return `${base}?Ocp-Apim-Subscription-Key=${token}&Sec-MS-GEC=${secMsGec}&Sec-MS-GEC-Version=${version}&ConnectionId=${connectionId}`;
+}
+function buildConfigMessage(timestamp2, outputFormat) {
+  return `X-Timestamp:${timestamp2}\r
+Content-Type:application/json; charset=utf-8\r
+Path:speech.config\r
+\r
+{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":true,"wordBoundaryEnabled":true},"outputFormat":"${outputFormat}"}}}}`;
+}
+function buildSSMLMessage(requestId, timestamp2, ssml) {
+  return `X-RequestId:${requestId}\r
+Content-Type:application/ssml+xml\r
+X-Timestamp:${timestamp2}\r
+Path:ssml\r
+\r
+${ssml}`;
+}
+function escapeXML(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildSSML(text, voice, pitch, rate, volume) {
+  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}">
+                            ${escapeXML(text)}
+                        </prosody>
+                    </voice>
+                </speak>`;
+}
+function headerPath(head) {
+  return /Path:([^\r\n]*)/i.exec(head)?.[1]?.trim() ?? "";
+}
+function parseTextFrame(text) {
+  const split = text.indexOf("\r\n\r\n");
+  if (split === -1) return { path: headerPath(text), body: "" };
+  return { path: headerPath(text.slice(0, split)), body: text.slice(split + 4) };
+}
+function parseBinaryFrame(data) {
+  if (data.length < 2) return { path: "", body: new Uint8Array(0) };
+  const headerLength = data[0] << 8 | data[1];
+  return {
+    path: headerPath(decoder.decode(data.subarray(2, 2 + headerLength))),
+    body: data.slice(2 + headerLength)
+  };
+}
+function parseMetadata(body) {
+  let metadata;
+  try {
+    metadata = JSON.parse(body);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(metadata?.Metadata)) return [];
+  const boundaries = [];
+  for (const item of metadata.Metadata) {
+    if (item?.Type !== "WordBoundary" && item?.Type !== "SentenceBoundary") continue;
+    boundaries.push({
+      type: item.Type,
+      offset: item.Data.Offset,
+      duration: item.Data.Duration,
+      text: item.Data.text?.Text
+    });
+  }
+  return boundaries;
+}
+var OPENING_PUNCTUATION = `\xBF\xA1\xAB"'\u201C\u2018([`;
+function sentenceTextRestorer(source) {
+  let cursor = 0;
+  return (text) => {
+    const index = text ? source.indexOf(text, cursor) : -1;
+    if (index === -1) return text;
+    let start = index;
+    while (start > cursor && OPENING_PUNCTUATION.includes(source[start - 1])) start--;
+    cursor = index + text.length;
+    return source.slice(start, cursor);
+  };
+}
+async function generateSecMsGec(trustedClientToken, nowMs) {
+  const ticks = Math.floor(nowMs / 1e3) + 11644473600;
+  const rounded = ticks - ticks % 300;
+  const windowsTicks = rounded * 1e7;
+  const data = new TextEncoder().encode(`${windowsTicks}${trustedClientToken}`);
+  const hashBuffer = await webCrypto().subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+function generateUUID() {
+  return "xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function fileExtension(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";
+}
+function estimateDuration(bytes, outputFormat) {
+  const kbps = Number(/(\d+)kbitrate/.exec(outputFormat)?.[1] ?? 48);
+  return bytes * 8 / (kbps * 1e3);
+}
+function concatChunks(chunks) {
+  const result = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function normalizeVoices(data) {
+  const out = [];
+  for (const v of data || []) {
+    const short = v?.ShortName || "";
+    const locale = v?.Locale || "";
+    let base = short.replace(/^[a-z]{2}-[A-Z]{2}-/, "");
+    base = base.replace(/NeuralHD$/, "").replace(/Neural$/, "").trim();
+    const mix = `${v?.Name || ""} ${short}`;
+    const voiceType = v?.VoiceType || (/NeuralHD/i.test(mix) ? "NeuralHD" : "Neural");
+    const localeName = v?.LocaleName || (locale || null);
+    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();
+    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;
+}
+
+// src/core/session.ts
+var CONNECTING = 0;
+var OPEN = 1;
+var CLEAN_CLOSE_CODES = [1e3, 1005, 1006];
+function closeError(event) {
+  const code = event?.code;
+  if (typeof code !== "number" || CLEAN_CLOSE_CODES.includes(code)) return void 0;
+  const reason = typeof event?.reason === "string" && event.reason !== "" ? event.reason : `close code ${code}`;
+  return new EdgeTTSError(`The service refused the request: ${reason}`, "REFUSED", { status: code });
+}
+function abortReason(signal) {
+  if (signal.reason !== void 0) return signal.reason;
+  const error = new Error("This operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function toBytes(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return new Uint8Array(0);
+}
+function runSession(open, options) {
+  return new Promise((resolve, reject) => {
+    if (options.signal?.aborted) {
+      reject(abortReason(options.signal));
+      return;
+    }
+    const socket = open();
+    socket.binaryType = "arraybuffer";
+    let settled = false;
+    let opened = false;
+    let timer;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      if (error === void 0) {
+        resolve();
+        return;
+      }
+      if (socket.readyState === CONNECTING || socket.readyState === OPEN) socket.close();
+      reject(error);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        finish(new EdgeTTSError("WebSocket inactivity timeout - no response from server", "TIMEOUT"));
+      }, options.timeout);
+    };
+    const onAbort = () => finish(abortReason(options.signal));
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    arm();
+    socket.onopen = () => {
+      if (settled) return;
+      opened = true;
+      arm();
+      socket.send(options.configMessage);
+      socket.send(options.ssmlMessage);
+    };
+    socket.onmessage = (event) => {
+      if (settled) return;
+      arm();
+      if (typeof event.data === "string") {
+        const frame2 = parseTextFrame(event.data);
+        if (frame2.path === "audio.metadata") {
+          for (const boundary of parseMetadata(frame2.body)) options.onBoundary(boundary);
+        } else if (frame2.path === "turn.end") {
+          socket.close();
+        }
+        return;
+      }
+      const frame = parseBinaryFrame(toBytes(event.data));
+      if (frame.path === "audio") options.onAudio(frame.body);
+    };
+    socket.onerror = (event) => finish(options.toError(event, opened));
+    socket.onclose = (event) => finish(closeError(event));
+  });
+}
+
+// src/core/subtitles.ts
+function timestamp(ticks, separator) {
+  const total = Math.max(0, Math.round(ticks / 1e4));
+  const ms = total % 1e3;
+  const s = Math.floor(total / 1e3) % 60;
+  const m = Math.floor(total / 6e4) % 60;
+  const h = Math.floor(total / 36e5);
+  const pad = (n, width = 2) => String(n).padStart(width, "0");
+  return `${pad(h)}:${pad(m)}:${pad(s)}${separator}${pad(ms, 3)}`;
+}
+function toSRT(cues) {
+  return cues.map((cue, i) => `${i + 1}
+${timestamp(cue.offset, ",")} --> ${timestamp(cue.offset + cue.duration, ",")}
+${cue.text}
+`).join("\n");
+}
+function toVTT(cues) {
+  const body = cues.map((cue) => `${timestamp(cue.offset, ".")} --> ${timestamp(cue.offset + cue.duration, ".")}
+${cue.text}
+`).join("\n");
+  return `WEBVTT
+
+${body}`;
+}
+
+// src/core/base.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_VOICES_CACHE_TTL = 10 * 6e4;
+var NO_AUDIO_MESSAGE = "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.";
+function noAudioMessage(outputFormat) {
+  const supported = Object.values(Constants.OUTPUT_FORMAT);
+  if (supported.includes(outputFormat)) return NO_AUDIO_MESSAGE;
+  return `${NO_AUDIO_MESSAGE} The output format "${outputFormat}" may also be the cause: the service is known to support ${supported.join(", ")}.`;
+}
+function collect(text, words, sentences) {
+  const restore = sentenceTextRestorer(text);
+  return (boundary) => {
+    if (boundary.type === "WordBoundary") words.push(boundary);
+    else sentences.push({ ...boundary, text: restore(boundary.text) });
+  };
+}
+var EdgeTTSCore = class {
+  constructor(options = {}) {
     __publicField(this, "audio_stream", []);
-    __publicField(this, "ws");
+    __publicField(this, "output_format", DEFAULT_OUTPUT_FORMAT);
+    __publicField(this, "word_boundaries", []);
+    __publicField(this, "sentence_boundaries", []);
+    __publicField(this, "options");
+    __publicField(this, "voicesCache");
+    this.options = { ...options };
+  }
+  async recoverHandshake() {
+    return false;
+  }
+  signature() {
+    return generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN, now());
   }
   async normalizeVoices(data) {
-    const out = [];
-    for (const v of data || []) {
-      const short = v?.ShortName || "";
-      const locale = v?.Locale || "";
-      let base = short.replace(/^[a-z]{2}-[A-Z]{2}-/, "");
-      base = base.replace(/NeuralHD$/, "").replace(/Neural$/, "").trim();
-      const mix = `${v?.Name || ""} ${short}`;
-      const voiceType = v?.VoiceType || (/NeuralHD/i.test(mix) ? "NeuralHD" : "Neural");
-      const localeName = v?.LocaleName || (locale || null);
-      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();
-      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;
+    return normalizeVoices(data);
   }
   async getVoices() {
-    const secMsGEC = await this.generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN);
-    const response = await fetch(
-      `${Constants.VOICES_URL}?TrustedClientToken=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${Constants.VERSION_MS_GEC}`,
-      { headers: Constants.getBaseHeaders() }
-    );
-    const data = await response.json();
-    const voices = Array.isArray(data) ? data : data?.voices || [];
-    return this.normalizeVoices(voices);
+    if (this.voicesCache && this.voicesCache.expires > Date.now()) {
+      return JSON.parse(JSON.stringify(this.voicesCache.voices));
+    }
+    const secMsGEC = await this.signature();
+    const url = `${this.options.voicesUrl ?? Constants.VOICES_URL}?TrustedClientToken=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${this.options.secMsGecVersion ?? Constants.VERSION_MS_GEC}`;
+    const voices = await this.normalizeVoices(await this.requestVoices(url));
+    const ttl = this.options.voicesCacheTtl ?? DEFAULT_VOICES_CACHE_TTL;
+    if (ttl > 0) {
+      this.voicesCache = { expires: Date.now() + ttl, voices: JSON.parse(JSON.stringify(voices)) };
+    }
+    return voices;
   }
   async getVoicesByLanguage(locale) {
     const voices = await this.getVoices();
-    return voices.filter((voice) => voice.Locale.startsWith(locale));
+    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 & 3 | 8;
-      return v.toString(16);
-    });
+  async synthesize(text, voice = this.defaultVoice, options = {}) {
+    const audio = [];
+    const words = [];
+    const sentences = [];
+    this.audio_stream = audio;
+    this.word_boundaries = words;
+    this.sentence_boundaries = sentences;
+    this.output_format = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+    await this.run(text, voice, options, (chunk) => audio.push(chunk), collect(text, words, sentences));
+  }
+  async *synthesizeStream(text, voice = this.defaultVoice, options = {}) {
+    const audio = [];
+    const words = [];
+    const sentences = [];
+    this.audio_stream = audio;
+    this.word_boundaries = words;
+    this.sentence_boundaries = sentences;
+    this.output_format = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+    const controller = new AbortController();
+    const forwardAbort = () => controller.abort(abortReason(options.signal));
+    if (options.signal?.aborted) forwardAbort();
+    else options.signal?.addEventListener("abort", forwardAbort, { once: true });
+    const queue = [];
+    let wake = null;
+    let done = false;
+    let failure;
+    const notify = () => {
+      wake?.();
+      wake = null;
+    };
+    this.run(text, voice, { ...options, signal: controller.signal }, (chunk) => {
+      audio.push(chunk);
+      queue.push(chunk);
+      notify();
+    }, collect(text, words, sentences)).then(
+      () => {
+        done = true;
+        notify();
+      },
+      (error) => {
+        failure = error;
+        done = true;
+        notify();
+      }
+    );
+    try {
+      while (!done || queue.length > 0) {
+        if (queue.length === 0) {
+          await new Promise((resolve) => wake = resolve);
+          continue;
+        }
+        yield queue.shift();
+      }
+      if (failure !== void 0) throw failure;
+    } finally {
+      options.signal?.removeEventListener("abort", forwardAbort);
+      if (!done) controller.abort();
+    }
+  }
+  async generate(text, voice = this.defaultVoice, options = {}) {
+    const chunks = [];
+    const words = [];
+    const sentences = [];
+    await this.run(text, voice, options, (chunk) => chunks.push(chunk), collect(text, words, sentences));
+    const audio = concatChunks(chunks);
+    const outputFormat = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+    if (audio.length === 0) throw new EdgeTTSError(noAudioMessage(outputFormat), "NO_AUDIO");
+    return {
+      audio,
+      format: fileExtension(outputFormat),
+      outputFormat,
+      wordBoundaries: words,
+      sentenceBoundaries: sentences,
+      duration: estimateDuration(audio.length, outputFormat)
+    };
+  }
+  getWordBoundaries() {
+    return this.word_boundaries;
+  }
+  getSentenceBoundaries() {
+    return this.sentence_boundaries;
+  }
+  toSRT() {
+    return toSRT(this.sentence_boundaries.length > 0 ? this.sentence_boundaries : this.word_boundaries);
+  }
+  toVTT() {
+    return toVTT(this.sentence_boundaries.length > 0 ? this.sentence_boundaries : this.word_boundaries);
+  }
+  async run(text, voice, options, onAudio, onBoundary) {
+    if (text.trim() === "") throw new EdgeTTSError("The text is empty.", "INVALID_OPTION");
+    const ssml = this.buildSSML(text, voice, options);
+    const outputFormat = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+    const attempt = async () => {
+      const requestId = generateUUID();
+      const url = buildSynthesisUrl(
+        this.options.wssUrl ?? Constants.WSS_URL,
+        Constants.TRUSTED_CLIENT_TOKEN,
+        await this.signature(),
+        this.options.secMsGecVersion ?? Constants.VERSION_MS_GEC,
+        requestId
+      );
+      await runSession(() => this.openSocket(url), {
+        configMessage: buildConfigMessage(this.timestamp(), outputFormat),
+        ssmlMessage: buildSSMLMessage(requestId, this.timestamp(), ssml),
+        timeout: options.timeout ?? this.options.timeout ?? DEFAULT_TIMEOUT,
+        signal: options.signal,
+        onAudio,
+        onBoundary,
+        toError: (event, opened) => this.socketError(event, opened)
+      });
+    };
+    try {
+      await attempt();
+    } catch (error) {
+      if (!(error instanceof EdgeTTSError && error.code === "HANDSHAKE")) throw error;
+      if (!await this.recoverHandshake()) throw error;
+      await attempt();
+    }
+  }
+};
+
+// src/browser/EdgeTTS.browser.ts
+var EdgeTTS = class extends EdgeTTSCore {
+  constructor(options = {}) {
+    super(options);
+    __publicField(this, "defaultVoice", "en-US-JennyNeural");
+    __publicField(this, "ws");
+  }
+  openSocket(url) {
+    this.ws = new WebSocket(url);
+    return this.ws;
+  }
+  async requestVoices(url) {
+    const response = await fetch(url, { headers: Constants.getBaseHeaders() });
+    if (!response.ok) {
+      throw new EdgeTTSError(`Voice list request failed with status ${response.status}`, "VOICES", { status: response.status });
+    }
+    const data = await response.json();
+    return Array.isArray(data) ? data : data?.voices || [];
+  }
+  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 buildSSML(text, voice, pitch, rate, volume);
+  }
+  timestamp() {
+    return (/* @__PURE__ */ new Date()).toUTCString();
+  }
+  socketError(_event, opened) {
+    return new EdgeTTSError("WebSocket error", opened ? "NETWORK" : "HANDSHAKE");
   }
   validatePitch(pitch) {
     if (typeof pitch === "number") {
@@ -141,244 +572,21 @@ var EdgeTTS = class {
     }
     return `${volumeValue}%`;
   }
-  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() {
-    return (/* @__PURE__ */ new Date()).toUTCString();
-  }
-  parseRFC1123(rfcStr) {
-    return new Date(rfcStr);
-  }
-  buildTTSConfigMessage() {
-    const timestamp = this.nowRFC1123();
-    return `X-Timestamp:${timestamp}\r
-Content-Type:application/json; charset=utf-8\r
-Path:speech.config\r
-\r
-{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}`;
-  }
-  async synthesize(text, voice = "en-US-JennyNeural", options = {}) {
-    const secMsGEC = await this.generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN);
-    return new Promise((resolve, reject) => {
-      this.audio_stream = [];
-      const reqId = this.generateUUID();
-      const url = `${Constants.WSS_URL}?Ocp-Apim-Subscription-Key=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
-      this.ws = new WebSocket(url);
-      this.ws.binaryType = "arraybuffer";
-      const SSML_text = this.getSSML(text, voice, options);
-      let timedOut = false;
-      let inactivityTimeout;
-      const resetInactivityTimeout = () => {
-        clearTimeout(inactivityTimeout);
-        inactivityTimeout = window.setTimeout(() => {
-          timedOut = true;
-          if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            this.ws.close();
-          }
-          reject(new Error("WebSocket inactivity timeout - no response from server"));
-        }, 3e4);
-      };
-      this.ws.onopen = () => {
-        resetInactivityTimeout();
-        const message = this.buildTTSConfigMessage();
-        this.ws.send(message);
-        const timestamp = this.nowRFC1123();
-        const speechMessage = `X-RequestId:${reqId}\r
-Content-Type:application/ssml+xml\r
-X-Timestamp:${timestamp}\r
-Path:ssml\r
-\r
-${SSML_text}`;
-        this.ws.send(speechMessage);
-      };
-      this.ws.onmessage = (event) => {
-        resetInactivityTimeout();
-        if (typeof event.data === "string") {
-          if (event.data.includes("Path:turn.end")) {
-            this.ws?.close();
-          }
-        } else {
-          this.processAudioData(new Uint8Array(event.data));
-        }
-      };
-      this.ws.onerror = (err) => {
-        clearTimeout(inactivityTimeout);
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-          this.ws.close();
-        }
-        reject(new Error("WebSocket error"));
-      };
-      this.ws.onclose = () => {
-        clearTimeout(inactivityTimeout);
-        if (!timedOut) {
-          resolve();
-        }
-      };
-    });
-  }
-  async *synthesizeStream(text, voice = "en-US-JennyNeural", options = {}) {
-    this.audio_stream = [];
-    const reqId = this.generateUUID();
-    const secMsGEC = await this.generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN);
-    const url = `${Constants.WSS_URL}?Ocp-Apim-Subscription-Key=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
-    this.ws = new WebSocket(url);
-    this.ws.binaryType = "arraybuffer";
-    const SSML_text = this.getSSML(text, voice, options);
-    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 = window.setTimeout(() => {
-        timedOut = true;
-        error = new Error("WebSocket inactivity timeout - no response from server");
-        done = true;
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-          this.ws.close();
-        }
-        if (notify) {
-          notify();
-          notify = null;
-        }
-      }, 3e4);
-    };
-    this.ws.onopen = () => {
-      resetInactivityTimeout();
-      const message = this.buildTTSConfigMessage();
-      this.ws.send(message);
-      const timestamp = this.nowRFC1123();
-      const speechMessage = `X-RequestId:${reqId}\r
-Content-Type:application/ssml+xml\r
-X-Timestamp:${timestamp}\r
-Path:ssml\r
-\r
-${SSML_text}`;
-      this.ws.send(speechMessage);
-    };
-    this.ws.onmessage = (event) => {
-      resetInactivityTimeout();
-      if (typeof event.data === "string") {
-        if (event.data.includes("Path:turn.end")) {
-          this.ws?.close();
-        }
-      } else {
-        const uint8Array = new Uint8Array(event.data);
-        const needle = new TextEncoder().encode("Path:audio\r\n");
-        const audioStartIndex = this.indexOf(uint8Array, needle);
-        if (audioStartIndex !== -1) {
-          const audioChunk = uint8Array.slice(audioStartIndex + needle.length);
-          this.audio_stream.push(audioChunk);
-          push(audioChunk);
-        }
-      }
-    };
-    this.ws.onerror = (err) => {
-      clearTimeout(inactivityTimeout);
-      error = new Error("WebSocket error");
-      done = true;
-      if (notify) {
-        notify();
-        notify = null;
-      }
-    };
-    this.ws.onclose = () => {
-      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(buffer) {
-    const needle = new TextEncoder().encode("Path:audio\r\n");
-    const audioStartIndex = this.indexOf(buffer, needle);
-    if (audioStartIndex !== -1) {
-      const audioChunk = buffer.slice(audioStartIndex + needle.length);
-      this.audio_stream.push(audioChunk);
-    }
-  }
-  indexOf(arr, subarr) {
-    for (let i = 0; i <= arr.length - subarr.length; i++) {
-      let match = true;
-      for (let j = 0; j < subarr.length; j++) {
-        if (arr[i + j] !== subarr[j]) {
-          match = false;
-          break;
-        }
-      }
-      if (match) return i;
-    }
-    return -1;
-  }
-  async generateSecMsGec(trustedClientToken) {
-    const now = this.nowRFC1123();
-    const fixedDate = this.parseRFC1123(now);
-    const ticks = Math.floor(fixedDate.getTime() / 1e3) + 11644473600;
-    const rounded = ticks - ticks % 300;
-    const windowsTicks = rounded * 1e7;
-    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();
-  }
   getAudioData() {
     if (this.audio_stream.length === 0) {
-      throw new Error("No audio data available");
-    }
-    const totalLength = this.audio_stream.reduce((acc, chunk) => acc + chunk.length, 0);
-    if (totalLength === 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 EdgeTTSError("No audio data available", "NO_AUDIO");
     }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of this.audio_stream) {
-      result.set(chunk, offset);
-      offset += chunk.length;
+    const result = concatChunks(this.audio_stream);
+    if (result.length === 0) {
+      throw new EdgeTTSError(noAudioMessage(this.output_format), "NO_AUDIO");
     }
     return result;
   }
 };
 export {
-  EdgeTTS
+  EdgeTTS,
+  EdgeTTSError,
+  toSRT,
+  toVTT
 };
 //# sourceMappingURL=edge-tts.esm.js.map