https://siscad.cfmv.gov.br/vendors/pdfmake/pdfmake.js

195)
196
197exports.Buffer = Buffer
198exports.SlowBuffer = SlowBuffer
199exports.INSPECT_MAX_BYTES = 50
200
201/**
202 * If `Buffer.TYPED_ARRAY_SUPPORT`:
203 *   === true    Use Uint8Array implementation (fastest)
204 *   === false   Use Object implementation (most compatible, even IE6)
205 *
206 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
207 * Opera 11.6+, iOS 4.2+.
208 *
209 * Due to various browser bugs, sometimes the Object implementation will be used even
210 * when the browser supports typed arrays.
211 *
212 * Note:
213 *
214 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
215 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
216 *
217 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
218 *
219 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
220 *     incorrect length in some situations.
221
222 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
223 * get the Object implementation, which is slower but behaves correctly.
224 */
225Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
226  ? global.TYPED_ARRAY_SUPPORT
227  : typedArraySupport()
228
229/*
230 * Export kMaxLength after typed array support is determined.
231 */
232exports.kMaxLength = kMaxLength()
233
234function typedArraySupport () {
235  try {
236    var arr = new Uint8Array(1)
237    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
238    return arr.foo() === 42 && // typed array instances can be augmented
239        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
240        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
241  } catch (e) {
242    return false
243  }
244}
245
246function kMaxLength () {
247  return Buffer.TYPED_ARRAY_SUPPORT
248    ? 0x7fffffff
249    : 0x3fffffff
250}
251
252function createBuffer (that, length) {
253  if (kMaxLength() < length) {
254    throw new RangeError('Invalid typed array length')
255  }
256  if (Buffer.TYPED_ARRAY_SUPPORT) {
257    // Return an augmented `Uint8Array` instance, for best performance
258    that = new Uint8Array(length)
259    that.__proto__ = Buffer.prototype
260  } else {
261    // Fallback: Return an object instance of the Buffer class
262    if (that === null) {
263      that = new Buffer(length)
264    }
265    that.length = length
266  }
267
268  return that
269}
270
271/**
272 * The Buffer constructor returns instances of `Uint8Array` that have their
273 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
274 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
275 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
276 * returns a single octet.
277 *
278 * The `Uint8Array` prototype remains unmodified.
279 */
280
281function Buffer (arg, encodingOrOffset, length) {
282  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
283    return new Buffer(arg, encodingOrOffset, length)
284  }
285
286  // Common case.
287  if (typeof arg === 'number') {
288    if (typeof encodingOrOffset === 'string') {
289      throw new Error(
290        'If encoding is specified then the first argument must be a string'
291      )
292    }
293    return allocUnsafe(this, arg)
294  }
295  return from(this, arg, encodingOrOffset, length)
296}
297
298Buffer.poolSize = 8192 // not used by this implementation
299
300// TODO: Legacy, not needed anymore. Remove in next major version.
301Buffer._augment = function (arr) {
302  arr.__proto__ = Buffer.prototype
303  return arr
304}
305
306function from (that, value, encodingOrOffset, length) {
307  if (typeof value === 'number') {
308    throw new TypeError('"value" argument must not be a number')
309  }
310
311  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
312    return fromArrayBuffer(that, value, encodingOrOffset, length)
313  }
314
315  if (typeof value === 'string') {
316    return fromString(that, value, encodingOrOffset)
317  }
318
319  return fromObject(that, value)
320}
321
322/**
323 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
324 * if value is a number.
325 * Buffer.from(str[, encoding])
326 * Buffer.from(array)
327 * Buffer.from(buffer)
328 * Buffer.from(arrayBuffer[, byteOffset[, length]])
329 **/
330Buffer.from = function (value, encodingOrOffset, length) {
331  return from(null, value, encodingOrOffset, length)
332}
333
334if (Buffer.TYPED_ARRAY_SUPPORT) {
335  Buffer.prototype.__proto__ = Uint8Array.prototype
336  Buffer.__proto__ = Uint8Array
337  if (typeof Symbol !== 'undefined' && Symbol.species &&
338      Buffer[Symbol.species] === Buffer) {
339    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
340    Object.defineProperty(Buffer, Symbol.species, {
341      value: null,
342      configurable: true
343    })
344  }
345}
346
347function assertSize (size) {
348  if (typeof size !== 'number') {
349    throw new TypeError('"size" argument must be a number')
350  } else if (size < 0) {
351    throw new RangeError('"size" argument must not be negative')
352  }
353}
354
355function alloc (that, size, fill, encoding) {
356  assertSize(size)
357  if (size <= 0) {
358    return createBuffer(that, size)
359  }
360  if (fill !== undefined) {
361    // Only pay attention to encoding if it's a string. This
362    // prevents accidentally sending in a number that would
363    // be interpretted as a start offset.
364    return typeof encoding === 'string'
365      ? createBuffer(that, size).fill(fill, encoding)
366      : createBuffer(that, size).fill(fill)
367  }
368  return createBuffer(that, size)
369}
370
371/**
372 * Creates a new filled Buffer instance.
373 * alloc(size[, fill[, encoding]])
374 **/
375Buffer.alloc = function (size, fill, encoding) {
376  return alloc(null, size, fill, encoding)
377}
378
379function allocUnsafe (that, size) {
380  assertSize(size)
381  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
382  if (!Buffer.TYPED_ARRAY_SUPPORT) {
383    for (var i = 0; i < size; ++i) {
384      that[i] = 0
385    }
386  }
387  return that
388}
389
390/**
391 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
392 * */
393Buffer.allocUnsafe = function (size) {
394  return allocUnsafe(null, size)
395}
396/**
397 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
398 */
399Buffer.allocUnsafeSlow = function (size) {
400  return allocUnsafe(null, size)
401}
402
403function fromString (that, string, encoding) {
404  if (typeof encoding !== 'string' || encoding === '') {
405    encoding = 'utf8'
406  }
407
408  if (!Buffer.isEncoding(encoding)) {
409    throw new TypeError('"encoding" must be a valid string encoding')
410  }
411
412  var length = byteLength(string, encoding) | 0
413  that = createBuffer(that, length)
414
415  var actual = that.write(string, encoding)
416
417  if (actual !== length) {

418    // Writing a hex string, for example, that contains invalid characters will
419    // cause everything after the first invalid character to be ignored. (e.g.
420    // 'abxxcd' will be treated as 'ab')
421    that = that.slice(0, actual)
422  }
423
424  return that
425}
426
427function fromArrayLike (that, array) {
428  var length = array.length < 0 ? 0 : checked(array.length) | 0
429  that = createBuffer(that, length)
430  for (var i = 0; i < length; i += 1) {
431    that[i] = array[i] & 255
432  }
433  return that
434}
435
436function fromArrayBuffer (that, array, byteOffset, length) {
437  array.byteLength // this throws if `array` is not a valid ArrayBuffer
438
439  if (byteOffset < 0 || array.byteLength < byteOffset) {
440    throw new RangeError('\'offset\' is out of bounds')
441  }
442
443  if (array.byteLength < byteOffset + (length || 0)) {
444    throw new RangeError('\'length\' is out of bounds')
445  }
446
447  if (byteOffset === undefined && length === undefined) {
448    array = new Uint8Array(array)
449  } else if (length === undefined) {
450    array = new Uint8Array(array, byteOffset)
451  } else {
452    array = new Uint8Array(array, byteOffset, length)
453  }
454
455  if (Buffer.TYPED_ARRAY_SUPPORT) {
456    // Return an augmented `Uint8Array` instance, for best performance
457    that = array
458    that.__proto__ = Buffer.prototype
459  } else {
460    // Fallback: Return an object instance of the Buffer class
461    that = fromArrayLike(that, array)
462  }
463  return that
464}
465
466function fromObject (that, obj) {
467  if (Buffer.isBuffer(obj)) {
468    var len = checked(obj.length) | 0
469    that = createBuffer(that, len)
470
471    if (that.length === 0) {
472      return that
473    }
474
475    obj.copy(that, 0, 0, len)
476    return that
477  }
478
479  if (obj) {
480    if ((typeof ArrayBuffer !== 'undefined' &&
481        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
482      if (typeof obj.length !== 'number' || isnan(obj.length)) {
483        return createBuffer(that, 0)
484      }
485      return fromArrayLike(that, obj)
486    }
487
488    if (obj.type === 'Buffer' && isArray(obj.data)) {
489      return fromArrayLike(that, obj.data)
490    }
491  }
492
493  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
494}
495
496function checked (length) {
497  // Note: cannot use `length < kMaxLength()` here because that fails when
498  // length is NaN (which is otherwise coerced to zero.)
499  if (length >= kMaxLength()) {
500    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
501                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
502  }
503  return length | 0
504}
505
506function SlowBuffer (length) {
507  if (+length != length) { // eslint-disable-line eqeqeq
508    length = 0
509  }
510  return Buffer.alloc(+length)
511}
512
513Buffer.isBuffer = function isBuffer (b) {
514  return !!(b != null && b._isBuffer)
515}
516
517Buffer.compare = function compare (a, b) {
518  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
519    throw new TypeError('Arguments must be Buffers')
520  }
521
522  if (a === b) return 0
523
524  var x = a.length
525  var y = b.length
526
527  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
528    if (a[i] !== b[i]) {
529      x = a[i]
530      y = b[i]
531      break
532    }
533  }
534
535  if (x < y) return -1
536  if (y < x) return 1
537  return 0
538}
539
540Buffer.isEncoding = function isEncoding (encoding) {
541  switch (String(encoding).toLowerCase()) {
542    case 'hex':
543    case 'utf8':
544    case 'utf-8':
545    case 'ascii':
546    case 'latin1':
547    case 'binary':
548    case 'base64':
549    case 'ucs2':
550    case 'ucs-2':
551    case 'utf16le':
552    case 'utf-16le':
553      return true
554    default:
555      return false
556  }
557}
558
559Buffer.concat = function concat (list, length) {
560  if (!isArray(list)) {
561    throw new TypeError('"list" argument must be an Array of Buffers')
562  }
563
564  if (list.length === 0) {
565    return Buffer.alloc(0)
566  }
567
568  var i
569  if (length === undefined) {
570    length = 0
571    for (i = 0; i < list.length; ++i) {
572      length += list[i].length
573    }
574  }
575
576  var buffer = Buffer.allocUnsafe(length)
577  var pos = 0
578  for (i = 0; i < list.length; ++i) {
579    var buf = list[i]
580    if (!Buffer.isBuffer(buf)) {
581      throw new TypeError('"list" argument must be an Array of Buffers')
582    }
583    buf.copy(buffer, pos)
584    pos += buf.length
585  }
586  return buffer
587}
588
589function byteLength (string, encoding) {
590  if (Buffer.isBuffer(string)) {
591    return string.length
592  }
593  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
594      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
595    return string.byteLength
596  }
597  if (typeof string !== 'string') {
598    string = '' + string
599  }
600
601  var len = string.length
602  if (len === 0) return 0
603
604  // Use a for loop to avoid recursion
605  var loweredCase = false
606  for (;;) {
607    switch (encoding) {
608      case 'ascii':
609      case 'latin1':
610      case 'binary':
611        return len
612      case 'utf8':
613      case 'utf-8':
614      case undefined:
615        return utf8ToBytes(string).length
616      case 'ucs2':
617      case 'ucs-2':
618      case 'utf16le':
619      case 'utf-16le':
620        return len * 2
621      case 'hex':
622        return len >>> 1
623      case 'base64':
624        return base64ToBytes(string).length
625      default:
626        if (loweredCase) return utf8ToBytes(string).length // assume utf8
627        encoding = ('' + encoding).toLowerCase()
628        loweredCase = true
629    }
630  }
631}
632Buffer.byteLength = byteLength
633
634function slowToString (encoding, start, end) {
635  var loweredCase = false
636
637  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
638  // property of a typed array.
639
640  // This behaves neither like String nor Uint8Array in that we set start/end
641  // to their upper/lower bounds if the value passed is out of range.
642  // undefined is handled specially as per ECMA-262 6th Edition,
643  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
644  if (start === undefined || start < 0) {
645    start = 0
646  }
647  // Return early if start > this.length. Done here to prevent potential uint32
648  // coercion fail below.
649  if (start > this.length) {
650    return ''
651  }
652
653  if (end === undefined || end > this.length) {
654    end = this.length
655  }
656
657  if (end <= 0) {
658    return ''
659  }
660
661  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
662  end >>>= 0
663  start >>>= 0
664
665  if (end <= start) {
666    return ''
667  }
668
669  if (!encoding) encoding = 'utf8'
670
671  while (true) {
672    switch (encoding) {
673      case 'hex':
674        return hexSlice(this, start, end)
675
676      case 'utf8':
677      case 'utf-8':
678        return utf8Slice(this, start, end)
679
680      case 'ascii':
681        return asciiSlice(this, start, end)
682
683      case 'latin1':
684      case 'binary':
685        return latin1Slice(this, start, end)
686
687      case 'base64':
688        return base64Slice(this, start, end)
689
690      case 'ucs2':
691      case 'ucs-2':
692      case 'utf16le':
693      case 'utf-16le':
694        return utf16leSlice(this, start, end)
695
696      default:
697        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
698        encoding = (encoding + '').toLowerCase()
699        loweredCase = true
700    }
701  }
702}
703
704// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
705// Buffer instances.
706Buffer.prototype._isBuffer = true
707
708function swap (b, n, m) {
709  var i = b[n]
710  b[n] = b[m]
711  b[m] = i
712}
713
714Buffer.prototype.swap16 = function swap16 () {
715  var len = this.length
716  if (len % 2 !== 0) {
717    throw new RangeError('Buffer size must be a multiple of 16-bits')
718  }
719  for (var i = 0; i < len; i += 2) {
720    swap(this, i, i + 1)
721  }
722  return this
723}
724
725Buffer.prototype.swap32 = function swap32 () {
726  var len = this.length
727  if (len % 4 !== 0) {
728    throw new RangeError('Buffer size must be a multiple of 32-bits')
729  }
730  for (var i = 0; i < len; i += 4) {
731    swap(this, i, i + 3)
732    swap(this, i + 1, i + 2)
733  }
734  return this
735}
736
737Buffer.prototype.swap64 = function swap64 () {
738  var len = this.length
739  if (len % 8 !== 0) {
740    throw new RangeError('Buffer size must be a multiple of 64-bits')
741  }
742  for (var i = 0; i < len; i += 8) {
743    swap(this, i, i + 7)
744    swap(this, i + 1, i + 6)
745    swap(this, i + 2, i + 5)
746    swap(this, i + 3, i + 4)
747  }
748  return this
749}
750
751Buffer.prototype.toString = function toString () {
752  var length = this.length | 0
753  if (length === 0) return ''
754  if (arguments.length === 0) return utf8Slice(this, 0, length)
755  return slowToString.apply(this, arguments)
756}
757
758Buffer.prototype.equals = function equals (b) {
759  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
760  if (this === b) return true
761  return Buffer.compare(this, b) === 0
762}
763
764Buffer.prototype.inspect = function inspect () {
765  var str = ''

766  var max = exports.INSPECT_MAX_BYTES
767  if (this.length > 0) {
768    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
769    if (this.length > max) str += ' ... '
770  }
771  return '<Buffer ' + str + '>'
772}
773
774Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
775  if (!Buffer.isBuffer(target)) {
776    throw new TypeError('Argument must be a Buffer')
777  }
778
779  if (start === undefined) {
780    start = 0
781  }
782  if (end === undefined) {
783    end = target ? target.length : 0
784  }
785  if (thisStart === undefined) {
786    thisStart = 0
787  }
788  if (thisEnd === undefined) {
789    thisEnd = this.length
790  }
791
792  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
793    throw new RangeError('out of range index')
794  }
795
796  if (thisStart >= thisEnd && start >= end) {
797    return 0
798  }
799  if (thisStart >= thisEnd) {
800    return -1
801  }
802  if (start >= end) {
803    return 1
804  }
805
806  start >>>= 0
807  end >>>= 0
808  thisStart >>>= 0
809  thisEnd >>>= 0
810
811  if (this === target) return 0
812
813  var x = thisEnd - thisStart
814  var y = end - start
815  var len = Math.min(x, y)
816
817  var thisCopy = this.slice(thisStart, thisEnd)
818  var targetCopy = target.slice(start, end)
819
820  for (var i = 0; i < len; ++i) {
821    if (thisCopy[i] !== targetCopy[i]) {
822      x = thisCopy[i]
823      y = targetCopy[i]
824      break
825    }
826  }
827
828  if (x < y) return -1
829  if (y < x) return 1
830  return 0
831}
832
833// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
834// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
835//
836// Arguments:
837// - buffer - a Buffer to search
838// - val - a string, Buffer, or number
839// - byteOffset - an index into `buffer`; will be clamped to an int32
840// - encoding - an optional encoding, relevant is val is a string
841// - dir - true for indexOf, false for lastIndexOf
842function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
843  // Empty buffer means no match
844  if (buffer.length === 0) return -1
845
846  // Normalize byteOffset
847  if (typeof byteOffset === 'string') {
848    encoding = byteOffset
849    byteOffset = 0
850  } else if (byteOffset > 0x7fffffff) {
851    byteOffset = 0x7fffffff
852  } else if (byteOffset < -0x80000000) {
853    byteOffset = -0x80000000
854  }
855  byteOffset = +byteOffset  // Coerce to Number.
856  if (isNaN(byteOffset)) {
857    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
858    byteOffset = dir ? 0 : (buffer.length - 1)
859  }
860
861  // Normalize byteOffset: negative offsets start from the end of the buffer
862  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
863  if (byteOffset >= buffer.length) {
864    if (dir) return -1
865    else byteOffset = buffer.length - 1
866  } else if (byteOffset < 0) {
867    if (dir) byteOffset = 0
868    else return -1
869  }
870
871  // Normalize val
872  if (typeof val === 'string') {
873    val = Buffer.from(val, encoding)
874  }
875
876  // Finally, search either indexOf (if dir is true) or lastIndexOf
877  if (Buffer.isBuffer(val)) {
878    // Special case: looking for empty string/buffer always fail

878s
879    if (val.length === 0) {
880      return -1
881    }
882    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
883  } else if (typeof val === 'number') {
884    val = val & 0xFF // Search for a byte value [0-255]
885    if (Buffer.TYPED_ARRAY_SUPPORT &&
886        typeof Uint8Array.prototype.indexOf === 'function') {
887      if (dir) {
888        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
889      } else {
890        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
891      }
892    }
893    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
894  }
895
896  throw new TypeError('val must be string, number or Buffer')
897}
898
899function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
900  var indexSize = 1
901  var arrLength = arr.length
902  var valLength = val.length
903
904  if (encoding !== undefined) {
905    encoding = String(encoding).toLowerCase()
906    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
907        encoding === 'utf16le' || encoding === 'utf-16le') {
908      if (arr.length < 2 || val.length < 2) {
909        return -1
910      }
911      indexSize = 2
912      arrLength /= 2
913      valLength /= 2
914      byteOffset /= 2
915    }
916  }
917
918  function read (buf, i) {
919    if (indexSize === 1) {
920      return buf[i]
921    } else {
922      return buf.readUInt16BE(i * indexSize)
923    }
924  }
925
926  var i
927  if (dir) {
928    var foundIndex = -1
929    for (i = byteOffset; i < arrLength; i++) {
930      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
931        if (foundIndex === -1) foundIndex = i
932        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
933      } else {
934        if (foundIndex !== -1) i -= i - foundIndex
935        foundIndex = -1
936      }
937    }
938  } else {
939    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
940    for (i = byteOffset; i >= 0; i--) {
941      var found = true
942      for (var j = 0; j < valLength; j++) {
943        if (read(arr, i + j) !== read(val, j)) {
944          found = false
945          break
946        }
947      }
948      if (found) return i
949    }
950  }
951
952  return -1
953}
954
955Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
956  return this.indexOf(val, byteOffset, encoding) !== -1
957}
958
959Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
960  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
961}
962
963Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
964  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
965}
966
967function hexWrite (buf, string, offset, length) {
968  offset = Number(offset) || 0
969  var remaining = buf.length - offset
970  if (!length) {
971    length = remaining
972  } else {
973    length = Number(length)
974    if (length > remaining) {
975      length = remaining
976    }
977  }
978
979  // must be an even number of digits
980  var strLen = string.length
981  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
982
983  if (length > strLen / 2) {
984    length = strLen / 2
985  }
986  for (var i = 0; i < length; ++i) {
987    var parsed = parseInt(string.substr(i * 2, 2), 16)
988    if (isNaN(parsed)) return i
989    buf[offset + i] = parsed
990  }
991  return i
992}
993
994function utf8Write (buf, string, offset, length) {
995  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
996}
997
998function asciiWrite (buf, string, offset, length) {
999  return blitBuffer(asciiToBytes(string), buf, offset, length)
1000}
1001
1002function latin1Write (buf, string, offset, length) {
1003  return asciiWrite(buf, string, offset, length)
1004}
1005
1006function base64Write (buf, string, offset, length) {
1007  return blitBuffer(base64ToBytes(string), buf, offset, length)
1008}
1009
1010function ucs2Write (buf, string, offset, length) {
1011  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
1012}
1013
1014Buffer.prototype.write = function write (string, offset, length, encoding) {
1015  // Buffer#write(string)
1016  if (offset === undefined) {
1017    encoding = 'utf8'
1018    length = this.length
1019    offset = 0
1020  // Buffer#write(string, encoding)
1021  } else if (length === undefined && typeof offset === 'string') {
1022    encoding = offset
1023    length = this.length
1024    offset = 0
1025  // Buffer#write(string, offset[, length][, encoding])
1026  } else if (isFinite(offset)) {
1027    offset = offset | 0
1028    if (isFinite(length)) {
1029      length = length | 0
1030      if (encoding === undefined) encoding = 'utf8'
1031    } else {
1032      encoding = length
1033      length = undefined
1034    }
1035  // legacy write(string, encoding, offset, length) - remove in v0.13
1036  } else {
1037    throw new Error(
1038      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
1039    )
1040  }
1041
1042  var remaining = this.length - offset
1043  if (length === undefined || length > remaining) length = remaining
1044
1045  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
1046    throw new RangeError('Attempt to write outside buffer bounds')
1047  }
1048
1049  if (!encoding) encoding = 'utf8'
1050
1051  var loweredCase = false
1052  for (;;) {
1053    switch (encoding) {
1054      case 'hex':
1055        return hexWrite(this, string, offset, length)
1056
1057      case 'utf8':
1058      case 'utf-8':
1059        return utf8Write(this, string, offset, length)
1060
1061      case 'ascii':
1062        return asciiWrite(this, string, offset, length)
1063
1064      case 'latin1':
1065      case 'binary':
1066        return latin1Write(this, string, offset, length)
1067
1068      case 'base64':
1069        // Warning: maxLength not taken into account in base64Write
1070        return base64Write(this, string, offset, length)
1071
1072      case 'ucs2':
1073      case 'ucs-2':
1074      case 'utf16le':
1075      case 'utf-16le':
1076        return ucs2Write(this, string, offset, length)
1077
1078      default:
1079        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
1080        encoding = ('' + encoding).toLowerCase()
1081        loweredCase = true
1082    }
1083  }
1084}
1085
1086Buffer.prototype.toJSON = function toJSON () {
1087  return {
1088    type: 'Buffer',
1089    data: Array.prototype.slice.call(this._arr || this, 0)
1090  }
1091}
1092
1093function base64Slice (buf, start, end) {
1094  if (start === 0 && end === buf.length) {
1095    return base64.fromByteArray(buf)
1096  } else {
1097    return base64.fromByteArray(buf.slice(start, end))
1098  }
1099}
1100
1101function utf8Slice (buf, start, end) {
1102  end = Math.min(buf.length, end)
1103  var res = []
1104
1105  var i = start
1106  while (i < end) {
1107    var firstByte = buf[i]
1108    var codePoint = null
1109    var bytesPerSequence = (firstByte > 0xEF) ? 4
1110      : (firstByte > 0xDF) ? 3
1111      : (firstByte > 0xBF) ? 2
1112      : 1
1113
1114    if (i + bytesPerSequence <= end) {
1115      var secondByte, thirdByte, fourthByte, tempCodePoint
1116
1117      switch (bytesPerSequence) {
1118        case 1:
1119          if (firstByte < 0x80) {
1120            codePoint = firstByte
1121          }
1122          break
1123        case 2:
1124          secondByte = buf[i + 1]
1125          if ((secondByte & 0xC0) === 0x80) {
1126            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
1127            if (tempCodePoint > 0x7F) {
1128              codePoint = tempCodePoint
1129            }
1130          }
1131          break
1132        case 3:
1133          secondByte = buf[i + 1]
1134          thirdByte = buf[i + 2]
1135          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
1136            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
1137            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
1138              codePoint = tempCodePoint
1139            }
1140          }
1141          break
1142        case 4:
1143          secondByte = buf[i + 1]
1144          thirdByte = buf[i + 2]
1145          fourthByte = buf[i + 3]
1146          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
1147            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
1148            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
1149              codePoint = tempCodePoint
1150            }
1151          }
1152      }
1153    }
1154
1155    if (codePoint === null) {
1156      // we did not generate a valid codePoint so insert a
1157      // replacement char (U+FFFD) and advance only 1 byte
1158      codePoint = 0xFFFD
1159      bytesPerSequence = 1
1160    } else if (codePoint > 0xFFFF) {
1161      // encode to utf16 (surrogate pair dance)
1162      codePoint -= 0x10000
1163      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
1164      codePoint = 0xDC00 | codePoint & 0x3FF
1165    }
1166
1167    res.push(codePoint)
1168    i += bytesPerSequence
1169  }
1170
1171  return decodeCodePointsArray(res)
1172}
1173
1174// Based on http://stackoverflow.com/a/22747272/680742, the browser with
1175// the lowest limit is Chrome, with 0x10000 args.
1176// We go 1 magnitude less, for safety
1177var MAX_ARGUMENTS_LENGTH = 0x1000
1178
1179function decodeCodePointsArray (codePoints) {
1180  var len = codePoints.length
1181  if (len <= MAX_ARGUMENTS_LENGTH) {
1182    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
1183  }
1184
1185  // Decode in chunks to avoid "call stack size exceeded".
1186  var res = ''
1187  var i = 0
1188  while (i < len) {
1189    res += String.fromCharCode.apply(
1190      String,
1191      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
1192    )
1193  }
1194  return res
1195}
1196
1197function asciiSlice (buf, start, end) {
1198  var ret = ''
1199  end = Math.min(buf.length, end)
1200
1201  for (var i = start; i < end; ++i) {
1202    ret += String.fromCharCode(buf[i] & 0x7F)
1203  }
1204  return ret
1205}
1206
1207function latin1Slice (buf, start, end) {
1208  var ret = ''
1209  end = Math.min(buf.length, end)
1210
1211  for (var i = start; i < end; ++i) {
1212    ret += String.fromCharCode(buf[i])
1213  }
1214  return ret
1215}
1216
1217function hexSlice (buf, start, end) {
1218  var len = buf.length
1219
1220  if (!start || start < 0) start = 0
1221  if (!end || end < 0 || end > len) end = len
1222
1223  var out = ''
1224  for (var i = start; i < end; ++i) {
1225    out += toHex(buf[i])
1226  }
1227  return out
1228}
1229
1230function utf16leSlice (buf, start, end) {
1231  var bytes = buf.slice(start, end)
1232  var res = ''
1233  for (var i = 0; i < bytes.length; i += 2) {
1234    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
1235  }
1236  return res
1237}
1238
1239Buffer.prototype.slice = function slice (start, end) {
1240  var len = this.length
1241  start = ~~start
1242  end = end === undefined ? len : ~~end
1243
1244  if (start < 0) {
1245    start += len
1246    if (start < 0) start = 0
1247  } else if (start > len) {
1248    start = len
1249  }
1250
1251  if (end < 0) {
1252    end += len
1253    if (end < 0) end = 0
1254  } else if (end > len) {
1255    end = len
1256  }
1257
1258  if (end < start) end = start
1259
1260  var newBuf
1261  if (Buffer.TYPED_ARRAY_SUPPORT) {
1262    newBuf = this.subarray(start, end)
1263    newBuf.__proto__ = Buffer.prototype
1264  } else {
1265    var sliceLen = end - start
1266    newBuf = new Buffer(sliceLen, undefined)
1267    for (var i = 0; i < sliceLen; ++i) {
1268      newBuf[i] = this[i + start]
1269    }
1270  }
1271
1272  return newBuf
1273}
1274
1275/*
1276 * Need to make sure that buffer isn't trying to write out of bounds.
1277 */
1278function checkOffset (offset, ext, length) {
1279  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
1280  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
1281}
1282
1283Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
1284  offset = offset | 0
1285  byteLength = byteLength | 0
1286  if (!noAssert) checkOffset(offset, byteLength, this.length)
1287
1288  var val = this[offset]
1289  var mul = 1
1290  var i = 0
1291  while (++i < byteLength && (mul *= 0x100)) {
1292    val += this[offset + i] * mul
1293  }
1294
1295  return val
1296}
1297
1298Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
1299  offset = offset | 0
1300  byteLength = byteLength | 0
1301  if (!noAssert) {
1302    checkOffset(offset, byteLength, this.length)
1303  }
1304
1305  var val = this[offset + --byteLength]
1306  var mul = 1
1307  while (byteLength > 0 && (mul *= 0x100)) {
1308    val += this[offset + --byteLength] * mul
1309  }
1310
1311  return val
1312}
1313
1314Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
1315  if (!noAssert) checkOffset(offset, 1, this.length)
1316  return this[offset]
1317}
1318
1319Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
1320  if (!noAssert) checkOffset(offset, 2, this.length)
1321  return this[offset] | (this[offset + 1] << 8)
1322}
1323
1324Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
1325  if (!noAssert) checkOffset(offset, 2, this.length)
1326  return (this[offset] << 8) | this[offset + 1]
1327}
1328
1329Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
1330  if (!noAssert) checkOffset(offset, 4, this.length)
1331
1332  return ((this[offset]) |
1333      (this[offset + 1] << 8) |
1334      (this[offset + 2] << 16)) +
1335      (this[offset + 3] * 0x1000000)
1336}
1337
1338Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
1339  if (!noAssert) checkOffset(offset, 4, this.length)
1340
1341  return (this[offset] * 0x1000000) +
1342    ((this[offset + 1] << 16) |
1343    (this[offset + 2] << 8) |
1344    this[offset + 3])
1345}
1346
1347Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
1348  offset = offset | 0
1349  byteLength = byteLength | 0
1350  if (!noAssert) checkOffset(offset, byteLength, this.length)
1351
1352  var val = this[offset]
1353  var mul = 1
1354  var i = 0
1355  while (++i < byteLength && (mul *= 0x100)) {
1356    val += this[offset + i] * mul
1357  }
1358  mul *= 0x80
1359
1360  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1361
1362  return val
1363}
1364
1365Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
1366  offset = offset | 0
1367  byteLength = byteLength | 0
1368  if (!noAssert) checkOffset(offset, byteLength, this.length)
1369
1370  var i = byteLength
1371  var mul = 1
1372  var val = this[offset + --i]
1373  while (i > 0 && (mul *= 0x100)) {
1374    val += this[offset + --i] * mul
1375  }
1376  mul *= 0x80
1377
1378  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1379
1380  return val
1381}
1382
1383Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
1384  if (!noAssert) checkOffset(offset, 1, this.length)
1385  if (!(this[offset] & 0x80)) return (this[offset])
1386  return ((0xff - this[offset] + 1) * -1)
1387}
1388
1389Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
1390  if (!noAssert) checkOffset(offset, 2, this.length)
1391  var val = this[offset] | (this[offset + 1] << 8)
1392  return (val & 0x8000) ? val | 0xFFFF0000 : val
1393}
1394
1395Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
1396  if (!noAssert) checkOffset(offset, 2, this.length)
1397  var val = this[offset + 1] | (this[offset] << 8)
1398  return (val & 0x8000) ? val | 0xFFFF0000 : val
1399}
1400
1401Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
1402  if (!noAssert) checkOffset(offset, 4, this.length)
1403
1404  return (this[offset]) |
1405    (this[offset + 1] << 8) |
1406    (this[offset + 2] << 16) |
1407    (this[offset + 3] << 24)
1408}
1409
1410Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
1411  if (!noAssert) checkOffset(offset, 4, this.length)
1412
1413  return (this[offset] << 24) |
1414    (this[offset + 1] << 16) |
1415    (this[offset + 2] << 8) |
1416    (this[offset + 3])
1417}
1418
1419Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
1420  if (!noAssert) checkOffset(offset, 4, this.length)
1421  return ieee754.read(this, offset, true, 23, 4)
1422}
1423
1424Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
1425  if (!noAssert) checkOffset(offset, 4, this.length)
1426  return ieee754.read(this, offset, false, 23, 4)
1427}
1428
1429Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
1430  if (!noAssert) checkOffset(offset, 8, this.length)
1431  return ieee754.read(this, offset, true, 52, 8)
1432}
1433
1434Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
1435  if (!noAssert) checkOffset(offset, 8, this.length)
1436  return ieee754.read(this, offset, false, 52, 8)
1437}
1438
1439function checkInt (buf, value, offset, ext, max, min) {
1440  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
1441  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
1442  if (offset + ext > buf.length) throw new RangeError('Index out of range')
1443}
1444
1445Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
1446  value = +value
1447  offset = offset | 0
1448  byteLength = byteLength | 0
1449  if (!noAssert) {
1450    var maxBytes = Math.pow(2, 8 * byteLength) - 1
1451    checkInt(this, value, offset, byteLength, maxBytes, 0)
1452  }
1453
1454  var mul = 1
1455  var i = 0
1456  this[offset] = value & 0xFF
1457  while (++i < byteLength && (mul *= 0x100)) {
1458    this[offset + i] = (value / mul) & 0xFF
1459  }
1460
1461  return offset + byteLength
1462}
1463
1464Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
1465  value = +value
1466  offset = offset | 0
1467  byteLength = byteLength | 0
1468  if (!noAssert) {
1469    var maxBytes = Math.pow(2, 8 * byteLength) - 1
1470    checkInt(this, value, offset, byteLength, maxBytes, 0)
1471  }
1472
1473  var i = byteLength - 1
1474  var mul = 1
1475  this[offset + i] = value & 0xFF
1476  while (--i >= 0 && (mul *= 0x100)) {
1477    this[offset + i] = (value / mul) & 0xFF
1478  }
1479
1480  return offset + byteLength
1481}
1482
1483Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
1484  value = +value
1485  offset = offset | 0
1486  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
1487  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
1488  this[offset] = (value & 0xff)
1489  return offset + 1
1490}
1491
1492function objectWriteUInt16 (buf, value, offset, littleEndian) {
1493  if (value < 0) value = 0xffff + value + 1
1494  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
1495    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
1496      (littleEndian ? i : 1 - i) * 8
1497  }
1498}
1499
1500Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
1501  value = +value
1502  offset = offset | 0
1503  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1504  if (Buffer.TYPED_ARRAY_SUPPORT) {
1505    this[offset] = (value & 0xff)
1506    this[offset + 1] = (value >>> 8)
1507  } else {
1508    objectWriteUInt16(this, value, offset, true)
1509  }
1510  return offset + 2
1511}
1512
1513Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
1514  value = +value
1515  offset = offset | 0
1516  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1517  if (Buffer.TYPED_ARRAY_SUPPORT) {
1518    this[offset] = (value >>> 8)
1519    this[offset + 1] = (value & 0xff)
1520  } else {
1521    objectWriteUInt16(this, value, offset, false)
1522  }
1523  return offset + 2
1524}
1525
1526function objectWriteUInt32 (buf, value, offset, littleEndian) {
1527  if (value < 0) value = 0xffffffff + value + 1
1528  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
1529    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
1530  }
1531}
1532
1533Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
1534  value = +value
1535  offset = offset | 0
1536  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1537  if (Buffer.TYPED_ARRAY_SUPPORT) {
1538    this[offset + 3] = (value >>> 24)
1539    this[offset + 2] = (value >>> 16)
1540    this[offset + 1] = (value >>> 8)
1541    this[offset] = (value & 0xff)
1542  } else {
1543    objectWriteUInt32(this, value, offset, true)
1544  }
1545  return offset + 4
1546}
1547
1548Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
1549  value = +value
1550  offset = offset | 0
1551  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1552  if (Buffer.TYPED_ARRAY_SUPPORT) {
1553    this[offset] = (value >>> 24)
1554    this[offset + 1] = (value >>> 16)
1555    this[offset + 2] = (value >>> 8)
1556    this[offset + 3] = (value & 0xff)
1557  } else {
1558    objectWriteUInt32(this, value, offset, false)
1559  }
1560  return offset + 4
1561}
1562
1563Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
1564  value = +value
1565  offset = offset | 0
1566  if (!noAssert) {
1567    var limit = Math.pow(2, 8 * byteLength - 1)
1568
1569    checkInt(this, value, offset, byteLength, limit - 1, -limit)
1570  }
1571
1572  var i = 0
1573  var mul = 1
1574  var sub = 0
1575  this[offset] = value & 0xFF
1576  while (++i < byteLength && (mul *= 0x100)) {
1577    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
1578      sub = 1
1579    }
1580    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1581  }
1582
1583  return offset + byteLength
1584}
1585
1586Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
1587  value = +value
1588  offset = offset | 0
1589  if (!noAssert) {
1590    var limit = Math.pow(2, 8 * byteLength - 1)
1591
1592    checkInt(this, value, offset, byteLength, limit - 1, -limit)
1593  }
1594
1595  var i = byteLength - 1
1596  var mul = 1
1597  var sub = 0
1598  this[offset + i] = value & 0xFF
1599  while (--i >= 0 && (mul *= 0x100)) {
1600    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
1601      sub = 1
1602    }
1603    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1604  }
1605
1606  return offset + byteLength
1607}
1608
1609Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
1610  value = +value
1611  offset = offset | 0
1612  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
1613  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
1614  if (value < 0) value = 0xff + value + 1
1615  this[offset] = (value & 0xff)
1616  return offset + 1
1617}
1618
1619Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
1620  value = +value
1621  offset = offset | 0
1622  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1623  if (Buffer.TYPED_ARRAY_SUPPORT) {
1624    this[offset] = (value & 0xff)
1625    this[offset + 1] = (value >>> 8)
1626  } else {
1627    objectWriteUInt16(this, value, offset, true)
1628  }
1629  return offset + 2
1630}
1631
1632Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
1633  value = +value
1634  offset = offset | 0
1635  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1636  if (Buffer.TYPED_ARRAY_SUPPORT) {
1637    this[offset] = (value >>> 8)
1638    this[offset + 1] = (value & 0xff)
1639  } else {
1640    objectWriteUInt16(this, value, offset, false)
1641  }
1642  return offset + 2
1643}
1644
1645Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
1646  value = +value
1647  offset = offset | 0
1648  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1649  if (Buffer.TYPED_ARRAY_SUPPORT) {
1650    this[offset] = (value & 0xff)
1651    this[offset + 1] = (value >>> 8)
1652    this[offset + 2] = (value >>> 16)
1653    this[offset + 3] = (value >>> 24)
1654  } else {
1655    objectWriteUInt32(this, value, offset, true)
1656  }
1657  return offset + 4
1658}
1659
1660Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
1661  value = +value
1662  offset = offset | 0
1663  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1664  if (value < 0) value = 0xffffffff + value + 1
1665  if (Buffer.TYPED_ARRAY_SUPPORT) {
1666    this[offset] = (value >>> 24)
1667    this[offset + 1] = (value >>> 16)
1668    this[offset + 2] = (value >>> 8)
1669    this[offset + 3] = (value & 0xff)
1670  } else {
1671    objectWriteUInt32(this, value, offset, false)
1672  }
1673  return offset + 4
1674}
1675
1676function checkIEEE754 (buf, value, offset, ext, max, min) {
1677  if (offset + ext > buf.length) throw new RangeError('Index out of range')
1678  if (offset < 0) throw new RangeError('Index out of range')
1679}
1680
1681function writeFloat (buf, value, offset, littleEndian, noAssert) {
1682  if (!noAssert) {
1683    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
1684  }
1685  ieee754.write(buf, value, offset, littleEndian, 23, 4)
1686  return offset + 4
1687}
1688
1689Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
1690  return writeFloat(this, value, offset, true, noAssert)
1691}
1692
1693Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
1694  return writeFloat(this, value, offset, false, noAssert)
1695}
1696
1697function writeDouble (buf, value, offset, littleEndian, noAssert) {
1698  if (!noAssert) {
1699    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
1700  }
1701  ieee754.write(buf, value, offset, littleEndian, 52, 8)
1702  return offset + 8
1703}
1704
1705Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
1706  return writeDouble(this, value, offset, true, noAssert)
1707}
1708
1709Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
1710  return writeDouble(this, value, offset, false, noAssert)
1711}
1712
1713// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
1714Buffer.prototype.copy = function copy (target, targetStart, start, end) {
1715  if (!start) start = 0
1716  if (!end && end !== 0) end = this.length
1717  if (targetStart >= target.length) targetStart = target.length
1718  if (!targetStart) targetStart = 0
1719  if (end > 0 && end < start) end = start
1720
1721  // Copy 0 bytes; we're done
1722  if (end === start) return 0
1723  if (target.length === 0 || this.length === 0) return 0
1724
1725  // Fatal error conditions
1726  if (targetStart < 0) {
1727    throw new RangeError('targetStart out of bounds')
1728  }
1729  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
1730  if (end < 0) throw new RangeError('sourceEnd out of bounds')
1731
1732  // Are we oob?
1733  if (end > this.length) end = this.length
1734  if (target.length - targetStart < end - start) {
1735    end = target.length - targetStart + start
1736  }
1737
1738  var len = end - start
1739  var i
1740
1741  if (this === target && start < targetStart && targetStart < end) {
1742    // descending copy from end
1743    for (i = len - 1; i >= 0; --i) {
1744      target[i + targetStart] = this[i + start]
1745    }
1746  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
1747    // ascending copy from start
1748    for (i = 0; i < len; ++i) {
1749      target[i + targetStart] = this[i + start]
1750    }
1751  } else {
1752    Uint8Array.prototype.set.call(
1753      target,
1754      this.subarray(start, start + len),
1755      targetStart
1756    )
1757  }
1758
1759  return len
1760}
1761
1762// Usage:
1763//    buffer.fill(number[, offset[, end]])
1764//    buffer.fill(buffer[, offset[, end]])
1765//    buffer.fill(string[, offset[, end]][, encoding])
1766Buffer.prototype.fill = function fill (val, start, end, encoding) {
1767  // Handle string cases:
1768  if (typeof val === 'string') {
1769    if (typeof start === 'string') {
1770      encoding = start
1771      start = 0
1772      end = this.length
1773    } else if (typeof end === 'string') {
1774      encoding = end
1775      end = this.length
1776    }
1777    if (val.length === 1) {
1778      var code = val.charCodeAt(0)
1779      if (code < 256) {
1780        val = code
1781      }
1782    }
1783    if (encoding !== undefined && typeof encoding !== 'string') {
1784      throw new TypeError('encoding must be a string')
1785    }
1786    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
1787      throw new TypeError('Unknown encoding: ' + encoding)
1788    }
1789  } else if (typeof val === 'number') {
1790    val = val & 255
1791  }
1792
1793  // Invalid ranges are not set to a default, so can range check early.
1794  if (start < 0 || this.length < start || this.length < end) {
1795    throw new RangeError('Out of range index')
1796  }
1797
1798  if (end <= start) {
1799    return this
1800  }
1801
1802  start = start >>> 0
1803  end = end === undefined ? this.length : end >>> 0
1804
1805  if (!val) val = 0
1806
1807  var i
1808  if (typeof val === 'number') {
1809    for (i = start; i < end; ++i) {
1810      this[i] = val
1811    }
1812  } else {
1813    var bytes = Buffer.isBuffer(val)
1814      ? val
1815      : utf8ToBytes(new Buffer(val, encoding).toString())
1816    var len = bytes.length
1817    for (i = 0; i < end - start; ++i) {
1818      this[i + start] = bytes[i % len]
1819    }
1820  }
1821
1822  return this
1823}
1824
1825// HELPER FUNCTIONS
1826// ================
1827
1828var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
1829
1830function base64clean (str) {
1831  // Node strips out invalid characters like \n and \t from the string, base64-js does not
1832  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
1833  // Node converts strings with length < 2 to ''
1834  if (str.length < 2) return ''
1835  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
1836  while (str.length % 4 !== 0) {
1837    str = str + '='
1838  }
1839  return str
1840}
1841
1842function stringtrim (str) {
1843  if (str.trim) return str.trim()
1844  return str.replace(/^\s+|\s+$/g, '')
1845}
1846
1847function toHex (n) {
1848  if (n < 16) return '0' + n.toString(16)
1849  return n.toString(16)
1850}
1851
1852function utf8ToBytes (string, units) {
1853  units = units || Infinity
1854  var codePoint
1855  var length = string.length
1856  var leadSurrogate = null
1857  var bytes = []
1858
1859  for (var i = 0; i < length; ++i) {
1860    codePoint = string.charCodeAt(i)
1861
1862    // is surrogate component
1863    if (codePoint > 0xD7FF && codePoint < 0xE000) {
1864      // last char was a lead
1865      if (!leadSurrogate) {
1866        // no lead yet
1867        if (codePoint > 0xDBFF) {
1868          // unexpected trail
1869          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1870          continue
1871        } else if (i + 1 === length) {
1872          // unpaired lead
1873          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1874          continue
1875        }
1876
1877        // valid lead
1878        leadSurrogate = codePoint
1879
1880        continue
1881      }
1882
1883      // 2 leads in a row
1884      if (codePoint < 0xDC00) {
1885        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1886        leadSurrogate = codePoint
1887        continue
1888      }
1889
1890      // valid surrogate pair
1891      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
1892    } else if (leadSurrogate) {
1893      // valid bmp char, but last char was a lead
1894      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1895    }
1896
1897    leadSurrogate = null
1898
1899    // encode utf8
1900    if (codePoint < 0x80) {
1901      if ((units -= 1) < 0) break
1902      bytes.push(codePoint)
1903    } else if (codePoint < 0x800) {
1904      if ((units -= 2) < 0) break
1905      bytes.push(
1906        codePoint >> 0x6 | 0xC0,
1907        codePoint & 0x3F | 0x80
1908      )
1909    } else if (codePoint < 0x10000) {
1910      if ((units -= 3) < 0) break
1911      bytes.push(
1912        codePoint >> 0xC | 0xE0,
1913        codePoint >> 0x6 & 0x3F | 0x80,
1914        codePoint & 0x3F | 0x80
1915      )
1916    } else if (codePoint < 0x110000) {
1917      if ((units -= 4) < 0) break
1918      bytes.push(
1919        codePoint >> 0x12 | 0xF0,
1920        codePoint >> 0xC & 0x3F | 0x80,
1921        codePoint >> 0x6 & 0x3F | 0x80,
1922        codePoint & 0x3F | 0x80
1923      )
1924    } else {
1925      throw new Error('Invalid code point')
1926    }
1927  }
1928
1929  return bytes
1930}
1931
1932function asciiToBytes (str) {
1933  var byteArray = []
1934  for (var i = 0; i < str.length; ++i) {
1935    // Node's code seems to be doing this and not & 0x7F..
1936    byteArray.push(str.charCodeAt(i) & 0xFF)
1937  }
1938  return byteArray
1939}
1940
1941function utf16leToBytes (str, units) {
1942  var c, hi, lo
1943  var byteArray = []
1944  for (var i = 0; i < str.length; ++i) {
1945    if ((units -= 2) < 0) break
1946
1947    c = str.charCodeAt(i)
1948    hi = c >> 8
1949    lo = c % 256
1950    byteArray.push(lo)
1951    byteArray.push(hi)
1952  }
1953
1954  return byteArray
1955}
1956
1957function base64ToBytes (str) {
1958  return base64.toByteArray(base64clean(str))
1959}
1960
1961function blitBuffer (src, dst, offset, length) {
1962  for (var i = 0; i < length; ++i) {
1963    if ((i + offset >= dst.length) || (i >= src.length)) break
1964    dst[i + offset] = src[i]
1965  }
1966  return i
1967}
1968
1969function isnan (val) {
1970  return val !== val // eslint-disable-line no-self-compare
1971}
1972

1973/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(7)))
1974
1975/***/ }),
1976/* 2 */
1977/***/ (function(module, exports) {
1978
1979var core = module.exports = { version: '2.5.3' };
1980if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
1981
1982
1983/***/ }),
1984/* 3 */
1985/***/ (function(module, exports, __webpack_require__) {
1986
1987var global = __webpack_require__(10);
1988var core = __webpack_require__(2);
1989var ctx = __webpack_require__(20);
1990var hide = __webpack_require__(13);
1991var PROTOTYPE = 'prototype';
1992
1993var $export = function (type, name, source) {
1994  var IS_FORCED = type & $export.F;
1995  var IS_GLOBAL = type & $export.G;
1996  var IS_STATIC = type & $export.S;
1997  var IS_PROTO = type & $export.P;
1998  var IS_BIND = type & $export.B;
1999  var IS_WRAP = type & $export.W;
2000  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
2001  var expProto = exports[PROTOTYPE];
2002  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];
2003  var key, own, out;
2004  if (IS_GLOBAL) source = name;
2005  for (key in source) {
2006    // contains in native
2007    own = !IS_FORCED && target && target[key] !== undefined;
2008    if (own && key in exports) continue;
2009    // export native or passed
2010    out = own ? target[key] : source[key];
2011    // prevent global pollution for namespaces
2012    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
2013    // bind timers to global for call from export context
2014    : IS_BIND && own ? ctx(out, global)
2015    // wrap global constructors for prevent change them in library
2016    : IS_WRAP && target[key] == out ? (function (C) {
2017      var F = function (a, b, c) {
2018        if (this instanceof C) {
2019          switch (arguments.length) {
2020            case 0: return new C();
2021            case 1: return new C(a);
2022            case 2: return new C(a, b);
2023          } return new C(a, b, c);
2024        } return C.apply(this, arguments);
2025      };
2026      F[PROTOTYPE] = C[PROTOTYPE];
2027      return F;
2028    // make static versions for prototype methods
2029    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
2030    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
2031    if (IS_PROTO) {
2032      (exports.virtual || (exports.virtual = {}))[key] = out;
2033      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
2034      if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);
2035    }
2036  }
2037};
2038// type bitmap
2039$export.F = 1;   // forced
2040$export.G = 2;   // global
2041$export.S = 4;   // static
2042$export.P = 8;   // proto
2043$export.B = 16;  // bind
2044$export.W = 32;  // wrap
2045$export.U = 64;  // safe
2046$export.R = 128; // real proto method for `library`
2047module.exports = $export;
2048
2049
2050/***/ }),
2051/* 4 */
2052/***/ (function(module, exports, __webpack_require__) {
2053
2054var store = __webpack_require__(65)('wks');
2055var uid = __webpack_require__(38);
2056var Symbol = __webpack_require__(10).Symbol;
2057var USE_SYMBOL = typeof Symbol == 'function';
2058

2059var $exports = module.exports = function (name) {
2060  return store[name] || (store[name] =
2061    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
2062};
2063
2064$exports.store = store;
2065
2066
2067/***/ }),
2068/* 5 */
2069/***/ (function(module, exports, __webpack_require__) {
2070
2071// Thank's IE8 for his funny defineProperty
2072module.exports = !__webpack_require__(19)(function () {
2073  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
2074});
2075
2076
2077/***/ }),
2078/* 6 */
2079/***/ (function(module, exports, __webpack_require__) {
2080
2081var anObject = __webpack_require__(14);
2082var IE8_DOM_DEFINE = __webpack_require__(95);
2083var toPrimitive = __webpack_require__(58);
2084var dP = Object.defineProperty;
2085
2086exports.f = __webpack_require__(5) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
2087  anObject(O);
2088  P = toPrimitive(P, true);
2089  anObject(Attributes);
2090  if (IE8_DOM_DEFINE) try {
2091    return dP(O, P, Attributes);
2092  } catch (e) { /* empty */ }
2093  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
2094  if ('value' in Attributes) O[P] = Attributes.value;
2095  return O;
2096};
2097
2098
2099/***/ }),
2100/* 7 */
2101/***/ (function(module, exports) {
2102
2103var g;
2104
2105// This works in non-strict mode
2106g = (function() {
2107	return this;
2108})();
2109
2110try {
2111	// This works if eval is allowed (see CSP)
2112	g = g || Function("return this")() || (1,eval)("this");
2113} catch(e) {
2114	// This works if the window reference is available
2115	if(typeof window === "object")
2116		g = window;
2117}
2118
2119// g can still be undefined, but nothing to do about it...
2120// We return undefined, instead of nothing here, so it's
2121// easier to handle this case. if(!global) { ...}
2122
2123module.exports = g;
2124
2125
2126/***/ }),
2127/* 8 */
2128/***/ (function(module, exports, __webpack_require__) {
2129
2130"use strict";
2131/* WEBPACK VAR INJECTION */(function(Buffer, __dirname) {
2132
2133function VirtualFileSystem() {
2134	this.fileSystem = {};
2135	this.baseSystem = {};
2136}
2137
2138VirtualFileSystem.prototype.readFileSync = function (filename) {
2139	filename = fixFilename(filename);
2140
2141	var base64content = this.baseSystem[filename];
2142	if (base64content) {
2143		return new Buffer(base64content, 'base64');
2144	}
2145
2146	var content = this.fileSystem[filename];
2147	if (content) {
2148		return content;
2149	}
2150
2151	throw 'File \'' + filename + '\' not found in virtual file system';
2152};
2153
2154VirtualFileSystem.prototype.writeFileSync = function (filename, content) {
2155	this.fileSystem[fixFilename(filename)] = content;
2156};
2157
2158VirtualFileSystem.prototype.bindFS = function (data) {
2159	this.baseSystem = data || {};
2160};
2161
2162
2163function fixFilename(filename) {
2164	if (filename.indexOf(__dirname) === 0) {
2165		filename = filename.substring(__dirname.length);
2166	}
2167
2168	if (filename.indexOf('/') === 0) {
2169		filename = filename.substring(1);
2170	}
2171
2172	return filename;
2173}
2174
2175module.exports = new VirtualFileSystem();
2176
2177/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1).Buffer, "/"))
2178
2179/***/ }),
2180/* 9 */
2181/***/ (function(module, exports) {
2182
2183module.exports = function (it) {
2184  return typeof it === 'object' ? it !== null : typeof it === 'function';
2185};
2186
2187
2188/***/ }),
2189/* 10 */
2190/***/ (function(module, exports) {
2191
2192// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
2193var global = module.exports = typeof window != 'undefined' && window.Math == Math
2194  ? window : typeof self != 'undefined' && self.Math == Math ? self
2195  // eslint-disable-next-line no-new-func
2196  : Function('return this')();
2197if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
2198
2199
2200/***/ }),
2201/* 11 */
2202/***/ (function(module, exports) {
2203
2204// shim for using process in browser
2205var process = module.exports = {};
2206
2207// cached from whatever global is present so that test runners that stub it
2208// don't break things.  But we need to wrap it in a try catch in case it is
2209// wrapped in strict mode code which doesn't define any globals.  It's inside a
2210// function because try/catches deoptimize in certain engines.
2211
2212var cachedSetTimeout;
2213var cachedClearTimeout;
2214
2215function defaultSetTimout() {
2216    throw new Error('setTimeout has not been defined');
2217}
2218function defaultClearTimeout () {
2219    throw new Error('clearTimeout has not been defined');
2220}
2221(function () {
2222    try {
2223        if (typeof setTimeout === 'function') {
2224            cachedSetTimeout = setTimeout;
2225        } else {
2226            cachedSetTimeout = defaultSetTimout;
2227        }
2228    } catch (e) {
2229        cachedSetTimeout = defaultSetTimout;
2230    }
2231    try {
2232        if (typeof clearTimeout === 'function') {
2233            cachedClearTimeout = clearTimeout;
2234        } else {
2235            cachedClearTimeout = defaultClearTimeout;
2236        }
2237    } catch (e) {
2238        cachedClearTimeout = defaultClearTimeout;
2239    }
2240} ())
2241function runTimeout(fun) {
2242    if (cachedSetTimeout === setTimeout) {
2243        //normal enviroments in sane situations
2244        return setTimeout(fun, 0);
2245    }
2246    // if setTimeout wasn't available but was latter defined
2247    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
2248        cachedSetTimeout = setTimeout;
2249        return setTimeout(fun, 0);
2250    }
2251    try {
2252        // when when somebody has screwed with setTimeout but no I.E. maddness
2253        return cachedSetTimeout(fun, 0);
2254    } catch(e){
2255        try {
2256            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
2257            return cachedSetTimeout.call(null, fun, 0);
2258        } catch(e){
2259            // 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
2260            return cachedSetTimeout.call(this, fun, 0);
2261        }
2262    }
2263
2264
2265}
2266function runClearTimeout(marker) {
2267    if (cachedClearTimeout === clearTimeout) {
2268        //normal enviroments in sane situations
2269        return clearTimeout(marker);
2270    }
2271    // if clearTimeout wasn't available but was latter defined
2272    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
2273        cachedClearTimeout = clearTimeout;
2274        return clearTimeout(marker);
2275    }
2276    try {
2277        // when when somebody has screwed with setTimeout but no I.E. maddness
2278        return cachedClearTimeout(marker);
2279    } catch (e){
2280        try {
2281            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
2282            return cachedClearTimeout.call(null, marker);
2283        } catch (e){
2284            // 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.
2285            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
2286            return cachedClearTimeout.call(this, marker);
2287        }
2288    }
2289
2290
2291
2292}
2293var queue = [];
2294var draining = false;

2295var currentQueue;
2296var queueIndex = -1;
2297
2298function cleanUpNextTick() {
2299    if (!draining || !currentQueue) {
2300        return;
2301    }
2302    draining = false;
2303    if (currentQueue.length) {
2304        queue = currentQueue.concat(queue);
2305    } else {
2306        queueIndex = -1;
2307    }
2308    if (queue.length) {
2309        drainQueue();
2310    }
2311}
2312
2313function drainQueue() {
2314    if (draining) {
2315        return;
2316    }
2317    var timeout = runTimeout(cleanUpNextTick);
2318    draining = true;
2319
2320    var len = queue.length;
2321    while(len) {
2322        currentQueue = queue;
2323        queue = [];
2324        while (++queueIndex < len) {
2325            if (currentQueue) {
2326                currentQueue[queueIndex].run();
2327            }
2328        }
2329        queueIndex = -1;
2330        len = queue.length;
2331    }
2332    currentQueue = null;
2333    draining = false;
2334    runClearTimeout(timeout);
2335}
2336
2337process.nextTick = function (fun) {
2338    var args = new Array(arguments.length - 1);
2339    if (arguments.length > 1) {
2340        for (var i = 1; i < arguments.length; i++) {
2341            args[i - 1] = arguments[i];
2342        }
2343    }
2344    queue.push(new Item(fun, args));
2345    if (queue.length === 1 && !draining) {
2346        runTimeout(drainQueue);
2347    }
2348};
2349
2350// v8 likes predictible objects
2351function Item(fun, array) {
2352    this.fun = fun;
2353    this.array = array;
2354}
2355Item.prototype.run = function () {
2356    this.fun.apply(null, this.array);
2357};
2358process.title = 'browser';
2359process.browser = true;
2360process.env = {};
2361process.argv = [];
2362process.version = ''; // empty string to avoid regexp issues
2363process.versions = {};
2364
2365function noop() {}
2366
2367process.on = noop;
2368process.addListener = noop;
2369process.once = noop;
2370process.off = noop;
2371process.removeListener = noop;
2372process.removeAllListeners = noop;
2373process.emit = noop;
2374process.prependListener = noop;
2375process.prependOnceListener = noop;
2376
2377process.listeners = function (name) { return [] }
2378
2379process.binding = function (name) {
2380    throw new Error('process.binding is not supported');
2381};
2382
2383process.cwd = function () { return '/' };
2384process.chdir = function (dir) {
2385    throw new Error('process.chdir is not supported');
2386};
2387process.umask = function() { return 0; };
2388
2389
2390/***/ }),
2391/* 12 */
2392/***/ (function(module, exports, __webpack_require__) {
2393
2394// Generated by CoffeeScript 1.7.1
2395(function() {
2396  var NumberT, PropertyDescriptor;
2397
2398  NumberT = __webpack_require__(22).Number;
2399
2400  exports.resolveLength = function(length, stream, parent) {
2401    var res;
2402    if (typeof length === 'number') {
2403      res = length;
2404    } else if (typeof length === 'function') {
2405      res = length.call(parent, parent);
2406    } else if (parent && typeof length === 'string') {
2407      res = parent[length];
2408    } else if (stream && length instanceof NumberT) {
2409      res = length.decode(stream);
2410    }
2411    if (isNaN(res)) {
2412      throw new Error('Not a fixed size');
2413    }
2414    return res;
2415  };
2416
2417  PropertyDescriptor = (function() {
2418    function PropertyDescriptor(opts) {
2419      var key, val;
2420      if (opts == null) {
2421        opts = {};
2422      }
2423      this.enumerable = true;
2424      this.configurable = true;
2425      for (key in opts) {
2426        val = opts[key];
2427        this[key] = val;
2428      }
2429    }
2430
2431    return PropertyDescriptor;
2432
2433  })();
2434
2435  exports.PropertyDescriptor = PropertyDescriptor;
2436
2437}).call(this);
2438
2439
2440/***/ }),
2441/* 13 */
2442/***/ (function(module, exports, __webpack_require__) {
2443
2444var dP = __webpack_require__(6);
2445var createDesc = __webpack_require__(27);
2446module.exports = __webpack_require__(5) ? function (object, key, value) {
2447  return dP.f(object, key, createDesc(1, value));
2448} : function (object, key, value) {
2449  object[key] = value;
2450  return object;
2451};
2452
2453
2454/***/ }),
2455/* 14 */
2456/***/ (function(module, exports, __webpack_require__) {
2457
2458var isObject = __webpack_require__(9);
2459module.exports = function (it) {
2460  if (!isObject(it)) throw TypeError(it + ' is not an object!');
2461  return it;
2462};
2463
2464
2465/***/ }),
2466/* 15 */
2467/***/ (function(module, exports, __webpack_require__) {
2468
2469// Copyright Joyent, Inc. and other Node contributors.
2470//
2471// Permission is hereby granted, free of charge, to any person obtaining a
2472// copy of this software and associated documentation files (the
2473// "Software"), to deal in the Software without restriction, including
2474// without limitation the rights to use, copy, modify, merge, publish,
2475// distribute, sublicense, and/or sell copies of the Software, and to permit
2476// persons to whom the Software is furnished to do so, subject to the
2477// following conditions:
2478//
2479// The above copyright notice and this permission notice shall be included
2480// in all copies or substantial portions of the Software.
2481//
2482// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2483// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2484// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2485// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2486// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2487// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2488// USE OR OTHER DEALINGS IN THE SOFTWARE.
2489
2490module.exports = Stream;
2491
2492var EE = __webpack_require__(31).EventEmitter;
2493var inherits = __webpack_require__(21);
2494
2495inherits(Stream, EE);
2496Stream.Readable = __webpack_require__(45);
2497Stream.Writable = __webpack_require__(146);
2498Stream.Duplex = __webpack_require__(147);
2499Stream.Transform = __webpack_require__(148);
2500Stream.PassThrough = __webpack_require__(149);
2501
2502// Backwards-compat with node 0.4.x
2503Stream.Stream = Stream;
2504
2505
2506
2507// old-style streams.  Note that the pipe method (the only relevant
2508// part of this class) is overridden in the Readable class.
2509
2510function Stream() {
2511  EE.call(this);
2512}
2513
2514Stream.prototype.pipe = function(dest, options) {
2515  var source = this;
2516
2517  function ondata(chunk) {
2518    if (dest.writable) {
2519      if (false === dest.write(chunk) && source.pause) {
2520        source.pause();
2521      }
2522    }
2523  }
2524
2525  source.on('data', ondata);
2526
2527  function ondrain() {
2528    if (source.readable && source.resume) {
2529      source.resume();
2530    }
2531  }
2532
2533  dest.on('drain', ondrain);
2534
2535  // If the 'end' option is not supplied, dest.end() will be called when
2536  // source gets the 'end' or 'close' events.  Only dest.end() once.
2537  if (!dest._isStdio && (!options || options.end !== false)) {
2538    source.on('end', onend);
2539    source.on('close', onclose);
2540  }
2541
2542  var didOnEnd = false;
2543  function onend() {
2544    if (didOnEnd) return;
2545    didOnEnd = true;
2546
2547    dest.end();
2548  }
2549
2550
2551  function onclose() {
2552    if (didOnEnd) return;
2553    didOnEnd = true;
2554
2555    if (typeof dest.destroy === 'function') dest.destroy();
2556  }
2557
2558  // don't leave dangling pipes when there are errors.
2559  function onerror(er) {
2560    cleanup();
2561    if (EE.listenerCount(this, 'error') === 0) {
2562      throw er; // Unhandled stream error in pipe.
2563    }
2564  }
2565
2566  source.on('error', onerror);
2567  dest.on('error', onerror);
2568
2569  // remove all the event listeners that were added.
2570  function cleanup() {
2571    source.removeListener('data', ondata);
2572    dest.removeListener('drain', ondrain);
2573
2574    source.removeListener('end', onend);
2575    source.removeListener('close', onclose);
2576
2577    source.removeListener('error', onerror);
2578    dest.removeListener('error', onerror);
2579
2580    source.removeListener('end', cleanup);
2581    source.removeListener('close', cleanup);
2582
2583    dest.removeListener('close', cleanup);
2584  }
2585
2586  source.on('end', cleanup);
2587  source.on('close', cleanup);
2588
2589  dest.on('close', cleanup);
2590
2591  dest.emit('pipe', source);
2592
2593  // Allow for unix-like usage: A.pipe(B).pipe(C)
2594  return dest;
2595};
2596
2597
2598/***/ }),
2599/* 16 */
2600/***/ (function(module, exports, __webpack_require__) {
2601
2602"use strict";

2603// Copyright Joyent, Inc. and other Node contributors.
2604//
2605// Permission is hereby granted, free of charge, to any person obtaining a
2606// copy of this software and associated documentation files (the
2607// "Software"), to deal in the Software without restriction, including
2608// without limitation the rights to use, copy, modify, merge, publish,
2609// distribute, sublicense, and/or sell copies of the Software, and to permit
2610// persons to whom the Software is furnished to do so, subject to the
2611// following conditions:
2612//
2613// The above copyright notice and this permission notice shall be included
2614// in all copies or substantial portions of the Software.
2615//
2616// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2617// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2618// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2619// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2620// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2621// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2622// USE OR OTHER DEALINGS IN THE SOFTWARE.
2623
2624// a duplex stream is just a stream that is both readable and writable.
2625// Since JS doesn't have multiple prototypal inheritance, this class
2626// prototypally inherits from Readable, and then parasitically from
2627// Writable.
2628
2629
2630
2631/*<replacement>*/
2632
2633var processNextTick = __webpack_require__(32).nextTick;
2634/*</replacement>*/
2635
2636/*<replacement>*/
2637var objectKeys = Object.keys || function (obj) {
2638  var keys = [];
2639  for (var key in obj) {
2640    keys.push(key);
2641  }return keys;
2642};
2643/*</replacement>*/
2644
2645module.exports = Duplex;
2646
2647/*<replacement>*/
2648var util = __webpack_require__(25);
2649util.inherits = __webpack_require__(21);
2650/*</replacement>*/
2651
2652var Readable = __webpack_require__(83);
2653var Writable = __webpack_require__(46);
2654
2655util.inherits(Duplex, Readable);
2656
2657var keys = objectKeys(Writable.prototype);
2658for (var v = 0; v < keys.length; v++) {
2659  var method = keys[v];
2660  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
2661}
2662
2663function Duplex(options) {
2664  if (!(this instanceof Duplex)) return new Duplex(options);
2665
2666  Readable.call(this, options);
2667  Writable.call(this, options);
2668
2669  if (options && options.readable === false) this.readable = false;
2670
2671  if (options && options.writable === false) this.writable = false;
2672
2673  this.allowHalfOpen = true;
2674  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
2675
2676  this.once('end', onend);
2677}
2678
2679// the no-half-open enforcer
2680function onend() {
2681  // if we allow half-open state, or if the writable side ended,
2682  // then we're ok.
2683  if (this.allowHalfOpen || this._writableState.ended) return;
2684
2685  // no more data can be written.
2686  // But allow more writes to happen in this tick.
2687  processNextTick(onEndNT, this);
2688}
2689
2690function onEndNT(self) {
2691  self.end();
2692}
2693
2694Object.defineProperty(Duplex.prototype, 'destroyed', {
2695  get: function () {
2696    if (this._readableState === undefined || this._writableState === undefined) {
2697      return false;
2698    }
2699    return this._readableState.destroyed && this._writableState.destroyed;
2700  },
2701  set: function (value) {
2702    // we ignore the value if the stream
2703    // has not been initialized yet
2704    if (this._readableState === undefined || this._writableState === undefined) {
2705      return;
2706    }
2707
2708    // backward compatibility, the user is explicitly
2709    // managing destroyed
2710    this._readableState.destroyed = value;
2711    this._writableState.destroyed = value;
2712  }
2713});
2714
2715Duplex.prototype._destroy = function (err, cb) {
2716  this.push(null);
2717  this.end();
2718
2719  processNextTick(cb, err);
2720};
2721
2722function forEach(xs, f) {
2723  for (var i = 0, l = xs.length; i < l; i++) {
2724    f(xs[i], i);
2725  }
2726}
2727
2728/***/ }),
2729/* 17 */
2730/***/ (function(module, exports, __webpack_require__) {
2731
2732// to indexed object, toObject with fallback for non-array-like ES3 strings
2733var IObject = __webpack_require__(54);
2734var defined = __webpack_require__(56);
2735module.exports = function (it) {
2736  return IObject(defined(it));
2737};
2738
2739
2740/***/ }),
2741/* 18 */
2742/***/ (function(module, exports) {
2743
2744var hasOwnProperty = {}.hasOwnProperty;
2745module.exports = function (it, key) {
2746  return hasOwnProperty.call(it, key);
2747};
2748
2749
2750/***/ }),
2751/* 19 */