ssml-builder-js 2.12.0 → 2.13.0

package/dist/{chunk-FHDFRM2F.mjs → chunk-LCTE26LS.mjs}

@@ -1,8 +1,158 @@
+import {
+  buildSsml,
+  parseSsml
+} from "./chunk-CZ2F3TET.mjs";
 import {
   __export
 } from "./chunk-6S5ODO6A.mjs";
 
 // packages/ssml-editor-react/src/locales.ts
+var SSML_ELEMENT_COPY = {
+  ja: {
+    dialog: {
+      label: "\u30C0\u30A4\u30A2\u30ED\u30B0",
+      description: "\u8907\u6570\u306E\u8A71\u8005\u30BF\u30FC\u30F3\u3092\u307E\u3068\u3081\u307E\u3059\u3002",
+      validationErrors: { turn: "turn \u306F dialog \u306E\u76F4\u4E0B\u306B\u914D\u7F6E\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    "mstts:dialog": {
+      label: "\u30C0\u30A4\u30A2\u30ED\u30B0",
+      description: "\u8907\u6570\u306E\u8A71\u8005\u30BF\u30FC\u30F3\u3092\u307E\u3068\u3081\u307E\u3059\u3002",
+      validationErrors: { turn: "turn \u306F dialog \u306E\u76F4\u4E0B\u306B\u914D\u7F6E\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    turn: {
+      label: "\u8A71\u8005\u30BF\u30FC\u30F3",
+      description: "\u30C0\u30A4\u30A2\u30ED\u30B0\u5185\u306E\u8A71\u8005\u3068\u767A\u8A71\u5185\u5BB9\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: { voice: "voice \u307E\u305F\u306F speaker \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    "mstts:turn": {
+      label: "\u8A71\u8005\u30BF\u30FC\u30F3",
+      description: "\u30C0\u30A4\u30A2\u30ED\u30B0\u5185\u306E\u8A71\u8005\u3068\u767A\u8A71\u5185\u5BB9\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: { voice: "voice \u307E\u305F\u306F speaker \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    backgroundaudio: {
+      label: "\u80CC\u666F\u97F3\u58F0",
+      description: "\u5408\u6210\u97F3\u58F0\u306E\u80CC\u5F8C\u3067\u518D\u751F\u3059\u308B\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: { src: "\u80CC\u666F\u97F3\u58F0\u306B\u306F URL \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    "mstts:backgroundaudio": {
+      label: "\u80CC\u666F\u97F3\u58F0",
+      description: "\u5408\u6210\u97F3\u58F0\u306E\u80CC\u5F8C\u3067\u518D\u751F\u3059\u308B\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: { src: "\u80CC\u666F\u97F3\u58F0\u306B\u306F URL \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    ttsembedding: {
+      label: "\u97F3\u58F0\u57CB\u3081\u8FBC\u307F",
+      description: "\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0\u307E\u305F\u306F\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u57CB\u3081\u8FBC\u307F\u307E\u3059\u3002",
+      validationErrors: { speakerProfileId: "\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB ID \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    "mstts:ttsembedding": {
+      label: "\u97F3\u58F0\u57CB\u3081\u8FBC\u307F",
+      description: "\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0\u307E\u305F\u306F\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u57CB\u3081\u8FBC\u307F\u307E\u3059\u3002",
+      validationErrors: { speakerProfileId: "\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB ID \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    embedding: {
+      label: "\u57CB\u3081\u8FBC\u307F",
+      description: "\u8A71\u8005\u57CB\u3081\u8FBC\u307F\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: {}
+    },
+    "mstts:embedding": {
+      label: "\u57CB\u3081\u8FBC\u307F",
+      description: "\u8A71\u8005\u57CB\u3081\u8FBC\u307F\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: {}
+    },
+    silence: {
+      label: "\u7121\u97F3",
+      description: "\u767A\u8A71\u524D\u5F8C\u307E\u305F\u306F\u53E5\u8AAD\u70B9\u306E\u5883\u754C\u306B\u7121\u97F3\u3092\u8FFD\u52A0\u3057\u307E\u3059\u3002",
+      validationErrors: { value: "\u7121\u97F3\u306E\u9577\u3055\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    "mstts:silence": {
+      label: "\u7121\u97F3",
+      description: "\u767A\u8A71\u524D\u5F8C\u307E\u305F\u306F\u53E5\u8AAD\u70B9\u306E\u5883\u754C\u306B\u7121\u97F3\u3092\u8FFD\u52A0\u3057\u307E\u3059\u3002",
+      validationErrors: { value: "\u7121\u97F3\u306E\u9577\u3055\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }
+    },
+    voiceconversion: {
+      label: "\u97F3\u58F0\u5909\u63DB",
+      description: "\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0\u306E\u5909\u63DB\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: {}
+    },
+    "mstts:voiceconversion": {
+      label: "\u97F3\u58F0\u5909\u63DB",
+      description: "\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0\u306E\u5909\u63DB\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      validationErrors: {}
+    }
+  },
+  en: {
+    dialog: {
+      label: "Dialog",
+      description: "Groups multiple speaker turns.",
+      validationErrors: { turn: "Place turns directly inside a dialog." }
+    },
+    "mstts:dialog": {
+      label: "Dialog",
+      description: "Groups multiple speaker turns.",
+      validationErrors: { turn: "Place turns directly inside a dialog." }
+    },
+    turn: {
+      label: "Dialog turn",
+      description: "Specifies a speaker and utterance within a dialog.",
+      validationErrors: { voice: "Provide a voice or speaker." }
+    },
+    "mstts:turn": {
+      label: "Dialog turn",
+      description: "Specifies a speaker and utterance within a dialog.",
+      validationErrors: { voice: "Provide a voice or speaker." }
+    },
+    backgroundaudio: {
+      label: "Background audio",
+      description: "Specifies an audio file played behind synthesized speech.",
+      validationErrors: { src: "Provide a background audio URL." }
+    },
+    "mstts:backgroundaudio": {
+      label: "Background audio",
+      description: "Specifies an audio file played behind synthesized speech.",
+      validationErrors: { src: "Provide a background audio URL." }
+    },
+    ttsembedding: {
+      label: "TTS embedding",
+      description: "Embeds custom voice or speaker profile metadata.",
+      validationErrors: { speakerProfileId: "Provide a speaker profile ID." }
+    },
+    "mstts:ttsembedding": {
+      label: "TTS embedding",
+      description: "Embeds custom voice or speaker profile metadata.",
+      validationErrors: { speakerProfileId: "Provide a speaker profile ID." }
+    },
+    embedding: {
+      label: "Embedding",
+      description: "Specifies speaker embedding metadata.",
+      validationErrors: {}
+    },
+    "mstts:embedding": {
+      label: "Embedding",
+      description: "Specifies speaker embedding metadata.",
+      validationErrors: {}
+    },
+    silence: {
+      label: "Silence",
+      description: "Adds silence before, after, or around punctuation.",
+      validationErrors: { value: "Provide a silence duration." }
+    },
+    "mstts:silence": {
+      label: "Silence",
+      description: "Adds silence before, after, or around punctuation.",
+      validationErrors: { value: "Provide a silence duration." }
+    },
+    voiceconversion: {
+      label: "Voice conversion",
+      description: "Specifies custom voice conversion metadata.",
+      validationErrors: {}
+    },
+    "mstts:voiceconversion": {
+      label: "Voice conversion",
+      description: "Specifies custom voice conversion metadata.",
+      validationErrors: {}
+    }
+  }
+};
 var EDITOR_COPY = {
   ja: {
     editorAriaLabel: "SSML\u30A8\u30C7\u30A3\u30BF\u30FC",
@@ -220,6 +370,42 @@ var SSML_HOVER_COPY = {
         parameters: {
           value: { title: "value", description: "\u76EE\u6A19\u6642\u9593\u3002\u4F8B: `10s`\u3001`5000ms`\u3001`00:00:10`\u3002" }
         }
+      },
+      "mstts:dialog": { title: "\u30C0\u30A4\u30A2\u30ED\u30B0", description: "\u8907\u6570\u306E\u8A71\u8005\u30BF\u30FC\u30F3\u3092\u307E\u3068\u3081\u307E\u3059\u3002", parameters: {} },
+      "mstts:turn": {
+        title: "\u8A71\u8005\u30BF\u30FC\u30F3",
+        description: "\u30C0\u30A4\u30A2\u30ED\u30B0\u5185\u306E\u8A71\u8005\u3068\u767A\u8A71\u5185\u5BB9\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+        parameters: {
+          voice: { title: "voice", description: "\u3053\u306E\u30BF\u30FC\u30F3\u3067\u4F7F\u7528\u3059\u308B Azure \u97F3\u58F0\u540D\u3002" },
+          speaker: { title: "speaker", description: "\u8A71\u8005\u8B58\u5225\u5B50\u3002" }
+        }
+      },
+      "mstts:backgroundaudio": {
+        title: "\u80CC\u666F\u97F3\u58F0",
+        description: "\u5408\u6210\u97F3\u58F0\u306E\u80CC\u5F8C\u3067\u518D\u751F\u3059\u308B\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+        parameters: { src: { title: "src", description: "\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u306E HTTPS URL\u3002" } }
+      },
+      "mstts:ttsembedding": {
+        title: "\u97F3\u58F0\u57CB\u3081\u8FBC\u307F",
+        description: "\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0\u307E\u305F\u306F\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u57CB\u3081\u8FBC\u307F\u307E\u3059\u3002",
+        parameters: { speakerProfileId: { title: "speakerProfileId", description: "\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB ID\u3002" } }
+      },
+      "mstts:embedding": {
+        title: "\u57CB\u3081\u8FBC\u307F",
+        description: "\u8A71\u8005\u57CB\u3081\u8FBC\u307F\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+        parameters: {
+          id: { title: "id", description: "\u57CB\u3081\u8FBC\u307F ID\u3002" },
+          speakerProfileId: { title: "speakerProfileId", description: "\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB ID\u3002" }
+        }
+      },
+      "mstts:voiceconversion": {
+        title: "\u97F3\u58F0\u5909\u63DB",
+        description: "\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0\u306E\u5909\u63DB\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+        parameters: {
+          url: { title: "url", description: "\u97F3\u58F0\u5909\u63DB\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB URL\u3002" },
+          profile: { title: "profile", description: "\u5909\u63DB\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u3002" },
+          speakerProfileId: { title: "speakerProfileId", description: "\u8A71\u8005\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB ID\u3002" }
+        }
       }
     }
   },
@@ -384,6 +570,42 @@ var SSML_HOVER_COPY = {
         parameters: {
           value: { title: "value", description: "The target duration, such as `10s`, `5000ms`, or `00:00:10`." }
         }
+      },
+      "mstts:dialog": { title: "Dialog", description: "Groups multiple speaker turns.", parameters: {} },
+      "mstts:turn": {
+        title: "Dialog turn",
+        description: "Specifies a speaker and utterance within a dialog.",
+        parameters: {
+          voice: { title: "voice", description: "The Azure voice used by this turn." },
+          speaker: { title: "speaker", description: "The speaker identifier." }
+        }
+      },
+      "mstts:backgroundaudio": {
+        title: "Background audio",
+        description: "Specifies an audio file played behind synthesized speech.",
+        parameters: { src: { title: "src", description: "The HTTPS URL of the audio file." } }
+      },
+      "mstts:ttsembedding": {
+        title: "TTS embedding",
+        description: "Embeds custom voice or speaker profile metadata.",
+        parameters: { speakerProfileId: { title: "speakerProfileId", description: "The speaker profile ID." } }
+      },
+      "mstts:embedding": {
+        title: "Embedding",
+        description: "Specifies speaker embedding metadata.",
+        parameters: {
+          id: { title: "id", description: "The embedding ID." },
+          speakerProfileId: { title: "speakerProfileId", description: "The speaker profile ID." }
+        }
+      },
+      "mstts:voiceconversion": {
+        title: "Voice conversion",
+        description: "Specifies custom voice conversion metadata.",
+        parameters: {
+          url: { title: "url", description: "The voice conversion profile URL." },
+          profile: { title: "profile", description: "The conversion profile." },
+          speakerProfileId: { title: "speakerProfileId", description: "The speaker profile ID." }
+        }
       }
     }
   }
@@ -1313,1698 +1535,6 @@ var SSML_INSERTION_MODES = {
   wrap: "wrap"
 };
 
-// packages/ssml-core/dist/index.mjs
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var SYNTHESIS_NAMESPACE = "http://www.w3.org/2001/10/synthesis";
-var MSTTS_NAMESPACE = "http://www.w3.org/2001/mstts";
-var DEFAULT_SSML_VERSION = "1.0";
-var DEFAULT_SSML_LANGUAGE = "en-US";
-var MAX_NESTING_DEPTH = 1e3;
-var XML_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
-var MSTTS_TAG_PREFIX = "mstts:";
-var SSML_TAGS = {
-  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_ATTRS = {
-  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"
-};
-function escapeText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeAttribute(value) {
-  return escapeText(value).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function addAttribute(attributes, name, value) {
-  if (value !== void 0) {
-    attributes[name] = value;
-  }
-}
-function getAttributes(element) {
-  const attributes = {
-    ...element.attributes ?? {}
-  };
-  switch (element.type) {
-    case SSML_TAGS.VOICE:
-      addAttribute(attributes, SSML_ATTRS.NAME, element.name);
-      addAttribute(attributes, SSML_ATTRS.EFFECT, element.effect);
-      break;
-    case SSML_TAGS.PROSODY:
-      addAttribute(attributes, SSML_ATTRS.RATE, element.rate);
-      addAttribute(attributes, SSML_ATTRS.PITCH, element.pitch);
-      addAttribute(attributes, SSML_ATTRS.VOLUME, element.volume);
-      addAttribute(attributes, SSML_ATTRS.CONTOUR, element.contour);
-      addAttribute(attributes, SSML_ATTRS.RANGE, element.range);
-      break;
-    case SSML_TAGS.BREAK:
-      addAttribute(attributes, SSML_ATTRS.TIME, element.time);
-      addAttribute(attributes, SSML_ATTRS.STRENGTH, element.strength);
-      break;
-    case SSML_TAGS.EXPRESS_AS:
-    case SSML_TAGS.EXPRESS_AS_CAMEL:
-    case SSML_TAGS.MSTTS_EXPRESS_AS:
-      addAttribute(attributes, SSML_ATTRS.STYLE, element.style);
-      addAttribute(attributes, SSML_ATTRS.STYLE_DEGREE, element.styleDegree);
-      addAttribute(attributes, SSML_ATTRS.ROLE, element.role);
-      break;
-    case SSML_TAGS.SAY_AS:
-    case SSML_TAGS.SAY_AS_CAMEL:
-      addAttribute(attributes, SSML_ATTRS.INTERPRET_AS, element.interpretAs);
-      addAttribute(attributes, SSML_ATTRS.FORMAT, element.format);
-      addAttribute(attributes, SSML_ATTRS.DETAIL, element.detail);
-      break;
-    case SSML_TAGS.PHONEME:
-      addAttribute(attributes, SSML_ATTRS.ALPHABET, element.alphabet);
-      addAttribute(attributes, SSML_ATTRS.PH, element.ph);
-      break;
-    case SSML_TAGS.EMPHASIS:
-      addAttribute(attributes, SSML_ATTRS.LEVEL, element.level);
-      break;
-    case SSML_TAGS.AUDIO:
-      addAttribute(attributes, SSML_ATTRS.SRC, element.src);
-      addAttribute(attributes, SSML_ATTRS.DESC, element.desc);
-      addAttribute(attributes, SSML_ATTRS.CLIP_BEGIN, element.clipBegin);
-      addAttribute(attributes, SSML_ATTRS.CLIP_END, element.clipEnd);
-      addAttribute(attributes, SSML_ATTRS.SPEED, element.speed);
-      addAttribute(attributes, SSML_ATTRS.REPEAT_COUNT, element.repeatCount);
-      addAttribute(attributes, SSML_ATTRS.REPEAT_DURATION, element.repeatDuration);
-      addAttribute(attributes, SSML_ATTRS.SOUND_LEVEL, element.soundLevel);
-      break;
-    case SSML_TAGS.SUB:
-      addAttribute(attributes, SSML_ATTRS.ALIAS, element.alias);
-      break;
-    case SSML_TAGS.LANG:
-      addAttribute(attributes, SSML_ATTRS.XML_LANG, element.lang);
-      break;
-    case SSML_TAGS.MARK:
-      addAttribute(attributes, SSML_ATTRS.NAME, element.name);
-      break;
-    case SSML_TAGS.BOOKMARK:
-      addAttribute(attributes, SSML_ATTRS.MARK, element.mark);
-      break;
-    case SSML_TAGS.LEXICON:
-      addAttribute(attributes, SSML_ATTRS.URI, element.uri);
-      break;
-    case SSML_TAGS.MSTTS_SILENCE:
-    case SSML_TAGS.SILENCE:
-      addAttribute(attributes, SSML_ATTRS.TYPE, element.typeValue ?? element.silenceType);
-      addAttribute(attributes, SSML_ATTRS.VALUE, element.value);
-      break;
-    case SSML_TAGS.MSTTS_VISEME:
-    case SSML_TAGS.VISEME:
-      addAttribute(attributes, SSML_ATTRS.TYPE, element.typeValue ?? element.visemeType);
-      break;
-    case SSML_TAGS.MSTTS_AUDIO_DURATION:
-      addAttribute(attributes, SSML_ATTRS.VALUE, element.value);
-      break;
-    case SSML_TAGS.MSTTS_TURN:
-      addAttribute(attributes, SSML_ATTRS.VOICE, element.voice);
-      addAttribute(attributes, SSML_ATTRS.SPEAKER, element.speaker);
-      break;
-    case SSML_TAGS.MSTTS_BACKGROUND_AUDIO:
-      addAttribute(attributes, SSML_ATTRS.SRC, element.src);
-      addAttribute(attributes, SSML_ATTRS.VOLUME, element.volume);
-      addAttribute(attributes, SSML_ATTRS.FADE_IN, element.fadeIn ?? element.fadein);
-      addAttribute(attributes, SSML_ATTRS.FADE_OUT, element.fadeOut ?? element.fadeout);
-      break;
-    case SSML_TAGS.MSTTS_DIALOG:
-      break;
-    case SSML_TAGS.MSTTS_TTS_EMBEDDING:
-      addAttribute(attributes, SSML_ATTRS.SPEAKER_PROFILE_ID, element.speakerProfileId);
-      break;
-    case SSML_TAGS.MSTTS_EMBEDDING:
-      addAttribute(attributes, SSML_ATTRS.ID, element.id);
-      addAttribute(attributes, SSML_ATTRS.SPEAKER_PROFILE_ID, element.speakerProfileId);
-      break;
-    case SSML_TAGS.MSTTS_VOICE_CONVERSION:
-      addAttribute(attributes, SSML_ATTRS.URL, element.url);
-      addAttribute(attributes, SSML_ATTRS.PROFILE, element.profile);
-      addAttribute(attributes, SSML_ATTRS.SPEAKER_PROFILE_ID, element.speakerProfileId);
-      break;
-    case SSML_TAGS.PARAGRAPH:
-    case SSML_TAGS.SENTENCE:
-    case SSML_TAGS.WORD:
-    case "element":
-    case "custom":
-      break;
-  }
-  return attributes;
-}
-function getTagName(element) {
-  switch (element.type) {
-    case SSML_TAGS.EXPRESS_AS:
-    case SSML_TAGS.EXPRESS_AS_CAMEL:
-    case SSML_TAGS.MSTTS_EXPRESS_AS:
-      return SSML_TAGS.MSTTS_EXPRESS_AS;
-    case SSML_TAGS.SAY_AS:
-    case SSML_TAGS.SAY_AS_CAMEL:
-      return SSML_TAGS.SAY_AS;
-    case SSML_TAGS.SILENCE:
-    case SSML_TAGS.MSTTS_SILENCE:
-      return SSML_TAGS.MSTTS_SILENCE;
-    case SSML_TAGS.VISEME:
-    case SSML_TAGS.MSTTS_VISEME:
-      return SSML_TAGS.MSTTS_VISEME;
-    case SSML_TAGS.MSTTS_AUDIO_DURATION:
-      return SSML_TAGS.MSTTS_AUDIO_DURATION;
-    case "element":
-    case "custom":
-      return element.name;
-    default:
-      return element.type;
-  }
-}
-function getChildren(element) {
-  return element.children ?? [];
-}
-function validateName(name, kind) {
-  if (!XML_NAME_PATTERN.test(name)) {
-    throw new Error(`Invalid XML ${kind} name: ${name}`);
-  }
-}
-function serializeAttributes(attributes) {
-  return Object.entries(attributes).map(([name, value]) => {
-    validateName(name, "attribute");
-    return ` ${name}="${escapeAttribute(String(value))}"`;
-  }).join("");
-}
-function serializeNode(node) {
-  if (typeof node === "string") {
-    return escapeText(node);
-  }
-  if (node.type === "text") {
-    return escapeText(node.value);
-  }
-  const tagName = getTagName(node);
-  validateName(tagName, "element");
-  const attributes = serializeAttributes(getAttributes(node));
-  const children = getChildren(node);
-  if (children.length === 0) {
-    return `<${tagName}${attributes}/>`;
-  }
-  return `<${tagName}${attributes}>${children.map(serializeNode).join("")}</${tagName}>`;
-}
-function usesMsttsNamespace(nodes) {
-  return nodes.some((node) => {
-    if (typeof node === "string" || node.type === "text") {
-      return false;
-    }
-    const tagName = getTagName(node);
-    return tagName.startsWith(MSTTS_TAG_PREFIX) || usesMsttsNamespace(getChildren(node));
-  });
-}
-function serializeDocument(document) {
-  const children = document.children ?? (document.content === void 0 ? [] : [document.content]);
-  const attributes = {
-    ...document.attributes ?? {},
-    [SSML_ATTRS.VERSION]: document.version,
-    [SSML_ATTRS.XMLNS]: SYNTHESIS_NAMESPACE,
-    [SSML_ATTRS.XML_LANG]: document.lang
-  };
-  if (usesMsttsNamespace(children) && attributes[SSML_ATTRS.MSTTS_XMLNS] === void 0) {
-    attributes[SSML_ATTRS.MSTTS_XMLNS] = MSTTS_NAMESPACE;
-  }
-  return `<${SSML_TAGS.SPEAK}${serializeAttributes(attributes)}>${children.map(serializeNode).join("")}</${SSML_TAGS.SPEAK}>`;
-}
-function buildSsml(documentOrContent, lang = DEFAULT_SSML_LANGUAGE) {
-  if (typeof documentOrContent === "string") {
-    return {
-      version: DEFAULT_SSML_VERSION,
-      lang,
-      content: documentOrContent
-    };
-  }
-  return serializeDocument(documentOrContent);
-}
-var XML_ENTITIES = {
-  amp: "&",
-  apos: "'",
-  gt: ">",
-  lt: "<",
-  quot: '"'
-};
-function hasOwn(object, property) {
-  return Object.getOwnPropertyDescriptor(object, property) !== void 0;
-}
-function setAttribute(attributes, name, value) {
-  Object.defineProperty(attributes, name, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
-}
-function decodeEntity(entity) {
-  const namedValue = hasOwn(XML_ENTITIES, entity) ? XML_ENTITIES[entity] : void 0;
-  if (namedValue !== void 0) {
-    return namedValue;
-  }
-  const isHexadecimal = entity.startsWith("#x") || entity.startsWith("#X");
-  const isDecimal = entity.startsWith("#");
-  if (!isHexadecimal && !isDecimal) {
-    throw new Error(`Unknown XML entity: &${entity};`);
-  }
-  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 decodeXmlEntities(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 += decodeEntity(value.slice(ampersand + 1, semicolon));
-    start = semicolon + 1;
-  }
-}
-function isXmlNameStart(value) {
-  return value !== void 0 && /[A-Za-z_]/.test(value);
-}
-function isXmlNameCharacter(value) {
-  return value !== void 0 && /[A-Za-z0-9_.:-]/.test(value);
-}
-function isXmlWhitespace(value) {
-  return value === " " || value === "	" || value === "\r" || value === "\n";
-}
-function removeStandardNamespaceAttributes(attributes) {
-  if (attributes[SSML_ATTRS.XMLNS] === SYNTHESIS_NAMESPACE) {
-    delete attributes[SSML_ATTRS.XMLNS];
-  }
-  if (attributes[SSML_ATTRS.MSTTS_XMLNS] === MSTTS_NAMESPACE) {
-    delete attributes[SSML_ATTRS.MSTTS_XMLNS];
-  }
-}
-var _index;
-var XmlParser = class {
-  constructor(source) {
-    __privateAdd(this, _index, 0);
-    this.source = source;
-  }
-  parse() {
-    if (this.source.charCodeAt(0) === 65279) {
-      __privateSet(this, _index, __privateGet(this, _index) + 1);
-    }
-    this.skipMisc();
-    if (__privateGet(this, _index) >= this.source.length) {
-      this.fail("SSML input is empty");
-    }
-    if (this.source[__privateGet(this, _index)] !== "<") {
-      this.fail("SSML input must start with an XML element");
-    }
-    const root = this.parseElement(0);
-    this.skipMisc();
-    if (__privateGet(this, _index) !== this.source.length) {
-      this.fail("Unexpected content after the root XML element");
-    }
-    return root;
-  }
-  parseElement(depth) {
-    if (depth > MAX_NESTING_DEPTH) {
-      this.fail("XML nesting depth exceeds the supported limit");
-    }
-    this.expect("<");
-    if (this.source[__privateGet(this, _index)] === "/") {
-      this.fail("Unexpected closing XML element");
-    }
-    const name = this.parseName();
-    const { attributes, selfClosing } = this.parseStartTag();
-    if (selfClosing) {
-      return { name, attributes, children: [] };
-    }
-    const children = [];
-    while (__privateGet(this, _index) < this.source.length) {
-      if (this.source.startsWith("</", __privateGet(this, _index))) {
-        __privateSet(this, _index, __privateGet(this, _index) + 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("<!--", __privateGet(this, _index))) {
-        this.skipComment();
-        continue;
-      }
-      if (this.source.startsWith("<![CDATA[", __privateGet(this, _index))) {
-        this.appendText(children, this.parseCdata());
-        continue;
-      }
-      if (this.source.startsWith("<?", __privateGet(this, _index))) {
-        this.skipProcessingInstruction();
-        continue;
-      }
-      if (this.source.startsWith("<!", __privateGet(this, _index))) {
-        this.fail("Unsupported XML declaration inside an element");
-      }
-      if (this.source[__privateGet(this, _index)] === "<") {
-        children.push(this.parseElement(depth + 1));
-      } else {
-        this.appendText(children, this.parseText());
-      }
-    }
-    this.fail(`Unclosed XML element: <${name}>`);
-  }
-  parseStartTag() {
-    const attributes = {};
-    while (__privateGet(this, _index) < this.source.length) {
-      this.skipWhitespace();
-      if (this.source.startsWith("/>", __privateGet(this, _index))) {
-        __privateSet(this, _index, __privateGet(this, _index) + 2);
-        return { attributes, selfClosing: true };
-      }
-      if (this.source[__privateGet(this, _index)] === ">") {
-        __privateSet(this, _index, __privateGet(this, _index) + 1);
-        return { attributes, selfClosing: false };
-      }
-      const name = this.parseName();
-      this.skipWhitespace();
-      this.expect("=");
-      this.skipWhitespace();
-      const quote = this.source[__privateGet(this, _index)];
-      if (quote !== '"' && quote !== "'") {
-        this.fail(`XML attribute ${name} must use a quoted value`);
-      }
-      __privateSet(this, _index, __privateGet(this, _index) + 1);
-      const valueStart = __privateGet(this, _index);
-      while (__privateGet(this, _index) < this.source.length && this.source[__privateGet(this, _index)] !== quote) {
-        if (this.source[__privateGet(this, _index)] === "<") {
-          this.fail(`Invalid "<" in XML attribute ${name}`);
-        }
-        __privateSet(this, _index, __privateGet(this, _index) + 1);
-      }
-      if (__privateGet(this, _index) >= this.source.length) {
-        this.fail(`Unclosed XML attribute ${name}`);
-      }
-      const value = decodeXmlEntities(this.source.slice(valueStart, __privateGet(this, _index)));
-      __privateSet(this, _index, __privateGet(this, _index) + 1);
-      if (hasOwn(attributes, name)) {
-        this.fail(`Duplicate XML attribute: ${name}`);
-      }
-      setAttribute(attributes, name, value);
-    }
-    this.fail("Unclosed XML start tag");
-  }
-  parseText() {
-    const start = __privateGet(this, _index);
-    while (__privateGet(this, _index) < this.source.length && this.source[__privateGet(this, _index)] !== "<") {
-      __privateSet(this, _index, __privateGet(this, _index) + 1);
-    }
-    const value = this.source.slice(start, __privateGet(this, _index));
-    if (value.includes("]]>")) {
-      this.fail("CDATA termination is not valid in ordinary XML text");
-    }
-    return decodeXmlEntities(value);
-  }
-  parseCdata() {
-    __privateSet(this, _index, __privateGet(this, _index) + "<![CDATA[".length);
-    const end = this.source.indexOf("]]>", __privateGet(this, _index));
-    if (end === -1) {
-      this.fail("Unclosed XML CDATA section");
-    }
-    const value = this.source.slice(__privateGet(this, _index), end);
-    __privateSet(this, _index, end + 3);
-    return value;
-  }
-  skipComment() {
-    __privateSet(this, _index, __privateGet(this, _index) + "<!--".length);
-    const end = this.source.indexOf("-->", __privateGet(this, _index));
-    if (end === -1) {
-      this.fail("Unclosed XML comment");
-    }
-    if (this.source.slice(__privateGet(this, _index), end).includes("--")) {
-      this.fail("XML comments cannot contain consecutive hyphens");
-    }
-    __privateSet(this, _index, end + 3);
-  }
-  skipProcessingInstruction() {
-    __privateSet(this, _index, __privateGet(this, _index) + "<?".length);
-    this.parseName();
-    const end = this.source.indexOf("?>", __privateGet(this, _index));
-    if (end === -1) {
-      this.fail("Unclosed XML processing instruction");
-    }
-    __privateSet(this, _index, end + 2);
-  }
-  skipMisc() {
-    while (__privateGet(this, _index) < this.source.length) {
-      this.skipWhitespace();
-      if (this.source.startsWith("<!--", __privateGet(this, _index))) {
-        this.skipComment();
-        continue;
-      }
-      if (this.source.startsWith("<?", __privateGet(this, _index))) {
-        this.skipProcessingInstruction();
-        continue;
-      }
-      if (this.source.startsWith("<!DOCTYPE", __privateGet(this, _index))) {
-        this.fail("DOCTYPE declarations are not supported");
-      }
-      break;
-    }
-  }
-  parseName() {
-    const first = this.source[__privateGet(this, _index)];
-    if (!isXmlNameStart(first)) {
-      this.fail("Invalid XML name");
-    }
-    const start = __privateGet(this, _index);
-    __privateSet(this, _index, __privateGet(this, _index) + 1);
-    while (isXmlNameCharacter(this.source[__privateGet(this, _index)])) {
-      __privateSet(this, _index, __privateGet(this, _index) + 1);
-    }
-    return this.source.slice(start, __privateGet(this, _index));
-  }
-  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 (isXmlWhitespace(this.source[__privateGet(this, _index)])) {
-      __privateSet(this, _index, __privateGet(this, _index) + 1);
-    }
-  }
-  expect(value) {
-    if (!this.source.startsWith(value, __privateGet(this, _index))) {
-      this.fail(`Expected "${value}"`);
-    }
-    __privateSet(this, _index, __privateGet(this, _index) + value.length);
-  }
-  fail(message) {
-    throw new Error(`${message} at position ${__privateGet(this, _index)}`);
-  }
-};
-_index = /* @__PURE__ */ new WeakMap();
-function readAttribute(attributes, ...names) {
-  let found = false;
-  let value;
-  for (const name of names) {
-    if (hasOwn(attributes, name)) {
-      if (!found) {
-        value = String(attributes[name]);
-        found = true;
-      }
-      delete attributes[name];
-    }
-  }
-  return value;
-}
-function getElementAttributes(node) {
-  const attributes = { ...node.attributes };
-  removeStandardNamespaceAttributes(attributes);
-  return attributes;
-}
-function finishElement(element, node, attributes) {
-  if (node.children.length > 0) {
-    element.children = node.children.map(convertNode);
-  }
-  if (Object.keys(attributes).length > 0) {
-    element.attributes = attributes;
-  }
-  return element;
-}
-function convertElement(node) {
-  const attributes = getElementAttributes(node);
-  switch (node.name) {
-    case SSML_TAGS.VOICE: {
-      const element = { type: SSML_TAGS.VOICE };
-      const name = readAttribute(attributes, SSML_ATTRS.NAME);
-      const effect = readAttribute(attributes, SSML_ATTRS.EFFECT);
-      if (name !== void 0) element.name = name;
-      if (effect !== void 0) element.effect = effect;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.PROSODY: {
-      const element = { type: SSML_TAGS.PROSODY };
-      const rate = readAttribute(attributes, SSML_ATTRS.RATE);
-      const pitch = readAttribute(attributes, SSML_ATTRS.PITCH);
-      const volume = readAttribute(attributes, SSML_ATTRS.VOLUME);
-      const contour = readAttribute(attributes, SSML_ATTRS.CONTOUR);
-      const range = readAttribute(attributes, SSML_ATTRS.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 finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.BREAK: {
-      const element = { type: SSML_TAGS.BREAK };
-      const time = readAttribute(attributes, SSML_ATTRS.TIME);
-      const strength = readAttribute(attributes, SSML_ATTRS.STRENGTH);
-      if (time !== void 0) element.time = time;
-      if (strength !== void 0) element.strength = strength;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.EXPRESS_AS:
-    case SSML_TAGS.EXPRESS_AS_CAMEL:
-    case SSML_TAGS.MSTTS_EXPRESS_AS: {
-      const element = { type: node.name };
-      const style = readAttribute(attributes, SSML_ATTRS.STYLE);
-      const styleDegree = readAttribute(
-        attributes,
-        SSML_ATTRS.STYLE_DEGREE,
-        SSML_ATTRS.STYLE_DEGREE_CAMEL,
-        SSML_ATTRS.STYLE_DEGREE_HYPHEN
-      );
-      const role = readAttribute(attributes, SSML_ATTRS.ROLE);
-      if (style !== void 0) element.style = style;
-      if (styleDegree !== void 0) element.styleDegree = styleDegree;
-      if (role !== void 0) element.role = role;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.SAY_AS:
-    case SSML_TAGS.SAY_AS_CAMEL: {
-      const element = { type: node.name };
-      const interpretAs = readAttribute(attributes, SSML_ATTRS.INTERPRET_AS);
-      const format = readAttribute(attributes, SSML_ATTRS.FORMAT);
-      const detail = readAttribute(attributes, SSML_ATTRS.DETAIL);
-      if (interpretAs !== void 0) element.interpretAs = interpretAs;
-      if (format !== void 0) element.format = format;
-      if (detail !== void 0) element.detail = detail;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.PHONEME: {
-      const element = { type: SSML_TAGS.PHONEME };
-      const alphabet = readAttribute(attributes, SSML_ATTRS.ALPHABET);
-      const ph = readAttribute(attributes, SSML_ATTRS.PH);
-      if (alphabet !== void 0) element.alphabet = alphabet;
-      if (ph !== void 0) element.ph = ph;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.EMPHASIS: {
-      const element = { type: SSML_TAGS.EMPHASIS };
-      const level = readAttribute(attributes, SSML_ATTRS.LEVEL);
-      if (level !== void 0) element.level = level;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.AUDIO: {
-      const element = { type: SSML_TAGS.AUDIO };
-      const src = readAttribute(attributes, SSML_ATTRS.SRC);
-      const desc = readAttribute(attributes, SSML_ATTRS.DESC);
-      const clipBegin = readAttribute(attributes, SSML_ATTRS.CLIP_BEGIN);
-      const clipEnd = readAttribute(attributes, SSML_ATTRS.CLIP_END);
-      const speed = readAttribute(attributes, SSML_ATTRS.SPEED);
-      const repeatCount = readAttribute(attributes, SSML_ATTRS.REPEAT_COUNT);
-      const repeatDuration = readAttribute(attributes, SSML_ATTRS.REPEAT_DURATION);
-      const soundLevel = readAttribute(attributes, SSML_ATTRS.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 finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.SUB: {
-      const element = { type: SSML_TAGS.SUB };
-      const alias = readAttribute(attributes, SSML_ATTRS.ALIAS);
-      if (alias !== void 0) element.alias = alias;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.LANG: {
-      const element = { type: SSML_TAGS.LANG };
-      const lang = readAttribute(attributes, SSML_ATTRS.XML_LANG, SSML_ATTRS.LANG);
-      if (lang !== void 0) element.lang = lang;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MARK: {
-      const element = { type: SSML_TAGS.MARK };
-      const name = readAttribute(attributes, SSML_ATTRS.NAME);
-      if (name !== void 0) element.name = name;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.BOOKMARK: {
-      const element = { type: SSML_TAGS.BOOKMARK };
-      const mark = readAttribute(attributes, SSML_ATTRS.MARK);
-      if (mark !== void 0) element.mark = mark;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.LEXICON: {
-      const element = { type: SSML_TAGS.LEXICON };
-      const uri = readAttribute(attributes, SSML_ATTRS.URI);
-      if (uri !== void 0) element.uri = uri;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.PARAGRAPH: {
-      const element = { type: SSML_TAGS.PARAGRAPH };
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.SENTENCE: {
-      const element = { type: SSML_TAGS.SENTENCE };
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.WORD: {
-      const element = { type: SSML_TAGS.WORD };
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_SILENCE:
-    case SSML_TAGS.SILENCE: {
-      const element = {
-        type: node.name === SSML_TAGS.MSTTS_SILENCE ? SSML_TAGS.MSTTS_SILENCE : SSML_TAGS.SILENCE
-      };
-      const typeValue = readAttribute(attributes, SSML_ATTRS.TYPE);
-      const value = readAttribute(attributes, SSML_ATTRS.VALUE);
-      if (typeValue !== void 0) element.typeValue = typeValue;
-      if (value !== void 0) element.value = value;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_VISEME:
-    case SSML_TAGS.VISEME: {
-      const element = {
-        type: node.name === SSML_TAGS.MSTTS_VISEME ? SSML_TAGS.MSTTS_VISEME : SSML_TAGS.VISEME
-      };
-      const typeValue = readAttribute(attributes, SSML_ATTRS.TYPE);
-      if (typeValue !== void 0) element.typeValue = typeValue;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_AUDIO_DURATION: {
-      const element = { type: SSML_TAGS.MSTTS_AUDIO_DURATION };
-      const value = readAttribute(attributes, SSML_ATTRS.VALUE);
-      if (value !== void 0) element.value = value;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_DIALOG: {
-      const element = { type: SSML_TAGS.MSTTS_DIALOG };
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_TURN: {
-      const element = { type: SSML_TAGS.MSTTS_TURN };
-      const voice = readAttribute(attributes, SSML_ATTRS.VOICE);
-      const speaker = readAttribute(attributes, SSML_ATTRS.SPEAKER);
-      if (voice !== void 0) element.voice = voice;
-      if (speaker !== void 0) element.speaker = speaker;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_BACKGROUND_AUDIO: {
-      const element = { type: SSML_TAGS.MSTTS_BACKGROUND_AUDIO };
-      const src = readAttribute(attributes, SSML_ATTRS.SRC);
-      const volume = readAttribute(attributes, SSML_ATTRS.VOLUME);
-      const fadeIn = readAttribute(attributes, SSML_ATTRS.FADE_IN);
-      const fadeOut = readAttribute(attributes, SSML_ATTRS.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 finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_TTS_EMBEDDING: {
-      const element = { type: SSML_TAGS.MSTTS_TTS_EMBEDDING };
-      const speakerProfileId = readAttribute(attributes, SSML_ATTRS.SPEAKER_PROFILE_ID);
-      if (speakerProfileId !== void 0) element.speakerProfileId = speakerProfileId;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_EMBEDDING: {
-      const element = { type: SSML_TAGS.MSTTS_EMBEDDING };
-      const id = readAttribute(attributes, SSML_ATTRS.ID);
-      const speakerProfileId = readAttribute(attributes, SSML_ATTRS.SPEAKER_PROFILE_ID);
-      if (id !== void 0) element.id = id;
-      if (speakerProfileId !== void 0) element.speakerProfileId = speakerProfileId;
-      return finishElement(element, node, attributes);
-    }
-    case SSML_TAGS.MSTTS_VOICE_CONVERSION: {
-      const element = { type: SSML_TAGS.MSTTS_VOICE_CONVERSION };
-      const url = readAttribute(attributes, SSML_ATTRS.URL);
-      const profile = readAttribute(attributes, SSML_ATTRS.PROFILE);
-      const speakerProfileId = readAttribute(attributes, SSML_ATTRS.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 finishElement(element, node, attributes);
-    }
-    default: {
-      const element = {
-        name: node.name,
-        type: "custom"
-      };
-      return finishElement(element, node, attributes);
-    }
-  }
-}
-function convertNode(node) {
-  return typeof node === "string" ? node : convertElement(node);
-}
-function parseSsml(xmlString) {
-  if (typeof xmlString !== "string") {
-    throw new TypeError("SSML input must be a string");
-  }
-  const root = new XmlParser(xmlString).parse();
-  if (root.name !== SSML_TAGS.SPEAK) {
-    throw new Error(`SSML root element must be <${SSML_TAGS.SPEAK}>, found <${root.name}>`);
-  }
-  const attributes = { ...root.attributes };
-  const version = readAttribute(attributes, SSML_ATTRS.VERSION);
-  const lang = readAttribute(attributes, SSML_ATTRS.XML_LANG, SSML_ATTRS.LANG);
-  if (version === void 0) {
-    throw new Error(`SSML <${SSML_TAGS.SPEAK}> element is missing the "${SSML_ATTRS.VERSION}" attribute`);
-  }
-  if (lang === void 0) {
-    throw new Error(`SSML <${SSML_TAGS.SPEAK}> element is missing the "${SSML_ATTRS.XML_LANG}" attribute`);
-  }
-  removeStandardNamespaceAttributes(attributes);
-  const document = {
-    children: root.children.map(convertNode),
-    lang,
-    type: SSML_TAGS.SPEAK,
-    version
-  };
-  if (Object.keys(attributes).length > 0) {
-    document.attributes = attributes;
-  }
-  return document;
-}
-function escapeAttribute2(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;");
-}
-function getPartialTextNodes(text, version, lang) {
-  if (!text.includes("<")) {
-    return [text];
-  }
-  try {
-    const openingTag = `<${SSML_TAGS.SPEAK} ${SSML_ATTRS.VERSION}="${escapeAttribute2(version)}" ${SSML_ATTRS.XMLNS}="${SYNTHESIS_NAMESPACE}" ${SSML_ATTRS.XML_LANG}="${escapeAttribute2(lang)}">`;
-    return parseSsml(`${openingTag}${text}</${SSML_TAGS.SPEAK}>`).children ?? [];
-  } catch {
-    return [{ type: "text", value: text }];
-  }
-}
-function getVoiceContext(context) {
-  const voice = context.voice;
-  if (typeof voice === "object" && voice !== null) {
-    return voice;
-  }
-  if (context.voiceName === void 0 && context.voiceEffect === void 0 && typeof voice !== "string") {
-    return void 0;
-  }
-  return {
-    name: context.voiceName ?? voice,
-    effect: context.voiceEffect
-  };
-}
-function serializePartialSsml(text, context) {
-  const version = context.version ?? DEFAULT_SSML_VERSION;
-  const lang = context.lang ?? DEFAULT_SSML_LANGUAGE;
-  let children = getPartialTextNodes(text, version, lang);
-  if (context.prosody) {
-    children = [
-      {
-        type: SSML_TAGS.PROSODY,
-        ...context.prosody,
-        children
-      }
-    ];
-  }
-  const voice = getVoiceContext(context);
-  if (voice) {
-    children = [
-      {
-        type: SSML_TAGS.VOICE,
-        ...voice,
-        children
-      }
-    ];
-  }
-  const document = {
-    type: SSML_TAGS.SPEAK,
-    version,
-    lang,
-    attributes: context.attributes,
-    children
-  };
-  return buildSsml(document);
-}
-function buildPartialSsml(textOrOptions, context) {
-  if (typeof textOrOptions === "string") {
-    return serializePartialSsml(textOrOptions, context ?? {});
-  }
-  return serializePartialSsml(textOrOptions.text, textOrOptions);
-}
-var PARSER_POSITION_SUFFIX = / at position (\d+)$/;
-function validateSsml(xmlString) {
-  try {
-    parseSsml(xmlString);
-    return null;
-  } catch (error) {
-    const rawMessage = error instanceof Error ? error.message : String(error);
-    const positionMatch = PARSER_POSITION_SUFFIX.exec(rawMessage);
-    return {
-      message: positionMatch ? rawMessage.slice(0, positionMatch.index) : rawMessage,
-      position: positionMatch ? Number.parseInt(positionMatch[1], 10) : 0
-    };
-  }
-}
-var AZURE_VOICE_DEFINITIONS = [
-  { 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_STRENGTHS = /* @__PURE__ */ new Set(["none", "x-weak", "weak", "medium", "strong", "x-strong"]);
-var ALLOWED_SAY_AS = /* @__PURE__ */ new Set([
-  "characters",
-  "spell-out",
-  "cardinal",
-  "ordinal",
-  "number",
-  "date",
-  "time",
-  "telephone",
-  "fraction",
-  "address",
-  "name",
-  "currency",
-  "number_digit"
-]);
-var ALLOWED_ROLES = /* @__PURE__ */ new Set([
-  "Girl",
-  "Boy",
-  "YoungAdultFemale",
-  "YoungAdultMale",
-  "OlderAdultFemale",
-  "OlderAdultMale",
-  "SeniorFemale",
-  "SeniorMale"
-]);
-var ALLOWED_EMPHASIS_LEVELS = /* @__PURE__ */ new Set(["strong", "moderate", "reduced", "none"]);
-var ALLOWED_SILENCE_TYPES = /* @__PURE__ */ new Set([
-  "Leading",
-  "Tailing",
-  "Sentenceboundary",
-  "Comma",
-  "Semicolon",
-  "Enumerationcomma"
-]);
-var ALLOWED_VISEME_TYPES = /* @__PURE__ */ new Set(["redlips_front", "FacialExpression"]);
-var DEFAULT_PREVIEW_TAGS = /* @__PURE__ */ new Set(["mstts:voiceconversion"]);
-function featureStatusForTag(name, options) {
-  const tagName = canonicalTagName(name);
-  const configured = Object.entries(options.tagStatuses ?? {}).find(
-    ([candidate]) => canonicalTagName(candidate) === tagName
-  )?.[1];
-  if (configured) return configured;
-  if ((options.previewTags ?? [...DEFAULT_PREVIEW_TAGS]).some((candidate) => canonicalTagName(candidate) === tagName))
-    return "preview";
-  if ((options.deprecatedTags ?? []).some((candidate) => canonicalTagName(candidate) === tagName)) return "deprecated";
-  return void 0;
-}
-function decodeAttribute(value) {
-  return value.replace(
-    /&(?:amp|apos|gt|lt|quot);/gi,
-    (entity) => ({ "&amp;": "&", "&apos;": "'", "&gt;": ">", "&lt;": "<", "&quot;": '"' })[entity.toLowerCase()] ?? entity
-  );
-}
-function findTagEnd2(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 tokenizeElements(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 = findTagEnd2(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(), decodeAttribute(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 location(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 addDiagnostic(diagnostics, source, offset, message, severity = "error", code2) {
-  diagnostics.push({
-    ...location(source, offset),
-    message,
-    severity,
-    source: "ssml-static-validator",
-    ...code2 ? { code: code2 } : {}
-  });
-}
-function isSupportedProsodyRate(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 isValidAzureAudioDuration(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 isValidAzureBackgroundAudioDuration(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 attr(token, name) {
-  return token.attributes.get(name.toLowerCase());
-}
-var DEFAULT_LANGUAGE_ALIASES = {
-  "zh-CN": ["zh-Hans"],
-  "zh-TW": ["zh-Hant"]
-};
-function canonicalLanguageTag(language) {
-  const trimmed = language.trim();
-  if (!trimmed) return "";
-  try {
-    return new Intl.Locale(trimmed).toString().toLowerCase();
-  } catch {
-    return trimmed.toLowerCase();
-  }
-}
-function createLanguageNormalizer(options) {
-  const aliases = /* @__PURE__ */ new Map();
-  const addAliasGroup = (canonical, values) => {
-    const normalizedCanonical = canonicalLanguageTag(canonical);
-    if (!normalizedCanonical) return;
-    aliases.set(normalizedCanonical, normalizedCanonical);
-    for (const value of values) {
-      const normalizedValue = canonicalLanguageTag(value);
-      if (normalizedValue) aliases.set(normalizedValue, normalizedCanonical);
-    }
-  };
-  for (const [canonical, values] of Object.entries(DEFAULT_LANGUAGE_ALIASES)) 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 = canonicalLanguageTag(customValue);
-    return aliases.get(normalized) ?? normalized;
-  };
-}
-function voiceLocalePrefix(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 definitionFromStyleMap(voiceName, styles) {
-  return {
-    name: voiceName,
-    locale: voiceLocalePrefix(voiceName)?.tag ?? "",
-    styles
-  };
-}
-function normalizeVoiceCatalog(options) {
-  const definitions = /* @__PURE__ */ new Map();
-  for (const definition of AZURE_VOICE_DEFINITIONS) 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 ?? definitionFromStyleMap(voiceName, styles),
-      name: current?.name ?? voiceName,
-      styles: styles.map((style) => style.toLowerCase())
-    });
-  }
-  return definitions;
-}
-function diagnosticSeverity(policy) {
-  if (policy === "ignore") return void 0;
-  return policy === "error" ? "error" : "warning";
-}
-function languagePart(language) {
-  try {
-    return new Intl.Locale(language).language.toLowerCase();
-  } catch {
-    return language.split("-")[0]?.toLowerCase() ?? "";
-  }
-}
-function definitionMatchesLanguage(definition, voiceName, language, normalizeLanguage) {
-  const candidateLanguages = definition ? [definition.locale, ...definition.secondaryLocales ?? []].filter(Boolean) : [voiceLocalePrefix(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 === languagePart(normalizedLanguage) ? normalizedCandidates.some((candidate) => languagePart(candidate) === normalizedLanguage) : false;
-}
-function canonicalTagName(name) {
-  const normalized = name.toLowerCase();
-  if (normalized === "express-as" || normalized === "expressas") return "mstts:express-as";
-  if (normalized === "sayas") return "say-as";
-  return normalized;
-}
-function validateVoiceFeatureMatrix(token, source, diagnostics, voiceName, definition) {
-  if (!voiceName || !definition || token.name.toLowerCase() === "voice" || token.name.toLowerCase() === "mstts:turn")
-    return;
-  const tagName = canonicalTagName(token.name);
-  const unsupportedTags = new Set((definition.unsupportedTags ?? []).map(canonicalTagName));
-  const supportedTags = definition.supportedTags?.map(canonicalTagName);
-  if (unsupportedTags.has(tagName) || supportedTags !== void 0 && !supportedTags.includes(tagName)) {
-    addDiagnostic(
-      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 validateAudioSource(token, source, diagnostics, options, elementName2) {
-  const src = attr(token, "src");
-  if (!src) {
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2}> requires a "src" attribute.`);
-    return;
-  }
-  let parsed;
-  try {
-    parsed = new URL(src);
-  } catch {
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must be an absolute HTTP(S) URL.`);
-    return;
-  }
-  if (parsed.username || parsed.password)
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must not contain URL credentials.`);
-  if (parsed.protocol !== "https:" && !(options.allowHttpAudio && parsed.protocol === "http:"))
-    addDiagnostic(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)
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> origin "${parsed.origin}" is not allowed.`);
-  else if (!isAllowedOrigin && !options.allowExternalAudio)
-    addDiagnostic(
-      diagnostics,
-      source,
-      token.start,
-      `<${elementName2} src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`
-    );
-}
-function validateElement(token, source, diagnostics, voiceName, options, voiceCatalog) {
-  const name = token.name.toLowerCase();
-  const tagStatus = featureStatusForTag(token.name, options);
-  if (tagStatus === "preview")
-    addDiagnostic(
-      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")
-    addDiagnostic(
-      diagnostics,
-      source,
-      token.start,
-      `<${token.name}> is deprecated by Azure Speech; migrate to a supported alternative.`,
-      "info",
-      "azure-deprecated-tag"
-    );
-  if (name === "voice" && !attr(token, "name")?.trim())
-    addDiagnostic(diagnostics, source, token.start, '<voice> requires a non-empty "name" attribute.');
-  if (name === "break") {
-    const time = attr(token, "time");
-    const strength = attr(token, "strength");
-    if (!time && !strength)
-      addDiagnostic(diagnostics, source, token.start, '<break> requires either "time" or "strength".');
-    if (time && strength)
-      addDiagnostic(diagnostics, source, token.start, '<break> must not specify both "time" and "strength".');
-    if (time && !/^\d+(?:\.\d+)?(?:ms|s)$/.test(time.trim()))
-      addDiagnostic(diagnostics, source, token.start, '<break time> must use a numeric value followed by "ms" or "s".');
-    if (strength && !ALLOWED_BREAK_STRENGTHS.has(strength))
-      addDiagnostic(diagnostics, source, token.start, `Unsupported <break strength> value "${strength}".`);
-  }
-  if (name === "prosody") {
-    const rate = attr(token, "rate");
-    const pitch = attr(token, "pitch");
-    const volume = attr(token, "volume");
-    if (rate && !isSupportedProsodyRate(rate))
-      addDiagnostic(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()))
-      addDiagnostic(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()))
-      addDiagnostic(diagnostics, source, token.start, `Unsupported <prosody volume> value "${volume}".`);
-  }
-  if (name === "mstts:express-as" || name === "express-as" || name === "expressas") {
-    const style = attr(token, "style");
-    if (!style?.trim())
-      addDiagnostic(diagnostics, source, token.start, '<mstts:express-as> requires a non-empty "style" attribute.');
-    const degree = attr(token, "styledegree") ?? attr(token, "style-degree");
-    if (degree && (!/^\d+(?:\.\d+)?$/.test(degree) || Number(degree) < 0.01 || Number(degree) > 2))
-      addDiagnostic(
-        diagnostics,
-        source,
-        token.start,
-        "<mstts:express-as styledegree> must be a number between 0.01 and 2."
-      );
-    const role = attr(token, "role");
-    if (role && !ALLOWED_ROLES.has(role))
-      addDiagnostic(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 = diagnosticSeverity(options.unsupportedStylePolicy ?? options.unknownVoicePolicy ?? "warn");
-    if (style && definition && !supportedStyles?.some((candidate) => candidate.toLowerCase() === style.toLowerCase()) && severity)
-      addDiagnostic(
-        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)
-      addDiagnostic(
-        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 = attr(token, "interpret-as");
-    if (!interpretAs || !ALLOWED_SAY_AS.has(interpretAs))
-      addDiagnostic(diagnostics, source, token.start, `<say-as> requires a supported "interpret-as" value.`);
-  }
-  if (name === "phoneme" && (!attr(token, "alphabet") || !attr(token, "ph")))
-    addDiagnostic(diagnostics, source, token.start, '<phoneme> requires both "alphabet" and "ph" attributes.');
-  if (name === "emphasis" && attr(token, "level") && !ALLOWED_EMPHASIS_LEVELS.has(attr(token, "level") ?? ""))
-    addDiagnostic(diagnostics, source, token.start, `Unsupported <emphasis level> value "${attr(token, "level")}".`);
-  if (name === "sub" && !attr(token, "alias")?.trim())
-    addDiagnostic(diagnostics, source, token.start, '<sub> requires a non-empty "alias" attribute.');
-  if (name === "lang" && !attr(token, "xml:lang")?.trim() && !attr(token, "lang")?.trim())
-    addDiagnostic(diagnostics, source, token.start, '<lang> requires an "xml:lang" attribute.');
-  if (name === "mark" && !attr(token, "name")?.trim())
-    addDiagnostic(diagnostics, source, token.start, '<mark> requires a non-empty "name" attribute.');
-  if (name === "bookmark" && !attr(token, "mark")?.trim())
-    addDiagnostic(diagnostics, source, token.start, '<bookmark> requires a non-empty "mark" attribute.');
-  if (name === "lexicon") {
-    const uri = attr(token, "uri");
-    if (!uri) addDiagnostic(diagnostics, source, token.start, '<lexicon> requires a "uri" attribute.');
-    else {
-      try {
-        const parsed = new URL(uri);
-        if (parsed.protocol !== "https:")
-          addDiagnostic(diagnostics, source, token.start, "<lexicon uri> must use HTTPS.");
-      } catch {
-        addDiagnostic(diagnostics, source, token.start, "<lexicon uri> must be an absolute HTTPS URL.");
-      }
-    }
-  }
-  if (name === "mstts:silence") {
-    const type = attr(token, "type");
-    const value = attr(token, "value");
-    if (!type || !ALLOWED_SILENCE_TYPES.has(type))
-      addDiagnostic(diagnostics, source, token.start, '<mstts:silence> requires a supported "type" attribute.');
-    if (!value || !/^\d+(?:\.\d+)?(?:ms|s)$/.test(value.trim()))
-      addDiagnostic(diagnostics, source, token.start, '<mstts:silence> requires a time-valued "value" attribute.');
-  }
-  if (name === "mstts:audioduration") {
-    const value = attr(token, "value");
-    if (!value || !isValidAzureAudioDuration(value))
-      addDiagnostic(
-        diagnostics,
-        source,
-        token.start,
-        '<mstts:audioduration> requires a positive duration such as "10s", "5000ms", or "00:00:10".'
-      );
-    if (!token.selfClosing)
-      addDiagnostic(diagnostics, source, token.start, "<mstts:audioduration> must be self-closing.");
-  }
-  if (name === "mstts:viseme") {
-    const type = attr(token, "type");
-    if (!type || !ALLOWED_VISEME_TYPES.has(type))
-      addDiagnostic(diagnostics, source, token.start, '<mstts:viseme> requires a supported "type" attribute.');
-  }
-  if (name === "audio") {
-    validateAudioSource(token, source, diagnostics, options, "audio");
-  }
-  if (name === "mstts:turn") {
-    if (!attr(token, "voice")?.trim() && !attr(token, "speaker")?.trim())
-      addDiagnostic(
-        diagnostics,
-        source,
-        token.start,
-        '<mstts:turn> requires a non-empty "voice" or "speaker" attribute.'
-      );
-    if (token.parentName?.toLowerCase() !== "mstts:dialog")
-      addDiagnostic(diagnostics, source, token.start, "<mstts:turn> is only allowed directly inside <mstts:dialog>.");
-  }
-  if (name === "mstts:backgroundaudio") {
-    validateAudioSource(token, source, diagnostics, options, "mstts:backgroundaudio");
-    const volume = attr(token, "volume");
-    if (volume !== void 0 && (!/^\d+(?:\.\d+)?$/.test(volume.trim()) || Number(volume) > 100))
-      addDiagnostic(diagnostics, source, token.start, `Unsupported <mstts:backgroundaudio volume> value "${volume}".`);
-    for (const [attribute, value] of [
-      ["fadein", attr(token, "fadein")],
-      ["fadeout", attr(token, "fadeout")]
-    ]) {
-      if (value !== void 0 && !isValidAzureBackgroundAudioDuration(value))
-        addDiagnostic(
-          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)
-      addDiagnostic(
-        diagnostics,
-        source,
-        token.start,
-        "<mstts:backgroundaudio> must be the first element directly under <speak>."
-      );
-    if (!token.selfClosing)
-      addDiagnostic(diagnostics, source, token.start, "<mstts:backgroundaudio> must be self-closing.");
-  }
-}
-function validateAzureSsml(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)
-    addDiagnostic(diagnostics, ssml, maxLength, `SSML exceeds the maximum length of ${maxLength} characters.`);
-  if (options.maxXmlDepth !== void 0 && (!Number.isInteger(options.maxXmlDepth) || options.maxXmlDepth <= 0)) {
-    addDiagnostic(diagnostics, ssml, 0, "maxXmlDepth must be a positive integer.");
-  }
-  try {
-    parseSsml(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 : "");
-    addDiagnostic(diagnostics, ssml, match ? Number(match[1]) : 0, message);
-    return diagnostics;
-  }
-  const tokens = tokenizeElements(ssml);
-  if (options.maxXmlDepth !== void 0) {
-    for (const token of tokens) {
-      if (token.depth > options.maxXmlDepth) {
-        addDiagnostic(
-          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)
-      addDiagnostic(
-        diagnostics,
-        ssml,
-        token.start,
-        "An SSML document can contain at most one <mstts:backgroundaudio> element."
-      );
-  }
-  if (!speak || voices.length === 0)
-    addDiagnostic(
-      diagnostics,
-      ssml,
-      speak?.start ?? 0,
-      "Azure SSML requires at least one <voice> element under <speak>."
-    );
-  const voiceName = voices[0] ? attr(voices[0], "name") : void 0;
-  const voiceCatalog = normalizeVoiceCatalog(options);
-  const normalizeLanguage = createLanguageNormalizer(options);
-  const policySeverity = diagnosticSeverity(options.unknownVoicePolicy ?? "warn");
-  const voicesToValidate = options.validateNestedVoices === false ? voices.slice(0, 1) : voices;
-  for (const token of voicesToValidate) {
-    const name = attr(token, "name")?.trim();
-    const language = attr(token, "xml:lang")?.trim() || (speak ? attr(speak, "xml:lang")?.trim() : void 0);
-    const definition = name ? voiceCatalog.get(name.toLowerCase()) : void 0;
-    if (name && definition?.status === "preview")
-      addDiagnostic(
-        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")
-      addDiagnostic(
-        diagnostics,
-        ssml,
-        token.start,
-        `Voice "${name}" is deprecated by Azure Speech; migrate to a supported voice.`,
-        "info",
-        "azure-deprecated-voice"
-      );
-    if (name && !definition && policySeverity)
-      addDiagnostic(
-        diagnostics,
-        ssml,
-        token.start,
-        `Unknown voice "${name}" is not registered in the voice catalog.`,
-        policySeverity,
-        "azure-unknown-voice"
-      );
-    if (name && language && definitionMatchesLanguage(definition, name, language, normalizeLanguage) === false)
-      addDiagnostic(
-        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" ? attr(token, "name")?.trim() : tokenName === "mstts:turn" ? attr(token, "voice")?.trim() || token.parentVoiceName : options.validateNestedVoices === false ? voiceName : token.parentVoiceName;
-    validateElement(token, ssml, diagnostics, tokenVoiceName, options, voiceCatalog);
-    const definition = tokenVoiceName ? voiceCatalog.get(tokenVoiceName.toLowerCase()) : void 0;
-    validateVoiceFeatureMatrix(token, ssml, diagnostics, tokenVoiceName, definition);
-    if (tokenName === "voice" && options.model && definition?.models && !definition.models.some((model) => model.toLowerCase() === options.model?.toLowerCase())) {
-      addDiagnostic(
-        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;
-}
-var AZURE_VOICE_CATALOG_METADATA = {
-  apiVersion: "2025-10-01",
-  generatedAt: "2026-08-28T00:00:00.000Z",
-  regions: [],
-  voiceCount: AZURE_VOICE_DEFINITIONS.length
-};
-
 // packages/ssml-editor-react/src/clearSsmlDocument.ts
 function getDocumentChildren(document) {
   return document.children ?? (document.content === void 0 ? [] : [document.content]);
@@ -3069,30 +1599,30 @@ var INTRINSICALLY_EMPTY_ELEMENTS = /* @__PURE__ */ new Set([
   "silence",
   "viseme"
 ]);
-function isXmlNameStart2(value) {
+function isXmlNameStart(value) {
   return value !== void 0 && /[A-Za-z_]/.test(value);
 }
-function isXmlNameCharacter2(value) {
+function isXmlNameCharacter(value) {
   return value !== void 0 && /[A-Za-z0-9_.:-]/.test(value);
 }
-function isXmlWhitespace2(value) {
+function isXmlWhitespace(value) {
   return value === " " || value === "	" || value === "\r" || value === "\n";
 }
 function fail(message) {
   throw new Error(message);
 }
 function skipWhitespace(source, index) {
-  while (isXmlWhitespace2(source[index])) {
+  while (isXmlWhitespace(source[index])) {
     index += 1;
   }
   return index;
 }
 function readName(source, start, end) {
-  if (!isXmlNameStart2(source[start])) {
+  if (!isXmlNameStart(source[start])) {
     fail("Invalid XML name");
   }
   let index = start + 1;
-  while (index < end && isXmlNameCharacter2(source[index])) {
+  while (index < end && isXmlNameCharacter(source[index])) {
     index += 1;
   }
   return { name: source.slice(start, index), index };
@@ -3128,7 +1658,7 @@ function validateEntityReferences(value) {
     index = semicolon + 1;
   }
 }
-function findTagEnd3(source, start, hasInternalSubset = false) {
+function findTagEnd2(source, start, hasInternalSubset = false) {
   let quote;
   let subsetDepth = 0;
   for (let index = start + 1; index < source.length; index += 1) {
@@ -3301,7 +1831,7 @@ function parseXml(source) {
       continue;
     }
     if (source.startsWith("</", index)) {
-      const end2 = findTagEnd3(source, index);
+      const end2 = findTagEnd2(source, index);
       const name2 = parseClosingTag(source, index, end2);
       const element = currentElement(stack);
       if (element === void 0 || element.name !== name2) {
@@ -3313,7 +1843,7 @@ function parseXml(source) {
       continue;
     }
     if (source.startsWith("<!", index)) {
-      const end2 = findTagEnd3(source, index, true);
+      const end2 = findTagEnd2(source, index, true);
       parseDeclaration(source, index, end2);
       appendNode2(currentElement(stack)?.children ?? children, {
         kind: "declaration",
@@ -3322,7 +1852,7 @@ function parseXml(source) {
       index = end2 + 1;
       continue;
     }
-    const end = findTagEnd3(source, index);
+    const end = findTagEnd2(source, index);
     const { name, selfClosing } = parseStartTag(source, index, end);
     if (stack.length === 0) {
       if (root !== void 0) {
@@ -4243,13 +2773,13 @@ for (const definition of SSML_TAG_DEFINITIONS) {
     definitionsByName.set(alias, definition);
   }
 }
-function isXmlNameStart3(value) {
+function isXmlNameStart2(value) {
   return value !== void 0 && /[A-Za-z_]/.test(value);
 }
-function isXmlNameCharacter3(value) {
+function isXmlNameCharacter2(value) {
   return value !== void 0 && /[A-Za-z0-9_.:-]/.test(value);
 }
-function isXmlWhitespace3(value) {
+function isXmlWhitespace2(value) {
   return value === " " || value === "	" || value === "\r" || value === "\n";
 }
 function positionToOffset(source, lineNumber, column) {
@@ -4292,7 +2822,7 @@ function toRange(source, token) {
 function containsOffset(token, offset) {
   return offset >= token.start && offset < token.end;
 }
-function findTagEnd4(source, start) {
+function findTagEnd3(source, start) {
   let quote;
   for (let index = start; index < source.length; index += 1) {
     const character = source[index];
@@ -4315,44 +2845,44 @@ function parseTag(source, start, contentEnd, tokenEnd) {
     closing = true;
     index += 1;
   }
-  while (index < contentEnd && isXmlWhitespace3(source[index])) {
+  while (index < contentEnd && isXmlWhitespace2(source[index])) {
     index += 1;
   }
-  if (!isXmlNameStart3(source[index])) {
+  if (!isXmlNameStart2(source[index])) {
     return void 0;
   }
   const nameStart = index;
   index += 1;
-  while (index < contentEnd && isXmlNameCharacter3(source[index])) {
+  while (index < contentEnd && isXmlNameCharacter2(source[index])) {
     index += 1;
   }
   const nameEnd = index;
   const attributes = [];
   if (!closing) {
     while (index < contentEnd) {
-      while (index < contentEnd && isXmlWhitespace3(source[index])) {
+      while (index < contentEnd && isXmlWhitespace2(source[index])) {
         index += 1;
       }
       if (index >= contentEnd || source[index] === "/") {
         break;
       }
-      if (!isXmlNameStart3(source[index])) {
+      if (!isXmlNameStart2(source[index])) {
         index += 1;
         continue;
       }
       const attributeStart = index;
       index += 1;
-      while (index < contentEnd && isXmlNameCharacter3(source[index])) {
+      while (index < contentEnd && isXmlNameCharacter2(source[index])) {
         index += 1;
       }
       const attributeEnd = index;
-      while (index < contentEnd && isXmlWhitespace3(source[index])) {
+      while (index < contentEnd && isXmlWhitespace2(source[index])) {
         index += 1;
       }
       let value;
       if (source[index] === "=") {
         index += 1;
-        while (index < contentEnd && isXmlWhitespace3(source[index])) {
+        while (index < contentEnd && isXmlWhitespace2(source[index])) {
           index += 1;
         }
         const quote = source[index];
@@ -4368,7 +2898,7 @@ function parseTag(source, start, contentEnd, tokenEnd) {
           }
         } else {
           const valueStart = index;
-          while (index < contentEnd && !isXmlWhitespace3(source[index]) && source[index] !== "/") {
+          while (index < contentEnd && !isXmlWhitespace2(source[index]) && source[index] !== "/") {
             index += 1;
           }
           value = { start: valueStart, end: index };
@@ -4423,7 +2953,7 @@ function findTagAtOffset(source, offset) {
       searchStart = tokenEnd2;
       continue;
     }
-    const tagEnd = findTagEnd4(source, start + 1);
+    const tagEnd = findTagEnd3(source, start + 1);
     const contentEnd = tagEnd ?? source.length;
     const tokenEnd = tagEnd === void 0 ? source.length : tagEnd + 1;
     if (offset < tokenEnd) {
@@ -4562,17 +3092,13 @@ export {
   SAY_AS_DESCRIPTIONS,
   LANGUAGE_DESCRIPTIONS,
   SILENCE_VALUE_DESCRIPTIONS,
+  SSML_ELEMENT_COPY,
   EDITOR_COPY,
   INLINE_BADGE_COPY,
   SSML_HOVER_COPY,
   DEFAULT_LOCALE,
   OVERLAY_Z_INDEX,
   SELECTION_OVERLAY_ABOVE_THRESHOLD_LINES,
-  buildSsml,
-  parseSsml,
-  buildPartialSsml,
-  validateSsml,
-  validateAzureSsml,
   clearSsmlDocument,
   formatXmlFragment,
   getEditableRegion,
@@ -4586,4 +3112,4 @@ export {
   findSsmlHoverTarget,
   formatSsmlHover
 };
-//# sourceMappingURL=chunk-FHDFRM2F.mjs.map
+//# sourceMappingURL=chunk-LCTE26LS.mjs.map