https://time-and-effort.netlify.app/app.c3f9f951.js

1// modules are defined as an array
2// [ module function, map of requires ]
3//
4// map of requires is short require name -> numeric require
5//
6// anything defined in a previous bundle is accessed via the
7// orig method which is the require for previous bundles
8parcelRequire = (function (modules, cache, entry, globalName) {
9  // Save the require from previous bundle to this closure if any
10  var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
11  var nodeRequire = typeof require === 'function' && require;
12
13  function newRequire(name, jumped) {
14    if (!cache[name]) {
15      if (!modules[name]) {
16        // if we cannot find the module within our internal map or
17        // cache jump to the current global require ie. the last bundle
18        // that was added to the page.
19        var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
20        if (!jumped && currentRequire) {
21          return currentRequire(name, true);
22        }
23
24        // If there are other bundles on this page the require from the
25        // previous one is saved to 'previousRequire'. Repeat this as
26        // many times as there are bundles until the module is found or
27        // we exhaust the require chain.
28        if (previousRequire) {
29          return previousRequire(name, true);
30        }
31
32        // Try the node require function if it exists.
33        if (nodeRequire && typeof name === 'string') {
34          return nodeRequire(name);
35        }
36
37        var err = new Error('Cannot find module \'' + name + '\'');
38        err.code = 'MODULE_NOT_FOUND';
39        throw err;
40      }
41
42      localRequire.resolve = resolve;
43      localRequire.cache = {};
44
45      var module = cache[name] = new newRequire.Module(name);
46
47      modules[name][0].call(module.exports, localRequire, module, module.exports, this);
48    }
49
50    return cache[name].exports;
51
52    function localRequire(x){
53      return newRequire(localRequire.resolve(x));
54    }
55
56    function resolve(x){
57      return modules[name][1][x] || x;
58    }
59  }
60
61  function Module(moduleName) {
62    this.id = moduleName;
63    this.bundle = newRequire;
64    this.exports = {};
65  }
66
67  newRequire.isParcelRequire = true;
68  newRequire.Module = Module;
69  newRequire.modules = modules;
70  newRequire.cache = cache;
71  newRequire.parent = previousRequire;
72  newRequire.register = function (id, exports) {
73    modules[id] = [function (require, module) {
74      module.exports = exports;
75    }, {}];
76  };
77
78  var error;
79  for (var i = 0; i < entry.length; i++) {
80    try {
81      newRequire(entry[i]);
82    } catch (e) {
83      // Save first error but execute all entries
84      if (!error) {
85        error = e;
86      }
87    }
88  }
89
90  if (entry.length) {
91    // Expose entry point to Node, AMD or browser globals
92    // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
93    var mainExports = newRequire(entry[entry.length - 1]);
94
95    // CommonJS
96    if (typeof exports === "object" && typeof module !== "undefined") {
97      module.exports = mainExports;
98
99    // RequireJS
100    } else if (typeof define === "function" && define.amd) {
101     define(function () {
102       return mainExports;
103     });
104
105    // <script>
106    } else if (globalName) {
107      this[globalName] = mainExports;
108    }
109  }
110
111  // Override the current require with this new one
112  parcelRequire = newRequire;
113
114  if (error) {
115    // throw error from earlier, _after updating parcelRequire_
116    throw error;
117  }
118
119  return newRequire;
120})({"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/src/builtins/bundle-url.js":[function(require,module,exports) {
121var bundleURL = null;
122
123function getBundleURLCached() {
124  if (!bundleURL) {
125    bundleURL = getBundleURL();
126  }
127
128  return bundleURL;
129}
130
131function getBundleURL() {
132  // Attempt to find the URL of the current script and use that as the base URL
133  try {
134    throw new Error();
135  } catch (err) {
136    var matches = ('' + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^)\n]+/g);
137
138    if (matches) {
139      return getBaseURL(matches[0]);
140    }
141  }
142
143  return '/';
144}
145
146function getBaseURL(url) {
147  return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)\/[^/]+$/, '$1') + '/';
148}
149
150exports.getBundleURL = getBundleURLCached;
151exports.getBaseURL = getBaseURL;
152},{}

345],"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/ieee754/index.js":[function(require,module,exports) {
346exports.read = function (buffer, offset, isLE, mLen, nBytes) {
347  var e, m
348  var eLen = (nBytes * 8) - mLen - 1
349  var eMax = (1 << eLen) - 1
350  var eBias = eMax >> 1
351  var nBits = -7
352  var i = isLE ? (nBytes - 1) : 0
353  var d = isLE ? -1 : 1
354  var s = buffer[offset + i]
355
356  i += d
357
358  e = s & ((1 << (-nBits)) - 1)
359  s >>= (-nBits)
360  nBits += eLen
361  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
362
363  m = e & ((1 << (-nBits)) - 1)
364  e >>= (-nBits)
365  nBits += mLen
366  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
367
368  if (e === 0) {
369    e = 1 - eBias
370  } else if (e === eMax) {
371    return m ? NaN : ((s ? -1 : 1) * Infinity)
372  } else {
373    m = m + Math.pow(2, mLen)
374    e = e - eBias
375  }
376  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
377}
378
379exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
380  var e, m, c
381  var eLen = (nBytes * 8) - mLen - 1
382  var eMax = (1 << eLen) - 1
383  var eBias = eMax >> 1
384  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
385  var i = isLE ? 0 : (nBytes - 1)
386  var d = isLE ? 1 : -1
387  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
388
389  value = Math.abs(value)
390
391  if (isNaN(value) || value === Infinity) {
392    m = isNaN(value) ? 1 : 0
393    e = eMax
394  } else {
395    e = Math.floor(Math.log(value) / Math.LN2)
396    if (value * (c = Math.pow(2, -e)) < 1) {
397      e--
398      c *= 2
399    }
400    if (e + eBias >= 1) {
401      value += rt / c
402    } else {
403      value += rt * Math.pow(2, 1 - eBias)
404    }
405    if (value * c >= 2) {
406      e++
407      c /= 2
408    }
409
410    if (e + eBias >= eMax) {
411      m = 0
412      e = eMax
413    } else if (e + eBias >= 1) {
414      m = ((value * c) - 1) * Math.pow(2, mLen)
415      e = e + eBias
416    } else {
417      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
418      e = 0
419    }
420  }
421
422  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
423
424  e = (e << mLen) | m
425  eLen += mLen
426  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
427
428  buffer[offset + i - d] |= s * 128
429}
430
431},{}],"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/isarray/index.js":[function(require,module,exports) {
432var toString = {}.toString;
433
434module.exports = Array.isArray || function (arr) {
435  return toString.call(arr) == '[object Array]';
436};
437
438},{}],"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/buffer/index.js":[function(require,module,exports) {
439
440var global = arguments[3];
441/*!
442 * The buffer module from node.js, for the browser.
443 *
444 * @author   Feross Aboukhadijeh <[email protected]> <http://feross.org>
445 * @license  MIT
446 */
447/* eslint-disable no-proto */
448
449'use strict'
450
451var base64 = require('base64-js')
452var ieee754 = require('ieee754')
453var isArray = require('isarray'

453)
454
455exports.Buffer = Buffer
456exports.SlowBuffer = SlowBuffer
457exports.INSPECT_MAX_BYTES = 50
458
459/**
460 * If `Buffer.TYPED_ARRAY_SUPPORT`:
461 *   === true    Use Uint8Array implementation (fastest)
462 *   === false   Use Object implementation (most compatible, even IE6)
463 *
464 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
465 * Opera 11.6+, iOS 4.2+.
466 *
467 * Due to various browser bugs, sometimes the Object implementation will be used even
468 * when the browser supports typed arrays.
469 *
470 * Note:
471 *
472 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
473 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
474 *
475 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
476 *
477 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
478 *     incorrect length in some situations.
479
480 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
481 * get the Object implementation, which is slower but behaves correctly.
482 */
483Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
484  ? global.TYPED_ARRAY_SUPPORT
485  : typedArraySupport()
486
487/*
488 * Export kMaxLength after typed array support is determined.
489 */
490exports.kMaxLength = kMaxLength()
491
492function typedArraySupport () {
493  try {
494    var arr = new Uint8Array(1)
495    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
496    return arr.foo() === 42 && // typed array instances can be augmented
497        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
498        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
499  } catch (e) {
500    return false
501  }
502}
503
504function kMaxLength () {
505  return Buffer.TYPED_ARRAY_SUPPORT
506    ? 0x7fffffff
507    : 0x3fffffff
508}
509
510function createBuffer (that, length) {
511  if (kMaxLength() < length) {
512    throw new RangeError('Invalid typed array length')
513  }
514  if (Buffer.TYPED_ARRAY_SUPPORT) {
515    // Return an augmented `Uint8Array` instance, for best performance
516    that = new Uint8Array(length)
517    that.__proto__ = Buffer.prototype
518  } else {
519    // Fallback: Return an object instance of the Buffer class
520    if (that === null) {
521      that = new Buffer(length)
522    }
523    that.length = length
524  }
525
526  return that
527}
528
529/**
530 * The Buffer constructor returns instances of `Uint8Array` that have their
531 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
532 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
533 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
534 * returns a single octet.
535 *
536 * The `Uint8Array` prototype remains unmodified.
537 */
538
539function Buffer (arg, encodingOrOffset, length) {
540  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
541    return new Buffer(arg, encodingOrOffset, length)
542  }
543
544  // Common case.
545  if (typeof arg === 'number') {
546    if (typeof encodingOrOffset === 'string') {
547      throw new Error(
548        'If encoding is specified then the first argument must be a string'
549      )
550    }
551    return allocUnsafe(this, arg)
552  }
553  return from(this, arg, encodingOrOffset, length)
554}
555
556Buffer.poolSize = 8192 // not used by this implementation
557
558// TODO: Legacy, not needed anymore. Remove in next major version.
559Buffer._augment = function (arr) {
560  arr.__proto__ = Buffer.prototype
561  return arr
562}
563
564function from (that, value, encodingOrOffset, length) {
565  if (typeof value === 'number') {
566    throw new TypeError('"value" argument must not be a number')
567  }
568
569  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
570    return fromArrayBuffer(that, value, encodingOrOffset, length)
571  }
572
573  if (typeof value === 'string') {
574    return fromString(that, value, encodingOrOffset)
575  }
576
577  return fromObject(that, value)
578}
579
580/**
581 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
582 * if value is a number.
583 * Buffer.from(str[, encoding])
584 * Buffer.from(array)
585 * Buffer.from(buffer)
586 * Buffer.from(arrayBuffer[, byteOffset[, length]])
587 **/
588Buffer.from = function (value, encodingOrOffset, length) {
589  return from(null, value, encodingOrOffset, length)
590}
591
592if (Buffer.TYPED_ARRAY_SUPPORT) {
593  Buffer.prototype.__proto__ = Uint8Array.prototype
594  Buffer.__proto__ = Uint8Array
595  if (typeof Symbol !== 'undefined' && Symbol.species &&
596      Buffer[Symbol.species] === Buffer) {
597    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
598    Object.defineProperty(Buffer, Symbol.species, {
599      value: null,
600      configurable: true
601    })
602  }
603}
604
605function assertSize (size) {
606  if (typeof size !== 'number') {
607    throw new TypeError('"size" argument must be a number')
608  } else if (size < 0) {
609    throw new RangeError('"size" argument must not be negative')
610  }
611}
612
613function alloc (that, size, fill, encoding) {
614  assertSize(size)
615  if (size <= 0) {
616    return createBuffer(that, size)
617  }
618  if (fill !== undefined) {
619    // Only pay attention to encoding if it's a string. This
620    // prevents accidentally sending in a number that would
621    // be interpretted as a start offset.
622    return typeof encoding === 'string'
623      ? createBuffer(that, size).fill(fill, encoding)
624      : createBuffer(that, size).fill(fill)
625  }
626  return createBuffer(that, size)
627}
628
629/**
630 * Creates a new filled Buffer instance.
631 * alloc(size[, fill[, encoding]])
632 **/
633Buffer.alloc = function (size, fill, encoding) {
634  return alloc(null, size, fill, encoding)
635}
636
637function allocUnsafe (that, size) {
638  assertSize(size)
639  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
640  if (!Buffer.TYPED_ARRAY_SUPPORT) {
641    for (var i = 0; i < size; ++i) {
642      that[i] = 0
643    }
644  }
645  return that
646}
647
648/**
649 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
650 * */
651Buffer.allocUnsafe = function (size) {
652  return allocUnsafe(null, size)
653}
654/**
655 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
656 */
657Buffer.allocUnsafeSlow = function (size) {
658  return allocUnsafe(null, size)
659}
660
661function fromString (that, string, encoding) {
662  if (typeof encoding !== 'string' || encoding === '') {
663    encoding = 'utf8'
664  }
665
666  if (!Buffer.isEncoding(encoding)) {
667    throw new TypeError('"encoding" must be a valid string encoding')
668  }
669
670  var length = byteLength(string, encoding) | 0
671  that = createBuffer(that, length)
672
673  var actual = that.write(string, encoding)
674
675  if (actual !== length) {
676    // Writing a hex string, for example, that contains invalid characters will
677    // cause everything after the first invalid character to be ignored. (e.g.
678    // 'abxxcd' will be treated as 'ab')
679    that = that.slice(0, actual)
680  }
681
682  return that
683}
684
685function fromArrayLike (that, array) {
686  var length = array.length < 0 ? 0 : checked(array.length) | 0
687  that = createBuffer(that, length)
688  for (var i = 0; i < length; i += 1) {
689    that[i] = array[i] & 255
690  }
691  return that
692}
693
694function fromArrayBuffer (that, array, byteOffset, length) {
695  array.byteLength // this throws if `array` is not a valid ArrayBuffer
696
697  if (byteOffset < 0 || array.byteLength < byteOffset) {
698    throw new RangeError('\'offset\' is out of bounds')
699  }
700
701  if (array.byteLength < byteOffset + (length || 0)) {
702    throw new RangeError('\'length\' is out of bounds')
703  }
704
705  if (byteOffset === undefined && length === undefined) {
706    array = new Uint8Array(array)
707  } else if (length === undefined) {
708    array = new Uint8Array(array, byteOffset)
709  } else {
710    array = new Uint8Array(array, byteOffset, length)
711  }
712
713  if (Buffer.TYPED_ARRAY_SUPPORT) {
714    // Return an augmented `Uint8Array` instance, for best performance
715    that = array
716    that.__proto__ = Buffer.prototype
717  } else {
718    // Fallback: Return an object instance of the Buffer class
719    that = fromArrayLike(that, array)
720  }
721  return that
722}
723
724function fromObject (that, obj) {
725  if (Buffer.isBuffer(obj)) {
726    var len = checked(obj.length) | 0
727    that = createBuffer(that, len)
728
729    if (that.length === 0) {
730      return that
731    }
732
733    obj.copy(that, 0, 0, len)
734    return that
735  }
736
737  if (obj) {
738    if ((typeof ArrayBuffer !== 'undefined' &&
739        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
740      if (typeof obj.length !== 'number' || isnan(obj.length)) {
741        return createBuffer(that, 0)
742      }
743      return fromArrayLike(that, obj)
744    }
745
746    if (obj.type === 'Buffer' && isArray(obj.data)) {
747      return fromArrayLike(that, obj.data)
748    }
749  }
750
751  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
752}
753
754function checked (length) {
755  // Note: cannot use `length < kMaxLength()` here because that fails when
756  // length is NaN (which is otherwise coerced to zero.)
757  if (length >= kMaxLength()) {
758    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
759                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
760  }
761  return length | 0
762}
763
764function SlowBuffer (length) {
765  if (+length != length) { // eslint-disable-line eqeqeq
766    length = 0
767  }
768  return Buffer.alloc(+length)
769}
770
771Buffer.isBuffer = function isBuffer (b) {
772  return !!(b != null && b._isBuffer)
773}
774
775Buffer.compare = function compare (a, b) {
776  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
777    throw new TypeError('Arguments must be Buffers')
778  }
779
780  if (a === b) return 0
781
782  var x = a.length
783  var y = b.length
784
785  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
786    if (a[i] !== b[i]) {
787      x = a[i]
788      y = b[i]
789      break
790    }
791  }
792
793  if (x < y) return -1
794  if (y < x) return 1
795  return 0
796}
797
798Buffer.isEncoding = function isEncoding (encoding) {
799  switch (String(encoding).toLowerCase()) {
800    case 'hex':
801    case 'utf8':
802    case 'utf-8':
803    case 'ascii':
804    case 'latin1':
805    case 'binary':
806    case 'base64':
807    case 'ucs2':
808    case 'ucs-2':
809    case 'utf16le':
810    case 'utf-16le':
811      return true
812    default:
813      return false
814  }
815}
816
817Buffer.concat = function concat (list, length) {
818  if (!isArray(list)) {
819    throw new TypeError('"list" argument must be an Array of Buffers')
820  }
821
822  if (list.length === 0) {
823    return Buffer.alloc(0)
824  }
825
826  var i
827  if (length === undefined) {
828    length = 0
829    for (i = 0; i < list.length; ++i) {
830      length += list[i].length
831    }
832  }
833
834  var buffer = Buffer.allocUnsafe(length)
835  var pos = 0
836  for (i = 0; i < list.length; ++i) {
837    var buf = list[i]
838    if (!Buffer.isBuffer(buf)) {
839      throw new TypeError('"list" argument must be an Array of Buffers')
840    }
841    buf.copy(buffer, pos)
842    pos += buf.length
843  }
844  return buffer
845}
846
847function byteLength (string, encoding) {
848  if (Buffer.isBuffer(string)) {
849    return string.length
850  }
851  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
852      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
853    return string.byteLength
854  }
855  if (typeof string !== 'string') {
856    string = '' + string
857  }
858
859  var len = string.length
860  if (len === 0) return 0
861
862  // Use a for loop to avoid recursion
863  var loweredCase = false
864  for (;;) {
865    switch (encoding) {
866      case 'ascii':
867      case 'latin1':
868      case 'binary':
869        return len
870      case 'utf8':
871      case 'utf-8':
872      case undefined:
873        return utf8ToBytes(string).length
874      case 'ucs2':
875      case 'ucs-2':
876      case 'utf16le':
877      case 'utf-16le':
878        return len * 2
879      case 'hex':
880        return len >>> 1
881      case 'base64':
882        return base64ToBytes(string).length
883      default:
884        if (loweredCase) return utf8ToBytes(string).length // assume utf8
885        encoding = ('' + encoding).toLowerCase()
886        loweredCase = true
887    }
888  }
889}
890Buffer.byteLength = byteLength
891
892function slowToString (encoding, start, end) {
893  var loweredCase = false
894
895  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
896  // property of a typed array.
897
898  // This behaves neither like String nor Uint8Array in that we set start/end
899  // to their upper/lower bounds if the value passed is out of range.
900  // undefined is handled specially as per ECMA-262 6th Edition,
901  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
902  if (start === undefined || start < 0) {
903    start = 0
904  }
905  // Return early if start > this.length. Done here to prevent potential uint32
906  // coercion fail below.
907  if (start > this.length) {
908    return ''
909  }
910
911  if (end === undefined || end > this.length) {
912    end = this.length
913  }
914
915  if (end <= 0) {
916    return ''
917  }
918
919  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
920  end >>>= 0
921  start >>>= 0
922
923  if (end <= start) {
924    return ''
925  }
926
927  if (!encoding) encoding = 'utf8'
928
929  while (true) {
930    switch (encoding) {
931      case 'hex':
932        return hexSlice(this, start, end)
933
934      case 'utf8':
935      case 'utf-8':
936        return utf8Slice(this, start, end)
937
938      case 'ascii':
939        return asciiSlice(this, start, end)
940
941      case 'latin1':
942      case 'binary':
943        return latin1Slice(this, start, end)
944
945      case 'base64':
946        return base64Slice(this, start, end)
947
948      case 'ucs2':
949      case 'ucs-2':
950      case 'utf16le':
951      case 'utf-16le':
952        return utf16leSlice(this, start, end)
953
954      default:
955        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
956        encoding = (encoding + '').toLowerCase()
957        loweredCase = true
958    }
959  }
960}
961
962// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
963// Buffer instances.
964Buffer.prototype._isBuffer = true
965
966function swap (b, n, m) {
967  var i = b[n]
968  b[n] = b[m]
969  b[m] = i
970}
971
972Buffer.prototype.swap16 = function swap16 () {
973  var len = this.length
974  if (len % 2 !== 0) {
975    throw new RangeError('Buffer size must be a multiple of 16-bits')
976  }
977  for (var i = 0; i < len; i += 2) {
978    swap(this, i, i + 1)
979  }
980  return this
981}
982
983Buffer.prototype.swap32 = function swap32 () {
984  var len = this.length
985  if (len % 4 !== 0) {
986    throw new RangeError('Buffer size must be a multiple of 32-bits')
987  }
988  for (var i = 0; i < len; i += 4) {
989    swap(this, i, i + 3)
990    swap(this, i + 1, i + 2)
991  }
992  return this
993}
994
995Buffer.prototype.swap64 = function swap64 () {
996  var len = this.length
997  if (len % 8 !== 0) {
998    throw new RangeError('Buffer size must be a multiple of 64-bits')
999  }
1000  for (var i = 0; i < len; i += 8) {
1001    swap(this, i, i + 7)
1002    swap(this, i + 1, i + 6)
1003    swap(this, i + 2, i + 5)
1004    swap(this, i + 3, i + 4)
1005  }
1006  return this
1007}
1008
1009Buffer.prototype.toString = function toString () {
1010  var length = this.length | 0
1011  if (length === 0) return ''
1012  if (arguments.length === 0) return utf8Slice(this, 0, length)
1013  return slowToString.apply(this, arguments)
1014}
1015
1016Buffer.prototype.equals = function equals (b) {
1017  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
1018  if (this === b) return true
1019  return Buffer.compare(this, b) === 0
1020}
1021
1022Buffer.prototype.inspect = function inspect () {
1023  var str = ''
1024  var max = exports.INSPECT_MAX_BYTES
1025  if (this.length > 0) {
1026    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
1027    if (this.length > max) str += ' ... '
1028  }
1029  return '<Buffer ' + str + '>'
1030}
1031
1032Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
1033  if (!Buffer.isBuffer(target)) {
1034    throw new TypeError('Argument must be a Buffer')
1035  }
1036
1037  if (start === undefined) {
1038    start = 0
1039  }
1040  if (end === undefined) {
1041    end = target ? target.length : 0
1042  }
1043  if (thisStart === undefined) {
1044    thisStart = 0
1045  }
1046  if (thisEnd === undefined) {
1047    thisEnd = this.length
1048  }
1049
1050  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
1051    throw new RangeError('out of range index')
1052  }
1053
1054  if (thisStart >= thisEnd && start >= end) {
1055    return 0
1056  }
1057  if (thisStart >= thisEnd) {
1058    return -1
1059  }
1060  if (start >= end) {
1061    return 1
1062  }
1063
1064  start >>>= 0
1065  end >>>= 0
1066  thisStart >>>= 0
1067  thisEnd >>>= 0
1068
1069  if (this === target) return 0
1070
1071  var x = thisEnd - thisStart
1072  var y = end - start
1073  var len = Math.min(x, y)
1074
1075  var thisCopy = this.slice(thisStart, thisEnd)
1076  var targetCopy = target.slice(start, end)
1077
1078  for (var i = 0; i < len; ++i) {
1079    if (thisCopy[i] !== targetCopy[i]) {
1080      x = thisCopy[i]
1081      y = targetCopy[i]
1082      break
1083    }
1084  }
1085
1086  if (x < y) return -1
1087  if (y < x) return 1
1088  return 0
1089}
1090
1091// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
1092// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
1093//
1094// Arguments:
1095// - buffer - a Buffer to search
1096// - val - a string, Buffer, or number
1097// - byteOffset - an index into `buffer`; will be clamped to an int32
1098// - encoding - an optional encoding, relevant is val is a string
1099// - dir - true for indexOf, false for lastIndexOf
1100function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
1101  // Empty buffer means no match
1102  if (buffer.length === 0) return -1
1103
1104  // Normalize byteOffset
1105  if (typeof byteOffset === 'string') {
1106    encoding = byteOffset
1107    byteOffset = 0
1108  } else if (byteOffset > 0x7fffffff) {
1109    byteOffset = 0x7fffffff
1110  } else if (byteOffset < -0x80000000) {
1111    byteOffset = -0x80000000
1112  }
1113  byteOffset = +byteOffset  // Coerce to Number.
1114  if (isNaN(byteOffset)) {
1115    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
1116    byteOffset = dir ? 0 : (buffer.length - 1)
1117  }
1118
1119  // Normalize byteOffset: negative offsets start from the end of the buffer
1120  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
1121  if (byteOffset >= buffer.length) {
1122    if (dir) return -1
1123    else byteOffset = buffer.length - 1
1124  } else if (byteOffset < 0) {
1125    if (dir) byteOffset = 0
1126    else return -1
1127  }
1128
1129  // Normalize val
1130  if (typeof val === 'string') {
1131    val = Buffer.from(val, encoding)
1132  }
1133
1134  // Finally, search either indexOf (if dir is true) or lastIndexOf
1135  if (Buffer.isBuffer(val)) {
1136    // Special case: looking for empty string/buffer always fails
1137    if (val.length === 0) {
1138      return -1
1139    }
1140    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
1141  } else if (typeof val === 'number') {
1142    val = val & 0xFF // Search for a byte value [0-255]
1143    if (Buffer.TYPED_ARRAY_SUPPORT &&
1144        typeof Uint8Array.prototype.indexOf === 'function') {
1145      if (dir) {
1146        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
1147      } else {
1148        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
1149      }
1150    }
1151    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
1152  }
1153
1154  throw new TypeError('val must be string, number or Buffer')
1155}
1156
1157function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
1158  var indexSize = 1
1159  var arrLength = arr.length
1160  var valLength = val.length
1161
1162  if (encoding !== undefined) {
1163    encoding = String(encoding).toLowerCase()
1164    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
1165        encoding === 'utf16le' || encoding === 'utf-16le') {
1166      if (arr.length < 2 || val.length < 2) {
1167        return -1
1168      }
1169      indexSize = 2
1170      arrLength /= 2
1171      valLength /= 2
1172      byteOffset /= 2
1173    }
1174  }
1175
1176  function read (buf, i) {
1177    if (indexSize === 1) {
1178      return buf[i]
1179    } else {
1180      return buf.readUInt16BE(i * indexSize)
1181    }
1182  }
1183
1184  var i
1185  if (dir) {
1186    var foundIndex = -1
1187    for (i = byteOffset; i < arrLength; i++) {
1188      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
1189        if (foundIndex === -1) foundIndex = i
1190        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
1191      } else {
1192        if (foundIndex !== -1) i -= i - foundIndex
1193        foundIndex = -1
1194      }
1195    }
1196  } else {
1197    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
1198    for (i = byteOffset; i >= 0; i--) {
1199      var found = true
1200      for (var j = 0; j < valLength; j++) {
1201        if (read(arr, i + j) !== read(val, j)) {
1202          found = false
1203          break
1204        }
1205      }
1206      if (found) return i
1207    }
1208  }
1209
1210  return -1
1211}
1212
1213Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
1214  return this.indexOf(val, byteOffset, encoding) !== -1
1215}
1216
1217Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
1218  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
1219}
1220
1221Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
1222  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
1223}
1224
1225function hexWrite (buf, string, offset, length) {
1226  offset = Number(offset) || 0
1227  var remaining = buf.length - offset
1228  if (!length) {
1229    length = remaining
1230  } else {
1231    length = Number(length)
1232    if (length > remaining) {
1233      length = remaining
1234    }
1235  }
1236
1237  // must be an even number of digits
1238  var strLen = string.length
1239  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
1240
1241  if (length > strLen / 2) {
1242    length = strLen / 2
1243  }
1244  for (var i = 0; i < length; ++i) {
1245    var parsed = parseInt(string.substr(i * 2, 2), 16)
1246    if (isNaN(parsed)) return i
1247    buf[offset + i] = parsed
1248  }
1249  return i
1250}
1251
1252function utf8Write (buf, string, offset, length) {
1253  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
1254}
1255
1256function asciiWrite (buf, string, offset, length) {
1257  return blitBuffer(asciiToBytes(string), buf, offset, length)
1258}
1259
1260function latin1Write (buf, string, offset, length) {
1261  return asciiWrite(buf, string, offset, length)
1262}
1263
1264function base64Write (buf, string, offset, length) {
1265  return blitBuffer(base64ToBytes(string), buf, offset, length)
1266}
1267
1268function ucs2Write (buf, string, offset, length) {
1269  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
1270}
1271
1272Buffer.prototype.write = function write (string, offset, length, encoding) {
1273  // Buffer#write(string)
1274  if (offset === undefined) {
1275    encoding = 'utf8'
1276    length = this.length
1277    offset = 0
1278  // Buffer#write(string, encoding)
1279  } else if (length === undefined && typeof offset === 'string') {
1280    encoding = offset
1281    length = this.length
1282    offset = 0
1283  // Buffer#write(string, offset[, length][, encoding])
1284  } else if (isFinite(offset)) {
1285    offset = offset | 0
1286    if (isFinite(length)) {
1287      length = length | 0
1288      if (encoding === undefined) encoding = 'utf8'
1289    } else {
1290      encoding = length
1291      length = undefined
1292    }
1293  // legacy write(string, encoding, offset, length) - remove in v0.13
1294  } else {
1295    throw new Error(
1296      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
1297    )
1298  }
1299
1300  var remaining = this.length - offset
1301  if (length === undefined || length > remaining) length = remaining
1302
1303  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
1304    throw new RangeError('Attempt to write outside buffer bounds')
1305  }
1306
1307  if (!encoding) encoding = 'utf8'
1308
1309  var loweredCase = false
1310  for (;;) {
1311    switch (encoding) {
1312      case 'hex':
1313        return hexWrite(this, string, offset, length)
1314
1315      case 'utf8':
1316      case 'utf-8':
1317        return utf8Write(this, string, offset, length)
1318
1319      case 'ascii':
1320        return asciiWrite(this, string, offset, length)
1321
1322      case 'latin1':
1323      case 'binary':
1324        return latin1Write(this, string, offset, length)
1325
1326      case 'base64':
1327        // Warning: maxLength not taken into account in base64Write
1328        return base64Write(this, string, offset, length)
1329
1330      case 'ucs2':
1331      case 'ucs-2':
1332      case 'utf16le':
1333      case 'utf-16le':
1334        return ucs2Write(this, string, offset, length)
1335
1336      default:
1337        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
1338        encoding = ('' + encoding).toLowerCase()
1339        loweredCase = true
1340    }
1341  }
1342}
1343
1344Buffer.prototype.toJSON = function toJSON () {
1345  return {
1346    type: 'Buffer',
1347    data: Array.prototype.slice.call(this._arr || this, 0)
1348  }
1349}
1350
1351function base64Slice (buf, start, end) {
1352  if (start === 0 && end === buf.length) {
1353    return base64.fromByteArray(buf)
1354  } else {
1355    return base64.fromByteArray(buf.slice(start, end))
1356  }
1357}
1358
1359function utf8Slice (buf, start, end) {
1360  end = Math.min(buf.length, end)
1361  var res = []
1362
1363  var i = start
1364  while (i < end) {
1365    var firstByte = buf[i]
1366    var codePoint = null
1367    var bytesPerSequence = (firstByte > 0xEF) ? 4
1368      : (firstByte > 0xDF) ? 3
1369      : (firstByte > 0xBF) ? 2
1370      : 1
1371
1372    if (i + bytesPerSequence <= end) {
1373      var secondByte, thirdByte, fourthByte, tempCodePoint
1374
1375      switch (bytesPerSequence) {
1376        case 1:
1377          if (firstByte < 0x80) {
1378            codePoint = firstByte
1379          }
1380          break
1381        case 2:
1382          secondByte = buf[i + 1]
1383          if ((secondByte & 0xC0) === 0x80) {
1384            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
1385            if (tempCodePoint > 0x7F) {
1386              codePoint = tempCodePoint
1387            }
1388          }
1389          break
1390        case 3:
1391          secondByte = buf[i + 1]
1392          thirdByte = buf[i + 2]
1393          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
1394            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
1395            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
1396              codePoint = tempCodePoint
1397            }
1398          }
1399          break
1400        case 4:
1401          secondByte = buf[i + 1]
1402          thirdByte = buf[i + 2]
1403          fourthByte = buf[i + 3]
1404          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
1405            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
1406            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
1407              codePoint = tempCodePoint
1408            }
1409          }
1410      }
1411    }
1412
1413    if (codePoint === null) {
1414      // we did not generate a valid codePoint so insert a
1415      // replacement char (U+FFFD) and advance only 1 byte
1416      codePoint = 0xFFFD
1417      bytesPerSequence = 1
1418    } else if (codePoint > 0xFFFF) {
1419      // encode to utf16 (surrogate pair dance)
1420      codePoint -= 0x10000
1421      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
1422      codePoint = 0xDC00 | codePoint & 0x3FF
1423    }
1424
1425    res.push(codePoint)
1426    i += bytesPerSequence
1427  }
1428
1429  return decodeCodePointsArray(res)
1430}
1431
1432// Based on http://stackoverflow.com/a/22747272/680742, the browser with
1433// the lowest limit is Chrome, with 0x10000 args.
1434// We go 1 magnitude less, for safety
1435var MAX_ARGUMENTS_LENGTH = 0x1000
1436
1437function decodeCodePointsArray (codePoints) {
1438  var len = codePoints.length
1439  if (len <= MAX_ARGUMENTS_LENGTH) {
1440    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
1441  }
1442
1443  // Decode in chunks to avoid "call stack size exceeded".
1444  var res = ''
1445  var i = 0
1446  while (i < len) {
1447    res += String.fromCharCode.apply(
1448      String,
1449      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
1450    )
1451  }
1452  return res
1453}
1454
1455function asciiSlice (buf, start, end) {
1456  var ret = ''
1457  end = Math.min(buf.length, end)
1458
1459  for (var i = start; i < end; ++i) {
1460    ret += String.fromCharCode(buf[i] & 0x7F)
1461  }
1462  return ret
1463}
1464
1465function latin1Slice (buf, start, end) {
1466  var ret = ''
1467  end = Math.min(buf.length, end)
1468
1469  for (var i = start; i < end; ++i) {
1470    ret += String.fromCharCode(buf[i])
1471  }
1472  return ret
1473}
1474
1475function hexSlice (buf, start, end) {
1476  var len = buf.length
1477
1478  if (!start || start < 0) start = 0
1479  if (!end || end < 0 || end > len) end = len
1480
1481  var out = ''
1482  for (var i = start; i < end; ++i) {
1483    out += toHex(buf[i])
1484  }
1485  return out
1486}
1487
1488function utf16leSlice (buf, start, end) {
1489  var bytes = buf.slice(start, end)
1490  var res = ''
1491  for (var i = 0; i < bytes.length; i += 2) {
1492    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
1493  }
1494  return res
1495}
1496
1497Buffer.prototype.slice = function slice (start, end) {
1498  var len = this.length
1499  start = ~~start
1500  end = end === undefined ? len : ~~end
1501
1502  if (start < 0) {
1503    start += len
1504    if (start < 0) start = 0
1505  } else if (start > len) {
1506    start = len
1507  }
1508
1509  if (end < 0) {
1510    end += len
1511    if (end < 0) end = 0
1512  } else if (end > len) {
1513    end = len
1514  }
1515
1516  if (end < start) end = start
1517
1518  var newBuf
1519  if (Buffer.TYPED_ARRAY_SUPPORT) {
1520    newBuf = this.subarray(start, end)
1521    newBuf.__proto__ = Buffer.prototype
1522  } else {
1523    var sliceLen = end - start
1524    newBuf = new Buffer(sliceLen, undefined)
1525    for (var i = 0; i < sliceLen; ++i) {
1526      newBuf[i] = this[i + start]
1527    }
1528  }
1529
1530  return newBuf
1531}
1532
1533/*
1534 * Need to make sure that buffer isn't trying to write out of bounds.
1535 */
1536function checkOffset (offset, ext, length) {
1537  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
1538  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
1539}
1540
1541Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
1542  offset = offset | 0
1543  byteLength = byteLength | 0
1544  if (!noAssert) checkOffset(offset, byteLength, this.length)
1545
1546  var val = this[offset]
1547  var mul = 1
1548  var i = 0
1549  while (++i < byteLength && (mul *= 0x100)) {
1550    val += this[offset + i] * mul
1551  }
1552
1553  return val
1554}
1555
1556Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
1557  offset = offset | 0
1558  byteLength = byteLength | 0
1559  if (!noAssert) {
1560    checkOffset(offset, byteLength, this.length)
1561  }
1562
1563  var val = this[offset + --byteLength]
1564  var mul = 1
1565  while (byteLength > 0 && (mul *= 0x100)) {
1566    val += this[offset + --byteLength] * mul
1567  }
1568
1569  return val
1570}
1571
1572Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
1573  if (!noAssert) checkOffset(offset, 1, this.length)
1574  return this[offset]
1575}
1576
1577Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
1578  if (!noAssert) checkOffset(offset, 2, this.length)
1579  return this[offset] | (this[offset + 1] << 8)
1580}
1581
1582Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
1583  if (!noAssert) checkOffset(offset, 2, this.length)
1584  return (this[offset] << 8) | this[offset + 1]
1585}
1586
1587Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
1588  if (!noAssert) checkOffset(offset, 4, this.length)
1589
1590  return ((this[offset]) |
1591      (this[offset + 1] << 8) |
1592      (this[offset + 2] << 16)) +
1593      (this[offset + 3] * 0x1000000)
1594}
1595
1596Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
1597  if (!noAssert) checkOffset(offset, 4, this.length)
1598
1599  return (this[offset] * 0x1000000) +
1600    ((this[offset + 1] << 16) |
1601    (this[offset + 2] << 8) |
1602    this[offset + 3])
1603}
1604
1605Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
1606  offset = offset | 0
1607  byteLength = byteLength | 0
1608  if (!noAssert) checkOffset(offset, byteLength, this.length)
1609
1610  var val = this[offset]
1611  var mul = 1
1612  var i = 0
1613  while (++i < byteLength && (mul *= 0x100)) {
1614    val += this[offset + i] * mul
1615  }
1616  mul *= 0x80
1617
1618  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1619
1620  return val
1621}
1622
1623Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
1624  offset = offset | 0
1625  byteLength = byteLength | 0
1626  if (!noAssert) checkOffset(offset, byteLength, this.length)
1627
1628  var i = byteLength
1629  var mul = 1
1630  var val = this[offset + --i]
1631  while (i > 0 && (mul *= 0x100)) {
1632    val += this[offset + --i] * mul
1633  }
1634  mul *= 0x80
1635
1636  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1637
1638  return val
1639}
1640
1641Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
1642  if (!noAssert) checkOffset(offset, 1, this.length)
1643  if (!(this[offset] & 0x80)) return (this[offset])
1644  return ((0xff - this[offset] + 1) * -1)
1645}
1646
1647Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
1648  if (!noAssert) checkOffset(offset, 2, this.length)
1649  var val = this[offset] | (this[offset + 1] << 8)
1650  return (val & 0x8000) ? val | 0xFFFF0000 : val
1651}
1652
1653Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
1654  if (!noAssert) checkOffset(offset, 2, this.length)
1655  var val = this[offset + 1] | (this[offset] << 8)
1656  return (val & 0x8000) ? val | 0xFFFF0000 : val
1657}
1658
1659Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
1660  if (!noAssert) checkOffset(offset, 4, this.length)
1661
1662  return (this[offset]) |
1663    (this[offset + 1] << 8) |
1664    (this[offset + 2] << 16) |
1665    (this[offset + 3] << 24)
1666}
1667
1668Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
1669  if (!noAssert) checkOffset(offset, 4, this.length)
1670
1671  return (this[offset] << 24) |
1672    (this[offset + 1] << 16) |
1673    (this[offset + 2] << 8) |
1674    (this[offset + 3])
1675}
1676
1677Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
1678  if (!noAssert) checkOffset(offset, 4, this.length)
1679  return ieee754.read(this, offset, true, 23, 4)
1680}
1681
1682Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
1683  if (!noAssert) checkOffset(offset, 4, this.length)
1684  return ieee754.read(this, offset, false, 23, 4)
1685}
1686
1687Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
1688  if (!noAssert) checkOffset(offset, 8, this.length)
1689  return ieee754.read(this, offset, true, 52, 8)
1690}
1691
1692Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
1693  if (!noAssert) checkOffset(offset, 8, this.length)
1694  return ieee754.read(this, offset, false, 52, 8)
1695}
1696
1697function checkInt (buf, value, offset, ext, max, min) {
1698  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
1699  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
1700  if (offset + ext > buf.length) throw new RangeError('Index out of range')
1701}
1702
1703Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
1704  value = +value
1705  offset = offset | 0
1706  byteLength = byteLength | 0
1707  if (!noAssert) {
1708    var maxBytes = Math.pow(2, 8 * byteLength) - 1
1709    checkInt(this, value, offset, byteLength, maxBytes, 0)
1710  }
1711
1712  var mul = 1
1713  var i = 0
1714  this[offset] = value & 0xFF
1715  while (++i < byteLength && (mul *= 0x100)) {
1716    this[offset + i] = (value / mul) & 0xFF
1717  }
1718
1719  return offset + byteLength
1720}
1721
1722Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
1723  value = +value
1724  offset = offset | 0
1725  byteLength = byteLength | 0
1726  if (!noAssert) {
1727    var maxBytes = Math.pow(2, 8 * byteLength) - 1
1728    checkInt(this, value, offset, byteLength, maxBytes, 0)
1729  }
1730
1731  var i = byteLength - 1
1732  var mul = 1
1733  this[offset + i] = value & 0xFF
1734  while (--i >= 0 && (mul *= 0x100)) {
1735    this[offset + i] = (value / mul) & 0xFF
1736  }
1737
1738  return offset + byteLength
1739}
1740
1741Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
1742  value = +value
1743  offset = offset | 0
1744  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
1745  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
1746  this[offset] = (value & 0xff)
1747  return offset + 1
1748}
1749
1750function objectWriteUInt16 (buf, value, offset, littleEndian) {
1751  if (value < 0) value = 0xffff + value + 1
1752  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
1753    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
1754      (littleEndian ? i : 1 - i) * 8
1755  }
1756}
1757
1758Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
1759  value = +value
1760  offset = offset | 0
1761  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1762  if (Buffer.TYPED_ARRAY_SUPPORT) {
1763    this[offset] = (value & 0xff)
1764    this[offset + 1] = (value >>> 8)
1765  } else {
1766    objectWriteUInt16(this, value, offset, true)
1767  }
1768  return offset + 2
1769}
1770
1771Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
1772  value = +value
1773  offset = offset | 0
1774  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1775  if (Buffer.TYPED_ARRAY_SUPPORT) {
1776    this[offset] = (value >>> 8)
1777    this[offset + 1] = (value & 0xff)
1778  } else {
1779    objectWriteUInt16(this, value, offset, false)
1780  }
1781  return offset + 2
1782}
1783
1784function objectWriteUInt32 (buf, value, offset, littleEndian) {
1785  if (value < 0) value = 0xffffffff + value + 1
1786  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
1787    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
1788  }
1789}
1790
1791Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
1792  value = +value
1793  offset = offset | 0
1794  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1795  if (Buffer.TYPED_ARRAY_SUPPORT) {
1796    this[offset + 3] = (value >>> 24)
1797    this[offset + 2] = (value >>> 16)
1798    this[offset + 1] = (value >>> 8)
1799    this[offset] = (value & 0xff)
1800  } else {
1801    objectWriteUInt32(this, value, offset, true)
1802  }
1803  return offset + 4
1804}
1805
1806Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
1807  value = +value
1808  offset = offset | 0
1809  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1810  if (Buffer.TYPED_ARRAY_SUPPORT) {
1811    this[offset] = (value >>> 24)
1812    this[offset + 1] = (value >>> 16)
1813    this[offset + 2] = (value >>> 8)
1814    this[offset + 3] = (value & 0xff)
1815  } else {
1816    objectWriteUInt32(this, value, offset, false)
1817  }
1818  return offset + 4
1819}
1820
1821Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
1822  value = +value
1823  offset = offset | 0
1824  if (!noAssert) {
1825    var limit = Math.pow(2, 8 * byteLength - 1)
1826
1827    checkInt(this, value, offset, byteLength, limit - 1, -limit)
1828  }
1829
1830  var i = 0
1831  var mul = 1
1832  var sub = 0
1833  this[offset] = value & 0xFF
1834  while (++i < byteLength && (mul *= 0x100)) {
1835    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
1836      sub = 1
1837    }
1838    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1839  }
1840
1841  return offset + byteLength
1842}
1843
1844Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
1845  value = +value
1846  offset = offset | 0
1847  if (!noAssert) {
1848    var limit = Math.pow(2, 8 * byteLength - 1)
1849
1850    checkInt(this, value, offset, byteLength, limit - 1, -limit)
1851  }
1852
1853  var i = byteLength - 1
1854  var mul = 1
1855  var sub = 0
1856  this[offset + i] = value & 0xFF
1857  while (--i >= 0 && (mul *= 0x100)) {
1858    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
1859      sub = 1
1860    }
1861    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1862  }
1863
1864  return offset + byteLength
1865}
1866
1867Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
1868  value = +value
1869  offset = offset | 0
1870  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
1871  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
1872  if (value < 0) value = 0xff + value + 1
1873  this[offset] = (value & 0xff)
1874  return offset + 1
1875}
1876
1877Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
1878  value = +value
1879  offset = offset | 0
1880  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1881  if (Buffer.TYPED_ARRAY_SUPPORT) {
1882    this[offset] = (value & 0xff)
1883    this[offset + 1] = (value >>> 8)
1884  } else {
1885    objectWriteUInt16(this, value, offset, true)
1886  }
1887  return offset + 2
1888}
1889
1890Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
1891  value = +value
1892  offset = offset | 0
1893  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1894  if (Buffer.TYPED_ARRAY_SUPPORT) {
1895    this[offset] = (value >>> 8)
1896    this[offset + 1] = (value & 0xff)
1897  } else {
1898    objectWriteUInt16(this, value, offset, false)
1899  }
1900  return offset + 2
1901}
1902
1903Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
1904  value = +value
1905  offset = offset | 0
1906  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1907  if (Buffer.TYPED_ARRAY_SUPPORT) {
1908    this[offset] = (value & 0xff)
1909    this[offset + 1] = (value >>> 8)
1910    this[offset + 2] = (value >>> 16)
1911    this[offset + 3] = (value >>> 24)
1912  } else {
1913    objectWriteUInt32(this, value, offset, true)
1914  }
1915  return offset + 4
1916}
1917
1918Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
1919  value = +value
1920  offset = offset | 0
1921  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1922  if (value < 0) value = 0xffffffff + value + 1
1923  if (Buffer.TYPED_ARRAY_SUPPORT) {
1924    this[offset] = (value >>> 24)
1925    this[offset + 1] = (value >>> 16)
1926    this[offset + 2] = (value >>> 8)
1927    this[offset + 3] = (value & 0xff)
1928  } else {
1929    objectWriteUInt32(this, value, offset, false)
1930  }
1931  return offset + 4
1932}
1933
1934function checkIEEE754 (buf, value, offset, ext, max, min) {
1935  if (offset + ext > buf.length) throw new RangeError('Index out of range')
1936  if (offset < 0) throw new RangeError('Index out of range')
1937}
1938
1939function writeFloat (buf, value, offset, littleEndian, noAssert) {
1940  if (!noAssert) {
1941    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
1942  }
1943  ieee754.write(buf, value, offset, littleEndian, 23, 4)
1944  return offset + 4
1945}
1946
1947Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
1948  return writeFloat(this, value, offset, true, noAssert)
1949}
1950
1951Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
1952  return writeFloat(this, value, offset, false, noAssert)
1953}
1954
1955function writeDouble (buf, value, offset, littleEndian, noAssert) {
1956  if (!noAssert) {
1957    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
1958  }
1959  ieee754.write(buf, value, offset, littleEndian, 52, 8)
1960  return offset + 8
1961}
1962
1963Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
1964  return writeDouble(this, value, offset, true, noAssert)
1965}
1966
1967Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
1968  return writeDouble(this, value, offset, false, noAssert)
1969}
1970
1971// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
1972Buffer.prototype.copy = function copy (target, targetStart, start, end) {
1973  if (!start) start = 0
1974  if (!end && end !== 0) end = this.length
1975  if (targetStart >= target.length) targetStart = target.length
1976  if (!targetStart) targetStart = 0
1977  if (end > 0 && end < start) end = start
1978
1979  // Copy 0 bytes; we're done
1980  if (end === start) return 0
1981  if (target.length === 0 || this.length === 0) return 0
1982
1983  // Fatal error conditions
1984  if (targetStart < 0) {
1985    throw new RangeError('targetStart out of bounds')
1986  }
1987  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
1988  if (end < 0) throw new RangeError('sourceEnd out of bounds')
1989
1990  // Are we oob?
1991  if (end > this.length) end = this.length
1992  if (target.length - targetStart < end - start) {
1993    end = target.length - targetStart + start
1994  }
1995
1996  var len = end - start
1997  var i
1998
1999  if (this === target && start < targetStart && targetStart < end) {
2000    // descending copy from end
2001    for (i = len - 1; i >= 0; --i) {
2002      target[i + targetStart] = this[i + start]
2003    }
2004  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
2005    // ascending copy from start
2006    for (i = 0; i < len; ++i) {
2007      target[i + targetStart] = this[i + start]
2008    }
2009  } else {
2010    Uint8Array.prototype.set.call(
2011      target,
2012      this.subarray(start, start + len),
2013      targetStart
2014    )
2015  }
2016
2017  return len
2018}
2019
2020// Usage:
2021//    buffer.fill(number[, offset[, end]])
2022//    buffer.fill(buffer[, offset[, end]])
2023//    buffer.fill(string[, offset[, end]][, encoding])
2024Buffer.prototype.fill = function fill (val, start, end, encoding) {
2025  // Handle string cases:
2026  if (typeof val === 'string') {
2027    if (typeof start === 'string') {
2028      encoding = start
2029      start = 0
2030      end = this.length
2031    } else if (typeof end === 'string') {
2032      encoding = end
2033      end = this.length
2034    }
2035    if (val.length === 1) {
2036      var code = val.charCodeAt(0)
2037      if (code < 256) {
2038        val = code
2039      }
2040    }
2041    if (encoding !== undefined && typeof encoding !== 'string') {
2042      throw new TypeError('encoding must be a string')
2043    }
2044    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
2045      throw new TypeError('Unknown encoding: ' + encoding)
2046    }
2047  } else if (typeof val === 'number') {
2048    val = val & 255
2049  }
2050
2051  // Invalid ranges are not set to a default, so can range check early.
2052  if (start < 0 || this.length < start || this.length < end) {
2053    throw new RangeError('Out of range index')
2054  }
2055
2056  if (end <= start) {
2057    return this
2058  }
2059
2060  start = start >>> 0
2061  end = end === undefined ? this.length : end >>> 0
2062
2063  if (!val) val = 0
2064
2065  var i
2066  if (typeof val === 'number') {
2067    for (i = start; i < end; ++i) {
2068      this[i] = val
2069    }
2070  } else {
2071    var bytes = Buffer.isBuffer(val)
2072      ? val
2073      : utf8ToBytes(new Buffer(val, encoding).toString())
2074    var len = bytes.length
2075    for (i = 0; i < end - start; ++i) {
2076      this[i + start] = bytes[i % len]
2077    }
2078  }
2079
2080  return this
2081}
2082
2083// HELPER FUNCTIONS
2084// ================
2085
2086var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
2087
2088function base64clean (str) {
2089  // Node strips out invalid characters like \n and \t from the string, base64-js does not
2090  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
2091  // Node converts strings with length < 2 to ''
2092  if (str.length < 2) return ''
2093  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
2094  while (str.length % 4 !== 0) {
2095    str = str + '='
2096  }
2097  return str
2098}
2099
2100function stringtrim (str) {
2101  if (str.trim) return str.trim()
2102  return str.replace(/^\s+|\s+$/g, '')
2103}
2104
2105function toHex (n) {
2106  if (n < 16) return '0' + n.toString(16)
2107  return n.toString(16)
2108}
2109
2110function utf8ToBytes (string, units) {
2111  units = units || Infinity
2112  var codePoint
2113  var length = string.length
2114  var leadSurrogate = null
2115  var bytes = []
2116
2117  for (var i = 0; i < length; ++i) {
2118    codePoint = string.charCodeAt(i)
2119
2120    // is surrogate component
2121    if (codePoint > 0xD7FF && codePoint < 0xE000) {
2122      // last char was a lead
2123      if (!leadSurrogate) {
2124        // no lead yet
2125        if (codePoint > 0xDBFF) {
2126          // unexpected trail
2127          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2128          continue
2129        } else if (i + 1 === length) {
2130          // unpaired lead
2131          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2132          continue
2133        }
2134
2135        // valid lead
2136        leadSurrogate = codePoint
2137
2138        continue
2139      }
2140
2141      // 2 leads in a row
2142      if (codePoint < 0xDC00) {
2143        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2144        leadSurrogate = codePoint
2145        continue
2146      }
2147
2148      // valid surrogate pair
2149      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
2150    } else if (leadSurrogate) {
2151      // valid bmp char, but last char was a lead
2152      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2153    }
2154
2155    leadSurrogate = null
2156
2157    // encode utf8
2158    if (codePoint < 0x80) {
2159      if ((units -= 1) < 0) break
2160      bytes.push(codePoint)
2161    } else if (codePoint < 0x800) {
2162      if ((units -= 2) < 0) break
2163      bytes.push(
2164        codePoint >> 0x6 | 0xC0,
2165        codePoint & 0x3F | 0x80
2166      )
2167    } else if (codePoint < 0x10000) {
2168      if ((units -= 3) < 0) break
2169      bytes.push(
2170        codePoint >> 0xC | 0xE0,
2171        codePoint >> 0x6 & 0x3F | 0x80,
2172        codePoint & 0x3F | 0x80
2173      )
2174    } else if (codePoint < 0x110000) {
2175      if ((units -= 4) < 0) break
2176      bytes.push(
2177        codePoint >> 0x12 | 0xF0,
2178        codePoint >> 0xC & 0x3F | 0x80,
2179        codePoint >> 0x6 & 0x3F | 0x80,
2180        codePoint & 0x3F | 0x80
2181      )
2182    } else {
2183      throw new Error('Invalid code point')
2184    }
2185  }
2186
2187  return bytes
2188}
2189
2190function asciiToBytes (str) {
2191  var byteArray = []
2192  for (var i = 0; i < str.length; ++i) {
2193    // Node's code seems to be doing this and not & 0x7F..
2194    byteArray.push(str.charCodeAt(i) & 0xFF)
2195  }
2196  return byteArray
2197}
2198
2199function utf16leToBytes (str, units) {
2200  var c, hi, lo
2201  var byteArray = []
2202  for (var i = 0; i < str.length; ++i) {
2203    if ((units -= 2) < 0) break
2204
2205    c = str.charCodeAt(i)
2206    hi = c >> 8
2207    lo = c % 256
2208    byteArray.push(lo)
2209    byteArray.push(hi)
2210  }
2211
2212  return byteArray
2213}
2214
2215function base64ToBytes (str) {
2216  return base64.toByteArray(base64clean(str))
2217}
2218
2219function blitBuffer (src, dst, offset, length) {
2220  for (var i = 0; i < length; ++i) {
2221    if ((i + offset >= dst.length) || (i >= src.length)) break
2222    dst[i + offset] = src[i]
2223  }
2224  return i
2225}
2226
2227function isnan (val) {
2228  return val !== val // eslint-disable-line no-self-compare
2229}
2230

2231},{"base64-js":"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/base64-js/index.js","ieee754":"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/ieee754/index.js","isarray":"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/isarray/index.js","buffer":"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/buffer/index.js"}],"C:/Users/tekur/AppData/Roaming/npm/node_modules/parcel-bundler/node_modules/process/browser.js":[function(require,module,exports) {
2232
2233// shim for using process in browser
2234var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it
2235// don't break things.  But we need to wrap it in a try catch in case it is
2236// wrapped in strict mode code which doesn't define any globals.  It's inside a
2237// function because try/catches deoptimize in certain engines.
2238
2239var cachedSetTimeout;
2240var cachedClearTimeout;
2241
2242function defaultSetTimout() {
2243  throw new Error('setTimeout has not been defined');
2244}
2245
2246function defaultClearTimeout() {
2247  throw new Error('clearTimeout has not been defined');
2248}
2249
2250(function () {
2251  try {
2252    if (typeof setTimeout === 'function') {
2253      cachedSetTimeout = setTimeout;
2254    } else {
2255      cachedSetTimeout = defaultSetTimout;
2256    }
2257  } catch (e) {
2258    cachedSetTimeout = defaultSetTimout;
2259  }
2260
2261  try {
2262    if (typeof clearTimeout === 'function') {
2263      cachedClearTimeout = clearTimeout;
2264    } else {
2265      cachedClearTimeout = defaultClearTimeout;
2266    }
2267  } catch (e) {
2268    cachedClearTimeout = defaultClearTimeout;
2269  }
2270})();
2271
2272function runTimeout(fun) {
2273  if (cachedSetTimeout === setTimeout) {
2274    //normal enviroments in sane situations
2275    return setTimeout(fun, 0);
2276  } // if setTimeout wasn't available but was latter defined
2277
2278
2279  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
2280    cachedSetTimeout = setTimeout;
2281    return setTimeout(fun, 0);
2282  }
2283
2284  try {
2285    // when when somebody has screwed with setTimeout but no I.E. maddness
2286    return cachedSetTimeout(fun, 0);
2287  } catch (e) {
2288    try {
2289      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
2290      return cachedSetTimeout.call(null, fun, 0);
2291    } catch (e) {
2292      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
2293      return cachedSetTimeout.call(this, fun, 0);
2294    }
2295  }
2296}
2297
2298function runClearTimeout(marker) {
2299  if (cachedClearTimeout === clearTimeout) {
2300    //normal enviroments in sane situations
2301    return clearTimeout(marker);
2302  } // if clearTimeout wasn't available but was latter defined
2303
2304
2305  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
2306    cachedClearTimeout = clearTimeout;
2307    return clearTimeout(marker);
2308  }
2309
2310  try {
2311    // when when somebody has screwed with setTimeout but no I.E. maddness
2312    return cachedClearTimeout(marker);
2313  } catch (e) {
2314    try {
2315      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
2316      return cachedClearTimeout.call(null, marker);
2317    } catch (e) {
2318      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
2319      // Some versions of I.E. have different rules for clearTimeout vs setTimeout
2320      return cachedClearTimeout.call(this, marker);
2321    }
2322  }
2323}
2324
2325var queue = [];
2326var draining = false;

2327var currentQueue;
2328var queueIndex = -1;
2329
2330function cleanUpNextTick() {
2331  if (!draining || !currentQueue) {
2332    return;
2333  }
2334
2335  draining = false;
2336
2337  if (currentQueue.length) {
2338    queue = currentQueue.concat(queue);
2339  } else {
2340    queueIndex = -1;
2341  }
2342
2343  if (queue.length) {
2344    drainQueue();
2345  }
2346}
2347
2348function drainQueue() {
2349  if (draining) {
2350    return;
2351  }
2352
2353  var timeout = runTimeout(cleanUpNextTick);
2354  draining = true;
2355  var len = queue.length;
2356
2357  while (len) {
2358    currentQueue = queue;
2359    queue = [];
2360
2361    while (++queueIndex < len) {
2362      if (currentQueue) {
2363        currentQueue[queueIndex].run();
2364      }
2365    }
2366
2367    queueIndex = -1;
2368    len = queue.length;
2369  }
2370
2371  currentQueue = null;
2372  draining = false;
2373  runClearTimeout(timeout);
2374}
2375
2376process.nextTick = function (fun) {
2377  var args = new Array(arguments.length - 1);
2378
2379  if (arguments.length > 1) {
2380    for (var i = 1; i < arguments.length; i++) {
2381      args[i - 1] = arguments[i];
2382    }
2383  }
2384
2385  queue.push(new Item(fun, args));
2386
2387  if (queue.length === 1 && !draining) {
2388    runTimeout(drainQueue);
2389  }
2390}; // v8 likes predictible objects
2391
2392
2393function Item(fun, array) {
2394  this.fun = fun;
2395  this.array = array;
2396}
2397
2398Item.prototype.run = function () {
2399  this.fun.apply(null, this.array);
2400};
2401
2402process.title = 'browser';
2403process.env = {};
2404process.argv = [];
2405process.version = ''; // empty string to avoid regexp issues
2406
2407process.versions = {};
2408
2409function noop() {}
2410
2411process.on = noop;
2412process.addListener = noop;
2413process.once = noop;
2414process.off = noop;
2415process.removeListener = noop;
2416process.removeAllListeners = noop;
2417process.emit = noop;
2418process.prependListener = noop;
2419process.prependOnceListener = noop;
2420
2421process.listeners = function (name) {
2422  return [];
2423};
2424
2425process.binding = function (name) {
2426  throw new Error('process.binding is not supported');
2427};
2428
2429process.cwd = function () {
2430  return '/';
2431};
2432
2433process.chdir = function (dir) {
2434  throw new Error('process.chdir is not supported');
2435};
2436
2437process.umask = function () {
2438  return 0;
2439};
2440},{}],"../node_modules/p5/lib/p5.js":[function(require,module,exports) {
2441var define;
2442var global = arguments[3];
2443var Buffer = require("buffer").Buffer;
2444var process = require("process");
2445/*! p5.js v0.7.3 January 20, 2019 */
2446(function (f) {
2447  if (typeof exports === "object" && typeof module !== "undefined") {
2448    module.exports = f();
2449  } else if (typeof define === "function" && define.amd) {
2450    define([], f);
2451  } else {
2452    var g;
2453
2454    if (typeof window !== "undefined") {
2455      g = window;
2456    } else if (typeof global !== "undefined") {
2457      g = global;
2458    } else if (typeof self !== "undefined") {
2459      g = self;
2460    } else {
2461      g = this;
2462    }
2463
2464    g.p5 = f();
2465  }
2466})(function () {
2467  var define, module, exports;
2468  return function () {
2469    function r(e, n, t) {
2470      function o(i, f) {
2471        if (!n[i]) {
2472          if (!e[i]) {
2473            var c = "function" == typeof require && require;
2474            if (!f && c) return c(i, !0);
2475            if (u) return u(i, !0);
2476            var a = new Error("Cannot find module '" + i + "'");
2477            throw a.code = "MODULE_NOT_FOUND", a;
2478          }
2479
2480          var p = n[i] = {
2481            exports: {}
2482          };
2483          e[i][0].call(p.exports, function (r) {
2484            var n = e[i][1][r];
2485            return o(n || r);
2486          }, p, p.exports, r, e, n, t);
2487        }
2488
2489        return n[i].exports;
2490      }
2491
2492      for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
2493
2494      return o;
2495    }
2496
2497    return r;
2498  }()({
2499    1: [function (_dereq_, module, exports) {
2500      module.exports = {
2501        "project": {
2502          "name": "p5",
2503          "description": "[![Build Status](https://travis-ci.org/processing/p5.js.svg?branch=master)](https://travis-ci.org/processing/p5.js) [![npm version](https://badge.fury.io/js/p5.svg)](https://www.npmjs.com/package/p5)",
2504          "version": "0.7.3",
2505          "url": "https://github.com/processing/p5.js#readme"
2506        },
2507        "files": {
2508          "src/color/color_conversion.js": {
2509            "name": "src/color/color_conversion.js",
2510            "modules": {
2511              "Color Conversion": 1
2512            },
2513            "classes": {},
2514            "fors": {