@ssml-builder-js/ssml-editor-elements 2.4.0

package/dist/index.mjs

@@ -0,0 +1,3790 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/SsmlEditorElement.ts
+import { buildSsml as buildSsml2, parseSsml as parseSsml2 } from "@ssml-builder-js/ssml-core";
+
+// ../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;
+}
+
+// ../ssml-editor-react/src/editableSsml.ts
+import { buildSsml, parseSsml } from "@ssml-builder-js/ssml-core";
+
+// ../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"]);
+var INTRINSICALLY_EMPTY_ELEMENTS = /* @__PURE__ */ new Set([
+  "break",
+  "bookmark",
+  "lexicon",
+  "mark",
+  "mstts:silence",
+  "mstts:viseme",
+  "silence",
+  "viseme"
+]);
+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 fail(message) {
+  throw new Error(message);
+}
+function skipWhitespace(source, index) {
+  while (isXmlWhitespace(source[index])) {
+    index += 1;
+  }
+  return index;
+}
+function readName(source, start, end) {
+  if (!isXmlNameStart(source[start])) {
+    fail("Invalid XML name");
+  }
+  let index = start + 1;
+  while (index < end && isXmlNameCharacter(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 hasOnlyWhitespaceText(node) {
+  return node.children.every((child) => child.kind === "text" && child.value.trim() === "");
+}
+function toSelfClosingTag(open) {
+  return `${open.slice(0, -1).trimEnd()}/>`;
+}
+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 (INTRINSICALLY_EMPTY_ELEMENTS.has(node.name) && hasOnlyWhitespaceText(node)) {
+    return [`${prefix}${toSelfClosingTag(node.open)}`];
+  }
+  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 getTrailingLineBreaks(value) {
+  let start = value.length;
+  while (start > 0) {
+    if (value[start - 1] === "\n") {
+      start -= 1;
+      if (start > 0 && value[start - 1] === "\r") {
+        start -= 1;
+      }
+      continue;
+    }
+    if (value[start - 1] === "\r") {
+      start -= 1;
+      continue;
+    }
+    break;
+  }
+  return value.slice(start);
+}
+function stripTrailingLineBreaks(value) {
+  let end = value.length;
+  while (end > 0) {
+    if (value[end - 1] === "\n") {
+      end -= 1;
+      if (end > 0 && value[end - 1] === "\r") {
+        end -= 1;
+      }
+      continue;
+    }
+    if (value[end - 1] === "\r") {
+      end -= 1;
+      continue;
+    }
+    break;
+  }
+  return value.slice(0, end);
+}
+function preserveTrailingLineBreak(formatted, trailingLineBreaks) {
+  if (trailingLineBreaks === "") {
+    return formatted;
+  }
+  return `${stripTrailingLineBreaks(formatted)}${trailingLineBreaks}`;
+}
+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 trailingLineBreaks = getTrailingLineBreaks(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 preserveTrailingLineBreak(unwrapFormattedFragment(formatted) ?? xml, trailingLineBreaks);
+}
+
+// ../ssml-editor-react/src/editableSsml.ts
+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 getSsmlElementName(element) {
+  return element.type === "custom" || element.type === "element" ? element.name : element.type;
+}
+function findEditableTagEnd(source, start) {
+  let quote;
+  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 (character === ">") {
+      return index;
+    }
+  }
+  return source.length;
+}
+function collectEditableStartTags(source) {
+  const tags = [];
+  let index = 0;
+  while (index < source.length) {
+    if (source[index] !== "<") {
+      index += 1;
+      continue;
+    }
+    if (source.startsWith("<!--", index)) {
+      const end2 = source.indexOf("-->", index + 4);
+      index = end2 === -1 ? source.length : end2 + 3;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", index)) {
+      const end2 = source.indexOf("]]>", index + 9);
+      index = end2 === -1 ? source.length : end2 + 3;
+      continue;
+    }
+    if (source.startsWith("<?", index)) {
+      const end2 = source.indexOf("?>", index + 2);
+      index = end2 === -1 ? source.length : end2 + 2;
+      continue;
+    }
+    if (source.startsWith("</", index) || source.startsWith("<!", index)) {
+      const end2 = findEditableTagEnd(source, index);
+      index = end2 === source.length ? source.length : end2 + 1;
+      continue;
+    }
+    const end = findEditableTagEnd(source, index);
+    if (end === source.length) {
+      break;
+    }
+    const raw = source.slice(index, end + 1);
+    const match = raw.match(/^<([A-Za-z_][A-Za-z0-9_.:-]*)/);
+    if (match) {
+      tags.push({ name: match[1], selfClosing: /\/\s*>$/.test(raw) });
+    }
+    index = end + 1;
+  }
+  return tags;
+}
+function preserveEmptyPairElements(nodes, startTags, startTagIndex) {
+  return nodes.map((node) => {
+    if (!isSsmlElement(node)) {
+      return node;
+    }
+    const elementName = getSsmlElementName(node);
+    const startTag = startTags[startTagIndex.value];
+    startTagIndex.value += 1;
+    if (node.children === void 0 || node.children.length === 0) {
+      return startTag?.name === elementName && !startTag.selfClosing && !INTRINSICALLY_EMPTY_ELEMENTS.has(elementName) ? { ...node, children: [""] } : node;
+    }
+    const children = preserveEmptyPairElements(node.children, startTags, startTagIndex);
+    if (children.every((child, index) => child === node.children?.[index])) {
+      return node;
+    }
+    return { ...node, children };
+  });
+}
+function getDocumentChildren2(document2) {
+  return document2.children ?? (document2.content === void 0 ? [] : [document2.content]);
+}
+function findFirstElementPath(nodes, predicate, ancestors = []) {
+  for (const node of nodes) {
+    if (!isSsmlElement(node)) {
+      continue;
+    }
+    const path = [...ancestors, node];
+    if (predicate(node)) {
+      return path;
+    }
+    const childPath = findFirstElementPath(node.children ?? [], predicate, path);
+    if (childPath) {
+      return childPath;
+    }
+  }
+  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) ? preserveEmptyPairElements(children, collectEditableStartTags(value), { value: 0 }) : [value];
+  } catch {
+    return [value];
+  }
+}
+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 getEditableRegion(document2) {
+  const children = getDocumentChildren2(document2);
+  const path = findFirstElementPath(children, isProsody) ?? findFirstElementPath(children, isVoice);
+  const element = path ? path[path.length - 1] : void 0;
+  const voice = path ? [...path].reverse().find(isVoice) : void 0;
+  return {
+    children: element?.children ?? children,
+    ...voice ? { voiceName: voice.name } : {}
+  };
+}
+function getEditableText(document2) {
+  return serializeEditableText(getEditableRegion(document2).children, document2.lang);
+}
+function updateEditableText(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);
+}
+
+// ../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_ROLE_PRESETS: () => EXPRESS_AS_ROLE_PRESETS,
+  EXPRESS_AS_STYLE_CATEGORIES: () => EXPRESS_AS_STYLE_CATEGORIES,
+  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_ATTRIBUTE_PRESETS: () => SSML_ATTRIBUTE_PRESETS,
+  SSML_PRESETS: () => SSML_PRESETS,
+  SSML_PRESET_EXAMPLES: () => SSML_PRESET_EXAMPLES,
+  VISEME_TYPE_PRESETS: () => VISEME_TYPE_PRESETS,
+  VOICE_STYLE_MAP: () => VOICE_STYLE_MAP,
+  getExpressAsStyleCategory: () => getExpressAsStyleCategory,
+  resolveExpressAsStyles: () => resolveExpressAsStyles
+});
+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",
+  "assistant",
+  "chat",
+  "customerservice",
+  "hopeful",
+  "newscast",
+  "shouting",
+  "terrified",
+  "unfriendly",
+  "whispering",
+  "empathetic",
+  "relieved",
+  "fearful",
+  "depressed",
+  "disgruntled",
+  "embarrassed",
+  "narration-relaxed",
+  "poetry-reading",
+  "sports_commentary",
+  "sports_commentary_excited",
+  "story"
+];
+var EXPRESS_AS_STYLE_CATEGORIES = {
+  emotions: [
+    "cheerful",
+    "sad",
+    "angry",
+    "calm",
+    "fearful",
+    "depressed",
+    "disgruntled",
+    "embarrassed",
+    "empathetic",
+    "envious",
+    "excited",
+    "friendly",
+    "gentle",
+    "hopeful",
+    "relieved",
+    "serious",
+    "shouting",
+    "terrified",
+    "unfriendly",
+    "whispering"
+  ],
+  scenarios: ["chat", "customerservice", "assistant", "livecommercial", "poetry-reading", "story"],
+  media: [
+    "newscast",
+    "newscast-casual",
+    "newscast-formal",
+    "narration-professional",
+    "narration-relaxed",
+    "documentary-narration",
+    "advertisement_upbeat",
+    "sports_commentary",
+    "sports_commentary_excited"
+  ]
+};
+function getExpressAsStyleCategory(style) {
+  for (const [category, styles] of Object.entries(EXPRESS_AS_STYLE_CATEGORIES)) {
+    if (styles.includes(style)) {
+      return category;
+    }
+  }
+  return "other";
+}
+var VOICE_STYLE_MAP = {
+  "ja-JP-MayuNeural": ["calm", "cheerful", "sad"],
+  "ja-JP-KeitaNeural": ["chat"],
+  "ja-JP-NanamiNeural": ["chat", "customerservice", "cheerful", "whispering", "sad"],
+  "en-US-JennyMultilingualNeural": [
+    "cheerful",
+    "empathetic",
+    "excited",
+    "friendly",
+    "hopeful",
+    "sad",
+    "shouting",
+    "terrified",
+    "unfriendly",
+    "whispering"
+  ],
+  "en-US-AndrewNeural": ["empathetic", "relieved"],
+  "en-US-JennyNeural": [
+    "assistant",
+    "chat",
+    "customerservice",
+    "newscast",
+    "cheerful",
+    "empathetic",
+    "excited",
+    "friendly",
+    "hopeful",
+    "sad",
+    "shouting",
+    "terrified",
+    "unfriendly",
+    "whispering"
+  ],
+  "en-US-GuyNeural": [
+    "angry",
+    "cheerful",
+    "excited",
+    "friendly",
+    "hopeful",
+    "newscast",
+    "sad",
+    "shouting",
+    "terrified",
+    "unfriendly",
+    "whispering"
+  ],
+  "ko-KR-SunHiNeural": ["cheerful", "sad"],
+  "zh-CN-XiaoxiaoNeural": [
+    "assistant",
+    "chat",
+    "customerservice",
+    "newscast",
+    "cheerful",
+    "empathetic",
+    "excited",
+    "friendly",
+    "hopeful",
+    "sad",
+    "terrified",
+    "whispering",
+    "poetry-reading",
+    "sports_commentary",
+    "sports_commentary_excited",
+    "story"
+  ],
+  "zh-CN-YunxiNeural": [
+    "narration-relaxed",
+    "embarrassed",
+    "fearful",
+    "sad",
+    "disgruntled",
+    "serious",
+    "angry",
+    "depressed",
+    "chat",
+    "cheerful",
+    "assistant"
+  ],
+  "fr-FR-DeniseNeural": ["cheerful", "sad"],
+  "fr-FR-HenriNeural": ["cheerful", "sad"],
+  "pt-BR-FranciscaNeural": ["calm"],
+  "it-IT-ElsaNeural": ["cheerful", "sad"],
+  "de-DE-KatjaNeural": ["cheerful", "sad"],
+  "de-DE-ConradNeural": ["cheerful", "sad"],
+  "ru-RU-SvetlanaNeural": ["cheerful", "sad", "angry", "disgruntled", "embarrassed", "fearful"]
+};
+var VOICE_STYLE_MAP_BY_NORMALIZED_NAME = new Map(
+  Object.entries(VOICE_STYLE_MAP).map(([voiceName, styles]) => [voiceName.toLowerCase(), styles])
+);
+function resolveExpressAsStyles(voiceName, candidates = EXPRESS_AS_STYLE_PRESETS) {
+  const normalizedVoiceName = voiceName?.trim().toLowerCase();
+  if (!normalizedVoiceName) {
+    return candidates;
+  }
+  const supportedStyles = VOICE_STYLE_MAP_BY_NORMALIZED_NAME.get(normalizedVoiceName);
+  if (supportedStyles === void 0) {
+    return [];
+  }
+  const supportedStyleSet = new Set(supportedStyles);
+  return candidates.filter((style) => supportedStyleSet.has(style));
+}
+var EXPRESS_AS_ROLE_PRESETS = [
+  "Girl",
+  "Boy",
+  "YoungAdultFemale",
+  "YoungAdultMale",
+  "OlderAdultFemale",
+  "OlderAdultMale",
+  "SeniorFemale",
+  "SeniorMale"
+];
+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_ATTRIBUTE_PRESETS = {
+  break: {
+    strength: BREAK_STRENGTH_PRESETS,
+    time: BREAK_TIME_PRESETS
+  },
+  prosody: {
+    rate: PROSODY_RATE_PRESETS,
+    pitch: PROSODY_PITCH_PRESETS,
+    volume: PROSODY_VOLUME_PRESETS
+  },
+  "mstts:express-as": {
+    style: EXPRESS_AS_STYLE_PRESETS,
+    role: EXPRESS_AS_ROLE_PRESETS
+  },
+  "express-as": {
+    style: EXPRESS_AS_STYLE_PRESETS,
+    role: EXPRESS_AS_ROLE_PRESETS
+  },
+  expressAs: {
+    style: EXPRESS_AS_STYLE_PRESETS,
+    role: EXPRESS_AS_ROLE_PRESETS
+  },
+  "say-as": {
+    "interpret-as": SAY_AS_PRESETS
+  },
+  sayAs: {
+    "interpret-as": SAY_AS_PRESETS
+  },
+  emphasis: {
+    level: EMPHASIS_LEVEL_PRESETS
+  },
+  lang: {
+    "xml:lang": LANGUAGE_PRESETS
+  },
+  phoneme: {
+    alphabet: PHONEME_ALPHABET_PRESETS
+  },
+  "mstts:silence": {
+    type: SILENCE_TYPE_PRESETS,
+    value: SILENCE_VALUE_PRESETS
+  },
+  silence: {
+    type: SILENCE_TYPE_PRESETS,
+    value: SILENCE_VALUE_PRESETS
+  },
+  "mstts:viseme": {
+    type: VISEME_TYPE_PRESETS
+  },
+  viseme: {
+    type: VISEME_TYPE_PRESETS
+  }
+};
+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."
+  },
+  empathetic: {
+    ja: "\u5171\u611F\u3092\u793A\u3059\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses an empathetic style."
+  },
+  relieved: {
+    ja: "\u5B89\u5FC3\u3057\u305F\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a relieved style."
+  },
+  fearful: {
+    ja: "\u6050\u308C\u3092\u611F\u3058\u3055\u305B\u308B\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a fearful style."
+  },
+  depressed: {
+    ja: "\u843D\u3061\u8FBC\u3093\u3060\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a depressed style."
+  },
+  disgruntled: {
+    ja: "\u4E0D\u6E80\u3092\u611F\u3058\u3055\u305B\u308B\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a disgruntled style."
+  },
+  embarrassed: {
+    ja: "\u6065\u305A\u304B\u3057\u305D\u3046\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses an embarrassed style."
+  },
+  serious: {
+    ja: "\u771F\u5263\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a serious style."
+  },
+  assistant: {
+    ja: "\u30C7\u30B8\u30BF\u30EB\u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a digital assistant style."
+  },
+  chat: {
+    ja: "\u4F1A\u8A71\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a conversational style."
+  },
+  customerservice: {
+    ja: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30FC\u30D3\u30B9\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a customer service style."
+  },
+  hopeful: {
+    ja: "\u5E0C\u671B\u306B\u6E80\u3061\u305F\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a hopeful style."
+  },
+  newscast: {
+    ja: "\u30CB\u30E5\u30FC\u30B9\u8AAD\u307F\u4E0A\u3052\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a newscast style."
+  },
+  shouting: {
+    ja: "\u53EB\u3076\u3088\u3046\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a shouting style."
+  },
+  terrified: {
+    ja: "\u6050\u6016\u306B\u6E80\u3061\u305F\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a terrified style."
+  },
+  unfriendly: {
+    ja: "\u7121\u611B\u60F3\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses an unfriendly style."
+  },
+  whispering: {
+    ja: "\u3055\u3055\u3084\u304F\u3088\u3046\u306A\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a whispering style."
+  },
+  "narration-relaxed": {
+    ja: "\u30EA\u30E9\u30C3\u30AF\u30B9\u3057\u305F\u30CA\u30EC\u30FC\u30B7\u30E7\u30F3\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a relaxed narration style."
+  },
+  "poetry-reading": {
+    ja: "\u8A69\u306E\u6717\u8AAD\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a poetry-reading style."
+  },
+  sports_commentary: {
+    ja: "\u30B9\u30DD\u30FC\u30C4\u5B9F\u6CC1\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a sports commentary style."
+  },
+  sports_commentary_excited: {
+    ja: "\u8208\u596E\u3057\u305F\u30B9\u30DD\u30FC\u30C4\u5B9F\u6CC1\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses an excited sports commentary style."
+  },
+  story: {
+    ja: "\u7269\u8A9E\u306E\u6717\u8AAD\u5411\u3051\u306E\u30B9\u30BF\u30A4\u30EB",
+    en: "Uses a storytelling 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."
+  }
+};
+
+// ../ssml-editor-react/src/ssmlContext.ts
+function findTagEnd2(source, start, limit) {
+  let quote;
+  for (let index = start + 1; index < limit; index += 1) {
+    const character = source[index];
+    if (quote !== void 0) {
+      if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === ">") {
+      return index;
+    }
+  }
+  return -1;
+}
+function getVoiceName(tag) {
+  return tag.match(/\bname\s*=\s*(["'])([\s\S]*?)\1/i)?.[2];
+}
+function closeElement(stack, name) {
+  for (let index = stack.length - 1; index >= 0; index -= 1) {
+    if (stack[index]?.name === name) {
+      stack.splice(index);
+      return;
+    }
+  }
+}
+function findActiveSsmlTags(source, offset) {
+  const limit = Math.max(0, Math.min(offset, source.length));
+  const stack = [];
+  let index = 0;
+  while (index < source.length) {
+    const tagStart = source.indexOf("<", index);
+    if (tagStart === -1 || tagStart > limit) {
+      break;
+    }
+    const nonContentEnd = source.startsWith("<!--", tagStart) ? source.indexOf("-->", tagStart + 4) : source.startsWith("<![CDATA[", tagStart) ? source.indexOf("]]>", tagStart + 9) : source.startsWith("<?", tagStart) ? source.indexOf("?>", tagStart + 2) : void 0;
+    if (nonContentEnd !== void 0) {
+      const delimiterLength = source.startsWith("<?", tagStart) ? 2 : 3;
+      const end = nonContentEnd === -1 ? source.length : nonContentEnd + delimiterLength;
+      if (limit < end) {
+        break;
+      }
+      index = end;
+      continue;
+    }
+    const tagEnd = findTagEnd2(source, tagStart, source.length);
+    const tag = source.slice(tagStart, tagEnd === -1 ? source.length : tagEnd + 1);
+    const closingMatch = tag.match(/^<\s*\/\s*([A-Za-z_][A-Za-z0-9_.:-]*)/);
+    const openingMatch = tag.match(/^<\s*([A-Za-z_][A-Za-z0-9_.:-]*)/);
+    if (tagEnd === -1 || limit <= tagEnd) {
+      if (openingMatch?.[1]) {
+        stack.push({ name: openingMatch[1].toLowerCase() });
+      }
+      break;
+    }
+    if (closingMatch?.[1]) {
+      closeElement(stack, closingMatch[1].toLowerCase());
+    } else if (openingMatch?.[1] && !/\/\s*>$/.test(tag)) {
+      stack.push({ name: openingMatch[1].toLowerCase() });
+    }
+    index = tagEnd + 1;
+  }
+  return new Set(stack.map(({ name }) => name));
+}
+function findSsmlVoiceContext(source, offset) {
+  const limit = Math.max(0, Math.min(offset, source.length));
+  const stack = [];
+  let index = 0;
+  while (index < limit) {
+    const tagStart = source.indexOf("<", index);
+    if (tagStart === -1 || tagStart >= limit) {
+      break;
+    }
+    if (source.startsWith("<!--", tagStart)) {
+      const end = source.indexOf("-->", tagStart + 4);
+      index = end === -1 || end + 3 > limit ? limit : end + 3;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", tagStart)) {
+      const end = source.indexOf("]]>", tagStart + 9);
+      index = end === -1 || end + 3 > limit ? limit : end + 3;
+      continue;
+    }
+    if (source.startsWith("<?", tagStart)) {
+      const end = source.indexOf("?>", tagStart + 2);
+      index = end === -1 || end + 2 > limit ? limit : end + 2;
+      continue;
+    }
+    const tagEnd = findTagEnd2(source, tagStart, limit);
+    if (tagEnd === -1) {
+      break;
+    }
+    const tag = source.slice(tagStart, tagEnd + 1);
+    if (tag.startsWith("<!")) {
+      index = tagEnd + 1;
+      continue;
+    }
+    const closingMatch = tag.match(/^<\s*\/\s*([A-Za-z_][A-Za-z0-9_.:-]*)/);
+    if (closingMatch?.[1]) {
+      closeElement(stack, closingMatch[1].toLowerCase());
+      index = tagEnd + 1;
+      continue;
+    }
+    const openingMatch = tag.match(/^<\s*([A-Za-z_][A-Za-z0-9_.:-]*)/);
+    if (openingMatch?.[1] && !/\/\s*>$/.test(tag)) {
+      const name = openingMatch[1].toLowerCase();
+      stack.push({
+        name,
+        ...name === "voice" ? { voiceName: getVoiceName(tag) } : {}
+      });
+    }
+    index = tagEnd + 1;
+  }
+  for (let stackIndex = stack.length - 1; stackIndex >= 0; stackIndex -= 1) {
+    const element = stack[stackIndex];
+    if (element?.name === "voice") {
+      return element.voiceName === void 0 ? {} : { voiceName: element.voiceName };
+    }
+  }
+  return void 0;
+}
+
+// ../ssml-editor-react/src/ssmlCompletion.ts
+var SSML_ATTRIBUTE_VALUE_PATTERN = /<([\w:-]+)\s+[^>]*?\b([\w:-]+)=["']([^"']*)$/i;
+var EXPRESS_AS_TAG_NAMES = /* @__PURE__ */ new Set(["mstts:express-as", "express-as", "expressas"]);
+function findSsmlAttributePresets(tagName, attributeName) {
+  const tagPresets = Object.entries(SSML_ATTRIBUTE_PRESETS).find(
+    ([presetTagName]) => presetTagName.toLowerCase() === tagName.toLowerCase()
+  )?.[1];
+  return Object.entries(tagPresets ?? {}).find(
+    ([presetAttributeName]) => presetAttributeName.toLowerCase() === attributeName.toLowerCase()
+  )?.[1];
+}
+var SSML_COMPLETION_SNIPPETS = [
+  {
+    label: "break",
+    insertText: '<break time="500ms" />'
+  },
+  {
+    label: "prosody",
+    insertText: `<prosody rate="medium" pitch="medium">\${1:text}</prosody>`
+  },
+  {
+    label: "mstts:express-as",
+    insertText: `<mstts:express-as style="cheerful">\${1:text}</mstts:express-as>`
+  },
+  {
+    label: "sub",
+    insertText: `<sub alias="\${1:\u8AAD\u307F}">\${2:\u6F22\u5B57}</sub>`
+  }
+];
+function registerSsmlCompletionProvider(monaco, options = {}) {
+  const provider = {
+    provideCompletionItems(model, position) {
+      if (options.model && options.model !== model) {
+        return { suggestions: [] };
+      }
+      const value = model.getValue();
+      const offset = model.getOffsetAt(position);
+      const textUntilPosition = value.slice(0, offset);
+      const isClosingTag = /<\/[a-zA-Z0-9:-]*$/.test(textUntilPosition);
+      if (isClosingTag) {
+        return { suggestions: [] };
+      }
+      const attributeMatch = SSML_ATTRIBUTE_VALUE_PATTERN.exec(textUntilPosition);
+      let attributeValues = attributeMatch ? findSsmlAttributePresets(attributeMatch[1], attributeMatch[2]) : void 0;
+      if (attributeMatch && attributeValues && EXPRESS_AS_TAG_NAMES.has(attributeMatch[1].toLowerCase()) && attributeMatch[2].toLowerCase() === "style") {
+        const voiceContext = findSsmlVoiceContext(value, offset);
+        const voiceName = voiceContext === void 0 ? options.getOuterVoiceName?.() : voiceContext.voiceName;
+        attributeValues = resolveExpressAsStyles(voiceName, attributeValues);
+      }
+      const openTagMatch = textUntilPosition.match(/<(?!\/)[a-zA-Z0-9:-]*$/);
+      const openTagLength = openTagMatch?.[0].length ?? 0;
+      const isAfterBracket = model.getValueInRange({
+        startLineNumber: position.lineNumber,
+        startColumn: position.column - 1,
+        endLineNumber: position.lineNumber,
+        endColumn: position.column
+      }) === "<";
+      const hasClosingBracket = isAfterBracket && model.getValueInRange({
+        startLineNumber: position.lineNumber,
+        startColumn: position.column,
+        endLineNumber: position.lineNumber,
+        endColumn: position.column + 1
+      }) === ">";
+      const range = {
+        startLineNumber: position.lineNumber,
+        startColumn: openTagLength > 0 ? position.column - openTagLength : position.column,
+        endLineNumber: position.lineNumber,
+        endColumn: hasClosingBracket ? position.column + 1 : position.column
+      };
+      return {
+        suggestions: [
+          ...attributeMatch ? [] : SSML_COMPLETION_SNIPPETS.map(({ label, insertText }) => ({
+            label,
+            kind: monaco.languages.CompletionItemKind.Snippet,
+            insertText,
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range
+          })),
+          ...attributeValues?.map((value2) => ({
+            label: value2,
+            kind: monaco.languages.CompletionItemKind.Value,
+            insertText: value2,
+            range
+          })) ?? []
+        ]
+      };
+    },
+    triggerCharacters: ["<", '"', "'"]
+  };
+  return monaco.languages.registerCompletionItemProvider("xml", provider);
+}
+
+// ../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",
+    noAvailableOptions: "\u5229\u7528\u53EF\u80FD\u306A\u9078\u629E\u80A2\u304C\u3042\u308A\u307E\u305B\u3093\u3002",
+    styleNotSupported: "\u3053\u306E\u97F3\u58F0\u306F\u30B9\u30BF\u30A4\u30EB\u6307\u5B9A\u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093",
+    categoryEmotions: "\u611F\u60C5\u30FB\u30C8\u30FC\u30F3",
+    categoryScenarios: "\u4F1A\u8A71\u30FB\u30B7\u30CA\u30EA\u30AA",
+    categoryMedia: "\u30E1\u30C7\u30A3\u30A2\u30FB\u30CA\u30EC\u30FC\u30B7\u30E7\u30F3",
+    categoryOther: "\u305D\u306E\u4ED6"
+  },
+  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",
+    noAvailableOptions: "No options are available.",
+    styleNotSupported: "This voice does not support style selection.",
+    categoryEmotions: "Emotions / Tone",
+    categoryScenarios: "Conversations / Scenarios",
+    categoryMedia: "Media / Broadcast",
+    categoryOther: "Other"
+  }
+};
+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." }
+        }
+      }
+    }
+  }
+};
+
+// ../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 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 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 findTagEnd3(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 && isXmlWhitespace2(source[index])) {
+    index += 1;
+  }
+  if (!isXmlNameStart2(source[index])) {
+    return void 0;
+  }
+  const nameStart = index;
+  index += 1;
+  while (index < contentEnd && isXmlNameCharacter2(source[index])) {
+    index += 1;
+  }
+  const nameEnd = index;
+  const attributes = [];
+  if (!closing) {
+    while (index < contentEnd) {
+      while (index < contentEnd && isXmlWhitespace2(source[index])) {
+        index += 1;
+      }
+      if (index >= contentEnd || source[index] === "/") {
+        break;
+      }
+      if (!isXmlNameStart2(source[index])) {
+        index += 1;
+        continue;
+      }
+      const attributeStart = index;
+      index += 1;
+      while (index < contentEnd && isXmlNameCharacter2(source[index])) {
+        index += 1;
+      }
+      const attributeEnd = index;
+      while (index < contentEnd && isXmlWhitespace2(source[index])) {
+        index += 1;
+      }
+      let value;
+      if (source[index] === "=") {
+        index += 1;
+        while (index < contentEnd && isXmlWhitespace2(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 && !isXmlWhitespace2(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 = findTagEnd3(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");
+}
+
+// ../ssml-editor-react/src/constants/ui.ts
+var SSML_INSERTION_MODES = {
+  insert: "insert",
+  wrap: "wrap"
+};
+
+// ../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 getLineBreakAt(value, offset) {
+  if (value.startsWith("\r\n", offset)) {
+    return "\r\n";
+  }
+  if (value[offset] === "\n" || value[offset] === "\r") {
+    return value[offset];
+  }
+  return "";
+}
+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, eol = "\n", selectedText = startOffset === endOffset ? "" : source.slice(startOffset, endOffset)) {
+  if (template.mode === SSML_INSERTION_MODES.wrap) {
+    const trailingLineBreak2 = getLineBreakAt(source, endOffset) === "" ? eol : "";
+    return {
+      replacement: `${template.prefix}${selectedText}${template.suffix}${trailingLineBreak2}`,
+      selectionOffset: template.prefix.length
+    };
+  }
+  const followingLineBreak = getLineBreakAt(source, endOffset);
+  const leadingLineBreak = !isLineStart(source, startOffset) && !startsWithLineBreak(template.prefix) ? eol : "";
+  const needsTrailingLineBreak = selectedText.length > 0 ? !selectedText.startsWith("\n") && !selectedText.startsWith("\r") : !isLineEnd(source, endOffset) || followingLineBreak === "";
+  const trailingLineBreak = needsTrailingLineBreak && !endsWithLineBreak(template.prefix) ? eol : "";
+  const insertionPrefix = `${leadingLineBreak}${template.prefix}`;
+  return {
+    replacement: `${insertionPrefix}${trailingLineBreak}${selectedText}`,
+    selectionOffset: insertionPrefix.length + trailingLineBreak.length + (selectedText.length === 0 && trailingLineBreak === "" ? followingLineBreak.length : 0)
+  };
+}
+
+// ../ssml-editor-react/src/ssmlInsertions.ts
+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"]
+  }
+];
+
+// src/SsmlEditorElement.ts
+var HTMLElementBase = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+var STYLE_ID = "ssml-editor-elements-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-active-bg: #dbeafe;
+  --ssml-editor-active-border: #2563eb;
+  --ssml-editor-preview-bg: #f3f4f6;
+}
+section[data-ssml-editor] {
+  display: grid;
+  grid-template-rows: auto minmax(8rem, 1fr);
+  gap: 0.75rem;
+  box-sizing: border-box;
+  width: 100%;
+  min-height: 100%;
+  padding: 1rem;
+  border: 1px solid var(--ssml-editor-border);
+  border-radius: 0.5rem;
+  color: var(--ssml-editor-color);
+  background: var(--ssml-editor-bg);
+}
+[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-active-bg: #1e3a8a;
+  --ssml-editor-active-border: #60a5fa;
+  --ssml-editor-preview-bg: #111827;
+}
+[data-ssml-editor] .ssml-editor-toolbar {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+[data-ssml-editor] .ssml-editor-toolbar-actions {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+[data-ssml-editor] .ssml-editor-toolbar-separator {
+  width: 1px;
+  height: 2.25rem;
+  margin: 0 0.25rem;
+  background: var(--ssml-editor-border);
+}
+[data-ssml-editor] .ssml-editor-toolbar-dropdown {
+  display: inline-block;
+}
+[data-ssml-editor] .ssml-editor-toolbar-button {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.375rem;
+  min-height: 2.25rem;
+  padding: 0.375rem 0.625rem;
+  border: 1px solid var(--ssml-editor-control-border);
+  border-radius: 0.25rem;
+  color: var(--ssml-editor-color);
+  background: var(--ssml-editor-control-bg);
+  font: inherit;
+  cursor: pointer;
+}
+[data-ssml-editor] .ssml-editor-toolbar-button:hover,
+[data-ssml-editor] .ssml-editor-toolbar-option:hover {
+  background: var(--ssml-editor-preview-bg);
+}
+[data-ssml-editor] .ssml-editor-toolbar-button:disabled {
+  cursor: not-allowed;
+  opacity: 0.55;
+}
+[data-ssml-editor] .ssml-editor-toolbar-button[data-active="true"] {
+  border-color: var(--ssml-editor-active-border);
+  background: var(--ssml-editor-active-bg);
+}
+[data-ssml-editor] .ssml-editor-toolbar-icon {
+  display: inline-flex;
+  width: 1.25rem;
+  justify-content: center;
+  font-size: 1.1rem;
+  line-height: 1;
+}
+[data-ssml-editor] .ssml-editor-toolbar-chevron {
+  font-size: 0.7rem;
+  line-height: 1;
+}
+[data-ssml-editor] .ssml-editor-toolbar-switch {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.375rem;
+  min-height: 2.25rem;
+}
+[data-ssml-editor] .ssml-editor-switch-track {
+  display: inline-flex;
+  align-items: center;
+  width: 2.75rem;
+  height: 1.5rem;
+  padding: 0.1875rem;
+  border: 0;
+  border-radius: 999px;
+  background: var(--ssml-editor-control-border);
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+}
+[data-ssml-editor] .ssml-editor-switch-track[aria-checked="true"] {
+  background: var(--ssml-editor-active-border);
+}
+[data-ssml-editor] .ssml-editor-switch-track:focus-visible {
+  outline: 2px solid var(--ssml-editor-active-border);
+  outline-offset: 2px;
+}
+[data-ssml-editor] .ssml-editor-switch-thumb {
+  width: 1.125rem;
+  height: 1.125rem;
+  border-radius: 50%;
+  background: var(--ssml-editor-bg);
+  transition: transform 0.2s ease;
+}
+[data-ssml-editor] .ssml-editor-switch-track[aria-checked="true"] .ssml-editor-switch-thumb {
+  transform: translateX(1.25rem);
+}
+[data-ssml-editor].ssml-editor-toolbar-menu {
+  position: fixed;
+  z-index: 9999;
+  display: grid;
+  min-width: max-content;
+  max-height: min(24rem, calc(100vh - 1rem));
+  gap: 0.125rem;
+  padding: 0.25rem;
+  border: 1px solid var(--ssml-editor-control-border);
+  border-radius: 0.25rem;
+  background: var(--ssml-editor-control-bg);
+  box-shadow: 0 0.25rem 0.75rem rgb(0 0 0 / 20%);
+  overflow-y: auto;
+}
+[data-ssml-editor] .ssml-editor-toolbar-option {
+  padding: 0.375rem 0.5rem;
+  border: 0;
+  border-radius: 0.125rem;
+  color: var(--ssml-editor-color);
+  background: transparent;
+  font: inherit;
+  text-align: left;
+  white-space: nowrap;
+  cursor: pointer;
+}
+[data-ssml-editor] .ssml-editor-toolbar-option-group {
+  display: grid;
+  gap: 0.125rem;
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+[data-ssml-editor] .ssml-editor-toolbar-option-group legend {
+  padding: 0.375rem 0.5rem 0.125rem;
+  font-size: 0.875rem;
+  font-weight: 600;
+  white-space: nowrap;
+}
+[data-ssml-editor] .ssml-editor-help {
+  display: grid;
+  gap: 0.5rem;
+  padding: 0.75rem;
+  border: 1px solid var(--ssml-editor-control-border);
+  border-radius: 0.25rem;
+  background: var(--ssml-editor-preview-bg);
+}
+[data-ssml-editor] .ssml-editor-help h3,
+[data-ssml-editor] .ssml-editor-help p {
+  margin: 0;
+}
+[data-ssml-editor] .ssml-editor-help-list {
+  display: grid;
+  gap: 0.375rem;
+  margin: 0;
+  padding-left: 1.25rem;
+}
+[data-ssml-editor] .ssml-editor-help-item {
+  list-style: none;
+}
+[data-ssml-editor] .ssml-editor-help-item details {
+  margin-top: 0.375rem;
+  border: 1px solid var(--ssml-editor-control-border);
+  border-radius: 0.25rem;
+  background: var(--ssml-editor-control-bg);
+}
+[data-ssml-editor] .ssml-editor-help-item summary {
+  padding: 0.5rem 0.625rem;
+  cursor: pointer;
+}
+[data-ssml-editor] .ssml-editor-help-item details p,
+[data-ssml-editor] .ssml-editor-help-item details ul {
+  margin: 0.5rem 0.75rem 0.75rem;
+  font-size: 0.875rem;
+}
+[data-ssml-editor] .ssml-editor-display {
+  display: grid;
+  grid-template-rows: auto minmax(8rem, 1fr);
+  gap: 0.5rem;
+  min-height: 0;
+}
+[data-ssml-editor] .ssml-editor-editor {
+  position: relative;
+  min-height: 8rem;
+  height: 100%;
+  border: 1px solid var(--ssml-editor-control-border);
+  border-radius: 0.25rem;
+  overflow: visible;
+}
+`.trim();
+function injectStyles() {
+  if (typeof document === "undefined" || document.getElementById(STYLE_ID)) {
+    return;
+  }
+  const style = document.createElement("style");
+  style.id = STYLE_ID;
+  style.textContent = STYLE_CSS;
+  document.head.appendChild(style);
+}
+function isDarkTheme(theme) {
+  return theme === "vs-dark" || theme.toLowerCase().includes("dark");
+}
+function getMenuPosition(trigger, menu) {
+  const bounds = trigger.getBoundingClientRect();
+  const margin = 8;
+  const top = Math.min(bounds.bottom + 4, window.innerHeight - menu.offsetHeight - margin);
+  const left = Math.min(bounds.left, window.innerWidth - menu.offsetWidth - margin);
+  return {
+    top: Math.max(margin, top),
+    left: Math.max(margin, left)
+  };
+}
+var SsmlEditorElement = class extends HTMLElementBase {
+  constructor() {
+    super(...arguments);
+    this.editor = null;
+    this.model = null;
+    this.monaco = null;
+    this.root = null;
+    this.toolbar = null;
+    this.toolbarActions = null;
+    this.display = null;
+    this.editorContainer = null;
+    this.helpPanel = null;
+    this.openMenu = null;
+    this.openMenuTrigger = null;
+    this.toolbarButtons = /* @__PURE__ */ new Map();
+    this.contentDisposable = null;
+    this.cursorDisposable = null;
+    this.completionDisposable = null;
+    this.hoverDisposable = null;
+    this.suppressChangeEvent = false;
+    this.initializationToken = 0;
+    this.documentState = null;
+    this.decorationsVisible = false;
+    this.helpOpen = false;
+    this.handleDocumentPointerDown = (event) => {
+      const target = event.target;
+      if (this.openMenu && target instanceof Node && !this.openMenu.contains(target) && !this.openMenuTrigger?.contains(target)) {
+        this.closeMenu();
+      }
+    };
+    this.handleDocumentKeyDown = (event) => {
+      if (event.key === "Escape" && this.openMenu) {
+        this.closeMenu(true);
+      }
+    };
+  }
+  get value() {
+    return this.valueState ?? this.getAttribute("value") ?? "";
+  }
+  set value(value) {
+    this.valueState = value;
+    this.setAttribute("value", value);
+  }
+  get theme() {
+    return this.getAttribute("theme") || "light";
+  }
+  set theme(theme) {
+    this.setAttribute("theme", theme);
+  }
+  get readonly() {
+    return this.hasAttribute("readonly");
+  }
+  set readonly(readonly) {
+    if (readonly) {
+      this.setAttribute("readonly", "");
+    } else {
+      this.removeAttribute("readonly");
+    }
+  }
+  get locale() {
+    return this.getAttribute("locale") === "en" ? "en" : "ja";
+  }
+  set locale(locale) {
+    this.setAttribute("locale", locale);
+  }
+  prepareDocument(value) {
+    try {
+      this.documentState = parseSsml2(value);
+      return getEditableText(this.documentState);
+    } catch {
+      this.documentState = null;
+      return value;
+    }
+  }
+  connectedCallback() {
+    if (this.editor || this.root) {
+      return;
+    }
+    injectStyles();
+    document.addEventListener("pointerdown", this.handleDocumentPointerDown);
+    document.addEventListener("keydown", this.handleDocumentKeyDown);
+    this.render();
+    const token = ++this.initializationToken;
+    void this.initialize(token);
+  }
+  disconnectedCallback() {
+    this.initializationToken += 1;
+    document.removeEventListener("pointerdown", this.handleDocumentPointerDown);
+    document.removeEventListener("keydown", this.handleDocumentKeyDown);
+    this.closeMenu();
+    this.disposeEditor();
+  }
+  attributeChangedCallback(name, _oldValue, newValue) {
+    if (name === "value") {
+      this.valueState = newValue ?? "";
+      if (this.editor) {
+        const value = newValue ?? "";
+        const editableValue = this.prepareDocument(value);
+        if (this.editor.getValue() !== editableValue) {
+          this.suppressChangeEvent = true;
+          try {
+            this.editor.setValue(editableValue);
+          } finally {
+            this.suppressChangeEvent = false;
+          }
+        }
+      }
+      return;
+    }
+    if (name === "theme" && this.monaco) {
+      this.monaco.editor.setTheme(this.theme);
+      this.updateTheme();
+      return;
+    }
+    if (name === "readonly") {
+      this.editor?.updateOptions({ readOnly: this.readonly });
+      this.renderToolbar();
+      return;
+    }
+    if (name === "locale" || name === "show-toolbar" || name === "show-toolbar-labels") {
+      this.renderToolbar();
+      this.renderHelp();
+      return;
+    }
+    if (name === "show-decorations") {
+      this.decorationsVisible = newValue !== null;
+      this.updateDecorations();
+    }
+  }
+  render() {
+    const root = document.createElement("section");
+    root.dataset.ssmlEditor = "";
+    root.setAttribute("aria-label", EDITOR_COPY[this.locale].editorAriaLabel);
+    root.dataset.theme = isDarkTheme(this.theme) ? "dark" : "light";
+    const toolbar = document.createElement("div");
+    toolbar.className = "ssml-editor-toolbar";
+    toolbar.dataset.ssmlEditorToolbar = "";
+    const toolbarActions = document.createElement("div");
+    toolbarActions.className = "ssml-editor-toolbar-actions";
+    toolbarActions.setAttribute("role", "toolbar");
+    toolbarActions.setAttribute("aria-label", EDITOR_COPY[this.locale].toolbarAriaLabel);
+    toolbarActions.dataset.ssmlEditorToolbarActions = "";
+    toolbar.append(toolbarActions);
+    const display = document.createElement("div");
+    display.className = "ssml-editor-display";
+    display.dataset.ssmlEditorDisplay = "";
+    const editorContainer = document.createElement("div");
+    editorContainer.className = "ssml-editor-editor";
+    display.append(editorContainer);
+    root.append(toolbar, display);
+    this.replaceChildren(root);
+    this.root = root;
+    this.toolbar = toolbar;
+    this.toolbarActions = toolbarActions;
+    this.display = display;
+    this.editorContainer = editorContainer;
+    this.renderToolbar();
+    this.renderHelp();
+  }
+  renderToolbar() {
+    const toolbar = this.toolbar;
+    const toolbarActions = this.toolbarActions;
+    if (!toolbar || !toolbarActions) {
+      return;
+    }
+    this.closeMenu();
+    const copy = EDITOR_COPY[this.locale];
+    toolbar.hidden = this.getAttribute("show-toolbar") === "false";
+    toolbar.setAttribute("aria-label", copy.toolbarAriaLabel);
+    toolbarActions.setAttribute("aria-label", copy.toolbarAriaLabel);
+    toolbarActions.replaceChildren();
+    this.toolbarButtons.clear();
+    if (toolbar.hidden) {
+      return;
+    }
+    const insertionById = new Map(SSML_INSERTIONS.map((insertion) => [insertion.id, insertion]));
+    const toolbarIds = [
+      "undo",
+      "redo",
+      ...DEFAULT_INSERTION_GROUPS.flatMap((group) => group.insertionIds),
+      "clearAll",
+      "format",
+      "decorations",
+      "help"
+    ];
+    const groupByButtonId = /* @__PURE__ */ new Map();
+    for (const group of DEFAULT_INSERTION_GROUPS) {
+      for (const buttonId of group.insertionIds) {
+        groupByButtonId.set(buttonId, group.id);
+      }
+    }
+    groupByButtonId.set("undo", "history");
+    groupByButtonId.set("redo", "history");
+    groupByButtonId.set("clearAll", "document");
+    groupByButtonId.set("format", "document");
+    groupByButtonId.set("decorations", "document");
+    groupByButtonId.set("help", "help");
+    let previousGroup;
+    for (const id of toolbarIds) {
+      const group = groupByButtonId.get(id);
+      if (previousGroup !== void 0 && group !== previousGroup) {
+        const separator = document.createElement("span");
+        separator.className = "ssml-editor-toolbar-separator";
+        separator.setAttribute("aria-hidden", "true");
+        toolbarActions.append(separator);
+      }
+      previousGroup = group;
+      const insertion = insertionById.get(id);
+      if (insertion) {
+        toolbarActions.append(this.createInsertionButton(insertion));
+      } else if (id === "decorations") {
+        toolbarActions.append(this.createDecorationsSwitch());
+      } else {
+        toolbarActions.append(this.createActionButton(id));
+      }
+    }
+    this.updateActiveButtons();
+  }
+  createActionButton(id) {
+    const copy = EDITOR_COPY[this.locale];
+    const labels = {
+      undo: copy.undo,
+      redo: copy.redo,
+      clearAll: copy.clearAll,
+      format: copy.format,
+      help: copy.help
+    };
+    const icons = {
+      undo: "\u21A9",
+      redo: "\u21AA",
+      clearAll: "\xD7",
+      format: "\u2261",
+      help: "?"
+    };
+    const titles = {
+      undo: copy.undoTitle,
+      redo: copy.redoTitle,
+      clearAll: copy.clearAllTitle,
+      format: copy.formatTitle,
+      help: copy.helpTitle
+    };
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "ssml-editor-toolbar-button";
+    button.dataset.ssmlEditorButton = id;
+    button.setAttribute("aria-label", labels[id] ?? id);
+    button.title = titles[id] ?? labels[id] ?? id;
+    button.disabled = this.readonly && id !== "help";
+    if (id === "help") {
+      button.setAttribute("aria-expanded", String(this.helpOpen));
+    }
+    const icon = document.createElement("span");
+    icon.className = "ssml-editor-toolbar-icon";
+    icon.setAttribute("aria-hidden", "true");
+    icon.textContent = icons[id] ?? "";
+    button.append(icon);
+    if (this.hasAttribute("show-toolbar-labels")) {
+      button.append(document.createTextNode(labels[id] ?? id));
+    }
+    button.addEventListener("click", () => {
+      if (id === "help") {
+        this.helpOpen = !this.helpOpen;
+        button.setAttribute("aria-expanded", String(this.helpOpen));
+        this.renderHelp();
+      } else if (!this.readonly) {
+        this.handleAction(id);
+      }
+    });
+    this.toolbarButtons.set(id, button);
+    return button;
+  }
+  createDecorationsSwitch() {
+    const copy = EDITOR_COPY[this.locale];
+    const wrapper = document.createElement("div");
+    wrapper.className = "ssml-editor-toolbar-switch";
+    const icon = document.createElement("span");
+    icon.className = "ssml-editor-toolbar-icon";
+    icon.setAttribute("aria-hidden", "true");
+    icon.textContent = "\u2606";
+    wrapper.append(icon);
+    if (this.hasAttribute("show-toolbar-labels")) {
+      wrapper.append(document.createTextNode(copy.decorations));
+    }
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "ssml-editor-switch-track";
+    button.dataset.ssmlEditorButton = "decorations";
+    button.setAttribute("role", "switch");
+    button.setAttribute("aria-label", copy.decorations);
+    button.addEventListener("click", () => {
+      this.decorationsVisible = !this.decorationsVisible;
+      this.updateDecorations();
+    });
+    wrapper.append(button);
+    this.toolbarButtons.set("decorations", button);
+    this.updateDecorations();
+    return wrapper;
+  }
+  createInsertionButton(insertion) {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "ssml-editor-toolbar-button";
+    button.dataset.ssmlEditorButton = insertion.id;
+    button.setAttribute("aria-label", insertion.labels[this.locale]);
+    button.setAttribute("aria-haspopup", "menu");
+    button.setAttribute("aria-expanded", "false");
+    button.title = insertion.titles?.[this.locale] ?? `${insertion.labels[this.locale]} \u2014 ${insertion.descriptions[this.locale]}`;
+    const icon = document.createElement("span");
+    icon.className = "ssml-editor-toolbar-icon";
+    icon.setAttribute("aria-hidden", "true");
+    icon.textContent = insertion.icon;
+    button.append(icon);
+    if (this.hasAttribute("show-toolbar-labels")) {
+      button.append(document.createTextNode(insertion.labels[this.locale]));
+    }
+    const chevron = document.createElement("span");
+    chevron.className = "ssml-editor-toolbar-chevron";
+    chevron.setAttribute("aria-hidden", "true");
+    chevron.textContent = "\u25BE";
+    button.append(chevron);
+    button.addEventListener("click", () => this.toggleInsertionMenu(insertion, button));
+    this.toolbarButtons.set(insertion.id, button);
+    const wrapper = document.createElement("div");
+    wrapper.className = "ssml-editor-toolbar-dropdown";
+    wrapper.append(button);
+    return wrapper;
+  }
+  toggleInsertionMenu(insertion, trigger) {
+    if (this.openMenuTrigger === trigger) {
+      this.closeMenu();
+      return;
+    }
+    this.closeMenu();
+    const menu = this.createInsertionMenu(insertion);
+    document.body.append(menu);
+    const position = getMenuPosition(trigger, menu);
+    menu.style.top = `${position.top}px`;
+    menu.style.left = `${position.left}px`;
+    trigger.setAttribute("aria-expanded", "true");
+    trigger.setAttribute("aria-controls", menu.id);
+    this.openMenu = menu;
+    this.openMenuTrigger = trigger;
+  }
+  createInsertionMenu(insertion) {
+    const menu = document.createElement("div");
+    menu.className = "ssml-editor-toolbar-menu";
+    menu.dataset.ssmlEditor = "";
+    menu.dataset.theme = isDarkTheme(this.theme) ? "dark" : "light";
+    menu.id = `ssml-editor-elements-menu-${insertion.id.replace(/[^A-Za-z0-9_-]/g, "-")}`;
+    menu.setAttribute("role", "menu");
+    menu.setAttribute("aria-label", insertion.labels[this.locale]);
+    menu.addEventListener("pointerdown", (event) => event.stopPropagation());
+    const options = this.getInsertionOptions(insertion);
+    if (options.length === 0) {
+      const empty = document.createElement("p");
+      empty.className = "ssml-editor-toolbar-option";
+      empty.textContent = EDITOR_COPY[this.locale].noAvailableOptions;
+      menu.append(empty);
+    } else {
+      for (const group of this.getOptionGroups(insertion, options)) {
+        if (group.label) {
+          const fieldset = document.createElement("fieldset");
+          fieldset.className = "ssml-editor-toolbar-option-group";
+          const legend = document.createElement("legend");
+          legend.textContent = group.label;
+          fieldset.append(legend);
+          for (const option of group.options) {
+            fieldset.append(this.createOptionButton(insertion, option));
+          }
+          menu.append(fieldset);
+        } else {
+          for (const option of group.options) {
+            menu.append(this.createOptionButton(insertion, option));
+          }
+        }
+      }
+    }
+    return menu;
+  }
+  getInsertionOptions(insertion) {
+    if (insertion.id !== "emotion") {
+      return insertion.options;
+    }
+    const model = this.model;
+    const selection = this.editor?.getSelection();
+    const voiceContext = model && selection ? findSsmlVoiceContext(model.getValue(), model.getOffsetAt(selection.getStartPosition())) : void 0;
+    const voiceName = voiceContext === void 0 ? this.documentState ? getEditableRegion(this.documentState).voiceName : void 0 : voiceContext.voiceName;
+    const availableStyles = new Set(
+      resolveExpressAsStyles(
+        voiceName,
+        insertion.options.map((option) => option.value)
+      )
+    );
+    return insertion.options.filter((option) => availableStyles.has(option.value));
+  }
+  getOptionGroups(insertion, options) {
+    if (insertion.id !== "emotion") {
+      return [{ label: "", options }];
+    }
+    const copy = EDITOR_COPY[this.locale];
+    const labels = {
+      emotions: copy.categoryEmotions,
+      scenarios: copy.categoryScenarios,
+      media: copy.categoryMedia,
+      other: copy.categoryOther
+    };
+    const categories = ["emotions", "scenarios", "media", "other"];
+    return categories.map((category) => ({
+      label: labels[category],
+      options: options.filter((option) => getExpressAsStyleCategory(option.value) === category)
+    })).filter((group) => group.options.length > 0);
+  }
+  createOptionButton(insertion, option) {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "ssml-editor-toolbar-option";
+    button.setAttribute("role", "menuitem");
+    button.title = option.descriptions?.[this.locale] ?? insertion.descriptions[this.locale];
+    button.textContent = option.labels[this.locale];
+    button.disabled = this.readonly;
+    button.addEventListener("click", () => {
+      if (!this.readonly) {
+        this.applyInsertion(insertion, option);
+      }
+      this.closeMenu(true);
+    });
+    button.addEventListener("mousedown", (event) => event.preventDefault());
+    return button;
+  }
+  handleAction(id) {
+    if (!this.editor) {
+      return;
+    }
+    if (id === "undo" || id === "redo") {
+      this.editor.trigger("ssml-toolbar", id, null);
+      this.editor.focus();
+    } else if (id === "clearAll") {
+      if (this.documentState) {
+        this.replaceDocument(clearSsmlDocument(this.documentState));
+      }
+    } else if (id === "format") {
+      if (this.documentState) {
+        this.replaceDocument(updateEditableText(this.documentState, formatXmlFragment(this.editor.getValue())));
+      } else {
+        this.replaceEditorValue(formatXmlFragment(this.editor.getValue()));
+      }
+    }
+  }
+  applyInsertion(insertion, option) {
+    const editor = this.editor;
+    const model = this.model;
+    const selection = editor?.getSelection();
+    if (!editor || !model || !selection) {
+      return;
+    }
+    const startOffset = model.getOffsetAt(selection.getStartPosition());
+    const endOffset = model.getOffsetAt(selection.getEndPosition());
+    const selectedText = selection.isEmpty() ? "" : model.getValueInRange(selection);
+    const result = createSsmlInsertionEdit(
+      model.getValue(),
+      startOffset,
+      endOffset,
+      insertion.createTemplate(option.value),
+      model.getEOL(),
+      selectedText
+    );
+    editor.pushUndoStop();
+    const applied = editor.executeEdits("ssml-toolbar", [{ range: selection, text: result.replacement }]);
+    editor.pushUndoStop();
+    if (!applied) {
+      return;
+    }
+    const start = model.getPositionAt(startOffset + result.selectionOffset);
+    const end = model.getPositionAt(endOffset + result.selectionOffset);
+    editor.setSelection({
+      selectionStartLineNumber: start.lineNumber,
+      selectionStartColumn: start.column,
+      positionLineNumber: end.lineNumber,
+      positionColumn: end.column
+    });
+    editor.focus();
+  }
+  replaceEditorValue(value) {
+    const editor = this.editor;
+    const model = editor?.getModel();
+    if (!editor || !model || editor.getValue() === value) {
+      return;
+    }
+    editor.pushUndoStop();
+    editor.executeEdits("ssml-editor-toolbar", [
+      {
+        range: model.getFullModelRange(),
+        text: value,
+        forceMoveMarkers: true
+      }
+    ]);
+    editor.pushUndoStop();
+    editor.focus();
+  }
+  replaceDocument(document2) {
+    const editor = this.editor;
+    const model = editor?.getModel();
+    const editableValue = getEditableText(document2);
+    const fullValue = buildSsml2(document2);
+    this.documentState = document2;
+    this.valueState = fullValue;
+    if (!editor || !model || editor.getValue() === editableValue) {
+      this.updateActiveButtons();
+      this.dispatchChange(fullValue);
+      return;
+    }
+    editor.pushUndoStop();
+    editor.executeEdits("ssml-editor-toolbar", [
+      {
+        range: model.getFullModelRange(),
+        text: editableValue,
+        forceMoveMarkers: true
+      }
+    ]);
+    editor.pushUndoStop();
+    editor.focus();
+  }
+  dispatchChange(value) {
+    if (this.suppressChangeEvent) {
+      return;
+    }
+    this.dispatchEvent(
+      new CustomEvent("change", {
+        detail: { value },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  updateDecorations() {
+    const button = this.toolbarButtons.get("decorations");
+    if (button) {
+      const copy = EDITOR_COPY[this.locale];
+      button.setAttribute("aria-checked", String(this.decorationsVisible));
+      button.title = this.decorationsVisible ? copy.decorationsHideTitle : copy.decorationsShowTitle;
+    }
+    this.editor?.updateOptions({
+      inlayHints: { enabled: this.decorationsVisible ? "on" : "off" }
+    });
+  }
+  renderHelp() {
+    const display = this.display;
+    if (!display) {
+      return;
+    }
+    this.helpPanel?.remove();
+    this.helpPanel = null;
+    const root = this.root;
+    if (root) {
+      root.setAttribute("aria-label", EDITOR_COPY[this.locale].editorAriaLabel);
+      this.updateTheme();
+    }
+    if (!this.helpOpen || this.getAttribute("show-toolbar") === "false") {
+      return;
+    }
+    const copy = EDITOR_COPY[this.locale];
+    const panel = document.createElement("section");
+    panel.className = "ssml-editor-help";
+    panel.setAttribute("aria-label", copy.helpHeading);
+    const heading = document.createElement("h3");
+    heading.textContent = copy.helpHeading;
+    const description = document.createElement("p");
+    description.textContent = copy.helpDescription;
+    const list = document.createElement("ul");
+    list.className = "ssml-editor-help-list";
+    for (const insertion of SSML_INSERTIONS) {
+      const item = document.createElement("li");
+      item.className = "ssml-editor-help-item";
+      const details = document.createElement("details");
+      const summary = document.createElement("summary");
+      summary.textContent = `${insertion.icon} ${insertion.labels[this.locale]} \u2014 ${insertion.descriptions[this.locale]}`;
+      const parameters = document.createElement("p");
+      parameters.textContent = `${copy.parameters}: ${insertion.parameterDescription[this.locale]}`;
+      const options = document.createElement("ul");
+      for (const option of insertion.options) {
+        const optionItem = document.createElement("li");
+        optionItem.textContent = `${option.labels[this.locale]}${option.descriptions?.[this.locale] ? ` \u2014 ${option.descriptions[this.locale]}` : ""}`;
+        options.append(optionItem);
+      }
+      details.append(summary, parameters, options);
+      item.append(details);
+      list.append(item);
+    }
+    panel.append(heading, description, list);
+    display.prepend(panel);
+    this.helpPanel = panel;
+  }
+  updateTheme() {
+    if (this.root) {
+      this.root.dataset.theme = isDarkTheme(this.theme) ? "dark" : "light";
+    }
+  }
+  updateActiveButtons() {
+    const editor = this.editor;
+    const model = this.model;
+    const selection = editor?.getSelection();
+    if (!editor || !model || !selection) {
+      return;
+    }
+    const activeTags = findActiveSsmlTags(model.getValue(), model.getOffsetAt(selection.getStartPosition()));
+    for (const insertion of SSML_INSERTIONS) {
+      const button = this.toolbarButtons.get(insertion.id);
+      if (button) {
+        button.dataset.active = String(
+          insertion.tagName !== void 0 && activeTags.has(insertion.tagName.toLowerCase())
+        );
+      }
+    }
+  }
+  async initialize(token) {
+    const container = this.editorContainer;
+    if (!container) {
+      return;
+    }
+    const monacoModule = await import("monaco-editor");
+    if (token !== this.initializationToken || !this.isConnected) {
+      return;
+    }
+    const model = monacoModule.editor.createModel(this.prepareDocument(this.value), "xml");
+    const editor = monacoModule.editor.create(container, {
+      model,
+      theme: this.theme,
+      readOnly: this.readonly,
+      automaticLayout: true,
+      minimap: { enabled: false },
+      wordWrap: "on",
+      inlayHints: { enabled: this.decorationsVisible ? "on" : "off" }
+    });
+    if (token !== this.initializationToken || !this.isConnected) {
+      editor.dispose();
+      model.dispose();
+      return;
+    }
+    this.monaco = monacoModule;
+    this.model = model;
+    this.editor = editor;
+    this.contentDisposable = editor.onDidChangeModelContent(() => {
+      const value = editor.getValue();
+      let nextValue = value;
+      if (this.documentState) {
+        this.documentState = updateEditableText(this.documentState, value);
+        nextValue = buildSsml2(this.documentState);
+      }
+      this.valueState = nextValue;
+      this.updateActiveButtons();
+      this.dispatchChange(nextValue);
+    });
+    this.cursorDisposable = editor.onDidChangeCursorPosition(() => this.updateActiveButtons());
+    this.completionDisposable = registerSsmlCompletionProvider(monacoModule, {
+      model,
+      getOuterVoiceName: () => this.documentState ? getEditableRegion(this.documentState).voiceName : void 0
+    });
+    this.hoverDisposable = monacoModule.languages.registerHoverProvider("xml", {
+      provideHover: (hoverModel, position) => {
+        const target = findSsmlHoverTarget(hoverModel.getValue(), position.lineNumber, position.column);
+        if (!target) {
+          return void 0;
+        }
+        return {
+          contents: [
+            {
+              isTrusted: false,
+              supportHtml: false,
+              value: formatSsmlHover(target)
+            }
+          ],
+          range: target.range
+        };
+      }
+    });
+    this.updateActiveButtons();
+  }
+  closeMenu(restoreFocus = false) {
+    this.openMenu?.remove();
+    this.openMenu = null;
+    if (this.openMenuTrigger) {
+      this.openMenuTrigger.setAttribute("aria-expanded", "false");
+      this.openMenuTrigger.removeAttribute("aria-controls");
+      if (restoreFocus) {
+        this.openMenuTrigger.focus();
+      }
+    }
+    this.openMenuTrigger = null;
+  }
+  disposeEditor() {
+    this.closeMenu();
+    this.contentDisposable?.dispose();
+    this.contentDisposable = null;
+    this.cursorDisposable?.dispose();
+    this.cursorDisposable = null;
+    this.completionDisposable?.dispose();
+    this.completionDisposable = null;
+    this.hoverDisposable?.dispose();
+    this.hoverDisposable = null;
+    this.editor?.dispose();
+    this.editor = null;
+    this.model?.dispose();
+    this.model = null;
+    this.monaco = null;
+    this.root?.remove();
+    this.root = null;
+    this.toolbar = null;
+    this.toolbarActions = null;
+    this.display = null;
+    this.editorContainer = null;
+    this.helpPanel = null;
+    this.toolbarButtons.clear();
+  }
+};
+SsmlEditorElement.tagName = "ssml-editor";
+SsmlEditorElement.observedAttributes = [
+  "value",
+  "theme",
+  "readonly",
+  "locale",
+  "show-toolbar",
+  "show-toolbar-labels",
+  "show-decorations"
+];
+
+// src/index.ts
+function defineSsmlEditorElement() {
+  if (typeof customElements === "undefined" || customElements.get(SsmlEditorElement.tagName)) {
+    return;
+  }
+  customElements.define(SsmlEditorElement.tagName, SsmlEditorElement);
+}
+export {
+  SsmlEditorElement,
+  defineSsmlEditorElement
+};
+//# sourceMappingURL=index.mjs.map