smooth-player 1.0.1 → 2.0.0

package/dist/SmoothPlayer.js

@@ -1,4 +1,5 @@
 import { TypedEventEmitter } from "./events.js";
+import { strings } from "./i18n/strings.js";
 const DEFAULT_ANALYZER = {
     fftSize: 2048,
     smoothingTimeConstant: 0.8,
@@ -6,8 +7,19 @@ const DEFAULT_ANALYZER = {
     maxDecibels: -10,
 };
 const DEFAULT_ACCENT_COLOR = "#0ed2a4";
-const DEFAULT_PLAYLIST_ID = "default";
-const DEFAULT_PLAYLIST_TITLE = "My playlist";
+const DEFAULT_BACKGROUND_COLOR = "#0b1220";
+const DEFAULT_PLAYLIST_ID = strings.playlist.defaultId;
+const DEFAULT_PLAYLIST_TITLE = strings.playlist.defaultTitle;
+const DEFAULT_SPECTRUM_STYLE = {
+    dualLayer: false,
+    inverted: false,
+    barWidth: "medium",
+};
+const DEFAULT_WAVEFORM_STYLE = {
+    doubleLine: false,
+    fill: false,
+    thickLine: false,
+};
 export class SmoothPlayer {
     constructor(options = {}) {
         this.events = new TypedEventEmitter();
@@ -29,7 +41,10 @@ export class SmoothPlayer {
         this.audio.preload = this.audio.preload || "metadata";
         this.audio.volume = this.clamp(options.initialVolume ?? 1);
         this.visualizerMode = options.visualizer ?? "spectrum";
+        this.spectrumStyle = { ...DEFAULT_SPECTRUM_STYLE, ...options.spectrumStyle };
+        this.waveformStyle = { ...DEFAULT_WAVEFORM_STYLE, ...options.waveformStyle };
         this.accentColor = options.accentColor ?? DEFAULT_ACCENT_COLOR;
+        this.backgroundColor = options.backgroundColor ?? DEFAULT_BACKGROUND_COLOR;
         this.shuffleEnabled = options.initialShuffle ?? false;
         this.debugEnabled = options.debug ?? false;
         this.durationFallbackEnabled = options.durationFallback ?? true;
@@ -63,6 +78,30 @@ export class SmoothPlayer {
     applyAccentColor(target) {
         target.style.setProperty("--smooth-player-accent", this.accentColor);
     }
+    setBackgroundColor(color) {
+        this.backgroundColor = color;
+    }
+    getBackgroundColor() {
+        return this.backgroundColor;
+    }
+    applyBackgroundColor(target) {
+        const normalized = this.backgroundColor.trim().toLowerCase();
+        if (normalized === DEFAULT_BACKGROUND_COLOR) {
+            target.style.removeProperty("--smooth-player-background");
+            target.style.removeProperty("--smooth-player-surface");
+            target.style.removeProperty("--smooth-player-panel");
+            target.style.removeProperty("--smooth-player-muted");
+            return;
+        }
+        target.style.setProperty("--smooth-player-background", this.backgroundColor);
+        target.style.setProperty("--smooth-player-surface", this.buildSurfaceGradient(this.backgroundColor));
+        target.style.setProperty("--smooth-player-panel", this.buildPanelGradient(this.backgroundColor));
+        target.style.setProperty("--smooth-player-muted", `color-mix(in srgb, ${this.backgroundColor} 30%, #d2deef 70%)`);
+    }
+    applyTheme(target) {
+        this.applyAccentColor(target);
+        this.applyBackgroundColor(target);
+    }
     setShuffle(enabled) {
         this.shuffleEnabled = enabled;
     }
@@ -152,8 +191,8 @@ export class SmoothPlayer {
             titleClassName: options.titleClassName ?? "smooth-player__playlist-title",
             artistClassName: options.artistClassName ?? "smooth-player__playlist-artist",
             selectedAriaAttr: options.selectedAriaAttr ?? "aria-current",
-            getTitle: options.getTitle ?? ((track, index) => track.metadata?.title ?? `Track ${index + 1}`),
-            getArtist: options.getArtist ?? ((track) => track.metadata?.artist ?? "Unknown artist"),
+            getTitle: options.getTitle ?? ((track, index) => track.metadata?.title ?? `${strings.track.unknownTitle} ${index + 1}`),
+            getArtist: options.getArtist ?? ((track) => track.metadata?.artist ?? strings.track.unknownArtist),
         };
         const onSelect = options.onSelect;
         const render = () => {
@@ -226,7 +265,7 @@ export class SmoothPlayer {
             trigger.className = "smooth-player__playlist-switcher-trigger";
             trigger.setAttribute("aria-haspopup", "listbox");
             trigger.setAttribute("aria-expanded", String(isOpen));
-            trigger.textContent = currentPlaylist?.title ?? playlists[0]?.title ?? "Playlist";
+            trigger.textContent = currentPlaylist?.title ?? playlists[0]?.title ?? strings.playlist.triggerLabel;
             const menu = doc.createElement("div");
             menu.className = "smooth-player__playlist-switcher-menu";
             menu.hidden = !isOpen;
@@ -295,8 +334,8 @@ export class SmoothPlayer {
         return () => off();
     }
     mountTrackInfo(titleElement, artistElement, options = {}) {
-        const unknownTitle = options.unknownTitle ?? "Unknown title";
-        const unknownArtist = options.unknownArtist ?? "Unknown artist";
+        const unknownTitle = options.unknownTitle ?? strings.track.unknownTitle;
+        const unknownArtist = options.unknownArtist ?? strings.track.unknownArtist;
         const render = () => {
             const track = this.getCurrentTrack();
             titleElement.textContent = track?.metadata?.title ?? unknownTitle;
@@ -308,8 +347,8 @@ export class SmoothPlayer {
     }
     mountPlayButton(button, options = {}) {
         const labelElement = options.labelElement ?? null;
-        const playLabel = options.playLabel ?? "Riproduci";
-        const pauseLabel = options.pauseLabel ?? "Pausa";
+        const playLabel = options.playLabel ?? strings.playback.playLabel;
+        const pauseLabel = options.pauseLabel ?? strings.playback.pauseLabel;
         const render = () => {
             const isPlaying = !this.audio.paused;
             const label = isPlaying ? pauseLabel : playLabel;
@@ -344,7 +383,7 @@ export class SmoothPlayer {
         };
     }
     mountShuffleToggle(options) {
-        const { button, labelElement = null, activeClassName = "smooth-player__toggle-on", enabledLabel = "Disattiva shuffle", disabledLabel = "Attiva shuffle", initialEnabled = false, } = options;
+        const { button, labelElement = null, activeClassName = "smooth-player__toggle-on", enabledLabel = strings.shuffle.enabledLabel, disabledLabel = strings.shuffle.disabledLabel, initialEnabled = false, } = options;
         const render = () => {
             const enabled = this.getShuffle();
             const label = enabled ? enabledLabel : disabledLabel;
@@ -367,24 +406,39 @@ export class SmoothPlayer {
         };
     }
     mountPlaylistPanel(options) {
-        const { root, toggleButton, panel, closeButton = null, openClassName = "smooth-player--playlist-open", openLabel = "Apri playlist", closeLabel = "Chiudi playlist", } = options;
+        const { root, toggleButton, panel, closeButton = null, openClassName = "smooth-player--playlist-open", openLabel = strings.playlist.openLabel, closeLabel = strings.playlist.closeLabel, } = options;
         let isOpen = false;
         const hasPlaylist = () => this.getPlaylists().length > 1 || this.getActiveTracks().length > 1;
         const syncVisibility = () => {
             toggleButton.hidden = !hasPlaylist();
         };
         const setOpen = (open) => {
+            const activeElement = (root.ownerDocument ?? document).activeElement;
+            const focusedInsidePanel = activeElement instanceof Node && panel.contains(activeElement);
             if (!hasPlaylist()) {
                 isOpen = false;
+                if (focusedInsidePanel) {
+                    toggleButton.focus();
+                }
                 root.classList.remove(openClassName);
                 panel.setAttribute("aria-hidden", "true");
+                panel.setAttribute("inert", "");
                 toggleButton.setAttribute("aria-expanded", "false");
                 toggleButton.setAttribute("aria-label", openLabel);
                 return;
             }
             isOpen = open;
+            if (!open && focusedInsidePanel) {
+                toggleButton.focus();
+            }
             root.classList.toggle(openClassName, open);
             panel.setAttribute("aria-hidden", String(!open));
+            if (open) {
+                panel.removeAttribute("inert");
+            }
+            else {
+                panel.setAttribute("inert", "");
+            }
             toggleButton.setAttribute("aria-expanded", String(open));
             toggleButton.setAttribute("aria-label", open ? closeLabel : openLabel);
         };
@@ -577,12 +631,199 @@ export class SmoothPlayer {
             offDurationChange();
         };
     }
+    mountAudioDrop(target, options = {}) {
+        const activeClassName = options.activeClassName ?? "is-drag-over";
+        const onDropCallback = options.onDrop;
+        let dragDepth = 0;
+        let activeObjectUrls = [];
+        const clearActiveState = () => {
+            dragDepth = 0;
+            target.classList.remove(activeClassName);
+        };
+        const revokeActiveUrls = () => {
+            for (const url of activeObjectUrls) {
+                URL.revokeObjectURL(url);
+            }
+            activeObjectUrls = [];
+        };
+        const isAudioFile = (file) => {
+            if (file.type.startsWith("audio/"))
+                return true;
+            return /\.(mp3|wav|ogg|m4a|aac|flac|opus)$/i.test(file.name);
+        };
+        const isPlaylistFile = (file) => {
+            if (/\.m3u8?$/i.test(file.name))
+                return true;
+            return /(?:application|audio)\/(?:vnd\.apple\.mpegurl|x-mpegurl)/i.test(file.type);
+        };
+        const baseName = (value) => {
+            const noQuery = value.split("?")[0]?.split("#")[0] ?? value;
+            const normalized = noQuery.replace(/\\/g, "/");
+            const tail = normalized.split("/").pop() ?? normalized;
+            try {
+                return decodeURIComponent(tail);
+            }
+            catch {
+                return tail;
+            }
+        };
+        const guessTitle = (value) => baseName(value).replace(/\.[^/.]+$/, "") || strings.track.unknownTitle;
+        const buildTrackFromAudioFile = (file, index) => {
+            const src = URL.createObjectURL(file);
+            activeObjectUrls.push(src);
+            const track = {
+                id: `dropped-${Date.now()}-${index}`,
+                src,
+                metadata: {
+                    title: file.name.replace(/\.[^/.]+$/, ""),
+                    artist: strings.track.localFileArtist,
+                },
+            };
+            if (file.type) {
+                track.type = file.type;
+            }
+            return track;
+        };
+        const parseM3U = (content, localAudioFiles) => {
+            const localByName = new Map();
+            localAudioFiles.forEach((file) => {
+                localByName.set(file.name.toLowerCase(), file);
+            });
+            const tracks = [];
+            const lines = content.split(/\r?\n/);
+            let extInfTitle = null;
+            lines.forEach((raw, index) => {
+                const line = raw.trim().replace(/^\uFEFF/, "");
+                if (!line)
+                    return;
+                if (line.startsWith("#EXTINF:")) {
+                    const commaIndex = line.indexOf(",");
+                    extInfTitle = commaIndex >= 0 ? line.slice(commaIndex + 1).trim() : null;
+                    return;
+                }
+                if (line.startsWith("#"))
+                    return;
+                const localFile = localByName.get(baseName(line).toLowerCase()) ?? null;
+                let src = "";
+                let type;
+                if (localFile) {
+                    src = URL.createObjectURL(localFile);
+                    activeObjectUrls.push(src);
+                    type = localFile.type || undefined;
+                }
+                else {
+                    try {
+                        src = new URL(line, window.location.href).href;
+                    }
+                    catch {
+                        src = "";
+                    }
+                }
+                if (!src) {
+                    extInfTitle = null;
+                    return;
+                }
+                const track = {
+                    id: `dropped-m3u-${Date.now()}-${index}`,
+                    src,
+                    metadata: {
+                        title: extInfTitle || guessTitle(line),
+                        artist: localFile ? strings.track.localFileArtist : strings.track.m3uArtist,
+                    },
+                };
+                if (type) {
+                    track.type = type;
+                }
+                tracks.push(track);
+                extInfTitle = null;
+            });
+            return tracks;
+        };
+        const hasFilePayload = (event) => {
+            const types = event.dataTransfer?.types;
+            if (!types)
+                return false;
+            return Array.from(types).includes("Files");
+        };
+        const onDragEnter = (event) => {
+            if (!hasFilePayload(event))
+                return;
+            event.preventDefault();
+            dragDepth += 1;
+            target.classList.add(activeClassName);
+        };
+        const onDragOver = (event) => {
+            if (!hasFilePayload(event))
+                return;
+            event.preventDefault();
+            if (event.dataTransfer) {
+                event.dataTransfer.dropEffect = "copy";
+            }
+        };
+        const onDragLeave = (event) => {
+            if (!hasFilePayload(event))
+                return;
+            event.preventDefault();
+            dragDepth = Math.max(0, dragDepth - 1);
+            if (dragDepth === 0) {
+                target.classList.remove(activeClassName);
+            }
+        };
+        const onDropEvent = async (event) => {
+            event.preventDefault();
+            clearActiveState();
+            const files = Array.from(event.dataTransfer?.files ?? []);
+            if (!files.length)
+                return;
+            const playlistFile = files.find(isPlaylistFile) ?? null;
+            const audioFiles = files.filter(isAudioFile);
+            let tracks = [];
+            let kind = "audio";
+            let sourceFile = null;
+            revokeActiveUrls();
+            if (playlistFile) {
+                kind = "playlist";
+                sourceFile = playlistFile;
+                const content = await playlistFile.text();
+                tracks = parseM3U(content, audioFiles);
+            }
+            else if (audioFiles.length) {
+                sourceFile = audioFiles[0] ?? null;
+                tracks = audioFiles.map((file, index) => buildTrackFromAudioFile(file, index));
+            }
+            const firstTrack = tracks[0];
+            if (!sourceFile || !firstTrack) {
+                this.events.emit("error", {
+                    error: new Error(strings.errors.noPlayableTracksDropped),
+                });
+                return;
+            }
+            this.setPlaylist(tracks, 0);
+            onDropCallback?.({ file: sourceFile, track: firstTrack, tracks, kind });
+            await this.play(0);
+        };
+        const onDrop = (event) => {
+            void onDropEvent(event);
+        };
+        target.addEventListener("dragenter", onDragEnter);
+        target.addEventListener("dragover", onDragOver);
+        target.addEventListener("dragleave", onDragLeave);
+        target.addEventListener("drop", onDrop);
+        return () => {
+            clearActiveState();
+            target.removeEventListener("dragenter", onDragEnter);
+            target.removeEventListener("dragover", onDragOver);
+            target.removeEventListener("dragleave", onDragLeave);
+            target.removeEventListener("drop", onDrop);
+            revokeActiveUrls();
+        };
+    }
     async play(index) {
         if (typeof index === "number") {
             this.loadTrackByIndex(index);
         }
         if (!this.audio.src) {
-            throw new Error("No track loaded. Use playlist option, setPlaylist(), or loadTrack().");
+            throw new Error(strings.errors.noTrackLoaded);
         }
         if (this.context.state === "suspended") {
             await this.context.resume();
@@ -669,7 +910,10 @@ export class SmoothPlayer {
             playlistTitle: playlist?.title ?? DEFAULT_PLAYLIST_TITLE,
             playlistCount: this.playlists.length,
             visualizer: this.visualizerMode,
+            spectrumStyle: { ...this.spectrumStyle },
+            waveformStyle: { ...this.waveformStyle },
             accentColor: this.accentColor,
+            backgroundColor: this.backgroundColor,
             shuffle: this.shuffleEnabled,
         };
     }
@@ -711,6 +955,18 @@ export class SmoothPlayer {
     getVisualizer() {
         return this.visualizerMode;
     }
+    setSpectrumStyle(options) {
+        this.spectrumStyle = { ...this.spectrumStyle, ...options };
+    }
+    getSpectrumStyle() {
+        return { ...this.spectrumStyle };
+    }
+    setWaveformStyle(options) {
+        this.waveformStyle = { ...this.waveformStyle, ...options };
+    }
+    getWaveformStyle() {
+        return { ...this.waveformStyle };
+    }
     configureAnalyzer(options = {}) {
         const config = { ...DEFAULT_ANALYZER, ...options };
         this.analyser.fftSize = config.fftSize;
@@ -718,6 +974,12 @@ export class SmoothPlayer {
         this.analyser.minDecibels = config.minDecibels;
         this.analyser.maxDecibels = config.maxDecibels;
     }
+    buildSurfaceGradient(baseColor) {
+        return `linear-gradient(145deg, color-mix(in srgb, ${baseColor} 74%, #2a3f67 26%), color-mix(in srgb, ${baseColor} 82%, #15233e 18%) 56%, color-mix(in srgb, ${baseColor} 88%, #0a1324 12%))`;
+    }
+    buildPanelGradient(baseColor) {
+        return `linear-gradient(190deg, color-mix(in srgb, ${baseColor} 72%, #2a4069 28%) 0%, color-mix(in srgb, ${baseColor} 82%, #16243f 18%) 58%, color-mix(in srgb, ${baseColor} 88%, #0a1222 12%) 100%)`;
+    }
     getActivePlaylist() {
         if (!this.activePlaylistId)
             return null;
@@ -767,11 +1029,31 @@ export class SmoothPlayer {
             this.events.emit("ended", undefined);
         });
         this.audio.addEventListener("error", () => {
+            const src = this.audio.currentSrc || this.audio.src || "";
+            const mediaError = this.audio.error;
+            const isCrossOrigin = this.isCrossOriginSource(src);
+            const isPossiblyCors = isCrossOrigin && mediaError?.code === MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED;
+            const message = isPossiblyCors
+                ? strings.errors.corsBlocked
+                : strings.errors.audioPlaybackFailed;
             this.events.emit("error", {
-                error: new Error("Audio playback failed."),
+                error: new Error(message),
             });
         });
     }
+    isCrossOriginSource(src) {
+        if (!src)
+            return false;
+        if (src.startsWith("blob:") || src.startsWith("data:") || src.startsWith("file:"))
+            return false;
+        try {
+            const url = new URL(src, window.location.href);
+            return url.origin !== window.location.origin;
+        }
+        catch {
+            return false;
+        }
+    }
     clamp(value) {
         return Math.min(1, Math.max(0, value));
     }

package/dist/i18n/en.generated.d.ts

@@ -0,0 +1,50 @@
+export declare const en: {
+    readonly playlist: {
+        readonly defaultId: "default";
+        readonly defaultTitle: "My playlist";
+        readonly triggerLabel: "Playlist";
+        readonly openLabel: "Open playlist";
+        readonly closeLabel: "Close playlist";
+    };
+    readonly playback: {
+        readonly playLabel: "Play";
+        readonly pauseLabel: "Pause";
+        readonly stopLabel: "Stop";
+    };
+    readonly shuffle: {
+        readonly enabledLabel: "Disable shuffle";
+        readonly disabledLabel: "Enable shuffle";
+    };
+    readonly visualizer: {
+        readonly toggleLabel: "Change visualizer";
+        readonly panelTitle: "Visualizer options";
+        readonly closeLabel: "Close visualizer options";
+        readonly modeLabel: "Mode";
+        readonly effectLabel: "Spectrum effects";
+        readonly effectDualLayer: "Bi-directional";
+        readonly effectInverted: "Inverted";
+        readonly barWidthLabel: "Bar width";
+        readonly barWidthThin: "Thin";
+        readonly barWidthMedium: "Medium";
+        readonly barWidthLarge: "Large";
+        readonly waveformEffectLabel: "Waveform effects";
+        readonly waveformEffectDoubleLine: "Double line";
+        readonly waveformEffectFill: "Fill";
+        readonly waveformEffectThickLine: "Thick line";
+        readonly modeSpectrum: "Spectrum";
+        readonly modeWaveform: "Waveform";
+        readonly modeNone: "Off";
+    };
+    readonly track: {
+        readonly unknownTitle: "Unknown title";
+        readonly unknownArtist: "Unknown artist";
+        readonly localFileArtist: "Local file";
+        readonly m3uArtist: "M3U playlist";
+    };
+    readonly errors: {
+        readonly noTrackLoaded: "No track loaded. Use playlist option, setPlaylist(), or loadTrack().";
+        readonly noPlayableTracksDropped: "No playable tracks found in dropped files.";
+        readonly audioPlaybackFailed: "Audio playback failed.";
+        readonly corsBlocked: "Unable to play this audio source. It may be blocked by CORS.";
+    };
+};

package/dist/i18n/en.generated.js

@@ -0,0 +1,51 @@
+/* Auto-generated from src/i18n/en.json. Do not edit manually. */
+export const en = {
+    "playlist": {
+        "defaultId": "default",
+        "defaultTitle": "My playlist",
+        "triggerLabel": "Playlist",
+        "openLabel": "Open playlist",
+        "closeLabel": "Close playlist"
+    },
+    "playback": {
+        "playLabel": "Play",
+        "pauseLabel": "Pause",
+        "stopLabel": "Stop"
+    },
+    "shuffle": {
+        "enabledLabel": "Disable shuffle",
+        "disabledLabel": "Enable shuffle"
+    },
+    "visualizer": {
+        "toggleLabel": "Change visualizer",
+        "panelTitle": "Visualizer options",
+        "closeLabel": "Close visualizer options",
+        "modeLabel": "Mode",
+        "effectLabel": "Spectrum effects",
+        "effectDualLayer": "Bi-directional",
+        "effectInverted": "Inverted",
+        "barWidthLabel": "Bar width",
+        "barWidthThin": "Thin",
+        "barWidthMedium": "Medium",
+        "barWidthLarge": "Large",
+        "waveformEffectLabel": "Waveform effects",
+        "waveformEffectDoubleLine": "Double line",
+        "waveformEffectFill": "Fill",
+        "waveformEffectThickLine": "Thick line",
+        "modeSpectrum": "Spectrum",
+        "modeWaveform": "Waveform",
+        "modeNone": "Off"
+    },
+    "track": {
+        "unknownTitle": "Unknown title",
+        "unknownArtist": "Unknown artist",
+        "localFileArtist": "Local file",
+        "m3uArtist": "M3U playlist"
+    },
+    "errors": {
+        "noTrackLoaded": "No track loaded. Use playlist option, setPlaylist(), or loadTrack().",
+        "noPlayableTracksDropped": "No playable tracks found in dropped files.",
+        "audioPlaybackFailed": "Audio playback failed.",
+        "corsBlocked": "Unable to play this audio source. It may be blocked by CORS."
+    }
+};

package/dist/i18n/strings.d.ts

@@ -0,0 +1,51 @@
+export interface SmoothPlayerStrings {
+    playlist: {
+        defaultId: string;
+        defaultTitle: string;
+        triggerLabel: string;
+        openLabel: string;
+        closeLabel: string;
+    };
+    playback: {
+        playLabel: string;
+        pauseLabel: string;
+        stopLabel: string;
+    };
+    shuffle: {
+        enabledLabel: string;
+        disabledLabel: string;
+    };
+    visualizer: {
+        toggleLabel: string;
+        panelTitle: string;
+        closeLabel: string;
+        modeLabel: string;
+        effectLabel: string;
+        effectDualLayer: string;
+        effectInverted: string;
+        barWidthLabel: string;
+        barWidthThin: string;
+        barWidthMedium: string;
+        barWidthLarge: string;
+        waveformEffectLabel: string;
+        waveformEffectDoubleLine: string;
+        waveformEffectFill: string;
+        waveformEffectThickLine: string;
+        modeSpectrum: string;
+        modeWaveform: string;
+        modeNone: string;
+    };
+    track: {
+        unknownTitle: string;
+        unknownArtist: string;
+        localFileArtist: string;
+        m3uArtist: string;
+    };
+    errors: {
+        noTrackLoaded: string;
+        noPlayableTracksDropped: string;
+        audioPlaybackFailed: string;
+        corsBlocked: string;
+    };
+}
+export declare const strings: SmoothPlayerStrings;

package/dist/i18n/strings.js

@@ -0,0 +1,2 @@
+import { en } from "./en.generated.js";
+export const strings = en;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { SmoothPlayer } from "./SmoothPlayer.js";
-export { mountStandardPlayerUI } from "./ui.js";
+export { mountPlayerUI } from "./ui.js";
+export { strings } from "./i18n/strings.js";
+export type { SmoothPlayerStrings } from "./i18n/strings.js";
 export { CanvasRadialVisualizer, CanvasSpectrumVisualizer, CanvasWaveformVisualizer, type RadialVisualizerOptions, type SpectrumVisualizerOptions, type WaveformVisualizerOptions, } from "./visualizers.js";
-export type { AnalyzerOptions, AudioPlaylist, AudioTrack, PlaybackState, PlaylistPanelController, PlaylistPanelMountOptions, PlaylistEntry, PlaylistMountOptions, PlaylistSwitcherMountOptions, PlaylistTitleMountOptions, PlayButtonMountOptions, ProgressMountOptions, PlayerEvents, SmoothPlayerOptions, ShuffleToggleMountOptions, DebugPanelMountOptions, TransportControlsMountOptions, StandardPlayerUIController, StandardPlayerUIMountOptions, TrackInfoMountOptions, TrackMetadata, VisualizerMode, } from "./types.js";
+export type { AnalyzerOptions, AudioDropMountOptions, AudioPlaylist, AudioTrack, PlaybackState, PlaylistPanelController, PlaylistPanelMountOptions, PlaylistEntry, PlaylistMountOptions, PlaylistSwitcherMountOptions, PlaylistTitleMountOptions, PlayButtonMountOptions, ProgressMountOptions, PlayerEvents, SmoothPlayerOptions, ShuffleToggleMountOptions, DebugPanelMountOptions, TransportControlsMountOptions, StandardPlayerUIController, StandardPlayerUIMountOptions, SpectrumStyleOptions, TrackInfoMountOptions, TrackMetadata, VisualizerMode, WaveformStyleOptions, } from "./types.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { SmoothPlayer } from "./SmoothPlayer.js";
-export { mountStandardPlayerUI } from "./ui.js";
+export { mountPlayerUI } from "./ui.js";
+export { strings } from "./i18n/strings.js";
 export { CanvasRadialVisualizer, CanvasSpectrumVisualizer, CanvasWaveformVisualizer, } from "./visualizers.js";