mirror of
https://github.com/bvanroll/rpiRadio.git
synced 2025-08-30 20:42:44 +00:00
1238 lines
96 KiB
JavaScript
1238 lines
96 KiB
JavaScript
(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(){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}return e})()({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/**
|
|
* Constants used in player.
|
|
*/
|
|
var Constants = {
|
|
VERSION: '2.0.3',
|
|
NOTES: [],
|
|
CIRCLE_OF_FOURTHS: ['C', 'F', 'Bb', 'Eb', 'Ab', 'Db', 'Gb', 'Cb', 'Fb', 'Bbb', 'Ebb', 'Abb'],
|
|
CIRCLE_OF_FIFTHS: ['C', 'G', 'D', 'A', 'E', 'B', 'F#', 'C#', 'G#', 'D#', 'A#', 'E#']
|
|
};
|
|
|
|
// 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
|
|
// FF 58 04 nn dd cc bb
|
|
eventJson.name = 'Time Signature';
|
|
eventJson.data = this.data.subarray(eventStartIndex + 3, eventStartIndex + 7);
|
|
eventJson.timeSignature = "" + eventJson.data[0] + "/" + Math.pow(eventJson.data[1], 2);
|
|
break;
|
|
case 0x59:
|
|
// Key Signature
|
|
// FF 59 02 sf mi
|
|
eventJson.name = 'Key Signature';
|
|
eventJson.data = this.data.subarray(eventStartIndex + 3, eventStartIndex + 5);
|
|
|
|
if (eventJson.data[0] >= 0) {
|
|
eventJson.keySignature = Constants.CIRCLE_OF_FIFTHS[eventJson.data[0]];
|
|
} else if (eventJson.data[0] < 0) {
|
|
eventJson.keySignature = Constants.CIRCLE_OF_FOURTHS[Math.abs(eventJson.data[0])];
|
|
}
|
|
|
|
if (eventJson.data[1] == 0) {
|
|
eventJson.keySignature += " Major";
|
|
} else if (eventJson.data[1] == 1) {
|
|
eventJson.keySignature += " Minor";
|
|
}
|
|
|
|
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/utils.js"],"names":[],"mappings":"AAAA;;;ACAA;;;AAGA,IAAI,YAAY;AACf,UAAS,OADM;AAEf,QAAO,EAFQ;AAGf,oBAAmB,CAAC,GAAD,EAAM,GAAN,EAAW,IAAX,EAAiB,IAAjB,EAAuB,IAAvB,EAA6B,IAA7B,EAAmC,IAAnC,EAAyC,IAAzC,EAA+C,IAA/C,EAAqD,KAArD,EAA4D,KAA5D,EAAmE,KAAnE,CAHJ;AAIf,mBAAkB,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,EAAgB,GAAhB,EAAqB,GAArB,EAA0B,GAA1B,EAA+B,IAA/B,EAAqC,IAArC,EAA2C,IAA3C,EAAiD,IAAjD,EAAuD,IAAvD,EAA6D,IAA7D;AAJH,CAAhB;;AAOA;AACA,IAAI,WAAW,CAAC,CAAC,GAAD,CAAD,EAAQ,CAAC,IAAD,EAAM,IAAN,CAAR,EAAqB,CAAC,GAAD,CAArB,EAA4B,CAAC,IAAD,EAAM,IAAN,CAA5B,EAAyC,CAAC,GAAD,CAAzC,EAA+C,CAAC,GAAD,CAA/C,EAAsD,CAAC,IAAD,EAAM,IAAN,CAAtD,EAAmE,CAAC,GAAD,CAAnE,EAA0E,CAAC,IAAD,EAAM,IAAN,CAA1E,EAAuF,CAAC,GAAD,CAAvF,EAA8F,CAAC,IAAD,EAAM,IAAN,CAA9F,EAA2G,CAAC,GAAD,CAA3G,CAAf;AACA,IAAI,UAAU,CAAd;;AAEA;;2BACS,C;AACR,UAAS,OAAT,CAAiB,qBAAa;AAC7B,YAAU,OAAV,CAAkB;AAAA,UAAQ,UAAU,KAAV,CAAgB,OAAhB,IAA2B,OAAO,CAA1C;AAAA,GAAlB;AACA;AACA,EAHD;;;AADD,KAAK,IAAI,IAAI,CAAC,CAAd,EAAiB,KAAK,CAAtB,EAAyB,GAAzB,EAA8B;AAAA,OAArB,CAAqB;AAK7B;;AAED,QAAQ,SAAR,GAAoB,SAApB;;;;;ACtBA,IAAM,SAAS,QAAQ,UAAR,CAAf;AACA,IAAM,QAAQ,QAAQ,SAAR,CAAd;AACA,IAAM,YAAY,QAAQ,aAAR,CAAlB;;AAEA,OAAO,OAAP,GAAiB;AACb,YAAO,OAAO,MADD;AAEb,WAAM,MAAM,KAFC;AAGb,eAAU,UAAU;AAHP,CAAjB;;;;;;;;;;;ACJA,IAAM,QAAQ,QAAQ,SAAR,EAAmB,KAAjC;AACA,IAAM,QAAQ,QAAQ,SAAR,EAAmB,KAAjC;;AAEA;AACA,IAAI,CAAC,WAAW,SAAX,CAAqB,OAA1B,EAAmC;AAClC,QAAO,cAAP,CAAsB,WAAW,SAAjC,EAA4C,SAA5C,EAAuD;AACtD,SAAO,MAAM,SAAN,CAAgB;AAD+B,EAAvD;AAGA;;AAED;;;;;;IAKM,M;AACL,iBAAY,YAAZ,EAA0B,MAA1B,EAAkC;AAAA;;AACjC,OAAK,UAAL,GAAkB,CAAlB,CADiC,CACZ;AACrB,OAAK,SAAL,GAAiB,CAAjB;AACA,OAAK,MAAL,GAAc,UAAU,IAAxB;AACA,OAAK,QAAL;AACA,OAAK,MAAL;AACA,OAAK,aAAL,GAAqB,KAArB;AACA,OAAK,MAAL,GAAc,EAAd;AACA,OAAK,WAAL,GAAmB,EAAnB;AACA,OAAK,YAAL,GAAoB,GAApB;AACA,OAAK,KAAL,GAAa,IAAb;AACA,OAAK,SAAL,GAAiB,CAAjB;AACA,OAAK,IAAL,GAAY,CAAZ;AACA,OAAK,QAAL,GAAgB,IAAhB;AACA,OAAK,MAAL,GAAc,KAAd;AACA,OAAK,UAAL,GAAkB,CAAlB;AACA,OAAK,MAAL,GAAc,EAAd;AACA,OAAK,WAAL,GAAmB,CAAnB;AACA,OAAK,cAAL,GAAsB,EAAtB;;AAEA,MAAI,OAAO,YAAP,KAAyB,UAA7B,EAAyC,KAAK,EAAL,CAAQ,WAAR,EAAqB,YAArB;AACzC;;AAED;;;;;;;;;2BAKS,I,EAAM;AACd,OAAI,KAAK,QAAQ,IAAR,CAAT;AACA,QAAK,MAAL,GAAc,GAAG,YAAH,CAAgB,IAAhB,CAAd;AACA,UAAO,KAAK,UAAL,EAAP;AACA;;AAED;;;;;;;;kCAKgB,W,EAAa;AAC5B,QAAK,MAAL,GAAc,IAAI,UAAJ,CAAe,WAAf,CAAd;AACA,UAAO,KAAK,UAAL,EAAP;AACA;;AAED;;;;;;;;8BAKY,O,EAAS;AACpB;AACA;AACA,OAAI,aAAa,MAAM,IAAN,CAAW,QAAQ,KAAR,CAAc,GAAd,EAAmB,CAAnB,CAAX,CAAjB;;AAEA;AACA,OAAI,KAAK,IAAI,UAAJ,CAAe,WAAW,MAA1B,CAAT;AACA,QAAK,IAAI,IAAI,CAAb,EAAgB,IAAI,WAAW,MAA/B,EAAuC,GAAvC,EAA4C;AAC3C,OAAG,CAAH,IAAQ,WAAW,UAAX,CAAsB,CAAtB,CAAR;AACA;;AAED,QAAK,MAAL,GAAc,EAAd;AACA,UAAO,KAAK,UAAL,EAAP;AACA;;AAED;;;;;;;gCAIc;AACb,UAAO,KAAK,MAAL,GAAc,KAAK,MAAL,CAAY,MAA1B,GAAmC,CAA1C;AACA;;AAED;;;;;;;;+BAKa;AACZ,OAAI,CAAC,KAAK,QAAL,EAAL,EAAsB,MAAM,2CAAN;AACtB,UAAO,KAAK,QAAL,CAAc,KAAK,YAAnB,EAAiC,WAAjC,GAA+C,SAA/C,GAA2D,SAA3D,GAAuE,MAAvE,EAAP;AACA;;AAED;;;;;;;6BAIW;AACV,UAAO,MAAM,cAAN,CAAqB,KAAK,MAAL,CAAY,QAAZ,CAAqB,CAArB,EAAwB,CAAxB,CAArB,MAAqD,MAA5D;AACA;;AAED;;;;;;;8BAIY;AACX;;;;;;;;;;AAUA,QAAK,MAAL,GAAc,MAAM,aAAN,CAAoB,KAAK,MAAL,CAAY,QAAZ,CAAqB,CAArB,EAAwB,EAAxB,CAApB,CAAd;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;8BAIY;AACX,QAAK,MAAL,GAAc,EAAd;AACA,OAAI,cAAc,CAAlB;AACA,UAAO,cAAc,KAAK,MAAL,CAAY,MAAjC,EAAyC;AACxC,QAAI,MAAM,cAAN,CAAqB,KAAK,MAAL,CAAY,QAAZ,CAAqB,WAArB,EAAkC,cAAc,CAAhD,CAArB,KAA4E,MAAhF,EAAwF;AACvF,SAAI,cAAc,MAAM,aAAN,CAAoB,KAAK,MAAL,CAAY,QAAZ,CAAqB,cAAc,CAAnC,EAAsC,cAAc,CAApD,CAApB,CAAlB;AACA,UAAK,MAAL,CAAY,IAAZ,CAAiB,IAAI,KAAJ,CAAU,KAAK,MAAL,CAAY,MAAtB,EAA8B,KAAK,MAAL,CAAY,QAAZ,CAAqB,cAAc,CAAnC,EAAsC,cAAc,CAAd,GAAkB,WAAxD,CAA9B,CAAjB;AACA;;AAED,mBAAe,MAAM,aAAN,CAAoB,KAAK,MAAL,CAAY,QAAZ,CAAqB,cAAc,CAAnC,EAAsC,cAAc,CAApD,CAApB,IAA8E,CAA7F;AACA;AACD,UAAO,IAAP;AACA;;AAED;;;;;;;;8BAKY,W,EAAa;AACxB,QAAK,MAAL,CAAY,cAAc,CAA1B,EAA6B,MAA7B;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;;+BAKa,W,EAAa;AACzB,QAAK,MAAL,CAAY,cAAc,CAA1B,EAA6B,OAA7B;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;gCAIc;AACb,QAAK,QAAL,GAAgB,MAAM,aAAN,CAAoB,KAAK,MAAL,CAAY,QAAZ,CAAqB,EAArB,EAAyB,EAAzB,CAApB,CAAhB;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;;2BAKS,M,EAAQ;AAChB,OAAI,CAAC,KAAK,MAAV,EAAkB;AACjB,SAAK,MAAL,GAAc,IAAd;AACA,SAAK,IAAL,GAAY,KAAK,cAAL,EAAZ;;AAEA,SAAK,MAAL,CAAY,OAAZ,CAAoB,UAAS,KAAT,EAAgB;AACnC;AACA,SAAI,CAAC,MAAD,IAAW,KAAK,SAAL,EAAf,EAAiC;AAChC;AACA,WAAK,kBAAL,CAAwB,WAAxB;AACA,WAAK,IAAL;AACA,MAJD,MAIO;AACN,UAAI,QAAQ,MAAM,WAAN,CAAkB,KAAK,IAAvB,EAA6B,MAA7B,CAAZ;;AAEA,UAAI,UAAU,KAAd,EAAqB;AACpB,WAAI,MAAM,cAAN,CAAqB,MAArB,KAAgC,MAAM,IAAN,KAAe,WAAnD,EAAgE;AAC/D;AACA,aAAK,QAAL,CAAc,MAAM,IAApB;AACA;AACD,WAAI,MAAM,cAAN,CAAqB,MAArB,KAAgC,MAAM,IAAN,KAAe,gBAAnD,EAAqE;AACpE,YAAI,CAAC,KAAK,WAAL,CAAiB,QAAjB,CAA0B,MAAM,KAAhC,CAAL,EAA6C;AAC5C,cAAK,WAAL,CAAiB,IAAjB,CAAsB,MAAM,KAA5B;AACA;AACD;AACD,OAVD,MAUO,IAAI,KAAJ,EAAW,KAAK,SAAL,CAAe,KAAf;AAClB;AAED,KAtBD,EAsBG,IAtBH;;AAwBA,QAAI,CAAC,MAAL,EAAa,KAAK,kBAAL,CAAwB,SAAxB,EAAmC,EAAC,MAAM,KAAK,IAAZ,EAAnC;AACb,SAAK,MAAL,GAAc,KAAd;AACA;AACD;;AAED;;;;;;;2BAIS,K,EAAO;AACf,QAAK,KAAL,GAAa,KAAb;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;+BAIa,S,EAAW;AACvB,QAAK,SAAL,GAAiB,SAAjB;AACA;;AAED;;;;;;;yBAIO;AACN,OAAI,KAAK,SAAL,EAAJ,EAAsB,MAAM,oBAAN;;AAEtB;AACA,OAAI,CAAC,KAAK,SAAV,EAAqB,KAAK,SAAL,GAAkB,IAAI,IAAJ,EAAD,CAAa,OAAb,EAAjB;;AAErB;AACA;AACA,QAAK,aAAL,GAAqB,YAAY,KAAK,QAAL,CAAc,IAAd,CAAmB,IAAnB,CAAZ,EAAsC,KAAK,UAA3C,CAArB;;AAEA,UAAO,IAAP;AACA;;AAED;;;;;;;0BAIQ;AACP,iBAAc,KAAK,aAAnB;AACA,QAAK,aAAL,GAAqB,KAArB;AACA,QAAK,SAAL,GAAiB,KAAK,IAAtB;AACA,QAAK,SAAL,GAAiB,CAAjB;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;yBAIO;AACN,iBAAc,KAAK,aAAnB;AACA,QAAK,aAAL,GAAqB,KAArB;AACA,QAAK,SAAL,GAAiB,CAAjB;AACA,QAAK,SAAL,GAAiB,CAAjB;AACA,QAAK,WAAL;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;;6BAKW,I,EAAM;AAChB,QAAK,IAAL;AACA,QAAK,SAAL,GAAiB,IAAjB;;AAEA;AACA,QAAK,MAAL,CAAY,OAAZ,CAAoB,UAAS,KAAT,EAAgB;AACnC,UAAM,mBAAN,CAA0B,IAA1B;AACA,IAFD;AAGA,UAAO,IAAP;AACA;;AAED;;;;;;;;gCAKc,O,EAAS;AACtB,OAAI,UAAU,CAAV,IAAe,UAAU,GAA7B,EAAkC,MAAM,2CAAN;AAClC,QAAK,UAAL,CAAgB,KAAK,KAAL,CAAW,UAAU,GAAV,GAAgB,KAAK,UAAhC,CAAhB;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;;gCAKc,O,EAAS;AACtB,OAAI,WAAW,KAAK,WAAL,EAAf;AACA,OAAI,UAAU,CAAV,IAAe,UAAU,QAA7B,EAAuC,MAAM,UAAU,mCAAV,GAAgD,QAAtD;AACvC,QAAK,aAAL,CAAmB,UAAU,QAAV,GAAqB,GAAxC;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;8BAIY;AACX,UAAO,KAAK,aAAL,GAAqB,CAArB,IAA0B,QAAO,KAAK,aAAZ,MAA8B,QAA/D;AACA;;AAED;;;;;;;2BAIS;AACR;AACA,QAAK,WAAL;AACA,UAAO,CAAC,KAAK,SAAL,EAAR;AAA0B,SAAK,QAAL,CAAc,IAAd;AAA1B,IACA,KAAK,MAAL,GAAc,KAAK,SAAL,EAAd;AACA,QAAK,WAAL,GAAmB,KAAK,cAAL,EAAnB;AACA,QAAK,UAAL,GAAkB,KAAK,aAAL,EAAlB;AACA,QAAK,SAAL,GAAiB,CAAjB;AACA,QAAK,SAAL,GAAiB,CAAjB;;AAEA;AACA,QAAK,WAAL;;AAEA;;AAEA,QAAK,kBAAL,CAAwB,YAAxB,EAAsC,IAAtC;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;gCAIc;AACb,QAAK,MAAL,CAAY,OAAZ,CAAoB;AAAA,WAAS,MAAM,KAAN,EAAT;AAAA,IAApB;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;8BAIY;AACX,UAAO,KAAK,MAAL,CAAY,GAAZ,CAAgB;AAAA,WAAS,MAAM,MAAf;AAAA,IAAhB,CAAP;AACA;;AAED;;;;;;;kCAIgB;AACf,UAAO,KAAK,GAAL,CAAS,KAAT,CAAe,IAAf,EAAqB,KAAK,MAAL,CAAY,GAAZ,CAAgB;AAAA,WAAS,MAAM,KAAf;AAAA,IAAhB,CAArB,CAAP;AACA;;AAED;;;;;;;mCAIiB;AAChB,UAAO,KAAK,MAAL,CAAY,MAAZ,CAAmB,UAAC,CAAD,EAAI,CAAJ,EAAU;AAAC,WAAO,EAAC,QAAQ,EAAC,QAAQ,EAAE,MAAF,CAAS,MAAT,GAAkB,EAAE,MAAF,CAAS,MAApC,EAAT,EAAP;AAA6D,IAA3F,EAA6F,EAAC,QAAQ,EAAC,QAAQ,CAAT,EAAT,EAA7F,EAAoH,MAApH,CAA2H,MAAlI;AACA;;AAED;;;;;;;gCAIc;AACb,UAAO,KAAK,UAAL,GAAkB,KAAK,QAAvB,GAAkC,KAAK,KAAvC,GAA+C,EAAtD;AACA;;AAED;;;;;;;yCAIuB;AACtB,UAAO,KAAK,KAAL,CAAW,CAAC,KAAK,UAAL,GAAkB,KAAK,IAAxB,IAAgC,KAAK,QAArC,GAAgD,KAAK,KAArD,GAA6D,EAAxE,CAAP;AACA;;AAED;;;;;;;4CAI0B;AACzB,UAAO,KAAK,KAAL,CAAW,KAAK,oBAAL,KAA8B,KAAK,WAAL,EAA9B,GAAmD,GAA9D,CAAP;AACA;;AAED;;;;;;;mCAIiB;AAChB;AACA,UAAO,KAAK,KAAK,MAAL,CAAY,MAAZ,GAAqB,CAA1B,GAA8B,KAAK,MAAL,CAAY,MAAZ,CAAmB,UAAC,CAAD,EAAI,CAAJ,EAAU;AAAC,WAAO,EAAC,SAAS,EAAE,OAAF,GAAY,EAAE,OAAxB,EAAP;AAAwC,IAAtE,EAAwE,EAAC,SAAS,CAAV,EAAxE,EAAsF,OAA3H;AACA;;AAED;;;;;;;iCAIe;AACd,UAAO,KAAK,MAAL,CAAY,MAAZ,CAAmB,UAAC,CAAD,EAAI,CAAJ,EAAU;AAAC,WAAO,EAAC,YAAY,EAAE,UAAF,GAAe,EAAE,UAA9B,EAAP;AAAiD,IAA/E,EAAiF,EAAC,YAAY,CAAb,EAAjF,EAAkG,UAAzG;AACA;;AAED;;;;;;;;;;8BAOY;AACX,OAAI,KAAK,SAAL,EAAJ,EAAsB;AACrB,WAAO,KAAK,YAAL,MAAuB,KAAK,WAAnC;AACA;;AAED,UAAO,KAAK,cAAL,MAAyB,KAAK,MAAL,CAAY,MAA5C;AACA;;AAED;;;;;;;mCAIiB;AAChB,UAAO,KAAK,KAAL,CAAW,CAAE,IAAI,IAAJ,EAAD,CAAa,OAAb,KAAyB,KAAK,SAA/B,IAA4C,IAA5C,IAAoD,KAAK,QAAL,IAAiB,KAAK,KAAL,GAAa,EAA9B,CAApD,CAAX,IAAqG,KAAK,SAAjH;AACA;;AAED;;;;;;;;4BAKU,K,EAAO;AAChB,QAAK,kBAAL,CAAwB,WAAxB,EAAqC,KAArC;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;;;qBAMG,W,EAAa,E,EAAI;AACnB,OAAI,CAAC,KAAK,cAAL,CAAoB,cAApB,CAAmC,WAAnC,CAAL,EAAsD,KAAK,cAAL,CAAoB,WAApB,IAAmC,EAAnC;AACtD,QAAK,cAAL,CAAoB,WAApB,EAAiC,IAAjC,CAAsC,EAAtC;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;;;qCAMmB,W,EAAa,I,EAAM;AACrC,OAAI,KAAK,cAAL,CAAoB,cAApB,CAAmC,WAAnC,CAAJ,EAAqD,KAAK,cAAL,CAAoB,WAApB,EAAiC,OAAjC,CAAyC;AAAA,WAAM,GAAG,QAAQ,EAAX,CAAN;AAAA,IAAzC;AACrD,UAAO,IAAP;AACA;;;;;;AAIF,QAAQ,MAAR,GAAiB,MAAjB;;;;;;;;;ACxdA,IAAM,YAAY,QAAQ,aAAR,EAAuB,SAAzC;AACA,IAAM,QAAQ,QAAQ,SAAR,EAAmB,KAAjC;;AAEA;;;;IAGM,K;AACL,gBAAY,KAAZ,EAAmB,IAAnB,EAAyB;AAAA;;AACxB,OAAK,OAAL,GAAe,IAAf;AACA,OAAK,UAAL,GAAkB,CAAlB;AACA,OAAK,OAAL,GAAe,CAAf;AACA,OAAK,QAAL,GAAgB,CAAhB;AACA,OAAK,UAAL,GAAkB,IAAlB;AACA,OAAK,KAAL,GAAa,KAAb;AACA,OAAK,IAAL,GAAY,IAAZ;AACA,OAAK,KAAL,GAAa,CAAb;AACA,OAAK,YAAL,GAAoB,CAApB;AACA,OAAK,MAAL,GAAc,EAAd;AACA;;AAED;;;;;;;;0BAIQ;AACP,QAAK,OAAL,GAAe,IAAf;AACA,QAAK,UAAL,GAAkB,CAAlB;AACA,QAAK,OAAL,GAAe,CAAf;AACA,QAAK,QAAL,GAAgB,CAAhB;AACA,QAAK,UAAL,GAAkB,IAAlB;AACA,QAAK,KAAL,GAAa,CAAb;AACA,QAAK,YAAL,GAAoB,CAApB;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;2BAIS;AACR,QAAK,OAAL,GAAe,IAAf;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;4BAIU;AACT,QAAK,OAAL,GAAe,KAAf;AACA,UAAO,IAAP;AACA;;AAED;;;;;;;;sCAKoB,I,EAAM;AACzB,UAAO,QAAQ,CAAf;;AAEA,QAAK,IAAI,CAAT,IAAc,KAAK,MAAnB,EAA2B;AAC1B,QAAI,KAAK,MAAL,CAAY,CAAZ,EAAe,IAAf,IAAuB,IAA3B,EAAiC;AAChC,UAAK,UAAL,GAAkB,CAAlB;AACA,YAAO,IAAP;AACA;AACD;AACD;;AAED;;;;;;;mCAIiB;AAChB,UAAO,KAAK,IAAL,CAAU,KAAK,OAAf,CAAP;AACA;;AAED;;;;;;;sCAIoB;AACnB;AACA;AACA;AACG;AACA;AACA,OAAI,cAAc,KAAK,cAAL,EAAlB;AACA,OAAI,YAAY,CAAhB;;AAEH,UAAO,eAAe,GAAtB,EAA2B;AAC1B,kBAAc,KAAK,IAAL,CAAU,KAAK,OAAL,GAAe,SAAzB,CAAd;AACA;AACA;;AAED,UAAO,SAAP;AACA;;AAED;;;;;;;6BAIW;AACV,UAAO,MAAM,UAAN,CAAiB,KAAK,IAAL,CAAU,QAAV,CAAmB,KAAK,OAAxB,EAAiC,KAAK,OAAL,GAAe,KAAK,iBAAL,EAAhD,CAAjB,CAAP;AACA;;AAED;;;;;;;;8BAKY,W,EAAa,M,EAAQ;AAChC,YAAS,UAAU,KAAnB;;AAEA,OAAI,MAAJ,EAAY;AACX,QAAI,eAAe,cAAc,KAAK,QAAtC;AACA,QAAI,QAAQ,KAAK,QAAL,EAAZ;AACA,QAAI,aAAa,gBAAgB,KAAjC;;AAEA,QAAI,KAAK,OAAL,GAAe,KAAK,IAAL,CAAU,MAAzB,KAAoC,UAAU,UAA9C,CAAJ,EAA+D;AAC9D,SAAI,SAAQ,KAAK,UAAL,EAAZ;AACA,SAAI,KAAK,OAAT,EAAkB,OAAO,MAAP;AAClB;AACA;AAED,IAXD,MAWO;AACN;AACA,QAAI,KAAK,MAAL,CAAY,KAAK,UAAjB,KAAgC,KAAK,MAAL,CAAY,KAAK,UAAjB,EAA6B,IAA7B,IAAqC,WAAzE,EAAsF;AACrF,UAAK,UAAL;AACA,SAAI,KAAK,OAAT,EAAkB,OAAO,KAAK,MAAL,CAAY,KAAK,UAAL,GAAkB,CAA9B,CAAP;AAClB;AACD;;AAED,UAAO,IAAP;AACA;;AAED;;;;;;;;gCAKc,e,EAAiB;AAC9B,OAAI,cAAc,KAAK,OAAvB;AACA,OAAI,YAAY,CAAhB;AACA,OAAI,SAAS,MAAM,UAAN,CAAiB,KAAK,IAAL,CAAU,QAAV,CAAmB,kBAAkB,CAArC,EAAwC,kBAAkB,CAAlB,GAAsB,SAA9D,CAAjB,CAAb;AACA,OAAI,eAAe,MAAnB;;AAEA,UAAO,MAAM,cAAN,CAAqB,KAAK,IAAL,CAAU,QAAV,CAAmB,kBAAkB,SAAlB,GAA8B,CAAjD,EAAoD,kBAAkB,SAAlB,GAA8B,MAA9B,GAAuC,CAA3F,CAArB,CAAP;AACA;;AAED;;;;;;;+BAIa;AACZ,OAAI,kBAAkB,KAAK,OAAL,GAAe,KAAK,iBAAL,EAArC;AACA,OAAI,YAAY,EAAhB;AACA,OAAI,iBAAiB,KAAK,iBAAL,EAArB;AACA,aAAU,KAAV,GAAkB,KAAK,KAAL,GAAa,CAA/B;AACA,aAAU,KAAV,GAAkB,KAAK,QAAL,EAAlB;AACA,QAAK,QAAL,GAAgB,KAAK,QAAL,GAAgB,UAAU,KAA1C;AACA,QAAK,YAAL,IAAqB,UAAU,KAA/B;AACA,aAAU,IAAV,GAAiB,KAAK,YAAtB;AACA,aAAU,SAAV,GAAsB,KAAK,OAA3B;;AAEA;AACA,OAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AACvC;;AAEA;AACA;AACA;;AAEA,YAAO,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAP;AACC,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,iBAAjB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,YAAjB;AACA,gBAAU,MAAV,GAAmB,KAAK,aAAL,CAAmB,eAAnB,CAAnB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,kBAAjB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,qBAAjB;AACA,gBAAU,MAAV,GAAmB,KAAK,aAAL,CAAmB,eAAnB,CAAnB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,iBAAjB;AACA,gBAAU,MAAV,GAAmB,KAAK,aAAL,CAAmB,eAAnB,CAAnB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,OAAjB;AACA,gBAAU,MAAV,GAAmB,KAAK,aAAL,CAAmB,eAAnB,CAAnB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,QAAjB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,WAAjB;AACA,gBAAU,MAAV,GAAmB,KAAK,aAAL,CAAmB,eAAnB,CAAnB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,aAAjB;AACA,gBAAU,MAAV,GAAmB,KAAK,aAAL,CAAmB,eAAnB,CAAnB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,qBAAjB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,WAAjB;AACA,gBAAU,IAAV,GAAiB,MAAM,aAAN,CAAoB,CAAC,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAD,CAApB,CAAjB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,cAAjB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,WAAjB;AACA,gBAAU,IAAV,GAAiB,KAAK,KAAL,CAAW,WAAW,MAAM,aAAN,CAAoB,KAAK,IAAL,CAAU,QAAV,CAAmB,kBAAkB,CAArC,EAAwC,kBAAkB,CAA1D,CAApB,CAAtB,CAAjB;AACA,WAAK,KAAL,GAAa,UAAU,IAAvB;AACA;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,cAAjB;AACA;AACD,UAAK,IAAL;AAAW;AACV;AACA,gBAAU,IAAV,GAAiB,gBAAjB;AACA,gBAAU,IAAV,GAAiB,KAAK,IAAL,CAAU,QAAV,CAAmB,kBAAkB,CAArC,EAAwC,kBAAkB,CAA1D,CAAjB;AACA,gBAAU,aAAV,GAA0B,KAAK,UAAU,IAAV,CAAe,CAAf,CAAL,GAAyB,GAAzB,GAA+B,KAAK,GAAL,CAAS,UAAU,IAAV,CAAe,CAAf,CAAT,EAA4B,CAA5B,CAAzD;AACA;AACD,UAAK,IAAL;AAAW;AACV;AACA,gBAAU,IAAV,GAAiB,eAAjB;AACA,gBAAU,IAAV,GAAiB,KAAK,IAAL,CAAU,QAAV,CAAmB,kBAAkB,CAArC,EAAwC,kBAAkB,CAA1D,CAAjB;;AAEA,UAAI,UAAU,IAAV,CAAe,CAAf,KAAqB,CAAzB,EAA4B;AAC3B,iBAAU,YAAV,GAAyB,UAAU,gBAAV,CAA2B,UAAU,IAAV,CAAe,CAAf,CAA3B,CAAzB;AAEA,OAHD,MAGO,IAAI,UAAU,IAAV,CAAe,CAAf,IAAoB,CAAxB,EAA2B;AACjC,iBAAU,YAAV,GAAyB,UAAU,iBAAV,CAA4B,KAAK,GAAL,CAAS,UAAU,IAAV,CAAe,CAAf,CAAT,CAA5B,CAAzB;AACA;;AAED,UAAI,UAAU,IAAV,CAAe,CAAf,KAAqB,CAAzB,EAA4B;AAC3B,iBAAU,YAAV,IAA0B,QAA1B;AAEA,OAHD,MAGO,IAAI,UAAU,IAAV,CAAe,CAAf,KAAqB,CAAzB,EAA4B;AAClC,iBAAU,YAAV,IAA0B,QAA1B;AACA;;AAED;AACD,UAAK,IAAL;AAAW;AACV,gBAAU,IAAV,GAAiB,+BAAjB;AACA;AACD;AACC,gBAAU,IAAV,GAAiB,cAAc,KAAK,IAAL,CAAU,kBAAkB,CAA5B,EAA+B,QAA/B,CAAwC,EAAxC,CAA/B;AACA;AAnFF;;AAsFA,QAAI,SAAS,KAAK,IAAL,CAAU,KAAK,OAAL,GAAe,cAAf,GAAgC,CAA1C,CAAb;AACA;;AAEA,SAAK,OAAL,IAAgB,iBAAiB,CAAjB,GAAqB,MAArC;AAEA,IAlGD,MAkGO,IAAG,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAjC,EAAuC;AAC7C;AACA,cAAU,IAAV,GAAiB,OAAjB;AACA,QAAI,SAAS,KAAK,IAAL,CAAU,KAAK,OAAL,GAAe,cAAf,GAAgC,CAA1C,CAAb;AACA,SAAK,OAAL,IAAgB,iBAAiB,CAAjB,GAAqB,MAArC;AAEA,IANM,MAMA;AACN;AACA,QAAI,KAAK,IAAL,CAAU,eAAV,IAA6B,IAAjC,EAAuC;AACtC;AACA,eAAU,OAAV,GAAoB,IAApB;AACA,eAAU,UAAV,GAAuB,KAAK,IAAL,CAAU,eAAV,CAAvB;AACA,eAAU,QAAV,GAAqB,UAAU,KAAV,CAAgB,KAAK,IAAL,CAAU,eAAV,CAAhB,CAArB;AACA,eAAU,QAAV,GAAqB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAArB;;AAEA,SAAI,KAAK,UAAL,IAAmB,IAAvB,EAA6B;AAC5B,gBAAU,IAAV,GAAiB,UAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AAEA,MAJD,MAIO,IAAI,KAAK,UAAL,IAAmB,IAAvB,EAA6B;AACnC,gBAAU,IAAV,GAAiB,SAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA;;AAED,UAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,KAlBD,MAkBO;AACN,UAAK,UAAL,GAAkB,KAAK,IAAL,CAAU,eAAV,CAAlB;;AAEA,SAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AACvC;AACA,gBAAU,IAAV,GAAiB,UAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA,gBAAU,UAAV,GAAuB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAvB;AACA,gBAAU,QAAV,GAAqB,UAAU,KAAV,CAAgB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAhB,CAArB;AACA,gBAAU,QAAV,GAAqB,KAAK,KAAL,CAAW,KAAK,IAAL,CAAU,kBAAkB,CAA5B,IAAiC,GAAjC,GAAuC,GAAlD,CAArB;AACA,WAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,MATD,MASO,IAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AAC9C;AACA,gBAAU,IAAV,GAAiB,SAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA,gBAAU,UAAV,GAAuB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAvB;AACA,gBAAU,QAAV,GAAqB,UAAU,KAAV,CAAgB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAhB,CAArB;AACA,gBAAU,QAAV,GAAqB,KAAK,KAAL,CAAW,KAAK,IAAL,CAAU,kBAAkB,CAA5B,IAAiC,GAAjC,GAAuC,GAAlD,CAArB;AACA,WAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,MATM,MASA,IAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AAC9C;AACA,gBAAU,IAAV,GAAiB,yBAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA,gBAAU,IAAV,GAAiB,UAAU,KAAV,CAAgB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAhB,CAAjB;AACA,gBAAU,QAAV,GAAqB,MAAM,CAAN,CAArB;AACA,WAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,MARM,MAQA,IAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AAC9C;AACA,gBAAU,IAAV,GAAiB,mBAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA,gBAAU,MAAV,GAAmB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAnB;AACA,gBAAU,KAAV,GAAkB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAlB;AACA,WAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,MARM,MAQA,IAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AAC9C;AACA,gBAAU,IAAV,GAAiB,gBAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA,gBAAU,KAAV,GAAkB,KAAK,IAAL,CAAU,kBAAkB,CAA5B,CAAlB;AACA,WAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,MAPM,MAOA,IAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AAC9C;AACA,gBAAU,IAAV,GAAiB,sBAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA,WAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,MANM,MAMA,IAAI,KAAK,IAAL,CAAU,eAAV,KAA8B,IAAlC,EAAwC;AAC9C;AACA,gBAAU,IAAV,GAAiB,YAAjB;AACA,gBAAU,OAAV,GAAoB,KAAK,UAAL,GAAkB,IAAlB,GAAyB,CAA7C;AACA,WAAK,OAAL,IAAgB,iBAAiB,CAAjC;AAEA,MANM,MAMA;AACN,gBAAU,IAAV,GAAiB,wBAAwB,KAAK,OAAL,CAAa,QAAb,EAAxB,GAAkD,GAAlD,GAAyD,gBAAgB,QAAhB,EAAzD,GAAsF,GAAtF,GAA4F,KAAK,IAAL,CAAU,MAAvH;AACA;AACD;AACD;;AAED,QAAK,KAAL,IAAc,UAAU,KAAxB;AACA,QAAK,MAAL,CAAY,IAAZ,CAAiB,SAAjB;;AAEA,UAAO,SAAP;AACA;;AAED;;;;;;;+BAIa;AACZ,OAAI,KAAK,IAAL,CAAU,KAAK,OAAL,GAAe,CAAzB,KAA+B,IAA/B,IAAuC,KAAK,IAAL,CAAU,KAAK,OAAL,GAAe,CAAzB,KAA+B,IAAtE,IAA8E,KAAK,IAAL,CAAU,KAAK,OAAL,GAAe,CAAzB,KAA+B,IAAjH,EAAuH;AACtH,WAAO,IAAP;AACA;;AAED,UAAO,KAAP;AACA;;;;;;AAGF,OAAO,OAAP,CAAe,KAAf,GAAuB,KAAvB;;;;;;;;;;ACnXA;;;IAGM,K;;;;;;;;;AAEL;;;;;4BAKiB,I,EAAM;AACtB;AACA,UAAO,CAAC,MAAM,KAAK,QAAL,CAAc,EAAd,CAAP,EAA0B,KAA1B,CAAgC,CAAC,CAAjC,CAAP;AACA;;AAED;;;;;;;;6BAKkB,S,EAAW;AAC5B,OAAI,MAAM,EAAV;AACA,aAAU,OAAV,CAAkB;AAAA,WAAQ,IAAI,IAAJ,CAAS,MAAM,SAAN,CAAgB,IAAhB,CAAT,CAAR;AAAA,IAAlB;AACA,UAAO,IAAI,IAAJ,CAAS,EAAT,CAAP;AACA;;AAED;;;;;;;;8BAKmB,S,EAAW;AAC7B,UAAO,SAAS,SAAT,EAAoB,EAApB,CAAP;AACA;;AAED;;;;;;;;gCAKqB,S,EAAW;AAC/B,UAAO,MAAM,WAAN,CAAkB,MAAM,UAAN,CAAiB,SAAjB,CAAlB,CAAP;AACA;;AAED;;;;;;;;iCAKsB,S,EAAW;AAChC,OAAI,UAAU,EAAd;AACA,aAAU,OAAV,CAAkB;AAAA,WAAQ,QAAQ,IAAR,CAAa,OAAO,YAAP,CAAoB,IAApB,CAAb,CAAR;AAAA,IAAlB;AACA,UAAO,QAAQ,IAAR,CAAa,EAAb,CAAP;AACA;;AAED;;;;;;;;8BAKmB,G,EAAK;AACpB,UAAO,CAAC,QAAQ,CAAT,EAAY,QAAZ,CAAqB,CAArB,CAAP;AACH;;AAED;;;;;;;;6BAKkB,S,EAAW;AAC5B,OAAI,SAAS,CAAb;AACA,aAAU,OAAV,CAAkB,kBAAU;AAC3B,QAAI,IAAI,MAAR;AACA,QAAI,IAAI,IAAR,EAAc;AACb,eAAW,IAAI,IAAf;AACA,gBAAW,CAAX;AACA,KAHD,MAGO;AACN;AACA,eAAU,CAAV;AACA;AACD,IATD;;AAWA,UAAO,MAAP;AACA;;AAED;;;;;;;;;;;;;;;;;;cAKY,M,EAAQ;AACnB,OAAI,OAAO,IAAP,KAAgB,UAApB,EAAgC,OAAO,KAAK,MAAL,CAAP;AAChC,UAAO,IAAI,MAAJ,CAAW,MAAX,EAAmB,QAAnB,EAA6B,QAA7B,CAAsC,QAAtC,CAAP;AACA,G;;;;;;AAGF,QAAQ,KAAR,GAAgB,KAAhB","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){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}return e})()","/**\n * Constants used in player.\n */\nvar Constants = {\n\tVERSION: '2.0.3',\n\tNOTES: [],\n\tCIRCLE_OF_FOURTHS: ['C', 'F', 'Bb', 'Eb', 'Ab', 'Db', 'Gb', 'Cb', 'Fb', 'Bbb', 'Ebb', 'Abb'],\n\tCIRCLE_OF_FIFTHS: ['C', 'G', 'D', 'A', 'E', 'B', 'F#', 'C#', 'G#', 'D#', 'A#', 'E#']\n};\n\n// Builds notes object for reference against binary values.\nvar allNotes = [['C'], ['C#','Db'], ['D'], ['D#','Eb'], ['E'],['F'], ['F#','Gb'], ['G'], ['G#','Ab'], ['A'], ['A#','Bb'], ['B']];\nvar counter = 0;\n\n// All available octaves.\nfor (let i = -1; i <= 9; i++) {\n\tallNotes.forEach(noteGroup => {\n\t\tnoteGroup.forEach(note => Constants.NOTES[counter] = note + i);\n\t\tcounter ++;\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\t// FF 58 04 nn dd cc bb\n\t\t\t\t\teventJson.name = 'Time Signature';\n\t\t\t\t\teventJson.data = this.data.subarray(eventStartIndex + 3, eventStartIndex + 7);\n\t\t\t\t\teventJson.timeSignature = \"\" + eventJson.data[0] + \"/\" + Math.pow(eventJson.data[1], 2);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 0x59: // Key Signature\n\t\t\t\t\t// FF 59 02 sf mi\n\t\t\t\t\teventJson.name = 'Key Signature';\n\t\t\t\t\teventJson.data = this.data.subarray(eventStartIndex + 3, eventStartIndex + 5);\n\n\t\t\t\t\tif (eventJson.data[0] >= 0) {\n\t\t\t\t\t\teventJson.keySignature = Constants.CIRCLE_OF_FIFTHS[eventJson.data[0]];\n\n\t\t\t\t\t} else if (eventJson.data[0] < 0) {\n\t\t\t\t\t\teventJson.keySignature = Constants.CIRCLE_OF_FOURTHS[Math.abs(eventJson.data[0])];\n\t\t\t\t\t}\n\n\t\t\t\t\tif (eventJson.data[1] == 0) {\n\t\t\t\t\t\teventJson.keySignature += \" Major\";\n\n\t\t\t\t\t} else if (eventJson.data[1] == 1) {\n\t\t\t\t\t\teventJson.keySignature += \" Minor\";\n\t\t\t\t\t}\n\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;"]}
|