{"version":3,"sources":["webpack:///./node_modules/timers-browserify/main.js","webpack:///./node_modules/setimmediate/setImmediate.js","webpack:///./node_modules/string_decoder/node_modules/safe-buffer/index.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/stream-browserify/index.js"],"names":["self","window","apply","Function","prototype","Timeout","id","clearFn","this","_id","_clearFn","exports","setTimeout","call","scope","arguments","clearTimeout","setInterval","clearInterval","timeout","close","unref","ref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","setImmediate","global","clearImmediate","registerImmediate","nextHandle","tasksByHandle","currentlyRunningATask","doc","document","attachTo","Object","getPrototypeOf","toString","process","installNextTickImplementation","canUsePostMessage","installPostMessageImplementation","MessageChannel","installMessageChannelImplementation","createElement","installReadyStateChangeImplementation","installSetTimeoutImplementation","callback","args","Array","length","i","task","handle","run","undefined","runIfPresent","nextTick","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","Math","random","onGlobalMessage","event","source","data","indexOf","slice","addEventListener","attachEvent","channel","port1","port2","html","documentElement","script","onreadystatechange","removeChild","appendChild","buffer","Buffer","copyProps","src","dst","key","SafeBuffer","arg","encodingOrOffset","from","alloc","allocUnsafe","allocUnsafeSlow","module","TypeError","size","fill","encoding","buf","SlowBuffer","isEncoding","toLowerCase","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","Error","StringDecoder","nb","text","utf16Text","end","utf16End","fillLast","utf8FillLast","base64Text","base64End","write","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","j","utf8CheckExtraBytes","p","r","copy","utf8Text","total","utf8End","c","charCodeAt","n","deprecate","fn","msg","config","warned","deprecated","console","trace","warn","name","localStorage","_","val","String","Stream","EE","EventEmitter","inherits","Readable","Writable","Duplex","Transform","PassThrough","pipe","dest","options","ondata","chunk","writable","pause","ondrain","readable","resume","on","_isStdio","onend","onclose","didOnEnd","destroy","onerror","er","cleanup","listenerCount","removeListener","emit"],"mappings":"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","file":"static/js/chunk-vendors~ec8c427e.731b7ecb.js","sourcesContent":["var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n"],"sourceRoot":""}