@therealtinhtute/baroiplayer 1.0.7 → 1.1.0

package/src/features/subtitles/subtitle-manager.ts

@@ -1,441 +1,435 @@
-import { SubtitleParser, type SubtitleCue, type ParsedSubtitles } from './subtitle-parser'
+import { type ParsedSubtitles, type SubtitleCue, SubtitleParser } from "./subtitle-parser"
 
 export interface SubtitleTrack {
-  id: string
-  url: string
-  label: string
-  language: string
-  isDefault?: boolean
-  format?: 'vtt' | 'srt'
-  parsedSubtitles?: ParsedSubtitles
-  loadingState?: 'idle' | 'loading' | 'loaded' | 'error'
-  error?: string
+	id: string
+	url: string
+	label: string
+	language: string
+	isDefault?: boolean
+	format?: "vtt" | "srt"
+	parsedSubtitles?: ParsedSubtitles
+	loadingState?: "idle" | "loading" | "loaded" | "error"
+	error?: string
 }
 
 export interface SubtitleStyle {
-  fontSize?: number
-  fontFamily?: string
-  color?: string
-  backgroundColor?: string
-  borderColor?: string
-  borderWidth?: number
-  opacity?: number
-  position?: 'top' | 'center' | 'bottom'
-  alignment?: 'left' | 'center' | 'right'
-  shadow?: boolean
+	fontSize?: number
+	fontFamily?: string
+	color?: string
+	backgroundColor?: string
+	borderColor?: string
+	borderWidth?: number
+	opacity?: number
+	position?: "top" | "center" | "bottom"
+	alignment?: "left" | "center" | "right"
+	shadow?: boolean
 }
 
 export interface SubtitleManagerOptions {
-  tracks?: SubtitleTrack[]
-  defaultStyle?: SubtitleStyle
-  enabledByDefault?: boolean
-  preloadTracks?: boolean
+	tracks?: SubtitleTrack[]
+	defaultStyle?: SubtitleStyle
+	enabledByDefault?: boolean
+	preloadTracks?: boolean
 }
 
 export class SubtitleManager {
-  private tracks: Map<string, SubtitleTrack> = new Map()
-  private activeTrackId: string | null = null
-  private currentCues: SubtitleCue[] = []
-  private isEnabled: boolean = false
-  private style: SubtitleStyle
-  private eventListeners: Map<string, Set<Function>> = new Map()
-
-  constructor(options: SubtitleManagerOptions = {}) {
-    this.style = {
-      fontSize: 16,
-      fontFamily: 'Arial, sans-serif',
-      color: '#ffffff',
-      backgroundColor: 'rgba(0, 0, 0, 0.7)',
-      borderColor: '#000000',
-      borderWidth: 1,
-      opacity: 1,
-      position: 'bottom',
-      alignment: 'center',
-      shadow: true,
-      ...options.defaultStyle
-    }
-    
-    this.isEnabled = options.enabledByDefault ?? false
-    
-    if (options.tracks) {
-      this.addTracks(options.tracks)
-      
-      if (options.preloadTracks) {
-        this.preloadAllTracks()
-      }
-    }
-  }
-
-  /**
-   * Add multiple subtitle tracks
-   */
-  addTracks(tracks: SubtitleTrack[]): void {
-    tracks.forEach(track => this.addTrack(track))
-  }
-
-  /**
-   * Add a single subtitle track
-   */
-  addTrack(track: SubtitleTrack): void {
-    const trackWithDefaults: SubtitleTrack = {
-      ...track,
-      loadingState: 'idle',
-      format: track.format || this.detectFormat(track.url)
-    }
-    
-    this.tracks.set(track.id, trackWithDefaults)
-    this.emit('trackAdded', trackWithDefaults)
-    
-    // Set as active if it's the default track and no track is currently active
-    if (track.isDefault && !this.activeTrackId) {
-      this.setActiveTrack(track.id)
-    }
-  }
-
-  /**
-   * Remove a subtitle track
-   */
-  removeTrack(trackId: string): void {
-    const track = this.tracks.get(trackId)
-    if (track) {
-      this.tracks.delete(trackId)
-      
-      if (this.activeTrackId === trackId) {
-        this.activeTrackId = null
-        this.currentCues = []
-        this.emit('cuesChanged', [])
-      }
-      
-      this.emit('trackRemoved', track)
-    }
-  }
-
-  /**
-   * Get all available tracks
-   */
-  getTracks(): SubtitleTrack[] {
-    return Array.from(this.tracks.values())
-  }
-
-  /**
-   * Get a specific track by ID
-   */
-  getTrack(trackId: string): SubtitleTrack | undefined {
-    return this.tracks.get(trackId)
-  }
-
-  /**
-   * Set the active subtitle track
-   */
-  async setActiveTrack(trackId: string | null): Promise<void> {
-    this.activeTrackId = trackId
-    this.currentCues = []
-    
-    if (trackId) {
-      const track = this.tracks.get(trackId)
-      if (track && !track.parsedSubtitles && track.loadingState === 'idle') {
-        await this.loadTrack(trackId)
-      }
-    }
-    
-    this.emit('activeTrackChanged', trackId)
-    this.emit('cuesChanged', [])
-  }
-
-  /**
-   * Get the currently active track
-   */
-  getActiveTrack(): SubtitleTrack | null {
-    return this.activeTrackId ? this.tracks.get(this.activeTrackId) || null : null
-  }
-
-  /**
-   * Enable or disable subtitles
-   */
-  setEnabled(enabled: boolean): void {
-    this.isEnabled = enabled
-    
-    if (!enabled) {
-      this.currentCues = []
-      this.emit('cuesChanged', [])
-    }
-    
-    this.emit('enabledChanged', enabled)
-  }
-
-  /**
-   * Check if subtitles are enabled
-   */
-  isSubtitlesEnabled(): boolean {
-    return this.isEnabled
-  }
-
-  /**
-   * Update subtitle styling
-   */
-  updateStyle(newStyle: Partial<SubtitleStyle>): void {
-    this.style = { ...this.style, ...newStyle }
-    this.emit('styleChanged', this.style)
-  }
-
-  /**
-   * Get current subtitle style
-   */
-  getStyle(): SubtitleStyle {
-    return { ...this.style }
-  }
-
-  /**
-   * Update current time and get active cues
-   */
-  updateTime(currentTime: number): SubtitleCue[] {
-    if (!this.isEnabled || !this.activeTrackId) {
-      if (this.currentCues.length > 0) {
-        this.currentCues = []
-        this.emit('cuesChanged', [])
-      }
-      return []
-    }
-
-    const activeTrack = this.tracks.get(this.activeTrackId)
-    if (!activeTrack?.parsedSubtitles) {
-      if (this.currentCues.length > 0) {
-        this.currentCues = []
-        this.emit('cuesChanged', [])
-      }
-      return []
-    }
-
-    const activeCues = SubtitleParser.getActiveCues(
-      activeTrack.parsedSubtitles.cues,
-      currentTime
-    )
-
-    // Check if cues have changed
-    const cuesChanged = 
-      activeCues.length !== this.currentCues.length ||
-      activeCues.some((cue, index) => 
-        !this.currentCues[index] || cue.id !== this.currentCues[index].id
-      )
-
-    if (cuesChanged) {
-      this.currentCues = activeCues
-      this.emit('cuesChanged', activeCues)
-    }
-
-    return activeCues
-  }
-
-  /**
-   * Get current active cues
-   */
-  getCurrentCues(): SubtitleCue[] {
-    return [...this.currentCues]
-  }
-
-  /**
-   * Load a subtitle track
-   */
-  async loadTrack(trackId: string): Promise<void> {
-    const track = this.tracks.get(trackId)
-    if (!track || track.loadingState === 'loading' || track.loadingState === 'loaded') {
-      return
-    }
-
-    // Update loading state
-    track.loadingState = 'loading'
-    this.emit('trackLoadingStateChanged', { trackId, state: 'loading' })
-
-    try {
-      const response = await fetch(track.url)
-      if (!response.ok) {
-        throw new Error(`Failed to fetch subtitles: ${response.status} ${response.statusText}`)
-      }
-
-      const content = await response.text()
-      const format = track.format || SubtitleParser.detectFormat(content)
-      
-      if (format === 'unknown') {
-        throw new Error('Unsupported subtitle format')
-      }
-
-      const parsedSubtitles = SubtitleParser.parse(content, format)
-      track.parsedSubtitles = parsedSubtitles
-      track.loadingState = 'loaded'
-      track.format = format
-      
-      this.emit('trackLoadingStateChanged', { trackId, state: 'loaded' })
-      this.emit('trackLoaded', track)
-
-    } catch (error) {
-      track.loadingState = 'error'
-      track.error = error instanceof Error ? error.message : 'Unknown error'
-      
-      this.emit('trackLoadingStateChanged', { trackId, state: 'error', error: track.error })
-      this.emit('trackError', { trackId, error: track.error })
-    }
-  }
-
-  /**
-   * Preload all available tracks
-   */
-  async preloadAllTracks(): Promise<void> {
-    const loadPromises = Array.from(this.tracks.keys()).map(trackId => 
-      this.loadTrack(trackId)
-    )
-    
-    await Promise.allSettled(loadPromises)
-  }
-
-  /**
-   * Search for cues containing text
-   */
-  searchCues(query: string, trackId?: string): Array<{ trackId: string, cue: SubtitleCue }> {
-    const results: Array<{ trackId: string, cue: SubtitleCue }> = []
-    const searchTracks = trackId ? [trackId] : Array.from(this.tracks.keys())
-    
-    for (const id of searchTracks) {
-      const track = this.tracks.get(id)
-      if (!track?.parsedSubtitles) continue
-      
-      for (const cue of track.parsedSubtitles.cues) {
-        const cleanText = SubtitleParser.cleanText(cue.text).toLowerCase()
-        if (cleanText.includes(query.toLowerCase())) {
-          results.push({ trackId: id, cue })
-        }
-      }
-    }
-    
-    return results
-  }
-
-  /**
-   * Export subtitles in a specific format
-   */
-  exportSubtitles(trackId: string, format: 'vtt' | 'srt'): string | null {
-    const track = this.tracks.get(trackId)
-    if (!track?.parsedSubtitles) return null
-    
-    const { cues, metadata } = track.parsedSubtitles
-    
-    if (format === 'vtt') {
-      return this.exportAsVTT(cues, metadata)
-    } else {
-      return this.exportAsSRT(cues)
-    }
-  }
-
-  /**
-   * Event system methods
-   */
-  on(event: string, callback: Function): () => void {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, new Set())
-    }
-    
-    this.eventListeners.get(event)!.add(callback)
-    
-    return () => {
-      const listeners = this.eventListeners.get(event)
-      if (listeners) {
-        listeners.delete(callback)
-      }
-    }
-  }
-
-  private emit(event: string, data?: any): void {
-    const listeners = this.eventListeners.get(event)
-    if (listeners) {
-      listeners.forEach(callback => callback(data))
-    }
-  }
-
-  /**
-   * Detect subtitle format from URL extension
-   */
-  private detectFormat(url: string): 'vtt' | 'srt' {
-    const extension = url.split('.').pop()?.toLowerCase()
-    return extension === 'srt' ? 'srt' : 'vtt'
-  }
-
-  /**
-   * Export cues as WebVTT format
-   */
-  private exportAsVTT(cues: SubtitleCue[], metadata?: any): string {
-    let output = 'WEBVTT\n\n'
-    
-    if (metadata) {
-      Object.entries(metadata).forEach(([key, value]) => {
-        output += `${key}: ${value}\n`
-      })
-      output += '\n'
-    }
-    
-    cues.forEach((cue, index) => {
-      if (cue.id) {
-        output += `${cue.id}\n`
-      }
-      
-      const startTime = this.formatTime(cue.startTime, 'vtt')
-      const endTime = this.formatTime(cue.endTime, 'vtt')
-      
-      output += `${startTime} --> ${endTime}`
-      
-      if (cue.settings) {
-        const settings = []
-        Object.entries(cue.settings).forEach(([key, value]) => {
-          settings.push(`${key}:${value}`)
-        })
-        if (settings.length > 0) {
-          output += ` ${settings.join(' ')}`
-        }
-      }
-      
-      output += `\n${cue.text}\n\n`
-    })
-    
-    return output
-  }
-
-  /**
-   * Export cues as SRT format
-   */
-  private exportAsSRT(cues: SubtitleCue[]): string {
-    let output = ''
-    
-    cues.forEach((cue, index) => {
-      const startTime = this.formatTime(cue.startTime, 'srt')
-      const endTime = this.formatTime(cue.endTime, 'srt')
-      
-      output += `${index + 1}\n`
-      output += `${startTime} --> ${endTime}\n`
-      output += `${cue.text}\n\n`
-    })
-    
-    return output
-  }
-
-  /**
-   * Format time for different subtitle formats
-   */
-  private formatTime(seconds: number, format: 'vtt' | 'srt'): string {
-    const hours = Math.floor(seconds / 3600)
-    const minutes = Math.floor((seconds % 3600) / 60)
-    const secs = Math.floor(seconds % 60)
-    const milliseconds = Math.floor((seconds % 1) * 1000)
-    
-    const separator = format === 'srt' ? ',' : '.'
-    
-    return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}${separator}${milliseconds.toString().padStart(3, '0')}`
-  }
-
-  /**
-   * Cleanup resources
-   */
-  destroy(): void {
-    this.tracks.clear()
-    this.eventListeners.clear()
-    this.activeTrackId = null
-    this.currentCues = []
-  }
-}
+	private tracks: Map<string, SubtitleTrack> = new Map()
+	private activeTrackId: string | null = null
+	private currentCues: SubtitleCue[] = []
+	private isEnabled: boolean = false
+	private style: SubtitleStyle
+	private eventListeners: Map<string, Set<Function>> = new Map()
+
+	constructor(options: SubtitleManagerOptions = {}) {
+		this.style = {
+			fontSize: 16,
+			fontFamily: "Arial, sans-serif",
+			color: "#ffffff",
+			backgroundColor: "rgba(0, 0, 0, 0.7)",
+			borderColor: "#000000",
+			borderWidth: 1,
+			opacity: 1,
+			position: "bottom",
+			alignment: "center",
+			shadow: true,
+			...options.defaultStyle
+		}
+
+		this.isEnabled = options.enabledByDefault ?? false
+
+		if (options.tracks) {
+			this.addTracks(options.tracks)
+
+			if (options.preloadTracks) {
+				this.preloadAllTracks()
+			}
+		}
+	}
+
+	/**
+	 * Add multiple subtitle tracks
+	 */
+	addTracks(tracks: SubtitleTrack[]): void {
+		tracks.forEach((track) => this.addTrack(track))
+	}
+
+	/**
+	 * Add a single subtitle track
+	 */
+	addTrack(track: SubtitleTrack): void {
+		const trackWithDefaults: SubtitleTrack = {
+			...track,
+			loadingState: "idle",
+			format: track.format || this.detectFormat(track.url)
+		}
+
+		this.tracks.set(track.id, trackWithDefaults)
+		this.emit("trackAdded", trackWithDefaults)
+
+		// Set as active if it's the default track and no track is currently active
+		if (track.isDefault && !this.activeTrackId) {
+			this.setActiveTrack(track.id)
+		}
+	}
+
+	/**
+	 * Remove a subtitle track
+	 */
+	removeTrack(trackId: string): void {
+		const track = this.tracks.get(trackId)
+		if (track) {
+			this.tracks.delete(trackId)
+
+			if (this.activeTrackId === trackId) {
+				this.activeTrackId = null
+				this.currentCues = []
+				this.emit("cuesChanged", [])
+			}
+
+			this.emit("trackRemoved", track)
+		}
+	}
+
+	/**
+	 * Get all available tracks
+	 */
+	getTracks(): SubtitleTrack[] {
+		return Array.from(this.tracks.values())
+	}
+
+	/**
+	 * Get a specific track by ID
+	 */
+	getTrack(trackId: string): SubtitleTrack | undefined {
+		return this.tracks.get(trackId)
+	}
+
+	/**
+	 * Set the active subtitle track
+	 */
+	async setActiveTrack(trackId: string | null): Promise<void> {
+		this.activeTrackId = trackId
+		this.currentCues = []
+
+		if (trackId) {
+			const track = this.tracks.get(trackId)
+			if (track && !track.parsedSubtitles && track.loadingState === "idle") {
+				await this.loadTrack(trackId)
+			}
+		}
+
+		this.emit("activeTrackChanged", trackId)
+		this.emit("cuesChanged", [])
+	}
+
+	/**
+	 * Get the currently active track
+	 */
+	getActiveTrack(): SubtitleTrack | null {
+		return this.activeTrackId ? this.tracks.get(this.activeTrackId) || null : null
+	}
+
+	/**
+	 * Enable or disable subtitles
+	 */
+	setEnabled(enabled: boolean): void {
+		this.isEnabled = enabled
+
+		if (!enabled) {
+			this.currentCues = []
+			this.emit("cuesChanged", [])
+		}
+
+		this.emit("enabledChanged", enabled)
+	}
+
+	/**
+	 * Check if subtitles are enabled
+	 */
+	isSubtitlesEnabled(): boolean {
+		return this.isEnabled
+	}
+
+	/**
+	 * Update subtitle styling
+	 */
+	updateStyle(newStyle: Partial<SubtitleStyle>): void {
+		this.style = { ...this.style, ...newStyle }
+		this.emit("styleChanged", this.style)
+	}
+
+	/**
+	 * Get current subtitle style
+	 */
+	getStyle(): SubtitleStyle {
+		return { ...this.style }
+	}
+
+	/**
+	 * Update current time and get active cues
+	 */
+	updateTime(currentTime: number): SubtitleCue[] {
+		if (!this.isEnabled || !this.activeTrackId) {
+			if (this.currentCues.length > 0) {
+				this.currentCues = []
+				this.emit("cuesChanged", [])
+			}
+			return []
+		}
+
+		const activeTrack = this.tracks.get(this.activeTrackId)
+		if (!activeTrack?.parsedSubtitles) {
+			if (this.currentCues.length > 0) {
+				this.currentCues = []
+				this.emit("cuesChanged", [])
+			}
+			return []
+		}
+
+		const activeCues = SubtitleParser.getActiveCues(activeTrack.parsedSubtitles.cues, currentTime)
+
+		// Check if cues have changed
+		const cuesChanged =
+			activeCues.length !== this.currentCues.length ||
+			activeCues.some(
+				(cue, index) => !this.currentCues[index] || cue.id !== this.currentCues[index].id
+			)
+
+		if (cuesChanged) {
+			this.currentCues = activeCues
+			this.emit("cuesChanged", activeCues)
+		}
+
+		return activeCues
+	}
+
+	/**
+	 * Get current active cues
+	 */
+	getCurrentCues(): SubtitleCue[] {
+		return [...this.currentCues]
+	}
+
+	/**
+	 * Load a subtitle track
+	 */
+	async loadTrack(trackId: string): Promise<void> {
+		const track = this.tracks.get(trackId)
+		if (!track || track.loadingState === "loading" || track.loadingState === "loaded") {
+			return
+		}
+
+		// Update loading state
+		track.loadingState = "loading"
+		this.emit("trackLoadingStateChanged", { trackId, state: "loading" })
+
+		try {
+			const response = await fetch(track.url)
+			if (!response.ok) {
+				throw new Error(`Failed to fetch subtitles: ${response.status} ${response.statusText}`)
+			}
+
+			const content = await response.text()
+			const format = track.format || SubtitleParser.detectFormat(content)
+
+			if (format === "unknown") {
+				throw new Error("Unsupported subtitle format")
+			}
+
+			const parsedSubtitles = SubtitleParser.parse(content, format)
+			track.parsedSubtitles = parsedSubtitles
+			track.loadingState = "loaded"
+			track.format = format
+
+			this.emit("trackLoadingStateChanged", { trackId, state: "loaded" })
+			this.emit("trackLoaded", track)
+		} catch (error) {
+			track.loadingState = "error"
+			track.error = error instanceof Error ? error.message : "Unknown error"
+
+			this.emit("trackLoadingStateChanged", { trackId, state: "error", error: track.error })
+			this.emit("trackError", { trackId, error: track.error })
+		}
+	}
+
+	/**
+	 * Preload all available tracks
+	 */
+	async preloadAllTracks(): Promise<void> {
+		const loadPromises = Array.from(this.tracks.keys()).map((trackId) => this.loadTrack(trackId))
+
+		await Promise.allSettled(loadPromises)
+	}
+
+	/**
+	 * Search for cues containing text
+	 */
+	searchCues(query: string, trackId?: string): Array<{ trackId: string; cue: SubtitleCue }> {
+		const results: Array<{ trackId: string; cue: SubtitleCue }> = []
+		const searchTracks = trackId ? [trackId] : Array.from(this.tracks.keys())
+
+		for (const id of searchTracks) {
+			const track = this.tracks.get(id)
+			if (!track?.parsedSubtitles) continue
+
+			for (const cue of track.parsedSubtitles.cues) {
+				const cleanText = SubtitleParser.cleanText(cue.text).toLowerCase()
+				if (cleanText.includes(query.toLowerCase())) {
+					results.push({ trackId: id, cue })
+				}
+			}
+		}
+
+		return results
+	}
+
+	/**
+	 * Export subtitles in a specific format
+	 */
+	exportSubtitles(trackId: string, format: "vtt" | "srt"): string | null {
+		const track = this.tracks.get(trackId)
+		if (!track?.parsedSubtitles) return null
+
+		const { cues, metadata } = track.parsedSubtitles
+
+		if (format === "vtt") {
+			return this.exportAsVTT(cues, metadata)
+		} else {
+			return this.exportAsSRT(cues)
+		}
+	}
+
+	/**
+	 * Event system methods
+	 */
+	on(event: string, callback: Function): () => void {
+		if (!this.eventListeners.has(event)) {
+			this.eventListeners.set(event, new Set())
+		}
+
+		this.eventListeners.get(event)!.add(callback)
+
+		return () => {
+			const listeners = this.eventListeners.get(event)
+			if (listeners) {
+				listeners.delete(callback)
+			}
+		}
+	}
+
+	private emit(event: string, data?: any): void {
+		const listeners = this.eventListeners.get(event)
+		if (listeners) {
+			listeners.forEach((callback) => callback(data))
+		}
+	}
+
+	/**
+	 * Detect subtitle format from URL extension
+	 */
+	private detectFormat(url: string): "vtt" | "srt" {
+		const extension = url.split(".").pop()?.toLowerCase()
+		return extension === "srt" ? "srt" : "vtt"
+	}
+
+	/**
+	 * Export cues as WebVTT format
+	 */
+	private exportAsVTT(cues: SubtitleCue[], metadata?: any): string {
+		let output = "WEBVTT\n\n"
+
+		if (metadata) {
+			Object.entries(metadata).forEach(([key, value]) => {
+				output += `${key}: ${value}\n`
+			})
+			output += "\n"
+		}
+
+		cues.forEach((cue, index) => {
+			if (cue.id) {
+				output += `${cue.id}\n`
+			}
+
+			const startTime = this.formatTime(cue.startTime, "vtt")
+			const endTime = this.formatTime(cue.endTime, "vtt")
+
+			output += `${startTime} --> ${endTime}`
+
+			if (cue.settings) {
+				const settings = []
+				Object.entries(cue.settings).forEach(([key, value]) => {
+					settings.push(`${key}:${value}`)
+				})
+				if (settings.length > 0) {
+					output += ` ${settings.join(" ")}`
+				}
+			}
+
+			output += `\n${cue.text}\n\n`
+		})
+
+		return output
+	}
+
+	/**
+	 * Export cues as SRT format
+	 */
+	private exportAsSRT(cues: SubtitleCue[]): string {
+		let output = ""
+
+		cues.forEach((cue, index) => {
+			const startTime = this.formatTime(cue.startTime, "srt")
+			const endTime = this.formatTime(cue.endTime, "srt")
+
+			output += `${index + 1}\n`
+			output += `${startTime} --> ${endTime}\n`
+			output += `${cue.text}\n\n`
+		})
+
+		return output
+	}
+
+	/**
+	 * Format time for different subtitle formats
+	 */
+	private formatTime(seconds: number, format: "vtt" | "srt"): string {
+		const hours = Math.floor(seconds / 3600)
+		const minutes = Math.floor((seconds % 3600) / 60)
+		const secs = Math.floor(seconds % 60)
+		const milliseconds = Math.floor((seconds % 1) * 1000)
+
+		const separator = format === "srt" ? "," : "."
+
+		return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}${separator}${milliseconds.toString().padStart(3, "0")}`
+	}
+
+	/**
+	 * Cleanup resources
+	 */
+	destroy(): void {
+		this.tracks.clear()
+		this.eventListeners.clear()
+		this.activeTrackId = null
+		this.currentCues = []
+	}
+}