ssml-builder-js 1.0.0

package/dist/index.js

@@ -0,0 +1,1054 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AzureTtsClient: () => AzureTtsClient,
+  AzureTtsError: () => AzureTtsError,
+  AzureTtsSdkError: () => AzureTtsSdkError,
+  buildPartialSsml: () => buildPartialSsml,
+  buildSsml: () => buildSsml,
+  parseSsml: () => parseSsml,
+  synthesizeSpeech: () => synthesizeSpeech,
+  validateSsml: () => validateSsml
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/ssml-core/src/constants/ssml.ts
+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"
+};
+var SSML_ATTRS = {
+  VERSION: "version",
+  XMLNS: "xmlns",
+  XML_LANG: "xml:lang",
+  LANG: "lang",
+  MSTTS_XMLNS: "xmlns:mstts",
+  NAME: "name",
+  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",
+  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",
+  TYPE: "type",
+  VALUE: "value"
+};
+
+// packages/ssml-core/src/builder.ts
+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.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 "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);
+}
+
+// packages/ssml-core/src/parser.ts
+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 = 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);
+      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);
+    }
+    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;
+}
+
+// packages/ssml-core/src/partial.ts
+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);
+}
+
+// packages/ssml-core/src/validation.ts
+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
+    };
+  }
+}
+
+// packages/azure-tts-client/src/errors.ts
+var AzureTtsError = class extends Error {
+  constructor(status, statusText, responseBody, requestId) {
+    super(`Azure TTS request failed: ${status} ${statusText}`);
+    this.name = "AzureTtsError";
+    this.status = status;
+    this.statusText = statusText;
+    this.responseBody = responseBody;
+    this.requestId = requestId;
+  }
+};
+var AzureTtsSdkError = class extends AzureTtsError {
+  constructor(errorDetails) {
+    super(0, "Speech SDK", errorDetails, null);
+    this.name = "AzureTtsSdkError";
+    this.message = `Azure TTS synthesis failed: ${errorDetails}`;
+    this.errorDetails = errorDetails;
+  }
+};
+function createSpeechSdkError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new AzureTtsSdkError(message);
+}
+
+// packages/azure-tts-client/src/synthesis.ts
+var SpeechSDK2 = __toESM(require("microsoft-cognitiveservices-speech-sdk"));
+
+// packages/azure-tts-client/src/speechConfig.ts
+var import_microsoft_cognitiveservices_speech_sdk = require("microsoft-cognitiveservices-speech-sdk");
+
+// packages/azure-tts-client/src/outputFormats.ts
+var SpeechSDK = __toESM(require("microsoft-cognitiveservices-speech-sdk"));
+var DEFAULT_OUTPUT_FORMAT = "audio-16khz-128kbitrate-mono-mp3";
+var OUTPUT_FORMATS = {
+  "raw-8khz-8bit-mono-mulaw": SpeechSDK.SpeechSynthesisOutputFormat.Raw8Khz8BitMonoMULaw,
+  "riff-16khz-16kbps-mono-siren": SpeechSDK.SpeechSynthesisOutputFormat.Riff16Khz16KbpsMonoSiren,
+  "audio-16khz-16kbps-mono-siren": SpeechSDK.SpeechSynthesisOutputFormat.Audio16Khz16KbpsMonoSiren,
+  "audio-16khz-32kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio16Khz32KBitRateMonoMp3,
+  "audio-16khz-128kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio16Khz128KBitRateMonoMp3,
+  "audio-16khz-64kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio16Khz64KBitRateMonoMp3,
+  "audio-24khz-48kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio24Khz48KBitRateMonoMp3,
+  "audio-24khz-96kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio24Khz96KBitRateMonoMp3,
+  "audio-24khz-160kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio24Khz160KBitRateMonoMp3,
+  "raw-16khz-16bit-mono-truesilk": SpeechSDK.SpeechSynthesisOutputFormat.Raw16Khz16BitMonoTrueSilk,
+  "riff-16khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Riff16Khz16BitMonoPcm,
+  "riff-8khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Riff8Khz16BitMonoPcm,
+  "riff-24khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Riff24Khz16BitMonoPcm,
+  "riff-8khz-8bit-mono-mulaw": SpeechSDK.SpeechSynthesisOutputFormat.Riff8Khz8BitMonoMULaw,
+  "raw-16khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Raw16Khz16BitMonoPcm,
+  "raw-24khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Raw24Khz16BitMonoPcm,
+  "raw-8khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Raw8Khz16BitMonoPcm,
+  "ogg-16khz-16bit-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Ogg16Khz16BitMonoOpus,
+  "ogg-24khz-16bit-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Ogg24Khz16BitMonoOpus,
+  "raw-48khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Raw48Khz16BitMonoPcm,
+  "riff-48khz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Riff48Khz16BitMonoPcm,
+  "audio-48khz-96kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio48Khz96KBitRateMonoMp3,
+  "audio-48khz-192kbitrate-mono-mp3": SpeechSDK.SpeechSynthesisOutputFormat.Audio48Khz192KBitRateMonoMp3,
+  "ogg-48khz-16bit-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Ogg48Khz16BitMonoOpus,
+  "webm-16khz-16bit-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Webm16Khz16BitMonoOpus,
+  "webm-24khz-16bit-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Webm24Khz16BitMonoOpus,
+  "webm-24khz-16bit-24kbps-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Webm24Khz16Bit24KbpsMonoOpus,
+  "raw-24khz-16bit-mono-truesilk": SpeechSDK.SpeechSynthesisOutputFormat.Raw24Khz16BitMonoTrueSilk,
+  "raw-8khz-8bit-mono-alaw": SpeechSDK.SpeechSynthesisOutputFormat.Raw8Khz8BitMonoALaw,
+  "riff-8khz-8bit-mono-alaw": SpeechSDK.SpeechSynthesisOutputFormat.Riff8Khz8BitMonoALaw,
+  "audio-16khz-16bit-32kbps-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Audio16Khz16Bit32KbpsMonoOpus,
+  "audio-24khz-16bit-48kbps-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Audio24Khz16Bit48KbpsMonoOpus,
+  "audio-24khz-16bit-24kbps-mono-opus": SpeechSDK.SpeechSynthesisOutputFormat.Audio24Khz16Bit24KbpsMonoOpus,
+  "raw-22050hz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Raw22050Hz16BitMonoPcm,
+  "riff-22050hz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Riff22050Hz16BitMonoPcm,
+  "raw-44100hz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Raw44100Hz16BitMonoPcm,
+  "riff-44100hz-16bit-mono-pcm": SpeechSDK.SpeechSynthesisOutputFormat.Riff44100Hz16BitMonoPcm,
+  "amr-wb-16000hz": SpeechSDK.SpeechSynthesisOutputFormat.AmrWb16000Hz,
+  "g722-16khz-64kbps": SpeechSDK.SpeechSynthesisOutputFormat.G72216Khz64Kbps
+};
+function resolveOutputFormat(outputFormat) {
+  const resolvedFormat = OUTPUT_FORMATS[outputFormat];
+  if (resolvedFormat === void 0) {
+    throw new Error(`Unsupported Azure Speech output format: ${outputFormat}`);
+  }
+  return resolvedFormat;
+}
+
+// packages/azure-tts-client/src/speechConfig.ts
+function resolveEndpoint(config) {
+  return config.endpoint.replace(/\{region\}/g, encodeURIComponent(config.region));
+}
+function createSpeechConfig(config) {
+  const { outputFormat = DEFAULT_OUTPUT_FORMAT, subscriptionKey } = config;
+  const endpoint = new URL(resolveEndpoint(config));
+  const speechConfig = import_microsoft_cognitiveservices_speech_sdk.SpeechConfig.fromEndpoint(endpoint, subscriptionKey);
+  speechConfig.speechSynthesisOutputFormat = resolveOutputFormat(outputFormat);
+  return speechConfig;
+}
+
+// packages/azure-tts-client/src/synthesis.ts
+function closeSpeechResources(speechConfig, synthesizer) {
+  try {
+    synthesizer.close();
+  } catch {
+  }
+  try {
+    speechConfig.close();
+  } catch {
+  }
+}
+async function synthesizeSpeech(ssml, config) {
+  const speechConfig = createSpeechConfig(config);
+  const synthesizer = new SpeechSDK2.SpeechSynthesizer(speechConfig, null);
+  return await new Promise((resolve, reject) => {
+    let resourcesClosed = false;
+    const closeResources = () => {
+      if (resourcesClosed) return;
+      resourcesClosed = true;
+      closeSpeechResources(speechConfig, synthesizer);
+    };
+    const rejectWithError = (error) => {
+      closeResources();
+      reject(createSpeechSdkError(error));
+    };
+    const cb = (result) => {
+      const { reason, errorDetails } = result;
+      if (reason !== SpeechSDK2.ResultReason.SynthesizingAudioCompleted) {
+        const err = errorDetails || `Speech synthesis failed with reason ${reason}.`;
+        rejectWithError(err);
+        return;
+      }
+      closeResources();
+      resolve(result.audioData);
+    };
+    try {
+      synthesizer.speakSsmlAsync(ssml, cb, rejectWithError);
+    } catch (error) {
+      rejectWithError(error);
+    }
+  });
+}
+
+// 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 } = __privateGet(this, _options);
+    const endpoint = __privateGet(this, _options).endpoint ?? ENDPOINT_TEMPLATE.replace("{region}", region);
+    console.debug("Using Azure TTS endpoint:", endpoint);
+    const config = { endpoint, region, subscriptionKey, outputFormat };
+    return synthesizeSpeech(ssml, config);
+  }
+};
+_options = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AzureTtsClient,
+  AzureTtsError,
+  AzureTtsSdkError,
+  buildPartialSsml,
+  buildSsml,
+  parseSsml,
+  synthesizeSpeech,
+  validateSsml
+});
+//# sourceMappingURL=index.js.map