(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.MidiPlayer = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
'use strict';

/**
 * Constants used in player.
 */
var Constants = {
	VERSION: '2.0.1',
	NOTES: []
};

(function () {
	// Builds notes object for reference against binary values.
	var allNotes = [['C'], ['C#', 'Db'], ['D'], ['D#', 'Eb'], ['E'], ['F'], ['F#', 'Gb'], ['G'], ['G#', 'Ab'], ['A'], ['A#', 'Bb'], ['B']];
	var counter = 0;

	// All available octaves.

	var _loop = function _loop(i) {
		allNotes.forEach(function (noteGroup) {
			noteGroup.forEach(function (note) {
				return Constants.NOTES[counter] = note + i;
			});
			counter++;
		});
	};

	for (var i = -1; i <= 9; i++) {
		_loop(i);
	}
})();

exports.Constants = Constants;

},{}],2:[function(require,module,exports){
"use strict";

var Player = require("./player");
var Utils = require("./utils");
var Constants = require("./constants");

module.exports = {
    Player: Player.Player,
    Utils: Utils.Utils,
    Constants: Constants.Constants
};

},{"./constants":1,"./player":3,"./utils":5}],3:[function(require,module,exports){
"use strict";

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Utils = require("./utils").Utils;
var Track = require("./track").Track;

// Polyfill Uint8Array.forEach: Doesn't exist on Safari <10
if (!Uint8Array.prototype.forEach) {
	Object.defineProperty(Uint8Array.prototype, 'forEach', {
		value: Array.prototype.forEach
	});
}

/**
 * Main player class.  Contains methods to load files, start, stop.
 * @param {function} - Callback to fire for each MIDI event.  Can also be added with on('midiEvent', fn)
 * @param {array} - Array buffer of MIDI file (optional).
 */

var Player = function () {
	function Player(eventHandler, buffer) {
		_classCallCheck(this, Player);

		this.sampleRate = 5; // milliseconds
		this.startTime = 0;
		this.buffer = buffer || null;
		this.division;
		this.format;
		this.setIntervalId = false;
		this.tracks = [];
		this.instruments = [];
		this.defaultTempo = 120;
		this.tempo = null;
		this.startTick = 0;
		this.tick = 0;
		this.lastTick = null;
		this.inLoop = false;
		this.totalTicks = 0;
		this.events = [];
		this.totalEvents = 0;
		this.eventListeners = {};

		if (typeof eventHandler === 'function') this.on('midiEvent', eventHandler);
	}

	/**
  * Load a file into the player (Node.js only).
  * @param {string} path - Path of file.
  * @return {Player}
  */


	_createClass(Player, [{
		key: "loadFile",
		value: function loadFile(path) {
			var fs = require('fs');
			this.buffer = fs.readFileSync(path);
			return this.fileLoaded();
		}

		/**
   * Load an array buffer into the player.
   * @param {array} arrayBuffer - Array buffer of file to be loaded.
   * @return {Player}
   */

	}, {
		key: "loadArrayBuffer",
		value: function loadArrayBuffer(arrayBuffer) {
			this.buffer = new Uint8Array(arrayBuffer);
			return this.fileLoaded();
		}

		/**
   * Load a data URI into the player.
   * @param {string} dataUri - Data URI to be loaded.
   * @return {Player}
   */

	}, {
		key: "loadDataUri",
		value: function loadDataUri(dataUri) {
			// convert base64 to raw binary data held in a string.
			// doesn't handle URLEncoded DataURIs - see SO answer #6850276 for code that does this
			var byteString = Utils.atob(dataUri.split(',')[1]);

			// write the bytes of the string to an ArrayBuffer
			var ia = new Uint8Array(byteString.length);
			for (var i = 0; i < byteString.length; i++) {
				ia[i] = byteString.charCodeAt(i);
			}

			this.buffer = ia;
			return this.fileLoaded();
		}

		/**
   * Get filesize of loaded file in number of bytes.
   * @return {number} - The filesize.
   */

	}, {
		key: "getFilesize",
		value: function getFilesize() {
			return this.buffer ? this.buffer.length : 0;
		}

		/**
   * Sets default tempo, parses file for necessary information, and does a dry run to calculate total length.
   * Populates this.events & this.totalTicks.
   * @return {Player}
   */

	}, {
		key: "fileLoaded",
		value: function fileLoaded() {
			if (!this.validate()) throw 'Invalid MIDI file; should start with MThd';
			return this.setTempo(this.defaultTempo).getDivision().getFormat().getTracks().dryRun();
		}

		/**
   * Validates file using simple means - first four bytes should == MThd.
   * @return {boolean}
   */

	}, {
		key: "validate",
		value: function validate() {
			return Utils.bytesToLetters(this.buffer.subarray(0, 4)) === 'MThd';
		}

		/**
   * Gets MIDI file format for loaded file.
   * @return {Player}
   */

	}, {
		key: "getFormat",
		value: function getFormat() {
			/*
   MIDI files come in 3 variations:
   Format 0 which contain a single track
   Format 1 which contain one or more simultaneous tracks
   (ie all tracks are to be played simultaneously).
   Format 2 which contain one or more independant tracks
   (ie each track is to be played independantly of the others).
   return Utils.bytesToNumber(this.buffer.subarray(8, 10));
   */

			this.format = Utils.bytesToNumber(this.buffer.subarray(8, 10));
			return this;
		}

		/**
   * Parses out tracks, places them in this.tracks and initializes this.pointers
   * @return {Player}
   */

	}, {
		key: "getTracks",
		value: function getTracks() {
			this.tracks = [];
			var trackOffset = 0;
			while (trackOffset < this.buffer.length) {
				if (Utils.bytesToLetters(this.buffer.subarray(trackOffset, trackOffset + 4)) == 'MTrk') {
					var trackLength = Utils.bytesToNumber(this.buffer.subarray(trackOffset + 4, trackOffset + 8));
					this.tracks.push(new Track(this.tracks.length, this.buffer.subarray(trackOffset + 8, trackOffset + 8 + trackLength)));
				}

				trackOffset += Utils.bytesToNumber(this.buffer.subarray(trackOffset + 4, trackOffset + 8)) + 8;
			}
			return this;
		}

		/**
   * Enables a track for playing.
   * @param {number} trackNumber - Track number
   * @return {Player}
   */

	}, {
		key: "enableTrack",
		value: function enableTrack(trackNumber) {
			this.tracks[trackNumber - 1].enable();
			return this;
		}

		/**
   * Disables a track for playing.
   * @param {number} - Track number
   * @return {Player}
   */

	}, {
		key: "disableTrack",
		value: function disableTrack(trackNumber) {
			this.tracks[trackNumber - 1].disable();
			return this;
		}

		/**
   * Gets quarter note division of loaded MIDI file.
   * @return {Player}
   */

	}, {
		key: "getDivision",
		value: function getDivision() {
			this.division = Utils.bytesToNumber(this.buffer.subarray(12, 14));
			return this;
		}

		/**
   * The main play loop.
   * @param {boolean} - Indicates whether or not this is being called simply for parsing purposes.  Disregards timing if so.
   * @return {undefined}
   */

	}, {
		key: "playLoop",
		value: function playLoop(dryRun) {
			if (!this.inLoop) {
				this.inLoop = true;
				this.tick = this.getCurrentTick();

				this.tracks.forEach(function (track) {
					// Handle next event
					if (!dryRun && this.endOfFile()) {
						//console.log('end of file')
						this.triggerPlayerEvent('endOfFile');
						this.stop();
					} else {
						var event = track.handleEvent(this.tick, dryRun);

						if (dryRun && event) {
							if (event.hasOwnProperty('name') && event.name === 'Set Tempo') {
								// Grab tempo if available.
								this.setTempo(event.data);
							}
							if (event.hasOwnProperty('name') && event.name === 'Program Change') {
								if (!this.instruments.includes(event.value)) {
									this.instruments.push(event.value);
								}
							}
						} else if (event) this.emitEvent(event);
					}
				}, this);

				if (!dryRun) this.triggerPlayerEvent('playing', { tick: this.tick });
				this.inLoop = false;
			}
		}

		/**
   * Setter for tempo.
   * @param {number} - Tempo in bpm (defaults to 120)
   */

	}, {
		key: "setTempo",
		value: function setTempo(tempo) {
			this.tempo = tempo;
			return this;
		}

		/**
   * Setter for startTime.
   * @param {number} - UTC timestamp
   */

	}, {
		key: "setStartTime",
		value: function setStartTime(startTime) {
			this.startTime = startTime;
		}

		/**
   * Start playing loaded MIDI file if not already playing.
   * @return {Player}
   */

	}, {
		key: "play",
		value: function play() {
			if (this.isPlaying()) throw 'Already playing...';

			// Initialize
			if (!this.startTime) this.startTime = new Date().getTime();

			// Start play loop
			//window.requestAnimationFrame(this.playLoop.bind(this));
			this.setIntervalId = setInterval(this.playLoop.bind(this), this.sampleRate);

			return this;
		}

		/**
   * Pauses playback if playing.
   * @return {Player}
   */

	}, {
		key: "pause",
		value: function pause() {
			clearInterval(this.setIntervalId);
			this.setIntervalId = false;
			this.startTick = this.tick;
			this.startTime = 0;
			return this;
		}

		/**
   * Stops playback if playing.
   * @return {Player}
   */

	}, {
		key: "stop",
		value: function stop() {
			clearInterval(this.setIntervalId);
			this.setIntervalId = false;
			this.startTick = 0;
			this.startTime = 0;
			this.resetTracks();
			return this;
		}

		/**
   * Skips player pointer to specified tick.
   * @param {number} - Tick to skip to.
   * @return {Player}
   */

	}, {
		key: "skipToTick",
		value: function skipToTick(tick) {
			this.stop();
			this.startTick = tick;

			// Need to set track event indexes to the nearest possible event to the specified tick.
			this.tracks.forEach(function (track) {
				track.setEventIndexByTick(tick);
			});
			return this;
		}

		/**
   * Skips player pointer to specified percentage.
   * @param {number} - Percent value in integer format.
   * @return {Player}
   */

	}, {
		key: "skipToPercent",
		value: function skipToPercent(percent) {
			if (percent < 0 || percent > 100) throw "Percent must be number between 1 and 100.";
			this.skipToTick(Math.round(percent / 100 * this.totalTicks));
			return this;
		}

		/**
   * Skips player pointer to specified seconds.
   * @param {number} - Seconds to skip to.
   * @return {Player}
   */

	}, {
		key: "skipToSeconds",
		value: function skipToSeconds(seconds) {
			var songTime = this.getSongTime();
			if (seconds < 0 || seconds > songTime) throw seconds + " seconds not within song time of " + songTime;
			this.skipToPercent(seconds / songTime * 100);
			return this;
		}

		/**
   * Checks if player is playing
   * @return {boolean}
   */

	}, {
		key: "isPlaying",
		value: function isPlaying() {
			return this.setIntervalId > 0 || _typeof(this.setIntervalId) === 'object';
		}

		/**
   * Plays the loaded MIDI file without regard for timing and saves events in this.events.  Essentially used as a parser.
   * @return {Player}
   */

	}, {
		key: "dryRun",
		value: function dryRun() {
			// Reset tracks first
			this.resetTracks();
			while (!this.endOfFile()) {
				this.playLoop(true);
			}this.events = this.getEvents();
			this.totalEvents = this.getTotalEvents();
			this.totalTicks = this.getTotalTicks();
			this.startTick = 0;
			this.startTime = 0;

			// Leave tracks in pristine condish
			this.resetTracks();

			//console.log('Song time: ' + this.getSongTime() + ' seconds / ' + this.totalTicks + ' ticks.');

			this.triggerPlayerEvent('fileLoaded', this);
			return this;
		}

		/**
   * Resets play pointers for all tracks.
   * @return {Player}
   */

	}, {
		key: "resetTracks",
		value: function resetTracks() {
			this.tracks.forEach(function (track) {
				return track.reset();
			});
			return this;
		}

		/**
   * Gets an array of events grouped by track.
   * @return {array}
   */

	}, {
		key: "getEvents",
		value: function getEvents() {
			return this.tracks.map(function (track) {
				return track.events;
			});
		}

		/**
   * Gets total number of ticks in the loaded MIDI file.
   * @return {number}
   */

	}, {
		key: "getTotalTicks",
		value: function getTotalTicks() {
			return Math.max.apply(null, this.tracks.map(function (track) {
				return track.delta;
			}));
		}

		/**
   * Gets total number of events in the loaded MIDI file.
   * @return {number}
   */

	}, {
		key: "getTotalEvents",
		value: function getTotalEvents() {
			return this.tracks.reduce(function (a, b) {
				return { events: { length: a.events.length + b.events.length } };
			}, { events: { length: 0 } }).events.length;
		}

		/**
   * Gets song duration in seconds.
   * @return {number}
   */

	}, {
		key: "getSongTime",
		value: function getSongTime() {
			return this.totalTicks / this.division / this.tempo * 60;
		}

		/**
   * Gets remaining number of seconds in playback.
   * @return {number}
   */

	}, {
		key: "getSongTimeRemaining",
		value: function getSongTimeRemaining() {
			return Math.round((this.totalTicks - this.tick) / this.division / this.tempo * 60);
		}

		/**
   * Gets remaining percent of playback.
   * @return {number}
   */

	}, {
		key: "getSongPercentRemaining",
		value: function getSongPercentRemaining() {
			return Math.round(this.getSongTimeRemaining() / this.getSongTime() * 100);
		}

		/**
   * Number of bytes processed in the loaded MIDI file.
   * @return {number}
   */

	}, {
		key: "bytesProcessed",
		value: function bytesProcessed() {
			// Currently assume header chunk is strictly 14 bytes
			return 14 + this.tracks.length * 8 + this.tracks.reduce(function (a, b) {
				return { pointer: a.pointer + b.pointer };
			}, { pointer: 0 }).pointer;
		}

		/**
   * Number of events played up to this point.
   * @return {number}
   */

	}, {
		key: "eventsPlayed",
		value: function eventsPlayed() {
			return this.tracks.reduce(function (a, b) {
				return { eventIndex: a.eventIndex + b.eventIndex };
			}, { eventIndex: 0 }).eventIndex;
		}

		/**
   * Determines if the player pointer has reached the end of the loaded MIDI file.
   * Used in two ways:
   * 1. If playing result is based on loaded JSON events.
   * 2. If parsing (dryRun) it's based on the actual buffer length vs bytes processed.
   * @return {boolean}
   */

	}, {
		key: "endOfFile",
		value: function endOfFile() {
			if (this.isPlaying()) {
				return this.eventsPlayed() == this.totalEvents;
			}

			return this.bytesProcessed() == this.buffer.length;
		}

		/**
   * Gets the current tick number in playback.
   * @return {number}
   */

	}, {
		key: "getCurrentTick",
		value: function getCurrentTick() {
			return Math.round((new Date().getTime() - this.startTime) / 1000 * (this.division * (this.tempo / 60))) + this.startTick;
		}

		/**
   * Sends MIDI event out to listener.
   * @param {object}
   * @return {Player}
   */

	}, {
		key: "emitEvent",
		value: function emitEvent(event) {
			this.triggerPlayerEvent('midiEvent', event);
			return this;
		}

		/**
   * Subscribes events to listeners
   * @param {string} - Name of event to subscribe to.
   * @param {function} - Callback to fire when event is broadcast.
   * @return {Player}
   */

	}, {
		key: "on",
		value: function on(playerEvent, fn) {
			if (!this.eventListeners.hasOwnProperty(playerEvent)) this.eventListeners[playerEvent] = [];
			this.eventListeners[playerEvent].push(fn);
			return this;
		}

		/**
   * Broadcasts event to trigger subscribed callbacks.
   * @param {string} - Name of event.
   * @param {object} - Data to be passed to subscriber callback.
   * @return {Player}
   */

	}, {
		key: "triggerPlayerEvent",
		value: function triggerPlayerEvent(playerEvent, data) {
			if (this.eventListeners.hasOwnProperty(playerEvent)) this.eventListeners[playerEvent].forEach(function (fn) {
				return fn(data || {});
			});
			return this;
		}
	}]);

	return Player;
}();

exports.Player = Player;

},{"./track":4,"./utils":5,"fs":undefined}],4:[function(require,module,exports){
"use strict";

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Constants = require("./constants").Constants;
var Utils = require("./utils").Utils;

/**
 * Class representing a track.  Contains methods for parsing events and keeping track of pointer.
 */

var Track = function () {
	function Track(index, data) {
		_classCallCheck(this, Track);

		this.enabled = true;
		this.eventIndex = 0;
		this.pointer = 0;
		this.lastTick = 0;
		this.lastStatus = null;
		this.index = index;
		this.data = data;
		this.delta = 0;
		this.runningDelta = 0;
		this.events = [];
	}

	/**
  * Resets all stateful track informaion used during playback.
  * @return {Track}
  */


	_createClass(Track, [{
		key: "reset",
		value: function reset() {
			this.enabled = true;
			this.eventIndex = 0;
			this.pointer = 0;
			this.lastTick = 0;
			this.lastStatus = null;
			this.delta = 0;
			this.runningDelta = 0;
			return this;
		}

		/**
   * Sets this track to be enabled during playback.
   * @return {Track}
   */

	}, {
		key: "enable",
		value: function enable() {
			this.enabled = true;
			return this;
		}

		/**
   * Sets this track to be disabled during playback.
   * @return {Track}
   */

	}, {
		key: "disable",
		value: function disable() {
			this.enabled = false;
			return this;
		}

		/**
   * Sets the track event index to the nearest event to the given tick.
   * @param {number} tick
   * @return {Track}
   */

	}, {
		key: "setEventIndexByTick",
		value: function setEventIndexByTick(tick) {
			tick = tick || 0;

			for (var i in this.events) {
				if (this.events[i].tick >= tick) {
					this.eventIndex = i;
					return this;
				}
			}
		}

		/**
   * Gets byte located at pointer position.
   * @return {number}
   */

	}, {
		key: "getCurrentByte",
		value: function getCurrentByte() {
			return this.data[this.pointer];
		}

		/**
   * Gets count of delta bytes and current pointer position.
   * @return {number}
   */

	}, {
		key: "getDeltaByteCount",
		value: function getDeltaByteCount() {
			// Get byte count of delta VLV
			// http://www.ccarh.org/courses/253/handout/vlv/
			// If byte is greater or equal to 80h (128 decimal) then the next byte
			// is also part of the VLV,
			// else byte is the last byte in a VLV.
			var currentByte = this.getCurrentByte();
			var byteCount = 1;

			while (currentByte >= 128) {
				currentByte = this.data[this.pointer + byteCount];
				byteCount++;
			}

			return byteCount;
		}

		/**
   * Get delta value at current pointer position.
   * @return {number}
   */

	}, {
		key: "getDelta",
		value: function getDelta() {
			return Utils.readVarInt(this.data.subarray(this.pointer, this.pointer + this.getDeltaByteCount()));
		}

		/**
   * Handles event within a given track starting at specified index
   * @param {number} currentTick
   * @param {boolean} dryRun - If true events will be parsed and returned regardless of time.
   */

	}, {
		key: "handleEvent",
		value: function handleEvent(currentTick, dryRun) {
			dryRun = dryRun || false;

			if (dryRun) {
				var elapsedTicks = currentTick - this.lastTick;
				var delta = this.getDelta();
				var eventReady = elapsedTicks >= delta;

				if (this.pointer < this.data.length && (dryRun || eventReady)) {
					var _event = this.parseEvent();
					if (this.enabled) return _event;
					// Recursively call this function for each event ahead that has 0 delta time?
				}
			} else {
				// Let's actually play the MIDI from the generated JSON events created by the dry run.
				if (this.events[this.eventIndex] && this.events[this.eventIndex].tick <= currentTick) {
					this.eventIndex++;
					if (this.enabled) return this.events[this.eventIndex - 1];
				}
			}

			return null;
		}

		/**
   * Get string data from event.
   * @param {number} eventStartIndex
   * @return {string}
   */

	}, {
		key: "getStringData",
		value: function getStringData(eventStartIndex) {
			var currentByte = this.pointer;
			var byteCount = 1;
			var length = Utils.readVarInt(this.data.subarray(eventStartIndex + 2, eventStartIndex + 2 + byteCount));
			var stringLength = length;

			return Utils.bytesToLetters(this.data.subarray(eventStartIndex + byteCount + 2, eventStartIndex + byteCount + length + 2));
		}

		/**
   * Parses event into JSON and advances pointer for the track
   * @return {object}
   */

	}, {
		key: "parseEvent",
		value: function parseEvent() {
			var eventStartIndex = this.pointer + this.getDeltaByteCount();
			var eventJson = {};
			var deltaByteCount = this.getDeltaByteCount();
			eventJson.track = this.index + 1;
			eventJson.delta = this.getDelta();
			this.lastTick = this.lastTick + eventJson.delta;
			this.runningDelta += eventJson.delta;
			eventJson.tick = this.runningDelta;
			eventJson.byteIndex = this.pointer;

			//eventJson.raw = event;
			if (this.data[eventStartIndex] == 0xff) {
				// Meta Event

				// If this is a meta event we should emit the data and immediately move to the next event
				// otherwise if we let it run through the next cycle a slight delay will accumulate if multiple tracks
				// are being played simultaneously

				switch (this.data[eventStartIndex + 1]) {
					case 0x00:
						// Sequence Number
						eventJson.name = 'Sequence Number';
						break;
					case 0x01:
						// Text Event
						eventJson.name = 'Text Event';
						eventJson.string = this.getStringData(eventStartIndex);
						break;
					case 0x02:
						// Copyright Notice
						eventJson.name = 'Copyright Notice';
						break;
					case 0x03:
						// Sequence/Track Name
						eventJson.name = 'Sequence/Track Name';
						eventJson.string = this.getStringData(eventStartIndex);
						break;
					case 0x04:
						// Instrument Name
						eventJson.name = 'Instrument Name';
						eventJson.string = this.getStringData(eventStartIndex);
						break;
					case 0x05:
						// Lyric
						eventJson.name = 'Lyric';
						eventJson.string = this.getStringData(eventStartIndex);
						break;
					case 0x06:
						// Marker
						eventJson.name = 'Marker';
						break;
					case 0x07:
						// Cue Point
						eventJson.name = 'Cue Point';
						eventJson.string = this.getStringData(eventStartIndex);
						break;
					case 0x09:
						// Device Name
						eventJson.name = 'Device Name';
						eventJson.string = this.getStringData(eventStartIndex);
						break;
					case 0x20:
						// MIDI Channel Prefix
						eventJson.name = 'MIDI Channel Prefix';
						break;
					case 0x21:
						// MIDI Port
						eventJson.name = 'MIDI Port';
						eventJson.data = Utils.bytesToNumber([this.data[eventStartIndex + 3]]);
						break;
					case 0x2F:
						// End of Track
						eventJson.name = 'End of Track';
						break;
					case 0x51:
						// Set Tempo
						eventJson.name = 'Set Tempo';
						eventJson.data = Math.round(60000000 / Utils.bytesToNumber(this.data.subarray(eventStartIndex + 3, eventStartIndex + 6)));
						this.tempo = eventJson.data;
						break;
					case 0x54:
						// SMTPE Offset
						eventJson.name = 'SMTPE Offset';
						break;
					case 0x58:
						// Time Signature
						eventJson.name = 'Time Signature';
						break;
					case 0x59:
						// Key Signature
						eventJson.name = 'Key Signature';
						break;
					case 0x7F:
						// Sequencer-Specific Meta-event
						eventJson.name = 'Sequencer-Specific Meta-event';
						break;
					default:
						eventJson.name = 'Unknown: ' + this.data[eventStartIndex + 1].toString(16);
						break;
				}

				var length = this.data[this.pointer + deltaByteCount + 2];
				// Some meta events will have vlv that needs to be handled

				this.pointer += deltaByteCount + 3 + length;
			} else if (this.data[eventStartIndex] == 0xf0) {
				// Sysex
				eventJson.name = 'Sysex';
				var length = this.data[this.pointer + deltaByteCount + 1];
				this.pointer += deltaByteCount + 2 + length;
			} else {
				// Voice event
				if (this.data[eventStartIndex] < 0x80) {
					// Running status
					eventJson.running = true;
					eventJson.noteNumber = this.data[eventStartIndex];
					eventJson.noteName = Constants.NOTES[this.data[eventStartIndex]];
					eventJson.velocity = this.data[eventStartIndex + 1];

					if (this.lastStatus <= 0x8f) {
						eventJson.name = 'Note off';
						eventJson.channel = this.lastStatus - 0x80 + 1;
					} else if (this.lastStatus <= 0x9f) {
						eventJson.name = 'Note on';
						eventJson.channel = this.lastStatus - 0x90 + 1;
					}

					this.pointer += deltaByteCount + 2;
				} else {
					this.lastStatus = this.data[eventStartIndex];

					if (this.data[eventStartIndex] <= 0x8f) {
						// Note off
						eventJson.name = 'Note off';
						eventJson.channel = this.lastStatus - 0x80 + 1;
						eventJson.noteNumber = this.data[eventStartIndex + 1];
						eventJson.noteName = Constants.NOTES[this.data[eventStartIndex + 1]];
						eventJson.velocity = Math.round(this.data[eventStartIndex + 2] / 127 * 100);
						this.pointer += deltaByteCount + 3;
					} else if (this.data[eventStartIndex] <= 0x9f) {
						// Note on
						eventJson.name = 'Note on';
						eventJson.channel = this.lastStatus - 0x90 + 1;
						eventJson.noteNumber = this.data[eventStartIndex + 1];
						eventJson.noteName = Constants.NOTES[this.data[eventStartIndex + 1]];
						eventJson.velocity = Math.round(this.data[eventStartIndex + 2] / 127 * 100);
						this.pointer += deltaByteCount + 3;
					} else if (this.data[eventStartIndex] <= 0xaf) {
						// Polyphonic Key Pressure
						eventJson.name = 'Polyphonic Key Pressure';
						eventJson.channel = this.lastStatus - 0xa0 + 1;
						eventJson.note = Constants.NOTES[this.data[eventStartIndex + 1]];
						eventJson.pressure = event[2];
						this.pointer += deltaByteCount + 3;
					} else if (this.data[eventStartIndex] <= 0xbf) {
						// Controller Change
						eventJson.name = 'Controller Change';
						eventJson.channel = this.lastStatus - 0xb0 + 1;
						eventJson.number = this.data[eventStartIndex + 1];
						eventJson.value = this.data[eventStartIndex + 2];
						this.pointer += deltaByteCount + 3;
					} else if (this.data[eventStartIndex] <= 0xcf) {
						// Program Change
						eventJson.name = 'Program Change';
						eventJson.channel = this.lastStatus - 0xc0 + 1;
						eventJson.value = this.data[eventStartIndex + 1];
						this.pointer += deltaByteCount + 2;
					} else if (this.data[eventStartIndex] <= 0xdf) {
						// Channel Key Pressure
						eventJson.name = 'Channel Key Pressure';
						eventJson.channel = this.lastStatus - 0xd0 + 1;
						this.pointer += deltaByteCount + 2;
					} else if (this.data[eventStartIndex] <= 0xef) {
						// Pitch Bend
						eventJson.name = 'Pitch Bend';
						eventJson.channel = this.lastStatus - 0xe0 + 1;
						this.pointer += deltaByteCount + 3;
					} else {
						eventJson.name = 'Unknown.  Pointer: ' + this.pointer.toString() + ' ' + eventStartIndex.toString() + ' ' + this.data.length;
					}
				}
			}

			this.delta += eventJson.delta;
			this.events.push(eventJson);

			return eventJson;
		}

		/**
   * Returns true if pointer has reached the end of the track.
   * @param {boolean}
   */

	}, {
		key: "endOfTrack",
		value: function endOfTrack() {
			if (this.data[this.pointer + 1] == 0xff && this.data[this.pointer + 2] == 0x2f && this.data[this.pointer + 3] == 0x00) {
				return true;
			}

			return false;
		}
	}]);

	return Track;
}();

module.exports.Track = Track;

},{"./constants":1,"./utils":5}],5:[function(require,module,exports){
(function (Buffer){
'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Contains misc static utility methods.
 */
var Utils = function () {
	function Utils() {
		_classCallCheck(this, Utils);
	}

	_createClass(Utils, null, [{
		key: 'byteToHex',


		/**
   * Converts a single byte to a hex string.
   * @param {number} byte
   * @return {string}
   */
		value: function byteToHex(byte) {
			// Ensure hex string always has two chars
			return ('0' + byte.toString(16)).slice(-2);
		}

		/**
   * Converts an array of bytes to a hex string.
   * @param {array} byteArray
   * @return {string}
   */

	}, {
		key: 'bytesToHex',
		value: function bytesToHex(byteArray) {
			var hex = [];
			byteArray.forEach(function (byte) {
				return hex.push(Utils.byteToHex(byte));
			});
			return hex.join('');
		}

		/**
   * Converts a hex string to a number.
   * @param {string} hexString
   * @return {number}
   */

	}, {
		key: 'hexToNumber',
		value: function hexToNumber(hexString) {
			return parseInt(hexString, 16);
		}

		/**
   * Converts an array of bytes to a number.
   * @param {array} byteArray
   * @return {number}
   */

	}, {
		key: 'bytesToNumber',
		value: function bytesToNumber(byteArray) {
			return Utils.hexToNumber(Utils.bytesToHex(byteArray));
		}

		/**
   * Converts an array of bytes to letters.
   * @param {array} byteArray
   * @return {string}
   */

	}, {
		key: 'bytesToLetters',
		value: function bytesToLetters(byteArray) {
			var letters = [];
			byteArray.forEach(function (byte) {
				return letters.push(String.fromCharCode(byte));
			});
			return letters.join('');
		}

		/**
   * Converts a decimal to it's binary representation.
   * @param {number} dec
   * @return {string}
   */

	}, {
		key: 'decToBinary',
		value: function decToBinary(dec) {
			return (dec >>> 0).toString(2);
		}

		/**
   * Reads a variable length value.
   * @param {array} byteArray
   * @return {number}
   */

	}, {
		key: 'readVarInt',
		value: function readVarInt(byteArray) {
			var result = 0;
			byteArray.forEach(function (number) {
				var b = number;
				if (b & 0x80) {
					result += b & 0x7f;
					result <<= 7;
				} else {
					/* b is the last byte */
					result += b;
				}
			});

			return result;
		}

		/**
   * Decodes base-64 encoded string
   * @param {string} string
   * @return {string}
   */

	}, {
		key: 'atob',
		value: function (_atob) {
			function atob(_x) {
				return _atob.apply(this, arguments);
			}

			atob.toString = function () {
				return _atob.toString();
			};

			return atob;
		}(function (string) {
			if (typeof atob === 'function') return atob(string);
			return new Buffer(string, 'base64').toString('binary');
		})
	}]);

	return Utils;
}();

exports.Utils = Utils;

}).call(this,require("buffer").Buffer)

},{"buffer":undefined}]},{},[2])(2)
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src\\constants.js","src\\index.js","src\\player.js","src\\track.js","src\\src\\utils.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * Constants used in player.\n */\nvar Constants = {\n\tVERSION: '2.0.1',\n\tNOTES: []\n};\n\n(function() {\n\t// Builds notes object for reference against binary values.\n\tvar allNotes = [['C'], ['C#','Db'], ['D'], ['D#','Eb'], ['E'],['F'], ['F#','Gb'], ['G'], ['G#','Ab'], ['A'], ['A#','Bb'], ['B']];\n\tvar counter = 0;\n\n\t// All available octaves.\n\tfor (let i = -1; i <= 9; i++) {\n\t\tallNotes.forEach(noteGroup => {\n\t\t\tnoteGroup.forEach(note => Constants.NOTES[counter] = note + i);\n\t\t\tcounter ++;\n\t\t});\n\t}\n})();\n\nexports.Constants = Constants;","const Player = require(\"./player\");\nconst Utils = require(\"./utils\");\nconst Constants = require(\"./constants\");\n\nmodule.exports = {\n    Player:Player.Player,\n    Utils:Utils.Utils,\n    Constants:Constants.Constants\n}","const Utils = require(\"./utils\").Utils;\nconst Track = require(\"./track\").Track;\n\n// Polyfill Uint8Array.forEach: Doesn't exist on Safari <10\nif (!Uint8Array.prototype.forEach) {\n\tObject.defineProperty(Uint8Array.prototype, 'forEach', {\n\t\tvalue: Array.prototype.forEach\n\t});\n}\n\n/**\n * Main player class.  Contains methods to load files, start, stop.\n * @param {function} - Callback to fire for each MIDI event.  Can also be added with on('midiEvent', fn)\n * @param {array} - Array buffer of MIDI file (optional).\n */\nclass Player {\n\tconstructor(eventHandler, buffer) {\n\t\tthis.sampleRate = 5; // milliseconds\n\t\tthis.startTime = 0;\n\t\tthis.buffer = buffer || null;\n\t\tthis.division;\n\t\tthis.format;\n\t\tthis.setIntervalId = false;\n\t\tthis.tracks = [];\n\t\tthis.instruments = [];\n\t\tthis.defaultTempo = 120;\n\t\tthis.tempo = null;\n\t\tthis.startTick = 0;\n\t\tthis.tick = 0;\n\t\tthis.lastTick = null;\n\t\tthis.inLoop = false;\n\t\tthis.totalTicks = 0;\n\t\tthis.events = [];\n\t\tthis.totalEvents = 0;\n\t\tthis.eventListeners = {};\n\n\t\tif (typeof(eventHandler) === 'function') this.on('midiEvent', eventHandler);\n\t}\n\n\t/**\n\t * Load a file into the player (Node.js only).\n\t * @param {string} path - Path of file.\n\t * @return {Player}\n\t */\n\tloadFile(path) {\n\t\tvar fs = require('fs');\n\t\tthis.buffer = fs.readFileSync(path);\n\t\treturn this.fileLoaded();\n\t}\n\n\t/**\n\t * Load an array buffer into the player.\n\t * @param {array} arrayBuffer - Array buffer of file to be loaded.\n\t * @return {Player}\n\t */\n\tloadArrayBuffer(arrayBuffer) {\n\t\tthis.buffer = new Uint8Array(arrayBuffer);\n\t\treturn this.fileLoaded();\n\t}\n\n\t/**\n\t * Load a data URI into the player.\n\t * @param {string} dataUri - Data URI to be loaded.\n\t * @return {Player}\n\t */\n\tloadDataUri(dataUri) {\n\t\t// convert base64 to raw binary data held in a string.\n\t\t// doesn't handle URLEncoded DataURIs - see SO answer #6850276 for code that does this\n\t\tvar byteString = Utils.atob(dataUri.split(',')[1]);\n\n\t\t// write the bytes of the string to an ArrayBuffer\n\t\tvar ia = new Uint8Array(byteString.length);\n\t\tfor (var i = 0; i < byteString.length; i++) {\n\t\t\tia[i] = byteString.charCodeAt(i);\n\t\t}\n\n\t\tthis.buffer = ia;\n\t\treturn this.fileLoaded();\n\t}\n\n\t/**\n\t * Get filesize of loaded file in number of bytes.\n\t * @return {number} - The filesize.\n\t */\n\tgetFilesize() {\n\t\treturn this.buffer ? this.buffer.length : 0;\n\t}\n\n\t/**\n\t * Sets default tempo, parses file for necessary information, and does a dry run to calculate total length.\n\t * Populates this.events & this.totalTicks.\n\t * @return {Player}\n\t */\n\tfileLoaded() {\n\t\tif (!this.validate()) throw 'Invalid MIDI file; should start with MThd';\n\t\treturn this.setTempo(this.defaultTempo).getDivision().getFormat().getTracks().dryRun();\n\t}\n\n\t/**\n\t * Validates file using simple means - first four bytes should == MThd.\n\t * @return {boolean}\n\t */\n\tvalidate() {\n\t\treturn Utils.bytesToLetters(this.buffer.subarray(0, 4)) === 'MThd';\n\t}\n\n\t/**\n\t * Gets MIDI file format for loaded file.\n\t * @return {Player}\n\t */\n\tgetFormat() {\n\t\t/*\n\t\tMIDI files come in 3 variations:\n\t\tFormat 0 which contain a single track\n\t\tFormat 1 which contain one or more simultaneous tracks\n\t\t(ie all tracks are to be played simultaneously).\n\t\tFormat 2 which contain one or more independant tracks\n\t\t(ie each track is to be played independantly of the others).\n\t\treturn Utils.bytesToNumber(this.buffer.subarray(8, 10));\n\t\t*/\n\n\t\tthis.format = Utils.bytesToNumber(this.buffer.subarray(8, 10));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Parses out tracks, places them in this.tracks and initializes this.pointers\n\t * @return {Player}\n\t */\n\tgetTracks() {\n\t\tthis.tracks = [];\n\t\tlet trackOffset = 0;\n\t\twhile (trackOffset < this.buffer.length) {\n\t\t\tif (Utils.bytesToLetters(this.buffer.subarray(trackOffset, trackOffset + 4)) == 'MTrk') {\n\t\t\t\tlet trackLength = Utils.bytesToNumber(this.buffer.subarray(trackOffset + 4, trackOffset + 8));\n\t\t\t\tthis.tracks.push(new Track(this.tracks.length, this.buffer.subarray(trackOffset + 8, trackOffset + 8 + trackLength)));\n\t\t\t}\n\n\t\t\ttrackOffset += Utils.bytesToNumber(this.buffer.subarray(trackOffset + 4, trackOffset + 8)) + 8;\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Enables a track for playing.\n\t * @param {number} trackNumber - Track number\n\t * @return {Player}\n\t */\n\tenableTrack(trackNumber) {\n\t\tthis.tracks[trackNumber - 1].enable();\n\t\treturn this;\n\t}\n\n\t/**\n\t * Disables a track for playing.\n\t * @param {number} - Track number\n\t * @return {Player}\n\t */\n\tdisableTrack(trackNumber) {\n\t\tthis.tracks[trackNumber - 1].disable();\n\t\treturn this;\n\t}\n\n\t/**\n\t * Gets quarter note division of loaded MIDI file.\n\t * @return {Player}\n\t */\n\tgetDivision() {\n\t\tthis.division = Utils.bytesToNumber(this.buffer.subarray(12, 14));\n\t\treturn this;\n\t}\n\n\t/**\n\t * The main play loop.\n\t * @param {boolean} - Indicates whether or not this is being called simply for parsing purposes.  Disregards timing if so.\n\t * @return {undefined}\n\t */\n\tplayLoop(dryRun) {\n\t\tif (!this.inLoop) {\n\t\t\tthis.inLoop = true;\n\t\t\tthis.tick = this.getCurrentTick();\n\n\t\t\tthis.tracks.forEach(function(track) {\n\t\t\t\t// Handle next event\n\t\t\t\tif (!dryRun && this.endOfFile()) {\n\t\t\t\t\t//console.log('end of file')\n\t\t\t\t\tthis.triggerPlayerEvent('endOfFile');\n\t\t\t\t\tthis.stop();\n\t\t\t\t} else {\n\t\t\t\t\tlet event = track.handleEvent(this.tick, dryRun);\n\n\t\t\t\t\tif (dryRun && event) {\n\t\t\t\t\t\tif (event.hasOwnProperty('name') && event.name === 'Set Tempo') {\n\t\t\t\t\t\t\t// Grab tempo if available.\n\t\t\t\t\t\t\tthis.setTempo(event.data);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (event.hasOwnProperty('name') && event.name === 'Program Change') {\n\t\t\t\t\t\t\tif (!this.instruments.includes(event.value)) {\n\t\t\t\t\t\t\t\tthis.instruments.push(event.value);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (event) this.emitEvent(event);\n\t\t\t\t}\n\n\t\t\t}, this);\n\n\t\t\tif (!dryRun) this.triggerPlayerEvent('playing', {tick: this.tick});\n\t\t\tthis.inLoop = false;\n\t\t}\n\t}\n\n\t/**\n\t * Setter for tempo.\n\t * @param {number} - Tempo in bpm (defaults to 120)\n\t */\n\tsetTempo(tempo) {\n\t\tthis.tempo = tempo;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Setter for startTime.\n\t * @param {number} - UTC timestamp\n\t */\n\tsetStartTime(startTime) {\n\t\tthis.startTime = startTime;\n\t}\n\n\t/**\n\t * Start playing loaded MIDI file if not already playing.\n\t * @return {Player}\n\t */\n\tplay() {\n\t\tif (this.isPlaying()) throw 'Already playing...';\n\n\t\t// Initialize\n\t\tif (!this.startTime) this.startTime = (new Date()).getTime();\n\n\t\t// Start play loop\n\t\t//window.requestAnimationFrame(this.playLoop.bind(this));\n\t\tthis.setIntervalId = setInterval(this.playLoop.bind(this), this.sampleRate);\n\n\t\treturn this;\n\t}\n\n\t/**\n\t * Pauses playback if playing.\n\t * @return {Player}\n\t */\n\tpause() {\n\t\tclearInterval(this.setIntervalId);\n\t\tthis.setIntervalId = false;\n\t\tthis.startTick = this.tick;\n\t\tthis.startTime = 0;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stops playback if playing.\n\t * @return {Player}\n\t */\n\tstop() {\n\t\tclearInterval(this.setIntervalId);\n\t\tthis.setIntervalId = false;\n\t\tthis.startTick = 0;\n\t\tthis.startTime = 0;\n\t\tthis.resetTracks();\n\t\treturn this;\n\t}\n\n\t/**\n\t * Skips player pointer to specified tick.\n\t * @param {number} - Tick to skip to.\n\t * @return {Player}\n\t */\n\tskipToTick(tick) {\n\t\tthis.stop();\n\t\tthis.startTick = tick;\n\n\t\t// Need to set track event indexes to the nearest possible event to the specified tick.\n\t\tthis.tracks.forEach(function(track) {\n\t\t\ttrack.setEventIndexByTick(tick);\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Skips player pointer to specified percentage.\n\t * @param {number} - Percent value in integer format.\n\t * @return {Player}\n\t */\n\tskipToPercent(percent) {\n\t\tif (percent < 0 || percent > 100) throw \"Percent must be number between 1 and 100.\";\n\t\tthis.skipToTick(Math.round(percent / 100 * this.totalTicks));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Skips player pointer to specified seconds.\n\t * @param {number} - Seconds to skip to.\n\t * @return {Player}\n\t */\n\tskipToSeconds(seconds) {\n\t\tvar songTime = this.getSongTime();\n\t\tif (seconds < 0 || seconds > songTime) throw seconds + \" seconds not within song time of \" + songTime;\n\t\tthis.skipToPercent(seconds / songTime * 100);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Checks if player is playing\n\t * @return {boolean}\n\t */\n\tisPlaying() {\n\t\treturn this.setIntervalId > 0 || typeof this.setIntervalId === 'object';\n\t}\n\n\t/**\n\t * Plays the loaded MIDI file without regard for timing and saves events in this.events.  Essentially used as a parser.\n\t * @return {Player}\n\t */\n\tdryRun() {\n\t\t// Reset tracks first\n\t\tthis.resetTracks();\n\t\twhile (!this.endOfFile()) this.playLoop(true);\n\t\tthis.events = this.getEvents();\n\t\tthis.totalEvents = this.getTotalEvents();\n\t\tthis.totalTicks = this.getTotalTicks();\n\t\tthis.startTick = 0;\n\t\tthis.startTime = 0;\n\n\t\t// Leave tracks in pristine condish\n\t\tthis.resetTracks();\n\n\t\t//console.log('Song time: ' + this.getSongTime() + ' seconds / ' + this.totalTicks + ' ticks.');\n\n\t\tthis.triggerPlayerEvent('fileLoaded', this);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Resets play pointers for all tracks.\n\t * @return {Player}\n\t */\n\tresetTracks() {\n\t\tthis.tracks.forEach(track => track.reset());\n\t\treturn this;\n\t}\n\n\t/**\n\t * Gets an array of events grouped by track.\n\t * @return {array}\n\t */\n\tgetEvents() {\n\t\treturn this.tracks.map(track => track.events);\n\t}\n\n\t/**\n\t * Gets total number of ticks in the loaded MIDI file.\n\t * @return {number}\n\t */\n\tgetTotalTicks() {\n\t\treturn Math.max.apply(null, this.tracks.map(track => track.delta));\n\t}\n\n\t/**\n\t * Gets total number of events in the loaded MIDI file.\n\t * @return {number}\n\t */\n\tgetTotalEvents() {\n\t\treturn this.tracks.reduce((a, b) => {return {events: {length: a.events.length + b.events.length}}}, {events: {length: 0}}).events.length;\n\t}\n\n\t/**\n\t * Gets song duration in seconds.\n\t * @return {number}\n\t */\n\tgetSongTime() {\n\t\treturn this.totalTicks / this.division / this.tempo * 60;\n\t}\n\n\t/**\n\t * Gets remaining number of seconds in playback.\n\t * @return {number}\n\t */\n\tgetSongTimeRemaining() {\n\t\treturn Math.round((this.totalTicks - this.tick) / this.division / this.tempo * 60);\n\t}\n\n\t/**\n\t * Gets remaining percent of playback.\n\t * @return {number}\n\t */\n\tgetSongPercentRemaining() {\n\t\treturn Math.round(this.getSongTimeRemaining() / this.getSongTime() * 100);\n\t}\n\n\t/**\n\t * Number of bytes processed in the loaded MIDI file.\n\t * @return {number}\n\t */\n\tbytesProcessed() {\n\t\t// Currently assume header chunk is strictly 14 bytes\n\t\treturn 14 + this.tracks.length * 8 + this.tracks.reduce((a, b) => {return {pointer: a.pointer + b.pointer}}, {pointer: 0}).pointer;\n\t}\n\n\t/**\n\t * Number of events played up to this point.\n\t * @return {number}\n\t */\n\teventsPlayed() {\n\t\treturn this.tracks.reduce((a, b) => {return {eventIndex: a.eventIndex + b.eventIndex}}, {eventIndex: 0}).eventIndex;\n\t}\n\n\t/**\n\t * Determines if the player pointer has reached the end of the loaded MIDI file.\n\t * Used in two ways:\n\t * 1. If playing result is based on loaded JSON events.\n\t * 2. If parsing (dryRun) it's based on the actual buffer length vs bytes processed.\n\t * @return {boolean}\n\t */\n\tendOfFile() {\n\t\tif (this.isPlaying()) {\n\t\t\treturn this.eventsPlayed() == this.totalEvents;\n\t\t}\n\n\t\treturn this.bytesProcessed() == this.buffer.length;\n\t}\n\n\t/**\n\t * Gets the current tick number in playback.\n\t * @return {number}\n\t */\n\tgetCurrentTick() {\n\t\treturn Math.round(((new Date()).getTime() - this.startTime) / 1000 * (this.division * (this.tempo / 60))) + this.startTick;\n\t}\n\n\t/**\n\t * Sends MIDI event out to listener.\n\t * @param {object}\n\t * @return {Player}\n\t */\n\temitEvent(event) {\n\t\tthis.triggerPlayerEvent('midiEvent', event);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Subscribes events to listeners\n\t * @param {string} - Name of event to subscribe to.\n\t * @param {function} - Callback to fire when event is broadcast.\n\t * @return {Player}\n\t */\n\ton(playerEvent, fn) {\n\t\tif (!this.eventListeners.hasOwnProperty(playerEvent)) this.eventListeners[playerEvent] = [];\n\t\tthis.eventListeners[playerEvent].push(fn);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Broadcasts event to trigger subscribed callbacks.\n\t * @param {string} - Name of event.\n\t * @param {object} - Data to be passed to subscriber callback.\n\t * @return {Player}\n\t */\n\ttriggerPlayerEvent(playerEvent, data) {\n\t\tif (this.eventListeners.hasOwnProperty(playerEvent)) this.eventListeners[playerEvent].forEach(fn => fn(data || {}));\n\t\treturn this;\n\t}\n\n}\n\nexports.Player = Player;\n","const Constants = require(\"./constants\").Constants;\nconst Utils = require(\"./utils\").Utils;\n\n/**\n * Class representing a track.  Contains methods for parsing events and keeping track of pointer.\n */\nclass Track\t{\n\tconstructor(index, data) {\n\t\tthis.enabled = true;\n\t\tthis.eventIndex = 0;\n\t\tthis.pointer = 0;\n\t\tthis.lastTick = 0;\n\t\tthis.lastStatus = null;\n\t\tthis.index = index;\n\t\tthis.data = data;\n\t\tthis.delta = 0;\n\t\tthis.runningDelta = 0;\n\t\tthis.events = [];\n\t}\n\n\t/**\n\t * Resets all stateful track informaion used during playback.\n\t * @return {Track}\n\t */\n\treset() {\n\t\tthis.enabled = true;\n\t\tthis.eventIndex = 0;\n\t\tthis.pointer = 0;\n\t\tthis.lastTick = 0;\n\t\tthis.lastStatus = null;\n\t\tthis.delta = 0;\n\t\tthis.runningDelta = 0;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets this track to be enabled during playback.\n\t * @return {Track}\n\t */\n\tenable() {\n\t\tthis.enabled = true;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets this track to be disabled during playback.\n\t * @return {Track}\n\t */\n\tdisable() {\n\t\tthis.enabled = false;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets the track event index to the nearest event to the given tick.\n\t * @param {number} tick\n\t * @return {Track}\n\t */\n\tsetEventIndexByTick(tick) {\n\t\ttick = tick || 0;\n\n\t\tfor (var i in this.events) {\n\t\t\tif (this.events[i].tick >= tick) {\n\t\t\t\tthis.eventIndex = i;\n\t\t\t\treturn this;\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Gets byte located at pointer position.\n\t * @return {number}\n\t */\n\tgetCurrentByte() {\n\t\treturn this.data[this.pointer];\n\t}\n\n\t/**\n\t * Gets count of delta bytes and current pointer position.\n\t * @return {number}\n\t */\n\tgetDeltaByteCount() {\n\t\t// Get byte count of delta VLV\n\t\t// http://www.ccarh.org/courses/253/handout/vlv/\n\t\t// If byte is greater or equal to 80h (128 decimal) then the next byte\n\t    // is also part of the VLV,\n\t   \t// else byte is the last byte in a VLV.\n\t   \tvar currentByte = this.getCurrentByte();\n\t   \tvar byteCount = 1;\n\n\t\twhile (currentByte >= 128) {\n\t\t\tcurrentByte = this.data[this.pointer + byteCount];\n\t\t\tbyteCount++;\n\t\t}\n\n\t\treturn byteCount;\n\t}\n\n\t/**\n\t * Get delta value at current pointer position.\n\t * @return {number}\n\t */\n\tgetDelta() {\n\t\treturn Utils.readVarInt(this.data.subarray(this.pointer, this.pointer + this.getDeltaByteCount()));\n\t}\n\n\t/**\n\t * Handles event within a given track starting at specified index\n\t * @param {number} currentTick\n\t * @param {boolean} dryRun - If true events will be parsed and returned regardless of time.\n\t */\n\thandleEvent(currentTick, dryRun) {\n\t\tdryRun = dryRun || false;\n\n\t\tif (dryRun) {\n\t\t\tvar elapsedTicks = currentTick - this.lastTick;\n\t\t\tvar delta = this.getDelta();\n\t\t\tvar eventReady = elapsedTicks >= delta;\n\n\t\t\tif (this.pointer < this.data.length && (dryRun || eventReady)) {\n\t\t\t\tlet event = this.parseEvent();\n\t\t\t\tif (this.enabled) return event;\n\t\t\t\t// Recursively call this function for each event ahead that has 0 delta time?\n\t\t\t}\n\n\t\t} else {\n\t\t\t// Let's actually play the MIDI from the generated JSON events created by the dry run.\n\t\t\tif (this.events[this.eventIndex] && this.events[this.eventIndex].tick <= currentTick) {\n\t\t\t\tthis.eventIndex++;\n\t\t\t\tif (this.enabled) return this.events[this.eventIndex - 1];\n\t\t\t}\n\t\t}\n\n\t\treturn null;\n\t}\n\n\t/**\n\t * Get string data from event.\n\t * @param {number} eventStartIndex\n\t * @return {string}\n\t */\n\tgetStringData(eventStartIndex) {\n\t\tvar currentByte = this.pointer;\n\t\tvar byteCount = 1;\n\t\tvar length = Utils.readVarInt(this.data.subarray(eventStartIndex + 2, eventStartIndex + 2 + byteCount));\n\t\tvar stringLength = length;\n\n\t\treturn Utils.bytesToLetters(this.data.subarray(eventStartIndex + byteCount + 2, eventStartIndex + byteCount + length + 2));\n\t}\n\n\t/**\n\t * Parses event into JSON and advances pointer for the track\n\t * @return {object}\n\t */\n\tparseEvent() {\n\t\tvar eventStartIndex = this.pointer + this.getDeltaByteCount();\n\t\tvar eventJson = {};\n\t\tvar deltaByteCount = this.getDeltaByteCount();\n\t\teventJson.track = this.index + 1;\n\t\teventJson.delta = this.getDelta();\n\t\tthis.lastTick = this.lastTick + eventJson.delta;\n\t\tthis.runningDelta += eventJson.delta;\n\t\teventJson.tick = this.runningDelta;\n\t\teventJson.byteIndex = this.pointer;\n\n\t\t//eventJson.raw = event;\n\t\tif (this.data[eventStartIndex] == 0xff) {\n\t\t\t// Meta Event\n\n\t\t\t// If this is a meta event we should emit the data and immediately move to the next event\n\t\t\t// otherwise if we let it run through the next cycle a slight delay will accumulate if multiple tracks\n\t\t\t// are being played simultaneously\n\n\t\t\tswitch(this.data[eventStartIndex + 1]) {\n\t\t\t\tcase 0x00: // Sequence Number\n\t\t\t\t\teventJson.name = 'Sequence Number';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x01: // Text Event\n\t\t\t\t\teventJson.name = 'Text Event';\n\t\t\t\t\teventJson.string = this.getStringData(eventStartIndex);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x02: // Copyright Notice\n\t\t\t\t\teventJson.name = 'Copyright Notice';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x03: // Sequence/Track Name\n\t\t\t\t\teventJson.name = 'Sequence/Track Name';\n\t\t\t\t\teventJson.string = this.getStringData(eventStartIndex);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x04: // Instrument Name\n\t\t\t\t\teventJson.name = 'Instrument Name';\n\t\t\t\t\teventJson.string = this.getStringData(eventStartIndex);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x05: // Lyric\n\t\t\t\t\teventJson.name = 'Lyric';\n\t\t\t\t\teventJson.string = this.getStringData(eventStartIndex);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x06: // Marker\n\t\t\t\t\teventJson.name = 'Marker';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x07: // Cue Point\n\t\t\t\t\teventJson.name = 'Cue Point';\n\t\t\t\t\teventJson.string = this.getStringData(eventStartIndex);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x09: // Device Name\n\t\t\t\t\teventJson.name = 'Device Name';\n\t\t\t\t\teventJson.string = this.getStringData(eventStartIndex);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x20: // MIDI Channel Prefix\n\t\t\t\t\teventJson.name = 'MIDI Channel Prefix';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x21: // MIDI Port\n\t\t\t\t\teventJson.name = 'MIDI Port';\n\t\t\t\t\teventJson.data = Utils.bytesToNumber([this.data[eventStartIndex + 3]]);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x2F: // End of Track\n\t\t\t\t\teventJson.name = 'End of Track';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x51: // Set Tempo\n\t\t\t\t\teventJson.name = 'Set Tempo';\n\t\t\t\t\teventJson.data = Math.round(60000000 / Utils.bytesToNumber(this.data.subarray(eventStartIndex + 3, eventStartIndex + 6)));\n\t\t\t\t\tthis.tempo = eventJson.data;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x54: // SMTPE Offset\n\t\t\t\t\teventJson.name = 'SMTPE Offset';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x58: // Time Signature\n\t\t\t\t\teventJson.name = 'Time Signature';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x59: // Key Signature\n\t\t\t\t\teventJson.name = 'Key Signature';\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x7F: // Sequencer-Specific Meta-event\n\t\t\t\t\teventJson.name = 'Sequencer-Specific Meta-event';\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\teventJson.name = 'Unknown: ' + this.data[eventStartIndex + 1].toString(16);\n\t\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tvar length = this.data[this.pointer + deltaByteCount + 2];\n\t\t\t// Some meta events will have vlv that needs to be handled\n\n\t\t\tthis.pointer += deltaByteCount + 3 + length;\n\n\t\t} else if(this.data[eventStartIndex] == 0xf0) {\n\t\t\t// Sysex\n\t\t\teventJson.name = 'Sysex';\n\t\t\tvar length = this.data[this.pointer + deltaByteCount + 1];\n\t\t\tthis.pointer += deltaByteCount + 2 + length;\n\n\t\t} else {\n\t\t\t// Voice event\n\t\t\tif (this.data[eventStartIndex] < 0x80) {\n\t\t\t\t// Running status\n\t\t\t\teventJson.running = true;\n\t\t\t\teventJson.noteNumber = this.data[eventStartIndex];\n\t\t\t\teventJson.noteName = Constants.NOTES[this.data[eventStartIndex]];\n\t\t\t\teventJson.velocity = this.data[eventStartIndex + 1];\n\n\t\t\t\tif (this.lastStatus <= 0x8f) {\n\t\t\t\t\teventJson.name = 'Note off';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0x80 + 1;\n\n\t\t\t\t} else if (this.lastStatus <= 0x9f) {\n\t\t\t\t\teventJson.name = 'Note on';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0x90 + 1;\n\t\t\t\t}\n\n\t\t\t\tthis.pointer += deltaByteCount + 2;\n\n\t\t\t} else {\n\t\t\t\tthis.lastStatus = this.data[eventStartIndex];\n\n\t\t\t\tif (this.data[eventStartIndex] <= 0x8f) {\n\t\t\t\t\t// Note off\n\t\t\t\t\teventJson.name = 'Note off';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0x80 + 1;\n\t\t\t\t\teventJson.noteNumber = this.data[eventStartIndex + 1];\n\t\t\t\t\teventJson.noteName = Constants.NOTES[this.data[eventStartIndex + 1]];\n\t\t\t\t\teventJson.velocity = Math.round(this.data[eventStartIndex + 2] / 127 * 100);\n\t\t\t\t\tthis.pointer += deltaByteCount + 3;\n\n\t\t\t\t} else if (this.data[eventStartIndex] <= 0x9f) {\n\t\t\t\t\t// Note on\n\t\t\t\t\teventJson.name = 'Note on';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0x90 + 1;\n\t\t\t\t\teventJson.noteNumber = this.data[eventStartIndex + 1];\n\t\t\t\t\teventJson.noteName = Constants.NOTES[this.data[eventStartIndex + 1]];\n\t\t\t\t\teventJson.velocity = Math.round(this.data[eventStartIndex + 2] / 127 * 100);\n\t\t\t\t\tthis.pointer += deltaByteCount + 3;\n\n\t\t\t\t} else if (this.data[eventStartIndex] <= 0xaf) {\n\t\t\t\t\t// Polyphonic Key Pressure\n\t\t\t\t\teventJson.name = 'Polyphonic Key Pressure';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0xa0 + 1;\n\t\t\t\t\teventJson.note = Constants.NOTES[this.data[eventStartIndex + 1]];\n\t\t\t\t\teventJson.pressure = event[2];\n\t\t\t\t\tthis.pointer += deltaByteCount + 3;\n\n\t\t\t\t} else if (this.data[eventStartIndex] <= 0xbf) {\n\t\t\t\t\t// Controller Change\n\t\t\t\t\teventJson.name = 'Controller Change';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0xb0 + 1;\n\t\t\t\t\teventJson.number = this.data[eventStartIndex + 1];\n\t\t\t\t\teventJson.value = this.data[eventStartIndex + 2];\n\t\t\t\t\tthis.pointer += deltaByteCount + 3;\n\n\t\t\t\t} else if (this.data[eventStartIndex] <= 0xcf) {\n\t\t\t\t\t// Program Change\n\t\t\t\t\teventJson.name = 'Program Change';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0xc0 + 1;\n\t\t\t\t\teventJson.value = this.data[eventStartIndex + 1];\n\t\t\t\t\tthis.pointer += deltaByteCount + 2;\n\n\t\t\t\t} else if (this.data[eventStartIndex] <= 0xdf) {\n\t\t\t\t\t// Channel Key Pressure\n\t\t\t\t\teventJson.name = 'Channel Key Pressure';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0xd0 + 1;\n\t\t\t\t\tthis.pointer += deltaByteCount + 2;\n\n\t\t\t\t} else if (this.data[eventStartIndex] <= 0xef) {\n\t\t\t\t\t// Pitch Bend\n\t\t\t\t\teventJson.name = 'Pitch Bend';\n\t\t\t\t\teventJson.channel = this.lastStatus - 0xe0 + 1;\n\t\t\t\t\tthis.pointer += deltaByteCount + 3;\n\n\t\t\t\t} else {\n\t\t\t\t\teventJson.name = 'Unknown.  Pointer: ' + this.pointer.toString() + ' '  + eventStartIndex.toString() + ' ' + this.data.length;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.delta += eventJson.delta;\n\t\tthis.events.push(eventJson);\n\n\t\treturn eventJson;\n\t}\n\n\t/**\n\t * Returns true if pointer has reached the end of the track.\n\t * @param {boolean}\n\t */\n\tendOfTrack() {\n\t\tif (this.data[this.pointer + 1] == 0xff && this.data[this.pointer + 2] == 0x2f && this.data[this.pointer + 3] == 0x00) {\n\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t}\n}\n\nmodule.exports.Track = Track;","/**\n * Contains misc static utility methods.\n */\nclass Utils {\n\n\t/**\n\t * Converts a single byte to a hex string.\n\t * @param {number} byte\n\t * @return {string}\n\t */\n\tstatic byteToHex(byte) {\n\t\t// Ensure hex string always has two chars\n\t\treturn ('0' + byte.toString(16)).slice(-2);\n\t}\n\n\t/**\n\t * Converts an array of bytes to a hex string.\n\t * @param {array} byteArray\n\t * @return {string}\n\t */\n\tstatic bytesToHex(byteArray) {\n\t\tvar hex = [];\n\t\tbyteArray.forEach(byte => hex.push(Utils.byteToHex(byte)));\n\t\treturn hex.join('');\n\t}\n\n\t/**\n\t * Converts a hex string to a number.\n\t * @param {string} hexString\n\t * @return {number}\n\t */\n\tstatic hexToNumber(hexString) {\n\t\treturn parseInt(hexString, 16);\n\t}\n\n\t/**\n\t * Converts an array of bytes to a number.\n\t * @param {array} byteArray\n\t * @return {number}\n\t */\n\tstatic bytesToNumber(byteArray) {\n\t\treturn Utils.hexToNumber(Utils.bytesToHex(byteArray));\n\t}\n\n\t/**\n\t * Converts an array of bytes to letters.\n\t * @param {array} byteArray\n\t * @return {string}\n\t */\n\tstatic bytesToLetters(byteArray) {\n\t\tvar letters = [];\n\t\tbyteArray.forEach(byte => letters.push(String.fromCharCode(byte)));\n\t\treturn letters.join('');\n\t}\n\n\t/**\n\t * Converts a decimal to it's binary representation.\n\t * @param {number} dec\n\t * @return {string}\n\t */\n\tstatic decToBinary(dec) {\n    \treturn (dec >>> 0).toString(2);\n\t}\n\n\t/**\n\t * Reads a variable length value.\n\t * @param {array} byteArray\n\t * @return {number}\n\t */\n\tstatic readVarInt(byteArray) {\n\t\tvar result = 0;\n\t\tbyteArray.forEach(number => {\n\t\t\tvar b = number;\n\t\t\tif (b & 0x80) {\n\t\t\t\tresult += (b & 0x7f);\n\t\t\t\tresult <<= 7;\n\t\t\t} else {\n\t\t\t\t/* b is the last byte */\n\t\t\t\tresult += b;\n\t\t\t}\n\t\t});\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Decodes base-64 encoded string\n\t * @param {string} string\n\t * @return {string}\n\t */\n\tstatic atob(string) {\n\t\tif (typeof atob === 'function') return atob(string);\n\t\treturn new Buffer(string, 'base64').toString('binary');\n\t}\n}\n\nexports.Utils = Utils;"]}