@pie-players/pie-assessment-toolkit 0.3.50 → 0.3.52

package/dist/components/PieAssessmentToolkit.custom-element.js

@@ -18971,22 +18971,81 @@ var isServerBackend = (backend) => backend === "polly" || backend === "google" |
 var withDefault = (value, fallback2) => value === undefined ? fallback2 : value;
 var normalizeTTSLayoutMode = (value, fallback2 = "left-aligned") => typeof value === "string" && VALID_TTS_LAYOUT_MODES.has(value) ? value : fallback2;
 var DEFAULT_TTS_SPEED_OPTIONS = Object.freeze([0.8, 1.25]);
-var normalizeTTSSpeedOptions = (value) => {
+var normalizeSpeedRate = (entry) => {
+  if (typeof entry !== "number" || !Number.isFinite(entry) || entry <= 0) {
+    return;
+  }
+  const rounded = Math.round(entry * 100) / 100;
+  return rounded === 1 ? undefined : rounded;
+};
+var trimOptionalText = (value) => {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : undefined;
+};
+var formatSpeedLabel = (rate) => `${rate}x`;
+var formatSpeedAriaLabel = (label, usedDefaultLabel) => usedDefaultLabel ? `Speed ${label}` : `${label} speed`;
+var normalizeSpeedAriaLabel = (label, ariaLabel, usedDefaultLabel) => {
+  if (!ariaLabel)
+    return formatSpeedAriaLabel(label, usedDefaultLabel);
+  if (ariaLabel.toLowerCase().includes(label.toLowerCase()))
+    return ariaLabel;
+  return `${label} ${ariaLabel}`;
+};
+var normalizeTTSSpeedOptionConfig = (entry) => {
+  if (typeof entry === "number")
+    return normalizeSpeedRate(entry);
+  if (!entry || typeof entry !== "object" || Array.isArray(entry))
+    return;
+  const record = entry;
+  const rate = normalizeSpeedRate(record.rate);
+  if (rate === undefined)
+    return;
+  const label = trimOptionalText(record.label);
+  const ariaLabel = trimOptionalText(record.ariaLabel);
+  return {
+    rate,
+    ...label ? { label } : {},
+    ...ariaLabel ? { ariaLabel } : {}
+  };
+};
+var normalizeTTSSpeedOptionConfigs = (value) => {
   if (!Array.isArray(value))
     return [...DEFAULT_TTS_SPEED_OPTIONS];
   if (value.length === 0)
     return [];
-  const deduped = new Set;
+  const dedupedRates = new Set;
+  const normalized = [];
   for (const entry of value) {
-    if (typeof entry !== "number" || !Number.isFinite(entry) || entry <= 0)
+    const option = normalizeTTSSpeedOptionConfig(entry);
+    if (option === undefined)
       continue;
-    const rounded = Math.round(entry * 100) / 100;
-    if (rounded === 1)
+    const rate = typeof option === "number" ? option : option.rate;
+    if (dedupedRates.has(rate))
       continue;
-    deduped.add(rounded);
+    dedupedRates.add(rate);
+    normalized.push(option);
   }
-  return deduped.size ? Array.from(deduped) : [...DEFAULT_TTS_SPEED_OPTIONS];
+  return normalized.length ? normalized : [...DEFAULT_TTS_SPEED_OPTIONS];
 };
+var normalizeTTSSpeedControlOptions = (value) => normalizeTTSSpeedOptionConfigs(value).map((option) => {
+  if (typeof option === "number") {
+    const label2 = formatSpeedLabel(option);
+    return {
+      rate: option,
+      label: label2,
+      ariaLabel: formatSpeedAriaLabel(label2, true)
+    };
+  }
+  const defaultLabel = formatSpeedLabel(option.rate);
+  const label = option.label || defaultLabel;
+  return {
+    rate: option.rate,
+    label,
+    ariaLabel: normalizeSpeedAriaLabel(label, option.ariaLabel, label === defaultLabel)
+  };
+});
 var applyRuntimeDefaults = (config) => {
   const withLayoutDefaults = {
     ...config,
@@ -19143,7 +19202,7 @@ var ttsToolRegistration = {
         settings.layoutMode = normalizeTTSLayoutMode(settings.layoutMode);
       }
       if (settings && "speedOptions" in settings) {
-        settings.speedOptions = normalizeTTSSpeedOptions(settings.speedOptions);
+        settings.speedOptions = normalizeTTSSpeedOptionConfigs(settings.speedOptions);
       }
       const normalizedConfig = {
         ...config
@@ -19152,7 +19211,7 @@ var ttsToolRegistration = {
         normalizedConfig.layoutMode = normalizeTTSLayoutMode(normalizedConfig.layoutMode);
       }
       if ("speedOptions" in normalizedConfig) {
-        normalizedConfig.speedOptions = normalizeTTSSpeedOptions(normalizedConfig.speedOptions);
+        normalizedConfig.speedOptions = normalizeTTSSpeedOptionConfigs(normalizedConfig.speedOptions);
       }
       if (settings) {
         normalizedConfig.settings = settings;
@@ -19175,7 +19234,7 @@ var ttsToolRegistration = {
     const resolveRuntimeSettings = () => resolveTTSRuntimeSettings(toolbarContext.toolkitCoordinator?.getToolConfig(this.toolId) || undefined);
     const resolveElementSpeedOptions = () => {
       const runtimeSettings = resolveRuntimeSettings();
-      return normalizeTTSSpeedOptions(runtimeSettings.speedOptions);
+      return normalizeTTSSpeedControlOptions(runtimeSettings.speedOptions);
     };
     const resolveLayoutMode = () => resolveTTSLayoutMode(resolveRuntimeSettings());
     const resolveHostLayout = () => resolveTTSHostToolbarLayout(resolveRuntimeSettings());
@@ -21007,27 +21066,27 @@ class HighlightCoordinator {
 
       /* Annotation highlights - persistent */
       ::highlight(annotation-yellow) {
-        background-color: color-mix(in srgb, var(--pie-missing, #ffff00) 35%, transparent);
+        background-color: var(--pie-annotation-yellow-highlight, rgba(253, 233, 149, 0.5));
         color: inherit;
       }
 
       ::highlight(annotation-green) {
-        background-color: color-mix(in srgb, var(--pie-correct, #90ee90) 35%, transparent);
+        background-color: var(--pie-annotation-green-highlight, rgba(166, 225, 197, 0.5));
         color: inherit;
       }
 
       ::highlight(annotation-blue) {
-        background-color: color-mix(in srgb, var(--pie-tertiary, #add8e6) 35%, transparent);
+        background-color: var(--pie-annotation-blue-highlight, rgba(167, 224, 246, 0.5));
         color: inherit;
       }
 
       ::highlight(annotation-pink) {
-        background-color: color-mix(in srgb, var(--pie-secondary-light, #ffb6c1) 35%, transparent);
+        background-color: var(--pie-annotation-pink-highlight, rgba(255, 159, 174, 0.5));
         color: inherit;
       }
 
       ::highlight(annotation-orange) {
-        background-color: color-mix(in srgb, var(--pie-incorrect, #ffa500) 35%, transparent);
+        background-color: var(--pie-annotation-orange-highlight, rgba(255, 165, 0, 0.5));
         color: inherit;
       }
 
@@ -21070,6 +21129,16 @@ class HighlightCoordinator {
     }
     this.highlightTTSElementFallbacks(ranges);
   }
+  highlightTTSSentenceElements(elements) {
+    if (!this.ttsSentenceHighlight)
+      return;
+    this.applyAdaptiveTTSStyle(elements[0] || null);
+    this.clearTTSSentence();
+    for (const element2 of elements) {
+      element2.setAttribute("data-pie-tts-sentence-element", "true");
+      this.ttsSentenceElementHighlights.add(element2);
+    }
+  }
   static SENTENCE_FALLBACK_SELECTOR = "math, mjx-container, svg, img, canvas, [role='img']";
   static WORD_FALLBACK_SELECTOR = "svg, img, canvas, [role='img']";
   highlightTTSElementFallbacks(ranges) {
@@ -23829,6 +23898,7 @@ class TTSService {
   currentProvider = null;
   provider = null;
   highlightCoordinator = null;
+  highlightTargetResolverProvider = null;
   catalogResolver = null;
   state = PlaybackState.IDLE;
   ttsConfig = {};
@@ -23839,6 +23909,7 @@ class TTSService {
   lastError = null;
   speakRunId = 0;
   currentBoundaryOffset = 0;
+  activeWordBoundaryOffset = 0;
   seekSegments = [];
   sentenceHighlightSegments = [];
   currentSeekSegmentIndex = 0;
@@ -23918,9 +23989,137 @@ class TTSService {
   setHighlightCoordinator(coordinator) {
     this.highlightCoordinator = coordinator;
   }
+  setHighlightTargetResolverProvider(provider) {
+    this.highlightTargetResolverProvider = provider;
+    return () => {
+      if (this.highlightTargetResolverProvider === provider) {
+        this.highlightTargetResolverProvider = null;
+      }
+    };
+  }
   setCatalogResolver(resolver) {
     this.catalogResolver = resolver;
   }
+  getHighlightResolverRuntime() {
+    let provided = null;
+    try {
+      provided = this.highlightTargetResolverProvider?.() ?? null;
+    } catch {
+      provided = null;
+    }
+    const providedContext = provided?.context ?? {};
+    const fallbackScope = typeof HTMLElement !== "undefined" && this.currentContentElement instanceof HTMLElement ? this.currentContentElement : null;
+    return {
+      context: {
+        ...providedContext,
+        scopeElement: providedContext.scopeElement ?? fallbackScope
+      },
+      resolver: provided?.resolver ?? null
+    };
+  }
+  getNodeElement(node) {
+    if (!node)
+      return null;
+    return node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+  }
+  isElementWithinScope(element2, scope) {
+    if (!scope)
+      return true;
+    return element2 === scope || scope.contains(element2);
+  }
+  isRangeWithinScope(range, scope) {
+    const startElement = this.getNodeElement(range.startContainer);
+    const endElement = this.getNodeElement(range.endContainer);
+    if (!startElement || !endElement)
+      return false;
+    return this.isElementWithinScope(startElement, scope) && this.isElementWithinScope(endElement, scope);
+  }
+  resolveWordHighlightRange(nativeRange) {
+    const { context, resolver } = this.getHighlightResolverRuntime();
+    const scope = context.scopeElement ?? this.currentContentElement;
+    try {
+      const resolved = resolver?.resolveWordRange?.(nativeRange, context);
+      if (resolved && this.isRangeWithinScope(resolved, scope)) {
+        return { range: resolved, remapped: !sameRange(nativeRange, resolved) };
+      }
+    } catch {}
+    return { range: nativeRange, remapped: false };
+  }
+  resolveSentenceHighlightTargets(nativeRanges) {
+    const { context, resolver } = this.getHighlightResolverRuntime();
+    const scope = context.scopeElement ?? this.currentContentElement;
+    try {
+      const resolved = resolver?.resolveSentenceRanges?.(nativeRanges, context);
+      if (!resolved)
+        return { ranges: nativeRanges, elements: [] };
+      const ranges = [];
+      const elements = [];
+      for (const target of resolved) {
+        if (typeof Range !== "undefined" && target instanceof Range) {
+          if (!this.isRangeWithinScope(target, scope)) {
+            return { ranges: nativeRanges, elements: [] };
+          }
+          ranges.push(target);
+          continue;
+        }
+        if (typeof Element !== "undefined" && target instanceof Element) {
+          if (!this.isElementWithinScope(target, scope)) {
+            return { ranges: nativeRanges, elements: [] };
+          }
+          elements.push(target);
+          continue;
+        }
+        return { ranges: nativeRanges, elements: [] };
+      }
+      return { ranges, elements };
+    } catch {
+      return { ranges: nativeRanges, elements: [] };
+    }
+  }
+  createTextRange(node, startOffset, endOffset) {
+    if (typeof document === "undefined")
+      return null;
+    if (typeof document.createRange !== "function")
+      return null;
+    try {
+      const range = document.createRange();
+      range.setStart(node, startOffset);
+      range.setEnd(node, endOffset);
+      if (range.startContainer !== node || range.endContainer !== node) {
+        return null;
+      }
+      return range;
+    } catch {
+      return null;
+    }
+  }
+  paintTTSWordRange(range) {
+    if (!this.highlightCoordinator)
+      return;
+    try {
+      if (range.startContainer === range.endContainer && range.startContainer.nodeType === Node.TEXT_NODE) {
+        this.highlightCoordinator.highlightTTSWord(range.startContainer, range.startOffset, range.endOffset);
+        return;
+      }
+    } catch {}
+    this.highlightCoordinator.highlightRange(range, HighlightType.TTS_WORD, HighlightColor.YELLOW);
+  }
+  paintTTSSentenceRanges(nativeRanges) {
+    if (!this.highlightCoordinator)
+      return;
+    const { ranges, elements } = this.resolveSentenceHighlightTargets(nativeRanges);
+    if (elements.length > 0 && ranges.length === 0 && this.highlightCoordinator.highlightTTSSentenceElements) {
+      this.highlightCoordinator.highlightTTSSentenceElements(elements);
+      return;
+    }
+    const paintedRanges = [...ranges];
+    for (const element2 of elements) {
+      const elementRange = document.createRange();
+      elementRange.selectNodeContents(element2);
+      paintedRanges.push(elementRange);
+    }
+    this.highlightCoordinator.highlightTTSSentence(paintedRanges);
+  }
   getCapabilities() {
     return this.currentProvider?.getCapabilities() || null;
   }
@@ -24232,11 +24431,11 @@ class TTSService {
       this.currentBoundaryOffset = 0;
       const originalOnWordBoundary = this.provider.onWordBoundary;
       this.provider.onWordBoundary = (word, position, length) => {
+        originalOnWordBoundary?.(word, position, length);
         if (Number.isFinite(position)) {
           this.currentBoundaryOffset = position;
           this.currentSeekSegmentIndex = this.getCurrentSeekSegmentIndex();
         }
-        originalOnWordBoundary?.(word, position, length);
       };
       try {
         await providerWithPlan.speakSegments(segments);
@@ -24247,6 +24446,10 @@ class TTSService {
       }
       return;
     }
+    this.configureWordBoundaryHighlighting({
+      highlightMode: options?.highlightMode || "word",
+      wordBoundaryOffset: this.activeWordBoundaryOffset
+    });
     for (const segment of segments) {
       if (runId !== this.speakRunId)
         return;
@@ -24278,7 +24481,7 @@ class TTSService {
     const range = document.createRange();
     range.setStart(start.node, start.offset);
     range.setEnd(end.node, end.offset + 1);
-    this.highlightCoordinator.highlightTTSSentence([range]);
+    this.paintTTSSentenceRanges([range]);
     this.activeSentenceStartOffset = startOffset;
   }
   getSegmentIndexForOffset(segments, offset) {
@@ -24366,6 +24569,7 @@ class TTSService {
       this.initializeSpeakTracking(highlightText, options);
       const highlightMode = options?.highlightModeOverride || (speechMatchesVisibleText ? this.resolveHighlightMode() : "sentence");
       this.activeHighlightMode = highlightMode;
+      this.activeWordBoundaryOffset = options?.wordBoundaryOffset || 0;
       const hasExplicitBreaks = this.hasExplicitBreakSemantics(contentToSpeak);
       const shouldUsePlan = !!this.currentContentElement && !usedCatalogSpoken && !hasExplicitBreaks && speechMatchesVisibleText;
       this.seekSegments = hasExplicitBreaks || !speechMatchesVisibleText ? [] : shouldUsePlan && this.currentContentElement ? this.createSpeechPlan(this.currentContentElement, normalizedText) : this.createSeekSegmentsFromText(highlightText);
@@ -24743,7 +24947,7 @@ class TTSService {
       try {
         const range = document.createRange();
         range.selectNodeContents(this.currentContentElement);
-        this.highlightCoordinator.highlightTTSSentence([range]);
+        this.paintTTSSentenceRanges([range]);
       } catch {}
     }
   }
@@ -24759,7 +24963,12 @@ class TTSService {
       if (highlightRange && this.highlightCoordinator) {
         const highlightText = highlightRange.node.textContent?.substring(highlightRange.start, highlightRange.end) || "";
         this.debugLog(`[TTSService] Highlighting "${highlightText}" (word: "${word}") at position ${globalIndex}`);
-        this.highlightCoordinator.highlightTTSWord(highlightRange.node, highlightRange.start, highlightRange.end);
+        const nativeRange = this.createTextRange(highlightRange.node, highlightRange.start, highlightRange.end);
+        if (nativeRange) {
+          this.paintTTSWordRange(this.resolveWordHighlightRange(nativeRange).range);
+        } else {
+          this.highlightCoordinator.highlightTTSWord(highlightRange.node, highlightRange.start, highlightRange.end);
+        }
       } else {
         console.warn(`[TTSService] Could not find highlight range for position ${globalIndex}, length ${wordLength}`);
       }
@@ -24778,7 +24987,7 @@ class TTSService {
       this.lastRenderedRegionTarget = null;
       if (chunk.regionRange) {
         this.highlightCoordinator.clearHighlights?.(HighlightType.TTS_WORD);
-        this.highlightCoordinator.highlightTTSSentence([chunk.regionRange]);
+        this.paintTTSSentenceRanges([chunk.regionRange]);
         return;
       }
       if (!element2)
@@ -24786,23 +24995,19 @@ class TTSService {
       const range = document.createRange();
       range.selectNodeContents(element2);
       this.highlightCoordinator.clearHighlights?.(HighlightType.TTS_WORD);
-      this.highlightCoordinator.highlightTTSSentence([range]);
+      this.paintTTSSentenceRanges([range]);
     } catch {}
   }
   highlightCatalogActiveRange(range) {
     if (!this.highlightCoordinator)
       return;
-    if (range.startContainer === range.endContainer && range.startContainer.nodeType === Node.TEXT_NODE) {
-      this.highlightCoordinator.highlightTTSWord(range.startContainer, range.startOffset, range.endOffset);
-      return;
-    }
-    this.highlightCoordinator.highlightRange(range, HighlightType.TTS_WORD, HighlightColor.YELLOW);
+    this.paintTTSWordRange(this.resolveWordHighlightRange(range).range);
   }
   highlightRenderableRegionTarget(target) {
     if (!this.highlightCoordinator || !target || typeof document === "undefined") {
       return;
     }
-    if (sameRenderableHighlightTarget(this.lastRenderedRegionTarget, target)) {
+    if (!this.highlightTargetResolverProvider && sameRenderableHighlightTarget(this.lastRenderedRegionTarget, target)) {
       return;
     }
     try {
@@ -24810,14 +25015,14 @@ class TTSService {
       if (target.type === "element") {
         range.selectNodeContents(target.element);
       } else if (target.type === "range") {
-        this.highlightCoordinator.highlightTTSSentence([target.range]);
+        this.paintTTSSentenceRanges([target.range]);
         this.lastRenderedRegionTarget = target;
         return;
       } else {
         range.setStart(target.node, target.startOffset);
         range.setEnd(target.node, target.endOffset);
       }
-      this.highlightCoordinator.highlightTTSSentence([range]);
+      this.paintTTSSentenceRanges([range]);
       this.lastRenderedRegionTarget = target;
     } catch {}
   }
@@ -24830,13 +25035,25 @@ class TTSService {
       return;
     }
     if (target.type === "text-range") {
-      this.highlightCoordinator.highlightTTSWord(target.node, target.startOffset, target.endOffset);
+      const nativeRange = this.createTextRange(target.node, target.startOffset, target.endOffset);
+      if (nativeRange) {
+        this.paintTTSWordRange(this.resolveWordHighlightRange(nativeRange).range);
+      } else {
+        this.highlightCoordinator.highlightTTSWord(target.node, target.startOffset, target.endOffset);
+      }
       return;
     }
     if (target.type === "range") {
       this.highlightCatalogActiveRange(target.range);
       return;
     }
+    const elementNativeRange = document.createRange();
+    elementNativeRange.selectNodeContents(target.element);
+    const resolvedElementRange = this.resolveWordHighlightRange(elementNativeRange);
+    if (resolvedElementRange.remapped) {
+      this.paintTTSWordRange(resolvedElementRange.range);
+      return;
+    }
     const onlyChild = target.element.childNodes.length === 1 ? target.element.firstChild : null;
     if (target.quality === "semantic-token" && onlyChild?.nodeType === Node.TEXT_NODE) {
       this.highlightCoordinator.highlightTTSWord(onlyChild, 0, onlyChild.textContent?.length || 0);
@@ -24951,6 +25168,7 @@ class TTSService {
     this.currentContentElement = null;
     this.normalizedToDOM.clear();
     this.currentBoundaryOffset = 0;
+    this.activeWordBoundaryOffset = 0;
     this.seekSegments = [];
     this.sentenceHighlightSegments = [];
     this.currentSeekSegmentIndex = 0;
@@ -25005,31 +25223,27 @@ class TTSService {
       this.setState(PlaybackState.PLAYING);
     }
   }
-  async seekBy(units) {
-    if (!this.provider || !this.currentText)
-      return;
-    if (this.state !== PlaybackState.PLAYING && this.state !== PlaybackState.PAUSED) {
-      return;
-    }
-    if (this.hasExplicitBreakSemantics(this.currentText))
-      return;
-    if (this.seekSegments.length === 0)
-      return;
-    const delta = Number.isFinite(units) ? Math.trunc(units) : 0;
-    if (delta === 0)
-      return;
-    const currentIndex = this.getCurrentSeekSegmentIndex();
-    const targetIndex = Math.max(0, Math.min(this.seekSegments.length - 1, currentIndex + delta));
-    if (targetIndex === currentIndex)
+  normalizePlaybackRate(rate) {
+    if (!Number.isFinite(rate))
+      return 1;
+    return Math.max(0.25, Math.min(4, rate));
+  }
+  async restartFromSeekIndex(targetIndex) {
+    if (!this.provider || this.seekSegments.length === 0)
       return;
+    const safeTargetIndex = Math.max(0, Math.min(this.seekSegments.length - 1, targetIndex));
     this.speakRunId += 1;
     this.provider.onWordBoundary = undefined;
     this.provider.stop();
-    this.currentSeekSegmentIndex = targetIndex;
+    this.currentSeekSegmentIndex = safeTargetIndex;
     const runId = ++this.speakRunId;
-    const restartSegments = this.seekSegments.slice(targetIndex);
+    const restartSegments = this.seekSegments.slice(safeTargetIndex);
     this.setState(PlaybackState.PLAYING);
     try {
+      this.configureWordBoundaryHighlighting({
+        highlightMode: this.activeHighlightMode,
+        wordBoundaryOffset: this.activeWordBoundaryOffset
+      });
       await this.speakWithPlan(restartSegments, runId, {
         highlightMode: this.activeHighlightMode
       });
@@ -25037,15 +25251,44 @@ class TTSService {
         return;
       this.setState(PlaybackState.IDLE);
       this.clearHighlightsAndTracking();
+      this.highlightTargetResolverProvider = null;
     } catch (error) {
       if (runId !== this.speakRunId)
         return;
       this.lastError = error instanceof Error ? error.message : String(error);
       this.setState(PlaybackState.ERROR);
       this.clearHighlightsAndTracking();
+      this.highlightTargetResolverProvider = null;
       throw error;
     }
   }
+  async setPlaybackRate(rate) {
+    const nextRate = this.normalizePlaybackRate(rate);
+    await this.updateSettings({ rate: nextRate });
+    if (this.state !== PlaybackState.PLAYING || !this.currentText || this.seekSegments.length === 0 || this.hasExplicitBreakSemantics(this.currentText)) {
+      return;
+    }
+    await this.restartFromSeekIndex(this.getCurrentSeekSegmentIndex());
+  }
+  async seekBy(units) {
+    if (!this.provider || !this.currentText)
+      return;
+    if (this.state !== PlaybackState.PLAYING && this.state !== PlaybackState.PAUSED) {
+      return;
+    }
+    if (this.hasExplicitBreakSemantics(this.currentText))
+      return;
+    if (this.seekSegments.length === 0)
+      return;
+    const delta = Number.isFinite(units) ? Math.trunc(units) : 0;
+    if (delta === 0)
+      return;
+    const currentIndex = this.getCurrentSeekSegmentIndex();
+    const targetIndex = Math.max(0, Math.min(this.seekSegments.length - 1, currentIndex + delta));
+    if (targetIndex === currentIndex)
+      return;
+    await this.restartFromSeekIndex(targetIndex);
+  }
   async seekForward(units = 1) {
     const step = Number.isFinite(units) ? Math.max(1, Math.trunc(units)) : 1;
     await this.seekBy(step);
@@ -25060,6 +25303,7 @@ class TTSService {
     this.speakRunId += 1;
     this.provider.onWordBoundary = undefined;
     this.provider.stop();
+    this.highlightTargetResolverProvider = null;
     this.setState(PlaybackState.IDLE);
     this.currentText = null;
     if (this.highlightCoordinator) {
@@ -25069,6 +25313,7 @@ class TTSService {
     this.currentContentElement = null;
     this.normalizedToDOM.clear();
     this.currentBoundaryOffset = 0;
+    this.activeWordBoundaryOffset = 0;
     this.seekSegments = [];
     this.sentenceHighlightSegments = [];
     this.currentSeekSegmentIndex = 0;