ssml-builder-js 1.0.0

package/dist/react.js

@@ -0,0 +1,4402 @@
+"use strict";
+"use client";
+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 __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);
+
+// src/react.tsx
+var react_exports = {};
+__export(react_exports, {
+  EDITOR_COPY: () => EDITOR_COPY,
+  INLINE_BADGE_COPY: () => INLINE_BADGE_COPY,
+  SSML_HOVER_COPY: () => SSML_HOVER_COPY,
+  SSML_INSERTIONS: () => SSML_INSERTIONS,
+  SsmlEditor: () => SsmlEditor,
+  createSsmlEditorInsertionDefinition: () => createSsmlEditorInsertionDefinition
+});
+module.exports = __toCommonJS(react_exports);
+
+// packages/ssml-editor-react/src/SsmlEditor.tsx
+var import_react = require("react");
+var import_react2 = __toESM(require("@monaco-editor/react"));
+var import_react_dom = require("react-dom");
+
+// 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"
+};
+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"
+};
+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(document2) {
+  const children = document2.children ?? (document2.content === void 0 ? [] : [document2.content]);
+  const attributes = {
+    ...document2.attributes ?? {},
+    [SSML_ATTRS.VERSION]: document2.version,
+    [SSML_ATTRS.XMLNS]: SYNTHESIS_NAMESPACE,
+    [SSML_ATTRS.XML_LANG]: document2.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);
+      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 document2 = {
+    children: root.children.map(convertNode),
+    lang,
+    type: SSML_TAGS.SPEAK,
+    version
+  };
+  if (Object.keys(attributes).length > 0) {
+    document2.attributes = attributes;
+  }
+  return document2;
+}
+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 document2 = {
+    type: SSML_TAGS.SPEAK,
+    version,
+    lang,
+    attributes: context.attributes,
+    children
+  };
+  return buildSsml(document2);
+}
+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
+    };
+  }
+}
+
+// packages/ssml-editor-react/src/buttonVisibility.ts
+function isSsmlEditorButtonVisible(buttonVisibility, button) {
+  return buttonVisibility?.[button] !== false;
+}
+
+// packages/ssml-editor-react/src/clearSsmlDocument.ts
+function getDocumentChildren(document2) {
+  return document2.children ?? (document2.content === void 0 ? [] : [document2.content]);
+}
+function appendNode(nodes, node) {
+  if (typeof node === "string") {
+    const lastNode = nodes[nodes.length - 1];
+    if (typeof lastNode === "string") {
+      nodes[nodes.length - 1] = lastNode + node;
+    } else if (node !== "") {
+      nodes.push(node);
+    }
+    return;
+  }
+  nodes.push(node);
+}
+function clearNodes(nodes) {
+  const clearedNodes = [];
+  for (const node of nodes) {
+    if (typeof node === "string") {
+      appendNode(clearedNodes, node);
+      continue;
+    }
+    if (node.type === "text") {
+      appendNode(clearedNodes, node.value);
+      continue;
+    }
+    const children = clearNodes(node.children ?? []);
+    if (node.type === "voice") {
+      appendNode(clearedNodes, { ...node, children });
+      continue;
+    }
+    for (const child of children) {
+      appendNode(clearedNodes, child);
+    }
+  }
+  return clearedNodes;
+}
+function clearSsmlDocument(document2) {
+  const nextDocument = {
+    ...document2,
+    children: clearNodes(getDocumentChildren(document2))
+  };
+  if (nextDocument.content !== void 0) {
+    delete nextDocument.content;
+  }
+  return nextDocument;
+}
+
+// packages/ssml-editor-react/src/constants/ssmlPresets.ts
+var ssmlPresets_exports = {};
+__export(ssmlPresets_exports, {
+  BREAK_STRENGTH_PRESETS: () => BREAK_STRENGTH_PRESETS,
+  BREAK_TIME_DESCRIPTIONS: () => BREAK_TIME_DESCRIPTIONS,
+  BREAK_TIME_PRESETS: () => BREAK_TIME_PRESETS,
+  EMPHASIS_LEVEL_DESCRIPTIONS: () => EMPHASIS_LEVEL_DESCRIPTIONS,
+  EMPHASIS_LEVEL_PRESETS: () => EMPHASIS_LEVEL_PRESETS,
+  EXPRESS_AS_STYLE_DESCRIPTIONS: () => EXPRESS_AS_STYLE_DESCRIPTIONS,
+  EXPRESS_AS_STYLE_PRESETS: () => EXPRESS_AS_STYLE_PRESETS,
+  LANGUAGE_DESCRIPTIONS: () => LANGUAGE_DESCRIPTIONS,
+  LANGUAGE_PRESETS: () => LANGUAGE_PRESETS,
+  PHONEME_ALPHABET_PRESETS: () => PHONEME_ALPHABET_PRESETS,
+  PROSODY_PITCH_DESCRIPTIONS: () => PROSODY_PITCH_DESCRIPTIONS,
+  PROSODY_PITCH_PRESETS: () => PROSODY_PITCH_PRESETS,
+  PROSODY_RATE_DESCRIPTIONS: () => PROSODY_RATE_DESCRIPTIONS,
+  PROSODY_RATE_PRESETS: () => PROSODY_RATE_PRESETS,
+  PROSODY_RATE_VALUES: () => PROSODY_RATE_VALUES,
+  PROSODY_VOLUME_DESCRIPTIONS: () => PROSODY_VOLUME_DESCRIPTIONS,
+  PROSODY_VOLUME_PRESETS: () => PROSODY_VOLUME_PRESETS,
+  SAY_AS_DESCRIPTIONS: () => SAY_AS_DESCRIPTIONS,
+  SAY_AS_PRESETS: () => SAY_AS_PRESETS,
+  SILENCE_TYPE_PRESETS: () => SILENCE_TYPE_PRESETS,
+  SILENCE_VALUE_DESCRIPTIONS: () => SILENCE_VALUE_DESCRIPTIONS,
+  SILENCE_VALUE_PRESETS: () => SILENCE_VALUE_PRESETS,
+  SSML_PRESETS: () => SSML_PRESETS,
+  SSML_PRESET_EXAMPLES: () => SSML_PRESET_EXAMPLES,
+  VISEME_TYPE_PRESETS: () => VISEME_TYPE_PRESETS
+});
+var SSML_PRESETS = [
+  {
+    id: "basic",
+    label: "Basic speech",
+    ssml: '<speak version="1.0" xml:lang="en-US">Hello, world!</speak>',
+    description: "A minimal SSML document."
+  },
+  {
+    id: "voice",
+    label: "Voice selection",
+    ssml: '<speak version="1.0" xml:lang="en-US"><voice name="en-US-JennyNeural">Hello, world!</voice></speak>',
+    description: "Speaks text with a selected voice."
+  },
+  {
+    id: "prosody",
+    label: "Prosody",
+    ssml: '<speak version="1.0" xml:lang="en-US"><prosody rate="fast" pitch="+2st">Hello, world!</prosody></speak>',
+    description: "Adjusts the speech rate and pitch."
+  }
+];
+var BREAK_TIME_PRESETS = ["500ms", "1s", "2s", "3s"];
+var BREAK_STRENGTH_PRESETS = ["none", "x-weak", "weak", "medium", "strong", "x-strong"];
+var PROSODY_RATE_PRESETS = ["x-slow", "slow", "medium", "fast", "x-fast"];
+var PROSODY_RATE_VALUES = [...PROSODY_RATE_PRESETS, "percentage"];
+var PROSODY_PITCH_PRESETS = ["+2st", "-2st", "0st", "+4st", "-4st", "+8st", "-8st", "+12st", "-12st"];
+var PROSODY_VOLUME_PRESETS = ["silent", "x-soft", "soft", "medium", "loud", "x-loud"];
+var EXPRESS_AS_STYLE_PRESETS = ["cheerful", "friendly", "calm", "sad", "angry", "excited", "serious"];
+var EMPHASIS_LEVEL_PRESETS = ["strong", "moderate", "reduced", "none"];
+var SAY_AS_PRESETS = [
+  "characters",
+  "spell-out",
+  "cardinal",
+  "ordinal",
+  "number",
+  "date",
+  "time",
+  "telephone",
+  "fraction",
+  "address",
+  "name",
+  "currency"
+];
+var LANGUAGE_PRESETS = ["ja-JP", "en-US", "de-DE", "fr-FR"];
+var SILENCE_VALUE_PRESETS = ["300ms", "500ms", "1s"];
+var SILENCE_TYPE_PRESETS = [
+  "Leading",
+  "Tailing",
+  "Sentenceboundary",
+  "Comma",
+  "Semicolon",
+  "Enumerationcomma"
+];
+var PHONEME_ALPHABET_PRESETS = ["ipa", "sapi", "ups", "x-sampa"];
+var VISEME_TYPE_PRESETS = ["redlips_front", "FacialExpression"];
+var SSML_PRESET_EXAMPLES = {
+  breakTime: "500ms",
+  prosodyRate: "fast",
+  prosodyPitch: "+2st",
+  prosodyVolume: "loud",
+  expressAsStyle: "cheerful",
+  phonemeAlphabet: "ipa",
+  silenceValue: "300ms"
+};
+var BREAK_TIME_DESCRIPTIONS = {
+  "500ms": {
+    ja: "500\u30DF\u30EA\u79D2\u306E\u7121\u97F3",
+    en: "Inserts 500 milliseconds of silence."
+  },
+  "1s": {
+    ja: "1\u79D2\u306E\u7121\u97F3",
+    en: "Inserts one second of silence."
+  },
+  "2s": {
+    ja: "2\u79D2\u306E\u7121\u97F3",
+    en: "Inserts two seconds of silence."
+  },
+  "3s": {
+    ja: "3\u79D2\u306E\u7121\u97F3",
+    en: "Inserts three seconds of silence."
+  }
+};
+var EMPHASIS_LEVEL_DESCRIPTIONS = {
+  strong: {
+    ja: "\u5F37\u3044\u5F37\u8ABF",
+    en: "Applies strong emphasis."
+  },
+  moderate: {
+    ja: "\u4E2D\u7A0B\u5EA6\u306E\u5F37\u8ABF",
+    en: "Applies moderate emphasis."
+  },
+  reduced: {
+    ja: "\u5F31\u3081\u306E\u5F37\u8ABF",
+    en: "Applies reduced emphasis."
+  },
+  none: {
+    ja: "\u5F37\u8ABF\u306A\u3057",
+    en: "Applies no emphasis."
+  }
+};
+var PROSODY_RATE_DESCRIPTIONS = {
+  "x-slow": {
+    ja: "\u6700\u3082\u9045\u3044\u901F\u5EA6",
+    en: "Uses the slowest speech rate."
+  },
+  slow: {
+    ja: "\u9045\u3044\u901F\u5EA6",
+    en: "Uses a slow speech rate."
+  },
+  medium: {
+    ja: "\u6A19\u6E96\u7684\u306A\u901F\u5EA6",
+    en: "Uses the standard speech rate."
+  },
+  fast: {
+    ja: "\u901F\u3044\u901F\u5EA6",
+    en: "Uses a fast speech rate."
+  },
+  "x-fast": {
+    ja: "\u6700\u3082\u901F\u3044\u901F\u5EA6",
+    en: "Uses the fastest speech rate."
+  }
+};
+var PROSODY_PITCH_DESCRIPTIONS = {
+  "+2st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A2\u534A\u97F3\u4E0A",
+    en: "Raises the pitch by two semitones."
+  },
+  "-2st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A2\u534A\u97F3\u4E0B",
+    en: "Lowers the pitch by two semitones."
+  },
+  "0st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055",
+    en: "Keeps the baseline pitch."
+  },
+  "+4st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A4\u534A\u97F3\u4E0A",
+    en: "Raises the pitch by four semitones."
+  },
+  "-4st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A4\u534A\u97F3\u4E0B",
+    en: "Lowers the pitch by four semitones."
+  },
+  "+8st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A8\u534A\u97F3\u4E0A",
+    en: "Raises the pitch by eight semitones."
+  },
+  "-8st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A8\u534A\u97F3\u4E0B",
+    en: "Lowers the pitch by eight semitones."
+  },
+  "+12st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A12\u534A\u97F3\u4E0A",
+    en: "Raises the pitch by twelve semitones."
+  },
+  "-12st": {
+    ja: "\u57FA\u6E96\u306E\u58F0\u306E\u9AD8\u3055\u3088\u308A12\u534A\u97F3\u4E0B",
+    en: "Lowers the pitch by twelve semitones."
+  }
+};
+var PROSODY_VOLUME_DESCRIPTIONS = {
+  silent: {
+    ja: "\u7121\u97F3",
+    en: "Makes the selected text silent."
+  },
+  "x-soft": {
+    ja: "\u6700\u3082\u5C0F\u3055\u3044\u97F3\u91CF",
+    en: "Uses the quietest volume."
+  },
+  soft: {
+    ja: "\u5C0F\u3055\u3044\u97F3\u91CF",
+    en: "Uses a soft volume."
+  },
+  medium: {
+    ja: "\u6A19\u6E96\u7684\u306A\u97F3\u91CF",
+    en: "Uses the standard volume."
+  },
+  loud: {
+    ja: "\u5927\u304D\u3044\u97F3\u91CF",
+    en: "Uses a loud volume."
+  },
+  "x-loud": {
+    ja: "\u6700\u3082\u5927\u304D\u3044\u97F3\u91CF",
+    en: "Uses the loudest volume."
+  }
+};
+var EXPRESS_AS_STYLE_DESCRIPTIONS = {
+  cheerful: {
+    ja: "\u660E\u308B\u304F\u5143\u6C17\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a cheerful style."
+  },
+  friendly: {
+    ja: "\u89AA\u3057\u307F\u3084\u3059\u3044\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a friendly style."
+  },
+  calm: {
+    ja: "\u7A4F\u3084\u304B\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a calm style."
+  },
+  sad: {
+    ja: "\u60B2\u3057\u3052\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a sad style."
+  },
+  angry: {
+    ja: "\u6012\u3063\u305F\u3088\u3046\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses an angry style."
+  },
+  excited: {
+    ja: "\u8208\u596E\u3057\u305F\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses an excited style."
+  },
+  serious: {
+    ja: "\u771F\u5263\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a serious style."
+  }
+};
+var SAY_AS_DESCRIPTIONS = {
+  characters: {
+    ja: "1\u6587\u5B57\u305A\u3064\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the characters one by one."
+  },
+  "spell-out": {
+    ja: "\u7DB4\u308A\u306E\u8AAD\u307F\u4E0A\u3052\uFF081\u6587\u5B57\u305A\u3064\uFF09",
+    en: "Spells out the text character by character."
+  },
+  cardinal: {
+    ja: "\u57FA\u6570\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as a cardinal number."
+  },
+  ordinal: {
+    ja: "\u5E8F\u6570\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as an ordinal number."
+  },
+  number: {
+    ja: "\u6570\u5024\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as a number."
+  },
+  date: {
+    ja: "\u65E5\u4ED8\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as a date."
+  },
+  time: {
+    ja: "\u6642\u523B\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as a time."
+  },
+  telephone: {
+    ja: "\u96FB\u8A71\u756A\u53F7\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as a telephone number."
+  },
+  fraction: {
+    ja: "\u5206\u6570\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as a fraction."
+  },
+  address: {
+    ja: "\u4F4F\u6240\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as an address."
+  },
+  name: {
+    ja: "\u540D\u524D\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as a name."
+  },
+  currency: {
+    ja: "\u901A\u8CA8\u3068\u3057\u3066\u306E\u8AAD\u307F\u4E0A\u3052",
+    en: "Speaks the value as currency."
+  }
+};
+var LANGUAGE_DESCRIPTIONS = {
+  "ja-JP": {
+    ja: "\u65E5\u672C\u8A9E\uFF08\u65E5\u672C\uFF09\u3067\u8AAD\u307F\u4E0A\u3052\u307E\u3059\u3002",
+    en: "Speaks the text in Japanese (Japan)."
+  },
+  "en-US": {
+    ja: "\u82F1\u8A9E\uFF08\u7C73\u56FD\uFF09\u3067\u8AAD\u307F\u4E0A\u3052\u307E\u3059\u3002",
+    en: "Speaks the text in English (United States)."
+  },
+  "de-DE": {
+    ja: "\u30C9\u30A4\u30C4\u8A9E\uFF08\u30C9\u30A4\u30C4\uFF09\u3067\u8AAD\u307F\u4E0A\u3052\u307E\u3059\u3002",
+    en: "Speaks the text in German (Germany)."
+  },
+  "fr-FR": {
+    ja: "\u30D5\u30E9\u30F3\u30B9\u8A9E\uFF08\u30D5\u30E9\u30F3\u30B9\uFF09\u3067\u8AAD\u307F\u4E0A\u3052\u307E\u3059\u3002",
+    en: "Speaks the text in French (France)."
+  }
+};
+var SILENCE_VALUE_DESCRIPTIONS = {
+  "300ms": {
+    ja: "\u5148\u982D\u306B300\u30DF\u30EA\u79D2\u306E\u7121\u97F3\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+    en: "Inserts 300 milliseconds of leading silence."
+  },
+  "500ms": {
+    ja: "\u5148\u982D\u306B500\u30DF\u30EA\u79D2\u306E\u7121\u97F3\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+    en: "Inserts 500 milliseconds of leading silence."
+  },
+  "1s": {
+    ja: "\u5148\u982D\u306B1\u79D2\u306E\u7121\u97F3\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+    en: "Inserts one second of leading silence."
+  }
+};
+
+// packages/ssml-editor-react/src/formatXml.ts
+var INDENT = "  ";
+var FRAGMENT_ROOT = "ssml-builder-fragment";
+var XML_ENTITY_NAMES = /* @__PURE__ */ new Set(["amp", "apos", "gt", "lt", "quot"]);
+function isXmlNameStart2(value) {
+  return value !== void 0 && /[A-Za-z_]/.test(value);
+}
+function isXmlNameCharacter2(value) {
+  return value !== void 0 && /[A-Za-z0-9_.:-]/.test(value);
+}
+function isXmlWhitespace2(value) {
+  return value === " " || value === "	" || value === "\r" || value === "\n";
+}
+function fail(message) {
+  throw new Error(message);
+}
+function skipWhitespace(source, index) {
+  while (isXmlWhitespace2(source[index])) {
+    index += 1;
+  }
+  return index;
+}
+function readName(source, start, end) {
+  if (!isXmlNameStart2(source[start])) {
+    fail("Invalid XML name");
+  }
+  let index = start + 1;
+  while (index < end && isXmlNameCharacter2(source[index])) {
+    index += 1;
+  }
+  return { name: source.slice(start, index), index };
+}
+function validateCharacterReference(entity) {
+  const isHexadecimal = entity.startsWith("#x") || entity.startsWith("#X");
+  const isDecimal = entity.startsWith("#");
+  if (!isHexadecimal && !isDecimal) {
+    if (!XML_ENTITY_NAMES.has(entity)) {
+      fail(`Unknown XML entity: &${entity};`);
+    }
+    return;
+  }
+  const digits = entity.slice(isHexadecimal ? 2 : 1);
+  const validDigits = isHexadecimal ? /^[0-9A-Fa-f]+$/.test(digits) : /^[0-9]+$/.test(digits);
+  const codePoint = Number.parseInt(digits, isHexadecimal ? 16 : 10);
+  if (!validDigits || !Number.isInteger(codePoint) || codePoint < 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 || codePoint < 32 && ![9, 10, 13].includes(codePoint)) {
+    fail(`Invalid XML character reference: &${entity};`);
+  }
+}
+function validateEntityReferences(value) {
+  let index = 0;
+  while (true) {
+    const ampersand = value.indexOf("&", index);
+    if (ampersand === -1) {
+      return;
+    }
+    const semicolon = value.indexOf(";", ampersand + 1);
+    if (semicolon === -1) {
+      fail("Unterminated XML entity reference");
+    }
+    validateCharacterReference(value.slice(ampersand + 1, semicolon));
+    index = semicolon + 1;
+  }
+}
+function findTagEnd(source, start, hasInternalSubset = false) {
+  let quote;
+  let subsetDepth = 0;
+  for (let index = start + 1; index < source.length; index += 1) {
+    const character = source[index];
+    if (quote !== void 0) {
+      if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (hasInternalSubset) {
+      if (character === "[") {
+        subsetDepth += 1;
+        continue;
+      }
+      if (character === "]" && subsetDepth > 0) {
+        subsetDepth -= 1;
+        continue;
+      }
+    }
+    if (character === ">" && subsetDepth === 0) {
+      return index;
+    }
+  }
+  fail("Unclosed XML markup");
+}
+function parseStartTag(source, start, end) {
+  const nameResult = readName(source, start + 1, end);
+  let index = nameResult.index;
+  let hasAttribute = false;
+  const attributeNames = /* @__PURE__ */ new Set();
+  while (index < end) {
+    const beforeWhitespace = index;
+    index = skipWhitespace(source, index);
+    if (index === end) {
+      break;
+    }
+    if (source[index] === "/") {
+      if (index + 1 !== end) {
+        fail("Invalid XML self-closing tag");
+      }
+      return { name: nameResult.name, selfClosing: true };
+    }
+    if (hasAttribute && beforeWhitespace === index) {
+      fail("XML attributes must be separated by whitespace");
+    }
+    const attribute = readName(source, index, end);
+    index = skipWhitespace(source, attribute.index);
+    if (source[index] !== "=") {
+      fail(`XML attribute ${attribute.name} must have a value`);
+    }
+    index = skipWhitespace(source, index + 1);
+    const quote = source[index];
+    if (quote !== '"' && quote !== "'") {
+      fail(`XML attribute ${attribute.name} must use a quoted value`);
+    }
+    index += 1;
+    const valueStart = index;
+    while (index < end && source[index] !== quote) {
+      if (source[index] === "<") {
+        fail(`Invalid "<" in XML attribute ${attribute.name}`);
+      }
+      index += 1;
+    }
+    if (index === end) {
+      fail(`Unclosed XML attribute ${attribute.name}`);
+    }
+    if (attributeNames.has(attribute.name)) {
+      fail(`Duplicate XML attribute: ${attribute.name}`);
+    }
+    attributeNames.add(attribute.name);
+    validateEntityReferences(source.slice(valueStart, index));
+    index += 1;
+    hasAttribute = true;
+  }
+  return { name: nameResult.name, selfClosing: false };
+}
+function parseClosingTag(source, start, end) {
+  const nameResult = readName(source, start + 2, end);
+  if (skipWhitespace(source, nameResult.index) !== end) {
+    fail("Invalid XML closing tag");
+  }
+  return nameResult.name;
+}
+function parseProcessingInstruction(source, start, end) {
+  readName(source, start + 2, end);
+}
+function parseDeclaration(source, start, end) {
+  readName(source, start + 2, end);
+}
+function appendNode2(nodes, node) {
+  const previous = nodes[nodes.length - 1];
+  if (node.kind === "text" && previous?.kind === "text") {
+    previous.value += node.value;
+    return;
+  }
+  nodes.push(node);
+}
+function currentElement(stack) {
+  return stack[stack.length - 1];
+}
+function parseXml(source) {
+  const children = [];
+  const stack = [];
+  let root;
+  let index = 0;
+  while (index < source.length) {
+    if (source[index] !== "<") {
+      const textStart = index;
+      while (index < source.length && source[index] !== "<") {
+        index += 1;
+      }
+      const value = source.slice(textStart, index);
+      if (value.includes("]]>")) {
+        fail("CDATA termination is not valid in ordinary XML text");
+      }
+      validateEntityReferences(value);
+      if (stack.length === 0 && value.trim() !== "") {
+        fail("Unexpected text outside the root XML element");
+      }
+      appendNode2(currentElement(stack)?.children ?? children, { kind: "text", value });
+      continue;
+    }
+    if (source.startsWith("<!--", index)) {
+      const end2 = source.indexOf("-->", index + 4);
+      if (end2 === -1) {
+        fail("Unclosed XML comment");
+      }
+      const content = source.slice(index + 4, end2);
+      if (content.includes("--") || content.endsWith("-")) {
+        fail("Invalid XML comment");
+      }
+      appendNode2(currentElement(stack)?.children ?? children, {
+        kind: "comment",
+        raw: source.slice(index, end2 + 3)
+      });
+      index = end2 + 3;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", index)) {
+      const end2 = source.indexOf("]]>", index + "<![CDATA[".length);
+      if (end2 === -1) {
+        fail("Unclosed XML CDATA section");
+      }
+      if (stack.length === 0) {
+        fail("CDATA is not allowed outside the root XML element");
+      }
+      appendNode2(currentElement(stack)?.children ?? children, {
+        kind: "cdata",
+        raw: source.slice(index, end2 + 3)
+      });
+      index = end2 + 3;
+      continue;
+    }
+    if (source.startsWith("<?", index)) {
+      const end2 = source.indexOf("?>", index + 2);
+      if (end2 === -1) {
+        fail("Unclosed XML processing instruction");
+      }
+      parseProcessingInstruction(source, index, end2);
+      appendNode2(currentElement(stack)?.children ?? children, {
+        kind: "processing-instruction",
+        raw: source.slice(index, end2 + 2)
+      });
+      index = end2 + 2;
+      continue;
+    }
+    if (source.startsWith("</", index)) {
+      const end2 = findTagEnd(source, index);
+      const name2 = parseClosingTag(source, index, end2);
+      const element = currentElement(stack);
+      if (element === void 0 || element.name !== name2) {
+        fail(`Mismatched closing XML element: </${name2}>`);
+      }
+      element.close = source.slice(index, end2 + 1);
+      stack.pop();
+      index = end2 + 1;
+      continue;
+    }
+    if (source.startsWith("<!", index)) {
+      const end2 = findTagEnd(source, index, true);
+      parseDeclaration(source, index, end2);
+      appendNode2(currentElement(stack)?.children ?? children, {
+        kind: "declaration",
+        raw: source.slice(index, end2 + 1)
+      });
+      index = end2 + 1;
+      continue;
+    }
+    const end = findTagEnd(source, index);
+    const { name, selfClosing } = parseStartTag(source, index, end);
+    if (stack.length === 0) {
+      if (root !== void 0) {
+        fail("Multiple root XML elements are not allowed");
+      }
+      root = {
+        kind: "element",
+        name,
+        open: source.slice(index, end + 1),
+        selfClosing,
+        children: []
+      };
+      children.push(root);
+    } else {
+      const element = {
+        kind: "element",
+        name,
+        open: source.slice(index, end + 1),
+        selfClosing,
+        children: []
+      };
+      currentElement(stack)?.children.push(element);
+      if (!selfClosing) {
+        stack.push(element);
+      }
+      index = end + 1;
+      continue;
+    }
+    if (!selfClosing) {
+      stack.push(root);
+    }
+    index = end + 1;
+  }
+  if (stack.length > 0) {
+    fail(`Unclosed XML element: <${currentElement(stack)?.name}>`);
+  }
+  if (root === void 0) {
+    fail("XML input does not contain a root element");
+  }
+  return { children, root };
+}
+function indentation(depth) {
+  return INDENT.repeat(depth);
+}
+function renderInline(node) {
+  const content = node.children.map((child) => {
+    if (child.kind === "element") {
+      return renderInline(child);
+    }
+    return child.kind === "text" ? child.value : child.raw;
+  }).join("");
+  return `${node.open}${content}${node.close ?? ""}`;
+}
+function hasOnlyTextChildren(node) {
+  return node.children.every((child) => child.kind === "text");
+}
+function hasSignificantText(node) {
+  return node.children.some((child) => child.kind === "text" && child.value.trim() !== "");
+}
+function formatElement(node, depth, isRoot) {
+  const prefix = indentation(depth);
+  if (node.selfClosing) {
+    return [`${prefix}${node.open}`];
+  }
+  if (node.close === void 0) {
+    fail(`Unclosed XML element: <${node.name}>`);
+  }
+  if (isRoot && hasOnlyTextChildren(node)) {
+    const text = node.children.filter((child) => child.kind === "text").map((child) => child.value).join("");
+    const trimmedText = text.trim();
+    if (trimmedText === "") {
+      return [`${prefix}${node.open}`, `${prefix}${node.close}`];
+    }
+    if (text.includes("\n") || text.includes("\r") || text !== trimmedText) {
+      return [`${prefix}${renderInline(node)}`];
+    }
+    return [`${prefix}${node.open}`, `${indentation(depth + 1)}${trimmedText}`, `${prefix}${node.close}`];
+  }
+  if (hasSignificantText(node)) {
+    return [`${prefix}${renderInline(node)}`];
+  }
+  const lines = [`${prefix}${node.open}`];
+  for (const child of node.children) {
+    if (child.kind === "text") {
+      continue;
+    }
+    if (child.kind === "element") {
+      lines.push(...formatElement(child, depth + 1, false));
+    } else {
+      lines.push(`${indentation(depth + 1)}${child.raw}`);
+    }
+  }
+  lines.push(`${prefix}${node.close}`);
+  return lines;
+}
+function stripTrailingWhitespace(value) {
+  return value.replace(/[ \t]+$/gm, "");
+}
+function renderDocument(document2) {
+  const lines = [];
+  for (const child of document2.children) {
+    if (child.kind === "text") {
+      continue;
+    }
+    if (child.kind === "element") {
+      lines.push(...formatElement(child, 0, child === document2.root));
+    } else {
+      lines.push(child.raw);
+    }
+  }
+  return stripTrailingWhitespace(lines.join("\n")).trim();
+}
+function unwrapFormattedFragment(formatted) {
+  const opening = `<${FRAGMENT_ROOT}>`;
+  const closing = `</${FRAGMENT_ROOT}>`;
+  if (!formatted.startsWith(opening) || !formatted.endsWith(closing)) {
+    return void 0;
+  }
+  if (formatted === `${opening}${closing}`) {
+    return "";
+  }
+  const multilineOpening = `${opening}
+`;
+  const multilineClosing = `
+${closing}`;
+  if (formatted.startsWith(multilineOpening) && formatted.endsWith(multilineClosing)) {
+    const content = formatted.slice(multilineOpening.length, -multilineClosing.length);
+    return content.split("\n").map((line) => line.startsWith(INDENT) ? line.slice(INDENT.length) : line).join("\n");
+  }
+  return formatted.slice(opening.length, -closing.length);
+}
+function formatXmlFragment(xml) {
+  const source = xml.trim();
+  if (source === "") {
+    return "";
+  }
+  const wrapped = `<${FRAGMENT_ROOT}>${source}</${FRAGMENT_ROOT}>`;
+  let formatted;
+  try {
+    formatted = renderDocument(parseXml(wrapped));
+  } catch {
+    return xml;
+  }
+  return unwrapFormattedFragment(formatted) ?? xml;
+}
+
+// packages/ssml-editor-react/src/locales.ts
+var EDITOR_COPY = {
+  ja: {
+    editorAriaLabel: "SSML\u30A8\u30C7\u30A3\u30BF\u30FC",
+    toolbarAriaLabel: "SSML\u30C4\u30FC\u30EB\u30D0\u30FC",
+    clearAll: "\u5168\u3066\u30AF\u30EA\u30A2",
+    clearAllTitle: "\u97F3\u58F0\u8A2D\u5B9A\u3092\u4FDD\u6301\u3057\u3066XML\u8981\u7D20\u3092\u524A\u9664\u3057\u672C\u6587\u3092\u6B8B\u3059",
+    undo: "\u5143\u306B\u623B\u3059",
+    undoTitle: "\u76F4\u524D\u306E\u5909\u66F4\u3092\u5143\u306B\u623B\u3059",
+    redo: "\u3084\u308A\u76F4\u3059",
+    redoTitle: "\u5143\u306B\u623B\u3057\u305F\u5909\u66F4\u3092\u3084\u308A\u76F4\u3059",
+    help: "\u8AAC\u660E",
+    helpTitle: "\u30DC\u30BF\u30F3\u3068\u30D1\u30E9\u30E1\u30FC\u30BF\u306E\u8AAC\u660E\u3092\u8868\u793A",
+    helpHeading: "\u30DC\u30BF\u30F3\u3068\u30D1\u30E9\u30E1\u30FC\u30BF\u306E\u8AAC\u660E",
+    helpDescription: "\u5404\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u306E\u6A5F\u80FD\u3068\u30D1\u30E9\u30E1\u30FC\u30BF\u3092\u78BA\u8A8D\u3067\u304D\u307E\u3059\u3002",
+    parameters: "\u30D1\u30E9\u30E1\u30FC\u30BF",
+    format: "\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8",
+    formatTitle: "\u672C\u6587\u306EXML\u3092\u6539\u884C\u3057\u3066\u898B\u3084\u3059\u304F\u8868\u793A",
+    decorations: "\u88C5\u98FE",
+    decorationsShowTitle: "\u30A4\u30F3\u30E9\u30A4\u30F3\u88C5\u98FE\u3092\u8868\u793A",
+    decorationsHideTitle: "\u30A4\u30F3\u30E9\u30A4\u30F3\u88C5\u98FE\u3092\u975E\u8868\u793A",
+    syntaxError: "\u69CB\u6587\u30A8\u30E9\u30FC",
+    selectionActions: "\u9078\u629E\u7BC4\u56F2\u306E\u64CD\u4F5C",
+    selectionCountSuffix: "\u6587\u5B57",
+    previewSelection: "\u9078\u629E\u90E8\u5206\u3092\u8A66\u8074",
+    previewSelectionTitle: "\u9078\u629E\u90E8\u5206\u306ESSML\u3092\u8A66\u8074"
+  },
+  en: {
+    editorAriaLabel: "SSML editor",
+    toolbarAriaLabel: "SSML toolbar",
+    clearAll: "Clear all",
+    clearAllTitle: "Remove non-voice XML elements and keep the text and voice settings",
+    undo: "Undo",
+    undoTitle: "Undo the last change",
+    redo: "Redo",
+    redoTitle: "Redo the last undone change",
+    help: "Help",
+    helpTitle: "Show button and parameter descriptions",
+    helpHeading: "Button and parameter descriptions",
+    helpDescription: "Review what each control does and its parameters.",
+    parameters: "Parameters",
+    format: "Format",
+    formatTitle: "Format the XML in the editor",
+    decorations: "Decorations",
+    decorationsShowTitle: "Show inline decorations",
+    decorationsHideTitle: "Hide inline decorations",
+    syntaxError: "Syntax error",
+    selectionActions: "Selection actions",
+    selectionCountSuffix: " characters",
+    previewSelection: "Preview selection",
+    previewSelectionTitle: "Preview the selected SSML"
+  }
+};
+var INLINE_BADGE_COPY = {
+  ja: {
+    pause: "\u9593",
+    pitch: "\u30D4\u30C3\u30C1\u5909\u5316",
+    prosody: "\u58F0\u306E\u8ABF\u6574"
+  },
+  en: {
+    pause: "Pause",
+    pitch: "Pitch change",
+    prosody: "Prosody"
+  }
+};
+var SSML_HOVER_COPY = {
+  ja: {
+    parameterHeading: "\u30D1\u30E9\u30E1\u30FC\u30BF",
+    parametersHeading: "\u30D1\u30E9\u30E1\u30FC\u30BF",
+    allowedValues: "\u4F7F\u7528\u3067\u304D\u308B\u5024",
+    example: "\u4F8B",
+    noParameters: "\u3053\u306E\u8981\u7D20\u306B\u30D1\u30E9\u30E1\u30FC\u30BF\u306F\u3042\u308A\u307E\u305B\u3093\u3002",
+    tags: {
+      voice: {
+        title: "\u97F3\u58F0",
+        description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u306E\u5408\u6210\u306B\u4F7F\u7528\u3059\u308B\u97F3\u58F0\u3068\u3001\u4EFB\u610F\u306E\u97F3\u58F0\u52B9\u679C\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+        parameters: {
+          name: { title: "name", description: "\u97F3\u58F0\u540D\u3002\u4F8B: `en-US-JennyNeural`\u3002" },
+          effect: { title: "effect", description: "\u4EFB\u610F\u306E\u97F3\u58F0\u52B9\u679C\u3002\u4F8B: `eq_car`\u3002" }
+        }
+      },
+      prosody: {
+        title: "\u97FB\u5F8B",
+        description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u306E\u901F\u5EA6\u3001\u30D4\u30C3\u30C1\u3001\u97F3\u91CF\u3001\u307E\u305F\u306F\u30D4\u30C3\u30C1\u66F2\u7DDA\u3092\u5909\u66F4\u3057\u307E\u3059\u3002",
+        parameters: {
+          rate: { title: "rate", description: "\u767A\u8A71\u901F\u5EA6\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002" },
+          pitch: { title: "pitch", description: "\u540D\u524D\u4ED8\u304D\u306E\u5024\u3001\u5272\u5408\u3001\u5468\u6CE2\u6570\u3001\u307E\u305F\u306F\u534A\u97F3\u3067\u30D4\u30C3\u30C1\u3092\u8ABF\u6574\u3057\u307E\u3059\u3002" },
+          volume: { title: "volume", description: "\u540D\u524D\u4ED8\u304D\u306E\u5024\u3001\u5272\u5408\u3001\u307E\u305F\u306F\u30C7\u30B7\u30D9\u30EB\u5024\u3067\u97F3\u91CF\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002" },
+          contour: { title: "contour", description: "\u30C6\u30AD\u30B9\u30C8\u5185\u306E\u4F4D\u7F6E\u3054\u3068\u306E\u76F8\u5BFE\u7684\u306A\u30D4\u30C3\u30C1\u5909\u5316\u3092\u5B9A\u7FA9\u3057\u307E\u3059\u3002" },
+          range: { title: "range", description: "\u97F3\u58F0\u306E\u30D4\u30C3\u30C1\u7BC4\u56F2\u3092\u8ABF\u6574\u3057\u307E\u3059\u3002" }
+        }
+      },
+      break: {
+        title: "\u9593",
+        description: "\u5358\u8A9E\u3084\u305D\u306E\u4ED6\u306E\u97F3\u58F0\u30B3\u30F3\u30C6\u30F3\u30C4\u306E\u9593\u306B\u30DD\u30FC\u30BA\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+        parameters: {
+          time: { title: "time", description: "\u30DD\u30FC\u30BA\u306E\u9577\u3055\u3002\u4F8B: `500ms` \u307E\u305F\u306F `1s`\u3002" },
+          strength: { title: "strength", description: "\u76F8\u5BFE\u7684\u306A\u30DD\u30FC\u30BA\u306E\u5F37\u3055\u3002" }
+        }
+      },
+      "mstts:express-as": {
+        title: "\u8868\u73FE",
+        description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u306B\u97F3\u58F0\u30B9\u30BF\u30A4\u30EB\u3001\u30B9\u30BF\u30A4\u30EB\u306E\u5F37\u3055\u3001\u307E\u305F\u306F\u5F79\u5272\u3092\u9069\u7528\u3057\u307E\u3059\u3002",
+        parameters: {
+          style: { title: "style", description: "\u9078\u629E\u3057\u305F\u97F3\u58F0\u304C\u5BFE\u5FDC\u3059\u308B\u97F3\u58F0\u30B9\u30BF\u30A4\u30EB\u3002\u4F8B: `cheerful`\u3002" },
+          styledegree: { title: "styledegree", description: "\u9078\u629E\u3057\u305F\u97F3\u58F0\u30B9\u30BF\u30A4\u30EB\u306E\u5F37\u3055\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002" },
+          role: { title: "role", description: "\u5BFE\u5FDC\u3057\u3066\u3044\u308B\u5834\u5408\u306B\u97F3\u58F0\u306E\u5F79\u5272\u3092\u5909\u66F4\u3057\u307E\u3059\u3002" }
+        }
+      },
+      "say-as": {
+        title: "\u8AAD\u307F\u4E0A\u3052\u65B9",
+        description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u306E\u89E3\u91C8\u65B9\u6CD5\u3068\u8AAD\u307F\u4E0A\u3052\u65B9\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+        parameters: {
+          "interpret-as": { title: "interpret-as", description: "\u6587\u5B57\u3001\u6570\u5B57\u3001\u65E5\u4ED8\u3001\u6642\u523B\u306A\u3069\u306E\u89E3\u91C8\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002" },
+          format: { title: "format", description: "\u9078\u629E\u3057\u305F\u89E3\u91C8\u306E\u5F62\u5F0F\u3092\u88DC\u8DB3\u3057\u307E\u3059\u3002" },
+          detail: { title: "detail", description: "\u9078\u629E\u3057\u305F\u89E3\u91C8\u306E\u8A73\u7D30\u3092\u88DC\u8DB3\u3057\u307E\u3059\u3002" }
+        }
+      },
+      phoneme: {
+        title: "\u97F3\u7D20",
+        description: "\u6307\u5B9A\u3057\u305F\u97F3\u7D20\u8868\u8A18\u3067\u901A\u5E38\u306E\u767A\u97F3\u3092\u7F6E\u304D\u63DB\u3048\u307E\u3059\u3002",
+        parameters: {
+          alphabet: { title: "alphabet", description: "`ph` \u5024\u306B\u4F7F\u7528\u3059\u308B\u97F3\u7D20\u30A2\u30EB\u30D5\u30A1\u30D9\u30C3\u30C8\u3002" },
+          ph: { title: "ph", description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u306E\u97F3\u7D20\u8868\u8A18\u3002" }
+        }
+      },
+      emphasis: {
+        title: "\u5F37\u8ABF",
+        description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u3092\u5F37\u8ABF\u3057\u307E\u3059\u3002",
+        parameters: {
+          level: { title: "level", description: "\u5F37\u8ABF\u306E\u5EA6\u5408\u3044\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002" }
+        }
+      },
+      audio: {
+        title: "\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB",
+        description: "\u5408\u6210\u7D50\u679C\u306E\u4E00\u90E8\u3068\u3057\u3066\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u3092\u518D\u751F\u3057\u307E\u3059\u3002",
+        parameters: {
+          src: { title: "src", description: "\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u306E URI\u3002" },
+          desc: { title: "desc", description: "\u97F3\u58F0\u3092\u518D\u751F\u3067\u304D\u306A\u3044\u5834\u5408\u306B\u4F7F\u7528\u3059\u308B\u4EE3\u66FF\u30C6\u30AD\u30B9\u30C8\u3002" },
+          clipBegin: { title: "clipBegin", description: "\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u5185\u306E\u958B\u59CB\u4F4D\u7F6E\u3002\u4F8B: `0s`\u3002" },
+          clipEnd: { title: "clipEnd", description: "\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u5185\u306E\u7D42\u4E86\u4F4D\u7F6E\u3002\u4F8B: `5s`\u3002" },
+          speed: { title: "speed", description: "\u97F3\u58F0\u30D5\u30A1\u30A4\u30EB\u306E\u518D\u751F\u901F\u5EA6\u3002\u4F8B: `1.0`\u3002" },
+          repeatCount: { title: "repeatCount", description: "\u97F3\u58F0\u3092\u7E70\u308A\u8FD4\u3059\u56DE\u6570\u3002\u4F8B: `2`\u3002" },
+          repeatDuration: { title: "repeatDuration", description: "\u97F3\u58F0\u3092\u7E70\u308A\u8FD4\u3059\u5408\u8A08\u6642\u9593\u3002\u4F8B: `10s`\u3002" },
+          soundLevel: { title: "soundLevel", description: "\u30C7\u30B7\u30D9\u30EB\u5358\u4F4D\u306E\u97F3\u91CF\u8ABF\u6574\u3002\u4F8B: `-3dB`\u3002" }
+        }
+      },
+      sub: {
+        title: "\u7F6E\u63DB",
+        description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u306E\u4EE3\u308F\u308A\u306B\u5225\u540D\u30C6\u30AD\u30B9\u30C8\u3092\u8AAD\u307F\u4E0A\u3052\u307E\u3059\u3002",
+        parameters: {
+          alias: { title: "alias", description: "\u5143\u306E\u30C6\u30AD\u30B9\u30C8\u306E\u4EE3\u308F\u308A\u306B\u8AAD\u307F\u4E0A\u3052\u308B\u30C6\u30AD\u30B9\u30C8\u3002\u4F8B: `World Wide Web`\u3002" }
+        }
+      },
+      lang: {
+        title: "\u8A00\u8A9E",
+        description: "\u56F2\u307E\u308C\u305F\u30C6\u30AD\u30B9\u30C8\u306E\u8AAD\u307F\u4E0A\u3052\u8A00\u8A9E\u3092\u5909\u66F4\u3057\u307E\u3059\u3002",
+        parameters: {
+          "xml:lang": { title: "xml:lang", description: "BCP-47 \u8A00\u8A9E\u30BF\u30B0\u3002\u4F8B: `ja-JP`\u3002" }
+        }
+      },
+      mark: {
+        title: "\u30DE\u30FC\u30AB\u30FC",
+        description: "\u5408\u6210\u97F3\u58F0\u30B9\u30C8\u30EA\u30FC\u30E0\u306B\u30AB\u30B9\u30BF\u30E0\u30DE\u30FC\u30AB\u30FC\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+        parameters: {
+          name: { title: "name", description: "\u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3\u3067\u5B9A\u7FA9\u3057\u305F\u30DE\u30FC\u30AB\u30FC\u540D\u3002\u4F8B: `chapter-1`\u3002" }
+        }
+      },
+      bookmark: {
+        title: "\u30D6\u30C3\u30AF\u30DE\u30FC\u30AF",
+        description: "\u5408\u6210\u97F3\u58F0\u30B9\u30C8\u30EA\u30FC\u30E0\u306B\u30D6\u30C3\u30AF\u30DE\u30FC\u30AF\u30DE\u30FC\u30AB\u30FC\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+        parameters: {
+          mark: { title: "mark", description: "\u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3\u3067\u5B9A\u7FA9\u3057\u305F\u30D6\u30C3\u30AF\u30DE\u30FC\u30AF\u540D\u3002\u4F8B: `chapter-1`\u3002" }
+        }
+      },
+      lexicon: {
+        title: "\u767A\u97F3\u8F9E\u66F8",
+        description: "\u5408\u6210\u6587\u66F8\u306B\u767A\u97F3\u8F9E\u66F8\u3092\u95A2\u9023\u4ED8\u3051\u307E\u3059\u3002",
+        parameters: {
+          uri: { title: "uri", description: "\u767A\u97F3\u8F9E\u66F8\u306E URI\u3002" }
+        }
+      },
+      p: { title: "\u6BB5\u843D", description: "\u30C6\u30AD\u30B9\u30C8\u3092\u6BB5\u843D\u3068\u3057\u3066\u307E\u3068\u3081\u307E\u3059\u3002", parameters: {} },
+      s: { title: "\u6587", description: "\u30C6\u30AD\u30B9\u30C8\u3092\u6587\u3068\u3057\u3066\u307E\u3068\u3081\u307E\u3059\u3002", parameters: {} },
+      w: { title: "\u5358\u8A9E", description: "\u30C6\u30AD\u30B9\u30C8\u3092\u5358\u8A9E\u3068\u3057\u3066\u307E\u3068\u3081\u307E\u3059\u3002", parameters: {} },
+      "mstts:silence": {
+        title: "\u7121\u97F3",
+        description: "\u30C6\u30AD\u30B9\u30C8\u306E\u524D\u5F8C\u3001\u307E\u305F\u306F\u53E5\u8AAD\u70B9\u306E\u5883\u754C\u306B\u6307\u5B9A\u3057\u305F\u7121\u97F3\u3092\u8FFD\u52A0\u3057\u307E\u3059\u3002",
+        parameters: {
+          type: { title: "type", description: "\u7121\u97F3\u306E\u4F4D\u7F6E\u307E\u305F\u306F\u53E5\u8AAD\u70B9\u306E\u5883\u754C\u3002" },
+          value: { title: "value", description: "\u7121\u97F3\u306E\u9577\u3055\u3002\u4F8B: `300ms`\u3002" }
+        }
+      },
+      "mstts:viseme": {
+        title: "\u30D3\u30BC\u30FC\u30E0",
+        description: "\u5408\u6210\u97F3\u58F0\u306E\u30D3\u30BC\u30FC\u30E0\u30A4\u30D9\u30F3\u30C8\u3092\u8981\u6C42\u3057\u307E\u3059\u3002",
+        parameters: {
+          type: { title: "type", description: "\u30D3\u30BC\u30FC\u30E0\u30A4\u30D9\u30F3\u30C8\u306E\u5F62\u5F0F\u3002" }
+        }
+      }
+    }
+  },
+  en: {
+    parameterHeading: "Parameter",
+    parametersHeading: "Parameters",
+    allowedValues: "Allowed values",
+    example: "Example",
+    noParameters: "This element has no parameters.",
+    tags: {
+      voice: {
+        title: "Voice",
+        description: "Selects the voice and optional voice effect used to synthesize the enclosed text.",
+        parameters: {
+          name: { title: "name", description: "The voice name, such as `en-US-JennyNeural`." },
+          effect: { title: "effect", description: "An optional voice effect, such as `eq_car`." }
+        }
+      },
+      prosody: {
+        title: "Prosody",
+        description: "Changes the speaking rate, pitch, volume, or pitch contour of the enclosed text.",
+        parameters: {
+          rate: { title: "rate", description: "Controls speaking speed." },
+          pitch: {
+            title: "pitch",
+            description: "Adjusts pitch using a named value, percentage, frequency, or semitone value."
+          },
+          volume: {
+            title: "volume",
+            description: "Controls loudness using a named value, percentage, or decibel value."
+          },
+          contour: {
+            title: "contour",
+            description: "Defines a sequence of relative pitch changes at positions in the text."
+          },
+          range: { title: "range", description: "Adjusts the pitch range of the voice." }
+        }
+      },
+      break: {
+        title: "Break",
+        description: "Inserts a pause between words or other spoken content.",
+        parameters: {
+          time: { title: "time", description: "The pause duration, for example `500ms` or `1s`." },
+          strength: { title: "strength", description: "The relative pause strength." }
+        }
+      },
+      "mstts:express-as": {
+        title: "Express-as",
+        description: "Applies a speaking style, style degree, or role to the enclosed text.",
+        parameters: {
+          style: {
+            title: "style",
+            description: "The speaking style supported by the selected voice, such as `cheerful`."
+          },
+          styledegree: { title: "styledegree", description: "Controls the intensity of the selected speaking style." },
+          role: { title: "role", description: "Changes the speaking role when supported by the selected voice." }
+        }
+      },
+      "say-as": {
+        title: "Say-as",
+        description: "Controls how the enclosed text is interpreted and spoken.",
+        parameters: {
+          "interpret-as": {
+            title: "interpret-as",
+            description: "Specifies the interpretation, such as characters, digits, date, or time."
+          },
+          format: { title: "format", description: "Provides a format hint for the selected interpretation." },
+          detail: {
+            title: "detail",
+            description: "Provides an additional detail hint for the selected interpretation."
+          }
+        }
+      },
+      phoneme: {
+        title: "Phoneme",
+        description: "Replaces normal pronunciation with the supplied phonetic pronunciation.",
+        parameters: {
+          alphabet: { title: "alphabet", description: "The phonetic alphabet used by the `ph` value." },
+          ph: { title: "ph", description: "The phonetic pronunciation for the enclosed text." }
+        }
+      },
+      emphasis: {
+        title: "Emphasis",
+        description: "Adds emphasis to the enclosed text.",
+        parameters: {
+          level: { title: "level", description: "Controls the amount of emphasis." }
+        }
+      },
+      audio: {
+        title: "Audio",
+        description: "Plays an audio file as part of the synthesized output.",
+        parameters: {
+          src: { title: "src", description: "The URI of the audio file." },
+          desc: { title: "desc", description: "Alternative text to use if the audio cannot be played." },
+          clipBegin: { title: "clipBegin", description: "The starting offset within the audio file." },
+          clipEnd: { title: "clipEnd", description: "The ending offset within the audio file." },
+          speed: { title: "speed", description: "The playback speed of the audio file." },
+          repeatCount: { title: "repeatCount", description: "The number of times to repeat the audio." },
+          repeatDuration: {
+            title: "repeatDuration",
+            description: "The total duration for which the audio may repeat."
+          },
+          soundLevel: { title: "soundLevel", description: "The audio volume adjustment in decibels." }
+        }
+      },
+      sub: {
+        title: "Substitution",
+        description: "Substitutes the alias text when speaking the enclosed text.",
+        parameters: {
+          alias: { title: "alias", description: "The text to speak instead of the enclosed text." }
+        }
+      },
+      lang: {
+        title: "Language",
+        description: "Changes the language used for the enclosed text.",
+        parameters: {
+          "xml:lang": { title: "xml:lang", description: "The BCP-47 language tag." }
+        }
+      },
+      mark: {
+        title: "Mark",
+        description: "Inserts a custom marker into the synthesized audio stream.",
+        parameters: {
+          name: { title: "name", description: "The application-defined marker name." }
+        }
+      },
+      bookmark: {
+        title: "Bookmark",
+        description: "Inserts a bookmark marker into the synthesized audio stream.",
+        parameters: {
+          mark: { title: "mark", description: "The application-defined bookmark name." }
+        }
+      },
+      lexicon: {
+        title: "Lexicon",
+        description: "Associates a pronunciation lexicon with the synthesized document.",
+        parameters: {
+          uri: { title: "uri", description: "The URI of the pronunciation lexicon." }
+        }
+      },
+      p: { title: "Paragraph", description: "Groups text into a paragraph.", parameters: {} },
+      s: { title: "Sentence", description: "Groups text into a sentence.", parameters: {} },
+      w: { title: "Word", description: "Groups text into a word.", parameters: {} },
+      "mstts:silence": {
+        title: "Silence",
+        description: "Adds a specified silence before or after text or at a punctuation boundary.",
+        parameters: {
+          type: { title: "type", description: "The silence position or punctuation boundary." },
+          value: { title: "value", description: "The silence duration, for example `300ms`." }
+        }
+      },
+      "mstts:viseme": {
+        title: "Viseme",
+        description: "Requests viseme events for the synthesized audio.",
+        parameters: {
+          type: { title: "type", description: "The viseme event format." }
+        }
+      }
+    }
+  }
+};
+
+// packages/ssml-editor-react/src/ssmlHover.ts
+var {
+  BREAK_STRENGTH_PRESETS: BREAK_STRENGTH_PRESETS2,
+  EMPHASIS_LEVEL_PRESETS: EMPHASIS_LEVEL_PRESETS2,
+  PHONEME_ALPHABET_PRESETS: PHONEME_ALPHABET_PRESETS2,
+  PROSODY_RATE_VALUES: PROSODY_RATE_VALUES2,
+  PROSODY_VOLUME_PRESETS: PROSODY_VOLUME_PRESETS2,
+  SILENCE_TYPE_PRESETS: SILENCE_TYPE_PRESETS2,
+  SSML_PRESET_EXAMPLES: SSML_PRESET_EXAMPLES2,
+  VISEME_TYPE_PRESETS: VISEME_TYPE_PRESETS2
+} = ssmlPresets_exports;
+var SSML_TAG_DEFINITIONS = [
+  {
+    name: "voice",
+    description: "Selects the voice and optional voice effect used to synthesize the enclosed text.",
+    parameters: [
+      {
+        name: "name",
+        description: "The voice name, such as `en-US-JennyNeural`.",
+        example: "en-US-JennyNeural"
+      },
+      {
+        name: "effect",
+        description: "An optional voice effect, such as `eq_car`."
+      }
+    ]
+  },
+  {
+    name: "prosody",
+    description: "Changes the speaking rate, pitch, volume, or pitch contour of the enclosed text.",
+    parameters: [
+      {
+        name: "rate",
+        description: "Controls speaking speed.",
+        values: PROSODY_RATE_VALUES2,
+        example: SSML_PRESET_EXAMPLES2.prosodyRate
+      },
+      {
+        name: "pitch",
+        description: "Adjusts pitch using a named value, percentage, frequency, or semitone value.",
+        example: SSML_PRESET_EXAMPLES2.prosodyPitch
+      },
+      {
+        name: "volume",
+        description: "Controls loudness using a named value, percentage, or decibel value.",
+        values: PROSODY_VOLUME_PRESETS2,
+        example: SSML_PRESET_EXAMPLES2.prosodyVolume
+      },
+      {
+        name: "contour",
+        description: "Defines a sequence of relative pitch changes at positions in the text.",
+        example: "(0%,+0st) (100%,+2st)"
+      },
+      {
+        name: "range",
+        description: "Adjusts the pitch range of the voice.",
+        example: "+2st"
+      }
+    ]
+  },
+  {
+    name: "break",
+    description: "Inserts a pause between words or other spoken content.",
+    parameters: [
+      {
+        name: "time",
+        description: "The pause duration, for example `500ms` or `1s`.",
+        example: SSML_PRESET_EXAMPLES2.breakTime
+      },
+      {
+        name: "strength",
+        description: "The relative pause strength.",
+        values: BREAK_STRENGTH_PRESETS2
+      }
+    ]
+  },
+  {
+    name: "mstts:express-as",
+    aliases: ["express-as", "expressAs"],
+    description: "Applies a speaking style, style degree, or role to the enclosed text.",
+    parameters: [
+      {
+        name: "style",
+        description: "The speaking style supported by the selected voice, such as `cheerful`.",
+        example: SSML_PRESET_EXAMPLES2.expressAsStyle
+      },
+      {
+        name: "styledegree",
+        aliases: ["style-degree", "styleDegree"],
+        description: "Controls the intensity of the selected speaking style.",
+        example: "1.5"
+      },
+      {
+        name: "role",
+        description: "Changes the speaking role when supported by the selected voice.",
+        example: "YoungAdultFemale"
+      }
+    ]
+  },
+  {
+    name: "say-as",
+    aliases: ["sayAs"],
+    description: "Controls how the enclosed text is interpreted and spoken.",
+    parameters: [
+      {
+        name: "interpret-as",
+        description: "Specifies the interpretation, such as characters, digits, date, or time.",
+        example: "characters"
+      },
+      {
+        name: "format",
+        description: "Provides a format hint for the selected interpretation."
+      },
+      {
+        name: "detail",
+        description: "Provides an additional detail hint for the selected interpretation."
+      }
+    ]
+  },
+  {
+    name: "phoneme",
+    description: "Replaces normal pronunciation with the supplied phonetic pronunciation.",
+    parameters: [
+      {
+        name: "alphabet",
+        description: "The phonetic alphabet used by the `ph` value.",
+        values: PHONEME_ALPHABET_PRESETS2,
+        example: SSML_PRESET_EXAMPLES2.phonemeAlphabet
+      },
+      {
+        name: "ph",
+        description: "The phonetic pronunciation for the enclosed text.",
+        example: "h\u0259\u02C8lo\u028A"
+      }
+    ]
+  },
+  {
+    name: "emphasis",
+    description: "Adds emphasis to the enclosed text.",
+    parameters: [
+      {
+        name: "level",
+        description: "Controls the amount of emphasis.",
+        values: EMPHASIS_LEVEL_PRESETS2
+      }
+    ]
+  },
+  {
+    name: "audio",
+    description: "Plays an audio file as part of the synthesized output.",
+    parameters: [
+      {
+        name: "src",
+        description: "The URI of the audio file.",
+        example: "https://example.com/intro.wav"
+      },
+      {
+        name: "desc",
+        description: "Alternative text to use if the audio cannot be played."
+      },
+      {
+        name: "clipBegin",
+        description: "The starting offset within the audio file.",
+        example: "0s"
+      },
+      {
+        name: "clipEnd",
+        description: "The ending offset within the audio file.",
+        example: "5s"
+      },
+      {
+        name: "speed",
+        description: "The playback speed of the audio file.",
+        example: "1.0"
+      },
+      {
+        name: "repeatCount",
+        description: "The number of times to repeat the audio.",
+        example: "2"
+      },
+      {
+        name: "repeatDuration",
+        description: "The total duration for which the audio may repeat.",
+        example: "10s"
+      },
+      {
+        name: "soundLevel",
+        description: "The audio volume adjustment in decibels.",
+        example: "-3dB"
+      }
+    ]
+  },
+  {
+    name: "sub",
+    description: "Substitutes the alias text when speaking the enclosed text.",
+    parameters: [
+      {
+        name: "alias",
+        description: "The text to speak instead of the enclosed text.",
+        example: "World Wide Web"
+      }
+    ]
+  },
+  {
+    name: "lang",
+    description: "Changes the language used for the enclosed text.",
+    parameters: [
+      {
+        name: "xml:lang",
+        aliases: ["lang"],
+        description: "The BCP-47 language tag.",
+        example: "ja-JP"
+      }
+    ]
+  },
+  {
+    name: "mark",
+    description: "Inserts a custom marker into the synthesized audio stream.",
+    parameters: [
+      {
+        name: "name",
+        description: "The application-defined marker name.",
+        example: "chapter-1"
+      }
+    ]
+  },
+  {
+    name: "bookmark",
+    description: "Inserts a bookmark marker into the synthesized audio stream.",
+    parameters: [
+      {
+        name: "mark",
+        description: "The application-defined bookmark name.",
+        example: "chapter-1"
+      }
+    ]
+  },
+  {
+    name: "lexicon",
+    description: "Associates a pronunciation lexicon with the synthesized document.",
+    parameters: [
+      {
+        name: "uri",
+        description: "The URI of the pronunciation lexicon.",
+        example: "https://example.com/lexicon.pls"
+      }
+    ]
+  },
+  {
+    name: "p",
+    description: "Groups text into a paragraph.",
+    parameters: []
+  },
+  {
+    name: "s",
+    description: "Groups text into a sentence.",
+    parameters: []
+  },
+  {
+    name: "w",
+    description: "Groups text into a word.",
+    parameters: []
+  },
+  {
+    name: "mstts:silence",
+    aliases: ["silence"],
+    description: "Adds a specified silence before or after text or at a punctuation boundary.",
+    parameters: [
+      {
+        name: "type",
+        description: "The silence position or punctuation boundary.",
+        values: SILENCE_TYPE_PRESETS2
+      },
+      {
+        name: "value",
+        description: "The silence duration, for example `300ms`.",
+        example: SSML_PRESET_EXAMPLES2.silenceValue
+      }
+    ]
+  },
+  {
+    name: "mstts:viseme",
+    aliases: ["viseme"],
+    description: "Requests viseme events for the synthesized audio.",
+    parameters: [
+      {
+        name: "type",
+        description: "The viseme event format.",
+        values: VISEME_TYPE_PRESETS2
+      }
+    ]
+  }
+];
+var definitionsByName = /* @__PURE__ */ new Map();
+for (const definition of SSML_TAG_DEFINITIONS) {
+  definitionsByName.set(definition.name, definition);
+  for (const alias of definition.aliases ?? []) {
+    definitionsByName.set(alias, definition);
+  }
+}
+function isXmlNameStart3(value) {
+  return value !== void 0 && /[A-Za-z_]/.test(value);
+}
+function isXmlNameCharacter3(value) {
+  return value !== void 0 && /[A-Za-z0-9_.:-]/.test(value);
+}
+function isXmlWhitespace3(value) {
+  return value === " " || value === "	" || value === "\r" || value === "\n";
+}
+function positionToOffset(source, lineNumber, column) {
+  if (!Number.isInteger(lineNumber) || !Number.isInteger(column) || lineNumber < 1 || column < 1) {
+    return void 0;
+  }
+  let lineStart = 0;
+  for (let line = 1; line < lineNumber; line += 1) {
+    const newline = source.indexOf("\n", lineStart);
+    if (newline === -1) {
+      return void 0;
+    }
+    lineStart = newline + 1;
+  }
+  const lineEnd = source.indexOf("\n", lineStart);
+  const lineLength = lineEnd === -1 ? source.length - lineStart : lineEnd - lineStart;
+  if (column > lineLength + 1) {
+    return void 0;
+  }
+  return lineStart + column - 1;
+}
+function offsetToPosition(source, offset) {
+  const lastNewline = source.lastIndexOf("\n", offset - 1);
+  const lineNumber = source.slice(0, offset).split("\n").length;
+  return {
+    lineNumber,
+    column: offset - lastNewline
+  };
+}
+function toRange(source, token) {
+  const start = offsetToPosition(source, token.start);
+  const end = offsetToPosition(source, token.end);
+  return {
+    startLineNumber: start.lineNumber,
+    startColumn: start.column,
+    endLineNumber: end.lineNumber,
+    endColumn: end.column
+  };
+}
+function containsOffset(token, offset) {
+  return offset >= token.start && offset < token.end;
+}
+function findTagEnd2(source, start) {
+  let quote;
+  for (let index = start; index < source.length; index += 1) {
+    const character = source[index];
+    if (quote !== void 0) {
+      if (character === quote) {
+        quote = void 0;
+      }
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === ">") {
+      return index;
+    }
+  }
+  return void 0;
+}
+function parseTag(source, start, contentEnd, tokenEnd) {
+  let index = start + 1;
+  let closing = false;
+  if (source[index] === "/") {
+    closing = true;
+    index += 1;
+  }
+  while (index < contentEnd && isXmlWhitespace3(source[index])) {
+    index += 1;
+  }
+  if (!isXmlNameStart3(source[index])) {
+    return void 0;
+  }
+  const nameStart = index;
+  index += 1;
+  while (index < contentEnd && isXmlNameCharacter3(source[index])) {
+    index += 1;
+  }
+  const nameEnd = index;
+  const attributes = [];
+  if (!closing) {
+    while (index < contentEnd) {
+      while (index < contentEnd && isXmlWhitespace3(source[index])) {
+        index += 1;
+      }
+      if (index >= contentEnd || source[index] === "/") {
+        break;
+      }
+      if (!isXmlNameStart3(source[index])) {
+        index += 1;
+        continue;
+      }
+      const attributeStart = index;
+      index += 1;
+      while (index < contentEnd && isXmlNameCharacter3(source[index])) {
+        index += 1;
+      }
+      const attributeEnd = index;
+      while (index < contentEnd && isXmlWhitespace3(source[index])) {
+        index += 1;
+      }
+      let value;
+      if (source[index] === "=") {
+        index += 1;
+        while (index < contentEnd && isXmlWhitespace3(source[index])) {
+          index += 1;
+        }
+        const quote = source[index];
+        if (quote === '"' || quote === "'") {
+          index += 1;
+          const valueStart = index;
+          while (index < contentEnd && source[index] !== quote) {
+            index += 1;
+          }
+          value = { start: valueStart, end: index };
+          if (index < contentEnd) {
+            index += 1;
+          }
+        } else {
+          const valueStart = index;
+          while (index < contentEnd && !isXmlWhitespace3(source[index]) && source[index] !== "/") {
+            index += 1;
+          }
+          value = { start: valueStart, end: index };
+        }
+      }
+      attributes.push({
+        name: { start: attributeStart, end: attributeEnd },
+        value
+      });
+    }
+  }
+  return {
+    name: source.slice(nameStart, nameEnd),
+    nameRange: { start: nameStart, end: nameEnd },
+    start,
+    end: tokenEnd,
+    closing,
+    attributes
+  };
+}
+function findTagAtOffset(source, offset) {
+  let searchStart = 0;
+  while (searchStart < source.length) {
+    const start = source.indexOf("<", searchStart);
+    if (start === -1 || start > offset) {
+      return void 0;
+    }
+    if (source.startsWith("<!--", start)) {
+      const commentEnd = source.indexOf("-->", start + 4);
+      const tokenEnd2 = commentEnd === -1 ? source.length : commentEnd + 3;
+      if (offset < tokenEnd2) {
+        return void 0;
+      }
+      searchStart = tokenEnd2;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", start)) {
+      const cdataEnd = source.indexOf("]]>", start + 9);
+      const tokenEnd2 = cdataEnd === -1 ? source.length : cdataEnd + 3;
+      if (offset < tokenEnd2) {
+        return void 0;
+      }
+      searchStart = tokenEnd2;
+      continue;
+    }
+    if (source.startsWith("<?", start)) {
+      const processingEnd = source.indexOf("?>", start + 2);
+      const tokenEnd2 = processingEnd === -1 ? source.length : processingEnd + 2;
+      if (offset < tokenEnd2) {
+        return void 0;
+      }
+      searchStart = tokenEnd2;
+      continue;
+    }
+    const tagEnd = findTagEnd2(source, start + 1);
+    const contentEnd = tagEnd ?? source.length;
+    const tokenEnd = tagEnd === void 0 ? source.length : tagEnd + 1;
+    if (offset < tokenEnd) {
+      return parseTag(source, start, contentEnd, tokenEnd);
+    }
+    if (tagEnd === void 0) {
+      return void 0;
+    }
+    searchStart = tokenEnd;
+  }
+  return void 0;
+}
+function findParameter(definition, name) {
+  return definition.parameters.find(
+    (parameter) => parameter.name === name || parameter.aliases?.includes(name) === true
+  );
+}
+function getSsmlTagDefinition(name) {
+  return definitionsByName.get(name);
+}
+function findSsmlHoverTarget(source, lineNumber, column) {
+  const offset = positionToOffset(source, lineNumber, column);
+  if (offset === void 0) {
+    return void 0;
+  }
+  const tag = findTagAtOffset(source, offset);
+  if (!tag) {
+    return void 0;
+  }
+  const definition = getSsmlTagDefinition(tag.name);
+  if (!definition) {
+    return void 0;
+  }
+  if (containsOffset(tag.nameRange, offset)) {
+    return {
+      kind: "tag",
+      tagName: tag.name,
+      isClosingTag: tag.closing,
+      definition,
+      range: toRange(source, tag.nameRange)
+    };
+  }
+  for (const attribute of tag.attributes) {
+    if (containsOffset(attribute.name, offset)) {
+      const parameter = findParameter(definition, source.slice(attribute.name.start, attribute.name.end));
+      if (!parameter) {
+        return void 0;
+      }
+      return {
+        kind: "parameter",
+        tagName: tag.name,
+        isClosingTag: tag.closing,
+        definition,
+        parameter,
+        range: toRange(source, attribute.name)
+      };
+    }
+    if (attribute.value && containsOffset(attribute.value, offset)) {
+      const parameter = findParameter(definition, source.slice(attribute.name.start, attribute.name.end));
+      if (!parameter) {
+        return void 0;
+      }
+      return {
+        kind: "parameter-value",
+        tagName: tag.name,
+        isClosingTag: tag.closing,
+        definition,
+        parameter,
+        range: toRange(source, attribute.value)
+      };
+    }
+  }
+  return void 0;
+}
+function code(value) {
+  return `\`${value.replace(/\\/g, "\\\\").replace(/`/g, "\\`")}\``;
+}
+function formatParameter(parameter, tagName, locale) {
+  const localizedParameter = SSML_HOVER_COPY[locale].tags[tagName]?.parameters[parameter.name];
+  const description = localizedParameter?.description ?? parameter.description;
+  const values = parameter.values && parameter.values.length > 0 ? ` ${SSML_HOVER_COPY[locale].allowedValues}: ${parameter.values.map(code).join(", ")}.` : "";
+  const example = parameter.example ? ` ${SSML_HOVER_COPY[locale].example}: ${code(parameter.example)}.` : "";
+  return `- ${code(parameter.name)}: ${description}${values}${example}`;
+}
+function formatSsmlHover(target, locale = "en") {
+  const localizedTag = SSML_HOVER_COPY[locale].tags[target.definition.name];
+  const tagTitle = localizedTag?.title ?? target.definition.name;
+  const tagDescription = localizedTag?.description ?? target.definition.description;
+  const tagSyntax = target.isClosingTag ? `</${target.tagName}>` : `<${target.tagName}>`;
+  const lines = [`### ${code(tagSyntax)}`, "", `**${tagTitle}**`, "", tagDescription];
+  if (target.parameter) {
+    const localizedParameter = localizedTag?.parameters[target.parameter.name];
+    const parameterTitle = localizedParameter?.title ?? target.parameter.name;
+    const parameterDescription = localizedParameter?.description ?? target.parameter.description;
+    lines.push("", `**${SSML_HOVER_COPY[locale].parameterHeading} ${code(parameterTitle)}**`, "", parameterDescription);
+    if (target.parameter.values && target.parameter.values.length > 0) {
+      lines.push("", `${SSML_HOVER_COPY[locale].allowedValues}: ${target.parameter.values.map(code).join(", ")}.`);
+    }
+    if (target.parameter.example) {
+      lines.push("", `${SSML_HOVER_COPY[locale].example}: ${code(target.parameter.example)}.`);
+    }
+  } else if (target.definition.parameters.length > 0) {
+    lines.push(
+      "",
+      `**${SSML_HOVER_COPY[locale].parametersHeading}**`,
+      "",
+      ...target.definition.parameters.map((parameter) => formatParameter(parameter, target.definition.name, locale))
+    );
+  } else {
+    lines.push("", SSML_HOVER_COPY[locale].noParameters);
+  }
+  return lines.join("\n");
+}
+
+// packages/ssml-editor-react/src/constants/ui.ts
+var DEFAULT_LOCALE = "ja";
+var OVERLAY_Z_INDEX = 9999;
+var SELECTION_OVERLAY_ABOVE_THRESHOLD_LINES = 4;
+var SSML_INSERTION_MODES = {
+  insert: "insert",
+  wrap: "wrap"
+};
+
+// packages/ssml-editor-react/src/ssmlInsertion.ts
+function isLineStart(value, offset) {
+  return offset === 0 || value[offset - 1] === "\n" || value[offset - 1] === "\r";
+}
+function isLineEnd(value, offset) {
+  return offset === value.length || value[offset] === "\n" || value[offset] === "\r";
+}
+function startsWithLineBreak(value) {
+  return value.startsWith("\n") || value.startsWith("\r");
+}
+function endsWithLineBreak(value) {
+  return value.endsWith("\n") || value.endsWith("\r");
+}
+function createSsmlInsertionEdit(source, startOffset, endOffset, template) {
+  const selectedText = source.slice(startOffset, endOffset);
+  if (template.mode === SSML_INSERTION_MODES.wrap) {
+    return {
+      replacement: `${template.prefix}${selectedText}${template.suffix}`,
+      selectionOffset: template.prefix.length
+    };
+  }
+  const leadingLineBreak = !isLineStart(source, startOffset) && !startsWithLineBreak(template.prefix) ? "\n" : "";
+  const needsTrailingLineBreak = selectedText.length > 0 ? !selectedText.startsWith("\n") && !selectedText.startsWith("\r") : !isLineEnd(source, endOffset);
+  const trailingLineBreak = needsTrailingLineBreak && !endsWithLineBreak(template.prefix) ? "\n" : "";
+  const insertionPrefix = `${leadingLineBreak}${template.prefix}`;
+  return {
+    replacement: `${insertionPrefix}${trailingLineBreak}${selectedText}`,
+    selectionOffset: insertionPrefix.length + (selectedText.length > 0 ? trailingLineBreak.length : 0)
+  };
+}
+
+// packages/ssml-editor-react/src/SsmlEditor.tsx
+var SSML_MARKER_OWNER = "ssml-builder";
+var UNGROUPED_TOOLBAR_GROUP = "__ssml-editor-ungrouped__";
+var EDITABLE_SSML_PREFIX = '<speak version="1.0" xml:lang="en-US">';
+var EDITABLE_SSML_SUFFIX = "</speak>";
+function localizedText(value) {
+  return { ja: value, en: value };
+}
+function escapeXmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;");
+}
+function createSsmlEditorInsertionDefinition(definition) {
+  const mode = definition.mode ?? "wrap";
+  const attribute = definition.attribute ? ` ${definition.attribute}="` : "";
+  return {
+    id: definition.id,
+    icon: definition.icon ?? "\uFF0B",
+    tagName: definition.tagName,
+    selfClosing: mode === "insert",
+    labels: definition.labels,
+    titles: definition.titles,
+    descriptions: definition.descriptions ?? localizedText(`Inserts the <${definition.tagName}> element.`),
+    parameterDescription: definition.parameterDescription ?? localizedText(`Selects the value for the <${definition.tagName}> element.`),
+    options: definition.options,
+    createTemplate: (value) => {
+      const attributeValue = definition.attribute ? `${attribute}${escapeXmlAttribute(value)}"` : "";
+      if (mode === "wrap") {
+        return {
+          prefix: `<${definition.tagName}${attributeValue}>`,
+          suffix: `</${definition.tagName}>`,
+          mode
+        };
+      }
+      return {
+        prefix: `<${definition.tagName}${attributeValue}/>`,
+        suffix: "",
+        mode
+      };
+    }
+  };
+}
+function createInsertionOptions(values, descriptions) {
+  return values.map((value) => ({
+    value,
+    labels: { ja: value, en: value },
+    ...descriptions?.[value] ? { descriptions: descriptions[value] } : {}
+  }));
+}
+var SSML_INSERTIONS = [
+  {
+    id: "break",
+    icon: "\u23F8",
+    tagName: "break",
+    selfClosing: true,
+    labels: { ja: "\u9593", en: "Break" },
+    descriptions: {
+      ja: "\u6307\u5B9A\u3057\u305F\u6642\u9593\u3060\u3051\u7121\u97F3\u306E\u9593\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+      en: "Inserts a silent pause for the selected duration."
+    },
+    parameterDescription: {
+      ja: "\u7121\u97F3\u306B\u3059\u308B\u6642\u9593\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the duration of the silent pause."
+    },
+    options: createInsertionOptions(BREAK_TIME_PRESETS, BREAK_TIME_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<break time="${value}"/>`,
+      suffix: "",
+      mode: "insert"
+    })
+  },
+  {
+    id: "emphasis",
+    icon: "\u2726",
+    tagName: "emphasis",
+    labels: { ja: "\u5F37\u8ABF", en: "Emphasis" },
+    descriptions: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u5F37\u8ABF\u30EC\u30D9\u30EB\u3092\u5909\u66F4\u3057\u307E\u3059\u3002",
+      en: "Changes the emphasis level of the selected text."
+    },
+    parameterDescription: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u5F37\u8ABF\u30EC\u30D9\u30EB\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the emphasis level for the selected text."
+    },
+    options: createInsertionOptions(EMPHASIS_LEVEL_PRESETS, EMPHASIS_LEVEL_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<emphasis level="${value}">`,
+      suffix: "</emphasis>",
+      mode: "wrap"
+    })
+  },
+  {
+    id: "rate",
+    icon: "\u2195",
+    tagName: "prosody",
+    labels: { ja: "\u901F\u5EA6", en: "Rate" },
+    descriptions: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u8AAD\u307F\u4E0A\u3052\u901F\u5EA6\u3092\u5909\u66F4\u3057\u307E\u3059\u3002",
+      en: "Changes the speech rate of the selected text."
+    },
+    parameterDescription: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u8AAD\u307F\u4E0A\u3052\u901F\u5EA6\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the speech rate for the selected text."
+    },
+    options: createInsertionOptions(PROSODY_RATE_PRESETS, PROSODY_RATE_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<prosody rate="${value}">`,
+      suffix: "</prosody>",
+      mode: "wrap"
+    })
+  },
+  {
+    id: "pitch",
+    icon: "\u2197",
+    tagName: "prosody",
+    labels: { ja: "\u9AD8\u3055", en: "Pitch" },
+    descriptions: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u58F0\u306E\u9AD8\u3055\u3092\u5909\u66F4\u3057\u307E\u3059\u3002",
+      en: "Changes the pitch of the selected text."
+    },
+    parameterDescription: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u58F0\u306E\u9AD8\u3055\u3092\u534A\u97F3\u5358\u4F4D\u3067\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the pitch adjustment in semitone steps."
+    },
+    options: createInsertionOptions(PROSODY_PITCH_PRESETS, PROSODY_PITCH_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<prosody pitch="${value}">`,
+      suffix: "</prosody>",
+      mode: "wrap"
+    })
+  },
+  {
+    id: "volume",
+    icon: "\u{1F50A}",
+    tagName: "prosody",
+    labels: { ja: "\u97F3\u91CF", en: "Volume" },
+    descriptions: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u97F3\u91CF\u3092\u5909\u66F4\u3057\u307E\u3059\u3002",
+      en: "Changes the volume of the selected text."
+    },
+    parameterDescription: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u97F3\u91CF\u30EC\u30D9\u30EB\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the volume level for the selected text."
+    },
+    options: createInsertionOptions(PROSODY_VOLUME_PRESETS, PROSODY_VOLUME_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<prosody volume="${value}">`,
+      suffix: "</prosody>",
+      mode: "wrap"
+    })
+  },
+  {
+    id: "emotion",
+    icon: "\u263A",
+    tagName: "mstts:express-as",
+    labels: { ja: "\u611F\u60C5", en: "Emotion" },
+    descriptions: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306B\u97F3\u58F0\u306E\u611F\u60C5\u30B9\u30BF\u30A4\u30EB\u3092\u9069\u7528\u3057\u307E\u3059\u3002",
+      en: "Applies a voice emotion style to the selected text."
+    },
+    parameterDescription: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306B\u9069\u7528\u3059\u308B\u97F3\u58F0\u306E\u611F\u60C5\u30B9\u30BF\u30A4\u30EB\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the voice emotion style to apply."
+    },
+    options: createInsertionOptions(EXPRESS_AS_STYLE_PRESETS, EXPRESS_AS_STYLE_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<mstts:express-as style="${value}">`,
+      suffix: "</mstts:express-as>",
+      mode: "wrap"
+    })
+  },
+  {
+    id: "say-as",
+    icon: "Aa",
+    tagName: "say-as",
+    labels: { ja: "\u8AAD\u307F\u4E0A\u3052", en: "Say as" },
+    descriptions: {
+      ja: "\u6570\u5B57\u3084\u65E5\u4ED8\u306A\u3069\u306E\u8AAD\u307F\u4E0A\u3052\u65B9\u3092\u6307\u5B9A\u3057\u307E\u3059\u3002",
+      en: "Specifies how values such as numbers or dates are spoken."
+    },
+    parameterDescription: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u8AAD\u307F\u4E0A\u3052\u65B9\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects how the selected text is spoken."
+    },
+    options: createInsertionOptions(SAY_AS_PRESETS, SAY_AS_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<say-as interpret-as="${value}">`,
+      suffix: "</say-as>",
+      mode: "wrap"
+    })
+  },
+  {
+    id: "lang",
+    icon: "\u6587",
+    tagName: "lang",
+    labels: { ja: "\u8A00\u8A9E", en: "Language" },
+    descriptions: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306E\u8AAD\u307F\u4E0A\u3052\u8A00\u8A9E\u3092\u5909\u66F4\u3057\u307E\u3059\u3002",
+      en: "Changes the speaking language of the selected text."
+    },
+    parameterDescription: {
+      ja: "\u9078\u629E\u7BC4\u56F2\u306B\u9069\u7528\u3059\u308B BCP-47 \u8A00\u8A9E\u30BF\u30B0\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the BCP-47 language tag for the selected text."
+    },
+    options: createInsertionOptions(LANGUAGE_PRESETS, LANGUAGE_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<lang xml:lang="${value}">`,
+      suffix: "</lang>",
+      mode: "wrap"
+    })
+  },
+  {
+    id: "mstts:silence",
+    icon: "\u23F3",
+    tagName: "mstts:silence",
+    selfClosing: true,
+    labels: { ja: "\u7121\u97F3", en: "Silence" },
+    descriptions: {
+      ja: "\u7121\u97F3\u6642\u9593\u3092\u633F\u5165\u3057\u307E\u3059\u3002",
+      en: "Inserts a silence interval."
+    },
+    parameterDescription: {
+      ja: "\u7121\u97F3\u306B\u3059\u308B\u6642\u9593\u3092\u9078\u629E\u3057\u307E\u3059\u3002",
+      en: "Selects the silence duration."
+    },
+    options: createInsertionOptions(SILENCE_VALUE_PRESETS, SILENCE_VALUE_DESCRIPTIONS),
+    createTemplate: (value) => ({
+      prefix: `<mstts:silence type="Leading" value="${value}"/>`,
+      suffix: "",
+      mode: "insert"
+    })
+  }
+];
+var DEFAULT_INSERTION_GROUPS = [
+  {
+    id: "pauses",
+    labels: { ja: "\u9593\u30FB\u7121\u97F3", en: "Pauses" },
+    insertionIds: ["break", "mstts:silence"]
+  },
+  {
+    id: "prosody",
+    labels: { ja: "\u58F0\u306E\u8ABF\u6574", en: "Voice" },
+    insertionIds: ["rate", "pitch", "volume"]
+  },
+  {
+    id: "expression",
+    labels: { ja: "\u8868\u73FE", en: "Expression" },
+    insertionIds: ["emphasis", "emotion"]
+  },
+  {
+    id: "pronunciation",
+    labels: { ja: "\u8AAD\u307F\u4E0A\u3052", en: "Pronunciation" },
+    insertionIds: ["say-as", "lang"]
+  }
+];
+function createDefaultToolbarGroups(insertionGroups) {
+  return [
+    {
+      id: "history",
+      buttonIds: ["undo", "redo"]
+    },
+    ...insertionGroups.map(({ id, insertionIds }) => ({
+      id,
+      buttonIds: insertionIds
+    })),
+    {
+      id: "document",
+      buttonIds: ["clearAll", "format", "decorations"]
+    },
+    {
+      id: "help",
+      buttonIds: ["help"]
+    }
+  ];
+}
+function getInsertionCollection(collection) {
+  if (!collection) {
+    return [];
+  }
+  return Array.isArray(collection) ? collection : Object.values(collection).filter((insertion) => insertion !== void 0);
+}
+function getConfiguredInsertions(emotionStyles, customInsertions, additionalInsertions) {
+  const insertions = /* @__PURE__ */ new Map();
+  for (const insertion of SSML_INSERTIONS) {
+    if (insertion.id === "emotion" && emotionStyles !== void 0) {
+      insertions.set(insertion.id, {
+        ...insertion,
+        options: createInsertionOptions(emotionStyles)
+      });
+      continue;
+    }
+    insertions.set(insertion.id, insertion);
+  }
+  const normalizeInsertion = (insertion) => "createTemplate" in insertion ? insertion : createSsmlEditorInsertionDefinition(insertion);
+  for (const insertion of getInsertionCollection(additionalInsertions)) {
+    const normalized = normalizeInsertion(insertion);
+    if (!insertions.has(normalized.id)) {
+      insertions.set(normalized.id, normalized);
+    }
+  }
+  for (const insertion of getInsertionCollection(customInsertions)) {
+    const normalized = normalizeInsertion(insertion);
+    insertions.set(normalized.id, normalized);
+  }
+  return [...insertions.values()];
+}
+function orderInsertions(insertions, insertionOrder) {
+  if (!insertionOrder || insertionOrder.length === 0) {
+    return insertions;
+  }
+  const insertionsById = new Map(insertions.map((insertion) => [insertion.id, insertion]));
+  const ordered = [];
+  const included = /* @__PURE__ */ new Set();
+  for (const id of insertionOrder) {
+    const insertion = insertionsById.get(id);
+    if (insertion && !included.has(id)) {
+      ordered.push(insertion);
+      included.add(id);
+    }
+  }
+  for (const insertion of insertions) {
+    if (!included.has(insertion.id)) {
+      ordered.push(insertion);
+    }
+  }
+  return ordered;
+}
+function orderToolbarButtons(buttonIds, toolbarOrder) {
+  if (!toolbarOrder || toolbarOrder.length === 0) {
+    return buttonIds;
+  }
+  const available = new Set(buttonIds);
+  const ordered = [];
+  const included = /* @__PURE__ */ new Set();
+  for (const id of toolbarOrder) {
+    if (available.has(id) && !included.has(id)) {
+      ordered.push(id);
+      included.add(id);
+    }
+  }
+  for (const id of buttonIds) {
+    if (!included.has(id)) {
+      ordered.push(id);
+    }
+  }
+  return ordered;
+}
+function getInsertionTitle(insertion, language) {
+  if (insertion.titles) {
+    return insertion.titles[language];
+  }
+  const tag = insertion.tagName ? ` <${insertion.tagName}${insertion.selfClosing ? "/>" : ">"}` : "";
+  return `${insertion.labels[language]}${tag} \u2014 ${insertion.descriptions[language]}`;
+}
+var STYLE_ID = "ssml-editor-theme";
+var STYLE_CSS = `
+[data-ssml-editor] {
+  --ssml-editor-color: #111827;
+  --ssml-editor-bg: #ffffff;
+  --ssml-editor-border: #d1d5db;
+  --ssml-editor-control-bg: #f9fafb;
+  --ssml-editor-control-border: #9ca3af;
+  --ssml-editor-preview-bg: #f3f4f6;
+  --ssml-editor-error: #b91c1c;
+  --ssml-editor-error-bg: #fef2f2;
+  --ssml-editor-switch-active: #2563eb;
+  --ssml-editor-pause-badge-bg: #e0e7ff;
+  --ssml-editor-pause-badge-color: #3730a3;
+  --ssml-editor-pause-badge-border: #c7d2fe;
+  --ssml-editor-prosody-badge-bg: #dcfce7;
+  --ssml-editor-prosody-badge-color: #166534;
+  --ssml-editor-prosody-badge-border: #86efac;
+}
+[data-ssml-editor][data-theme="dark"] {
+  --ssml-editor-color: #f9fafb;
+  --ssml-editor-bg: #1f2937;
+  --ssml-editor-border: #374151;
+  --ssml-editor-control-bg: #111827;
+  --ssml-editor-control-border: #4b5563;
+  --ssml-editor-preview-bg: #111827;
+  --ssml-editor-error: #fca5a5;
+  --ssml-editor-error-bg: #450a0a;
+  --ssml-editor-switch-active: #60a5fa;
+  --ssml-editor-pause-badge-bg: #312e81;
+  --ssml-editor-pause-badge-color: #c7d2fe;
+  --ssml-editor-pause-badge-border: #6366f1;
+  --ssml-editor-prosody-badge-bg: #14532d;
+  --ssml-editor-prosody-badge-color: #bbf7d0;
+  --ssml-editor-prosody-badge-border: #4ade80;
+}
+[data-ssml-editor] .ssml-editor-inline-badge {
+  display: inline-block;
+  margin-left: 0.35em;
+  padding: 0 0.35em;
+  border: 1px solid;
+  border-radius: 999px;
+  font-size: 0.75em;
+  font-weight: 600;
+  line-height: 1.4;
+  white-space: nowrap;
+  vertical-align: middle;
+  pointer-events: none;
+}
+[data-ssml-editor] .ssml-editor-inline-badge-pause {
+  color: var(--ssml-editor-pause-badge-color);
+  background-color: var(--ssml-editor-pause-badge-bg);
+  border-color: var(--ssml-editor-pause-badge-border);
+}
+[data-ssml-editor] .ssml-editor-inline-badge-prosody {
+  color: var(--ssml-editor-prosody-badge-color);
+  background-color: var(--ssml-editor-prosody-badge-bg);
+  border-color: var(--ssml-editor-prosody-badge-border);
+}
+[data-ssml-editor] .ssml-editor-switch-track[aria-checked="true"] {
+  background-color: var(--ssml-editor-switch-active);
+}
+[data-ssml-editor] .ssml-editor-switch-track[aria-checked="true"] .ssml-editor-switch-thumb {
+  transform: translateX(1.25rem);
+}
+[data-ssml-editor] .ssml-editor-switch-track:focus-visible {
+  outline: 2px solid var(--ssml-editor-switch-active);
+  outline-offset: 2px;
+}
+[data-ssml-editor] .ssml-editor-help-settings-summary {
+  list-style: none;
+}
+[data-ssml-editor] .ssml-editor-help-settings-summary::-webkit-details-marker {
+  display: none;
+}
+[data-ssml-editor] .ssml-editor-help-settings-summary:hover {
+  background-color: var(--ssml-editor-preview-bg);
+}
+[data-ssml-editor] .ssml-editor-help-settings-summary:focus-visible {
+  outline: 2px solid var(--ssml-editor-control-border);
+  outline-offset: -2px;
+}
+[data-ssml-editor] .ssml-editor-help-settings-summary::before {
+  content: "\u25B8";
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 1rem;
+  line-height: 1.45;
+}
+[data-ssml-editor]
+  .ssml-editor-help-settings-accordion[open]
+  > .ssml-editor-help-settings-summary::before {
+  content: "\u25BE";
+}
+`.trim();
+function injectEditorTheme() {
+  if (typeof document !== "undefined" && !document.getElementById(STYLE_ID)) {
+    const style = document.createElement("style");
+    style.id = STYLE_ID;
+    style.textContent = STYLE_CSS;
+    document.head.appendChild(style);
+  }
+}
+var styles = {
+  container: {
+    display: "grid",
+    gap: "0.75rem",
+    padding: "1rem",
+    border: "1px solid var(--ssml-editor-border)",
+    borderRadius: "0.5rem",
+    color: "var(--ssml-editor-color)",
+    backgroundColor: "var(--ssml-editor-bg)"
+  },
+  toolbarContainer: {
+    display: "flex",
+    alignItems: "center",
+    flexWrap: "wrap",
+    gap: "0.5rem"
+  },
+  toolbarActions: {
+    display: "flex",
+    alignItems: "center",
+    flexWrap: "wrap",
+    gap: "0.5rem"
+  },
+  toolbarSeparator: {
+    width: "1px",
+    height: "2.25rem",
+    margin: "0 0.25rem",
+    backgroundColor: "var(--ssml-editor-border)"
+  },
+  toolbarDropdown: {
+    position: "relative",
+    display: "inline-block"
+  },
+  toolbarSwitch: {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "0.375rem",
+    minHeight: "2.25rem",
+    color: "var(--ssml-editor-color)",
+    font: "inherit"
+  },
+  toolbarSwitchTrack: {
+    display: "inline-flex",
+    alignItems: "center",
+    width: "2.75rem",
+    height: "1.5rem",
+    padding: "0.1875rem",
+    border: 0,
+    borderRadius: "999px",
+    backgroundColor: "var(--ssml-editor-control-border)",
+    cursor: "pointer",
+    font: "inherit",
+    transition: "background-color 0.2s ease"
+  },
+  toolbarSwitchThumb: {
+    width: "1.125rem",
+    height: "1.125rem",
+    borderRadius: "50%",
+    backgroundColor: "var(--ssml-editor-bg)",
+    transition: "transform 0.2s ease"
+  },
+  toolbarButton: {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "0.375rem",
+    minHeight: "2.25rem",
+    padding: "0.375rem 0.625rem",
+    border: "1px solid var(--ssml-editor-control-border)",
+    borderRadius: "0.25rem",
+    color: "var(--ssml-editor-color)",
+    backgroundColor: "var(--ssml-editor-control-bg)",
+    font: "inherit",
+    cursor: "pointer"
+  },
+  display: {
+    display: "grid",
+    gap: "0.5rem"
+  },
+  toolbarIconOnly: {
+    justifyContent: "center",
+    minWidth: "2.25rem",
+    padding: "0.375rem"
+  },
+  toolbarIcon: {
+    display: "inline-flex",
+    width: "1.25rem",
+    justifyContent: "center",
+    fontSize: "1.1rem",
+    lineHeight: 1
+  },
+  toolbarChevron: {
+    fontSize: "0.7rem",
+    lineHeight: 1
+  },
+  toolbarMenu: {
+    position: "fixed",
+    zIndex: OVERLAY_Z_INDEX,
+    display: "grid",
+    minWidth: "max-content",
+    maxHeight: "min(24rem, calc(100vh - 1rem))",
+    gap: "0.125rem",
+    padding: "0.25rem",
+    border: "1px solid var(--ssml-editor-control-border)",
+    borderRadius: "0.25rem",
+    backgroundColor: "var(--ssml-editor-control-bg)",
+    boxShadow: "0 0.25rem 0.75rem rgb(0 0 0 / 20%)",
+    overflowY: "auto"
+  },
+  toolbarOption: {
+    padding: "0.375rem 0.5rem",
+    border: 0,
+    borderRadius: "0.125rem",
+    color: "var(--ssml-editor-color)",
+    backgroundColor: "transparent",
+    font: "inherit",
+    textAlign: "left",
+    whiteSpace: "nowrap",
+    cursor: "pointer"
+  },
+  helpPanel: {
+    display: "grid",
+    gap: "0.5rem",
+    width: "100%",
+    padding: "0.75rem",
+    border: "1px solid var(--ssml-editor-control-border)",
+    borderRadius: "0.25rem",
+    backgroundColor: "var(--ssml-editor-preview-bg)"
+  },
+  helpHeading: {
+    margin: 0,
+    fontSize: "1rem"
+  },
+  helpDescription: {
+    margin: 0,
+    lineHeight: 1.5
+  },
+  helpList: {
+    display: "grid",
+    gap: "0.375rem",
+    margin: 0,
+    paddingLeft: "1.25rem"
+  },
+  helpItem: {
+    listStyleType: "none",
+    lineHeight: 1.45
+  },
+  helpIcon: {
+    display: "inline-flex",
+    width: "1.25rem",
+    justifyContent: "center",
+    fontSize: "1.1rem",
+    lineHeight: 1.45
+  },
+  helpSettingsAccordion: {
+    marginTop: "0.375rem",
+    overflow: "hidden",
+    border: "1px solid var(--ssml-editor-control-border)",
+    borderRadius: "0.25rem",
+    backgroundColor: "var(--ssml-editor-control-bg)"
+  },
+  helpSettingsSummary: {
+    display: "grid",
+    gridTemplateColumns: "1rem 1.25rem minmax(0, 1fr)",
+    columnGap: "0.5rem",
+    alignItems: "start",
+    padding: "0.5rem 0.625rem",
+    cursor: "pointer"
+  },
+  helpSettingsSummaryContent: {
+    minWidth: 0
+  },
+  helpSettingsDescription: {
+    margin: "0.5rem 0.75rem 0",
+    fontSize: "0.875rem"
+  },
+  helpSettingsList: {
+    display: "grid",
+    gap: "0.125rem",
+    margin: "0.25rem 0.75rem 0.75rem",
+    paddingLeft: "1.25rem",
+    fontSize: "0.875rem"
+  },
+  editor: {
+    boxSizing: "border-box",
+    position: "relative",
+    width: "100%",
+    minHeight: "8rem",
+    border: "1px solid var(--ssml-editor-control-border)",
+    borderRadius: "0.25rem",
+    overflow: "visible"
+  },
+  selectionActions: {
+    position: "absolute",
+    zIndex: OVERLAY_Z_INDEX,
+    display: "flex",
+    alignItems: "center",
+    flexWrap: "wrap",
+    gap: "0.25rem",
+    maxWidth: "calc(100% - 1rem)",
+    padding: "0.25rem",
+    border: "1px solid var(--ssml-editor-control-border)",
+    borderRadius: "0.375rem",
+    color: "var(--ssml-editor-color)",
+    backgroundColor: "var(--ssml-editor-control-bg)",
+    boxShadow: "0 0.25rem 0.75rem rgb(0 0 0 / 20%)"
+  },
+  selectionCount: {
+    padding: "0.25rem 0.375rem",
+    fontSize: "0.875rem",
+    fontWeight: 600,
+    whiteSpace: "nowrap"
+  },
+  selectionActionsDivider: {
+    width: "1px",
+    height: "1.5rem",
+    backgroundColor: "var(--ssml-editor-border)"
+  },
+  selectionActionButton: {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "0.25rem",
+    minHeight: "1.75rem",
+    padding: "0.25rem 0.375rem",
+    border: "1px solid var(--ssml-editor-control-border)",
+    borderRadius: "0.25rem",
+    color: "var(--ssml-editor-color)",
+    backgroundColor: "var(--ssml-editor-bg)",
+    font: "inherit",
+    fontSize: "0.875rem",
+    cursor: "pointer"
+  },
+  selectionActionIcon: {
+    display: "inline-flex",
+    width: "1rem",
+    justifyContent: "center",
+    lineHeight: 1
+  },
+  error: {
+    margin: 0,
+    padding: "0.5rem 0.75rem",
+    border: "1px solid var(--ssml-editor-error)",
+    borderRadius: "0.25rem",
+    color: "var(--ssml-editor-error)",
+    backgroundColor: "var(--ssml-editor-error-bg)",
+    lineHeight: 1.5
+  }
+};
+function ToolbarInsertionMenu({
+  insertion,
+  language,
+  isDarkTheme,
+  showToolbarIcons,
+  showToolbarText,
+  toolbarButtonStyle,
+  isReadOnly,
+  onApply
+}) {
+  const menuId = (0, import_react.useId)();
+  const triggerRef = (0, import_react.useRef)(null);
+  const menuRef = (0, import_react.useRef)(null);
+  const [isOpen, setIsOpen] = (0, import_react.useState)(false);
+  const [menuPosition, setMenuPosition] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (!isOpen) {
+      setMenuPosition(null);
+      return;
+    }
+    const updateMenuPosition = () => {
+      const trigger = triggerRef.current;
+      if (!trigger) {
+        return;
+      }
+      const triggerBounds = trigger.getBoundingClientRect();
+      setMenuPosition({
+        top: triggerBounds.bottom + 4,
+        left: triggerBounds.left
+      });
+    };
+    const handlePointerDown = (event) => {
+      const target = event.target;
+      if (target instanceof Node && !triggerRef.current?.contains(target) && !menuRef.current?.contains(target)) {
+        setIsOpen(false);
+      }
+    };
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        setIsOpen(false);
+        triggerRef.current?.focus();
+      }
+    };
+    updateMenuPosition();
+    window.addEventListener("resize", updateMenuPosition);
+    window.addEventListener("scroll", updateMenuPosition, true);
+    document.addEventListener("pointerdown", handlePointerDown);
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      window.removeEventListener("resize", updateMenuPosition);
+      window.removeEventListener("scroll", updateMenuPosition, true);
+      document.removeEventListener("pointerdown", handlePointerDown);
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [isOpen]);
+  const menu = isOpen && menuPosition && typeof document !== "undefined" && /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      ref: menuRef,
+      id: menuId,
+      "data-ssml-editor": "",
+      "data-theme": isDarkTheme ? "dark" : "light",
+      style: { ...styles.toolbarMenu, top: menuPosition.top, left: menuPosition.left },
+      role: "menu",
+      "aria-label": insertion.labels[language]
+    },
+    insertion.options.map((option) => /* @__PURE__ */ React.createElement(
+      "button",
+      {
+        key: option.value,
+        type: "button",
+        role: "menuitem",
+        style: styles.toolbarOption,
+        title: option.descriptions?.[language] ?? insertion.descriptions[language],
+        disabled: isReadOnly,
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => {
+          if (!isReadOnly) {
+            onApply(insertion, option);
+          }
+          setIsOpen(false);
+        }
+      },
+      option.labels[language]
+    ))
+  );
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { style: styles.toolbarDropdown }, /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      ref: triggerRef,
+      type: "button",
+      style: toolbarButtonStyle,
+      title: getInsertionTitle(insertion, language),
+      "aria-label": insertion.labels[language],
+      "aria-haspopup": "menu",
+      "aria-expanded": isOpen,
+      "aria-controls": isOpen ? menuId : void 0,
+      onClick: () => setIsOpen((open) => !open)
+    },
+    showToolbarIcons && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarIcon, "aria-hidden": "true" }, insertion.icon),
+    showToolbarText && /* @__PURE__ */ React.createElement("span", null, insertion.labels[language]),
+    /* @__PURE__ */ React.createElement("span", { style: styles.toolbarChevron, "aria-hidden": "true" }, "\u25BE")
+  )), menu && (0, import_react_dom.createPortal)(menu, document.body));
+}
+function ToolbarDecorationsSwitch({
+  copy,
+  showToolbarIcons,
+  showToolbarText,
+  decorationsVisible,
+  onVisibilityChange
+}) {
+  return /* @__PURE__ */ React.createElement("div", { style: styles.toolbarSwitch }, showToolbarIcons && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarIcon, "aria-hidden": "true" }, "\u2606"), showToolbarText && /* @__PURE__ */ React.createElement("span", null, copy.decorations), /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      type: "button",
+      className: "ssml-editor-switch-track",
+      style: styles.toolbarSwitchTrack,
+      role: "switch",
+      "aria-checked": decorationsVisible,
+      "aria-label": copy.decorations,
+      title: decorationsVisible ? copy.decorationsHideTitle : copy.decorationsShowTitle,
+      onClick: () => onVisibilityChange(!decorationsVisible)
+    },
+    /* @__PURE__ */ React.createElement("span", { className: "ssml-editor-switch-thumb", style: styles.toolbarSwitchThumb, "aria-hidden": "true" })
+  ));
+}
+var EMPTY_SELECTION_OVERLAY = {
+  selectedText: "",
+  characterCount: 0,
+  hasSelection: false,
+  position: null,
+  placement: "above"
+};
+var hoverProviderRegistrations = /* @__PURE__ */ new WeakMap();
+function updateSsmlMarkers(monaco, model, value, syntaxError) {
+  if (!syntaxError) {
+    monaco.editor.setModelMarkers(model, SSML_MARKER_OWNER, []);
+    return;
+  }
+  const startOffset = value.length === 0 ? 0 : Math.min(syntaxError.offset, value.length - 1);
+  const endOffset = Math.min(startOffset + 1, value.length);
+  const start = model.getPositionAt(startOffset);
+  const end = model.getPositionAt(endOffset);
+  monaco.editor.setModelMarkers(model, SSML_MARKER_OWNER, [
+    {
+      message: syntaxError.message,
+      severity: monaco.MarkerSeverity.Error,
+      startLineNumber: start.lineNumber,
+      startColumn: start.column,
+      endLineNumber: end.lineNumber,
+      endColumn: end.column
+    }
+  ]);
+}
+function getSsmlAttributeValue(tag, attributeName) {
+  const escapedAttributeName = attributeName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = tag.match(new RegExp(`\\b${escapedAttributeName}\\s*=\\s*("|')([^"']*)\\1`, "i"));
+  return match?.[2];
+}
+function getSsmlInlineDecorations(model, value, language) {
+  const decorations = [];
+  const tagPattern = /<(break|prosody)\b[^>]*>/gi;
+  const badgeCopy = INLINE_BADGE_COPY[language];
+  for (const match of value.matchAll(tagPattern)) {
+    const tag = match[0];
+    const tagName = match[1].toLowerCase();
+    const startOffset = match.index ?? 0;
+    const endOffset = startOffset + tag.length;
+    const start = model.getPositionAt(startOffset);
+    const end = model.getPositionAt(endOffset);
+    const pauseValue = getSsmlAttributeValue(tag, "time") ?? getSsmlAttributeValue(tag, "strength");
+    const pitchValue = getSsmlAttributeValue(tag, "pitch") ?? getSsmlAttributeValue(tag, "contour") ?? getSsmlAttributeValue(tag, "range");
+    const prosodyValue = pitchValue ?? getSsmlAttributeValue(tag, "rate") ?? getSsmlAttributeValue(tag, "volume");
+    const badge = tagName === "break" ? `${badgeCopy.pause}${pauseValue ? ` ${pauseValue}` : ""}` : `${pitchValue ? badgeCopy.pitch : badgeCopy.prosody}${prosodyValue ? ` ${prosodyValue}` : ""}`;
+    decorations.push({
+      range: {
+        startLineNumber: start.lineNumber,
+        startColumn: start.column,
+        endLineNumber: end.lineNumber,
+        endColumn: end.column
+      },
+      options: {
+        after: {
+          content: ` ${badge}`,
+          inlineClassName: `ssml-editor-inline-badge ssml-editor-inline-badge-${tagName === "break" ? "pause" : "prosody"}`
+        }
+      }
+    });
+  }
+  return decorations;
+}
+function updateSsmlInlineDecorations(model, value, language, decorationIds) {
+  return model.deltaDecorations(decorationIds, getSsmlInlineDecorations(model, value, language));
+}
+function clearSsmlInlineDecorations(model, decorationIds) {
+  return model.deltaDecorations(decorationIds, []);
+}
+function syncSsmlInlineDecorations(model, value, language, showDecorations, decorationIds) {
+  return showDecorations ? updateSsmlInlineDecorations(model, value, language, decorationIds) : clearSsmlInlineDecorations(model, decorationIds);
+}
+function isSsmlElement(node) {
+  return typeof node !== "string" && node.type !== "text";
+}
+function isVoice(element) {
+  return element.type === "voice";
+}
+function isProsody(element) {
+  return element.type === "prosody";
+}
+function getDocumentChildren2(document2) {
+  return document2.children ?? (document2.content === void 0 ? [] : [document2.content]);
+}
+function getPartialContext(document2) {
+  const children = getDocumentChildren2(document2);
+  const voice = findFirstElement(children, isVoice);
+  const prosody = findFirstElement(children, isProsody);
+  const context = {
+    version: document2.version,
+    lang: document2.lang
+  };
+  if (voice) {
+    context.voice = {
+      name: voice.name,
+      effect: voice.effect,
+      attributes: voice.attributes
+    };
+  }
+  if (prosody) {
+    context.prosody = {
+      rate: prosody.rate,
+      pitch: prosody.pitch,
+      volume: prosody.volume,
+      contour: prosody.contour,
+      range: prosody.range,
+      attributes: prosody.attributes
+    };
+  }
+  return context;
+}
+function findFirstElement(nodes, predicate) {
+  for (const node of nodes) {
+    if (!isSsmlElement(node)) {
+      continue;
+    }
+    if (predicate(node)) {
+      return node;
+    }
+    const child = findFirstElement(node.children ?? [], predicate);
+    if (child) {
+      return child;
+    }
+  }
+  return void 0;
+}
+function updateFirstElement(nodes, predicate, update) {
+  let updated = false;
+  const nextNodes = nodes.map((node) => {
+    if (updated || !isSsmlElement(node)) {
+      return node;
+    }
+    if (predicate(node)) {
+      updated = true;
+      return update(node);
+    }
+    if (node.children) {
+      const result = updateFirstElement(node.children, predicate, update);
+      if (result.updated) {
+        updated = true;
+        return { ...node, children: result.nodes };
+      }
+    }
+    return node;
+  });
+  return { nodes: nextNodes, updated };
+}
+function withChildren(document2, children) {
+  const nextDocument = { ...document2, children };
+  if (nextDocument.content !== void 0) {
+    delete nextDocument.content;
+  }
+  return nextDocument;
+}
+function parseEditableText(value, lang) {
+  try {
+    const wrapper = buildSsml({
+      version: "1.0",
+      lang,
+      children: []
+    });
+    const openingTagEnd = wrapper.indexOf(">") + 1;
+    const children = parseSsml(`${wrapper.slice(0, openingTagEnd)}${value}</speak>`).children ?? [];
+    return children.some(isSsmlElement) ? children : [value];
+  } catch {
+    return [value];
+  }
+}
+function validateEditableText(value) {
+  if (!value.includes("<")) {
+    return null;
+  }
+  const source = `${EDITABLE_SSML_PREFIX}${value}${EDITABLE_SSML_SUFFIX}`;
+  const validationError = validateSsml(source);
+  if (!validationError) {
+    return null;
+  }
+  return {
+    message: validationError.message,
+    offset: Math.min(Math.max(validationError.position - EDITABLE_SSML_PREFIX.length, 0), value.length)
+  };
+}
+function serializeEditableText(nodes, lang) {
+  if (nodes.length === 1 && typeof nodes[0] === "string") {
+    return nodes[0];
+  }
+  const xml = buildSsml({
+    version: "1.0",
+    lang,
+    children: nodes
+  });
+  const contentStart = xml.indexOf(">") + 1;
+  return xml.slice(contentStart, -"</speak>".length);
+}
+function getEditableChildren(document2) {
+  const children = getDocumentChildren2(document2);
+  const element = findFirstElement(children, isProsody) ?? findFirstElement(children, isVoice);
+  return element?.children ?? children;
+}
+function getEditableText(document2) {
+  return serializeEditableText(getEditableChildren(document2), document2.lang);
+}
+function updateText(document2, value) {
+  const nextChildren = parseEditableText(value, document2.lang);
+  const editableChildren = nextChildren.length > 0 ? nextChildren : [value];
+  const children = getDocumentChildren2(document2);
+  const prosodyResult = updateFirstElement(children, isProsody, (prosody) => ({
+    ...prosody,
+    children: editableChildren
+  }));
+  if (prosodyResult.updated) {
+    return withChildren(document2, prosodyResult.nodes);
+  }
+  const voiceResult = updateFirstElement(children, isVoice, (voice) => ({
+    ...voice,
+    children: editableChildren
+  }));
+  if (voiceResult.updated) {
+    return withChildren(document2, voiceResult.nodes);
+  }
+  return withChildren(document2, editableChildren);
+}
+function getSelectionInfo(editor) {
+  const model = editor.getModel();
+  const selection = editor.getSelection();
+  if (!model || !selection) {
+    return {
+      selectedText: "",
+      characterCount: 0,
+      hasSelection: false
+    };
+  }
+  const selectedText = model.getValueInRange(selection);
+  return {
+    selectedText,
+    characterCount: selectedText.length,
+    hasSelection: selectedText.length > 0
+  };
+}
+function getSelectionOverlayState(editor) {
+  const info = getSelectionInfo(editor);
+  if (!info.hasSelection) {
+    return { ...info, position: null, placement: "above" };
+  }
+  const selection = editor.getSelection();
+  if (!selection) {
+    return { ...info, position: null, placement: "above" };
+  }
+  const position = editor.getScrolledVisiblePosition(selection.getStartPosition());
+  if (!position) {
+    return { ...info, position: null, placement: "above" };
+  }
+  const editorHeight = editor.getLayoutInfo().height;
+  if (position.top + position.height < 0 || position.top > editorHeight) {
+    return { ...info, position: null, placement: "above" };
+  }
+  return {
+    ...info,
+    position,
+    placement: position.top >= SELECTION_OVERLAY_ABOVE_THRESHOLD_LINES * position.height ? "above" : "below"
+  };
+}
+function getCurrentDocument(document2, editor) {
+  const value = editor?.getValue();
+  return value === void 0 ? document2 : updateText(document2, value);
+}
+function getCurrentLineText(editor) {
+  const model = editor.getModel();
+  const selection = editor.getSelection();
+  if (!model || !selection) {
+    return null;
+  }
+  const text = model.getLineContent(selection.positionLineNumber);
+  return text.trim().length > 0 ? text : null;
+}
+function getSelectedText(editor) {
+  const model = editor.getModel();
+  const selection = editor.getSelection();
+  if (!model || !selection) {
+    return null;
+  }
+  const selectedText = model.getValueInRange(selection);
+  return selectedText.length > 0 ? selectedText : getCurrentLineText(editor);
+}
+function getSelectedSsml(editor, document2) {
+  const selectedText = getSelectedText(editor);
+  return selectedText === null ? null : buildPartialSsml(selectedText, getPartialContext(document2));
+}
+function getCurrentLineSsml(editor, document2) {
+  const currentLineText = getCurrentLineText(editor);
+  return currentLineText === null ? null : buildPartialSsml(currentLineText, getPartialContext(document2));
+}
+function acquireSsmlHoverProvider(monaco, locale) {
+  const languages = monaco.languages;
+  let registrations = hoverProviderRegistrations.get(languages);
+  if (!registrations) {
+    registrations = /* @__PURE__ */ new Map();
+    hoverProviderRegistrations.set(languages, registrations);
+  }
+  let registration = registrations.get(locale);
+  if (!registration) {
+    const provider = {
+      provideHover(model, position) {
+        const target = findSsmlHoverTarget(model.getValue(), position.lineNumber, position.column);
+        if (!target) {
+          return void 0;
+        }
+        return {
+          contents: [
+            {
+              isTrusted: false,
+              supportHtml: false,
+              value: formatSsmlHover(target, locale)
+            }
+          ],
+          range: target.range
+        };
+      }
+    };
+    const disposable = languages.registerHoverProvider("xml", {
+      ...provider
+    });
+    registration = { disposable, references: 0 };
+    registrations.set(locale, registration);
+  }
+  registration.references += 1;
+  let released = false;
+  return () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    const currentRegistrations = hoverProviderRegistrations.get(languages);
+    const current = currentRegistrations?.get(locale);
+    if (!current) {
+      return;
+    }
+    current.references -= 1;
+    if (current.references === 0) {
+      current.disposable.dispose();
+      currentRegistrations?.delete(locale);
+      if (currentRegistrations?.size === 0) {
+        hoverProviderRegistrations.delete(languages);
+      }
+    }
+  };
+}
+function applySsmlTemplate(editor, template) {
+  const model = editor.getModel();
+  const selection = editor.getSelection();
+  if (!model || !selection) {
+    return;
+  }
+  const startOffset = model.getOffsetAt(selection.getStartPosition());
+  const endOffset = model.getOffsetAt(selection.getEndPosition());
+  const { replacement, selectionOffset } = createSsmlInsertionEdit(model.getValue(), startOffset, endOffset, template);
+  editor.pushUndoStop();
+  const applied = editor.executeEdits("ssml-toolbar", [
+    {
+      range: selection,
+      text: replacement
+    }
+  ]);
+  editor.pushUndoStop();
+  if (!applied) {
+    return;
+  }
+  const nextSelectionStart = model.getPositionAt(startOffset + selectionOffset);
+  const nextSelectionEnd = model.getPositionAt(endOffset + selectionOffset);
+  editor.setSelection({
+    selectionStartLineNumber: nextSelectionStart.lineNumber,
+    selectionStartColumn: nextSelectionStart.column,
+    positionLineNumber: nextSelectionEnd.lineNumber,
+    positionColumn: nextSelectionEnd.column
+  });
+  editor.focus();
+}
+function applySsmlInsertion(editor, insertion, option) {
+  applySsmlTemplate(editor, insertion.createTemplate(option.value));
+}
+var SsmlEditor = (0, import_react.forwardRef)(function SsmlEditor2({
+  document: document2,
+  onChange,
+  onSsmlChange,
+  onSelectionChange,
+  onPreviewSelection,
+  language: languageProp,
+  locale: localeProp,
+  showToolbar = true,
+  showToolbarIcons = true,
+  showToolbarLabels = false,
+  showDecorations = false,
+  buttonVisibility,
+  editorOptions,
+  settings,
+  height,
+  minHeight,
+  readOnly,
+  theme,
+  fontSize,
+  wordWrap,
+  lineNumbers,
+  minimap,
+  automaticLayout,
+  toolbarOrder,
+  toolbarGroups,
+  insertionOrder,
+  insertionGroups,
+  customInsertions,
+  additionalInsertions,
+  emotionStyles,
+  className,
+  style,
+  toolbarClassName,
+  toolbarStyle,
+  displayClassName,
+  displayStyle,
+  loadingFallback
+}, ref) {
+  const resolvedEditorOptions = {
+    ...settings,
+    ...editorOptions,
+    ...height === void 0 ? {} : { height },
+    ...minHeight === void 0 ? {} : { minHeight },
+    ...readOnly === void 0 ? {} : { readOnly },
+    ...theme === void 0 ? {} : { theme },
+    ...fontSize === void 0 ? {} : { fontSize },
+    ...wordWrap === void 0 ? {} : { wordWrap },
+    ...lineNumbers === void 0 ? {} : { lineNumbers },
+    ...minimap === void 0 ? {} : { minimap },
+    ...automaticLayout === void 0 ? {} : { automaticLayout }
+  };
+  const helpPanelId = (0, import_react.useId)();
+  const [draftDocument, setDraftDocument] = (0, import_react.useState)(document2);
+  const draftDocumentRef = (0, import_react.useRef)(document2);
+  const editorRef = (0, import_react.useRef)(null);
+  const monacoRef = (0, import_react.useRef)(null);
+  const releaseHoverProviderRef = (0, import_react.useRef)(null);
+  const selectionChangeRef = (0, import_react.useRef)(null);
+  const selectionLayoutDisposablesRef = (0, import_react.useRef)([]);
+  const inlineDecorationIdsRef = (0, import_react.useRef)([]);
+  const onSelectionChangeRef = (0, import_react.useRef)(onSelectionChange);
+  const onPreviewSelectionRef = (0, import_react.useRef)(onPreviewSelection);
+  const [selectionOverlay, setSelectionOverlay] = (0, import_react.useState)(EMPTY_SELECTION_OVERLAY);
+  const [isDark, setIsDark] = (0, import_react.useState)(false);
+  const [decorationsVisible, setDecorationsVisible] = (0, import_react.useState)(showDecorations);
+  const [isHelpOpen, setIsHelpOpen] = (0, import_react.useState)(false);
+  const [syntaxError, setSyntaxError] = (0, import_react.useState)(null);
+  const language = localeProp ?? languageProp ?? DEFAULT_LOCALE;
+  const languageRef = (0, import_react.useRef)(language);
+  draftDocumentRef.current = draftDocument;
+  languageRef.current = language;
+  onSelectionChangeRef.current = onSelectionChange;
+  onPreviewSelectionRef.current = onPreviewSelection;
+  const copy = EDITOR_COPY[language];
+  const showToolbarText = showToolbarLabels || !showToolbarIcons;
+  const resolvedTheme = resolvedEditorOptions.theme ?? "system";
+  const isDarkTheme = resolvedTheme === "dark" || resolvedTheme === "system" && isDark;
+  const editorMinHeight = resolvedEditorOptions.minHeight ?? "8rem";
+  const editorHeight = resolvedEditorOptions.height ?? editorMinHeight;
+  const isReadOnly = resolvedEditorOptions.readOnly ?? false;
+  const toolbarButtonStyle = showToolbarText ? styles.toolbarButton : { ...styles.toolbarButton, ...styles.toolbarIconOnly };
+  const configuredInsertions = getConfiguredInsertions(emotionStyles, customInsertions, additionalInsertions);
+  const visibleInsertions = orderInsertions(configuredInsertions, insertionOrder).filter(
+    (insertion) => isSsmlEditorButtonVisible(buttonVisibility, insertion.id)
+  );
+  const insertionById = new Map(visibleInsertions.map((insertion) => [insertion.id, insertion]));
+  const configuredInsertionGroups = insertionGroups ?? DEFAULT_INSERTION_GROUPS;
+  const groupedInsertionIds = /* @__PURE__ */ new Set();
+  const visibleInsertionGroups = configuredInsertionGroups.map((group) => {
+    const groupInsertionIds = new Set(group.insertionIds);
+    const candidates = insertionOrder && insertionOrder.length > 0 ? visibleInsertions.filter((insertion) => groupInsertionIds.has(insertion.id)) : group.insertionIds.map((id) => insertionById.get(id)).filter((insertion) => insertion !== void 0);
+    const insertions = candidates.filter((insertion) => {
+      if (groupedInsertionIds.has(insertion.id)) {
+        return false;
+      }
+      groupedInsertionIds.add(insertion.id);
+      return true;
+    });
+    return { group, insertions };
+  }).filter(({ insertions }) => insertions.length > 0);
+  const ungroupedInsertions = visibleInsertions.filter((insertion) => !groupedInsertionIds.has(insertion.id));
+  const toolbarActionIds = ["undo", "redo", "clearAll", "format", "decorations", "help"];
+  const defaultToolbarOrder = [
+    "undo",
+    "redo",
+    ...visibleInsertionGroups.flatMap(({ insertions }) => insertions.map((insertion) => insertion.id)),
+    ...ungroupedInsertions.map((insertion) => insertion.id),
+    "clearAll",
+    "format",
+    "decorations",
+    "help"
+  ];
+  const visibleToolbarIds = /* @__PURE__ */ new Set([
+    ...visibleInsertions.map((insertion) => insertion.id),
+    ...toolbarActionIds.filter((id) => isSsmlEditorButtonVisible(buttonVisibility, id))
+  ]);
+  const toolbarItemIds = orderToolbarButtons(
+    defaultToolbarOrder.filter((id) => visibleToolbarIds.has(id)),
+    toolbarOrder
+  );
+  const effectiveToolbarGroups = toolbarGroups ?? createDefaultToolbarGroups(configuredInsertionGroups);
+  const toolbarGroupByButtonId = /* @__PURE__ */ new Map();
+  for (const group of effectiveToolbarGroups) {
+    for (const buttonId of group.buttonIds) {
+      if (!toolbarGroupByButtonId.has(buttonId)) {
+        toolbarGroupByButtonId.set(buttonId, group.id);
+      }
+    }
+  }
+  const helpInsertions = [
+    ...visibleInsertionGroups.flatMap(({ insertions }) => insertions),
+    ...ungroupedInsertions
+  ].filter(
+    (insertion, index, insertions) => insertions.findIndex((candidate) => candidate.id === insertion.id) === index
+  );
+  const refreshSelectionOverlay = (editor, notify) => {
+    const nextSelection = getSelectionOverlayState(editor);
+    setSelectionOverlay(nextSelection);
+    if (notify) {
+      onSelectionChangeRef.current?.({
+        selectedText: nextSelection.selectedText,
+        characterCount: nextSelection.characterCount,
+        hasSelection: nextSelection.hasSelection
+      });
+    }
+  };
+  (0, import_react.useEffect)(() => {
+    injectEditorTheme();
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    setIsDark(mq.matches);
+    const handler = (e) => setIsDark(e.matches);
+    mq.addEventListener("change", handler);
+    return () => mq.removeEventListener("change", handler);
+  }, []);
+  (0, import_react.useEffect)(() => {
+    draftDocumentRef.current = document2;
+    setDraftDocument(document2);
+  }, [document2]);
+  (0, import_react.useEffect)(() => {
+    setDecorationsVisible(showDecorations);
+  }, [showDecorations]);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      const model = editorRef.current?.getModel();
+      if (model && monacoRef.current) {
+        updateSsmlMarkers(monacoRef.current, model, model.getValue(), null);
+        inlineDecorationIdsRef.current = clearSsmlInlineDecorations(model, inlineDecorationIdsRef.current);
+      }
+      selectionChangeRef.current?.dispose();
+      selectionChangeRef.current = null;
+      for (const disposable of selectionLayoutDisposablesRef.current) {
+        disposable.dispose();
+      }
+      selectionLayoutDisposablesRef.current = [];
+      releaseHoverProviderRef.current?.();
+      releaseHoverProviderRef.current = null;
+      editorRef.current = null;
+      monacoRef.current = null;
+    };
+  }, []);
+  (0, import_react.useEffect)(() => {
+    const monaco = monacoRef.current;
+    if (!monaco) {
+      return;
+    }
+    releaseHoverProviderRef.current?.();
+    releaseHoverProviderRef.current = acquireSsmlHoverProvider(monaco, language);
+  }, [language]);
+  const text = getEditableText(draftDocument);
+  (0, import_react.useEffect)(() => {
+    const nextSyntaxError = validateEditableText(text);
+    setSyntaxError(nextSyntaxError);
+    const model = editorRef.current?.getModel();
+    if (model && monacoRef.current) {
+      updateSsmlMarkers(monacoRef.current, model, text, nextSyntaxError);
+      inlineDecorationIdsRef.current = syncSsmlInlineDecorations(
+        model,
+        text,
+        language,
+        decorationsVisible,
+        inlineDecorationIdsRef.current
+      );
+    }
+  }, [decorationsVisible, language, text]);
+  const commit = (nextDocument) => {
+    draftDocumentRef.current = nextDocument;
+    setDraftDocument(nextDocument);
+    onChange?.(nextDocument);
+    onSsmlChange?.(buildSsml(nextDocument));
+  };
+  const canPreviewSelection = onPreviewSelection !== void 0;
+  const previewSelection = () => {
+    const editor = editorRef.current;
+    if (!editor) {
+      return;
+    }
+    const selectedSsml = getSelectedSsml(editor, draftDocumentRef.current);
+    if (selectedSsml === null) {
+      return;
+    }
+    onPreviewSelectionRef.current?.(selectedSsml);
+  };
+  (0, import_react.useImperativeHandle)(
+    ref,
+    () => ({
+      getSelectedSsml: () => {
+        const editor = editorRef.current;
+        return editor ? getSelectedSsml(editor, draftDocumentRef.current) : null;
+      },
+      getCurrentLineSsml: () => {
+        const editor = editorRef.current;
+        return editor ? getCurrentLineSsml(editor, draftDocumentRef.current) : null;
+      },
+      getFullSsml: () => buildSsml(getCurrentDocument(draftDocumentRef.current, editorRef.current))
+    }),
+    []
+  );
+  const renderInsertion = (insertion) => /* @__PURE__ */ React.createElement(
+    ToolbarInsertionMenu,
+    {
+      key: insertion.id,
+      insertion,
+      language,
+      isDarkTheme,
+      showToolbarIcons,
+      showToolbarText,
+      toolbarButtonStyle,
+      isReadOnly,
+      onApply: (selectedInsertion, option) => {
+        if (editorRef.current) {
+          applySsmlInsertion(editorRef.current, selectedInsertion, option);
+        }
+      }
+    }
+  );
+  const toolbarItemRenderers = /* @__PURE__ */ new Map([
+    [
+      "undo",
+      () => /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          key: "undo",
+          type: "button",
+          style: toolbarButtonStyle,
+          "aria-label": copy.undo,
+          title: copy.undoTitle,
+          disabled: isReadOnly,
+          onClick: () => {
+            if (!isReadOnly) {
+              editorRef.current?.trigger("toolbar", "undo", null);
+              editorRef.current?.focus();
+            }
+          }
+        },
+        showToolbarIcons && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarIcon, "aria-hidden": "true" }, "\u21A9"),
+        showToolbarText && /* @__PURE__ */ React.createElement("span", null, copy.undo)
+      )
+    ],
+    [
+      "redo",
+      () => /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          key: "redo",
+          type: "button",
+          style: toolbarButtonStyle,
+          "aria-label": copy.redo,
+          title: copy.redoTitle,
+          disabled: isReadOnly,
+          onClick: () => {
+            if (!isReadOnly) {
+              editorRef.current?.trigger("toolbar", "redo", null);
+              editorRef.current?.focus();
+            }
+          }
+        },
+        showToolbarIcons && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarIcon, "aria-hidden": "true" }, "\u21AA"),
+        showToolbarText && /* @__PURE__ */ React.createElement("span", null, copy.redo)
+      )
+    ],
+    [
+      "clearAll",
+      () => /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          key: "clearAll",
+          type: "button",
+          style: toolbarButtonStyle,
+          "aria-label": copy.clearAll,
+          title: copy.clearAllTitle,
+          disabled: isReadOnly,
+          onClick: () => {
+            if (!isReadOnly) {
+              commit(clearSsmlDocument(draftDocument));
+            }
+          }
+        },
+        showToolbarIcons && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarIcon, "aria-hidden": "true" }, "\xD7"),
+        showToolbarText && /* @__PURE__ */ React.createElement("span", null, copy.clearAll)
+      )
+    ],
+    [
+      "format",
+      () => /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          key: "format",
+          type: "button",
+          style: toolbarButtonStyle,
+          "aria-label": copy.format,
+          title: copy.formatTitle,
+          disabled: isReadOnly,
+          onClick: () => {
+            if (!isReadOnly) {
+              const value = editorRef.current?.getValue() ?? getEditableText(draftDocument);
+              commit(updateText(draftDocument, formatXmlFragment(value)));
+            }
+          }
+        },
+        showToolbarIcons && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarIcon, "aria-hidden": "true" }, "\u2261"),
+        showToolbarText && /* @__PURE__ */ React.createElement("span", null, copy.format)
+      )
+    ],
+    [
+      "decorations",
+      () => /* @__PURE__ */ React.createElement(
+        ToolbarDecorationsSwitch,
+        {
+          key: "decorations",
+          copy,
+          showToolbarIcons,
+          showToolbarText,
+          decorationsVisible,
+          onVisibilityChange: setDecorationsVisible
+        }
+      )
+    ],
+    [
+      "help",
+      () => /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          key: "help",
+          type: "button",
+          style: toolbarButtonStyle,
+          "aria-label": copy.help,
+          title: copy.helpTitle,
+          "aria-expanded": isHelpOpen,
+          "aria-controls": helpPanelId,
+          onClick: () => setIsHelpOpen((open) => !open)
+        },
+        showToolbarIcons && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarIcon, "aria-hidden": "true" }, "?"),
+        showToolbarText && /* @__PURE__ */ React.createElement("span", null, copy.help)
+      )
+    ]
+  ]);
+  for (const insertion of visibleInsertions) {
+    toolbarItemRenderers.set(insertion.id, () => renderInsertion(insertion));
+  }
+  const renderToolbarItems = () => {
+    let previousRenderedGroupId = UNGROUPED_TOOLBAR_GROUP;
+    let hasRenderedToolbarItem = false;
+    const renderedItems = [];
+    for (const id of toolbarItemIds) {
+      const render = toolbarItemRenderers.get(id);
+      if (!render) {
+        continue;
+      }
+      const groupId = toolbarGroupByButtonId.get(id) ?? UNGROUPED_TOOLBAR_GROUP;
+      const showSeparator = hasRenderedToolbarItem && groupId !== previousRenderedGroupId;
+      previousRenderedGroupId = groupId;
+      hasRenderedToolbarItem = true;
+      renderedItems.push(
+        /* @__PURE__ */ React.createElement(import_react.Fragment, { key: id }, showSeparator && /* @__PURE__ */ React.createElement("span", { style: styles.toolbarSeparator, "aria-hidden": "true" }), render())
+      );
+    }
+    return renderedItems;
+  };
+  return /* @__PURE__ */ React.createElement(
+    "section",
+    {
+      className,
+      style: { ...styles.container, ...style },
+      "aria-label": copy.editorAriaLabel,
+      "data-ssml-editor": "",
+      "data-theme": isDarkTheme ? "dark" : "light"
+    },
+    showToolbar && /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        className: toolbarClassName,
+        style: { ...styles.toolbarContainer, ...toolbarStyle },
+        "data-ssml-editor-toolbar": ""
+      },
+      /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: styles.toolbarActions,
+          role: "toolbar",
+          "aria-label": copy.toolbarAriaLabel,
+          "data-ssml-editor-toolbar-actions": ""
+        },
+        renderToolbarItems()
+      )
+    ),
+    /* @__PURE__ */ React.createElement("div", { className: displayClassName, style: { ...styles.display, ...displayStyle }, "data-ssml-editor-display": "" }, isHelpOpen && isSsmlEditorButtonVisible(buttonVisibility, "help") && /* @__PURE__ */ React.createElement("section", { id: helpPanelId, style: styles.helpPanel, "aria-label": copy.helpHeading }, /* @__PURE__ */ React.createElement("h3", { style: styles.helpHeading }, copy.helpHeading), /* @__PURE__ */ React.createElement("p", { style: styles.helpDescription }, copy.helpDescription), helpInsertions.length > 0 && /* @__PURE__ */ React.createElement("ul", { style: styles.helpList }, helpInsertions.map((insertion) => /* @__PURE__ */ React.createElement("li", { key: insertion.id, style: styles.helpItem }, /* @__PURE__ */ React.createElement("details", { className: "ssml-editor-help-settings-accordion", style: styles.helpSettingsAccordion }, /* @__PURE__ */ React.createElement("summary", { className: "ssml-editor-help-settings-summary", style: styles.helpSettingsSummary }, /* @__PURE__ */ React.createElement("span", { style: styles.helpIcon, "aria-hidden": "true" }, insertion.icon), /* @__PURE__ */ React.createElement("span", { style: styles.helpSettingsSummaryContent }, /* @__PURE__ */ React.createElement("strong", null, insertion.labels[language]), " ", insertion.tagName && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("code", null, `<${insertion.tagName}${insertion.selfClosing ? "/>" : ">"}`), " \u2014", " "), insertion.descriptions[language])), /* @__PURE__ */ React.createElement("p", { style: styles.helpSettingsDescription }, /* @__PURE__ */ React.createElement("strong", null, copy.parameters, ":"), " ", insertion.parameterDescription[language]), /* @__PURE__ */ React.createElement("ul", { style: styles.helpSettingsList }, insertion.options.map((option) => /* @__PURE__ */ React.createElement("li", { key: option.value }, /* @__PURE__ */ React.createElement("strong", null, option.labels[language]), option.descriptions && /* @__PURE__ */ React.createElement(React.Fragment, null, " \u2014 ", option.descriptions[language]))))))))), /* @__PURE__ */ React.createElement("div", { style: { ...styles.editor, minHeight: editorMinHeight } }, /* @__PURE__ */ React.createElement(
+      import_react2.default,
+      {
+        height: editorHeight,
+        language: "xml",
+        theme: isDarkTheme ? "vs-dark" : "light",
+        options: {
+          automaticLayout: resolvedEditorOptions.automaticLayout ?? true,
+          fontSize: resolvedEditorOptions.fontSize,
+          hover: { enabled: "on" },
+          inlayHints: { enabled: decorationsVisible ? "on" : "off" },
+          lineNumbers: resolvedEditorOptions.lineNumbers,
+          minimap: {
+            enabled: resolvedEditorOptions.minimap ?? true
+          },
+          readOnly: isReadOnly,
+          wordWrap: resolvedEditorOptions.wordWrap
+        },
+        value: text,
+        loading: loadingFallback,
+        onMount: (editor, monaco) => {
+          editorRef.current = editor;
+          monacoRef.current = monaco;
+          selectionChangeRef.current?.dispose();
+          selectionChangeRef.current = editor.onDidChangeCursorSelection(() => {
+            refreshSelectionOverlay(editor, true);
+          });
+          for (const disposable of selectionLayoutDisposablesRef.current) {
+            disposable.dispose();
+          }
+          selectionLayoutDisposablesRef.current = [
+            editor.onDidScrollChange(() => refreshSelectionOverlay(editor, false)),
+            editor.onDidLayoutChange(() => refreshSelectionOverlay(editor, false)),
+            editor.onDidContentSizeChange(() => refreshSelectionOverlay(editor, false))
+          ];
+          releaseHoverProviderRef.current?.();
+          releaseHoverProviderRef.current = acquireSsmlHoverProvider(monaco, languageRef.current);
+          const model = editor.getModel();
+          const nextSyntaxError = validateEditableText(editor.getValue());
+          setSyntaxError(nextSyntaxError);
+          if (model) {
+            updateSsmlMarkers(monaco, model, editor.getValue(), nextSyntaxError);
+            inlineDecorationIdsRef.current = syncSsmlInlineDecorations(
+              model,
+              editor.getValue(),
+              language,
+              decorationsVisible,
+              inlineDecorationIdsRef.current
+            );
+          }
+          refreshSelectionOverlay(editor, true);
+        },
+        onChange: (value) => {
+          commit(updateText(draftDocument, value ?? ""));
+          if (editorRef.current) {
+            refreshSelectionOverlay(editorRef.current, false);
+          }
+        }
+      }
+    ), selectionOverlay.hasSelection && selectionOverlay.position && /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        role: "toolbar",
+        "aria-label": copy.selectionActions,
+        "data-ssml-editor-selection-actions": "",
+        style: {
+          ...styles.selectionActions,
+          top: selectionOverlay.position.top,
+          left: selectionOverlay.position.left,
+          transform: selectionOverlay.placement === "above" ? "translateY(calc(-100% - 0.5rem))" : `translateY(calc(${selectionOverlay.position.height}px + 0.5rem))`
+        },
+        onMouseDown: (event) => event.preventDefault()
+      },
+      /* @__PURE__ */ React.createElement("span", { style: styles.selectionCount, "aria-live": "polite" }, selectionOverlay.characterCount, copy.selectionCountSuffix),
+      /* @__PURE__ */ React.createElement("span", { style: styles.selectionActionsDivider, "aria-hidden": "true" }),
+      /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          type: "button",
+          style: styles.selectionActionButton,
+          title: copy.previewSelectionTitle,
+          disabled: !canPreviewSelection,
+          onClick: previewSelection
+        },
+        /* @__PURE__ */ React.createElement("span", { style: styles.selectionActionIcon, "aria-hidden": "true" }, "\u25B6"),
+        copy.previewSelection
+      )
+    )), syntaxError && /* @__PURE__ */ React.createElement("p", { style: styles.error, role: "alert" }, copy.syntaxError, ": ", syntaxError.message))
+  );
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EDITOR_COPY,
+  INLINE_BADGE_COPY,
+  SSML_HOVER_COPY,
+  SSML_INSERTIONS,
+  SsmlEditor,
+  createSsmlEditorInsertionDefinition
+});
+//# sourceMappingURL=react.js.map