ssml-builder-js 2.11.0 → 2.13.0

package/README.md

@@ -236,9 +236,26 @@ const diagnostics = validateAzureSsml(ssml, {
   customVoiceStyleMap: { "my-custom-voice": ["narration"] },
   unknownVoicePolicy: "error", // "error" | "warn" | "ignore"
   allowedAudioOrigins: ["https://cdn.example.com"],
+  maxXmlDepth: 24,
 });
 ```
 
+`audio`、`mstts:backgroundaudio`、`lexicon`、`mstts:voiceconversion` の URL は `urlValidator`（または `customUrlValidator`）へ渡せます。Promise を返す検証関数で DNS 解決後のプライベート IP 遮断などを実装できます。
+
+`maxXmlDepth` は `<speak>` を深さ 1 として XML の過剰なネストを検出します。長文は `splitSsmlDocument` で `<p>`／`<s>` と親の `voice`、`prosody` コンテキストを保ったまま分割できます。
+
+```ts
+import { splitSsmlDocument } from "ssml-builder-js/core";
+
+const blocks = splitSsmlDocument(longSsml, 10_000);
+for (const block of blocks) {
+  // 各 block は独立した <speak> 文書として Azure へ送信できます。
+  await client.synthesize(block.ssml);
+}
+```
+
+各ブロックは `SsmlChunk`（`chunkIndex`、`originalTextRange`、継承した音声/言語/韻律、内包マーク、背景音声の有無）です。`<mstts:backgroundaudio>` はデフォルトで先頭チャンクだけに含まれ、全チャンクへ複製する場合は `splitSsmlDocument(longSsml, 10_000, { replicateBackgroundAudio: true })` を指定します。
+
 Azure Speech は `<audio>` の URL を取得するため、任意の URL をそのまま受け付けるサーバーは SSRF の踏み台になり得ます。ユーザー入力の SSML を合成する場合は、HTTPS、許可オリジン、リダイレクト先、応答サイズをサーバー側でも制限し、`allowExternalAudio` だけで無制限に許可しないでください。
 
 ## `ssml-editor-react` の利用方法
@@ -251,10 +268,14 @@ Visual Editor と Code Editor の対応要素は次のとおりです。
 
 | 要素 | Visual Editor | Code Editor |
 | --- | --- | --- |
-| `voice`、`prosody`、`break`、`express-as`、`say-as`、`phoneme` | フォーム操作・構造ツリー | 完全対応 |
+| `voice`、`prosody` | 音声名/effect、rate/pitch/volume/contour/range のフォーム | 完全対応 |
+| `say-as`、`phoneme` | 属性フォーム・構造ツリー | 完全対応 |
+| `audio` | URL、説明、clip、速度、繰り返し、音量のフォーム | 完全対応 |
+| `mark`、`bookmark` | 名前のフォーム | 完全対応 |
+| `mstts:silence`、`mstts:audioduration` | 種別/value・duration のフォーム | 完全対応 |
 | `mstts:dialog` / `mstts:turn` | 話者ターンの追加・音声/話者/本文編集 | 完全対応・補完あり |
 | `mstts:backgroundaudio` | URL、音量、フェードイン/アウト編集 | 完全対応・補完あり |
-| `mstts:ttsembedding`、`mstts:embedding`、`mstts:voiceconversion` | 構造ツリーで保持 | 完全対応 |
+| `mstts:ttsembedding`、`mstts:embedding`、`mstts:voiceconversion` | profile/id/url のフォーム | 完全対応 |
 | 未定義の XML 要素 | 構造ツリーで保持 | `custom` として編集 |
 
 Azure Speech のライフサイクル対応状況は次のとおりです。GA 要素は通常の静的検証対象、プレビュー要素・音声は Warning、非推奨要素・音声は Info の診断を返します。`AzureVoiceDefinition.status` と `AzureValidationOptions.tagStatuses` で外部カタログの状態も指定できます。
@@ -301,7 +322,7 @@ export function App() {
 - `onSsmlChange`: 編集後に生成された SSML 文字列を受け取るコールバック
 - `ref`: `SsmlEditorRef` の `getFullSsml()` で全体の SSML、`getSelectedSsml()` で選択範囲（未選択時は内容が空でないカーソル行）の SSML、`getCurrentLineSsml()` で現在行の SSML を取得。選択範囲やカーソル行が空の場合は `null` を返します
 - `onSelectionChange`: 選択テキスト、文字数、選択状態を受け取るコールバック
-- `onPreviewSelection`: フローティングアクションの試聴ボタン押下時に、選択部分の SSML を受け取るコールバック。省略時は試聴ボタンが無効になります。Azure などの音声 API はこのコールバックから呼び出してください
+- `onPreviewSelection`: フローティングアクションの試聴ボタン押下時に、選択部分を元の `speak` 属性、`voice`、`prosody` などの親コンテキストで包んだ一時 SSML を受け取るコールバック。省略時は試聴ボタンが無効になります。Azure などの音声 API はこのコールバックから呼び出してください
 - `editMode`: 初期編集モード（`"code"` または `"visual"`）。Visual モードは構造ツリーとフォームによる構造化編集を提供します
 - `locale`: 画面表示の言語（`"ja"` または `"en"`）。省略時は `"ja"`。ホバーヘルプを含む UI の翻訳にも使用されます
 - `language`: `locale` の旧名称。既存コードとの互換性のため利用できますが、新しいコードでは `locale` を使用してください
@@ -319,6 +340,8 @@ export function App() {
 - `insertionGroups`: 挿入メニューを縦線で区切るグループ設定。`toolbarGroups` を省略した場合は、この設定からツールバーの既定グループも作成されます。省略時は間・無音、声の調整、表現、読み上げに分けて表示されます
 - `emotionStyles`: `emotion` メニューに表示する音声スタイル候補
 - `customInsertions` / `additionalInsertions`: カスタム SSML 挿入定義。`customInsertions` は同じ ID の標準定義を置き換え、`additionalInsertions` は標準定義へ追加します
+- `customInspectors`: Visual Editor のタグ名ごとに Inspector を差し替えるレンダラー
+- `renderVoiceSelector`: 音声セレクターのカスタムレンダラー。`voiceCatalog` と `voiceLocale`、`voiceRegion`、`voiceStyle` で候補を絞り込めます。プレビュー音声にはバッジ情報も渡されます
 - `className` / `style`: エディター全体のクラス名とインラインスタイル
 - `toolbarClassName` / `toolbarStyle`: ツールバーのクラス名とインラインスタイル
 - `displayClassName` / `displayStyle`: 本文表示エリアのクラス名とインラインスタイル
@@ -685,6 +708,8 @@ const diagnostics = validateAzureSsml(ssml, {
 });
 ```
 
+URLs in `audio`, `mstts:backgroundaudio`, `lexicon`, and `mstts:voiceconversion` can be passed to `urlValidator` (or `customUrlValidator`). The callback may be asynchronous, making it suitable for host-side DNS/private-IP and SSRF policy checks.
+
 The catalog is represented by `AzureVoiceDefinition` with `name`, `locale`, optional `secondaryLocales`, `styles`, `supportedTags`, `unsupportedTags`, `models`, `regions`, and `status`. Pass `voiceDefinitions` (or `voiceCatalog`) to supplement or override the built-in catalog with an external definition. A tag that violates `supportedTags` or `unsupportedTags` produces `azure-unsupported-tag-for-voice` with error severity. `customVoiceStyleMap` remains supported for backward compatibility and overrides styles for the named voice. Diagnostics distinguish an unregistered voice (`azure-unknown-voice`, controlled by `unknownVoicePolicy`), an unsupported style on a registered voice (`azure-unsupported-style`), and a locale mismatch (`azure-locale-mismatch`). The `<mstts:audioduration value="10s"/>` element accepts positive `ms` or `s` values and `hh:mm:ss[.fff]` clock values.
 
 `npm run sync:voices -- --regions eastus,japaneast` fetches Azure's List Voices API for each region, deduplicates the results, and updates the generated TypeScript definitions plus `azureVoiceCatalog.json` with generation time, API version, regions, and voice count. Provide credentials through `AZURE_SPEECH_KEY` and `AZURE_SPEECH_REGION(S)`, or CLI options.
@@ -718,6 +743,17 @@ const diagnostics = validateAzureSsml(ssml, {
 
 Azure Speech fetches `<audio>` URLs, so a server that accepts arbitrary user-provided SSML can become an SSRF proxy. For untrusted SSML, enforce HTTPS, an origin allowlist, redirect policy, and response-size limits on the server; do not treat `allowExternalAudio` as a substitute for those controls.
 
+Long documents can be split into independently synthesizable `SsmlChunk` values:
+
+```ts
+import { splitSsmlDocument } from "ssml-builder-js/core";
+
+const chunks = splitSsmlDocument(longSsml, 10_000);
+for (const chunk of chunks) await client.synthesize(chunk.ssml);
+```
+
+Each chunk includes `chunkIndex`, `originalTextRange`, inherited voice/language/prosody context, contained markers, and background-audio state. Background audio is placed in the first chunk by default; pass `{ replicateBackgroundAudio: true }` as the third argument to include it in every chunk.
+
 ## Using `ssml-editor-react`
 
 `SsmlEditor` accepts an `SsmlDocument` and renders only a toolbar and text display area. The toolbar applies rate, volume, and pitch settings to the selection and provides undo and redo actions. The application is responsible for selecting and displaying the voice. Monaco Editor is used for text editing, and SSML syntax is validated whenever the text changes. Syntax errors are shown with editor markers and an error message. Hovering over XML tag names or parameters shows SSML descriptions. Selecting text displays a floating action bar with the character count and preview action. When `enableCodeLens` is enabled (the default), CodeLens quick controls for editing and unwrapping `prosody` tags and editing or deleting `break` tags are shown above those tags. When `showDecorations` is enabled, inline badges for pause and pitch changes are rendered next to `break` and `prosody` tags, and Monaco inline decorations are enabled. Generated SSML is provided through `onSsmlChange` so the application can display it wherever it needs. Pass an `SsmlEditorRef` through `ref` to retrieve full, selected, or current-line SSML, and use `onSelectionChange` to observe selection text and state. The UI supports Japanese (the default) and English.
@@ -796,6 +832,8 @@ export function App() {
 - `insertionGroups`: Groups insertion menus with vertical separators; when `toolbarGroups` is omitted, these groups also define the default toolbar groups. Menus are grouped into pauses, voice, expression, and pronunciation by default
 - `emotionStyles`: Candidate voice styles shown by the `emotion` menu
 - `customInsertions` / `additionalInsertions`: Custom SSML insertion definitions. `customInsertions` replaces a built-in definition with the same ID, while `additionalInsertions` adds definitions to the built-ins
+- `customInspectors`: Custom renderers keyed by element type or serialized tag name for the Visual Editor
+- `renderVoiceSelector`: Custom voice selector renderer. Supply `voiceCatalog` and optional `voiceLocale`, `voiceRegion`, or `voiceStyle` filters; preview status is included in each voice entry
 - `className` / `style`: A class name and inline styles for the editor container
 - `toolbarClassName` / `toolbarStyle`: A class name and inline styles for the toolbar
 - `displayClassName` / `displayStyle`: A class name and inline styles for the text display area
@@ -855,6 +893,26 @@ const catalog = await fetchAzureVoiceCatalog({
 });
 ```
 
+同期情報が必要な場合は `synthesizeSsml`（または `AzureTtsClient.synthesizeSsml`）を使用します。SDK の 100 ナノ秒単位のオフセットはミリ秒へ変換されます。
+
+```ts
+import { synthesizeSsml } from "ssml-builder-js";
+
+const result = await synthesizeSsml(ssml, {
+  subscriptionKey: process.env.AZURE_SPEECH_KEY!,
+  region: process.env.AZURE_SPEECH_REGION!,
+});
+result.audioData; // ArrayBuffer
+result.durationMs;
+result.boundaries; // { text, audioOffsetMs, durationMs }[]
+result.visemes; // { visemeId, audioOffsetMs }[]
+result.bookmarks; // { name, audioOffsetMs }[]
+```
+
+長文を分割して合成する場合は `synthesizeSsmlChunks` または `AzureTtsClient.synthesizeChunks` を使います。音声バイナリを連結し、`boundaries`、`visemes`、`bookmarks` のオフセットを累積 `durationMs` 分だけ補正します。`synthesizeSsmlSafe(client, ssml, { validation })` は検証エラー時に Azure API を呼び出さず、`status: "validation-error"` / `"azure-api-error"` / `"success"` の結果を返します。
+
+For long documents, use `synthesizeSsmlChunks` or `AzureTtsClient.synthesizeChunks`; `onProgress` reports completed chunks while audio and synchronization offsets are merged. `synthesizeSsmlSafe(client, ssml, { validation })` validates before synthesis and returns a discriminated result without calling Azure when static validation fails.
+
 The public updater CLI is `npx ssml-builder sync-voices --region eastus --output ./azure-voices.json`. It reads the key from `AZURE_SPEECH_KEY` (or `--key`) and regions from `AZURE_SPEECH_REGION(S)` (or `--region(s)`).
 
 ```ts

package/dist/{chunk-SNRI43QJ.mjs → chunk-25LOR4AJ.mjs}

@@ -931,6 +931,183 @@ function buildPartialSsml(textOrOptions, context) {
   return serializePartialSsml(textOrOptions.text, textOrOptions);
 }
 
+// packages/ssml-core/src/split.ts
+var DEFAULT_MAX_LENGTH = 1e4;
+function cloneElement(element, children) {
+  return { ...element, children };
+}
+function documentWithChildren(document, children) {
+  return buildSsml({ ...document, children });
+}
+function wrapWithContext(node, context) {
+  return context.reduceRight((current, parent) => cloneElement(parent, [current]), node);
+}
+function documentWithNode(document, node, context) {
+  return documentWithChildren(document, [wrapWithContext(node, context)]);
+}
+function splitTextNode(text, document, context, maxLength) {
+  if (!text) return [text];
+  const parts = [];
+  let start = 0;
+  while (start < text.length) {
+    let end = start + 1;
+    let bestEnd = end;
+    while (end <= text.length) {
+      if (documentWithNode(document, text.slice(start, end), context).length > maxLength) break;
+      bestEnd = end;
+      end += 1;
+    }
+    if (bestEnd === start) {
+      throw new RangeError("maxLength is too small to contain the SSML document wrapper");
+    }
+    const segment = text.slice(start, bestEnd);
+    const boundary = Math.max(segment.lastIndexOf(" "), segment.lastIndexOf("\n"), segment.lastIndexOf("	"));
+    const splitEnd = boundary > 0 ? start + boundary + 1 : bestEnd;
+    parts.push(text.slice(start, splitEnd));
+    start = splitEnd;
+  }
+  return parts;
+}
+function splitNode(document, node, maxLength, context = []) {
+  if (typeof node === "string" || node.type === "text") {
+    const value = typeof node === "string" ? node : node.value;
+    if (documentWithNode(document, node, context).length <= maxLength) return [node];
+    return splitTextNode(value, document, context, maxLength);
+  }
+  if (documentWithNode(document, node, context).length <= maxLength) return [node];
+  const children = node.children ?? [];
+  if (children.length === 0) {
+    throw new RangeError(`maxLength is too small to contain <${node.type}>`);
+  }
+  const splitChildren = children.flatMap((child) => splitNode(document, child, maxLength, [...context, node]));
+  const parts = [];
+  let group = [];
+  const flush = () => {
+    if (group.length > 0) {
+      parts.push(cloneElement(node, group));
+      group = [];
+    }
+  };
+  for (const child of splitChildren) {
+    const candidate = cloneElement(node, [...group, child]);
+    if (documentWithNode(document, candidate, context).length <= maxLength) {
+      group.push(child);
+      continue;
+    }
+    flush();
+    if (documentWithNode(document, cloneElement(node, [child]), context).length > maxLength) {
+      throw new RangeError(`maxLength is too small to contain <${node.type}>`);
+    }
+    group.push(child);
+  }
+  flush();
+  return parts;
+}
+function textFromNode(node) {
+  if (typeof node === "string") return node;
+  if (node.type === "text") return node.value;
+  return (node.children ?? []).map(textFromNode).join("");
+}
+function collectMarks(node, marks) {
+  if (typeof node === "string" || node.type === "text") return;
+  if (node.type === "mark" && node.name) marks.push(node.name);
+  if (node.type === "bookmark" && node.mark) marks.push(node.mark);
+  for (const child of node.children ?? []) collectMarks(child, marks);
+}
+function collectInheritedContext(nodes) {
+  const context = {};
+  const visit = (node) => {
+    if (typeof node === "string" || node.type === "text") return;
+    if (context.voice === void 0 && node.type === "voice" && node.name) context.voice = node.name;
+    if (context.lang === void 0 && node.type === "lang" && node.lang) context.lang = node.lang;
+    if (context.prosody === void 0 && node.type === "prosody") {
+      const prosody = {};
+      for (const [key, value] of Object.entries(node.attributes ?? {})) prosody[key] = String(value);
+      for (const key of ["rate", "pitch", "volume", "contour", "range"]) {
+        const value = node[key];
+        if (value !== void 0) prosody[key] = String(value);
+      }
+      if (Object.keys(prosody).length > 0) context.prosody = prosody;
+    }
+    for (const child of node.children ?? []) visit(child);
+  };
+  nodes.forEach(visit);
+  return context;
+}
+function createChunk(document, nodes, chunkIndex, textStart, backgroundAudio, replicateBackgroundAudio) {
+  const chunkNodes = backgroundAudio && (replicateBackgroundAudio || chunkIndex === 0) ? [backgroundAudio, ...nodes] : nodes;
+  const text = nodes.map(textFromNode).join("");
+  const marks = [];
+  for (const node of nodes) collectMarks(node, marks);
+  const inheritedContext = collectInheritedContext(nodes);
+  if (inheritedContext.lang === void 0 && document.lang) inheritedContext.lang = document.lang;
+  return {
+    chunkIndex,
+    ssml: documentWithChildren(document, chunkNodes),
+    originalTextRange: { start: textStart, end: textStart + text.length },
+    inheritedContext,
+    containedMarks: marks,
+    hasBackgroundAudio: chunkNodes.some(
+      (node) => typeof node !== "string" && node.type !== "text" && node.type === "mstts:backgroundaudio"
+    )
+  };
+}
+function splitSsmlDocument(ssml, maxLength = DEFAULT_MAX_LENGTH, options = {}) {
+  const resolvedMaxLength = typeof maxLength === "number" ? maxLength : maxLength.maxLength ?? DEFAULT_MAX_LENGTH;
+  const resolvedOptions = typeof maxLength === "number" ? options : maxLength;
+  if (!Number.isInteger(resolvedMaxLength) || resolvedMaxLength <= 0) {
+    throw new RangeError("maxLength must be a positive integer");
+  }
+  const document = parseSsml(ssml);
+  const backgroundAudio = (document.children ?? []).find(
+    (node) => typeof node !== "string" && node.type !== "text" && node.type === "mstts:backgroundaudio"
+  );
+  if (ssml.length <= resolvedMaxLength) {
+    return [createChunk(document, document.children ?? [], 0, 0, backgroundAudio, true)];
+  }
+  const contentChildren = (document.children ?? []).filter((node) => node !== backgroundAudio);
+  const plainDocumentLength = documentWithChildren(document, []).length;
+  const backgroundDocumentLength = backgroundAudio ? documentWithChildren(document, [backgroundAudio]).length : plainDocumentLength;
+  const backgroundOverhead = Math.max(0, backgroundDocumentLength - plainDocumentLength);
+  const contentMaxLength = Math.max(1, resolvedMaxLength - backgroundOverhead);
+  const splitChildren = contentChildren.flatMap((child) => splitNode(document, child, contentMaxLength));
+  const chunks = [];
+  let group = [];
+  for (const child of splitChildren) {
+    const candidate = [...group, child];
+    if (documentWithChildren(document, candidate).length <= contentMaxLength) {
+      group = candidate;
+      continue;
+    }
+    if (group.length > 0) chunks.push(group);
+    group = [child];
+    if (documentWithChildren(document, group).length > contentMaxLength) {
+      throw new RangeError("maxLength is too small to contain the SSML document wrapper");
+    }
+  }
+  if (group.length > 0) chunks.push(group);
+  if (chunks.length === 0) {
+    const result = createChunk(document, [], 0, 0, backgroundAudio, resolvedOptions.replicateBackgroundAudio ?? false);
+    if (result.ssml.length > resolvedMaxLength) {
+      throw new RangeError("maxLength is too small to contain the SSML document wrapper");
+    }
+    return [result];
+  }
+  let textStart = 0;
+  return chunks.map((chunk, chunkIndex) => {
+    const result = createChunk(
+      document,
+      chunk,
+      chunkIndex,
+      textStart,
+      backgroundAudio,
+      resolvedOptions.replicateBackgroundAudio ?? false
+    );
+    textStart = result.originalTextRange.end;
+    return result;
+  });
+}
+
 // packages/ssml-core/src/validation.ts
 var PARSER_POSITION_SUFFIX = / at position (\d+)$/;
 function validateSsml(xmlString) {
@@ -1625,6 +1802,7 @@ function tokenizeElements(source) {
       attributes,
       childElementIndex,
       end,
+      depth: openElements.length + 1,
       name: tokenName,
       parentName: parent?.name,
       parentVoiceName,
@@ -1815,13 +1993,18 @@ function validateAudioSource(token, source, diagnostics, options, elementName2)
     addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must be an absolute HTTP(S) URL.`);
     return;
   }
+  if (parsed.username || parsed.password)
+    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must not contain URL credentials.`);
   if (parsed.protocol !== "https:" && !(options.allowHttpAudio && parsed.protocol === "http:"))
     addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must use HTTPS.`);
   const isAllowedOrigin = options.allowedAudioOrigins?.some((allowedOrigin) => {
     try {
-      return new URL(allowedOrigin).origin === parsed.origin;
+      const configured = new URL(allowedOrigin);
+      if (configured.protocol !== "https:" && configured.protocol !== "http:" || configured.username || configured.password || configured.pathname !== "/" || configured.search || configured.hash)
+        return false;
+      return configured.origin === parsed.origin;
     } catch {
-      return allowedOrigin === parsed.origin;
+      return false;
     }
   }) ?? false;
   if (options.allowedAudioOrigins && !isAllowedOrigin)
@@ -2013,7 +2196,7 @@ function validateElement(token, source, diagnostics, voiceName, options, voiceCa
       addDiagnostic(diagnostics, source, token.start, "<mstts:backgroundaudio> must be self-closing.");
   }
 }
-function validateAzureSsml(ssml, options = {}) {
+function validateAzureSsmlStatic(ssml, options = {}) {
   const diagnostics = [];
   if (typeof ssml !== "string") {
     return [
@@ -2029,6 +2212,9 @@ function validateAzureSsml(ssml, options = {}) {
   const maxLength = options.maxLength ?? 1e4;
   if (ssml.length > maxLength)
     addDiagnostic(diagnostics, ssml, maxLength, `SSML exceeds the maximum length of ${maxLength} characters.`);
+  if (options.maxXmlDepth !== void 0 && (!Number.isInteger(options.maxXmlDepth) || options.maxXmlDepth <= 0)) {
+    addDiagnostic(diagnostics, ssml, 0, "maxXmlDepth must be a positive integer.");
+  }
   try {
     parseSsml(ssml);
   } catch (error) {
@@ -2038,6 +2224,18 @@ function validateAzureSsml(ssml, options = {}) {
     return diagnostics;
   }
   const tokens = tokenizeElements(ssml);
+  if (options.maxXmlDepth !== void 0) {
+    for (const token of tokens) {
+      if (token.depth > options.maxXmlDepth) {
+        addDiagnostic(
+          diagnostics,
+          ssml,
+          token.start,
+          `XML nesting depth ${token.depth} exceeds the configured maximum of ${options.maxXmlDepth}.`
+        );
+      }
+    }
+  }
   const speak = tokens.find((token) => token.name.toLowerCase() === "speak");
   const voices = tokens.filter((token) => token.name.toLowerCase() === "voice");
   const backgroundAudioTokens = tokens.filter((token) => token.name.toLowerCase() === "mstts:backgroundaudio");
@@ -2122,6 +2320,51 @@ function validateAzureSsml(ssml, options = {}) {
   }
   return diagnostics;
 }
+function urlAttributes(token) {
+  const tag = canonicalTagName(token.name);
+  const attributes = tag === "audio" || tag === "mstts:backgroundaudio" ? ["src"] : tag === "lexicon" ? ["uri"] : tag === "mstts:voiceconversion" ? ["url"] : [];
+  return attributes.flatMap((attribute) => {
+    const value = attr(token, attribute);
+    return value === void 0 ? [] : [{ attribute, value }];
+  });
+}
+function validateAzureSsml(ssml, options = {}) {
+  const diagnostics = validateAzureSsmlStatic(ssml, options);
+  const validator = options.urlValidator ?? options.customUrlValidator;
+  if (!validator || typeof ssml !== "string") return diagnostics;
+  let tokens;
+  try {
+    tokens = tokenizeElements(ssml);
+  } catch {
+    return diagnostics;
+  }
+  const checks = tokens.flatMap(
+    (token) => urlAttributes(token).map(async ({ attribute, value }) => {
+      try {
+        const result = await validator(value, { tag: token.name, attribute });
+        const valid = typeof result === "boolean" ? result : result.valid;
+        if (!valid) {
+          const reason = typeof result === "boolean" ? void 0 : result.reason;
+          addDiagnostic(
+            diagnostics,
+            ssml,
+            token.start,
+            `<${token.name} ${attribute}> was rejected by the custom URL validator${reason ? `: ${reason}` : "."}`
+          );
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        addDiagnostic(
+          diagnostics,
+          ssml,
+          token.start,
+          `<${token.name} ${attribute}> could not be validated by the custom URL validator: ${reason}`
+        );
+      }
+    })
+  );
+  return Promise.all(checks).then(() => diagnostics);
+}
 
 // packages/ssml-core/src/generated/azureVoiceCatalog.ts
 var AZURE_VOICE_CATALOG_METADATA = {
@@ -2144,6 +2387,7 @@ export {
   buildSsml,
   parseSsml,
   buildPartialSsml,
+  splitSsmlDocument,
   validateSsml,
   extractSsmlText,
   mapSsmlTextNodes,
@@ -2157,4 +2401,4 @@ export {
   getAzureVoiceCatalogMetadata,
   getBuiltInVoiceCatalogMetadata
 };
-//# sourceMappingURL=chunk-SNRI43QJ.mjs.map
+//# sourceMappingURL=chunk-25LOR4AJ.mjs.map