https://www.stackradioapp.com/assets/playlist/dist/amplitude.js

1(function webpackUniversalModuleDefinition(root, factory) {
2	if(typeof exports === 'object' && typeof module === 'object')
3		module.exports = factory();
4	else if(typeof define === 'function' && define.amd)
5		define("Amplitude", [], factory);
6	else if(typeof exports === 'object')
7		exports["Amplitude"] = factory();
8	else
9		root["Amplitude"] = factory();
10})(this, function() {
11return /******/ (function(modules) { // webpackBootstrap
12/******/ 	// The module cache
13/******/ 	var installedModules = {};
14/******/
15/******/ 	// The require function
16/******/ 	function __webpack_require__(moduleId) {
17/******/
18/******/ 		// Check if module is in cache
19/******/ 		if(installedModules[moduleId]) {
20/******/ 			return installedModules[moduleId].exports;
21/******/ 		}
22/******/ 		// Create a new module (and put it into the cache)
23/******/ 		var module = installedModules[moduleId] = {
24/******/ 			i: moduleId,
25/******/ 			l: false,
26/******/ 			exports: {}
27/******/ 		};
28/******/
29/******/ 		// Execute the module function
30/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
31/******/
32/******/ 		// Flag the module as loaded
33/******/ 		module.l = true;
34/******/
35/******/ 		// Return the exports of the module
36/******/ 		return module.exports;
37/******/ 	}
38/******/
39/******/
40/******/ 	// expose the modules object (__webpack_modules__)
41/******/ 	__webpack_require__.m = modules;
42/******/
43/******/ 	// expose the module cache
44/******/ 	__webpack_require__.c = installedModules;
45/******/
46/******/ 	// identity function for calling harmony imports with the correct context
47/******/ 	__webpack_require__.i = function(value) { return value; };
48/******/
49/******/ 	// define getter function for harmony exports
50/******/ 	__webpack_require__.d = function(exports, name, getter) {
51/******/ 		if(!__webpack_require__.o(exports, name)) {
52/******/ 			Object.defineProperty(exports, name, {
53/******/ 				configurable: false,
54/******/ 				enumerable: true,
55/******/ 				get: getter
56/******/ 			});
57/******/ 		}
58/******/ 	};
59/******/
60/******/ 	// getDefaultExport function for compatibility with non-harmony modules
61/******/ 	__webpack_require__.n = function(module) {
62/******/ 		var getter = module && module.__esModule ?
63/******/ 			function getDefault() { return module['default']; } :
64/******/ 			function getModuleExports() { return module; };
65/******/ 		__webpack_require__.d(getter, 'a', getter);
66/******/ 		return getter;
67/******/ 	};
68/******/
69/******/ 	// Object.prototype.hasOwnProperty.call
70/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
71/******/
72/******/ 	// __webpack_public_path__
73/******/ 	__webpack_require__.p = "";
74/******/
75/******/ 	// Load entry module and return exports
76/******/ 	return __webpack_require__(__webpack_require__.s = 8);
77/******/ })
78/************************************************************************/
79/******/ ([
80/* 0 */
81/***/ (function(module, exports, __webpack_require__) {
82
83"use strict";
84
85
86/**
87 * These variables make Amplitude run. The config is the most important
88 * containing active settings and parameters.
89 *
90 * The config JSON is the global settings for ALL of Amplitude functions.
91 * This is global and contains all of the user preferences. The default
92 * settings are set, and the user overwrites them when they initialize
93 * Amplitude.
94 *
95 * @module config
96 * @type {object}
97 * @property {string}  	config.version          				- The current version of AmplitudeJS.
98 * @property {object} 	config.active_song 		 					-	Handles all of the audio.
99 * @property {object} 	config.active_metadata					- Contains the active metadata for the song.
100 * @property {string} 	config.active_album							- Holds the active album name. Used to check and see if the album changed and run the album changed callback.
101 * @property {number} 	config.active_index							- Contains the index of the actively playing song.
102 * @property {string} 	config.active_playlist					- Contains the key to the active playlist index.
103 * @property {boolean}

896			var playlist = songInfoElements[i].getAttribute('amplitude-playlist');
897
898			/*
899   	Get the main song info flag.
900   */
901			var main = songInfoElements[i].getAttribute('amplitude-main-song-info');
902
903			/*
904   	If the playlists match or the element is a main element, then
905   	we set the song info.
906   */
907			if (_config2.default.active_playlist == playlist || main == 'true') {
908				/*
909    	If the active metadata has the key, then we set it,
910    	otherwise we clear it. If it's an image element then
911    	we default it to the default info if needed.
912    */
913				if (_config2.default.active_metadata[info] != undefined) {
914					if (imageMetaDataKeys.indexOf(info) >= 0) {
915						songInfoElements[i].setAttribute('src', _config2.default.active_metadata[info]);
916					} else {
917						songInfoElements[i].innerHTML = _config2.default.active_metadata[info];
918					}
919				} else {
920					/*
921     	We look for the default album art because
922     	the actual key didn't exist. If the default album
923     	art doesn't exist then we set the src attribute
924     	to null.
925     */
926					if (imageMetaDataKeys.indexOf(info) >= 0) {
927						if (_config2.default.default_album_art != '') {
928							songInfoElements[i].setAttribute('src', _config2.default.default_album_art);
929						} else {
930							songInfoElements[i].setAttribute('src', '');
931						}
932					} else {
933						songInfoElements[i].innerHTML = '';
934					}
935				}
936			}
937		}
938	}
939
940	/**
941   * Sets the first song in the playlist. This is used to fill in the meta
942  * data in the playlist
943  *
944  * @param {object} song 			- The song we are setting to be the first song in the playlist
945  * @param {string} playlist 	- Key of the playlist we are setting the first song in
946  */
947	function setFirstSongInPlaylist(song, playlist) {
948		/*
949  	Define the image meta data keys. These are managed separately
950  	since we aren't actually changing the inner HTML of these elements.
951  */
952		var imageMetaDataKeys = ['cover_art_url', 'station_art_url', 'podcast_episode_cover_art_url'];
953
954		/*
955  	These are the ignored keys that we won't be worrying about displaying.
956  	Every other key in the song object can be displayed.
957  */
958		var ignoredKeys = ['url', 'live'];
959
960		/*
961  	Get all of the song info elements
962  */
963		var songInfoElements = document.querySelectorAll('[amplitude-song-info][amplitude-playlist="' + playlist + '"]');
964
965		/*
966  	Iterate over all of the song info elements. We will either
967  	set these to the new values, or clear them if the active song
968  	doesn't have the info set.
969  */
970		for (var i = 0; i < songInfoElements.length; i++) {
971			/*
972   	Get the info so we can check if the active meta data has the
973   	key.
974   */
975			var info = songInfoElements[i].getAttribute('amplitude-song-info');
976
977			/*
978   	Get the song info element playlist.
979   */
980			var elementPlaylist = songInfoElements[i].getAttribute('amplitude-playlist');
981
982			/*
983   	If the playlists match or the element is a main element, then
984   	we set the song info.
985   */
986			if (elementPlaylist == playlist) {
987				/*
988    	If the active metadata has the key, then we set it,
989    	otherwise we clear it. If it's an image element then
990    	we default it to the default info if needed.
991    */
992				if (song[info] != undefined) {
993					if (imageMetaDataKeys.indexOf(info) >= 0) {
994						songInfoElements[i].setAttribute('src', song[info]);
995					} else {
996						songInfoElements[i].innerHTML = song[info];
997					}
998				} else {
999					/*
1000     	We look for the default album art because
1001     	the actual key didn't exist. If the default album
1002     	art doesn't exist then we set the src attribute
1003     	to null.
1004     */
1005					if (imageMetaDataKeys.indexOf(info) >= 0) {
1006						if (song.default_album_art != '') {
1007							songInfoElements[i].setAttribute('src', song.default_album_art);
1008						} else {
1009							songInfoElements[i].setAttribute('src', '');
1010						}
1011					} else {
1012						songInfoElements[i].innerHTML = '';
1013					}
1014				}
1015			}
1016		}
1017	}
1018
1019	/**
1020  * Sets all of the visual playback speed buttons to have the right class
1021  * to display the background image that represents the current playback
1022  * speed.
1023  *
1024  * @access public
1025  */
1026	function syncPlaybackSpeed() {
1027		/*
1028  	Gets all of the playback speed classes.
1029  */
1030		var playbackSpeedClasses = document.getElementsByClassName("amplitude-playback-speed");
1031
1032		/*
1033  	Iterates over all of the playback speed classes
1034  	applying the right speed class for visual purposes.
1035  */
1036		for (var i = 0; i < playbackSpeedClasses.length; i++) {
1037			/*
1038   	Removes all of the old playback speed classes.
1039   */
1040			playbackSpeedClasses[i].classList.remove('amplitude-playback-speed-10');
1041			playbackSpeedClasses[i].classList.remove('amplitude-playback-speed-15');
1042			playbackSpeedClasses[i].classList.remove('amplitude-playback-speed-20');
1043
1044			/*
1045   	Switch the current playback speed and apply the appropriate
1046   	speed class.
1047   */
1048			switch (_config2.default.playback_speed) {
1049				case 1:
1050					playbackSpeedClasses[i].classList.add('amplitude-playback-speed-10');
1051					break;
1052				case 1.5:
1053					playbackSpeedClasses[i].classList.add('amplitude-playback-speed-15');
1054					break;
1055				case 2:
1056					playbackSpeedClasses[i].classList.add('amplitude-playback-speed-20');
1057					break;
1058			}
1059		}
1060	}
1061

1294	/**
1295  * Syncs repeat for all of the repeat buttons. Users
1296  * can apply styles to the 'amplitude-repeat-on' and
1297  * 'amplitude-repeat-off' classes. They represent the state
1298  * of the player.
1299  */
1300	function syncRepeat() {
1301		/*
1302  	Gets all of the repeat classes
1303  */
1304		var repeatClasses = document.getElementsByClassName("amplitude-repeat");
1305
1306		/*
1307  	Iterate over all of the repeat classes. If repeat is on,
1308  	then add the 'amplitude-repeat-on' class and remove the
1309  	'amplitude-repeat-off' class. If it's off, then do the
1310  	opposite.
1311  */
1312		for (var i = 0; i < repeatClasses.length; i++) {
1313			if (_config2.default.repeat) {
1314				repeatClasses[i].classList.add('amplitude-repeat-on');
1315				repeatClasses[i].classList.remove('amplitude-repeat-off');
1316			} else {
1317				repeatClasses[i].classList.remove('amplitude-repeat-on');
1318				repeatClasses[i].classList.add('amplitude-repeat-off');
1319			}
1320		}
1321	}
1322
1323	/**
1324  * Syncs repeat for all of the playlist repeat buttons. Users
1325  * can apply styles to the `amplitude-repeat-on` and `amplitude-repeat-off`
1326  * classes. They repreent the state of the playlist in the player.
1327  */
1328	function syncRepeatPlaylist(playlist) {
1329		/*
1330   Gets all of the repeat buttons.
1331  */
1332		var repeatButtons = document.getElementsByClassName("amplitude-repeat");
1333
1334		/*
1335   Iterate over all of the repeat buttons
1336  */
1337		for (var i = 0; i < repeatButtons.length; i++) {
1338			/*
1339    Ensure that the repeat button belongs to matches the
1340    playlist we are syncing the state for.
1341   */
1342			if (repeatButtons[i].getAttribute('amplitude-playlist') == playlist) {
1343				/*
1344     If the state of the playlist is shuffled on, true, then
1345     we add the 'amplitude-repeat-on' class and remove the
1346     'amplitude-repeat-off' class. If the player is not shuffled
1347     then we do the opposite.
1348    */
1349				if (_config2.default.repeat_statuses[playlist]) {
1350					repeatButtons[i].classList.add('amplitude-repeat-on');
1351					repeatButtons[i].classList.remove('amplitude-repeat-off');
1352				} else {
1353					repeatButtons[i].classList.add('amplitude-repeat-off');
1354					repeatButtons[i].classList.remove('amplitude-repeat-on');
1355				}
1356			}
1357		}
1358	}
1359
1360	/**
1361  * Syncs repeat for all of the repeat song buttons. Users
1362  * can apply styles to the 'amplitude-repeat-song-on' and
1363  * 'amplitude-repeat-song-off' classes. They represent the state
1364  * of the player.
1365  */
1366	function syncRepeatSong() {
1367		/*
1368  	Gets all of the repeat song classes
1369  */
1370		var repeatSongClasses = document.getElementsByClassName("amplitude-repeat-song");
1371
1372		/*
1373  	Iterate over all of the repeat song classes. If repeat is on,
1374  	then add the 'amplitude-repeat-song-on' class and remove the
1375  	'amplitude-repeat-song-off' class. If it's off, then do the
1376  	opposite.
1377  */
1378		for (var i = 0; i < repeatSongClasses.length; i++) {
1379			if (_config2.default.repeat_song) {
1380				repeatSongClasses[i].classList.add('amplitude-repeat-song-on');
1381				repeatSongClasses[i].classList.remove('amplitude-repeat-song-off');
1382			} else {
1383				repeatSongClasses[i].classList.remove('amplitude-repeat-song-on');
1384				repeatSongClasses[i].classList.add('amplitude-repeat-song-off');
1385			}
1386		}
1387	}
1388
1389	/**
1390  * Syncs mute for all of the mute buttons. This represents the
1391  * state of the player if it's muted or not.
1392  *
1393  * @access public
1394  * @param {string} state 	- The muted state of the player.
1395  */
1396	function syncMute(state) {
1397		/*
1398  	Get all of the mute buttons.
1399  */
1400		var muteClasses = document.getElementsByClassName("amplitude-mute");
1401
1402		/*
1403  	Iterate over all of the mute classes. If the state of the player
1404  	is not-muted then we add the amplitude-not-muted classe and remove
1405  	the amplitude muted class otherwise we do the opposite.
1406  */
1407		for (var i = 0; i < muteClasses.length; i++) {
1408			if (!state) {
1409				muteClasses[i].classList.add('amplitude-not-muted');
1410				muteClasses[i].classList.remove('amplitude-muted');
1411			} else {
1412				muteClasses[i].classList.remove('amplitude-not-muted');
1413				muteClasses[i].classList.add('amplitude-muted');
1414			}
1415		}
1416	}
1417
1418	/**
1419  * Syncs the global shuffle button visual state.
1420  *
1421  * @access public
1422  * @param {boolean} state  	- The shuffled state of the player.
1423  */
1424	function syncShuffle(state) {
1425		/*
1426  	Gets the shuffle buttons.
1427  */
1428		var shuffleButtons = document.getElementsByClassName("amplitude-shuffle");
1429
1430		/*
1431  	Iterate over all of the shuffle buttons.
1432  */
1433		for (var i = 0; i < shuffleButtons.length; i++) {
1434			/*
1435   	Ensure the shuffle button doesn't belong to a playlist. We have
1436   	a separate method for that.
1437   */
1438			if (shuffleButtons[i].getAttribute('amplitude-playlist') == null) {
1439				/*
1440    	If the state of the player is shuffled on, true, then
1441    	we add the 'amplitude-shuffle-on' class and remove the
1442    	'amplitude-shuffle-off' class. If the player is not shuffled
1443    	then we do the opposite.
1444    */
1445				if (state) {
1446					shuffleButtons[i].classList.add('amplitude-shuffle-on');
1447					shuffleButtons[i].classList.remove('amplitude-shuffle-off');
1448				} else {
1449					shuffleButtons[i].classList.add('amplitude-shuffle-off');
1450					shuffleButtons[i].classList.remove('amplitude-shuffle-on');
1451				}
1452			}
1453		}
1454	}
1455

1940		}
1941
1942		/*
1943  	Sets the volume in the config so we can reference it later on.
1944  */
1945		_config2.default.volume = volumeLevel;
1946
1947		/*
1948  	Set the volume of the active song.
1949  */
1950		_config2.default.active_song.volume = volumeLevel / 100;
1951	}
1952
1953	/**
1954  * Sets the song percentage. If it's a live song, we ignore this because
1955  * we can't skip ahead. This is an issue if you have a playlist with
1956  * a live source.
1957  *
1958  * Public Accessor: Amplitude.setSongLocation( songPercentage )
1959  *
1960  * @access public
1961  * @param {number} songPercentage - A number between 1 and 100 as a percentage of song completion.
1962  */
1963	function setSongLocation(songPercentage) {
1964		/*
1965  	As long as the song is not live, we can set the current time of the
1966  	song to the percentage the user passed in.
1967  */
1968		if (!_config2.default.active_metadata.live) {
1969			_config2.default.active_song.currentTime = _config2.default.active_song.duration * (song_percentage / 100);
1970		}
1971	}
1972
1973	/**
1974  * Skips to a location in a song
1975  *
1976  * Public Accessor: Amplitude.skipToLocation( seconds )
1977  *
1978  * @access public
1979  * @param {number} seconds - An integer containing the seconds to skip to
1980  */
1981	function skipToLocation(seconds) {
1982		/*
1983  	When the active song can be played through, we can check to
1984  	see if the seconds will work. We only bind the event handler
1985  	once and remove it once it's fired.
1986  */
1987		_config2.default.active_song.addEventListener('canplaythrough', function () {
1988			/*
1989   	If the active song duration is greater than or equal to the
1990   	amount of seconds the user wants to skip to and the seconds
1991   	is greater than 0, we skip to the seconds defined.
1992   */
1993			if (_config2.default.active_song.duration >= seconds && seconds > 0) {
1994				_config2.default.active_song.currentTime = seconds;
1995			} else {
1996				_helpers2.default.writeDebugMessage('Amplitude can\'t skip to a location greater than the duration of the audio or less than 0');
1997			}
1998		}, { once: true });
1999	}
2000
2001	/**
2002  * Disconnects the live stream
2003  *
2004  * Public Accessor: Amplitude.disconnectStream()
2005  *
2006  * @access public
2007  */
2008	function disconnectStream() {
2009		_config2.default.active_song.src = '';
2010		_config2.default.active_song.load();
2011	}
2012
2013	/**
2014  * Reconnects the live stream
2015  *
2016  * Public Accessor: Amplitude.reconnectStream()
2017  *
2018  * @access public\
2019  */
2020	function reconnectStream() {
2021		_config2.default.active_song.src = _config2.default.active_metadata.url;
2022		_config2.default.active_song.load();
2023	}
2024
2025	/**
2026  * When you pass a song object it plays that song right awawy.  It sets
2027  * the active song in the config to the song you pass in and synchronizes
2028  * the visuals.
2029  *
2030  * Public Accessor: Amplitude.playNow( song )
2031  *
2032  * @access public
2033  * @param {object} song - JSON representation of a song.
2034  */
2035	function playNow(song) {
2036		/*
2037  	Makes sure the song object has a URL associated with it
2038  	or there will be nothing to play.
2039  */
2040		if (song.url) {
2041			_config2.default.active_song.src = song.url;
2042			_config2.default.active_metadata = song;
2043			_config2.default.active_album = song.album;
2044		} else {
2045			/*
2046   	Write error message since the song passed in doesn't
2047   	have a URL.
2048   */
2049			_helpers2.default.writeDebugMessage('The song needs to have a URL!');
2050		}
2051
2052		/*
2053  	Sets the main song control status visual
2054  */
2055		_visual2.default.syncMainPlayPause('playing');
2056
2057		/*
2058  	Update the song meta data
2059  */
2060		_visual2.default.displaySongMetadata();
2061
2062		/*
2063  	Reset the song sliders, song progress bar info, and
2064  	reset times. This ensures everything stays in sync.
2065  */
2066		_visual2.default.resetSongSliders();
2067
2068		_visual2.default.resetSongPlayedProgressBars();
2069
2070		_visual2.default.resetTimes();
2071
2072		/*
2073  	Plays the song.
2074  */
2075		play();
2076	}
2077
2078	/**
2079  * Plays the song at a specific index in the songs array
2080  *
2081  * Public Accessor: Amplitude.playSongAtIndex( song )
2082  *
2083  * @access public
2084  * @param {number} index - The number representing the song in the songs array
2085  */
2086	function playSongAtIndex(index) {
2087		/*
2088  	Stop the current song.
2089  */
2090		stop();
2091
2092		/*
2093  	Determine if there is a new playlist, if so set the active playlist and change the song.
2094  */
2095		if (_helpers2.default.checkNewPlaylist(null)) {
2096			_helpers2.default.setActivePlaylist(null);
2097
2098			_helpers2.default.changeSong(index);
2099		}
2100
2101		/*
2102  	Check if the song is new. If so, change the song.
2103  */
2104		if (_helpers2.default.checkNewSong(index)) {
2105			_helpers2.default.changeSong(index);
2106		}
2107
2108		/*
2109   Sync all of the play pause buttons.
2110  */
2111		_visual2.default.syncMainPlayPause('playing');
2112		_visual2.default.syncPlaylistPlayPause(_config2.default.active_playlist, 'playing');
2113		_visual2.default.syncSongPlayPause(_config2.default.active_playlist, _config2.default.active_index, 'playing');
2114
2115		/*
2116   Play the song
2117  */
2118		play();
2119	}
2120
2121	/**
2122 * Plays a song at the index passed in for the playlist provided. The index passed
2123 * in should be the index of the song in the playlist and not the songs array.
2124 *
2125 * @access public
2126 * @param {number} index 		- The number representing the song in the playlist array.
2127 * @param {string} playlist 	- The key string representing the playlist we are playing the song from.
2128 *
2129 */
2130	function playPlaylistSongAtIndex(index, playlist) {
2131		/*
2132  		Stop the current song.
2133  */
2134		stop();
2135
2136		/*
2137  		Get the index of the song in the songs array. This is the integer at the index
2138  	in the playlist.
2139  */
2140		var songIndex = _config2.default.playlists[playlist][index];
2141
2142		/*
2143  		Determine if there is a new playlist, if so set the active playlist and change the song.
2144  */
2145		if (_helpers2.default.checkNewPlaylist(playlist)) {
2146			_helpers2.default.setActivePlaylist(playlist);
2147
2148			_helpers2.default.changeSong(songIndex);
2149		}
2150
2151		/*
2152  		Check if the song is new. If so, change the song.
2153  */
2154		if (_helpers2.default.checkNewSong(songIndex)) {
2155			_helpers2.default.changeSong(songIndex);
2156		}
2157
2158		/*
2159  	Sync all of the play pause buttons.
2160  */
2161		_visual2.default.syncMainPlayPause('playing');
2162		_visual2.default.syncPlaylistPlayPause(_config2.default.active_playlist, 'playing');
2163		_visual2.default.syncSongPlayPause(_config2.default.active_playlist, _config2.default.active_index, 'playing');
2164
2165		/*
2166  	Play the song
2167  */
2168		play();
2169	}
2170
2171	/**
2172  * Sets the playback speed for the song.
2173  *
2174  * @param {number} playbackSpeed The speed we want the song to play back at.
2175  */
2176	function setPlaybackSpeed(playbackSpeed) {
2177		/*
2178  	Set the config playback speed.
2179  */
2180		_config2.default.playback_speed = playbackSpeed;
2181
2182		/*
2183  	Set the active song playback rate.
2184  */
2185		_config2.default.active_song.playbackRate = _config2.default.playback_speed;
2186	}
2187
2188	/*
2189 	Return publically facing functions
2190 */
2191	return {
2192		play: play,
2193		pause: pause,
2194		stop: stop,
2195		setVolume: setVolume,
2196		setSongLocation: setSongLocation,
2197		skipToLocation: skipToLocation,
2198		disconnectStream: disconnectStream,
2199		reconnectStream: reconnectStream,
2200		playNow: playNow,
2201		playSongAtIndex: playSongAtIndex,
2202		playPlaylistSongAtIndex: playPlaylistSongAtIndex,
2203		setPlaybackSpeed: setPlaybackSpeed
2204	};
2205}();
2206
2207/**
2208 * AmplitudeJS Visual Sync
2209 * @module visual/visual
2210*/
2211/**
2212 * Imports the config module
2213 * @module config
2214 */
2215exports.default = AmplitudeCore;
2216module.exports = exports['default'];
2217
2218/***/ }),
2219/* 4 */
2220/***/ (function(module, exports, __webpack_require__) {
2221
2222"use strict";
2223
2224
2225Object.defineProperty(exports, "__esModule", {
2226	value: true
2227});
2228
2229var _config = __webpack_require__(0);
2230
2231var _config2 = _interopRequireDefault(_config);
2232
2233var _helpers = __webpack_require__(1);
2234
2235var _helpers2 = _interopRequireDefault(_helpers);
2236
2237var _handlers = __webpack_require__(7);
2238
2239var _handlers2 = _interopRequireDefault(_handlers);
2240
2241function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
2242
2243/*
2244|----------------------------------------------------------------------------------------------------
2245| EVENTS METHODS
2246|----------------------------------------------------------------------------------------------------
2247| These methods are called when we need to bind events to certain elements.
2248|
2249| METHODS:
2250| 	initializeEvents()
2251|	bindPlay()
2252|	bindPause()
2253|	bindPlayPause()
2254|	bindStop()
2255|	bindMute()
2256|	bindVolumeUp()
2257|	bindVolumeDown()
2258|	bindSongSlider()
2259|	bindVolumeSlider()
2260|	bindNext()
2261|	bindPrev()
2262|	bindShuffle()
2263|	bindRepeat()
2264|	bindPlaybackSpeed()
2265|	bindSkipTo()
2266|      bindProgress()
2267*/
2268var AmplitudeEvents = function () {
2269	/*--------------------------------------------------------------------------
2270 	Initializes the handlers for the events listened to by Amplitude
2271 --------------------------------------------------------------------------*/
2272	function initializeEvents() {
2273		/*
2274  	Write out debug message
2275  */
2276		_helpers2.default.writeDebugMessage('Beginning initialization of event handlers..');
2277
2278		/*
2279  	Sets flag that the screen is moving and not a tap
2280  */
2281		document.addEventListener('touchmove', function () {
2282			_config2.default.is_touch_moving = true;
2283		});
2284
2285		/*
2286  	On touch end if it was a touch move event, set moving to
2287  	false
2288  */
2289		document.addEventListener('touchend', function () {
2290			if (_config2.default.is_touch_moving) {
2291				_config2.default.is_touch_moving = false;
2292			}
2293		});
2294
2295		/*
2296  	On time update for the audio element, update visual displays that
2297  	represent the time on either a visualized element or time display.
2298  */
2299		bindTimeUpdate();
2300
2301		/*
2302  	Binds key down event handlers for matching key codes to functions.
2303  */
2304		bindKeyDownEventHandlers();
2305
2306		/*
2307  	When the audio element has ended playing, we handle the song
2308  	ending. In a single song or multiple modular song instance,
2309  	this just synchronizes the visuals for time and song time
2310  	visualization, but for a playlist it determines whether
2311  	it should play the next song or not.
2312  */
2313		bindSongEnded();
2314
2315		/*
2316  	Binds progress event so we can see how much of the song is loaded.
2317  */
2318		bindProgress();
2319
2320		/*
2321  	Binds 'amplitude-play' event handlers
2322  */
2323		bindPlay();
2324
2325		/*
2326  	Binds 'amplitude-pause' event handlers.
2327  */
2328		bindPause();
2329
2330		/*
2331  	Binds 'amplitude-play-pause' event handlers.
2332  */
2333		bindPlayPause();
2334
2335		/*
2336  	Binds 'amplitude-stop' event handlers.
2337  */
2338		bindStop();
2339
2340		/*
2341  	Binds 'amplitude-mute' event handlers.
2342  */
2343		bindMute();
2344
2345		/*
2346  	Binds 'amplitude-volume-up' event handlers
2347  */
2348		bindVolumeUp();
2349
2350		/*
2351  	Binds 'amplitude-volume-down' event handlers
2352  */
2353		bindVolumeDown();
2354
2355		/*
2356  	Binds 'amplitude-song-slider' event handlers
2357  */
2358		bindSongSlider();
2359
2360		/*
2361  	Binds 'amplitude-volume-slider' event handlers.
2362  */
2363		bindVolumeSlider();
2364
2365		/*
2366  	Binds 'amplitude-next' event handlers.
2367  */
2368		bindNext();
2369
2370		/*
2371  	Binds 'amplitude-prev' event handlers.
2372  */
2373		bindPrev();
2374
2375		/*
2376  	Binds 'amplitude-shuffle' event handlers.
2377  */
2378		bindShuffle();
2379
2380		/*
2381  	Binds 'amplitude-repeat' event handlers.
2382  */
2383		bindRepeat();
2384
2385		/*
2386  	Binds 'amplitude-playback-speed' event handlers.
2387  */
2388		bindPlaybackSpeed();
2389
2390		/*
2391  	Binds 'amplitude-skip-to' event handlers.
2392  */
2393		bindSkipTo();
2394	}
2395
2396	/*--------------------------------------------------------------------------
2397 	On time update for the audio element, update visual displays that
2398 		represent the time on either a visualized element or time display.
2399 --------------------------------------------------------------------------*/
2400	function bindTimeUpdate() {
2401		_config2.default.active_song.removeEventListener('timeupdate', _handlers2.default.updateTime);
2402		_config2.default.active_song.addEventListener('timeupdate', _handlers2.default.updateTime);
2403
2404		// also bind change of duratuion
2405		_config2.default.active_song.removeEventListener('durationchange', _handlers2.default.updateTime);
2406		_config2.default.active_song.addEventListener('durationchange', _handlers2.default.updateTime);
2407	}
2408
2409	/*--------------------------------------------------------------------------
2410 	On keydown, we listen to what key got pressed so we can map the key to
2411 	a function. This allows the user to map pause and play, next, etc. to key
2412 	presses.
2413 --------------------------------------------------------------------------*/
2414	function bindKeyDownEventHandlers() {
2415		document.removeEventListener("keydown", _helpers2.default.keydown);
2416		document.addEventListener("keydown", _handlers2.default.keydown);
2417	}
2418
2419	/*--------------------------------------------------------------------------
2420 	When the audio element has ended playing, we handle the song
2421 	ending. In a single song or multiple modular song instance,
2422 	this just synchronizes the visuals for time and song time
2423 	visualization, but for a playlist it determines whether
2424 	it should play the next song or not.
2425 --------------------------------------------------------------------------*/
2426	function bindSongEnded() {
2427		_config2.default.active_song.removeEventListener('ended', _handlers2.default.songEnded);
2428		_config2.default.active_song.addEventListener('ended', _handlers2.default.songEnded);
2429	}
2430
2431	/*--------------------------------------------------------------------------
2432 	As the audio is loaded, the progress event gets fired. We bind into this
2433 	to grab the buffered percentage of the song. We can then add more elements
2434 	to show the buffered amount.
2435 --------------------------------------------------------------------------*/
2436	function bindProgress() {
2437		_config2.default.active_song.removeEventListener('progress', _handlers2.default.progess);
2438		_config2.default.active_song.addEventListener('progress', _handlers2.default.progress);
2439	}
2440
2441	/*--------------------------------------------------------------------------
2442 	BINDS: class="amplitude-play"
2443 		Binds click and touchend events for amplitude play buttons.
2444 --------------------------------------------------------------------------*/
2445	function bindPlay() {
2446		/*
2447  	Gets all of the elements with the class amplitude-play
2448  */
2449		var play_classes = document.getElementsByClassName("amplitude-play");
2450
2451		/*
2452  	Iterates over all of the play classes and binds the event interaction
2453  	method to the element. If the browser is mobile, then the event is touchend
2454  	otherwise it is click.
2455  */
2456		for (var i = 0; i < play_classes.length; i++) {
2457			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2458				play_classes[i].removeEventListener('touchend', _handlers2.default.play);
2459				play_classes[i].addEventListener('touchend', _handlers2.default.play);
2460			} else {
2461				play_classes[i].removeEventListener('click', _handlers2.default.play);
2462				play_classes[i].addEventListener('click', _handlers2.default.play);
2463			}
2464		}
2465	}
2466
2467	/*--------------------------------------------------------------------------
2468 	BINDS: class="amplitude-pause"
2469 		Binds click and touchend events for amplitude pause buttons.
2470 --------------------------------------------------------------------------*/
2471	function bindPause() {
2472		/*
2473  	Gets all of the elements with the class amplitude-pause
2474  */
2475		var pause_classes = document.getElementsByClassName("amplitude-pause");
2476
2477		/*
2478  	Iterates over all of the pause classes and binds the event interaction
2479  	method to the element. If the browser is mobile, then the event is touchend
2480  	otherwise it is click.
2481  */
2482		for (var i = 0; i < pause_classes.length; i++) {
2483			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2484				pause_classes[i].removeEventListener('touchend', _handlers2.default.pause);
2485				pause_classes[i].addEventListener('touchend', _handlers2.default.pause);
2486			} else {
2487				pause_classes[i].removeEventListener('click', _handlers2.default.pause);
2488				pause_classes[i].addEventListener('click', _handlers2.default.pause);
2489			}
2490		}
2491	}
2492
2493	/*--------------------------------------------------------------------------
2494 	BINDS: class="amplitude-play-pause"
2495 		Binds click and touchend events for amplitude play pause buttons.
2496 --------------------------------------------------------------------------*/
2497	function bindPlayPause() {
2498		/*
2499  	Gets all of the elements with the class amplitude-play-pause
2500  */
2501		var play_pause_classes = document.getElementsByClassName("amplitude-play-pause");
2502
2503		/*
2504  	Iterates over all of the play/pause classes and binds the event interaction
2505  	method to the element. If the browser is mobile, then the event is touchend
2506  	otherwise it is click.
2507  */
2508		for (var i = 0; i < play_pause_classes.length; i++) {
2509			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2510				play_pause_classes[i].removeEventListener('touchend', _handlers2.default.playPause);
2511				play_pause_classes[i].addEventListener('touchend', _handlers2.default.playPause);
2512			} else {
2513				play_pause_classes[i].removeEventListener('click', _handlers2.default.playPause);
2514				play_pause_classes[i].addEventListener('click', _handlers2.default.playPause);
2515			}
2516		}
2517	}
2518
2519	/*--------------------------------------------------------------------------
2520 	BINDS: class="amplitude-stop"
2521 		Binds click and touchend events for amplitude stop buttons
2522 --------------------------------------------------------------------------*/
2523	function bindStop() {
2524		/*
2525  	Gets all of the elements with the class amplitude-stop
2526  */
2527		var stop_classes = document.getElementsByClassName("amplitude-stop");
2528
2529		/*
2530  	Iterates over all of the stop classes and binds the event interaction
2531  	method to the element.  If the browser is mobile, then the event is touchend
2532  	otherwise it is click.
2533  */
2534		for (var i = 0; i < stop_classes.length; i++) {
2535			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2536				stop_classes[i].removeEventListener('touchend', _handlers2.default.stop);
2537				stop_classes[i].addEventListener('touchend', _handlers2.default.stop);
2538			} else {
2539				stop_classes[i].removeEventListener('click', _handlers2.default.stop);
2540				stop_classes[i].addEventListener('click', _handlers2.default.stop);
2541			}
2542		}
2543	}
2544
2545	/*--------------------------------------------------------------------------
2546 	BINDS: class="amplitude-mute"
2547 		Binds click and touchend events for amplitude mute buttons
2548 --------------------------------------------------------------------------*/
2549	function bindMute() {
2550		/*
2551  	Gets all of the elements with the class amplitue-mute
2552  */
2553		var mute_classes = document.getElementsByClassName("amplitude-mute");
2554
2555		/*
2556  	Iterates over all of the mute classes and binds the event interaction
2557  	method to the element. If the browser is mobile, then the event is touchend
2558  	otherwise it is click.
2559  */
2560		for (var i = 0; i < mute_classes.length; i++) {
2561			/*
2562   	WARNING: If iOS, we don't do anything because iOS does not allow the
2563   	volume to be adjusted through anything except the buttons on the side of
2564   	the device.
2565   */
2566			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2567				/*
2568    	Checks for an iOS device and displays an error message if debugging
2569    	is turned on.
2570    */
2571				if (/iPhone|iPad|iPod/i.test(navigator.userAgent)) {
2572					_helpers2.default.writeDebugMessage('iOS does NOT allow volume to be set through javascript: https://developer.apple.com/library/safari/documentation/AudioVideo/Conceptual/Using_HTML5_Audio_Video/Device-SpecificConsiderations/Device-SpecificConsiderations.html#//apple_ref/doc/uid/TP40009523-CH5-SW4');
2573				} else {
2574					mute_classes[i].removeEventListener('touchend', _handlers2.default.mute);
2575					mute_classes[i].addEventListener('touchend', _handlers2.default.mute);
2576				}
2577			} else {
2578				mute_classes[i].removeEventListener('click', _handlers2.default.mute);
2579				mute_classes[i].addEventListener('click', _handlers2.default.mute);
2580			}
2581		}
2582	}
2583
2584	/*--------------------------------------------------------------------------
2585 	BINDS: class="amplitude-volume-up"
2586 		Binds click and touchend events for amplitude volume up buttons
2587 --------------------------------------------------------------------------*/
2588	function bindVolumeUp() {
2589		/*
2590  	Gets all of the elements with the class amplitude-volume-up
2591  */
2592		var volume_up_classes = document.getElementsByClassName("amplitude-volume-up");
2593
2594		/*
2595  	Iterates over all of the volume up classes and binds the event interaction
2596  	methods to the element. If the browser is mobile, then the event is touchend
2597  	otherwise it is click.
2598  */
2599		for (var i = 0; i < volume_up_classes.length; i++) {
2600			/*
2601   	WARNING: If iOS, we don't do anything because iOS does not allow the
2602   	volume to be adjusted through anything except the buttons on the side of
2603   	the device.
2604   */
2605			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2606				/*
2607    	Checks for an iOS device and displays an error message if debugging
2608    	is turned on.
2609    */
2610				if (/iPhone|iPad|iPod/i.test(navigator.userAgent)) {
2611					_helpers2.default.writeDebugMessage('iOS does NOT allow volume to be set through javascript: https://developer.apple.com/library/safari/documentation/AudioVideo/Conceptual/Using_HTML5_Audio_Video/Device-SpecificConsiderations/Device-SpecificConsiderations.html#//apple_ref/doc/uid/TP40009523-CH5-SW4');
2612				} else {
2613					volume_up_classes[i].removeEventListener('touchend', _handlers2.default.volumeUp);
2614					volume_up_classes[i].addEventListener('touchend', _handlers2.default.volumeUp);
2615				}
2616			} else {
2617				volume_up_classes[i].removeEventListener('click', _handlers2.default.volumeUp);
2618				volume_up_classes[i].addEventListener('click', _handlers2.default.volumeUp);
2619			}
2620		}
2621	}
2622
2623	/*--------------------------------------------------------------------------
2624 	BINDS: class="amplitude-volume-down"
2625 		Binds click and touchend events for amplitude volume down buttons
2626 --------------------------------------------------------------------------*/
2627	function bindVolumeDown() {
2628		/*
2629  	Gets all of the elements with the class amplitude-volume-down
2630  */
2631		var volume_down_classes = document.getElementsByClassName("amplitude-volume-down");
2632
2633		/*
2634  	Iterates over all of the volume down classes and binds the event interaction
2635  	methods to the element. If the browser is mobile, then the event is touchend
2636  	otherwise it is click.
2637  */
2638		for (var i = 0; i < volume_down_classes.length; i++) {
2639			/*
2640   	WARNING: If iOS, we don't do anything because iOS does not allow the
2641   	volume to be adjusted through anything except the buttons on the side of
2642   	the device.
2643   */
2644			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2645				/*
2646    	Checks for an iOS device and displays an error message if debugging
2647    	is turned on.
2648    */
2649				if (/iPhone|iPad|iPod/i.test(navigator.userAgent)) {
2650					_helpers2.default.writeDebugMessage('iOS does NOT allow volume to be set through javascript: https://developer.apple.com/library/safari/documentation/AudioVideo/Conceptual/Using_HTML5_Audio_Video/Device-SpecificConsiderations/Device-SpecificConsiderations.html#//apple_ref/doc/uid/TP40009523-CH5-SW4');
2651				} else {
2652					volume_down_classes[i].removeEventListener('touchend', _handlers2.default.volumeDown);
2653					volume_down_classes[i].addEventListener('touchend', _handlers2.default.volumeDown);
2654				}
2655			} else {
2656				volume_down_classes[i].removeEventListener('click', _handlers2.default.volumeDown);
2657				volume_down_classes[i].addEventListener('click', _handlers2.default.volumeDown);
2658			}
2659		}
2660	}
2661
2662	/*--------------------------------------------------------------------------
2663 	BINDS: class="amplitude-song-slider"
2664 		Binds change and input events for amplitude song slider inputs
2665 --------------------------------------------------------------------------*/
2666	function bindSongSlider() {
2667		/*
2668  	Gets browser so if we need to apply overrides, like we usually
2669  	have to do for anything cool in IE, we can do that.
2670  */
2671		var ua = window.navigator.userAgent;
2672		var msie = ua.indexOf("MSIE ");
2673
2674		/*
2675  	Gets all of the elements with the class amplitude-song-slider
2676  */
2677		var song_sliders = document.getElementsByClassName("amplitude-song-slider");
2678
2679		/*
2680  	Iterates over all of the song slider classes and binds the event interaction
2681  	methods to the element. If the browser is IE we listen to the change event
2682  	where if it is anything else, it's the input method.
2683  */
2684		for (var i = 0; i < song_sliders.length; i++) {
2685			if (msie > 0 || !!navigator.userAgent.match(/Trident.*rv\:11\./)) {
2686				song_sliders[i].removeEventListener('change', _handlers2.default.songSlider);
2687				song_sliders[i].addEventListener('change', _handlers2.default.songSlider);
2688			} else {
2689				song_sliders[i].removeEventListener('input', _handlers2.default.songSlider);
2690				song_sliders[i].addEventListener('input', _handlers2.default.songSlider);
2691			}
2692		}
2693	}
2694
2695	/*--------------------------------------------------------------------------
2696 	BINDS: class="amplitude-volume-slider"
2697 		Binds change and input events for amplitude volume slider inputs
2698 --------------------------------------------------------------------------*/
2699	function bindVolumeSlider() {
2700		/*
2701  	Gets browser so if we need to apply overrides, like we usually
2702  	have to do for anything cool in IE, we can do that.
2703  */
2704		var ua = window.navigator.userAgent;
2705		var msie = ua.indexOf("MSIE ");
2706
2707		/*
2708  Gets all of the elements with the class amplitude-volume-slider
2709  */
2710		var volume_sliders = document.getElementsByClassName("amplitude-volume-slider");
2711
2712		/*
2713  	Iterates over all of the volume slider classes and binds the event interaction
2714  	methods to the element. If the browser is IE we listen to the change event
2715  	where if it is anything else, it's the input method.
2716  */
2717		for (var i = 0; i < volume_sliders.length; i++) {
2718			/*
2719   	WARNING: If iOS, we don't do anything because iOS does not allow the
2720   	volume to be adjusted through anything except the buttons on the side of
2721   	the device.
2722   */
2723			if (/iPhone|iPad|iPod/i.test(navigator.userAgent)) {
2724				_helpers2.default.writeDebugMessage('iOS does NOT allow volume to be set through javascript: https://developer.apple.com/library/safari/documentation/AudioVideo/Conceptual/Using_HTML5_Audio_Video/Device-SpecificConsiderations/Device-SpecificConsiderations.html#//apple_ref/doc/uid/TP40009523-CH5-SW4');
2725			} else {
2726				if (msie > 0 || !!navigator.userAgent.match(/Trident.*rv\:11\./)) {
2727					volume_sliders[i].removeEventListener('change', _handlers2.default.volumeSlider);
2728					volume_sliders[i].addEventListener('change', _handlers2.default.volumeSlider);
2729				} else {
2730					volume_sliders[i].removeEventListener('input', _handlers2.default.volumeSlider);
2731					volume_sliders[i].addEventListener('input', _handlers2.default.volumeSlider);
2732				}
2733			}
2734		}
2735	}
2736
2737	/*--------------------------------------------------------------------------
2738 	BINDS: class="amplitude-next"
2739 		Binds click and touchend events for amplitude next buttons.
2740 --------------------------------------------------------------------------*/
2741	function bindNext() {
2742		/*
2743  	Gets all of the elements with the class amplitude-next
2744        */
2745		var next_classes = document.getElementsByClassName("amplitude-next");
2746
2747		/*
2748  	Iterates over all of the next classes and binds the event interaction
2749  	methods to the element. If the browser is mobile, then the event is touchend
2750  	otherwise it is click.
2751  */
2752		for (var i = 0; i < next_classes.length; i++) {
2753			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2754				next_classes[i].removeEventListener('touchend', _handlers2.default.next);
2755				next_classes[i].addEventListener('touchend', _handlers2.default.next);
2756			} else {
2757				next_classes[i].removeEventListener('click', _handlers2.default.next);
2758				next_classes[i].addEventListener('click', _handlers2.default.next);
2759			}
2760		}
2761	}
2762
2763	/*--------------------------------------------------------------------------
2764 	BINDS: class="amplitude-prev"
2765 		Binds click and touchend events for amplitude prev buttons.
2766 --------------------------------------------------------------------------*/
2767	function bindPrev() {
2768		/*
2769  	Gets all of the elements with the class amplitude-prev
2770  */
2771		var prev_classes = document.getElementsByClassName("amplitude-prev");
2772
2773		/*
2774  	Iterates over all of the prev classes and binds the event interaction
2775  	methods to the element. If the browser is mobile, then the event is touchend
2776  	otherwise it is click.
2777  */
2778		for (var i = 0; i < prev_classes.length; i++) {
2779			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2780				prev_classes[i].removeEventListener('touchend', _handlers2.default.prev);
2781				prev_classes[i].addEventListener('touchend', _handlers2.default.prev);
2782			} else {
2783				prev_classes[i].removeEventListener('click', _handlers2.default.prev);
2784				prev_classes[i].addEventListener('click', _handlers2.default.prev);
2785			}
2786		}
2787	}
2788
2789	/*--------------------------------------------------------------------------
2790 	BINDS: class="amplitude-shuffle"
2791 		Binds click and touchend events for amplitude shuffle buttons.
2792 --------------------------------------------------------------------------*/
2793	function bindShuffle() {
2794		/*
2795  	Gets all of the elements with the class amplitude-shuffle
2796  */
2797		var shuffle_classes = document.getElementsByClassName("amplitude-shuffle");
2798
2799		/*
2800  	Iterates over all of the shuffle classes and binds the event interaction
2801  	methods to the element. If the browser is mobile, then the event is touchend
2802  	otherwise it is click.
2803  */
2804		for (var i = 0; i < shuffle_classes.length; i++) {
2805			/*
2806   	Since we are re-binding everything we remove any classes that signify
2807   	a state of the shuffle control.
2808   */
2809			shuffle_classes[i].classList.remove('amplitude-shuffle-on');
2810			shuffle_classes[i].classList.add('amplitude-shuffle-off');
2811
2812			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2813				shuffle_classes[i].removeEventListener('touchend', _handlers2.default.shuffle);
2814				shuffle_classes[i].addEventListener('touchend', _handlers2.default.shuffle);
2815			} else {
2816				shuffle_classes[i].removeEventListener('click', _handlers2.default.shuffle);
2817				shuffle_classes[i].addEventListener('click', _handlers2.default.shuffle);
2818			}
2819		}
2820	}
2821
2822	/*--------------------------------------------------------------------------
2823 	BINDS: class="amplitude-repeat"
2824 		Binds click and touchend events for amplitude repeat buttons.
2825 --------------------------------------------------------------------------*/
2826	function bindRepeat() {
2827		/*
2828  	Gets all of the elements with the class amplitude-repeat
2829  */
2830		var repeat_classes = document.getElementsByClassName("amplitude-repeat");
2831
2832		/*
2833  	Iterates over all of the repeat classes and binds the event interaction
2834  	methods to the element. If the browser is mobile, then the event is touchend
2835  	otherwise it is click.
2836  */
2837		for (var i = 0; i < repeat_classes.length; i++) {
2838			/*
2839   	Since we are re-binding everything we remove any classes that signify
2840   	a state of the repeat control.
2841   */
2842			repeat_classes[i].classList.remove('amplitude-repeat-on');
2843			repeat_classes[i].classList.add('amplitude-repeat-off');
2844
2845			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2846				repeat_classes[i].removeEventListener('touchend', _handlers2.default.repeat);
2847				repeat_classes[i].addEventListener('touchend', _handlers2.default.repeat);
2848			} else {
2849				repeat_classes[i].removeEventListener('click', _handlers2.default.repeat);
2850				repeat_classes[i].addEventListener('click', _handlers2.default.repeat);
2851			}
2852		}
2853	}
2854
2855	/*--------------------------------------------------------------------------
2856 	BINDS: class="amplitude-playback-speed"
2857 		Binds click and touchend events for amplitude playback speed buttons.
2858 --------------------------------------------------------------------------*/
2859	function bindPlaybackSpeed() {
2860		/*
2861  	Gets all of the elements with the class amplitude-playback-speed
2862  */
2863		var playback_speed_classes = document.getElementsByClassName("amplitude-playback-speed");
2864
2865		/*
2866  	Iterates over all of the playback speed classes and binds the event interaction
2867  	methods to the element. If the browser is mobile, then the event is touchend
2868  	otherwise it is click.
2869  */
2870		for (var i = 0; i < playback_speed_classes.length; i++) {
2871			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2872				playback_speed_classes[i].removeEventListener('touchend', _handlers2.default.playbackSpeed);
2873				playback_speed_classes[i].addEventListener('touchend', _handlers2.default.playbackSpeed);
2874			} else {
2875				playback_speed_classes[i].removeEventListener('click', _handlers2.default.playbackSpeed);
2876				playback_speed_classes[i].addEventListener('click', _handlers2.default.playbackSpeed);
2877			}
2878		}
2879	}
2880
2881	/*--------------------------------------------------------------------------
2882 	BINDS: class="amplitude-skip-to"
2883 		Binds click and touchend events for amplitude skip to buttons.
2884 --------------------------------------------------------------------------*/
2885	function bindSkipTo() {
2886		/*
2887  	Gets all of the skip to elements with the class 'amplitude-skip-to'
2888  */
2889		var skipToClasses = document.getElementsByClassName("amplitude-skip-to");
2890
2891		/*
2892  	Iterates over all of the skip to classes and binds the event interaction
2893  	methods to the element. If the browser is mobile, then the event is touchend
2894  	otherwise it's a click.
2895  */
2896		for (var i = 0; i < skipToClasses.length; i++) {
2897			if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
2898				skipToClasses[i].removeEventListener('touchend', _handlers2.default.skipTo);
2899				skipToClasses[i].addEventListener('touchend', _handlers2.default.skipTo);
2900			} else {
2901				skipToClasses[i].removeEventListener('click', _handlers2.default.skipTo);
2902				skipToClasses[i].addEventListener('click', _handlers2.default.skipTo);
2903			}
2904		}
2905	}
2906
2907	return {
2908		initializeEvents: initializeEvents
2909	};
2910}(); /*
2911     	Import the necessary classes and config to use
2912     	with the events.
2913     */
2914exports.default = AmplitudeEvents;
2915module.exports = exports['default'];
2916
2917/***/ }),
2918/* 5 */
2919/***/ (function(module, exports, __webpack_require__) {
2920
2921"use strict";
2922
2923
2924Object.defineProperty(exports, "__esModule", {
2925	value: true
2926});
2927
2928var _config = __webpack_require__(0);
2929
2930var _config2 = _interopRequireDefault(_config);
2931
2932var _visual = __webpack_require__(2);
2933
2934var _visual2 = _interopRequireDefault(_visual);
2935
2936var _core = __webpack_require__(3);
2937
2938var _core2 = _interopRequireDefault(_core);
2939
2940var _helpers = __webpack_require__(1);
2941
2942var _helpers2 = _interopRequireDefault(_helpers);
2943
2944function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
2945
2946/**
2947 * These methods help handle interactions whether it's computation or shuffling
2948 * songs.
2949 *
2950 * @module events/AmplitudeEventsHelpers
2951 */
2952
2953
2954/**
2955 * Imports the Amplitude Core module
2956 * @module core/AmplitudeCore
2957 */
2958/**
2959 * Imports the config module
2960 * @module config
2961 */
2962var AmplitudeEventsHelpers = function () {
2963	/**
2964  * Computes the current song time. Breaks down where the song is into
2965  * hours, minutes, seconds and formats it to be displayed to the user.
2966  *
2967  * @access public
2968  */
2969	function computeCurrentTimes() {
2970		/*
2971  	Initialize the current time object that will be returned.
2972  */
2973		var currentTime = {};
2974
2975		/*
2976  	Computes the current seconds for the song.
2977  */
2978		var currentSeconds = (Math.floor(_config2.default.active_song.currentTime % 60) < 10 ? '0' : '') + Math.floor(_config2.default.active_song.currentTime % 60);
2979
2980		/*
2981  	Computes the current minutes for the song.
2982  */
2983		var currentMinutes = Math.floor(_config2.default.active_song.currentTime / 60);
2984
2985		/*
2986  	Initialize the current hours variable.
2987  */
2988		var currentHours = '00';
2989
2990		/*
2991  	If the current minutes is less than 10, we add a leading 0.
2992  */
2993		if (currentMinutes < 10) {
2994			currentMinutes = '0' + currentMinutes;
2995		}
2996
2997		/*
2998  	If the user is more than 60 minutes into the song, then
2999  	we extract the hours.
3000  */
3001		if (currentMinutes >= 60) {
3002			currentHours = Math.floor(currentMinutes / 60);
3003			currentMinutes = currentMinutes % 60;
3004
3005			/*
3006   	If the user is less than 10 minutes in, we append the
3007   	additional 0 to the minutes.
3008   */
3009			if (currentMinutes < 10) {
3010				currentMinutes = '0' + currentMinutes;
3011			}
3012		}
3013
3014		/*
3015  	Build a clean current time object and send back the appropriate information.
3016  */
3017		currentTime.seconds = currentSeconds;
3018		currentTime.minutes = currentMinutes;
3019		currentTime.hours = currentHours;
3020
3021		return currentTime;
3022	}
3023
3024	/**
3025  * Computes the current song duration. Breaks down where the song is into
3026  * hours, minutes, seconds and formats it to be displayed to the user.
3027  *
3028  * @access public
3029  */
3030	function computeSongDuration() {
3031		/*
3032  	Initialize the song duration object that will be returned.
3033  */
3034		var songDuration = {};
3035
3036		/*
3037  	Computes the duration of the song's seconds.
3038  */
3039		var songDurationSeconds = (Math.floor(_config2.default.active_song.duration % 60) < 10 ? '0' : '') + Math.floor(_config2.default.active_song.duration % 60);
3040
3041		/*
3042  	Computes the duration of the song's minutes.
3043  */
3044		var songDurationMinutes = Math.floor(_config2.default.active_song.duration / 60);
3045
3046		/*
3047  	Initialize the hours duration variable.
3048  */
3049		var songDurationHours = '0';
3050
3051		/*
3052  	If the song duration minutes is less than 10, we add a leading 0.
3053  */
3054		if (songDurationMinutes < 10) {
3055			songDurationMinutes = '0' + songDurationMinutes;
3056		}
3057
3058		/*
3059  	If there is more than 60 minutes in the song, then we
3060  	extract the hours.
3061  */
3062		if (songDurationMinutes >= 60) {
3063			songDurationHours = Math.floor(songDurationMinutes / 60);
3064			songDurationMinutes = songDurationMinutes % 60;
3065
3066			/*
3067   	If the song duration minutes is less than 10 we append
3068   	the additional 0.
3069   */
3070			if (songDurationMinutes < 10) {
3071				songDurationMinutes = '0' + songDurationMinutes;
3072			}
3073		}
3074
3075		/*
3076  	Build a clean song duration object and send back the appropriate information.
3077  */
3078		songDuration.seconds = songDurationSeconds;
3079		songDuration.minutes = songDurationMinutes;
3080		songDuration.hours = songDurationHours;
3081
3082		return songDuration;
3083	}
3084
3085	/**
3086  * Computes the song completion percentage.
3087  *
3088  * @access public
3089  */
3090	function computeSongCompletionPercentage() {
3091		return _config2.default.active_song.currentTime / _config2.default.active_song.duration * 100;
3092	}
3093
3094	/**
3095  * Sets the current song's playback speed
3096  *
3097  * @access public
3098  * @param {number} speed 	- The float with a base of 1 representing the speed
3099  *
3100  */
3101	function setPlaybackSpeed(speed) {
3102		_core2.default.setPlaybackSpeed(speed);
3103	}
3104
3105	/**
3106  * Sets the state of the repeat for the current song.
3107  *
3108  * @access public
3109  * @param {boolean} repeat - A boolean representing whether the repeat should be on or off
3110  * @param {string} playlist - The key of the playlist for repeating
3111  */
3112	function setRepeat(repeat, playlist) {
3113		/*
3114    If the playlist is null, then we are dealing with the global
3115    repeat status.
3116  */
3117		if (playlist == null) {
3118			/*
3119   	Set the global repeat to be toggled
3120   */
3121			_config2.default.repeat = repeat;
3122
3123			/*
3124   	Visually sync repeat
3125   */
3126			_visual2.default.syncRepeat();
3127		} else {
3128			/*
3129   	Set the playlist repeat to be toggled.
3130   */