https://pose-animator-demo.firebaseapp.com/camera.283d5d54.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})({"node_modules/parcel-bundler/src/builtins/_empty.js":[function(require,module,exports) {
121
122},{}],"node_modules/process/browser.js":[function(require,module,exports) {
123
124// shim for using process in browser
125var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it
126// don't break things.  But we need to wrap it in a try catch in case it is
127// wrapped in strict mode code which doesn't define any globals.  It's inside a
128// function because try/catches deoptimize in certain engines.
129
130var cachedSetTimeout;
131var cachedClearTimeout;
132
133function defaultSetTimout() {
134  throw new Error('setTimeout has not been defined');
135}
136
137function defaultClearTimeout() {
138  throw new Error('clearTimeout has not been defined');
139}
140
141(function () {
142  try {
143    if (typeof setTimeout === 'function') {
144      cachedSetTimeout = setTimeout;
145    } else {
146      cachedSetTimeout = defaultSetTimout;
147    }
148  } catch (e) {
149    cachedSetTimeout = defaultSetTimout;
150  }
151
152  try {
153    if (typeof clearTimeout === 'function') {
154      cachedClearTimeout = clearTimeout;
155    } else {
156      cachedClearTimeout = defaultClearTimeout;
157    }
158  } catch (e) {
159    cachedClearTimeout = defaultClearTimeout;
160  }
161})();
162
163function runTimeout(fun) {
164  if (cachedSetTimeout === setTimeout) {
165    //normal enviroments in sane situations
166    return setTimeout(fun, 0);
167  } // if setTimeout wasn't available but was latter defined
168
169
170  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
171    cachedSetTimeout = setTimeout;
172    return setTimeout(fun, 0);
173  }
174
175  try {
176    // when when somebody has screwed with setTimeout but no I.E. maddness
177    return cachedSetTimeout(fun, 0);
178  } catch (e) {
179    try {
180      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
181      return cachedSetTimeout.call(null, fun, 0);
182    } catch (e) {
183      // 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
184      return cachedSetTimeout.call(this, fun, 0);
185    }
186  }
187}
188
189function runClearTimeout(marker) {
190  if (cachedClearTimeout === clearTimeout) {
191    //normal enviroments in sane situations
192    return clearTimeout(marker);
193  } // if clearTimeout wasn't available but was latter defined
194
195
196  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
197    cachedClearTimeout = clearTimeout;
198    return clearTimeout(marker);
199  }
200
201  try {
202    // when when somebody has screwed with setTimeout but no I.E. maddness
203    return cachedClearTimeout(marker);
204  } catch (e) {
205    try {
206      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
207      return cachedClearTimeout.call(null, marker);
208    } catch (e) {
209      // 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.
210      // Some versions of I.E. have different rules for clearTimeout vs setTimeout
211      return cachedClearTimeout.call(this, marker);
212    }
213  }
214}
215
216var queue = [];
217var draining = false;
218var currentQueue;
219var queueIndex = -1;
220
221function cleanUpNextTick() {
222  if (!draining || !currentQueue) {
223    return;
224  }
225
226  draining = false;
227
228  if (currentQueue.length) {
229    queue = currentQueue.concat(queue);
230  } else {
231    queueIndex = -1;
232  }
233
234  if (queue.length) {
235    drainQueue();
236  }
237}
238
239function drainQueue() {
240  if (draining) {
241    return;
242  }
243
244  var timeout = runTimeout(cleanUpNextTick);
245  draining = true;
246  var len = queue.length;
247
248  while (len) {
249    currentQueue = queue;
250    queue = [];
251
252    while (++queueIndex < len) {
253      if (currentQueue) {
254        currentQueue[queueIndex].run();
255      }
256    }
257
258    queueIndex = -1;
259    len = queue.length;
260  }
261
262  currentQueue = null;
263  draining = false;
264  runClearTimeout(timeout);
265}
266
267process.nextTick = function (fun) {
268  var args = new Array(arguments.length - 1);
269
270  if (arguments.length > 1) {
271    for (var i = 1; i < arguments.length; i++) {
272      args[i - 1] = arguments[i];
273    }
274  }
275
276  queue.push(new Item(fun, args));
277
278  if (queue.length === 1 && !draining) {
279    runTimeout(drainQueue);
280  }
281}; // v8 likes predictible objects
282
283
284function Item(fun, array) {
285  this.fun = fun;
286  this.array = array;
287}
288
289Item.prototype.run = function () {
290  this.fun.apply(null, this.array);
291};
292
293process.title = 'browser';
294process.env = {};
295process.argv = [];
296process.version = ''; // empty string to avoid regexp issues
297
298process.versions = {};
299
300function noop() {}
301
302process.on = noop;
303process.addListener = noop;
304process.once = noop;
305process.off = noop;
306process.removeListener = noop;
307process.removeAllListeners = noop;
308process.emit = noop;
309process.prependListener = noop;
310process.prependOnceListener = noop;
311
312process.listeners = function (name) {
313  return [];
314};
315
316process.binding = function (name) {
317  throw new Error('process.binding is not supported');
318};
319
320process.cwd = function () {
321  return '/';
322};
323
324process.chdir = function (dir) {
325  throw new Error('process.chdir is not supported');
326};
327
328process.umask = function () {
329  return 0;
330};
331},{}],"node_modules/base64-js/index.js":[function(require,module,exports) {
332'use strict'
333
334exports.byteLength = byteLength
335exports.toByteArray = toByteArray
336exports.fromByteArray = fromByteArray
337
338var lookup = []
339var revLookup = []
340var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
341
342var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
343for (var i = 0, len = code.length; i < len; ++i) {
344  lookup[i] = code[i]
345  revLookup[code.charCodeAt(i)] = i
346}
347
348// Support decoding URL-safe base64 strings, as Node.js does.
349// See: https://en.wikipedia.org/wiki/Base64#URL_applications
350revLookup['-'.charCodeAt(0)] = 62
351revLookup['_'.charCodeAt(0)] = 63
352
353function getLens (b64) {
354  var len = b64.length
355
356  if (len % 4 > 0) {
357    throw new Error('Invalid string. Length must be a multiple of 4')
358  }
359
360  // Trim off extra bytes after placeholder bytes are found
361  // See: https://github.com/beatgammit/base64-js/issues/42
362  var validLen = b64.indexOf('=')
363  if (validLen === -1) validLen = len
364
365  var placeHoldersLen = validLen === len
366    ? 0
367    : 4 - (validLen % 4)
368
369  return [validLen, placeHoldersLen]
370}
371
372// base64 is 4/3 + up to two characters of the original data
373function byteLength (b64) {
374  var lens = getLens(b64)
375  var validLen = lens[0]
376  var placeHoldersLen = lens[1]
377  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
378}
379
380function _byteLength (b64, validLen, placeHoldersLen) {
381  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
382}
383
384function toByteArray (b64) {
385  var tmp
386  var lens = getLens(b64)
387  var validLen = lens[0]
388  var placeHoldersLen = lens[1]
389
390  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
391
392  var curByte = 0
393
394  // if there are placeholders, only get up to the last complete 4 chars
395  var len = placeHoldersLen > 0
396    ? validLen - 4
397    : validLen
398
399  var i
400  for (i = 0; i < len; i += 4) {
401    tmp =
402      (revLookup[b64.charCodeAt(i)] << 18) |
403      (revLookup[b64.charCodeAt(i + 1)] << 12) |
404      (revLookup[b64.charCodeAt(i + 2)] << 6) |
405      revLookup[b64.charCodeAt(i + 3)]
406    arr[curByte++] = (tmp >> 16) & 0xFF
407    arr[curByte++] = (tmp >> 8) & 0xFF
408    arr[curByte++] = tmp & 0xFF
409  }
410
411  if (placeHoldersLen === 2) {
412    tmp =
413      (revLookup[b64.charCodeAt(i)] << 2) |
414      (revLookup[b64.charCodeAt(i + 1)] >> 4)
415    arr[curByte++] = tmp & 0xFF
416  }
417
418  if (placeHoldersLen === 1) {
419    tmp =
420      (revLookup[b64.charCodeAt(i)] << 10) |
421      (revLookup[b64.charCodeAt(i + 1)] << 4) |
422      (revLookup[b64.charCodeAt(i + 2)] >> 2)
423    arr[curByte++] = (tmp >> 8) & 0xFF
424    arr[curByte++] = tmp & 0xFF
425  }
426
427  return arr
428}
429
430function tripletToBase64 (num) {
431  return lookup[num >> 18 & 0x3F] +
432    lookup[num >> 12 & 0x3F] +
433    lookup[num >> 6 & 0x3F] +
434    lookup[num & 0x3F]
435}
436
437function encodeChunk (uint8, start, end) {
438  var tmp
439  var output = []
440  for (var i = start; i < end; i += 3) {
441    tmp =
442      ((uint8[i] << 16) & 0xFF0000) +
443      ((uint8[i + 1] << 8) & 0xFF00) +
444      (uint8[i + 2] & 0xFF)
445    output.push(tripletToBase64(tmp))
446  }
447  return output.join('')
448}
449
450function fromByteArray (uint8) {
451  var tmp
452  var len = uint8.length
453  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
454  var parts = []
455  var maxChunkLength = 16383 // must be multiple of 3
456
457  // go through the array every three bytes, we'll deal with trailing stuff later
458  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
459    parts.push(encodeChunk(
460      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
461    ))
462  }
463
464  // pad the end with zeros, but make sure to not forget the extra bytes
465  if (extraBytes === 1) {
466    tmp = uint8[len - 1]
467    parts.push(
468      lookup[tmp >> 2] +
469      lookup[(tmp << 4) & 0x3F] +
470      '=='
471    )
472  } else if (extraBytes === 2) {
473    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
474    parts.push(
475      lookup[tmp >> 10] +
476      lookup[(tmp >> 4) & 0x3F] +
477      lookup[(tmp << 2) & 0x3F] +
478      '='
479    )
480  }
481
482  return parts.join('')
483}
484
485},{}],"node_modules/ieee754/index.js":[function(require,module,exports) {
486exports.read = function (buffer, offset, isLE, mLen, nBytes) {
487  var e, m
488  var eLen = (nBytes * 8) - mLen - 1
489  var eMax = (1 << eLen) - 1
490  var eBias = eMax >> 1
491  var nBits = -7
492  var i = isLE ? (nBytes - 1) : 0
493  var d = isLE ? -1 : 1
494  var s = buffer[offset + i]
495
496  i += d
497
498  e = s & ((1 << (-nBits)) - 1)
499  s >>= (-nBits)
500  nBits += eLen
501  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
502
503  m = e & ((1 << (-nBits)) - 1)
504  e >>= (-nBits)
505  nBits += mLen
506  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
507
508  if (e === 0) {
509    e = 1 - eBias
510  } else if (e === eMax) {
511    return m ? NaN : ((s ? -1 : 1) * Infinity)
512  } else {
513    m = m + Math.pow(2, mLen)
514    e = e - eBias
515  }
516  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
517}
518
519exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
520  var e, m, c
521  var eLen = (nBytes * 8) - mLen - 1
522  var eMax = (1 << eLen) - 1
523  var eBias = eMax >> 1
524  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
525  var i = isLE ? 0 : (nBytes - 1)
526  var d = isLE ? 1 : -1
527  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
528
529  value = Math.abs(value)
530
531  if (isNaN(value) || value === Infinity) {
532    m = isNaN(value) ? 1 : 0
533    e = eMax
534  } else {
535    e = Math.floor(Math.log(value) / Math.LN2)
536    if (value * (c = Math.pow(2, -e)) < 1) {
537      e--
538      c *= 2
539    }
540    if (e + eBias >= 1) {
541      value += rt / c
542    } else {
543      value += rt * Math.pow(2, 1 - eBias)
544    }
545    if (value * c >= 2) {
546      e++
547      c /= 2
548    }
549
550    if (e + eBias >= eMax) {
551      m = 0
552      e = eMax
553    } else if (e + eBias >= 1) {
554      m = ((value * c) - 1) * Math.pow(2, mLen)
555      e = e + eBias
556    } else {
557      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
558      e = 0
559    }
560  }
561
562  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
563
564  e = (e << mLen) | m
565  eLen += mLen
566  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
567
568  buffer[offset + i - d] |= s * 128
569}
570
571},{}],"node_modules/isarray/index.js":[function(require,module,exports) {
572var toString = {}.toString;
573
574module.exports = Array.isArray || function (arr) {
575  return toString.call(arr) == '[object Array]';
576};
577
578},{}],"node_modules/buffer/index.js":[function(require,module,exports) {
579
580var global = arguments[3];
581/*!
582 * The buffer module from node.js, for the browser.
583 *
584 * @author   Feross Aboukhadijeh <http://feross.org>
585 * @license  MIT
586 */
587/* eslint-disable no-proto */
588
589'use strict'
590
591var base64 = require('base64-js')
592var ieee754 = require('ieee754')
593var isArray = require('isarray'

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