ssml-builder-js 2.6.0 → 2.7.0

package/dist/elements.mjs

@@ -33,7 +33,7 @@ import {
   registerSsmlCompletionProvider,
   resolveExpressAsStyles,
   updateEditableText
-} from "./chunk-GF4QZHLJ.mjs";
+} from "./chunk-QJTVHANI.mjs";
 import "./chunk-6S5ODO6A.mjs";
 
 // packages/ssml-editor-react/src/ssmlInsertions.ts

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { AudioElement, AzureSsmlValidationOptions, AzureValidationOptions, BookmarkElement, BreakElement, BuildPartialSsmlOptions, CustomElement, EmphasisElement, ExpressAsElement, LangElement, LexiconElement, MapSsmlTextNodesOptions, MarkElement, MsttsSilenceElement, MsttsVisemeElement, NamedElement, ParagraphElement, PhonemeElement, ProsodyElement, SayAsElement, SentenceElement, SsmlAttributeValue, SsmlAttributes, SsmlBreakElement, SsmlDiagnostic, SsmlDiagnosticSeverity, SsmlDocument, SsmlElement, SsmlElementBase, SsmlExpressAsElement, SsmlNode, SsmlPartialContext, SsmlPartialProsody, SsmlPartialVoice, SsmlPhonemeElement, SsmlProsodyElement, SsmlSayAsElement, SsmlText, SsmlTextNodeContext, SsmlValidationError, SsmlVoiceElement, SubElement, VoiceElement, WordElement, buildPartialSsml, buildSsml, extractSsmlText, mapSsmlTextNodes, parseSsml, validateAzureSsml, validateSsml } from './core.mjs';
+export { AudioElement, AzureDiagnosticCode, AzureLanguageNormalizationOptions, AzureSsmlValidationOptions, AzureValidationOptions, AzureVoiceDefinition, AzureVoiceMetadata, BookmarkElement, BreakElement, BuildPartialSsmlOptions, CustomElement, EmphasisElement, ExpressAsElement, LangElement, LexiconElement, MapSsmlTextNodesOptions, MarkElement, MsttsSilenceElement, MsttsVisemeElement, NamedElement, ParagraphElement, PhonemeElement, ProsodyElement, SayAsElement, SentenceElement, SsmlAttributeValue, SsmlAttributes, SsmlBreakElement, SsmlDiagnostic, SsmlDiagnosticSeverity, SsmlDocument, SsmlElement, SsmlElementBase, SsmlExpressAsElement, SsmlNode, SsmlPartialContext, SsmlPartialProsody, SsmlPartialVoice, SsmlPhonemeElement, SsmlProsodyElement, SsmlSayAsElement, SsmlText, SsmlTextNodeContext, SsmlValidationError, SsmlVoiceElement, SubElement, VoiceElement, WordElement, areAzureLanguagesEquivalent, buildPartialSsml, buildSsml, extractSsmlText, mapSsmlTextNodes, normalizeAzureLanguage, parseSsml, validateAzureSsml, validateSsml } from './core.mjs';
 
 interface TtsConfig {
     signal?: AbortSignal;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { AudioElement, AzureSsmlValidationOptions, AzureValidationOptions, BookmarkElement, BreakElement, BuildPartialSsmlOptions, CustomElement, EmphasisElement, ExpressAsElement, LangElement, LexiconElement, MapSsmlTextNodesOptions, MarkElement, MsttsSilenceElement, MsttsVisemeElement, NamedElement, ParagraphElement, PhonemeElement, ProsodyElement, SayAsElement, SentenceElement, SsmlAttributeValue, SsmlAttributes, SsmlBreakElement, SsmlDiagnostic, SsmlDiagnosticSeverity, SsmlDocument, SsmlElement, SsmlElementBase, SsmlExpressAsElement, SsmlNode, SsmlPartialContext, SsmlPartialProsody, SsmlPartialVoice, SsmlPhonemeElement, SsmlProsodyElement, SsmlSayAsElement, SsmlText, SsmlTextNodeContext, SsmlValidationError, SsmlVoiceElement, SubElement, VoiceElement, WordElement, buildPartialSsml, buildSsml, extractSsmlText, mapSsmlTextNodes, parseSsml, validateAzureSsml, validateSsml } from './core.js';
+export { AudioElement, AzureDiagnosticCode, AzureLanguageNormalizationOptions, AzureSsmlValidationOptions, AzureValidationOptions, AzureVoiceDefinition, AzureVoiceMetadata, BookmarkElement, BreakElement, BuildPartialSsmlOptions, CustomElement, EmphasisElement, ExpressAsElement, LangElement, LexiconElement, MapSsmlTextNodesOptions, MarkElement, MsttsSilenceElement, MsttsVisemeElement, NamedElement, ParagraphElement, PhonemeElement, ProsodyElement, SayAsElement, SentenceElement, SsmlAttributeValue, SsmlAttributes, SsmlBreakElement, SsmlDiagnostic, SsmlDiagnosticSeverity, SsmlDocument, SsmlElement, SsmlElementBase, SsmlExpressAsElement, SsmlNode, SsmlPartialContext, SsmlPartialProsody, SsmlPartialVoice, SsmlPhonemeElement, SsmlProsodyElement, SsmlSayAsElement, SsmlText, SsmlTextNodeContext, SsmlValidationError, SsmlVoiceElement, SubElement, VoiceElement, WordElement, areAzureLanguagesEquivalent, buildPartialSsml, buildSsml, extractSsmlText, mapSsmlTextNodes, normalizeAzureLanguage, parseSsml, validateAzureSsml, validateSsml } from './core.js';
 
 interface TtsConfig {
     signal?: AbortSignal;

package/dist/index.js

@@ -40,10 +40,12 @@ __export(src_exports, {
   AzureTtsClient: () => AzureTtsClient,
   AzureTtsError: () => AzureTtsError,
   AzureTtsSdkError: () => AzureTtsSdkError,
+  areAzureLanguagesEquivalent: () => areAzureLanguagesEquivalent,
   buildPartialSsml: () => buildPartialSsml,
   buildSsml: () => buildSsml,
   extractSsmlText: () => extractSsmlText,
   mapSsmlTextNodes: () => mapSsmlTextNodes,
+  normalizeAzureLanguage: () => normalizeAzureLanguage,
   parseSsml: () => parseSsml,
   synthesizeSpeech: () => synthesizeSpeech,
   validateAzureSsml: () => validateAzureSsml,
@@ -1241,51 +1243,123 @@ function location(source, offset) {
   const line = before.split("\n").length;
   return { line, column: before.length - (before.lastIndexOf("\n") + 1) + 1 };
 }
-function addDiagnostic(diagnostics, source, offset, message, severity = "error") {
-  diagnostics.push({ ...location(source, offset), message, severity });
+function addDiagnostic(diagnostics, source, offset, message, severity = "error", code) {
+  diagnostics.push({ ...location(source, offset), message, severity, ...code ? { code } : {} });
 }
 function attr(token, name) {
   return token.attributes.get(name.toLowerCase());
 }
-function normalizeVoiceStyleMap(customVoiceStyleMap) {
-  const map = new Map(
-    Object.entries(EXPRESS_AS_STYLES).map(([voiceName, styles]) => [voiceName.toLowerCase(), styles])
-  );
-  for (const [voiceName, styles] of Object.entries(customVoiceStyleMap ?? {})) {
-    map.set(
-      voiceName.toLowerCase(),
-      styles.map((style) => style.toLowerCase())
-    );
+var ADDITIONAL_VOICE_DEFINITIONS = [
+  { name: "zh-TW-HsiaoChenNeural", locale: "zh-TW" },
+  { name: "es-ES-ElviraNeural", locale: "es-ES" },
+  { name: "th-TH-PremwadeeNeural", locale: "th-TH" },
+  { name: "fil-PH-AngeloNeural", locale: "fil-PH" },
+  { name: "vi-VN-HoaiMyNeural", locale: "vi-VN" },
+  { name: "id-ID-GadisNeural", locale: "id-ID" },
+  { name: "ms-MY-YasminNeural", locale: "ms-MY" }
+];
+var DEFAULT_LANGUAGE_ALIASES = {
+  "zh-CN": ["zh-Hans"],
+  "zh-TW": ["zh-Hant"]
+};
+function canonicalLanguageTag(language) {
+  const trimmed = language.trim();
+  if (!trimmed) return "";
+  try {
+    return new Intl.Locale(trimmed).toString().toLowerCase();
+  } catch {
+    return trimmed.toLowerCase();
   }
-  return map;
 }
-function diagnosticSeverity(policy) {
-  if (policy === "ignore") return void 0;
-  return policy === "error" ? "error" : "warning";
+function createLanguageNormalizer(options) {
+  const aliases = /* @__PURE__ */ new Map();
+  const addAliasGroup = (canonical, values) => {
+    const normalizedCanonical = canonicalLanguageTag(canonical);
+    if (!normalizedCanonical) return;
+    aliases.set(normalizedCanonical, normalizedCanonical);
+    for (const value of values) {
+      const normalizedValue = canonicalLanguageTag(value);
+      if (normalizedValue) aliases.set(normalizedValue, normalizedCanonical);
+    }
+  };
+  for (const [canonical, values] of Object.entries(DEFAULT_LANGUAGE_ALIASES)) addAliasGroup(canonical, values);
+  for (const [canonical, valueOrValues] of Object.entries(options.languageAliases ?? {}))
+    addAliasGroup(canonical, typeof valueOrValues === "string" ? [valueOrValues] : valueOrValues);
+  return (language) => {
+    const customValue = options.normalizeLanguage ? options.normalizeLanguage(language) : language;
+    const normalized = canonicalLanguageTag(customValue);
+    return aliases.get(normalized) ?? normalized;
+  };
+}
+function normalizeAzureLanguage(language, options = {}) {
+  return createLanguageNormalizer(options)(language);
+}
+function areAzureLanguagesEquivalent(first, second, options = {}) {
+  const normalize = createLanguageNormalizer(options);
+  const normalizedFirst = normalize(first);
+  const normalizedSecond = normalize(second);
+  if (normalizedFirst === normalizedSecond) return true;
+  return normalizedFirst === languagePart(normalizedFirst) && languagePart(normalizedFirst) === languagePart(normalizedSecond);
 }
 function voiceLocalePrefix(voiceName) {
   const match = /^(?<language>[A-Za-z]{2,3})-(?<region>[A-Za-z]{2}|\d{3})(?:-|$)/.exec(voiceName.trim());
   if (!match?.groups) return void 0;
+  const tag = `${match.groups.language}-${match.groups.region}`;
   return {
     language: match.groups.language.toLowerCase(),
-    region: match.groups.region.toLowerCase()
+    region: match.groups.region.toLowerCase(),
+    tag
   };
 }
-function languageLocalePrefix(language) {
-  const match = /^(?<language>[A-Za-z]{2,3})(?:-(?<region>[A-Za-z]{2}|\d{3}))?(?:-|$)/.exec(language.trim());
-  if (!match?.groups) return void 0;
+function definitionFromStyleMap(voiceName, styles) {
   return {
-    language: match.groups.language.toLowerCase(),
-    region: match.groups.region?.toLowerCase()
+    name: voiceName,
+    locale: voiceLocalePrefix(voiceName)?.tag ?? "",
+    styles
   };
 }
-function voiceMatchesLanguage(voiceName, language) {
-  const voiceLocale = voiceLocalePrefix(voiceName);
-  const languageLocale = languageLocalePrefix(language);
-  if (!voiceLocale || !languageLocale) return void 0;
-  return voiceLocale.language === languageLocale.language && (languageLocale.region === void 0 || voiceLocale.region === languageLocale.region);
+function normalizeVoiceCatalog(options) {
+  const definitions = /* @__PURE__ */ new Map();
+  for (const [name, styles] of Object.entries(EXPRESS_AS_STYLES)) {
+    definitions.set(name.toLowerCase(), definitionFromStyleMap(name, styles));
+  }
+  for (const definition of ADDITIONAL_VOICE_DEFINITIONS) definitions.set(definition.name.toLowerCase(), definition);
+  for (const definition of options.voiceCatalog ?? []) definitions.set(definition.name.toLowerCase(), definition);
+  for (const definition of options.voiceDefinitions ?? []) definitions.set(definition.name.toLowerCase(), definition);
+  for (const definition of options.customVoiceDefinitions ?? [])
+    definitions.set(definition.name.toLowerCase(), definition);
+  for (const [voiceName, styles] of Object.entries(options.customVoiceStyleMap ?? {})) {
+    const key = voiceName.toLowerCase();
+    const current = definitions.get(key);
+    definitions.set(key, {
+      ...current ?? definitionFromStyleMap(voiceName, styles),
+      name: current?.name ?? voiceName,
+      styles: styles.map((style) => style.toLowerCase())
+    });
+  }
+  return definitions;
+}
+function diagnosticSeverity(policy) {
+  if (policy === "ignore") return void 0;
+  return policy === "error" ? "error" : "warning";
 }
-function validateElement(token, source, diagnostics, voiceName, options, voiceStyleMap) {
+function languagePart(language) {
+  try {
+    return new Intl.Locale(language).language.toLowerCase();
+  } catch {
+    return language.split("-")[0]?.toLowerCase() ?? "";
+  }
+}
+function definitionMatchesLanguage(definition, voiceName, language, normalizeLanguage) {
+  const candidateLanguages = definition ? [definition.locale, ...definition.secondaryLocales ?? []].filter(Boolean) : [voiceLocalePrefix(voiceName)?.tag ?? ""];
+  if (candidateLanguages.length === 0 || !language.trim()) return void 0;
+  const normalizedLanguage = normalizeLanguage(language);
+  const normalizedCandidates = candidateLanguages.map(normalizeLanguage);
+  if (normalizedCandidates.includes(normalizedLanguage)) return true;
+  if (!normalizedLanguage || !normalizedCandidates.some(Boolean)) return void 0;
+  return normalizedLanguage === languagePart(normalizedLanguage) ? normalizedCandidates.some((candidate) => languagePart(candidate) === normalizedLanguage) : false;
+}
+function validateElement(token, source, diagnostics, voiceName, options, voiceCatalog) {
   const name = token.name.toLowerCase();
   if (name === "voice" && !attr(token, "name")?.trim())
     addDiagnostic(diagnostics, source, token.start, '<voice> requires a non-empty "name" attribute.');
@@ -1327,17 +1401,19 @@ function validateElement(token, source, diagnostics, voiceName, options, voiceSt
     const role = attr(token, "role");
     if (role && !ALLOWED_ROLES.has(role))
       addDiagnostic(diagnostics, source, token.start, `Unsupported <mstts:express-as role> value "${role}".`);
-    const supportedStyles = voiceName ? voiceStyleMap.get(voiceName.toLowerCase()) : void 0;
-    const severity = diagnosticSeverity(options.unknownVoicePolicy ?? "warn");
-    if (style && supportedStyles && !supportedStyles.includes(style.toLowerCase()) && severity)
+    const definition = voiceName ? voiceCatalog.get(voiceName.toLowerCase()) : void 0;
+    const supportedStyles = definition?.styles;
+    const severity = diagnosticSeverity(options.unsupportedStylePolicy ?? options.unknownVoicePolicy ?? "warn");
+    if (style && definition && !supportedStyles?.some((candidate) => candidate.toLowerCase() === style.toLowerCase()) && severity)
       addDiagnostic(
         diagnostics,
         source,
         token.start,
         `Unknown style "${style}" is not supported by voice "${voiceName}" according to the configured voice style map.`,
-        severity
+        severity,
+        "azure-unsupported-style"
       );
-    if (style && voiceName && !supportedStyles && severity)
+    if (style && voiceName && !definition && severity)
       addDiagnostic(
         diagnostics,
         source,
@@ -1442,32 +1518,36 @@ function validateAzureSsml(ssml, options = {}) {
       "Azure SSML requires at least one <voice> element under <speak>."
     );
   const voiceName = voices[0] ? attr(voices[0], "name") : void 0;
-  const voiceStyleMap = normalizeVoiceStyleMap(options.customVoiceStyleMap);
+  const voiceCatalog = normalizeVoiceCatalog(options);
+  const normalizeLanguage = createLanguageNormalizer(options);
   const policySeverity = diagnosticSeverity(options.unknownVoicePolicy ?? "warn");
   const voicesToValidate = options.validateNestedVoices === false ? voices.slice(0, 1) : voices;
   for (const token of voicesToValidate) {
     const name = attr(token, "name")?.trim();
     const language = attr(token, "xml:lang")?.trim() || (speak ? attr(speak, "xml:lang")?.trim() : void 0);
-    if (name && !voiceStyleMap.has(name.toLowerCase()) && policySeverity)
+    const definition = name ? voiceCatalog.get(name.toLowerCase()) : void 0;
+    if (name && !definition && policySeverity)
       addDiagnostic(
         diagnostics,
         ssml,
         token.start,
-        `Unknown voice "${name}" is not registered in the voice style map.`,
-        policySeverity
+        `Unknown voice "${name}" is not registered in the voice catalog.`,
+        policySeverity,
+        "azure-unknown-voice"
       );
-    if (name && language && voiceMatchesLanguage(name, language) === false)
+    if (name && language && definitionMatchesLanguage(definition, name, language, normalizeLanguage) === false)
       addDiagnostic(
         diagnostics,
         ssml,
         token.start,
         `Voice "${name}" does not match language "${language}"; the voice name prefix indicates a different language or region.`,
-        "warning"
+        "warning",
+        "azure-locale-mismatch"
       );
   }
   for (const token of tokens) {
     const tokenVoiceName = options.validateNestedVoices === false ? voiceName : token.parentVoiceName;
-    validateElement(token, ssml, diagnostics, tokenVoiceName, options, voiceStyleMap);
+    validateElement(token, ssml, diagnostics, tokenVoiceName, options, voiceCatalog);
   }
   return diagnostics;
 }
@@ -1658,10 +1738,12 @@ _options = new WeakMap();
   AzureTtsClient,
   AzureTtsError,
   AzureTtsSdkError,
+  areAzureLanguagesEquivalent,
   buildPartialSsml,
   buildSsml,
   extractSsmlText,
   mapSsmlTextNodes,
+  normalizeAzureLanguage,
   parseSsml,
   synthesizeSpeech,
   validateAzureSsml,