(function(f){if(typeof exports==="object"&&typeof module!

=="undefined")
{module.exports=f()}else if(typeof define==="function"&&define.amd)
{define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof
global!=="undefined"){g=global}else if(typeof self!=="undefined")
{g=self}else{g=this}g.bitcoin = f()}})(function(){var define,module,exports;return
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof
require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new
Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var
l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?
n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof
require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:
[function(require,module,exports){
// base-x encoding
// Forked from https://github.com/cryptocoinjs/bs58
// Originally written by Mike Hearn for BitcoinJ
// Copyright (c) 2011 Google Inc
// Ported to JavaScript by Stefan Thomas
// Merged Buffer refactorings from base58-native by Stephen Pair
// Copyright (c) 2013 BitPay Inc

var Buffer = require('safe-buffer').Buffer

module.exports = function base (ALPHABET) {

var ALPHABET_MAP = {}
var BASE = ALPHABET.length
var LEADER = ALPHABET.charAt(0)

// pre-compute lookup table

for (var z = 0; z < ALPHABET.length; z++) {
var x = ALPHABET.charAt(z)

if (ALPHABET_MAP[x] !== undefined) throw new TypeError(x + ' is ambiguous')

ALPHABET_MAP[x] = z
}

function encode (source) {

if (source.length === 0) return ''

var digits = [0]

for (var i = 0; i < source.length; ++i) {
for (var j = 0, carry = source[i]; j < digits.length; ++j) {
carry += digits[j] << 8
digits[j] = carry % BASE
carry = (carry / BASE) | 0
}

while (carry > 0) {

digits.push(carry % BASE)
carry = (carry / BASE) | 0
}
}

var string = ''

// deal with leading zeros

for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) string += LEADER
// convert digits to a string
for (var q = digits.length - 1; q >= 0; --q) string += ALPHABET[digits[q]]
 return string
}

function decodeUnsafe (string) {

if (typeof string !== 'string') throw new TypeError('Expected String')
if (string.length === 0) return Buffer.allocUnsafe(0)

var bytes = [0]

for (var i = 0; i < string.length; i++) {
var value = ALPHABET_MAP[string[i]]
if (value === undefined) return

for (var j = 0, carry = value; j < bytes.length; ++j) {

carry += bytes[j] * BASE
bytes[j] = carry & 0xff
carry >>= 8
}

while (carry > 0) {

bytes.push(carry & 0xff)
carry >>= 8
}
}

// deal with leading zeros

for (var k = 0; string[k] === LEADER && k < string.length - 1; ++k) {
bytes.push(0)
}

return Buffer.from(bytes.reverse())
}

function decode (string) {

var buffer = decodeUnsafe(string)
if (buffer) return buffer

throw new Error('Non-base' + BASE + ' character')

}

return {
encode: encode,
decodeUnsafe: decodeUnsafe,
decode: decode
}
}

},{"safe-buffer":30}],2:[function(require,module,exports){
'use strict'
var ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'

// pre-compute lookup table

var ALPHABET_MAP = {}
for (var z = 0; z < ALPHABET.length; z++) {
var x = ALPHABET.charAt(z)

if (ALPHABET_MAP[x] !== undefined) throw new TypeError(x + ' is ambiguous')

ALPHABET_MAP[x] = z
}
function polymodStep (pre) {
var b = pre >> 25
return ((pre & 0x1FFFFFF) << 5) ^
(-((b >> 0) & 1) & 0x3b6a57b2) ^
(-((b >> 1) & 1) & 0x26508e6d) ^
(-((b >> 2) & 1) & 0x1ea119fa) ^
(-((b >> 3) & 1) & 0x3d4233dd) ^
(-((b >> 4) & 1) & 0x2a1462b3)
}

function prefixChk (prefix) {

var chk = 1
for (var i = 0; i < prefix.length; ++i) {
var c = prefix.charCodeAt(i)
if (c < 33 || c > 126) throw new Error('Invalid prefix (' + prefix + ')')

chk = polymodStep(chk) ^ (c >> 5)

}
chk = polymodStep(chk)

for (i = 0; i < prefix.length; ++i) {

var v = prefix.charCodeAt(i)
chk = polymodStep(chk) ^ (v & 0x1f)
}
return chk
}

function encode (prefix, words, LIMIT) {

LIMIT = LIMIT || 90
if ((prefix.length + 7 + words.length) > LIMIT) throw new TypeError('Exceeds
length limit')

prefix = prefix.toLowerCase()

// determine chk mod

var chk = prefixChk(prefix)
var result = prefix + '1'
for (var i = 0; i < words.length; ++i) {
var x = words[i]
if ((x >> 5) !== 0) throw new Error('Non 5-bit word')

chk = polymodStep(chk) ^ x
result += ALPHABET.charAt(x)
}

for (i = 0; i < 6; ++i) {

chk = polymodStep(chk)
}
chk ^= 1

for (i = 0; i < 6; ++i) {

var v = (chk >> ((5 - i) * 5)) & 0x1f
result += ALPHABET.charAt(v)
}

return result
}

function decode (str, LIMIT) {

 LIMIT = LIMIT || 90
if (str.length < 8) throw new TypeError(str + ' too short')
if (str.length > LIMIT) throw new TypeError('Exceeds length limit')

// don't allow mixed case

var lowered = str.toLowerCase()
var uppered = str.toUpperCase()
if (str !== lowered && str !== uppered) throw new Error('Mixed-case string ' +
str)
str = lowered

var split = str.lastIndexOf('1')

if (split === -1) throw new Error('No separator character for ' + str)
if (split === 0) throw new Error('Missing prefix for ' + str)

var prefix = str.slice(0, split)

var wordChars = str.slice(split + 1)
if (wordChars.length < 6) throw new Error('Data too short')

var chk = prefixChk(prefix)

var words = []
for (var i = 0; i < wordChars.length; ++i) {
var c = wordChars.charAt(i)
var v = ALPHABET_MAP[c]
if (v === undefined) throw new Error('Unknown character ' + c)
chk = polymodStep(chk) ^ v

// not in the checksum?

if (i + 6 >= wordChars.length) continue
words.push(v)
}

if (chk !== 1) throw new Error('Invalid checksum for ' + str)

return { prefix: prefix, words: words }
}

function convert (data, inBits, outBits, pad) {

var value = 0
var bits = 0
var maxV = (1 << outBits) - 1

var result = []
for (var i = 0; i < data.length; ++i) {
value = (value << inBits) | data[i]
bits += inBits

while (bits >= outBits) {

bits -= outBits
result.push((value >> bits) & maxV)
}
}

if (pad) {
if (bits > 0) {
result.push((value << (outBits - bits)) & maxV)
}
} else {
if (bits >= inBits) throw new Error('Excess padding')
if ((value << (outBits - bits)) & maxV) throw new Error('Non-zero padding')
 }

return result
}

function toWords (bytes) {

return convert(bytes, 8, 5, true)
}

function fromWords (words) {

return convert(words, 5, 8, false)
}

module.exports = {
decode: decode,
encode: encode,
toWords: toWords,
fromWords: fromWords
}

},{}],3:[function(require,module,exports){
// (public) Constructor
function BigInteger(a, b, c) {
if (!(this instanceof BigInteger))
return new BigInteger(a, b, c)

if (a != null) {
if ("number" == typeof a) this.fromNumber(a, b, c)
else if (b == null && "string" != typeof a) this.fromString(a, 256)
else this.fromString(a, b)
}
}

var proto = BigInteger.prototype

// duck-typed isBigInteger
proto.__bigi = require('../package.json').version
BigInteger.isBigInteger = function (obj, check_ver) {
return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi)
}

// Bits per digit

var dbits

// am: Compute w_j += (x*this_i), propagate carries,

// c is initial carry, returns final carry.
// c < 3*dvalue, x < 2*dvalue, this_i < dvalue
// We need to select the fastest one that works in this environment.

// am1: use a single mult and divide to get the high bits,
// max digit bits should be 26 because
// max internal value = 2*dvalue^2-2*dvalue (< 2^53)
function am1(i, x, w, j, c, n) {
while (--n >= 0) {
var v = x * this[i++] + w[j] + c
c = Math.floor(v / 0x4000000)
w[j++] = v & 0x3ffffff
}
return c
}
// am2 avoids a big mult-and-extract completely.
// Max digit bits should be <= 30 because we do bitwise ops
// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
function am2(i, x, w, j, c, n) {
var xl = x & 0x7fff,
xh = x >> 15
while (--n >= 0) {
var l = this[i] & 0x7fff
var h = this[i++] >> 15
var m = xh * l + h * xl
l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff)
c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)
w[j++] = l & 0x3fffffff
}
return c
}
// Alternately, set max digit bits to 28 since some
// browsers slow down when dealing with 32-bit numbers.
function am3(i, x, w, j, c, n) {
var xl = x & 0x3fff,
xh = x >> 14
while (--n >= 0) {
var l = this[i] & 0x3fff
var h = this[i++] >> 14
var m = xh * l + h * xl
l = xl * l + ((m & 0x3fff) << 14) + w[j] + c
c = (l >> 28) + (m >> 14) + xh * h
w[j++] = l & 0xfffffff
}
return c
}

// wtf?
BigInteger.prototype.am = am1
dbits = 26

BigInteger.prototype.DB = dbits
BigInteger.prototype.DM = ((1 << dbits) - 1)
var DV = BigInteger.prototype.DV = (1 << dbits)

var BI_FP = 52
BigInteger.prototype.FV = Math.pow(2, BI_FP)
BigInteger.prototype.F1 = BI_FP - dbits
BigInteger.prototype.F2 = 2 * dbits - BI_FP

// Digit conversions
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz"
var BI_RC = new Array()
var rr, vv
rr = "0".charCodeAt(0)
for (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv
rr = "a".charCodeAt(0)
for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv
rr = "A".charCodeAt(0)
for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv

function int2char(n) {
return BI_RM.charAt(n)
}

function intAt(s, i) {
var c = BI_RC[s.charCodeAt(i)]
return (c == null) ? -1 : c
}

// (protected) copy this to r

function bnpCopyTo(r) {
for (var i = this.t - 1; i >= 0; --i) r[i] = this[i]
r.t = this.t
r.s = this.s
}

// (protected) set from integer value x, -DV <= x < DV

function bnpFromInt(x) {
this.t = 1
this.s = (x < 0) ? -1 : 0
if (x > 0) this[0] = x
else if (x < -1) this[0] = x + DV
else this.t = 0
}

// return bigint initialized to value

function nbv(i) {
var r = new BigInteger()
r.fromInt(i)
return r
}

// (protected) set from string and radix

function bnpFromString(s, b) {
var self = this

var k
if (b == 16) k = 4
else if (b == 8) k = 3
else if (b == 256) k = 8; // byte array
else if (b == 2) k = 1
else if (b == 32) k = 5
else if (b == 4) k = 2
else {
self.fromRadix(s, b)
return
}
self.t = 0
self.s = 0
var i = s.length,
mi = false,
sh = 0
while (--i >= 0) {
var x = (k == 8) ? s[i] & 0xff : intAt(s, i)
if (x < 0) {
if (s.charAt(i) == "-") mi = true
continue
}
mi = false
if (sh == 0)
self[self.t++] = x
 else if (sh + k > self.DB) {
self[self.t - 1] |= (x & ((1 << (self.DB - sh)) - 1)) << sh
self[self.t++] = (x >> (self.DB - sh))
} else
self[self.t - 1] |= x << sh
sh += k
if (sh >= self.DB) sh -= self.DB
}
if (k == 8 && (s[0] & 0x80) != 0) {
self.s = -1
if (sh > 0) self[self.t - 1] |= ((1 << (self.DB - sh)) - 1) << sh
}
self.clamp()
if (mi) BigInteger.ZERO.subTo(self, self)
}

// (protected) clamp off excess high words

function bnpClamp() {
var c = this.s & this.DM
while (this.t > 0 && this[this.t - 1] == c)--this.t
}

// (public) return string representation in given radix

function bnToString(b) {
var self = this
if (self.s < 0) return "-" + self.negate()
.toString(b)
var k
if (b == 16) k = 4
else if (b == 8) k = 3
else if (b == 2) k = 1
else if (b == 32) k = 5
else if (b == 4) k = 2
else return self.toRadix(b)
var km = (1 << k) - 1,
d, m = false,
r = "",
i = self.t
var p = self.DB - (i * self.DB) % k
if (i-- > 0) {
if (p < self.DB && (d = self[i] >> p) > 0) {
m = true
r = int2char(d)
}
while (i >= 0) {
if (p < k) {
d = (self[i] & ((1 << p) - 1)) << (k - p)
d |= self[--i] >> (p += self.DB - k)
} else {
d = (self[i] >> (p -= k)) & km
if (p <= 0) {
p += self.DB
--i
}
}
if (d > 0) m = true
if (m) r += int2char(d)
}
}
 return m ? r : "0"
}

// (public) -this
function bnNegate() {
var r = new BigInteger()
BigInteger.ZERO.subTo(this, r)
return r
}

// (public) |this|
function bnAbs() {
return (this.s < 0) ? this.negate() : this
}

// (public) return + if this > a, - if this < a, 0 if equal

function bnCompareTo(a) {
var r = this.s - a.s
if (r != 0) return r
var i = this.t
r = i - a.t
if (r != 0) return (this.s < 0) ? -r : r
while (--i >= 0)
if ((r = this[i] - a[i]) != 0) return r
return 0
}

// returns bit length of the integer x

function nbits(x) {
var r = 1,
t
if ((t = x >>> 16) != 0) {
x = t
r += 16
}
if ((t = x >> 8) != 0) {
x = t
r += 8
}
if ((t = x >> 4) != 0) {
x = t
r += 4
}
if ((t = x >> 2) != 0) {
x = t
r += 2
}
if ((t = x >> 1) != 0) {
x = t
r += 1
}
return r
}

// (public) return the number of bits in "this"

function bnBitLength() {
if (this.t <= 0) return 0
return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM))
}
// (public) return the number of bytes in "this"
function bnByteLength() {
return this.bitLength() >> 3
}

// (protected) r = this << n*DB

function bnpDLShiftTo(n, r) {
var i
for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i]
for (i = n - 1; i >= 0; --i) r[i] = 0
r.t = this.t + n
r.s = this.s
}

// (protected) r = this >> n*DB

function bnpDRShiftTo(n, r) {
for (var i = n; i < this.t; ++i) r[i - n] = this[i]
r.t = Math.max(this.t - n, 0)
r.s = this.s
}

// (protected) r = this << n

function bnpLShiftTo(n, r) {
var self = this
var bs = n % self.DB
var cbs = self.DB - bs
var bm = (1 << cbs) - 1
var ds = Math.floor(n / self.DB),
c = (self.s << bs) & self.DM,
i
for (i = self.t - 1; i >= 0; --i) {
r[i + ds + 1] = (self[i] >> cbs) | c
c = (self[i] & bm) << bs
}
for (i = ds - 1; i >= 0; --i) r[i] = 0
r[ds] = c
r.t = self.t + ds + 1
r.s = self.s
r.clamp()
}

// (protected) r = this >> n

function bnpRShiftTo(n, r) {
var self = this
r.s = self.s
var ds = Math.floor(n / self.DB)
if (ds >= self.t) {
r.t = 0
return
}
var bs = n % self.DB
var cbs = self.DB - bs
var bm = (1 << bs) - 1
r[0] = self[ds] >> bs
for (var i = ds + 1; i < self.t; ++i) {
r[i - ds - 1] |= (self[i] & bm) << cbs
r[i - ds] = self[i] >> bs
}
 if (bs > 0) r[self.t - ds - 1] |= (self.s & bm) << cbs
r.t = self.t - ds
r.clamp()
}

// (protected) r = this - a
function bnpSubTo(a, r) {
var self = this
var i = 0,
c = 0,
m = Math.min(a.t, self.t)
while (i < m) {
c += self[i] - a[i]
r[i++] = c & self.DM
c >>= self.DB
}
if (a.t < self.t) {
c -= a.s
while (i < self.t) {
c += self[i]
r[i++] = c & self.DM
c >>= self.DB
}
c += self.s
} else {
c += self.s
while (i < a.t) {
c -= a[i]
r[i++] = c & self.DM
c >>= self.DB
}
c -= a.s
}
r.s = (c < 0) ? -1 : 0
if (c < -1) r[i++] = self.DV + c
else if (c > 0) r[i++] = c
r.t = i
r.clamp()
}

// (protected) r = this * a, r != this,a (HAC 14.12)

// "this" should be the larger one if appropriate.
function bnpMultiplyTo(a, r) {
var x = this.abs(),
y = a.abs()
var i = x.t
r.t = i + y.t
while (--i >= 0) r[i] = 0
for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t)
r.s = 0
r.clamp()
if (this.s != a.s) BigInteger.ZERO.subTo(r, r)
}

// (protected) r = this^2, r != this (HAC 14.16)

function bnpSquareTo(r) {
var x = this.abs()
var i = r.t = 2 * x.t
while (--i >= 0) r[i] = 0
 for (i = 0; i < x.t - 1; ++i) {
var c = x.am(i, x[i], r, 2 * i, 0, 1)
if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >=
x.DV) {
r[i + x.t] -= x.DV
r[i + x.t + 1] = 1
}
}
if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)
r.s = 0
r.clamp()
}

// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)

// r != q, this != m. q or r may be null.
function bnpDivRemTo(m, q, r) {
var self = this
var pm = m.abs()
if (pm.t <= 0) return
var pt = self.abs()
if (pt.t < pm.t) {
if (q != null) q.fromInt(0)
if (r != null) self.copyTo(r)
return
}
if (r == null) r = new BigInteger()
var y = new BigInteger(),
ts = self.s,
ms = m.s
var nsh = self.DB - nbits(pm[pm.t - 1]); // normalize modulus
if (nsh > 0) {
pm.lShiftTo(nsh, y)
pt.lShiftTo(nsh, r)
} else {
pm.copyTo(y)
pt.copyTo(r)
}
var ys = y.t
var y0 = y[ys - 1]
if (y0 == 0) return
var yt = y0 * (1 << self.F1) + ((ys > 1) ? y[ys - 2] >> self.F2 : 0)
var d1 = self.FV / yt,
d2 = (1 << self.F1) / yt,
e = 1 << self.F2
var i = r.t,
j = i - ys,
t = (q == null) ? new BigInteger() : q
y.dlShiftTo(j, t)
if (r.compareTo(t) >= 0) {
r[r.t++] = 1
r.subTo(t, r)
}
BigInteger.ONE.dlShiftTo(ys, t)
t.subTo(y, y); // "negative" y so we can replace sub with am later
while (y.t < ys) y[y.t++] = 0
while (--j >= 0) {
// Estimate quotient digit
var qd = (r[--i] == y0) ? self.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2)
if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { // Try it out
 y.dlShiftTo(j, t)
r.subTo(t, r)
while (r[i] < --qd) r.subTo(t, r)
}
}
if (q != null) {
r.drShiftTo(ys, q)
if (ts != ms) BigInteger.ZERO.subTo(q, q)
}
r.t = ys
r.clamp()
if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder
if (ts < 0) BigInteger.ZERO.subTo(r, r)
}

// (public) this mod a

function bnMod(a) {
var r = new BigInteger()
this.abs()
.divRemTo(a, null, r)
if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r)
return r
}

// Modular reduction using "classic" algorithm

function Classic(m) {
this.m = m
}

function cConvert(x) {
if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m)
else return x
}

function cRevert(x) {
return x
}

function cReduce(x) {
x.divRemTo(this.m, null, x)
}

function cMulTo(x, y, r) {
x.multiplyTo(y, r)
this.reduce(r)
}

function cSqrTo(x, r) {
x.squareTo(r)
this.reduce(r)
}

Classic.prototype.convert = cConvert
Classic.prototype.revert = cRevert
Classic.prototype.reduce = cReduce
Classic.prototype.mulTo = cMulTo
Classic.prototype.sqrTo = cSqrTo

// (protected) return "-1/this % 2^DB"; useful for Mont. reduction

// justification:
// xy == 1 (mod m)
// xy = 1+km
// xy(2-xy) = (1+km)(1-km)
// x[y(2-xy)] = 1-k^2m^2
// x[y(2-xy)] == 1 (mod m^2)
// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
// JS multiply "overflows" differently from C/C++, so care is needed here.
function bnpInvDigit() {
if (this.t < 1) return 0
var x = this[0]
if ((x & 1) == 0) return 0
var y = x & 3; // y == 1/x mod 2^2
y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4
y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8
y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16
// last step - calculate inverse mod DV directly
// assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
y = (y * (2 - x * y % this.DV)) % this.DV; // y == 1/x mod 2^dbits
// we really want the negative inverse, and -DV < y < DV
return (y > 0) ? this.DV - y : -y
}

// Montgomery reduction
function Montgomery(m) {
this.m = m
this.mp = m.invDigit()
this.mpl = this.mp & 0x7fff
this.mph = this.mp >> 15
this.um = (1 << (m.DB - 15)) - 1
this.mt2 = 2 * m.t
}

// xR mod m
function montConvert(x) {
var r = new BigInteger()
x.abs()
.dlShiftTo(this.m.t, r)
r.divRemTo(this.m, null, r)
if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r)
return r
}

// x/R mod m
function montRevert(x) {
var r = new BigInteger()
x.copyTo(r)
this.reduce(r)
return r
}

// x = x/R mod m (HAC 14.32)

function montReduce(x) {
while (x.t <= this.mt2) // pad x so am has enough room later
x[x.t++] = 0
for (var i = 0; i < this.m.t; ++i) {
// faster way of calculating u0 = x[i]*mp mod DV
var j = x[i] & 0x7fff
 var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um)
<< 15)) & x.DM
// use am to combine the multiply-shift-add into one call
j = i + this.m.t
x[j] += this.m.am(0, u0, x, i, 0, this.m.t)
// propagate carry
while (x[j] >= x.DV) {
x[j] -= x.DV
x[++j]++
}
}
x.clamp()
x.drShiftTo(this.m.t, x)
if (x.compareTo(this.m) >= 0) x.subTo(this.m, x)
}

// r = "x^2/R mod m"; x != r

function montSqrTo(x, r) {
x.squareTo(r)
this.reduce(r)
}

// r = "xy/R mod m"; x,y != r

function montMulTo(x, y, r) {
x.multiplyTo(y, r)
this.reduce(r)
}

Montgomery.prototype.convert = montConvert
Montgomery.prototype.revert = montRevert
Montgomery.prototype.reduce = montReduce
Montgomery.prototype.mulTo = montMulTo
Montgomery.prototype.sqrTo = montSqrTo

// (protected) true iff this is even

function bnpIsEven() {
return ((this.t > 0) ? (this[0] & 1) : this.s) == 0
}

// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
function bnpExp(e, z) {
if (e > 0xffffffff || e < 1) return BigInteger.ONE
var r = new BigInteger(),
r2 = new BigInteger(),
g = z.convert(this),
i = nbits(e) - 1
g.copyTo(r)
while (--i >= 0) {
z.sqrTo(r, r2)
if ((e & (1 << i)) > 0) z.mulTo(r2, g, r)
else {
var t = r
r = r2
r2 = t
}
}
return z.revert(r)
}
// (public) this^e % m, 0 <= e < 2^32
function bnModPowInt(e, m) {
var z
if (e < 256 || m.isEven()) z = new Classic(m)
else z = new Montgomery(m)
return this.exp(e, z)
}

// protected
proto.copyTo = bnpCopyTo
proto.fromInt = bnpFromInt
proto.fromString = bnpFromString
proto.clamp = bnpClamp
proto.dlShiftTo = bnpDLShiftTo
proto.drShiftTo = bnpDRShiftTo
proto.lShiftTo = bnpLShiftTo
proto.rShiftTo = bnpRShiftTo
proto.subTo = bnpSubTo
proto.multiplyTo = bnpMultiplyTo
proto.squareTo = bnpSquareTo
proto.divRemTo = bnpDivRemTo
proto.invDigit = bnpInvDigit
proto.isEven = bnpIsEven
proto.exp = bnpExp

// public
proto.toString = bnToString
proto.negate = bnNegate
proto.abs = bnAbs
proto.compareTo = bnCompareTo
proto.bitLength = bnBitLength
proto.byteLength = bnByteLength
proto.mod = bnMod
proto.modPowInt = bnModPowInt

// (public)
function bnClone() {
var r = new BigInteger()
this.copyTo(r)
return r
}

// (public) return value as integer

function bnIntValue() {
if (this.s < 0) {
if (this.t == 1) return this[0] - this.DV
else if (this.t == 0) return -1
} else if (this.t == 1) return this[0]
else if (this.t == 0) return 0
// assumes 16 < DB < 32
return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]
}

// (public) return value as byte

function bnByteValue() {
return (this.t == 0) ? this.s : (this[0] << 24) >> 24
}

// (public) return value as short (assumes DB>=16)

function bnShortValue() {
return (this.t == 0) ? this.s : (this[0] << 16) >> 16
}

// (protected) return x s.t. r^x < DV

function bnpChunkSize(r) {
return Math.floor(Math.LN2 * this.DB / Math.log(r))
}

// (public) 0 if this == 0, 1 if this > 0

function bnSigNum() {
if (this.s < 0) return -1
else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0
else return 1
}

// (protected) convert to radix string

function bnpToRadix(b) {
if (b == null) b = 10
if (this.signum() == 0 || b < 2 || b > 36) return "0"
var cs = this.chunkSize(b)
var a = Math.pow(b, cs)
var d = nbv(a),
y = new BigInteger(),
z = new BigInteger(),
r = ""
this.divRemTo(d, y, z)
while (y.signum() > 0) {
r = (a + z.intValue())
.toString(b)
.substr(1) + r
y.divRemTo(d, y, z)
}
return z.intValue()
.toString(b) + r
}

// (protected) convert from radix string

function bnpFromRadix(s, b) {
var self = this
self.fromInt(0)
if (b == null) b = 10
var cs = self.chunkSize(b)
var d = Math.pow(b, cs),
mi = false,
j = 0,
w = 0
for (var i = 0; i < s.length; ++i) {
var x = intAt(s, i)
if (x < 0) {
if (s.charAt(i) == "-" && self.signum() == 0) mi = true
continue
}
w = b * w + x
if (++j >= cs) {
self.dMultiply(d)
self.dAddOffset(w, 0)
j = 0
w = 0
 }
}
if (j > 0) {
self.dMultiply(Math.pow(b, j))
self.dAddOffset(w, 0)
}
if (mi) BigInteger.ZERO.subTo(self, self)
}

// (protected) alternate constructor

function bnpFromNumber(a, b, c) {
var self = this
if ("number" == typeof b) {
// new BigInteger(int,int,RNG)
if (a < 2) self.fromInt(1)
else {
self.fromNumber(a, c)
if (!self.testBit(a - 1)) // force MSB set
self.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, self)
if (self.isEven()) self.dAddOffset(1, 0); // force odd
while (!self.isProbablePrime(b)) {
self.dAddOffset(2, 0)
if (self.bitLength() > a) self.subTo(BigInteger.ONE.shiftLeft(a - 1), self)
}
}
} else {
// new BigInteger(int,RNG)
var x = new Array(),
t = a & 7
x.length = (a >> 3) + 1
b.nextBytes(x)
if (t > 0) x[0] &= ((1 << t) - 1)
else x[0] = 0
self.fromString(x, 256)
}
}

// (public) convert to bigendian byte array

function bnToByteArray() {
var self = this
var i = self.t,
r = new Array()
r[0] = self.s
var p = self.DB - (i * self.DB) % 8,
d, k = 0
if (i-- > 0) {
if (p < self.DB && (d = self[i] >> p) != (self.s & self.DM) >> p)
r[k++] = d | (self.s << (self.DB - p))
while (i >= 0) {
if (p < 8) {
d = (self[i] & ((1 << p) - 1)) << (8 - p)
d |= self[--i] >> (p += self.DB - 8)
} else {
d = (self[i] >> (p -= 8)) & 0xff
if (p <= 0) {
p += self.DB
--i
}
}
 if ((d & 0x80) != 0) d |= -256
if (k === 0 && (self.s & 0x80) != (d & 0x80))++k
if (k > 0 || d != self.s) r[k++] = d
}
}
return r
}

function bnEquals(a) {
return (this.compareTo(a) == 0)
}

function bnMin(a) {
return (this.compareTo(a) < 0) ? this : a
}

function bnMax(a) {
return (this.compareTo(a) > 0) ? this : a
}

// (protected) r = this op a (bitwise)

function bnpBitwiseTo(a, op, r) {
var self = this
var i, f, m = Math.min(a.t, self.t)
for (i = 0; i < m; ++i) r[i] = op(self[i], a[i])
if (a.t < self.t) {
f = a.s & self.DM
for (i = m; i < self.t; ++i) r[i] = op(self[i], f)
r.t = self.t
} else {
f = self.s & self.DM
for (i = m; i < a.t; ++i) r[i] = op(f, a[i])
r.t = a.t
}
r.s = op(self.s, a.s)
r.clamp()
}

// (public) this & a

function op_and(x, y) {
return x & y
}

function bnAnd(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_and, r)
return r
}

// (public) this | a
function op_or(x, y) {
return x | y
}

function bnOr(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_or, r)
return r
}
// (public) this ^ a
function op_xor(x, y) {
return x ^ y
}

function bnXor(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_xor, r)
return r
}

// (public) this & ~a

function op_andnot(x, y) {
return x & ~y
}

function bnAndNot(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_andnot, r)
return r
}

// (public) ~this
function bnNot() {
var r = new BigInteger()
for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i]
r.t = this.t
r.s = ~this.s
return r
}

// (public) this << n

function bnShiftLeft(n) {
var r = new BigInteger()
if (n < 0) this.rShiftTo(-n, r)
else this.lShiftTo(n, r)
return r
}

// (public) this >> n

function bnShiftRight(n) {
var r = new BigInteger()
if (n < 0) this.lShiftTo(-n, r)
else this.rShiftTo(n, r)
return r
}

// return index of lowest 1-bit in x, x < 2^31

function lbit(x) {
if (x == 0) return -1
var r = 0
if ((x & 0xffff) == 0) {
x >>= 16
r += 16
}
if ((x & 0xff) == 0) {
x >>= 8
r += 8
 }
if ((x & 0xf) == 0) {
x >>= 4
r += 4
}
if ((x & 3) == 0) {
x >>= 2
r += 2
}
if ((x & 1) == 0)++r
return r
}

// (public) returns index of lowest 1-bit (or -1 if none)

function bnGetLowestSetBit() {
for (var i = 0; i < this.t; ++i)
if (this[i] != 0) return i * this.DB + lbit(this[i])
if (this.s < 0) return this.t * this.DB
return -1
}

// return number of 1 bits in x

function cbit(x) {
var r = 0
while (x != 0) {
x &= x - 1
++r
}
return r
}

// (public) return number of set bits

function bnBitCount() {
var r = 0,
x = this.s & this.DM
for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x)
return r
}

// (public) true iff nth bit is set

function bnTestBit(n) {
var j = Math.floor(n / this.DB)
if (j >= this.t) return (this.s != 0)
return ((this[j] & (1 << (n % this.DB))) != 0)
}

// (protected) this op (1<<n)

function bnpChangeBit(n, op) {
var r = BigInteger.ONE.shiftLeft(n)
this.bitwiseTo(r, op, r)
return r
}

// (public) this | (1<<n)

function bnSetBit(n) {
return this.changeBit(n, op_or)
}

// (public) this & ~(1<<n)

function bnClearBit(n) {
return this.changeBit(n, op_andnot)
}

// (public) this ^ (1<<n)

function bnFlipBit(n) {
return this.changeBit(n, op_xor)
}

// (protected) r = this + a
function bnpAddTo(a, r) {
var self = this

var i = 0,
c = 0,
m = Math.min(a.t, self.t)
while (i < m) {
c += self[i] + a[i]
r[i++] = c & self.DM
c >>= self.DB
}
if (a.t < self.t) {
c += a.s
while (i < self.t) {
c += self[i]
r[i++] = c & self.DM
c >>= self.DB
}
c += self.s
} else {
c += self.s
while (i < a.t) {
c += a[i]
r[i++] = c & self.DM
c >>= self.DB
}
c += a.s
}
r.s = (c < 0) ? -1 : 0
if (c > 0) r[i++] = c
else if (c < -1) r[i++] = self.DV + c
r.t = i
r.clamp()
}

// (public) this + a
function bnAdd(a) {
var r = new BigInteger()
this.addTo(a, r)
return r
}

// (public) this - a
function bnSubtract(a) {
var r = new BigInteger()
this.subTo(a, r)
return r
}
// (public) this * a
function bnMultiply(a) {
var r = new BigInteger()
this.multiplyTo(a, r)
return r
}

// (public) this^2
function bnSquare() {
var r = new BigInteger()
this.squareTo(r)
return r
}

// (public) this / a
function bnDivide(a) {
var r = new BigInteger()
this.divRemTo(a, r, null)
return r
}

// (public) this % a
function bnRemainder(a) {
var r = new BigInteger()
this.divRemTo(a, null, r)
return r
}

// (public) [this/a,this%a]
function bnDivideAndRemainder(a) {
var q = new BigInteger(),
r = new BigInteger()
this.divRemTo(a, q, r)
return new Array(q, r)
}

// (protected) this *= n, this >= 0, 1 < n < DV

function bnpDMultiply(n) {
this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)
++this.t
this.clamp()
}

// (protected) this += n << w words, this >= 0

function bnpDAddOffset(n, w) {
if (n == 0) return
while (this.t <= w) this[this.t++] = 0
this[w] += n
while (this[w] >= this.DV) {
this[w] -= this.DV
if (++w >= this.t) this[this.t++] = 0
++this[w]
}
}

// A "null" reducer
function NullExp() {}

function nNop(x) {
 return x
}

function nMulTo(x, y, r) {
x.multiplyTo(y, r)
}

function nSqrTo(x, r) {
x.squareTo(r)
}

NullExp.prototype.convert = nNop
NullExp.prototype.revert = nNop
NullExp.prototype.mulTo = nMulTo
NullExp.prototype.sqrTo = nSqrTo

// (public) this^e
function bnPow(e) {
return this.exp(e, new NullExp())
}

// (protected) r = lower n words of "this * a", a.t <= n

// "this" should be the larger one if appropriate.
function bnpMultiplyLowerTo(a, n, r) {
var i = Math.min(this.t + a.t, n)
r.s = 0; // assumes a,this >= 0
r.t = i
while (i > 0) r[--i] = 0
var j
for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0,
this.t)
for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i)
r.clamp()
}

// (protected) r = "this * a" without lower n words, n > 0

// "this" should be the larger one if appropriate.
function bnpMultiplyUpperTo(a, n, r) {
--n
var i = r.t = this.t + a.t - n
r.s = 0; // assumes a,this >= 0
while (--i >= 0) r[i] = 0
for (i = Math.max(n - this.t, 0); i < a.t; ++i)
r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n)
r.clamp()
r.drShiftTo(1, r)
}

// Barrett modular reduction

function Barrett(m) {
// setup Barrett
this.r2 = new BigInteger()
this.q3 = new BigInteger()
BigInteger.ONE.dlShiftTo(2 * m.t, this.r2)
this.mu = this.r2.divide(m)
this.m = m
}

function barrettConvert(x) {
 if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m)
else if (x.compareTo(this.m) < 0) return x
else {
var r = new BigInteger()
x.copyTo(r)
this.reduce(r)
return r
}
}

function barrettRevert(x) {
return x
}

// x = x mod m (HAC 14.42)

function barrettReduce(x) {
var self = this
x.drShiftTo(self.m.t - 1, self.r2)
if (x.t > self.m.t + 1) {
x.t = self.m.t + 1
x.clamp()
}
self.mu.multiplyUpperTo(self.r2, self.m.t + 1, self.q3)
self.m.multiplyLowerTo(self.q3, self.m.t + 1, self.r2)
while (x.compareTo(self.r2) < 0) x.dAddOffset(1, self.m.t + 1)
x.subTo(self.r2, x)
while (x.compareTo(self.m) >= 0) x.subTo(self.m, x)
}

// r = x^2 mod m; x != r
function barrettSqrTo(x, r) {
x.squareTo(r)
this.reduce(r)
}

// r = x*y mod m; x,y != r

function barrettMulTo(x, y, r) {
x.multiplyTo(y, r)
this.reduce(r)
}

Barrett.prototype.convert = barrettConvert
Barrett.prototype.revert = barrettRevert
Barrett.prototype.reduce = barrettReduce
Barrett.prototype.mulTo = barrettMulTo
Barrett.prototype.sqrTo = barrettSqrTo

// (public) this^e % m (HAC 14.85)

function bnModPow(e, m) {
var i = e.bitLength(),
k, r = nbv(1),
z
if (i <= 0) return r
else if (i < 18) k = 1
else if (i < 48) k = 3
else if (i < 144) k = 4
else if (i < 768) k = 5
else k = 6
if (i < 8)
 z = new Classic(m)
else if (m.isEven())
z = new Barrett(m)
else
z = new Montgomery(m)

// precomputation
var g = new Array(),
n = 3,
k1 = k - 1,
km = (1 << k) - 1
g[1] = z.convert(this)
if (k > 1) {
var g2 = new BigInteger()
z.sqrTo(g[1], g2)
while (n <= km) {
g[n] = new BigInteger()
z.mulTo(g2, g[n - 2], g[n])
n += 2
}
}

var j = e.t - 1,
w, is1 = true,
r2 = new BigInteger(),
t
i = nbits(e[j]) - 1
while (j >= 0) {
if (i >= k1) w = (e[j] >> (i - k1)) & km
else {
w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)
if (j > 0) w |= e[j - 1] >> (this.DB + i - k1)
}

n = k
while ((w & 1) == 0) {
w >>= 1
--n
}
if ((i -= n) < 0) {
i += this.DB
--j
}
if (is1) { // ret == 1, don't bother squaring or multiplying it
g[w].copyTo(r)
is1 = false
} else {
while (n > 1) {
z.sqrTo(r, r2)
z.sqrTo(r2, r)
n -= 2
}
if (n > 0) z.sqrTo(r, r2)
else {
t = r
r = r2
r2 = t
}
z.mulTo(r2, g[w], r)
 }

while (j >= 0 && (e[j] & (1 << i)) == 0) {

z.sqrTo(r, r2)
t = r
r = r2
r2 = t
if (--i < 0) {
i = this.DB - 1
--j
}
}
}
return z.revert(r)
}

// (public) gcd(this,a) (HAC 14.54)

function bnGCD(a) {
var x = (this.s < 0) ? this.negate() : this.clone()
var y = (a.s < 0) ? a.negate() : a.clone()
if (x.compareTo(y) < 0) {
var t = x
x = y
y = t
}
var i = x.getLowestSetBit(),
g = y.getLowestSetBit()
if (g < 0) return x
if (i < g) g = i
if (g > 0) {
x.rShiftTo(g, x)
y.rShiftTo(g, y)
}
while (x.signum() > 0) {
if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x)
if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, y)
if (x.compareTo(y) >= 0) {
x.subTo(y, x)
x.rShiftTo(1, x)
} else {
y.subTo(x, y)
y.rShiftTo(1, y)
}
}
if (g > 0) y.lShiftTo(g, y)
return y
}

// (protected) this % n, n < 2^26

function bnpModInt(n) {
if (n <= 0) return 0
var d = this.DV % n,
r = (this.s < 0) ? n - 1 : 0
if (this.t > 0)
if (d == 0) r = this[0] % n
else
for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n
return r
}
// (public) 1/this % m (HAC 14.61)
function bnModInverse(m) {
var ac = m.isEven()
if (this.signum() === 0) throw new Error('division by zero')
if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO
var u = m.clone(),
v = this.clone()
var a = nbv(1),
b = nbv(0),
c = nbv(0),
d = nbv(1)
while (u.signum() != 0) {
while (u.isEven()) {
u.rShiftTo(1, u)
if (ac) {
if (!a.isEven() || !b.isEven()) {
a.addTo(this, a)
b.subTo(m, b)
}
a.rShiftTo(1, a)
} else if (!b.isEven()) b.subTo(m, b)
b.rShiftTo(1, b)
}
while (v.isEven()) {
v.rShiftTo(1, v)
if (ac) {
if (!c.isEven() || !d.isEven()) {
c.addTo(this, c)
d.subTo(m, d)
}
c.rShiftTo(1, c)
} else if (!d.isEven()) d.subTo(m, d)
d.rShiftTo(1, d)
}
if (u.compareTo(v) >= 0) {
u.subTo(v, u)
if (ac) a.subTo(c, a)
b.subTo(d, b)
} else {
v.subTo(u, v)
if (ac) c.subTo(a, c)
d.subTo(b, d)
}
}
if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO
while (d.compareTo(m) >= 0) d.subTo(m, d)
while (d.signum() < 0) d.addTo(m, d)
return d
}

var lowprimes = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,
421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,
 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997
]

var lplim = (1 << 26) / lowprimes[lowprimes.length - 1]

// (public) test primality with certainty >= 1-.5^t

function bnIsProbablePrime(t) {
var i, x = this.abs()
if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {
for (i = 0; i < lowprimes.length; ++i)
if (x[0] == lowprimes[i]) return true
return false
}
if (x.isEven()) return false
i = 1
while (i < lowprimes.length) {
var m = lowprimes[i],
j = i + 1
while (j < lowprimes.length && m < lplim) m *= lowprimes[j++]
m = x.modInt(m)
while (i < j) if (m % lowprimes[i++] == 0) return false
}
return x.millerRabin(t)
}

// (protected) true if probably prime (HAC 4.24, Miller-Rabin)

function bnpMillerRabin(t) {
var n1 = this.subtract(BigInteger.ONE)
var k = n1.getLowestSetBit()
if (k <= 0) return false
var r = n1.shiftRight(k)
t = (t + 1) >> 1
if (t > lowprimes.length) t = lowprimes.length
var a = new BigInteger(null)
var j, bases = []
for (var i = 0; i < t; ++i) {
for (;;) {
j = lowprimes[Math.floor(Math.random() * lowprimes.length)]
if (bases.indexOf(j) == -1) break
}
bases.push(j)
a.fromInt(j)
var y = a.modPow(r, this)
if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
var j = 1
while (j++ < k && y.compareTo(n1) != 0) {
y = y.modPowInt(2, this)
if (y.compareTo(BigInteger.ONE) == 0) return false
}
if (y.compareTo(n1) != 0) return false
}
}
return true
}

// protected
proto.chunkSize = bnpChunkSize
proto.toRadix = bnpToRadix
proto.fromRadix = bnpFromRadix
proto.fromNumber = bnpFromNumber
proto.bitwiseTo = bnpBitwiseTo
proto.changeBit = bnpChangeBit
proto.addTo = bnpAddTo
proto.dMultiply = bnpDMultiply
proto.dAddOffset = bnpDAddOffset
proto.multiplyLowerTo = bnpMultiplyLowerTo
proto.multiplyUpperTo = bnpMultiplyUpperTo
proto.modInt = bnpModInt
proto.millerRabin = bnpMillerRabin

// public
proto.clone = bnClone
proto.intValue = bnIntValue
proto.byteValue = bnByteValue
proto.shortValue = bnShortValue
proto.signum = bnSigNum
proto.toByteArray = bnToByteArray
proto.equals = bnEquals
proto.min = bnMin
proto.max = bnMax
proto.and = bnAnd
proto.or = bnOr
proto.xor = bnXor
proto.andNot = bnAndNot
proto.not = bnNot
proto.shiftLeft = bnShiftLeft
proto.shiftRight = bnShiftRight
proto.getLowestSetBit = bnGetLowestSetBit
proto.bitCount = bnBitCount
proto.testBit = bnTestBit
proto.setBit = bnSetBit
proto.clearBit = bnClearBit
proto.flipBit = bnFlipBit
proto.add = bnAdd
proto.subtract = bnSubtract
proto.multiply = bnMultiply
proto.divide = bnDivide
proto.remainder = bnRemainder
proto.divideAndRemainder = bnDivideAndRemainder
proto.modPow = bnModPow
proto.modInverse = bnModInverse
proto.pow = bnPow
proto.gcd = bnGCD
proto.isProbablePrime = bnIsProbablePrime

// JSBN-specific extension
proto.square = bnSquare

// constants
BigInteger.ZERO = nbv(0)
BigInteger.ONE = nbv(1)
BigInteger.valueOf = nbv

module.exports = BigInteger
},{"../package.json":6}],4:[function(require,module,exports){
(function (Buffer){
// FIXME: Kind of a weird way to throw exceptions, consider removing
var assert = require('assert')
var BigInteger = require('./bigi')

/**
* Turns a byte array into a big integer.
*
* This function will interpret a byte array as a big integer in big
* endian notation.
*/
BigInteger.fromByteArrayUnsigned = function(byteArray) {
// BigInteger expects a DER integer conformant byte array
if (byteArray[0] & 0x80) {
return new BigInteger([0].concat(byteArray))
}

return new BigInteger(byteArray)

}

/**
* Returns a byte array representation of the big integer.
*
* This returns the absolute of the contained value in big endian
* form. A value of zero results in an empty array.
*/
BigInteger.prototype.toByteArrayUnsigned = function() {
var byteArray = this.toByteArray()
return byteArray[0] === 0 ? byteArray.slice(1) : byteArray
}

BigInteger.fromDERInteger = function(byteArray) {
return new BigInteger(byteArray)
}

/*
* Converts BigInteger to a DER integer representation.
*
* The format for this value uses the most significant bit as a sign
* bit. If the most significant bit is already set and the integer is
* positive, a 0x00 is prepended.
*
* Examples:
*
* 0 => 0x00
* 1 => 0x01
* -1 => 0xff
* 127 => 0x7f
* -127 => 0x81
* 128 => 0x0080
* -128 => 0x80
* 255 => 0x00ff
* -255 => 0xff01
* 16300 => 0x3fac
* -16300 => 0xc054
* 62300 => 0x00f35c
* -62300 => 0xff0ca4
*/
BigInteger.prototype.toDERInteger = BigInteger.prototype.toByteArray

BigInteger.fromBuffer = function(buffer) {
// BigInteger expects a DER integer conformant byte array
if (buffer[0] & 0x80) {
var byteArray = Array.prototype.slice.call(buffer)

return new BigInteger([0].concat(byteArray))

}

return new BigInteger(buffer)

}

BigInteger.fromHex = function(hex) {
if (hex === '') return BigInteger.ZERO

assert.equal(hex, hex.match(/^[A-Fa-f0-9]+/), 'Invalid hex string')

assert.equal(hex.length % 2, 0, 'Incomplete hex')
return new BigInteger(hex, 16)
}

BigInteger.prototype.toBuffer = function(size) {
var byteArray = this.toByteArrayUnsigned()
var zeros = []

var padding = size - byteArray.length

while (zeros.length < padding) zeros.push(0)

return new Buffer(zeros.concat(byteArray))

}

BigInteger.prototype.toHex = function(size) {
return this.toBuffer(size).toString('hex')
}

}).call(this,require("buffer").Buffer)
},{"./bigi":3,"assert":82,"buffer":84}],5:[function(require,module,exports){
var BigInteger = require('./bigi')

//addons
require('./convert')

module.exports = BigInteger
},{"./bigi":3,"./convert":4}],6:[function(require,module,exports){
module.exports={
"_from": "bigi@^1.4.0",
"_id": "[email protected]",
"_inBundle": false,
"_integrity": "sha1-nGZalfiLiwj8Bc/XMfVhhZ1yWCU=",
"_location": "/bigi",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "bigi@^1.4.0",
"name": "bigi",
"escapedName": "bigi",
"rawSpec": "^1.4.0",
"saveSpec": null,
 "fetchSpec": "^1.4.0"
},
"_requiredBy": [
"/",
"/ecurve"
],
"_resolved": "https://registry.npmjs.org/bigi/-/bigi-1.4.2.tgz",
"_shasum": "9c665a95f88b8b08fc05cfd731f561859d725825",
"_spec": "bigi@^1.4.0",
"_where": "/home/anazir/bitcoinjs-lib",
"bugs": {
"url": "https://github.com/cryptocoinjs/bigi/issues"
},
"bundleDependencies": false,
"dependencies": {},
"deprecated": false,
"description": "Big integers.",
"devDependencies": {
"coveralls": "^2.11.2",
"istanbul": "^0.3.5",
"jshint": "^2.5.1",
"mocha": "^2.1.0",
"mochify": "^2.1.0"
},
"homepage": "https://github.com/cryptocoinjs/bigi#readme",
"keywords": [
"cryptography",
"math",
"bitcoin",
"arbitrary",
"precision",
"arithmetic",
"big",
"integer",
"int",
"number",
"biginteger",
"bigint",
"bignumber",
"decimal",
"float"
],
"main": "./lib/index.js",
"name": "bigi",
"repository": {
"url": "git+https://github.com/cryptocoinjs/bigi.git",
"type": "git"
},
"scripts": {
"browser-test": "mochify --wd -R spec",
"coverage": "istanbul cover ./node_modules/.bin/_mocha -- --reporter list
test/*.js",
"coveralls": "npm run-script coverage && node ./node_modules/.bin/coveralls <
coverage/lcov.info",
"jshint": "jshint --config jshint.json lib/*.js ; true",
"test": "_mocha -- test/*.js",
"unit": "mocha"
},
"testling": {
 "files": "test/*.js",
"harness": "mocha",
"browsers": [
"ie/9..latest",
"firefox/latest",
"chrome/latest",
"safari/6.0..latest",
"iphone/6.0..latest",
"android-browser/4.2..latest"
]
},
"version": "1.4.2"
}

},{}],7:[function(require,module,exports){
// Reference https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
// Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
// NOTE: SIGHASH byte ignored AND restricted, truncate before use

var Buffer = require('safe-buffer').Buffer

function check (buffer) {

if (buffer.length < 8) return false
if (buffer.length > 72) return false
if (buffer[0] !== 0x30) return false
if (buffer[1] !== buffer.length - 2) return false
if (buffer[2] !== 0x02) return false

var lenR = buffer[3]

if (lenR === 0) return false
if (5 + lenR >= buffer.length) return false
if (buffer[4 + lenR] !== 0x02) return false

var lenS = buffer[5 + lenR]

if (lenS === 0) return false
if ((6 + lenR + lenS) !== buffer.length) return false

if (buffer[4] & 0x80) return false

if (lenR > 1 && (buffer[4] === 0x00) && !(buffer[5] & 0x80)) return false

if (buffer[lenR + 6] & 0x80) return false

if (lenS > 1 && (buffer[lenR + 6] === 0x00) && !(buffer[lenR + 7] & 0x80)) return
false
return true
}

function decode (buffer) {

if (buffer.length < 8) throw new Error('DER sequence length is too short')
if (buffer.length > 72) throw new Error('DER sequence length is too long')
if (buffer[0] !== 0x30) throw new Error('Expected DER sequence')
if (buffer[1] !== buffer.length - 2) throw new Error('DER sequence length is
invalid')
if (buffer[2] !== 0x02) throw new Error('Expected DER integer')

var lenR = buffer[3]

if (lenR === 0) throw new Error('R length is zero')
if (5 + lenR >= buffer.length) throw new Error('R length is too long')
if (buffer[4 + lenR] !== 0x02) throw new Error('Expected DER integer (2)')
 var lenS = buffer[5 + lenR]
if (lenS === 0) throw new Error('S length is zero')
if ((6 + lenR + lenS) !== buffer.length) throw new Error('S length is invalid')

if (buffer[4] & 0x80) throw new Error('R value is negative')

if (lenR > 1 && (buffer[4] === 0x00) && !(buffer[5] & 0x80)) throw new Error('R
value excessively padded')

if (buffer[lenR + 6] & 0x80) throw new Error('S value is negative')

if (lenS > 1 && (buffer[lenR + 6] === 0x00) && !(buffer[lenR + 7] & 0x80)) throw
new Error('S value excessively padded')

// non-BIP66 - extract R, S values

return {
r: buffer.slice(4, 4 + lenR),
s: buffer.slice(6 + lenR)
}
}

/*
* Expects r and s to be positive DER integers.
*
* The DER format uses the most significant bit as a sign bit (& 0x80).
* If the significant bit is set AND the integer is positive, a 0x00 is prepended.
*
* Examples:
*
* 0 => 0x00
* 1 => 0x01
* -1 => 0xff
* 127 => 0x7f
* -127 => 0x81
* 128 => 0x0080
* -128 => 0x80
* 255 => 0x00ff
* -255 => 0xff01
* 16300 => 0x3fac
* -16300 => 0xc054
* 62300 => 0x00f35c
* -62300 => 0xff0ca4
*/
function encode (r, s) {
var lenR = r.length
var lenS = s.length
if (lenR === 0) throw new Error('R length is zero')
if (lenS === 0) throw new Error('S length is zero')
if (lenR > 33) throw new Error('R length is too long')
if (lenS > 33) throw new Error('S length is too long')
if (r[0] & 0x80) throw new Error('R value is negative')
if (s[0] & 0x80) throw new Error('S value is negative')
if (lenR > 1 && (r[0] === 0x00) && !(r[1] & 0x80)) throw new Error('R value
excessively padded')
if (lenS > 1 && (s[0] === 0x00) && !(s[1] & 0x80)) throw new Error('S value
excessively padded')

var signature = Buffer.allocUnsafe(6 + lenR + lenS)

// 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]

signature[0] = 0x30
 signature[1] = signature.length - 2
signature[2] = 0x02
signature[3] = r.length
r.copy(signature, 4)
signature[4 + lenR] = 0x02
signature[5 + lenR] = s.length
s.copy(signature, 6 + lenR)

return signature
}

module.exports = {
check: check,
decode: decode,
encode: encode
}

},{"safe-buffer":30}],8:[function(require,module,exports){
module.exports={
"OP_FALSE": 0,
"OP_0": 0,
"OP_PUSHDATA1": 76,
"OP_PUSHDATA2": 77,
"OP_PUSHDATA4": 78,
"OP_1NEGATE": 79,
"OP_RESERVED": 80,
"OP_TRUE": 81,
"OP_1": 81,
"OP_2": 82,
"OP_3": 83,
"OP_4": 84,
"OP_5": 85,
"OP_6": 86,
"OP_7": 87,
"OP_8": 88,
"OP_9": 89,
"OP_10": 90,
"OP_11": 91,
"OP_12": 92,
"OP_13": 93,
"OP_14": 94,
"OP_15": 95,
"OP_16": 96,

"OP_NOP": 97,
"OP_VER": 98,
"OP_IF": 99,
"OP_NOTIF": 100,
"OP_VERIF": 101,
"OP_VERNOTIF": 102,
"OP_ELSE": 103,
"OP_ENDIF": 104,
"OP_VERIFY": 105,
"OP_RETURN": 106,

"OP_TOALTSTACK": 107,
"OP_FROMALTSTACK": 108,
"OP_2DROP": 109,
"OP_2DUP": 110,
"OP_3DUP": 111,
"OP_2OVER": 112,
"OP_2ROT": 113,
"OP_2SWAP": 114,
"OP_IFDUP": 115,
"OP_DEPTH": 116,
"OP_DROP": 117,
"OP_DUP": 118,
"OP_NIP": 119,
"OP_OVER": 120,
"OP_PICK": 121,
"OP_ROLL": 122,
"OP_ROT": 123,
"OP_SWAP": 124,
"OP_TUCK": 125,

"OP_CAT": 126,
"OP_SUBSTR": 127,
"OP_LEFT": 128,
"OP_RIGHT": 129,
"OP_SIZE": 130,

"OP_INVERT": 131,
"OP_AND": 132,
"OP_OR": 133,
"OP_XOR": 134,
"OP_EQUAL": 135,
"OP_EQUALVERIFY": 136,
"OP_RESERVED1": 137,
"OP_RESERVED2": 138,

"OP_1ADD": 139,
"OP_1SUB": 140,
"OP_2MUL": 141,
"OP_2DIV": 142,
"OP_NEGATE": 143,
"OP_ABS": 144,
"OP_NOT": 145,
"OP_0NOTEQUAL": 146,
"OP_ADD": 147,
"OP_SUB": 148,
"OP_MUL": 149,
"OP_DIV": 150,
"OP_MOD": 151,
"OP_LSHIFT": 152,
"OP_RSHIFT": 153,

"OP_BOOLAND": 154,
"OP_BOOLOR": 155,
"OP_NUMEQUAL": 156,
"OP_NUMEQUALVERIFY": 157,
"OP_NUMNOTEQUAL": 158,
"OP_LESSTHAN": 159,
"OP_GREATERTHAN": 160,
"OP_LESSTHANOREQUAL": 161,
"OP_GREATERTHANOREQUAL": 162,
"OP_MIN": 163,
"OP_MAX": 164,
 "OP_WITHIN": 165,

"OP_RIPEMD160": 166,
"OP_SHA1": 167,
"OP_SHA256": 168,
"OP_HASH160": 169,
"OP_HASH256": 170,
"OP_CODESEPARATOR": 171,
"OP_CHECKSIG": 172,
"OP_CHECKSIGVERIFY": 173,
"OP_CHECKMULTISIG": 174,
"OP_CHECKMULTISIGVERIFY": 175,

"OP_NOP1": 176,

"OP_NOP2": 177,
"OP_CHECKLOCKTIMEVERIFY": 177,

"OP_NOP3": 178,
"OP_CHECKSEQUENCEVERIFY": 178,

"OP_NOP4": 179,
"OP_NOP5": 180,
"OP_NOP6": 181,
"OP_NOP7": 182,
"OP_NOP8": 183,
"OP_NOP9": 184,
"OP_NOP10": 185,

"OP_PUBKEYHASH": 253,
"OP_PUBKEY": 254,
"OP_INVALIDOPCODE": 255
}

},{}],9:[function(require,module,exports){
var OPS = require('./index.json')

var map = {}
for (var op in OPS) {
var code = OPS[op]
map[code] = op
}

module.exports = map

},{"./index.json":8}],10:[function(require,module,exports){
var basex = require('base-x')
var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

module.exports = basex(ALPHABET)

},{"base-x":1}],11:[function(require,module,exports){
'use strict'

var base58 = require('bs58')

var Buffer = require('safe-buffer').Buffer

module.exports = function (checksumFn) {

// Encode a buffer as a base58-check encoded string
 function encode (payload) {
var checksum = checksumFn(payload)

return base58.encode(Buffer.concat([
payload,
checksum
], payload.length + 4))
}

function decodeRaw (buffer) {

var payload = buffer.slice(0, -4)
var checksum = buffer.slice(-4)
var newChecksum = checksumFn(payload)

if (checksum[0] ^ newChecksum[0] |
checksum[1] ^ newChecksum[1] |
checksum[2] ^ newChecksum[2] |
checksum[3] ^ newChecksum[3]) return

return payload
}

// Decode a base58-check encoded string to a buffer, no result if checksum is

wrong
function decodeUnsafe (string) {
var buffer = base58.decodeUnsafe(string)
if (!buffer) return

return decodeRaw(buffer)
}

function decode (string) {

var buffer = base58.decode(string)
var payload = decodeRaw(buffer, checksumFn)
if (!payload) throw new Error('Invalid checksum')
return payload
}

return {
encode: encode,
decode: decode,
decodeUnsafe: decodeUnsafe
}
}

},{"bs58":10,"safe-buffer":30}],12:[function(require,module,exports){
'use strict'

var createHash = require('create-hash')

var bs58checkBase = require('./base')

// SHA256(SHA256(buffer))
function sha256x2 (buffer) {
var tmp = createHash('sha256').update(buffer).digest()
return createHash('sha256').update(tmp).digest()
}

module.exports = bs58checkBase(sha256x2)
},{"./base":11,"create-hash":14}],13:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var Transform = require('stream').Transform
var StringDecoder = require('string_decoder').StringDecoder
var inherits = require('inherits')

function CipherBase (hashMode) {

Transform.call(this)
this.hashMode = typeof hashMode === 'string'
if (this.hashMode) {
this[hashMode] = this._finalOrDigest
} else {
this.final = this._finalOrDigest
}
if (this._final) {
this.__final = this._final
this._final = null
}
this._decoder = null
this._encoding = null
}
inherits(CipherBase, Transform)

CipherBase.prototype.update = function (data, inputEnc, outputEnc) {

if (typeof data === 'string') {
data = Buffer.from(data, inputEnc)
}

var outData = this._update(data)

if (this.hashMode) return this

if (outputEnc) {
outData = this._toString(outData, outputEnc)
}

return outData
}

CipherBase.prototype.setAutoPadding = function () {}
CipherBase.prototype.getAuthTag = function () {
throw new Error('trying to get auth tag in unsupported state')
}

CipherBase.prototype.setAuthTag = function () {
throw new Error('trying to set auth tag in unsupported state')
}

CipherBase.prototype.setAAD = function () {
throw new Error('trying to set aad in unsupported state')
}

CipherBase.prototype._transform = function (data, _, next) {

var err
try {
if (this.hashMode) {
this._update(data)
} else {
this.push(this._update(data))
}
 } catch (e) {
err = e
} finally {
next(err)
}
}
CipherBase.prototype._flush = function (done) {
var err
try {
this.push(this.__final())
} catch (e) {
err = e
}

done(err)
}
CipherBase.prototype._finalOrDigest = function (outputEnc) {
var outData = this.__final() || Buffer.alloc(0)
if (outputEnc) {
outData = this._toString(outData, outputEnc, true)
}
return outData
}

CipherBase.prototype._toString = function (value, enc, fin) {

if (!this._decoder) {
this._decoder = new StringDecoder(enc)
this._encoding = enc
}

if (this._encoding !== enc) throw new Error('can\'t switch encodings')

var out = this._decoder.write(value)

if (fin) {
out += this._decoder.end()
}

return out
}

module.exports = CipherBase

},{"inherits":24,"safe-buffer":30,"stream":103,"string_decoder":104}],14:
[function(require,module,exports){
'use strict'
var inherits = require('inherits')
var MD5 = require('md5.js')
var RIPEMD160 = require('ripemd160')
var sha = require('sha.js')
var Base = require('cipher-base')

function Hash (hash) {

Base.call(this, 'digest')

this._hash = hash
}

inherits(Hash, Base)
Hash.prototype._update = function (data) {
this._hash.update(data)
}

Hash.prototype._final = function () {
return this._hash.digest()
}

module.exports = function createHash (alg) {

alg = alg.toLowerCase()
if (alg === 'md5') return new MD5()
if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()

return new Hash(sha(alg))

}

},{"cipher-base":13,"inherits":24,"md5.js":25,"ripemd160":29,"sha.js":32}],15:
[function(require,module,exports){
var MD5 = require('md5.js')

module.exports = function (buffer) {

return new MD5().update(buffer).digest()
}

},{"md5.js":25}],16:[function(require,module,exports){
'use strict'
var inherits = require('inherits')
var Legacy = require('./legacy')
var Base = require('cipher-base')
var Buffer = require('safe-buffer').Buffer
var md5 = require('create-hash/md5')
var RIPEMD160 = require('ripemd160')

var sha = require('sha.js')

var ZEROS = Buffer.alloc(128)

function Hmac (alg, key) {

Base.call(this, 'digest')
if (typeof key === 'string') {
key = Buffer.from(key)
}

var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64

this._alg = alg
this._key = key
if (key.length > blocksize) {
var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
key = hash.update(key).digest()
} else if (key.length < blocksize) {
key = Buffer.concat([key, ZEROS], blocksize)
}

var ipad = this._ipad = Buffer.allocUnsafe(blocksize)

var opad = this._opad = Buffer.allocUnsafe(blocksize)

for (var i = 0; i < blocksize; i++) {

ipad[i] = key[i] ^ 0x36
 opad[i] = key[i] ^ 0x5C
}
this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)
this._hash.update(ipad)
}

inherits(Hmac, Base)

Hmac.prototype._update = function (data) {

this._hash.update(data)
}

Hmac.prototype._final = function () {
var h = this._hash.digest()
var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)
return hash.update(this._opad).update(h).digest()
}

module.exports = function createHmac (alg, key) {

alg = alg.toLowerCase()
if (alg === 'rmd160' || alg === 'ripemd160') {
return new Hmac('rmd160', key)
}
if (alg === 'md5') {
return new Legacy(md5, key)
}
return new Hmac(alg, key)
}

},{"./legacy":17,"cipher-base":13,"create-hash/
md5":15,"inherits":24,"ripemd160":29,"safe-buffer":30,"sha.js":32}],17:
[function(require,module,exports){
'use strict'
var inherits = require('inherits')
var Buffer = require('safe-buffer').Buffer

var Base = require('cipher-base')

var ZEROS = Buffer.alloc(128)

var blocksize = 64

function Hmac (alg, key) {

Base.call(this, 'digest')
if (typeof key === 'string') {
key = Buffer.from(key)
}

this._alg = alg
this._key = key

if (key.length > blocksize) {

key = alg(key)
} else if (key.length < blocksize) {
key = Buffer.concat([key, ZEROS], blocksize)
}

var ipad = this._ipad = Buffer.allocUnsafe(blocksize)

var opad = this._opad = Buffer.allocUnsafe(blocksize)
 for (var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 0x36
opad[i] = key[i] ^ 0x5C
}

this._hash = [ipad]
}

inherits(Hmac, Base)

Hmac.prototype._update = function (data) {

this._hash.push(data)
}

Hmac.prototype._final = function () {
var h = this._alg(Buffer.concat(this._hash))
return this._alg(Buffer.concat([this._opad, h]))
}
module.exports = Hmac

},{"cipher-base":13,"inherits":24,"safe-buffer":30}],18:
[function(require,module,exports){
var assert = require('assert')
var BigInteger = require('bigi')

var Point = require('./point')

function Curve (p, a, b, Gx, Gy, n, h) {

this.p = p
this.a = a
this.b = b
this.G = Point.fromAffine(this, Gx, Gy)
this.n = n
this.h = h

this.infinity = new Point(this, null, null, BigInteger.ZERO)

// result caching
this.pOverFour = p.add(BigInteger.ONE).shiftRight(2)

// determine size of p in bytes

this.pLength = Math.floor((this.p.bitLength() + 7) / 8)
}

Curve.prototype.pointFromX = function (isOdd, x) {

var alpha = x.pow(3).add(this.a.multiply(x)).add(this.b).mod(this.p)
var beta = alpha.modPow(this.pOverFour, this.p) // XXX: not compatible with all
curves

var y = beta
if (beta.isEven() ^ !isOdd) {
y = this.p.subtract(y) // -y % p
}

return Point.fromAffine(this, x, y)
}

Curve.prototype.isInfinity = function (Q) {

if (Q === this.infinity) return true
 return Q.z.signum() === 0 && Q.y.signum() !== 0
}

Curve.prototype.isOnCurve = function (Q) {

if (this.isInfinity(Q)) return true

var x = Q.affineX
var y = Q.affineY
var a = this.a
var b = this.b
var p = this.p

// Check that xQ and yQ are integers in the interval [0, p - 1]

if (x.signum() < 0 || x.compareTo(p) >= 0) return false
if (y.signum() < 0 || y.compareTo(p) >= 0) return false

// and check that y^2 = x^3 + ax + b (mod p)

var lhs = y.square().mod(p)
var rhs = x.pow(3).add(a.multiply(x)).add(b).mod(p)
return lhs.equals(rhs)
}

/**
* Validate an elliptic curve point.
*
* See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive
*/
Curve.prototype.validate = function (Q) {
// Check Q != O
assert(!this.isInfinity(Q), 'Point is at infinity')
assert(this.isOnCurve(Q), 'Point is not on the curve')

// Check nQ = O (where Q is a scalar multiple of G)

var nQ = Q.multiply(this.n)
assert(this.isInfinity(nQ), 'Point is not a scalar multiple of G')

return true
}

module.exports = Curve

},{"./point":22,"assert":82,"bigi":5}],19:[function(require,module,exports){
module.exports={
"secp128r1": {
"p": "fffffffdffffffffffffffffffffffff",
"a": "fffffffdfffffffffffffffffffffffc",
"b": "e87579c11079f43dd824993c2cee5ed3",
"n": "fffffffe0000000075a30d1b9038a115",
"h": "01",
"Gx": "161ff7528b899b2d0c28607ca52c5b86",
"Gy": "cf5ac8395bafeb13c02da292dded7a83"
},
"secp160k1": {
"p": "fffffffffffffffffffffffffffffffeffffac73",
"a": "00",
"b": "07",
"n": "0100000000000000000001b8fa16dfab9aca16b6b3",
"h": "01",
 "Gx": "3b4c382ce37aa192a4019e763036f4f5dd4d7ebb",
"Gy": "938cf935318fdced6bc28286531733c3f03c4fee"
},
"secp160r1": {
"p": "ffffffffffffffffffffffffffffffff7fffffff",
"a": "ffffffffffffffffffffffffffffffff7ffffffc",
"b": "1c97befc54bd7a8b65acf89f81d4d4adc565fa45",
"n": "0100000000000000000001f4c8f927aed3ca752257",
"h": "01",
"Gx": "4a96b5688ef573284664698968c38bb913cbfc82",
"Gy": "23a628553168947d59dcc912042351377ac5fb32"
},
"secp192k1": {
"p": "fffffffffffffffffffffffffffffffffffffffeffffee37",
"a": "00",
"b": "03",
"n": "fffffffffffffffffffffffe26f2fc170f69466a74defd8d",
"h": "01",
"Gx": "db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d",
"Gy": "9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d"
},
"secp192r1": {
"p": "fffffffffffffffffffffffffffffffeffffffffffffffff",
"a": "fffffffffffffffffffffffffffffffefffffffffffffffc",
"b": "64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
"n": "ffffffffffffffffffffffff99def836146bc9b1b4d22831",
"h": "01",
"Gx": "188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
"Gy": "07192b95ffc8da78631011ed6b24cdd573f977a11e794811"
},
"secp256k1": {
"p": "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
"a": "00",
"b": "07",
"n": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
"h": "01",
"Gx": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"Gy": "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
},
"secp256r1": {
"p": "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
"a": "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
"b": "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
"n": "ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
"h": "01",
"Gx": "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
"Gy": "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"
}
}

},{}],20:[function(require,module,exports){
var Point = require('./point')
var Curve = require('./curve')

var getCurveByName = require('./names')

module.exports = {
Curve: Curve,
Point: Point,
 getCurveByName: getCurveByName
}

},{"./curve":18,"./names":21,"./point":22}],21:[function(require,module,exports){
var BigInteger = require('bigi')

var curves = require('./curves.json')

var Curve = require('./curve')

function getCurveByName (name) {

var curve = curves[name]
if (!curve) return null

var p = new BigInteger(curve.p, 16)

var a = new BigInteger(curve.a, 16)
var b = new BigInteger(curve.b, 16)
var n = new BigInteger(curve.n, 16)
var h = new BigInteger(curve.h, 16)
var Gx = new BigInteger(curve.Gx, 16)
var Gy = new BigInteger(curve.Gy, 16)

return new Curve(p, a, b, Gx, Gy, n, h)

}

module.exports = getCurveByName

},{"./curve":18,"./curves.json":19,"bigi":5}],22:[function(require,module,exports){
var assert = require('assert')
var Buffer = require('safe-buffer').Buffer
var BigInteger = require('bigi')

var THREE = BigInteger.valueOf(3)

function Point (curve, x, y, z) {

assert.notStrictEqual(z, undefined, 'Missing Z coordinate')

this.curve = curve
this.x = x
this.y = y
this.z = z
this._zInv = null

this.compressed = true
}

Object.defineProperty(Point.prototype, 'zInv', {
get: function () {
if (this._zInv === null) {
this._zInv = this.z.modInverse(this.curve.p)
}

return this._zInv
}
})

Object.defineProperty(Point.prototype, 'affineX', {
get: function () {
return this.x.multiply(this.zInv).mod(this.curve.p)
}
})

Object.defineProperty(Point.prototype, 'affineY', {
get: function () {
return this.y.multiply(this.zInv).mod(this.curve.p)
}
})

Point.fromAffine = function (curve, x, y) {

return new Point(curve, x, y, BigInteger.ONE)
}

Point.prototype.equals = function (other) {

if (other === this) return true
if (this.curve.isInfinity(this)) return this.curve.isInfinity(other)
if (this.curve.isInfinity(other)) return this.curve.isInfinity(this)

// u = Y2 * Z1 - Y1 * Z2
var u =
other.y.multiply(this.z).subtract(this.y.multiply(other.z)).mod(this.curve.p)

if (u.signum() !== 0) return false

// v = X2 * Z1 - X1 * Z2
var v =
other.x.multiply(this.z).subtract(this.x.multiply(other.z)).mod(this.curve.p)

return v.signum() === 0

}

Point.prototype.negate = function () {
var y = this.curve.p.subtract(this.y)

return new Point(this.curve, this.x, y, this.z)

}

Point.prototype.add = function (b) {

if (this.curve.isInfinity(this)) return b
if (this.curve.isInfinity(b)) return this

var x1 = this.x
var y1 = this.y
var x2 = b.x
var y2 = b.y

// u = Y2 * Z1 - Y1 * Z2
var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.p)
// v = X2 * Z1 - X1 * Z2
var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.p)

if (v.signum() === 0) {
if (u.signum() === 0) {
return this.twice() // this == b, so double
}

return this.curve.infinity // this = -b, so infinity

}

var v2 = v.square()
 var v3 = v2.multiply(v)
var x1v2 = x1.multiply(v2)
var zu2 = u.square().multiply(this.z)

// x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)

var x3 =
zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.cur
ve.p)
// y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
var y3 =
x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)
).multiply(b.z).add(u.multiply(v3)).mod(this.curve.p)
// z3 = v^3 * z1 * z2
var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.p)

return new Point(this.curve, x3, y3, z3)

}

Point.prototype.twice = function () {
if (this.curve.isInfinity(this)) return this
if (this.y.signum() === 0) return this.curve.infinity

var x1 = this.x
var y1 = this.y

var y1z1 = y1.multiply(this.z).mod(this.curve.p)

var y1sqz1 = y1z1.multiply(y1).mod(this.curve.p)
var a = this.curve.a

// w = 3 * x1^2 + a * z1^2
var w = x1.square().multiply(THREE)

if (a.signum() !== 0) {
w = w.add(this.z.square().multiply(a))
}

w = w.mod(this.curve.p)
// x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
var x3 =
w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).m
od(this.curve.p)
// y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
var y3 =
w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(
y1sqz1).subtract(w.pow(3)).mod(this.curve.p)
// z3 = 8 * (y1 * z1)^3
var z3 = y1z1.pow(3).shiftLeft(3).mod(this.curve.p)

return new Point(this.curve, x3, y3, z3)

}

// Simple NAF (Non-Adjacent Form) multiplication algorithm

// TODO: modularize the multiplication algorithm
Point.prototype.multiply = function (k) {
if (this.curve.isInfinity(this)) return this
if (k.signum() === 0) return this.curve.infinity

var e = k
var h = e.multiply(THREE)
 var neg = this.negate()
var R = this

for (var i = h.bitLength() - 2; i > 0; --i) {

var hBit = h.testBit(i)
var eBit = e.testBit(i)

R = R.twice()

if (hBit !== eBit) {

R = R.add(hBit ? this : neg)
}
}

return R
}

// Compute this*j + x*k (simultaneous multiplication)

Point.prototype.multiplyTwo = function (j, x, k) {
var i = Math.max(j.bitLength(), k.bitLength()) - 1
var R = this.curve.infinity
var both = this.add(x)

while (i >= 0) {
var jBit = j.testBit(i)
var kBit = k.testBit(i)

R = R.twice()

if (jBit) {
if (kBit) {
R = R.add(both)
} else {
R = R.add(this)
}
} else if (kBit) {
R = R.add(x)
}
--i
}

return R
}

Point.prototype.getEncoded = function (compressed) {

if (compressed == null) compressed = this.compressed
if (this.curve.isInfinity(this)) return Buffer.alloc(1, 0) // Infinity point
encoded is simply '00'

var x = this.affineX
var y = this.affineY
var byteLength = this.curve.pLength
var buffer

// 0x02/0x03 | X
if (compressed) {
buffer = Buffer.allocUnsafe(1 + byteLength)
buffer.writeUInt8(y.isEven() ? 0x02 : 0x03, 0)
 // 0x04 | X | Y
} else {
buffer = Buffer.allocUnsafe(1 + byteLength + byteLength)
buffer.writeUInt8(0x04, 0)

y.toBuffer(byteLength).copy(buffer, 1 + byteLength)
}

x.toBuffer(byteLength).copy(buffer, 1)

return buffer
}

Point.decodeFrom = function (curve, buffer) {

var type = buffer.readUInt8(0)
var compressed = (type !== 4)

var byteLength = Math.floor((curve.p.bitLength() + 7) / 8)

var x = BigInteger.fromBuffer(buffer.slice(1, 1 + byteLength))

var Q
if (compressed) {
assert.equal(buffer.length, byteLength + 1, 'Invalid sequence length')
assert(type === 0x02 || type === 0x03, 'Invalid sequence tag')

var isOdd = (type === 0x03)

Q = curve.pointFromX(isOdd, x)
} else {
assert.equal(buffer.length, 1 + byteLength + byteLength, 'Invalid sequence
length')

var y = BigInteger.fromBuffer(buffer.slice(1 + byteLength))

Q = Point.fromAffine(curve, x, y)
}

Q.compressed = compressed
return Q
}

Point.prototype.toString = function () {
if (this.curve.isInfinity(this)) return '(INFINITY)'

return '(' + this.affineX.toString() + ',' + this.affineY.toString() + ')'

}

module.exports = Point

},{"assert":82,"bigi":5,"safe-buffer":30}],23:[function(require,module,exports){
'use strict'
var Buffer = require('safe-buffer').Buffer
var Transform = require('stream').Transform
var inherits = require('inherits')

function throwIfNotStringOrBuffer (val, prefix) {

if (!Buffer.isBuffer(val) && typeof val !== 'string') {
throw new TypeError(prefix + ' must be a string or a buffer')
}
}
function HashBase (blockSize) {
Transform.call(this)

this._block = Buffer.allocUnsafe(blockSize)
this._blockSize = blockSize
this._blockOffset = 0
this._length = [0, 0, 0, 0]

this._finalized = false
}

inherits(HashBase, Transform)

HashBase.prototype._transform = function (chunk, encoding, callback) {

var error = null
try {
this.update(chunk, encoding)
} catch (err) {
error = err
}

callback(error)
}

HashBase.prototype._flush = function (callback) {

var error = null
try {
this.push(this.digest())
} catch (err) {
error = err
}

callback(error)
}

HashBase.prototype.update = function (data, encoding) {

throwIfNotStringOrBuffer(data, 'Data')
if (this._finalized) throw new Error('Digest already called')
if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)

// consume data
var block = this._block
var offset = 0
while (this._blockOffset + data.length - offset >= this._blockSize) {
for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset+
+]
this._update()
this._blockOffset = 0
}
while (offset < data.length) block[this._blockOffset++] = data[offset++]

// update length
for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
this._length[j] += carry
carry = (this._length[j] / 0x0100000000) | 0
if (carry > 0) this._length[j] -= 0x0100000000 * carry
}
 return this
}

HashBase.prototype._update = function () {
throw new Error('_update is not implemented')
}

HashBase.prototype.digest = function (encoding) {

if (this._finalized) throw new Error('Digest already called')
this._finalized = true

var digest = this._digest()

if (encoding !== undefined) digest = digest.toString(encoding)

// reset state
this._block.fill(0)
this._blockOffset = 0
for (var i = 0; i < 4; ++i) this._length[i] = 0

return digest
}

HashBase.prototype._digest = function () {
throw new Error('_digest is not implemented')
}

module.exports = HashBase

},{"inherits":24,"safe-buffer":30,"stream":103}],24:
[function(require,module,exports){
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}

},{}],25:[function(require,module,exports){
(function (Buffer){
'use strict'
var inherits = require('inherits')
var HashBase = require('hash-base')
var ARRAY16 = new Array(16)

function MD5 () {
HashBase.call(this, 64)

// state
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
}

inherits(MD5, HashBase)

MD5.prototype._update = function () {
var M = ARRAY16
for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)

var a = this._a
var b = this._b
var c = this._c
var d = this._d

a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)

d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)
c = fnF(c, d, a, b, M[2], 0x242070db, 17)
b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)
a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)
d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)
c = fnF(c, d, a, b, M[6], 0xa8304613, 17)
b = fnF(b, c, d, a, M[7], 0xfd469501, 22)
a = fnF(a, b, c, d, M[8], 0x698098d8, 7)
d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)
c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)
b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)
a = fnF(a, b, c, d, M[12], 0x6b901122, 7)
d = fnF(d, a, b, c, M[13], 0xfd987193, 12)
c = fnF(c, d, a, b, M[14], 0xa679438e, 17)
b = fnF(b, c, d, a, M[15], 0x49b40821, 22)

a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)

d = fnG(d, a, b, c, M[6], 0xc040b340, 9)
c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)
b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)
a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)
d = fnG(d, a, b, c, M[10], 0x02441453, 9)
c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)
b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)
a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)
d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)
c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)
b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)
a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)
d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)
c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)
b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)

a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)

 d = fnH(d, a, b, c, M[8], 0x8771f681, 11)
c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)
b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)
a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)
d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)
c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)
b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)
a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)
d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)
c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)
b = fnH(b, c, d, a, M[6], 0x04881d05, 23)
a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)
d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)
c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)
b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)

a = fnI(a, b, c, d, M[0], 0xf4292244, 6)

d = fnI(d, a, b, c, M[7], 0x432aff97, 10)
c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)
b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)
a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)
d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)
c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)
b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)
a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)
d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)
c = fnI(c, d, a, b, M[6], 0xa3014314, 15)
b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)
a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)
d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)
c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)
b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)

this._a = (this._a + a) | 0
this._b = (this._b + b) | 0
this._c = (this._c + c) | 0
this._d = (this._d + d) | 0
}

MD5.prototype._digest = function () {
// create padding and handle blocks
this._block[this._blockOffset++] = 0x80
if (this._blockOffset > 56) {
this._block.fill(0, this._blockOffset, 64)
this._update()
this._blockOffset = 0
}

this._block.fill(0, this._blockOffset, 56)

this._block.writeUInt32LE(this._length[0], 56)
this._block.writeUInt32LE(this._length[1], 60)
this._update()

// produce result
var buffer = new Buffer(16)
buffer.writeInt32LE(this._a, 0)
buffer.writeInt32LE(this._b, 4)
buffer.writeInt32LE(this._c, 8)
buffer.writeInt32LE(this._d, 12)
 return buffer
}

function rotl (x, n) {

return (x << n) | (x >>> (32 - n))
}

function fnF (a, b, c, d, m, k, s) {

return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0
}

function fnG (a, b, c, d, m, k, s) {

return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0
}

function fnH (a, b, c, d, m, k, s) {

return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0
}

function fnI (a, b, c, d, m, k, s) {

return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0
}

module.exports = MD5

}).call(this,require("buffer").Buffer)
},{"buffer":84,"hash-base":23,"inherits":24}],26:[function(require,module,exports){
(function (Buffer){
// constant-space merkle root calculation algorithm
module.exports = function fastRoot (values, digestFn) {
if (!Array.isArray(values)) throw TypeError('Expected values Array')
if (typeof digestFn !== 'function') throw TypeError('Expected digest Function')

var length = values.length

var results = values.concat()

while (length > 1) {

var j = 0

for (var i = 0; i < length; i += 2, ++j) {

var left = results[i]
var right = i + 1 === length ? left : results[i + 1]
var data = Buffer.concat([left, right])

results[j] = digestFn(data)
}

length = j
}

return results[0]
}

}).call(this,require("buffer").Buffer)
},{"buffer":84}],27:[function(require,module,exports){
var OPS = require('bitcoin-ops')

function encodingLength (i) {

return i < OPS.OP_PUSHDATA1 ? 1
 : i <= 0xff ? 2
: i <= 0xffff ? 3
: 5
}

function encode (buffer, number, offset) {

var size = encodingLength(number)

// ~6 bit
if (size === 1) {
buffer.writeUInt8(number, offset)

// 8 bit
} else if (size === 2) {
buffer.writeUInt8(OPS.OP_PUSHDATA1, offset)
buffer.writeUInt8(number, offset + 1)

// 16 bit
} else if (size === 3) {
buffer.writeUInt8(OPS.OP_PUSHDATA2, offset)
buffer.writeUInt16LE(number, offset + 1)

// 32 bit
} else {
buffer.writeUInt8(OPS.OP_PUSHDATA4, offset)
buffer.writeUInt32LE(number, offset + 1)
}

return size
}

function decode (buffer, offset) {

var opcode = buffer.readUInt8(offset)
var number, size

// ~6 bit
if (opcode < OPS.OP_PUSHDATA1) {
number = opcode
size = 1

// 8 bit
} else if (opcode === OPS.OP_PUSHDATA1) {
if (offset + 2 > buffer.length) return null
number = buffer.readUInt8(offset + 1)
size = 2

// 16 bit
} else if (opcode === OPS.OP_PUSHDATA2) {
if (offset + 3 > buffer.length) return null
number = buffer.readUInt16LE(offset + 1)
size = 3

// 32 bit
} else {
if (offset + 5 > buffer.length) return null
if (opcode !== OPS.OP_PUSHDATA4) throw new Error('Unexpected opcode')

number = buffer.readUInt32LE(offset + 1)
size = 5
 }

return {
opcode: opcode,
number: number,
size: size
}
}

module.exports = {
encodingLength: encodingLength,
encode: encode,
decode: decode
}

},{"bitcoin-ops":8}],28:[function(require,module,exports){
(function (process,global){
'use strict'

function oldBrowser () {
throw new Error('Secure random number generation is not supported by this
browser.\nUse Chrome, Firefox or Internet Explorer 11')
}

var Buffer = require('safe-buffer').Buffer

var crypto = global.crypto || global.msCrypto

if (crypto && crypto.getRandomValues) {

module.exports = randomBytes
} else {
module.exports = oldBrowser
}

function randomBytes (size, cb) {

// phantomjs needs to throw
if (size > 65536) throw new Error('requested too many random bytes')
// in case browserify isn't using the Uint8Array version
var rawBytes = new global.Uint8Array(size)

// This will not work in older browsers.

// See
https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
if (size > 0) { // getRandomValues fails on IE if size == 0
crypto.getRandomValues(rawBytes)
}

// XXX: phantomjs doesn't like a buffer being passed here

var bytes = Buffer.from(rawBytes.buffer)

if (typeof cb === 'function') {

return process.nextTick(function () {
cb(null, bytes)
})
}

return bytes
}

}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof

self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"_process":91,"safe-buffer":30}],29:[function(require,module,exports){
'use strict'
var Buffer = require('buffer').Buffer
var inherits = require('inherits')
var HashBase = require('hash-base')

var ARRAY16 = new Array(16)

var zl = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
]

var zr = [
5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
]

var sl = [
11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
]

var sr = [
8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
]

var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]

var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]

function RIPEMD160 () {
HashBase.call(this, 64)

// state
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0
}

inherits(RIPEMD160, HashBase)

RIPEMD160.prototype._update = function () {
var words = ARRAY16
 for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)

var al = this._a | 0
var bl = this._b | 0
var cl = this._c | 0
var dl = this._d | 0
var el = this._e | 0

var ar = this._a | 0
var br = this._b | 0
var cr = this._c | 0
var dr = this._d | 0
var er = this._e | 0

// computation
for (var i = 0; i < 80; i += 1) {
var tl
var tr
if (i < 16) {
tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])
tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])
} else if (i < 32) {
tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])
tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])
} else if (i < 48) {
tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])
tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])
} else if (i < 64) {
tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])
tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])
} else { // if (i<80) {
tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])
tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])
}

al = el
el = dl
dl = rotl(cl, 10)
cl = bl
bl = tl

ar = er
er = dr
dr = rotl(cr, 10)
cr = br
br = tr
}

// update state
var t = (this._b + cl + dr) | 0
this._b = (this._c + dl + er) | 0
this._c = (this._d + el + ar) | 0
this._d = (this._e + al + br) | 0
this._e = (this._a + bl + cr) | 0
this._a = t
}

RIPEMD160.prototype._digest = function () {
// create padding and handle blocks
 this._block[this._blockOffset++] = 0x80
if (this._blockOffset > 56) {
this._block.fill(0, this._blockOffset, 64)
this._update()
this._blockOffset = 0
}

this._block.fill(0, this._blockOffset, 56)

this._block.writeUInt32LE(this._length[0], 56)
this._block.writeUInt32LE(this._length[1], 60)
this._update()

// produce result
var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)
buffer.writeInt32LE(this._a, 0)
buffer.writeInt32LE(this._b, 4)
buffer.writeInt32LE(this._c, 8)
buffer.writeInt32LE(this._d, 12)
buffer.writeInt32LE(this._e, 16)
return buffer
}

function rotl (x, n) {

return (x << n) | (x >>> (32 - n))
}

function fn1 (a, b, c, d, e, m, k, s) {

return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
}

function fn2 (a, b, c, d, e, m, k, s) {

return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
}

function fn3 (a, b, c, d, e, m, k, s) {

return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
}

function fn4 (a, b, c, d, e, m, k, s) {

return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
}

function fn5 (a, b, c, d, e, m, k, s) {

return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
}

module.exports = RIPEMD160

},{"buffer":84,"hash-base":23,"inherits":24}],30:[function(require,module,exports){
/* eslint-disable node/no-deprecated-api */
var buffer = require('buffer')
var Buffer = buffer.Buffer

// alternative to using Object.keys for old browsers

function copyProps (src, dst) {
for (var key in src) {
dst[key] = src[key]
}
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
module.exports = buffer
} else {
// Copy properties from require('buffer')
copyProps(buffer, exports)
exports.Buffer = SafeBuffer
}

function SafeBuffer (arg, encodingOrOffset, length) {

return Buffer(arg, encodingOrOffset, length)
}

// Copy static methods from Buffer

copyProps(Buffer, SafeBuffer)

SafeBuffer.from = function (arg, encodingOrOffset, length) {

if (typeof arg === 'number') {
throw new TypeError('Argument must not be a number')
}
return Buffer(arg, encodingOrOffset, length)
}

SafeBuffer.alloc = function (size, fill, encoding) {

if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
var buf = Buffer(size)
if (fill !== undefined) {
if (typeof encoding === 'string') {
buf.fill(fill, encoding)
} else {
buf.fill(fill)
}
} else {
buf.fill(0)
}
return buf
}

SafeBuffer.allocUnsafe = function (size) {

if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return Buffer(size)
}

SafeBuffer.allocUnsafeSlow = function (size) {

if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return buffer.SlowBuffer(size)
}

},{"buffer":84}],31:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer

// prototype class for hash functions

function Hash (blockSize, finalSize) {
this._block = Buffer.alloc(blockSize)
 this._finalSize = finalSize
this._blockSize = blockSize
this._len = 0
}

Hash.prototype.update = function (data, enc) {

if (typeof data === 'string') {
enc = enc || 'utf8'
data = Buffer.from(data, enc)
}

var block = this._block

var blockSize = this._blockSize
var length = data.length
var accum = this._len

for (var offset = 0; offset < length;) {

var assigned = accum % blockSize
var remainder = Math.min(length - offset, blockSize - assigned)

for (var i = 0; i < remainder; i++) {

block[assigned + i] = data[offset + i]
}

accum += remainder
offset += remainder

if ((accum % blockSize) === 0) {

this._update(block)
}
}

this._len += length
return this
}

Hash.prototype.digest = function (enc) {

var rem = this._len % this._blockSize

this._block[rem] = 0x80

// zero (rem + 1) trailing bits, where (rem + 1) is the smallest

// non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize
mod blockSize
this._block.fill(0, rem + 1)

if (rem >= this._finalSize) {

this._update(this._block)
this._block.fill(0)
}

var bits = this._len * 8

// uint32
if (bits <= 0xffffffff) {
this._block.writeUInt32BE(bits, this._blockSize - 4)

// uint64
} else {
 var lowBits = (bits & 0xffffffff) >>> 0
var highBits = (bits - lowBits) / 0x100000000

this._block.writeUInt32BE(highBits, this._blockSize - 8)
this._block.writeUInt32BE(lowBits, this._blockSize - 4)
}

this._update(this._block)
var hash = this._hash()

return enc ? hash.toString(enc) : hash

}

Hash.prototype._update = function () {
throw new Error('_update must be implemented by subclass')
}

module.exports = Hash

},{"safe-buffer":30}],32:[function(require,module,exports){
var exports = module.exports = function SHA (algorithm) {
algorithm = algorithm.toLowerCase()

var Algorithm = exports[algorithm]

if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull
requests)')

return new Algorithm()

}

exports.sha = require('./sha')
exports.sha1 = require('./sha1')
exports.sha224 = require('./sha224')
exports.sha256 = require('./sha256')
exports.sha384 = require('./sha384')
exports.sha512 = require('./sha512')

},{"./sha":33,"./sha1":34,"./sha224":35,"./sha256":36,"./sha384":37,"./
sha512":38}],33:[function(require,module,exports){
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
* in FIPS PUB 180-1
* This source code is derived from sha1.js of the same repository.
* The difference between SHA-0 and SHA-1 is just a bitwise rotate left
* operation was added.
*/

var inherits = require('inherits')

var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
]

var W = new Array(80)

function Sha () {
this.init()
 this._w = W

Hash.call(this, 64, 56)

}

inherits(Sha, Hash)

Sha.prototype.init = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0

return this
}

function rotl5 (num) {

return (num << 5) | (num >>> 27)
}

function rotl30 (num) {

return (num << 30) | (num >>> 2)
}

function ft (s, b, c, d) {
if (s === 0) return (b & c) | ((~b) & d)
if (s === 2) return (b & c) | (b & d) | (c & d)
return b ^ c ^ d
}

Sha.prototype._update = function (M) {

var W = this._w

var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0

for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)

for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]

for (var j = 0; j < 80; ++j) {

var s = ~~(j / 20)
var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0

e = d
d = c
c = rotl30(b)
b = a
a = t
}

this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
}

Sha.prototype._hash = function () {
var H = Buffer.allocUnsafe(20)

H.writeInt32BE(this._a | 0, 0)
H.writeInt32BE(this._b | 0, 4)
H.writeInt32BE(this._c | 0, 8)
H.writeInt32BE(this._d | 0, 12)
H.writeInt32BE(this._e | 0, 16)

return H
}

module.exports = Sha

},{"./hash":31,"inherits":24,"safe-buffer":30}],34:
[function(require,module,exports){
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
* in FIPS PUB 180-1
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for details.
*/

var inherits = require('inherits')

var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
]

var W = new Array(80)

function Sha1 () {
this.init()
this._w = W

Hash.call(this, 64, 56)

}

inherits(Sha1, Hash)

Sha1.prototype.init = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0

return this
}

function rotl1 (num) {

return (num << 1) | (num >>> 31)
}
function rotl5 (num) {
return (num << 5) | (num >>> 27)
}

function rotl30 (num) {

return (num << 30) | (num >>> 2)
}

function ft (s, b, c, d) {
if (s === 0) return (b & c) | ((~b) & d)
if (s === 2) return (b & c) | (b & d) | (c & d)
return b ^ c ^ d
}

Sha1.prototype._update = function (M) {

var W = this._w

var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0

for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)

for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])

for (var j = 0; j < 80; ++j) {

var s = ~~(j / 20)
var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0

e = d
d = c
c = rotl30(b)
b = a
a = t
}

this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
}

Sha1.prototype._hash = function () {
var H = Buffer.allocUnsafe(20)

H.writeInt32BE(this._a | 0, 0)
H.writeInt32BE(this._b | 0, 4)
H.writeInt32BE(this._c | 0, 8)
H.writeInt32BE(this._d | 0, 12)
H.writeInt32BE(this._e | 0, 16)

return H
}

module.exports = Sha1
},{"./hash":31,"inherits":24,"safe-buffer":30}],35:
[function(require,module,exports){
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/

var inherits = require('inherits')

var Sha256 = require('./sha256')
var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var W = new Array(64)

function Sha224 () {
this.init()

this._w = W // new Array(64)

Hash.call(this, 64, 56)

}

inherits(Sha224, Sha256)

Sha224.prototype.init = function () {
this._a = 0xc1059ed8
this._b = 0x367cd507
this._c = 0x3070dd17
this._d = 0xf70e5939
this._e = 0xffc00b31
this._f = 0x68581511
this._g = 0x64f98fa7
this._h = 0xbefa4fa4

return this
}

Sha224.prototype._hash = function () {
var H = Buffer.allocUnsafe(28)

H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)

return H
}

module.exports = Sha224

},{"./hash":31,"./sha256":36,"inherits":24,"safe-buffer":30}],36:
[function(require,module,exports){
/**
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/

var inherits = require('inherits')

var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
]

var W = new Array(64)

function Sha256 () {
this.init()

this._w = W // new Array(64)

Hash.call(this, 64, 56)

}

inherits(Sha256, Hash)

Sha256.prototype.init = function () {
this._a = 0x6a09e667
this._b = 0xbb67ae85
this._c = 0x3c6ef372
this._d = 0xa54ff53a
this._e = 0x510e527f
this._f = 0x9b05688c
this._g = 0x1f83d9ab
this._h = 0x5be0cd19

return this
}

function ch (x, y, z) {
return z ^ (x & (y ^ z))
}
function maj (x, y, z) {
return (x & y) | (z & (x | y))
}

function sigma0 (x) {

return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)
}

function sigma1 (x) {

return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)
}

function gamma0 (x) {

return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)
}

function gamma1 (x) {

return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)
}

Sha256.prototype._update = function (M) {

var W = this._w

var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0
var f = this._f | 0
var g = this._g | 0
var h = this._h | 0

for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)

for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i
- 16]) | 0

for (var j = 0; j < 64; ++j) {

var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0
var T2 = (sigma0(a) + maj(a, b, c)) | 0

h = g
g = f
f = e
e = (d + T1) | 0
d = c
c = b
b = a
a = (T1 + T2) | 0
}

this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
this._f = (f + this._f) | 0
this._g = (g + this._g) | 0
this._h = (h + this._h) | 0
}
Sha256.prototype._hash = function () {
var H = Buffer.allocUnsafe(32)

H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)
H.writeInt32BE(this._h, 28)

return H
}

module.exports = Sha256

},{"./hash":31,"inherits":24,"safe-buffer":30}],37:
[function(require,module,exports){
var inherits = require('inherits')
var SHA512 = require('./sha512')
var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var W = new Array(160)

function Sha384 () {
this.init()
this._w = W

Hash.call(this, 128, 112)

}

inherits(Sha384, SHA512)

Sha384.prototype.init = function () {
this._ah = 0xcbbb9d5d
this._bh = 0x629a292a
this._ch = 0x9159015a
this._dh = 0x152fecd8
this._eh = 0x67332667
this._fh = 0x8eb44a87
this._gh = 0xdb0c2e0d
this._hh = 0x47b5481d

this._al = 0xc1059ed8
this._bl = 0x367cd507
this._cl = 0x3070dd17
this._dl = 0xf70e5939
this._el = 0xffc00b31
this._fl = 0x68581511
this._gl = 0x64f98fa7
this._hl = 0xbefa4fa4

return this
}

Sha384.prototype._hash = function () {
 var H = Buffer.allocUnsafe(48)

function writeInt64BE (h, l, offset) {

H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}

writeInt64BE(this._ah, this._al, 0)
writeInt64BE(this._bh, this._bl, 8)
writeInt64BE(this._ch, this._cl, 16)
writeInt64BE(this._dh, this._dl, 24)
writeInt64BE(this._eh, this._el, 32)
writeInt64BE(this._fh, this._fl, 40)

return H
}

module.exports = Sha384

},{"./hash":31,"./sha512":38,"inherits":24,"safe-buffer":30}],38:
[function(require,module,exports){
var inherits = require('inherits')
var Hash = require('./hash')
var Buffer = require('safe-buffer').Buffer

var K = [
0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
]

var W = new Array(160)

function Sha512 () {
this.init()
this._w = W

Hash.call(this, 128, 112)

}

inherits(Sha512, Hash)

Sha512.prototype.init = function () {
this._ah = 0x6a09e667
this._bh = 0xbb67ae85
this._ch = 0x3c6ef372
this._dh = 0xa54ff53a
this._eh = 0x510e527f
this._fh = 0x9b05688c
this._gh = 0x1f83d9ab
this._hh = 0x5be0cd19

this._al = 0xf3bcc908
this._bl = 0x84caa73b
this._cl = 0xfe94f82b
this._dl = 0x5f1d36f1
this._el = 0xade682d1
this._fl = 0x2b3e6c1f
this._gl = 0xfb41bd6b
this._hl = 0x137e2179

return this
}

function Ch (x, y, z) {
return z ^ (x & (y ^ z))
}

function maj (x, y, z) {

return (x & y) | (z & (x | y))
}

function sigma0 (x, xl) {

return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)
}

function sigma1 (x, xl) {

return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)
}

function Gamma0 (x, xl) {

 return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)
}

function Gamma0l (x, xl) {

return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)
}

function Gamma1 (x, xl) {

return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)
}

function Gamma1l (x, xl) {

return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)
}

function getCarry (a, b) {

return (a >>> 0) < (b >>> 0) ? 1 : 0
}

Sha512.prototype._update = function (M) {

var W = this._w

var ah = this._ah | 0
var bh = this._bh | 0
var ch = this._ch | 0
var dh = this._dh | 0
var eh = this._eh | 0
var fh = this._fh | 0
var gh = this._gh | 0
var hh = this._hh | 0

var al = this._al | 0
var bl = this._bl | 0
var cl = this._cl | 0
var dl = this._dl | 0
var el = this._el | 0
var fl = this._fl | 0
var gl = this._gl | 0
var hl = this._hl | 0

for (var i = 0; i < 32; i += 2) {

W[i] = M.readInt32BE(i * 4)
W[i + 1] = M.readInt32BE(i * 4 + 4)
}
for (; i < 160; i += 2) {
var xh = W[i - 15 * 2]
var xl = W[i - 15 * 2 + 1]
var gamma0 = Gamma0(xh, xl)
var gamma0l = Gamma0l(xl, xh)

xh = W[i - 2 * 2]
xl = W[i - 2 * 2 + 1]
var gamma1 = Gamma1(xh, xl)
var gamma1l = Gamma1l(xl, xh)

// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]

var Wi7h = W[i - 7 * 2]
var Wi7l = W[i - 7 * 2 + 1]
 var Wi16h = W[i - 16 * 2]
var Wi16l = W[i - 16 * 2 + 1]

var Wil = (gamma0l + Wi7l) | 0

var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0
Wil = (Wil + gamma1l) | 0
Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0
Wil = (Wil + Wi16l) | 0
Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0

W[i] = Wih
W[i + 1] = Wil
}

for (var j = 0; j < 160; j += 2) {

Wih = W[j]
Wil = W[j + 1]

var majh = maj(ah, bh, ch)

var majl = maj(al, bl, cl)

var sigma0h = sigma0(ah, al)

var sigma0l = sigma0(al, ah)
var sigma1h = sigma1(eh, el)
var sigma1l = sigma1(el, eh)

// t1 = h + sigma1 + ch + K[j] + W[j]

var Kih = K[j]
var Kil = K[j + 1]

var chh = Ch(eh, fh, gh)

var chl = Ch(el, fl, gl)

var t1l = (hl + sigma1l) | 0

var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0
t1l = (t1l + chl) | 0
t1h = (t1h + chh + getCarry(t1l, chl)) | 0
t1l = (t1l + Kil) | 0
t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0
t1l = (t1l + Wil) | 0
t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0

// t2 = sigma0 + maj
var t2l = (sigma0l + majl) | 0
var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0

hh = gh
hl = gl
gh = fh
gl = fl
fh = eh
fl = el
el = (dl + t1l) | 0
eh = (dh + t1h + getCarry(el, dl)) | 0
dh = ch
dl = cl
ch = bh
cl = bl
bh = ah
 bl = al
al = (t1l + t2l) | 0
ah = (t1h + t2h + getCarry(al, t1l)) | 0
}

this._al = (this._al + al) | 0

this._bl = (this._bl + bl) | 0
this._cl = (this._cl + cl) | 0
this._dl = (this._dl + dl) | 0
this._el = (this._el + el) | 0
this._fl = (this._fl + fl) | 0
this._gl = (this._gl + gl) | 0
this._hl = (this._hl + hl) | 0

this._ah = (this._ah + ah + getCarry(this._al, al)) | 0

this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0
this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0
this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0
this._eh = (this._eh + eh + getCarry(this._el, el)) | 0
this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0
this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0
this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0
}

Sha512.prototype._hash = function () {
var H = Buffer.allocUnsafe(64)

function writeInt64BE (h, l, offset) {

H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}

writeInt64BE(this._ah, this._al, 0)
writeInt64BE(this._bh, this._bl, 8)
writeInt64BE(this._ch, this._cl, 16)
writeInt64BE(this._dh, this._dl, 24)
writeInt64BE(this._eh, this._el, 32)
writeInt64BE(this._fh, this._fl, 40)
writeInt64BE(this._gh, this._gl, 48)
writeInt64BE(this._hh, this._hl, 56)

return H
}

module.exports = Sha512

},{"./hash":31,"inherits":24,"safe-buffer":30}],39:
[function(require,module,exports){
var native = require('./native')

function getTypeName (fn) {

return fn.name || fn.toString().match(/function (.*?)\s*\(/)[1]
}

function getValueTypeName (value) {

return native.Nil(value) ? '' : getTypeName(value.constructor)
}

function getValue (value) {

 if (native.Function(value)) return ''
if (native.String(value)) return JSON.stringify(value)
if (value && native.Object(value)) return ''
return value
}

function tfJSON (type) {

if (native.Function(type)) return type.toJSON ? type.toJSON() : getTypeName(type)
if (native.Array(type)) return 'Array'
if (type && native.Object(type)) return 'Object'

return type !== undefined ? type : ''

}

function tfErrorString (type, value, valueTypeName) {

var valueJson = getValue(value)

return 'Expected ' + tfJSON(type) + ', got' +

(valueTypeName !== '' ? ' ' + valueTypeName : '') +
(valueJson !== '' ? ' ' + valueJson : '')
}

function TfTypeError (type, value, valueTypeName) {

valueTypeName = valueTypeName || getValueTypeName(value)
this.message = tfErrorString(type, value, valueTypeName)

Error.captureStackTrace(this, TfTypeError)
this.__type = type
this.__value = value
this.__valueTypeName = valueTypeName
}

TfTypeError.prototype = Object.create(Error.prototype)
TfTypeError.prototype.constructor = TfTypeError

function tfPropertyErrorString (type, label, name, value, valueTypeName) {

var description = '" of type '
if (label === 'key') description = '" with key type '

return tfErrorString('property "' + tfJSON(name) + description + tfJSON(type),

value, valueTypeName)
}

function TfPropertyTypeError (type, property, label, value, valueTypeName) {

if (type) {
valueTypeName = valueTypeName || getValueTypeName(value)
this.message = tfPropertyErrorString(type, label, property, value,
valueTypeName)
} else {
this.message = 'Unexpected property "' + property + '"'
}

Error.captureStackTrace(this, TfTypeError)
this.__label = label
this.__property = property
this.__type = type
this.__value = value
this.__valueTypeName = valueTypeName
}
TfPropertyTypeError.prototype = Object.create(Error.prototype)
TfPropertyTypeError.prototype.constructor = TfTypeError

function tfCustomError (expected, actual) {

return new TfTypeError(expected, {}, actual)
}

function tfSubError (e, property, label) {

// sub child?
if (e instanceof TfPropertyTypeError) {
property = property + '.' + e.__property

e = new TfPropertyTypeError(
e.__type, property, e.__label, e.__value, e.__valueTypeName
)

// child?
} else if (e instanceof TfTypeError) {
e = new TfPropertyTypeError(
e.__type, property, label, e.__value, e.__valueTypeName
)
}

Error.captureStackTrace(e)
return e
}

module.exports = {
TfTypeError: TfTypeError,
TfPropertyTypeError: TfPropertyTypeError,
tfCustomError: tfCustomError,
tfSubError: tfSubError,
tfJSON: tfJSON,
getValueTypeName: getValueTypeName
}

},{"./native":42}],40:[function(require,module,exports){
(function (Buffer){
var NATIVE = require('./native')
var ERRORS = require('./errors')

function _Buffer (value) {

return Buffer.isBuffer(value)
}

function Hex (value) {

return typeof value === 'string' && /^([0-9a-f]{2})+$/i.test(value)
}

function _LengthN (type, length) {

var name = type.toJSON()

function Length (value) {

if (!type(value)) return false
if (value.length === length) return true

throw ERRORS.tfCustomError(name + '(Length: ' + length + ')', name + '(Length:

' + value.length + ')')
 }
Length.toJSON = function () { return name }

return Length
}

var _ArrayN = _LengthN.bind(null, NATIVE.Array)

var _BufferN = _LengthN.bind(null, _Buffer)
var _HexN = _LengthN.bind(null, Hex)
var _StringN = _LengthN.bind(null, NATIVE.String)

var UINT53_MAX = Math.pow(2, 53) - 1

function Finite (value) {

return typeof value === 'number' && isFinite(value)
}
function Int8 (value) { return ((value << 24) >> 24) === value }
function Int16 (value) { return ((value << 16) >> 16) === value }
function Int32 (value) { return (value | 0) === value }
function UInt8 (value) { return (value & 0xff) === value }
function UInt16 (value) { return (value & 0xffff) === value }
function UInt32 (value) { return (value >>> 0) === value }
function UInt53 (value) {
return typeof value === 'number' &&
value >= 0 &&
value <= UINT53_MAX &&
Math.floor(value) === value
}

var types = {
ArrayN: _ArrayN,
Buffer: _Buffer,
BufferN: _BufferN,
Finite: Finite,
Hex: Hex,
HexN: _HexN,
Int8: Int8,
Int16: Int16,
Int32: Int32,
StringN: _StringN,
UInt8: UInt8,
UInt16: UInt16,
UInt32: UInt32,
UInt53: UInt53
}

for (var typeName in types) {

types[typeName].toJSON = function (t) {
return t
}.bind(null, typeName)
}

module.exports = types

}).call(this,require("buffer").Buffer)
},{"./errors":39,"./native":42,"buffer":84}],41:[function(require,module,exports){
var ERRORS = require('./errors')
var NATIVE = require('./native')
// short-hand
var tfJSON = ERRORS.tfJSON
var TfTypeError = ERRORS.TfTypeError
var TfPropertyTypeError = ERRORS.TfPropertyTypeError
var tfSubError = ERRORS.tfSubError
var getValueTypeName = ERRORS.getValueTypeName

var TYPES = {
arrayOf: function arrayOf (type) {
type = compile(type)

function _arrayOf (array, strict) {

if (!NATIVE.Array(array)) return false
if (NATIVE.Nil(array)) return false

return array.every(function (value, i) {

try {
return typeforce(type, value, strict)
} catch (e) {
throw tfSubError(e, i)
}
})
}
_arrayOf.toJSON = function () { return '[' + tfJSON(type) + ']' }

return _arrayOf
},

maybe: function maybe (type) {

type = compile(type)

function _maybe (value, strict) {

return NATIVE.Nil(value) || type(value, strict, maybe)
}
_maybe.toJSON = function () { return '?' + tfJSON(type) }

return _maybe
},

map: function map (propertyType, propertyKeyType) {

propertyType = compile(propertyType)
if (propertyKeyType) propertyKeyType = compile(propertyKeyType)

function _map (value, strict) {

if (!NATIVE.Object(value)) return false
if (NATIVE.Nil(value)) return false

for (var propertyName in value) {

try {
if (propertyKeyType) {
typeforce(propertyKeyType, propertyName, strict)
}
} catch (e) {
throw tfSubError(e, propertyName, 'key')
}

try {
var propertyValue = value[propertyName]
typeforce(propertyType, propertyValue, strict)
 } catch (e) {
throw tfSubError(e, propertyName)
}
}

return true
}

if (propertyKeyType) {
_map.toJSON = function () {
return '{' + tfJSON(propertyKeyType) + ': ' + tfJSON(propertyType) + '}'
}
} else {
_map.toJSON = function () { return '{' + tfJSON(propertyType) + '}' }
}

return _map
},

object: function object (uncompiled) {

var type = {}

for (var typePropertyName in uncompiled) {

type[typePropertyName] = compile(uncompiled[typePropertyName])
}

function _object (value, strict) {

if (!NATIVE.Object(value)) return false
if (NATIVE.Nil(value)) return false

var propertyName

try {
for (propertyName in type) {
var propertyType = type[propertyName]
var propertyValue = value[propertyName]

typeforce(propertyType, propertyValue, strict)

}
} catch (e) {
throw tfSubError(e, propertyName)
}

if (strict) {
for (propertyName in value) {
if (type[propertyName]) continue

throw new TfPropertyTypeError(undefined, propertyName)

}
}

return true
}
_object.toJSON = function () { return tfJSON(type) }

return _object
},

oneOf: function oneOf () {

 var types = [].slice.call(arguments).map(compile)

function _oneOf (value, strict) {

return types.some(function (type) {
try {
return typeforce(type, value, strict)
} catch (e) {
return false
}
})
}
_oneOf.toJSON = function () { return types.map(tfJSON).join('|') }

return _oneOf
},

quacksLike: function quacksLike (type) {

function _quacksLike (value) {
return type === getValueTypeName(value)
}
_quacksLike.toJSON = function () { return type }

return _quacksLike
},

tuple: function tuple () {

var types = [].slice.call(arguments).map(compile)

function _tuple (values, strict) {

if (NATIVE.Nil(values)) return false
if (NATIVE.Nil(values.length)) return false
if (strict && (values.length !== types.length)) return false

return types.every(function (type, i) {

try {
return typeforce(type, values[i], strict)
} catch (e) {
throw tfSubError(e, i)
}
})
}
_tuple.toJSON = function () { return '(' + types.map(tfJSON).join(', ') + ')' }

return _tuple
},

value: function value (expected) {

function _value (actual) {
return actual === expected
}
_value.toJSON = function () { return expected }

return _value
}
}

function compile (type) {

if (NATIVE.String(type)) {
if (type[0] === '?') return TYPES.maybe(type.slice(1))
 return NATIVE[type] || TYPES.quacksLike(type)
} else if (type && NATIVE.Object(type)) {
if (NATIVE.Array(type)) return TYPES.arrayOf(type[0])

return TYPES.object(type)
} else if (NATIVE.Function(type)) {
return type
}

return TYPES.value(type)
}

function typeforce (type, value, strict, surrogate) {

if (NATIVE.Function(type)) {
if (type(value, strict)) return true

throw new TfTypeError(surrogate || type, value)

}

// JIT
return typeforce(compile(type), value, strict)
}

// assign types to typeforce function

for (var typeName in NATIVE) {
typeforce[typeName] = NATIVE[typeName]
}

for (typeName in TYPES) {

typeforce[typeName] = TYPES[typeName]
}

var EXTRA = require('./extra')

for (typeName in EXTRA) {
typeforce[typeName] = EXTRA[typeName]
}

// async wrapper
function __async (type, value, strict, callback) {
// default to falsy strict if using shorthand overload
if (typeof strict === 'function') return __async(type, value, false, strict)

try {
typeforce(type, value, strict)
} catch (e) {
return callback(e)
}

callback()
}

typeforce.async = __async
typeforce.compile = compile
typeforce.TfTypeError = TfTypeError
typeforce.TfPropertyTypeError = TfPropertyTypeError

module.exports = typeforce
},{"./errors":39,"./extra":40,"./native":42}],42:[function(require,module,exports){
var types = {
Array: function (value) { return value !== null && value !== undefined &&
value.constructor === Array },
Boolean: function (value) { return typeof value === 'boolean' },
Function: function (value) { return typeof value === 'function' },
Nil: function (value) { return value === undefined || value === null },
Number: function (value) { return typeof value === 'number' },
Object: function (value) { return typeof value === 'object' },
String: function (value) { return typeof value === 'string' },
'': function () { return true }
}

// TODO: deprecate
types.Null = types.Nil

for (var typeName in types) {

types[typeName].toJSON = function (t) {
return t
}.bind(null, typeName)
}

module.exports = types

},{}],43:[function(require,module,exports){
'use strict'
var Buffer = require('safe-buffer').Buffer

// Number.MAX_SAFE_INTEGER
var MAX_SAFE_INTEGER = 9007199254740991

function checkUInt53 (n) {

if (n < 0 || n > MAX_SAFE_INTEGER || n % 1 !== 0) throw new RangeError('value out
of range')
}

function encode (number, buffer, offset) {

checkUInt53(number)

if (!buffer) buffer = Buffer.allocUnsafe(encodingLength(number))

if (!Buffer.isBuffer(buffer)) throw new TypeError('buffer must be a Buffer
instance')
if (!offset) offset = 0

// 8 bit
if (number < 0xfd) {
buffer.writeUInt8(number, offset)
encode.bytes = 1

// 16 bit
} else if (number <= 0xffff) {
buffer.writeUInt8(0xfd, offset)
buffer.writeUInt16LE(number, offset + 1)
encode.bytes = 3

// 32 bit
} else if (number <= 0xffffffff) {
buffer.writeUInt8(0xfe, offset)
buffer.writeUInt32LE(number, offset + 1)
 encode.bytes = 5

// 64 bit
} else {
buffer.writeUInt8(0xff, offset)
buffer.writeUInt32LE(number >>> 0, offset + 1)
buffer.writeUInt32LE((number / 0x100000000) | 0, offset + 5)
encode.bytes = 9
}

return buffer
}

function decode (buffer, offset) {

if (!Buffer.isBuffer(buffer)) throw new TypeError('buffer must be a Buffer
instance')
if (!offset) offset = 0

var first = buffer.readUInt8(offset)

// 8 bit
if (first < 0xfd) {
decode.bytes = 1
return first

// 16 bit
} else if (first === 0xfd) {
decode.bytes = 3
return buffer.readUInt16LE(offset + 1)

// 32 bit
} else if (first === 0xfe) {
decode.bytes = 5
return buffer.readUInt32LE(offset + 1)

// 64 bit
} else {
decode.bytes = 9
var lo = buffer.readUInt32LE(offset + 1)
var hi = buffer.readUInt32LE(offset + 5)
var number = hi * 0x0100000000 + lo
checkUInt53(number)

return number
}
}

function encodingLength (number) {

checkUInt53(number)

return (
number < 0xfd ? 1
: number <= 0xffff ? 3
: number <= 0xffffffff ? 5
: 9
)
}

module.exports = { encode: encode, decode: decode, encodingLength: encodingLength }

},{"safe-buffer":30}],44:[function(require,module,exports){
(function (Buffer){
var bs58check = require('bs58check')

function decodeRaw (buffer, version) {

// check version only if defined
if (version !== undefined && buffer[0] !== version) throw new Error('Invalid
network version')

// uncompressed
if (buffer.length === 33) {
return {
version: buffer[0],
privateKey: buffer.slice(1, 33),
compressed: false
}
}

// invalid length
if (buffer.length !== 34) throw new Error('Invalid WIF length')

// invalid compression flag

if (buffer[33] !== 0x01) throw new Error('Invalid compression flag')

return {
version: buffer[0],
privateKey: buffer.slice(1, 33),
compressed: true
}
}

function encodeRaw (version, privateKey, compressed) {

var result = new Buffer(compressed ? 34 : 33)

result.writeUInt8(version, 0)
privateKey.copy(result, 1)

if (compressed) {
result[33] = 0x01
}

return result
}

function decode (string, version) {

return decodeRaw(bs58check.decode(string), version)
}

function encode (version, privateKey, compressed) {

if (typeof version === 'number') return bs58check.encode(encodeRaw(version,
privateKey, compressed))

return bs58check.encode(
encodeRaw(
version.version,
version.privateKey,
version.compressed
)
 )
}

module.exports = {
decode: decode,
decodeRaw: decodeRaw,
encode: encode,
encodeRaw: encodeRaw
}

}).call(this,require("buffer").Buffer)
},{"bs58check":12,"buffer":84}],45:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bech32 = require('bech32')
var bs58check = require('bs58check')
var bscript = require('./script')
var btemplates = require('./templates')
var networks = require('./networks')
var typeforce = require('typeforce')
var types = require('./types')

function fromBase58Check (address) {

var payload = bs58check.decode(address)

// TODO: 4.0.0, move to "toOutputScript"

if (payload.length < 21) throw new TypeError(address + ' is too short')
if (payload.length > 21) throw new TypeError(address + ' is too long')

var version = payload.readUInt8(0)

var hash = payload.slice(1)

return { version: version, hash: hash }

}

function fromBech32 (address) {

var result = bech32.decode(address)
var data = bech32.fromWords(result.words.slice(1))

return {
version: result.words[0],
prefix: result.prefix,
data: Buffer.from(data)
}
}

function toBase58Check (hash, version) {

typeforce(types.tuple(types.Hash160bit, types.UInt8), arguments)

var payload = Buffer.allocUnsafe(21)

payload.writeUInt8(version, 0)
hash.copy(payload, 1)

return bs58check.encode(payload)
}

function toBech32 (data, version, prefix) {

var words = bech32.toWords(data)
words.unshift(version)
 return bech32.encode(prefix, words)
}

function fromOutputScript (outputScript, network) {

network = network || networks.bitcoin

if (btemplates.pubKeyHash.output.check(outputScript)) return
toBase58Check(bscript.compile(outputScript).slice(3, 23), network.pubKeyHash)
if (btemplates.scriptHash.output.check(outputScript)) return
toBase58Check(bscript.compile(outputScript).slice(2, 22), network.scriptHash)
if (btemplates.witnessPubKeyHash.output.check(outputScript)) return
toBech32(bscript.compile(outputScript).slice(2, 22), 0, network.bech32)
if (btemplates.witnessScriptHash.output.check(outputScript)) return
toBech32(bscript.compile(outputScript).slice(2, 34), 0, network.bech32)

throw new Error(bscript.toASM(outputScript) + ' has no matching Address')

}

function toOutputScript (address, network) {

network = network || networks.bitcoin

var decode
try {
decode = fromBase58Check(address)
} catch (e) {}

if (decode) {
if (decode.version === network.pubKeyHash) return
btemplates.pubKeyHash.output.encode(decode.hash)
if (decode.version === network.scriptHash) return
btemplates.scriptHash.output.encode(decode.hash)
} else {
try {
decode = fromBech32(address)
} catch (e) {}

if (decode) {
if (decode.prefix !== network.bech32) throw new Error(address + ' has an
invalid prefix')
if (decode.version === 0) {
if (decode.data.length === 20) return
btemplates.witnessPubKeyHash.output.encode(decode.data)
if (decode.data.length === 32) return
btemplates.witnessScriptHash.output.encode(decode.data)
}
}
}

throw new Error(address + ' has no matching Script')

}

module.exports = {
fromBase58Check: fromBase58Check,
fromBech32: fromBech32,
fromOutputScript: fromOutputScript,
toBase58Check: toBase58Check,
toBech32: toBech32,
toOutputScript: toOutputScript
}
},{"./networks":54,"./script":55,"./templates":57,"./
types":81,"bech32":2,"bs58check":12,"safe-buffer":30,"typeforce":41}],46:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bcrypto = require('./crypto')
var fastMerkleRoot = require('merkle-lib/fastRoot')
var typeforce = require('typeforce')
var types = require('./types')
var varuint = require('varuint-bitcoin')

var Transaction = require('./transaction')

function Block () {
this.version = 1
this.prevHash = null
this.merkleRoot = null
this.timestamp = 0
this.bits = 0
this.nonce = 0
}

Block.fromBuffer = function (buffer) {

if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)')

var offset = 0
function readSlice (n) {
offset += n
return buffer.slice(offset - n, offset)
}

function readUInt32 () {
var i = buffer.readUInt32LE(offset)
offset += 4
return i
}

function readInt32 () {
var i = buffer.readInt32LE(offset)
offset += 4
return i
}

var block = new Block()

block.version = readInt32()
block.prevHash = readSlice(32)
block.merkleRoot = readSlice(32)
block.timestamp = readUInt32()
block.bits = readUInt32()
block.nonce = readUInt32()

if (buffer.length === 80) return block

function readVarInt () {
var vi = varuint.decode(buffer, offset)
offset += varuint.decode.bytes
return vi
}
 function readTransaction () {
var tx = Transaction.fromBuffer(buffer.slice(offset), true)
offset += tx.byteLength()
return tx
}

var nTransactions = readVarInt()

block.transactions = []

for (var i = 0; i < nTransactions; ++i) {

var tx = readTransaction()
block.transactions.push(tx)
}

return block
}

Block.prototype.byteLength = function (headersOnly) {

if (headersOnly || !this.transactions) return 80

return 80 + varuint.encodingLength(this.transactions.length) +
this.transactions.reduce(function (a, x) {
return a + x.byteLength()
}, 0)
}

Block.fromHex = function (hex) {

return Block.fromBuffer(Buffer.from(hex, 'hex'))
}

Block.prototype.getHash = function () {
return bcrypto.hash256(this.toBuffer(true))
}

Block.prototype.getId = function () {
return this.getHash().reverse().toString('hex')
}

Block.prototype.getUTCDate = function () {
var date = new Date(0) // epoch
date.setUTCSeconds(this.timestamp)

return date
}

// TODO: buffer, offset compatibility

Block.prototype.toBuffer = function (headersOnly) {
var buffer = Buffer.allocUnsafe(this.byteLength(headersOnly))

var offset = 0
function writeSlice (slice) {
slice.copy(buffer, offset)
offset += slice.length
}

function writeInt32 (i) {

buffer.writeInt32LE(i, offset)
offset += 4
}
 function writeUInt32 (i) {
buffer.writeUInt32LE(i, offset)
offset += 4
}

writeInt32(this.version)
writeSlice(this.prevHash)
writeSlice(this.merkleRoot)
writeUInt32(this.timestamp)
writeUInt32(this.bits)
writeUInt32(this.nonce)

if (headersOnly || !this.transactions) return buffer

varuint.encode(this.transactions.length, buffer, offset)

offset += varuint.encode.bytes

this.transactions.forEach(function (tx) {
var txSize = tx.byteLength() // TODO: extract from toBuffer?
tx.toBuffer(buffer, offset)
offset += txSize
})

return buffer
}

Block.prototype.toHex = function (headersOnly) {

return this.toBuffer(headersOnly).toString('hex')
}

Block.calculateTarget = function (bits) {

var exponent = ((bits & 0xff000000) >> 24) - 3
var mantissa = bits & 0x007fffff
var target = Buffer.alloc(32, 0)
target.writeUInt32BE(mantissa, 28 - exponent)
return target
}

Block.calculateMerkleRoot = function (transactions) {

typeforce([{ getHash: types.Function }], transactions)
if (transactions.length === 0) throw TypeError('Cannot compute merkle root for
zero transactions')

var hashes = transactions.map(function (transaction) {

return transaction.getHash()
})

return fastMerkleRoot(hashes, bcrypto.hash256)

}

Block.prototype.checkMerkleRoot = function () {
if (!this.transactions) return false

var actualMerkleRoot = Block.calculateMerkleRoot(this.transactions)

return this.merkleRoot.compare(actualMerkleRoot) === 0
}

Block.prototype.checkProofOfWork = function () {
var hash = this.getHash().reverse()
 var target = Block.calculateTarget(this.bits)

return hash.compare(target) <= 0

}

module.exports = Block

},{"./crypto":48,"./transaction":79,"./types":81,"merkle-lib/fastRoot":26,"safe-
buffer":30,"typeforce":41,"varuint-bitcoin":43}],47:
[function(require,module,exports){
var pushdata = require('pushdata-bitcoin')
var varuint = require('varuint-bitcoin')

// https://github.com/feross/buffer/blob/master/index.js#L1127
function verifuint (value, max) {
if (typeof value !== 'number') throw new Error('cannot write a non-number as a
number')
if (value < 0) throw new Error('specified a negative value for writing an
unsigned value')
if (value > max) throw new Error('RangeError: value out of range')
if (Math.floor(value) !== value) throw new Error('value has a fractional
component')
}

function readUInt64LE (buffer, offset) {

var a = buffer.readUInt32LE(offset)
var b = buffer.readUInt32LE(offset + 4)
b *= 0x100000000

verifuint(b + a, 0x001fffffffffffff)

return b + a
}

function writeUInt64LE (buffer, value, offset) {

verifuint(value, 0x001fffffffffffff)

buffer.writeInt32LE(value & -1, offset)

buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4)
return offset + 8
}

// TODO: remove in 4.0.0?

function readVarInt (buffer, offset) {
var result = varuint.decode(buffer, offset)

return {
number: result,
size: varuint.decode.bytes
}
}

// TODO: remove in 4.0.0?

function writeVarInt (buffer, number, offset) {
varuint.encode(number, buffer, offset)
return varuint.encode.bytes
}

module.exports = {
 pushDataSize: pushdata.encodingLength,
readPushDataInt: pushdata.decode,
readUInt64LE: readUInt64LE,
readVarInt: readVarInt,
varIntBuffer: varuint.encode,
varIntSize: varuint.encodingLength,
writePushDataInt: pushdata.encode,
writeUInt64LE: writeUInt64LE,
writeVarInt: writeVarInt
}

},{"pushdata-bitcoin":27,"varuint-bitcoin":43}],48:
[function(require,module,exports){
var createHash = require('create-hash')

function ripemd160 (buffer) {

return createHash('rmd160').update(buffer).digest()
}

function sha1 (buffer) {

return createHash('sha1').update(buffer).digest()
}

function sha256 (buffer) {

return createHash('sha256').update(buffer).digest()
}

function hash160 (buffer) {

return ripemd160(sha256(buffer))
}

function hash256 (buffer) {

return sha256(sha256(buffer))
}

module.exports = {
hash160: hash160,
hash256: hash256,
ripemd160: ripemd160,
sha1: sha1,
sha256: sha256
}

},{"create-hash":14}],49:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var createHmac = require('create-hmac')
var typeforce = require('typeforce')
var types = require('./types')

var BigInteger = require('bigi')

var ECSignature = require('./ecsignature')

var ZERO = Buffer.alloc(1, 0)

var ONE = Buffer.alloc(1, 1)

var ecurve = require('ecurve')

var secp256k1 = ecurve.getCurveByName('secp256k1')

// https://tools.ietf.org/html/rfc6979#section-3.2
function deterministicGenerateK (hash, x, checkSig) {
typeforce(types.tuple(
types.Hash256bit,
types.Buffer256bit,
types.Function
), arguments)

// Step A, ignored as hash already provided

// Step B
// Step C
var k = Buffer.alloc(32, 0)
var v = Buffer.alloc(32, 1)

// Step D
k = createHmac('sha256', k)
.update(v)
.update(ZERO)
.update(x)
.update(hash)
.digest()

// Step E
v = createHmac('sha256', k).update(v).digest()

// Step F
k = createHmac('sha256', k)
.update(v)
.update(ONE)
.update(x)
.update(hash)
.digest()

// Step G
v = createHmac('sha256', k).update(v).digest()

// Step H1/H2a, ignored as tlen === qlen (256 bit)

// Step H2b
v = createHmac('sha256', k).update(v).digest()

var T = BigInteger.fromBuffer(v)

// Step H3, repeat until T is within the interval [1, n - 1] and is suitable for
ECDSA
while (T.signum() <= 0 || T.compareTo(secp256k1.n) >= 0 || !checkSig(T)) {
k = createHmac('sha256', k)
.update(v)
.update(ZERO)
.digest()

v = createHmac('sha256', k).update(v).digest()

// Step H1/H2a, again, ignored as tlen === qlen (256 bit)

// Step H2b again
v = createHmac('sha256', k).update(v).digest()
T = BigInteger.fromBuffer(v)
}

return T
}
var N_OVER_TWO = secp256k1.n.shiftRight(1)

function sign (hash, d) {

typeforce(types.tuple(types.Hash256bit, types.BigInt), arguments)

var x = d.toBuffer(32)
var e = BigInteger.fromBuffer(hash)
var n = secp256k1.n
var G = secp256k1.G

var r, s
deterministicGenerateK(hash, x, function (k) {
var Q = G.multiply(k)

if (secp256k1.isInfinity(Q)) return false

r = Q.affineX.mod(n)
if (r.signum() === 0) return false

s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n)
if (s.signum() === 0) return false

return true
})

// enforce low S values, see bip62: 'low s values in signatures'

if (s.compareTo(N_OVER_TWO) > 0) {
s = n.subtract(s)
}

return new ECSignature(r, s)

}

function verify (hash, signature, Q) {

typeforce(types.tuple(
types.Hash256bit,
types.ECSignature,
types.ECPoint
), arguments)

var n = secp256k1.n
var G = secp256k1.G

var r = signature.r
var s = signature.s

// 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]

if (r.signum() <= 0 || r.compareTo(n) >= 0) return false
if (s.signum() <= 0 || s.compareTo(n) >= 0) return false

// 1.4.2 H = Hash(M), already done by the user

// 1.4.3 e = H
var e = BigInteger.fromBuffer(hash)

// Compute s^-1
var sInv = s.modInverse(n)

// 1.4.4 Compute u1 = es^−1 mod n

 // u2 = rs^−1 mod n
var u1 = e.multiply(sInv).mod(n)
var u2 = r.multiply(sInv).mod(n)

// 1.4.5 Compute R = (xR, yR)

// R = u1G + u2Q
var R = G.multiplyTwo(u1, Q, u2)

// 1.4.5 (cont.) Enforce R is not at infinity

if (secp256k1.isInfinity(R)) return false

// 1.4.6 Convert the field element R.x to an integer

var xR = R.affineX

// 1.4.7 Set v = xR mod n

var v = xR.mod(n)

// 1.4.8 If v = r, output "valid", and if v != r, output "invalid"

return v.equals(r)
}

module.exports = {
deterministicGenerateK: deterministicGenerateK,
sign: sign,
verify: verify,

// TODO: remove
__curve: secp256k1
}

},{"./ecsignature":51,"./types":81,"bigi":5,"create-hmac":16,"ecurve":20,"safe-
buffer":30,"typeforce":41}],50:[function(require,module,exports){
var baddress = require('./address')
var bcrypto = require('./crypto')
var ecdsa = require('./ecdsa')
var randomBytes = require('randombytes')
var typeforce = require('typeforce')
var types = require('./types')
var wif = require('wif')

var NETWORKS = require('./networks')

var BigInteger = require('bigi')

var ecurve = require('ecurve')

var secp256k1 = ecdsa.__curve
var Buffer = require('safe-buffer').Buffer

function ECPair (d, Q, options) {

if (options) {
typeforce({
compressed: types.maybe(types.Boolean),
network: types.maybe(types.Network)
}, options)
}

options = options || {}

if (d) {
if (d.signum() <= 0) throw new Error('Private key must be greater than 0')
 if (d.compareTo(secp256k1.n) >= 0) throw new Error('Private key must be less
than the curve order')
if (Q) throw new TypeError('Unexpected publicKey parameter')

this.d = d
} else {
typeforce(types.ECPoint, Q)

this.__Q = Q
}

this.compressed = options.compressed === undefined ? true : options.compressed

this.network = options.network || NETWORKS.bitcoin
}

Object.defineProperty(ECPair.prototype, 'Q', {
get: function () {
if (!this.__Q && this.d) {
this.__Q = secp256k1.G.multiply(this.d)
}

return this.__Q
}
})

ECPair.fromPublicKeyBuffer = function (buffer, network) {

var Q = ecurve.Point.decodeFrom(secp256k1, buffer)

return new ECPair(null, Q, {

compressed: Q.compressed,
network: network
})
}

ECPair.fromWIF = function (string, network) {

var decoded = wif.decode(string)
var version = decoded.version

// list of networks?
if (types.Array(network)) {
network = network.filter(function (x) {
return version === x.wif
}).pop()

if (!network) throw new Error('Unknown network version')

// otherwise, assume a network object (or default to bitcoin)

} else {
network = network || NETWORKS.bitcoin

if (version !== network.wif) throw new Error('Invalid network version')

}

var d = BigInteger.fromBuffer(decoded.privateKey)

return new ECPair(d, null, {

compressed: decoded.compressed,
network: network
})
}

ECPair.fromPassphrase = function (passphrase, options) {

var buffer = new Buffer(passphrase, 'hex')
options = options || {}
buffer = bcrypto.sha256(buffer)
var d = BigInteger.fromBuffer(buffer).mod(secp256k1.n)
return new ECPair(d, null, {compressed: true, network: options.network ||
NETWORKS.bitcoin})
}

ECPair.makeRandom = function (options) {

options = options || {}

var rng = options.rng || randomBytes

var d
do {
var buffer = rng(32)
typeforce(types.Buffer256bit, buffer)

d = BigInteger.fromBuffer(buffer)
} while (d.signum() <= 0 || d.compareTo(secp256k1.n) >= 0)

return new ECPair(d, null, options)

}

ECPair.prototype.getAddress = function () {
return baddress.toBase58Check(bcrypto.hash160(this.getPublicKeyBuffer()),
this.getNetwork().pubKeyHash)
}

ECPair.prototype.getNetwork = function () {
return this.network
}

ECPair.prototype.getPublicKeyBuffer = function () {
return this.Q.getEncoded(this.compressed)
}

ECPair.prototype.sign = function (hash) {

if (!this.d) throw new Error('Missing private key')

return ecdsa.sign(hash, this.d)

}

ECPair.prototype.signHex = function (hash) {

var b = new Buffer(hash, 'hex');
return this.sign(b).toDER().toString('hex')
}

ECPair.prototype.toWIF = function () {
if (!this.d) throw new Error('Missing private key')

return wif.encode(this.network.wif, this.d.toBuffer(32), this.compressed)

}

ECPair.prototype.verify = function (hash, signature) {

return ecdsa.verify(hash, signature, this.Q)
}

module.exports = ECPair

},{"./address":45,"./crypto":48,"./ecdsa":49,"./networks":54,"./
types":81,"bigi":5,"ecurve":20,"randombytes":28,"safe-
buffer":30,"typeforce":41,"wif":44}],51:[function(require,module,exports){
var bip66 = require('bip66')
var typeforce = require('typeforce')
var types = require('./types')

var BigInteger = require('bigi')

var Buffer = require('safe-buffer').Buffer

function ECSignature (r, s) {

typeforce(types.tuple(types.BigInt, types.BigInt), arguments)

this.r = r
this.s = s
}

ECSignature.parseCompact = function (buffer) {

typeforce(types.BufferN(65), buffer)

var flagByte = buffer.readUInt8(0) - 27

if (flagByte !== (flagByte & 7)) throw new Error('Invalid signature parameter')

var compressed = !!(flagByte & 4)

var recoveryParam = flagByte & 3
var signature = ECSignature.fromRSBuffer(buffer.slice(1))

return {
compressed: compressed,
i: recoveryParam,
signature: signature
}
}

ECSignature.fromRSBuffer = function (buffer) {

typeforce(types.BufferN(64), buffer)

var r = BigInteger.fromBuffer(buffer.slice(0, 32))

var s = BigInteger.fromBuffer(buffer.slice(32, 64))
return new ECSignature(r, s)
}

ECSignature.fromDER = function (buffer) {

var decode = bip66.decode(buffer)
var r = BigInteger.fromDERInteger(decode.r)
var s = BigInteger.fromDERInteger(decode.s)

return new ECSignature(r, s)

}

// BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are
allowed)
ECSignature.parseScriptSignature = function (buffer) {
var hashType = buffer.readUInt8(buffer.length - 1)
var hashTypeMod = hashType & ~0x80
 if (hashTypeMod <= 0x00 || hashTypeMod >= 0x04) throw new Error('Invalid hashType
' + hashType)

return {
signature: ECSignature.fromDER(buffer.slice(0, -1)),
hashType: hashType
}
}

ECSignature.prototype.toCompact = function (i, compressed) {

if (compressed) {
i += 4
}

i += 27

var buffer = Buffer.alloc(65)

buffer.writeUInt8(i, 0)
this.toRSBuffer(buffer, 1)
return buffer
}

ECSignature.prototype.toDER = function () {
var r = Buffer.from(this.r.toDERInteger())
var s = Buffer.from(this.s.toDERInteger())

return bip66.encode(r, s)
}

ECSignature.prototype.toRSBuffer = function (buffer, offset) {

buffer = buffer || Buffer.alloc(64)
this.r.toBuffer(32).copy(buffer, offset)
this.s.toBuffer(32).copy(buffer, offset + 32)
return buffer
}

ECSignature.prototype.toScriptSignature = function (hashType) {

var hashTypeMod = hashType & ~0x80
if (hashTypeMod <= 0 || hashTypeMod >= 4) throw new Error('Invalid hashType ' +
hashType)

var hashTypeBuffer = Buffer.alloc(1)

hashTypeBuffer.writeUInt8(hashType, 0)

return Buffer.concat([this.toDER(), hashTypeBuffer])

}

module.exports = ECSignature

},{"./types":81,"bigi":5,"bip66":7,"safe-buffer":30,"typeforce":41}],52:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var base58check = require('bs58check')
var bcrypto = require('./crypto')
var createHmac = require('create-hmac')
var typeforce = require('typeforce')
var types = require('./types')
var NETWORKS = require('./networks')
var BigInteger = require('bigi')
var ECPair = require('./ecpair')

var ecurve = require('ecurve')

var curve = ecurve.getCurveByName('secp256k1')

function HDNode (keyPair, chainCode) {

typeforce(types.tuple('ECPair', types.Buffer256bit), arguments)

if (!keyPair.compressed) throw new TypeError('BIP32 only allows compressed

keyPairs')

this.keyPair = keyPair
this.chainCode = chainCode
this.depth = 0
this.index = 0
this.parentFingerprint = 0x00000000
}

HDNode.HIGHEST_BIT = 0x80000000
HDNode.LENGTH = 78
HDNode.MASTER_SECRET = Buffer.from('Bitcoin seed', 'utf8')

HDNode.fromSeedBuffer = function (seed, network) {

typeforce(types.tuple(types.Buffer, types.maybe(types.Network)), arguments)

if (seed.length < 16) throw new TypeError('Seed should be at least 128 bits')
if (seed.length > 64) throw new TypeError('Seed should be at most 512 bits')

var I = createHmac('sha512', HDNode.MASTER_SECRET).update(seed).digest()

var IL = I.slice(0, 32)
var IR = I.slice(32)

// In case IL is 0 or >= n, the master key is invalid

// This is handled by the ECPair constructor
var pIL = BigInteger.fromBuffer(IL)
var keyPair = new ECPair(pIL, null, {
network: network
})

return new HDNode(keyPair, IR)

}

HDNode.fromSeedHex = function (hex, network) {

return HDNode.fromSeedBuffer(Buffer.from(hex, 'hex'), network)
}

HDNode.fromBase58 = function (string, networks) {

var buffer = base58check.decode(string)
if (buffer.length !== 78) throw new Error('Invalid buffer length')

// 4 bytes: version bytes

var version = buffer.readUInt32BE(0)
var network

// list of networks?
if (Array.isArray(networks)) {
network = networks.filter(function (x) {
 return version === x.bip32.private ||
version === x.bip32.public
}).pop()

if (!network) throw new Error('Unknown network version')

// otherwise, assume a network object (or default to bitcoin)

} else {
network = networks || NETWORKS.bitcoin
}

if (version !== network.bip32.private &&

version !== network.bip32.public) throw new Error('Invalid network version')

// 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ...
var depth = buffer[4]

// 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)

var parentFingerprint = buffer.readUInt32BE(5)
if (depth === 0) {
if (parentFingerprint !== 0x00000000) throw new Error('Invalid parent
fingerprint')
}

// 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key
being serialized.
// This is encoded in MSB order. (0x00000000 if master key)
var index = buffer.readUInt32BE(9)
if (depth === 0 && index !== 0) throw new Error('Invalid index')

// 32 bytes: the chain code

var chainCode = buffer.slice(13, 45)
var keyPair

// 33 bytes: private key data (0x00 + k)

if (version === network.bip32.private) {
if (buffer.readUInt8(45) !== 0x00) throw new Error('Invalid private key')

var d = BigInteger.fromBuffer(buffer.slice(46, 78))

keyPair = new ECPair(d, null, { network: network })

// 33 bytes: public key data (0x02 + X or 0x03 + X)

} else {
var Q = ecurve.Point.decodeFrom(curve, buffer.slice(45, 78))
// Q.compressed is assumed, if somehow this assumption is broken, `new HDNode`
will throw

// Verify that the X coordinate in the public point corresponds to a point on

the curve.
// If not, the extended public key is invalid.
curve.validate(Q)

keyPair = new ECPair(null, Q, { network: network })

}

var hd = new HDNode(keyPair, chainCode)

hd.depth = depth
hd.index = index
hd.parentFingerprint = parentFingerprint
 return hd
}

HDNode.prototype.getAddress = function () {
return this.keyPair.getAddress()
}

HDNode.prototype.getIdentifier = function () {
return bcrypto.hash160(this.keyPair.getPublicKeyBuffer())
}

HDNode.prototype.getFingerprint = function () {
return this.getIdentifier().slice(0, 4)
}

HDNode.prototype.getNetwork = function () {
return this.keyPair.getNetwork()
}

HDNode.prototype.getPublicKeyBuffer = function () {
return this.keyPair.getPublicKeyBuffer()
}

HDNode.prototype.neutered = function () {
var neuteredKeyPair = new ECPair(null, this.keyPair.Q, {
network: this.keyPair.network
})

var neutered = new HDNode(neuteredKeyPair, this.chainCode)

neutered.depth = this.depth
neutered.index = this.index
neutered.parentFingerprint = this.parentFingerprint

return neutered
}

HDNode.prototype.sign = function (hash) {

return this.keyPair.sign(hash)
}

HDNode.prototype.verify = function (hash, signature) {

return this.keyPair.verify(hash, signature)
}

HDNode.prototype.toBase58 = function (__isPrivate) {

if (__isPrivate !== undefined) throw new TypeError('Unsupported argument in
2.0.0')

// Version
var network = this.keyPair.network
var version = (!this.isNeutered()) ? network.bip32.private : network.bip32.public
var buffer = Buffer.allocUnsafe(78)

// 4 bytes: version bytes

buffer.writeUInt32BE(version, 0)

// 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
buffer.writeUInt8(this.depth, 4)
 // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
buffer.writeUInt32BE(this.parentFingerprint, 5)

// 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key
being serialized.
// This is encoded in big endian. (0x00000000 if master key)
buffer.writeUInt32BE(this.index, 9)

// 32 bytes: the chain code

this.chainCode.copy(buffer, 13)

// 33 bytes: the public key or private key data

if (!this.isNeutered()) {
// 0x00 + k for private keys
buffer.writeUInt8(0, 45)
this.keyPair.d.toBuffer(32).copy(buffer, 46)

// 33 bytes: the public key

} else {
// X9.62 encoding for public keys
this.keyPair.getPublicKeyBuffer().copy(buffer, 45)
}

return base58check.encode(buffer)
}

// https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-
derivation-ckd-functions
HDNode.prototype.derive = function (index) {
typeforce(types.UInt32, index)

var isHardened = index >= HDNode.HIGHEST_BIT

var data = Buffer.allocUnsafe(37)

// Hardened child
if (isHardened) {
if (this.isNeutered()) throw new TypeError('Could not derive hardened child
key')

// data = 0x00 || ser256(kpar) || ser32(index)

data[0] = 0x00
this.keyPair.d.toBuffer(32).copy(data, 1)
data.writeUInt32BE(index, 33)

// Normal child
} else {
// data = serP(point(kpar)) || ser32(index)
// = serP(Kpar) || ser32(index)
this.keyPair.getPublicKeyBuffer().copy(data, 0)
data.writeUInt32BE(index, 33)
}

var I = createHmac('sha512', this.chainCode).update(data).digest()

var IL = I.slice(0, 32)
var IR = I.slice(32)

var pIL = BigInteger.fromBuffer(IL)

 // In case parse256(IL) >= n, proceed with the next value for i
if (pIL.compareTo(curve.n) >= 0) {
return this.derive(index + 1)
}

// Private parent key -> private child key

var derivedKeyPair
if (!this.isNeutered()) {
// ki = parse256(IL) + kpar (mod n)
var ki = pIL.add(this.keyPair.d).mod(curve.n)

// In case ki == 0, proceed with the next value for i

if (ki.signum() === 0) {
return this.derive(index + 1)
}

derivedKeyPair = new ECPair(ki, null, {

network: this.keyPair.network
})

// Public parent key -> public child key

} else {
// Ki = point(parse256(IL)) + Kpar
// = G*IL + Kpar
var Ki = curve.G.multiply(pIL).add(this.keyPair.Q)

// In case Ki is the point at infinity, proceed with the next value for i
if (curve.isInfinity(Ki)) {
return this.derive(index + 1)
}

derivedKeyPair = new ECPair(null, Ki, {

network: this.keyPair.network
})
}

var hd = new HDNode(derivedKeyPair, IR)

hd.depth = this.depth + 1
hd.index = index
hd.parentFingerprint = this.getFingerprint().readUInt32BE(0)

return hd
}

HDNode.prototype.deriveHardened = function (index) {

typeforce(types.UInt31, index)

// Only derives hardened private keys by default

return this.derive(index + HDNode.HIGHEST_BIT)
}

// Private === not neutered

// Public === neutered
HDNode.prototype.isNeutered = function () {
return !(this.keyPair.d)
}

HDNode.prototype.derivePath = function (path) {

typeforce(types.BIP32Path, path)
 var splitPath = path.split('/')
if (splitPath[0] === 'm') {
if (this.parentFingerprint) {
throw new Error('Not a master node')
}

splitPath = splitPath.slice(1)
}

return splitPath.reduce(function (prevHd, indexStr) {

var index
if (indexStr.slice(-1) === "'") {
index = parseInt(indexStr.slice(0, -1), 10)
return prevHd.deriveHardened(index)
} else {
index = parseInt(indexStr, 10)
return prevHd.derive(index)
}
}, this)
}

module.exports = HDNode

},{"./crypto":48,"./ecpair":50,"./networks":54,"./
types":81,"bigi":5,"bs58check":12,"create-hmac":16,"ecurve":20,"safe-
buffer":30,"typeforce":41}],53:[function(require,module,exports){
var script = require('./script')

var templates = require('./templates')

for (var key in templates) {
script[key] = templates[key]
}

module.exports = {
bufferutils: require('./bufferutils'), // TODO: remove in 4.0.0

Block: require('./block'),
ECPair: require('./ecpair'),
ECSignature: require('./ecsignature'),
HDNode: require('./hdnode'),
Transaction: require('./transaction'),
TransactionBuilder: require('./transaction_builder'),

address: require('./address'),
crypto: require('./crypto'),
networks: require('./networks'),
opcodes: require('bitcoin-ops'),
script: script
}

},{"./address":45,"./block":46,"./bufferutils":47,"./crypto":48,"./ecpair":50,"./
ecsignature":51,"./hdnode":52,"./networks":54,"./script":55,"./templates":57,"./
transaction":79,"./transaction_builder":80,"bitcoin-ops":8}],54:
[function(require,module,exports){
// https://en.bitcoin.it/wiki/List_of_address_prefixes
// Dogecoin BIP32 is a proposed standard: https://bitcointalk.org/index.php?
topic=409731
module.exports = {
bitcoin: {
messagePrefix: '\x18Bitcoin Signed Message:\n',
bech32: 'bc',
bip32: {
public: 0x0488b21e,
private: 0x0488ade4
},
pubKeyHash: 0x00,
scriptHash: 0x05,
wif: 0x80
},
litecoin: {
messagePrefix: '\x19Litecoin Signed Message:\n',
bech32: 'ltc',
bip32: {
public: 0x019da462,
private: 0x019d9cfe
},
pubKeyHash: 0x30,
scriptHash: 0x32,
wif: 0xb0
},
dogecoin: {
messagePrefix: '\x19Dogecoin Signed Message:\n',
bech32: undefined,
bip32: {
public: 0x02facafd,
private: 0x02fac398
},
pubKeyHash: 0x1e,
scriptHash: 0x16,
wif: 0x9e
},
bitcoin_testnet: {
messagePrefix: '\x18Bitcoin Signed Message:\n',
bech32: 'tb',
bip32: {
public: 0x043587cf,
private: 0x04358394
},
pubKeyHash: 0x6f,
scriptHash: 0xc4,
wif: 0xef
},
dogecoin_testnet: {
messagePrefix: '\x18Dogecoin Signed Message:\n',
bech32: undefined,
bip32: {
public: 0x0432a9a8,
private: 0x0432a243
},
pubKeyHash: 0x71,
scriptHash: 0xc4,
wif: 0xf1
},
litecoin_testnet: {
messagePrefix: '\x18Litecoin Signed Message:\n',
bech32: 'tltc',
 bip32: {
public: 0x0436ef7d,
private: 0x0436f6e1
},
pubKeyHash: 0x6f,
scriptHash: 0xc4,
wif: 0xef
}
}

},{}],55:[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bip66 = require('bip66')
var pushdata = require('pushdata-bitcoin')
var typeforce = require('typeforce')
var types = require('./types')
var scriptNumber = require('./script_number')

var OPS = require('bitcoin-ops')

var REVERSE_OPS = require('bitcoin-ops/map')
var OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1

function isOPInt (value) {

return types.Number(value) &&
((value === OPS.OP_0) ||
(value >= OPS.OP_1 && value <= OPS.OP_16) ||
(value === OPS.OP_1NEGATE))
}

function isPushOnlyChunk (value) {

return types.Buffer(value) || isOPInt(value)
}

function isPushOnly (value) {

return types.Array(value) && value.every(isPushOnlyChunk)
}

function asMinimalOP (buffer) {

if (buffer.length === 0) return OPS.OP_0
if (buffer.length !== 1) return
if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0]
if (buffer[0] === 0x81) return OPS.OP_1NEGATE
}

function compile (chunks) {

// TODO: remove me
if (Buffer.isBuffer(chunks)) return chunks

typeforce(types.Array, chunks)

var bufferSize = chunks.reduce(function (accum, chunk) {

// data chunk
if (Buffer.isBuffer(chunk)) {
// adhere to BIP62.3, minimal push policy
if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
return accum + 1
}

return accum + pushdata.encodingLength(chunk.length) + chunk.length

 }

// opcode
return accum + 1
}, 0.0)

var buffer = Buffer.allocUnsafe(bufferSize)

var offset = 0

chunks.forEach(function (chunk) {
// data chunk
if (Buffer.isBuffer(chunk)) {
// adhere to BIP62.3, minimal push policy
var opcode = asMinimalOP(chunk)
if (opcode !== undefined) {
buffer.writeUInt8(opcode, offset)
offset += 1
return
}

offset += pushdata.encode(buffer, chunk.length, offset)

chunk.copy(buffer, offset)
offset += chunk.length

// opcode
} else {
buffer.writeUInt8(chunk, offset)
offset += 1
}
})

if (offset !== buffer.length) throw new Error('Could not decode chunks')

return buffer
}

function decompile (buffer) {

// TODO: remove me
if (types.Array(buffer)) return buffer

typeforce(types.Buffer, buffer)

var chunks = []
var i = 0

while (i < buffer.length) {

var opcode = buffer[i]

// data chunk
if ((opcode > OPS.OP_0) && (opcode <= OPS.OP_PUSHDATA4)) {
var d = pushdata.decode(buffer, i)

// did reading a pushDataInt fail? empty script

if (d === null) return []
i += d.size

// attempt to read too much data? empty script

if (i + d.number > buffer.length) return []

var data = buffer.slice(i, i + d.number)

 i += d.number

// decompile minimally
var op = asMinimalOP(data)
if (op !== undefined) {
chunks.push(op)
} else {
chunks.push(data)
}

// opcode
} else {
chunks.push(opcode)

i += 1
}
}

return chunks
}

function toASM (chunks) {

if (Buffer.isBuffer(chunks)) {
chunks = decompile(chunks)
}

return chunks.map(function (chunk) {

// data?
if (Buffer.isBuffer(chunk)) {
var op = asMinimalOP(chunk)
if (op === undefined) return chunk.toString('hex')
chunk = op
}

// opcode!
return REVERSE_OPS[chunk]
}).join(' ')
}

function fromASM (asm) {

typeforce(types.String, asm)

return compile(asm.split(' ').map(function (chunkStr) {

// opcode?
if (OPS[chunkStr] !== undefined) return OPS[chunkStr]
typeforce(types.Hex, chunkStr)

// data!
return Buffer.from(chunkStr, 'hex')
}))
}

function toStack (chunks) {

chunks = decompile(chunks)
typeforce(isPushOnly, chunks)

return chunks.map(function (op) {

if (Buffer.isBuffer(op)) return op
if (op === OPS.OP_0) return Buffer.allocUnsafe(0)
 return scriptNumber.encode(op - OP_INT_BASE)
})
}

function isCanonicalPubKey (buffer) {

if (!Buffer.isBuffer(buffer)) return false
if (buffer.length < 33) return false

switch (buffer[0]) {
case 0x02:
case 0x03:
return buffer.length === 33
case 0x04:
return buffer.length === 65
}

return false
}

function isDefinedHashType (hashType) {

var hashTypeMod = hashType & ~0x80

// return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE

return hashTypeMod > 0x00 && hashTypeMod < 0x04
}

function isCanonicalSignature (buffer) {

if (!Buffer.isBuffer(buffer)) return false
if (!isDefinedHashType(buffer[buffer.length - 1])) return false

return bip66.check(buffer.slice(0, -1))

}

module.exports = {
compile: compile,
decompile: decompile,
fromASM: fromASM,
toASM: toASM,
toStack: toStack,

number: require('./script_number'),

isCanonicalPubKey: isCanonicalPubKey,
isCanonicalSignature: isCanonicalSignature,
isPushOnly: isPushOnly,
isDefinedHashType: isDefinedHashType
}

},{"./script_number":56,"./types":81,"bip66":7,"bitcoin-ops":8,"bitcoin-ops/
map":9,"pushdata-bitcoin":27,"safe-buffer":30,"typeforce":41}],56:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer

function decode (buffer, maxLength, minimal) {

maxLength = maxLength || 4
minimal = minimal === undefined ? true : minimal

var length = buffer.length

 if (length === 0) return 0
if (length > maxLength) throw new TypeError('Script number overflow')
if (minimal) {
if ((buffer[length - 1] & 0x7f) === 0) {
if (length <= 1 || (buffer[length - 2] & 0x80) === 0) throw new Error('Non-
minimally encoded script number')
}
}

// 40-bit
if (length === 5) {
var a = buffer.readUInt32LE(0)
var b = buffer.readUInt8(4)

if (b & 0x80) return -(((b & ~0x80) * 0x100000000) + a)

return (b * 0x100000000) + a
}

var result = 0

// 32-bit / 24-bit / 16-bit / 8-bit

for (var i = 0; i < length; ++i) {
result |= buffer[i] << (8 * i)
}

if (buffer[length - 1] & 0x80) return -(result & ~(0x80 << (8 * (length - 1))))
return result
}

function scriptNumSize (i) {

return i > 0x7fffffff ? 5
: i > 0x7fffff ? 4
: i > 0x7fff ? 3
: i > 0x7f ? 2
: i > 0x00 ? 1
: 0
}

function encode (number) {

var value = Math.abs(number)
var size = scriptNumSize(value)
var buffer = Buffer.allocUnsafe(size)
var negative = number < 0

for (var i = 0; i < size; ++i) {

buffer.writeUInt8(value & 0xff, i)
value >>= 8
}

if (buffer[size - 1] & 0x80) {

buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1)
} else if (negative) {
buffer[size - 1] |= 0x80
}

return buffer
}

module.exports = {
 decode: decode,
encode: encode
}

},{"safe-buffer":30}],57:[function(require,module,exports){
var decompile = require('../script').decompile
var multisig = require('./multisig')
var nullData = require('./nulldata')
var pubKey = require('./pubkey')
var pubKeyHash = require('./pubkeyhash')
var scriptHash = require('./scripthash')
var witnessPubKeyHash = require('./witnesspubkeyhash')
var witnessScriptHash = require('./witnessscripthash')
var witnessCommitment = require('./witnesscommitment')

var types = {
MULTISIG: 'multisig',
NONSTANDARD: 'nonstandard',
NULLDATA: 'nulldata',
P2PK: 'pubkey',
P2PKH: 'pubkeyhash',
P2SH: 'scripthash',
P2WPKH: 'witnesspubkeyhash',
P2WSH: 'witnessscripthash',
WITNESS_COMMITMENT: 'witnesscommitment'
}

function classifyOutput (script) {

if (witnessPubKeyHash.output.check(script)) return types.P2WPKH
if (witnessScriptHash.output.check(script)) return types.P2WSH
if (pubKeyHash.output.check(script)) return types.P2PKH
if (scriptHash.output.check(script)) return types.P2SH

// XXX: optimization, below functions .decompile before use

var chunks = decompile(script)
if (multisig.output.check(chunks)) return types.MULTISIG
if (pubKey.output.check(chunks)) return types.P2PK
if (witnessCommitment.output.check(chunks)) return types.WITNESS_COMMITMENT
if (nullData.output.check(chunks)) return types.NULLDATA

return types.NONSTANDARD
}

function classifyInput (script, allowIncomplete) {

// XXX: optimization, below functions .decompile before use
var chunks = decompile(script)

if (pubKeyHash.input.check(chunks)) return types.P2PKH

if (scriptHash.input.check(chunks, allowIncomplete)) return types.P2SH
if (multisig.input.check(chunks, allowIncomplete)) return types.MULTISIG
if (pubKey.input.check(chunks)) return types.P2PK

return types.NONSTANDARD
}

function classifyWitness (script, allowIncomplete) {

// XXX: optimization, below functions .decompile before use
var chunks = decompile(script)
 if (witnessPubKeyHash.input.check(chunks)) return types.P2WPKH
if (witnessScriptHash.input.check(chunks, allowIncomplete)) return types.P2WSH

return types.NONSTANDARD
}

module.exports = {
classifyInput: classifyInput,
classifyOutput: classifyOutput,
classifyWitness: classifyWitness,
multisig: multisig,
nullData: nullData,
pubKey: pubKey,
pubKeyHash: pubKeyHash,
scriptHash: scriptHash,
witnessPubKeyHash: witnessPubKeyHash,
witnessScriptHash: witnessScriptHash,
witnessCommitment: witnessCommitment,
types: types
}

},{"../script":55,"./multisig":58,"./nulldata":61,"./pubkey":62,"./
pubkeyhash":65,"./scripthash":68,"./witnesscommitment":71,"./
witnesspubkeyhash":73,"./witnessscripthash":76}],58:
[function(require,module,exports){
module.exports = {
input: require('./input'),
output: require('./output')
}

},{"./input":59,"./output":60}],59:[function(require,module,exports){
// OP_0 [signatures ...]

var Buffer = require('safe-buffer').Buffer

var bscript = require('../../script')
var p2mso = require('./output')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function partialSignature (value) {

return value === OPS.OP_0 || bscript.isCanonicalSignature(value)
}

function check (script, allowIncomplete) {

var chunks = bscript.decompile(script)
if (chunks.length < 2) return false
if (chunks[0] !== OPS.OP_0) return false

if (allowIncomplete) {
return chunks.slice(1).every(partialSignature)
}

return chunks.slice(1).every(bscript.isCanonicalSignature)
}
check.toJSON = function () { return 'multisig input' }

var EMPTY_BUFFER = Buffer.allocUnsafe(0)

function encodeStack (signatures, scriptPubKey) {

 typeforce([partialSignature], signatures)

if (scriptPubKey) {
var scriptData = p2mso.decode(scriptPubKey)

if (signatures.length < scriptData.m) {

throw new TypeError('Not enough signatures provided')
}

if (signatures.length > scriptData.pubKeys.length) {

throw new TypeError('Too many signatures provided')
}
}

return [].concat(EMPTY_BUFFER, signatures.map(function (sig) {

if (sig === OPS.OP_0) {
return EMPTY_BUFFER
}
return sig
}))
}

function encode (signatures, scriptPubKey) {

return bscript.compile(encodeStack(signatures, scriptPubKey))
}

function decodeStack (stack, allowIncomplete) {

typeforce(typeforce.Array, stack)
typeforce(check, stack, allowIncomplete)
return stack.slice(1)
}

function decode (buffer, allowIncomplete) {

var stack = bscript.decompile(buffer)
return decodeStack(stack, allowIncomplete)
}

module.exports = {
check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"./output":60,"bitcoin-ops":8,"safe-
buffer":30,"typeforce":41}],60:[function(require,module,exports){
// m [pubKeys ...] n OP_CHECKMULTISIG

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')
var OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1

function check (script, allowIncomplete) {

var chunks = bscript.decompile(script)

if (chunks.length < 4) return false

 if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG) return false
if (!types.Number(chunks[0])) return false
if (!types.Number(chunks[chunks.length - 2])) return false
var m = chunks[0] - OP_INT_BASE
var n = chunks[chunks.length - 2] - OP_INT_BASE

if (m <= 0) return false

if (n > 16) return false
if (m > n) return false
if (n !== chunks.length - 3) return false
if (allowIncomplete) return true

var keys = chunks.slice(1, -2)

return keys.every(bscript.isCanonicalPubKey)
}
check.toJSON = function () { return 'multi-sig output' }

function encode (m, pubKeys) {

typeforce({
m: types.Number,
pubKeys: [bscript.isCanonicalPubKey]
}, {
m: m,
pubKeys: pubKeys
})

var n = pubKeys.length
if (n < m) throw new TypeError('Not enough pubKeys provided')

return bscript.compile([].concat(
OP_INT_BASE + m,
pubKeys,
OP_INT_BASE + n,
OPS.OP_CHECKMULTISIG
))
}

function decode (buffer, allowIncomplete) {

var chunks = bscript.decompile(buffer)
typeforce(check, chunks, allowIncomplete)

return {
m: chunks[0] - OP_INT_BASE,
pubKeys: chunks.slice(1, -2)
}
}

module.exports = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],61:
[function(require,module,exports){
// OP_RETURN {data}

var bscript = require('../script')

var types = require('../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = bscript.compile(script)

return buffer.length > 1 &&

buffer[0] === OPS.OP_RETURN
}
check.toJSON = function () { return 'null data output' }

function encode (data) {

typeforce(types.Buffer, data)

return bscript.compile([OPS.OP_RETURN, data])

}

function decode (buffer) {

typeforce(check, buffer)

return buffer.slice(2)
}

module.exports = {
output: {
check: check,
decode: decode,
encode: encode
}
}

},{"../script":55,"../types":81,"bitcoin-ops":8,"typeforce":41}],62:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":63,"./output":64,"dup":58}],63:[function(require,module,exports){
// {signature}

var bscript = require('../../script')

var typeforce = require('typeforce')

function check (script) {

var chunks = bscript.decompile(script)

return chunks.length === 1 &&

bscript.isCanonicalSignature(chunks[0])
}
check.toJSON = function () { return 'pubKey input' }

function encodeStack (signature) {

typeforce(bscript.isCanonicalSignature, signature)
return [signature]
}

function encode (signature) {

return bscript.compile(encodeStack(signature))
}

function decodeStack (stack) {

typeforce(typeforce.Array, stack)
 typeforce(check, stack)
return stack[0]
}

function decode (buffer) {

var stack = bscript.decompile(buffer)
return decodeStack(stack)
}

module.exports = {
check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"typeforce":41}],64:[function(require,module,exports){
// {pubKey} OP_CHECKSIG

var bscript = require('../../script')

var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var chunks = bscript.decompile(script)

return chunks.length === 2 &&

bscript.isCanonicalPubKey(chunks[0]) &&
chunks[1] === OPS.OP_CHECKSIG
}
check.toJSON = function () { return 'pubKey output' }

function encode (pubKey) {

typeforce(bscript.isCanonicalPubKey, pubKey)

return bscript.compile([pubKey, OPS.OP_CHECKSIG])

}

function decode (buffer) {

var chunks = bscript.decompile(buffer)
typeforce(check, chunks)

return chunks[0]
}

module.exports = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"bitcoin-ops":8,"typeforce":41}],65:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":66,"./output":67,"dup":58}],66:[function(require,module,exports){
// {signature} {pubKey}

var bscript = require('../../script')

var typeforce = require('typeforce')

function check (script) {

var chunks = bscript.decompile(script)

return chunks.length === 2 &&

bscript.isCanonicalSignature(chunks[0]) &&
bscript.isCanonicalPubKey(chunks[1])
}
check.toJSON = function () { return 'pubKeyHash input' }

function encodeStack (signature, pubKey) {

typeforce({
signature: bscript.isCanonicalSignature,
pubKey: bscript.isCanonicalPubKey
}, {
signature: signature,
pubKey: pubKey
})

return [signature, pubKey]

}

function encode (signature, pubKey) {

return bscript.compile(encodeStack(signature, pubKey))
}

function decodeStack (stack) {

typeforce(typeforce.Array, stack)
typeforce(check, stack)

return {
signature: stack[0],
pubKey: stack[1]
}
}

function decode (buffer) {

var stack = bscript.decompile(buffer)
return decodeStack(stack)
}

module.exports = {
check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"typeforce":41}],67:[function(require,module,exports){
// OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

 var buffer = bscript.compile(script)

return buffer.length === 25 &&

buffer[0] === OPS.OP_DUP &&
buffer[1] === OPS.OP_HASH160 &&
buffer[2] === 0x14 &&
buffer[23] === OPS.OP_EQUALVERIFY &&
buffer[24] === OPS.OP_CHECKSIG
}
check.toJSON = function () { return 'pubKeyHash output' }

function encode (pubKeyHash) {

typeforce(types.Hash160bit, pubKeyHash)

return bscript.compile([
OPS.OP_DUP,
OPS.OP_HASH160,
pubKeyHash,
OPS.OP_EQUALVERIFY,
OPS.OP_CHECKSIG
])
}

function decode (buffer) {

typeforce(check, buffer)

return buffer.slice(3, 23)

}

module.exports = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],68:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":69,"./output":70,"dup":58}],69:[function(require,module,exports){
// <scriptSig> {serialized scriptPubKey script}

var Buffer = require('safe-buffer').Buffer

var bscript = require('../../script')
var typeforce = require('typeforce')

var p2ms = require('../multisig/')

var p2pk = require('../pubkey/')
var p2pkh = require('../pubkeyhash/')
var p2wpkho = require('../witnesspubkeyhash/output')
var p2wsho = require('../witnessscripthash/output')

function check (script, allowIncomplete) {

var chunks = bscript.decompile(script)
if (chunks.length < 1) return false

var lastChunk = chunks[chunks.length - 1]

if (!Buffer.isBuffer(lastChunk)) return false

var scriptSigChunks = bscript.decompile(bscript.compile(chunks.slice(0, -1)))

 var redeemScriptChunks = bscript.decompile(lastChunk)

// is redeemScript a valid script?

if (redeemScriptChunks.length === 0) return false

// is redeemScriptSig push only?

if (!bscript.isPushOnly(scriptSigChunks)) return false

// is witness?
if (chunks.length === 1) {
return p2wsho.check(redeemScriptChunks) ||
p2wpkho.check(redeemScriptChunks)
}

// match types
if (p2pkh.input.check(scriptSigChunks) &&
p2pkh.output.check(redeemScriptChunks)) return true

if (p2ms.input.check(scriptSigChunks, allowIncomplete) &&

p2ms.output.check(redeemScriptChunks)) return true

if (p2pk.input.check(scriptSigChunks) &&
p2pk.output.check(redeemScriptChunks)) return true

return false
}
check.toJSON = function () { return 'scriptHash input' }

function encodeStack (redeemScriptStack, redeemScript) {

var serializedScriptPubKey = bscript.compile(redeemScript)

return [].concat(redeemScriptStack, serializedScriptPubKey)

}

function encode (redeemScriptSig, redeemScript) {

var redeemScriptStack = bscript.decompile(redeemScriptSig)

return bscript.compile(encodeStack(redeemScriptStack, redeemScript))

}

function decodeStack (stack) {

typeforce(typeforce.Array, stack)
typeforce(check, stack)

return {
redeemScriptStack: stack.slice(0, -1),
redeemScript: stack[stack.length - 1]
}
}

function decode (buffer) {

var stack = bscript.decompile(buffer)
var result = decodeStack(stack)
result.redeemScriptSig = bscript.compile(result.redeemScriptStack)
delete result.redeemScriptStack
return result
}

module.exports = {
 check: check,
decode: decode,
decodeStack: decodeStack,
encode: encode,
encodeStack: encodeStack
}

},{"../../script":55,"../multisig/":58,"../pubkey/":62,"../pubkeyhash/":65,"../
witnesspubkeyhash/output":75,"../witnessscripthash/output":78,"safe-
buffer":30,"typeforce":41}],70:[function(require,module,exports){
// OP_HASH160 {scriptHash} OP_EQUAL

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = bscript.compile(script)

return buffer.length === 23 &&

buffer[0] === OPS.OP_HASH160 &&
buffer[1] === 0x14 &&
buffer[22] === OPS.OP_EQUAL
}
check.toJSON = function () { return 'scriptHash output' }

function encode (scriptHash) {

typeforce(types.Hash160bit, scriptHash)

return bscript.compile([OPS.OP_HASH160, scriptHash, OPS.OP_EQUAL])

}

function decode (buffer) {

typeforce(check, buffer)

return buffer.slice(2, 22)

}

module.exports = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],71:
[function(require,module,exports){
module.exports = {
output: require('./output')
}

},{"./output":72}],72:[function(require,module,exports){
// OP_RETURN {aa21a9ed} {commitment}

var Buffer = require('safe-buffer').Buffer

var bscript = require('../../script')
var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')
var HEADER = Buffer.from('aa21a9ed', 'hex')

function check (script) {

var buffer = bscript.compile(script)

return buffer.length > 37 &&

buffer[0] === OPS.OP_RETURN &&
buffer[1] === 0x24 &&
buffer.slice(2, 6).equals(HEADER)
}

check.toJSON = function () { return 'Witness commitment output' }

function encode (commitment) {

typeforce(types.Hash256bit, commitment)

var buffer = Buffer.allocUnsafe(36)

HEADER.copy(buffer, 0)
commitment.copy(buffer, 4)

return bscript.compile([OPS.OP_RETURN, buffer])

}

function decode (buffer) {

typeforce(check, buffer)

return bscript.decompile(buffer)[1].slice(4, 36)

}

module.exports = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"safe-
buffer":30,"typeforce":41}],73:[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":74,"./output":75,"dup":58}],74:[function(require,module,exports){
// {signature} {pubKey}

var bscript = require('../../script')

var typeforce = require('typeforce')

function isCompressedCanonicalPubKey (pubKey) {

return bscript.isCanonicalPubKey(pubKey) && pubKey.length === 33
}

function check (script) {

var chunks = bscript.decompile(script)

return chunks.length === 2 &&

bscript.isCanonicalSignature(chunks[0]) &&
isCompressedCanonicalPubKey(chunks[1])
}
check.toJSON = function () { return 'witnessPubKeyHash input' }

function encodeStack (signature, pubKey) {

 typeforce({
signature: bscript.isCanonicalSignature,
pubKey: isCompressedCanonicalPubKey
}, {
signature: signature,
pubKey: pubKey
})

return [signature, pubKey]

}

function decodeStack (stack) {

typeforce(typeforce.Array, stack)
typeforce(check, stack)

return {
signature: stack[0],
pubKey: stack[1]
}
}

module.exports = {
check: check,
decodeStack: decodeStack,
encodeStack: encodeStack
}

},{"../../script":55,"typeforce":41}],75:[function(require,module,exports){
// OP_0 {pubKeyHash}

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = bscript.compile(script)

return buffer.length === 22 &&

buffer[0] === OPS.OP_0 &&
buffer[1] === 0x14
}
check.toJSON = function () { return 'Witness pubKeyHash output' }

function encode (pubKeyHash) {

typeforce(types.Hash160bit, pubKeyHash)

return bscript.compile([OPS.OP_0, pubKeyHash])

}

function decode (buffer) {

typeforce(check, buffer)

return buffer.slice(2)
}

module.exports = {
check: check,
decode: decode,
 encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],76:
[function(require,module,exports){
arguments[4][58][0].apply(exports,arguments)
},{"./input":77,"./output":78,"dup":58}],77:[function(require,module,exports){
(function (Buffer){
// <scriptSig> {serialized scriptPubKey script}

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')

var p2ms = require('../multisig/')

var p2pk = require('../pubkey/')
var p2pkh = require('../pubkeyhash/')

function check (chunks, allowIncomplete) {

typeforce(types.Array, chunks)
if (chunks.length < 1) return false

var witnessScript = chunks[chunks.length - 1]

if (!Buffer.isBuffer(witnessScript)) return false

var witnessScriptChunks = bscript.decompile(witnessScript)

// is witnessScript a valid script?

if (witnessScriptChunks.length === 0) return false

var witnessRawScriptSig = bscript.compile(chunks.slice(0, -1))

// match types
if (p2pkh.input.check(witnessRawScriptSig) &&
p2pkh.output.check(witnessScriptChunks)) return true

if (p2ms.input.check(witnessRawScriptSig, allowIncomplete) &&

p2ms.output.check(witnessScriptChunks)) return true

if (p2pk.input.check(witnessRawScriptSig) &&
p2pk.output.check(witnessScriptChunks)) return true

return false
}
check.toJSON = function () { return 'witnessScriptHash input' }

function encodeStack (witnessData, witnessScript) {

typeforce({
witnessData: [types.Buffer],
witnessScript: types.Buffer
}, {
witnessData: witnessData,
witnessScript: witnessScript
})

return [].concat(witnessData, witnessScript)

}

function decodeStack (stack) {

 typeforce(typeforce.Array, stack)
typeforce(check, stack)
return {
witnessData: stack.slice(0, -1),
witnessScript: stack[stack.length - 1]
}
}

module.exports = {
check: check,
decodeStack: decodeStack,
encodeStack: encodeStack
}

}).call(this,require("buffer").Buffer)
},{"../../script":55,"../../types":81,"../multisig/":58,"../pubkey/":62,"../
pubkeyhash/":65,"buffer":84,"typeforce":41}],78:[function(require,module,exports){
// OP_0 {scriptHash}

var bscript = require('../../script')

var types = require('../../types')
var typeforce = require('typeforce')
var OPS = require('bitcoin-ops')

function check (script) {

var buffer = bscript.compile(script)

return buffer.length === 34 &&

buffer[0] === OPS.OP_0 &&
buffer[1] === 0x20
}
check.toJSON = function () { return 'Witness scriptHash output' }

function encode (scriptHash) {

typeforce(types.Hash256bit, scriptHash)

return bscript.compile([OPS.OP_0, scriptHash])

}

function decode (buffer) {

typeforce(check, buffer)

return buffer.slice(2)
}

module.exports = {
check: check,
decode: decode,
encode: encode
}

},{"../../script":55,"../../types":81,"bitcoin-ops":8,"typeforce":41}],79:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var bcrypto = require('./crypto')
var bscript = require('./script')
var bufferutils = require('./bufferutils')
var opcodes = require('bitcoin-ops')
var typeforce = require('typeforce')
var types = require('./types')
var varuint = require('varuint-bitcoin')

function varSliceSize (someScript) {

var length = someScript.length

return varuint.encodingLength(length) + length

}

function vectorSize (someVector) {

var length = someVector.length

return varuint.encodingLength(length) + someVector.reduce(function (sum, witness)

{
return sum + varSliceSize(witness)
}, 0)
}

function Transaction () {
this.version = 1
this.locktime = 0
this.ins = []
this.outs = []
}

Transaction.DEFAULT_SEQUENCE = 0xffffffff
Transaction.SIGHASH_ALL = 0x01
Transaction.SIGHASH_NONE = 0x02
Transaction.SIGHASH_SINGLE = 0x03
Transaction.SIGHASH_ANYONECANPAY = 0x80
Transaction.ADVANCED_TRANSACTION_MARKER = 0x00
Transaction.ADVANCED_TRANSACTION_FLAG = 0x01

var EMPTY_SCRIPT = Buffer.allocUnsafe(0)

var EMPTY_WITNESS = []
var ZERO =
Buffer.from('0000000000000000000000000000000000000000000000000000000000000000',
'hex')
var ONE =
Buffer.from('0000000000000000000000000000000000000000000000000000000000000001',
'hex')
var VALUE_UINT64_MAX = Buffer.from('ffffffffffffffff', 'hex')
var BLANK_OUTPUT = {
script: EMPTY_SCRIPT,
valueBuffer: VALUE_UINT64_MAX
}

Transaction.fromBuffer = function (buffer, __noStrict) {

var offset = 0
function readSlice (n) {
offset += n
return buffer.slice(offset - n, offset)
}

function readUInt32 () {
var i = buffer.readUInt32LE(offset)
offset += 4
return i
}
function readInt32 () {
var i = buffer.readInt32LE(offset)
offset += 4
return i
}

function readUInt64 () {
var i = bufferutils.readUInt64LE(buffer, offset)
offset += 8
return i
}

function readVarInt () {
var vi = varuint.decode(buffer, offset)
offset += varuint.decode.bytes
return vi
}

function readVarSlice () {
return readSlice(readVarInt())
}

function readVector () {
var count = readVarInt()
var vector = []
for (var i = 0; i < count; i++) vector.push(readVarSlice())
return vector
}

var tx = new Transaction()

tx.version = readInt32()

var marker = buffer.readUInt8(offset)

var flag = buffer.readUInt8(offset + 1)

var hasWitnesses = false

if (marker === Transaction.ADVANCED_TRANSACTION_MARKER &&
flag === Transaction.ADVANCED_TRANSACTION_FLAG) {
offset += 2
hasWitnesses = true
}

var vinLen = readVarInt()

for (var i = 0; i < vinLen; ++i) {
tx.ins.push({
hash: readSlice(32),
index: readUInt32(),
script: readVarSlice(),
sequence: readUInt32(),
witness: EMPTY_WITNESS
})
}

var voutLen = readVarInt()

for (i = 0; i < voutLen; ++i) {
tx.outs.push({
value: readUInt64(),
script: readVarSlice()
 })
}

if (hasWitnesses) {
for (i = 0; i < vinLen; ++i) {
tx.ins[i].witness = readVector()
}

// was this pointless?

if (!tx.hasWitnesses()) throw new Error('Transaction has superfluous witness
data')
}

tx.locktime = readUInt32()

if (__noStrict) return tx
if (offset !== buffer.length) throw new Error('Transaction has unexpected data')

return tx
}

Transaction.fromHex = function (hex) {

return Transaction.fromBuffer(Buffer.from(hex, 'hex'))
}

Transaction.isCoinbaseHash = function (buffer) {

typeforce(types.Hash256bit, buffer)
for (var i = 0; i < 32; ++i) {
if (buffer[i] !== 0) return false
}
return true
}

Transaction.prototype.isCoinbase = function () {
return this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash)
}

Transaction.prototype.addInput = function (hash, index, sequence, scriptSig) {

typeforce(types.tuple(
types.Hash256bit,
types.UInt32,
types.maybe(types.UInt32),
types.maybe(types.Buffer)
), arguments)

if (types.Null(sequence)) {
sequence = Transaction.DEFAULT_SEQUENCE
}

// Add the input and return the input's index

return (this.ins.push({
hash: hash,
index: index,
script: scriptSig || EMPTY_SCRIPT,
sequence: sequence,
witness: EMPTY_WITNESS
}) - 1)
}
Transaction.prototype.addOutput = function (scriptPubKey, value) {
typeforce(types.tuple(types.Buffer, types.Satoshi), arguments)

// Add the output and return the output's index

return (this.outs.push({
script: scriptPubKey,
value: value
}) - 1)
}

Transaction.prototype.hasWitnesses = function () {
return this.ins.some(function (x) {
return x.witness.length !== 0
})
}

Transaction.prototype.weight = function () {
var base = this.__byteLength(false)
var total = this.__byteLength(true)
return base * 3 + total
}

Transaction.prototype.virtualSize = function () {
return Math.ceil(this.weight() / 4)
}

Transaction.prototype.byteLength = function () {
return this.__byteLength(true)
}

Transaction.prototype.__byteLength = function (__allowWitness) {

var hasWitnesses = __allowWitness && this.hasWitnesses()

return (
(hasWitnesses ? 10 : 8) +
varuint.encodingLength(this.ins.length) +
varuint.encodingLength(this.outs.length) +
this.ins.reduce(function (sum, input) { return sum + 40 +
varSliceSize(input.script) }, 0) +
this.outs.reduce(function (sum, output) { return sum + 8 +
varSliceSize(output.script) }, 0) +
(hasWitnesses ? this.ins.reduce(function (sum, input) { return sum +
vectorSize(input.witness) }, 0) : 0)
)
}

Transaction.prototype.clone = function () {
var newTx = new Transaction()
newTx.version = this.version
newTx.locktime = this.locktime

newTx.ins = this.ins.map(function (txIn) {

return {
hash: txIn.hash,
index: txIn.index,
script: txIn.script,
sequence: txIn.sequence,
witness: txIn.witness
}
 })

newTx.outs = this.outs.map(function (txOut) {

return {
script: txOut.script,
value: txOut.value
}
})

return newTx
}

/**
* Hash transaction for signing a specific input.
*
* Bitcoin uses a different hash for each signed transaction input.
* This method copies the transaction, makes the necessary changes based on the
* hashType, and then hashes the result.
* This hash can then be used to sign the provided transaction input.
*/
Transaction.prototype.hashForSignature = function (inIndex, prevOutScript,
hashType) {
typeforce(types.tuple(types.UInt32, types.Buffer, /* types.UInt8 */
types.Number), arguments)

// https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L29
if (inIndex >= this.ins.length) return ONE

// ignore OP_CODESEPARATOR
var ourScript = bscript.compile(bscript.decompile(prevOutScript).filter(function
(x) {
return x !== opcodes.OP_CODESEPARATOR
}))

var txTmp = this.clone()

// SIGHASH_NONE: ignore all outputs? (wildcard payee)

if ((hashType & 0x1f) === Transaction.SIGHASH_NONE) {
txTmp.outs = []

// ignore sequence numbers (except at inIndex)

txTmp.ins.forEach(function (input, i) {
if (i === inIndex) return

input.sequence = 0
})

// SIGHASH_SINGLE: ignore all outputs, except at the same index?

} else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE) {
//
https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L60
if (inIndex >= this.outs.length) return ONE

// truncate outputs after

txTmp.outs.length = inIndex + 1

// "blank" outputs before

for (var i = 0; i < inIndex; i++) {
txTmp.outs[i] = BLANK_OUTPUT
 }

// ignore sequence numbers (except at inIndex)

txTmp.ins.forEach(function (input, y) {
if (y === inIndex) return

input.sequence = 0
})
}

// SIGHASH_ANYONECANPAY: ignore inputs entirely?

if (hashType & Transaction.SIGHASH_ANYONECANPAY) {
txTmp.ins = [txTmp.ins[inIndex]]
txTmp.ins[0].script = ourScript

// SIGHASH_ALL: only ignore input scripts

} else {
// "blank" others input scripts
txTmp.ins.forEach(function (input) { input.script = EMPTY_SCRIPT })
txTmp.ins[inIndex].script = ourScript
}

// serialize and hash

var buffer = Buffer.allocUnsafe(txTmp.__byteLength(false) + 4)
buffer.writeInt32LE(hashType, buffer.length - 4)
txTmp.__toBuffer(buffer, 0, false)

return bcrypto.hash256(buffer)
}

Transaction.prototype.hashForWitnessV0 = function (inIndex, prevOutScript, value,

hashType) {
typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32),
arguments)

var tbuffer, toffset

function writeSlice (slice) { toffset += slice.copy(tbuffer, toffset) }
function writeUInt32 (i) { toffset = tbuffer.writeUInt32LE(i, toffset) }
function writeUInt64 (i) { toffset = bufferutils.writeUInt64LE(tbuffer, i,
toffset) }
function writeVarInt (i) {
varuint.encode(i, tbuffer, toffset)
toffset += varuint.encode.bytes
}
function writeVarSlice (slice) { writeVarInt(slice.length); writeSlice(slice) }

var hashOutputs = ZERO

var hashPrevouts = ZERO
var hashSequence = ZERO

if (!(hashType & Transaction.SIGHASH_ANYONECANPAY)) {

tbuffer = Buffer.allocUnsafe(36 * this.ins.length)
toffset = 0

this.ins.forEach(function (txIn) {
writeSlice(txIn.hash)
writeUInt32(txIn.index)
})
 hashPrevouts = bcrypto.hash256(tbuffer)
}

if (!(hashType & Transaction.SIGHASH_ANYONECANPAY) &&

(hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
tbuffer = Buffer.allocUnsafe(4 * this.ins.length)
toffset = 0

this.ins.forEach(function (txIn) {
writeUInt32(txIn.sequence)
})

hashSequence = bcrypto.hash256(tbuffer)
}

if ((hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&

(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
var txOutsSize = this.outs.reduce(function (sum, output) {
return sum + 8 + varSliceSize(output.script)
}, 0)

tbuffer = Buffer.allocUnsafe(txOutsSize)
toffset = 0

this.outs.forEach(function (out) {
writeUInt64(out.value)
writeVarSlice(out.script)
})

hashOutputs = bcrypto.hash256(tbuffer)
} else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE && inIndex <
this.outs.length) {
var output = this.outs[inIndex]

tbuffer = Buffer.allocUnsafe(8 + varSliceSize(output.script))

toffset = 0
writeUInt64(output.value)
writeVarSlice(output.script)

hashOutputs = bcrypto.hash256(tbuffer)
}

tbuffer = Buffer.allocUnsafe(156 + varSliceSize(prevOutScript))

toffset = 0

var input = this.ins[inIndex]

writeUInt32(this.version)
writeSlice(hashPrevouts)
writeSlice(hashSequence)
writeSlice(input.hash)
writeUInt32(input.index)
writeVarSlice(prevOutScript)
writeUInt64(value)
writeUInt32(input.sequence)
writeSlice(hashOutputs)
writeUInt32(this.locktime)
writeUInt32(hashType)
return bcrypto.hash256(tbuffer)
}

Transaction.prototype.getHash = function () {
return bcrypto.hash256(this.__toBuffer(undefined, undefined, false))
}

Transaction.prototype.getId = function () {
// transaction hash's are displayed in reverse order
return this.getHash().reverse().toString('hex')
}

Transaction.prototype.toBuffer = function (buffer, initialOffset) {

return this.__toBuffer(buffer, initialOffset, true)
}

Transaction.prototype.__toBuffer = function (buffer, initialOffset, __allowWitness)

{
if (!buffer) buffer = Buffer.allocUnsafe(this.__byteLength(__allowWitness))

var offset = initialOffset || 0

function writeSlice (slice) { offset += slice.copy(buffer, offset) }
function writeUInt8 (i) { offset = buffer.writeUInt8(i, offset) }
function writeUInt32 (i) { offset = buffer.writeUInt32LE(i, offset) }
function writeInt32 (i) { offset = buffer.writeInt32LE(i, offset) }
function writeUInt64 (i) { offset = bufferutils.writeUInt64LE(buffer, i,
offset) }
function writeVarInt (i) {
varuint.encode(i, buffer, offset)
offset += varuint.encode.bytes
}
function writeVarSlice (slice) { writeVarInt(slice.length); writeSlice(slice) }
function writeVector (vector) { writeVarInt(vector.length);
vector.forEach(writeVarSlice) }

writeInt32(this.version)

var hasWitnesses = __allowWitness && this.hasWitnesses()

if (hasWitnesses) {
writeUInt8(Transaction.ADVANCED_TRANSACTION_MARKER)
writeUInt8(Transaction.ADVANCED_TRANSACTION_FLAG)
}

writeVarInt(this.ins.length)

this.ins.forEach(function (txIn) {
writeSlice(txIn.hash)
writeUInt32(txIn.index)
writeVarSlice(txIn.script)
writeUInt32(txIn.sequence)
})

writeVarInt(this.outs.length)
this.outs.forEach(function (txOut) {
if (!txOut.valueBuffer) {
writeUInt64(txOut.value)
} else {
writeSlice(txOut.valueBuffer)
}
 writeVarSlice(txOut.script)
})

if (hasWitnesses) {
this.ins.forEach(function (input) {
writeVector(input.witness)
})
}

writeUInt32(this.locktime)

// avoid slicing unless necessary

if (initialOffset !== undefined) return buffer.slice(initialOffset, offset)
return buffer
}

Transaction.prototype.toHex = function () {
return this.toBuffer().toString('hex')
}

Transaction.prototype.setInputScript = function (index, scriptSig) {

typeforce(types.tuple(types.Number, types.Buffer), arguments)

this.ins[index].script = scriptSig
}

Transaction.prototype.setWitness = function (index, witness) {

typeforce(types.tuple(types.Number, [types.Buffer]), arguments)

this.ins[index].witness = witness
}

module.exports = Transaction

},{"./bufferutils":47,"./crypto":48,"./script":55,"./types":81,"bitcoin-
ops":8,"safe-buffer":30,"typeforce":41,"varuint-bitcoin":43}],80:
[function(require,module,exports){
var Buffer = require('safe-buffer').Buffer
var baddress = require('./address')
var bcrypto = require('./crypto')
var bscript = require('./script')
var btemplates = require('./templates')
var networks = require('./networks')
var ops = require('bitcoin-ops')
var typeforce = require('typeforce')
var types = require('./types')
var scriptTypes = btemplates.types
var SIGNABLE = [btemplates.types.P2PKH, btemplates.types.P2PK,
btemplates.types.MULTISIG]
var P2SH = SIGNABLE.concat([btemplates.types.P2WPKH, btemplates.types.P2WSH])

var ECPair = require('./ecpair')

var ECSignature = require('./ecsignature')
var Transaction = require('./transaction')

function supportedType (type) {

return SIGNABLE.indexOf(type) !== -1
}
function supportedP2SHType (type) {
return P2SH.indexOf(type) !== -1
}

function extractChunks (type, chunks, script) {

var pubKeys = []
var signatures = []
switch (type) {
case scriptTypes.P2PKH:
// if (redeemScript) throw new Error('Nonstandard... P2SH(P2PKH)')
pubKeys = chunks.slice(1)
signatures = chunks.slice(0, 1)
break

case scriptTypes.P2PK:
pubKeys[0] = script ? btemplates.pubKey.output.decode(script) : undefined
signatures = chunks.slice(0, 1)
break

case scriptTypes.MULTISIG:
if (script) {
var multisig = btemplates.multisig.output.decode(script)
pubKeys = multisig.pubKeys
}

signatures = chunks.slice(1).map(function (chunk) {

return chunk.length === 0 ? undefined : chunk
})
break
}

return {
pubKeys: pubKeys,
signatures: signatures
}
}
function expandInput (scriptSig, witnessStack) {
if (scriptSig.length === 0 && witnessStack.length === 0) return {}

var prevOutScript
var prevOutType
var scriptType
var script
var redeemScript
var witnessScript
var witnessScriptType
var redeemScriptType
var witness = false
var p2wsh = false
var p2sh = false
var witnessProgram
var chunks

var scriptSigChunks = bscript.decompile(scriptSig)

var sigType = btemplates.classifyInput(scriptSigChunks, true)
if (sigType === scriptTypes.P2SH) {
p2sh = true
redeemScript = scriptSigChunks[scriptSigChunks.length - 1]
 redeemScriptType = btemplates.classifyOutput(redeemScript)
prevOutScript =
btemplates.scriptHash.output.encode(bcrypto.hash160(redeemScript))
prevOutType = scriptTypes.P2SH
script = redeemScript
}

var classifyWitness = btemplates.classifyWitness(witnessStack, true)

if (classifyWitness === scriptTypes.P2WSH) {
witnessScript = witnessStack[witnessStack.length - 1]
witnessScriptType = btemplates.classifyOutput(witnessScript)
p2wsh = true
witness = true
if (scriptSig.length === 0) {
prevOutScript =
btemplates.witnessScriptHash.output.encode(bcrypto.sha256(witnessScript))
prevOutType = scriptTypes.P2WSH
if (redeemScript !== undefined) {
throw new Error('Redeem script given when unnecessary')
}
// bare witness
} else {
if (!redeemScript) {
throw new Error('No redeemScript provided for P2WSH, but scriptSig non-
empty')
}
witnessProgram =
btemplates.witnessScriptHash.output.encode(bcrypto.sha256(witnessScript))
if (!redeemScript.equals(witnessProgram)) {
throw new Error('Redeem script didn\'t match witnessScript')
}
}

if (!supportedType(btemplates.classifyOutput(witnessScript))) {
throw new Error('unsupported witness script')
}

script = witnessScript
scriptType = witnessScriptType
chunks = witnessStack.slice(0, -1)
} else if (classifyWitness === scriptTypes.P2WPKH) {
witness = true
var key = witnessStack[witnessStack.length - 1]
var keyHash = bcrypto.hash160(key)
if (scriptSig.length === 0) {
prevOutScript = btemplates.witnessPubKeyHash.output.encode(keyHash)
prevOutType = scriptTypes.P2WPKH
if (typeof redeemScript !== 'undefined') {
throw new Error('Redeem script given when unnecessary')
}
} else {
if (!redeemScript) {
throw new Error('No redeemScript provided for P2WPKH, but scriptSig wasn\'t
empty')
}
witnessProgram = btemplates.witnessPubKeyHash.output.encode(keyHash)
if (!redeemScript.equals(witnessProgram)) {
throw new Error('Redeem script did not have the right witness program')
}
 }

scriptType = scriptTypes.P2PKH
chunks = witnessStack
} else if (redeemScript) {
if (!supportedP2SHType(redeemScriptType)) {
throw new Error('Bad redeemscript!')
}

script = redeemScript
scriptType = redeemScriptType
chunks = scriptSigChunks.slice(0, -1)
} else {
prevOutType = scriptType = btemplates.classifyInput(scriptSig)
chunks = scriptSigChunks
}

var expanded = extractChunks(scriptType, chunks, script)

var result = {
pubKeys: expanded.pubKeys,
signatures: expanded.signatures,
prevOutScript: prevOutScript,
prevOutType: prevOutType,
signType: scriptType,
signScript: script,
witness: Boolean(witness)
}

if (p2sh) {
result.redeemScript = redeemScript
result.redeemScriptType = redeemScriptType
}

if (p2wsh) {
result.witnessScript = witnessScript
result.witnessScriptType = witnessScriptType
}

return result
}

// could be done in expandInput, but requires the original Transaction for

hashForSignature
function fixMultisigOrder (input, transaction, vin) {
if (input.redeemScriptType !== scriptTypes.MULTISIG || !input.redeemScript)
return
if (input.pubKeys.length === input.signatures.length) return

var unmatched = input.signatures.concat()

input.signatures = input.pubKeys.map(function (pubKey) {

var keyPair = ECPair.fromPublicKeyBuffer(pubKey)
var match

// check for a signature

unmatched.some(function (signature, i) {
// skip if undefined || OP_0
if (!signature) return false
 // TODO: avoid O(n) hashForSignature
var parsed = ECSignature.parseScriptSignature(signature)
var hash = transaction.hashForSignature(vin, input.redeemScript,
parsed.hashType)

// skip if signature does not match pubKey

if (!keyPair.verify(hash, parsed.signature)) return false

// remove matched signature from unmatched

unmatched[i] = undefined
match = signature

return true
})

return match
})
}

function expandOutput (script, scriptType, ourPubKey) {

typeforce(types.Buffer, script)

var scriptChunks = bscript.decompile(script)

if (!scriptType) {
scriptType = btemplates.classifyOutput(script)
}

var pubKeys = []

switch (scriptType) {
// does our hash160(pubKey) match the output scripts?
case scriptTypes.P2PKH:
if (!ourPubKey) break

var pkh1 = scriptChunks[2]

var pkh2 = bcrypto.hash160(ourPubKey)
if (pkh1.equals(pkh2)) pubKeys = [ourPubKey]
break

// does our hash160(pubKey) match the output scripts?

case scriptTypes.P2WPKH:
if (!ourPubKey) break

var wpkh1 = scriptChunks[1]

var wpkh2 = bcrypto.hash160(ourPubKey)
if (wpkh1.equals(wpkh2)) pubKeys = [ourPubKey]
break

case scriptTypes.P2PK:
pubKeys = scriptChunks.slice(0, 1)
break

case scriptTypes.MULTISIG:
pubKeys = scriptChunks.slice(1, -2)
break

default: return { scriptType: scriptType }

}
 return {
pubKeys: pubKeys,
scriptType: scriptType,
signatures: pubKeys.map(function () { return undefined })
}
}

function checkP2SHInput (input, redeemScriptHash) {

if (input.prevOutType) {
if (input.prevOutType !== scriptTypes.P2SH) throw new Error('PrevOutScript must
be P2SH')

var prevOutScriptScriptHash = bscript.decompile(input.prevOutScript)[1]

if (!prevOutScriptScriptHash.equals(redeemScriptHash)) throw new
Error('Inconsistent hash160(RedeemScript)')
}
}

function checkP2WSHInput (input, witnessScriptHash) {

if (input.prevOutType) {
if (input.prevOutType !== scriptTypes.P2WSH) throw new Error('PrevOutScript
must be P2WSH')

var scriptHash = bscript.decompile(input.prevOutScript)[1]

if (!scriptHash.equals(witnessScriptHash)) throw new Error('Inconsistent
sha25(WitnessScript)')
}
}

function prepareInput (input, kpPubKey, redeemScript, witnessValue, witnessScript)

{
var expanded
var prevOutType
var prevOutScript

var p2sh = false

var p2shType
var redeemScriptHash

var witness = false

var p2wsh = false
var witnessType
var witnessScriptHash

var signType
var signScript

if (redeemScript && witnessScript) {

redeemScriptHash = bcrypto.hash160(redeemScript)
witnessScriptHash = bcrypto.sha256(witnessScript)
checkP2SHInput(input, redeemScriptHash)

if (!
redeemScript.equals(btemplates.witnessScriptHash.output.encode(witnessScriptHash)))
throw new Error('Witness script inconsistent with redeem script')

expanded = expandOutput(witnessScript, undefined, kpPubKey)

if (!expanded.pubKeys) throw new Error('WitnessScript not supported "' +
bscript.toASM(redeemScript) + '"')

prevOutType = btemplates.types.P2SH
prevOutScript = btemplates.scriptHash.output.encode(redeemScriptHash)
p2sh = witness = p2wsh = true
p2shType = btemplates.types.P2WSH
signType = witnessType = expanded.scriptType
signScript = witnessScript
} else if (redeemScript) {
redeemScriptHash = bcrypto.hash160(redeemScript)
checkP2SHInput(input, redeemScriptHash)

expanded = expandOutput(redeemScript, undefined, kpPubKey)

if (!expanded.pubKeys) throw new Error('RedeemScript not supported "' +
bscript.toASM(redeemScript) + '"')

prevOutType = btemplates.types.P2SH
prevOutScript = btemplates.scriptHash.output.encode(redeemScriptHash)
p2sh = true
signType = p2shType = expanded.scriptType
signScript = redeemScript
witness = signType === btemplates.types.P2WPKH
} else if (witnessScript) {
witnessScriptHash = bcrypto.sha256(witnessScript)
checkP2WSHInput(input, witnessScriptHash)

expanded = expandOutput(witnessScript, undefined, kpPubKey)

if (!expanded.pubKeys) throw new Error('WitnessScript not supported "' +
bscript.toASM(redeemScript) + '"')

prevOutType = btemplates.types.P2WSH
prevOutScript = btemplates.witnessScriptHash.output.encode(witnessScriptHash)
witness = p2wsh = true
signType = witnessType = expanded.scriptType
signScript = witnessScript
} else if (input.prevOutType) {
// embedded scripts are not possible without a redeemScript
if (input.prevOutType === scriptTypes.P2SH ||
input.prevOutType === scriptTypes.P2WSH) {
throw new Error('PrevOutScript is ' + input.prevOutType + ', requires
redeemScript')
}

prevOutType = input.prevOutType
prevOutScript = input.prevOutScript
expanded = expandOutput(input.prevOutScript, input.prevOutType, kpPubKey)
if (!expanded.pubKeys) return

witness = (input.prevOutType === scriptTypes.P2WPKH)

signType = prevOutType
signScript = prevOutScript
} else {
prevOutScript = btemplates.pubKeyHash.output.encode(bcrypto.hash160(kpPubKey))
expanded = expandOutput(prevOutScript, scriptTypes.P2PKH, kpPubKey)

prevOutType = scriptTypes.P2PKH
witness = false
signType = prevOutType
signScript = prevOutScript
 }

if (signType === scriptTypes.P2WPKH) {

signScript =
btemplates.pubKeyHash.output.encode(btemplates.witnessPubKeyHash.output.decode(sign
Script))
}

if (p2sh) {
input.redeemScript = redeemScript
input.redeemScriptType = p2shType
}

if (p2wsh) {
input.witnessScript = witnessScript
input.witnessScriptType = witnessType
}

input.pubKeys = expanded.pubKeys
input.signatures = expanded.signatures
input.signScript = signScript
input.signType = signType
input.prevOutScript = prevOutScript
input.prevOutType = prevOutType
input.witness = witness
}

function buildStack (type, signatures, pubKeys, allowIncomplete) {

if (type === scriptTypes.P2PKH) {
if (signatures.length === 1 && Buffer.isBuffer(signatures[0]) && pubKeys.length
=== 1) return btemplates.pubKeyHash.input.encodeStack(signatures[0], pubKeys[0])
} else if (type === scriptTypes.P2PK) {
if (signatures.length === 1 && Buffer.isBuffer(signatures[0])) return
btemplates.pubKey.input.encodeStack(signatures[0])
} else if (type === scriptTypes.MULTISIG) {
if (signatures.length > 0) {
signatures = signatures.map(function (signature) {
return signature || ops.OP_0
})
if (!allowIncomplete) {
// remove blank signatures
signatures = signatures.filter(function (x) { return x !== ops.OP_0 })
}

return btemplates.multisig.input.encodeStack(signatures)
}
} else {
throw new Error('Not yet supported')
}

if (!allowIncomplete) throw new Error('Not enough signatures provided')

return []
}

function buildInput (input, allowIncomplete) {

var scriptType = input.prevOutType
var sig = []
var witness = []
 if (supportedType(scriptType)) {
sig = buildStack(scriptType, input.signatures, input.pubKeys, allowIncomplete)
}

var p2sh = false

if (scriptType === btemplates.types.P2SH) {
// We can remove this error later when we have a guarantee prepareInput
// rejects unsignable scripts - it MUST be signable at this point.
if (!allowIncomplete && !supportedP2SHType(input.redeemScriptType)) {
throw new Error('Impossible to sign this type')
}

if (supportedType(input.redeemScriptType)) {
sig = buildStack(input.redeemScriptType, input.signatures, input.pubKeys,
allowIncomplete)
}

// If it wasn't SIGNABLE, it's witness, defer to that

if (input.redeemScriptType) {
p2sh = true
scriptType = input.redeemScriptType
}
}

switch (scriptType) {
// P2WPKH is a special case of P2PKH
case btemplates.types.P2WPKH:
witness = buildStack(btemplates.types.P2PKH, input.signatures, input.pubKeys,
allowIncomplete)
break

case btemplates.types.P2WSH:
// We can remove this check later
if (!allowIncomplete && !supportedType(input.witnessScriptType)) {
throw new Error('Impossible to sign this type')
}

if (supportedType(input.witnessScriptType)) {
witness = buildStack(input.witnessScriptType, input.signatures,
input.pubKeys, allowIncomplete)
witness.push(input.witnessScript)
scriptType = input.witnessScriptType
}

break
}

// append redeemScript if necessary

if (p2sh) {
sig.push(input.redeemScript)
}

return {
type: scriptType,
script: bscript.compile(sig),
witness: witness
}
}
function TransactionBuilder (network, maximumFeeRate) {
this.prevTxMap = {}
this.network = network || networks.bitcoin

// WARNING: This is __NOT__ to be relied on, its just another potential safety
mechanism (safety in-depth)
this.maximumFeeRate = maximumFeeRate || 2500

this.inputs = []
this.tx = new Transaction()
}

TransactionBuilder.prototype.setLockTime = function (locktime) {

typeforce(types.UInt32, locktime)

// if any signatures exist, throw

if (this.inputs.some(function (input) {
if (!input.signatures) return false

return input.signatures.some(function (s) { return s })

})) {
throw new Error('No, this would invalidate signatures')
}

this.tx.locktime = locktime
}

TransactionBuilder.prototype.setVersion = function (version) {

typeforce(types.UInt32, version)

// XXX: this might eventually become more complex depending on what the versions
represent
this.tx.version = version
}

TransactionBuilder.fromTransaction = function (transaction, network) {

var txb = new TransactionBuilder(network)

// Copy transaction fields

txb.setVersion(transaction.version)
txb.setLockTime(transaction.locktime)

// Copy outputs (done first to avoid signature invalidation)

transaction.outs.forEach(function (txOut) {
txb.addOutput(txOut.script, txOut.value)
})

// Copy inputs
transaction.ins.forEach(function (txIn) {
txb.__addInputUnsafe(txIn.hash, txIn.index, {
sequence: txIn.sequence,
script: txIn.script,
witness: txIn.witness
})
})

// fix some things not possible through the public API

txb.inputs.forEach(function (input, i) {
fixMultisigOrder(input, transaction, i)
 })

return txb
}

TransactionBuilder.prototype.addInput = function (txHash, vout, sequence,

prevOutScript) {
if (!this.__canModifyInputs()) {
throw new Error('No, this would invalidate signatures')
}

var value

// is it a hex string?
if (typeof txHash === 'string') {
// transaction hashs's are displayed in reverse order, un-reverse it
txHash = Buffer.from(txHash, 'hex').reverse()

// is it a Transaction object?
} else if (txHash instanceof Transaction) {
var txOut = txHash.outs[vout]
prevOutScript = txOut.script
value = txOut.value

txHash = txHash.getHash()
}

return this.__addInputUnsafe(txHash, vout, {

sequence: sequence,
prevOutScript: prevOutScript,
value: value
})
}

TransactionBuilder.prototype.__addInputUnsafe = function (txHash, vout, options) {

if (Transaction.isCoinbaseHash(txHash)) {
throw new Error('coinbase inputs not supported')
}

var prevTxOut = txHash.toString('hex') + ':' + vout

if (this.prevTxMap[prevTxOut] !== undefined) throw new Error('Duplicate TxOut: '
+ prevTxOut)

var input = {}

// derive what we can from the scriptSig

if (options.script !== undefined) {
input = expandInput(options.script, options.witness || [])
}

// if an input value was given, retain it

if (options.value !== undefined) {
input.value = options.value
}

// derive what we can from the previous transactions output script

if (!input.prevOutScript && options.prevOutScript) {
var prevOutType
 if (!input.pubKeys && !input.signatures) {
var expanded = expandOutput(options.prevOutScript)

if (expanded.pubKeys) {
input.pubKeys = expanded.pubKeys
input.signatures = expanded.signatures
}

prevOutType = expanded.scriptType
}

input.prevOutScript = options.prevOutScript
input.prevOutType = prevOutType ||
btemplates.classifyOutput(options.prevOutScript)
}

var vin = this.tx.addInput(txHash, vout, options.sequence, options.scriptSig)

this.inputs[vin] = input
this.prevTxMap[prevTxOut] = vin
return vin
}

TransactionBuilder.prototype.addOutput = function (scriptPubKey, value) {

if (!this.__canModifyOutputs()) {
throw new Error('No, this would invalidate signatures')
}

// Attempt to get a script if it's a base58 address string

if (typeof scriptPubKey === 'string') {
scriptPubKey = baddress.toOutputScript(scriptPubKey, this.network)
}

return this.tx.addOutput(scriptPubKey, value)

}

TransactionBuilder.prototype.build = function () {
return this.__build(false)
}
TransactionBuilder.prototype.buildIncomplete = function () {
return this.__build(true)
}

TransactionBuilder.prototype.__build = function (allowIncomplete) {

if (!allowIncomplete) {
if (!this.tx.ins.length) throw new Error('Transaction has no inputs')
if (!this.tx.outs.length) throw new Error('Transaction has no outputs')
}

var tx = this.tx.clone()
// Create script signatures from inputs
this.inputs.forEach(function (input, i) {
var scriptType = input.witnessScriptType || input.redeemScriptType ||
input.prevOutType
if (!scriptType && !allowIncomplete) throw new Error('Transaction is not
complete')
var result = buildInput(input, allowIncomplete)

// skip if no result
if (!allowIncomplete) {
 if (!supportedType(result.type) && result.type !== btemplates.types.P2WPKH) {
throw new Error(result.type + ' not supported')
}
}

tx.setInputScript(i, result.script)
tx.setWitness(i, result.witness)
})

if (!allowIncomplete) {
// do not rely on this, its merely a last resort
if (this.__overMaximumFees(tx.virtualSize())) {
throw new Error('Transaction has absurd fees')
}
}

return tx
}

function canSign (input) {

return input.prevOutScript !== undefined &&
input.signScript !== undefined &&
input.pubKeys !== undefined &&
input.signatures !== undefined &&
input.signatures.length === input.pubKeys.length &&
input.pubKeys.length > 0 &&
(
input.witness === false ||
(input.witness === true && input.value !== undefined)
)
}

TransactionBuilder.prototype.sign = function (vin, keyPair, redeemScript, hashType,

witnessValue, witnessScript) {
// TODO: remove keyPair.network matching in 4.0.0
if (keyPair.network && keyPair.network !== this.network) throw new
TypeError('Inconsistent network')
if (!this.inputs[vin]) throw new Error('No input at index: ' + vin)
hashType = hashType || Transaction.SIGHASH_ALL

var input = this.inputs[vin]

// if redeemScript was previously provided, enforce consistency

if (input.redeemScript !== undefined &&
redeemScript &&
!input.redeemScript.equals(redeemScript)) {
throw new Error('Inconsistent redeemScript')
}

var kpPubKey = keyPair.publicKey || keyPair.getPublicKeyBuffer()

if (!canSign(input)) {
if (witnessValue !== undefined) {
if (input.value !== undefined && input.value !== witnessValue) throw new
Error('Input didn\'t match witnessValue')
typeforce(types.Satoshi, witnessValue)
input.value = witnessValue
}

if (!canSign(input)) prepareInput(input, kpPubKey, redeemScript, witnessValue,

witnessScript)
if (!canSign(input)) throw Error(input.prevOutType + ' not supported')
}

// ready to sign
var signatureHash
if (input.witness) {
signatureHash = this.tx.hashForWitnessV0(vin, input.signScript, input.value,
hashType)
} else {
signatureHash = this.tx.hashForSignature(vin, input.signScript, hashType)
}

// enforce in order signing of public keys

var signed = input.pubKeys.some(function (pubKey, i) {
if (!kpPubKey.equals(pubKey)) return false
if (input.signatures[i]) throw new Error('Signature already exists')
if (kpPubKey.length !== 33 &&
input.signType === scriptTypes.P2WPKH) throw new Error('BIP143 rejects
uncompressed public keys in P2WPKH or P2WSH')

var signature = keyPair.sign(signatureHash)

if (Buffer.isBuffer(signature)) signature = ECSignature.fromRSBuffer(signature)

input.signatures[i] = signature.toScriptSignature(hashType)
return true
})

if (!signed) throw new Error('Key pair cannot sign for this input')
}

function signatureHashType (buffer) {

return buffer.readUInt8(buffer.length - 1)
}

TransactionBuilder.prototype.__canModifyInputs = function () {
return this.inputs.every(function (input) {
// any signatures?
if (input.signatures === undefined) return true

return input.signatures.every(function (signature) {

if (!signature) return true
var hashType = signatureHashType(signature)

// if SIGHASH_ANYONECANPAY is set, signatures would not

// be invalidated by more inputs
return hashType & Transaction.SIGHASH_ANYONECANPAY
})
})
}

TransactionBuilder.prototype.__canModifyOutputs = function () {
var nInputs = this.tx.ins.length
var nOutputs = this.tx.outs.length

return this.inputs.every(function (input) {

if (input.signatures === undefined) return true

return input.signatures.every(function (signature) {

 if (!signature) return true
var hashType = signatureHashType(signature)

var hashTypeMod = hashType & 0x1f

if (hashTypeMod === Transaction.SIGHASH_NONE) return true
if (hashTypeMod === Transaction.SIGHASH_SINGLE) {
// if SIGHASH_SINGLE is set, and nInputs > nOutputs
// some signatures would be invalidated by the addition
// of more outputs
return nInputs <= nOutputs
}
})
})
}

TransactionBuilder.prototype.__overMaximumFees = function (bytes) {

// not all inputs will have .value defined
var incoming = this.inputs.reduce(function (a, x) { return a + (x.value >>> 0) },
0)

// but all outputs do, and if we have any input value

// we can immediately determine if the outputs are too small
var outgoing = this.tx.outs.reduce(function (a, x) { return a + x.value }, 0)
var fee = incoming - outgoing
var feeRate = fee / bytes

return feeRate > this.maximumFeeRate

}

module.exports = TransactionBuilder

},{"./address":45,"./crypto":48,"./ecpair":50,"./ecsignature":51,"./
networks":54,"./script":55,"./templates":57,"./transaction":79,"./
types":81,"bitcoin-ops":8,"safe-buffer":30,"typeforce":41}],81:
[function(require,module,exports){
var typeforce = require('typeforce')

var UINT31_MAX = Math.pow(2, 31) - 1

function UInt31 (value) {
return typeforce.UInt32(value) && value <= UINT31_MAX
}

function BIP32Path (value) {

return typeforce.String(value) && value.match(/^(m\/)?(\d+'?\/)*\d+'?$/)
}
BIP32Path.toJSON = function () { return 'BIP32 derivation path' }

var SATOSHI_MAX = 21 * 1e14

function Satoshi (value) {
return typeforce.UInt53(value) && value <= SATOSHI_MAX
}

// external dependent types

var BigInt = typeforce.quacksLike('BigInteger')
var ECPoint = typeforce.quacksLike('Point')

// exposed, external API

var ECSignature = typeforce.compile({ r: BigInt, s: BigInt })
var Network = typeforce.compile({
 messagePrefix: typeforce.oneOf(typeforce.Buffer, typeforce.String),
bip32: {
public: typeforce.UInt32,
private: typeforce.UInt32
},
pubKeyHash: typeforce.UInt8,
scriptHash: typeforce.UInt8,
wif: typeforce.UInt8
})

// extend typeforce types with ours

var types = {
BigInt: BigInt,
BIP32Path: BIP32Path,
Buffer256bit: typeforce.BufferN(32),
ECPoint: ECPoint,
ECSignature: ECSignature,
Hash160bit: typeforce.BufferN(20),
Hash256bit: typeforce.BufferN(32),
Network: Network,
Satoshi: Satoshi,
UInt31: UInt31
}

for (var typeName in typeforce) {

types[typeName] = typeforce[typeName]
}

module.exports = types

},{"typeforce":41}],82:[function(require,module,exports){
// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
//
// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
//
// Originally from narwhal.js (http://narwhaljs.org)
// Copyright (c) 2009 Thomas Robinson <280north.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the 'Software'), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// when used in node, this will actually load the util module we depend on
// versus loading the builtin util module as happens otherwise
// this is a bug in node module loading as far as I am concerned
var util = require('util/');
var pSlice = Array.prototype.slice;
var hasOwn = Object.prototype.hasOwnProperty;

// 1. The assert module provides functions that throw

// AssertionError's when particular conditions are not met. The
// assert module must conform to the following interface.

var assert = module.exports = ok;

// 2. The AssertionError is defined in assert.

// new assert.AssertionError({ message: message,
// actual: actual,
// expected: expected })

assert.AssertionError = function AssertionError(options) {

this.name = 'AssertionError';
this.actual = options.actual;
this.expected = options.expected;
this.operator = options.operator;
if (options.message) {
this.message = options.message;
this.generatedMessage = false;
} else {
this.message = getMessage(this);
this.generatedMessage = true;
}
var stackStartFunction = options.stackStartFunction || fail;

if (Error.captureStackTrace) {
Error.captureStackTrace(this, stackStartFunction);
}
else {
// non v8 browsers so we can have a stacktrace
var err = new Error();
if (err.stack) {
var out = err.stack;

// try to strip useless frames

var fn_name = stackStartFunction.name;
var idx = out.indexOf('\n' + fn_name);
if (idx >= 0) {
// once we have located the function frame
// we need to strip out everything before it (and its line)
var next_line = out.indexOf('\n', idx + 1);
out = out.substring(next_line + 1);
}

this.stack = out;
}
}
};

// assert.AssertionError instanceof Error

util.inherits(assert.AssertionError, Error);

function replacer(key, value) {

if (util.isUndefined(value)) {
return '' + value;
 }
if (util.isNumber(value) && !isFinite(value)) {
return value.toString();
}
if (util.isFunction(value) || util.isRegExp(value)) {
return value.toString();
}
return value;
}

function truncate(s, n) {
if (util.isString(s)) {
return s.length < n ? s : s.slice(0, n);
} else {
return s;
}
}

function getMessage(self) {
return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
self.operator + ' ' +
truncate(JSON.stringify(self.expected, replacer), 128);
}

// At present only the three keys mentioned above are used and
// understood by the spec. Implementations or sub modules can pass
// other keys to the AssertionError's constructor - they will be
// ignored.

// 3. All of the following functions must throw an AssertionError

// when a corresponding condition is not met, with a message that
// may be undefined if not provided. All assertion methods provide
// both the actual and expected values to the assertion error for
// display purposes.

function fail(actual, expected, message, operator, stackStartFunction) {

throw new assert.AssertionError({
message: message,
actual: actual,
expected: expected,
operator: operator,
stackStartFunction: stackStartFunction
});
}

// EXTENSION! allows for well behaved errors defined elsewhere.

assert.fail = fail;

// 4. Pure assertion tests whether a value is truthy, as determined

// by !!guard.
// assert.ok(guard, message_opt);
// This statement is equivalent to assert.equal(true, !!guard,
// message_opt);. To test strictly for the value true, use
// assert.strictEqual(true, guard, message_opt);.

function ok(value, message) {

if (!value) fail(value, true, message, '==', assert.ok);
}
assert.ok = ok;
// 5. The equality assertion tests shallow, coercive equality with
// ==.
// assert.equal(actual, expected, message_opt);

assert.equal = function equal(actual, expected, message) {

if (actual != expected) fail(actual, expected, message, '==', assert.equal);
};

// 6. The non-equality assertion tests for whether two objects are not equal
// with != assert.notEqual(actual, expected, message_opt);

assert.notEqual = function notEqual(actual, expected, message) {

if (actual == expected) {
fail(actual, expected, message, '!=', assert.notEqual);
}
};

// 7. The equivalence assertion tests a deep equality relation.

// assert.deepEqual(actual, expected, message_opt);

assert.deepEqual = function deepEqual(actual, expected, message) {

if (!_deepEqual(actual, expected)) {
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
}
};

function _deepEqual(actual, expected) {

// 7.1. All identical values are equivalent, as determined by ===.
if (actual === expected) {
return true;

} else if (util.isBuffer(actual) && util.isBuffer(expected)) {

if (actual.length != expected.length) return false;

for (var i = 0; i < actual.length; i++) {

if (actual[i] !== expected[i]) return false;
}

return true;

// 7.2. If the expected value is a Date object, the actual value is

// equivalent if it is also a Date object that refers to the same time.
} else if (util.isDate(actual) && util.isDate(expected)) {
return actual.getTime() === expected.getTime();

// 7.3 If the expected value is a RegExp object, the actual value is

// equivalent if it is also a RegExp object with the same source and
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
return actual.source === expected.source &&
actual.global === expected.global &&
actual.multiline === expected.multiline &&
actual.lastIndex === expected.lastIndex &&
actual.ignoreCase === expected.ignoreCase;

// 7.4. Other pairs that do not both pass typeof value == 'object',
// equivalence is determined by ==.
} else if (!util.isObject(actual) && !util.isObject(expected)) {
 return actual == expected;

// 7.5 For all other Object pairs, including Array objects, equivalence is
// determined by having the same number of owned properties (as verified
// with Object.prototype.hasOwnProperty.call), the same set of keys
// (although not necessarily the same order), equivalent values for every
// corresponding key, and an identical 'prototype' property. Note: this
// accounts for both named and indexed properties on Arrays.
} else {
return objEquiv(actual, expected);
}
}

function isArguments(object) {
return Object.prototype.toString.call(object) == '[object Arguments]';
}

function objEquiv(a, b) {
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
return false;
// an identical 'prototype' property.
if (a.prototype !== b.prototype) return false;
// if one is a primitive, the other must be same
if (util.isPrimitive(a) || util.isPrimitive(b)) {
return a === b;
}
var aIsArgs = isArguments(a),
bIsArgs = isArguments(b);
if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
return false;
if (aIsArgs) {
a = pSlice.call(a);
b = pSlice.call(b);
return _deepEqual(a, b);
}
var ka = objectKeys(a),
kb = objectKeys(b),
key, i;
// having the same number of owned properties (keys incorporates
// hasOwnProperty)
if (ka.length != kb.length)
return false;
//the same set of keys (although not necessarily the same order),
ka.sort();
kb.sort();
//~~~cheap key test
for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] != kb[i])
return false;
}
//equivalent values for every corresponding key, and
//~~~possibly expensive deep test
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!_deepEqual(a[key], b[key])) return false;
}
return true;
}
// 8. The non-equivalence assertion tests for any deep inequality.
// assert.notDeepEqual(actual, expected, message_opt);

assert.notDeepEqual = function notDeepEqual(actual, expected, message) {

if (_deepEqual(actual, expected)) {
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
}
};

// 9. The strict equality assertion tests strict equality, as determined by ===.

// assert.strictEqual(actual, expected, message_opt);

assert.strictEqual = function strictEqual(actual, expected, message) {

if (actual !== expected) {
fail(actual, expected, message, '===', assert.strictEqual);
}
};

// 10. The strict non-equality assertion tests for strict inequality, as

// determined by !==. assert.notStrictEqual(actual, expected, message_opt);

assert.notStrictEqual = function notStrictEqual(actual, expected, message) {

if (actual === expected) {
fail(actual, expected, message, '!==', assert.notStrictEqual);
}
};

function expectedException(actual, expected) {

if (!actual || !expected) {
return false;
}

if (Object.prototype.toString.call(expected) == '[object RegExp]') {

return expected.test(actual);
} else if (actual instanceof expected) {
return true;
} else if (expected.call({}, actual) === true) {
return true;
}

return false;
}

function _throws(shouldThrow, block, expected, message) {

var actual;

if (util.isString(expected)) {
message = expected;
expected = null;
}

try {
block();
} catch (e) {
actual = e;
}

message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +

(message ? ' ' + message : '.');
 if (shouldThrow && !actual) {
fail(actual, expected, 'Missing expected exception' + message);
}

if (!shouldThrow && expectedException(actual, expected)) {

fail(actual, expected, 'Got unwanted exception' + message);
}

if ((shouldThrow && actual && expected &&

!expectedException(actual, expected)) || (!shouldThrow && actual)) {
throw actual;
}
}

// 11. Expected to throw an error:

// assert.throws(block, Error_opt, message_opt);

assert.throws = function(block, /*optional*/error, /*optional*/message) {

_throws.apply(this, [true].concat(pSlice.call(arguments)));
};

// EXTENSION! This is annoying to write outside this module.

assert.doesNotThrow = function(block, /*optional*/message) {
_throws.apply(this, [false].concat(pSlice.call(arguments)));
};

assert.ifError = function(err) { if (err) {throw err;}};

var objectKeys = Object.keys || function (obj) {

var keys = [];
for (var key in obj) {
if (hasOwn.call(obj, key)) keys.push(key);
}
return keys;
};

},{"util/":106}],83:[function(require,module,exports){

},{}],84:[function(require,module,exports){
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <[email protected]> <http://feross.org>
* @license MIT
*/

var base64 = require('base64-js')

var ieee754 = require('ieee754')
var isArray = require('is-array')

exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50
Buffer.poolSize = 8192 // not used by this implementation

var kMaxLength = 0x3fffffff

var rootParent = {}
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari
5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Note:
*
* - Implementation must support adding new properties to `Uint8Array` instances.
* Firefox 4-29 lacked support, fixed in Firefox 30+.
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
*
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
*
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns
arrays of
* incorrect length in some situations.
*
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false`
so they will
* get the Object implementation, which is slower but will work correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = (function () {
try {
var buf = new ArrayBuffer(0)
var arr = new Uint8Array(buf)
arr.foo = function () { return 42 }
return arr.foo() === 42 && // typed array instances can be augmented
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken
`subarray`
} catch (e) {
return false
}
})()

/**
* Class: Buffer
* =============
*
* The Buffer constructor returns instances of `Uint8Array` that are augmented
* with function properties for all the node `Buffer` API functions. We use
* `Uint8Array` so that square bracket notation works as expected -- it returns
* a single octet.
*
* By augmenting the instances, we can avoid modifying the `Uint8Array`
* prototype.
*/
function Buffer (subject, encoding, noZero) {
if (!(this instanceof Buffer))
return new Buffer(subject, encoding, noZero)

var type = typeof subject

// Find the length

var length
 if (type === 'number') {
length = +subject
} else if (type === 'string') {
length = Buffer.byteLength(subject, encoding)
} else if (type === 'object' && subject !== null) { // assume object is array-
like
if (subject.type === 'Buffer' && isArray(subject.data))
subject = subject.data
length = +subject.length
} else {
throw new TypeError('must start with number, buffer, array or string')
}

if (length > kMaxLength)

throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + kMaxLength.toString(16) + ' bytes')

if (length < 0)
length = 0
else
length >>>= 0 // Coerce to uint32.

var self = this

if (Buffer.TYPED_ARRAY_SUPPORT) {
// Preferred: Return an augmented `Uint8Array` instance for best performance
/*eslint-disable consistent-this */
self = Buffer._augment(new Uint8Array(length))
/*eslint-enable consistent-this */
} else {
// Fallback: Return THIS instance of Buffer (created by `new`)
self.length = length
self._isBuffer = true
}

var i
if (Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') {
// Speed optimization -- use set if we're copying from a typed array
self._set(subject)
} else if (isArrayish(subject)) {
// Treat array-ish objects as a byte array
if (Buffer.isBuffer(subject)) {
for (i = 0; i < length; i++)
self[i] = subject.readUInt8(i)
} else {
for (i = 0; i < length; i++)
self[i] = ((subject[i] % 256) + 256) % 256
}
} else if (type === 'string') {
self.write(subject, 0, encoding)
} else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT && !noZero) {
for (i = 0; i < length; i++) {
self[i] = 0
}
}

if (length > 0 && length <= Buffer.poolSize)

self.parent = rootParent

return self
}

function SlowBuffer (subject, encoding, noZero) {

if (!(this instanceof SlowBuffer))
return new SlowBuffer(subject, encoding, noZero)

var buf = new Buffer(subject, encoding, noZero)

delete buf.parent
return buf
}

Buffer.isBuffer = function (b) {

return !!(b != null && b._isBuffer)
}

Buffer.compare = function (a, b) {

if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b))
throw new TypeError('Arguments must be Buffers')

if (a === b) return 0

var x = a.length
var y = b.length
for (var i = 0, len = Math.min(x, y); i < len && a[i] === b[i]; i++) {}
if (i !== len) {
x = a[i]
y = b[i]
}
if (x < y) return -1
if (y < x) return 1
return 0
}

Buffer.isEncoding = function (encoding) {

switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'binary':
case 'base64':
case 'raw':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}

Buffer.concat = function (list, totalLength) {

if (!isArray(list)) throw new TypeError('Usage: Buffer.concat(list[, length])')

if (list.length === 0) {
return new Buffer(0)
} else if (list.length === 1) {
return list[0]
 }

var i
if (totalLength === undefined) {
totalLength = 0
for (i = 0; i < list.length; i++) {
totalLength += list[i].length
}
}

var buf = new Buffer(totalLength)

var pos = 0
for (i = 0; i < list.length; i++) {
var item = list[i]
item.copy(buf, pos)
pos += item.length
}
return buf
}

Buffer.byteLength = function (str, encoding) {

var ret
str = str + ''
switch (encoding || 'utf8') {
case 'ascii':
case 'binary':
case 'raw':
ret = str.length
break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = str.length * 2
break
case 'hex':
ret = str.length >>> 1
break
case 'utf8':
case 'utf-8':
ret = utf8ToBytes(str).length
break
case 'base64':
ret = base64ToBytes(str).length
break
default:
ret = str.length
}
return ret
}

// pre-set for values that may exist in the future

Buffer.prototype.length = undefined
Buffer.prototype.parent = undefined

// toString(encoding, start=0, end=buffer.length)

Buffer.prototype.toString = function (encoding, start, end) {
var loweredCase = false
 start = start >>> 0
end = end === undefined || end === Infinity ? this.length : end >>> 0

if (!encoding) encoding = 'utf8'

if (start < 0) start = 0
if (end > this.length) end = this.length
if (end <= start) return ''

while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)

case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)

case 'ascii':
return asciiSlice(this, start, end)

case 'binary':
return binarySlice(this, start, end)

case 'base64':
return base64Slice(this, start, end)

case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)

default:
if (loweredCase)
throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}

Buffer.prototype.equals = function (b) {

if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if (this.length > 0) {
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
if (this.length > max)
str += ' ... '
}
return '<Buffer ' + str + '>'
}

Buffer.prototype.compare = function (b) {

 if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return 0
return Buffer.compare(this, b)
}

// `get` will be removed in Node 0.13+

Buffer.prototype.get = function (offset) {
console.log('.get() is deprecated. Access using array indexes instead.')
return this.readUInt8(offset)
}

// `set` will be removed in Node 0.13+

Buffer.prototype.set = function (v, offset) {
console.log('.set() is deprecated. Access using array indexes instead.')
return this.writeUInt8(v, offset)
}

function hexWrite (buf, string, offset, length) {

offset = Number(offset) || 0
var remaining = buf.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}

// must be an even number of digits

var strLen = string.length
if (strLen % 2 !== 0) throw new Error('Invalid hex string')

if (length > strLen / 2) {

length = strLen / 2
}
for (var i = 0; i < length; i++) {
var byte = parseInt(string.substr(i * 2, 2), 16)
if (isNaN(byte)) throw new Error('Invalid hex string')
buf[offset + i] = byte
}
return i
}

function utf8Write (buf, string, offset, length) {

var charsWritten = blitBuffer(utf8ToBytes(string, buf.length - offset), buf,
offset, length)
return charsWritten
}

function asciiWrite (buf, string, offset, length) {

var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length)
return charsWritten
}

function binaryWrite (buf, string, offset, length) {

return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length)
return charsWritten
}

function utf16leWrite (buf, string, offset, length) {

var charsWritten = blitBuffer(utf16leToBytes(string, buf.length - offset), buf,
offset, length)
return charsWritten
}

Buffer.prototype.write = function (string, offset, length, encoding) {

// Support both (string, offset, length, encoding)
// and the legacy (string, encoding, offset, length)
if (isFinite(offset)) {
if (!isFinite(length)) {
encoding = length
length = undefined
}
} else { // legacy
var swap = encoding
encoding = offset
offset = length
length = swap
}

offset = Number(offset) || 0

if (length < 0 || offset < 0 || offset > this.length)

throw new RangeError('attempt to write outside buffer bounds')

var remaining = this.length - offset

if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
encoding = String(encoding || 'utf8').toLowerCase()

var ret
switch (encoding) {
case 'hex':
ret = hexWrite(this, string, offset, length)
break
case 'utf8':
case 'utf-8':
ret = utf8Write(this, string, offset, length)
break
case 'ascii':
ret = asciiWrite(this, string, offset, length)
break
case 'binary':
ret = binaryWrite(this, string, offset, length)
break
case 'base64':
ret = base64Write(this, string, offset, length)
 break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = utf16leWrite(this, string, offset, length)
break
default:
throw new TypeError('Unknown encoding: ' + encoding)
}
return ret
}

Buffer.prototype.toJSON = function () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
}

function base64Slice (buf, start, end) {

if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}

function utf8Slice (buf, start, end) {

var res = ''
var tmp = ''
end = Math.min(buf.length, end)

for (var i = start; i < end; i++) {

if (buf[i] <= 0x7F) {
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
tmp = ''
} else {
tmp += '%' + buf[i].toString(16)
}
}

return res + decodeUtf8Char(tmp)

}

function asciiSlice (buf, start, end) {

var ret = ''
end = Math.min(buf.length, end)

for (var i = start; i < end; i++) {

ret += String.fromCharCode(buf[i] & 0x7F)
}
return ret
}

function binarySlice (buf, start, end) {

var ret = ''
end = Math.min(buf.length, end)
 for (var i = start; i < end; i++) {
ret += String.fromCharCode(buf[i])
}
return ret
}

function hexSlice (buf, start, end) {

var len = buf.length

if (!start || start < 0) start = 0

if (!end || end < 0 || end > len) end = len

var out = ''

for (var i = start; i < end; i++) {
out += toHex(buf[i])
}
return out
}

function utf16leSlice (buf, start, end) {

var bytes = buf.slice(start, end)
var res = ''
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
}
return res
}

Buffer.prototype.slice = function (start, end) {

var len = this.length
start = ~~start
end = end === undefined ? len : ~~end

if (start < 0) {
start += len
if (start < 0)
start = 0
} else if (start > len) {
start = len
}

if (end < 0) {
end += len
if (end < 0)
end = 0
} else if (end > len) {
end = len
}

if (end < start)

end = start

var newBuf
if (Buffer.TYPED_ARRAY_SUPPORT) {
newBuf = Buffer._augment(this.subarray(start, end))
} else {
var sliceLen = end - start
newBuf = new Buffer(sliceLen, undefined, true)
for (var i = 0; i < sliceLen; i++) {
 newBuf[i] = this[i + start]
}
}

if (newBuf.length)
newBuf.parent = this.parent || this

return newBuf
}

/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0)
throw new RangeError('offset is not uint')
if (offset + ext > length)
throw new RangeError('Trying to access beyond buffer length')
}

Buffer.prototype.readUIntLE = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, this.length)

var val = this[offset]

var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100))
val += this[offset + i] * mul

return val
}

Buffer.prototype.readUIntBE = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, this.length)

var val = this[offset + --byteLength]

var mul = 1
while (byteLength > 0 && (mul *= 0x100))
val += this[offset + --byteLength] * mul

return val
}

Buffer.prototype.readUInt8 = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 1, this.length)
return this[offset]
}

Buffer.prototype.readUInt16LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, this.length)
return this[offset] | (this[offset + 1] << 8)
}

Buffer.prototype.readUInt16BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, this.length)
return (this[offset] << 8) | this[offset + 1]
}

Buffer.prototype.readUInt32LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, this.length)

return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}

Buffer.prototype.readUInt32BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, this.length)

return (this[offset] * 0x1000000) +

((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}

Buffer.prototype.readIntLE = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, this.length)

var val = this[offset]

var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100))
val += this[offset + i] * mul
mul *= 0x80

if (val >= mul)

val -= Math.pow(2, 8 * byteLength)

return val
}

Buffer.prototype.readIntBE = function (offset, byteLength, noAssert) {

offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkOffset(offset, byteLength, this.length)

var i = byteLength
var mul = 1
var val = this[offset + --i]
while (i > 0 && (mul *= 0x100))
val += this[offset + --i] * mul
mul *= 0x80
 if (val >= mul)
val -= Math.pow(2, 8 * byteLength)

return val
}

Buffer.prototype.readInt8 = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 1, this.length)
if (!(this[offset] & 0x80))
return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}

Buffer.prototype.readInt16LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, this.length)
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt16BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 2, this.length)
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt32LE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, this.length)

return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}

Buffer.prototype.readInt32BE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, this.length)

return (this[offset] << 24) |

(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}

Buffer.prototype.readFloatLE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, true, 23, 4)
}

Buffer.prototype.readFloatBE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, false, 23, 4)
}

Buffer.prototype.readDoubleLE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, true, 52, 8)
}

Buffer.prototype.readDoubleBE = function (offset, noAssert) {

if (!noAssert)
checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {

if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer
instance')
if (value > max || value < min) throw new RangeError('value is out of bounds')
if (offset + ext > buf.length) throw new RangeError('index out of range')
}

Buffer.prototype.writeUIntLE = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)

var mul = 1
var i = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100))
this[offset + i] = (value / mul) >>> 0 & 0xFF

return offset + byteLength

}

Buffer.prototype.writeUIntBE = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert)
checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)

var i = byteLength - 1
var mul = 1
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100))
this[offset + i] = (value / mul) >>> 0 & 0xFF

return offset + byteLength

}

Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 1, 0xff, 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
 this[offset] = value
return offset + 1
}

function objectWriteUInt16 (buf, value, offset, littleEndian) {

if (value < 0) value = 0xffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
(littleEndian ? i : 1 - i) * 8
}
}

Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}

Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}

function objectWriteUInt32 (buf, value, offset, littleEndian) {

if (value < 0) value = 0xffffffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
}
}

Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = value
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}

Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {

value = +value
 offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}

Buffer.prototype.writeIntLE = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert) {
checkInt(this,
value,
offset,
byteLength,
Math.pow(2, 8 * byteLength - 1) - 1,
-Math.pow(2, 8 * byteLength - 1))
}

var i = 0
var mul = 1
var sub = value < 0 ? 1 : 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100))
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF

return offset + byteLength

}

Buffer.prototype.writeIntBE = function (value, offset, byteLength, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert) {
checkInt(this,
value,
offset,
byteLength,
Math.pow(2, 8 * byteLength - 1) - 1,
-Math.pow(2, 8 * byteLength - 1))
}

var i = byteLength - 1
var mul = 1
var sub = value < 0 ? 1 : 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100))
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF

return offset + byteLength

}

Buffer.prototype.writeInt8 = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
 if (!noAssert)
checkInt(this, value, offset, 1, 0x7f, -0x80)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
if (value < 0) value = 0xff + value + 1
this[offset] = value
return offset + 1
}

Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}

Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}

Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}

Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {

value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}

function checkIEEE754 (buf, value, offset, ext, max, min) {

if (value > max || value < min) throw new RangeError('value is out of bounds')
if (offset + ext > buf.length) throw new RangeError('index out of range')
if (offset < 0) throw new RangeError('index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {

if (!noAssert)
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -
3.4028234663852886e+38)
ieee754.write(buf, value, offset, littleEndian, 23, 4)
return offset + 4
}

Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {

return writeFloat(this, value, offset, true, noAssert)
}

Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {

return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {

if (!noAssert)
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -
1.7976931348623157E+308)
ieee754.write(buf, value, offset, littleEndian, 52, 8)
return offset + 8
}

Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {

return writeDouble(this, value, offset, true, noAssert)
}

Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {

return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)

Buffer.prototype.copy = function (target, target_start, start, end) {
var self = this // source

if (!start) start = 0
if (!end && end !== 0) end = this.length
if (target_start >= target.length) target_start = target.length
if (!target_start) target_start = 0
if (end > 0 && end < start) end = start

// Copy 0 bytes; we're done

if (end === start) return 0
if (target.length === 0 || self.length === 0) return 0

// Fatal error conditions

if (target_start < 0)
throw new RangeError('targetStart out of bounds')
if (start < 0 || start >= self.length) throw new RangeError('sourceStart out of
bounds')
 if (end < 0) throw new RangeError('sourceEnd out of bounds')

// Are we oob?
if (end > this.length)
end = this.length
if (target.length - target_start < end - start)
end = target.length - target_start + start

var len = end - start

if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {

for (var i = 0; i < len; i++) {
target[i + target_start] = this[i + start]
}
} else {
target._set(this.subarray(start, start + len), target_start)
}

return len
}

// fill(value, start=0, end=buffer.length)

Buffer.prototype.fill = function (value, start, end) {
if (!value) value = 0
if (!start) start = 0
if (!end) end = this.length

if (end < start) throw new RangeError('end < start')

// Fill 0 bytes; we're done

if (end === start) return
if (this.length === 0) return

if (start < 0 || start >= this.length) throw new RangeError('start out of

bounds')
if (end < 0 || end > this.length) throw new RangeError('end out of bounds')

var i
if (typeof value === 'number') {
for (i = start; i < end; i++) {
this[i] = value
}
} else {
var bytes = utf8ToBytes(value.toString())
var len = bytes.length
for (i = start; i < end; i++) {
this[i] = bytes[i % len]
}
}

return this
}

/**
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
* Added in Node 0.12. Only available in browsers that support ArrayBuffer.
*/
Buffer.prototype.toArrayBuffer = function () {
if (typeof Uint8Array !== 'undefined') {
 if (Buffer.TYPED_ARRAY_SUPPORT) {
return (new Buffer(this)).buffer
} else {
var buf = new Uint8Array(this.length)
for (var i = 0, len = buf.length; i < len; i += 1) {
buf[i] = this[i]
}
return buf.buffer
}
} else {
throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
}
}

// HELPER FUNCTIONS
// ================

var BP = Buffer.prototype

/**
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
*/
Buffer._augment = function (arr) {
arr.constructor = Buffer
arr._isBuffer = true

// save reference to original Uint8Array get/set methods before overwriting

arr._get = arr.get
arr._set = arr.set

// deprecated, will be removed in node 0.13+

arr.get = BP.get
arr.set = BP.set

arr.write = BP.write
arr.toString = BP.toString
arr.toLocaleString = BP.toString
arr.toJSON = BP.toJSON
arr.equals = BP.equals
arr.compare = BP.compare
arr.copy = BP.copy
arr.slice = BP.slice
arr.readUIntLE = BP.readUIntLE
arr.readUIntBE = BP.readUIntBE
arr.readUInt8 = BP.readUInt8
arr.readUInt16LE = BP.readUInt16LE
arr.readUInt16BE = BP.readUInt16BE
arr.readUInt32LE = BP.readUInt32LE
arr.readUInt32BE = BP.readUInt32BE
arr.readIntLE = BP.readIntLE
arr.readIntBE = BP.readIntBE
arr.readInt8 = BP.readInt8
arr.readInt16LE = BP.readInt16LE
arr.readInt16BE = BP.readInt16BE
arr.readInt32LE = BP.readInt32LE
arr.readInt32BE = BP.readInt32BE
arr.readFloatLE = BP.readFloatLE
arr.readFloatBE = BP.readFloatBE
arr.readDoubleLE = BP.readDoubleLE
 arr.readDoubleBE = BP.readDoubleBE
arr.writeUInt8 = BP.writeUInt8
arr.writeUIntLE = BP.writeUIntLE
arr.writeUIntBE = BP.writeUIntBE
arr.writeUInt16LE = BP.writeUInt16LE
arr.writeUInt16BE = BP.writeUInt16BE
arr.writeUInt32LE = BP.writeUInt32LE
arr.writeUInt32BE = BP.writeUInt32BE
arr.writeIntLE = BP.writeIntLE
arr.writeIntBE = BP.writeIntBE
arr.writeInt8 = BP.writeInt8
arr.writeInt16LE = BP.writeInt16LE
arr.writeInt16BE = BP.writeInt16BE
arr.writeInt32LE = BP.writeInt32LE
arr.writeInt32BE = BP.writeInt32BE
arr.writeFloatLE = BP.writeFloatLE
arr.writeFloatBE = BP.writeFloatBE
arr.writeDoubleLE = BP.writeDoubleLE
arr.writeDoubleBE = BP.writeDoubleBE
arr.fill = BP.fill
arr.inspect = BP.inspect
arr.toArrayBuffer = BP.toArrayBuffer

return arr
}

var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g

function base64clean (str) {

// Node strips out invalid characters like \n and \t from the string, base64-js
does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
// Node converts strings with length < 2 to ''
if (str.length < 2) return ''
// Node allows for non-padded base64 strings (missing trailing ===), base64-js
does not
while (str.length % 4 !== 0) {
str = str + '='
}
return str
}

function stringtrim (str) {

if (str.trim) return str.trim()
return str.replace(/^\s+|\s+$/g, '')
}

function isArrayish (subject) {

return isArray(subject) || Buffer.isBuffer(subject) ||
subject && typeof subject === 'object' &&
typeof subject.length === 'number'
}

function toHex (n) {

if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}

function utf8ToBytes (string, units) {

units = units || Infinity
var codePoint
var length = string.length
var leadSurrogate = null
var bytes = []
var i = 0

for (; i < length; i++) {

codePoint = string.charCodeAt(i)

// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (leadSurrogate) {
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
} else {
// valid surrogate pair
codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000
leadSurrogate = null
}
} else {
// no lead yet

if (codePoint > 0xDBFF) {

// unexpected trail
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else {
// valid lead
leadSurrogate = codePoint
continue
}
}
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = null
}

// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
 bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x200000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}

return bytes
}

function asciiToBytes (str) {

var byteArray = []
for (var i = 0; i < str.length; i++) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF)
}
return byteArray
}

function utf16leToBytes (str, units) {

var c, hi, lo
var byteArray = []
for (var i = 0; i < str.length; i++) {
if ((units -= 2) < 0) break

c = str.charCodeAt(i)
hi = c >> 8
lo = c % 256
byteArray.push(lo)
byteArray.push(hi)
}

return byteArray
}

function base64ToBytes (str) {

return base64.toByteArray(base64clean(str))
}

function blitBuffer (src, dst, offset, length) {

for (var i = 0; i < length; i++) {
if ((i + offset >= dst.length) || (i >= src.length))
break
dst[i + offset] = src[i]
}
return i
}
function decodeUtf8Char (str) {
try {
return decodeURIComponent(str)
} catch (err) {
return String.fromCharCode(0xFFFD) // UTF 8 invalid char
}
}

},{"base64-js":85,"ieee754":86,"is-array":87}],85:[function(require,module,exports)
{
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

;(function (exports) {
'use strict';

var Arr = (typeof Uint8Array !== 'undefined')

? Uint8Array
: Array

var PLUS = '+'.charCodeAt(0)

var SLASH = '/'.charCodeAt(0)
var NUMBER = '0'.charCodeAt(0)
var LOWER = 'a'.charCodeAt(0)
var UPPER = 'A'.charCodeAt(0)
var PLUS_URL_SAFE = '-'.charCodeAt(0)
var SLASH_URL_SAFE = '_'.charCodeAt(0)

function decode (elt) {

var code = elt.charCodeAt(0)
if (code === PLUS ||
code === PLUS_URL_SAFE)
return 62 // '+'
if (code === SLASH ||
code === SLASH_URL_SAFE)
return 63 // '/'
if (code < NUMBER)
return -1 //no match
if (code < NUMBER + 10)
return code - NUMBER + 26 + 26
if (code < UPPER + 26)
return code - UPPER
if (code < LOWER + 26)
return code - LOWER + 26
}

function b64ToByteArray (b64) {

var i, j, l, tmp, placeHolders, arr

if (b64.length % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}

// the number of equal signs (place holders)

// if there are two placeholders, than the two characters before it
// represent one byte
// if there is only one, then the three characters before it represent
2 bytes
// this is just a cheap hack to not do indexOf twice
var len = b64.length
 placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len
- 1) ? 1 : 0

// base64 is 4/3 + up to two characters of the original data

arr = new Arr(b64.length * 3 / 4 - placeHolders)

// if there are placeholders, only get up to the last complete 4 chars

l = placeHolders > 0 ? b64.length - 4 : b64.length

var L = 0

function push (v) {

arr[L++] = v
}

for (i = 0, j = 0; i < l; i += 4, j += 3) {
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1))
<< 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
push((tmp & 0xFF0000) >> 16)
push((tmp & 0xFF00) >> 8)
push(tmp & 0xFF)
}

if (placeHolders === 2) {
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1))
>> 4)
push(tmp & 0xFF)
} else if (placeHolders === 1) {
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1))
<< 4) | (decode(b64.charAt(i + 2)) >> 2)
push((tmp >> 8) & 0xFF)
push(tmp & 0xFF)
}

return arr
}

function uint8ToBase64 (uint8) {

var i,
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2
bytes
output = "",
temp, length

function encode (num) {

return lookup.charAt(num)
}

function tripletToBase64 (num) {

return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) +
encode(num >> 6 & 0x3F) + encode(num & 0x3F)
}

// go through the array every three bytes, we'll deal with trailing
stuff later
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
output += tripletToBase64(temp)
}
 // pad the end with zeros, but make sure to not forget the extra bytes
switch (extraBytes) {
case 1:
temp = uint8[uint8.length - 1]
output += encode(temp >> 2)
output += encode((temp << 4) & 0x3F)
output += '=='
break
case 2:
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length
- 1])
output += encode(temp >> 10)
output += encode((temp >> 4) & 0x3F)
output += encode((temp << 2) & 0x3F)
output += '='
break
}

return output
}

exports.toByteArray = b64ToByteArray
exports.fromByteArray = uint8ToBase64
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))

},{}],86:[function(require,module,exports){
exports.read = function(buffer, offset, isLE, mLen, nBytes) {
var e, m,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
nBits = -7,
i = isLE ? (nBytes - 1) : 0,
d = isLE ? -1 : 1,
s = buffer[offset + i];

i += d;

e = s & ((1 << (-nBits)) - 1);

s >>= (-nBits);
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);

m = e & ((1 << (-nBits)) - 1);

e >>= (-nBits);
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);

if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity);
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
i = isLE ? 0 : (nBytes - 1),
d = isLE ? 1 : -1,
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

value = Math.abs(value);

if (isNaN(value) || value === Infinity) {

m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * Math.pow(2, 1 - eBias);
}
if (value * c >= 2) {
e++;
c /= 2;
}

if (e + eBias >= eMax) {

m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}

for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);

e = (e << mLen) | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);

buffer[offset + i - d] |= s * 128;
};

},{}],87:[function(require,module,exports){

/**
* isArray
*/
var isArray = Array.isArray;

/**
* toString
*/

var str = Object.prototype.toString;

/**
* Whether or not the given `val`
* is an array.
*
* example:
*
* isArray([]);
* // > true
* isArray(arguments);
* // > false
* isArray('');
* // > false
*
* @param {mixed} val
* @return {bool}
*/

module.exports = isArray || function (val) {

return !! val && '[object Array]' == str.call(val);
};

},{}],88:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

function EventEmitter() {
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;

// Backwards-compat with node 0.10.x

EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are

// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};

EventEmitter.prototype.emit = function(type) {
var er, handler, len, args, i, listeners;

if (!this._events)
this._events = {};

// If there is no 'error' event listener then throw.

if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.error.length)) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
}
throw TypeError('Uncaught, unspecified "error" event.');
}
}

handler = this._events[type];

if (isUndefined(handler))
return false;

if (isFunction(handler)) {
switch (arguments.length) {
// fast cases
case 1:
handler.call(this);
break;
case 2:
handler.call(this, arguments[1]);
break;
case 3:
handler.call(this, arguments[1], arguments[2]);
break;
// slower
default:
len = arguments.length;
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
handler.apply(this, args);
 }
} else if (isObject(handler)) {
len = arguments.length;
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];

listeners = handler.slice();
len = listeners.length;
for (i = 0; i < len; i++)
listeners[i].apply(this, args);
}

return true;
};

EventEmitter.prototype.addListener = function(type, listener) {

var m;

if (!isFunction(listener))
throw TypeError('listener must be a function');

if (!this._events)
this._events = {};

// To avoid recursion in the case that type === "newListener"! Before

// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
this.emit('newListener', type,
isFunction(listener.listener) ?
listener.listener : listener);

if (!this._events[type])
// Optimize the case of one listener. Don't need the extra array object.
this._events[type] = listener;
else if (isObject(this._events[type]))
// If we've already got an array, just append.
this._events[type].push(listener);
else
// Adding the second element, need to change to array.
this._events[type] = [this._events[type], listener];

// Check for listener leak

if (isObject(this._events[type]) && !this._events[type].warned) {
var m;
if (!isUndefined(this._maxListeners)) {
m = this._maxListeners;
} else {
m = EventEmitter.defaultMaxListeners;
}

if (m && m > 0 && this._events[type].length > m) {

this._events[type].warned = true;
console.error('(node) warning: possible EventEmitter memory ' +
'leak detected. %d listeners added. ' +
'Use emitter.setMaxListeners() to increase limit.',
this._events[type].length);
if (typeof console.trace === 'function') {
// not supported in IE 10
 console.trace();
}
}
}

return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type, listener) {

if (!isFunction(listener))
throw TypeError('listener must be a function');

var fired = false;

function g() {
this.removeListener(type, g);

if (!fired) {
fired = true;
listener.apply(this, arguments);
}
}

g.listener = listener;
this.on(type, g);

return this;
};

// emits a 'removeListener' event iff the listener was removed

EventEmitter.prototype.removeListener = function(type, listener) {
var list, position, length, i;

if (!isFunction(listener))
throw TypeError('listener must be a function');

if (!this._events || !this._events[type])
return this;

list = this._events[type];
length = list.length;
position = -1;

if (list === listener ||

(isFunction(list.listener) && list.listener === listener)) {
delete this._events[type];
if (this._events.removeListener)
this.emit('removeListener', type, listener);

} else if (isObject(list)) {
for (i = length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
position = i;
break;
}
}
 if (position < 0)
return this;

if (list.length === 1) {
list.length = 0;
delete this._events[type];
} else {
list.splice(position, 1);
}

if (this._events.removeListener)
this.emit('removeListener', type, listener);
}

return this;
};

EventEmitter.prototype.removeAllListeners = function(type) {
var key, listeners;

if (!this._events)
return this;

// not listening for removeListener, no need to emit

if (!this._events.removeListener) {
if (arguments.length === 0)
this._events = {};
else if (this._events[type])
delete this._events[type];
return this;
}

// emit removeListener for all listeners on all events

if (arguments.length === 0) {
for (key in this._events) {
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = {};
return this;
}

listeners = this._events[type];

if (isFunction(listeners)) {
this.removeListener(type, listeners);
} else {
// LIFO order
while (listeners.length)
this.removeListener(type, listeners[listeners.length - 1]);
}
delete this._events[type];

return this;
};

EventEmitter.prototype.listeners = function(type) {
 var ret;
if (!this._events || !this._events[type])
ret = [];
else if (isFunction(this._events[type]))
ret = [this._events[type]];
else
ret = this._events[type].slice();
return ret;
};

EventEmitter.listenerCount = function(emitter, type) {

var ret;
if (!emitter._events || !emitter._events[type])
ret = 0;
else if (isFunction(emitter._events[type]))
ret = 1;
else
ret = emitter._events[type].length;
return ret;
};

function isFunction(arg) {
return typeof arg === 'function';
}

function isNumber(arg) {
return typeof arg === 'number';
}

function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}

function isUndefined(arg) {
return arg === void 0;
}

},{}],89:[function(require,module,exports){
arguments[4][24][0].apply(exports,arguments)
},{"dup":24}],90:[function(require,module,exports){
module.exports = Array.isArray || function (arr) {
return Object.prototype.toString.call(arr) == '[object Array]';
};

},{}],91:[function(require,module,exports){
// shim for using process in browser

var process = module.exports = {};

var queue = [];
var draining = false;

function drainQueue() {
if (draining) {
return;
}
draining = true;
var currentQueue;
var len = queue.length;
while(len) {
 currentQueue = queue;
queue = [];
var i = -1;
while (++i < len) {
currentQueue[i]();
}
len = queue.length;
}
draining = false;
}
process.nextTick = function (fun) {
queue.push(fun);
if (!draining) {
setTimeout(drainQueue, 0);
}
};

process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;

process.binding = function (name) {

throw new Error('process.binding is not supported');
};

// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };

},{}],92:[function(require,module,exports){
module.exports = require("./lib/_stream_duplex.js")

},{"./lib/_stream_duplex.js":93}],93:[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a duplex stream is just a stream that is both readable and writable.

// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.

module.exports = Duplex;

/*<replacement>*/
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) keys.push(key);
return keys;
}
/*</replacement>*/

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

var Readable = require('./_stream_readable');

var Writable = require('./_stream_writable');

util.inherits(Duplex, Readable);

forEach(objectKeys(Writable.prototype), function(method) {
if (!Duplex.prototype[method])
Duplex.prototype[method] = Writable.prototype[method];
});

function Duplex(options) {
if (!(this instanceof Duplex))
return new Duplex(options);

Readable.call(this, options);
Writable.call(this, options);

if (options && options.readable === false)

this.readable = false;

if (options && options.writable === false)

this.writable = false;

this.allowHalfOpen = true;
if (options && options.allowHalfOpen === false)
this.allowHalfOpen = false;
 this.once('end', onend);
}

// the no-half-open enforcer

function onend() {
// if we allow half-open state, or if the writable side ended,
// then we're ok.
if (this.allowHalfOpen || this._writableState.ended)
return;

// no more data can be written.

// But allow more writes to happen in this tick.
process.nextTick(this.end.bind(this));
}

function forEach (xs, f) {

for (var i = 0, l = xs.length; i < l; i++) {
f(xs[i], i);
}
}

}).call(this,require('_process'))
},{"./_stream_readable":95,"./_stream_writable":97,"_process":91,"core-util-
is":98,"inherits":89}],94:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.

module.exports = PassThrough;

var Transform = require('./_stream_transform');

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

util.inherits(PassThrough, Transform);
function PassThrough(options) {
if (!(this instanceof PassThrough))
return new PassThrough(options);

Transform.call(this, options);
}

PassThrough.prototype._transform = function(chunk, encoding, cb) {

cb(null, chunk);
};

},{"./_stream_transform":96,"core-util-is":98,"inherits":89}],95:
[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

module.exports = Readable;

/*<replacement>*/
var isArray = require('isarray');
/*</replacement>*/

/*<replacement>*/
var Buffer = require('buffer').Buffer;
/*</replacement>*/

Readable.ReadableState = ReadableState;

var EE = require('events').EventEmitter;

/*<replacement>*/
if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
return emitter.listeners(type).length;
};
/*</replacement>*/

var Stream = require('stream');

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

var StringDecoder;

/*<replacement>*/
var debug = require('util');
if (debug && debug.debuglog) {
debug = debug.debuglog('stream');
} else {
debug = function () {};
}
/*</replacement>*/

util.inherits(Readable, Stream);

function ReadableState(options, stream) {

var Duplex = require('./_stream_duplex');

options = options || {};

// the point at which it stops calling _read() to fill the buffer

// Note: 0 is a valid value, means "don't call _read preemptively ever"
var hwm = options.highWaterMark;
var defaultHwm = options.objectMode ? 16 : 16 * 1024;
this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;

// cast to ints.
this.highWaterMark = ~~this.highWaterMark;

this.buffer = [];
this.length = 0;
this.pipes = null;
this.pipesCount = 0;
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false;

// a flag to be able to tell if the onwrite cb is called immediately,

// or on a later tick. We set this to true at first, because any
// actions that shouldn't happen until "later" should generally also
// not happen before the first write call.
this.sync = true;

// whenever we return null, then we set a flag to say

// that we're awaiting a 'readable' event emission.
this.needReadable = false;
this.emittedReadable = false;
this.readableListening = false;

// object stream flag. Used to make read(n) ignore n and to

// make all the buffer merging and length checks go away
this.objectMode = !!options.objectMode;
 if (stream instanceof Duplex)
this.objectMode = this.objectMode || !!options.readableObjectMode;

// Crypto is kind of old and crusty. Historically, its default string

// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
this.defaultEncoding = options.defaultEncoding || 'utf8';

// when piping, we only care about 'readable' events that happen

// after read()ing all the bytes and not getting any pushback.
this.ranOut = false;

// the number of writers that are awaiting a drain event in .pipe()s

this.awaitDrain = 0;

// if true, a maybeReadMore has been scheduled

this.readingMore = false;

this.decoder = null;
this.encoding = null;
if (options.encoding) {
if (!StringDecoder)
StringDecoder = require('string_decoder/').StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}

function Readable(options) {
var Duplex = require('./_stream_duplex');

if (!(this instanceof Readable))

return new Readable(options);

this._readableState = new ReadableState(options, this);

// legacy
this.readable = true;

Stream.call(this);
}

// Manually shove something into the read() buffer.

// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.
Readable.prototype.push = function(chunk, encoding) {
var state = this._readableState;

if (util.isString(chunk) && !state.objectMode) {

encoding = encoding || state.defaultEncoding;
if (encoding !== state.encoding) {
chunk = new Buffer(chunk, encoding);
encoding = '';
}
}

return readableAddChunk(this, state, chunk, encoding, false);

};

// Unshift should *always* be something directly out of read()

Readable.prototype.unshift = function(chunk) {
var state = this._readableState;
return readableAddChunk(this, state, chunk, '', true);
};

function readableAddChunk(stream, state, chunk, encoding, addToFront) {

var er = chunkInvalid(state, chunk);
if (er) {
stream.emit('error', er);
} else if (util.isNullOrUndefined(chunk)) {
state.reading = false;
if (!state.ended)
onEofChunk(stream, state);
} else if (state.objectMode || chunk && chunk.length > 0) {
if (state.ended && !addToFront) {
var e = new Error('stream.push() after EOF');
stream.emit('error', e);
} else if (state.endEmitted && addToFront) {
var e = new Error('stream.unshift() after end event');
stream.emit('error', e);
} else {
if (state.decoder && !addToFront && !encoding)
chunk = state.decoder.write(chunk);

if (!addToFront)
state.reading = false;

// if we want the data now, just emit it.

if (state.flowing && state.length === 0 && !state.sync) {
stream.emit('data', chunk);
stream.read(0);
} else {
// update the buffer info.
state.length += state.objectMode ? 1 : chunk.length;
if (addToFront)
state.buffer.unshift(chunk);
else
state.buffer.push(chunk);

if (state.needReadable)
emitReadable(stream);
}

maybeReadMore(stream, state);
}
} else if (!addToFront) {
state.reading = false;
}

return needMoreData(state);
}

// if it's past the high water mark, we can push in some more.
// Also, if we have no data yet, we can stand some
// more bytes. This is to work around cases where hwm=0,
// such as the repl. Also, if the push() triggered a
// readable event, and the user called read(largeNumber) such that
// needReadable was set, then we ought to push more, so that another
// 'readable' event will be triggered.
function needMoreData(state) {
return !state.ended &&
(state.needReadable ||
state.length < state.highWaterMark ||
state.length === 0);
}

// backwards compatibility.
Readable.prototype.setEncoding = function(enc) {
if (!StringDecoder)
StringDecoder = require('string_decoder/').StringDecoder;
this._readableState.decoder = new StringDecoder(enc);
this._readableState.encoding = enc;
return this;
};

// Don't raise the hwm > 128MB

var MAX_HWM = 0x800000;
function roundUpToNextPowerOf2(n) {
if (n >= MAX_HWM) {
n = MAX_HWM;
} else {
// Get the next highest power of 2
n--;
for (var p = 1; p < 32; p <<= 1) n |= n >> p;
n++;
}
return n;
}

function howMuchToRead(n, state) {

if (state.length === 0 && state.ended)
return 0;

if (state.objectMode)
return n === 0 ? 0 : 1;

if (isNaN(n) || util.isNull(n)) {
// only flow one buffer at a time
if (state.flowing && state.buffer.length)
return state.buffer[0].length;
else
return state.length;
}

if (n <= 0)
return 0;

// If we're asking for more than the target buffer level,

// then raise the water mark. Bump up to the next highest
// power of 2, to prevent increasing it excessively in tiny
// amounts.
if (n > state.highWaterMark)
state.highWaterMark = roundUpToNextPowerOf2(n);
 // don't have that much. return null, unless we've ended.
if (n > state.length) {
if (!state.ended) {
state.needReadable = true;
return 0;
} else
return state.length;
}

return n;
}

// you can override either this method, or the async _read(n) below.
Readable.prototype.read = function(n) {
debug('read', n);
var state = this._readableState;
var nOrig = n;

if (!util.isNumber(n) || n > 0)
state.emittedReadable = false;

// if we're doing read(0) to trigger a readable event, but we

// already have a bunch of data in the buffer, then just trigger
// the 'readable' event and move on.
if (n === 0 &&
state.needReadable &&
(state.length >= state.highWaterMark || state.ended)) {
debug('read: emitReadable', state.length, state.ended);
if (state.length === 0 && state.ended)
endReadable(this);
else
emitReadable(this);
return null;
}

n = howMuchToRead(n, state);

// if we've ended, and we're now clear, then finish it up.

if (n === 0 && state.ended) {
if (state.length === 0)
endReadable(this);
return null;
}

// All the actual chunk generation logic needs to be

// *below* the call to _read. The reason is that in certain
// synthetic stream cases, such as passthrough streams, _read
// may be a completely synchronous operation which may change
// the state of the read buffer, providing enough data when
// before there was *not* enough.
//
// So, the steps are:
// 1. Figure out what the state of things will be after we do
// a read from the buffer.
//
// 2. If that resulting state will trigger a _read, then call _read.
// Note that this may be asynchronous, or synchronous. Yes, it is
// deeply ugly to write APIs this way, but that still doesn't mean
// that the Readable class should behave improperly, as streams are
// designed to be sync/async agnostic.
// Take note if the _read call is sync or async (ie, if the read call
// has returned yet), so that we know whether or not it's safe to emit
// 'readable' etc.
//
// 3. Actually pull the requested chunks out of the buffer and return.

// if we need a readable event, then we need to do some reading.

var doRead = state.needReadable;
debug('need readable', doRead);

// if we currently have less than the highWaterMark, then also read some
if (state.length === 0 || state.length - n < state.highWaterMark) {
doRead = true;
debug('length less than watermark', doRead);
}

// however, if we've ended, then there's no point, and if we're already

// reading, then it's unnecessary.
if (state.ended || state.reading) {
doRead = false;
debug('reading or ended', doRead);
}

if (doRead) {
debug('do read');
state.reading = true;
state.sync = true;
// if the length is currently zero, then we *need* a readable event.
if (state.length === 0)
state.needReadable = true;
// call internal read method
this._read(state.highWaterMark);
state.sync = false;
}

// If _read pushed data synchronously, then `reading` will be false,

// and we need to re-evaluate how much data we can return to the user.
if (doRead && !state.reading)
n = howMuchToRead(nOrig, state);

var ret;
if (n > 0)
ret = fromList(n, state);
else
ret = null;

if (util.isNull(ret)) {
state.needReadable = true;
n = 0;
}

state.length -= n;

// If we have nothing in the buffer, then we want to know

// as soon as we *do* get something into the buffer.
if (state.length === 0 && !state.ended)
state.needReadable = true;
 // If we tried to read() past the EOF, then emit end on the next tick.
if (nOrig !== n && state.ended && state.length === 0)
endReadable(this);

if (!util.isNull(ret))
this.emit('data', ret);

return ret;
};

function chunkInvalid(state, chunk) {

var er = null;
if (!util.isBuffer(chunk) &&
!util.isString(chunk) &&
!util.isNullOrUndefined(chunk) &&
!state.objectMode) {
er = new TypeError('Invalid non-string/buffer chunk');
}
return er;
}

function onEofChunk(stream, state) {

if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length) {
state.buffer.push(chunk);
state.length += state.objectMode ? 1 : chunk.length;
}
}
state.ended = true;

// emit 'readable' now to make sure it gets picked up.

emitReadable(stream);
}

// Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow. This way, it might trigger
// a nextTick recursion warning, but that's not so bad.
function emitReadable(stream) {
var state = stream._readableState;
state.needReadable = false;
if (!state.emittedReadable) {
debug('emitReadable', state.flowing);
state.emittedReadable = true;
if (state.sync)
process.nextTick(function() {
emitReadable_(stream);
});
else
emitReadable_(stream);
}
}

function emitReadable_(stream) {
debug('emit readable');
stream.emit('readable');
flow(stream);
}

// at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data. that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.
function maybeReadMore(stream, state) {
if (!state.readingMore) {
state.readingMore = true;
process.nextTick(function() {
maybeReadMore_(stream, state);
});
}
}

function maybeReadMore_(stream, state) {

var len = state.length;
while (!state.reading && !state.flowing && !state.ended &&
state.length < state.highWaterMark) {
debug('maybeReadMore read 0');
stream.read(0);
if (len === state.length)
// didn't get any data, stop spinning.
break;
else
len = state.length;
}
state.readingMore = false;
}

// abstract method. to be overridden in specific implementation classes.

// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.
Readable.prototype._read = function(n) {
this.emit('error', new Error('not implemented'));
};

Readable.prototype.pipe = function(dest, pipeOpts) {

var src = this;
var state = this._readableState;

switch (state.pipesCount) {
case 0:
state.pipes = dest;
break;
case 1:
state.pipes = [state.pipes, dest];
break;
default:
state.pipes.push(dest);
break;
}
state.pipesCount += 1;
debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
dest !== process.stdout &&
dest !== process.stderr;

var endFn = doEnd ? onend : cleanup;

if (state.endEmitted)
process.nextTick(endFn);
else
src.once('end', endFn);

dest.on('unpipe', onunpipe);
function onunpipe(readable) {
debug('onunpipe');
if (readable === src) {
cleanup();
}
}

function onend() {
debug('onend');
dest.end();
}

// when the dest drains, it reduces the awaitDrain counter

// on the source. This would be more elegant with a .once()
// handler in flow(), but adding and removing repeatedly is
// too slow.
var ondrain = pipeOnDrain(src);
dest.on('drain', ondrain);

function cleanup() {
debug('cleanup');
// cleanup event handlers once the pipe is broken
dest.removeListener('close', onclose);
dest.removeListener('finish', onfinish);
dest.removeListener('drain', ondrain);
dest.removeListener('error', onerror);
dest.removeListener('unpipe', onunpipe);
src.removeListener('end', onend);
src.removeListener('end', cleanup);
src.removeListener('data', ondata);

// if the reader is waiting for a drain event from this

// specific writer, then it would cause it to never start
// flowing again.
// So, if this is awaiting a drain, then we just call it now.
// If we don't know, then assume that we are waiting for one.
if (state.awaitDrain &&
(!dest._writableState || dest._writableState.needDrain))
ondrain();
}

src.on('data', ondata);
function ondata(chunk) {
debug('ondata');
var ret = dest.write(chunk);
if (false === ret) {
debug('false write response, pause',
src._readableState.awaitDrain);
 src._readableState.awaitDrain++;
src.pause();
}
}

// if the dest has an error, then stop piping into it.

// however, don't suppress the throwing behavior for this.
function onerror(er) {
debug('onerror', er);
unpipe();
dest.removeListener('error', onerror);
if (EE.listenerCount(dest, 'error') === 0)
dest.emit('error', er);
}
// This is a brutally ugly hack to make sure that our error handler
// is attached before any userland ones. NEVER DO THIS.
if (!dest._events || !dest._events.error)
dest.on('error', onerror);
else if (isArray(dest._events.error))
dest._events.error.unshift(onerror);
else
dest._events.error = [onerror, dest._events.error];

// Both close and finish should trigger unpipe, but only once.
function onclose() {
dest.removeListener('finish', onfinish);
unpipe();
}
dest.once('close', onclose);
function onfinish() {
debug('onfinish');
dest.removeListener('close', onclose);
unpipe();
}
dest.once('finish', onfinish);

function unpipe() {
debug('unpipe');
src.unpipe(dest);
}

// tell the dest that it's being piped to

dest.emit('pipe', src);

// start the flow if it hasn't been started already.

if (!state.flowing) {
debug('pipe resume');
src.resume();
}

return dest;
};

function pipeOnDrain(src) {
return function() {
var state = src._readableState;
debug('pipeOnDrain', state.awaitDrain);
 if (state.awaitDrain)
state.awaitDrain--;
if (state.awaitDrain === 0 && EE.listenerCount(src, 'data')) {
state.flowing = true;
flow(src);
}
};
}

Readable.prototype.unpipe = function(dest) {
var state = this._readableState;

// if we're not piping anywhere, then do nothing.

if (state.pipesCount === 0)
return this;

// just one destination. most common case.

if (state.pipesCount === 1) {
// passed in one, but it's not the right one.
if (dest && dest !== state.pipes)
return this;

if (!dest)
dest = state.pipes;

// got a match.
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
if (dest)
dest.emit('unpipe', this);
return this;
}

// slow case. multiple pipe destinations.

if (!dest) {
// remove all.
var dests = state.pipes;
var len = state.pipesCount;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;

for (var i = 0; i < len; i++)

dests[i].emit('unpipe', this);
return this;
}

// try to find the right one.

var i = indexOf(state.pipes, dest);
if (i === -1)
return this;

state.pipes.splice(i, 1);
state.pipesCount -= 1;
if (state.pipesCount === 1)
state.pipes = state.pipes[0];
 dest.emit('unpipe', this);

return this;
};

// set up data events if they are asked for

// Ensure readable listeners eventually get something
Readable.prototype.on = function(ev, fn) {
var res = Stream.prototype.on.call(this, ev, fn);

// If listening to data, and it has not explicitly been paused,

// then call resume to start the flow of data on the next tick.
if (ev === 'data' && false !== this._readableState.flowing) {
this.resume();
}

if (ev === 'readable' && this.readable) {

var state = this._readableState;
if (!state.readableListening) {
state.readableListening = true;
state.emittedReadable = false;
state.needReadable = true;
if (!state.reading) {
var self = this;
process.nextTick(function() {
debug('readable nexttick read 0');
self.read(0);
});
} else if (state.length) {
emitReadable(this, state);
}
}
}

return res;
};
Readable.prototype.addListener = Readable.prototype.on;

// pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.
Readable.prototype.resume = function() {
var state = this._readableState;
if (!state.flowing) {
debug('resume');
state.flowing = true;
if (!state.reading) {
debug('resume read 0');
this.read(0);
}
resume(this, state);
}
return this;
};

function resume(stream, state) {

if (!state.resumeScheduled) {
state.resumeScheduled = true;
process.nextTick(function() {
 resume_(stream, state);
});
}
}

function resume_(stream, state) {

state.resumeScheduled = false;
stream.emit('resume');
flow(stream);
if (state.flowing && !state.reading)
stream.read(0);
}

Readable.prototype.pause = function() {
debug('call pause flowing=%j', this._readableState.flowing);
if (false !== this._readableState.flowing) {
debug('pause');
this._readableState.flowing = false;
this.emit('pause');
}
return this;
};

function flow(stream) {
var state = stream._readableState;
debug('flow', state.flowing);
if (state.flowing) {
do {
var chunk = stream.read();
} while (null !== chunk && state.flowing);
}
}

// wrap an old-style stream as the async data source.

// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.
Readable.prototype.wrap = function(stream) {
var state = this._readableState;
var paused = false;

var self = this;

stream.on('end', function() {
debug('wrapped end');
if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length)
self.push(chunk);
}

self.push(null);
});

stream.on('data', function(chunk) {
debug('wrapped data');
if (state.decoder)
chunk = state.decoder.write(chunk);
if (!chunk || !state.objectMode && !chunk.length)
return;
 var ret = self.push(chunk);
if (!ret) {
paused = true;
stream.pause();
}
});

// proxy all the other methods.

// important when wrapping filters and duplexes.
for (var i in stream) {
if (util.isFunction(stream[i]) && util.isUndefined(this[i])) {
this[i] = function(method) { return function() {
return stream[method].apply(stream, arguments);
}}(i);
}
}

// proxy certain important events.

var events = ['error', 'close', 'destroy', 'pause', 'resume'];
forEach(events, function(ev) {
stream.on(ev, self.emit.bind(self, ev));
});

// when we try to consume some more bytes, simply unpause the

// underlying stream.
self._read = function(n) {
debug('wrapped _read', n);
if (paused) {
paused = false;
stream.resume();
}
};

return self;
};

// exposed for testing purposes only.

Readable._fromList = fromList;

// Pluck off n bytes from an array of buffers.

// Length is the combined lengths of all the buffers in the list.
function fromList(n, state) {
var list = state.buffer;
var length = state.length;
var stringMode = !!state.decoder;
var objectMode = !!state.objectMode;
var ret;

// nothing in the list, definitely empty.

if (list.length === 0)
return null;

if (length === 0)
ret = null;
else if (objectMode)
ret = list.shift();
else if (!n || n >= length) {
 // read it all, truncate the array.
if (stringMode)
ret = list.join('');
else
ret = Buffer.concat(list, length);
list.length = 0;
} else {
// read just some of it.
if (n < list[0].length) {
// just take a part of the first list item.
// slice is the same for buffers and strings.
var buf = list[0];
ret = buf.slice(0, n);
list[0] = buf.slice(n);
} else if (n === list[0].length) {
// first list is a perfect match
ret = list.shift();
} else {
// complex case.
// we have enough to cover it, but it spans past the first buffer.
if (stringMode)
ret = '';
else
ret = new Buffer(n);

var c = 0;
for (var i = 0, l = list.length; i < l && c < n; i++) {
var buf = list[0];
var cpy = Math.min(n - c, buf.length);

if (stringMode)
ret += buf.slice(0, cpy);
else
buf.copy(ret, c, 0, cpy);

if (cpy < buf.length)

list[0] = buf.slice(cpy);
else
list.shift();

c += cpy;
}
}
}

return ret;
}

function endReadable(stream) {
var state = stream._readableState;

// If we get here before consuming all the bytes, then that is a

// bug in node. Should never happen.
if (state.length > 0)
throw new Error('endReadable called on non-empty stream');

if (!state.endEmitted) {
state.ended = true;
process.nextTick(function() {
 // Check that we didn't get one last unshift.
if (!state.endEmitted && state.length === 0) {
state.endEmitted = true;
stream.readable = false;
stream.emit('end');
}
});
}
}

function forEach (xs, f) {

for (var i = 0, l = xs.length; i < l; i++) {
f(xs[i], i);
}
}

function indexOf (xs, x) {

for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}

}).call(this,require('_process'))
},{"./_stream_duplex":93,"_process":91,"buffer":84,"core-util-
is":98,"events":88,"inherits":89,"isarray":90,"stream":103,"string_decoder/":104,"u
til":83}],96:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a transform stream is a readable/writable stream where you do

// something with the data. Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored. (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation. For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes. When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up. When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer. When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks. If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk. However,
// a pathological inflate type of transform can cause excessive buffering
// here. For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output. In this case, you could write a very small
// amount of input, and end up with a very large amount of output. In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform. A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.

module.exports = Transform;

var Duplex = require('./_stream_duplex');

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

util.inherits(Transform, Duplex);

function TransformState(options, stream) {

this.afterTransform = function(er, data) {
return afterTransform(stream, er, data);
};

this.needTransform = false;
this.transforming = false;
this.writecb = null;
this.writechunk = null;
}

function afterTransform(stream, er, data) {

var ts = stream._transformState;
ts.transforming = false;
 var cb = ts.writecb;

if (!cb)
return stream.emit('error', new Error('no writecb in Transform class'));

ts.writechunk = null;
ts.writecb = null;

if (!util.isNullOrUndefined(data))
stream.push(data);

if (cb)
cb(er);

var rs = stream._readableState;
rs.reading = false;
if (rs.needReadable || rs.length < rs.highWaterMark) {
stream._read(rs.highWaterMark);
}
}

function Transform(options) {
if (!(this instanceof Transform))
return new Transform(options);

Duplex.call(this, options);

this._transformState = new TransformState(options, this);

// when the writable side finishes, then flush out anything remaining.
var stream = this;

// start out asking for a readable event once data is transformed.

this._readableState.needReadable = true;

// we have implemented the _read method, and done the other things
// that Readable wants before the first _read call, so unset the
// sync guard flag.
this._readableState.sync = false;

this.once('prefinish', function() {
if (util.isFunction(this._flush))
this._flush(function(er) {
done(stream, er);
});
else
done(stream);
});
}

Transform.prototype.push = function(chunk, encoding) {

this._transformState.needTransform = false;
return Duplex.prototype.push.call(this, chunk, encoding);
};

// This is the part where you do stuff!

// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side. You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk. If you pass
// an error, then that'll put the hurt on the whole operation. If you
// never call cb(), then you'll never get another chunk.
Transform.prototype._transform = function(chunk, encoding, cb) {
throw new Error('not implemented');
};

Transform.prototype._write = function(chunk, encoding, cb) {

var ts = this._transformState;
ts.writecb = cb;
ts.writechunk = chunk;
ts.writeencoding = encoding;
if (!ts.transforming) {
var rs = this._readableState;
if (ts.needTransform ||
rs.needReadable ||
rs.length < rs.highWaterMark)
this._read(rs.highWaterMark);
}
};

// Doesn't matter what the args are here.

// _transform does all the work.
// That we got here means that the readable side wants more data.
Transform.prototype._read = function(n) {
var ts = this._transformState;

if (!util.isNull(ts.writechunk) && ts.writecb && !ts.transforming) {

ts.transforming = true;
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
} else {
// mark that we need a transform, so that any data that comes in
// will get processed, now that we've asked for it.
ts.needTransform = true;
}
};

function done(stream, er) {

if (er)
return stream.emit('error', er);

// if there's nothing in the write buffer, then that means

// that nothing more will ever be provided
var ws = stream._writableState;
var ts = stream._transformState;

if (ws.length)
throw new Error('calling transform done when ws.length != 0');

if (ts.transforming)
throw new Error('calling transform done when still transforming');

return stream.push(null);
}
},{"./_stream_duplex":93,"core-util-is":98,"inherits":89}],97:
[function(require,module,exports){
(function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// A bit simpler than readable streams.

// Implement an async ._write(chunk, cb), and it'll handle all
// the drain event emission and buffering.

module.exports = Writable;

/*<replacement>*/
var Buffer = require('buffer').Buffer;
/*</replacement>*/

Writable.WritableState = WritableState;

/*<replacement>*/
var util = require('core-util-is');
util.inherits = require('inherits');
/*</replacement>*/

var Stream = require('stream');

util.inherits(Writable, Stream);

function WriteReq(chunk, encoding, cb) {

this.chunk = chunk;
this.encoding = encoding;
this.callback = cb;
}

function WritableState(options, stream) {

var Duplex = require('./_stream_duplex');

options = options || {};

// the point at which write() starts returning false

// Note: 0 is a valid value, means that we always return false if
// the entire buffer is not flushed immediately on write()
var hwm = options.highWaterMark;
var defaultHwm = options.objectMode ? 16 : 16 * 1024;
this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;

// object stream flag to indicate whether or not this stream

// contains buffers or objects.
this.objectMode = !!options.objectMode;

if (stream instanceof Duplex)

this.objectMode = this.objectMode || !!options.writableObjectMode;

// cast to ints.
this.highWaterMark = ~~this.highWaterMark;

this.needDrain = false;
// at the start of calling end()
this.ending = false;
// when end() has been called, and returned
this.ended = false;
// when 'finish' is emitted
this.finished = false;

// should we decode strings into buffers before passing to _write?

// this is here so that some node-core streams can optimize string
// handling at a lower level.
var noDecode = options.decodeStrings === false;
this.decodeStrings = !noDecode;

// Crypto is kind of old and crusty. Historically, its default string

// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
this.defaultEncoding = options.defaultEncoding || 'utf8';

// not an actual buffer we keep track of, but a measurement

// of how much we're waiting to get pushed to some underlying
// socket or file.
this.length = 0;

// a flag to see when we're in the middle of a write.

this.writing = false;

// when true all writes will be buffered until .uncork() call

this.corked = 0;

// a flag to be able to tell if the onwrite cb is called immediately,

// or on a later tick. We set this to true at first, because any
// actions that shouldn't happen until "later" should generally also
// not happen before the first write call.
this.sync = true;

// a flag to know if we're processing previously buffered items, which

// may call the _write() callback in the same tick, so that we don't
// end up in an overlapped onwrite situation.
this.bufferProcessing = false;

// the callback that's passed to _write(chunk,cb)

this.onwrite = function(er) {
 onwrite(stream, er);
};

// the callback that the user supplies to write(chunk,encoding,cb)

this.writecb = null;

// the amount that is being written when _write is called.

this.writelen = 0;

this.buffer = [];

// number of pending user-supplied write callbacks

// this must be 0 before 'finish' can be emitted
this.pendingcb = 0;

// emit prefinish if the only thing we're waiting for is _write cbs
// This is relevant for synchronous Transform streams
this.prefinished = false;

// True if the error was already emitted and should not be thrown again
this.errorEmitted = false;
}

function Writable(options) {
var Duplex = require('./_stream_duplex');

// Writable ctor is applied to Duplexes, though they're not

// instanceof Writable, they're instanceof Readable.
if (!(this instanceof Writable) && !(this instanceof Duplex))
return new Writable(options);

this._writableState = new WritableState(options, this);

// legacy.
this.writable = true;

Stream.call(this);
}

// Otherwise people can pipe Writable streams, which is just wrong.

Writable.prototype.pipe = function() {
this.emit('error', new Error('Cannot pipe. Not readable.'));
};

function writeAfterEnd(stream, state, cb) {

var er = new Error('write after end');
// TODO: defer error events consistently everywhere, not just the cb
stream.emit('error', er);
process.nextTick(function() {
cb(er);
});
}

// If we get something that is not a buffer, string, null, or undefined,

// and we're not in objectMode, then that's an error.
// Otherwise stream chunks are all considered to be of length=1, and the
// watermarks determine how many objects to keep in the buffer, rather than
// how many bytes or characters.
function validChunk(stream, state, chunk, cb) {
var valid = true;
if (!util.isBuffer(chunk) &&
!util.isString(chunk) &&
!util.isNullOrUndefined(chunk) &&
!state.objectMode) {
var er = new TypeError('Invalid non-string/buffer chunk');
stream.emit('error', er);
process.nextTick(function() {
cb(er);
});
valid = false;
}
return valid;
}

Writable.prototype.write = function(chunk, encoding, cb) {

var state = this._writableState;
var ret = false;

if (util.isFunction(encoding)) {
cb = encoding;
encoding = null;
}

if (util.isBuffer(chunk))
encoding = 'buffer';
else if (!encoding)
encoding = state.defaultEncoding;

if (!util.isFunction(cb))
cb = function() {};

if (state.ended)
writeAfterEnd(this, state, cb);
else if (validChunk(this, state, chunk, cb)) {
state.pendingcb++;
ret = writeOrBuffer(this, state, chunk, encoding, cb);
}

return ret;
};

Writable.prototype.cork = function() {
var state = this._writableState;

state.corked++;
};

Writable.prototype.uncork = function() {
var state = this._writableState;

if (state.corked) {
state.corked--;

if (!state.writing &&
!state.corked &&
!state.finished &&
!state.bufferProcessing &&
 state.buffer.length)
clearBuffer(this, state);
}
};

function decodeChunk(state, chunk, encoding) {

if (!state.objectMode &&
state.decodeStrings !== false &&
util.isString(chunk)) {
chunk = new Buffer(chunk, encoding);
}
return chunk;
}

// if we're already writing something, then just put this

// in the queue, and wait our turn. Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
function writeOrBuffer(stream, state, chunk, encoding, cb) {
chunk = decodeChunk(state, chunk, encoding);
if (util.isBuffer(chunk))
encoding = 'buffer';
var len = state.objectMode ? 1 : chunk.length;

state.length += len;

var ret = state.length < state.highWaterMark;

// we must ensure that previous needDrain will not be reset to false.
if (!ret)
state.needDrain = true;

if (state.writing || state.corked)
state.buffer.push(new WriteReq(chunk, encoding, cb));
else
doWrite(stream, state, false, len, chunk, encoding, cb);

return ret;
}

function doWrite(stream, state, writev, len, chunk, encoding, cb) {

state.writelen = len;
state.writecb = cb;
state.writing = true;
state.sync = true;
if (writev)
stream._writev(chunk, state.onwrite);
else
stream._write(chunk, encoding, state.onwrite);
state.sync = false;
}

function onwriteError(stream, state, sync, er, cb) {

if (sync)
process.nextTick(function() {
state.pendingcb--;
cb(er);
});
else {
state.pendingcb--;
cb(er);
 }

stream._writableState.errorEmitted = true;
stream.emit('error', er);
}

function onwriteStateUpdate(state) {
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;
}

function onwrite(stream, er) {

var state = stream._writableState;
var sync = state.sync;
var cb = state.writecb;

onwriteStateUpdate(state);

if (er)
onwriteError(stream, state, sync, er, cb);
else {
// Check if we're actually ready to finish, but don't emit yet
var finished = needFinish(stream, state);

if (!finished &&
!state.corked &&
!state.bufferProcessing &&
state.buffer.length) {
clearBuffer(stream, state);
}

if (sync) {
process.nextTick(function() {
afterWrite(stream, state, finished, cb);
});
} else {
afterWrite(stream, state, finished, cb);
}
}
}

function afterWrite(stream, state, finished, cb) {

if (!finished)
onwriteDrain(stream, state);
state.pendingcb--;
cb();
finishMaybe(stream, state);
}

// Must force callback to be called on nextTick, so that we don't

// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.
function onwriteDrain(stream, state) {
if (state.length === 0 && state.needDrain) {
state.needDrain = false;
stream.emit('drain');
}
}

// if there's something in the buffer waiting, then process it

function clearBuffer(stream, state) {
state.bufferProcessing = true;

if (stream._writev && state.buffer.length > 1) {

// Fast case, write everything using _writev()
var cbs = [];
for (var c = 0; c < state.buffer.length; c++)
cbs.push(state.buffer[c].callback);

// count the one we are adding, as well.

// TODO(isaacs) clean this up
state.pendingcb++;
doWrite(stream, state, true, state.length, state.buffer, '', function(err) {
for (var i = 0; i < cbs.length; i++) {
state.pendingcb--;
cbs[i](err);
}
});

// Clear buffer
state.buffer = [];
} else {
// Slow case, write chunks one-by-one
for (var c = 0; c < state.buffer.length; c++) {
var entry = state.buffer[c];
var chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
var len = state.objectMode ? 1 : chunk.length;

doWrite(stream, state, false, len, chunk, encoding, cb);

// if we didn't call the onwrite immediately, then

// it means that we need to wait until it does.
// also, that means that the chunk and cb are currently
// being processed, so move the buffer counter past them.
if (state.writing) {
c++;
break;
}
}

if (c < state.buffer.length)
state.buffer = state.buffer.slice(c);
else
state.buffer.length = 0;
}

state.bufferProcessing = false;
}

Writable.prototype._write = function(chunk, encoding, cb) {

cb(new Error('not implemented'));

};
Writable.prototype._writev = null;

Writable.prototype.end = function(chunk, encoding, cb) {

var state = this._writableState;

if (util.isFunction(chunk)) {
cb = chunk;
chunk = null;
encoding = null;
} else if (util.isFunction(encoding)) {
cb = encoding;
encoding = null;
}

if (!util.isNullOrUndefined(chunk))
this.write(chunk, encoding);

// .end() fully uncorks

if (state.corked) {
state.corked = 1;
this.uncork();
}

// ignore unnecessary end() calls.

if (!state.ending && !state.finished)
endWritable(this, state, cb);
};

function needFinish(stream, state) {

return (state.ending &&
state.length === 0 &&
!state.finished &&
!state.writing);
}

function prefinish(stream, state) {

if (!state.prefinished) {
state.prefinished = true;
stream.emit('prefinish');
}
}

function finishMaybe(stream, state) {

var need = needFinish(stream, state);
if (need) {
if (state.pendingcb === 0) {
prefinish(stream, state);
state.finished = true;
stream.emit('finish');
} else
prefinish(stream, state);
}
return need;
}

function endWritable(stream, state, cb) {

state.ending = true;
 finishMaybe(stream, state);
if (cb) {
if (state.finished)
process.nextTick(cb);
else
stream.once('finish', cb);
}
state.ended = true;
}

}).call(this,require('_process'))
},{"./_stream_duplex":93,"_process":91,"buffer":84,"core-util-
is":98,"inherits":89,"stream":103}],98:[function(require,module,exports){
(function (Buffer){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// NOTE: These type checking functions intentionally don't use `instanceof`

// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;

function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;

function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;

function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;

function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;

function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;

function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;

function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;

function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;

function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;

function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;

function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;

function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;

function isBuffer(arg) {
return Buffer.isBuffer(arg);
}
exports.isBuffer = isBuffer;
function objectToString(o) {
return Object.prototype.toString.call(o);
}
}).call(this,require("buffer").Buffer)
},{"buffer":84}],99:[function(require,module,exports){
module.exports = require("./lib/_stream_passthrough.js")

},{"./lib/_stream_passthrough.js":94}],100:[function(require,module,exports){
exports = module.exports = require('./lib/_stream_readable.js');
exports.Stream = require('stream');
exports.Readable = exports;
exports.Writable = require('./lib/_stream_writable.js');
exports.Duplex = require('./lib/_stream_duplex.js');
exports.Transform = require('./lib/_stream_transform.js');
exports.PassThrough = require('./lib/_stream_passthrough.js');

},{"./lib/_stream_duplex.js":93,"./lib/_stream_passthrough.js":94,"./lib/
_stream_readable.js":95,"./lib/_stream_transform.js":96,"./lib/
_stream_writable.js":97,"stream":103}],101:[function(require,module,exports){
module.exports = require("./lib/_stream_transform.js")

},{"./lib/_stream_transform.js":96}],102:[function(require,module,exports){
module.exports = require("./lib/_stream_writable.js")

},{"./lib/_stream_writable.js":97}],103:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

module.exports = Stream;

var EE = require('events').EventEmitter;
var inherits = require('inherits');

inherits(Stream, EE);
Stream.Readable = require('readable-stream/readable.js');
Stream.Writable = require('readable-stream/writable.js');
Stream.Duplex = require('readable-stream/duplex.js');
Stream.Transform = require('readable-stream/transform.js');
Stream.PassThrough = require('readable-stream/passthrough.js');

// Backwards-compat with node 0.4.x

Stream.Stream = Stream;

// old-style streams. Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.

function Stream() {
EE.call(this);
}

Stream.prototype.pipe = function(dest, options) {

var source = this;

function ondata(chunk) {
if (dest.writable) {
if (false === dest.write(chunk) && source.pause) {
source.pause();
}
}
}

source.on('data', ondata);

function ondrain() {
if (source.readable && source.resume) {
source.resume();
}
}

dest.on('drain', ondrain);

// If the 'end' option is not supplied, dest.end() will be called when

// source gets the 'end' or 'close' events. Only dest.end() once.
if (!dest._isStdio && (!options || options.end !== false)) {
source.on('end', onend);
source.on('close', onclose);
}

var didOnEnd = false;

function onend() {
if (didOnEnd) return;
didOnEnd = true;

dest.end();
}

function onclose() {
if (didOnEnd) return;
didOnEnd = true;

if (typeof dest.destroy === 'function') dest.destroy();

}

// don't leave dangling pipes when there are errors.

function onerror(er) {
cleanup();
if (EE.listenerCount(this, 'error') === 0) {
 throw er; // Unhandled stream error in pipe.
}
}

source.on('error', onerror);
dest.on('error', onerror);

// remove all the event listeners that were added.

function cleanup() {
source.removeListener('data', ondata);
dest.removeListener('drain', ondrain);

source.removeListener('end', onend);
source.removeListener('close', onclose);

source.removeListener('error', onerror);
dest.removeListener('error', onerror);

source.removeListener('end', cleanup);
source.removeListener('close', cleanup);

dest.removeListener('close', cleanup);
}

source.on('end', cleanup);
source.on('close', cleanup);

dest.on('close', cleanup);

dest.emit('pipe', source);

// Allow for unix-like usage: A.pipe(B).pipe(C)

return dest;
};

},{"events":88,"inherits":89,"readable-stream/duplex.js":92,"readable-stream/
passthrough.js":99,"readable-stream/readable.js":100,"readable-stream/
transform.js":101,"readable-stream/writable.js":102}],104:
[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var Buffer = require('buffer').Buffer;

var isBufferEncoding = Buffer.isEncoding

|| function(encoding) {
switch (encoding && encoding.toLowerCase()) {
case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case
'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw':
return true;
default: return false;
}
}

function assertEncoding(encoding) {
if (encoding && !isBufferEncoding(encoding)) {
throw new Error('Unknown encoding: ' + encoding);
}
}

// StringDecoder provides an interface for efficiently splitting a series of

// buffers into a series of JS strings without breaking apart multi-byte
// characters. CESU-8 is handled as part of the UTF-8 encoding.
//
// @TODO Handling all encodings inside a single object makes it very difficult
// to reason about this code, so it should be split up in the future.
// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
// points as used by CESU-8.
var StringDecoder = exports.StringDecoder = function(encoding) {
this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
assertEncoding(encoding);
switch (this.encoding) {
case 'utf8':
// CESU-8 represents each of Surrogate Pair by 3-bytes
this.surrogateSize = 3;
break;
case 'ucs2':
case 'utf16le':
// UTF-16 represents each of Surrogate Pair by 2-bytes
this.surrogateSize = 2;
this.detectIncompleteChar = utf16DetectIncompleteChar;
break;
case 'base64':
// Base-64 stores 3 bytes in 4 chars, and pads the remainder.
this.surrogateSize = 3;
this.detectIncompleteChar = base64DetectIncompleteChar;
break;
default:
this.write = passThroughWrite;
return;
}

// Enough space to store all bytes of a single character. UTF-8 needs 4

// bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
this.charBuffer = new Buffer(6);
// Number of bytes received for the current incomplete multi-byte character.
this.charReceived = 0;
// Number of bytes expected for the current incomplete multi-byte character.
this.charLength = 0;
};

// write decodes the given buffer and returns it as JS string that is

// guaranteed to not contain any partial multi-byte characters. Any partial
// character found at the end of the buffer is buffered up, and will be
// returned when calling write again with the remaining bytes.
//
// Note: Converting a Buffer containing an orphan surrogate to a String
// currently works, but converting a String to a Buffer (via `new Buffer`, or
// Buffer#write) will replace incomplete surrogates with the unicode
// replacement character. See https://codereview.chromium.org/121173009/ .
StringDecoder.prototype.write = function(buffer) {
var charStr = '';
// if our last write ended with an incomplete multibyte character
while (this.charLength) {
// determine how many remaining bytes this buffer has to offer for this char
var available = (buffer.length >= this.charLength - this.charReceived) ?
this.charLength - this.charReceived :
buffer.length;

// add the new bytes to the char buffer

buffer.copy(this.charBuffer, this.charReceived, 0, available);
this.charReceived += available;

if (this.charReceived < this.charLength) {

// still not enough chars in this buffer? wait for more ...
return '';
}

// remove bytes belonging to the current character from the buffer

buffer = buffer.slice(available, buffer.length);

// get the character that was split

charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);

// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character

var charCode = charStr.charCodeAt(charStr.length - 1);
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
this.charLength += this.surrogateSize;
charStr = '';
continue;
}
this.charReceived = this.charLength = 0;

// if there are no more bytes in this buffer, just emit our char
if (buffer.length === 0) {
return charStr;
}
break;
}

// determine and set charLength / charReceived

this.detectIncompleteChar(buffer);

var end = buffer.length;

if (this.charLength) {
// buffer the incomplete character bytes we got
buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
 end -= this.charReceived;
}

charStr += buffer.toString(this.encoding, 0, end);

var end = charStr.length - 1;

var charCode = charStr.charCodeAt(end);
// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
var size = this.surrogateSize;
this.charLength += size;
this.charReceived += size;
this.charBuffer.copy(this.charBuffer, size, 0, size);
buffer.copy(this.charBuffer, 0, 0, size);
return charStr.substring(0, end);
}

// or just emit the charStr

return charStr;
};

// detectIncompleteChar determines if there is an incomplete UTF-8 character at

// the end of the given buffer. If so, it sets this.charLength to the byte
// length that character, and sets this.charReceived to the number of bytes
// that are available for this character.
StringDecoder.prototype.detectIncompleteChar = function(buffer) {
// determine how many bytes we have to check at the end of this buffer
var i = (buffer.length >= 3) ? 3 : buffer.length;

// Figure out if one of the last i bytes of our buffer announces an

// incomplete char.
for (; i > 0; i--) {
var c = buffer[buffer.length - i];

// See http://en.wikipedia.org/wiki/UTF-8#Description

// 110XXXXX
if (i == 1 && c >> 5 == 0x06) {
this.charLength = 2;
break;
}

// 1110XXXX
if (i <= 2 && c >> 4 == 0x0E) {
this.charLength = 3;
break;
}

// 11110XXX
if (i <= 3 && c >> 3 == 0x1E) {
this.charLength = 4;
break;
}
}
this.charReceived = i;
};

StringDecoder.prototype.end = function(buffer) {
var res = '';
 if (buffer && buffer.length)
res = this.write(buffer);

if (this.charReceived) {
var cr = this.charReceived;
var buf = this.charBuffer;
var enc = this.encoding;
res += buf.slice(0, cr).toString(enc);
}

return res;
};

function passThroughWrite(buffer) {
return buffer.toString(this.encoding);
}

function utf16DetectIncompleteChar(buffer) {
this.charReceived = buffer.length % 2;
this.charLength = this.charReceived ? 2 : 0;
}

function base64DetectIncompleteChar(buffer) {
this.charReceived = buffer.length % 3;
this.charLength = this.charReceived ? 3 : 0;
}

},{"buffer":84}],105:[function(require,module,exports){
module.exports = function isBuffer(arg) {
return arg && typeof arg === 'object'
&& typeof arg.copy === 'function'
&& typeof arg.fill === 'function'
&& typeof arg.readUInt8 === 'function';
}
},{}],106:[function(require,module,exports){
(function (process,global){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

var formatRegExp = /%[sdj%]/g;

exports.format = function(f) {
 if (!isString(f)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(inspect(arguments[i]));
}
return objects.join(' ');
}

var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (x === '%%') return '%';
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j':
try {
return JSON.stringify(args[i++]);
} catch (_) {
return '[Circular]';
}
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull(x) || !isObject(x)) {
str += ' ' + x;
} else {
str += ' ' + inspect(x);
}
}
return str;
};

// Mark that a method should not be used.

// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
// Allow for deprecating things in the process of starting up.
if (isUndefined(global.process)) {
return function() {
return exports.deprecate(fn, msg).apply(this, arguments);
};
}

if (process.noDeprecation === true) {

return fn;
}

var warned = false;

function deprecated() {
if (!warned) {
if (process.throwDeprecation) {
throw new Error(msg);
} else if (process.traceDeprecation) {
 console.trace(msg);
} else {
console.error(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}

return deprecated;
};

var debugs = {};

var debugEnviron;
exports.debuglog = function(set) {
if (isUndefined(debugEnviron))
debugEnviron = process.env.NODE_DEBUG || '';
set = set.toUpperCase();
if (!debugs[set]) {
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
var pid = process.pid;
debugs[set] = function() {
var msg = exports.format.apply(exports, arguments);
console.error('%s %d: %s', set, pid, msg);
};
} else {
debugs[set] = function() {};
}
}
return debugs[set];
};

/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
// default options
var ctx = {
seen: [],
stylize: stylizeNoColor
};
// legacy...
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean(opts)) {
// legacy...
ctx.showHidden = opts;
} else if (opts) {
// got an "options" object
exports._extend(ctx, opts);
}
// set default options
 if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined(ctx.depth)) ctx.depth = 2;
if (isUndefined(ctx.colors)) ctx.colors = false;
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;

// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
'bold' : [1, 22],
'italic' : [3, 23],
'underline' : [4, 24],
'inverse' : [7, 27],
'white' : [37, 39],
'grey' : [90, 39],
'black' : [30, 39],
'blue' : [34, 39],
'cyan' : [36, 39],
'green' : [32, 39],
'magenta' : [35, 39],
'red' : [31, 39],
'yellow' : [33, 39]
};

// Don't use 'blue' not visible on cmd.exe

inspect.styles = {
'special': 'cyan',
'number': 'yellow',
'boolean': 'yellow',
'undefined': 'grey',
'null': 'bold',
'string': 'green',
'date': 'magenta',
// "name": intentionally not styling
'regexp': 'red'
};

function stylizeWithColor(str, styleType) {

var style = inspect.styles[styleType];

if (style) {
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
'\u001b[' + inspect.colors[style][1] + 'm';
} else {
return str;
}
}

function stylizeNoColor(str, styleType) {

return str;
}

function arrayToHash(array) {
 var hash = {};

array.forEach(function(val, idx) {
hash[val] = true;
});

return hash;
}

function formatValue(ctx, value, recurseTimes) {

// Provide a hook for user-specified inspect functions.
// Check that value is an object with an inspect function on it
if (ctx.customInspect &&
value &&
isFunction(value.inspect) &&
// Filter out the util module, it's inspect function is special
value.inspect !== exports.inspect &&
// Also filter out any prototype objects using the circular check.
!(value.constructor && value.constructor.prototype === value)) {
var ret = value.inspect(recurseTimes, ctx);
if (!isString(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}

// Primitive types cannot have properties

var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}

// Look up the keys of the object.

var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);

if (ctx.showHidden) {
keys = Object.getOwnPropertyNames(value);
}

// IE doesn't make error fields non-enumerable

// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
if (isError(value)
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
return formatError(value);
}

// Some type of object without properties can be shortcutted.

if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ': ' + value.name : '';
return ctx.stylize('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
}
if (isDate(value)) {
return ctx.stylize(Date.prototype.toString.call(value), 'date');
 }
if (isError(value)) {
return formatError(value);
}
}

var base = '', array = false, braces = ['{', '}'];

// Make Array say that they are Array

if (isArray(value)) {
array = true;
braces = ['[', ']'];
}

// Make functions say that they are functions

if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}

// Make RegExps say that they are RegExps

if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}

// Make dates with properties first say the date

if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}

// Make error with message first say the error

if (isError(value)) {
base = ' ' + formatError(value);
}

if (keys.length === 0 && (!array || value.length == 0)) {

return braces[0] + base + braces[1];
}

if (recurseTimes < 0) {
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
} else {
return ctx.stylize('[Object]', 'special');
}
}

ctx.seen.push(value);

var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = keys.map(function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}

ctx.seen.pop();
 return reduceToSingleString(output, base, braces);
}

function formatPrimitive(ctx, value) {

if (isUndefined(value))
return ctx.stylize('undefined', 'undefined');
if (isString(value)) {
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
.replace(/'/g, "\\'")
.replace(/\\"/g, '"') + '\'';
return ctx.stylize(simple, 'string');
}
if (isNumber(value))
return ctx.stylize('' + value, 'number');
if (isBoolean(value))
return ctx.stylize('' + value, 'boolean');
// For some reason typeof null is "object", so special case here.
if (isNull(value))
return ctx.stylize('null', 'null');
}

function formatError(value) {
return '[' + Error.prototype.toString.call(value) + ']';
}

function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {

var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
String(i), true));
} else {
output.push('');
}
}
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
key, true));
}
});
return output;
}

function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {

var name, str, desc;
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
if (desc.get) {
if (desc.set) {
str = ctx.stylize('[Getter/Setter]', 'special');
} else {
str = ctx.stylize('[Getter]', 'special');
}
} else {
 if (desc.set) {
str = ctx.stylize('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(ctx, desc.value, recurseTimes - 1);
}
if (str.indexOf('\n') > -1) {
if (array) {
str = str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n').substr(2);
} else {
str = '\n' + str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = ctx.stylize('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && key.match(/^\d+$/)) {
return str;
}
name = JSON.stringify('' + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.substr(1, name.length - 2);
name = ctx.stylize(name, 'name');
} else {
name = name.replace(/'/g, "\\'")
.replace(/\\"/g, '"')
.replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, 'string');
}
}

return name + ': ' + str;

}

function reduceToSingleString(output, base, braces) {

var numLinesEst = 0;
var length = output.reduce(function(prev, cur) {
numLinesEst++;
if (cur.indexOf('\n') >= 0) numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
}, 0);

if (length > 60) {

return braces[0] +
 (base === '' ? '' : base + '\n ') +
' ' +
output.join(',\n ') +
' ' +
braces[1];
}

return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}

// NOTE: These type checking functions intentionally don't use `instanceof`

// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;

function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;

function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;

function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;

function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;

function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;

function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;

function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;

function isObject(arg) {
 return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;

function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;

function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;

function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;

function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;

exports.isBuffer = require('./support/isBuffer');

function objectToString(o) {
return Object.prototype.toString.call(o);
}

function pad(n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
}

var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
function timestamp() {
var d = new Date();
var time = [pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())].join(':');
return [d.getDate(), months[d.getMonth()], time].join(' ');
}

// log is just a thin wrapper to console.log that prepends a timestamp

exports.log = function() {
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};
/**
* Inherit the prototype methods from one constructor into another.
*
* The Function.prototype.inherits from lang.js rewritten as a standalone
* function (not on Function.prototype). NOTE: If this file is to be loaded
* during bootstrapping this function needs to be rewritten using some native
* functions as prototype setup using normal JavaScript does not work as
* expected during bootstrapping (see mirror.js in r114903).
*
* @param {function} ctor Constructor function which needs to inherit the
* prototype.
* @param {function} superCtor Constructor function to inherit prototype from.
*/
exports.inherits = require('inherits');

exports._extend = function(origin, add) {

// Don't do anything if add isn't an object
if (!add || !isObject(add)) return origin;

var keys = Object.keys(add);

var i = keys.length;
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
};

function hasOwnProperty(obj, prop) {

return Object.prototype.hasOwnProperty.call(obj, prop);
}

}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof

self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./support/isBuffer":105,"_process":91,"inherits":89}]},{},[53])(53)
});