dist.js

module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 11);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

var microee = __webpack_require__(13);

// Implements a subset of Node's stream.Transform - in a cross-platform manner.
function Transform() {}

microee.mixin(Transform);

// The write() signature is different from Node's
// --> makes it much easier to work with objects in logs.
// One of the lessons from v1 was that it's better to target
// a good browser rather than the lowest common denominator
// internally.
// If you want to use external streams, pipe() to ./stringify.js first.
Transform.prototype.write = function(name, level, args) {
  this.emit('item', name, level, args);
};

Transform.prototype.end = function() {
  this.emit('end');
  this.removeAllListeners();
};

Transform.prototype.pipe = function(dest) {
  var s = this;
  // prevent double piping
  s.emit('unpipe', dest);
  // tell the dest that it's being piped to
  dest.emit('pipe', s);

  function onItem() {
    dest.write.apply(dest, Array.prototype.slice.call(arguments));
  }
  function onEnd() { !dest._isStdio && dest.end(); }

  s.on('item', onItem);
  s.on('end', onEnd);

  s.when('unpipe', function(from) {
    var match = (from === dest) || typeof from == 'undefined';
    if(match) {
      s.removeListener('item', onItem);
      s.removeListener('end', onEnd);
      dest.emit('unpipe');
    }
    return match;
  });

  return dest;
};

Transform.prototype.unpipe = function(from) {
  this.emit('unpipe', from);
  return this;
};

Transform.prototype.format = function(dest) {
  throw new Error([
    'Warning: .format() is deprecated in Minilog v2! Use .pipe() instead. For example:',
    'var Minilog = require(\'minilog\');',
    'Minilog',
    '  .pipe(Minilog.backends.console.formatClean)',
    '  .pipe(Minilog.backends.console);'].join('\n'));
};

Transform.mixin = function(dest) {
  var o = Transform.prototype, k;
  for (k in o) {
    o.hasOwnProperty(k) && (dest.prototype[k] = o[k]);
  }
};

module.exports = Transform;


/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var minilog = __webpack_require__(20);
minilog.enable();

module.exports = minilog('scratch-audioengine');

/***/ }),
/* 2 */
/***/ (function(module, exports) {

var hex = {
  black: '#000',
  red: '#c23621',
  green: '#25bc26',
  yellow: '#bbbb00',
  blue:  '#492ee1',
  magenta: '#d338d3',
  cyan: '#33bbc8',
  gray: '#808080',
  purple: '#708'
};
function color(fg, isInverse) {
  if(isInverse) {
    return 'color: #fff; background: '+hex[fg]+';';
  } else {
    return 'color: '+hex[fg]+';';
  }
}

module.exports = color;


/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var window = __webpack_require__(12)

var OfflineContext = window.OfflineAudioContext || window.webkitOfflineAudioContext
var Context = window.AudioContext || window.webkitAudioContext

var cache = {}

module.exports = function getContext (options) {
	if (!Context) return null

	if (typeof options === 'number') {
		options = {sampleRate: options}
	}

	var sampleRate = options && options.sampleRate


	if (options && options.offline) {
		if (!OfflineContext) return null

		return new OfflineContext(options.channels || 2, options.length, sampleRate || 44100)
	}


	//cache by sampleRate, rather strong guess
	var ctx = cache[sampleRate]

	if (ctx) return ctx

	//several versions of firefox have issues with the
	//constructor argument
	//see: https://bugzilla.mozilla.org/show_bug.cgi?id=1361475
	try {
		ctx = new Context(options)
	}
	catch (err) {
		ctx = new Context()
	}
	cache[ctx.sampleRate] = cache[sampleRate] = ctx

	return ctx
}


/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"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 ArrayBufferStream = __webpack_require__(10);
var log = __webpack_require__(1);

/**
 * Decode wav audio files that have been compressed with the ADPCM format.
 * This is necessary because, while web browsers have native decoders for many audio
 * formats, ADPCM is a non-standard format used by Scratch since its early days.
 * This decoder is based on code from Scratch-Flash:
 * https://github.com/LLK/scratch-flash/blob/master/src/sound/WAVFile.as
 */

var ADPCMSoundDecoder = function () {
    /**
     * @param {AudioContext} audioContext - a webAudio context
     * @constructor
     */
    function ADPCMSoundDecoder(audioContext) {
        _classCallCheck(this, ADPCMSoundDecoder);

        this.audioContext = audioContext;
    }
    /**
     * Data used by the decompression algorithm
     * @type {Array}
     */


    _createClass(ADPCMSoundDecoder, [{
        key: 'decode',


        /**
         * Decode an ADPCM sound stored in an ArrayBuffer and return a promise
         * with the decoded audio buffer.
         * @param  {ArrayBuffer} audioData - containing ADPCM encoded wav audio
         * @return {AudioBuffer} the decoded audio buffer
         */
        value: function decode(audioData) {
            var _this = this;

            return new Promise(function (resolve, reject) {
                var stream = new ArrayBufferStream(audioData);

                var riffStr = stream.readUint8String(4);
                if (riffStr !== 'RIFF') {
                    log.warn('incorrect adpcm wav header');
                    reject();
                }

                var lengthInHeader = stream.readInt32();
                if (lengthInHeader + 8 !== audioData.byteLength) {
                    log.warn('adpcm wav length in header: ' + lengthInHeader + ' is incorrect');
                }

                var wavStr = stream.readUint8String(4);
                if (wavStr !== 'WAVE') {
                    log.warn('incorrect adpcm wav header');
                    reject();
                }

                var formatChunk = _this.extractChunk('fmt ', stream);
                _this.encoding = formatChunk.readUint16();
                _this.channels = formatChunk.readUint16();
                _this.samplesPerSecond = formatChunk.readUint32();
                _this.bytesPerSecond = formatChunk.readUint32();
                _this.blockAlignment = formatChunk.readUint16();
                _this.bitsPerSample = formatChunk.readUint16();
                formatChunk.position += 2; // skip extra header byte count
                _this.samplesPerBlock = formatChunk.readUint16();
                _this.adpcmBlockSize = (_this.samplesPerBlock - 1) / 2 + 4; // block size in bytes

                var samples = _this.imaDecompress(_this.extractChunk('data', stream), _this.adpcmBlockSize);

                var buffer = _this.audioContext.createBuffer(1, samples.length, _this.samplesPerSecond);

                // @todo optimize this? e.g. replace the divide by storing 1/32768 and multiply?
                for (var i = 0; i < samples.length; i++) {
                    buffer.getChannelData(0)[i] = samples[i] / 32768;
                }

                resolve(buffer);
            });
        }

        /**
         * Extract a chunk of audio data from the stream, consisting of a set of audio data bytes
         * @param  {string} chunkType - the type of chunk to extract. 'data' or 'fmt' (format)
         * @param  {ArrayBufferStream} stream - an stream containing the audio data
         * @return {ArrayBufferStream} a stream containing the desired chunk
         */

    }, {
        key: 'extractChunk',
        value: function extractChunk(chunkType, stream) {
            stream.position = 12;
            while (stream.position < stream.getLength() - 8) {
                var typeStr = stream.readUint8String(4);
                var chunkSize = stream.readInt32();
                if (typeStr === chunkType) {
                    var chunk = stream.extract(chunkSize);
                    return chunk;
                }
                stream.position += chunkSize;
            }
        }

        /**
         * Decompress sample data using the IMA ADPCM algorithm.
         * Note: Handles only one channel, 4-bits per sample.
         * @param  {ArrayBufferStream} compressedData - a stream of compressed audio samples
         * @param  {number} blockSize - the number of bytes in the stream
         * @return {Int16Array} the uncompressed audio samples
         */

    }, {
        key: 'imaDecompress',
        value: function imaDecompress(compressedData, blockSize) {
            var sample = void 0;
            var step = void 0;
            var code = void 0;
            var delta = void 0;
            var index = 0;
            var lastByte = -1; // -1 indicates that there is no saved lastByte
            var out = [];

            // Bail and return no samples if we have no data
            if (!compressedData) return out;

            compressedData.position = 0;

            // @todo Update this loop ported from Scratch 2.0 to use a condition or a for loop.
            while (true) {
                // eslint-disable-line no-constant-condition
                if (compressedData.position % blockSize === 0 && lastByte < 0) {
                    // read block header
                    if (compressedData.getBytesAvailable() === 0) break;
                    sample = compressedData.readInt16();
                    index = compressedData.readUint8();
                    compressedData.position++; // skip extra header byte
                    if (index > 88) index = 88;
                    out.push(sample);
                } else {
                    // read 4-bit code and compute delta from previous sample
                    if (lastByte < 0) {
                        if (compressedData.getBytesAvailable() === 0) break;
                        lastByte = compressedData.readUint8();
                        code = lastByte & 0xF;
                    } else {
                        code = lastByte >> 4 & 0xF;
                        lastByte = -1;
                    }
                    step = ADPCMSoundDecoder.STEP_TABLE[index];
                    delta = 0;
                    if (code & 4) delta += step;
                    if (code & 2) delta += step >> 1;
                    if (code & 1) delta += step >> 2;
                    delta += step >> 3;
                    // compute next index
                    index += ADPCMSoundDecoder.INDEX_TABLE[code];
                    if (index > 88) index = 88;
                    if (index < 0) index = 0;
                    // compute and output sample
                    sample += code & 8 ? -delta : delta;
                    if (sample > 32767) sample = 32767;
                    if (sample < -32768) sample = -32768;
                    out.push(sample);
                }
            }
            var samples = Int16Array.from(out);
            return samples;
        }
    }], [{
        key: 'STEP_TABLE',
        get: function get() {
            return [7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767];
        }

        /**
         * Data used by the decompression algorithm
         * @type {Array}
         */

    }, {
        key: 'INDEX_TABLE',
        get: function get() {
            return [-1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8];
        }
    }]);

    return ADPCMSoundDecoder;
}();

module.exports = ADPCMSoundDecoder;

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"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 log = __webpack_require__(1);

/**
 * A SoundPlayer stores an audio buffer, and plays it
 */

var SoundPlayer = function () {
    /**
     * @param {AudioContext} audioContext - a webAudio context
     * @constructor
     */
    function SoundPlayer(audioContext) {
        _classCallCheck(this, SoundPlayer);

        this.audioContext = audioContext;
        this.outputNode = null;
        this.buffer = null;
        this.bufferSource = null;
        this.playbackRate = 1;
        this.isPlaying = false;
    }

    /**
     * Connect the SoundPlayer to an output node
     * @param {GainNode} node - an output node to connect to
     */


    _createClass(SoundPlayer, [{
        key: 'connect',
        value: function connect(node) {
            this.outputNode = node;
        }

        /**
         * Set an audio buffer
         * @param {AudioBuffer} buffer - Buffer to set
         */

    }, {
        key: 'setBuffer',
        value: function setBuffer(buffer) {
            this.buffer = buffer;
        }

        /**
         * Set the playback rate for the sound
         * @param {number} playbackRate - a ratio where 1 is normal playback, 0.5 is half speed, 2 is double speed, etc.
         */

    }, {
        key: 'setPlaybackRate',
        value: function setPlaybackRate(playbackRate) {
            this.playbackRate = playbackRate;
            if (this.bufferSource && this.bufferSource.playbackRate) {
                this.bufferSource.playbackRate.value = this.playbackRate;
            }
        }

        /**
         * Stop the sound
         */

    }, {
        key: 'stop',
        value: function stop() {
            if (this.bufferSource && this.isPlaying) {
                this.bufferSource.stop();
            }
            this.isPlaying = false;
        }

        /**
         * Start playing the sound
         * The web audio framework requires a new audio buffer source node for each playback
         */

    }, {
        key: 'start',
        value: function start() {
            if (!this.buffer) {
                log.warn('tried to play a sound that was not loaded yet');
                return;
            }

            this.bufferSource = this.audioContext.createBufferSource();
            this.bufferSource.buffer = this.buffer;
            this.bufferSource.playbackRate.value = this.playbackRate;
            this.bufferSource.connect(this.outputNode);
            this.bufferSource.start();

            this.isPlaying = true;
        }

        /**
         * The sound has finished playing. This is called at the correct time even if the playback rate
         * has been changed
         * @return {Promise} a Promise that resolves when the sound finishes playing
         */

    }, {
        key: 'finished',
        value: function finished() {
            var _this = this;

            return new Promise(function (resolve) {
                _this.bufferSource.onended = function () {
                    _this.isPlaying = false;
                    resolve();
                };
            });
        }
    }]);

    return SoundPlayer;
}();

module.exports = SoundPlayer;

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"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"); } }

/**
* A pan effect, which moves the sound to the left or right between the speakers
* Effect value of -100 puts the audio entirely on the left channel,
* 0 centers it, 100 puts it on the right.
*/
var PanEffect = function () {
    /**
    * @param {AudioEngine} audioEngine - the audio engine.
    * @constructor
    */
    function PanEffect(audioEngine) {
        _classCallCheck(this, PanEffect);

        this.audioEngine = audioEngine;
        this.audioContext = this.audioEngine.audioContext;
        this.value = 0;

        this.input = this.audioContext.createGain();
        this.leftGain = this.audioContext.createGain();
        this.rightGain = this.audioContext.createGain();
        this.channelMerger = this.audioContext.createChannelMerger(2);

        this.input.connect(this.leftGain);
        this.input.connect(this.rightGain);
        this.leftGain.connect(this.channelMerger, 0, 0);
        this.rightGain.connect(this.channelMerger, 0, 1);

        this.set(this.value);
    }

    /**
    * Set the effect value
    * @param {number} val - the new value to set the effect to
    */


    _createClass(PanEffect, [{
        key: "set",
        value: function set(val) {
            this.value = val;

            // Map the scratch effect value (-100 to 100) to (0 to 1)
            var p = (val + 100) / 200;

            // Use trig functions for equal-loudness panning
            // See e.g. https://docs.cycling74.com/max7/tutorials/13_panningchapter01
            var leftVal = Math.cos(p * Math.PI / 2);
            var rightVal = Math.sin(p * Math.PI / 2);

            this.leftGain.gain.setTargetAtTime(leftVal, 0, this.audioEngine.DECAY_TIME);
            this.rightGain.gain.setTargetAtTime(rightVal, 0, this.audioEngine.DECAY_TIME);
        }

        /**
         * Connnect this effect's output to another audio node
         * @param {AudioNode} node - the node to connect to
         */

    }, {
        key: "connect",
        value: function connect(node) {
            this.channelMerger.connect(node);
        }

        /**
         * Clean up and disconnect audio nodes.
         */

    }, {
        key: "dispose",
        value: function dispose() {
            this.input.disconnect();
            this.leftGain.disconnect();
            this.rightGain.disconnect();
            this.channelMerger.disconnect();
        }
    }]);

    return PanEffect;
}();

module.exports = PanEffect;

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"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"); } }

/**
* A pitch change effect, which changes the playback rate of the sound in order
* to change its pitch: reducing the playback rate lowers the pitch, increasing the rate
* raises the pitch. The duration of the sound is also changed.
*
* Changing the value of the pitch effect by 10 causes a change in pitch by 1 semitone
* (i.e. a musical half-step, such as the difference between C and C#)
* Changing the pitch effect by 120 changes the pitch by one octave (12 semitones)
*
* The value of this effect is not clamped (i.e. it is typically between -120 and 120,
* but can be set much higher or much lower, with weird and fun results).
* We should consider what extreme values to use for clamping it.
*
* Note that this effect functions differently from the other audio effects. It is
* not part of a chain of audio nodes. Instead, it provides a way to set the playback
* on one SoundPlayer or a group of them.
*/
var PitchEffect = function () {
    function PitchEffect() {
        _classCallCheck(this, PitchEffect);

        this.value = 0; // effect value
        this.ratio = 1; // the playback rate ratio
    }

    /**
    * Set the effect value
    * @param {number} val - the new value to set the effect to
    * @param {object} players - a dictionary of SoundPlayer objects to apply the effect to, indexed by md5
    */


    _createClass(PitchEffect, [{
        key: "set",
        value: function set(val, players) {
            this.value = val;
            this.ratio = this.getRatio(this.value);
            this.updatePlayers(players);
        }

        /**
        * Change the effect value
        * @param {number} val - the value to change the effect by
        * @param {object} players - a dictionary of SoundPlayer objects indexed by md5
        */

    }, {
        key: "changeBy",
        value: function changeBy(val, players) {
            this.set(this.value + val, players);
        }

        /**
        * Compute the playback ratio for an effect value.
        * The playback ratio is scaled so that a change of 10 in the effect value
        * gives a change of 1 semitone in the ratio.
        * @param {number} val - an effect value
        * @returns {number} a playback ratio
        */

    }, {
        key: "getRatio",
        value: function getRatio(val) {
            var interval = val / 10;
            // Convert the musical interval in semitones to a frequency ratio
            return Math.pow(2, interval / 12);
        }

        /**
        * Update a sound player's playback rate using the current ratio for the effect
        * @param {object} player - a SoundPlayer object
        */

    }, {
        key: "updatePlayer",
        value: function updatePlayer(player) {
            player.setPlaybackRate(this.ratio);
        }

        /**
        * Update a sound player's playback rate using the current ratio for the effect
        * @param {object} players - a dictionary of SoundPlayer objects to update, indexed by md5
        */

    }, {
        key: "updatePlayers",
        value: function updatePlayers(players) {
            if (!players) return;

            for (var md5 in players) {
                if (players.hasOwnProperty(md5)) {
                    this.updatePlayer(players[md5]);
                }
            }
        }
    }]);

    return PitchEffect;
}();

module.exports = PitchEffect;

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


/**
 * @fileoverview UID generator, from Blockly.
 */

/**
 * Legal characters for the unique ID.
 * Should be all on a US keyboard.  No XML special characters or control codes.
 * Removed $ due to issue 251.
 * @private
 */
var soup_ = '!#%()*+,-./:;=?@[]^_`{|}~' + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

/**
 * Generate a unique ID, from Blockly.  This should be globally unique.
 * 87 characters ^ 20 length > 128 bits (better than a UUID).
 * @return {string} A globally unique ID string.
 */
var uid = function uid() {
  var length = 20;
  var soupLength = soup_.length;
  var id = [];
  for (var i = 0; i < length; i++) {
    id[i] = soup_.charAt(Math.random() * soupLength);
  }
  return id.join('');
};

module.exports = uid;

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 *  StartAudioContext.js
 *  @author Yotam Mann
 *  @license http://opensource.org/licenses/MIT MIT License
 *  @copyright 2016 Yotam Mann
 */
(function (root, factory) {
	if (true) {
		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))
	 } else if (typeof module === "object" && module.exports) {
        module.exports = factory()
	} else {
		root.StartAudioContext = factory()
  }
}(this, function () {

	//TAP LISTENER/////////////////////////////////////////////////////////////

	/**
	 * @class  Listens for non-dragging tap ends on the given element
	 * @param {Element} element
	 * @internal
	 */
	var TapListener = function(element, context){

		this._dragged = false

		this._element = element

		this._bindedMove = this._moved.bind(this)
		this._bindedEnd = this._ended.bind(this, context)

		element.addEventListener("touchstart", this._bindedEnd)
		element.addEventListener("touchmove", this._bindedMove)
		element.addEventListener("touchend", this._bindedEnd)
		element.addEventListener("mouseup", this._bindedEnd)
	}

	/**
	 * drag move event
	 */
	TapListener.prototype._moved = function(e){
		this._dragged = true
	};

	/**
	 * tap ended listener
	 */
	TapListener.prototype._ended = function(context){
		if (!this._dragged){
			startContext(context)
		}
		this._dragged = false
	};

	/**
	 * remove all the bound events
	 */
	TapListener.prototype.dispose = function(){
		this._element.removeEventListener("touchstart", this._bindedEnd)
		this._element.removeEventListener("touchmove", this._bindedMove)
		this._element.removeEventListener("touchend", this._bindedEnd)
		this._element.removeEventListener("mouseup", this._bindedEnd)
		this._bindedMove = null
		this._bindedEnd = null
		this._element = null
	};

	//END TAP LISTENER/////////////////////////////////////////////////////////

	/**
	 * Plays a silent sound and also invoke the "resume" method
	 * @param {AudioContext} context
	 * @private
	 */
	function startContext(context){
		// this accomplishes the iOS specific requirement
		var buffer = context.createBuffer(1, 1, context.sampleRate)
		var source = context.createBufferSource()
		source.buffer = buffer
		source.connect(context.destination)
		source.start(0)

		// resume the audio context
		if (context.resume){
			context.resume()
		}
	}

	/**
	 * Returns true if the audio context is started
	 * @param  {AudioContext}  context
	 * @return {Boolean}
	 * @private
	 */
	function isStarted(context){
		 return context.state === "running"
	}

	/**
	 * Invokes the callback as soon as the AudioContext
	 * is started
	 * @param  {AudioContext}   context
	 * @param  {Function} callback
	 */
	function onStarted(context, callback){

		function checkLoop(){
			if (isStarted(context)){
				callback()
			} else {
				requestAnimationFrame(checkLoop)
				if (context.resume){
					context.resume()
				}
			}
		}

		if (isStarted(context)){
			callback()
		} else {
			checkLoop()
		}
	}

	/**
	 * Add a tap listener to the audio context
	 * @param  {Array|Element|String|jQuery} element
	 * @param {Array} tapListeners
	 */
	function bindTapListener(element, tapListeners, context){
		if (Array.isArray(element) || (NodeList && element instanceof NodeList)){
			for (var i = 0; i < element.length; i++){
				bindTapListener(element[i], tapListeners, context)
			}
		} else if (typeof element === "string"){
			bindTapListener(document.querySelectorAll(element), tapListeners, context)
		} else if (element.jquery && typeof element.toArray === "function"){
			bindTapListener(element.toArray(), tapListeners, context)
		} else if (Element && element instanceof Element){
			//if it's an element, create a TapListener
			var tap = new TapListener(element, context)
			tapListeners.push(tap)
		} 
	}

	/**
	 * @param {AudioContext} context The AudioContext to start.
	 * @param {Array|String|Element|jQuery=} elements For iOS, the list of elements
	 *                                               to bind tap event listeners
	 *                                               which will start the AudioContext. If
	 *                                               no elements are given, it will bind
	 *                                               to the document.body.
	 * @param {Function=} callback The callback to invoke when the AudioContext is started.
	 * @return {Promise} The promise is invoked when the AudioContext
	 *                       is started.
	 */
	function StartAudioContext(context, elements, callback){

		//the promise is invoked when the AudioContext is started
		var promise = new Promise(function(success) {
			onStarted(context, success)
		})

		// The TapListeners bound to the elements
		var tapListeners = []

		// add all the tap listeners
		if (!elements){
			elements = document.body
		}
		bindTapListener(elements, tapListeners, context)

		//dispose all these tap listeners when the context is started
		promise.then(function(){
			for (var i = 0; i < tapListeners.length; i++){
				tapListeners[i].dispose()
			}
			tapListeners = null

			if (callback){
				callback()
			}
		})

		return promise
	}

	return StartAudioContext
}))

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

"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 ArrayBufferStream = function () {
    /**
     * ArrayBufferStream wraps the built-in javascript ArrayBuffer, adding the ability to access
     * data in it like a stream, tracking its position.
     * You can request to read a value from the front of the array, and it will keep track of the position
     * within the byte array, so that successive reads are consecutive.
     * The available types to read include:
     * Uint8, Uint8String, Int16, Uint16, Int32, Uint32
     * @param {ArrayBuffer} arrayBuffer - array to use as a stream
     * @constructor
     */
    function ArrayBufferStream(arrayBuffer) {
        _classCallCheck(this, ArrayBufferStream);

        this.arrayBuffer = arrayBuffer;
        this.position = 0;
    }

    /**
     * Return a new ArrayBufferStream that is a slice of the existing one
     * @param  {number} length - the number of bytes of extract
     * @return {ArrayBufferStream} the extracted stream
     */


    _createClass(ArrayBufferStream, [{
        key: 'extract',
        value: function extract(length) {
            var slicedArrayBuffer = this.arrayBuffer.slice(this.position, this.position + length);
            var newStream = new ArrayBufferStream(slicedArrayBuffer);
            return newStream;
        }

        /**
         * @return {number} the length of the stream in bytes
         */

    }, {
        key: 'getLength',
        value: function getLength() {
            return this.arrayBuffer.byteLength;
        }

        /**
         * @return {number} the number of bytes available after the current position in the stream
         */

    }, {
        key: 'getBytesAvailable',
        value: function getBytesAvailable() {
            return this.arrayBuffer.byteLength - this.position;
        }

        /**
         * Read an unsigned 8 bit integer from the stream
         * @return {number} the next 8 bit integer in the stream
         */

    }, {
        key: 'readUint8',
        value: function readUint8() {
            var val = new Uint8Array(this.arrayBuffer, this.position, 1)[0];
            this.position += 1;
            return val;
        }

        /**
         * Read a sequence of bytes of the given length and convert to a string.
         * This is a convenience method for use with short strings.
         * @param {number} length - the number of bytes to convert
         * @return {string} a String made by concatenating the chars in the input
         */

    }, {
        key: 'readUint8String',
        value: function readUint8String(length) {
            var arr = new Uint8Array(this.arrayBuffer, this.position, length);
            this.position += length;
            var str = '';
            for (var i = 0; i < arr.length; i++) {
                str += String.fromCharCode(arr[i]);
            }
            return str;
        }

        /**
         * Read a 16 bit integer from the stream
         * @return {number} the next 16 bit integer in the stream
         */

    }, {
        key: 'readInt16',
        value: function readInt16() {
            var val = new Int16Array(this.arrayBuffer, this.position, 1)[0];
            this.position += 2; // one 16 bit int is 2 bytes
            return val;
        }

        /**
         * Read an unsigned 16 bit integer from the stream
         * @return {number} the next unsigned 16 bit integer in the stream
         */

    }, {
        key: 'readUint16',
        value: function readUint16() {
            var val = new Uint16Array(this.arrayBuffer, this.position, 1)[0];
            this.position += 2; // one 16 bit int is 2 bytes
            return val;
        }

        /**
         * Read a 32 bit integer from the stream
         * @return {number} the next 32 bit integer in the stream
         */

    }, {
        key: 'readInt32',
        value: function readInt32() {
            var val = new Int32Array(this.arrayBuffer, this.position, 1)[0];
            this.position += 4; // one 32 bit int is 4 bytes
            return val;
        }

        /**
         * Read an unsigned 32 bit integer from the stream
         * @return {number} the next unsigned 32 bit integer in the stream
         */

    }, {
        key: 'readUint32',
        value: function readUint32() {
            var val = new Uint32Array(this.arrayBuffer, this.position, 1)[0];
            this.position += 4; // one 32 bit int is 4 bytes
            return val;
        }
    }]);

    return ArrayBufferStream;
}();

module.exports = ArrayBufferStream;

/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

"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 StartAudioContext = __webpack_require__(9);
var AudioContext = __webpack_require__(3);

var log = __webpack_require__(1);
var uid = __webpack_require__(8);

var PitchEffect = __webpack_require__(7);
var PanEffect = __webpack_require__(6);

var SoundPlayer = __webpack_require__(5);
var ADPCMSoundDecoder = __webpack_require__(4);

/**
 * @fileOverview Scratch Audio is divided into a single AudioEngine,
 * that handles global functionality, and AudioPlayers, belonging to individual sprites and clones.
 */

var AudioPlayer = function () {
    /**
     * Each sprite or clone has an audio player
     * the audio player handles sound playback, volume, and the sprite-specific audio effects:
     * pitch and pan
     * @param {AudioEngine} audioEngine AudioEngine for player
     * @constructor
     */
    function AudioPlayer(audioEngine) {
        _classCallCheck(this, AudioPlayer);

        this.audioEngine = audioEngine;

        // Create the audio effects
        this.pitchEffect = new PitchEffect();
        this.panEffect = new PanEffect(this.audioEngine);

        // Chain the audio effects together
        // effectsNode -> panEffect -> audioEngine.input
        this.effectsNode = this.audioEngine.audioContext.createGain();
        this.effectsNode.connect(this.panEffect.input);
        this.panEffect.connect(this.audioEngine.input);

        // reset effects to their default parameters
        this.clearEffects();

        // sound players that are currently playing, indexed by the sound's soundId
        this.activeSoundPlayers = {};
    }

    /**
     * Get this sprite's input node, so that other objects can route sound through it.
     * @return {AudioNode} the AudioNode for this sprite's input
     */


    _createClass(AudioPlayer, [{
        key: 'getInputNode',
        value: function getInputNode() {
            return this.effectsNode;
        }

        /**
         * Play a sound
         * @param  {string} soundId - the soundId id of a sound file
         * @return {Promise} a Promise that resolves when the sound finishes playing
         */

    }, {
        key: 'playSound',
        value: function playSound(soundId) {
            // if this sound is not in the audio engine, return
            if (!this.audioEngine.audioBuffers[soundId]) {
                return;
            }

            // if this sprite or clone is already playing this sound, stop it first
            if (this.activeSoundPlayers[soundId]) {
                this.activeSoundPlayers[soundId].stop();
            }

            // create a new soundplayer to play the sound
            var player = new SoundPlayer(this.audioEngine.audioContext);
            player.setBuffer(this.audioEngine.audioBuffers[soundId]);
            player.connect(this.effectsNode);
            this.pitchEffect.updatePlayer(player);
            player.start();

            // add it to the list of active sound players
            this.activeSoundPlayers[soundId] = player;

            // remove sounds that are not playing from the active sound players array
            for (var id in this.activeSoundPlayers) {
                if (this.activeSoundPlayers.hasOwnProperty(id)) {
                    if (!this.activeSoundPlayers[id].isPlaying) {
                        delete this.activeSoundPlayers[id];
                    }
                }
            }

            return player.finished();
        }

        /**
         * Stop all sounds that are playing
         */

    }, {
        key: 'stopAllSounds',
        value: function stopAllSounds() {
            // stop all active sound players
            for (var soundId in this.activeSoundPlayers) {
                this.activeSoundPlayers[soundId].stop();
            }
        }

        /**
         * Set an audio effect to a value
         * @param {string} effect - the name of the effect
         * @param {number} value - the value to set the effect to
         */

    }, {
        key: 'setEffect',
        value: function setEffect(effect, value) {
            switch (effect) {
                case this.audioEngine.EFFECT_NAMES.pitch:
                    this.pitchEffect.set(value, this.activeSoundPlayers);
                    break;
                case this.audioEngine.EFFECT_NAMES.pan:
                    this.panEffect.set(value);
                    break;
            }
        }

        /**
         * Clear all audio effects
         */

    }, {
        key: 'clearEffects',
        value: function clearEffects() {
            this.panEffect.set(0);
            this.pitchEffect.set(0, this.activeSoundPlayers);
            if (this.audioEngine === null) return;
            this.effectsNode.gain.setTargetAtTime(1.0, 0, this.audioEngine.DECAY_TIME);
        }

        /**
         * Set the volume for sounds played by this AudioPlayer
         * @param {number} value - the volume in range 0-100
         */

    }, {
        key: 'setVolume',
        value: function setVolume(value) {
            if (this.audioEngine === null) return;
            this.effectsNode.gain.setTargetAtTime(value / 100, 0, this.audioEngine.DECAY_TIME);
        }

        /**
         * Clean up and disconnect audio nodes.
         */

    }, {
        key: 'dispose',
        value: function dispose() {
            this.panEffect.dispose();
            this.effectsNode.disconnect();
        }
    }]);

    return AudioPlayer;
}();

/**
 * There is a single instance of the AudioEngine. It handles global audio properties and effects,
 * loads all the audio buffers for sounds belonging to sprites.
 */


var AudioEngine = function () {
    function AudioEngine() {
        _classCallCheck(this, AudioEngine);

        this.audioContext = new AudioContext();
        StartAudioContext(this.audioContext);

        this.input = this.audioContext.createGain();
        this.input.connect(this.audioContext.destination);

        // a map of soundIds to audio buffers, holding sounds for all sprites
        this.audioBuffers = {};

        // microphone, for measuring loudness, with a level meter analyzer
        this.mic = null;
    }

    /**
     * Names of the audio effects.
     * @enum {string}
     */


    _createClass(AudioEngine, [{
        key: 'decodeSound',


        /**
         * Decode a sound, decompressing it into audio samples.
         * Store a reference to it the sound in the audioBuffers dictionary, indexed by soundId
         * @param  {object} sound - an object containing audio data and metadata for a sound
         * @property {Buffer} data - sound data loaded from scratch-storage.
         * @property {string} format - format type, either empty or adpcm.
         * @returns {?Promise} - a promise which will resolve to the soundId if decoded and stored.
         */
        value: function decodeSound(sound) {
            var _this = this;

            var soundId = uid();
            var loaderPromise = null;

            // Make a copy of the buffer because decoding detaches the original buffer
            var bufferCopy = sound.data.buffer.slice(0);

            switch (sound.format) {
                case '':
                    // Check for newer promise-based API
                    if (this.audioContext.decodeAudioData.length === 1) {
                        loaderPromise = this.audioContext.decodeAudioData(bufferCopy);
                    } else {
                        // Fall back to callback API
                        loaderPromise = new Promise(function (resolve, reject) {
                            _this.audioContext.decodeAudioData(bufferCopy, function (decodedAudio) {
                                return resolve(decodedAudio);
                            }, function (error) {
                                return reject(error);
                            });
                        });
                    }
                    break;
                case 'adpcm':
                    loaderPromise = new ADPCMSoundDecoder(this.audioContext).decode(bufferCopy);
                    break;
                default:
                    return log.warn('unknown sound format', sound.format);
            }

            var storedContext = this;
            return loaderPromise.then(function (decodedAudio) {
                storedContext.audioBuffers[soundId] = decodedAudio;
                return soundId;
            }, function (error) {
                log.warn('audio data could not be decoded', error);
            });
        }

        /**
         * Retrieve the audio buffer as held in memory for a given sound id.
         * @param {!string} soundId - the id of the sound buffer to get
         * @return {AudioBuffer} the buffer corresponding to the given sound id.
         */

    }, {
        key: 'getSoundBuffer',
        value: function getSoundBuffer(soundId) {
            return this.audioBuffers[soundId];
        }

        /**
         * Update the in-memory audio buffer to a new one by soundId.
         * @param {!string} soundId - the id of the sound buffer to update.
         * @param {AudioBuffer} newBuffer - the new buffer to swap in.
         */

    }, {
        key: 'updateSoundBuffer',
        value: function updateSoundBuffer(soundId, newBuffer) {
            this.audioBuffers[soundId] = newBuffer;
        }

        /**
         * An older version of the AudioEngine had this function to load all sounds
         * This is a stub to provide a warning when it is called
         * @todo remove this
         */

    }, {
        key: 'loadSounds',
        value: function loadSounds() {
            log.warn('The loadSounds function is no longer available. Please use Scratch Storage.');
        }

        /**
         * Get the current loudness of sound received by the microphone.
         * Sound is measured in RMS and smoothed.
         * Some code adapted from Tone.js: https://github.com/Tonejs/Tone.js
         * @return {number} loudness scaled 0 to 100
         */

    }, {
        key: 'getLoudness',
        value: function getLoudness() {
            var _this2 = this;

            // The microphone has not been set up, so try to connect to it
            if (!this.mic && !this.connectingToMic) {
                this.connectingToMic = true; // prevent multiple connection attempts
                navigator.mediaDevices.getUserMedia({ audio: true }).then(function (stream) {
                    _this2.audioStream = stream;
                    _this2.mic = _this2.audioContext.createMediaStreamSource(stream);
                    _this2.analyser = _this2.audioContext.createAnalyser();
                    _this2.mic.connect(_this2.analyser);
                    _this2.micDataArray = new Float32Array(_this2.analyser.fftSize);
                }).catch(function (err) {
                    log.warn(err);
                });
            }

            // If the microphone is set up and active, measure the loudness
            if (this.mic && this.audioStream.active) {
                this.analyser.getFloatTimeDomainData(this.micDataArray);
                var sum = 0;
                // compute the RMS of the sound
                for (var i = 0; i < this.micDataArray.length; i++) {
                    sum += Math.pow(this.micDataArray[i], 2);
                }
                var rms = Math.sqrt(sum / this.micDataArray.length);
                // smooth the value, if it is descending
                if (this._lastValue) {
                    rms = Math.max(rms, this._lastValue * 0.6);
                }
                this._lastValue = rms;

                // Scale the measurement so it's more sensitive to quieter sounds
                rms *= 1.63;
                rms = Math.sqrt(rms);
                // Scale it up to 0-100 and round
                rms = Math.round(rms * 100);
                // Prevent it from going above 100
                rms = Math.min(rms, 100);
                return rms;
            }

            // if there is no microphone input, return -1
            return -1;
        }

        /**
         * Create an AudioPlayer. Each sprite or clone has an AudioPlayer.
         * It includes a reference to the AudioEngine so it can use global
         * functionality such as playing notes.
         * @return {AudioPlayer} new AudioPlayer instance
         */

    }, {
        key: 'createPlayer',
        value: function createPlayer() {
            return new AudioPlayer(this);
        }
    }, {
        key: 'EFFECT_NAMES',
        get: function get() {
            return {
                pitch: 'pitch',
                pan: 'pan'
            };
        }

        /**
         * A short duration, for use as a time constant for exponential audio parameter transitions.
         * See:
         * https://developer.mozilla.org/en-US/docs/Web/API/AudioParam/setTargetAtTime
         * @const {number}
         */

    }, {
        key: 'DECAY_TIME',
        get: function get() {
            return 0.001;
        }
    }]);

    return AudioEngine;
}();

module.exports = AudioEngine;

/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {var win;

if (typeof window !== "undefined") {
    win = window;
} else if (typeof global !== "undefined") {
    win = global;
} else if (typeof self !== "undefined"){
    win = self;
} else {
    win = {};
}

module.exports = win;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(23)))

/***/ }),
/* 13 */
/***/ (function(module, exports) {

function M() { this._events = {}; }
M.prototype = {
  on: function(ev, cb) {
    this._events || (this._events = {});
    var e = this._events;
    (e[ev] || (e[ev] = [])).push(cb);
    return this;
  },
  removeListener: function(ev, cb) {
    var e = this._events[ev] || [], i;
    for(i = e.length-1; i >= 0 && e[i]; i--){
      if(e[i] === cb || e[i].cb === cb) { e.splice(i, 1); }
    }
  },
  removeAllListeners: function(ev) {
    if(!ev) { this._events = {}; }
    else { this._events[ev] && (this._events[ev] = []); }
  },
  listeners: function(ev) {
    return (this._events ? this._events[ev] || [] : []);
  },
  emit: function(ev) {
    this._events || (this._events = {});
    var args = Array.prototype.slice.call(arguments, 1), i, e = this._events[ev] || [];
    for(i = e.length-1; i >= 0 && e[i]; i--){
      e[i].apply(this, args);
    }
    return this;
  },
  when: function(ev, cb) {
    return this.once(ev, cb, true);
  },
  once: function(ev, cb, when) {
    if(!cb) return this;
    function c() {
      if(!when) this.removeListener(ev, c);
      if(cb.apply(this, arguments) && when) this.removeListener(ev, c);
    }
    c.cb = cb;
    this.on(ev, c);
    return this;
  }
};
M.mixin = function(dest) {
  var o = M.prototype, k;
  for (k in o) {
    o.hasOwnProperty(k) && (dest.prototype[k] = o[k]);
  }
};
module.exports = M;


/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

// default filter
var Transform = __webpack_require__(0);

var levelMap = { debug: 1, info: 2, warn: 3, error: 4 };

function Filter() {
  this.enabled = true;
  this.defaultResult = true;
  this.clear();
}

Transform.mixin(Filter);

// allow all matching, with level >= given level
Filter.prototype.allow = function(name, level) {
  this._white.push({ n: name, l: levelMap[level] });
  return this;
};

// deny all matching, with level <= given level
Filter.prototype.deny = function(name, level) {
  this._black.push({ n: name, l: levelMap[level] });
  return this;
};

Filter.prototype.clear = function() {
  this._white = [];
  this._black = [];
  return this;
};

function test(rule, name) {
  // use .test for RegExps
  return (rule.n.test ? rule.n.test(name) : rule.n == name);
};

Filter.prototype.test = function(name, level) {
  var i, len = Math.max(this._white.length, this._black.length);
  for(i = 0; i < len; i++) {
    if(this._white[i] && test(this._white[i], name) && levelMap[level] >= this._white[i].l) {
      return true;
    }
    if(this._black[i] && test(this._black[i], name) && levelMap[level] <= this._black[i].l) {
      return false;
    }
  }
  return this.defaultResult;
};

Filter.prototype.write = function(name, level, args) {
  if(!this.enabled || this.test(name, level)) {
    return this.emit('item', name, level, args);
  }
};

module.exports = Filter;


/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

var Transform = __webpack_require__(0),
    Filter = __webpack_require__(14);

var log = new Transform(),
    slice = Array.prototype.slice;

exports = module.exports = function create(name) {
  var o   = function() { log.write(name, undefined, slice.call(arguments)); return o; };
  o.debug = function() { log.write(name, 'debug', slice.call(arguments)); return o; };
  o.info  = function() { log.write(name, 'info',  slice.call(arguments)); return o; };
  o.warn  = function() { log.write(name, 'warn',  slice.call(arguments)); return o; };
  o.error = function() { log.write(name, 'error', slice.call(arguments)); return o; };
  o.log   = o.debug; // for interface compliance with Node and browser consoles
  o.suggest = exports.suggest;
  o.format = log.format;
  return o;
};

// filled in separately
exports.defaultBackend = exports.defaultFormatter = null;

exports.pipe = function(dest) {
  return log.pipe(dest);
};

exports.end = exports.unpipe = exports.disable = function(from) {
  return log.unpipe(from);
};

exports.Transform = Transform;
exports.Filter = Filter;
// this is the default filter that's applied when .enable() is called normally
// you can bypass it completely and set up your own pipes
exports.suggest = new Filter();

exports.enable = function() {
  if(exports.defaultFormatter) {
    return log.pipe(exports.suggest) // filter
              .pipe(exports.defaultFormatter) // formatter
              .pipe(exports.defaultBackend); // backend
  }
  return log.pipe(exports.suggest) // filter
            .pipe(exports.defaultBackend); // formatter
};



/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

var Transform = __webpack_require__(0),
    cache = [ ];

var logger = new Transform();

logger.write = function(name, level, args) {
  cache.push([ name, level, args ]);
};

// utility functions
logger.get = function() { return cache; };
logger.empty = function() { cache = []; };

module.exports = logger;


/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

var Transform = __webpack_require__(0);

var newlines = /\n+$/,
    logger = new Transform();

logger.write = function(name, level, args) {
  var i = args.length-1;
  if (typeof console === 'undefined' || !console.log) {
    return;
  }
  if(console.log.apply) {
    return console.log.apply(console, [name, level].concat(args));
  } else if(JSON && JSON.stringify) {
    // console.log.apply is undefined in IE8 and IE9
    // for IE8/9: make console.log at least a bit less awful
    if(args[i] && typeof args[i] == 'string') {
      args[i] = args[i].replace(newlines, '');
    }
    try {
      for(i = 0; i < args.length; i++) {
        args[i] = JSON.stringify(args[i]);
      }
    } catch(e) {}
    console.log(args.join(' '));
  }
};

logger.formatters = ['color', 'minilog'];
logger.color = __webpack_require__(18);
logger.minilog = __webpack_require__(19);

module.exports = logger;


/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

var Transform = __webpack_require__(0),
    color = __webpack_require__(2);

var colors = { debug: ['cyan'], info: ['purple' ], warn: [ 'yellow', true ], error: [ 'red', true ] },
    logger = new Transform();

logger.write = function(name, level, args) {
  var fn = console.log;
  if(console[level] && console[level].apply) {
    fn = console[level];
    fn.apply(console, [ '%c'+name+' %c'+level, color('gray'), color.apply(color, colors[level])].concat(args));
  }
};

// NOP, because piping the formatted logs can only cause trouble.
logger.pipe = function() { };

module.exports = logger;


/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

var Transform = __webpack_require__(0),
    color = __webpack_require__(2),
    colors = { debug: ['gray'], info: ['purple' ], warn: [ 'yellow', true ], error: [ 'red', true ] },
    logger = new Transform();

logger.write = function(name, level, args) {
  var fn = console.log;
  if(level != 'debug' && console[level]) {
    fn = console[level];
  }

  var subset = [], i = 0;
  if(level != 'info') {
    for(; i < args.length; i++) {
      if(typeof args[i] != 'string') break;
    }
    fn.apply(console, [ '%c'+name +' '+ args.slice(0, i).join(' '), color.apply(color, colors[level]) ].concat(args.slice(i)));
  } else {
    fn.apply(console, [ '%c'+name, color.apply(color, colors[level]) ].concat(args));
  }
};

// NOP, because piping the formatted logs can only cause trouble.
logger.pipe = function() { };

module.exports = logger;


/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

var Minilog = __webpack_require__(15);

var oldEnable = Minilog.enable,
    oldDisable = Minilog.disable,
    isChrome = (typeof navigator != 'undefined' && /chrome/i.test(navigator.userAgent)),
    console = __webpack_require__(17);

// Use a more capable logging backend if on Chrome
Minilog.defaultBackend = (isChrome ? console.minilog : console);

// apply enable inputs from localStorage and from the URL
if(typeof window != 'undefined') {
  try {
    Minilog.enable(JSON.parse(window.localStorage['minilogSettings']));
  } catch(e) {}
  if(window.location && window.location.search) {
    var match = RegExp('[?&]minilog=([^&]*)').exec(window.location.search);
    match && Minilog.enable(decodeURIComponent(match[1]));
  }
}

// Make enable also add to localStorage
Minilog.enable = function() {
  oldEnable.call(Minilog, true);
  try { window.localStorage['minilogSettings'] = JSON.stringify(true); } catch(e) {}
  return this;
};

Minilog.disable = function() {
  oldDisable.call(Minilog);
  try { delete window.localStorage.minilogSettings; } catch(e) {}
  return this;
};

exports = module.exports = Minilog;

exports.backends = {
  array: __webpack_require__(16),
  browser: Minilog.defaultBackend,
  localStorage: __webpack_require__(22),
  jQuery: __webpack_require__(21)
};


/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

var Transform = __webpack_require__(0);

var cid = new Date().valueOf().toString(36);

function AjaxLogger(options) {
  this.url = options.url || '';
  this.cache = [];
  this.timer = null;
  this.interval = options.interval || 30*1000;
  this.enabled = true;
  this.jQuery = window.jQuery;
  this.extras = {};
}

Transform.mixin(AjaxLogger);

AjaxLogger.prototype.write = function(name, level, args) {
  if(!this.timer) { this.init(); }
  this.cache.push([name, level].concat(args));
};

AjaxLogger.prototype.init = function() {
  if(!this.enabled || !this.jQuery) return;
  var self = this;
  this.timer = setTimeout(function() {
    var i, logs = [], ajaxData, url = self.url;
    if(self.cache.length == 0) return self.init();
    // Test each log line and only log the ones that are valid (e.g. don't have circular references).
    // Slight performance hit but benefit is we log all valid lines.
    for(i = 0; i < self.cache.length; i++) {
      try {
        JSON.stringify(self.cache[i]);
        logs.push(self.cache[i]);
      } catch(e) { }
    }
    if(self.jQuery.isEmptyObject(self.extras)) {
        ajaxData = JSON.stringify({ logs: logs });
        url = self.url + '?client_id=' + cid;
    } else {
        ajaxData = JSON.stringify(self.jQuery.extend({logs: logs}, self.extras));
    }

    self.jQuery.ajax(url, {
      type: 'POST',
      cache: false,
      processData: false,
      data: ajaxData,
      contentType: 'application/json',
      timeout: 10000
    }).success(function(data, status, jqxhr) {
      if(data.interval) {
        self.interval = Math.max(1000, data.interval);
      }
    }).error(function() {
      self.interval = 30000;
    }).always(function() {
      self.init();
    });
    self.cache = [];
  }, this.interval);
};

AjaxLogger.prototype.end = function() {};

// wait until jQuery is defined. Useful if you don't control the load order.
AjaxLogger.jQueryWait = function(onDone) {
  if(typeof window !== 'undefined' && (window.jQuery || window.$)) {
    return onDone(window.jQuery || window.$);
  } else if (typeof window !== 'undefined') {
    setTimeout(function() { AjaxLogger.jQueryWait(onDone); }, 200);
  }
};

module.exports = AjaxLogger;


/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

var Transform = __webpack_require__(0),
    cache = false;

var logger = new Transform();

logger.write = function(name, level, args) {
  if(typeof window == 'undefined' || typeof JSON == 'undefined' || !JSON.stringify || !JSON.parse) return;
  try {
    if(!cache) { cache = (window.localStorage.minilog ? JSON.parse(window.localStorage.minilog) : []); }
    cache.push([ new Date().toString(), name, level, args ]);
    window.localStorage.minilog = JSON.stringify(cache);
  } catch(e) {}
};

module.exports = logger;

/***/ }),
/* 23 */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
	// This works if the window reference is available
	if(typeof window === "object")
		g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;


/***/ })
/******/ ]);
//# sourceMappingURL=dist.js.map