ssml-builder-js 2.13.0 → 2.15.0

package/dist/{chunk-CZ2F3TET.mjs → chunk-WXFLUCLR.mjs}

@@ -925,6 +925,130 @@ function buildPartialSsml(textOrOptions, context) {
   }
   return serializePartialSsml(textOrOptions.text, textOrOptions);
 }
+function decodeXmlText(value) {
+  return value.replace(/&(?:amp|apos|gt|lt|quot);|&#(?:x[\da-f]+|\d+);/gi, (entity) => {
+    if (entity === "&") return "&";
+    if (entity === "'") return "'";
+    if (entity === ">") return ">";
+    if (entity === "&lt;") return "<";
+    if (entity === "&quot;") return '"';
+    const hexadecimal = entity.toLowerCase().startsWith("&#x");
+    const digits = entity.slice(hexadecimal ? 3 : 2, -1);
+    return String.fromCodePoint(Number.parseInt(digits, hexadecimal ? 16 : 10));
+  });
+}
+function decodeXmlAttribute(value) {
+  return decodeXmlText(value);
+}
+function findTagEnd(source, start) {
+  let quote = "";
+  for (let index = start; index < source.length; index += 1) {
+    const character = source[index];
+    if (quote) {
+      if (character === quote) quote = "";
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === ">") {
+      return index;
+    }
+  }
+  return source.length - 1;
+}
+function readTagName(tag) {
+  const match = /^<\s*([A-Za-z_][A-Za-z0-9_.:-]*)/.exec(tag);
+  return match?.[1];
+}
+function readTagAttributes(tag, name) {
+  const attributes = {};
+  const nameStart = tag.indexOf(name);
+  const attributeSource = tag.slice(nameStart + name.length, tag.length - 1).replace(/\/\s*$/, "");
+  const attributePattern = /([A-Za-z_][A-Za-z0-9_.:-]*)\s*=\s*(["'])([\s\S]*?)\2/g;
+  for (const match of attributeSource.matchAll(attributePattern)) {
+    attributes[match[1].toLowerCase()] = decodeXmlAttribute(match[3]);
+  }
+  return attributes;
+}
+function collectSourceMap(source) {
+  const segments = [];
+  const markers = [];
+  const elements = [];
+  let textOffset = 0;
+  let index = 0;
+  const textParts = [];
+  const addText = (value) => {
+    if (!value) return;
+    const parent = elements[elements.length - 1];
+    if (parent) parent.nextChildIndex += 1;
+    const sourceNodePath = parent?.path ?? ["speak"];
+    const start = textOffset;
+    textOffset += value.length;
+    textParts.push(value);
+    segments.push({ text: value, range: { start, end: textOffset }, sourceNodePath: [...sourceNodePath] });
+  };
+  while (index < source.length) {
+    if (source[index] !== "<") {
+      const end2 = source.indexOf("<", index);
+      const textEnd = end2 === -1 ? source.length : end2;
+      addText(decodeXmlText(source.slice(index, textEnd)));
+      index = textEnd;
+      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 contentStart = index + 9;
+      const end2 = source.indexOf("]]>", contentStart);
+      const contentEnd = end2 === -1 ? source.length : end2;
+      addText(source.slice(contentStart, contentEnd));
+      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;
+    }
+    const end = findTagEnd(source, index + 1);
+    const rawTag = source.slice(index, end + 1);
+    if (rawTag.startsWith("</")) {
+      elements.pop();
+      index = end + 1;
+      continue;
+    }
+    const name = readTagName(rawTag);
+    if (!name) {
+      index = end + 1;
+      continue;
+    }
+    const parent = elements[elements.length - 1];
+    const childIndex = parent?.nextChildIndex ?? 0;
+    if (parent) parent.nextChildIndex += 1;
+    const path = parent ? [...parent.path, `${name}[${childIndex}]`] : [name];
+    const attributes = readTagAttributes(rawTag, name);
+    const normalizedName = name.toLowerCase();
+    if (normalizedName === "mark" || normalizedName === "bookmark") {
+      const markerName = attributes[normalizedName === "mark" ? "name" : "mark"];
+      if (markerName) {
+        markers.push({
+          kind: normalizedName,
+          name: markerName,
+          originalTextRange: { start: textOffset, end: textOffset },
+          sourceNodePath: [...path]
+        });
+      }
+    }
+    if (!/\/\s*>$/.test(rawTag)) elements.push({ name, path, nextChildIndex: 0 });
+    index = end + 1;
+  }
+  return { text: textParts.join(""), segments, markers };
+}
+function getSsmlSourceMap(ssml) {
+  parseSsml(ssml);
+  return collectSourceMap(ssml);
+}
 var PARSER_POSITION_SUFFIX = / at position (\d+)$/;
 function validateSsml(xmlString) {
   try {
@@ -1059,6 +1183,86 @@ var AZURE_VOICE_DEFINITIONS = [
   },
   { name: "zh-TW-HsiaoChenNeural", locale: "zh-TW" }
 ];
+function createAzureUrlValidatorRunner(validator, options = {}) {
+  if (typeof validator !== "function") throw new TypeError("A URL validator function is required.");
+  const concurrency = options.concurrency === void 0 ? Infinity : Number.isFinite(options.concurrency) ? Math.max(1, Math.floor(options.concurrency)) : Infinity;
+  const cache = options.cache ?? /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  const waiters = [];
+  let active = 0;
+  const configuredSignal = options.signal ?? new AbortController().signal;
+  const acquire = async (signal) => {
+    if (signal.aborted) throw new Error("URL validation was aborted.");
+    if (active < concurrency) {
+      active += 1;
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      let waiter;
+      const abortHandler = () => {
+        const index = waiters.indexOf(waiter);
+        if (index >= 0) waiters.splice(index, 1);
+        signal.removeEventListener("abort", abortHandler);
+        reject(new Error("URL validation was aborted."));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      waiter = () => {
+        signal.removeEventListener("abort", abortHandler);
+        resolve();
+      };
+      waiters.push(waiter);
+    });
+    active += 1;
+  };
+  const release = () => {
+    active -= 1;
+    waiters.shift()?.();
+  };
+  const check = async (url, context, signal = configuredSignal) => {
+    if (signal.aborted) throw new Error("URL validation was aborted.");
+    const key = `${context.tag}:${context.attribute}:${url}`;
+    const cached = cache.get(key);
+    if (cached !== void 0) return cached;
+    const existing = inFlight.get(key);
+    if (existing) return existing;
+    const promise = (async () => {
+      await acquire(signal);
+      try {
+        if (signal.aborted) throw new Error("URL validation was aborted.");
+        const validation = Promise.resolve(validator(url, context, signal));
+        let timer;
+        let abortHandler;
+        const cancellation = new Promise((_resolve, reject) => {
+          abortHandler = () => reject(new Error("URL validation was aborted."));
+          signal.addEventListener("abort", abortHandler, { once: true });
+          if (options.timeoutMs !== void 0 && options.timeoutMs > 0) {
+            timer = setTimeout(
+              () => reject(new Error(`URL validation timed out after ${options.timeoutMs} ms.`)),
+              options.timeoutMs
+            );
+          }
+        });
+        try {
+          const result = await (timer || abortHandler ? Promise.race([validation, cancellation]) : validation);
+          cache.set(key, result);
+          return result;
+        } finally {
+          if (timer) clearTimeout(timer);
+          if (abortHandler) signal.removeEventListener("abort", abortHandler);
+        }
+      } finally {
+        release();
+      }
+    })();
+    inFlight.set(key, promise);
+    try {
+      return await promise;
+    } finally {
+      inFlight.delete(key);
+    }
+  };
+  return (url, context, signal) => check(url, context, signal ?? configuredSignal);
+}
 var ALLOWED_BREAK_STRENGTHS = /* @__PURE__ */ new Set(["none", "x-weak", "weak", "medium", "strong", "x-strong"]);
 var ALLOWED_SAY_AS = /* @__PURE__ */ new Set([
   "characters",
@@ -1343,23 +1547,23 @@ function validateVoiceFeatureMatrix(token, source, diagnostics, voiceName, defin
     );
   }
 }
-function validateAudioSource(token, source, diagnostics, options, elementName2) {
+function validateAudioSource(token, source, diagnostics, options, elementName3) {
   const src = attr(token, "src");
   if (!src) {
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2}> requires a "src" attribute.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3}> requires a "src" attribute.`);
     return;
   }
   let parsed;
   try {
     parsed = new URL(src);
   } catch {
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must be an absolute HTTP(S) URL.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} 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.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} 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.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} src> must use HTTPS.`);
   const isAllowedOrigin = options.allowedAudioOrigins?.some((allowedOrigin) => {
     try {
       const configured = new URL(allowedOrigin);
@@ -1371,13 +1575,13 @@ function validateAudioSource(token, source, diagnostics, options, elementName2)
     }
   }) ?? false;
   if (options.allowedAudioOrigins && !isAllowedOrigin)
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> origin "${parsed.origin}" is not allowed.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} src> origin "${parsed.origin}" is not allowed.`);
   else if (!isAllowedOrigin && !options.allowExternalAudio)
     addDiagnostic(
       diagnostics,
       source,
       token.start,
-      `<${elementName2} src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`
+      `<${elementName3} src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`
     );
 }
 function validateElement(token, source, diagnostics, voiceName, options, voiceCatalog) {
@@ -1695,6 +1899,15 @@ function validateAzureSsml(ssml, options = {}) {
   const diagnostics = validateAzureSsmlStatic(ssml, options);
   const validator = options.urlValidator ?? options.customUrlValidator;
   if (!validator || typeof ssml !== "string") return diagnostics;
+  const runnerOptions = options.urlValidation ?? {};
+  const boundedValidator = createAzureUrlValidatorRunner(validator, {
+    ...runnerOptions,
+    ...options.urlValidatorConcurrency !== void 0 ? { concurrency: options.urlValidatorConcurrency } : {},
+    ...options.urlValidatorTimeoutMs !== void 0 ? { timeoutMs: options.urlValidatorTimeoutMs } : {},
+    ...options.urlValidatorSignal ? { signal: options.urlValidatorSignal } : {},
+    ...options.urlValidatorCache ? { cache: options.urlValidatorCache } : {}
+  });
+  const validationSignal = options.urlValidatorSignal ?? options.urlValidation?.signal ?? new AbortController().signal;
   let tokens;
   try {
     tokens = tokenizeElements(ssml);
@@ -1704,7 +1917,11 @@ function validateAzureSsml(ssml, options = {}) {
   const checks = tokens.flatMap(
     (token) => urlAttributes(token).map(async ({ attribute, value }) => {
       try {
-        const result = await validator(value, { tag: token.name, attribute });
+        const result = await boundedValidator(
+          value,
+          { tag: token.name, attribute, ...options.sourceNodePath ? { sourceNodePath: options.sourceNodePath } : {} },
+          validationSignal
+        );
         const valid = typeof result === "boolean" ? result : result.valid;
         if (!valid) {
           const reason = typeof result === "boolean" ? void 0 : result.reason;
@@ -1739,7 +1956,8 @@ export {
   buildSsml,
   parseSsml,
   buildPartialSsml,
+  getSsmlSourceMap,
   validateSsml,
   validateAzureSsml
 };
-//# sourceMappingURL=chunk-CZ2F3TET.mjs.map
+//# sourceMappingURL=chunk-WXFLUCLR.mjs.map