ssml-builder-js 2.12.0 → 2.13.0

package/dist/index.js

@@ -51,11 +51,14 @@ __export(src_exports, {
   getBuiltInVoiceCatalogMetadata: () => getBuiltInVoiceCatalogMetadata,
   isValidAzureAudioDuration: () => isValidAzureAudioDuration,
   mapSsmlTextNodes: () => mapSsmlTextNodes,
+  mergeSynthesisResults: () => mergeSynthesisResults,
   normalizeAzureLanguage: () => normalizeAzureLanguage,
   parseSsml: () => parseSsml,
   splitSsmlDocument: () => splitSsmlDocument,
   synthesizeSpeech: () => synthesizeSpeech,
   synthesizeSsml: () => synthesizeSsml,
+  synthesizeSsmlChunks: () => synthesizeSsmlChunks,
+  synthesizeSsmlSafe: () => synthesizeSsmlSafe,
   validateAzureSsml: () => validateAzureSsml,
   validateSsml: () => validateSsml,
   validateSsmlStructureIntegrity: () => validateSsmlStructureIntegrity
@@ -1061,30 +1064,109 @@ function splitNode(document, node, maxLength, context = []) {
   flush();
   return parts;
 }
-function splitSsmlDocument(ssml, maxLength = DEFAULT_MAX_LENGTH) {
-  if (!Number.isInteger(maxLength) || maxLength <= 0) {
+function textFromNode(node) {
+  if (typeof node === "string") return node;
+  if (node.type === "text") return node.value;
+  return (node.children ?? []).map(textFromNode).join("");
+}
+function collectMarks(node, marks) {
+  if (typeof node === "string" || node.type === "text") return;
+  if (node.type === "mark" && node.name) marks.push(node.name);
+  if (node.type === "bookmark" && node.mark) marks.push(node.mark);
+  for (const child of node.children ?? []) collectMarks(child, marks);
+}
+function collectInheritedContext(nodes) {
+  const context = {};
+  const visit = (node) => {
+    if (typeof node === "string" || node.type === "text") return;
+    if (context.voice === void 0 && node.type === "voice" && node.name) context.voice = node.name;
+    if (context.lang === void 0 && node.type === "lang" && node.lang) context.lang = node.lang;
+    if (context.prosody === void 0 && node.type === "prosody") {
+      const prosody = {};
+      for (const [key, value] of Object.entries(node.attributes ?? {})) prosody[key] = String(value);
+      for (const key of ["rate", "pitch", "volume", "contour", "range"]) {
+        const value = node[key];
+        if (value !== void 0) prosody[key] = String(value);
+      }
+      if (Object.keys(prosody).length > 0) context.prosody = prosody;
+    }
+    for (const child of node.children ?? []) visit(child);
+  };
+  nodes.forEach(visit);
+  return context;
+}
+function createChunk(document, nodes, chunkIndex, textStart, backgroundAudio, replicateBackgroundAudio) {
+  const chunkNodes = backgroundAudio && (replicateBackgroundAudio || chunkIndex === 0) ? [backgroundAudio, ...nodes] : nodes;
+  const text = nodes.map(textFromNode).join("");
+  const marks = [];
+  for (const node of nodes) collectMarks(node, marks);
+  const inheritedContext = collectInheritedContext(nodes);
+  if (inheritedContext.lang === void 0 && document.lang) inheritedContext.lang = document.lang;
+  return {
+    chunkIndex,
+    ssml: documentWithChildren(document, chunkNodes),
+    originalTextRange: { start: textStart, end: textStart + text.length },
+    inheritedContext,
+    containedMarks: marks,
+    hasBackgroundAudio: chunkNodes.some(
+      (node) => typeof node !== "string" && node.type !== "text" && node.type === "mstts:backgroundaudio"
+    )
+  };
+}
+function splitSsmlDocument(ssml, maxLength = DEFAULT_MAX_LENGTH, options = {}) {
+  const resolvedMaxLength = typeof maxLength === "number" ? maxLength : maxLength.maxLength ?? DEFAULT_MAX_LENGTH;
+  const resolvedOptions = typeof maxLength === "number" ? options : maxLength;
+  if (!Number.isInteger(resolvedMaxLength) || resolvedMaxLength <= 0) {
     throw new RangeError("maxLength must be a positive integer");
   }
   const document = parseSsml(ssml);
-  if (ssml.length <= maxLength) return [ssml];
-  const children = document.children ?? [];
-  const splitChildren = children.flatMap((child) => splitNode(document, child, maxLength));
+  const backgroundAudio = (document.children ?? []).find(
+    (node) => typeof node !== "string" && node.type !== "text" && node.type === "mstts:backgroundaudio"
+  );
+  if (ssml.length <= resolvedMaxLength) {
+    return [createChunk(document, document.children ?? [], 0, 0, backgroundAudio, true)];
+  }
+  const contentChildren = (document.children ?? []).filter((node) => node !== backgroundAudio);
+  const plainDocumentLength = documentWithChildren(document, []).length;
+  const backgroundDocumentLength = backgroundAudio ? documentWithChildren(document, [backgroundAudio]).length : plainDocumentLength;
+  const backgroundOverhead = Math.max(0, backgroundDocumentLength - plainDocumentLength);
+  const contentMaxLength = Math.max(1, resolvedMaxLength - backgroundOverhead);
+  const splitChildren = contentChildren.flatMap((child) => splitNode(document, child, contentMaxLength));
   const chunks = [];
   let group = [];
   for (const child of splitChildren) {
     const candidate = [...group, child];
-    if (documentWithChildren(document, candidate).length <= maxLength) {
+    if (documentWithChildren(document, candidate).length <= contentMaxLength) {
       group = candidate;
       continue;
     }
     if (group.length > 0) chunks.push(group);
     group = [child];
-    if (documentWithChildren(document, group).length > maxLength) {
+    if (documentWithChildren(document, group).length > contentMaxLength) {
       throw new RangeError("maxLength is too small to contain the SSML document wrapper");
     }
   }
   if (group.length > 0) chunks.push(group);
-  return chunks.map((chunk) => documentWithChildren(document, chunk));
+  if (chunks.length === 0) {
+    const result = createChunk(document, [], 0, 0, backgroundAudio, resolvedOptions.replicateBackgroundAudio ?? false);
+    if (result.ssml.length > resolvedMaxLength) {
+      throw new RangeError("maxLength is too small to contain the SSML document wrapper");
+    }
+    return [result];
+  }
+  let textStart = 0;
+  return chunks.map((chunk, chunkIndex) => {
+    const result = createChunk(
+      document,
+      chunk,
+      chunkIndex,
+      textStart,
+      backgroundAudio,
+      resolvedOptions.replicateBackgroundAudio ?? false
+    );
+    textStart = result.originalTextRange.end;
+    return result;
+  });
 }
 
 // packages/ssml-core/src/validation.ts
@@ -2175,7 +2257,7 @@ function validateElement(token, source, diagnostics, voiceName, options, voiceCa
       addDiagnostic(diagnostics, source, token.start, "<mstts:backgroundaudio> must be self-closing.");
   }
 }
-function validateAzureSsml(ssml, options = {}) {
+function validateAzureSsmlStatic(ssml, options = {}) {
   const diagnostics = [];
   if (typeof ssml !== "string") {
     return [
@@ -2299,6 +2381,51 @@ function validateAzureSsml(ssml, options = {}) {
   }
   return diagnostics;
 }
+function urlAttributes(token) {
+  const tag = canonicalTagName(token.name);
+  const attributes = tag === "audio" || tag === "mstts:backgroundaudio" ? ["src"] : tag === "lexicon" ? ["uri"] : tag === "mstts:voiceconversion" ? ["url"] : [];
+  return attributes.flatMap((attribute) => {
+    const value = attr(token, attribute);
+    return value === void 0 ? [] : [{ attribute, value }];
+  });
+}
+function validateAzureSsml(ssml, options = {}) {
+  const diagnostics = validateAzureSsmlStatic(ssml, options);
+  const validator = options.urlValidator ?? options.customUrlValidator;
+  if (!validator || typeof ssml !== "string") return diagnostics;
+  let tokens;
+  try {
+    tokens = tokenizeElements(ssml);
+  } catch {
+    return diagnostics;
+  }
+  const checks = tokens.flatMap(
+    (token) => urlAttributes(token).map(async ({ attribute, value }) => {
+      try {
+        const result = await validator(value, { tag: token.name, attribute });
+        const valid = typeof result === "boolean" ? result : result.valid;
+        if (!valid) {
+          const reason = typeof result === "boolean" ? void 0 : result.reason;
+          addDiagnostic(
+            diagnostics,
+            ssml,
+            token.start,
+            `<${token.name} ${attribute}> was rejected by the custom URL validator${reason ? `: ${reason}` : "."}`
+          );
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        addDiagnostic(
+          diagnostics,
+          ssml,
+          token.start,
+          `<${token.name} ${attribute}> could not be validated by the custom URL validator: ${reason}`
+        );
+      }
+    })
+  );
+  return Promise.all(checks).then(() => diagnostics);
+}
 
 // packages/ssml-core/src/generated/azureVoiceCatalog.ts
 var AZURE_VOICE_CATALOG_METADATA = {
@@ -2485,12 +2612,23 @@ async function synthesizeSsml(ssml, config) {
         ...(bookmarks ?? []).map((bookmark) => bookmark.audioOffsetMs)
       );
       const durationMs = result.audioDuration ? ticksToMilliseconds(result.audioDuration) : eventDurationMs;
+      const requestId = result.resultId;
+      const addSourceMetadata = (event) => ({
+        ...event,
+        ...config.sourceTextRange ? { textRange: { ...config.sourceTextRange } } : {},
+        ...requestId ? { requestId } : {}
+      });
+      const sourceBoundaries = boundaries.map((boundary) => addSourceMetadata(boundary));
+      const sourceVisemes = visemes.map((viseme) => addSourceMetadata(viseme));
+      const sourceBookmarks = bookmarks.map((bookmark) => addSourceMetadata(bookmark));
       resolve({
         audioData: result.audioData,
         durationMs,
-        ...boundaries.length > 0 ? { boundaries, wordBoundary: boundaries, wordBoundaries: boundaries } : {},
-        ...visemes.length > 0 ? { visemes } : {},
-        ...bookmarks.length > 0 ? { bookmarks } : {}
+        ...config.sourceTextRange ? { textRange: { ...config.sourceTextRange } } : {},
+        ...requestId ? { requestId } : {},
+        ...sourceBoundaries.length > 0 ? { boundaries: sourceBoundaries, wordBoundary: sourceBoundaries, wordBoundaries: sourceBoundaries } : {},
+        ...sourceVisemes.length > 0 ? { visemes: sourceVisemes } : {},
+        ...sourceBookmarks.length > 0 ? { bookmarks: sourceBookmarks } : {}
       });
     };
     try {
@@ -2510,30 +2648,1591 @@ async function synthesizeSsml(ssml, config) {
     }
   });
 }
+async function synthesizeSsmlChunks(chunks, config) {
+  const results = [];
+  const totalChunks = chunks.length;
+  for (const [index, chunk] of chunks.entries()) {
+    const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
+    const result = await synthesizeSsml(input.ssml, {
+      ...config,
+      ...input.originalTextRange ? { sourceTextRange: input.originalTextRange } : {},
+      onProgress: void 0
+    });
+    results.push(result);
+    config.onProgress?.({
+      currentChunk: index + 1,
+      totalChunks,
+      percent: totalChunks === 0 ? 100 : Math.round((index + 1) / totalChunks * 100)
+    });
+  }
+  return mergeSynthesisResults(results);
+}
+function mergeSynthesisResults(results) {
+  const audioLength = results.reduce((total, result) => total + result.audioData.byteLength, 0);
+  const audioData = new Uint8Array(audioLength);
+  const boundaries = [];
+  const visemes = [];
+  const bookmarks = [];
+  let byteOffset = 0;
+  let durationOffset = 0;
+  for (const result of results) {
+    audioData.set(new Uint8Array(result.audioData), byteOffset);
+    byteOffset += result.audioData.byteLength;
+    const chunkBoundaries = result.boundaries && result.boundaries.length > 0 ? result.boundaries : result.wordBoundary ?? result.wordBoundaries ?? [];
+    for (const boundary of chunkBoundaries) {
+      const textRange = boundary.textRange ?? result.textRange;
+      const requestId = boundary.requestId ?? result.requestId;
+      boundaries.push({
+        ...boundary,
+        audioOffsetMs: boundary.audioOffsetMs + durationOffset,
+        ...textRange ? { textRange: { ...textRange } } : {},
+        ...requestId ? { requestId } : {}
+      });
+    }
+    for (const viseme of result.visemes ?? []) {
+      const textRange = viseme.textRange ?? result.textRange;
+      const requestId = viseme.requestId ?? result.requestId;
+      visemes.push({
+        ...viseme,
+        audioOffsetMs: viseme.audioOffsetMs + durationOffset,
+        ...textRange ? { textRange: { ...textRange } } : {},
+        ...requestId ? { requestId } : {}
+      });
+    }
+    for (const bookmark of result.bookmarks ?? []) {
+      const textRange = bookmark.textRange ?? result.textRange;
+      const requestId = bookmark.requestId ?? result.requestId;
+      bookmarks.push({
+        ...bookmark,
+        audioOffsetMs: bookmark.audioOffsetMs + durationOffset,
+        ...textRange ? { textRange: { ...textRange } } : {},
+        ...requestId ? { requestId } : {}
+      });
+    }
+    durationOffset += Math.max(0, result.durationMs);
+  }
+  return {
+    audioData: audioData.buffer,
+    durationMs: durationOffset,
+    ...boundaries.length > 0 ? { boundaries, wordBoundary: boundaries, wordBoundaries: boundaries } : {},
+    ...visemes.length > 0 ? { visemes } : {},
+    ...bookmarks.length > 0 ? { bookmarks } : {},
+    ...results.length === 1 && results[0]?.requestId ? { requestId: results[0].requestId } : {},
+    ...results.length === 1 && results[0]?.textRange ? { textRange: { ...results[0].textRange } } : {}
+  };
+}
 async function synthesizeSpeech(ssml, config) {
   return (await synthesizeSsml(ssml, config)).audioData;
 }
 
-// packages/azure-tts-client/src/client.ts
-var ENDPOINT_TEMPLATE = "https://{region}.tts.speech.microsoft.com/cognitiveservices/v1";
-var _options;
-var AzureTtsClient = class {
-  constructor(options) {
-    __privateAdd(this, _options);
-    __privateSet(this, _options, options);
+// packages/ssml-core/dist/index.mjs
+var __typeError2 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck2 = (obj, member, msg) => member.has(obj) || __typeError2("Cannot " + msg);
+var __privateGet2 = (obj, member, getter) => (__accessCheck2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd2 = (obj, member, value) => member.has(obj) ? __typeError2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet2 = (obj, member, value, setter) => (__accessCheck2(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var SYNTHESIS_NAMESPACE2 = "http://www.w3.org/2001/10/synthesis";
+var MSTTS_NAMESPACE2 = "http://www.w3.org/2001/mstts";
+var MAX_NESTING_DEPTH2 = 1e3;
+var SSML_TAGS2 = {
+  SPEAK: "speak",
+  VOICE: "voice",
+  PROSODY: "prosody",
+  BREAK: "break",
+  EXPRESS_AS: "express-as",
+  EXPRESS_AS_CAMEL: "expressAs",
+  MSTTS_EXPRESS_AS: "mstts:express-as",
+  SAY_AS: "say-as",
+  SAY_AS_CAMEL: "sayAs",
+  PHONEME: "phoneme",
+  EMPHASIS: "emphasis",
+  AUDIO: "audio",
+  SUB: "sub",
+  LANG: "lang",
+  MARK: "mark",
+  BOOKMARK: "bookmark",
+  LEXICON: "lexicon",
+  PARAGRAPH: "p",
+  SENTENCE: "s",
+  WORD: "w",
+  MSTTS_SILENCE: "mstts:silence",
+  SILENCE: "silence",
+  MSTTS_VISEME: "mstts:viseme",
+  VISEME: "viseme",
+  MSTTS_AUDIO_DURATION: "mstts:audioduration",
+  MSTTS_DIALOG: "mstts:dialog",
+  MSTTS_TURN: "mstts:turn",
+  MSTTS_BACKGROUND_AUDIO: "mstts:backgroundaudio",
+  MSTTS_TTS_EMBEDDING: "mstts:ttsembedding",
+  MSTTS_EMBEDDING: "mstts:embedding",
+  MSTTS_VOICE_CONVERSION: "mstts:voiceconversion"
+};
+var SSML_ATTRS2 = {
+  VERSION: "version",
+  XMLNS: "xmlns",
+  XML_LANG: "xml:lang",
+  LANG: "lang",
+  MSTTS_XMLNS: "xmlns:mstts",
+  NAME: "name",
+  VOICE: "voice",
+  SPEAKER: "speaker",
+  EFFECT: "effect",
+  RATE: "rate",
+  PITCH: "pitch",
+  VOLUME: "volume",
+  CONTOUR: "contour",
+  RANGE: "range",
+  TIME: "time",
+  STRENGTH: "strength",
+  STYLE: "style",
+  STYLE_DEGREE: "styledegree",
+  STYLE_DEGREE_CAMEL: "styleDegree",
+  STYLE_DEGREE_HYPHEN: "style-degree",
+  ROLE: "role",
+  INTERPRET_AS: "interpret-as",
+  FORMAT: "format",
+  DETAIL: "detail",
+  ALPHABET: "alphabet",
+  PH: "ph",
+  LEVEL: "level",
+  SRC: "src",
+  DESC: "desc",
+  CLIP_BEGIN: "clipBegin",
+  CLIP_END: "clipEnd",
+  SPEED: "speed",
+  REPEAT_COUNT: "repeatCount",
+  REPEAT_DURATION: "repeatDuration",
+  SOUND_LEVEL: "soundLevel",
+  ALIAS: "alias",
+  MARK: "mark",
+  URI: "uri",
+  ID: "id",
+  MODEL: "model",
+  PROFILE: "profile",
+  URL: "url",
+  SPEAKER_PROFILE_ID: "speakerProfileId",
+  TYPE: "type",
+  VALUE: "value",
+  FADE_IN: "fadein",
+  FADE_OUT: "fadeout"
+};
+var XML_ENTITIES2 = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  quot: '"'
+};
+function hasOwn2(object, property) {
+  return Object.getOwnPropertyDescriptor(object, property) !== void 0;
+}
+function setAttribute2(attributes, name, value) {
+  Object.defineProperty(attributes, name, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+function decodeEntity2(entity) {
+  const namedValue = hasOwn2(XML_ENTITIES2, entity) ? XML_ENTITIES2[entity] : void 0;
+  if (namedValue !== void 0) {
+    return namedValue;
   }
-  async synthesize(ssml) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
-    const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
-    __privateGet(this, _options).logger?.debug?.("Using Azure TTS endpoint:", endpoint);
-    const config = { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs };
-    return synthesizeSpeech(ssml, config);
+  const isHexadecimal = entity.startsWith("#x") || entity.startsWith("#X");
+  const isDecimal = entity.startsWith("#");
+  if (!isHexadecimal && !isDecimal) {
+    throw new Error(`Unknown XML entity: &${entity};`);
   }
-  async synthesizeSsml(ssml) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
-    const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
-    __privateGet(this, _options).logger?.debug?.("Using Azure TTS endpoint:", endpoint);
-    return synthesizeSsml(ssml, { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs });
+  const digits = entity.slice(isHexadecimal ? 2 : 1);
+  const codePoint = Number.parseInt(digits, isHexadecimal ? 16 : 10);
+  if (!digits || !Number.isInteger(codePoint) || codePoint < 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 || codePoint < 32 && ![9, 10, 13].includes(codePoint)) {
+    throw new Error(`Invalid XML character reference: &${entity};`);
+  }
+  return String.fromCodePoint(codePoint);
+}
+function decodeXmlEntities2(value) {
+  let result = "";
+  let start = 0;
+  while (true) {
+    const ampersand = value.indexOf("&", start);
+    if (ampersand === -1) {
+      return result + value.slice(start);
+    }
+    result += value.slice(start, ampersand);
+    const semicolon = value.indexOf(";", ampersand + 1);
+    if (semicolon === -1) {
+      throw new Error("Unterminated XML entity reference");
+    }
+    result += decodeEntity2(value.slice(ampersand + 1, semicolon));
+    start = semicolon + 1;
+  }
+}
+function isXmlNameStart2(value) {
+  return value !== void 0 && /[A-Za-z_]/.test(value);
+}
+function isXmlNameCharacter2(value) {
+  return value !== void 0 && /[A-Za-z0-9_.:-]/.test(value);
+}
+function isXmlWhitespace2(value) {
+  return value === " " || value === "	" || value === "\r" || value === "\n";
+}
+function removeStandardNamespaceAttributes2(attributes) {
+  if (attributes[SSML_ATTRS2.XMLNS] === SYNTHESIS_NAMESPACE2) {
+    delete attributes[SSML_ATTRS2.XMLNS];
+  }
+  if (attributes[SSML_ATTRS2.MSTTS_XMLNS] === MSTTS_NAMESPACE2) {
+    delete attributes[SSML_ATTRS2.MSTTS_XMLNS];
+  }
+}
+var _index2;
+var XmlParser2 = class {
+  constructor(source) {
+    __privateAdd2(this, _index2, 0);
+    this.source = source;
+  }
+  parse() {
+    if (this.source.charCodeAt(0) === 65279) {
+      __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+    }
+    this.skipMisc();
+    if (__privateGet2(this, _index2) >= this.source.length) {
+      this.fail("SSML input is empty");
+    }
+    if (this.source[__privateGet2(this, _index2)] !== "<") {
+      this.fail("SSML input must start with an XML element");
+    }
+    const root = this.parseElement(0);
+    this.skipMisc();
+    if (__privateGet2(this, _index2) !== this.source.length) {
+      this.fail("Unexpected content after the root XML element");
+    }
+    return root;
+  }
+  parseElement(depth) {
+    if (depth > MAX_NESTING_DEPTH2) {
+      this.fail("XML nesting depth exceeds the supported limit");
+    }
+    this.expect("<");
+    if (this.source[__privateGet2(this, _index2)] === "/") {
+      this.fail("Unexpected closing XML element");
+    }
+    const name = this.parseName();
+    const { attributes, selfClosing } = this.parseStartTag();
+    if (selfClosing) {
+      return { name, attributes, children: [] };
+    }
+    const children = [];
+    while (__privateGet2(this, _index2) < this.source.length) {
+      if (this.source.startsWith("</", __privateGet2(this, _index2))) {
+        __privateSet2(this, _index2, __privateGet2(this, _index2) + 2);
+        const closingName = this.parseName();
+        this.skipWhitespace();
+        this.expect(">");
+        if (closingName !== name) {
+          this.fail(`Mismatched closing element: expected </${name}> but found </${closingName}>`);
+        }
+        return { name, attributes, children };
+      }
+      if (this.source.startsWith("<!--", __privateGet2(this, _index2))) {
+        this.skipComment();
+        continue;
+      }
+      if (this.source.startsWith("<![CDATA[", __privateGet2(this, _index2))) {
+        this.appendText(children, this.parseCdata());
+        continue;
+      }
+      if (this.source.startsWith("<?", __privateGet2(this, _index2))) {
+        this.skipProcessingInstruction();
+        continue;
+      }
+      if (this.source.startsWith("<!", __privateGet2(this, _index2))) {
+        this.fail("Unsupported XML declaration inside an element");
+      }
+      if (this.source[__privateGet2(this, _index2)] === "<") {
+        children.push(this.parseElement(depth + 1));
+      } else {
+        this.appendText(children, this.parseText());
+      }
+    }
+    this.fail(`Unclosed XML element: <${name}>`);
+  }
+  parseStartTag() {
+    const attributes = {};
+    while (__privateGet2(this, _index2) < this.source.length) {
+      this.skipWhitespace();
+      if (this.source.startsWith("/>", __privateGet2(this, _index2))) {
+        __privateSet2(this, _index2, __privateGet2(this, _index2) + 2);
+        return { attributes, selfClosing: true };
+      }
+      if (this.source[__privateGet2(this, _index2)] === ">") {
+        __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+        return { attributes, selfClosing: false };
+      }
+      const name = this.parseName();
+      this.skipWhitespace();
+      this.expect("=");
+      this.skipWhitespace();
+      const quote = this.source[__privateGet2(this, _index2)];
+      if (quote !== '"' && quote !== "'") {
+        this.fail(`XML attribute ${name} must use a quoted value`);
+      }
+      __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+      const valueStart = __privateGet2(this, _index2);
+      while (__privateGet2(this, _index2) < this.source.length && this.source[__privateGet2(this, _index2)] !== quote) {
+        if (this.source[__privateGet2(this, _index2)] === "<") {
+          this.fail(`Invalid "<" in XML attribute ${name}`);
+        }
+        __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+      }
+      if (__privateGet2(this, _index2) >= this.source.length) {
+        this.fail(`Unclosed XML attribute ${name}`);
+      }
+      const value = decodeXmlEntities2(this.source.slice(valueStart, __privateGet2(this, _index2)));
+      __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+      if (hasOwn2(attributes, name)) {
+        this.fail(`Duplicate XML attribute: ${name}`);
+      }
+      setAttribute2(attributes, name, value);
+    }
+    this.fail("Unclosed XML start tag");
+  }
+  parseText() {
+    const start = __privateGet2(this, _index2);
+    while (__privateGet2(this, _index2) < this.source.length && this.source[__privateGet2(this, _index2)] !== "<") {
+      __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+    }
+    const value = this.source.slice(start, __privateGet2(this, _index2));
+    if (value.includes("]]>")) {
+      this.fail("CDATA termination is not valid in ordinary XML text");
+    }
+    return decodeXmlEntities2(value);
+  }
+  parseCdata() {
+    __privateSet2(this, _index2, __privateGet2(this, _index2) + "<![CDATA[".length);
+    const end = this.source.indexOf("]]>", __privateGet2(this, _index2));
+    if (end === -1) {
+      this.fail("Unclosed XML CDATA section");
+    }
+    const value = this.source.slice(__privateGet2(this, _index2), end);
+    __privateSet2(this, _index2, end + 3);
+    return value;
+  }
+  skipComment() {
+    __privateSet2(this, _index2, __privateGet2(this, _index2) + "<!--".length);
+    const end = this.source.indexOf("-->", __privateGet2(this, _index2));
+    if (end === -1) {
+      this.fail("Unclosed XML comment");
+    }
+    if (this.source.slice(__privateGet2(this, _index2), end).includes("--")) {
+      this.fail("XML comments cannot contain consecutive hyphens");
+    }
+    __privateSet2(this, _index2, end + 3);
+  }
+  skipProcessingInstruction() {
+    __privateSet2(this, _index2, __privateGet2(this, _index2) + "<?".length);
+    this.parseName();
+    const end = this.source.indexOf("?>", __privateGet2(this, _index2));
+    if (end === -1) {
+      this.fail("Unclosed XML processing instruction");
+    }
+    __privateSet2(this, _index2, end + 2);
+  }
+  skipMisc() {
+    while (__privateGet2(this, _index2) < this.source.length) {
+      this.skipWhitespace();
+      if (this.source.startsWith("<!--", __privateGet2(this, _index2))) {
+        this.skipComment();
+        continue;
+      }
+      if (this.source.startsWith("<?", __privateGet2(this, _index2))) {
+        this.skipProcessingInstruction();
+        continue;
+      }
+      if (this.source.startsWith("<!DOCTYPE", __privateGet2(this, _index2))) {
+        this.fail("DOCTYPE declarations are not supported");
+      }
+      break;
+    }
+  }
+  parseName() {
+    const first = this.source[__privateGet2(this, _index2)];
+    if (!isXmlNameStart2(first)) {
+      this.fail("Invalid XML name");
+    }
+    const start = __privateGet2(this, _index2);
+    __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+    while (isXmlNameCharacter2(this.source[__privateGet2(this, _index2)])) {
+      __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+    }
+    return this.source.slice(start, __privateGet2(this, _index2));
+  }
+  appendText(children, value) {
+    if (!value) {
+      return;
+    }
+    const previous = children[children.length - 1];
+    if (typeof previous === "string") {
+      children[children.length - 1] = previous + value;
+    } else {
+      children.push(value);
+    }
+  }
+  skipWhitespace() {
+    while (isXmlWhitespace2(this.source[__privateGet2(this, _index2)])) {
+      __privateSet2(this, _index2, __privateGet2(this, _index2) + 1);
+    }
+  }
+  expect(value) {
+    if (!this.source.startsWith(value, __privateGet2(this, _index2))) {
+      this.fail(`Expected "${value}"`);
+    }
+    __privateSet2(this, _index2, __privateGet2(this, _index2) + value.length);
+  }
+  fail(message) {
+    throw new Error(`${message} at position ${__privateGet2(this, _index2)}`);
+  }
+};
+_index2 = /* @__PURE__ */ new WeakMap();
+function readAttribute2(attributes, ...names) {
+  let found = false;
+  let value;
+  for (const name of names) {
+    if (hasOwn2(attributes, name)) {
+      if (!found) {
+        value = String(attributes[name]);
+        found = true;
+      }
+      delete attributes[name];
+    }
+  }
+  return value;
+}
+function getElementAttributes2(node) {
+  const attributes = { ...node.attributes };
+  removeStandardNamespaceAttributes2(attributes);
+  return attributes;
+}
+function finishElement2(element, node, attributes) {
+  if (node.children.length > 0) {
+    element.children = node.children.map(convertNode2);
+  }
+  if (Object.keys(attributes).length > 0) {
+    element.attributes = attributes;
+  }
+  return element;
+}
+function convertElement2(node) {
+  const attributes = getElementAttributes2(node);
+  switch (node.name) {
+    case SSML_TAGS2.VOICE: {
+      const element = { type: SSML_TAGS2.VOICE };
+      const name = readAttribute2(attributes, SSML_ATTRS2.NAME);
+      const effect = readAttribute2(attributes, SSML_ATTRS2.EFFECT);
+      if (name !== void 0) element.name = name;
+      if (effect !== void 0) element.effect = effect;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.PROSODY: {
+      const element = { type: SSML_TAGS2.PROSODY };
+      const rate = readAttribute2(attributes, SSML_ATTRS2.RATE);
+      const pitch = readAttribute2(attributes, SSML_ATTRS2.PITCH);
+      const volume = readAttribute2(attributes, SSML_ATTRS2.VOLUME);
+      const contour = readAttribute2(attributes, SSML_ATTRS2.CONTOUR);
+      const range = readAttribute2(attributes, SSML_ATTRS2.RANGE);
+      if (rate !== void 0) element.rate = rate;
+      if (pitch !== void 0) element.pitch = pitch;
+      if (volume !== void 0) element.volume = volume;
+      if (contour !== void 0) element.contour = contour;
+      if (range !== void 0) element.range = range;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.BREAK: {
+      const element = { type: SSML_TAGS2.BREAK };
+      const time = readAttribute2(attributes, SSML_ATTRS2.TIME);
+      const strength = readAttribute2(attributes, SSML_ATTRS2.STRENGTH);
+      if (time !== void 0) element.time = time;
+      if (strength !== void 0) element.strength = strength;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.EXPRESS_AS:
+    case SSML_TAGS2.EXPRESS_AS_CAMEL:
+    case SSML_TAGS2.MSTTS_EXPRESS_AS: {
+      const element = { type: node.name };
+      const style = readAttribute2(attributes, SSML_ATTRS2.STYLE);
+      const styleDegree = readAttribute2(
+        attributes,
+        SSML_ATTRS2.STYLE_DEGREE,
+        SSML_ATTRS2.STYLE_DEGREE_CAMEL,
+        SSML_ATTRS2.STYLE_DEGREE_HYPHEN
+      );
+      const role = readAttribute2(attributes, SSML_ATTRS2.ROLE);
+      if (style !== void 0) element.style = style;
+      if (styleDegree !== void 0) element.styleDegree = styleDegree;
+      if (role !== void 0) element.role = role;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.SAY_AS:
+    case SSML_TAGS2.SAY_AS_CAMEL: {
+      const element = { type: node.name };
+      const interpretAs = readAttribute2(attributes, SSML_ATTRS2.INTERPRET_AS);
+      const format = readAttribute2(attributes, SSML_ATTRS2.FORMAT);
+      const detail = readAttribute2(attributes, SSML_ATTRS2.DETAIL);
+      if (interpretAs !== void 0) element.interpretAs = interpretAs;
+      if (format !== void 0) element.format = format;
+      if (detail !== void 0) element.detail = detail;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.PHONEME: {
+      const element = { type: SSML_TAGS2.PHONEME };
+      const alphabet = readAttribute2(attributes, SSML_ATTRS2.ALPHABET);
+      const ph = readAttribute2(attributes, SSML_ATTRS2.PH);
+      if (alphabet !== void 0) element.alphabet = alphabet;
+      if (ph !== void 0) element.ph = ph;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.EMPHASIS: {
+      const element = { type: SSML_TAGS2.EMPHASIS };
+      const level = readAttribute2(attributes, SSML_ATTRS2.LEVEL);
+      if (level !== void 0) element.level = level;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.AUDIO: {
+      const element = { type: SSML_TAGS2.AUDIO };
+      const src = readAttribute2(attributes, SSML_ATTRS2.SRC);
+      const desc = readAttribute2(attributes, SSML_ATTRS2.DESC);
+      const clipBegin = readAttribute2(attributes, SSML_ATTRS2.CLIP_BEGIN);
+      const clipEnd = readAttribute2(attributes, SSML_ATTRS2.CLIP_END);
+      const speed = readAttribute2(attributes, SSML_ATTRS2.SPEED);
+      const repeatCount = readAttribute2(attributes, SSML_ATTRS2.REPEAT_COUNT);
+      const repeatDuration = readAttribute2(attributes, SSML_ATTRS2.REPEAT_DURATION);
+      const soundLevel = readAttribute2(attributes, SSML_ATTRS2.SOUND_LEVEL);
+      if (src !== void 0) element.src = src;
+      if (desc !== void 0) element.desc = desc;
+      if (clipBegin !== void 0) element.clipBegin = clipBegin;
+      if (clipEnd !== void 0) element.clipEnd = clipEnd;
+      if (speed !== void 0) element.speed = speed;
+      if (repeatCount !== void 0) element.repeatCount = repeatCount;
+      if (repeatDuration !== void 0) element.repeatDuration = repeatDuration;
+      if (soundLevel !== void 0) element.soundLevel = soundLevel;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.SUB: {
+      const element = { type: SSML_TAGS2.SUB };
+      const alias = readAttribute2(attributes, SSML_ATTRS2.ALIAS);
+      if (alias !== void 0) element.alias = alias;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.LANG: {
+      const element = { type: SSML_TAGS2.LANG };
+      const lang = readAttribute2(attributes, SSML_ATTRS2.XML_LANG, SSML_ATTRS2.LANG);
+      if (lang !== void 0) element.lang = lang;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MARK: {
+      const element = { type: SSML_TAGS2.MARK };
+      const name = readAttribute2(attributes, SSML_ATTRS2.NAME);
+      if (name !== void 0) element.name = name;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.BOOKMARK: {
+      const element = { type: SSML_TAGS2.BOOKMARK };
+      const mark = readAttribute2(attributes, SSML_ATTRS2.MARK);
+      if (mark !== void 0) element.mark = mark;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.LEXICON: {
+      const element = { type: SSML_TAGS2.LEXICON };
+      const uri = readAttribute2(attributes, SSML_ATTRS2.URI);
+      if (uri !== void 0) element.uri = uri;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.PARAGRAPH: {
+      const element = { type: SSML_TAGS2.PARAGRAPH };
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.SENTENCE: {
+      const element = { type: SSML_TAGS2.SENTENCE };
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.WORD: {
+      const element = { type: SSML_TAGS2.WORD };
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_SILENCE:
+    case SSML_TAGS2.SILENCE: {
+      const element = {
+        type: node.name === SSML_TAGS2.MSTTS_SILENCE ? SSML_TAGS2.MSTTS_SILENCE : SSML_TAGS2.SILENCE
+      };
+      const typeValue = readAttribute2(attributes, SSML_ATTRS2.TYPE);
+      const value = readAttribute2(attributes, SSML_ATTRS2.VALUE);
+      if (typeValue !== void 0) element.typeValue = typeValue;
+      if (value !== void 0) element.value = value;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_VISEME:
+    case SSML_TAGS2.VISEME: {
+      const element = {
+        type: node.name === SSML_TAGS2.MSTTS_VISEME ? SSML_TAGS2.MSTTS_VISEME : SSML_TAGS2.VISEME
+      };
+      const typeValue = readAttribute2(attributes, SSML_ATTRS2.TYPE);
+      if (typeValue !== void 0) element.typeValue = typeValue;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_AUDIO_DURATION: {
+      const element = { type: SSML_TAGS2.MSTTS_AUDIO_DURATION };
+      const value = readAttribute2(attributes, SSML_ATTRS2.VALUE);
+      if (value !== void 0) element.value = value;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_DIALOG: {
+      const element = { type: SSML_TAGS2.MSTTS_DIALOG };
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_TURN: {
+      const element = { type: SSML_TAGS2.MSTTS_TURN };
+      const voice = readAttribute2(attributes, SSML_ATTRS2.VOICE);
+      const speaker = readAttribute2(attributes, SSML_ATTRS2.SPEAKER);
+      if (voice !== void 0) element.voice = voice;
+      if (speaker !== void 0) element.speaker = speaker;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_BACKGROUND_AUDIO: {
+      const element = { type: SSML_TAGS2.MSTTS_BACKGROUND_AUDIO };
+      const src = readAttribute2(attributes, SSML_ATTRS2.SRC);
+      const volume = readAttribute2(attributes, SSML_ATTRS2.VOLUME);
+      const fadeIn = readAttribute2(attributes, SSML_ATTRS2.FADE_IN);
+      const fadeOut = readAttribute2(attributes, SSML_ATTRS2.FADE_OUT);
+      if (src !== void 0) element.src = src;
+      if (volume !== void 0) element.volume = volume;
+      if (fadeIn !== void 0) element.fadeIn = fadeIn;
+      if (fadeOut !== void 0) element.fadeOut = fadeOut;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_TTS_EMBEDDING: {
+      const element = { type: SSML_TAGS2.MSTTS_TTS_EMBEDDING };
+      const speakerProfileId = readAttribute2(attributes, SSML_ATTRS2.SPEAKER_PROFILE_ID);
+      if (speakerProfileId !== void 0) element.speakerProfileId = speakerProfileId;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_EMBEDDING: {
+      const element = { type: SSML_TAGS2.MSTTS_EMBEDDING };
+      const id = readAttribute2(attributes, SSML_ATTRS2.ID);
+      const speakerProfileId = readAttribute2(attributes, SSML_ATTRS2.SPEAKER_PROFILE_ID);
+      if (id !== void 0) element.id = id;
+      if (speakerProfileId !== void 0) element.speakerProfileId = speakerProfileId;
+      return finishElement2(element, node, attributes);
+    }
+    case SSML_TAGS2.MSTTS_VOICE_CONVERSION: {
+      const element = { type: SSML_TAGS2.MSTTS_VOICE_CONVERSION };
+      const url = readAttribute2(attributes, SSML_ATTRS2.URL);
+      const profile = readAttribute2(attributes, SSML_ATTRS2.PROFILE);
+      const speakerProfileId = readAttribute2(attributes, SSML_ATTRS2.SPEAKER_PROFILE_ID);
+      if (url !== void 0) element.url = url;
+      if (profile !== void 0) element.profile = profile;
+      if (speakerProfileId !== void 0) element.speakerProfileId = speakerProfileId;
+      return finishElement2(element, node, attributes);
+    }
+    default: {
+      const element = {
+        name: node.name,
+        type: "custom"
+      };
+      return finishElement2(element, node, attributes);
+    }
+  }
+}
+function convertNode2(node) {
+  return typeof node === "string" ? node : convertElement2(node);
+}
+function parseSsml2(xmlString) {
+  if (typeof xmlString !== "string") {
+    throw new TypeError("SSML input must be a string");
+  }
+  const root = new XmlParser2(xmlString).parse();
+  if (root.name !== SSML_TAGS2.SPEAK) {
+    throw new Error(`SSML root element must be <${SSML_TAGS2.SPEAK}>, found <${root.name}>`);
+  }
+  const attributes = { ...root.attributes };
+  const version = readAttribute2(attributes, SSML_ATTRS2.VERSION);
+  const lang = readAttribute2(attributes, SSML_ATTRS2.XML_LANG, SSML_ATTRS2.LANG);
+  if (version === void 0) {
+    throw new Error(`SSML <${SSML_TAGS2.SPEAK}> element is missing the "${SSML_ATTRS2.VERSION}" attribute`);
+  }
+  if (lang === void 0) {
+    throw new Error(`SSML <${SSML_TAGS2.SPEAK}> element is missing the "${SSML_ATTRS2.XML_LANG}" attribute`);
+  }
+  removeStandardNamespaceAttributes2(attributes);
+  const document = {
+    children: root.children.map(convertNode2),
+    lang,
+    type: SSML_TAGS2.SPEAK,
+    version
+  };
+  if (Object.keys(attributes).length > 0) {
+    document.attributes = attributes;
+  }
+  return document;
+}
+var AZURE_VOICE_DEFINITIONS2 = [
+  { name: "de-DE-ConradNeural", locale: "de-DE", styles: ["cheerful", "sad"] },
+  { name: "de-DE-KatjaNeural", locale: "de-DE", styles: ["cheerful", "sad"] },
+  { name: "en-US-AndrewNeural", locale: "en-US", styles: ["empathetic", "relieved"] },
+  {
+    name: "en-US-GuyNeural",
+    locale: "en-US",
+    styles: [
+      "angry",
+      "cheerful",
+      "excited",
+      "friendly",
+      "hopeful",
+      "newscast",
+      "sad",
+      "shouting",
+      "terrified",
+      "unfriendly",
+      "whispering"
+    ]
+  },
+  {
+    name: "en-US-JennyMultilingualNeural",
+    locale: "en-US",
+    styles: [
+      "cheerful",
+      "empathetic",
+      "excited",
+      "friendly",
+      "hopeful",
+      "sad",
+      "shouting",
+      "terrified",
+      "unfriendly",
+      "whispering"
+    ]
+  },
+  {
+    name: "en-US-JennyNeural",
+    locale: "en-US",
+    styles: [
+      "assistant",
+      "chat",
+      "customerservice",
+      "newscast",
+      "cheerful",
+      "empathetic",
+      "excited",
+      "friendly",
+      "hopeful",
+      "sad",
+      "shouting",
+      "terrified",
+      "unfriendly",
+      "whispering"
+    ]
+  },
+  { name: "es-ES-ElviraNeural", locale: "es-ES" },
+  { name: "fil-PH-AngeloNeural", locale: "fil-PH" },
+  { name: "fil-PH-Angelo:DragonHDLatestNeural", locale: "fil-PH" },
+  { name: "fil-PH-BlessicaNeural", locale: "fil-PH" },
+  { name: "fil-PH-Blessica:DragonHDLatestNeural", locale: "fil-PH" },
+  { name: "fr-FR-DeniseNeural", locale: "fr-FR", styles: ["cheerful", "sad"] },
+  { name: "fr-FR-HenriNeural", locale: "fr-FR", styles: ["cheerful", "sad"] },
+  { name: "id-ID-GadisNeural", locale: "id-ID" },
+  { name: "it-IT-ElsaNeural", locale: "it-IT", styles: ["cheerful", "sad"] },
+  { name: "ja-JP-KeitaNeural", locale: "ja-JP", styles: ["chat"] },
+  { name: "ja-JP-MayuNeural", locale: "ja-JP", styles: ["calm", "cheerful", "sad"] },
+  { name: "ja-JP-NanamiNeural", locale: "ja-JP", styles: ["chat", "customerservice", "cheerful", "whispering", "sad"] },
+  { name: "ko-KR-SunHiNeural", locale: "ko-KR", styles: ["cheerful", "sad"] },
+  { name: "ms-MY-YasminNeural", locale: "ms-MY" },
+  { name: "pt-BR-FranciscaNeural", locale: "pt-BR", styles: ["calm"] },
+  {
+    name: "ru-RU-SvetlanaNeural",
+    locale: "ru-RU",
+    styles: ["cheerful", "sad", "angry", "disgruntled", "embarrassed", "fearful"]
+  },
+  { name: "th-TH-PremwadeeNeural", locale: "th-TH" },
+  { name: "vi-VN-HoaiMyNeural", locale: "vi-VN" },
+  {
+    name: "zh-CN-XiaoxiaoNeural",
+    locale: "zh-CN",
+    styles: [
+      "assistant",
+      "chat",
+      "customerservice",
+      "newscast",
+      "cheerful",
+      "empathetic",
+      "excited",
+      "friendly",
+      "hopeful",
+      "sad",
+      "terrified",
+      "whispering",
+      "poetry-reading",
+      "sports_commentary",
+      "sports_commentary_excited",
+      "story"
+    ]
+  },
+  {
+    name: "zh-CN-YunxiNeural",
+    locale: "zh-CN",
+    styles: [
+      "narration-relaxed",
+      "embarrassed",
+      "fearful",
+      "sad",
+      "disgruntled",
+      "serious",
+      "angry",
+      "depressed",
+      "chat",
+      "cheerful",
+      "assistant"
+    ]
+  },
+  { name: "zh-TW-HsiaoChenNeural", locale: "zh-TW" }
+];
+var ALLOWED_BREAK_STRENGTHS2 = /* @__PURE__ */ new Set(["none", "x-weak", "weak", "medium", "strong", "x-strong"]);
+var ALLOWED_SAY_AS2 = /* @__PURE__ */ new Set([
+  "characters",
+  "spell-out",
+  "cardinal",
+  "ordinal",
+  "number",
+  "date",
+  "time",
+  "telephone",
+  "fraction",
+  "address",
+  "name",
+  "currency",
+  "number_digit"
+]);
+var ALLOWED_ROLES2 = /* @__PURE__ */ new Set([
+  "Girl",
+  "Boy",
+  "YoungAdultFemale",
+  "YoungAdultMale",
+  "OlderAdultFemale",
+  "OlderAdultMale",
+  "SeniorFemale",
+  "SeniorMale"
+]);
+var ALLOWED_EMPHASIS_LEVELS2 = /* @__PURE__ */ new Set(["strong", "moderate", "reduced", "none"]);
+var ALLOWED_SILENCE_TYPES2 = /* @__PURE__ */ new Set([
+  "Leading",
+  "Tailing",
+  "Sentenceboundary",
+  "Comma",
+  "Semicolon",
+  "Enumerationcomma"
+]);
+var ALLOWED_VISEME_TYPES2 = /* @__PURE__ */ new Set(["redlips_front", "FacialExpression"]);
+var DEFAULT_PREVIEW_TAGS2 = /* @__PURE__ */ new Set(["mstts:voiceconversion"]);
+function featureStatusForTag2(name, options) {
+  const tagName = canonicalTagName2(name);
+  const configured = Object.entries(options.tagStatuses ?? {}).find(
+    ([candidate]) => canonicalTagName2(candidate) === tagName
+  )?.[1];
+  if (configured) return configured;
+  if ((options.previewTags ?? [...DEFAULT_PREVIEW_TAGS2]).some((candidate) => canonicalTagName2(candidate) === tagName))
+    return "preview";
+  if ((options.deprecatedTags ?? []).some((candidate) => canonicalTagName2(candidate) === tagName)) return "deprecated";
+  return void 0;
+}
+function decodeAttribute2(value) {
+  return value.replace(
+    /&(?:amp|apos|gt|lt|quot);/gi,
+    (entity) => ({ "&amp;": "&", "&apos;": "'", "&gt;": ">", "&lt;": "<", "&quot;": '"' })[entity.toLowerCase()] ?? entity
+  );
+}
+function findTagEnd22(source, start) {
+  let quote = "";
+  for (let index = start; index < source.length; index += 1) {
+    const character = source[index];
+    if (quote) {
+      if (character === quote) quote = "";
+    } else if (character === '"' || character === "'") quote = character;
+    else if (character === ">") return index;
+  }
+  return source.length - 1;
+}
+function tokenizeElements2(source) {
+  const tokens = [];
+  const openElements = [];
+  let index = 0;
+  while (index < source.length) {
+    const start = source.indexOf("<", index);
+    if (start === -1) break;
+    if (source.startsWith("<!--", start)) {
+      const end2 = source.indexOf("-->", start + 4);
+      index = end2 === -1 ? source.length : end2 + 3;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", start)) {
+      const end2 = source.indexOf("]]>", start + 9);
+      index = end2 === -1 ? source.length : end2 + 3;
+      continue;
+    }
+    if (source.startsWith("<?", start)) {
+      const end2 = source.indexOf("?>", start + 2);
+      index = end2 === -1 ? source.length : end2 + 2;
+      continue;
+    }
+    const end = findTagEnd22(source, start + 1);
+    const raw = source.slice(start, end + 1);
+    if (raw.startsWith("</")) {
+      openElements.pop();
+      index = end + 1;
+      continue;
+    }
+    const nameMatch = /^<\s*([A-Za-z_][A-Za-z0-9_.:-]*)/.exec(raw);
+    if (!nameMatch?.[1]) {
+      index = end + 1;
+      continue;
+    }
+    const attributes = /* @__PURE__ */ new Map();
+    const attributeSource = raw.slice(nameMatch[0].length, raw.length - 1).replace(/\/\s*$/, "");
+    const attributePattern = /([A-Za-z_][A-Za-z0-9_.:-]*)\s*=\s*(["'])([\s\S]*?)\2/g;
+    for (const match of attributeSource.matchAll(attributePattern)) {
+      attributes.set(match[1].toLowerCase(), decodeAttribute2(match[3]));
+    }
+    const selfClosing = /\/\s*>$/.test(raw);
+    const parent = openElements[openElements.length - 1];
+    const childElementIndex = parent?.childElementCount;
+    if (parent) parent.childElementCount += 1;
+    const parentVoiceName = [...openElements].reverse().find((element) => element.voiceName)?.voiceName;
+    const tokenName = nameMatch[1];
+    const tokenVoiceName = tokenName.toLowerCase() === "voice" ? attributes.get("name") : tokenName.toLowerCase() === "mstts:turn" ? attributes.get("voice") ?? parentVoiceName : parentVoiceName;
+    tokens.push({
+      attributes,
+      childElementIndex,
+      end,
+      depth: openElements.length + 1,
+      name: tokenName,
+      parentName: parent?.name,
+      parentVoiceName,
+      selfClosing,
+      start
+    });
+    if (!selfClosing) {
+      openElements.push({
+        childElementCount: 0,
+        name: tokenName,
+        voiceName: tokenVoiceName
+      });
+    }
+    index = end + 1;
+  }
+  return tokens;
+}
+function location2(source, offset) {
+  const before = source.slice(0, Math.max(0, offset));
+  const line = before.split("\n").length;
+  return { line, column: before.length - (before.lastIndexOf("\n") + 1) + 1 };
+}
+function addDiagnostic2(diagnostics, source, offset, message, severity = "error", code) {
+  diagnostics.push({
+    ...location2(source, offset),
+    message,
+    severity,
+    source: "ssml-static-validator",
+    ...code ? { code } : {}
+  });
+}
+function isSupportedProsodyRate2(value) {
+  const trimmed = value.trim();
+  if (/^(x-slow|slow|medium|fast|x-fast|[+-]?\d+(?:\.\d+)?%)$/.test(trimmed)) return true;
+  const multiplier = /^(\d+(?:\.\d+)?)(x)?$/i.exec(trimmed);
+  if (!multiplier) return false;
+  const numericValue = Number(multiplier[1]);
+  return numericValue >= 0.5 && numericValue <= 2;
+}
+function isValidAzureAudioDuration2(value) {
+  const trimmed = value.trim();
+  const numeric = /^(\d+(?:\.\d+)?)(ms|s)$/.exec(trimmed);
+  if (numeric) return Number(numeric[1]) > 0;
+  const clock = /^(\d{2,}):([0-5]\d):([0-5]\d)(?:\.(\d{1,3}))?$/.exec(trimmed);
+  if (!clock) return false;
+  return Number(clock[1]) > 0 || Number(clock[2]) > 0 || Number(clock[3]) > 0 || Number(clock[4] ?? 0) > 0;
+}
+function isValidAzureBackgroundAudioDuration2(value) {
+  const match = /^(\d+)$/.exec(value.trim());
+  if (!match) return false;
+  const milliseconds = Number(match[1]);
+  return Number.isFinite(milliseconds) && milliseconds >= 0 && milliseconds <= 1e4;
+}
+function attr2(token, name) {
+  return token.attributes.get(name.toLowerCase());
+}
+var DEFAULT_LANGUAGE_ALIASES2 = {
+  "zh-CN": ["zh-Hans"],
+  "zh-TW": ["zh-Hant"]
+};
+function canonicalLanguageTag2(language) {
+  const trimmed = language.trim();
+  if (!trimmed) return "";
+  try {
+    return new Intl.Locale(trimmed).toString().toLowerCase();
+  } catch {
+    return trimmed.toLowerCase();
+  }
+}
+function createLanguageNormalizer2(options) {
+  const aliases = /* @__PURE__ */ new Map();
+  const addAliasGroup = (canonical, values) => {
+    const normalizedCanonical = canonicalLanguageTag2(canonical);
+    if (!normalizedCanonical) return;
+    aliases.set(normalizedCanonical, normalizedCanonical);
+    for (const value of values) {
+      const normalizedValue = canonicalLanguageTag2(value);
+      if (normalizedValue) aliases.set(normalizedValue, normalizedCanonical);
+    }
+  };
+  for (const [canonical, values] of Object.entries(DEFAULT_LANGUAGE_ALIASES2)) addAliasGroup(canonical, values);
+  for (const [canonical, valueOrValues] of Object.entries(options.languageAliases ?? {}))
+    addAliasGroup(canonical, typeof valueOrValues === "string" ? [valueOrValues] : valueOrValues);
+  return (language) => {
+    const customValue = options.normalizeLanguage ? options.normalizeLanguage(language) : language;
+    const normalized = canonicalLanguageTag2(customValue);
+    return aliases.get(normalized) ?? normalized;
+  };
+}
+function voiceLocalePrefix2(voiceName) {
+  const match = /^(?<language>[A-Za-z]{2,3})-(?<region>[A-Za-z]{2}|\d{3})(?:-|$)/.exec(voiceName.trim());
+  if (!match?.groups) return void 0;
+  const tag = `${match.groups.language}-${match.groups.region}`;
+  return {
+    language: match.groups.language.toLowerCase(),
+    region: match.groups.region.toLowerCase(),
+    tag
+  };
+}
+function definitionFromStyleMap2(voiceName, styles) {
+  return {
+    name: voiceName,
+    locale: voiceLocalePrefix2(voiceName)?.tag ?? "",
+    styles
+  };
+}
+function normalizeVoiceCatalog2(options) {
+  const definitions = /* @__PURE__ */ new Map();
+  for (const definition of AZURE_VOICE_DEFINITIONS2) definitions.set(definition.name.toLowerCase(), definition);
+  for (const definition of options.voiceCatalog ?? []) definitions.set(definition.name.toLowerCase(), definition);
+  for (const definition of options.voiceDefinitions ?? []) definitions.set(definition.name.toLowerCase(), definition);
+  for (const definition of options.customVoiceDefinitions ?? [])
+    definitions.set(definition.name.toLowerCase(), definition);
+  for (const [voiceName, styles] of Object.entries(options.customVoiceStyleMap ?? {})) {
+    const key = voiceName.toLowerCase();
+    const current = definitions.get(key);
+    definitions.set(key, {
+      ...current ?? definitionFromStyleMap2(voiceName, styles),
+      name: current?.name ?? voiceName,
+      styles: styles.map((style) => style.toLowerCase())
+    });
+  }
+  return definitions;
+}
+function diagnosticSeverity2(policy) {
+  if (policy === "ignore") return void 0;
+  return policy === "error" ? "error" : "warning";
+}
+function languagePart2(language) {
+  try {
+    return new Intl.Locale(language).language.toLowerCase();
+  } catch {
+    return language.split("-")[0]?.toLowerCase() ?? "";
+  }
+}
+function definitionMatchesLanguage2(definition, voiceName, language, normalizeLanguage) {
+  const candidateLanguages = definition ? [definition.locale, ...definition.secondaryLocales ?? []].filter(Boolean) : [voiceLocalePrefix2(voiceName)?.tag ?? ""];
+  if (candidateLanguages.length === 0 || !language.trim()) return void 0;
+  const normalizedLanguage = normalizeLanguage(language);
+  const normalizedCandidates = candidateLanguages.map(normalizeLanguage);
+  if (normalizedCandidates.includes(normalizedLanguage)) return true;
+  if (!normalizedLanguage || !normalizedCandidates.some(Boolean)) return void 0;
+  return normalizedLanguage === languagePart2(normalizedLanguage) ? normalizedCandidates.some((candidate) => languagePart2(candidate) === normalizedLanguage) : false;
+}
+function canonicalTagName2(name) {
+  const normalized = name.toLowerCase();
+  if (normalized === "express-as" || normalized === "expressas") return "mstts:express-as";
+  if (normalized === "sayas") return "say-as";
+  return normalized;
+}
+function validateVoiceFeatureMatrix2(token, source, diagnostics, voiceName, definition) {
+  if (!voiceName || !definition || token.name.toLowerCase() === "voice" || token.name.toLowerCase() === "mstts:turn")
+    return;
+  const tagName = canonicalTagName2(token.name);
+  const unsupportedTags = new Set((definition.unsupportedTags ?? []).map(canonicalTagName2));
+  const supportedTags = definition.supportedTags?.map(canonicalTagName2);
+  if (unsupportedTags.has(tagName) || supportedTags !== void 0 && !supportedTags.includes(tagName)) {
+    addDiagnostic2(
+      diagnostics,
+      source,
+      token.start,
+      `Tag <${token.name}> is not supported by voice "${voiceName}" according to the configured feature matrix.`,
+      "error",
+      "azure-unsupported-tag-for-voice"
+    );
+  }
+}
+function validateAudioSource2(token, source, diagnostics, options, elementName2) {
+  const src = attr2(token, "src");
+  if (!src) {
+    addDiagnostic2(diagnostics, source, token.start, `<${elementName2}> requires a "src" attribute.`);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = new URL(src);
+  } catch {
+    addDiagnostic2(diagnostics, source, token.start, `<${elementName2} src> must be an absolute HTTP(S) URL.`);
+    return;
+  }
+  if (parsed.username || parsed.password)
+    addDiagnostic2(diagnostics, source, token.start, `<${elementName2} src> must not contain URL credentials.`);
+  if (parsed.protocol !== "https:" && !(options.allowHttpAudio && parsed.protocol === "http:"))
+    addDiagnostic2(diagnostics, source, token.start, `<${elementName2} src> must use HTTPS.`);
+  const isAllowedOrigin = options.allowedAudioOrigins?.some((allowedOrigin) => {
+    try {
+      const configured = new URL(allowedOrigin);
+      if (configured.protocol !== "https:" && configured.protocol !== "http:" || configured.username || configured.password || configured.pathname !== "/" || configured.search || configured.hash)
+        return false;
+      return configured.origin === parsed.origin;
+    } catch {
+      return false;
+    }
+  }) ?? false;
+  if (options.allowedAudioOrigins && !isAllowedOrigin)
+    addDiagnostic2(diagnostics, source, token.start, `<${elementName2} src> origin "${parsed.origin}" is not allowed.`);
+  else if (!isAllowedOrigin && !options.allowExternalAudio)
+    addDiagnostic2(
+      diagnostics,
+      source,
+      token.start,
+      `<${elementName2} src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`
+    );
+}
+function validateElement2(token, source, diagnostics, voiceName, options, voiceCatalog) {
+  const name = token.name.toLowerCase();
+  const tagStatus = featureStatusForTag2(token.name, options);
+  if (tagStatus === "preview")
+    addDiagnostic2(
+      diagnostics,
+      source,
+      token.start,
+      `<${token.name}> is an Azure Speech preview feature and may change or require preview access.`,
+      "warning",
+      "azure-preview-tag"
+    );
+  if (tagStatus === "deprecated")
+    addDiagnostic2(
+      diagnostics,
+      source,
+      token.start,
+      `<${token.name}> is deprecated by Azure Speech; migrate to a supported alternative.`,
+      "info",
+      "azure-deprecated-tag"
+    );
+  if (name === "voice" && !attr2(token, "name")?.trim())
+    addDiagnostic2(diagnostics, source, token.start, '<voice> requires a non-empty "name" attribute.');
+  if (name === "break") {
+    const time = attr2(token, "time");
+    const strength = attr2(token, "strength");
+    if (!time && !strength)
+      addDiagnostic2(diagnostics, source, token.start, '<break> requires either "time" or "strength".');
+    if (time && strength)
+      addDiagnostic2(diagnostics, source, token.start, '<break> must not specify both "time" and "strength".');
+    if (time && !/^\d+(?:\.\d+)?(?:ms|s)$/.test(time.trim()))
+      addDiagnostic2(diagnostics, source, token.start, '<break time> must use a numeric value followed by "ms" or "s".');
+    if (strength && !ALLOWED_BREAK_STRENGTHS2.has(strength))
+      addDiagnostic2(diagnostics, source, token.start, `Unsupported <break strength> value "${strength}".`);
+  }
+  if (name === "prosody") {
+    const rate = attr2(token, "rate");
+    const pitch = attr2(token, "pitch");
+    const volume = attr2(token, "volume");
+    if (rate && !isSupportedProsodyRate2(rate))
+      addDiagnostic2(diagnostics, source, token.start, `Unsupported <prosody rate> value "${rate}".`);
+    if (pitch && !/^(x-low|low|medium|high|x-high|[+-]?\d+(?:\.\d+)?(?:st|Hz|%)?)$/.test(pitch.trim()))
+      addDiagnostic2(diagnostics, source, token.start, `Unsupported <prosody pitch> value "${pitch}".`);
+    if (volume && !/^(silent|x-soft|soft|medium|loud|x-loud|[+-]?\d+(?:\.\d+)?(?:dB|%)?)$/.test(volume.trim()))
+      addDiagnostic2(diagnostics, source, token.start, `Unsupported <prosody volume> value "${volume}".`);
+  }
+  if (name === "mstts:express-as" || name === "express-as" || name === "expressas") {
+    const style = attr2(token, "style");
+    if (!style?.trim())
+      addDiagnostic2(diagnostics, source, token.start, '<mstts:express-as> requires a non-empty "style" attribute.');
+    const degree = attr2(token, "styledegree") ?? attr2(token, "style-degree");
+    if (degree && (!/^\d+(?:\.\d+)?$/.test(degree) || Number(degree) < 0.01 || Number(degree) > 2))
+      addDiagnostic2(
+        diagnostics,
+        source,
+        token.start,
+        "<mstts:express-as styledegree> must be a number between 0.01 and 2."
+      );
+    const role = attr2(token, "role");
+    if (role && !ALLOWED_ROLES2.has(role))
+      addDiagnostic2(diagnostics, source, token.start, `Unsupported <mstts:express-as role> value "${role}".`);
+    const definition = voiceName ? voiceCatalog.get(voiceName.toLowerCase()) : void 0;
+    const supportedStyles = definition?.styles;
+    const severity = diagnosticSeverity2(options.unsupportedStylePolicy ?? options.unknownVoicePolicy ?? "warn");
+    if (style && definition && !supportedStyles?.some((candidate) => candidate.toLowerCase() === style.toLowerCase()) && severity)
+      addDiagnostic2(
+        diagnostics,
+        source,
+        token.start,
+        `Unknown style "${style}" is not supported by voice "${voiceName}" according to the configured voice style map.`,
+        severity,
+        "azure-unsupported-style"
+      );
+    if (style && voiceName && !definition && severity)
+      addDiagnostic2(
+        diagnostics,
+        source,
+        token.start,
+        `Unknown style "${style}" cannot be verified because voice "${voiceName}" is not registered in the voice style map.`,
+        severity
+      );
+  }
+  if (name === "say-as" || name === "sayas") {
+    const interpretAs = attr2(token, "interpret-as");
+    if (!interpretAs || !ALLOWED_SAY_AS2.has(interpretAs))
+      addDiagnostic2(diagnostics, source, token.start, `<say-as> requires a supported "interpret-as" value.`);
+  }
+  if (name === "phoneme" && (!attr2(token, "alphabet") || !attr2(token, "ph")))
+    addDiagnostic2(diagnostics, source, token.start, '<phoneme> requires both "alphabet" and "ph" attributes.');
+  if (name === "emphasis" && attr2(token, "level") && !ALLOWED_EMPHASIS_LEVELS2.has(attr2(token, "level") ?? ""))
+    addDiagnostic2(diagnostics, source, token.start, `Unsupported <emphasis level> value "${attr2(token, "level")}".`);
+  if (name === "sub" && !attr2(token, "alias")?.trim())
+    addDiagnostic2(diagnostics, source, token.start, '<sub> requires a non-empty "alias" attribute.');
+  if (name === "lang" && !attr2(token, "xml:lang")?.trim() && !attr2(token, "lang")?.trim())
+    addDiagnostic2(diagnostics, source, token.start, '<lang> requires an "xml:lang" attribute.');
+  if (name === "mark" && !attr2(token, "name")?.trim())
+    addDiagnostic2(diagnostics, source, token.start, '<mark> requires a non-empty "name" attribute.');
+  if (name === "bookmark" && !attr2(token, "mark")?.trim())
+    addDiagnostic2(diagnostics, source, token.start, '<bookmark> requires a non-empty "mark" attribute.');
+  if (name === "lexicon") {
+    const uri = attr2(token, "uri");
+    if (!uri) addDiagnostic2(diagnostics, source, token.start, '<lexicon> requires a "uri" attribute.');
+    else {
+      try {
+        const parsed = new URL(uri);
+        if (parsed.protocol !== "https:")
+          addDiagnostic2(diagnostics, source, token.start, "<lexicon uri> must use HTTPS.");
+      } catch {
+        addDiagnostic2(diagnostics, source, token.start, "<lexicon uri> must be an absolute HTTPS URL.");
+      }
+    }
+  }
+  if (name === "mstts:silence") {
+    const type = attr2(token, "type");
+    const value = attr2(token, "value");
+    if (!type || !ALLOWED_SILENCE_TYPES2.has(type))
+      addDiagnostic2(diagnostics, source, token.start, '<mstts:silence> requires a supported "type" attribute.');
+    if (!value || !/^\d+(?:\.\d+)?(?:ms|s)$/.test(value.trim()))
+      addDiagnostic2(diagnostics, source, token.start, '<mstts:silence> requires a time-valued "value" attribute.');
+  }
+  if (name === "mstts:audioduration") {
+    const value = attr2(token, "value");
+    if (!value || !isValidAzureAudioDuration2(value))
+      addDiagnostic2(
+        diagnostics,
+        source,
+        token.start,
+        '<mstts:audioduration> requires a positive duration such as "10s", "5000ms", or "00:00:10".'
+      );
+    if (!token.selfClosing)
+      addDiagnostic2(diagnostics, source, token.start, "<mstts:audioduration> must be self-closing.");
+  }
+  if (name === "mstts:viseme") {
+    const type = attr2(token, "type");
+    if (!type || !ALLOWED_VISEME_TYPES2.has(type))
+      addDiagnostic2(diagnostics, source, token.start, '<mstts:viseme> requires a supported "type" attribute.');
+  }
+  if (name === "audio") {
+    validateAudioSource2(token, source, diagnostics, options, "audio");
+  }
+  if (name === "mstts:turn") {
+    if (!attr2(token, "voice")?.trim() && !attr2(token, "speaker")?.trim())
+      addDiagnostic2(
+        diagnostics,
+        source,
+        token.start,
+        '<mstts:turn> requires a non-empty "voice" or "speaker" attribute.'
+      );
+    if (token.parentName?.toLowerCase() !== "mstts:dialog")
+      addDiagnostic2(diagnostics, source, token.start, "<mstts:turn> is only allowed directly inside <mstts:dialog>.");
+  }
+  if (name === "mstts:backgroundaudio") {
+    validateAudioSource2(token, source, diagnostics, options, "mstts:backgroundaudio");
+    const volume = attr2(token, "volume");
+    if (volume !== void 0 && (!/^\d+(?:\.\d+)?$/.test(volume.trim()) || Number(volume) > 100))
+      addDiagnostic2(diagnostics, source, token.start, `Unsupported <mstts:backgroundaudio volume> value "${volume}".`);
+    for (const [attribute, value] of [
+      ["fadein", attr2(token, "fadein")],
+      ["fadeout", attr2(token, "fadeout")]
+    ]) {
+      if (value !== void 0 && !isValidAzureBackgroundAudioDuration2(value))
+        addDiagnostic2(
+          diagnostics,
+          source,
+          token.start,
+          `<mstts:backgroundaudio ${attribute}> must be between 0 and 10000 milliseconds, for example "500ms" or "10s".`
+        );
+    }
+    if (token.parentName?.toLowerCase() !== "speak" || token.childElementIndex !== 0)
+      addDiagnostic2(
+        diagnostics,
+        source,
+        token.start,
+        "<mstts:backgroundaudio> must be the first element directly under <speak>."
+      );
+    if (!token.selfClosing)
+      addDiagnostic2(diagnostics, source, token.start, "<mstts:backgroundaudio> must be self-closing.");
+  }
+}
+function validateAzureSsmlStatic2(ssml, options = {}) {
+  const diagnostics = [];
+  if (typeof ssml !== "string") {
+    return [
+      {
+        line: 1,
+        column: 1,
+        message: "SSML input must be a string",
+        severity: "error",
+        source: "ssml-static-validator"
+      }
+    ];
+  }
+  const maxLength = options.maxLength ?? 1e4;
+  if (ssml.length > maxLength)
+    addDiagnostic2(diagnostics, ssml, maxLength, `SSML exceeds the maximum length of ${maxLength} characters.`);
+  if (options.maxXmlDepth !== void 0 && (!Number.isInteger(options.maxXmlDepth) || options.maxXmlDepth <= 0)) {
+    addDiagnostic2(diagnostics, ssml, 0, "maxXmlDepth must be a positive integer.");
+  }
+  try {
+    parseSsml2(ssml);
+  } catch (error) {
+    const message = error instanceof Error ? error.message.replace(/ at position \d+$/, "") : String(error);
+    const match = / at position (\d+)$/.exec(error instanceof Error ? error.message : "");
+    addDiagnostic2(diagnostics, ssml, match ? Number(match[1]) : 0, message);
+    return diagnostics;
+  }
+  const tokens = tokenizeElements2(ssml);
+  if (options.maxXmlDepth !== void 0) {
+    for (const token of tokens) {
+      if (token.depth > options.maxXmlDepth) {
+        addDiagnostic2(
+          diagnostics,
+          ssml,
+          token.start,
+          `XML nesting depth ${token.depth} exceeds the configured maximum of ${options.maxXmlDepth}.`
+        );
+      }
+    }
+  }
+  const speak = tokens.find((token) => token.name.toLowerCase() === "speak");
+  const voices = tokens.filter((token) => token.name.toLowerCase() === "voice");
+  const backgroundAudioTokens = tokens.filter((token) => token.name.toLowerCase() === "mstts:backgroundaudio");
+  for (const [index, token] of backgroundAudioTokens.entries()) {
+    if (index > 0)
+      addDiagnostic2(
+        diagnostics,
+        ssml,
+        token.start,
+        "An SSML document can contain at most one <mstts:backgroundaudio> element."
+      );
+  }
+  if (!speak || voices.length === 0)
+    addDiagnostic2(
+      diagnostics,
+      ssml,
+      speak?.start ?? 0,
+      "Azure SSML requires at least one <voice> element under <speak>."
+    );
+  const voiceName = voices[0] ? attr2(voices[0], "name") : void 0;
+  const voiceCatalog = normalizeVoiceCatalog2(options);
+  const normalizeLanguage = createLanguageNormalizer2(options);
+  const policySeverity = diagnosticSeverity2(options.unknownVoicePolicy ?? "warn");
+  const voicesToValidate = options.validateNestedVoices === false ? voices.slice(0, 1) : voices;
+  for (const token of voicesToValidate) {
+    const name = attr2(token, "name")?.trim();
+    const language = attr2(token, "xml:lang")?.trim() || (speak ? attr2(speak, "xml:lang")?.trim() : void 0);
+    const definition = name ? voiceCatalog.get(name.toLowerCase()) : void 0;
+    if (name && definition?.status === "preview")
+      addDiagnostic2(
+        diagnostics,
+        ssml,
+        token.start,
+        `Voice "${name}" is an Azure Speech preview voice and may change or require preview access.`,
+        "warning",
+        "azure-preview-voice"
+      );
+    if (name && definition?.status === "deprecated")
+      addDiagnostic2(
+        diagnostics,
+        ssml,
+        token.start,
+        `Voice "${name}" is deprecated by Azure Speech; migrate to a supported voice.`,
+        "info",
+        "azure-deprecated-voice"
+      );
+    if (name && !definition && policySeverity)
+      addDiagnostic2(
+        diagnostics,
+        ssml,
+        token.start,
+        `Unknown voice "${name}" is not registered in the voice catalog.`,
+        policySeverity,
+        "azure-unknown-voice"
+      );
+    if (name && language && definitionMatchesLanguage2(definition, name, language, normalizeLanguage) === false)
+      addDiagnostic2(
+        diagnostics,
+        ssml,
+        token.start,
+        `Voice "${name}" does not match language "${language}"; the voice name prefix indicates a different language or region.`,
+        "warning",
+        "azure-locale-mismatch"
+      );
+  }
+  for (const token of tokens) {
+    const tokenName = token.name.toLowerCase();
+    const tokenVoiceName = tokenName === "voice" ? attr2(token, "name")?.trim() : tokenName === "mstts:turn" ? attr2(token, "voice")?.trim() || token.parentVoiceName : options.validateNestedVoices === false ? voiceName : token.parentVoiceName;
+    validateElement2(token, ssml, diagnostics, tokenVoiceName, options, voiceCatalog);
+    const definition = tokenVoiceName ? voiceCatalog.get(tokenVoiceName.toLowerCase()) : void 0;
+    validateVoiceFeatureMatrix2(token, ssml, diagnostics, tokenVoiceName, definition);
+    if (tokenName === "voice" && options.model && definition?.models && !definition.models.some((model) => model.toLowerCase() === options.model?.toLowerCase())) {
+      addDiagnostic2(
+        diagnostics,
+        ssml,
+        token.start,
+        `Voice "${tokenVoiceName}" does not support model "${options.model}" according to the configured feature matrix.`,
+        "error",
+        "azure-unsupported-model-for-voice"
+      );
+    }
+  }
+  return diagnostics;
+}
+function urlAttributes2(token) {
+  const tag = canonicalTagName2(token.name);
+  const attributes = tag === "audio" || tag === "mstts:backgroundaudio" ? ["src"] : tag === "lexicon" ? ["uri"] : tag === "mstts:voiceconversion" ? ["url"] : [];
+  return attributes.flatMap((attribute) => {
+    const value = attr2(token, attribute);
+    return value === void 0 ? [] : [{ attribute, value }];
+  });
+}
+function validateAzureSsml2(ssml, options = {}) {
+  const diagnostics = validateAzureSsmlStatic2(ssml, options);
+  const validator = options.urlValidator ?? options.customUrlValidator;
+  if (!validator || typeof ssml !== "string") return diagnostics;
+  let tokens;
+  try {
+    tokens = tokenizeElements2(ssml);
+  } catch {
+    return diagnostics;
+  }
+  const checks = tokens.flatMap(
+    (token) => urlAttributes2(token).map(async ({ attribute, value }) => {
+      try {
+        const result = await validator(value, { tag: token.name, attribute });
+        const valid = typeof result === "boolean" ? result : result.valid;
+        if (!valid) {
+          const reason = typeof result === "boolean" ? void 0 : result.reason;
+          addDiagnostic2(
+            diagnostics,
+            ssml,
+            token.start,
+            `<${token.name} ${attribute}> was rejected by the custom URL validator${reason ? `: ${reason}` : "."}`
+          );
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        addDiagnostic2(
+          diagnostics,
+          ssml,
+          token.start,
+          `<${token.name} ${attribute}> could not be validated by the custom URL validator: ${reason}`
+        );
+      }
+    })
+  );
+  return Promise.all(checks).then(() => diagnostics);
+}
+var AZURE_VOICE_CATALOG_METADATA2 = {
+  apiVersion: "2025-10-01",
+  generatedAt: "2026-08-28T00:00:00.000Z",
+  regions: [],
+  voiceCount: AZURE_VOICE_DEFINITIONS2.length
+};
+
+// packages/azure-tts-client/src/safe.ts
+async function synthesizeSsmlSafe(client, ssml, options = {}) {
+  const validationOptions = options.validation ?? options;
+  const diagnostics = await Promise.resolve(validateAzureSsml2(ssml, validationOptions));
+  const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (errors.length > 0) {
+    return {
+      ok: false,
+      success: false,
+      status: "validation-error",
+      error: {
+        kind: "validation",
+        message: "SSML validation failed; the Azure Speech API was not called.",
+        diagnostics: errors
+      }
+    };
+  }
+  try {
+    return { ok: true, success: true, status: "success", value: await client.synthesizeSsml(ssml) };
+  } catch (error) {
+    const azureError = error instanceof AzureTtsError ? error : createSpeechSdkError(error);
+    return { ok: false, success: false, status: "azure-api-error", error: azureError };
+  }
+}
+
+// packages/azure-tts-client/src/client.ts
+var ENDPOINT_TEMPLATE = "https://{region}.tts.speech.microsoft.com/cognitiveservices/v1";
+var _options;
+var AzureTtsClient = class {
+  constructor(options) {
+    __privateAdd(this, _options);
+    __privateSet(this, _options, options);
+  }
+  async synthesize(ssml) {
+    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
+    const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
+    __privateGet(this, _options).logger?.debug?.("Using Azure TTS endpoint:", endpoint);
+    const config = { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs };
+    return synthesizeSpeech(ssml, config);
+  }
+  async synthesizeSsml(ssml) {
+    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
+    const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
+    __privateGet(this, _options).logger?.debug?.("Using Azure TTS endpoint:", endpoint);
+    return synthesizeSsml(ssml, { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs });
+  }
+  async synthesizeChunks(chunks, options = {}) {
+    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
+    const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
+    return synthesizeSsmlChunks(chunks, {
+      endpoint,
+      region,
+      subscriptionKey,
+      outputFormat,
+      signal,
+      timeoutMs,
+      onProgress: options.onProgress ?? __privateGet(this, _options).onProgress
+    });
+  }
+  async synthesizeSsmlSafe(ssml, options = {}) {
+    return synthesizeSsmlSafe(this, ssml, options);
   }
 };
 _options = new WeakMap();
@@ -2631,11 +4330,14 @@ async function fetchAzureVoiceCatalog(options) {
   getBuiltInVoiceCatalogMetadata,
   isValidAzureAudioDuration,
   mapSsmlTextNodes,
+  mergeSynthesisResults,
   normalizeAzureLanguage,
   parseSsml,
   splitSsmlDocument,
   synthesizeSpeech,
   synthesizeSsml,
+  synthesizeSsmlChunks,
+  synthesizeSsmlSafe,
   validateAzureSsml,
   validateSsml,
   validateSsmlStructureIntegrity