(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core')) :
    typeof define === 'function' && define.amd ? define('ngx-soundmanager2', ['exports', '@angular/core'], factory) :
    (factory((global['ngx-soundmanager2'] = {}),global.ng.core));
}(this, (function (exports,core) { 'use strict';

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    /** @enum {string} */
    var MusicPlayerEventConstants = {
        ANGULAR_PLAYER_READY: 'angularPlayer:ready',
        // CURRENT_TRACK_DURATION = 'currentTrack:duration',
        // CURRENT_TRACK_POSITION = 'currentTrack:position',
        MUSIC_IS_PLAYING: 'music:isPlaying',
        MUSIC_MUTE: 'music:mute',
        MUSIC_REPEAT: 'music:repeat',
        MUSIC_VOLUME: 'music:volume',
        PLAYER_PLAYLIST: 'player:playlist',
        SOUND_MANAGER_READY: 'Sound manager ready!',
        TRACK_ID: 'track:id',
        TRACK_LOADED: 'track:loaded',
        TRACK_STOP: 'track:stop',
    };

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var MusicPlayerUtils = /** @class */ (function () {
        function MusicPlayerUtils() {
        }
        /**
         *
         * @param track
         */
        /**
         *
         * @param {?} track
         * @return {?}
         */
        MusicPlayerUtils.IsTrackValid = /**
         *
         * @param {?} track
         * @return {?}
         */
        function (track) {
            if (typeof track === 'undefined') {
                console.warn('invalid track data');
                return false;
            }
            if (track.url.indexOf('soundcloud') > -1) {
                // if soundcloud url
                if (typeof track.url === 'undefined') {
                    console.warn('invalid soundcloud track url');
                    return false;
                }
            }
            else {
                if (soundManager.canPlayURL(track.url) !== true) {
                    console.warn('invalid song url');
                    return false;
                }
            }
            return true;
        };
        /**
         * getIndexByValue used by this service
         */
        /**
         * getIndexByValue used by this service
         * @param {?} array
         * @param {?} value
         * @return {?}
         */
        MusicPlayerUtils.GetIndexByValue = /**
         * getIndexByValue used by this service
         * @param {?} array
         * @param {?} value
         * @return {?}
         */
        function (array, value) {
            for (var /** @type {?} */ i = 0; i < array.length; i++) {
                if (array[i] === value) {
                    return i;
                }
            }
            return -1;
        };
        /**
         * To check if value is in array
         */
        /**
         * To check if value is in array
         * @param {?} array
         * @param {?} value
         * @return {?}
         */
        MusicPlayerUtils.IsInArray = /**
         * To check if value is in array
         * @param {?} array
         * @param {?} value
         * @return {?}
         */
        function (array, value) {
            for (var /** @type {?} */ i = 0; i < array.length; i++) {
                if (array[i].id === value) {
                    return i;
                }
            }
            return -1;
        };
        /**
         * asyncLoop
         * @param o
         */
        /**
         * asyncLoop
         * @param {?} o
         * @return {?}
         */
        MusicPlayerUtils.AsyncLoop = /**
         * asyncLoop
         * @param {?} o
         * @return {?}
         */
        function (o) {
            var /** @type {?} */ i = -1;
            var /** @type {?} */ loop = function () {
                i++;
                if (i === o.length) {
                    o.callback();
                    return;
                }
                o.functionToLoop(loop, i);
            };
            loop(); // init
        };
        return MusicPlayerUtils;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var MusicPlayerService = /** @class */ (function () {
        function MusicPlayerService(setupOptions) {
            this.setupOptions = setupOptions;
            this.currentTrack = null;
            this.repeat = false;
            this.autoPlay = true;
            this.isPlaying = false;
            this.trackProgress = 0;
            this.volume = 90;
            this.playlist = [];
            this.musicPlayerEventEmitter = new core.EventEmitter();
            this.musicPlayerMuteEventEmitter = new core.EventEmitter();
            this.musicPlayerRepeatEventEmitter = new core.EventEmitter();
            this.musicPlayerStopEventEmitter = new core.EventEmitter();
            this.musicPlayerTrackEventEmitter = new core.EventEmitter();
            this.musicPlayerVolumeEventEmitter = new core.EventEmitter();
            this.init(setupOptions);
        }
        /**
         * Initialize soundmanager,
         * requires soundmanager2 to be loaded first
         */
        /**
         * Initialize soundmanager,
         * requires soundmanager2 to be loaded first
         * @param {?=} setupOptions
         * @return {?}
         */
        MusicPlayerService.prototype.init = /**
         * Initialize soundmanager,
         * requires soundmanager2 to be loaded first
         * @param {?=} setupOptions
         * @return {?}
         */
        function (setupOptions) {
            var _this = this;
            if (typeof soundManager === 'undefined') {
                alert('Please include SoundManager2 Library!');
            }
            Object.assign(soundManager.setupOptions, setupOptions);
            soundManager.setupOptions.ignoreMobileRestrictions = true;
            this._soundObject = soundManager.setup({
                preferFlash: false,
                // prefer 100% HTML5 mode, where both supported
                debugMode: false,
                // enable debugging output
                useHTML5Audio: true,
                // http://www.schillmania.com/projects/soundmanager2/doc/#soundmanager-usehtml5audio
                /**
                       * @reference http://www.schillmania.com/projects/soundmanager2/doc/#sm-config
                       * @description onready Events (Callbacks)
                       * Queues an event callback/handler for successful initialization and "ready to use" state of SoundManager 2.
                       * An optional scope parameter can be specified; if none, the callback is scoped to the window.
                       * If onready() is called after successful initialization, the callback will be executed immediately.
                       * The onready() queue is processed before soundManager.onload().
                       */
                onready: function () {
                    // Assign instance of this Angular MusicPlayerService to soundManager object
                    // so that the SMSound Objects can access it
                    soundManager.parent = _this;
                    // Ready to use; soundManager.createSound() etc. can now be called.
                    // Emit event
                    var /** @type {?} */ isSupported = soundManager.ok();
                    _this.musicPlayerEventEmitter.emit({
                        event: MusicPlayerEventConstants.ANGULAR_PLAYER_READY,
                        data: isSupported
                    });
                },
                /**
                       * @reference http://www.schillmania.com/projects/soundmanager2/doc/#sm-config
                       * @description ontimeout Events (Callbacks)
                       * Queues an event callback/handler for SM2 init failure, processed at (or immediately,
                       * if added after) SM2 initialization has failed, just before soundManager.onerror() is called.
                       * An optional scope parameter can be specified; if none, the callback is scoped to the window.
                       * Additionally, a status object containing success and error->type parameters is passed as an argument to your callback.
                       */
                ontimeout: function () {
                    alert('SM2 failed to start. Flash missing, blocked or security error?');
                    alert('The status is ' + _this._soundObject.status.success + ', the error type is ' + _this._soundObject.status.error.type);
                },
                defaultOptions: {
                    // set global default volume for all sound objects
                    autoLoad: false,
                    // enable automatic loading (otherwise .load() will call with .play())
                    autoPlay: false,
                    // enable playing of file ASAP (much faster if "stream" is true)
                    from: null,
                    // position to start playback within a sound (msec), see demo
                    loops: 1,
                    // number of times to play the sound. Related: looping (API demo)
                    multiShot: false,
                    // let sounds "restart" or "chorus" when played multiple times..
                    multiShotEvents: false,
                    // allow events (onfinish()) to fire for each shot, if supported.
                    onid3: null,
                    // callback function for "ID3 data is added/available"
                    onload: null,
                    // callback function for "load finished"
                    onstop: null,
                    // callback for "user stop"
                    onfailure: 'nextTrack',
                    // callback function for when playing fails
                    onpause: null,
                    // callback for "pause"
                    onplay: null,
                    // callback for "play" start
                    onresume: null,
                    // callback for "resume" (pause toggle)
                    position: null,
                    // offset (milliseconds) to seek to within downloaded sound.
                    pan: 0,
                    // "pan" settings, left-to-right, -100 to 100
                    stream: true,
                    // allows playing before entire file has loaded (recommended)
                    to: null,
                    // position to end playback within a sound (msec), see demo
                    type: 'audio/mp3',
                    // MIME-like hint for canPlay() tests, eg. 'audio/mp3'
                    usePolicyFile: false,
                    // enable crossdomain.xml request for remote domains (for ID3/waveform access)
                    volume: this.volume,
                    // self-explanatory. 0-100, the latter being the max.
                    /**
                             * SMSound (sound instance) object instance event handler
                             * @note Event handlers are scoped to the relevant sound object,
                             * so the this keyword will point to the sound object on which
                             * the event fired such that its properties can easily be accessed
                             */
                    whileloading: function () {
                        soundManager._writeDebug('sound ' + this.id + ' loading, ' + this.bytesLoaded + ' of ' + this.bytesTotal);
                        var /** @type {?} */ trackLoaded = ((this.bytesLoaded / this.bytesTotal) * 100);
                        var /** @type {?} */ musicPlayerService = soundManager.parent;
                        if (musicPlayerService) {
                            musicPlayerService.musicPlayerEventEmitter.emit({
                                event: MusicPlayerEventConstants.TRACK_LOADED,
                                data: trackLoaded
                            });
                        }
                    },
                    /**
                             * SMSound (sound instance) object instance event handler
                             * @note Event handlers are scoped to the relevant sound object,
                             * so the this keyword will point to the sound object on which
                             * the event fired such that its properties can easily be accessed
                             */
                    whileplaying: function () {
                        soundManager._writeDebug('sound ' + this.id + ' playing, ' + this.position + ' of ' + this.duration);
                        var /** @type {?} */ musicPlayerService = soundManager.parent;
                        if (musicPlayerService) {
                            // broadcast current playing track id
                            musicPlayerService.currentTrack = this.id;
                            try {
                                musicPlayerService.trackProgress = ((this.position / this.duration) * 100);
                                musicPlayerService.position = this.position;
                                musicPlayerService.duration = this.duration;
                            }
                            catch (/** @type {?} */ error) {
                                musicPlayerService.trackProgress = 0;
                                musicPlayerService.position = 0;
                                musicPlayerService.duration = 0;
                            }
                            var /** @type {?} */ trackEventData = {
                                trackId: musicPlayerService.currentTrack,
                                trackProgress: musicPlayerService.trackProgress,
                                trackPosition: this.position,
                                trackDuration: this.duration
                            };
                            musicPlayerService.musicPlayerTrackEventEmitter.emit({
                                event: MusicPlayerEventConstants.TRACK_ID,
                                data: trackEventData
                            });
                        }
                    },
                    /**
                             * SMSound (sound instance) object instance event handler
                             * @note Using ES6 and this refers to the Angular MusicPlayerService instances
                             * instead of the SMSound object instance
                             */
                    onfinish: function () {
                        if (_this.autoPlay === true) {
                            _this.nextTrack();
                            var /** @type {?} */ trackEventData = {
                                trackId: _this.currentTrack,
                                trackProgress: _this.trackProgress,
                                trackDuration: 0,
                                trackPosition: 0
                            };
                            _this.musicPlayerTrackEventEmitter.emit({
                                event: MusicPlayerEventConstants.TRACK_ID,
                                data: trackEventData
                            });
                        }
                    }
                }
            });
        };
        /**
         * @param {?} key
         * @return {?}
         */
        MusicPlayerService.prototype.setCurrentTrack = /**
         * @param {?} key
         * @return {?}
         */
        function (key) {
            this.currentTrack = key;
        };
        /**
         * @return {?}
         */
        MusicPlayerService.prototype.getCurrentTrack = /**
         * @return {?}
         */
        function () {
            return this.currentTrack;
        };
        /**
         * @return {?}
         */
        MusicPlayerService.prototype.currentTrackData = /**
         * @return {?}
         */
        function () {
            var /** @type {?} */ trackId = this.getCurrentTrack();
            var /** @type {?} */ currentKey = MusicPlayerUtils.IsInArray(this.playlist, trackId);
            return this.playlist[currentKey];
        };
        /**
         *
         * @param key
         */
        /**
         *
         * @param {?=} key
         * @return {?}
         */
        MusicPlayerService.prototype.getPlaylist = /**
         *
         * @param {?=} key
         * @return {?}
         */
        function (key) {
            if (typeof key === 'undefined') {
                return this.playlist;
            }
            else {
                return this.playlist[key];
            }
        };
        /**
         *
         * @param track
         */
        /**
         *
         * @param {?} track
         * @return {?}
         */
        MusicPlayerService.prototype.addToPlaylist = /**
         *
         * @param {?} track
         * @return {?}
         */
        function (track) {
            this.playlist.push(track);
            // broadcast playlist
            this.musicPlayerEventEmitter.emit({
                event: MusicPlayerEventConstants.PLAYER_PLAYLIST,
                data: this.playlist
            });
        };
        /**
         *
         * @param track
         */
        /**
         *
         * @param {?} track
         * @return {?}
         */
        MusicPlayerService.prototype.addTrack = /**
         *
         * @param {?} track
         * @return {?}
         */
        function (track) {
            // check if track itself is valid and if its url is playable
            if (!MusicPlayerUtils.IsTrackValid) {
                return null;
            }
            // check if song already does not exists then add to playlist
            var /** @type {?} */ inArrayKey = MusicPlayerUtils.IsInArray(this.getPlaylist(undefined), track.id);
            if (inArrayKey < 0) {
                // console.warn('song does not exists in playlist:', track);
                // add to sound manager
                soundManager.createSound({
                    id: track.id,
                    url: track.url
                });
                // add to playlist
                this.addToPlaylist(track);
            }
            return track.id;
        };
        /**
         * @param {?} song
         * @param {?} index
         * @return {?}
         */
        MusicPlayerService.prototype.removeSong = /**
         * @param {?} song
         * @param {?} index
         * @return {?}
         */
        function (song, index) {
            // if this song is playing stop it
            if (song === this.currentTrack) {
                this.stop();
            }
            // unload from soundManager
            soundManager.destroySound(song);
            // remove from playlist
            this.playlist.splice(index, 1);
            // once all done then broadcast
            this.musicPlayerEventEmitter.emit({
                event: MusicPlayerEventConstants.PLAYER_PLAYLIST,
                data: this.playlist
            });
        };
        /**
         *
         * @param trackId
         * @param isResume
         */
        /**
         *
         * @param {?} trackId
         * @param {?} isResume
         * @return {?}
         */
        MusicPlayerService.prototype.initPlayTrack = /**
         *
         * @param {?} trackId
         * @param {?} isResume
         * @return {?}
         */
        function (trackId, isResume) {
            if (isResume !== true) {
                // stop and unload currently playing track
                this.stop();
                // set new track as current track
                this.setCurrentTrack(trackId);
            }
            // play it
            soundManager.play(trackId);
            var /** @type {?} */ trackEventData = {
                trackId: this.currentTrack,
                trackProgress: this.trackProgress,
                trackDuration: this.duration,
                trackPosition: 0
            };
            this.musicPlayerTrackEventEmitter.emit({
                event: MusicPlayerEventConstants.TRACK_ID,
                data: trackEventData
            });
            // set as playing
            this.isPlaying = true;
            this.musicPlayerEventEmitter.emit({
                event: MusicPlayerEventConstants.MUSIC_IS_PLAYING,
                data: this.isPlaying
            });
        };
        /**
         * Plays currently selected track
         * If the track is already playing, ignore event
         */
        /**
         * Plays currently selected track
         * If the track is already playing, ignore event
         * @return {?}
         */
        MusicPlayerService.prototype.play = /**
         * Plays currently selected track
         * If the track is already playing, ignore event
         * @return {?}
         */
        function () {
            if (!this.isPlaying) {
                var /** @type {?} */ trackToPlay = null;
                // check if no track loaded, else play loaded track
                if (this.getCurrentTrack() === null) {
                    if (soundManager.soundIDs.length === 0) {
                        return;
                    }
                    trackToPlay = soundManager.soundIDs[0];
                    this.initPlayTrack(trackToPlay, false);
                }
                else {
                    trackToPlay = this.getCurrentTrack();
                    this.initPlayTrack(trackToPlay, true);
                }
            }
        };
        /**
         * Toggles Pause state
         */
        /**
         * Toggles Pause state
         * @return {?}
         */
        MusicPlayerService.prototype.pause = /**
         * Toggles Pause state
         * @return {?}
         */
        function () {
            this.isPlaying = !this.isPlaying;
            if (this.isPlaying) {
                soundManager.play(this.currentTrack);
            }
            else {
                soundManager.pause(this.getCurrentTrack());
            }
            this.musicPlayerEventEmitter.emit({
                event: MusicPlayerEventConstants.MUSIC_IS_PLAYING,
                data: this.isPlaying
            });
        };
        /**
         * Stops audio playback and clears playback status
         */
        /**
         * Stops audio playback and clears playback status
         * @return {?}
         */
        MusicPlayerService.prototype.stop = /**
         * Stops audio playback and clears playback status
         * @return {?}
         */
        function () {
            // first pause it
            soundManager.pause(this.getCurrentTrack());
            this.isPlaying = false;
            this.resetProgress();
            var /** @type {?} */ trackEventData = {
                trackId: this.currentTrack,
                trackProgress: this.trackProgress,
                trackDuration: 0,
                trackPosition: 0
            };
            this.musicPlayerStopEventEmitter.emit({
                event: MusicPlayerEventConstants.TRACK_STOP,
                data: trackEventData
            });
            soundManager.stopAll();
            soundManager.unload(this.getCurrentTrack());
        };
        /**
         * Plays selected track
         * @param trackId
         */
        /**
         * Plays selected track
         * @param {?} trackId
         * @return {?}
         */
        MusicPlayerService.prototype.playTrack = /**
         * Plays selected track
         * @param {?} trackId
         * @return {?}
         */
        function (trackId) {
            this.initPlayTrack(trackId, false);
        };
        /**
         *
         */
        /**
         *
         * @return {?}
         */
        MusicPlayerService.prototype.nextTrack = /**
         *
         * @return {?}
         */
        function () {
            if (this.getCurrentTrack() === null) {
                console.log('Please click on Play before this action');
                return null;
            }
            var /** @type {?} */ currentTrackKey = MusicPlayerUtils.GetIndexByValue(soundManager.soundIDs, this.getCurrentTrack());
            var /** @type {?} */ nextTrackKey = +currentTrackKey + 1;
            var /** @type {?} */ nextTrack = soundManager.soundIDs[nextTrackKey];
            if (typeof nextTrack !== 'undefined') {
                this.playTrack(nextTrack);
            }
            else {
                // if no next track found
                if (this.repeat === true) {
                    // start first track if repeat is on
                    this.playTrack(soundManager.soundIDs[0]);
                }
                else {
                    // breadcase not playing anything
                    this.isPlaying = false;
                    this.musicPlayerEventEmitter.emit({
                        event: MusicPlayerEventConstants.MUSIC_IS_PLAYING,
                        data: this.isPlaying
                    });
                }
            }
        };
        /**
         *
         */
        /**
         *
         * @return {?}
         */
        MusicPlayerService.prototype.prevTrack = /**
         *
         * @return {?}
         */
        function () {
            if (this.getCurrentTrack() === null) {
                console.log('Please click on Play before this action');
                return null;
            }
            var /** @type {?} */ currentTrackKey = MusicPlayerUtils.GetIndexByValue(soundManager.soundIDs, this.getCurrentTrack());
            var /** @type {?} */ prevTrackKey = +currentTrackKey - 1;
            var /** @type {?} */ prevTrack = soundManager.soundIDs[prevTrackKey];
            if (typeof prevTrack !== 'undefined') {
                this.playTrack(prevTrack);
            }
            else {
                console.warn('no prev track found!');
            }
        };
        /**
         *  Mute/Unmute audio
         */
        /**
         *  Mute/Unmute audio
         * @return {?}
         */
        MusicPlayerService.prototype.mute = /**
         *  Mute/Unmute audio
         * @return {?}
         */
        function () {
            if (soundManager.muted === true) {
                soundManager.unmute();
            }
            else {
                soundManager.mute();
            }
            this.musicPlayerMuteEventEmitter.emit({
                event: MusicPlayerEventConstants.MUSIC_MUTE,
                data: soundManager.muted
            });
        };
        /**
         * Mute Accessor
         */
        /**
         * Mute Accessor
         * @return {?}
         */
        MusicPlayerService.prototype.getMuteStatus = /**
         * Mute Accessor
         * @return {?}
         */
        function () {
            return soundManager.muted;
        };
        /**
         *
         */
        /**
         *
         * @return {?}
         */
        MusicPlayerService.prototype.repeatToggle = /**
         *
         * @return {?}
         */
        function () {
            if (this.repeat === true) {
                this.repeat = false;
            }
            else {
                this.repeat = true;
            }
            this.musicPlayerRepeatEventEmitter.emit({
                event: MusicPlayerEventConstants.MUSIC_REPEAT,
                data: this.repeat
            });
            return false;
        };
        /**
         * @return {?}
         */
        MusicPlayerService.prototype.getRepeatStatus = /**
         * @return {?}
         */
        function () {
            return this.repeat;
        };
        /**
         * @return {?}
         */
        MusicPlayerService.prototype.getVolume = /**
         * @return {?}
         */
        function () {
            return this.volume;
        };
        /**
         *
         * @param increase
         */
        /**
         *
         * @param {?} increase
         * @return {?}
         */
        MusicPlayerService.prototype.adjustVolume = /**
         *
         * @param {?} increase
         * @return {?}
         */
        function (increase) {
            var _this = this;
            var /** @type {?} */ changeVolume = function (volume) {
                for (var /** @type {?} */ i = 0; i < soundManager.soundIDs.length; i++) {
                    var /** @type {?} */ mySound = soundManager.getSoundById(soundManager.soundIDs[i]);
                    mySound.setVolume(volume);
                }
                _this.musicPlayerVolumeEventEmitter.emit({
                    event: MusicPlayerEventConstants.MUSIC_VOLUME,
                    data: volume
                });
            };
            if (increase === true) {
                if (this.volume < 100) {
                    this.volume = this.volume + 10;
                    changeVolume(this.volume);
                }
            }
            else {
                if (this.volume > 0) {
                    this.volume = this.volume - 10;
                    changeVolume(this.volume);
                }
            }
        };
        /**
         *
         * @param value
         */
        /**
         *
         * @param {?} value
         * @return {?}
         */
        MusicPlayerService.prototype.adjustVolumeSlider = /**
         *
         * @param {?} value
         * @return {?}
         */
        function (value) {
            var _this = this;
            var /** @type {?} */ changeVolume = function (volume) {
                for (var /** @type {?} */ i = 0; i < soundManager.soundIDs.length; i++) {
                    var /** @type {?} */ mySound = soundManager.getSoundById(soundManager.soundIDs[i]);
                    mySound.setVolume(volume);
                }
                _this.musicPlayerVolumeEventEmitter.emit({
                    event: MusicPlayerEventConstants.MUSIC_VOLUME,
                    data: volume
                });
            };
            changeVolume(value);
        };
        /**
         *
         * @param callback
         */
        /**
         *
         * @param {?=} callback
         * @return {?}
         */
        MusicPlayerService.prototype.clearPlaylist = /**
         *
         * @param {?=} callback
         * @return {?}
         */
        function (callback) {
            var _this = this;
            this.isPlaying = false;
            this.currentTrack = null;
            this.resetProgress();
            // unload and destroy soundmanager sounds
            var /** @type {?} */ smIdsLength = soundManager.soundIDs.length;
            MusicPlayerUtils.AsyncLoop({
                length: smIdsLength,
                functionToLoop: function (loop /*, i: number*/) {
                    setTimeout(function () {
                        // custom code
                        soundManager.destroySound(soundManager.soundIDs[0]);
                        // custom code
                        loop();
                    }, 0);
                },
                callback: function () {
                    // callback custom code
                    // clear playlist
                    // callback custom code
                    // clear playlist
                    _this.playlist = [];
                    _this.musicPlayerEventEmitter.emit({
                        event: MusicPlayerEventConstants.PLAYER_PLAYLIST,
                        data: _this.playlist
                    });
                    if (callback) {
                        // callback custom code
                        callback(true);
                    }
                }
            });
        };
        /**
         *
         */
        /**
         *
         * @return {?}
         */
        MusicPlayerService.prototype.resetProgress = /**
         *
         * @return {?}
         */
        function () {
            this.trackProgress = 0;
        };
        /**
         * @return {?}
         */
        MusicPlayerService.prototype.isPlayingStatus = /**
         * @return {?}
         */
        function () {
            return this.isPlaying;
        };
        MusicPlayerService.decorators = [
            { type: core.Injectable }
        ];
        /** @nocollapse */
        MusicPlayerService.ctorParameters = function () { return [
            { type: Object, decorators: [{ type: core.Inject, args: ['setupOptions',] }, { type: core.Optional },] },
        ]; };
        return MusicPlayerService;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var ClearPlaylistDirective = /** @class */ (function () {
        function ClearPlaylistDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        ClearPlaylistDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.stop();
            this._musicPlayerService.setCurrentTrack(null);
            this._musicPlayerService.clearPlaylist();
        };
        ClearPlaylistDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[clearPlaylist]'
                    },] }
        ];
        /** @nocollapse */
        ClearPlaylistDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        ClearPlaylistDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return ClearPlaylistDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var DecreaseVolumeDirective = /** @class */ (function () {
        function DecreaseVolumeDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        DecreaseVolumeDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.adjustVolume(false);
        };
        DecreaseVolumeDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[decreaseVolume]'
                    },] }
        ];
        /** @nocollapse */
        DecreaseVolumeDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        DecreaseVolumeDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return DecreaseVolumeDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var IncreaseVolumeDirective = /** @class */ (function () {
        function IncreaseVolumeDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        IncreaseVolumeDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.adjustVolume(true);
        };
        IncreaseVolumeDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[increaseVolume]'
                    },] }
        ];
        /** @nocollapse */
        IncreaseVolumeDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        IncreaseVolumeDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return IncreaseVolumeDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var MusicPlayerDirective = /** @class */ (function () {
        function MusicPlayerDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        MusicPlayerDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            var /** @type {?} */ trackId;
            if (this.song) {
                trackId = this._musicPlayerService.addTrack(this.song);
                if (this.musicPlayer === 'play') {
                    this._musicPlayerService.playTrack(trackId);
                }
            }
        };
        MusicPlayerDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[musicPlayer]'
                    },] }
        ];
        /** @nocollapse */
        MusicPlayerDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        MusicPlayerDirective.propDecorators = {
            "musicPlayer": [{ type: core.Input },],
            "song": [{ type: core.Input },],
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return MusicPlayerDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var MuteMusicDirective = /** @class */ (function () {
        function MuteMusicDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        MuteMusicDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.mute();
        };
        MuteMusicDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[muteMusic]'
                    },] }
        ];
        /** @nocollapse */
        MuteMusicDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        MuteMusicDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return MuteMusicDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var NextTrackDirective = /** @class */ (function () {
        function NextTrackDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        NextTrackDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.nextTrack();
        };
        NextTrackDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[nextTrack]'
                    },] }
        ];
        /** @nocollapse */
        NextTrackDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        NextTrackDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return NextTrackDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var PauseMusicDirective = /** @class */ (function () {
        function PauseMusicDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        PauseMusicDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.pause();
        };
        PauseMusicDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[pauseMusic]'
                    },] }
        ];
        /** @nocollapse */
        PauseMusicDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        PauseMusicDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return PauseMusicDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var PlayAllDirective = /** @class */ (function () {
        function PlayAllDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
            this.play = true;
        }
        /**
         * @return {?}
         */
        PlayAllDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            var _this = this;
            this._musicPlayerService.clearPlaylist(function () {
                for (var /** @type {?} */ i = 0; i < _this.songs.length; i++) {
                    _this._musicPlayerService.addTrack(_this.songs[i]);
                }
                if (_this.play) {
                    // play first song
                    // play first song
                    _this._musicPlayerService.play();
                }
            });
        };
        PlayAllDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[playAll]'
                    },] }
        ];
        /** @nocollapse */
        PlayAllDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        PlayAllDirective.propDecorators = {
            "songs": [{ type: core.Input },],
            "play": [{ type: core.Input },],
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return PlayAllDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var PlayFromPlaylistDirective = /** @class */ (function () {
        function PlayFromPlaylistDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        PlayFromPlaylistDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.playTrack(this.song.id);
        };
        PlayFromPlaylistDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[playFromPlaylist]'
                    },] }
        ];
        /** @nocollapse */
        PlayFromPlaylistDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        PlayFromPlaylistDirective.propDecorators = {
            "song": [{ type: core.Input },],
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return PlayFromPlaylistDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var PlayMusicDirective = /** @class */ (function () {
        function PlayMusicDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        PlayMusicDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.play();
        };
        PlayMusicDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[playMusic]'
                    },] }
        ];
        /** @nocollapse */
        PlayMusicDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        PlayMusicDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return PlayMusicDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var PreviousTrackDirective = /** @class */ (function () {
        function PreviousTrackDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        PreviousTrackDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.prevTrack();
        };
        PreviousTrackDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[previousTrack]'
                    },] }
        ];
        /** @nocollapse */
        PreviousTrackDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        PreviousTrackDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return PreviousTrackDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var RemoveFromPlaylistDirective = /** @class */ (function () {
        function RemoveFromPlaylistDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        RemoveFromPlaylistDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            console.log('remove:', this.index);
            this._musicPlayerService.removeSong(this.song.id, this.index);
        };
        RemoveFromPlaylistDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[removeFromPlaylist]'
                    },] }
        ];
        /** @nocollapse */
        RemoveFromPlaylistDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        RemoveFromPlaylistDirective.propDecorators = {
            "song": [{ type: core.Input },],
            "index": [{ type: core.Input },],
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return RemoveFromPlaylistDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var RepeatMusicDirective = /** @class */ (function () {
        function RepeatMusicDirective(_musicPlayerService, _element) {
            this._musicPlayerService = _musicPlayerService;
            this._element = _element;
        }
        /**
         * @return {?}
         */
        RepeatMusicDirective.prototype.ngOnInit = /**
         * @return {?}
         */
        function () {
            var _this = this;
            this.repeat = this._musicPlayerService.getRepeatStatus();
            this.highlight();
            // Subscribe for repeat changes to update bindings
            this._musicPlayerRepeatSubscription = this._musicPlayerService.musicPlayerRepeatEventEmitter
                .subscribe(function (event) {
                _this.repeat = event.data;
                _this.highlight();
            });
        };
        /**
         * @return {?}
         */
        RepeatMusicDirective.prototype.ngOnDestroy = /**
         * @return {?}
         */
        function () {
            this._musicPlayerRepeatSubscription.unsubscribe();
        };
        /**
         * Element click event handler
         * @return {?}
         */
        RepeatMusicDirective.prototype.onClick = /**
         * Element click event handler
         * @return {?}
         */
        function () {
            this._musicPlayerService.repeatToggle();
        };
        /**
         * Change background color of element based on repeat state
         * @return {?}
         */
        RepeatMusicDirective.prototype.highlight = /**
         * Change background color of element based on repeat state
         * @return {?}
         */
        function () {
            this._element.nativeElement.style.backgroundColor = this.repeat ? 'green' : 'red';
        };
        RepeatMusicDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[repeatMusic]'
                    },] }
        ];
        /** @nocollapse */
        RepeatMusicDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
            { type: core.ElementRef, },
        ]; };
        RepeatMusicDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return RepeatMusicDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var StopMusicDirective = /** @class */ (function () {
        function StopMusicDirective(_musicPlayerService) {
            this._musicPlayerService = _musicPlayerService;
        }
        /**
         * @return {?}
         */
        StopMusicDirective.prototype.onClick = /**
         * @return {?}
         */
        function () {
            this._musicPlayerService.stop();
        };
        StopMusicDirective.decorators = [
            { type: core.Directive, args: [{
                        selector: '[stopMusic]'
                    },] }
        ];
        /** @nocollapse */
        StopMusicDirective.ctorParameters = function () { return [
            { type: MusicPlayerService, },
        ]; };
        StopMusicDirective.propDecorators = {
            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
        };
        return StopMusicDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var HumanTimePipe = /** @class */ (function () {
        function HumanTimePipe() {
        }
        /**
         * @param {?} value
         * @return {?}
         */
        HumanTimePipe.prototype.transform = /**
         * @param {?} value
         * @return {?}
         */
        function (value) {
            var /** @type {?} */ min = (value / 1000 / 60) << 0;
            var /** @type {?} */ sec = Math.round((value / 1000) % 60);
            return this.pad(min) + ':' + this.pad(sec);
        };
        /**
         * Pads string with zeros if less than 10
         * @param {?} d
         * @return {?}
         */
        HumanTimePipe.prototype.pad = /**
         * Pads string with zeros if less than 10
         * @param {?} d
         * @return {?}
         */
        function (d) {
            return (d < 10) ? '0' + d.toString() : d.toString();
        };
        HumanTimePipe.decorators = [
            { type: core.Pipe, args: [{ name: 'humanTime' },] }
        ];
        return HumanTimePipe;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes} checked by tsc
     */
    var NgxSoundmanager2Module = /** @class */ (function () {
        function NgxSoundmanager2Module() {
        }
        /**
         * @param {?=} setupOptions
         * @return {?}
         */
        NgxSoundmanager2Module.forRoot = /**
         * @param {?=} setupOptions
         * @return {?}
         */
        function (setupOptions) {
            return {
                ngModule: NgxSoundmanager2Module,
                providers: [
                    MusicPlayerService,
                    { provide: 'setupOptions', useValue: setupOptions }
                ]
            };
        };
        NgxSoundmanager2Module.decorators = [
            { type: core.NgModule, args: [{
                        declarations: [
                            ClearPlaylistDirective,
                            DecreaseVolumeDirective,
                            IncreaseVolumeDirective,
                            MusicPlayerDirective,
                            MuteMusicDirective,
                            NextTrackDirective,
                            PauseMusicDirective,
                            PlayAllDirective,
                            PlayFromPlaylistDirective,
                            PlayMusicDirective,
                            PreviousTrackDirective,
                            RemoveFromPlaylistDirective,
                            RepeatMusicDirective,
                            StopMusicDirective,
                            HumanTimePipe
                        ],
                        exports: [
                            ClearPlaylistDirective,
                            DecreaseVolumeDirective,
                            IncreaseVolumeDirective,
                            MusicPlayerDirective,
                            MuteMusicDirective,
                            NextTrackDirective,
                            PauseMusicDirective,
                            PlayAllDirective,
                            PlayFromPlaylistDirective,
                            PlayMusicDirective,
                            PreviousTrackDirective,
                            RemoveFromPlaylistDirective,
                            RepeatMusicDirective,
                            StopMusicDirective,
                            HumanTimePipe
                        ]
                    },] }
        ];
        /** @nocollapse */
        NgxSoundmanager2Module.ctorParameters = function () { return []; };
        return NgxSoundmanager2Module;
    }());

    exports.MusicPlayerEventConstants = MusicPlayerEventConstants;
    exports.ClearPlaylistDirective = ClearPlaylistDirective;
    exports.DecreaseVolumeDirective = DecreaseVolumeDirective;
    exports.IncreaseVolumeDirective = IncreaseVolumeDirective;
    exports.MusicPlayerDirective = MusicPlayerDirective;
    exports.MuteMusicDirective = MuteMusicDirective;
    exports.NextTrackDirective = NextTrackDirective;
    exports.PauseMusicDirective = PauseMusicDirective;
    exports.PlayAllDirective = PlayAllDirective;
    exports.PlayFromPlaylistDirective = PlayFromPlaylistDirective;
    exports.PlayMusicDirective = PlayMusicDirective;
    exports.PreviousTrackDirective = PreviousTrackDirective;
    exports.RemoveFromPlaylistDirective = RemoveFromPlaylistDirective;
    exports.RepeatMusicDirective = RepeatMusicDirective;
    exports.StopMusicDirective = StopMusicDirective;
    exports.NgxSoundmanager2Module = NgxSoundmanager2Module;
    exports.HumanTimePipe = HumanTimePipe;
    exports.MusicPlayerService = MusicPlayerService;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=ngx-soundmanager2.umd.js.map