1 (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
.bitcoinjs
= 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
){
5 // compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
9 * The buffer module from node.js, for the browser.
11 * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
14 function compare(a
, b
) {
22 for (var i
= 0, len
= Math
.min(x
, y
); i
< len
; ++i
) {
38 function isBuffer(b
) {
39 if (global
.Buffer
&& typeof global
.Buffer
.isBuffer
=== 'function') {
40 return global
.Buffer
.isBuffer(b
);
42 return !!(b
!= null && b
._isBuffer
);
45 // based on node assert, original notice:
47 // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
49 // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
51 // Originally from narwhal.js (http://narwhaljs.org)
52 // Copyright (c) 2009 Thomas Robinson <280north.com>
54 // Permission is hereby granted, free of charge, to any person obtaining a copy
55 // of this software and associated documentation files (the 'Software'), to
56 // deal in the Software without restriction, including without limitation the
57 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
58 // sell copies of the Software, and to permit persons to whom the Software is
59 // furnished to do so, subject to the following conditions:
61 // The above copyright notice and this permission notice shall be included in
62 // all copies or substantial portions of the Software.
64 // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
65 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
66 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
67 // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
68 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
69 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
71 var util
= require('util/');
72 var hasOwn
= Object
.prototype.hasOwnProperty
;
73 var pSlice
= Array
.prototype.slice
;
74 var functionsHaveNames
= (function () {
75 return function foo() {}.name
=== 'foo';
77 function pToString (obj
) {
78 return Object
.prototype.toString
.call(obj
);
80 function isView(arrbuf
) {
81 if (isBuffer(arrbuf
)) {
84 if (typeof global
.ArrayBuffer
!== 'function') {
87 if (typeof ArrayBuffer
.isView
=== 'function') {
88 return ArrayBuffer
.isView(arrbuf
);
93 if (arrbuf
instanceof DataView
) {
96 if (arrbuf
.buffer
&& arrbuf
.buffer
instanceof ArrayBuffer
) {
101 // 1. The assert module provides functions that throw
102 // AssertionError's when particular conditions are not met. The
103 // assert module must conform to the following interface.
105 var assert
= module
.exports
= ok
;
107 // 2. The AssertionError is defined in assert.
108 // new assert.AssertionError({ message: message,
110 // expected: expected })
112 var regex
= /\s*function\s+([^\(\s]*)\s*/;
113 // based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
114 function getName(func
) {
115 if (!util
.isFunction(func
)) {
118 if (functionsHaveNames
) {
121 var str
= func
.toString();
122 var match
= str
.match(regex
);
123 return match
&& match
[1];
125 assert
.AssertionError
= function AssertionError(options
) {
126 this.name
= 'AssertionError';
127 this.actual
= options
.actual
;
128 this.expected
= options
.expected
;
129 this.operator
= options
.operator
;
130 if (options
.message
) {
131 this.message
= options
.message
;
132 this.generatedMessage
= false;
134 this.message
= getMessage(this);
135 this.generatedMessage
= true;
137 var stackStartFunction
= options
.stackStartFunction
|| fail
;
138 if (Error
.captureStackTrace
) {
139 Error
.captureStackTrace(this, stackStartFunction
);
141 // non v8 browsers so we can have a stacktrace
142 var err
= new Error();
146 // try to strip useless frames
147 var fn_name
= getName(stackStartFunction
);
148 var idx
= out
.indexOf('\n' + fn_name
);
150 // once we have located the function frame
151 // we need to strip out everything before it (and its line)
152 var next_line
= out
.indexOf('\n', idx
+ 1);
153 out
= out
.substring(next_line
+ 1);
161 // assert.AssertionError instanceof Error
162 util
.inherits(assert
.AssertionError
, Error
);
164 function truncate(s
, n
) {
165 if (typeof s
=== 'string') {
166 return s
.length
< n
? s : s
.slice(0, n
);
171 function inspect(something
) {
172 if (functionsHaveNames
|| !util
.isFunction(something
)) {
173 return util
.inspect(something
);
175 var rawname
= getName(something
);
176 var name
= rawname
? ': ' + rawname : '';
177 return '[Function' + name
+ ']';
179 function getMessage(self
) {
180 return truncate(inspect(self
.actual
), 128) + ' ' +
181 self
.operator
+ ' ' +
182 truncate(inspect(self
.expected
), 128);
185 // At present only the three keys mentioned above are used and
186 // understood by the spec. Implementations or sub modules can pass
187 // other keys to the AssertionError's constructor - they will be
190 // 3. All of the following functions must throw an AssertionError
191 // when a corresponding condition is not met, with a message that
192 // may be undefined if not provided. All assertion methods provide
193 // both the actual and expected values to the assertion error for
196 function fail(actual
, expected
, message
, operator
, stackStartFunction
) {
197 throw new assert
.AssertionError({
202 stackStartFunction: stackStartFunction
206 // EXTENSION! allows for well behaved errors defined elsewhere.
209 // 4. Pure assertion tests whether a value is truthy, as determined
211 // assert.ok(guard, message_opt);
212 // This statement is equivalent to assert.equal(true, !!guard,
213 // message_opt);. To test strictly for the value true, use
214 // assert.strictEqual(true, guard, message_opt);.
216 function ok(value
, message
) {
217 if (!value
) fail(value
, true, message
, '==', assert
.ok
);
221 // 5. The equality assertion tests shallow, coercive equality with
223 // assert.equal(actual, expected, message_opt);
225 assert
.equal
= function equal(actual
, expected
, message
) {
226 if (actual
!= expected
) fail(actual
, expected
, message
, '==', assert
.equal
);
229 // 6. The non-equality assertion tests for whether two objects are not equal
230 // with != assert.notEqual(actual, expected, message_opt);
232 assert
.notEqual
= function notEqual(actual
, expected
, message
) {
233 if (actual
== expected
) {
234 fail(actual
, expected
, message
, '!=', assert
.notEqual
);
238 // 7. The equivalence assertion tests a deep equality relation.
239 // assert.deepEqual(actual, expected, message_opt);
241 assert
.deepEqual
= function deepEqual(actual
, expected
, message
) {
242 if (!_deepEqual(actual
, expected
, false)) {
243 fail(actual
, expected
, message
, 'deepEqual', assert
.deepEqual
);
247 assert
.deepStrictEqual
= function deepStrictEqual(actual
, expected
, message
) {
248 if (!_deepEqual(actual
, expected
, true)) {
249 fail(actual
, expected
, message
, 'deepStrictEqual', assert
.deepStrictEqual
);
253 function _deepEqual(actual
, expected
, strict
, memos
) {
254 // 7.1. All identical values are equivalent, as determined by ===.
255 if (actual
=== expected
) {
257 } else if (isBuffer(actual
) && isBuffer(expected
)) {
258 return compare(actual
, expected
) === 0;
260 // 7.2. If the expected value is a Date object, the actual value is
261 // equivalent if it is also a Date object that refers to the same time.
262 } else if (util
.isDate(actual
) && util
.isDate(expected
)) {
263 return actual
.getTime() === expected
.getTime();
265 // 7.3 If the expected value is a RegExp object, the actual value is
266 // equivalent if it is also a RegExp object with the same source and
267 // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
268 } else if (util
.isRegExp(actual
) && util
.isRegExp(expected
)) {
269 return actual
.source
=== expected
.source
&&
270 actual
.global
=== expected
.global
&&
271 actual
.multiline
=== expected
.multiline
&&
272 actual
.lastIndex
=== expected
.lastIndex
&&
273 actual
.ignoreCase
=== expected
.ignoreCase
;
275 // 7.4. Other pairs that do not both pass typeof value == 'object',
276 // equivalence is determined by ==.
277 } else if ((actual
=== null || typeof actual
!== 'object') &&
278 (expected
=== null || typeof expected
!== 'object')) {
279 return strict
? actual
=== expected : actual
== expected
;
281 // If both values are instances of typed arrays, wrap their underlying
282 // ArrayBuffers in a Buffer each to increase performance
283 // This optimization requires the arrays to have the same type as checked by
284 // Object.prototype.toString (aka pToString). Never perform binary
285 // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
286 // bit patterns are not identical.
287 } else if (isView(actual
) && isView(expected
) &&
288 pToString(actual
) === pToString(expected
) &&
289 !(actual
instanceof Float32Array
||
290 actual
instanceof Float64Array
)) {
291 return compare(new Uint8Array(actual
.buffer
),
292 new Uint8Array(expected
.buffer
)) === 0;
294 // 7.5 For all other Object pairs, including Array objects, equivalence is
295 // determined by having the same number of owned properties (as verified
296 // with Object.prototype.hasOwnProperty.call), the same set of keys
297 // (although not necessarily the same order), equivalent values for every
298 // corresponding key, and an identical 'prototype' property. Note: this
299 // accounts for both named and indexed properties on Arrays.
300 } else if (isBuffer(actual
) !== isBuffer(expected
)) {
303 memos
= memos
|| {actual: [], expected: []};
305 var actualIndex
= memos
.actual
.indexOf(actual
);
306 if (actualIndex
!== -1) {
307 if (actualIndex
=== memos
.expected
.indexOf(expected
)) {
312 memos
.actual
.push(actual
);
313 memos
.expected
.push(expected
);
315 return objEquiv(actual
, expected
, strict
, memos
);
319 function isArguments(object
) {
320 return Object
.prototype.toString
.call(object
) == '[object Arguments]';
323 function objEquiv(a
, b
, strict
, actualVisitedObjects
) {
324 if (a
=== null || a
=== undefined || b
=== null || b
=== undefined)
326 // if one is a primitive, the other must be same
327 if (util
.isPrimitive(a
) || util
.isPrimitive(b
))
329 if (strict
&& Object
.getPrototypeOf(a
) !== Object
.getPrototypeOf(b
))
331 var aIsArgs
= isArguments(a
);
332 var bIsArgs
= isArguments(b
);
333 if ((aIsArgs
&& !bIsArgs
) || (!aIsArgs
&& bIsArgs
))
338 return _deepEqual(a
, b
, strict
);
340 var ka
= objectKeys(a
);
341 var kb
= objectKeys(b
);
343 // having the same number of owned properties (keys incorporates
345 if (ka
.length
!== kb
.length
)
347 //the same set of keys (although not necessarily the same order),
351 for (i
= ka
.length
- 1; i
>= 0; i
--) {
355 //equivalent values for every corresponding key, and
356 //~~~possibly expensive deep test
357 for (i
= ka
.length
- 1; i
>= 0; i
--) {
359 if (!_deepEqual(a
[key
], b
[key
], strict
, actualVisitedObjects
))
365 // 8. The non-equivalence assertion tests for any deep inequality.
366 // assert.notDeepEqual(actual, expected, message_opt);
368 assert
.notDeepEqual
= function notDeepEqual(actual
, expected
, message
) {
369 if (_deepEqual(actual
, expected
, false)) {
370 fail(actual
, expected
, message
, 'notDeepEqual', assert
.notDeepEqual
);
374 assert
.notDeepStrictEqual
= notDeepStrictEqual
;
375 function notDeepStrictEqual(actual
, expected
, message
) {
376 if (_deepEqual(actual
, expected
, true)) {
377 fail(actual
, expected
, message
, 'notDeepStrictEqual', notDeepStrictEqual
);
382 // 9. The strict equality assertion tests strict equality, as determined by ===.
383 // assert.strictEqual(actual, expected, message_opt);
385 assert
.strictEqual
= function strictEqual(actual
, expected
, message
) {
386 if (actual
!== expected
) {
387 fail(actual
, expected
, message
, '===', assert
.strictEqual
);
391 // 10. The strict non-equality assertion tests for strict inequality, as
392 // determined by !==. assert.notStrictEqual(actual, expected, message_opt);
394 assert
.notStrictEqual
= function notStrictEqual(actual
, expected
, message
) {
395 if (actual
=== expected
) {
396 fail(actual
, expected
, message
, '!==', assert
.notStrictEqual
);
400 function expectedException(actual
, expected
) {
401 if (!actual
|| !expected
) {
405 if (Object
.prototype.toString
.call(expected
) == '[object RegExp]') {
406 return expected
.test(actual
);
410 if (actual
instanceof expected
) {
414 // Ignore. The instanceof check doesn't work for arrow functions.
417 if (Error
.isPrototypeOf(expected
)) {
421 return expected
.call({}, actual
) === true;
424 function _tryBlock(block
) {
434 function _throws(shouldThrow
, block
, expected
, message
) {
437 if (typeof block
!== 'function') {
438 throw new TypeError('"block" argument must be a function');
441 if (typeof expected
=== 'string') {
446 actual
= _tryBlock(block
);
448 message
= (expected
&& expected
.name
? ' (' + expected
.name
+ ').' : '.') +
449 (message
? ' ' + message : '.');
451 if (shouldThrow
&& !actual
) {
452 fail(actual
, expected
, 'Missing expected exception' + message
);
455 var userProvidedMessage
= typeof message
=== 'string';
456 var isUnwantedException
= !shouldThrow
&& util
.isError(actual
);
457 var isUnexpectedException
= !shouldThrow
&& actual
&& !expected
;
459 if ((isUnwantedException
&&
460 userProvidedMessage
&&
461 expectedException(actual
, expected
)) ||
462 isUnexpectedException
) {
463 fail(actual
, expected
, 'Got unwanted exception' + message
);
466 if ((shouldThrow
&& actual
&& expected
&&
467 !expectedException(actual
, expected
)) || (!shouldThrow
&& actual
)) {
472 // 11. Expected to throw an error:
473 // assert.throws(block, Error_opt, message_opt);
475 assert
.throws = function(block
, /*optional*/error
, /*optional*/message
) {
476 _throws(true, block
, error
, message
);
479 // EXTENSION! This is annoying to write outside this module.
480 assert
.doesNotThrow = function(block
, /*optional*/error
, /*optional*/message
) {
481 _throws(false, block
, error
, message
);
484 assert
.ifError = function(err
) { if (err
) throw err
; };
486 var objectKeys
= Object
.keys
|| function (obj
) {
488 for (var key
in obj
) {
489 if (hasOwn
.call(obj
, key
)) keys
.push(key
);
494 }).call(this,typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
495 },{"util/":32}],2:[function(require
,module
,exports
){
498 exports
.byteLength
= byteLength
499 exports
.toByteArray
= toByteArray
500 exports
.fromByteArray
= fromByteArray
504 var Arr
= typeof Uint8Array
!== 'undefined' ? Uint8Array : Array
506 var code
= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
507 for (var i
= 0, len
= code
.length
; i
< len
; ++i
) {
509 revLookup
[code
.charCodeAt(i
)] = i
512 revLookup
['-'.charCodeAt(0)] = 62
513 revLookup
['_'.charCodeAt(0)] = 63
515 function placeHoldersCount (b64
) {
518 throw new Error('Invalid string. Length must be a multiple of 4')
521 // the number of equal signs (place holders)
522 // if there are two placeholders, than the two characters before it
523 // represent one byte
524 // if there is only one, then the three characters before it represent 2 bytes
525 // this is just a cheap hack to not do indexOf twice
526 return b64
[len
- 2] === '=' ? 2 : b64
[len
- 1] === '=' ? 1 : 0
529 function byteLength (b64
) {
530 // base64 is 4/3 + up to two characters of the original data
531 return (b64
.length
* 3 / 4) - placeHoldersCount(b64
)
534 function toByteArray (b64
) {
535 var i
, l
, tmp
, placeHolders
, arr
537 placeHolders
= placeHoldersCount(b64
)
539 arr
= new Arr((len
* 3 / 4) - placeHolders
)
541 // if there are placeholders, only get up to the last complete 4 chars
542 l
= placeHolders
> 0 ? len
- 4 : len
546 for (i
= 0; i
< l
; i
+= 4) {
547 tmp
= (revLookup
[b64
.charCodeAt(i
)] << 18) | (revLookup
[b64
.charCodeAt(i
+ 1)] << 12) | (revLookup
[b64
.charCodeAt(i
+ 2)] << 6) | revLookup
[b64
.charCodeAt(i
+ 3)]
548 arr
[L
++] = (tmp
>> 16) & 0xFF
549 arr
[L
++] = (tmp
>> 8) & 0xFF
550 arr
[L
++] = tmp
& 0xFF
553 if (placeHolders
=== 2) {
554 tmp
= (revLookup
[b64
.charCodeAt(i
)] << 2) | (revLookup
[b64
.charCodeAt(i
+ 1)] >> 4)
555 arr
[L
++] = tmp
& 0xFF
556 } else if (placeHolders
=== 1) {
557 tmp
= (revLookup
[b64
.charCodeAt(i
)] << 10) | (revLookup
[b64
.charCodeAt(i
+ 1)] << 4) | (revLookup
[b64
.charCodeAt(i
+ 2)] >> 2)
558 arr
[L
++] = (tmp
>> 8) & 0xFF
559 arr
[L
++] = tmp
& 0xFF
565 function tripletToBase64 (num
) {
566 return lookup
[num
>> 18 & 0x3F] + lookup
[num
>> 12 & 0x3F] + lookup
[num
>> 6 & 0x3F] + lookup
[num
& 0x3F]
569 function encodeChunk (uint8
, start
, end
) {
572 for (var i
= start
; i
< end
; i
+= 3) {
573 tmp
= (uint8
[i
] << 16) + (uint8
[i
+ 1] << 8) + (uint8
[i
+ 2])
574 output
.push(tripletToBase64(tmp
))
576 return output
.join('')
579 function fromByteArray (uint8
) {
581 var len
= uint8
.length
582 var extraBytes
= len
% 3 // if we have 1 byte left, pad 2 bytes
585 var maxChunkLength
= 16383 // must be multiple of 3
587 // go through the array every three bytes, we'll deal with trailing stuff later
588 for (var i
= 0, len2
= len
- extraBytes
; i
< len2
; i
+= maxChunkLength
) {
589 parts
.push(encodeChunk(uint8
, i
, (i
+ maxChunkLength
) > len2
? len2 : (i
+ maxChunkLength
)))
592 // pad the end with zeros, but make sure to not forget the extra bytes
593 if (extraBytes
=== 1) {
595 output
+= lookup
[tmp
>> 2]
596 output
+= lookup
[(tmp
<< 4) & 0x3F]
598 } else if (extraBytes
=== 2) {
599 tmp
= (uint8
[len
- 2] << 8) + (uint8
[len
- 1])
600 output
+= lookup
[tmp
>> 10]
601 output
+= lookup
[(tmp
>> 4) & 0x3F]
602 output
+= lookup
[(tmp
<< 2) & 0x3F]
608 return parts
.join('')
611 },{}],3:[function(require
,module
,exports
){
613 },{}],4:[function(require
,module
,exports
){
615 * The buffer module from node.js, for the browser.
617 * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
620 /* eslint-disable no-proto */
624 var base64
= require('base64-js')
625 var ieee754
= require('ieee754')
627 exports
.Buffer
= Buffer
628 exports
.SlowBuffer
= SlowBuffer
629 exports
.INSPECT_MAX_BYTES
= 50
631 var K_MAX_LENGTH
= 0x7fffffff
632 exports
.kMaxLength
= K_MAX_LENGTH
635 * If `Buffer.TYPED_ARRAY_SUPPORT`:
636 * === true Use Uint8Array implementation (fastest)
637 * === false Print warning and recommend using `buffer` v4.x which has an Object
638 * implementation (most compatible, even IE6)
640 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
641 * Opera 11.6+, iOS 4.2+.
643 * We report that the browser does not support typed arrays if the are not subclassable
644 * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
645 * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
646 * for __proto__ and has a buggy typed array implementation.
648 Buffer
.TYPED_ARRAY_SUPPORT
= typedArraySupport()
650 if (!Buffer
.TYPED_ARRAY_SUPPORT
&& typeof console
!== 'undefined' &&
651 typeof console
.error
=== 'function') {
653 'This browser lacks typed array (Uint8Array) support which is required by ' +
654 '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
658 function typedArraySupport () {
659 // Can typed array instances can be augmented?
661 var arr
= new Uint8Array(1)
662 arr
.__proto__
= {__proto__: Uint8Array
.prototype, foo: function () { return 42 }}
663 return arr
.foo() === 42
669 function createBuffer (length
) {
670 if (length
> K_MAX_LENGTH
) {
671 throw new RangeError('Invalid typed array length')
673 // Return an augmented `Uint8Array` instance
674 var buf
= new Uint8Array(length
)
675 buf
.__proto__
= Buffer
.prototype
680 * The Buffer constructor returns instances of `Uint8Array` that have their
681 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
682 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
683 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
684 * returns a single octet.
686 * The `Uint8Array` prototype remains unmodified.
689 function Buffer (arg
, encodingOrOffset
, length
) {
691 if (typeof arg
=== 'number') {
692 if (typeof encodingOrOffset
=== 'string') {
694 'If encoding is specified then the first argument must be a string'
697 return allocUnsafe(arg
)
699 return from(arg
, encodingOrOffset
, length
)
702 // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
703 if (typeof Symbol
!== 'undefined' && Symbol
.species
&&
704 Buffer
[Symbol
.species
] === Buffer
) {
705 Object
.defineProperty(Buffer
, Symbol
.species
, {
713 Buffer
.poolSize
= 8192 // not used by this implementation
715 function from (value
, encodingOrOffset
, length
) {
716 if (typeof value
=== 'number') {
717 throw new TypeError('"value" argument must not be a number')
720 if (value
instanceof ArrayBuffer
) {
721 return fromArrayBuffer(value
, encodingOrOffset
, length
)
724 if (typeof value
=== 'string') {
725 return fromString(value
, encodingOrOffset
)
728 return fromObject(value
)
732 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
733 * if value is a number.
734 * Buffer.from(str[, encoding])
736 * Buffer.from(buffer)
737 * Buffer.from(arrayBuffer[, byteOffset[, length]])
739 Buffer
.from = function (value
, encodingOrOffset
, length
) {
740 return from(value
, encodingOrOffset
, length
)
743 // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
744 // https://github.com/feross/buffer/pull/148
745 Buffer
.prototype.__proto__
= Uint8Array
.prototype
746 Buffer
.__proto__
= Uint8Array
748 function assertSize (size
) {
749 if (typeof size
!== 'number') {
750 throw new TypeError('"size" argument must be a number')
751 } else if (size
< 0) {
752 throw new RangeError('"size" argument must not be negative')
756 function alloc (size
, fill
, encoding
) {
759 return createBuffer(size
)
761 if (fill
!== undefined) {
762 // Only pay attention to encoding if it's a string. This
763 // prevents accidentally sending in a number that would
764 // be interpretted as a start offset.
765 return typeof encoding
=== 'string'
766 ? createBuffer(size
).fill(fill
, encoding
)
767 : createBuffer(size
).fill(fill
)
769 return createBuffer(size
)
773 * Creates a new filled Buffer instance.
774 * alloc(size[, fill[, encoding]])
776 Buffer
.alloc = function (size
, fill
, encoding
) {
777 return alloc(size
, fill
, encoding
)
780 function allocUnsafe (size
) {
782 return createBuffer(size
< 0 ? 0 : checked(size
) | 0)
786 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
788 Buffer
.allocUnsafe = function (size
) {
789 return allocUnsafe(size
)
792 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
794 Buffer
.allocUnsafeSlow = function (size
) {
795 return allocUnsafe(size
)
798 function fromString (string
, encoding
) {
799 if (typeof encoding
!== 'string' || encoding
=== '') {
803 if (!Buffer
.isEncoding(encoding
)) {
804 throw new TypeError('"encoding" must be a valid string encoding')
807 var length
= byteLength(string
, encoding
) | 0
808 var buf
= createBuffer(length
)
810 var actual
= buf
.write(string
, encoding
)
812 if (actual
!== length
) {
813 // Writing a hex string, for example, that contains invalid characters will
814 // cause everything after the first invalid character to be ignored. (e.g.
815 // 'abxxcd' will be treated as 'ab')
816 buf
= buf
.slice(0, actual
)
822 function fromArrayLike (array
) {
823 var length
= array
.length
< 0 ? 0 : checked(array
.length
) | 0
824 var buf
= createBuffer(length
)
825 for (var i
= 0; i
< length
; i
+= 1) {
826 buf
[i
] = array
[i
] & 255
831 function fromArrayBuffer (array
, byteOffset
, length
) {
832 if (byteOffset
< 0 || array
.byteLength
< byteOffset
) {
833 throw new RangeError('\'offset\' is out of bounds')
836 if (array
.byteLength
< byteOffset
+ (length
|| 0)) {
837 throw new RangeError('\'length\' is out of bounds')
841 if (byteOffset
=== undefined && length
=== undefined) {
842 buf
= new Uint8Array(array
)
843 } else if (length
=== undefined) {
844 buf
= new Uint8Array(array
, byteOffset
)
846 buf
= new Uint8Array(array
, byteOffset
, length
)
849 // Return an augmented `Uint8Array` instance
850 buf
.__proto__
= Buffer
.prototype
854 function fromObject (obj
) {
855 if (Buffer
.isBuffer(obj
)) {
856 var len
= checked(obj
.length
) | 0
857 var buf
= createBuffer(len
)
859 if (buf
.length
=== 0) {
863 obj
.copy(buf
, 0, 0, len
)
868 if (isArrayBufferView(obj
) || 'length' in obj
) {
869 if (typeof obj
.length
!== 'number' || numberIsNaN(obj
.length
)) {
870 return createBuffer(0)
872 return fromArrayLike(obj
)
875 if (obj
.type
=== 'Buffer' && Array
.isArray(obj
.data
)) {
876 return fromArrayLike(obj
.data
)
880 throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
883 function checked (length
) {
884 // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
885 // length is NaN (which is otherwise coerced to zero.)
886 if (length
>= K_MAX_LENGTH
) {
887 throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
888 'size: 0x' + K_MAX_LENGTH
.toString(16) + ' bytes')
893 function SlowBuffer (length
) {
894 if (+length
!= length
) { // eslint-disable-line eqeqeq
897 return Buffer
.alloc(+length
)
900 Buffer
.isBuffer
= function isBuffer (b
) {
901 return b
!= null && b
._isBuffer
=== true
904 Buffer
.compare
= function compare (a
, b
) {
905 if (!Buffer
.isBuffer(a
) || !Buffer
.isBuffer(b
)) {
906 throw new TypeError('Arguments must be Buffers')
909 if (a
=== b
) return 0
914 for (var i
= 0, len
= Math
.min(x
, y
); i
< len
; ++i
) {
927 Buffer
.isEncoding
= function isEncoding (encoding
) {
928 switch (String(encoding
).toLowerCase()) {
946 Buffer
.concat
= function concat (list
, length
) {
947 if (!Array
.isArray(list
)) {
948 throw new TypeError('"list" argument must be an Array of Buffers')
951 if (list
.length
=== 0) {
952 return Buffer
.alloc(0)
956 if (length
=== undefined) {
958 for (i
= 0; i
< list
.length
; ++i
) {
959 length
+= list
[i
].length
963 var buffer
= Buffer
.allocUnsafe(length
)
965 for (i
= 0; i
< list
.length
; ++i
) {
967 if (!Buffer
.isBuffer(buf
)) {
968 throw new TypeError('"list" argument must be an Array of Buffers')
970 buf
.copy(buffer
, pos
)
976 function byteLength (string
, encoding
) {
977 if (Buffer
.isBuffer(string
)) {
980 if (isArrayBufferView(string
) || string
instanceof ArrayBuffer
) {
981 return string
.byteLength
983 if (typeof string
!== 'string') {
987 var len
= string
.length
988 if (len
=== 0) return 0
990 // Use a for loop to avoid recursion
991 var loweredCase
= false
1001 return utf8ToBytes(string
).length
1010 return base64ToBytes(string
).length
1012 if (loweredCase
) return utf8ToBytes(string
).length
// assume utf8
1013 encoding
= ('' + encoding
).toLowerCase()
1018 Buffer
.byteLength
= byteLength
1020 function slowToString (encoding
, start
, end
) {
1021 var loweredCase
= false
1023 // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
1024 // property of a typed array.
1026 // This behaves neither like String nor Uint8Array in that we set start/end
1027 // to their upper/lower bounds if the value passed is out of range.
1028 // undefined is handled specially as per ECMA-262 6th Edition,
1029 // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
1030 if (start
=== undefined || start
< 0) {
1033 // Return early if start > this.length. Done here to prevent potential uint32
1034 // coercion fail below.
1035 if (start
> this.length
) {
1039 if (end
=== undefined || end
> this.length
) {
1047 // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
1055 if (!encoding
) encoding
= 'utf8'
1060 return hexSlice(this, start
, end
)
1064 return utf8Slice(this, start
, end
)
1067 return asciiSlice(this, start
, end
)
1071 return latin1Slice(this, start
, end
)
1074 return base64Slice(this, start
, end
)
1080 return utf16leSlice(this, start
, end
)
1083 if (loweredCase
) throw new TypeError('Unknown encoding: ' + encoding
)
1084 encoding
= (encoding
+ '').toLowerCase()
1090 // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
1091 // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
1092 // reliably in a browserify context because there could be multiple different
1093 // copies of the 'buffer' package in use. This method works even for Buffer
1094 // instances that were created from another copy of the `buffer` package.
1095 // See: https://github.com/feross/buffer/issues/154
1096 Buffer
.prototype._isBuffer
= true
1098 function swap (b
, n
, m
) {
1104 Buffer
.prototype.swap16
= function swap16 () {
1105 var len
= this.length
1106 if (len
% 2 !== 0) {
1107 throw new RangeError('Buffer size must be a multiple of 16-bits')
1109 for (var i
= 0; i
< len
; i
+= 2) {
1110 swap(this, i
, i
+ 1)
1115 Buffer
.prototype.swap32
= function swap32 () {
1116 var len
= this.length
1117 if (len
% 4 !== 0) {
1118 throw new RangeError('Buffer size must be a multiple of 32-bits')
1120 for (var i
= 0; i
< len
; i
+= 4) {
1121 swap(this, i
, i
+ 3)
1122 swap(this, i
+ 1, i
+ 2)
1127 Buffer
.prototype.swap64
= function swap64 () {
1128 var len
= this.length
1129 if (len
% 8 !== 0) {
1130 throw new RangeError('Buffer size must be a multiple of 64-bits')
1132 for (var i
= 0; i
< len
; i
+= 8) {
1133 swap(this, i
, i
+ 7)
1134 swap(this, i
+ 1, i
+ 6)
1135 swap(this, i
+ 2, i
+ 5)
1136 swap(this, i
+ 3, i
+ 4)
1141 Buffer
.prototype.toString
= function toString () {
1142 var length
= this.length
1143 if (length
=== 0) return ''
1144 if (arguments
.length
=== 0) return utf8Slice(this, 0, length
)
1145 return slowToString
.apply(this, arguments
)
1148 Buffer
.prototype.equals
= function equals (b
) {
1149 if (!Buffer
.isBuffer(b
)) throw new TypeError('Argument must be a Buffer')
1150 if (this === b
) return true
1151 return Buffer
.compare(this, b
) === 0
1154 Buffer
.prototype.inspect
= function inspect () {
1156 var max
= exports
.INSPECT_MAX_BYTES
1157 if (this.length
> 0) {
1158 str
= this.toString('hex', 0, max
).match(/.{2}/g).join(' ')
1159 if (this.length
> max
) str
+= ' ... '
1161 return '<Buffer ' + str
+ '>'
1164 Buffer
.prototype.compare
= function compare (target
, start
, end
, thisStart
, thisEnd
) {
1165 if (!Buffer
.isBuffer(target
)) {
1166 throw new TypeError('Argument must be a Buffer')
1169 if (start
=== undefined) {
1172 if (end
=== undefined) {
1173 end
= target
? target
.length : 0
1175 if (thisStart
=== undefined) {
1178 if (thisEnd
=== undefined) {
1179 thisEnd
= this.length
1182 if (start
< 0 || end
> target
.length
|| thisStart
< 0 || thisEnd
> this.length
) {
1183 throw new RangeError('out of range index')
1186 if (thisStart
>= thisEnd
&& start
>= end
) {
1189 if (thisStart
>= thisEnd
) {
1201 if (this === target
) return 0
1203 var x
= thisEnd
- thisStart
1205 var len
= Math
.min(x
, y
)
1207 var thisCopy
= this.slice(thisStart
, thisEnd
)
1208 var targetCopy
= target
.slice(start
, end
)
1210 for (var i
= 0; i
< len
; ++i
) {
1211 if (thisCopy
[i
] !== targetCopy
[i
]) {
1218 if (x
< y
) return -1
1223 // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
1224 // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
1227 // - buffer - a Buffer to search
1228 // - val - a string, Buffer, or number
1229 // - byteOffset - an index into `buffer`; will be clamped to an int32
1230 // - encoding - an optional encoding, relevant is val is a string
1231 // - dir - true for indexOf, false for lastIndexOf
1232 function bidirectionalIndexOf (buffer
, val
, byteOffset
, encoding
, dir
) {
1233 // Empty buffer means no match
1234 if (buffer
.length
=== 0) return -1
1236 // Normalize byteOffset
1237 if (typeof byteOffset
=== 'string') {
1238 encoding
= byteOffset
1240 } else if (byteOffset
> 0x7fffffff) {
1241 byteOffset
= 0x7fffffff
1242 } else if (byteOffset
< -0x80000000) {
1243 byteOffset
= -0x80000000
1245 byteOffset
= +byteOffset
// Coerce to Number.
1246 if (numberIsNaN(byteOffset
)) {
1247 // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
1248 byteOffset
= dir
? 0 : (buffer
.length
- 1)
1251 // Normalize byteOffset: negative offsets start from the end of the buffer
1252 if (byteOffset
< 0) byteOffset
= buffer
.length
+ byteOffset
1253 if (byteOffset
>= buffer
.length
) {
1255 else byteOffset
= buffer
.length
- 1
1256 } else if (byteOffset
< 0) {
1257 if (dir
) byteOffset
= 0
1262 if (typeof val
=== 'string') {
1263 val
= Buffer
.from(val
, encoding
)
1266 // Finally, search either indexOf (if dir is true) or lastIndexOf
1267 if (Buffer
.isBuffer(val
)) {
1268 // Special case: looking for empty string/buffer always fails
1269 if (val
.length
=== 0) {
1272 return arrayIndexOf(buffer
, val
, byteOffset
, encoding
, dir
)
1273 } else if (typeof val
=== 'number') {
1274 val
= val
& 0xFF // Search for a byte value [0-255]
1275 if (typeof Uint8Array
.prototype.indexOf
=== 'function') {
1277 return Uint8Array
.prototype.indexOf
.call(buffer
, val
, byteOffset
)
1279 return Uint8Array
.prototype.lastIndexOf
.call(buffer
, val
, byteOffset
)
1282 return arrayIndexOf(buffer
, [ val
], byteOffset
, encoding
, dir
)
1285 throw new TypeError('val must be string, number or Buffer')
1288 function arrayIndexOf (arr
, val
, byteOffset
, encoding
, dir
) {
1290 var arrLength
= arr
.length
1291 var valLength
= val
.length
1293 if (encoding
!== undefined) {
1294 encoding
= String(encoding
).toLowerCase()
1295 if (encoding
=== 'ucs2' || encoding
=== 'ucs-2' ||
1296 encoding
=== 'utf16le' || encoding
=== 'utf-16le') {
1297 if (arr
.length
< 2 || val
.length
< 2) {
1307 function read (buf
, i
) {
1308 if (indexSize
=== 1) {
1311 return buf
.readUInt16BE(i
* indexSize
)
1318 for (i
= byteOffset
; i
< arrLength
; i
++) {
1319 if (read(arr
, i
) === read(val
, foundIndex
=== -1 ? 0 : i
- foundIndex
)) {
1320 if (foundIndex
=== -1) foundIndex
= i
1321 if (i
- foundIndex
+ 1 === valLength
) return foundIndex
* indexSize
1323 if (foundIndex
!== -1) i
-= i
- foundIndex
1328 if (byteOffset
+ valLength
> arrLength
) byteOffset
= arrLength
- valLength
1329 for (i
= byteOffset
; i
>= 0; i
--) {
1331 for (var j
= 0; j
< valLength
; j
++) {
1332 if (read(arr
, i
+ j
) !== read(val
, j
)) {
1344 Buffer
.prototype.includes
= function includes (val
, byteOffset
, encoding
) {
1345 return this.indexOf(val
, byteOffset
, encoding
) !== -1
1348 Buffer
.prototype.indexOf
= function indexOf (val
, byteOffset
, encoding
) {
1349 return bidirectionalIndexOf(this, val
, byteOffset
, encoding
, true)
1352 Buffer
.prototype.lastIndexOf
= function lastIndexOf (val
, byteOffset
, encoding
) {
1353 return bidirectionalIndexOf(this, val
, byteOffset
, encoding
, false)
1356 function hexWrite (buf
, string
, offset
, length
) {
1357 offset
= Number(offset
) || 0
1358 var remaining
= buf
.length
- offset
1362 length
= Number(length
)
1363 if (length
> remaining
) {
1368 // must be an even number of digits
1369 var strLen
= string
.length
1370 if (strLen
% 2 !== 0) throw new TypeError('Invalid hex string')
1372 if (length
> strLen
/ 2) {
1375 for (var i
= 0; i
< length
; ++i
) {
1376 var parsed
= parseInt(string
.substr(i
* 2, 2), 16)
1377 if (numberIsNaN(parsed
)) return i
1378 buf
[offset
+ i
] = parsed
1383 function utf8Write (buf
, string
, offset
, length
) {
1384 return blitBuffer(utf8ToBytes(string
, buf
.length
- offset
), buf
, offset
, length
)
1387 function asciiWrite (buf
, string
, offset
, length
) {
1388 return blitBuffer(asciiToBytes(string
), buf
, offset
, length
)
1391 function latin1Write (buf
, string
, offset
, length
) {
1392 return asciiWrite(buf
, string
, offset
, length
)
1395 function base64Write (buf
, string
, offset
, length
) {
1396 return blitBuffer(base64ToBytes(string
), buf
, offset
, length
)
1399 function ucs2Write (buf
, string
, offset
, length
) {
1400 return blitBuffer(utf16leToBytes(string
, buf
.length
- offset
), buf
, offset
, length
)
1403 Buffer
.prototype.write
= function write (string
, offset
, length
, encoding
) {
1404 // Buffer#write(string)
1405 if (offset
=== undefined) {
1407 length
= this.length
1409 // Buffer#write(string, encoding)
1410 } else if (length
=== undefined && typeof offset
=== 'string') {
1412 length
= this.length
1414 // Buffer#write(string, offset[, length][, encoding])
1415 } else if (isFinite(offset
)) {
1416 offset
= offset
>>> 0
1417 if (isFinite(length
)) {
1418 length
= length
>>> 0
1419 if (encoding
=== undefined) encoding
= 'utf8'
1426 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
1430 var remaining
= this.length
- offset
1431 if (length
=== undefined || length
> remaining
) length
= remaining
1433 if ((string
.length
> 0 && (length
< 0 || offset
< 0)) || offset
> this.length
) {
1434 throw new RangeError('Attempt to write outside buffer bounds')
1437 if (!encoding
) encoding
= 'utf8'
1439 var loweredCase
= false
1443 return hexWrite(this, string
, offset
, length
)
1447 return utf8Write(this, string
, offset
, length
)
1450 return asciiWrite(this, string
, offset
, length
)
1454 return latin1Write(this, string
, offset
, length
)
1457 // Warning: maxLength not taken into account in base64Write
1458 return base64Write(this, string
, offset
, length
)
1464 return ucs2Write(this, string
, offset
, length
)
1467 if (loweredCase
) throw new TypeError('Unknown encoding: ' + encoding
)
1468 encoding
= ('' + encoding
).toLowerCase()
1474 Buffer
.prototype.toJSON
= function toJSON () {
1477 data: Array
.prototype.slice
.call(this._arr
|| this, 0)
1481 function base64Slice (buf
, start
, end
) {
1482 if (start
=== 0 && end
=== buf
.length
) {
1483 return base64
.fromByteArray(buf
)
1485 return base64
.fromByteArray(buf
.slice(start
, end
))
1489 function utf8Slice (buf
, start
, end
) {
1490 end
= Math
.min(buf
.length
, end
)
1495 var firstByte
= buf
[i
]
1496 var codePoint
= null
1497 var bytesPerSequence
= (firstByte
> 0xEF) ? 4
1498 : (firstByte
> 0xDF) ? 3
1499 : (firstByte
> 0xBF) ? 2
1502 if (i
+ bytesPerSequence
<= end
) {
1503 var secondByte
, thirdByte
, fourthByte
, tempCodePoint
1505 switch (bytesPerSequence
) {
1507 if (firstByte
< 0x80) {
1508 codePoint
= firstByte
1512 secondByte
= buf
[i
+ 1]
1513 if ((secondByte
& 0xC0) === 0x80) {
1514 tempCodePoint
= (firstByte
& 0x1F) << 0x6 | (secondByte
& 0x3F)
1515 if (tempCodePoint
> 0x7F) {
1516 codePoint
= tempCodePoint
1521 secondByte
= buf
[i
+ 1]
1522 thirdByte
= buf
[i
+ 2]
1523 if ((secondByte
& 0xC0) === 0x80 && (thirdByte
& 0xC0) === 0x80) {
1524 tempCodePoint
= (firstByte
& 0xF) << 0xC | (secondByte
& 0x3F) << 0x6 | (thirdByte
& 0x3F)
1525 if (tempCodePoint
> 0x7FF && (tempCodePoint
< 0xD800 || tempCodePoint
> 0xDFFF)) {
1526 codePoint
= tempCodePoint
1531 secondByte
= buf
[i
+ 1]
1532 thirdByte
= buf
[i
+ 2]
1533 fourthByte
= buf
[i
+ 3]
1534 if ((secondByte
& 0xC0) === 0x80 && (thirdByte
& 0xC0) === 0x80 && (fourthByte
& 0xC0) === 0x80) {
1535 tempCodePoint
= (firstByte
& 0xF) << 0x12 | (secondByte
& 0x3F) << 0xC | (thirdByte
& 0x3F) << 0x6 | (fourthByte
& 0x3F)
1536 if (tempCodePoint
> 0xFFFF && tempCodePoint
< 0x110000) {
1537 codePoint
= tempCodePoint
1543 if (codePoint
=== null) {
1544 // we did not generate a valid codePoint so insert a
1545 // replacement char (U+FFFD) and advance only 1 byte
1547 bytesPerSequence
= 1
1548 } else if (codePoint
> 0xFFFF) {
1549 // encode to utf16 (surrogate pair dance)
1550 codePoint
-= 0x10000
1551 res
.push(codePoint
>>> 10 & 0x3FF | 0xD800)
1552 codePoint
= 0xDC00 | codePoint
& 0x3FF
1556 i
+= bytesPerSequence
1559 return decodeCodePointsArray(res
)
1562 // Based on http://stackoverflow.com/a/22747272/680742, the browser with
1563 // the lowest limit is Chrome, with 0x10000 args.
1564 // We go 1 magnitude less, for safety
1565 var MAX_ARGUMENTS_LENGTH
= 0x1000
1567 function decodeCodePointsArray (codePoints
) {
1568 var len
= codePoints
.length
1569 if (len
<= MAX_ARGUMENTS_LENGTH
) {
1570 return String
.fromCharCode
.apply(String
, codePoints
) // avoid extra slice()
1573 // Decode in chunks to avoid "call stack size exceeded".
1577 res
+= String
.fromCharCode
.apply(
1579 codePoints
.slice(i
, i
+= MAX_ARGUMENTS_LENGTH
)
1585 function asciiSlice (buf
, start
, end
) {
1587 end
= Math
.min(buf
.length
, end
)
1589 for (var i
= start
; i
< end
; ++i
) {
1590 ret
+= String
.fromCharCode(buf
[i
] & 0x7F)
1595 function latin1Slice (buf
, start
, end
) {
1597 end
= Math
.min(buf
.length
, end
)
1599 for (var i
= start
; i
< end
; ++i
) {
1600 ret
+= String
.fromCharCode(buf
[i
])
1605 function hexSlice (buf
, start
, end
) {
1606 var len
= buf
.length
1608 if (!start
|| start
< 0) start
= 0
1609 if (!end
|| end
< 0 || end
> len
) end
= len
1612 for (var i
= start
; i
< end
; ++i
) {
1613 out
+= toHex(buf
[i
])
1618 function utf16leSlice (buf
, start
, end
) {
1619 var bytes
= buf
.slice(start
, end
)
1621 for (var i
= 0; i
< bytes
.length
; i
+= 2) {
1622 res
+= String
.fromCharCode(bytes
[i
] + (bytes
[i
+ 1] * 256))
1627 Buffer
.prototype.slice
= function slice (start
, end
) {
1628 var len
= this.length
1630 end
= end
=== undefined ? len : ~~end
1634 if (start
< 0) start
= 0
1635 } else if (start
> len
) {
1641 if (end
< 0) end
= 0
1642 } else if (end
> len
) {
1646 if (end
< start
) end
= start
1648 var newBuf
= this.subarray(start
, end
)
1649 // Return an augmented `Uint8Array` instance
1650 newBuf
.__proto__
= Buffer
.prototype
1655 * Need to make sure that buffer isn't trying to write out of bounds.
1657 function checkOffset (offset
, ext
, length
) {
1658 if ((offset
% 1) !== 0 || offset
< 0) throw new RangeError('offset is not uint')
1659 if (offset
+ ext
> length
) throw new RangeError('Trying to access beyond buffer length')
1662 Buffer
.prototype.readUIntLE
= function readUIntLE (offset
, byteLength
, noAssert
) {
1663 offset
= offset
>>> 0
1664 byteLength
= byteLength
>>> 0
1665 if (!noAssert
) checkOffset(offset
, byteLength
, this.length
)
1667 var val
= this[offset
]
1670 while (++i
< byteLength
&& (mul
*= 0x100)) {
1671 val
+= this[offset
+ i
] * mul
1677 Buffer
.prototype.readUIntBE
= function readUIntBE (offset
, byteLength
, noAssert
) {
1678 offset
= offset
>>> 0
1679 byteLength
= byteLength
>>> 0
1681 checkOffset(offset
, byteLength
, this.length
)
1684 var val
= this[offset
+ --byteLength
]
1686 while (byteLength
> 0 && (mul
*= 0x100)) {
1687 val
+= this[offset
+ --byteLength
] * mul
1693 Buffer
.prototype.readUInt8
= function readUInt8 (offset
, noAssert
) {
1694 offset
= offset
>>> 0
1695 if (!noAssert
) checkOffset(offset
, 1, this.length
)
1699 Buffer
.prototype.readUInt16LE
= function readUInt16LE (offset
, noAssert
) {
1700 offset
= offset
>>> 0
1701 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1702 return this[offset
] | (this[offset
+ 1] << 8)
1705 Buffer
.prototype.readUInt16BE
= function readUInt16BE (offset
, noAssert
) {
1706 offset
= offset
>>> 0
1707 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1708 return (this[offset
] << 8) | this[offset
+ 1]
1711 Buffer
.prototype.readUInt32LE
= function readUInt32LE (offset
, noAssert
) {
1712 offset
= offset
>>> 0
1713 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1715 return ((this[offset
]) |
1716 (this[offset
+ 1] << 8) |
1717 (this[offset
+ 2] << 16)) +
1718 (this[offset
+ 3] * 0x1000000)
1721 Buffer
.prototype.readUInt32BE
= function readUInt32BE (offset
, noAssert
) {
1722 offset
= offset
>>> 0
1723 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1725 return (this[offset
] * 0x1000000) +
1726 ((this[offset
+ 1] << 16) |
1727 (this[offset
+ 2] << 8) |
1731 Buffer
.prototype.readIntLE
= function readIntLE (offset
, byteLength
, noAssert
) {
1732 offset
= offset
>>> 0
1733 byteLength
= byteLength
>>> 0
1734 if (!noAssert
) checkOffset(offset
, byteLength
, this.length
)
1736 var val
= this[offset
]
1739 while (++i
< byteLength
&& (mul
*= 0x100)) {
1740 val
+= this[offset
+ i
] * mul
1744 if (val
>= mul
) val
-= Math
.pow(2, 8 * byteLength
)
1749 Buffer
.prototype.readIntBE
= function readIntBE (offset
, byteLength
, noAssert
) {
1750 offset
= offset
>>> 0
1751 byteLength
= byteLength
>>> 0
1752 if (!noAssert
) checkOffset(offset
, byteLength
, this.length
)
1756 var val
= this[offset
+ --i
]
1757 while (i
> 0 && (mul
*= 0x100)) {
1758 val
+= this[offset
+ --i
] * mul
1762 if (val
>= mul
) val
-= Math
.pow(2, 8 * byteLength
)
1767 Buffer
.prototype.readInt8
= function readInt8 (offset
, noAssert
) {
1768 offset
= offset
>>> 0
1769 if (!noAssert
) checkOffset(offset
, 1, this.length
)
1770 if (!(this[offset
] & 0x80)) return (this[offset
])
1771 return ((0xff - this[offset
] + 1) * -1)
1774 Buffer
.prototype.readInt16LE
= function readInt16LE (offset
, noAssert
) {
1775 offset
= offset
>>> 0
1776 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1777 var val
= this[offset
] | (this[offset
+ 1] << 8)
1778 return (val
& 0x8000) ? val
| 0xFFFF0000 : val
1781 Buffer
.prototype.readInt16BE
= function readInt16BE (offset
, noAssert
) {
1782 offset
= offset
>>> 0
1783 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1784 var val
= this[offset
+ 1] | (this[offset
] << 8)
1785 return (val
& 0x8000) ? val
| 0xFFFF0000 : val
1788 Buffer
.prototype.readInt32LE
= function readInt32LE (offset
, noAssert
) {
1789 offset
= offset
>>> 0
1790 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1792 return (this[offset
]) |
1793 (this[offset
+ 1] << 8) |
1794 (this[offset
+ 2] << 16) |
1795 (this[offset
+ 3] << 24)
1798 Buffer
.prototype.readInt32BE
= function readInt32BE (offset
, noAssert
) {
1799 offset
= offset
>>> 0
1800 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1802 return (this[offset
] << 24) |
1803 (this[offset
+ 1] << 16) |
1804 (this[offset
+ 2] << 8) |
1808 Buffer
.prototype.readFloatLE
= function readFloatLE (offset
, noAssert
) {
1809 offset
= offset
>>> 0
1810 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1811 return ieee754
.read(this, offset
, true, 23, 4)
1814 Buffer
.prototype.readFloatBE
= function readFloatBE (offset
, noAssert
) {
1815 offset
= offset
>>> 0
1816 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1817 return ieee754
.read(this, offset
, false, 23, 4)
1820 Buffer
.prototype.readDoubleLE
= function readDoubleLE (offset
, noAssert
) {
1821 offset
= offset
>>> 0
1822 if (!noAssert
) checkOffset(offset
, 8, this.length
)
1823 return ieee754
.read(this, offset
, true, 52, 8)
1826 Buffer
.prototype.readDoubleBE
= function readDoubleBE (offset
, noAssert
) {
1827 offset
= offset
>>> 0
1828 if (!noAssert
) checkOffset(offset
, 8, this.length
)
1829 return ieee754
.read(this, offset
, false, 52, 8)
1832 function checkInt (buf
, value
, offset
, ext
, max
, min
) {
1833 if (!Buffer
.isBuffer(buf
)) throw new TypeError('"buffer" argument must be a Buffer instance')
1834 if (value
> max
|| value
< min
) throw new RangeError('"value" argument is out of bounds')
1835 if (offset
+ ext
> buf
.length
) throw new RangeError('Index out of range')
1838 Buffer
.prototype.writeUIntLE
= function writeUIntLE (value
, offset
, byteLength
, noAssert
) {
1840 offset
= offset
>>> 0
1841 byteLength
= byteLength
>>> 0
1843 var maxBytes
= Math
.pow(2, 8 * byteLength
) - 1
1844 checkInt(this, value
, offset
, byteLength
, maxBytes
, 0)
1849 this[offset
] = value
& 0xFF
1850 while (++i
< byteLength
&& (mul
*= 0x100)) {
1851 this[offset
+ i
] = (value
/ mul
) & 0xFF
1854 return offset
+ byteLength
1857 Buffer
.prototype.writeUIntBE
= function writeUIntBE (value
, offset
, byteLength
, noAssert
) {
1859 offset
= offset
>>> 0
1860 byteLength
= byteLength
>>> 0
1862 var maxBytes
= Math
.pow(2, 8 * byteLength
) - 1
1863 checkInt(this, value
, offset
, byteLength
, maxBytes
, 0)
1866 var i
= byteLength
- 1
1868 this[offset
+ i
] = value
& 0xFF
1869 while (--i
>= 0 && (mul
*= 0x100)) {
1870 this[offset
+ i
] = (value
/ mul
) & 0xFF
1873 return offset
+ byteLength
1876 Buffer
.prototype.writeUInt8
= function writeUInt8 (value
, offset
, noAssert
) {
1878 offset
= offset
>>> 0
1879 if (!noAssert
) checkInt(this, value
, offset
, 1, 0xff, 0)
1880 this[offset
] = (value
& 0xff)
1884 Buffer
.prototype.writeUInt16LE
= function writeUInt16LE (value
, offset
, noAssert
) {
1886 offset
= offset
>>> 0
1887 if (!noAssert
) checkInt(this, value
, offset
, 2, 0xffff, 0)
1888 this[offset
] = (value
& 0xff)
1889 this[offset
+ 1] = (value
>>> 8)
1893 Buffer
.prototype.writeUInt16BE
= function writeUInt16BE (value
, offset
, noAssert
) {
1895 offset
= offset
>>> 0
1896 if (!noAssert
) checkInt(this, value
, offset
, 2, 0xffff, 0)
1897 this[offset
] = (value
>>> 8)
1898 this[offset
+ 1] = (value
& 0xff)
1902 Buffer
.prototype.writeUInt32LE
= function writeUInt32LE (value
, offset
, noAssert
) {
1904 offset
= offset
>>> 0
1905 if (!noAssert
) checkInt(this, value
, offset
, 4, 0xffffffff, 0)
1906 this[offset
+ 3] = (value
>>> 24)
1907 this[offset
+ 2] = (value
>>> 16)
1908 this[offset
+ 1] = (value
>>> 8)
1909 this[offset
] = (value
& 0xff)
1913 Buffer
.prototype.writeUInt32BE
= function writeUInt32BE (value
, offset
, noAssert
) {
1915 offset
= offset
>>> 0
1916 if (!noAssert
) checkInt(this, value
, offset
, 4, 0xffffffff, 0)
1917 this[offset
] = (value
>>> 24)
1918 this[offset
+ 1] = (value
>>> 16)
1919 this[offset
+ 2] = (value
>>> 8)
1920 this[offset
+ 3] = (value
& 0xff)
1924 Buffer
.prototype.writeIntLE
= function writeIntLE (value
, offset
, byteLength
, noAssert
) {
1926 offset
= offset
>>> 0
1928 var limit
= Math
.pow(2, (8 * byteLength
) - 1)
1930 checkInt(this, value
, offset
, byteLength
, limit
- 1, -limit
)
1936 this[offset
] = value
& 0xFF
1937 while (++i
< byteLength
&& (mul
*= 0x100)) {
1938 if (value
< 0 && sub
=== 0 && this[offset
+ i
- 1] !== 0) {
1941 this[offset
+ i
] = ((value
/ mul
) >> 0) - sub
& 0xFF
1944 return offset
+ byteLength
1947 Buffer
.prototype.writeIntBE
= function writeIntBE (value
, offset
, byteLength
, noAssert
) {
1949 offset
= offset
>>> 0
1951 var limit
= Math
.pow(2, (8 * byteLength
) - 1)
1953 checkInt(this, value
, offset
, byteLength
, limit
- 1, -limit
)
1956 var i
= byteLength
- 1
1959 this[offset
+ i
] = value
& 0xFF
1960 while (--i
>= 0 && (mul
*= 0x100)) {
1961 if (value
< 0 && sub
=== 0 && this[offset
+ i
+ 1] !== 0) {
1964 this[offset
+ i
] = ((value
/ mul
) >> 0) - sub
& 0xFF
1967 return offset
+ byteLength
1970 Buffer
.prototype.writeInt8
= function writeInt8 (value
, offset
, noAssert
) {
1972 offset
= offset
>>> 0
1973 if (!noAssert
) checkInt(this, value
, offset
, 1, 0x7f, -0x80)
1974 if (value
< 0) value
= 0xff + value
+ 1
1975 this[offset
] = (value
& 0xff)
1979 Buffer
.prototype.writeInt16LE
= function writeInt16LE (value
, offset
, noAssert
) {
1981 offset
= offset
>>> 0
1982 if (!noAssert
) checkInt(this, value
, offset
, 2, 0x7fff, -0x8000)
1983 this[offset
] = (value
& 0xff)
1984 this[offset
+ 1] = (value
>>> 8)
1988 Buffer
.prototype.writeInt16BE
= function writeInt16BE (value
, offset
, noAssert
) {
1990 offset
= offset
>>> 0
1991 if (!noAssert
) checkInt(this, value
, offset
, 2, 0x7fff, -0x8000)
1992 this[offset
] = (value
>>> 8)
1993 this[offset
+ 1] = (value
& 0xff)
1997 Buffer
.prototype.writeInt32LE
= function writeInt32LE (value
, offset
, noAssert
) {
1999 offset
= offset
>>> 0
2000 if (!noAssert
) checkInt(this, value
, offset
, 4, 0x7fffffff, -0x80000000)
2001 this[offset
] = (value
& 0xff)
2002 this[offset
+ 1] = (value
>>> 8)
2003 this[offset
+ 2] = (value
>>> 16)
2004 this[offset
+ 3] = (value
>>> 24)
2008 Buffer
.prototype.writeInt32BE
= function writeInt32BE (value
, offset
, noAssert
) {
2010 offset
= offset
>>> 0
2011 if (!noAssert
) checkInt(this, value
, offset
, 4, 0x7fffffff, -0x80000000)
2012 if (value
< 0) value
= 0xffffffff + value
+ 1
2013 this[offset
] = (value
>>> 24)
2014 this[offset
+ 1] = (value
>>> 16)
2015 this[offset
+ 2] = (value
>>> 8)
2016 this[offset
+ 3] = (value
& 0xff)
2020 function checkIEEE754 (buf
, value
, offset
, ext
, max
, min
) {
2021 if (offset
+ ext
> buf
.length
) throw new RangeError('Index out of range')
2022 if (offset
< 0) throw new RangeError('Index out of range')
2025 function writeFloat (buf
, value
, offset
, littleEndian
, noAssert
) {
2027 offset
= offset
>>> 0
2029 checkIEEE754(buf
, value
, offset
, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
2031 ieee754
.write(buf
, value
, offset
, littleEndian
, 23, 4)
2035 Buffer
.prototype.writeFloatLE
= function writeFloatLE (value
, offset
, noAssert
) {
2036 return writeFloat(this, value
, offset
, true, noAssert
)
2039 Buffer
.prototype.writeFloatBE
= function writeFloatBE (value
, offset
, noAssert
) {
2040 return writeFloat(this, value
, offset
, false, noAssert
)
2043 function writeDouble (buf
, value
, offset
, littleEndian
, noAssert
) {
2045 offset
= offset
>>> 0
2047 checkIEEE754(buf
, value
, offset
, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
2049 ieee754
.write(buf
, value
, offset
, littleEndian
, 52, 8)
2053 Buffer
.prototype.writeDoubleLE
= function writeDoubleLE (value
, offset
, noAssert
) {
2054 return writeDouble(this, value
, offset
, true, noAssert
)
2057 Buffer
.prototype.writeDoubleBE
= function writeDoubleBE (value
, offset
, noAssert
) {
2058 return writeDouble(this, value
, offset
, false, noAssert
)
2061 // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
2062 Buffer
.prototype.copy
= function copy (target
, targetStart
, start
, end
) {
2063 if (!start
) start
= 0
2064 if (!end
&& end
!== 0) end
= this.length
2065 if (targetStart
>= target
.length
) targetStart
= target
.length
2066 if (!targetStart
) targetStart
= 0
2067 if (end
> 0 && end
< start
) end
= start
2069 // Copy 0 bytes; we're done
2070 if (end
=== start
) return 0
2071 if (target
.length
=== 0 || this.length
=== 0) return 0
2073 // Fatal error conditions
2074 if (targetStart
< 0) {
2075 throw new RangeError('targetStart out of bounds')
2077 if (start
< 0 || start
>= this.length
) throw new RangeError('sourceStart out of bounds')
2078 if (end
< 0) throw new RangeError('sourceEnd out of bounds')
2081 if (end
> this.length
) end
= this.length
2082 if (target
.length
- targetStart
< end
- start
) {
2083 end
= target
.length
- targetStart
+ start
2086 var len
= end
- start
2089 if (this === target
&& start
< targetStart
&& targetStart
< end
) {
2090 // descending copy from end
2091 for (i
= len
- 1; i
>= 0; --i
) {
2092 target
[i
+ targetStart
] = this[i
+ start
]
2094 } else if (len
< 1000) {
2095 // ascending copy from start
2096 for (i
= 0; i
< len
; ++i
) {
2097 target
[i
+ targetStart
] = this[i
+ start
]
2100 Uint8Array
.prototype.set.call(
2102 this.subarray(start
, start
+ len
),
2111 // buffer.fill(number[, offset[, end]])
2112 // buffer.fill(buffer[, offset[, end]])
2113 // buffer.fill(string[, offset[, end]][, encoding])
2114 Buffer
.prototype.fill
= function fill (val
, start
, end
, encoding
) {
2115 // Handle string cases:
2116 if (typeof val
=== 'string') {
2117 if (typeof start
=== 'string') {
2121 } else if (typeof end
=== 'string') {
2125 if (val
.length
=== 1) {
2126 var code
= val
.charCodeAt(0)
2131 if (encoding
!== undefined && typeof encoding
!== 'string') {
2132 throw new TypeError('encoding must be a string')
2134 if (typeof encoding
=== 'string' && !Buffer
.isEncoding(encoding
)) {
2135 throw new TypeError('Unknown encoding: ' + encoding
)
2137 } else if (typeof val
=== 'number') {
2141 // Invalid ranges are not set to a default, so can range check early.
2142 if (start
< 0 || this.length
< start
|| this.length
< end
) {
2143 throw new RangeError('Out of range index')
2151 end
= end
=== undefined ? this.length : end
>>> 0
2156 if (typeof val
=== 'number') {
2157 for (i
= start
; i
< end
; ++i
) {
2161 var bytes
= Buffer
.isBuffer(val
)
2163 : new Buffer(val
, encoding
)
2164 var len
= bytes
.length
2165 for (i
= 0; i
< end
- start
; ++i
) {
2166 this[i
+ start
] = bytes
[i
% len
]
2176 var INVALID_BASE64_RE
= /[^+/0-9A
-Za
-z
-_
]/g
2178 function base64clean (str
) {
2179 // Node strips out invalid characters like \n and \t from the string, base64-js does not
2180 str
= str
.trim().replace(INVALID_BASE64_RE
, '')
2181 // Node converts strings with length < 2 to ''
2182 if (str
.length
< 2) return ''
2183 // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
2184 while (str
.length
% 4 !== 0) {
2190 function toHex (n
) {
2191 if (n
< 16) return '0' + n
.toString(16)
2192 return n
.toString(16)
2195 function utf8ToBytes (string
, units
) {
2196 units
= units
|| Infinity
2198 var length
= string
.length
2199 var leadSurrogate
= null
2202 for (var i
= 0; i
< length
; ++i
) {
2203 codePoint
= string
.charCodeAt(i
)
2205 // is surrogate component
2206 if (codePoint
> 0xD7FF && codePoint
< 0xE000) {
2207 // last char was a lead
2208 if (!leadSurrogate
) {
2210 if (codePoint
> 0xDBFF) {
2212 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2214 } else if (i
+ 1 === length
) {
2216 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2221 leadSurrogate
= codePoint
2227 if (codePoint
< 0xDC00) {
2228 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2229 leadSurrogate
= codePoint
2233 // valid surrogate pair
2234 codePoint
= (leadSurrogate
- 0xD800 << 10 | codePoint
- 0xDC00) + 0x10000
2235 } else if (leadSurrogate
) {
2236 // valid bmp char, but last char was a lead
2237 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2240 leadSurrogate
= null
2243 if (codePoint
< 0x80) {
2244 if ((units
-= 1) < 0) break
2245 bytes
.push(codePoint
)
2246 } else if (codePoint
< 0x800) {
2247 if ((units
-= 2) < 0) break
2249 codePoint
>> 0x6 | 0xC0,
2250 codePoint
& 0x3F | 0x80
2252 } else if (codePoint
< 0x10000) {
2253 if ((units
-= 3) < 0) break
2255 codePoint
>> 0xC | 0xE0,
2256 codePoint
>> 0x6 & 0x3F | 0x80,
2257 codePoint
& 0x3F | 0x80
2259 } else if (codePoint
< 0x110000) {
2260 if ((units
-= 4) < 0) break
2262 codePoint
>> 0x12 | 0xF0,
2263 codePoint
>> 0xC & 0x3F | 0x80,
2264 codePoint
>> 0x6 & 0x3F | 0x80,
2265 codePoint
& 0x3F | 0x80
2268 throw new Error('Invalid code point')
2275 function asciiToBytes (str
) {
2277 for (var i
= 0; i
< str
.length
; ++i
) {
2278 // Node's code seems to be doing this and not & 0x7F..
2279 byteArray
.push(str
.charCodeAt(i
) & 0xFF)
2284 function utf16leToBytes (str
, units
) {
2287 for (var i
= 0; i
< str
.length
; ++i
) {
2288 if ((units
-= 2) < 0) break
2290 c
= str
.charCodeAt(i
)
2300 function base64ToBytes (str
) {
2301 return base64
.toByteArray(base64clean(str
))
2304 function blitBuffer (src
, dst
, offset
, length
) {
2305 for (var i
= 0; i
< length
; ++i
) {
2306 if ((i
+ offset
>= dst
.length
) || (i
>= src
.length
)) break
2307 dst
[i
+ offset
] = src
[i
]
2312 // Node 0.10 supports `ArrayBuffer` but lacks `ArrayBuffer.isView`
2313 function isArrayBufferView (obj
) {
2314 return (typeof ArrayBuffer
.isView
=== 'function') && ArrayBuffer
.isView(obj
)
2317 function numberIsNaN (obj
) {
2318 return obj
!== obj
// eslint-disable-line no-self-compare
2321 },{"base64-js":2,"ieee754":7}],5:[function(require
,module
,exports
){
2323 // Copyright Joyent, Inc. and other Node contributors.
2325 // Permission is hereby granted, free of charge, to any person obtaining a
2326 // copy of this software and associated documentation files (the
2327 // "Software"), to deal in the Software without restriction, including
2328 // without limitation the rights to use, copy, modify, merge, publish,
2329 // distribute, sublicense, and/or sell copies of the Software, and to permit
2330 // persons to whom the Software is furnished to do so, subject to the
2331 // following conditions:
2333 // The above copyright notice and this permission notice shall be included
2334 // in all copies or substantial portions of the Software.
2336 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2337 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2338 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2339 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2340 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2341 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2342 // USE OR OTHER DEALINGS IN THE SOFTWARE.
2344 // NOTE: These type checking functions intentionally don't use `instanceof`
2345 // because it is fragile and can be easily faked with `Object.create()`.
2347 function isArray(arg
) {
2348 if (Array
.isArray
) {
2349 return Array
.isArray(arg
);
2351 return objectToString(arg
) === '[object Array]';
2353 exports
.isArray
= isArray
;
2355 function isBoolean(arg
) {
2356 return typeof arg
=== 'boolean';
2358 exports
.isBoolean
= isBoolean
;
2360 function isNull(arg
) {
2361 return arg
=== null;
2363 exports
.isNull
= isNull
;
2365 function isNullOrUndefined(arg
) {
2368 exports
.isNullOrUndefined
= isNullOrUndefined
;
2370 function isNumber(arg
) {
2371 return typeof arg
=== 'number';
2373 exports
.isNumber
= isNumber
;
2375 function isString(arg
) {
2376 return typeof arg
=== 'string';
2378 exports
.isString
= isString
;
2380 function isSymbol(arg
) {
2381 return typeof arg
=== 'symbol';
2383 exports
.isSymbol
= isSymbol
;
2385 function isUndefined(arg
) {
2386 return arg
=== void 0;
2388 exports
.isUndefined
= isUndefined
;
2390 function isRegExp(re
) {
2391 return objectToString(re
) === '[object RegExp]';
2393 exports
.isRegExp
= isRegExp
;
2395 function isObject(arg
) {
2396 return typeof arg
=== 'object' && arg
!== null;
2398 exports
.isObject
= isObject
;
2400 function isDate(d
) {
2401 return objectToString(d
) === '[object Date]';
2403 exports
.isDate
= isDate
;
2405 function isError(e
) {
2406 return (objectToString(e
) === '[object Error]' || e
instanceof Error
);
2408 exports
.isError
= isError
;
2410 function isFunction(arg
) {
2411 return typeof arg
=== 'function';
2413 exports
.isFunction
= isFunction
;
2415 function isPrimitive(arg
) {
2416 return arg
=== null ||
2417 typeof arg
=== 'boolean' ||
2418 typeof arg
=== 'number' ||
2419 typeof arg
=== 'string' ||
2420 typeof arg
=== 'symbol' || // ES6 symbol
2421 typeof arg
=== 'undefined';
2423 exports
.isPrimitive
= isPrimitive
;
2425 exports
.isBuffer
= Buffer
.isBuffer
;
2427 function objectToString(o
) {
2428 return Object
.prototype.toString
.call(o
);
2431 }).call(this,{"isBuffer":require("../../is-buffer/index.js")})
2432 },{"../../is-buffer/index.js":9}],6:[function(require
,module
,exports
){
2433 // Copyright Joyent, Inc. and other Node contributors.
2435 // Permission is hereby granted, free of charge, to any person obtaining a
2436 // copy of this software and associated documentation files (the
2437 // "Software"), to deal in the Software without restriction, including
2438 // without limitation the rights to use, copy, modify, merge, publish,
2439 // distribute, sublicense, and/or sell copies of the Software, and to permit
2440 // persons to whom the Software is furnished to do so, subject to the
2441 // following conditions:
2443 // The above copyright notice and this permission notice shall be included
2444 // in all copies or substantial portions of the Software.
2446 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2447 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2448 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2449 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2450 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2451 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2452 // USE OR OTHER DEALINGS IN THE SOFTWARE.
2454 function EventEmitter() {
2455 this._events
= this._events
|| {};
2456 this._maxListeners
= this._maxListeners
|| undefined;
2458 module
.exports
= EventEmitter
;
2460 // Backwards-compat with node 0.10.x
2461 EventEmitter
.EventEmitter
= EventEmitter
;
2463 EventEmitter
.prototype._events
= undefined;
2464 EventEmitter
.prototype._maxListeners
= undefined;
2466 // By default EventEmitters will print a warning if more than 10 listeners are
2467 // added to it. This is a useful default which helps finding memory leaks.
2468 EventEmitter
.defaultMaxListeners
= 10;
2470 // Obviously not all Emitters should be limited to 10. This function allows
2471 // that to be increased. Set to zero for unlimited.
2472 EventEmitter
.prototype.setMaxListeners = function(n
) {
2473 if (!isNumber(n
) || n
< 0 || isNaN(n
))
2474 throw TypeError('n must be a positive number');
2475 this._maxListeners
= n
;
2479 EventEmitter
.prototype.emit = function(type
) {
2480 var er
, handler
, len
, args
, i
, listeners
;
2485 // If there is no 'error' event listener then throw.
2486 if (type
=== 'error') {
2487 if (!this._events
.error
||
2488 (isObject(this._events
.error
) && !this._events
.error
.length
)) {
2490 if (er
instanceof Error
) {
2491 throw er
; // Unhandled 'error' event
2493 // At least give some kind of context to the user
2494 var err
= new Error('Uncaught, unspecified "error" event. (' + er
+ ')');
2501 handler
= this._events
[type
];
2503 if (isUndefined(handler
))
2506 if (isFunction(handler
)) {
2507 switch (arguments
.length
) {
2513 handler
.call(this, arguments
[1]);
2516 handler
.call(this, arguments
[1], arguments
[2]);
2520 args
= Array
.prototype.slice
.call(arguments
, 1);
2521 handler
.apply(this, args
);
2523 } else if (isObject(handler
)) {
2524 args
= Array
.prototype.slice
.call(arguments
, 1);
2525 listeners
= handler
.slice();
2526 len
= listeners
.length
;
2527 for (i
= 0; i
< len
; i
++)
2528 listeners
[i
].apply(this, args
);
2534 EventEmitter
.prototype.addListener = function(type
, listener
) {
2537 if (!isFunction(listener
))
2538 throw TypeError('listener must be a function');
2543 // To avoid recursion in the case that type === "newListener"! Before
2544 // adding it to the listeners, first emit "newListener".
2545 if (this._events
.newListener
)
2546 this.emit('newListener', type
,
2547 isFunction(listener
.listener
) ?
2548 listener
.listener : listener
);
2550 if (!this._events
[type
])
2551 // Optimize the case of one listener. Don't need the extra array object.
2552 this._events
[type
] = listener
;
2553 else if (isObject(this._events
[type
]))
2554 // If we've already got an array, just append.
2555 this._events
[type
].push(listener
);
2557 // Adding the second element, need to change to array.
2558 this._events
[type
] = [this._events
[type
], listener
];
2560 // Check for listener leak
2561 if (isObject(this._events
[type
]) && !this._events
[type
].warned
) {
2562 if (!isUndefined(this._maxListeners
)) {
2563 m
= this._maxListeners
;
2565 m
= EventEmitter
.defaultMaxListeners
;
2568 if (m
&& m
> 0 && this._events
[type
].length
> m
) {
2569 this._events
[type
].warned
= true;
2570 console
.error('(node) warning: possible EventEmitter memory ' +
2571 'leak detected. %d listeners added. ' +
2572 'Use emitter.setMaxListeners() to increase limit.',
2573 this._events
[type
].length
);
2574 if (typeof console
.trace
=== 'function') {
2575 // not supported in IE 10
2584 EventEmitter
.prototype.on
= EventEmitter
.prototype.addListener
;
2586 EventEmitter
.prototype.once = function(type
, listener
) {
2587 if (!isFunction(listener
))
2588 throw TypeError('listener must be a function');
2593 this.removeListener(type
, g
);
2597 listener
.apply(this, arguments
);
2601 g
.listener
= listener
;
2607 // emits a 'removeListener' event iff the listener was removed
2608 EventEmitter
.prototype.removeListener = function(type
, listener
) {
2609 var list
, position
, length
, i
;
2611 if (!isFunction(listener
))
2612 throw TypeError('listener must be a function');
2614 if (!this._events
|| !this._events
[type
])
2617 list
= this._events
[type
];
2618 length
= list
.length
;
2621 if (list
=== listener
||
2622 (isFunction(list
.listener
) && list
.listener
=== listener
)) {
2623 delete this._events
[type
];
2624 if (this._events
.removeListener
)
2625 this.emit('removeListener', type
, listener
);
2627 } else if (isObject(list
)) {
2628 for (i
= length
; i
-- > 0;) {
2629 if (list
[i
] === listener
||
2630 (list
[i
].listener
&& list
[i
].listener
=== listener
)) {
2639 if (list
.length
=== 1) {
2641 delete this._events
[type
];
2643 list
.splice(position
, 1);
2646 if (this._events
.removeListener
)
2647 this.emit('removeListener', type
, listener
);
2653 EventEmitter
.prototype.removeAllListeners = function(type
) {
2659 // not listening for removeListener, no need to emit
2660 if (!this._events
.removeListener
) {
2661 if (arguments
.length
=== 0)
2663 else if (this._events
[type
])
2664 delete this._events
[type
];
2668 // emit removeListener for all listeners on all events
2669 if (arguments
.length
=== 0) {
2670 for (key
in this._events
) {
2671 if (key
=== 'removeListener') continue;
2672 this.removeAllListeners(key
);
2674 this.removeAllListeners('removeListener');
2679 listeners
= this._events
[type
];
2681 if (isFunction(listeners
)) {
2682 this.removeListener(type
, listeners
);
2683 } else if (listeners
) {
2685 while (listeners
.length
)
2686 this.removeListener(type
, listeners
[listeners
.length
- 1]);
2688 delete this._events
[type
];
2693 EventEmitter
.prototype.listeners = function(type
) {
2695 if (!this._events
|| !this._events
[type
])
2697 else if (isFunction(this._events
[type
]))
2698 ret
= [this._events
[type
]];
2700 ret
= this._events
[type
].slice();
2704 EventEmitter
.prototype.listenerCount = function(type
) {
2706 var evlistener
= this._events
[type
];
2708 if (isFunction(evlistener
))
2710 else if (evlistener
)
2711 return evlistener
.length
;
2716 EventEmitter
.listenerCount = function(emitter
, type
) {
2717 return emitter
.listenerCount(type
);
2720 function isFunction(arg
) {
2721 return typeof arg
=== 'function';
2724 function isNumber(arg
) {
2725 return typeof arg
=== 'number';
2728 function isObject(arg
) {
2729 return typeof arg
=== 'object' && arg
!== null;
2732 function isUndefined(arg
) {
2733 return arg
=== void 0;
2736 },{}],7:[function(require
,module
,exports
){
2737 exports
.read = function (buffer
, offset
, isLE
, mLen
, nBytes
) {
2739 var eLen
= nBytes
* 8 - mLen
- 1
2740 var eMax
= (1 << eLen
) - 1
2741 var eBias
= eMax
>> 1
2743 var i
= isLE
? (nBytes
- 1) : 0
2744 var d
= isLE
? -1 : 1
2745 var s
= buffer
[offset
+ i
]
2749 e
= s
& ((1 << (-nBits
)) - 1)
2752 for (; nBits
> 0; e
= e
* 256 + buffer
[offset
+ i
], i
+= d
, nBits
-= 8) {}
2754 m
= e
& ((1 << (-nBits
)) - 1)
2757 for (; nBits
> 0; m
= m
* 256 + buffer
[offset
+ i
], i
+= d
, nBits
-= 8) {}
2761 } else if (e
=== eMax
) {
2762 return m
? NaN : ((s
? -1 : 1) * Infinity
)
2764 m
= m
+ Math
.pow(2, mLen
)
2767 return (s
? -1 : 1) * m
* Math
.pow(2, e
- mLen
)
2770 exports
.write = function (buffer
, value
, offset
, isLE
, mLen
, nBytes
) {
2772 var eLen
= nBytes
* 8 - mLen
- 1
2773 var eMax
= (1 << eLen
) - 1
2774 var eBias
= eMax
>> 1
2775 var rt
= (mLen
=== 23 ? Math
.pow(2, -24) - Math
.pow(2, -77) : 0)
2776 var i
= isLE
? 0 : (nBytes
- 1)
2777 var d
= isLE
? 1 : -1
2778 var s
= value
< 0 || (value
=== 0 && 1 / value
< 0) ? 1 : 0
2780 value
= Math
.abs(value
)
2782 if (isNaN(value
) || value
=== Infinity
) {
2783 m
= isNaN(value
) ? 1 : 0
2786 e
= Math
.floor(Math
.log(value
) / Math
.LN2
)
2787 if (value
* (c
= Math
.pow(2, -e
)) < 1) {
2791 if (e
+ eBias
>= 1) {
2794 value
+= rt
* Math
.pow(2, 1 - eBias
)
2796 if (value
* c
>= 2) {
2801 if (e
+ eBias
>= eMax
) {
2804 } else if (e
+ eBias
>= 1) {
2805 m
= (value
* c
- 1) * Math
.pow(2, mLen
)
2808 m
= value
* Math
.pow(2, eBias
- 1) * Math
.pow(2, mLen
)
2813 for (; mLen
>= 8; buffer
[offset
+ i
] = m
& 0xff, i
+= d
, m
/= 256, mLen
-= 8) {}
2817 for (; eLen
> 0; buffer
[offset
+ i
] = e
& 0xff, i
+= d
, e
/= 256, eLen
-= 8) {}
2819 buffer
[offset
+ i
- d
] |= s
* 128
2822 },{}],8:[function(require
,module
,exports
){
2823 if (typeof Object
.create
=== 'function') {
2824 // implementation from standard node.js 'util' module
2825 module
.exports
= function inherits(ctor
, superCtor
) {
2826 ctor
.super_
= superCtor
2827 ctor
.prototype = Object
.create(superCtor
.prototype, {
2837 // old school shim for old browsers
2838 module
.exports
= function inherits(ctor
, superCtor
) {
2839 ctor
.super_
= superCtor
2840 var TempCtor = function () {}
2841 TempCtor
.prototype = superCtor
.prototype
2842 ctor
.prototype = new TempCtor()
2843 ctor
.prototype.constructor = ctor
2847 },{}],9:[function(require
,module
,exports
){
2849 * Determine if an object is a Buffer
2851 * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
2855 // The _isBuffer check is for Safari 5-7 support, because it's missing
2856 // Object.prototype.constructor. Remove this eventually
2857 module
.exports = function (obj
) {
2858 return obj
!= null && (isBuffer(obj
) || isSlowBuffer(obj
) || !!obj
._isBuffer
)
2861 function isBuffer (obj
) {
2862 return !!obj
.constructor && typeof obj
.constructor.isBuffer
=== 'function' && obj
.constructor.isBuffer(obj
)
2865 // For Node v0.10 support. Remove this eventually.
2866 function isSlowBuffer (obj
) {
2867 return typeof obj
.readFloatLE
=== 'function' && typeof obj
.slice
=== 'function' && isBuffer(obj
.slice(0, 0))
2870 },{}],10:[function(require
,module
,exports
){
2871 var toString
= {}.toString
;
2873 module
.exports
= Array
.isArray
|| function (arr
) {
2874 return toString
.call(arr
) == '[object Array]';
2877 },{}],11:[function(require
,module
,exports
){
2878 (function (process
){
2881 if (!process
.version
||
2882 process
.version
.indexOf('v0.') === 0 ||
2883 process
.version
.indexOf('v1.') === 0 && process
.version
.indexOf('v1.8.') !== 0) {
2884 module
.exports
= nextTick
;
2886 module
.exports
= process
.nextTick
;
2889 function nextTick(fn
, arg1
, arg2
, arg3
) {
2890 if (typeof fn
!== 'function') {
2891 throw new TypeError('"callback" argument must be a function');
2893 var len
= arguments
.length
;
2898 return process
.nextTick(fn
);
2900 return process
.nextTick(function afterTickOne() {
2901 fn
.call(null, arg1
);
2904 return process
.nextTick(function afterTickTwo() {
2905 fn
.call(null, arg1
, arg2
);
2908 return process
.nextTick(function afterTickThree() {
2909 fn
.call(null, arg1
, arg2
, arg3
);
2912 args
= new Array(len
- 1);
2914 while (i
< args
.length
) {
2915 args
[i
++] = arguments
[i
];
2917 return process
.nextTick(function afterTick() {
2918 fn
.apply(null, args
);
2923 }).call(this,require('_process'))
2924 },{"_process":12}],12:[function(require
,module
,exports
){
2925 // shim for using process in browser
2926 var process
= module
.exports
= {};
2928 // cached from whatever global is present so that test runners that stub it
2929 // don't break things. But we need to wrap it in a try catch in case it is
2930 // wrapped in strict mode code which doesn't define any globals. It's inside a
2931 // function because try/catches deoptimize in certain engines.
2933 var cachedSetTimeout
;
2934 var cachedClearTimeout
;
2936 function defaultSetTimout() {
2937 throw new Error('setTimeout has not been defined');
2939 function defaultClearTimeout () {
2940 throw new Error('clearTimeout has not been defined');
2944 if (typeof setTimeout
=== 'function') {
2945 cachedSetTimeout
= setTimeout
;
2947 cachedSetTimeout
= defaultSetTimout
;
2950 cachedSetTimeout
= defaultSetTimout
;
2953 if (typeof clearTimeout
=== 'function') {
2954 cachedClearTimeout
= clearTimeout
;
2956 cachedClearTimeout
= defaultClearTimeout
;
2959 cachedClearTimeout
= defaultClearTimeout
;
2962 function runTimeout(fun
) {
2963 if (cachedSetTimeout
=== setTimeout
) {
2964 //normal enviroments in sane situations
2965 return setTimeout(fun
, 0);
2967 // if setTimeout wasn't available but was latter defined
2968 if ((cachedSetTimeout
=== defaultSetTimout
|| !cachedSetTimeout
) && setTimeout
) {
2969 cachedSetTimeout
= setTimeout
;
2970 return setTimeout(fun
, 0);
2973 // when when somebody has screwed with setTimeout but no I.E. maddness
2974 return cachedSetTimeout(fun
, 0);
2977 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
2978 return cachedSetTimeout
.call(null, fun
, 0);
2980 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
2981 return cachedSetTimeout
.call(this, fun
, 0);
2987 function runClearTimeout(marker
) {
2988 if (cachedClearTimeout
=== clearTimeout
) {
2989 //normal enviroments in sane situations
2990 return clearTimeout(marker
);
2992 // if clearTimeout wasn't available but was latter defined
2993 if ((cachedClearTimeout
=== defaultClearTimeout
|| !cachedClearTimeout
) && clearTimeout
) {
2994 cachedClearTimeout
= clearTimeout
;
2995 return clearTimeout(marker
);
2998 // when when somebody has screwed with setTimeout but no I.E. maddness
2999 return cachedClearTimeout(marker
);
3002 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
3003 return cachedClearTimeout
.call(null, marker
);
3005 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
3006 // Some versions of I.E. have different rules for clearTimeout vs setTimeout
3007 return cachedClearTimeout
.call(this, marker
);
3015 var draining
= false;
3017 var queueIndex
= -1;
3019 function cleanUpNextTick() {
3020 if (!draining
|| !currentQueue
) {
3024 if (currentQueue
.length
) {
3025 queue
= currentQueue
.concat(queue
);
3034 function drainQueue() {
3038 var timeout
= runTimeout(cleanUpNextTick
);
3041 var len
= queue
.length
;
3043 currentQueue
= queue
;
3045 while (++queueIndex
< len
) {
3047 currentQueue
[queueIndex
].run();
3053 currentQueue
= null;
3055 runClearTimeout(timeout
);
3058 process
.nextTick = function (fun
) {
3059 var args
= new Array(arguments
.length
- 1);
3060 if (arguments
.length
> 1) {
3061 for (var i
= 1; i
< arguments
.length
; i
++) {
3062 args
[i
- 1] = arguments
[i
];
3065 queue
.push(new Item(fun
, args
));
3066 if (queue
.length
=== 1 && !draining
) {
3067 runTimeout(drainQueue
);
3071 // v8 likes predictible objects
3072 function Item(fun
, array
) {
3076 Item
.prototype.run = function () {
3077 this.fun
.apply(null, this.array
);
3079 process
.title
= 'browser';
3080 process
.browser
= true;
3083 process
.version
= ''; // empty string to avoid regexp issues
3084 process
.versions
= {};
3089 process
.addListener
= noop
;
3090 process
.once
= noop
;
3092 process
.removeListener
= noop
;
3093 process
.removeAllListeners
= noop
;
3094 process
.emit
= noop
;
3095 process
.prependListener
= noop
;
3096 process
.prependOnceListener
= noop
;
3098 process
.listeners = function (name
) { return [] }
3100 process
.binding = function (name
) {
3101 throw new Error('process.binding is not supported');
3104 process
.cwd = function () { return '/' };
3105 process
.chdir = function (dir
) {
3106 throw new Error('process.chdir is not supported');
3108 process
.umask = function() { return 0; };
3110 },{}],13:[function(require
,module
,exports
){
3111 module
.exports
= require('./lib/_stream_duplex.js');
3113 },{"./lib/_stream_duplex.js":14}],14:[function(require
,module
,exports
){
3114 // Copyright Joyent, Inc. and other Node contributors.
3116 // Permission is hereby granted, free of charge, to any person obtaining a
3117 // copy of this software and associated documentation files (the
3118 // "Software"), to deal in the Software without restriction, including
3119 // without limitation the rights to use, copy, modify, merge, publish,
3120 // distribute, sublicense, and/or sell copies of the Software, and to permit
3121 // persons to whom the Software is furnished to do so, subject to the
3122 // following conditions:
3124 // The above copyright notice and this permission notice shall be included
3125 // in all copies or substantial portions of the Software.
3127 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
3128 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
3129 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
3130 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
3131 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
3132 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
3133 // USE OR OTHER DEALINGS IN THE SOFTWARE.
3135 // a duplex stream is just a stream that is both readable and writable.
3136 // Since JS doesn't have multiple prototypal inheritance, this class
3137 // prototypally inherits from Readable, and then parasitically from
3144 var processNextTick
= require('process-nextick-args');
3148 var objectKeys
= Object
.keys
|| function (obj
) {
3150 for (var key
in obj
) {
3156 module.exports = Duplex;
3159 var util
= require('core-util-is');
3160 util
.inherits
= require('inherits');
3163 var Readable = require('./_stream_readable');
3164 var Writable = require('./_stream_writable');
3166 util.inherits(Duplex, Readable);
3168 var keys = objectKeys(Writable.prototype);
3169 for (var v = 0; v < keys.length; v++) {
3170 var method = keys[v];
3171 if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
3174 function Duplex(options) {
3175 if (!(this instanceof Duplex)) return new Duplex(options);
3177 Readable.call(this, options);
3178 Writable.call(this, options);
3180 if (options && options.readable === false) this.readable = false;
3182 if (options && options.writable === false) this.writable = false;
3184 this.allowHalfOpen = true;
3185 if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
3187 this.once('end', onend);
3190 // the no-half-open enforcer
3192 // if we allow half-open state, or if the writable side ended,
3194 if (this.allowHalfOpen || this._writableState.ended) return;
3196 // no more data can be written.
3197 // But allow more writes to happen in this tick.
3198 processNextTick(onEndNT, this);
3201 function onEndNT(self) {
3205 Object.defineProperty(Duplex.prototype, 'destroyed', {
3207 if (this._readableState === undefined || this._writableState === undefined) {
3210 return this._readableState.destroyed && this._writableState.destroyed;
3212 set: function (value) {
3213 // we ignore the value if the stream
3214 // has not been initialized yet
3215 if (this._readableState === undefined || this._writableState === undefined) {
3219 // backward compatibility, the user is explicitly
3220 // managing destroyed
3221 this._readableState.destroyed = value;
3222 this._writableState.destroyed = value;
3226 Duplex.prototype._destroy = function (err, cb) {
3230 processNextTick(cb, err);
3233 function forEach(xs, f) {
3234 for (var i = 0, l = xs.length; i < l; i++) {
3238 },{"./_stream_readable":16,"./_stream_writable":18,"core-util-is":5,"inherits":8,"process-nextick-args":11}],15:[function(require,module,exports){
3239 // Copyright Joyent, Inc. and other Node contributors.
3241 // Permission is hereby granted, free of charge, to any person obtaining a
3242 // copy of this software and associated documentation files (the
3243 // "Software"), to deal in the Software without restriction, including
3244 // without limitation the rights to use, copy, modify, merge, publish,
3245 // distribute, sublicense, and/or sell copies of the Software, and to permit
3246 // persons to whom the Software is furnished to do so, subject to the
3247 // following conditions:
3249 // The above copyright notice and this permission notice shall be included
3250 // in all copies or substantial portions of the Software.
3252 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
3253 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
3254 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
3255 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
3256 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
3257 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
3258 // USE OR OTHER DEALINGS IN THE SOFTWARE.
3260 // a passthrough stream.
3261 // basically just the most minimal sort of Transform stream.
3262 // Every written chunk gets output as-is.
3266 module.exports = PassThrough;
3268 var Transform = require('./_stream_transform');
3271 var util
= require('core-util-is');
3272 util
.inherits
= require('inherits');
3275 util.inherits(PassThrough, Transform);
3277 function PassThrough(options) {
3278 if (!(this instanceof PassThrough)) return new PassThrough(options);
3280 Transform.call(this, options);
3283 PassThrough.prototype._transform = function (chunk, encoding, cb) {
3286 },{"./_stream_transform":17,"core-util-is":5,"inherits":8}],16:[function(require,module,exports){
3287 (function (process,global){
3288 // Copyright Joyent, Inc. and other Node contributors.
3290 // Permission is hereby granted, free of charge, to any person obtaining a
3291 // copy of this software and associated documentation files (the
3292 // "Software"), to deal in the Software without restriction, including
3293 // without limitation the rights to use, copy, modify, merge, publish,
3294 // distribute, sublicense, and/or sell copies of the Software, and to permit
3295 // persons to whom the Software is furnished to do so, subject to the
3296 // following conditions:
3298 // The above copyright notice and this permission notice shall be included
3299 // in all copies or substantial portions of the Software.
3301 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
3302 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
3303 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
3304 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
3305 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
3306 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
3307 // USE OR OTHER DEALINGS IN THE SOFTWARE.
3313 var processNextTick
= require('process-nextick-args');
3316 module.exports = Readable;
3319 var isArray
= require('isarray');
3326 Readable.ReadableState = ReadableState;
3329 var EE
= require('events').EventEmitter
;
3331 var EElistenerCount = function (emitter
, type
) {
3332 return emitter
.listeners(type
).length
;
3337 var Stream
= require('./internal/streams/stream');
3340 // TODO(bmeurer): Change this back to const once hole checks are
3341 // properly optimized away early in Ignition+TurboFan.
3343 var Buffer
= require('safe-buffer').Buffer
;
3344 var OurUint8Array
= global
.Uint8Array
|| function () {};
3345 function _uint8ArrayToBuffer(chunk
) {
3346 return Buffer
.from(chunk
);
3348 function _isUint8Array(obj
) {
3349 return Buffer
.isBuffer(obj
) || obj
instanceof OurUint8Array
;
3354 var util
= require('core-util-is');
3355 util
.inherits
= require('inherits');
3359 var debugUtil
= require('util');
3361 if (debugUtil
&& debugUtil
.debuglog
) {
3362 debug
= debugUtil
.debuglog('stream');
3364 debug = function () {};
3368 var BufferList = require('./internal/streams/BufferList');
3369 var destroyImpl = require('./internal/streams/destroy');
3372 util.inherits(Readable, Stream);
3374 var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
3376 function prependListener(emitter, event, fn) {
3377 // Sadly this is not cacheable as some libraries bundle their own
3378 // event emitter implementation with them.
3379 if (typeof emitter.prependListener === 'function') {
3380 return emitter.prependListener(event, fn);
3382 // This is a hack to make sure that our error handler is attached before any
3383 // userland ones. NEVER DO THIS. This is here only because this code needs
3384 // to continue to work with older versions of Node.js that do not include
3385 // the prependListener() method. The goal is to eventually remove this hack.
3386 if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
3390 function ReadableState(options, stream) {
3391 Duplex = Duplex || require('./_stream_duplex');
3393 options = options || {};
3395 // object stream flag. Used to make read(n) ignore n and to
3396 // make all the buffer merging and length checks go away
3397 this.objectMode = !!options.objectMode;
3399 if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
3401 // the point at which it stops calling _read() to fill the buffer
3402 // Note: 0 is a valid value, means "don't call _read preemptively ever"
3403 var hwm = options.highWaterMark;
3404 var defaultHwm = this.objectMode ? 16 : 16 * 1024;
3405 this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
3408 this.highWaterMark = Math.floor(this.highWaterMark);
3410 // A linked list is used to store data chunks instead of an array because the
3411 // linked list can remove elements from the beginning faster than
3413 this.buffer = new BufferList();
3416 this.pipesCount = 0;
3417 this.flowing = null;
3419 this.endEmitted = false;
3420 this.reading = false;
3422 // a flag to be able to tell if the event 'readable'/'data' is emitted
3423 // immediately, or on a later tick. We set this to true at first, because
3424 // any actions that shouldn't happen until "later" should generally also
3425 // not happen before the first read call.
3428 // whenever we return null, then we set a flag to say
3429 // that we're awaiting a 'readable' event emission.
3430 this.needReadable = false;
3431 this.emittedReadable = false;
3432 this.readableListening = false;
3433 this.resumeScheduled = false;
3435 // has it been destroyed
3436 this.destroyed = false;
3438 // Crypto is kind of old and crusty. Historically, its default string
3439 // encoding is 'binary' so we have to make this configurable.
3440 // Everything else in the universe uses 'utf8', though.
3441 this.defaultEncoding = options.defaultEncoding || 'utf8';
3443 // the number of writers that are awaiting a drain event in .pipe()s
3444 this.awaitDrain = 0;
3446 // if true, a maybeReadMore has been scheduled
3447 this.readingMore = false;
3449 this.decoder = null;
3450 this.encoding = null;
3451 if (options.encoding) {
3452 if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
3453 this.decoder = new StringDecoder(options.encoding);
3454 this.encoding = options.encoding;
3458 function Readable(options) {
3459 Duplex = Duplex || require('./_stream_duplex');
3461 if (!(this instanceof Readable)) return new Readable(options);
3463 this._readableState = new ReadableState(options, this);
3466 this.readable = true;
3469 if (typeof options.read === 'function') this._read = options.read;
3471 if (typeof options.destroy === 'function') this._destroy = options.destroy;
3477 Object.defineProperty(Readable.prototype, 'destroyed', {
3479 if (this._readableState === undefined) {
3482 return this._readableState.destroyed;
3484 set: function (value) {
3485 // we ignore the value if the stream
3486 // has not been initialized yet
3487 if (!this._readableState) {
3491 // backward compatibility, the user is explicitly
3492 // managing destroyed
3493 this._readableState.destroyed = value;
3497 Readable.prototype.destroy = destroyImpl.destroy;
3498 Readable.prototype._undestroy = destroyImpl.undestroy;
3499 Readable.prototype._destroy = function (err, cb) {
3504 // Manually shove something into the read() buffer.
3505 // This returns true if the highWaterMark has not been hit yet,
3506 // similar to how Writable.write() returns true if you should
3507 // write() some more.
3508 Readable.prototype.push = function (chunk, encoding) {
3509 var state = this._readableState;
3512 if (!state.objectMode) {
3513 if (typeof chunk === 'string') {
3514 encoding = encoding || state.defaultEncoding;
3515 if (encoding !== state.encoding) {
3516 chunk = Buffer.from(chunk, encoding);
3519 skipChunkCheck = true;
3522 skipChunkCheck = true;
3525 return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
3528 // Unshift should *always* be something directly out of read()
3529 Readable.prototype.unshift = function (chunk) {
3530 return readableAddChunk(this, chunk, null, true, false);
3533 function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
3534 var state = stream._readableState;
3535 if (chunk === null) {
3536 state.reading = false;
3537 onEofChunk(stream, state);
3540 if (!skipChunkCheck) er = chunkInvalid(state, chunk);
3542 stream.emit('error', er);
3543 } else if (state.objectMode || chunk && chunk.length > 0) {
3544 if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
3545 chunk = _uint8ArrayToBuffer(chunk);
3549 if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
3550 } else if (state.ended) {
3551 stream.emit('error', new Error('stream.push() after EOF'));
3553 state.reading = false;
3554 if (state.decoder && !encoding) {
3555 chunk = state.decoder.write(chunk);
3556 if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
3558 addChunk(stream, state, chunk, false);
3561 } else if (!addToFront) {
3562 state.reading = false;
3566 return needMoreData(state);
3569 function addChunk(stream, state, chunk, addToFront) {
3570 if (state.flowing && state.length === 0 && !state.sync) {
3571 stream.emit('data', chunk);
3574 // update the buffer info.
3575 state.length += state.objectMode ? 1 : chunk.length;
3576 if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
3578 if (state.needReadable) emitReadable(stream);
3580 maybeReadMore(stream, state);
3583 function chunkInvalid(state, chunk) {
3585 if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
3586 er = new TypeError('Invalid non-string/buffer chunk');
3591 // if it's past the high water mark, we can push in some more.
3592 // Also, if we have no data yet, we can stand some
3593 // more bytes. This is to work around cases where hwm=0,
3594 // such as the repl. Also, if the push() triggered a
3595 // readable event, and the user called read(largeNumber) such that
3596 // needReadable was set, then we ought to push more, so that another
3597 // 'readable' event will be triggered.
3598 function needMoreData(state) {
3599 return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
3602 Readable.prototype.isPaused = function () {
3603 return this._readableState.flowing === false;
3606 // backwards compatibility.
3607 Readable.prototype.setEncoding = function (enc) {
3608 if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
3609 this._readableState.decoder = new StringDecoder(enc);
3610 this._readableState.encoding = enc;
3614 // Don't raise the hwm > 8MB
3615 var MAX_HWM = 0x800000;
3616 function computeNewHighWaterMark(n) {
3620 // Get the next highest power of 2 to prevent increasing hwm excessively in
3633 // This function is designed to be inlinable, so please take care when making
3634 // changes to the function body.
3635 function howMuchToRead(n, state) {
3636 if (n <= 0 || state.length === 0 && state.ended) return 0;
3637 if (state.objectMode) return 1;
3639 // Only flow one buffer at a time
3640 if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
3642 // If we're asking for more than the current hwm, then raise the hwm.
3643 if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
3644 if (n <= state.length) return n;
3645 // Don't have enough
3647 state.needReadable = true;
3650 return state.length;
3653 // you can override either this method, or the async _read(n) below.
3654 Readable.prototype.read = function (n) {
3656 n = parseInt(n, 10);
3657 var state = this._readableState;
3660 if (n !== 0) state.emittedReadable = false;
3662 // if we're doing read(0) to trigger a readable event, but we
3663 // already have a bunch of data in the buffer, then just trigger
3664 // the 'readable' event and move on.
3665 if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
3666 debug('read: emitReadable', state.length, state.ended);
3667 if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
3671 n = howMuchToRead(n, state);
3673 // if we've ended, and we're now clear, then finish it up.
3674 if (n === 0 && state.ended) {
3675 if (state.length === 0) endReadable(this);
3679 // All the actual chunk generation logic needs to be
3680 // *below* the call to _read. The reason is that in certain
3681 // synthetic stream cases, such as passthrough streams, _read
3682 // may be a completely synchronous operation which may change
3683 // the state of the read buffer, providing enough data when
3684 // before there was *not* enough.
3686 // So, the steps are:
3687 // 1. Figure out what the state of things will be after we do
3688 // a read from the buffer.
3690 // 2. If that resulting state will trigger a _read, then call _read.
3691 // Note that this may be asynchronous, or synchronous. Yes, it is
3692 // deeply ugly to write APIs this way, but that still doesn't mean
3693 // that the Readable class should behave improperly, as streams are
3694 // designed to be sync/async agnostic.
3695 // Take note if the _read call is sync or async (ie, if the read call
3696 // has returned yet), so that we know whether or not it's safe to emit
3699 // 3. Actually pull the requested chunks out of the buffer and return.
3701 // if we need a readable event, then we need to do some reading.
3702 var doRead = state.needReadable;
3703 debug('need readable', doRead);
3705 // if we currently have less than the highWaterMark, then also read some
3706 if (state.length === 0 || state.length - n < state.highWaterMark) {
3708 debug('length less than watermark', doRead);
3711 // however, if we've ended, then there's no point, and if we're already
3712 // reading, then it's unnecessary.
3713 if (state.ended || state.reading) {
3715 debug('reading or ended', doRead);
3716 } else if (doRead) {
3718 state.reading = true;
3720 // if the length is currently zero, then we *need* a readable event.
3721 if (state.length === 0) state.needReadable = true;
3722 // call internal read method
3723 this._read(state.highWaterMark);
3725 // If _read pushed data synchronously, then `reading` will be false,
3726 // and we need to re-evaluate how much data we can return to the user.
3727 if (!state.reading) n = howMuchToRead(nOrig, state);
3731 if (n > 0) ret = fromList(n, state);else ret = null;
3734 state.needReadable = true;
3740 if (state.length === 0) {
3741 // If we have nothing in the buffer, then we want to know
3742 // as soon as we *do* get something into the buffer.
3743 if (!state.ended) state.needReadable = true;
3745 // If we tried to read() past the EOF, then emit end on the next tick.
3746 if (nOrig !== n && state.ended) endReadable(this);
3749 if (ret !== null) this.emit('data', ret);
3754 function onEofChunk(stream, state) {
3755 if (state.ended) return;
3756 if (state.decoder) {
3757 var chunk = state.decoder.end();
3758 if (chunk && chunk.length) {
3759 state.buffer.push(chunk);
3760 state.length += state.objectMode ? 1 : chunk.length;
3765 // emit 'readable' now to make sure it gets picked up.
3766 emitReadable(stream);
3769 // Don't emit readable right away in sync mode, because this can trigger
3770 // another read() call => stack overflow. This way, it might trigger
3771 // a nextTick recursion warning, but that's not so bad.
3772 function emitReadable(stream) {
3773 var state = stream._readableState;
3774 state.needReadable = false;
3775 if (!state.emittedReadable) {
3776 debug('emitReadable', state.flowing);
3777 state.emittedReadable = true;
3778 if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);
3782 function emitReadable_(stream) {
3783 debug('emit readable');
3784 stream.emit('readable');
3788 // at this point, the user has presumably seen the 'readable' event,
3789 // and called read() to consume some data. that may have triggered
3790 // in turn another _read(n) call, in which case reading = true if
3791 // it's in progress.
3792 // However, if we're not ended, or reading, and the length < hwm,
3793 // then go ahead and try to read some more preemptively.
3794 function maybeReadMore(stream, state) {
3795 if (!state.readingMore) {
3796 state.readingMore = true;
3797 processNextTick(maybeReadMore_, stream, state);
3801 function maybeReadMore_(stream, state) {
3802 var len = state.length;
3803 while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
3804 debug('maybeReadMore read 0');
3806 if (len === state.length)
3807 // didn't get any data, stop spinning.
3808 break;else len = state.length;
3810 state.readingMore = false;
3813 // abstract method. to be overridden in specific implementation classes.
3814 // call cb(er, data) where data is <= n in length.
3815 // for virtual (non-string, non-buffer) streams, "length" is somewhat
3816 // arbitrary, and perhaps not very meaningful.
3817 Readable.prototype._read = function (n) {
3818 this.emit('error', new Error('_read() is not implemented'));
3821 Readable.prototype.pipe = function (dest, pipeOpts) {
3823 var state = this._readableState;
3825 switch (state.pipesCount) {
3830 state.pipes = [state.pipes, dest];
3833 state.pipes.push(dest);
3836 state.pipesCount += 1;
3837 debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
3839 var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
3841 var endFn = doEnd ? onend : unpipe;
3842 if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);
3844 dest.on('unpipe', onunpipe);
3845 function onunpipe(readable, unpipeInfo) {
3847 if (readable === src) {
3848 if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
3849 unpipeInfo.hasUnpiped = true;
3860 // when the dest drains, it reduces the awaitDrain counter
3861 // on the source. This would be more elegant with a .once()
3862 // handler in flow(), but adding and removing repeatedly is
3864 var ondrain = pipeOnDrain(src);
3865 dest.on('drain', ondrain);
3867 var cleanedUp = false;
3868 function cleanup() {
3870 // cleanup event handlers once the pipe is broken
3871 dest.removeListener('close', onclose);
3872 dest.removeListener('finish', onfinish);
3873 dest.removeListener('drain', ondrain);
3874 dest.removeListener('error', onerror);
3875 dest.removeListener('unpipe', onunpipe);
3876 src.removeListener('end', onend);
3877 src.removeListener('end', unpipe);
3878 src.removeListener('data', ondata);
3882 // if the reader is waiting for a drain event from this
3883 // specific writer, then it would cause it to never start
3885 // So, if this is awaiting a drain, then we just call it now.
3886 // If we don't know, then assume that we are waiting for one.
3887 if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
3890 // If the user pushes more data while we're writing to dest then we'll end up
3891 // in ondata again. However, we only want to increase awaitDrain once because
3892 // dest will only emit one 'drain' event for the multiple writes.
3893 // => Introduce a guard on increasing awaitDrain.
3894 var increasedAwaitDrain = false;
3895 src.on('data', ondata);
3896 function ondata(chunk) {
3898 increasedAwaitDrain = false;
3899 var ret = dest.write(chunk);
3900 if (false === ret && !increasedAwaitDrain) {
3901 // If the user unpiped during `dest.write()`, it is possible
3902 // to get stuck in a permanently paused state if that write
3903 // also returned false.
3904 // => Check whether `dest` is still a piping destination.
3905 if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
3906 debug('false write response, pause', src._readableState.awaitDrain);
3907 src._readableState.awaitDrain++;
3908 increasedAwaitDrain = true;
3914 // if the dest has an error, then stop piping into it.
3915 // however, don't suppress the throwing behavior for this.
3916 function onerror(er) {
3917 debug('onerror', er);
3919 dest.removeListener('error', onerror);
3920 if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
3923 // Make sure our error handler is attached before userland ones.
3924 prependListener(dest, 'error', onerror);
3926 // Both close and finish should trigger unpipe, but only once.
3927 function onclose() {
3928 dest.removeListener('finish', onfinish);
3931 dest.once('close', onclose);
3932 function onfinish() {
3934 dest.removeListener('close', onclose);
3937 dest.once('finish', onfinish);
3944 // tell the dest that it's being piped to
3945 dest.emit('pipe', src);
3947 // start the flow if it hasn't been started already.
3948 if (!state.flowing) {
3949 debug('pipe resume');
3956 function pipeOnDrain(src) {
3957 return function () {
3958 var state = src._readableState;
3959 debug('pipeOnDrain', state.awaitDrain);
3960 if (state.awaitDrain) state.awaitDrain--;
3961 if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
3962 state.flowing = true;
3968 Readable.prototype.unpipe = function (dest) {
3969 var state = this._readableState;
3970 var unpipeInfo = { hasUnpiped: false };
3972 // if we're not piping anywhere, then do nothing.
3973 if (state.pipesCount === 0) return this;
3975 // just one destination. most common case.
3976 if (state.pipesCount === 1) {
3977 // passed in one, but it's not the right one.
3978 if (dest && dest !== state.pipes) return this;
3980 if (!dest) dest = state.pipes;
3984 state.pipesCount = 0;
3985 state.flowing = false;
3986 if (dest) dest.emit('unpipe', this, unpipeInfo);
3990 // slow case. multiple pipe destinations.
3994 var dests = state.pipes;
3995 var len = state.pipesCount;
3997 state.pipesCount = 0;
3998 state.flowing = false;
4000 for (var i = 0; i < len; i++) {
4001 dests[i].emit('unpipe', this, unpipeInfo);
4005 // try to find the right one.
4006 var index = indexOf(state.pipes, dest);
4007 if (index === -1) return this;
4009 state.pipes.splice(index, 1);
4010 state.pipesCount -= 1;
4011 if (state.pipesCount === 1) state.pipes = state.pipes[0];
4013 dest.emit('unpipe', this, unpipeInfo);
4018 // set up data events if they are asked for
4019 // Ensure readable listeners eventually get something
4020 Readable.prototype.on = function (ev, fn) {
4021 var res = Stream.prototype.on.call(this, ev, fn);
4023 if (ev === 'data') {
4024 // Start flowing on next tick if stream isn't explicitly paused
4025 if (this._readableState.flowing !== false) this.resume();
4026 } else if (ev === 'readable') {
4027 var state = this._readableState;
4028 if (!state.endEmitted && !state.readableListening) {
4029 state.readableListening = state.needReadable = true;
4030 state.emittedReadable = false;
4031 if (!state.reading) {
4032 processNextTick(nReadingNextTick, this);
4033 } else if (state.length) {
4041 Readable.prototype.addListener = Readable.prototype.on;
4043 function nReadingNextTick(self) {
4044 debug('readable nexttick read 0');
4048 // pause() and resume() are remnants of the legacy readable stream API
4049 // If the user uses them, then switch into old mode.
4050 Readable.prototype.resume = function () {
4051 var state = this._readableState;
4052 if (!state.flowing) {
4054 state.flowing = true;
4055 resume(this, state);
4060 function resume(stream, state) {
4061 if (!state.resumeScheduled) {
4062 state.resumeScheduled = true;
4063 processNextTick(resume_, stream, state);
4067 function resume_(stream, state) {
4068 if (!state.reading) {
4069 debug('resume read 0');
4073 state.resumeScheduled = false;
4074 state.awaitDrain = 0;
4075 stream.emit('resume');
4077 if (state.flowing && !state.reading) stream.read(0);
4080 Readable.prototype.pause = function () {
4081 debug('call pause flowing=%j', this._readableState.flowing);
4082 if (false !== this._readableState.flowing) {
4084 this._readableState.flowing = false;
4090 function flow(stream) {
4091 var state = stream._readableState;
4092 debug('flow', state.flowing);
4093 while (state.flowing && stream.read() !== null) {}
4096 // wrap an old-style stream as the async data source.
4097 // This is *not* part of the readable stream interface.
4098 // It is an ugly unfortunate mess of history.
4099 Readable.prototype.wrap = function (stream) {
4100 var state = this._readableState;
4104 stream.on('end', function () {
4105 debug('wrapped end');
4106 if (state.decoder && !state.ended) {
4107 var chunk = state.decoder.end();
4108 if (chunk && chunk.length) self.push(chunk);
4114 stream.on('data', function (chunk) {
4115 debug('wrapped data');
4116 if (state.decoder) chunk = state.decoder.write(chunk);
4118 // don't skip over falsy values in objectMode
4119 if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
4121 var ret = self.push(chunk);
4128 // proxy all the other methods.
4129 // important when wrapping filters and duplexes.
4130 for (var i in stream) {
4131 if (this[i] === undefined && typeof stream[i] === 'function') {
4132 this[i] = function (method) {
4133 return function () {
4134 return stream[method].apply(stream, arguments);
4140 // proxy certain important events.
4141 for (var n = 0; n < kProxyEvents.length; n++) {
4142 stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));
4145 // when we try to consume some more bytes, simply unpause the
4146 // underlying stream.
4147 self._read = function (n) {
4148 debug('wrapped _read', n);
4158 // exposed for testing purposes only.
4159 Readable._fromList = fromList;
4161 // Pluck off n bytes from an array of buffers.
4162 // Length is the combined lengths of all the buffers in the list.
4163 // This function is designed to be inlinable, so please take care when making
4164 // changes to the function body.
4165 function fromList(n, state) {
4167 if (state.length === 0) return null;
4170 if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
4171 // read it all, truncate the list
4172 if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
4173 state.buffer.clear();
4175 // read part of list
4176 ret = fromListPartial(n, state.buffer, state.decoder);
4182 // Extracts only enough buffered data to satisfy the amount requested.
4183 // This function is designed to be inlinable, so please take care when making
4184 // changes to the function body.
4185 function fromListPartial(n, list, hasStrings) {
4187 if (n < list.head.data.length) {
4188 // slice is the same for buffers and strings
4189 ret = list.head.data.slice(0, n);
4190 list.head.data = list.head.data.slice(n);
4191 } else if (n === list.head.data.length) {
4192 // first chunk is a perfect match
4195 // result spans more than one buffer
4196 ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
4201 // Copies a specified amount of characters from the list of buffered data
4203 // This function is designed to be inlinable, so please take care when making
4204 // changes to the function body.
4205 function copyFromBufferString(n, list) {
4210 while (p = p.next) {
4212 var nb = n > str.length ? str.length : n;
4213 if (nb === str.length) ret += str;else ret += str.slice(0, n);
4216 if (nb === str.length) {
4218 if (p.next) list.head = p.next;else list.head = list.tail = null;
4221 p.data = str.slice(nb);
4231 // Copies a specified amount of bytes from the list of buffered data chunks.
4232 // This function is designed to be inlinable, so please take care when making
4233 // changes to the function body.
4234 function copyFromBuffer(n, list) {
4235 var ret = Buffer.allocUnsafe(n);
4240 while (p = p.next) {
4242 var nb = n > buf.length ? buf.length : n;
4243 buf.copy(ret, ret.length - n, 0, nb);
4246 if (nb === buf.length) {
4248 if (p.next) list.head = p.next;else list.head = list.tail = null;
4251 p.data = buf.slice(nb);
4261 function endReadable(stream) {
4262 var state = stream._readableState;
4264 // If we get here before consuming all the bytes, then that is a
4265 // bug in node. Should never happen.
4266 if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
4268 if (!state.endEmitted) {
4270 processNextTick(endReadableNT, state, stream);
4274 function endReadableNT(state, stream) {
4275 // Check that we didn't get one last unshift.
4276 if (!state.endEmitted && state.length === 0) {
4277 state.endEmitted = true;
4278 stream.readable = false;
4283 function forEach(xs, f) {
4284 for (var i = 0, l = xs.length; i < l; i++) {
4289 function indexOf(xs, x) {
4290 for (var i = 0, l = xs.length; i < l; i++) {
4291 if (xs[i] === x) return i;
4295 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
4296 },{"./_stream_duplex":14,"./internal/streams/BufferList":19,"./internal/streams/destroy":20,"./internal/streams/stream":21,"_process":12,"core-util-is":5,"events":6,"inherits":8,"isarray":10,"process-nextick-args":11,"safe-buffer":26,"string_decoder/":28,"util":3}],17:[function(require,module,exports){
4297 // Copyright Joyent, Inc. and other Node contributors.
4299 // Permission is hereby granted, free of charge, to any person obtaining a
4300 // copy of this software and associated documentation files (the
4301 // "Software"), to deal in the Software without restriction, including
4302 // without limitation the rights to use, copy, modify, merge, publish,
4303 // distribute, sublicense, and/or sell copies of the Software, and to permit
4304 // persons to whom the Software is furnished to do so, subject to the
4305 // following conditions:
4307 // The above copyright notice and this permission notice shall be included
4308 // in all copies or substantial portions of the Software.
4310 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
4311 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
4312 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
4313 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
4314 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
4315 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
4316 // USE OR OTHER DEALINGS IN THE SOFTWARE.
4318 // a transform stream is a readable/writable stream where you do
4319 // something with the data. Sometimes it's called a "filter",
4320 // but that's not a great name for it, since that implies a thing where
4321 // some bits pass through, and others are simply ignored. (That would
4322 // be a valid example of a transform, of course.)
4324 // While the output is causally related to the input, it's not a
4325 // necessarily symmetric or synchronous transformation. For example,
4326 // a zlib stream might take multiple plain-text writes(), and then
4327 // emit a single compressed chunk some time in the future.
4329 // Here's how this works:
4331 // The Transform stream has all the aspects of the readable and writable
4332 // stream classes. When you write(chunk), that calls _write(chunk,cb)
4333 // internally, and returns false if there's a lot of pending writes
4334 // buffered up. When you call read(), that calls _read(n) until
4335 // there's enough pending readable data buffered up.
4337 // In a transform stream, the written data is placed in a buffer. When
4338 // _read(n) is called, it transforms the queued up data, calling the
4339 // buffered _write cb's as it consumes chunks. If consuming a single
4340 // written chunk would result in multiple output chunks, then the first
4341 // outputted bit calls the readcb, and subsequent chunks just go into
4342 // the read buffer, and will cause it to emit 'readable' if necessary.
4344 // This way, back-pressure is actually determined by the reading side,
4345 // since _read has to be called to start processing a new chunk. However,
4346 // a pathological inflate type of transform can cause excessive buffering
4347 // here. For example, imagine a stream where every byte of input is
4348 // interpreted as an integer from 0-255, and then results in that many
4349 // bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
4350 // 1kb of data being output. In this case, you could write a very small
4351 // amount of input, and end up with a very large amount of output. In
4352 // such a pathological inflating mechanism, there'd be no way to tell
4353 // the system to stop doing the transform. A single 4MB write could
4354 // cause the system to run out of memory.
4356 // However, even in such a pathological case, only a single written chunk
4357 // would be consumed, and then the rest would wait (un-transformed) until
4358 // the results of the previous transformed chunk were consumed.
4362 module.exports = Transform;
4364 var Duplex = require('./_stream_duplex');
4367 var util
= require('core-util-is');
4368 util
.inherits
= require('inherits');
4371 util.inherits(Transform, Duplex);
4373 function TransformState(stream) {
4374 this.afterTransform = function (er, data) {
4375 return afterTransform(stream, er, data);
4378 this.needTransform = false;
4379 this.transforming = false;
4380 this.writecb = null;
4381 this.writechunk = null;
4382 this.writeencoding = null;
4385 function afterTransform(stream, er, data) {
4386 var ts = stream._transformState;
4387 ts.transforming = false;
4389 var cb = ts.writecb;
4392 return stream.emit('error', new Error('write callback called multiple times'));
4395 ts.writechunk = null;
4398 if (data !== null && data !== undefined) stream.push(data);
4402 var rs = stream._readableState;
4404 if (rs.needReadable || rs.length < rs.highWaterMark) {
4405 stream._read(rs.highWaterMark);
4409 function Transform(options) {
4410 if (!(this instanceof Transform)) return new Transform(options);
4412 Duplex.call(this, options);
4414 this._transformState = new TransformState(this);
4418 // start out asking for a readable event once data is transformed.
4419 this._readableState.needReadable = true;
4421 // we have implemented the _read method, and done the other things
4422 // that Readable wants before the first _read call, so unset the
4424 this._readableState.sync = false;
4427 if (typeof options.transform === 'function') this._transform = options.transform;
4429 if (typeof options.flush === 'function') this._flush = options.flush;
4432 // When the writable side finishes, then flush out anything remaining.
4433 this.once('prefinish', function () {
4434 if (typeof this._flush === 'function') this._flush(function (er, data) {
4435 done(stream, er, data);
4436 });else done(stream);
4440 Transform.prototype.push = function (chunk, encoding) {
4441 this._transformState.needTransform = false;
4442 return Duplex.prototype.push.call(this, chunk, encoding);
4445 // This is the part where you do stuff!
4446 // override this function in implementation classes.
4447 // 'chunk' is an input chunk.
4449 // Call `push(newChunk)` to pass along transformed output
4450 // to the readable side. You may call 'push' zero or more times.
4452 // Call `cb(err)` when you are done with this chunk. If you pass
4453 // an error, then that'll put the hurt on the whole operation. If you
4454 // never call cb(), then you'll never get another chunk.
4455 Transform.prototype._transform = function (chunk, encoding, cb) {
4456 throw new Error('_transform() is not implemented');
4459 Transform.prototype._write = function (chunk, encoding, cb) {
4460 var ts = this._transformState;
4462 ts.writechunk = chunk;
4463 ts.writeencoding = encoding;
4464 if (!ts.transforming) {
4465 var rs = this._readableState;
4466 if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
4470 // Doesn't matter what the args are here.
4471 // _transform does all the work.
4472 // That we got here means that the readable side wants more data.
4473 Transform.prototype._read = function (n) {
4474 var ts = this._transformState;
4476 if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
4477 ts.transforming = true;
4478 this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
4480 // mark that we need a transform, so that any data that comes in
4481 // will get processed, now that we've asked for it.
4482 ts.needTransform = true;
4486 Transform.prototype._destroy = function (err, cb) {
4489 Duplex.prototype._destroy.call(this, err, function (err2) {
4491 _this.emit('close');
4495 function done(stream, er, data) {
4496 if (er) return stream.emit('error', er);
4498 if (data !== null && data !== undefined) stream.push(data);
4500 // if there's nothing in the write buffer, then that means
4501 // that nothing more will ever be provided
4502 var ws = stream._writableState;
4503 var ts = stream._transformState;
4505 if (ws.length) throw new Error('Calling transform done when ws.length != 0');
4507 if (ts.transforming) throw new Error('Calling transform done when still transforming');
4509 return stream.push(null);
4511 },{"./_stream_duplex":14,"core-util-is":5,"inherits":8}],18:[function(require,module,exports){
4512 (function (process,global){
4513 // Copyright Joyent, Inc. and other Node contributors.
4515 // Permission is hereby granted, free of charge, to any person obtaining a
4516 // copy of this software and associated documentation files (the
4517 // "Software"), to deal in the Software without restriction, including
4518 // without limitation the rights to use, copy, modify, merge, publish,
4519 // distribute, sublicense, and/or sell copies of the Software, and to permit
4520 // persons to whom the Software is furnished to do so, subject to the
4521 // following conditions:
4523 // The above copyright notice and this permission notice shall be included
4524 // in all copies or substantial portions of the Software.
4526 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
4527 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
4528 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
4529 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
4530 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
4531 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
4532 // USE OR OTHER DEALINGS IN THE SOFTWARE.
4534 // A bit simpler than readable streams.
4535 // Implement an async ._write(chunk, encoding, cb), and it'll handle all
4536 // the drain event emission and buffering.
4542 var processNextTick
= require('process-nextick-args');
4545 module.exports = Writable;
4548 function WriteReq(chunk
, encoding
, cb
) {
4550 this.encoding
= encoding
;
4555 // It seems a linked list but it is not
4556 // there will be only 2 of these for each stream
4557 function CorkedRequest(state
) {
4562 this.finish = function () {
4563 onCorkedFinish(_this
, state
);
4566 /* </replacement> */
4569 var asyncWrite
= !process
.browser
&& ['v0.10', 'v0.9.'].indexOf(process
.version
.slice(0, 5)) > -1 ? setImmediate : processNextTick
;
4576 Writable.WritableState = WritableState;
4579 var util
= require('core-util-is');
4580 util
.inherits
= require('inherits');
4584 var internalUtil
= {
4585 deprecate: require('util-deprecate')
4590 var Stream
= require('./internal/streams/stream');
4594 var Buffer
= require('safe-buffer').Buffer
;
4595 var OurUint8Array
= global
.Uint8Array
|| function () {};
4596 function _uint8ArrayToBuffer(chunk
) {
4597 return Buffer
.from(chunk
);
4599 function _isUint8Array(obj
) {
4600 return Buffer
.isBuffer(obj
) || obj
instanceof OurUint8Array
;
4604 var destroyImpl = require('./internal/streams/destroy');
4606 util.inherits(Writable, Stream);
4610 function WritableState(options, stream) {
4611 Duplex = Duplex || require('./_stream_duplex');
4613 options = options || {};
4615 // object stream flag to indicate whether or not this stream
4616 // contains buffers or objects.
4617 this.objectMode = !!options.objectMode;
4619 if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
4621 // the point at which write() starts returning false
4622 // Note: 0 is a valid value, means that we always return false if
4623 // the entire buffer is not flushed immediately on write()
4624 var hwm = options.highWaterMark;
4625 var defaultHwm = this.objectMode ? 16 : 16 * 1024;
4626 this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
4629 this.highWaterMark = Math.floor(this.highWaterMark);
4631 // if _final has been called
4632 this.finalCalled = false;
4634 // drain event flag.
4635 this.needDrain = false;
4636 // at the start of calling end()
4637 this.ending = false;
4638 // when end() has been called, and returned
4640 // when 'finish' is emitted
4641 this.finished = false;
4643 // has it been destroyed
4644 this.destroyed = false;
4646 // should we decode strings into buffers before passing to _write?
4647 // this is here so that some node-core streams can optimize string
4648 // handling at a lower level.
4649 var noDecode = options.decodeStrings === false;
4650 this.decodeStrings = !noDecode;
4652 // Crypto is kind of old and crusty. Historically, its default string
4653 // encoding is 'binary' so we have to make this configurable.
4654 // Everything else in the universe uses 'utf8', though.
4655 this.defaultEncoding = options.defaultEncoding || 'utf8';
4657 // not an actual buffer we keep track of, but a measurement
4658 // of how much we're waiting to get pushed to some underlying
4662 // a flag to see when we're in the middle of a write.
4663 this.writing = false;
4665 // when true all writes will be buffered until .uncork() call
4668 // a flag to be able to tell if the onwrite cb is called immediately,
4669 // or on a later tick. We set this to true at first, because any
4670 // actions that shouldn't happen until "later" should generally also
4671 // not happen before the first write call.
4674 // a flag to know if we're processing previously buffered items, which
4675 // may call the _write() callback in the same tick, so that we don't
4676 // end up in an overlapped onwrite situation.
4677 this.bufferProcessing = false;
4679 // the callback that's passed to _write(chunk,cb)
4680 this.onwrite = function (er) {
4681 onwrite(stream, er);
4684 // the callback that the user supplies to write(chunk,encoding,cb)
4685 this.writecb = null;
4687 // the amount that is being written when _write is called.
4690 this.bufferedRequest = null;
4691 this.lastBufferedRequest = null;
4693 // number of pending user-supplied write callbacks
4694 // this must be 0 before 'finish' can be emitted
4697 // emit prefinish if the only thing we're waiting for is _write cbs
4698 // This is relevant for synchronous Transform streams
4699 this.prefinished = false;
4701 // True if the error was already emitted and should not be thrown again
4702 this.errorEmitted = false;
4704 // count buffered requests
4705 this.bufferedRequestCount = 0;
4707 // allocate the first CorkedRequest, there is always
4708 // one allocated and free to use, and we maintain at most two
4709 this.corkedRequestsFree = new CorkedRequest(this);
4712 WritableState.prototype.getBuffer = function getBuffer() {
4713 var current = this.bufferedRequest;
4717 current = current.next;
4724 Object.defineProperty(WritableState.prototype, 'buffer', {
4725 get: internalUtil.deprecate(function () {
4726 return this.getBuffer();
4727 }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
4732 // Test _writableState for inheritance to account for Duplex streams,
4733 // whose prototype chain only points to Readable.
4734 var realHasInstance;
4735 if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
4736 realHasInstance = Function.prototype[Symbol.hasInstance];
4737 Object.defineProperty(Writable, Symbol.hasInstance, {
4738 value: function (object) {
4739 if (realHasInstance.call(this, object)) return true;
4741 return object && object._writableState instanceof WritableState;
4745 realHasInstance = function (object) {
4746 return object instanceof this;
4750 function Writable(options) {
4751 Duplex = Duplex || require('./_stream_duplex');
4753 // Writable ctor is applied to Duplexes, too.
4754 // `realHasInstance` is necessary because using plain `instanceof`
4755 // would return false, as no `_writableState` property is attached.
4757 // Trying to use the custom `instanceof` for Writable here will also break the
4758 // Node.js LazyTransform implementation, which has a non-trivial getter for
4759 // `_writableState` that would lead to infinite recursion.
4760 if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
4761 return new Writable(options);
4764 this._writableState = new WritableState(options, this);
4767 this.writable = true;
4770 if (typeof options.write === 'function') this._write = options.write;
4772 if (typeof options.writev === 'function') this._writev = options.writev;
4774 if (typeof options.destroy === 'function') this._destroy = options.destroy;
4776 if (typeof options.final === 'function') this._final = options.final;
4782 // Otherwise people can pipe Writable streams, which is just wrong.
4783 Writable.prototype.pipe = function () {
4784 this.emit('error', new Error('Cannot pipe, not readable'));
4787 function writeAfterEnd(stream, cb) {
4788 var er = new Error('write after end');
4789 // TODO: defer error events consistently everywhere, not just the cb
4790 stream.emit('error', er);
4791 processNextTick(cb, er);
4794 // Checks that a user-supplied chunk is valid, especially for the particular
4795 // mode the stream is in. Currently this means that `null` is never accepted
4796 // and undefined/non-string values are only allowed in object mode.
4797 function validChunk(stream, state, chunk, cb) {
4801 if (chunk === null) {
4802 er = new TypeError('May not write null values to stream');
4803 } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
4804 er = new TypeError('Invalid non-string/buffer chunk');
4807 stream.emit('error', er);
4808 processNextTick(cb, er);
4814 Writable.prototype.write = function (chunk, encoding, cb) {
4815 var state = this._writableState;
4817 var isBuf = _isUint8Array(chunk) && !state.objectMode;
4819 if (isBuf && !Buffer.isBuffer(chunk)) {
4820 chunk = _uint8ArrayToBuffer(chunk);
4823 if (typeof encoding === 'function') {
4828 if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
4830 if (typeof cb !== 'function') cb = nop;
4832 if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
4834 ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
4840 Writable.prototype.cork = function () {
4841 var state = this._writableState;
4846 Writable.prototype.uncork = function () {
4847 var state = this._writableState;
4852 if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
4856 Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
4857 // node::ParseEncoding() requires lower case.
4858 if (typeof encoding === 'string') encoding = encoding.toLowerCase();
4859 if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
4860 this._writableState.defaultEncoding = encoding;
4864 function decodeChunk(state, chunk, encoding) {
4865 if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
4866 chunk = Buffer.from(chunk, encoding);
4871 // if we're already writing something, then just put this
4872 // in the queue, and wait our turn. Otherwise, call _write
4873 // If we return false, then we need a drain event, so set that flag.
4874 function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
4876 var newChunk = decodeChunk(state, chunk, encoding);
4877 if (chunk !== newChunk) {
4879 encoding = 'buffer';
4883 var len = state.objectMode ? 1 : chunk.length;
4885 state.length += len;
4887 var ret = state.length < state.highWaterMark;
4888 // we must ensure that previous needDrain will not be reset to false.
4889 if (!ret) state.needDrain = true;
4891 if (state.writing || state.corked) {
4892 var last = state.lastBufferedRequest;
4893 state.lastBufferedRequest = {
4901 last.next = state.lastBufferedRequest;
4903 state.bufferedRequest = state.lastBufferedRequest;
4905 state.bufferedRequestCount += 1;
4907 doWrite(stream, state, false, len, chunk, encoding, cb);
4913 function doWrite(stream, state, writev, len, chunk, encoding, cb) {
4914 state.writelen = len;
4916 state.writing = true;
4918 if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
4922 function onwriteError(stream, state, sync, er, cb) {
4926 // defer the callback if we are being called synchronously
4927 // to avoid piling up things on the stack
4928 processNextTick(cb, er);
4929 // this can emit finish, and it will always happen
4931 processNextTick(finishMaybe, stream, state);
4932 stream._writableState.errorEmitted = true;
4933 stream.emit('error', er);
4935 // the caller expect this to happen before if
4938 stream._writableState.errorEmitted = true;
4939 stream.emit('error', er);
4940 // this can emit finish, but finish must
4941 // always follow error
4942 finishMaybe(stream, state);
4946 function onwriteStateUpdate(state) {
4947 state.writing = false;
4948 state.writecb = null;
4949 state.length -= state.writelen;
4953 function onwrite(stream, er) {
4954 var state = stream._writableState;
4955 var sync = state.sync;
4956 var cb = state.writecb;
4958 onwriteStateUpdate(state);
4960 if (er) onwriteError(stream, state, sync, er, cb);else {
4961 // Check if we're actually ready to finish, but don't emit yet
4962 var finished = needFinish(state);
4964 if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
4965 clearBuffer(stream, state);
4970 asyncWrite(afterWrite
, stream
, state
, finished
, cb
);
4973 afterWrite(stream, state, finished, cb);
4978 function afterWrite(stream, state, finished, cb) {
4979 if (!finished) onwriteDrain(stream, state);
4982 finishMaybe(stream, state);
4985 // Must force callback to be called on nextTick, so that we don't
4986 // emit 'drain' before the write() consumer gets the 'false' return
4987 // value, and has a chance to attach a 'drain' listener.
4988 function onwriteDrain(stream, state) {
4989 if (state.length === 0 && state.needDrain) {
4990 state.needDrain = false;
4991 stream.emit('drain');
4995 // if there's something in the buffer waiting, then process it
4996 function clearBuffer(stream, state) {
4997 state.bufferProcessing = true;
4998 var entry = state.bufferedRequest;
5000 if (stream._writev && entry && entry.next) {
5001 // Fast case, write everything using _writev()
5002 var l = state.bufferedRequestCount;
5003 var buffer = new Array(l);
5004 var holder = state.corkedRequestsFree;
5005 holder.entry = entry;
5008 var allBuffers = true;
5010 buffer[count] = entry;
5011 if (!entry.isBuf) allBuffers = false;
5015 buffer.allBuffers = allBuffers;
5017 doWrite(stream, state, true, state.length, buffer, '', holder.finish);
5019 // doWrite is almost always async, defer these to save a bit of time
5020 // as the hot path ends with doWrite
5022 state.lastBufferedRequest = null;
5024 state.corkedRequestsFree = holder.next;
5027 state.corkedRequestsFree = new CorkedRequest(state);
5030 // Slow case, write chunks one-by-one
5032 var chunk = entry.chunk;
5033 var encoding = entry.encoding;
5034 var cb = entry.callback;
5035 var len = state.objectMode ? 1 : chunk.length;
5037 doWrite(stream, state, false, len, chunk, encoding, cb);
5039 // if we didn't call the onwrite immediately, then
5040 // it means that we need to wait until it does.
5041 // also, that means that the chunk and cb are currently
5042 // being processed, so move the buffer counter past them.
5043 if (state.writing) {
5048 if (entry === null) state.lastBufferedRequest = null;
5051 state.bufferedRequestCount = 0;
5052 state.bufferedRequest = entry;
5053 state.bufferProcessing = false;
5056 Writable.prototype._write = function (chunk, encoding, cb) {
5057 cb(new Error('_write() is not implemented'));
5060 Writable.prototype._writev = null;
5062 Writable.prototype.end = function (chunk, encoding, cb) {
5063 var state = this._writableState;
5065 if (typeof chunk === 'function') {
5069 } else if (typeof encoding === 'function') {
5074 if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
5076 // .end() fully uncorks
5082 // ignore unnecessary end() calls.
5083 if (!state.ending && !state.finished) endWritable(this, state, cb);
5086 function needFinish(state) {
5087 return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
5089 function callFinal(stream, state) {
5090 stream._final(function (err) {
5093 stream.emit('error', err);
5095 state.prefinished = true;
5096 stream.emit('prefinish');
5097 finishMaybe(stream, state);
5100 function prefinish(stream, state) {
5101 if (!state.prefinished && !state.finalCalled) {
5102 if (typeof stream._final === 'function') {
5104 state.finalCalled = true;
5105 processNextTick(callFinal, stream, state);
5107 state.prefinished = true;
5108 stream.emit('prefinish');
5113 function finishMaybe(stream, state) {
5114 var need = needFinish(state);
5116 prefinish(stream, state);
5117 if (state.pendingcb === 0) {
5118 state.finished = true;
5119 stream.emit('finish');
5125 function endWritable(stream, state, cb) {
5126 state.ending = true;
5127 finishMaybe(stream, state);
5129 if (state.finished) processNextTick(cb);else stream.once('finish', cb);
5132 stream.writable = false;
5135 function onCorkedFinish(corkReq, state, err) {
5136 var entry = corkReq.entry;
5137 corkReq.entry = null;
5139 var cb = entry.callback;
5144 if (state.corkedRequestsFree) {
5145 state.corkedRequestsFree.next = corkReq;
5147 state.corkedRequestsFree = corkReq;
5151 Object.defineProperty(Writable.prototype, 'destroyed', {
5153 if (this._writableState === undefined) {
5156 return this._writableState.destroyed;
5158 set: function (value) {
5159 // we ignore the value if the stream
5160 // has not been initialized yet
5161 if (!this._writableState) {
5165 // backward compatibility, the user is explicitly
5166 // managing destroyed
5167 this._writableState.destroyed = value;
5171 Writable.prototype.destroy = destroyImpl.destroy;
5172 Writable.prototype._undestroy = destroyImpl.undestroy;
5173 Writable.prototype._destroy = function (err, cb) {
5177 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
5178 },{"./_stream_duplex":14,"./internal/streams/destroy":20,"./internal/streams/stream":21,"_process":12,"core-util-is":5,"inherits":8,"process-nextick-args":11,"safe-buffer":26,"util-deprecate":29}],19:[function(require,module,exports){
5183 function _classCallCheck(instance
, Constructor
) { if (!(instance
instanceof Constructor
)) { throw new TypeError("Cannot call a class as a function"); } }
5185 var Buffer
= require('safe-buffer').Buffer
;
5188 function copyBuffer(src, target, offset) {
5189 src.copy(target, offset);
5192 module.exports = function () {
5193 function BufferList() {
5194 _classCallCheck(this, BufferList);
5201 BufferList.prototype.push = function push(v) {
5202 var entry = { data: v, next: null };
5203 if (this.length > 0) this.tail.next = entry;else this.head = entry;
5208 BufferList.prototype.unshift = function unshift(v) {
5209 var entry = { data: v, next: this.head };
5210 if (this.length === 0) this.tail = entry;
5215 BufferList.prototype.shift = function shift() {
5216 if (this.length === 0) return;
5217 var ret = this.head.data;
5218 if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
5223 BufferList.prototype.clear = function clear() {
5224 this.head = this.tail = null;
5228 BufferList.prototype.join = function join(s) {
5229 if (this.length === 0) return '';
5231 var ret = '' + p.data;
5232 while (p = p.next) {
5237 BufferList.prototype.concat = function concat(n) {
5238 if (this.length === 0) return Buffer.alloc(0);
5239 if (this.length === 1) return this.head.data;
5240 var ret = Buffer.allocUnsafe(n >>> 0);
5244 copyBuffer(p.data, ret, i);
5253 },{"safe-buffer":26}],20:[function(require,module,exports){
5258 var processNextTick
= require('process-nextick-args');
5261 // undocumented cb() API, needed for core, not for public API
5262 function destroy(err, cb) {
5265 var readableDestroyed = this._readableState && this._readableState.destroyed;
5266 var writableDestroyed = this._writableState && this._writableState.destroyed;
5268 if (readableDestroyed || writableDestroyed) {
5271 } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
5272 processNextTick(emitErrorNT, this, err);
5277 // we set destroyed to true before firing error callbacks in order
5278 // to make it re-entrance safe in case destroy() is called within callbacks
5280 if (this._readableState) {
5281 this._readableState.destroyed = true;
5284 // if this is a duplex stream mark the writable part as destroyed as well
5285 if (this._writableState) {
5286 this._writableState.destroyed = true;
5289 this._destroy(err || null, function (err) {
5291 processNextTick(emitErrorNT, _this, err);
5292 if (_this._writableState) {
5293 _this._writableState.errorEmitted = true;
5301 function undestroy() {
5302 if (this._readableState) {
5303 this._readableState.destroyed = false;
5304 this._readableState.reading = false;
5305 this._readableState.ended = false;
5306 this._readableState.endEmitted = false;
5309 if (this._writableState) {
5310 this._writableState.destroyed = false;
5311 this._writableState.ended = false;
5312 this._writableState.ending = false;
5313 this._writableState.finished = false;
5314 this._writableState.errorEmitted = false;
5318 function emitErrorNT(self, err) {
5319 self.emit('error', err);
5324 undestroy: undestroy
5326 },{"process-nextick-args":11}],21:[function(require,module,exports){
5327 module.exports = require('events').EventEmitter;
5329 },{"events":6}],22:[function(require,module,exports){
5330 module.exports = require('./readable').PassThrough
5332 },{"./readable":23}],23:[function(require,module,exports){
5333 exports = module.exports = require('./lib/_stream_readable.js');
5334 exports.Stream = exports;
5335 exports.Readable = exports;
5336 exports.Writable = require('./lib/_stream_writable.js');
5337 exports.Duplex = require('./lib/_stream_duplex.js');
5338 exports.Transform = require('./lib/_stream_transform.js');
5339 exports.PassThrough = require('./lib/_stream_passthrough.js');
5341 },{"./lib/_stream_duplex.js":14,"./lib/_stream_passthrough.js":15,"./lib/_stream_readable.js":16,"./lib/_stream_transform.js":17,"./lib/_stream_writable.js":18}],24:[function(require,module,exports){
5342 module.exports = require('./readable').Transform
5344 },{"./readable":23}],25:[function(require,module,exports){
5345 module.exports = require('./lib/_stream_writable.js');
5347 },{"./lib/_stream_writable.js":18}],26:[function(require,module,exports){
5348 /* eslint-disable node/no-deprecated-api */
5349 var buffer
= require('buffer')
5350 var Buffer
= buffer
.Buffer
5352 // alternative to using Object.keys for old browsers
5353 function copyProps (src
, dst
) {
5354 for (var key
in src
) {
5358 if (Buffer
.from && Buffer
.alloc
&& Buffer
.allocUnsafe
&& Buffer
.allocUnsafeSlow
) {
5359 module
.exports
= buffer
5361 // Copy properties from require('buffer')
5362 copyProps(buffer
, exports
)
5363 exports
.Buffer
= SafeBuffer
5366 function SafeBuffer (arg
, encodingOrOffset
, length
) {
5367 return Buffer(arg
, encodingOrOffset
, length
)
5370 // Copy static methods from Buffer
5371 copyProps(Buffer
, SafeBuffer
)
5373 SafeBuffer
.from = function (arg
, encodingOrOffset
, length
) {
5374 if (typeof arg
=== 'number') {
5375 throw new TypeError('Argument must not be a number')
5377 return Buffer(arg
, encodingOrOffset
, length
)
5380 SafeBuffer
.alloc = function (size
, fill
, encoding
) {
5381 if (typeof size
!== 'number') {
5382 throw new TypeError('Argument must be a number')
5384 var buf
= Buffer(size
)
5385 if (fill
!== undefined) {
5386 if (typeof encoding
=== 'string') {
5387 buf
.fill(fill
, encoding
)
5397 SafeBuffer
.allocUnsafe = function (size
) {
5398 if (typeof size
!== 'number') {
5399 throw new TypeError('Argument must be a number')
5404 SafeBuffer
.allocUnsafeSlow = function (size
) {
5405 if (typeof size
!== 'number') {
5406 throw new TypeError('Argument must be a number')
5408 return buffer
.SlowBuffer(size
)
5411 },{"buffer":4}],27:[function(require
,module
,exports
){
5412 // Copyright Joyent, Inc. and other Node contributors.
5414 // Permission is hereby granted, free of charge, to any person obtaining a
5415 // copy of this software and associated documentation files (the
5416 // "Software"), to deal in the Software without restriction, including
5417 // without limitation the rights to use, copy, modify, merge, publish,
5418 // distribute, sublicense, and/or sell copies of the Software, and to permit
5419 // persons to whom the Software is furnished to do so, subject to the
5420 // following conditions:
5422 // The above copyright notice and this permission notice shall be included
5423 // in all copies or substantial portions of the Software.
5425 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
5426 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
5427 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
5428 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
5429 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
5430 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
5431 // USE OR OTHER DEALINGS IN THE SOFTWARE.
5433 module
.exports
= Stream
;
5435 var EE
= require('events').EventEmitter
;
5436 var inherits
= require('inherits');
5438 inherits(Stream
, EE
);
5439 Stream
.Readable
= require('readable-stream/readable.js');
5440 Stream
.Writable
= require('readable-stream/writable.js');
5441 Stream
.Duplex
= require('readable-stream/duplex.js');
5442 Stream
.Transform
= require('readable-stream/transform.js');
5443 Stream
.PassThrough
= require('readable-stream/passthrough.js');
5445 // Backwards-compat with node 0.4.x
5446 Stream
.Stream
= Stream
;
5450 // old-style streams. Note that the pipe method (the only relevant
5451 // part of this class) is overridden in the Readable class.
5457 Stream
.prototype.pipe = function(dest
, options
) {
5460 function ondata(chunk
) {
5461 if (dest
.writable
) {
5462 if (false === dest
.write(chunk
) && source
.pause
) {
5468 source
.on('data', ondata
);
5470 function ondrain() {
5471 if (source
.readable
&& source
.resume
) {
5476 dest
.on('drain', ondrain
);
5478 // If the 'end' option is not supplied, dest.end() will be called when
5479 // source gets the 'end' or 'close' events. Only dest.end() once.
5480 if (!dest
._isStdio
&& (!options
|| options
.end
!== false)) {
5481 source
.on('end', onend
);
5482 source
.on('close', onclose
);
5485 var didOnEnd
= false;
5487 if (didOnEnd
) return;
5494 function onclose() {
5495 if (didOnEnd
) return;
5498 if (typeof dest
.destroy
=== 'function') dest
.destroy();
5501 // don't leave dangling pipes when there are errors.
5502 function onerror(er
) {
5504 if (EE
.listenerCount(this, 'error') === 0) {
5505 throw er
; // Unhandled stream error in pipe.
5509 source
.on('error', onerror
);
5510 dest
.on('error', onerror
);
5512 // remove all the event listeners that were added.
5513 function cleanup() {
5514 source
.removeListener('data', ondata
);
5515 dest
.removeListener('drain', ondrain
);
5517 source
.removeListener('end', onend
);
5518 source
.removeListener('close', onclose
);
5520 source
.removeListener('error', onerror
);
5521 dest
.removeListener('error', onerror
);
5523 source
.removeListener('end', cleanup
);
5524 source
.removeListener('close', cleanup
);
5526 dest
.removeListener('close', cleanup
);
5529 source
.on('end', cleanup
);
5530 source
.on('close', cleanup
);
5532 dest
.on('close', cleanup
);
5534 dest
.emit('pipe', source
);
5536 // Allow for unix-like usage: A.pipe(B).pipe(C)
5540 },{"events":6,"inherits":8,"readable-stream/duplex.js":13,"readable-stream/passthrough.js":22,"readable-stream/readable.js":23,"readable-stream/transform.js":24,"readable-stream/writable.js":25}],28:[function(require
,module
,exports
){
5543 var Buffer
= require('safe-buffer').Buffer
;
5545 var isEncoding
= Buffer
.isEncoding
|| function (encoding
) {
5546 encoding
= '' + encoding
;
5547 switch (encoding
&& encoding
.toLowerCase()) {
5548 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':
5555 function _normalizeEncoding(enc
) {
5556 if (!enc
) return 'utf8';
5576 if (retried
) return; // undefined
5577 enc
= ('' + enc
).toLowerCase();
5583 // Do not cache `Buffer.isEncoding` when checking encoding names as some
5584 // modules monkey-patch it to support additional encodings
5585 function normalizeEncoding(enc
) {
5586 var nenc
= _normalizeEncoding(enc
);
5587 if (typeof nenc
!== 'string' && (Buffer
.isEncoding
=== isEncoding
|| !isEncoding(enc
))) throw new Error('Unknown encoding: ' + enc
);
5591 // StringDecoder provides an interface for efficiently splitting a series of
5592 // buffers into a series of JS strings without breaking apart multi-byte
5594 exports
.StringDecoder
= StringDecoder
;
5595 function StringDecoder(encoding
) {
5596 this.encoding
= normalizeEncoding(encoding
);
5598 switch (this.encoding
) {
5600 this.text
= utf16Text
;
5601 this.end
= utf16End
;
5605 this.fillLast
= utf8FillLast
;
5609 this.text
= base64Text
;
5610 this.end
= base64End
;
5614 this.write
= simpleWrite
;
5615 this.end
= simpleEnd
;
5620 this.lastChar
= Buffer
.allocUnsafe(nb
);
5623 StringDecoder
.prototype.write = function (buf
) {
5624 if (buf
.length
=== 0) return '';
5627 if (this.lastNeed
) {
5628 r
= this.fillLast(buf
);
5629 if (r
=== undefined) return '';
5635 if (i
< buf
.length
) return r
? r
+ this.text(buf
, i
) : this.text(buf
, i
);
5639 StringDecoder
.prototype.end
= utf8End
;
5641 // Returns only complete characters in a Buffer
5642 StringDecoder
.prototype.text
= utf8Text
;
5644 // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
5645 StringDecoder
.prototype.fillLast = function (buf
) {
5646 if (this.lastNeed
<= buf
.length
) {
5647 buf
.copy(this.lastChar
, this.lastTotal
- this.lastNeed
, 0, this.lastNeed
);
5648 return this.lastChar
.toString(this.encoding
, 0, this.lastTotal
);
5650 buf
.copy(this.lastChar
, this.lastTotal
- this.lastNeed
, 0, buf
.length
);
5651 this.lastNeed
-= buf
.length
;
5654 // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
5655 // continuation byte.
5656 function utf8CheckByte(byte) {
5657 if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
5661 // Checks at most 3 bytes at the end of a Buffer in order to detect an
5662 // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
5663 // needed to complete the UTF-8 character (if applicable) are returned.
5664 function utf8CheckIncomplete(self
, buf
, i
) {
5665 var j
= buf
.length
- 1;
5666 if (j
< i
) return 0;
5667 var nb
= utf8CheckByte(buf
[j
]);
5669 if (nb
> 0) self
.lastNeed
= nb
- 1;
5672 if (--j
< i
) return 0;
5673 nb
= utf8CheckByte(buf
[j
]);
5675 if (nb
> 0) self
.lastNeed
= nb
- 2;
5678 if (--j
< i
) return 0;
5679 nb
= utf8CheckByte(buf
[j
]);
5682 if (nb
=== 2) nb
= 0;else self
.lastNeed
= nb
- 3;
5689 // Validates as many continuation bytes for a multi-byte UTF-8 character as
5690 // needed or are available. If we see a non-continuation byte where we expect
5691 // one, we "replace" the validated continuation bytes we've seen so far with
5692 // UTF-8 replacement characters ('\ufffd'), to match v8's UTF-8 decoding
5693 // behavior. The continuation byte check is included three times in the case
5694 // where all of the continuation bytes for a character exist in the same buffer.
5695 // It is also done this way as a slight performance increase instead of using a
5697 function utf8CheckExtraBytes(self
, buf
, p
) {
5698 if ((buf
[0] & 0xC0) !== 0x80) {
5700 return '\ufffd'.repeat(p
);
5702 if (self
.lastNeed
> 1 && buf
.length
> 1) {
5703 if ((buf
[1] & 0xC0) !== 0x80) {
5705 return '\ufffd'.repeat(p
+ 1);
5707 if (self
.lastNeed
> 2 && buf
.length
> 2) {
5708 if ((buf
[2] & 0xC0) !== 0x80) {
5710 return '\ufffd'.repeat(p
+ 2);
5716 // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
5717 function utf8FillLast(buf
) {
5718 var p
= this.lastTotal
- this.lastNeed
;
5719 var r
= utf8CheckExtraBytes(this, buf
, p
);
5720 if (r
!== undefined) return r
;
5721 if (this.lastNeed
<= buf
.length
) {
5722 buf
.copy(this.lastChar
, p
, 0, this.lastNeed
);
5723 return this.lastChar
.toString(this.encoding
, 0, this.lastTotal
);
5725 buf
.copy(this.lastChar
, p
, 0, buf
.length
);
5726 this.lastNeed
-= buf
.length
;
5729 // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
5730 // partial character, the character's bytes are buffered until the required
5731 // number of bytes are available.
5732 function utf8Text(buf
, i
) {
5733 var total
= utf8CheckIncomplete(this, buf
, i
);
5734 if (!this.lastNeed
) return buf
.toString('utf8', i
);
5735 this.lastTotal
= total
;
5736 var end
= buf
.length
- (total
- this.lastNeed
);
5737 buf
.copy(this.lastChar
, 0, end
);
5738 return buf
.toString('utf8', i
, end
);
5741 // For UTF-8, a replacement character for each buffered byte of a (partial)
5742 // character needs to be added to the output.
5743 function utf8End(buf
) {
5744 var r
= buf
&& buf
.length
? this.write(buf
) : '';
5745 if (this.lastNeed
) return r
+ '\ufffd'.repeat(this.lastTotal
- this.lastNeed
);
5749 // UTF-16LE typically needs two bytes per character, but even if we have an even
5750 // number of bytes available, we need to check if we end on a leading/high
5751 // surrogate. In that case, we need to wait for the next two bytes in order to
5752 // decode the last character properly.
5753 function utf16Text(buf
, i
) {
5754 if ((buf
.length
- i
) % 2 === 0) {
5755 var r
= buf
.toString('utf16le', i
);
5757 var c
= r
.charCodeAt(r
.length
- 1);
5758 if (c
>= 0xD800 && c
<= 0xDBFF) {
5761 this.lastChar
[0] = buf
[buf
.length
- 2];
5762 this.lastChar
[1] = buf
[buf
.length
- 1];
5763 return r
.slice(0, -1);
5770 this.lastChar
[0] = buf
[buf
.length
- 1];
5771 return buf
.toString('utf16le', i
, buf
.length
- 1);
5774 // For UTF-16LE we do not explicitly append special replacement characters if we
5775 // end on a partial character, we simply let v8 handle that.
5776 function utf16End(buf
) {
5777 var r
= buf
&& buf
.length
? this.write(buf
) : '';
5778 if (this.lastNeed
) {
5779 var end
= this.lastTotal
- this.lastNeed
;
5780 return r
+ this.lastChar
.toString('utf16le', 0, end
);
5785 function base64Text(buf
, i
) {
5786 var n
= (buf
.length
- i
) % 3;
5787 if (n
=== 0) return buf
.toString('base64', i
);
5788 this.lastNeed
= 3 - n
;
5791 this.lastChar
[0] = buf
[buf
.length
- 1];
5793 this.lastChar
[0] = buf
[buf
.length
- 2];
5794 this.lastChar
[1] = buf
[buf
.length
- 1];
5796 return buf
.toString('base64', i
, buf
.length
- n
);
5799 function base64End(buf
) {
5800 var r
= buf
&& buf
.length
? this.write(buf
) : '';
5801 if (this.lastNeed
) return r
+ this.lastChar
.toString('base64', 0, 3 - this.lastNeed
);
5805 // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
5806 function simpleWrite(buf
) {
5807 return buf
.toString(this.encoding
);
5810 function simpleEnd(buf
) {
5811 return buf
&& buf
.length
? this.write(buf
) : '';
5813 },{"safe-buffer":26}],29:[function(require
,module
,exports
){
5820 module
.exports
= deprecate
;
5823 * Mark that a method should not be used.
5824 * Returns a modified function which warns once by default.
5826 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
5828 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
5829 * will throw an Error when invoked.
5831 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
5832 * will invoke `console.trace()` instead of `console.error()`.
5834 * @param {Function} fn - the function to deprecate
5835 * @param {String} msg - the string to print to the console when `fn` is invoked
5836 * @returns {Function} a new "deprecated" version of `fn`
5840 function deprecate (fn
, msg
) {
5841 if (config('noDeprecation')) {
5846 function deprecated() {
5848 if (config('throwDeprecation')) {
5849 throw new Error(msg
);
5850 } else if (config('traceDeprecation')) {
5857 return fn
.apply(this, arguments
);
5864 * Checks `localStorage` for boolean values for the given `name`.
5866 * @param {String} name
5867 * @returns {Boolean}
5871 function config (name
) {
5872 // accessing global.localStorage can trigger a DOMException in sandboxed iframes
5874 if (!global
.localStorage
) return false;
5878 var val
= global
.localStorage
[name
];
5879 if (null == val
) return false;
5880 return String(val
).toLowerCase() === 'true';
5883 }).call(this,typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
5884 },{}],30:[function(require
,module
,exports
){
5885 arguments
[4][8][0].apply(exports
,arguments
)
5886 },{"dup":8}],31:[function(require
,module
,exports
){
5887 module
.exports
= function isBuffer(arg
) {
5888 return arg
&& typeof arg
=== 'object'
5889 && typeof arg
.copy
=== 'function'
5890 && typeof arg
.fill
=== 'function'
5891 && typeof arg
.readUInt8
=== 'function';
5893 },{}],32:[function(require
,module
,exports
){
5894 (function (process
,global
){
5895 // Copyright Joyent, Inc. and other Node contributors.
5897 // Permission is hereby granted, free of charge, to any person obtaining a
5898 // copy of this software and associated documentation files (the
5899 // "Software"), to deal in the Software without restriction, including
5900 // without limitation the rights to use, copy, modify, merge, publish,
5901 // distribute, sublicense, and/or sell copies of the Software, and to permit
5902 // persons to whom the Software is furnished to do so, subject to the
5903 // following conditions:
5905 // The above copyright notice and this permission notice shall be included
5906 // in all copies or substantial portions of the Software.
5908 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
5909 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
5910 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
5911 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
5912 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
5913 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
5914 // USE OR OTHER DEALINGS IN THE SOFTWARE.
5916 var formatRegExp
= /%[sdj%]/g;
5917 exports
.format = function(f
) {
5920 for (var i
= 0; i
< arguments
.length
; i
++) {
5921 objects
.push(inspect(arguments
[i
]));
5923 return objects
.join(' ');
5927 var args
= arguments
;
5928 var len
= args
.length
;
5929 var str
= String(f
).replace(formatRegExp
, function(x
) {
5930 if (x
=== '%%') return '%';
5931 if (i
>= len
) return x
;
5933 case '%s': return String(args
[i
++]);
5934 case '%d': return Number(args
[i
++]);
5937 return JSON
.stringify(args
[i
++]);
5939 return '[Circular]';
5945 for (var x
= args
[i
]; i
< len
; x
= args
[++i
]) {
5946 if (isNull(x
) || !isObject(x
)) {
5949 str
+= ' ' + inspect(x
);
5956 // Mark that a method should not be used.
5957 // Returns a modified function which warns once by default.
5958 // If --no-deprecation is set, then it is a no-op.
5959 exports
.deprecate = function(fn
, msg
) {
5960 // Allow for deprecating things in the process of starting up.
5961 if (isUndefined(global
.process
)) {
5963 return exports
.deprecate(fn
, msg
).apply(this, arguments
);
5967 if (process
.noDeprecation
=== true) {
5972 function deprecated() {
5974 if (process
.throwDeprecation
) {
5975 throw new Error(msg
);
5976 } else if (process
.traceDeprecation
) {
5983 return fn
.apply(this, arguments
);
5992 exports
.debuglog = function(set) {
5993 if (isUndefined(debugEnviron
))
5994 debugEnviron
= process
.env
.NODE_DEBUG
|| '';
5995 set = set.toUpperCase();
5997 if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron
)) {
5998 var pid
= process
.pid
;
5999 debugs
[set] = function() {
6000 var msg
= exports
.format
.apply(exports
, arguments
);
6001 console
.error('%s %d: %s', set, pid
, msg
);
6004 debugs
[set] = function() {};
6012 * Echos the value of a value. Trys to print the value out
6013 * in the best way possible given the different types.
6015 * @param {Object} obj The object to print out.
6016 * @param {Object} opts Optional options object that alters the output.
6018 /* legacy: obj, showHidden, depth, colors*/
6019 function inspect(obj
, opts
) {
6023 stylize: stylizeNoColor
6026 if (arguments
.length
>= 3) ctx
.depth
= arguments
[2];
6027 if (arguments
.length
>= 4) ctx
.colors
= arguments
[3];
6028 if (isBoolean(opts
)) {
6030 ctx
.showHidden
= opts
;
6032 // got an "options" object
6033 exports
._extend(ctx
, opts
);
6035 // set default options
6036 if (isUndefined(ctx
.showHidden
)) ctx
.showHidden
= false;
6037 if (isUndefined(ctx
.depth
)) ctx
.depth
= 2;
6038 if (isUndefined(ctx
.colors
)) ctx
.colors
= false;
6039 if (isUndefined(ctx
.customInspect
)) ctx
.customInspect
= true;
6040 if (ctx
.colors
) ctx
.stylize
= stylizeWithColor
;
6041 return formatValue(ctx
, obj
, ctx
.depth
);
6043 exports
.inspect
= inspect
;
6046 // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
6050 'underline' : [4, 24],
6051 'inverse' : [7, 27],
6058 'magenta' : [35, 39],
6063 // Don't use 'blue' not visible on cmd.exe
6067 'boolean': 'yellow',
6068 'undefined': 'grey',
6072 // "name": intentionally not styling
6077 function stylizeWithColor(str
, styleType
) {
6078 var style
= inspect
.styles
[styleType
];
6081 return '\u001b[' + inspect
.colors
[style
][0] + 'm' + str
+
6082 '\u001b[' + inspect
.colors
[style
][1] + 'm';
6089 function stylizeNoColor(str
, styleType
) {
6094 function arrayToHash(array
) {
6097 array
.forEach(function(val
, idx
) {
6105 function formatValue(ctx
, value
, recurseTimes
) {
6106 // Provide a hook for user-specified inspect functions.
6107 // Check that value is an object with an inspect function on it
6108 if (ctx
.customInspect
&&
6110 isFunction(value
.inspect
) &&
6111 // Filter out the util module, it's inspect function is special
6112 value
.inspect
!== exports
.inspect
&&
6113 // Also filter out any prototype objects using the circular check.
6114 !(value
.constructor && value
.constructor.prototype === value
)) {
6115 var ret
= value
.inspect(recurseTimes
, ctx
);
6116 if (!isString(ret
)) {
6117 ret
= formatValue(ctx
, ret
, recurseTimes
);
6122 // Primitive types cannot have properties
6123 var primitive
= formatPrimitive(ctx
, value
);
6128 // Look up the keys of the object.
6129 var keys
= Object
.keys(value
);
6130 var visibleKeys
= arrayToHash(keys
);
6132 if (ctx
.showHidden
) {
6133 keys
= Object
.getOwnPropertyNames(value
);
6136 // IE doesn't make error fields non-enumerable
6137 // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
6139 && (keys
.indexOf('message') >= 0 || keys
.indexOf('description') >= 0)) {
6140 return formatError(value
);
6143 // Some type of object without properties can be shortcutted.
6144 if (keys
.length
=== 0) {
6145 if (isFunction(value
)) {
6146 var name
= value
.name
? ': ' + value
.name : '';
6147 return ctx
.stylize('[Function' + name
+ ']', 'special');
6149 if (isRegExp(value
)) {
6150 return ctx
.stylize(RegExp
.prototype.toString
.call(value
), 'regexp');
6152 if (isDate(value
)) {
6153 return ctx
.stylize(Date
.prototype.toString
.call(value
), 'date');
6155 if (isError(value
)) {
6156 return formatError(value
);
6160 var base
= '', array
= false, braces
= ['{', '}'];
6162 // Make Array say that they are Array
6163 if (isArray(value
)) {
6165 braces
= ['[', ']'];
6168 // Make functions say that they are functions
6169 if (isFunction(value
)) {
6170 var n
= value
.name
? ': ' + value
.name : '';
6171 base
= ' [Function' + n
+ ']';
6174 // Make RegExps say that they are RegExps
6175 if (isRegExp(value
)) {
6176 base
= ' ' + RegExp
.prototype.toString
.call(value
);
6179 // Make dates with properties first say the date
6180 if (isDate(value
)) {
6181 base
= ' ' + Date
.prototype.toUTCString
.call(value
);
6184 // Make error with message first say the error
6185 if (isError(value
)) {
6186 base
= ' ' + formatError(value
);
6189 if (keys
.length
=== 0 && (!array
|| value
.length
== 0)) {
6190 return braces
[0] + base
+ braces
[1];
6193 if (recurseTimes
< 0) {
6194 if (isRegExp(value
)) {
6195 return ctx
.stylize(RegExp
.prototype.toString
.call(value
), 'regexp');
6197 return ctx
.stylize('[Object]', 'special');
6201 ctx
.seen
.push(value
);
6205 output
= formatArray(ctx
, value
, recurseTimes
, visibleKeys
, keys
);
6207 output
= keys
.map(function(key
) {
6208 return formatProperty(ctx
, value
, recurseTimes
, visibleKeys
, key
, array
);
6214 return reduceToSingleString(output
, base
, braces
);
6218 function formatPrimitive(ctx
, value
) {
6219 if (isUndefined(value
))
6220 return ctx
.stylize('undefined', 'undefined');
6221 if (isString(value
)) {
6222 var simple
= '\'' + JSON
.stringify(value
).replace(/^"|"$/g, '')
6223 .replace(/'/g, "\\'")
6224 .replace(/\\"/g
, '"') + '\'';
6225 return ctx
.stylize(simple
, 'string');
6227 if (isNumber(value
))
6228 return ctx
.stylize('' + value
, 'number');
6229 if (isBoolean(value
))
6230 return ctx
.stylize('' + value
, 'boolean');
6231 // For some reason typeof null is "object", so special case here.
6233 return ctx
.stylize('null', 'null');
6237 function formatError(value
) {
6238 return '[' + Error
.prototype.toString
.call(value
) + ']';
6242 function formatArray(ctx
, value
, recurseTimes
, visibleKeys
, keys
) {
6244 for (var i
= 0, l
= value
.length
; i
< l
; ++i
) {
6245 if (hasOwnProperty(value
, String(i
))) {
6246 output
.push(formatProperty(ctx
, value
, recurseTimes
, visibleKeys
,
6252 keys
.forEach(function(key
) {
6253 if (!key
.match(/^\d+$/)) {
6254 output
.push(formatProperty(ctx
, value
, recurseTimes
, visibleKeys
,
6262 function formatProperty(ctx
, value
, recurseTimes
, visibleKeys
, key
, array
) {
6263 var name
, str
, desc
;
6264 desc
= Object
.getOwnPropertyDescriptor(value
, key
) || { value: value
[key
] };
6267 str
= ctx
.stylize('[Getter/Setter]', 'special');
6269 str
= ctx
.stylize('[Getter]', 'special');
6273 str
= ctx
.stylize('[Setter]', 'special');
6276 if (!hasOwnProperty(visibleKeys
, key
)) {
6277 name
= '[' + key
+ ']';
6280 if (ctx
.seen
.indexOf(desc
.value
) < 0) {
6281 if (isNull(recurseTimes
)) {
6282 str
= formatValue(ctx
, desc
.value
, null);
6284 str
= formatValue(ctx
, desc
.value
, recurseTimes
- 1);
6286 if (str
.indexOf('\n') > -1) {
6288 str
= str
.split('\n').map(function(line
) {
6290 }).join('\n').substr(2);
6292 str
= '\n' + str
.split('\n').map(function(line
) {
6298 str
= ctx
.stylize('[Circular]', 'special');
6301 if (isUndefined(name
)) {
6302 if (array
&& key
.match(/^\d+$/)) {
6305 name
= JSON
.stringify('' + key
);
6306 if (name
.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
6307 name
= name
.substr(1, name
.length
- 2);
6308 name
= ctx
.stylize(name
, 'name');
6310 name
= name
.replace(/'/g, "\\'")
6311 .replace(/\\"/g
, '"')
6312 .replace(/(^"|"$)/g, "'");
6313 name
= ctx
.stylize(name
, 'string');
6317 return name
+ ': ' + str
;
6321 function reduceToSingleString(output
, base
, braces
) {
6322 var numLinesEst
= 0;
6323 var length
= output
.reduce(function(prev
, cur
) {
6325 if (cur
.indexOf('\n') >= 0) numLinesEst
++;
6326 return prev
+ cur
.replace(/\u001b\[\d\d?m/g, '').length
+ 1;
6331 (base
=== '' ? '' : base
+ '\n ') +
6333 output
.join(',\n ') +
6338 return braces
[0] + base
+ ' ' + output
.join(', ') + ' ' + braces
[1];
6342 // NOTE: These type checking functions intentionally don't use `instanceof`
6343 // because it is fragile and can be easily faked with `Object.create()`.
6344 function isArray(ar
) {
6345 return Array
.isArray(ar
);
6347 exports
.isArray
= isArray
;
6349 function isBoolean(arg
) {
6350 return typeof arg
=== 'boolean';
6352 exports
.isBoolean
= isBoolean
;
6354 function isNull(arg
) {
6355 return arg
=== null;
6357 exports
.isNull
= isNull
;
6359 function isNullOrUndefined(arg
) {
6362 exports
.isNullOrUndefined
= isNullOrUndefined
;
6364 function isNumber(arg
) {
6365 return typeof arg
=== 'number';
6367 exports
.isNumber
= isNumber
;
6369 function isString(arg
) {
6370 return typeof arg
=== 'string';
6372 exports
.isString
= isString
;
6374 function isSymbol(arg
) {
6375 return typeof arg
=== 'symbol';
6377 exports
.isSymbol
= isSymbol
;
6379 function isUndefined(arg
) {
6380 return arg
=== void 0;
6382 exports
.isUndefined
= isUndefined
;
6384 function isRegExp(re
) {
6385 return isObject(re
) && objectToString(re
) === '[object RegExp]';
6387 exports
.isRegExp
= isRegExp
;
6389 function isObject(arg
) {
6390 return typeof arg
=== 'object' && arg
!== null;
6392 exports
.isObject
= isObject
;
6394 function isDate(d
) {
6395 return isObject(d
) && objectToString(d
) === '[object Date]';
6397 exports
.isDate
= isDate
;
6399 function isError(e
) {
6400 return isObject(e
) &&
6401 (objectToString(e
) === '[object Error]' || e
instanceof Error
);
6403 exports
.isError
= isError
;
6405 function isFunction(arg
) {
6406 return typeof arg
=== 'function';
6408 exports
.isFunction
= isFunction
;
6410 function isPrimitive(arg
) {
6411 return arg
=== null ||
6412 typeof arg
=== 'boolean' ||
6413 typeof arg
=== 'number' ||
6414 typeof arg
=== 'string' ||
6415 typeof arg
=== 'symbol' || // ES6 symbol
6416 typeof arg
=== 'undefined';
6418 exports
.isPrimitive
= isPrimitive
;
6420 exports
.isBuffer
= require('./support/isBuffer');
6422 function objectToString(o
) {
6423 return Object
.prototype.toString
.call(o
);
6428 return n
< 10 ? '0' + n
.toString(10) : n
.toString(10);
6432 var months
= ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
6433 'Oct', 'Nov', 'Dec'];
6436 function timestamp() {
6438 var time
= [pad(d
.getHours()),
6439 pad(d
.getMinutes()),
6440 pad(d
.getSeconds())].join(':');
6441 return [d
.getDate(), months
[d
.getMonth()], time
].join(' ');
6445 // log is just a thin wrapper to console.log that prepends a timestamp
6446 exports
.log = function() {
6447 console
.log('%s - %s', timestamp(), exports
.format
.apply(exports
, arguments
));
6452 * Inherit the prototype methods from one constructor into another.
6454 * The Function.prototype.inherits from lang.js rewritten as a standalone
6455 * function (not on Function.prototype). NOTE: If this file is to be loaded
6456 * during bootstrapping this function needs to be rewritten using some native
6457 * functions as prototype setup using normal JavaScript does not work as
6458 * expected during bootstrapping (see mirror.js in r114903).
6460 * @param {function} ctor Constructor function which needs to inherit the
6462 * @param {function} superCtor Constructor function to inherit prototype from.
6464 exports
.inherits
= require('inherits');
6466 exports
._extend = function(origin
, add
) {
6467 // Don't do anything if add isn't an object
6468 if (!add
|| !isObject(add
)) return origin
;
6470 var keys
= Object
.keys(add
);
6471 var i
= keys
.length
;
6473 origin
[keys
[i
]] = add
[keys
[i
]];
6478 function hasOwnProperty(obj
, prop
) {
6479 return Object
.prototype.hasOwnProperty
.call(obj
, prop
);
6482 }).call(this,require('_process'),typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
6483 },{"./support/isBuffer":31,"_process":12,"inherits":30}],33:[function(require
,module
,exports
){
6485 base58: require('bs58'),
6486 bitcoin: require('bitcoinjs-lib'),
6487 ecurve: require('ecurve'),
6488 BigInteger: require('bigi')
6491 },{"bigi":37,"bitcoinjs-lib":50,"bs58":79,"ecurve":89}],34:[function(require
,module
,exports
){
6493 // Forked from https://github.com/cryptocoinjs/bs58
6494 // Originally written by Mike Hearn for BitcoinJ
6495 // Copyright (c) 2011 Google Inc
6496 // Ported to JavaScript by Stefan Thomas
6497 // Merged Buffer refactorings from base58-native by Stephen Pair
6498 // Copyright (c) 2013 BitPay Inc
6500 var Buffer
= require('safe-buffer').Buffer
6502 module
.exports
= function base (ALPHABET
) {
6503 var ALPHABET_MAP
= {}
6504 var BASE
= ALPHABET
.length
6505 var LEADER
= ALPHABET
.charAt(0)
6507 // pre-compute lookup table
6508 for (var z
= 0; z
< ALPHABET
.length
; z
++) {
6509 var x
= ALPHABET
.charAt(z
)
6511 if (ALPHABET_MAP
[x
] !== undefined) throw new TypeError(x
+ ' is ambiguous')
6515 function encode (source
) {
6516 if (source
.length
=== 0) return ''
6519 for (var i
= 0; i
< source
.length
; ++i
) {
6520 for (var j
= 0, carry
= source
[i
]; j
< digits
.length
; ++j
) {
6521 carry
+= digits
[j
] << 8
6522 digits
[j
] = carry
% BASE
6523 carry
= (carry
/ BASE
) | 0
6527 digits
.push(carry
% BASE
)
6528 carry
= (carry
/ BASE
) | 0
6534 // deal with leading zeros
6535 for (var k
= 0; source
[k
] === 0 && k
< source
.length
- 1; ++k
) string
+= ALPHABET
[0]
6536 // convert digits to a string
6537 for (var q
= digits
.length
- 1; q
>= 0; --q
) string
+= ALPHABET
[digits
[q
]]
6542 function decodeUnsafe (string
) {
6543 if (string
.length
=== 0) return Buffer
.allocUnsafe(0)
6546 for (var i
= 0; i
< string
.length
; i
++) {
6547 var value
= ALPHABET_MAP
[string
[i
]]
6548 if (value
=== undefined) return
6550 for (var j
= 0, carry
= value
; j
< bytes
.length
; ++j
) {
6551 carry
+= bytes
[j
] * BASE
6552 bytes
[j
] = carry
& 0xff
6557 bytes
.push(carry
& 0xff)
6562 // deal with leading zeros
6563 for (var k
= 0; string
[k
] === LEADER
&& k
< string
.length
- 1; ++k
) {
6567 return Buffer
.from(bytes
.reverse())
6570 function decode (string
) {
6571 var buffer
= decodeUnsafe(string
)
6572 if (buffer
) return buffer
6574 throw new Error('Non-base' + BASE
+ ' character')
6579 decodeUnsafe: decodeUnsafe
,
6584 },{"safe-buffer":98}],35:[function(require
,module
,exports
){
6585 // (public) Constructor
6586 function BigInteger(a
, b
, c
) {
6587 if (!(this instanceof BigInteger
))
6588 return new BigInteger(a
, b
, c
)
6591 if ("number" == typeof a
) this.fromNumber(a
, b
, c
)
6592 else if (b
== null && "string" != typeof a
) this.fromString(a
, 256)
6593 else this.fromString(a
, b
)
6597 var proto
= BigInteger
.prototype
6599 // duck-typed isBigInteger
6600 proto
.__bigi
= require('../package.json').version
6601 BigInteger
.isBigInteger = function (obj
, check_ver
) {
6602 return obj
&& obj
.__bigi
&& (!check_ver
|| obj
.__bigi
=== proto
.__bigi
)
6608 // am: Compute w_j += (x*this_i), propagate carries,
6609 // c is initial carry, returns final carry.
6610 // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
6611 // We need to select the fastest one that works in this environment.
6613 // am1: use a single mult and divide to get the high bits,
6614 // max digit bits should be 26 because
6615 // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
6616 function am1(i
, x
, w
, j
, c
, n
) {
6618 var v
= x
* this[i
++] + w
[j
] + c
6619 c
= Math
.floor(v
/ 0x4000000)
6620 w
[j
++] = v
& 0x3ffffff
6624 // am2 avoids a big mult-and-extract completely.
6625 // Max digit bits should be <= 30 because we do bitwise ops
6626 // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
6627 function am2(i
, x
, w
, j
, c
, n
) {
6628 var xl
= x
& 0x7fff,
6631 var l
= this[i
] & 0x7fff
6632 var h
= this[i
++] >> 15
6633 var m
= xh
* l
+ h
* xl
6634 l
= xl
* l
+ ((m
& 0x7fff) << 15) + w
[j
] + (c
& 0x3fffffff)
6635 c
= (l
>>> 30) + (m
>>> 15) + xh
* h
+ (c
>>> 30)
6636 w
[j
++] = l
& 0x3fffffff
6640 // Alternately, set max digit bits to 28 since some
6641 // browsers slow down when dealing with 32-bit numbers.
6642 function am3(i
, x
, w
, j
, c
, n
) {
6643 var xl
= x
& 0x3fff,
6646 var l
= this[i
] & 0x3fff
6647 var h
= this[i
++] >> 14
6648 var m
= xh
* l
+ h
* xl
6649 l
= xl
* l
+ ((m
& 0x3fff) << 14) + w
[j
] + c
6650 c
= (l
>> 28) + (m
>> 14) + xh
* h
6651 w
[j
++] = l
& 0xfffffff
6657 BigInteger
.prototype.am
= am1
6660 BigInteger
.prototype.DB
= dbits
6661 BigInteger
.prototype.DM
= ((1 << dbits
) - 1)
6662 var DV
= BigInteger
.prototype.DV
= (1 << dbits
)
6665 BigInteger
.prototype.FV
= Math
.pow(2, BI_FP
)
6666 BigInteger
.prototype.F1
= BI_FP
- dbits
6667 BigInteger
.prototype.F2
= 2 * dbits
- BI_FP
6669 // Digit conversions
6670 var BI_RM
= "0123456789abcdefghijklmnopqrstuvwxyz"
6671 var BI_RC
= new Array()
6673 rr
= "0".charCodeAt(0)
6674 for (vv
= 0; vv
<= 9; ++vv
) BI_RC
[rr
++] = vv
6675 rr
= "a".charCodeAt(0)
6676 for (vv
= 10; vv
< 36; ++vv
) BI_RC
[rr
++] = vv
6677 rr
= "A".charCodeAt(0)
6678 for (vv
= 10; vv
< 36; ++vv
) BI_RC
[rr
++] = vv
6680 function int2char(n
) {
6681 return BI_RM
.charAt(n
)
6684 function intAt(s
, i
) {
6685 var c
= BI_RC
[s
.charCodeAt(i
)]
6686 return (c
== null) ? -1 : c
6689 // (protected) copy this to r
6690 function bnpCopyTo(r
) {
6691 for (var i
= this.t
- 1; i
>= 0; --i
) r
[i
] = this[i
]
6696 // (protected) set from integer value x, -DV <= x < DV
6697 function bnpFromInt(x
) {
6699 this.s
= (x
< 0) ? -1 : 0
6700 if (x
> 0) this[0] = x
6701 else if (x
< -1) this[0] = x
+ DV
6705 // return bigint initialized to value
6707 var r
= new BigInteger()
6712 // (protected) set from string and radix
6713 function bnpFromString(s
, b
) {
6718 else if (b
== 8) k
= 3
6719 else if (b
== 256) k
= 8; // byte array
6720 else if (b
== 2) k
= 1
6721 else if (b
== 32) k
= 5
6722 else if (b
== 4) k
= 2
6724 self
.fromRadix(s
, b
)
6733 var x
= (k
== 8) ? s
[i
] & 0xff : intAt(s
, i
)
6735 if (s
.charAt(i
) == "-") mi
= true
6741 else if (sh
+ k
> self
.DB
) {
6742 self
[self
.t
- 1] |= (x
& ((1 << (self
.DB
- sh
)) - 1)) << sh
6743 self
[self
.t
++] = (x
>> (self
.DB
- sh
))
6745 self
[self
.t
- 1] |= x
<< sh
6747 if (sh
>= self
.DB
) sh
-= self
.DB
6749 if (k
== 8 && (s
[0] & 0x80) != 0) {
6751 if (sh
> 0) self
[self
.t
- 1] |= ((1 << (self
.DB
- sh
)) - 1) << sh
6754 if (mi
) BigInteger
.ZERO
.subTo(self
, self
)
6757 // (protected) clamp off excess high words
6758 function bnpClamp() {
6759 var c
= this.s
& this.DM
6760 while (this.t
> 0 && this[this.t
- 1] == c
)--this.t
6763 // (public) return string representation in given radix
6764 function bnToString(b
) {
6766 if (self
.s
< 0) return "-" + self
.negate()
6770 else if (b
== 8) k
= 3
6771 else if (b
== 2) k
= 1
6772 else if (b
== 32) k
= 5
6773 else if (b
== 4) k
= 2
6774 else return self
.toRadix(b
)
6775 var km
= (1 << k
) - 1,
6779 var p
= self
.DB
- (i
* self
.DB
) % k
6781 if (p
< self
.DB
&& (d
= self
[i
] >> p
) > 0) {
6787 d
= (self
[i
] & ((1 << p
) - 1)) << (k
- p
)
6788 d
|= self
[--i
] >> (p
+= self
.DB
- k
)
6790 d
= (self
[i
] >> (p
-= k
)) & km
6797 if (m
) r
+= int2char(d
)
6804 function bnNegate() {
6805 var r
= new BigInteger()
6806 BigInteger
.ZERO
.subTo(this, r
)
6812 return (this.s
< 0) ? this.negate() : this
6815 // (public) return + if this > a, - if this < a, 0 if equal
6816 function bnCompareTo(a
) {
6817 var r
= this.s
- a
.s
6818 if (r
!= 0) return r
6821 if (r
!= 0) return (this.s
< 0) ? -r : r
6823 if ((r
= this[i
] - a
[i
]) != 0) return r
6827 // returns bit length of the integer x
6831 if ((t
= x
>>> 16) != 0) {
6835 if ((t
= x
>> 8) != 0) {
6839 if ((t
= x
>> 4) != 0) {
6843 if ((t
= x
>> 2) != 0) {
6847 if ((t
= x
>> 1) != 0) {
6854 // (public) return the number of bits in "this"
6855 function bnBitLength() {
6856 if (this.t
<= 0) return 0
6857 return this.DB
* (this.t
- 1) + nbits(this[this.t
- 1] ^ (this.s
& this.DM
))
6860 // (public) return the number of bytes in "this"
6861 function bnByteLength() {
6862 return this.bitLength() >> 3
6865 // (protected) r = this << n*DB
6866 function bnpDLShiftTo(n
, r
) {
6868 for (i
= this.t
- 1; i
>= 0; --i
) r
[i
+ n
] = this[i
]
6869 for (i
= n
- 1; i
>= 0; --i
) r
[i
] = 0
6874 // (protected) r = this >> n*DB
6875 function bnpDRShiftTo(n
, r
) {
6876 for (var i
= n
; i
< this.t
; ++i
) r
[i
- n
] = this[i
]
6877 r
.t
= Math
.max(this.t
- n
, 0)
6881 // (protected) r = this << n
6882 function bnpLShiftTo(n
, r
) {
6884 var bs
= n
% self
.DB
6885 var cbs
= self
.DB
- bs
6886 var bm
= (1 << cbs
) - 1
6887 var ds
= Math
.floor(n
/ self
.DB
),
6888 c
= (self
.s
<< bs
) & self
.DM
,
6890 for (i
= self
.t
- 1; i
>= 0; --i
) {
6891 r
[i
+ ds
+ 1] = (self
[i
] >> cbs
) | c
6892 c
= (self
[i
] & bm
) << bs
6894 for (i
= ds
- 1; i
>= 0; --i
) r
[i
] = 0
6896 r
.t
= self
.t
+ ds
+ 1
6901 // (protected) r = this >> n
6902 function bnpRShiftTo(n
, r
) {
6905 var ds
= Math
.floor(n
/ self
.DB
)
6910 var bs
= n
% self
.DB
6911 var cbs
= self
.DB
- bs
6912 var bm
= (1 << bs
) - 1
6913 r
[0] = self
[ds
] >> bs
6914 for (var i
= ds
+ 1; i
< self
.t
; ++i
) {
6915 r
[i
- ds
- 1] |= (self
[i
] & bm
) << cbs
6916 r
[i
- ds
] = self
[i
] >> bs
6918 if (bs
> 0) r
[self
.t
- ds
- 1] |= (self
.s
& bm
) << cbs
6923 // (protected) r = this - a
6924 function bnpSubTo(a
, r
) {
6928 m
= Math
.min(a
.t
, self
.t
)
6931 r
[i
++] = c
& self
.DM
6936 while (i
< self
.t
) {
6938 r
[i
++] = c
& self
.DM
6946 r
[i
++] = c
& self
.DM
6951 r
.s
= (c
< 0) ? -1 : 0
6952 if (c
< -1) r
[i
++] = self
.DV
+ c
6953 else if (c
> 0) r
[i
++] = c
6958 // (protected) r = this * a, r != this,a (HAC 14.12)
6959 // "this" should be the larger one if appropriate.
6960 function bnpMultiplyTo(a
, r
) {
6965 while (--i
>= 0) r
[i
] = 0
6966 for (i
= 0; i
< y
.t
; ++i
) r
[i
+ x
.t
] = x
.am(0, y
[i
], r
, i
, 0, x
.t
)
6969 if (this.s
!= a
.s
) BigInteger
.ZERO
.subTo(r
, r
)
6972 // (protected) r = this^2, r != this (HAC 14.16)
6973 function bnpSquareTo(r
) {
6975 var i
= r
.t
= 2 * x
.t
6976 while (--i
>= 0) r
[i
] = 0
6977 for (i
= 0; i
< x
.t
- 1; ++i
) {
6978 var c
= x
.am(i
, x
[i
], r
, 2 * i
, 0, 1)
6979 if ((r
[i
+ x
.t
] += x
.am(i
+ 1, 2 * x
[i
], r
, 2 * i
+ 1, c
, x
.t
- i
- 1)) >= x
.DV
) {
6984 if (r
.t
> 0) r
[r
.t
- 1] += x
.am(i
, x
[i
], r
, 2 * i
, 0, 1)
6989 // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
6990 // r != q, this != m. q or r may be null.
6991 function bnpDivRemTo(m
, q
, r
) {
6994 if (pm
.t
<= 0) return
6997 if (q
!= null) q
.fromInt(0)
6998 if (r
!= null) self
.copyTo(r
)
7001 if (r
== null) r
= new BigInteger()
7002 var y
= new BigInteger(),
7005 var nsh
= self
.DB
- nbits(pm
[pm
.t
- 1]); // normalize modulus
7016 var yt
= y0
* (1 << self
.F1
) + ((ys
> 1) ? y
[ys
- 2] >> self
.F2 : 0)
7017 var d1
= self
.FV
/ yt
,
7018 d2
= (1 << self
.F1
) / yt
,
7022 t
= (q
== null) ? new BigInteger() : q
7024 if (r
.compareTo(t
) >= 0) {
7028 BigInteger
.ONE
.dlShiftTo(ys
, t
)
7029 t
.subTo(y
, y
); // "negative" y so we can replace sub with am later
7030 while (y
.t
< ys
) y
[y
.t
++] = 0
7032 // Estimate quotient digit
7033 var qd
= (r
[--i
] == y0
) ? self
.DM : Math
.floor(r
[i
] * d1
+ (r
[i
- 1] + e
) * d2
)
7034 if ((r
[i
] += y
.am(0, qd
, r
, j
, 0, ys
)) < qd
) { // Try it out
7037 while (r
[i
] < --qd
) r
.subTo(t
, r
)
7042 if (ts
!= ms
) BigInteger
.ZERO
.subTo(q
, q
)
7046 if (nsh
> 0) r
.rShiftTo(nsh
, r
); // Denormalize remainder
7047 if (ts
< 0) BigInteger
.ZERO
.subTo(r
, r
)
7050 // (public) this mod a
7052 var r
= new BigInteger()
7054 .divRemTo(a
, null, r
)
7055 if (this.s
< 0 && r
.compareTo(BigInteger
.ZERO
) > 0) a
.subTo(r
, r
)
7059 // Modular reduction using "classic" algorithm
7060 function Classic(m
) {
7064 function cConvert(x
) {
7065 if (x
.s
< 0 || x
.compareTo(this.m
) >= 0) return x
.mod(this.m
)
7069 function cRevert(x
) {
7073 function cReduce(x
) {
7074 x
.divRemTo(this.m
, null, x
)
7077 function cMulTo(x
, y
, r
) {
7082 function cSqrTo(x
, r
) {
7087 Classic
.prototype.convert
= cConvert
7088 Classic
.prototype.revert
= cRevert
7089 Classic
.prototype.reduce
= cReduce
7090 Classic
.prototype.mulTo
= cMulTo
7091 Classic
.prototype.sqrTo
= cSqrTo
7093 // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
7097 // xy(2-xy) = (1+km)(1-km)
7098 // x[y(2-xy)] = 1-k^2m^2
7099 // x[y(2-xy)] == 1 (mod m^2)
7100 // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
7101 // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
7102 // JS multiply "overflows" differently from C/C++, so care is needed here.
7103 function bnpInvDigit() {
7104 if (this.t
< 1) return 0
7106 if ((x
& 1) == 0) return 0
7107 var y
= x
& 3; // y == 1/x mod 2^2
7108 y
= (y
* (2 - (x
& 0xf) * y
)) & 0xf; // y == 1/x mod 2^4
7109 y
= (y
* (2 - (x
& 0xff) * y
)) & 0xff; // y == 1/x mod 2^8
7110 y
= (y
* (2 - (((x
& 0xffff) * y
) & 0xffff))) & 0xffff; // y == 1/x mod 2^16
7111 // last step - calculate inverse mod DV directly
7112 // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
7113 y
= (y
* (2 - x
* y
% this.DV
)) % this.DV
; // y == 1/x mod 2^dbits
7114 // we really want the negative inverse, and -DV < y < DV
7115 return (y
> 0) ? this.DV
- y : -y
7118 // Montgomery reduction
7119 function Montgomery(m
) {
7121 this.mp
= m
.invDigit()
7122 this.mpl
= this.mp
& 0x7fff
7123 this.mph
= this.mp
>> 15
7124 this.um
= (1 << (m
.DB
- 15)) - 1
7129 function montConvert(x
) {
7130 var r
= new BigInteger()
7132 .dlShiftTo(this.m
.t
, r
)
7133 r
.divRemTo(this.m
, null, r
)
7134 if (x
.s
< 0 && r
.compareTo(BigInteger
.ZERO
) > 0) this.m
.subTo(r
, r
)
7139 function montRevert(x
) {
7140 var r
= new BigInteger()
7146 // x = x/R mod m (HAC 14.32)
7147 function montReduce(x
) {
7148 while (x
.t
<= this.mt2
) // pad x so am has enough room later
7150 for (var i
= 0; i
< this.m
.t
; ++i
) {
7151 // faster way of calculating u0 = x[i]*mp mod DV
7152 var j
= x
[i
] & 0x7fff
7153 var u0
= (j
* this.mpl
+ (((j
* this.mph
+ (x
[i
] >> 15) * this.mpl
) & this.um
) << 15)) & x
.DM
7154 // use am to combine the multiply-shift-add into one call
7156 x
[j
] += this.m
.am(0, u0
, x
, i
, 0, this.m
.t
)
7158 while (x
[j
] >= x
.DV
) {
7164 x
.drShiftTo(this.m
.t
, x
)
7165 if (x
.compareTo(this.m
) >= 0) x
.subTo(this.m
, x
)
7168 // r = "x^2/R mod m"; x != r
7169 function montSqrTo(x
, r
) {
7174 // r = "xy/R mod m"; x,y != r
7175 function montMulTo(x
, y
, r
) {
7180 Montgomery
.prototype.convert
= montConvert
7181 Montgomery
.prototype.revert
= montRevert
7182 Montgomery
.prototype.reduce
= montReduce
7183 Montgomery
.prototype.mulTo
= montMulTo
7184 Montgomery
.prototype.sqrTo
= montSqrTo
7186 // (protected) true iff this is even
7187 function bnpIsEven() {
7188 return ((this.t
> 0) ? (this[0] & 1) : this.s
) == 0
7191 // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
7192 function bnpExp(e
, z
) {
7193 if (e
> 0xffffffff || e
< 1) return BigInteger
.ONE
7194 var r
= new BigInteger(),
7195 r2
= new BigInteger(),
7196 g
= z
.convert(this),
7201 if ((e
& (1 << i
)) > 0) z
.mulTo(r2
, g
, r
)
7211 // (public) this^e % m, 0 <= e < 2^32
7212 function bnModPowInt(e
, m
) {
7214 if (e
< 256 || m
.isEven()) z
= new Classic(m
)
7215 else z
= new Montgomery(m
)
7216 return this.exp(e
, z
)
7220 proto
.copyTo
= bnpCopyTo
7221 proto
.fromInt
= bnpFromInt
7222 proto
.fromString
= bnpFromString
7223 proto
.clamp
= bnpClamp
7224 proto
.dlShiftTo
= bnpDLShiftTo
7225 proto
.drShiftTo
= bnpDRShiftTo
7226 proto
.lShiftTo
= bnpLShiftTo
7227 proto
.rShiftTo
= bnpRShiftTo
7228 proto
.subTo
= bnpSubTo
7229 proto
.multiplyTo
= bnpMultiplyTo
7230 proto
.squareTo
= bnpSquareTo
7231 proto
.divRemTo
= bnpDivRemTo
7232 proto
.invDigit
= bnpInvDigit
7233 proto
.isEven
= bnpIsEven
7237 proto
.toString
= bnToString
7238 proto
.negate
= bnNegate
7240 proto
.compareTo
= bnCompareTo
7241 proto
.bitLength
= bnBitLength
7242 proto
.byteLength
= bnByteLength
7244 proto
.modPowInt
= bnModPowInt
7247 function bnClone() {
7248 var r
= new BigInteger()
7253 // (public) return value as integer
7254 function bnIntValue() {
7256 if (this.t
== 1) return this[0] - this.DV
7257 else if (this.t
== 0) return -1
7258 } else if (this.t
== 1) return this[0]
7259 else if (this.t
== 0) return 0
7260 // assumes 16 < DB < 32
7261 return ((this[1] & ((1 << (32 - this.DB
)) - 1)) << this.DB
) | this[0]
7264 // (public) return value as byte
7265 function bnByteValue() {
7266 return (this.t
== 0) ? this.s : (this[0] << 24) >> 24
7269 // (public) return value as short (assumes DB>=16)
7270 function bnShortValue() {
7271 return (this.t
== 0) ? this.s : (this[0] << 16) >> 16
7274 // (protected) return x s.t. r^x < DV
7275 function bnpChunkSize(r
) {
7276 return Math
.floor(Math
.LN2
* this.DB
/ Math
.log(r
))
7279 // (public) 0 if this == 0, 1 if this > 0
7280 function bnSigNum() {
7281 if (this.s
< 0) return -1
7282 else if (this.t
<= 0 || (this.t
== 1 && this[0] <= 0)) return 0
7286 // (protected) convert to radix string
7287 function bnpToRadix(b
) {
7288 if (b
== null) b
= 10
7289 if (this.signum() == 0 || b
< 2 || b
> 36) return "0"
7290 var cs
= this.chunkSize(b
)
7291 var a
= Math
.pow(b
, cs
)
7293 y
= new BigInteger(),
7294 z
= new BigInteger(),
7296 this.divRemTo(d
, y
, z
)
7297 while (y
.signum() > 0) {
7298 r
= (a
+ z
.intValue())
7307 // (protected) convert from radix string
7308 function bnpFromRadix(s
, b
) {
7311 if (b
== null) b
= 10
7312 var cs
= self
.chunkSize(b
)
7313 var d
= Math
.pow(b
, cs
),
7317 for (var i
= 0; i
< s
.length
; ++i
) {
7320 if (s
.charAt(i
) == "-" && self
.signum() == 0) mi
= true
7326 self
.dAddOffset(w
, 0)
7332 self
.dMultiply(Math
.pow(b
, j
))
7333 self
.dAddOffset(w
, 0)
7335 if (mi
) BigInteger
.ZERO
.subTo(self
, self
)
7338 // (protected) alternate constructor
7339 function bnpFromNumber(a
, b
, c
) {
7341 if ("number" == typeof b
) {
7342 // new BigInteger(int,int,RNG)
7343 if (a
< 2) self
.fromInt(1)
7345 self
.fromNumber(a
, c
)
7346 if (!self
.testBit(a
- 1)) // force MSB set
7347 self
.bitwiseTo(BigInteger
.ONE
.shiftLeft(a
- 1), op_or
, self
)
7348 if (self
.isEven()) self
.dAddOffset(1, 0); // force odd
7349 while (!self
.isProbablePrime(b
)) {
7350 self
.dAddOffset(2, 0)
7351 if (self
.bitLength() > a
) self
.subTo(BigInteger
.ONE
.shiftLeft(a
- 1), self
)
7355 // new BigInteger(int,RNG)
7356 var x
= new Array(),
7358 x
.length
= (a
>> 3) + 1
7360 if (t
> 0) x
[0] &= ((1 << t
) - 1)
7362 self
.fromString(x
, 256)
7366 // (public) convert to bigendian byte array
7367 function bnToByteArray() {
7372 var p
= self
.DB
- (i
* self
.DB
) % 8,
7375 if (p
< self
.DB
&& (d
= self
[i
] >> p
) != (self
.s
& self
.DM
) >> p
)
7376 r
[k
++] = d
| (self
.s
<< (self
.DB
- p
))
7379 d
= (self
[i
] & ((1 << p
) - 1)) << (8 - p
)
7380 d
|= self
[--i
] >> (p
+= self
.DB
- 8)
7382 d
= (self
[i
] >> (p
-= 8)) & 0xff
7388 if ((d
& 0x80) != 0) d
|= -256
7389 if (k
=== 0 && (self
.s
& 0x80) != (d
& 0x80))++k
7390 if (k
> 0 || d
!= self
.s
) r
[k
++] = d
7396 function bnEquals(a
) {
7397 return (this.compareTo(a
) == 0)
7401 return (this.compareTo(a
) < 0) ? this : a
7405 return (this.compareTo(a
) > 0) ? this : a
7408 // (protected) r = this op a (bitwise)
7409 function bnpBitwiseTo(a
, op
, r
) {
7411 var i
, f
, m
= Math
.min(a
.t
, self
.t
)
7412 for (i
= 0; i
< m
; ++i
) r
[i
] = op(self
[i
], a
[i
])
7415 for (i
= m
; i
< self
.t
; ++i
) r
[i
] = op(self
[i
], f
)
7418 f
= self
.s
& self
.DM
7419 for (i
= m
; i
< a
.t
; ++i
) r
[i
] = op(f
, a
[i
])
7422 r
.s
= op(self
.s
, a
.s
)
7426 // (public) this & a
7427 function op_and(x
, y
) {
7432 var r
= new BigInteger()
7433 this.bitwiseTo(a
, op_and
, r
)
7437 // (public) this | a
7438 function op_or(x
, y
) {
7443 var r
= new BigInteger()
7444 this.bitwiseTo(a
, op_or
, r
)
7448 // (public) this ^ a
7449 function op_xor(x
, y
) {
7454 var r
= new BigInteger()
7455 this.bitwiseTo(a
, op_xor
, r
)
7459 // (public) this & ~a
7460 function op_andnot(x
, y
) {
7464 function bnAndNot(a
) {
7465 var r
= new BigInteger()
7466 this.bitwiseTo(a
, op_andnot
, r
)
7472 var r
= new BigInteger()
7473 for (var i
= 0; i
< this.t
; ++i
) r
[i
] = this.DM
& ~this[i
]
7479 // (public) this << n
7480 function bnShiftLeft(n
) {
7481 var r
= new BigInteger()
7482 if (n
< 0) this.rShiftTo(-n
, r
)
7483 else this.lShiftTo(n
, r
)
7487 // (public) this >> n
7488 function bnShiftRight(n
) {
7489 var r
= new BigInteger()
7490 if (n
< 0) this.lShiftTo(-n
, r
)
7491 else this.rShiftTo(n
, r
)
7495 // return index of lowest 1-bit in x, x < 2^31
7497 if (x
== 0) return -1
7499 if ((x
& 0xffff) == 0) {
7503 if ((x
& 0xff) == 0) {
7507 if ((x
& 0xf) == 0) {
7515 if ((x
& 1) == 0)++r
7519 // (public) returns index of lowest 1-bit (or -1 if none)
7520 function bnGetLowestSetBit() {
7521 for (var i
= 0; i
< this.t
; ++i
)
7522 if (this[i
] != 0) return i
* this.DB
+ lbit(this[i
])
7523 if (this.s
< 0) return this.t
* this.DB
7527 // return number of 1 bits in x
7537 // (public) return number of set bits
7538 function bnBitCount() {
7540 x
= this.s
& this.DM
7541 for (var i
= 0; i
< this.t
; ++i
) r
+= cbit(this[i
] ^ x
)
7545 // (public) true iff nth bit is set
7546 function bnTestBit(n
) {
7547 var j
= Math
.floor(n
/ this.DB
)
7548 if (j
>= this.t
) return (this.s
!= 0)
7549 return ((this[j
] & (1 << (n
% this.DB
))) != 0)
7552 // (protected) this op (1<<n)
7553 function bnpChangeBit(n
, op
) {
7554 var r
= BigInteger
.ONE
.shiftLeft(n
)
7555 this.bitwiseTo(r
, op
, r
)
7559 // (public) this | (1<<n)
7560 function bnSetBit(n
) {
7561 return this.changeBit(n
, op_or
)
7564 // (public) this & ~(1<<n)
7565 function bnClearBit(n
) {
7566 return this.changeBit(n
, op_andnot
)
7569 // (public) this ^ (1<<n)
7570 function bnFlipBit(n
) {
7571 return this.changeBit(n
, op_xor
)
7574 // (protected) r = this + a
7575 function bnpAddTo(a
, r
) {
7580 m
= Math
.min(a
.t
, self
.t
)
7583 r
[i
++] = c
& self
.DM
7588 while (i
< self
.t
) {
7590 r
[i
++] = c
& self
.DM
7598 r
[i
++] = c
& self
.DM
7603 r
.s
= (c
< 0) ? -1 : 0
7604 if (c
> 0) r
[i
++] = c
7605 else if (c
< -1) r
[i
++] = self
.DV
+ c
7610 // (public) this + a
7612 var r
= new BigInteger()
7617 // (public) this - a
7618 function bnSubtract(a
) {
7619 var r
= new BigInteger()
7624 // (public) this * a
7625 function bnMultiply(a
) {
7626 var r
= new BigInteger()
7627 this.multiplyTo(a
, r
)
7632 function bnSquare() {
7633 var r
= new BigInteger()
7638 // (public) this / a
7639 function bnDivide(a
) {
7640 var r
= new BigInteger()
7641 this.divRemTo(a
, r
, null)
7645 // (public) this % a
7646 function bnRemainder(a
) {
7647 var r
= new BigInteger()
7648 this.divRemTo(a
, null, r
)
7652 // (public) [this/a,this%a]
7653 function bnDivideAndRemainder(a
) {
7654 var q
= new BigInteger(),
7655 r
= new BigInteger()
7656 this.divRemTo(a
, q
, r
)
7657 return new Array(q
, r
)
7660 // (protected) this *= n, this >= 0, 1 < n < DV
7661 function bnpDMultiply(n
) {
7662 this[this.t
] = this.am(0, n
- 1, this, 0, 0, this.t
)
7667 // (protected) this += n << w words, this >= 0
7668 function bnpDAddOffset(n
, w
) {
7670 while (this.t
<= w
) this[this.t
++] = 0
7672 while (this[w
] >= this.DV
) {
7674 if (++w
>= this.t
) this[this.t
++] = 0
7680 function NullExp() {}
7686 function nMulTo(x
, y
, r
) {
7690 function nSqrTo(x
, r
) {
7694 NullExp
.prototype.convert
= nNop
7695 NullExp
.prototype.revert
= nNop
7696 NullExp
.prototype.mulTo
= nMulTo
7697 NullExp
.prototype.sqrTo
= nSqrTo
7701 return this.exp(e
, new NullExp())
7704 // (protected) r = lower n words of "this * a", a.t <= n
7705 // "this" should be the larger one if appropriate.
7706 function bnpMultiplyLowerTo(a
, n
, r
) {
7707 var i
= Math
.min(this.t
+ a
.t
, n
)
7708 r
.s
= 0; // assumes a,this >= 0
7710 while (i
> 0) r
[--i
] = 0
7712 for (j
= r
.t
- this.t
; i
< j
; ++i
) r
[i
+ this.t
] = this.am(0, a
[i
], r
, i
, 0, this.t
)
7713 for (j
= Math
.min(a
.t
, n
); i
< j
; ++i
) this.am(0, a
[i
], r
, i
, 0, n
- i
)
7717 // (protected) r = "this * a" without lower n words, n > 0
7718 // "this" should be the larger one if appropriate.
7719 function bnpMultiplyUpperTo(a
, n
, r
) {
7721 var i
= r
.t
= this.t
+ a
.t
- n
7722 r
.s
= 0; // assumes a,this >= 0
7723 while (--i
>= 0) r
[i
] = 0
7724 for (i
= Math
.max(n
- this.t
, 0); i
< a
.t
; ++i
)
7725 r
[this.t
+ i
- n
] = this.am(n
- i
, a
[i
], r
, 0, 0, this.t
+ i
- n
)
7730 // Barrett modular reduction
7731 function Barrett(m
) {
7733 this.r2
= new BigInteger()
7734 this.q3
= new BigInteger()
7735 BigInteger
.ONE
.dlShiftTo(2 * m
.t
, this.r2
)
7736 this.mu
= this.r2
.divide(m
)
7740 function barrettConvert(x
) {
7741 if (x
.s
< 0 || x
.t
> 2 * this.m
.t
) return x
.mod(this.m
)
7742 else if (x
.compareTo(this.m
) < 0) return x
7744 var r
= new BigInteger()
7751 function barrettRevert(x
) {
7755 // x = x mod m (HAC 14.42)
7756 function barrettReduce(x
) {
7758 x
.drShiftTo(self
.m
.t
- 1, self
.r2
)
7759 if (x
.t
> self
.m
.t
+ 1) {
7763 self
.mu
.multiplyUpperTo(self
.r2
, self
.m
.t
+ 1, self
.q3
)
7764 self
.m
.multiplyLowerTo(self
.q3
, self
.m
.t
+ 1, self
.r2
)
7765 while (x
.compareTo(self
.r2
) < 0) x
.dAddOffset(1, self
.m
.t
+ 1)
7767 while (x
.compareTo(self
.m
) >= 0) x
.subTo(self
.m
, x
)
7770 // r = x^2 mod m; x != r
7771 function barrettSqrTo(x
, r
) {
7776 // r = x*y mod m; x,y != r
7777 function barrettMulTo(x
, y
, r
) {
7782 Barrett
.prototype.convert
= barrettConvert
7783 Barrett
.prototype.revert
= barrettRevert
7784 Barrett
.prototype.reduce
= barrettReduce
7785 Barrett
.prototype.mulTo
= barrettMulTo
7786 Barrett
.prototype.sqrTo
= barrettSqrTo
7788 // (public) this^e % m (HAC 14.85)
7789 function bnModPow(e
, m
) {
7790 var i
= e
.bitLength(),
7793 if (i
<= 0) return r
7794 else if (i
< 18) k
= 1
7795 else if (i
< 48) k
= 3
7796 else if (i
< 144) k
= 4
7797 else if (i
< 768) k
= 5
7801 else if (m
.isEven())
7804 z
= new Montgomery(m
)
7807 var g
= new Array(),
7811 g
[1] = z
.convert(this)
7813 var g2
= new BigInteger()
7816 g
[n
] = new BigInteger()
7817 z
.mulTo(g2
, g
[n
- 2], g
[n
])
7824 r2
= new BigInteger(),
7828 if (i
>= k1
) w
= (e
[j
] >> (i
- k1
)) & km
7830 w
= (e
[j
] & ((1 << (i
+ 1)) - 1)) << (k1
- i
)
7831 if (j
> 0) w
|= e
[j
- 1] >> (this.DB
+ i
- k1
)
7835 while ((w
& 1) == 0) {
7843 if (is1
) { // ret == 1, don't bother squaring or multiplying it
7852 if (n
> 0) z
.sqrTo(r
, r2
)
7858 z
.mulTo(r2
, g
[w
], r
)
7861 while (j
>= 0 && (e
[j
] & (1 << i
)) == 0) {
7875 // (public) gcd(this,a) (HAC 14.54)
7877 var x
= (this.s
< 0) ? this.negate() : this.clone()
7878 var y
= (a
.s
< 0) ? a
.negate() : a
.clone()
7879 if (x
.compareTo(y
) < 0) {
7884 var i
= x
.getLowestSetBit(),
7885 g
= y
.getLowestSetBit()
7892 while (x
.signum() > 0) {
7893 if ((i
= x
.getLowestSetBit()) > 0) x
.rShiftTo(i
, x
)
7894 if ((i
= y
.getLowestSetBit()) > 0) y
.rShiftTo(i
, y
)
7895 if (x
.compareTo(y
) >= 0) {
7903 if (g
> 0) y
.lShiftTo(g
, y
)
7907 // (protected) this % n, n < 2^26
7908 function bnpModInt(n
) {
7909 if (n
<= 0) return 0
7910 var d
= this.DV
% n
,
7911 r
= (this.s
< 0) ? n
- 1 : 0
7913 if (d
== 0) r
= this[0] % n
7915 for (var i
= this.t
- 1; i
>= 0; --i
) r
= (d
* r
+ this[i
]) % n
7919 // (public) 1/this % m (HAC 14.61)
7920 function bnModInverse(m
) {
7922 if (this.signum() === 0) throw new Error('division by zero')
7923 if ((this.isEven() && ac
) || m
.signum() == 0) return BigInteger
.ZERO
7930 while (u
.signum() != 0) {
7931 while (u
.isEven()) {
7934 if (!a
.isEven() || !b
.isEven()) {
7939 } else if (!b
.isEven()) b
.subTo(m
, b
)
7942 while (v
.isEven()) {
7945 if (!c
.isEven() || !d
.isEven()) {
7950 } else if (!d
.isEven()) d
.subTo(m
, d
)
7953 if (u
.compareTo(v
) >= 0) {
7955 if (ac
) a
.subTo(c
, a
)
7959 if (ac
) c
.subTo(a
, c
)
7963 if (v
.compareTo(BigInteger
.ONE
) != 0) return BigInteger
.ZERO
7964 while (d
.compareTo(m
) >= 0) d
.subTo(m
, d
)
7965 while (d
.signum() < 0) d
.addTo(m
, d
)
7970 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
7971 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
7972 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
7973 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
7974 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,
7975 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
7976 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,
7977 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
7978 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
7979 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
7980 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997
7983 var lplim
= (1 << 26) / lowprimes
[lowprimes
.length
- 1]
7985 // (public) test primality with certainty >= 1-.5^t
7986 function bnIsProbablePrime(t
) {
7987 var i
, x
= this.abs()
7988 if (x
.t
== 1 && x
[0] <= lowprimes
[lowprimes
.length
- 1]) {
7989 for (i
= 0; i
< lowprimes
.length
; ++i
)
7990 if (x
[0] == lowprimes
[i
]) return true
7993 if (x
.isEven()) return false
7995 while (i
< lowprimes
.length
) {
7996 var m
= lowprimes
[i
],
7998 while (j
< lowprimes
.length
&& m
< lplim
) m
*= lowprimes
[j
++]
8000 while (i
< j
) if (m
% lowprimes
[i
++] == 0) return false
8002 return x
.millerRabin(t
)
8005 // (protected) true if probably prime (HAC 4.24, Miller-Rabin)
8006 function bnpMillerRabin(t
) {
8007 var n1
= this.subtract(BigInteger
.ONE
)
8008 var k
= n1
.getLowestSetBit()
8009 if (k
<= 0) return false
8010 var r
= n1
.shiftRight(k
)
8012 if (t
> lowprimes
.length
) t
= lowprimes
.length
8013 var a
= new BigInteger(null)
8015 for (var i
= 0; i
< t
; ++i
) {
8017 j
= lowprimes
[Math
.floor(Math
.random() * lowprimes
.length
)]
8018 if (bases
.indexOf(j
) == -1) break
8022 var y
= a
.modPow(r
, this)
8023 if (y
.compareTo(BigInteger
.ONE
) != 0 && y
.compareTo(n1
) != 0) {
8025 while (j
++ < k
&& y
.compareTo(n1
) != 0) {
8026 y
= y
.modPowInt(2, this)
8027 if (y
.compareTo(BigInteger
.ONE
) == 0) return false
8029 if (y
.compareTo(n1
) != 0) return false
8036 proto
.chunkSize
= bnpChunkSize
8037 proto
.toRadix
= bnpToRadix
8038 proto
.fromRadix
= bnpFromRadix
8039 proto
.fromNumber
= bnpFromNumber
8040 proto
.bitwiseTo
= bnpBitwiseTo
8041 proto
.changeBit
= bnpChangeBit
8042 proto
.addTo
= bnpAddTo
8043 proto
.dMultiply
= bnpDMultiply
8044 proto
.dAddOffset
= bnpDAddOffset
8045 proto
.multiplyLowerTo
= bnpMultiplyLowerTo
8046 proto
.multiplyUpperTo
= bnpMultiplyUpperTo
8047 proto
.modInt
= bnpModInt
8048 proto
.millerRabin
= bnpMillerRabin
8051 proto
.clone
= bnClone
8052 proto
.intValue
= bnIntValue
8053 proto
.byteValue
= bnByteValue
8054 proto
.shortValue
= bnShortValue
8055 proto
.signum
= bnSigNum
8056 proto
.toByteArray
= bnToByteArray
8057 proto
.equals
= bnEquals
8063 proto
.andNot
= bnAndNot
8065 proto
.shiftLeft
= bnShiftLeft
8066 proto
.shiftRight
= bnShiftRight
8067 proto
.getLowestSetBit
= bnGetLowestSetBit
8068 proto
.bitCount
= bnBitCount
8069 proto
.testBit
= bnTestBit
8070 proto
.setBit
= bnSetBit
8071 proto
.clearBit
= bnClearBit
8072 proto
.flipBit
= bnFlipBit
8074 proto
.subtract
= bnSubtract
8075 proto
.multiply
= bnMultiply
8076 proto
.divide
= bnDivide
8077 proto
.remainder
= bnRemainder
8078 proto
.divideAndRemainder
= bnDivideAndRemainder
8079 proto
.modPow
= bnModPow
8080 proto
.modInverse
= bnModInverse
8083 proto
.isProbablePrime
= bnIsProbablePrime
8085 // JSBN-specific extension
8086 proto
.square
= bnSquare
8089 BigInteger
.ZERO
= nbv(0)
8090 BigInteger
.ONE
= nbv(1)
8091 BigInteger
.valueOf
= nbv
8093 module
.exports
= BigInteger
8095 },{"../package.json":38}],36:[function(require
,module
,exports
){
8097 // FIXME: Kind of a weird way to throw exceptions, consider removing
8098 var assert
= require('assert')
8099 var BigInteger
= require('./bigi')
8102 * Turns a byte array into a big integer.
8104 * This function will interpret a byte array as a big integer in big
8107 BigInteger
.fromByteArrayUnsigned = function(byteArray
) {
8108 // BigInteger expects a DER integer conformant byte array
8109 if (byteArray
[0] & 0x80) {
8110 return new BigInteger([0].concat(byteArray
))
8113 return new BigInteger(byteArray
)
8117 * Returns a byte array representation of the big integer.
8119 * This returns the absolute of the contained value in big endian
8120 * form. A value of zero results in an empty array.
8122 BigInteger
.prototype.toByteArrayUnsigned = function() {
8123 var byteArray
= this.toByteArray()
8124 return byteArray
[0] === 0 ? byteArray
.slice(1) : byteArray
8127 BigInteger
.fromDERInteger = function(byteArray
) {
8128 return new BigInteger(byteArray
)
8132 * Converts BigInteger to a DER integer representation.
8134 * The format for this value uses the most significant bit as a sign
8135 * bit. If the most significant bit is already set and the integer is
8136 * positive, a 0x00 is prepended.
8152 * -62300 => 0xff0ca4
8154 BigInteger
.prototype.toDERInteger
= BigInteger
.prototype.toByteArray
8156 BigInteger
.fromBuffer = function(buffer
) {
8157 // BigInteger expects a DER integer conformant byte array
8158 if (buffer
[0] & 0x80) {
8159 var byteArray
= Array
.prototype.slice
.call(buffer
)
8161 return new BigInteger([0].concat(byteArray
))
8164 return new BigInteger(buffer
)
8167 BigInteger
.fromHex = function(hex
) {
8168 if (hex
=== '') return BigInteger
.ZERO
8170 assert
.equal(hex
, hex
.match(/^[A-Fa-f0-9]+/), 'Invalid hex string')
8171 assert
.equal(hex
.length
% 2, 0, 'Incomplete hex')
8172 return new BigInteger(hex
, 16)
8175 BigInteger
.prototype.toBuffer = function(size
) {
8176 var byteArray
= this.toByteArrayUnsigned()
8179 var padding
= size
- byteArray
.length
8180 while (zeros
.length
< padding
) zeros
.push(0)
8182 return new Buffer(zeros
.concat(byteArray
))
8185 BigInteger
.prototype.toHex = function(size
) {
8186 return this.toBuffer(size
).toString('hex')
8189 }).call(this,require("buffer").Buffer
)
8190 },{"./bigi":35,"assert":1,"buffer":4}],37:[function(require
,module
,exports
){
8191 var BigInteger
= require('./bigi')
8194 require('./convert')
8196 module
.exports
= BigInteger
8197 },{"./bigi":35,"./convert":36}],38:[function(require
,module
,exports
){
8202 "/home/ian/git/bitcoin/bitcoinjs-lib-browser"
8205 "_from": "bigi@latest",
8206 "_id": "bigi@1.4.2",
8208 "_installable": true,
8209 "_location": "/bigi",
8210 "_nodeVersion": "6.1.0",
8211 "_npmOperationalInternal": {
8212 "host": "packages-12-west.internal.npmjs.com",
8213 "tmp": "tmp/bigi-1.4.2.tgz_1469584192413_0.6801238611806184"
8216 "email": "jprichardson@gmail.com",
8217 "name": "jprichardson"
8219 "_npmVersion": "3.8.6",
8220 "_phantomChildren": {},
8234 "_resolved": "https://registry.npmjs.org/bigi/-/bigi-1.4.2.tgz",
8235 "_shasum": "9c665a95f88b8b08fc05cfd731f561859d725825",
8236 "_shrinkwrap": null,
8238 "_where": "/home/ian/git/bitcoin/bitcoinjs-lib-browser",
8240 "url": "https://github.com/cryptocoinjs/bigi/issues"
8243 "description": "Big integers.",
8244 "devDependencies": {
8245 "coveralls": "^2.11.2",
8246 "istanbul": "^0.3.5",
8253 "shasum": "9c665a95f88b8b08fc05cfd731f561859d725825",
8254 "tarball": "https://registry.npmjs.org/bigi/-/bigi-1.4.2.tgz"
8256 "gitHead": "c25308081c896ff84702303722bf5ecd8b3f78e3",
8257 "homepage": "https://github.com/cryptocoinjs/bigi#readme",
8275 "main": "./lib/index.js",
8278 "email": "boydb@midnightdesign.ws",
8279 "name": "midnightlightning"
8282 "email": "sidazhang89@gmail.com",
8286 "email": "npm@shesek.info",
8290 "email": "jprichardson@gmail.com",
8291 "name": "jprichardson"
8295 "optionalDependencies": {},
8296 "readme": "ERROR: No README data found!",
8299 "url": "git+https://github.com/cryptocoinjs/bigi.git"
8302 "browser-test": "mochify --wd -R spec",
8303 "coverage": "istanbul cover ./node_modules/.bin/_mocha -- --reporter list test/*.js",
8304 "coveralls": "npm run-script coverage && node ./node_modules/.bin/coveralls < coverage/lcov.info",
8305 "jshint": "jshint --config jshint.json lib/*.js ; true",
8306 "test": "_mocha -- test/*.js",
8314 "safari/6.0..latest",
8315 "iphone/6.0..latest",
8316 "android-browser/4.2..latest"
8318 "files": "test/*.js",
8324 },{}],39:[function(require
,module
,exports
){
8325 // Reference https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
8326 // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
8327 // NOTE: SIGHASH byte ignored AND restricted, truncate before use
8329 var Buffer
= require('safe-buffer').Buffer
8331 function check (buffer
) {
8332 if (buffer
.length
< 8) return false
8333 if (buffer
.length
> 72) return false
8334 if (buffer
[0] !== 0x30) return false
8335 if (buffer
[1] !== buffer
.length
- 2) return false
8336 if (buffer
[2] !== 0x02) return false
8338 var lenR
= buffer
[3]
8339 if (lenR
=== 0) return false
8340 if (5 + lenR
>= buffer
.length
) return false
8341 if (buffer
[4 + lenR
] !== 0x02) return false
8343 var lenS
= buffer
[5 + lenR
]
8344 if (lenS
=== 0) return false
8345 if ((6 + lenR
+ lenS
) !== buffer
.length
) return false
8347 if (buffer
[4] & 0x80) return false
8348 if (lenR
> 1 && (buffer
[4] === 0x00) && !(buffer
[5] & 0x80)) return false
8350 if (buffer
[lenR
+ 6] & 0x80) return false
8351 if (lenS
> 1 && (buffer
[lenR
+ 6] === 0x00) && !(buffer
[lenR
+ 7] & 0x80)) return false
8355 function decode (buffer
) {
8356 if (buffer
.length
< 8) throw new Error('DER sequence length is too short')
8357 if (buffer
.length
> 72) throw new Error('DER sequence length is too long')
8358 if (buffer
[0] !== 0x30) throw new Error('Expected DER sequence')
8359 if (buffer
[1] !== buffer
.length
- 2) throw new Error('DER sequence length is invalid')
8360 if (buffer
[2] !== 0x02) throw new Error('Expected DER integer')
8362 var lenR
= buffer
[3]
8363 if (lenR
=== 0) throw new Error('R length is zero')
8364 if (5 + lenR
>= buffer
.length
) throw new Error('R length is too long')
8365 if (buffer
[4 + lenR
] !== 0x02) throw new Error('Expected DER integer (2)')
8367 var lenS
= buffer
[5 + lenR
]
8368 if (lenS
=== 0) throw new Error('S length is zero')
8369 if ((6 + lenR
+ lenS
) !== buffer
.length
) throw new Error('S length is invalid')
8371 if (buffer
[4] & 0x80) throw new Error('R value is negative')
8372 if (lenR
> 1 && (buffer
[4] === 0x00) && !(buffer
[5] & 0x80)) throw new Error('R value excessively padded')
8374 if (buffer
[lenR
+ 6] & 0x80) throw new Error('S value is negative')
8375 if (lenS
> 1 && (buffer
[lenR
+ 6] === 0x00) && !(buffer
[lenR
+ 7] & 0x80)) throw new Error('S value excessively padded')
8377 // non-BIP66 - extract R, S values
8379 r: buffer
.slice(4, 4 + lenR
),
8380 s: buffer
.slice(6 + lenR
)
8385 * Expects r and s to be positive DER integers.
8387 * The DER format uses the most significant bit as a sign bit (& 0x80).
8388 * If the significant bit is set AND the integer is positive, a 0x00 is prepended.
8404 * -62300 => 0xff0ca4
8406 function encode (r
, s
) {
8409 if (lenR
=== 0) throw new Error('R length is zero')
8410 if (lenS
=== 0) throw new Error('S length is zero')
8411 if (lenR
> 33) throw new Error('R length is too long')
8412 if (lenS
> 33) throw new Error('S length is too long')
8413 if (r
[0] & 0x80) throw new Error('R value is negative')
8414 if (s
[0] & 0x80) throw new Error('S value is negative')
8415 if (lenR
> 1 && (r
[0] === 0x00) && !(r
[1] & 0x80)) throw new Error('R value excessively padded')
8416 if (lenS
> 1 && (s
[0] === 0x00) && !(s
[1] & 0x80)) throw new Error('S value excessively padded')
8418 var signature
= Buffer
.allocUnsafe(6 + lenR
+ lenS
)
8420 // 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
8422 signature
[1] = signature
.length
- 2
8424 signature
[3] = r
.length
8425 r
.copy(signature
, 4)
8426 signature
[4 + lenR
] = 0x02
8427 signature
[5 + lenR
] = s
.length
8428 s
.copy(signature
, 6 + lenR
)
8439 },{"safe-buffer":98}],40:[function(require
,module
,exports
){
8477 "OP_TOALTSTACK": 107,
8478 "OP_FROMALTSTACK": 108,
8508 "OP_EQUALVERIFY": 136,
8509 "OP_RESERVED1": 137,
8510 "OP_RESERVED2": 138,
8519 "OP_0NOTEQUAL": 146,
8531 "OP_NUMEQUALVERIFY": 157,
8532 "OP_NUMNOTEQUAL": 158,
8534 "OP_GREATERTHAN": 160,
8535 "OP_LESSTHANOREQUAL": 161,
8536 "OP_GREATERTHANOREQUAL": 162,
8542 "OP_RIPEMD160": 166,
8547 "OP_CODESEPARATOR": 171,
8549 "OP_CHECKSIGVERIFY": 173,
8550 "OP_CHECKMULTISIG": 174,
8551 "OP_CHECKMULTISIGVERIFY": 175,
8555 "OP_CHECKLOCKTIMEVERIFY": 177,
8566 "OP_PUBKEYHASH": 253,
8568 "OP_INVALIDOPCODE": 255
8571 },{}],41:[function(require
,module
,exports
){
8572 var OPS
= require('./index.json')
8575 for (var op
in OPS
) {
8580 module
.exports
= map
8582 },{"./index.json":40}],42:[function(require
,module
,exports
){
8583 var Buffer
= require('safe-buffer').Buffer
8584 var bs58check
= require('bs58check')
8585 var bscript
= require('./script')
8586 var networks
= require('./networks')
8587 var typeforce
= require('typeforce')
8588 var types
= require('./types')
8590 function fromBase58Check (address
) {
8591 var payload
= bs58check
.decode(address
)
8592 if (payload
.length
< 21) throw new TypeError(address
+ ' is too short')
8593 if (payload
.length
> 21) throw new TypeError(address
+ ' is too long')
8595 var version
= payload
.readUInt8(0)
8596 var hash
= payload
.slice(1)
8598 return { hash: hash
, version: version
}
8601 function toBase58Check (hash
, version
) {
8602 typeforce(types
.tuple(types
.Hash160bit
, types
.UInt8
), arguments
)
8604 var payload
= Buffer
.allocUnsafe(21)
8605 payload
.writeUInt8(version
, 0)
8606 hash
.copy(payload
, 1)
8608 return bs58check
.encode(payload
)
8611 function fromOutputScript (outputScript
, network
) {
8612 network
= network
|| networks
.bitcoin
8614 if (bscript
.pubKeyHash
.output
.check(outputScript
)) return toBase58Check(bscript
.compile(outputScript
).slice(3, 23), network
.pubKeyHash
)
8615 if (bscript
.scriptHash
.output
.check(outputScript
)) return toBase58Check(bscript
.compile(outputScript
).slice(2, 22), network
.scriptHash
)
8617 throw new Error(bscript
.toASM(outputScript
) + ' has no matching Address')
8620 function toOutputScript (address
, network
) {
8621 network
= network
|| networks
.bitcoin
8623 var decode
= fromBase58Check(address
)
8624 if (decode
.version
=== network
.pubKeyHash
) return bscript
.pubKeyHash
.output
.encode(decode
.hash
)
8625 if (decode
.version
=== network
.scriptHash
) return bscript
.scriptHash
.output
.encode(decode
.hash
)
8627 throw new Error(address
+ ' has no matching Script')
8631 fromBase58Check: fromBase58Check
,
8632 fromOutputScript: fromOutputScript
,
8633 toBase58Check: toBase58Check
,
8634 toOutputScript: toOutputScript
8637 },{"./networks":51,"./script":52,"./types":78,"bs58check":80,"safe-buffer":98,"typeforce":109}],43:[function(require
,module
,exports
){
8638 var Buffer
= require('safe-buffer').Buffer
8639 var bcrypto
= require('./crypto')
8640 var fastMerkleRoot
= require('merkle-lib/fastRoot')
8641 var typeforce
= require('typeforce')
8642 var types
= require('./types')
8643 var varuint
= require('varuint-bitcoin')
8645 var Transaction
= require('./transaction')
8649 this.prevHash
= null
8650 this.merkleRoot
= null
8656 Block
.fromBuffer = function (buffer
) {
8657 if (buffer
.length
< 80) throw new Error('Buffer too small (< 80 bytes)')
8660 function readSlice (n
) {
8662 return buffer
.slice(offset
- n
, offset
)
8665 function readUInt32 () {
8666 var i
= buffer
.readUInt32LE(offset
)
8671 function readInt32 () {
8672 var i
= buffer
.readInt32LE(offset
)
8677 var block
= new Block()
8678 block
.version
= readInt32()
8679 block
.prevHash
= readSlice(32)
8680 block
.merkleRoot
= readSlice(32)
8681 block
.timestamp
= readUInt32()
8682 block
.bits
= readUInt32()
8683 block
.nonce
= readUInt32()
8685 if (buffer
.length
=== 80) return block
8687 function readVarInt () {
8688 var vi
= varuint
.decode(buffer
, offset
)
8689 offset
+= varuint
.decode
.bytes
8693 function readTransaction () {
8694 var tx
= Transaction
.fromBuffer(buffer
.slice(offset
), true)
8695 offset
+= tx
.byteLength()
8699 var nTransactions
= readVarInt()
8700 block
.transactions
= []
8702 for (var i
= 0; i
< nTransactions
; ++i
) {
8703 var tx
= readTransaction()
8704 block
.transactions
.push(tx
)
8710 Block
.prototype.byteLength = function (headersOnly
) {
8711 if (headersOnly
|| !this.transactions
) return 80
8713 return 80 + varuint
.encodingLength(this.transactions
.length
) + this.transactions
.reduce(function (a
, x
) {
8714 return a
+ x
.byteLength()
8718 Block
.fromHex = function (hex
) {
8719 return Block
.fromBuffer(Buffer
.from(hex
, 'hex'))
8722 Block
.prototype.getHash = function () {
8723 return bcrypto
.hash256(this.toBuffer(true))
8726 Block
.prototype.getId = function () {
8727 return this.getHash().reverse().toString('hex')
8730 Block
.prototype.getUTCDate = function () {
8731 var date
= new Date(0) // epoch
8732 date
.setUTCSeconds(this.timestamp
)
8737 // TODO: buffer, offset compatibility
8738 Block
.prototype.toBuffer = function (headersOnly
) {
8739 var buffer
= Buffer
.allocUnsafe(this.byteLength(headersOnly
))
8742 function writeSlice (slice
) {
8743 slice
.copy(buffer
, offset
)
8744 offset
+= slice
.length
8747 function writeInt32 (i
) {
8748 buffer
.writeInt32LE(i
, offset
)
8751 function writeUInt32 (i
) {
8752 buffer
.writeUInt32LE(i
, offset
)
8756 writeInt32(this.version
)
8757 writeSlice(this.prevHash
)
8758 writeSlice(this.merkleRoot
)
8759 writeUInt32(this.timestamp
)
8760 writeUInt32(this.bits
)
8761 writeUInt32(this.nonce
)
8763 if (headersOnly
|| !this.transactions
) return buffer
8765 varuint
.encode(this.transactions
.length
, buffer
, offset
)
8766 offset
+= varuint
.encode
.bytes
8768 this.transactions
.forEach(function (tx
) {
8769 var txSize
= tx
.byteLength() // TODO: extract from toBuffer?
8770 tx
.toBuffer(buffer
, offset
)
8777 Block
.prototype.toHex = function (headersOnly
) {
8778 return this.toBuffer(headersOnly
).toString('hex')
8781 Block
.calculateTarget = function (bits
) {
8782 var exponent
= ((bits
& 0xff000000) >> 24) - 3
8783 var mantissa
= bits
& 0x007fffff
8784 var target
= Buffer
.alloc(32, 0)
8785 target
.writeUInt32BE(mantissa
, 28 - exponent
)
8789 Block
.calculateMerkleRoot = function (transactions
) {
8790 typeforce([{ getHash: types
.Function
}], transactions
)
8791 if (transactions
.length
=== 0) throw TypeError('Cannot compute merkle root for zero transactions')
8793 var hashes
= transactions
.map(function (transaction
) {
8794 return transaction
.getHash()
8797 return fastMerkleRoot(hashes
, bcrypto
.hash256
)
8800 Block
.prototype.checkMerkleRoot = function () {
8801 if (!this.transactions
) return false
8803 var actualMerkleRoot
= Block
.calculateMerkleRoot(this.transactions
)
8804 return this.merkleRoot
.compare(actualMerkleRoot
) === 0
8807 Block
.prototype.checkProofOfWork = function () {
8808 var hash
= this.getHash().reverse()
8809 var target
= Block
.calculateTarget(this.bits
)
8811 return hash
.compare(target
) <= 0
8814 module
.exports
= Block
8816 },{"./crypto":45,"./transaction":76,"./types":78,"merkle-lib/fastRoot":94,"safe-buffer":98,"typeforce":109,"varuint-bitcoin":111}],44:[function(require
,module
,exports
){
8817 var pushdata
= require('pushdata-bitcoin')
8818 var varuint
= require('varuint-bitcoin')
8820 // https://github.com/feross/buffer/blob/master/index.js#L1127
8821 function verifuint (value
, max
) {
8822 if (typeof value
!== 'number') throw new Error('cannot write a non-number as a number')
8823 if (value
< 0) throw new Error('specified a negative value for writing an unsigned value')
8824 if (value
> max
) throw new Error('RangeError: value out of range')
8825 if (Math
.floor(value
) !== value
) throw new Error('value has a fractional component')
8828 function readUInt64LE (buffer
, offset
) {
8829 var a
= buffer
.readUInt32LE(offset
)
8830 var b
= buffer
.readUInt32LE(offset
+ 4)
8833 verifuint(b
+ a
, 0x001fffffffffffff)
8838 function writeUInt64LE (buffer
, value
, offset
) {
8839 verifuint(value
, 0x001fffffffffffff)
8841 buffer
.writeInt32LE(value
& -1, offset
)
8842 buffer
.writeUInt32LE(Math
.floor(value
/ 0x100000000), offset
+ 4)
8846 // TODO: remove in 4.0.0?
8847 function readVarInt (buffer
, offset
) {
8848 var result
= varuint
.decode(buffer
, offset
)
8852 size: varuint
.decode
.bytes
8856 // TODO: remove in 4.0.0?
8857 function writeVarInt (buffer
, number
, offset
) {
8858 varuint
.encode(number
, buffer
, offset
)
8859 return varuint
.encode
.bytes
8863 pushDataSize: pushdata
.encodingLength
,
8864 readPushDataInt: pushdata
.decode
,
8865 readUInt64LE: readUInt64LE
,
8866 readVarInt: readVarInt
,
8867 varIntBuffer: varuint
.encode
,
8868 varIntSize: varuint
.encodingLength
,
8869 writePushDataInt: pushdata
.encode
,
8870 writeUInt64LE: writeUInt64LE
,
8871 writeVarInt: writeVarInt
8874 },{"pushdata-bitcoin":95,"varuint-bitcoin":111}],45:[function(require
,module
,exports
){
8875 var createHash
= require('create-hash')
8877 function ripemd160 (buffer
) {
8878 return createHash('rmd160').update(buffer
).digest()
8881 function sha1 (buffer
) {
8882 return createHash('sha1').update(buffer
).digest()
8885 function sha256 (buffer
) {
8886 return createHash('sha256').update(buffer
).digest()
8889 function hash160 (buffer
) {
8890 return ripemd160(sha256(buffer
))
8893 function hash256 (buffer
) {
8894 return sha256(sha256(buffer
))
8900 ripemd160: ripemd160
,
8905 },{"create-hash":82}],46:[function(require
,module
,exports
){
8906 var Buffer
= require('safe-buffer').Buffer
8907 var createHmac
= require('create-hmac')
8908 var typeforce
= require('typeforce')
8909 var types
= require('./types')
8911 var BigInteger
= require('bigi')
8912 var ECSignature
= require('./ecsignature')
8914 var ZERO
= Buffer
.alloc(1, 0)
8915 var ONE
= Buffer
.alloc(1, 1)
8917 var ecurve
= require('ecurve')
8918 var secp256k1
= ecurve
.getCurveByName('secp256k1')
8920 // https://tools.ietf.org/html/rfc6979#section-3.2
8921 function deterministicGenerateK (hash
, x
, checkSig
) {
8922 typeforce(types
.tuple(
8928 // Step A, ignored as hash already provided
8931 var k
= Buffer
.alloc(32, 0)
8932 var v
= Buffer
.alloc(32, 1)
8935 k
= createHmac('sha256', k
)
8943 v
= createHmac('sha256', k
).update(v
).digest()
8946 k
= createHmac('sha256', k
)
8954 v
= createHmac('sha256', k
).update(v
).digest()
8956 // Step H1/H2a, ignored as tlen === qlen (256 bit)
8958 v
= createHmac('sha256', k
).update(v
).digest()
8960 var T
= BigInteger
.fromBuffer(v
)
8962 // Step H3, repeat until T is within the interval [1, n - 1] and is suitable for ECDSA
8963 while (T
.signum() <= 0 || T
.compareTo(secp256k1
.n
) >= 0 || !checkSig(T
)) {
8964 k
= createHmac('sha256', k
)
8969 v
= createHmac('sha256', k
).update(v
).digest()
8971 // Step H1/H2a, again, ignored as tlen === qlen (256 bit)
8973 v
= createHmac('sha256', k
).update(v
).digest()
8974 T
= BigInteger
.fromBuffer(v
)
8980 var N_OVER_TWO
= secp256k1
.n
.shiftRight(1)
8982 function sign (hash
, d
) {
8983 typeforce(types
.tuple(types
.Hash256bit
, types
.BigInt
), arguments
)
8985 var x
= d
.toBuffer(32)
8986 var e
= BigInteger
.fromBuffer(hash
)
8991 deterministicGenerateK(hash
, x
, function (k
) {
8992 var Q
= G
.multiply(k
)
8994 if (secp256k1
.isInfinity(Q
)) return false
8996 r
= Q
.affineX
.mod(n
)
8997 if (r
.signum() === 0) return false
8999 s
= k
.modInverse(n
).multiply(e
.add(d
.multiply(r
))).mod(n
)
9000 if (s
.signum() === 0) return false
9005 // enforce low S values, see bip62: 'low s values in signatures'
9006 if (s
.compareTo(N_OVER_TWO
) > 0) {
9010 return new ECSignature(r
, s
)
9013 function verify (hash
, signature
, Q
) {
9014 typeforce(types
.tuple(
9026 // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]
9027 if (r
.signum() <= 0 || r
.compareTo(n
) >= 0) return false
9028 if (s
.signum() <= 0 || s
.compareTo(n
) >= 0) return false
9030 // 1.4.2 H = Hash(M), already done by the user
9032 var e
= BigInteger
.fromBuffer(hash
)
9035 var sInv
= s
.modInverse(n
)
9037 // 1.4.4 Compute u1 = es^−1 mod n
9038 // u2 = rs^−1 mod n
9039 var u1
= e
.multiply(sInv
).mod(n
)
9040 var u2
= r
.multiply(sInv
).mod(n
)
9042 // 1.4.5 Compute R = (xR, yR)
9044 var R
= G
.multiplyTwo(u1
, Q
, u2
)
9046 // 1.4.5 (cont.) Enforce R is not at infinity
9047 if (secp256k1
.isInfinity(R
)) return false
9049 // 1.4.6 Convert the field element R.x to an integer
9052 // 1.4.7 Set v = xR mod n
9055 // 1.4.8 If v = r, output "valid", and if v != r, output "invalid"
9060 deterministicGenerateK: deterministicGenerateK
,
9068 },{"./ecsignature":48,"./types":78,"bigi":37,"create-hmac":85,"ecurve":89,"safe-buffer":98,"typeforce":109}],47:[function(require
,module
,exports
){
9069 var baddress
= require('./address')
9070 var bcrypto
= require('./crypto')
9071 var ecdsa
= require('./ecdsa')
9072 var randomBytes
= require('randombytes')
9073 var typeforce
= require('typeforce')
9074 var types
= require('./types')
9075 var wif
= require('wif')
9077 var NETWORKS
= require('./networks')
9078 var BigInteger
= require('bigi')
9080 var ecurve
= require('ecurve')
9081 var secp256k1
= ecdsa
.__curve
9083 function ECPair (d
, Q
, options
) {
9086 compressed: types
.maybe(types
.Boolean
),
9087 network: types
.maybe(types
.Network
)
9091 options
= options
|| {}
9094 if (d
.signum() <= 0) throw new Error('Private key must be greater than 0')
9095 if (d
.compareTo(secp256k1
.n
) >= 0) throw new Error('Private key must be less than the curve order')
9096 if (Q
) throw new TypeError('Unexpected publicKey parameter')
9100 typeforce(types
.ECPoint
, Q
)
9105 this.compressed
= options
.compressed
=== undefined ? true : options
.compressed
9106 this.network
= options
.network
|| NETWORKS
.bitcoin
9109 Object
.defineProperty(ECPair
.prototype, 'Q', {
9111 if (!this.__Q
&& this.d
) {
9112 this.__Q
= secp256k1
.G
.multiply(this.d
)
9119 ECPair
.fromPublicKeyBuffer = function (buffer
, network
) {
9120 var Q
= ecurve
.Point
.decodeFrom(secp256k1
, buffer
)
9122 return new ECPair(null, Q
, {
9123 compressed: Q
.compressed
,
9128 ECPair
.fromWIF = function (string
, network
) {
9129 var decoded
= wif
.decode(string
)
9130 var version
= decoded
.version
9132 // list of networks?
9133 if (types
.Array(network
)) {
9134 network
= network
.filter(function (x
) {
9135 return version
=== x
.wif
9138 if (!network
) throw new Error('Unknown network version')
9140 // otherwise, assume a network object (or default to bitcoin)
9142 network
= network
|| NETWORKS
.bitcoin
9144 if (version
!== network
.wif
) throw new Error('Invalid network version')
9147 var d
= BigInteger
.fromBuffer(decoded
.privateKey
)
9149 return new ECPair(d
, null, {
9150 compressed: decoded
.compressed
,
9155 ECPair
.makeRandom = function (options
) {
9156 options
= options
|| {}
9158 var rng
= options
.rng
|| randomBytes
9162 var buffer
= rng(32)
9163 typeforce(types
.Buffer256bit
, buffer
)
9165 d
= BigInteger
.fromBuffer(buffer
)
9166 } while (d
.signum() <= 0 || d
.compareTo(secp256k1
.n
) >= 0)
9168 return new ECPair(d
, null, options
)
9171 ECPair
.prototype.getAddress = function () {
9172 return baddress
.toBase58Check(bcrypto
.hash160(this.getPublicKeyBuffer()), this.getNetwork().pubKeyHash
)
9175 ECPair
.prototype.getNetwork = function () {
9179 ECPair
.prototype.getPublicKeyBuffer = function () {
9180 return this.Q
.getEncoded(this.compressed
)
9183 ECPair
.prototype.sign = function (hash
) {
9184 if (!this.d
) throw new Error('Missing private key')
9186 return ecdsa
.sign(hash
, this.d
)
9189 ECPair
.prototype.toWIF = function () {
9190 if (!this.d
) throw new Error('Missing private key')
9192 return wif
.encode(this.network
.wif
, this.d
.toBuffer(32), this.compressed
)
9195 ECPair
.prototype.verify = function (hash
, signature
) {
9196 return ecdsa
.verify(hash
, signature
, this.Q
)
9199 module
.exports
= ECPair
9201 },{"./address":42,"./crypto":45,"./ecdsa":46,"./networks":51,"./types":78,"bigi":37,"ecurve":89,"randombytes":96,"typeforce":109,"wif":112}],48:[function(require
,module
,exports
){
9203 var bip66
= require('bip66')
9204 var typeforce
= require('typeforce')
9205 var types
= require('./types')
9207 var BigInteger
= require('bigi')
9209 function ECSignature (r
, s
) {
9210 typeforce(types
.tuple(types
.BigInt
, types
.BigInt
), arguments
)
9216 ECSignature
.parseCompact = function (buffer
) {
9217 if (buffer
.length
!== 65) throw new Error('Invalid signature length')
9219 var flagByte
= buffer
.readUInt8(0) - 27
9220 if (flagByte
!== (flagByte
& 7)) throw new Error('Invalid signature parameter')
9222 var compressed
= !!(flagByte
& 4)
9223 var recoveryParam
= flagByte
& 3
9225 var r
= BigInteger
.fromBuffer(buffer
.slice(1, 33))
9226 var s
= BigInteger
.fromBuffer(buffer
.slice(33))
9229 compressed: compressed
,
9231 signature: new ECSignature(r
, s
)
9235 ECSignature
.fromDER = function (buffer
) {
9236 var decode
= bip66
.decode(buffer
)
9237 var r
= BigInteger
.fromDERInteger(decode
.r
)
9238 var s
= BigInteger
.fromDERInteger(decode
.s
)
9240 return new ECSignature(r
, s
)
9243 // BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are allowed)
9244 ECSignature
.parseScriptSignature = function (buffer
) {
9245 var hashType
= buffer
.readUInt8(buffer
.length
- 1)
9246 var hashTypeMod
= hashType
& ~0x80
9248 if (hashTypeMod
<= 0x00 || hashTypeMod
>= 0x04) throw new Error('Invalid hashType ' + hashType
)
9251 signature: ECSignature
.fromDER(buffer
.slice(0, -1)),
9256 ECSignature
.prototype.toCompact = function (i
, compressed
) {
9263 var buffer
= Buffer
.alloc(65)
9264 buffer
.writeUInt8(i
, 0)
9265 this.r
.toBuffer(32).copy(buffer
, 1)
9266 this.s
.toBuffer(32).copy(buffer
, 33)
9271 ECSignature
.prototype.toDER = function () {
9272 var r
= Buffer
.from(this.r
.toDERInteger())
9273 var s
= Buffer
.from(this.s
.toDERInteger())
9275 return bip66
.encode(r
, s
)
9278 ECSignature
.prototype.toScriptSignature = function (hashType
) {
9279 var hashTypeMod
= hashType
& ~0x80
9280 if (hashTypeMod
<= 0 || hashTypeMod
>= 4) throw new Error('Invalid hashType ' + hashType
)
9282 var hashTypeBuffer
= Buffer
.alloc(1)
9283 hashTypeBuffer
.writeUInt8(hashType
, 0)
9285 return Buffer
.concat([this.toDER(), hashTypeBuffer
])
9288 module
.exports
= ECSignature
9290 }).call(this,require("buffer").Buffer
)
9291 },{"./types":78,"bigi":37,"bip66":39,"buffer":4,"typeforce":109}],49:[function(require
,module
,exports
){
9292 var Buffer
= require('safe-buffer').Buffer
9293 var base58check
= require('bs58check')
9294 var bcrypto
= require('./crypto')
9295 var createHmac
= require('create-hmac')
9296 var typeforce
= require('typeforce')
9297 var types
= require('./types')
9298 var NETWORKS
= require('./networks')
9300 var BigInteger
= require('bigi')
9301 var ECPair
= require('./ecpair')
9303 var ecurve
= require('ecurve')
9304 var curve
= ecurve
.getCurveByName('secp256k1')
9306 function HDNode (keyPair
, chainCode
) {
9307 typeforce(types
.tuple('ECPair', types
.Buffer256bit
), arguments
)
9309 if (!keyPair
.compressed
) throw new TypeError('BIP32 only allows compressed keyPairs')
9311 this.keyPair
= keyPair
9312 this.chainCode
= chainCode
9315 this.parentFingerprint
= 0x00000000
9318 HDNode
.HIGHEST_BIT
= 0x80000000
9320 HDNode
.MASTER_SECRET
= Buffer
.from('Bitcoin seed', 'utf8')
9322 HDNode
.fromSeedBuffer = function (seed
, network
) {
9323 typeforce(types
.tuple(types
.Buffer
, types
.maybe(types
.Network
)), arguments
)
9325 if (seed
.length
< 16) throw new TypeError('Seed should be at least 128 bits')
9326 if (seed
.length
> 64) throw new TypeError('Seed should be at most 512 bits')
9328 var I
= createHmac('sha512', HDNode
.MASTER_SECRET
).update(seed
).digest()
9329 var IL
= I
.slice(0, 32)
9330 var IR
= I
.slice(32)
9332 // In case IL is 0 or >= n, the master key is invalid
9333 // This is handled by the ECPair constructor
9334 var pIL
= BigInteger
.fromBuffer(IL
)
9335 var keyPair
= new ECPair(pIL
, null, {
9339 return new HDNode(keyPair
, IR
)
9342 HDNode
.fromSeedHex = function (hex
, network
) {
9343 return HDNode
.fromSeedBuffer(Buffer
.from(hex
, 'hex'), network
)
9346 HDNode
.fromBase58 = function (string
, networks
) {
9347 var buffer
= base58check
.decode(string
)
9348 if (buffer
.length
!== 78) throw new Error('Invalid buffer length')
9350 // 4 bytes: version bytes
9351 var version
= buffer
.readUInt32BE(0)
9354 // list of networks?
9355 if (Array
.isArray(networks
)) {
9356 network
= networks
.filter(function (x
) {
9357 return version
=== x
.bip32
.private ||
9358 version
=== x
.bip32
.public
9361 if (!network
) throw new Error('Unknown network version')
9363 // otherwise, assume a network object (or default to bitcoin)
9365 network
= networks
|| NETWORKS
.bitcoin
9368 if (version
!== network
.bip32
.private &&
9369 version
!== network
.bip32
.public) throw new Error('Invalid network version')
9371 // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ...
9372 var depth
= buffer
[4]
9374 // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
9375 var parentFingerprint
= buffer
.readUInt32BE(5)
9377 if (parentFingerprint
!== 0x00000000) throw new Error('Invalid parent fingerprint')
9380 // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
9381 // This is encoded in MSB order. (0x00000000 if master key)
9382 var index
= buffer
.readUInt32BE(9)
9383 if (depth
=== 0 && index
!== 0) throw new Error('Invalid index')
9385 // 32 bytes: the chain code
9386 var chainCode
= buffer
.slice(13, 45)
9389 // 33 bytes: private key data (0x00 + k)
9390 if (version
=== network
.bip32
.private) {
9391 if (buffer
.readUInt8(45) !== 0x00) throw new Error('Invalid private key')
9393 var d
= BigInteger
.fromBuffer(buffer
.slice(46, 78))
9394 keyPair
= new ECPair(d
, null, { network: network
})
9396 // 33 bytes: public key data (0x02 + X or 0x03 + X)
9398 var Q
= ecurve
.Point
.decodeFrom(curve
, buffer
.slice(45, 78))
9399 // Q.compressed is assumed, if somehow this assumption is broken, `new HDNode` will throw
9401 // Verify that the X coordinate in the public point corresponds to a point on the curve.
9402 // If not, the extended public key is invalid.
9405 keyPair
= new ECPair(null, Q
, { network: network
})
9408 var hd
= new HDNode(keyPair
, chainCode
)
9411 hd
.parentFingerprint
= parentFingerprint
9416 HDNode
.prototype.getAddress = function () {
9417 return this.keyPair
.getAddress()
9420 HDNode
.prototype.getIdentifier = function () {
9421 return bcrypto
.hash160(this.keyPair
.getPublicKeyBuffer())
9424 HDNode
.prototype.getFingerprint = function () {
9425 return this.getIdentifier().slice(0, 4)
9428 HDNode
.prototype.getNetwork = function () {
9429 return this.keyPair
.getNetwork()
9432 HDNode
.prototype.getPublicKeyBuffer = function () {
9433 return this.keyPair
.getPublicKeyBuffer()
9436 HDNode
.prototype.neutered = function () {
9437 var neuteredKeyPair
= new ECPair(null, this.keyPair
.Q
, {
9438 network: this.keyPair
.network
9441 var neutered
= new HDNode(neuteredKeyPair
, this.chainCode
)
9442 neutered
.depth
= this.depth
9443 neutered
.index
= this.index
9444 neutered
.parentFingerprint
= this.parentFingerprint
9449 HDNode
.prototype.sign = function (hash
) {
9450 return this.keyPair
.sign(hash
)
9453 HDNode
.prototype.verify = function (hash
, signature
) {
9454 return this.keyPair
.verify(hash
, signature
)
9457 HDNode
.prototype.toBase58 = function (__isPrivate
) {
9458 if (__isPrivate
!== undefined) throw new TypeError('Unsupported argument in 2.0.0')
9461 var network
= this.keyPair
.network
9462 var version
= (!this.isNeutered()) ? network
.bip32
.private : network
.bip32
.public
9463 var buffer
= Buffer
.allocUnsafe(78)
9465 // 4 bytes: version bytes
9466 buffer
.writeUInt32BE(version
, 0)
9468 // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
9469 buffer
.writeUInt8(this.depth
, 4)
9471 // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
9472 buffer
.writeUInt32BE(this.parentFingerprint
, 5)
9474 // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
9475 // This is encoded in big endian. (0x00000000 if master key)
9476 buffer
.writeUInt32BE(this.index
, 9)
9478 // 32 bytes: the chain code
9479 this.chainCode
.copy(buffer
, 13)
9481 // 33 bytes: the public key or private key data
9482 if (!this.isNeutered()) {
9483 // 0x00 + k for private keys
9484 buffer
.writeUInt8(0, 45)
9485 this.keyPair
.d
.toBuffer(32).copy(buffer
, 46)
9487 // 33 bytes: the public key
9489 // X9.62 encoding for public keys
9490 this.keyPair
.getPublicKeyBuffer().copy(buffer
, 45)
9493 return base58check
.encode(buffer
)
9496 // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
9497 HDNode
.prototype.derive = function (index
) {
9498 typeforce(types
.UInt32
, index
)
9500 var isHardened
= index
>= HDNode
.HIGHEST_BIT
9501 var data
= Buffer
.allocUnsafe(37)
9505 if (this.isNeutered()) throw new TypeError('Could not derive hardened child key')
9507 // data = 0x00 || ser256(kpar) || ser32(index)
9509 this.keyPair
.d
.toBuffer(32).copy(data
, 1)
9510 data
.writeUInt32BE(index
, 33)
9514 // data = serP(point(kpar)) || ser32(index)
9515 // = serP(Kpar) || ser32(index)
9516 this.keyPair
.getPublicKeyBuffer().copy(data
, 0)
9517 data
.writeUInt32BE(index
, 33)
9520 var I
= createHmac('sha512', this.chainCode
).update(data
).digest()
9521 var IL
= I
.slice(0, 32)
9522 var IR
= I
.slice(32)
9524 var pIL
= BigInteger
.fromBuffer(IL
)
9526 // In case parse256(IL) >= n, proceed with the next value for i
9527 if (pIL
.compareTo(curve
.n
) >= 0) {
9528 return this.derive(index
+ 1)
9531 // Private parent key -> private child key
9533 if (!this.isNeutered()) {
9534 // ki = parse256(IL) + kpar (mod n)
9535 var ki
= pIL
.add(this.keyPair
.d
).mod(curve
.n
)
9537 // In case ki == 0, proceed with the next value for i
9538 if (ki
.signum() === 0) {
9539 return this.derive(index
+ 1)
9542 derivedKeyPair
= new ECPair(ki
, null, {
9543 network: this.keyPair
.network
9546 // Public parent key -> public child key
9548 // Ki = point(parse256(IL)) + Kpar
9550 var Ki
= curve
.G
.multiply(pIL
).add(this.keyPair
.Q
)
9552 // In case Ki is the point at infinity, proceed with the next value for i
9553 if (curve
.isInfinity(Ki
)) {
9554 return this.derive(index
+ 1)
9557 derivedKeyPair
= new ECPair(null, Ki
, {
9558 network: this.keyPair
.network
9562 var hd
= new HDNode(derivedKeyPair
, IR
)
9563 hd
.depth
= this.depth
+ 1
9565 hd
.parentFingerprint
= this.getFingerprint().readUInt32BE(0)
9570 HDNode
.prototype.deriveHardened = function (index
) {
9571 typeforce(types
.UInt31
, index
)
9573 // Only derives hardened private keys by default
9574 return this.derive(index
+ HDNode
.HIGHEST_BIT
)
9577 // Private === not neutered
9578 // Public === neutered
9579 HDNode
.prototype.isNeutered = function () {
9580 return !(this.keyPair
.d
)
9583 HDNode
.prototype.derivePath = function (path
) {
9584 typeforce(types
.BIP32Path
, path
)
9586 var splitPath
= path
.split('/')
9587 if (splitPath
[0] === 'm') {
9588 if (this.parentFingerprint
) {
9589 throw new Error('Not a master node')
9592 splitPath
= splitPath
.slice(1)
9595 return splitPath
.reduce(function (prevHd
, indexStr
) {
9597 if (indexStr
.slice(-1) === "'") {
9598 index
= parseInt(indexStr
.slice(0, -1), 10)
9599 return prevHd
.deriveHardened(index
)
9601 index
= parseInt(indexStr
, 10)
9602 return prevHd
.derive(index
)
9607 module
.exports
= HDNode
9609 },{"./crypto":45,"./ecpair":47,"./networks":51,"./types":78,"bigi":37,"bs58check":80,"create-hmac":85,"ecurve":89,"safe-buffer":98,"typeforce":109}],50:[function(require
,module
,exports
){
9611 Block: require('./block'),
9612 ECPair: require('./ecpair'),
9613 ECSignature: require('./ecsignature'),
9614 HDNode: require('./hdnode'),
9615 Transaction: require('./transaction'),
9616 TransactionBuilder: require('./transaction_builder'),
9618 address: require('./address'),
9619 bufferutils: require('./bufferutils'), // TODO: remove in 4.0.0
9620 crypto: require('./crypto'),
9621 networks: require('./networks'),
9622 opcodes: require('bitcoin-ops'),
9623 script: require('./script')
9626 },{"./address":42,"./block":43,"./bufferutils":44,"./crypto":45,"./ecpair":47,"./ecsignature":48,"./hdnode":49,"./networks":51,"./script":52,"./transaction":76,"./transaction_builder":77,"bitcoin-ops":40}],51:[function(require
,module
,exports
){
9627 // https://en.bitcoin.it/wiki/List_of_address_prefixes
9628 // Dogecoin BIP32 is a proposed standard: https://bitcointalk.org/index.php?topic=409731
9632 messagePrefix: '\x18Bitcoin Signed Message:\n',
9642 messagePrefix: '\x18Bitcoin Signed Message:\n',
9652 messagePrefix: '\x19Litecoin Signed Message:\n',
9655 private: 0x0488ade4,
9662 messagePrefix: '\x19Litecoin Signed Message:\n',
9673 },{}],52:[function(require
,module
,exports
){
9674 var Buffer
= require('safe-buffer').Buffer
9675 var bip66
= require('bip66')
9676 var pushdata
= require('pushdata-bitcoin')
9677 var typeforce
= require('typeforce')
9678 var types
= require('./types')
9679 var scriptNumber
= require('./script_number')
9681 var OPS
= require('bitcoin-ops')
9682 var REVERSE_OPS
= require('bitcoin-ops/map')
9683 var OP_INT_BASE
= OPS
.OP_RESERVED
// OP_1 - 1
9685 function isOPInt (value
) {
9686 return types
.Number(value
) &&
9687 ((value
=== OPS
.OP_0
) ||
9688 (value
>= OPS
.OP_1
&& value
<= OPS
.OP_16
) ||
9689 (value
=== OPS
.OP_1NEGATE
))
9692 function isPushOnlyChunk (value
) {
9693 return types
.Buffer(value
) || isOPInt(value
)
9696 function isPushOnly (value
) {
9697 return types
.Array(value
) && value
.every(isPushOnlyChunk
)
9700 function compile (chunks
) {
9702 if (Buffer
.isBuffer(chunks
)) return chunks
9704 typeforce(types
.Array
, chunks
)
9706 var bufferSize
= chunks
.reduce(function (accum
, chunk
) {
9708 if (Buffer
.isBuffer(chunk
)) {
9709 // adhere to BIP62.3, minimal push policy
9710 if (chunk
.length
=== 1 && (chunk
[0] === 0x81 || (chunk
[0] >= 1 && chunk
[0] <= 16))) {
9714 return accum
+ pushdata
.encodingLength(chunk
.length
) + chunk
.length
9721 var buffer
= Buffer
.allocUnsafe(bufferSize
)
9724 chunks
.forEach(function (chunk
) {
9726 if (Buffer
.isBuffer(chunk
)) {
9727 // adhere to BIP62.3, minimal push policy
9728 if (chunk
.length
=== 1 && chunk
[0] >= 1 && chunk
[0] <= 16) {
9729 var opcode
= OP_INT_BASE
+ chunk
[0]
9730 buffer
.writeUInt8(opcode
, offset
)
9735 if (chunk
.length
=== 1 && chunk
[0] === 0x81) {
9736 buffer
.writeUInt8(OPS
.OP_1NEGATE
, offset
)
9741 offset
+= pushdata
.encode(buffer
, chunk
.length
, offset
)
9743 chunk
.copy(buffer
, offset
)
9744 offset
+= chunk
.length
9748 buffer
.writeUInt8(chunk
, offset
)
9753 if (offset
!== buffer
.length
) throw new Error('Could not decode chunks')
9757 function decompile (buffer
) {
9759 if (types
.Array(buffer
)) return buffer
9761 typeforce(types
.Buffer
, buffer
)
9766 while (i
< buffer
.length
) {
9767 var opcode
= buffer
[i
]
9770 if ((opcode
> OPS
.OP_0
) && (opcode
<= OPS
.OP_PUSHDATA4
)) {
9771 var d
= pushdata
.decode(buffer
, i
)
9773 // did reading a pushDataInt fail? empty script
9774 if (d
=== null) return []
9777 // attempt to read too much data? empty script
9778 if (i
+ d
.number
> buffer
.length
) return []
9780 var data
= buffer
.slice(i
, i
+ d
.number
)
9796 function toASM (chunks
) {
9797 if (Buffer
.isBuffer(chunks
)) {
9798 chunks
= decompile(chunks
)
9801 return chunks
.map(function (chunk
) {
9803 if (Buffer
.isBuffer(chunk
)) return chunk
.toString('hex')
9806 return REVERSE_OPS
[chunk
]
9810 function fromASM (asm
) {
9811 typeforce(types
.String
, asm
)
9813 return compile(asm
.split(' ').map(function (chunkStr
) {
9815 if (OPS
[chunkStr
] !== undefined) return OPS
[chunkStr
]
9816 typeforce(types
.Hex
, chunkStr
)
9819 return Buffer
.from(chunkStr
, 'hex')
9823 function toStack (chunks
) {
9824 chunks
= decompile(chunks
)
9825 typeforce(isPushOnly
, chunks
)
9827 return chunks
.map(function (op
) {
9828 if (Buffer
.isBuffer(op
)) return op
9829 if (op
=== OPS
.OP_0
) return Buffer
.allocUnsafe(0)
9831 return scriptNumber
.encode(op
- OP_INT_BASE
)
9835 function isCanonicalPubKey (buffer
) {
9836 if (!Buffer
.isBuffer(buffer
)) return false
9837 if (buffer
.length
< 33) return false
9839 switch (buffer
[0]) {
9842 return buffer
.length
=== 33
9844 return buffer
.length
=== 65
9850 function isDefinedHashType (hashType
) {
9851 var hashTypeMod
= hashType
& ~0x80
9853 // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
9854 return hashTypeMod
> 0x00 && hashTypeMod
< 0x04
9857 function isCanonicalSignature (buffer
) {
9858 if (!Buffer
.isBuffer(buffer
)) return false
9859 if (!isDefinedHashType(buffer
[buffer
.length
- 1])) return false
9861 return bip66
.check(buffer
.slice(0, -1))
9866 decompile: decompile
,
9871 number: require('./script_number'),
9873 isCanonicalPubKey: isCanonicalPubKey
,
9874 isCanonicalSignature: isCanonicalSignature
,
9875 isPushOnly: isPushOnly
,
9876 isDefinedHashType: isDefinedHashType
9879 var templates
= require('./templates')
9880 for (var key
in templates
) {
9881 module
.exports
[key
] = templates
[key
]
9884 },{"./script_number":53,"./templates":54,"./types":78,"bip66":39,"bitcoin-ops":40,"bitcoin-ops/map":41,"pushdata-bitcoin":95,"safe-buffer":98,"typeforce":109}],53:[function(require
,module
,exports
){
9885 var Buffer
= require('safe-buffer').Buffer
9887 function decode (buffer
, maxLength
, minimal
) {
9888 maxLength
= maxLength
|| 4
9889 minimal
= minimal
=== undefined ? true : minimal
9891 var length
= buffer
.length
9892 if (length
=== 0) return 0
9893 if (length
> maxLength
) throw new TypeError('Script number overflow')
9895 if ((buffer
[length
- 1] & 0x7f) === 0) {
9896 if (length
<= 1 || (buffer
[length
- 2] & 0x80) === 0) throw new Error('Non-minimally encoded script number')
9902 var a
= buffer
.readUInt32LE(0)
9903 var b
= buffer
.readUInt8(4)
9905 if (b
& 0x80) return -(((b
& ~0x80) * 0x100000000) + a
)
9906 return (b
* 0x100000000) + a
9911 // 32-bit / 24-bit / 16-bit / 8-bit
9912 for (var i
= 0; i
< length
; ++i
) {
9913 result
|= buffer
[i
] << (8 * i
)
9916 if (buffer
[length
- 1] & 0x80) return -(result
& ~(0x80 << (8 * (length
- 1))))
9920 function scriptNumSize (i
) {
9921 return i
> 0x7fffffff ? 5
9929 function encode (number
) {
9930 var value
= Math
.abs(number
)
9931 var size
= scriptNumSize(value
)
9932 var buffer
= Buffer
.allocUnsafe(size
)
9933 var negative
= number
< 0
9935 for (var i
= 0; i
< size
; ++i
) {
9936 buffer
.writeUInt8(value
& 0xff, i
)
9940 if (buffer
[size
- 1] & 0x80) {
9941 buffer
.writeUInt8(negative
? 0x80 : 0x00, size
- 1)
9942 } else if (negative
) {
9943 buffer
[size
- 1] |= 0x80
9954 },{"safe-buffer":98}],54:[function(require
,module
,exports
){
9955 var decompile
= require('../script').decompile
9956 var multisig
= require('./multisig')
9957 var nullData
= require('./nulldata')
9958 var pubKey
= require('./pubkey')
9959 var pubKeyHash
= require('./pubkeyhash')
9960 var scriptHash
= require('./scripthash')
9961 var witnessPubKeyHash
= require('./witnesspubkeyhash')
9962 var witnessScriptHash
= require('./witnessscripthash')
9963 var witnessCommitment
= require('./witnesscommitment')
9966 MULTISIG: 'multisig',
9967 NONSTANDARD: 'nonstandard',
9968 NULLDATA: 'nulldata',
9970 P2PKH: 'pubkeyhash',
9972 P2WPKH: 'witnesspubkeyhash',
9973 P2WSH: 'witnessscripthash',
9974 WITNESS_COMMITMENT: 'witnesscommitment'
9977 function classifyOutput (script
) {
9978 if (witnessPubKeyHash
.output
.check(script
)) return types
.P2WPKH
9979 if (witnessScriptHash
.output
.check(script
)) return types
.P2WSH
9980 if (pubKeyHash
.output
.check(script
)) return types
.P2PKH
9981 if (scriptHash
.output
.check(script
)) return types
.P2SH
9983 // XXX: optimization, below functions .decompile before use
9984 var chunks
= decompile(script
)
9985 if (multisig
.output
.check(chunks
)) return types
.MULTISIG
9986 if (pubKey
.output
.check(chunks
)) return types
.P2PK
9987 if (witnessCommitment
.output
.check(chunks
)) return types
.WITNESS_COMMITMENT
9988 if (nullData
.output
.check(chunks
)) return types
.NULLDATA
9990 return types
.NONSTANDARD
9993 function classifyInput (script
, allowIncomplete
) {
9994 // XXX: optimization, below functions .decompile before use
9995 var chunks
= decompile(script
)
9997 if (pubKeyHash
.input
.check(chunks
)) return types
.P2PKH
9998 if (scriptHash
.input
.check(chunks
, allowIncomplete
)) return types
.P2SH
9999 if (multisig
.input
.check(chunks
, allowIncomplete
)) return types
.MULTISIG
10000 if (pubKey
.input
.check(chunks
)) return types
.P2PK
10002 return types
.NONSTANDARD
10005 function classifyWitness (script
, allowIncomplete
) {
10006 // XXX: optimization, below functions .decompile before use
10007 var chunks
= decompile(script
)
10009 if (witnessPubKeyHash
.input
.check(chunks
)) return types
.P2WPKH
10010 if (witnessScriptHash
.input
.check(chunks
, allowIncomplete
)) return types
.P2WSH
10012 return types
.NONSTANDARD
10016 classifyInput: classifyInput
,
10017 classifyOutput: classifyOutput
,
10018 classifyWitness: classifyWitness
,
10019 multisig: multisig
,
10020 nullData: nullData
,
10022 pubKeyHash: pubKeyHash
,
10023 scriptHash: scriptHash
,
10024 witnessPubKeyHash: witnessPubKeyHash
,
10025 witnessScriptHash: witnessScriptHash
,
10026 witnessCommitment: witnessCommitment
,
10030 },{"../script":52,"./multisig":55,"./nulldata":58,"./pubkey":59,"./pubkeyhash":62,"./scripthash":65,"./witnesscommitment":68,"./witnesspubkeyhash":70,"./witnessscripthash":73}],55:[function(require
,module
,exports
){
10032 input: require('./input'),
10033 output: require('./output')
10036 },{"./input":56,"./output":57}],56:[function(require
,module
,exports
){
10037 // OP_0 [signatures ...]
10039 var Buffer
= require('safe-buffer').Buffer
10040 var bscript
= require('../../script')
10041 var typeforce
= require('typeforce')
10042 var OPS
= require('bitcoin-ops')
10044 function partialSignature (value
) {
10045 return value
=== OPS
.OP_0
|| bscript
.isCanonicalSignature(value
)
10048 function check (script
, allowIncomplete
) {
10049 var chunks
= bscript
.decompile(script
)
10050 if (chunks
.length
< 2) return false
10051 if (chunks
[0] !== OPS
.OP_0
) return false
10053 if (allowIncomplete
) {
10054 return chunks
.slice(1).every(partialSignature
)
10057 return chunks
.slice(1).every(bscript
.isCanonicalSignature
)
10059 check
.toJSON = function () { return 'multisig input' }
10061 var EMPTY_BUFFER
= Buffer
.allocUnsafe(0)
10063 function encodeStack (signatures
, scriptPubKey
) {
10064 typeforce([partialSignature
], signatures
)
10066 if (scriptPubKey
) {
10067 var scriptData
= bscript
.multisig
.output
.decode(scriptPubKey
)
10069 if (signatures
.length
< scriptData
.m
) {
10070 throw new TypeError('Not enough signatures provided')
10073 if (signatures
.length
> scriptData
.pubKeys
.length
) {
10074 throw new TypeError('Too many signatures provided')
10078 return [].concat(EMPTY_BUFFER
, signatures
)
10081 function encode (signatures
, scriptPubKey
) {
10082 return bscript
.compile(encodeStack(signatures
, scriptPubKey
))
10085 function decodeStack (stack
, allowIncomplete
) {
10086 typeforce(check
, stack
, allowIncomplete
)
10087 return stack
.slice(1)
10090 function decode (buffer
, allowIncomplete
) {
10091 var stack
= bscript
.decompile(buffer
)
10092 return decodeStack(stack
, allowIncomplete
)
10098 decodeStack: decodeStack
,
10100 encodeStack: encodeStack
10103 },{"../../script":52,"bitcoin-ops":40,"safe-buffer":98,"typeforce":109}],57:[function(require
,module
,exports
){
10104 // m [pubKeys ...] n OP_CHECKMULTISIG
10106 var bscript
= require('../../script')
10107 var types
= require('../../types')
10108 var typeforce
= require('typeforce')
10109 var OPS
= require('bitcoin-ops')
10110 var OP_INT_BASE
= OPS
.OP_RESERVED
// OP_1 - 1
10112 function check (script
, allowIncomplete
) {
10113 var chunks
= bscript
.decompile(script
)
10115 if (chunks
.length
< 4) return false
10116 if (chunks
[chunks
.length
- 1] !== OPS
.OP_CHECKMULTISIG
) return false
10117 if (!types
.Number(chunks
[0])) return false
10118 if (!types
.Number(chunks
[chunks
.length
- 2])) return false
10119 var m
= chunks
[0] - OP_INT_BASE
10120 var n
= chunks
[chunks
.length
- 2] - OP_INT_BASE
10122 if (m
<= 0) return false
10123 if (n
> 16) return false
10124 if (m
> n
) return false
10125 if (n
!== chunks
.length
- 3) return false
10126 if (allowIncomplete
) return true
10128 var keys
= chunks
.slice(1, -2)
10129 return keys
.every(bscript
.isCanonicalPubKey
)
10131 check
.toJSON = function () { return 'multi-sig output' }
10133 function encode (m
, pubKeys
) {
10136 pubKeys: [bscript
.isCanonicalPubKey
]
10142 var n
= pubKeys
.length
10143 if (n
< m
) throw new TypeError('Not enough pubKeys provided')
10145 return bscript
.compile([].concat(
10149 OPS
.OP_CHECKMULTISIG
10153 function decode (buffer
, allowIncomplete
) {
10154 var chunks
= bscript
.decompile(buffer
)
10155 typeforce(check
, chunks
, allowIncomplete
)
10158 m: chunks
[0] - OP_INT_BASE
,
10159 pubKeys: chunks
.slice(1, -2)
10169 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],58:[function(require
,module
,exports
){
10170 // OP_RETURN {data}
10172 var bscript
= require('../script')
10173 var types
= require('../types')
10174 var typeforce
= require('typeforce')
10175 var OPS
= require('bitcoin-ops')
10177 function check (script
) {
10178 var buffer
= bscript
.compile(script
)
10180 return buffer
.length
> 1 &&
10181 buffer
[0] === OPS
.OP_RETURN
10183 check
.toJSON = function () { return 'null data output' }
10185 function encode (data
) {
10186 typeforce(types
.Buffer
, data
)
10188 return bscript
.compile([OPS
.OP_RETURN
, data
])
10191 function decode (buffer
) {
10192 typeforce(check
, buffer
)
10194 return buffer
.slice(2)
10205 },{"../script":52,"../types":78,"bitcoin-ops":40,"typeforce":109}],59:[function(require
,module
,exports
){
10206 arguments
[4][55][0].apply(exports
,arguments
)
10207 },{"./input":60,"./output":61,"dup":55}],60:[function(require
,module
,exports
){
10210 var bscript
= require('../../script')
10211 var types
= require('../../types')
10212 var typeforce
= require('typeforce')
10214 function check (script
) {
10215 var chunks
= bscript
.decompile(script
)
10217 return chunks
.length
=== 1 &&
10218 bscript
.isCanonicalSignature(chunks
[0])
10220 check
.toJSON = function () { return 'pubKey input' }
10222 function encodeStack (signature
) {
10223 typeforce(types
.Buffer
, signature
)
10227 function encode (signature
) {
10228 return bscript
.compile(encodeStack(signature
))
10231 function decodeStack (stack
) {
10232 typeforce(check
, stack
)
10236 function decode (buffer
) {
10237 var stack
= bscript
.decompile(buffer
)
10238 return decodeStack(stack
)
10244 decodeStack: decodeStack
,
10246 encodeStack: encodeStack
10249 },{"../../script":52,"../../types":78,"typeforce":109}],61:[function(require
,module
,exports
){
10250 // {pubKey} OP_CHECKSIG
10252 var bscript
= require('../../script')
10253 var typeforce
= require('typeforce')
10254 var OPS
= require('bitcoin-ops')
10256 function check (script
) {
10257 var chunks
= bscript
.decompile(script
)
10259 return chunks
.length
=== 2 &&
10260 bscript
.isCanonicalPubKey(chunks
[0]) &&
10261 chunks
[1] === OPS
.OP_CHECKSIG
10263 check
.toJSON = function () { return 'pubKey output' }
10265 function encode (pubKey
) {
10266 typeforce(bscript
.isCanonicalPubKey
, pubKey
)
10268 return bscript
.compile([pubKey
, OPS
.OP_CHECKSIG
])
10271 function decode (buffer
) {
10272 var chunks
= bscript
.decompile(buffer
)
10273 typeforce(check
, chunks
)
10284 },{"../../script":52,"bitcoin-ops":40,"typeforce":109}],62:[function(require
,module
,exports
){
10285 arguments
[4][55][0].apply(exports
,arguments
)
10286 },{"./input":63,"./output":64,"dup":55}],63:[function(require
,module
,exports
){
10287 // {signature} {pubKey}
10289 var bscript
= require('../../script')
10290 var types
= require('../../types')
10291 var typeforce
= require('typeforce')
10293 function check (script
) {
10294 var chunks
= bscript
.decompile(script
)
10296 return chunks
.length
=== 2 &&
10297 bscript
.isCanonicalSignature(chunks
[0]) &&
10298 bscript
.isCanonicalPubKey(chunks
[1])
10300 check
.toJSON = function () { return 'pubKeyHash input' }
10302 function encodeStack (signature
, pubKey
) {
10304 signature: types
.Buffer
, pubKey: types
.Buffer
10306 signature: signature
, pubKey: pubKey
10309 return [signature
, pubKey
]
10312 function encode (signature
, pubKey
) {
10313 return bscript
.compile(encodeStack(signature
, pubKey
))
10316 function decodeStack (stack
) {
10317 typeforce(check
, stack
)
10320 signature: stack
[0],
10325 function decode (buffer
) {
10326 var stack
= bscript
.decompile(buffer
)
10327 return decodeStack(stack
)
10333 decodeStack: decodeStack
,
10335 encodeStack: encodeStack
10338 },{"../../script":52,"../../types":78,"typeforce":109}],64:[function(require
,module
,exports
){
10339 // OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG
10341 var bscript
= require('../../script')
10342 var types
= require('../../types')
10343 var typeforce
= require('typeforce')
10344 var OPS
= require('bitcoin-ops')
10346 function check (script
) {
10347 var buffer
= bscript
.compile(script
)
10349 return buffer
.length
=== 25 &&
10350 buffer
[0] === OPS
.OP_DUP
&&
10351 buffer
[1] === OPS
.OP_HASH160
&&
10352 buffer
[2] === 0x14 &&
10353 buffer
[23] === OPS
.OP_EQUALVERIFY
&&
10354 buffer
[24] === OPS
.OP_CHECKSIG
10356 check
.toJSON = function () { return 'pubKeyHash output' }
10358 function encode (pubKeyHash
) {
10359 typeforce(types
.Hash160bit
, pubKeyHash
)
10361 return bscript
.compile([
10365 OPS
.OP_EQUALVERIFY
,
10370 function decode (buffer
) {
10371 typeforce(check
, buffer
)
10373 return buffer
.slice(3, 23)
10382 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],65:[function(require
,module
,exports
){
10383 arguments
[4][55][0].apply(exports
,arguments
)
10384 },{"./input":66,"./output":67,"dup":55}],66:[function(require
,module
,exports
){
10385 // <scriptSig> {serialized scriptPubKey script}
10387 var Buffer
= require('safe-buffer').Buffer
10388 var bscript
= require('../../script')
10389 var typeforce
= require('typeforce')
10391 function check (script
, allowIncomplete
) {
10392 var chunks
= bscript
.decompile(script
)
10393 if (chunks
.length
< 1) return false
10395 var lastChunk
= chunks
[chunks
.length
- 1]
10396 if (!Buffer
.isBuffer(lastChunk
)) return false
10398 var scriptSigChunks
= bscript
.decompile(bscript
.compile(chunks
.slice(0, -1)))
10399 var redeemScriptChunks
= bscript
.decompile(lastChunk
)
10401 // is redeemScript a valid script?
10402 if (redeemScriptChunks
.length
=== 0) return false
10404 // is redeemScriptSig push only?
10405 if (!bscript
.isPushOnly(scriptSigChunks
)) return false
10407 var inputType
= bscript
.classifyInput(scriptSigChunks
, allowIncomplete
)
10408 var outputType
= bscript
.classifyOutput(redeemScriptChunks
)
10409 if (chunks
.length
=== 1) {
10410 return outputType
=== bscript
.types
.P2WSH
|| outputType
=== bscript
.types
.P2WPKH
10412 return inputType
=== outputType
10414 check
.toJSON = function () { return 'scriptHash input' }
10416 function encodeStack (redeemScriptStack
, redeemScript
) {
10417 var serializedScriptPubKey
= bscript
.compile(redeemScript
)
10419 return [].concat(redeemScriptStack
, serializedScriptPubKey
)
10422 function encode (redeemScriptSig
, redeemScript
) {
10423 var redeemScriptStack
= bscript
.decompile(redeemScriptSig
)
10425 return bscript
.compile(encodeStack(redeemScriptStack
, redeemScript
))
10428 function decodeStack (stack
) {
10429 typeforce(check
, stack
)
10432 redeemScriptStack: stack
.slice(0, -1),
10433 redeemScript: stack
[stack
.length
- 1]
10437 function decode (buffer
) {
10438 var stack
= bscript
.decompile(buffer
)
10439 var result
= decodeStack(stack
)
10440 result
.redeemScriptSig
= bscript
.compile(result
.redeemScriptStack
)
10441 delete result
.redeemScriptStack
10448 decodeStack: decodeStack
,
10450 encodeStack: encodeStack
10453 },{"../../script":52,"safe-buffer":98,"typeforce":109}],67:[function(require
,module
,exports
){
10454 // OP_HASH160 {scriptHash} OP_EQUAL
10456 var bscript
= require('../../script')
10457 var types
= require('../../types')
10458 var typeforce
= require('typeforce')
10459 var OPS
= require('bitcoin-ops')
10461 function check (script
) {
10462 var buffer
= bscript
.compile(script
)
10464 return buffer
.length
=== 23 &&
10465 buffer
[0] === OPS
.OP_HASH160
&&
10466 buffer
[1] === 0x14 &&
10467 buffer
[22] === OPS
.OP_EQUAL
10469 check
.toJSON = function () { return 'scriptHash output' }
10471 function encode (scriptHash
) {
10472 typeforce(types
.Hash160bit
, scriptHash
)
10474 return bscript
.compile([OPS
.OP_HASH160
, scriptHash
, OPS
.OP_EQUAL
])
10477 function decode (buffer
) {
10478 typeforce(check
, buffer
)
10480 return buffer
.slice(2, 22)
10489 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],68:[function(require
,module
,exports
){
10491 output: require('./output')
10494 },{"./output":69}],69:[function(require
,module
,exports
){
10495 // OP_RETURN {aa21a9ed} {commitment}
10497 var Buffer
= require('safe-buffer').Buffer
10498 var bscript
= require('../../script')
10499 var types
= require('../../types')
10500 var typeforce
= require('typeforce')
10501 var OPS
= require('bitcoin-ops')
10503 var HEADER
= Buffer
.from('aa21a9ed', 'hex')
10505 function check (script
) {
10506 var buffer
= bscript
.compile(script
)
10508 return buffer
.length
> 37 &&
10509 buffer
[0] === OPS
.OP_RETURN
&&
10510 buffer
[1] === 0x24 &&
10511 buffer
.slice(2, 6).equals(HEADER
)
10514 check
.toJSON = function () { return 'Witness commitment output' }
10516 function encode (commitment
) {
10517 typeforce(types
.Hash256bit
, commitment
)
10519 var buffer
= Buffer
.allocUnsafe(36)
10520 HEADER
.copy(buffer
, 0)
10521 commitment
.copy(buffer
, 4)
10523 return bscript
.compile([OPS
.OP_RETURN
, buffer
])
10526 function decode (buffer
) {
10527 typeforce(check
, buffer
)
10529 return bscript
.decompile(buffer
)[1].slice(4, 36)
10538 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"safe-buffer":98,"typeforce":109}],70:[function(require
,module
,exports
){
10539 arguments
[4][55][0].apply(exports
,arguments
)
10540 },{"./input":71,"./output":72,"dup":55}],71:[function(require
,module
,exports
){
10541 // {signature} {pubKey}
10543 var pkh
= require('../pubkeyhash/input')
10547 decodeStack: pkh
.decodeStack
,
10548 encodeStack: pkh
.encodeStack
10551 },{"../pubkeyhash/input":63}],72:[function(require
,module
,exports
){
10552 // OP_0 {pubKeyHash}
10554 var bscript
= require('../../script')
10555 var types
= require('../../types')
10556 var typeforce
= require('typeforce')
10557 var OPS
= require('bitcoin-ops')
10559 function check (script
) {
10560 var buffer
= bscript
.compile(script
)
10562 return buffer
.length
=== 22 &&
10563 buffer
[0] === OPS
.OP_0
&&
10566 check
.toJSON = function () { return 'Witness pubKeyHash output' }
10568 function encode (pubKeyHash
) {
10569 typeforce(types
.Hash160bit
, pubKeyHash
)
10571 return bscript
.compile([OPS
.OP_0
, pubKeyHash
])
10574 function decode (buffer
) {
10575 typeforce(check
, buffer
)
10577 return buffer
.slice(2)
10586 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],73:[function(require
,module
,exports
){
10587 arguments
[4][55][0].apply(exports
,arguments
)
10588 },{"./input":74,"./output":75,"dup":55}],74:[function(require
,module
,exports
){
10589 // {signature} {pubKey}
10591 var p2sh
= require('../scripthash/input')
10595 decodeStack: p2sh
.decodeStack
,
10596 encodeStack: p2sh
.encodeStack
10599 },{"../scripthash/input":66}],75:[function(require
,module
,exports
){
10600 // OP_0 {scriptHash}
10602 var bscript
= require('../../script')
10603 var types
= require('../../types')
10604 var typeforce
= require('typeforce')
10605 var OPS
= require('bitcoin-ops')
10607 function check (script
) {
10608 var buffer
= bscript
.compile(script
)
10610 return buffer
.length
=== 34 &&
10611 buffer
[0] === OPS
.OP_0
&&
10614 check
.toJSON = function () { return 'Witness scriptHash output' }
10616 function encode (scriptHash
) {
10617 typeforce(types
.Hash256bit
, scriptHash
)
10619 return bscript
.compile([OPS
.OP_0
, scriptHash
])
10622 function decode (buffer
) {
10623 typeforce(check
, buffer
)
10625 return buffer
.slice(2)
10634 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],76:[function(require
,module
,exports
){
10635 var Buffer
= require('safe-buffer').Buffer
10636 var bcrypto
= require('./crypto')
10637 var bscript
= require('./script')
10638 var bufferutils
= require('./bufferutils')
10639 var opcodes
= require('bitcoin-ops')
10640 var typeforce
= require('typeforce')
10641 var types
= require('./types')
10642 var varuint
= require('varuint-bitcoin')
10644 function varSliceSize (someScript
) {
10645 var length
= someScript
.length
10647 return varuint
.encodingLength(length
) + length
10650 function vectorSize (someVector
) {
10651 var length
= someVector
.length
10653 return varuint
.encodingLength(length
) + someVector
.reduce(function (sum
, witness
) {
10654 return sum
+ varSliceSize(witness
)
10658 function Transaction () {
10665 Transaction
.DEFAULT_SEQUENCE
= 0xffffffff
10666 Transaction
.SIGHASH_ALL
= 0x01
10667 Transaction
.SIGHASH_NONE
= 0x02
10668 Transaction
.SIGHASH_SINGLE
= 0x03
10669 Transaction
.SIGHASH_ANYONECANPAY
= 0x80
10670 Transaction
.ADVANCED_TRANSACTION_MARKER
= 0x00
10671 Transaction
.ADVANCED_TRANSACTION_FLAG
= 0x01
10673 var EMPTY_SCRIPT
= Buffer
.allocUnsafe(0)
10674 var EMPTY_WITNESS
= []
10675 var ZERO
= Buffer
.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
10676 var ONE
= Buffer
.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex')
10677 var VALUE_UINT64_MAX
= Buffer
.from('ffffffffffffffff', 'hex')
10678 var BLANK_OUTPUT
= {
10679 script: EMPTY_SCRIPT
,
10680 valueBuffer: VALUE_UINT64_MAX
10683 Transaction
.fromBuffer = function (buffer
, __noStrict
) {
10685 function readSlice (n
) {
10687 return buffer
.slice(offset
- n
, offset
)
10690 function readUInt32 () {
10691 var i
= buffer
.readUInt32LE(offset
)
10696 function readInt32 () {
10697 var i
= buffer
.readInt32LE(offset
)
10702 function readUInt64 () {
10703 var i
= bufferutils
.readUInt64LE(buffer
, offset
)
10708 function readVarInt () {
10709 var vi
= varuint
.decode(buffer
, offset
)
10710 offset
+= varuint
.decode
.bytes
10714 function readVarSlice () {
10715 return readSlice(readVarInt())
10718 function readVector () {
10719 var count
= readVarInt()
10721 for (var i
= 0; i
< count
; i
++) vector
.push(readVarSlice())
10725 var tx
= new Transaction()
10726 tx
.version
= readInt32()
10728 var marker
= buffer
.readUInt8(offset
)
10729 var flag
= buffer
.readUInt8(offset
+ 1)
10731 var hasWitnesses
= false
10732 if (marker
=== Transaction
.ADVANCED_TRANSACTION_MARKER
&&
10733 flag
=== Transaction
.ADVANCED_TRANSACTION_FLAG
) {
10735 hasWitnesses
= true
10738 var vinLen
= readVarInt()
10739 for (var i
= 0; i
< vinLen
; ++i
) {
10741 hash: readSlice(32),
10742 index: readUInt32(),
10743 script: readVarSlice(),
10744 sequence: readUInt32(),
10745 witness: EMPTY_WITNESS
10749 var voutLen
= readVarInt()
10750 for (i
= 0; i
< voutLen
; ++i
) {
10752 value: readUInt64(),
10753 script: readVarSlice()
10757 if (hasWitnesses
) {
10758 for (i
= 0; i
< vinLen
; ++i
) {
10759 tx
.ins
[i
].witness
= readVector()
10762 // was this pointless?
10763 if (!tx
.hasWitnesses()) throw new Error('Transaction has superfluous witness data')
10766 tx
.locktime
= readUInt32()
10768 if (__noStrict
) return tx
10769 if (offset
!== buffer
.length
) throw new Error('Transaction has unexpected data')
10774 Transaction
.fromHex = function (hex
) {
10775 return Transaction
.fromBuffer(Buffer
.from(hex
, 'hex'))
10778 Transaction
.isCoinbaseHash = function (buffer
) {
10779 typeforce(types
.Hash256bit
, buffer
)
10780 for (var i
= 0; i
< 32; ++i
) {
10781 if (buffer
[i
] !== 0) return false
10786 Transaction
.prototype.isCoinbase = function () {
10787 return this.ins
.length
=== 1 && Transaction
.isCoinbaseHash(this.ins
[0].hash
)
10790 Transaction
.prototype.addInput = function (hash
, index
, sequence
, scriptSig
) {
10791 typeforce(types
.tuple(
10794 types
.maybe(types
.UInt32
),
10795 types
.maybe(types
.Buffer
)
10798 if (types
.Null(sequence
)) {
10799 sequence
= Transaction
.DEFAULT_SEQUENCE
10802 // Add the input and return the input's index
10803 return (this.ins
.push({
10806 script: scriptSig
|| EMPTY_SCRIPT
,
10807 sequence: sequence
,
10808 witness: EMPTY_WITNESS
10812 Transaction
.prototype.addOutput = function (scriptPubKey
, value
) {
10813 typeforce(types
.tuple(types
.Buffer
, types
.Satoshi
), arguments
)
10815 // Add the output and return the output's index
10816 return (this.outs
.push({
10817 script: scriptPubKey
,
10822 Transaction
.prototype.hasWitnesses = function () {
10823 return this.ins
.some(function (x
) {
10824 return x
.witness
.length
!== 0
10828 Transaction
.prototype.weight = function () {
10829 var base
= this.__byteLength(false)
10830 var total
= this.__byteLength(true)
10831 return base
* 3 + total
10834 Transaction
.prototype.virtualSize = function () {
10835 return Math
.ceil(this.weight() / 4)
10838 Transaction
.prototype.byteLength = function () {
10839 return this.__byteLength(true)
10842 Transaction
.prototype.__byteLength = function (__allowWitness
) {
10843 var hasWitnesses
= __allowWitness
&& this.hasWitnesses()
10846 (hasWitnesses
? 10 : 8) +
10847 varuint
.encodingLength(this.ins
.length
) +
10848 varuint
.encodingLength(this.outs
.length
) +
10849 this.ins
.reduce(function (sum
, input
) { return sum
+ 40 + varSliceSize(input
.script
) }, 0) +
10850 this.outs
.reduce(function (sum
, output
) { return sum
+ 8 + varSliceSize(output
.script
) }, 0) +
10851 (hasWitnesses
? this.ins
.reduce(function (sum
, input
) { return sum
+ vectorSize(input
.witness
) }, 0) : 0)
10855 Transaction
.prototype.clone = function () {
10856 var newTx
= new Transaction()
10857 newTx
.version
= this.version
10858 newTx
.locktime
= this.locktime
10860 newTx
.ins
= this.ins
.map(function (txIn
) {
10864 script: txIn
.script
,
10865 sequence: txIn
.sequence
,
10866 witness: txIn
.witness
10870 newTx
.outs
= this.outs
.map(function (txOut
) {
10872 script: txOut
.script
,
10881 * Hash transaction for signing a specific input.
10883 * Bitcoin uses a different hash for each signed transaction input.
10884 * This method copies the transaction, makes the necessary changes based on the
10885 * hashType, and then hashes the result.
10886 * This hash can then be used to sign the provided transaction input.
10888 Transaction
.prototype.hashForSignature = function (inIndex
, prevOutScript
, hashType
) {
10889 typeforce(types
.tuple(types
.UInt32
, types
.Buffer
, /* types.UInt8 */ types
.Number
), arguments
)
10891 // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L29
10892 if (inIndex
>= this.ins
.length
) return ONE
10894 // ignore OP_CODESEPARATOR
10895 var ourScript
= bscript
.compile(bscript
.decompile(prevOutScript
).filter(function (x
) {
10896 return x
!== opcodes
.OP_CODESEPARATOR
10899 var txTmp
= this.clone()
10901 // SIGHASH_NONE: ignore all outputs? (wildcard payee)
10902 if ((hashType
& 0x1f) === Transaction
.SIGHASH_NONE
) {
10905 // ignore sequence numbers (except at inIndex)
10906 txTmp
.ins
.forEach(function (input
, i
) {
10907 if (i
=== inIndex
) return
10912 // SIGHASH_SINGLE: ignore all outputs, except at the same index?
10913 } else if ((hashType
& 0x1f) === Transaction
.SIGHASH_SINGLE
) {
10914 // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L60
10915 if (inIndex
>= this.outs
.length
) return ONE
10917 // truncate outputs after
10918 txTmp
.outs
.length
= inIndex
+ 1
10920 // "blank" outputs before
10921 for (var i
= 0; i
< inIndex
; i
++) {
10922 txTmp
.outs
[i
] = BLANK_OUTPUT
10925 // ignore sequence numbers (except at inIndex)
10926 txTmp
.ins
.forEach(function (input
, y
) {
10927 if (y
=== inIndex
) return
10933 // SIGHASH_ANYONECANPAY: ignore inputs entirely?
10934 if (hashType
& Transaction
.SIGHASH_ANYONECANPAY
) {
10935 txTmp
.ins
= [txTmp
.ins
[inIndex
]]
10936 txTmp
.ins
[0].script
= ourScript
10938 // SIGHASH_ALL: only ignore input scripts
10940 // "blank" others input scripts
10941 txTmp
.ins
.forEach(function (input
) { input
.script
= EMPTY_SCRIPT
})
10942 txTmp
.ins
[inIndex
].script
= ourScript
10945 // serialize and hash
10946 var buffer
= Buffer
.allocUnsafe(txTmp
.__byteLength(false) + 4)
10947 buffer
.writeInt32LE(hashType
, buffer
.length
- 4)
10948 txTmp
.__toBuffer(buffer
, 0, false)
10950 return bcrypto
.hash256(buffer
)
10953 Transaction
.prototype.hashForWitnessV0 = function (inIndex
, prevOutScript
, value
, hashType
) {
10954 typeforce(types
.tuple(types
.UInt32
, types
.Buffer
, types
.Satoshi
, types
.UInt32
), arguments
)
10956 var tbuffer
, toffset
10957 function writeSlice (slice
) { toffset
+= slice
.copy(tbuffer
, toffset
) }
10958 function writeUInt32 (i
) { toffset
= tbuffer
.writeUInt32LE(i
, toffset
) }
10959 function writeUInt64 (i
) { toffset
= bufferutils
.writeUInt64LE(tbuffer
, i
, toffset
) }
10960 function writeVarInt (i
) {
10961 varuint
.encode(i
, tbuffer
, toffset
)
10962 toffset
+= varuint
.encode
.bytes
10964 function writeVarSlice (slice
) { writeVarInt(slice
.length
); writeSlice(slice
) }
10966 var hashOutputs
= ZERO
10967 var hashPrevouts
= ZERO
10968 var hashSequence
= ZERO
10970 if (!(hashType
& Transaction
.SIGHASH_ANYONECANPAY
)) {
10971 tbuffer
= Buffer
.allocUnsafe(36 * this.ins
.length
)
10974 this.ins
.forEach(function (txIn
) {
10975 writeSlice(txIn
.hash
)
10976 writeUInt32(txIn
.index
)
10979 hashPrevouts
= bcrypto
.hash256(tbuffer
)
10982 if (!(hashType
& Transaction
.SIGHASH_ANYONECANPAY
) &&
10983 (hashType
& 0x1f) !== Transaction
.SIGHASH_SINGLE
&&
10984 (hashType
& 0x1f) !== Transaction
.SIGHASH_NONE
) {
10985 tbuffer
= Buffer
.allocUnsafe(4 * this.ins
.length
)
10988 this.ins
.forEach(function (txIn
) {
10989 writeUInt32(txIn
.sequence
)
10992 hashSequence
= bcrypto
.hash256(tbuffer
)
10995 if ((hashType
& 0x1f) !== Transaction
.SIGHASH_SINGLE
&&
10996 (hashType
& 0x1f) !== Transaction
.SIGHASH_NONE
) {
10997 var txOutsSize
= this.outs
.reduce(function (sum
, output
) {
10998 return sum
+ 8 + varSliceSize(output
.script
)
11001 tbuffer
= Buffer
.allocUnsafe(txOutsSize
)
11004 this.outs
.forEach(function (out
) {
11005 writeUInt64(out
.value
)
11006 writeVarSlice(out
.script
)
11009 hashOutputs
= bcrypto
.hash256(tbuffer
)
11010 } else if ((hashType
& 0x1f) === Transaction
.SIGHASH_SINGLE
&& inIndex
< this.outs
.length
) {
11011 var output
= this.outs
[inIndex
]
11013 tbuffer
= Buffer
.allocUnsafe(8 + varSliceSize(output
.script
))
11015 writeUInt64(output
.value
)
11016 writeVarSlice(output
.script
)
11018 hashOutputs
= bcrypto
.hash256(tbuffer
)
11021 tbuffer
= Buffer
.allocUnsafe(156 + varSliceSize(prevOutScript
))
11024 var input
= this.ins
[inIndex
]
11025 writeUInt32(this.version
)
11026 writeSlice(hashPrevouts
)
11027 writeSlice(hashSequence
)
11028 writeSlice(input
.hash
)
11029 writeUInt32(input
.index
)
11030 writeVarSlice(prevOutScript
)
11032 writeUInt32(input
.sequence
)
11033 writeSlice(hashOutputs
)
11034 writeUInt32(this.locktime
)
11035 writeUInt32(hashType
)
11036 return bcrypto
.hash256(tbuffer
)
11039 Transaction
.prototype.getHash = function () {
11040 return bcrypto
.hash256(this.__toBuffer(undefined, undefined, false))
11043 Transaction
.prototype.getId = function () {
11044 // transaction hash's are displayed in reverse order
11045 return this.getHash().reverse().toString('hex')
11048 Transaction
.prototype.toBuffer = function (buffer
, initialOffset
) {
11049 return this.__toBuffer(buffer
, initialOffset
, true)
11052 Transaction
.prototype.__toBuffer = function (buffer
, initialOffset
, __allowWitness
) {
11053 if (!buffer
) buffer
= Buffer
.allocUnsafe(this.__byteLength(__allowWitness
))
11055 var offset
= initialOffset
|| 0
11056 function writeSlice (slice
) { offset
+= slice
.copy(buffer
, offset
) }
11057 function writeUInt8 (i
) { offset
= buffer
.writeUInt8(i
, offset
) }
11058 function writeUInt32 (i
) { offset
= buffer
.writeUInt32LE(i
, offset
) }
11059 function writeInt32 (i
) { offset
= buffer
.writeInt32LE(i
, offset
) }
11060 function writeUInt64 (i
) { offset
= bufferutils
.writeUInt64LE(buffer
, i
, offset
) }
11061 function writeVarInt (i
) {
11062 varuint
.encode(i
, buffer
, offset
)
11063 offset
+= varuint
.encode
.bytes
11065 function writeVarSlice (slice
) { writeVarInt(slice
.length
); writeSlice(slice
) }
11066 function writeVector (vector
) { writeVarInt(vector
.length
); vector
.forEach(writeVarSlice
) }
11068 writeInt32(this.version
)
11070 var hasWitnesses
= __allowWitness
&& this.hasWitnesses()
11072 if (hasWitnesses
) {
11073 writeUInt8(Transaction
.ADVANCED_TRANSACTION_MARKER
)
11074 writeUInt8(Transaction
.ADVANCED_TRANSACTION_FLAG
)
11077 writeVarInt(this.ins
.length
)
11079 this.ins
.forEach(function (txIn
) {
11080 writeSlice(txIn
.hash
)
11081 writeUInt32(txIn
.index
)
11082 writeVarSlice(txIn
.script
)
11083 writeUInt32(txIn
.sequence
)
11086 writeVarInt(this.outs
.length
)
11087 this.outs
.forEach(function (txOut
) {
11088 if (!txOut
.valueBuffer
) {
11089 writeUInt64(txOut
.value
)
11091 writeSlice(txOut
.valueBuffer
)
11094 writeVarSlice(txOut
.script
)
11097 if (hasWitnesses
) {
11098 this.ins
.forEach(function (input
) {
11099 writeVector(input
.witness
)
11103 writeUInt32(this.locktime
)
11105 // avoid slicing unless necessary
11106 if (initialOffset
!== undefined) return buffer
.slice(initialOffset
, offset
)
11110 Transaction
.prototype.toHex = function () {
11111 return this.toBuffer().toString('hex')
11114 Transaction
.prototype.setInputScript = function (index
, scriptSig
) {
11115 typeforce(types
.tuple(types
.Number
, types
.Buffer
), arguments
)
11117 this.ins
[index
].script
= scriptSig
11120 Transaction
.prototype.setWitness = function (index
, witness
) {
11121 typeforce(types
.tuple(types
.Number
, [types
.Buffer
]), arguments
)
11123 this.ins
[index
].witness
= witness
11126 module
.exports
= Transaction
11128 },{"./bufferutils":44,"./crypto":45,"./script":52,"./types":78,"bitcoin-ops":40,"safe-buffer":98,"typeforce":109,"varuint-bitcoin":111}],77:[function(require
,module
,exports
){
11129 var Buffer
= require('safe-buffer').Buffer
11130 var baddress
= require('./address')
11131 var bcrypto
= require('./crypto')
11132 var bscript
= require('./script')
11133 var networks
= require('./networks')
11134 var ops
= require('bitcoin-ops')
11135 var typeforce
= require('typeforce')
11136 var types
= require('./types')
11137 var scriptTypes
= bscript
.types
11138 var SIGNABLE
= [bscript
.types
.P2PKH
, bscript
.types
.P2PK
, bscript
.types
.MULTISIG
]
11139 var P2SH
= SIGNABLE
.concat([bscript
.types
.P2WPKH
, bscript
.types
.P2WSH
])
11141 var ECPair
= require('./ecpair')
11142 var ECSignature
= require('./ecsignature')
11143 var Transaction
= require('./transaction')
11145 function extractChunks (type
, chunks
, script
) {
11147 var signatures
= []
11149 case scriptTypes
.P2PKH:
11150 // if (redeemScript) throw new Error('Nonstandard... P2SH(P2PKH)')
11151 pubKeys
= chunks
.slice(1)
11152 signatures
= chunks
.slice(0, 1)
11155 case scriptTypes
.P2PK:
11156 pubKeys
[0] = script
? bscript
.pubKey
.output
.decode(script
) : undefined
11157 signatures
= chunks
.slice(0, 1)
11160 case scriptTypes
.MULTISIG:
11162 var multisig
= bscript
.multisig
.output
.decode(script
)
11163 pubKeys
= multisig
.pubKeys
11166 signatures
= chunks
.slice(1).map(function (chunk
) {
11167 return chunk
.length
=== 0 ? undefined : chunk
11174 signatures: signatures
11177 function expandInput (scriptSig
, witnessStack
) {
11178 if (scriptSig
.length
=== 0 && witnessStack
.length
=== 0) return {}
11186 var witnessScriptType
11187 var redeemScriptType
11188 var witness
= false
11194 var scriptSigChunks
= bscript
.decompile(scriptSig
)
11195 var sigType
= bscript
.classifyInput(scriptSigChunks
, true)
11196 if (sigType
=== scriptTypes
.P2SH
) {
11198 redeemScript
= scriptSigChunks
[scriptSigChunks
.length
- 1]
11199 redeemScriptType
= bscript
.classifyOutput(redeemScript
)
11200 prevOutScript
= bscript
.scriptHash
.output
.encode(bcrypto
.hash160(redeemScript
))
11201 prevOutType
= scriptTypes
.P2SH
11202 script
= redeemScript
11205 var classifyWitness
= bscript
.classifyWitness(witnessStack
)
11206 if (classifyWitness
=== scriptTypes
.P2WSH
) {
11207 witnessScript
= witnessStack
[witnessStack
.length
- 1]
11208 witnessScriptType
= bscript
.classifyOutput(witnessScript
)
11210 if (scriptSig
.length
=== 0) {
11211 prevOutScript
= bscript
.witnessScriptHash
.output
.encode(bcrypto
.sha256(witnessScript
))
11212 prevOutType
= scriptTypes
.P2WSH
11213 if (typeof redeemScript
!== 'undefined') {
11214 throw new Error('Redeem script given when unnecessary')
11218 if (!redeemScript
) {
11219 throw new Error('No redeemScript provided for P2WSH, but scriptSig non-empty')
11221 witnessProgram
= bscript
.witnessScriptHash
.output
.encode(bcrypto
.sha256(witnessScript
))
11222 if (!redeemScript
.equals(witnessProgram
)) {
11223 throw new Error('Redeem script didn\'t match witnessScript')
11227 if (SIGNABLE
.indexOf(bscript
.classifyOutput(witnessScript
)) === -1) {
11228 throw new Error('unsupported witness script')
11230 script
= witnessScript
11231 scriptType
= witnessScriptType
11232 chunks
= witnessStack
.slice(0, -1)
11233 } else if (classifyWitness
=== scriptTypes
.P2WPKH
) {
11234 var key
= witnessStack
[witnessStack
.length
- 1]
11235 var keyHash
= bcrypto
.hash160(key
)
11236 if (scriptSig
.length
=== 0) {
11237 prevOutScript
= bscript
.witnessPubKeyHash
.output
.encode(keyHash
)
11238 prevOutType
= scriptTypes
.P2WPKH
11239 if (typeof redeemScript
!== 'undefined') {
11240 throw new Error('Redeem script given when unnecessary')
11243 if (!redeemScript
) {
11244 throw new Error('No redeemScript provided for P2WPKH, but scriptSig wasn\'t empty')
11246 witnessProgram
= bscript
.witnessPubKeyHash
.output
.encode(keyHash
)
11247 if (!redeemScript
.equals(witnessProgram
)) {
11248 throw new Error('Redeem script did not have the right witness program')
11252 scriptType
= scriptTypes
.P2PKH
11253 chunks
= witnessStack
11254 } else if (redeemScript
) {
11255 if (P2SH
.indexOf(redeemScriptType
) === -1) {
11256 throw new Error('Bad redeemscript!')
11259 script
= redeemScript
11260 scriptType
= redeemScriptType
11261 chunks
= scriptSigChunks
.slice(0, -1)
11263 prevOutType
= scriptType
= bscript
.classifyInput(scriptSig
)
11264 chunks
= scriptSigChunks
11267 var expanded
= extractChunks(scriptType
, chunks
, script
)
11270 pubKeys: expanded
.pubKeys
,
11271 signatures: expanded
.signatures
,
11272 prevOutScript: prevOutScript
,
11273 prevOutType: prevOutType
,
11274 signType: scriptType
,
11275 signScript: script
,
11276 witness: Boolean(witness
)
11280 result
.redeemScript
= redeemScript
11281 result
.redeemScriptType
= redeemScriptType
11285 result
.witnessScript
= witnessScript
11286 result
.witnessScriptType
= witnessScriptType
11292 // could be done in expandInput, but requires the original Transaction for hashForSignature
11293 function fixMultisigOrder (input
, transaction
, vin
) {
11294 if (input
.redeemScriptType
!== scriptTypes
.MULTISIG
|| !input
.redeemScript
) return
11295 if (input
.pubKeys
.length
=== input
.signatures
.length
) return
11297 var unmatched
= input
.signatures
.concat()
11299 input
.signatures
= input
.pubKeys
.map(function (pubKey
) {
11300 var keyPair
= ECPair
.fromPublicKeyBuffer(pubKey
)
11303 // check for a signature
11304 unmatched
.some(function (signature
, i
) {
11305 // skip if undefined || OP_0
11306 if (!signature
) return false
11308 // TODO: avoid O(n) hashForSignature
11309 var parsed
= ECSignature
.parseScriptSignature(signature
)
11310 var hash
= transaction
.hashForSignature(vin
, input
.redeemScript
, parsed
.hashType
)
11312 // skip if signature does not match pubKey
11313 if (!keyPair
.verify(hash
, parsed
.signature
)) return false
11315 // remove matched signature from unmatched
11316 unmatched
[i
] = undefined
11326 function expandOutput (script
, scriptType
, ourPubKey
) {
11327 typeforce(types
.Buffer
, script
)
11329 var scriptChunks
= bscript
.decompile(script
)
11331 scriptType
= bscript
.classifyOutput(script
)
11336 switch (scriptType
) {
11337 // does our hash160(pubKey) match the output scripts?
11338 case scriptTypes
.P2PKH:
11339 if (!ourPubKey
) break
11341 var pkh1
= scriptChunks
[2]
11342 var pkh2
= bcrypto
.hash160(ourPubKey
)
11343 if (pkh1
.equals(pkh2
)) pubKeys
= [ourPubKey
]
11346 // does our hash160(pubKey) match the output scripts?
11347 case scriptTypes
.P2WPKH:
11348 if (!ourPubKey
) break
11350 var wpkh1
= scriptChunks
[1]
11351 var wpkh2
= bcrypto
.hash160(ourPubKey
)
11352 if (wpkh1
.equals(wpkh2
)) pubKeys
= [ourPubKey
]
11355 case scriptTypes
.P2PK:
11356 pubKeys
= scriptChunks
.slice(0, 1)
11359 case scriptTypes
.MULTISIG:
11360 pubKeys
= scriptChunks
.slice(1, -2)
11363 default: return { scriptType: scriptType
}
11368 scriptType: scriptType
,
11369 signatures: pubKeys
.map(function () { return undefined })
11373 function checkP2shInput (input
, redeemScriptHash
) {
11374 if (input
.prevOutType
) {
11375 if (input
.prevOutType
!== scriptTypes
.P2SH
) throw new Error('PrevOutScript must be P2SH')
11377 var prevOutScriptScriptHash
= bscript
.decompile(input
.prevOutScript
)[1]
11378 if (!prevOutScriptScriptHash
.equals(redeemScriptHash
)) throw new Error('Inconsistent hash160(RedeemScript)')
11382 function checkP2WSHInput (input
, witnessScriptHash
) {
11383 if (input
.prevOutType
) {
11384 if (input
.prevOutType
!== scriptTypes
.P2WSH
) throw new Error('PrevOutScript must be P2WSH')
11386 var scriptHash
= bscript
.decompile(input
.prevOutScript
)[1]
11387 if (!scriptHash
.equals(witnessScriptHash
)) throw new Error('Inconsistent sha25(WitnessScript)')
11391 function prepareInput (input
, kpPubKey
, redeemScript
, witnessValue
, witnessScript
) {
11398 var redeemScriptHash
11400 var witness
= false
11403 var witnessScriptHash
11408 if (redeemScript
&& witnessScript
) {
11409 redeemScriptHash
= bcrypto
.hash160(redeemScript
)
11410 witnessScriptHash
= bcrypto
.sha256(witnessScript
)
11411 checkP2shInput(input
, redeemScriptHash
)
11413 if (!redeemScript
.equals(bscript
.witnessScriptHash
.output
.encode(witnessScriptHash
))) throw new Error('Witness script inconsistent with redeem script')
11415 expanded
= expandOutput(witnessScript
, undefined, kpPubKey
)
11416 if (!expanded
.pubKeys
) throw new Error('WitnessScript not supported "' + bscript
.toASM(redeemScript
) + '"')
11417 prevOutType
= bscript
.types
.P2SH
11418 prevOutScript
= bscript
.scriptHash
.output
.encode(redeemScriptHash
)
11419 p2sh
= witness
= p2wsh
= true
11420 p2shType
= bscript
.types
.P2WSH
11421 signType
= witnessType
= expanded
.scriptType
11422 signScript
= witnessScript
11423 } else if (redeemScript
) {
11424 redeemScriptHash
= bcrypto
.hash160(redeemScript
)
11425 checkP2shInput(input
, redeemScriptHash
)
11427 expanded
= expandOutput(redeemScript
, undefined, kpPubKey
)
11428 if (!expanded
.pubKeys
) throw new Error('RedeemScript not supported "' + bscript
.toASM(redeemScript
) + '"')
11430 prevOutType
= bscript
.types
.P2SH
11431 prevOutScript
= bscript
.scriptHash
.output
.encode(redeemScriptHash
)
11433 signType
= p2shType
= expanded
.scriptType
11434 signScript
= redeemScript
11435 witness
= signType
=== bscript
.types
.P2WPKH
11436 } else if (witnessScript
) {
11437 witnessScriptHash
= bcrypto
.sha256(witnessScript
)
11438 checkP2WSHInput(input
, witnessScriptHash
)
11440 expanded
= expandOutput(witnessScript
, undefined, kpPubKey
)
11441 if (!expanded
.pubKeys
) throw new Error('WitnessScript not supported "' + bscript
.toASM(redeemScript
) + '"')
11443 prevOutType
= bscript
.types
.P2WSH
11444 prevOutScript
= bscript
.witnessScriptHash
.output
.encode(witnessScriptHash
)
11445 witness
= p2wsh
= true
11446 signType
= witnessType
= expanded
.scriptType
11447 signScript
= witnessScript
11448 } else if (input
.prevOutType
) {
11449 // embedded scripts are not possible without a redeemScript
11450 if (input
.prevOutType
=== scriptTypes
.P2SH
||
11451 input
.prevOutType
=== scriptTypes
.P2WSH
) {
11452 throw new Error('PrevOutScript is ' + input
.prevOutType
+ ', requires redeemScript')
11455 prevOutType
= input
.prevOutType
11456 prevOutScript
= input
.prevOutScript
11457 expanded
= expandOutput(input
.prevOutScript
, input
.prevOutType
, kpPubKey
)
11458 if (!expanded
.pubKeys
) return
11460 witness
= (input
.prevOutType
=== scriptTypes
.P2WPKH
)
11461 signType
= prevOutType
11462 signScript
= prevOutScript
11464 prevOutScript
= bscript
.pubKeyHash
.output
.encode(bcrypto
.hash160(kpPubKey
))
11465 expanded
= expandOutput(prevOutScript
, scriptTypes
.P2PKH
, kpPubKey
)
11466 prevOutType
= scriptTypes
.P2PKH
11468 signType
= prevOutType
11469 signScript
= prevOutScript
11472 if (witness
&& !types
.Satoshi(witnessValue
)) {
11473 throw new Error('Input was witness but not given witness value')
11476 if (signType
=== scriptTypes
.P2WPKH
) {
11477 signScript
= bscript
.pubKeyHash
.output
.encode(bscript
.witnessPubKeyHash
.output
.decode(signScript
))
11481 input
.redeemScript
= redeemScript
11482 input
.redeemScriptType
= p2shType
11486 input
.witnessScript
= witnessScript
11487 input
.witnessScriptType
= witnessType
11490 input
.pubKeys
= expanded
.pubKeys
11491 input
.signatures
= expanded
.signatures
11492 input
.signScript
= signScript
11493 input
.signType
= signType
11494 input
.prevOutScript
= prevOutScript
11495 input
.prevOutType
= prevOutType
11496 input
.witness
= witness
11499 function buildStack (type
, signatures
, pubKeys
, allowIncomplete
) {
11500 if (type
=== scriptTypes
.P2PKH
) {
11501 if (signatures
.length
=== 1 && Buffer
.isBuffer(signatures
[0]) && pubKeys
.length
=== 1) return bscript
.pubKeyHash
.input
.encodeStack(signatures
[0], pubKeys
[0])
11502 } else if (type
=== scriptTypes
.P2PK
) {
11503 if (signatures
.length
=== 1 && Buffer
.isBuffer(signatures
[0])) return bscript
.pubKey
.input
.encodeStack(signatures
[0])
11504 } else if (type
=== scriptTypes
.MULTISIG
) {
11505 if (signatures
.length
> 0) {
11506 signatures
= signatures
.map(function (signature
) {
11507 return signature
|| ops
.OP_0
11509 if (!allowIncomplete
) {
11510 // remove blank signatures
11511 signatures
= signatures
.filter(function (x
) { return x
!== ops
.OP_0
})
11514 return bscript
.multisig
.input
.encodeStack(signatures
/* see if it's necessary first */)
11517 throw new Error('Not yet supported')
11520 if (!allowIncomplete
) throw new Error('Not enough signatures provided')
11525 function buildInput (input
, allowIncomplete
) {
11526 var scriptType
= input
.prevOutType
11529 if (SIGNABLE
.indexOf(scriptType
) !== -1) {
11530 sig
= buildStack(scriptType
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11534 if (scriptType
=== bscript
.types
.P2SH
) {
11535 // We can remove this error later when we have a guarantee prepareInput
11536 // rejects unsignable scripts - it MUST be signable at this point.
11537 if (P2SH
.indexOf(input
.redeemScriptType
) === -1) {
11538 throw new Error('Impossible to sign this type')
11541 if (SIGNABLE
.indexOf(input
.redeemScriptType
) !== -1) {
11542 sig
= buildStack(input
.redeemScriptType
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11544 // If it wasn't SIGNABLE, it's witness, defer to that
11545 scriptType
= input
.redeemScriptType
11548 if (scriptType
=== bscript
.types
.P2WPKH
) {
11549 // P2WPKH is a special case of P2PKH
11550 witness
= buildStack(bscript
.types
.P2PKH
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11551 } else if (scriptType
=== bscript
.types
.P2WSH
) {
11552 // We can remove this check later
11553 if (SIGNABLE
.indexOf(input
.witnessScriptType
) !== -1) {
11554 witness
= buildStack(input
.witnessScriptType
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11555 witness
.push(input
.witnessScript
)
11557 // We can remove this error later when we have a guarantee prepareInput
11558 // rejects unsignble scripts - it MUST be signable at this point.
11562 scriptType
= input
.witnessScriptType
11565 // append redeemScript if necessary
11567 sig
.push(input
.redeemScript
)
11572 script: bscript
.compile(sig
),
11577 function TransactionBuilder (network
, maximumFeeRate
) {
11578 this.prevTxMap
= {}
11579 this.network
= network
|| networks
.bitcoin
11581 // WARNING: This is __NOT__ to be relied on, its just another potential safety mechanism (safety in-depth)
11582 this.maximumFeeRate
= maximumFeeRate
|| 1000
11585 this.tx
= new Transaction()
11588 TransactionBuilder
.prototype.setLockTime = function (locktime
) {
11589 typeforce(types
.UInt32
, locktime
)
11591 // if any signatures exist, throw
11592 if (this.inputs
.some(function (input
) {
11593 if (!input
.signatures
) return false
11595 return input
.signatures
.some(function (s
) { return s
})
11597 throw new Error('No, this would invalidate signatures')
11600 this.tx
.locktime
= locktime
11603 TransactionBuilder
.prototype.setVersion = function (version
) {
11604 typeforce(types
.UInt32
, version
)
11606 // XXX: this might eventually become more complex depending on what the versions represent
11607 this.tx
.version
= version
11610 TransactionBuilder
.fromTransaction = function (transaction
, network
) {
11611 var txb
= new TransactionBuilder(network
)
11613 // Copy transaction fields
11614 txb
.setVersion(transaction
.version
)
11615 txb
.setLockTime(transaction
.locktime
)
11617 // Copy outputs (done first to avoid signature invalidation)
11618 transaction
.outs
.forEach(function (txOut
) {
11619 txb
.addOutput(txOut
.script
, txOut
.value
)
11623 transaction
.ins
.forEach(function (txIn
) {
11624 txb
.__addInputUnsafe(txIn
.hash
, txIn
.index
, {
11625 sequence: txIn
.sequence
,
11626 script: txIn
.script
,
11627 witness: txIn
.witness
11631 // fix some things not possible through the public API
11632 txb
.inputs
.forEach(function (input
, i
) {
11633 fixMultisigOrder(input
, transaction
, i
)
11639 TransactionBuilder
.prototype.addInput = function (txHash
, vout
, sequence
, prevOutScript
) {
11640 if (!this.__canModifyInputs()) {
11641 throw new Error('No, this would invalidate signatures')
11646 // is it a hex string?
11647 if (typeof txHash
=== 'string') {
11648 // transaction hashs's are displayed in reverse order, un-reverse it
11649 txHash
= Buffer
.from(txHash
, 'hex').reverse()
11651 // is it a Transaction object?
11652 } else if (txHash
instanceof Transaction
) {
11653 var txOut
= txHash
.outs
[vout
]
11654 prevOutScript
= txOut
.script
11655 value
= txOut
.value
11657 txHash
= txHash
.getHash()
11660 return this.__addInputUnsafe(txHash
, vout
, {
11661 sequence: sequence
,
11662 prevOutScript: prevOutScript
,
11667 TransactionBuilder
.prototype.__addInputUnsafe = function (txHash
, vout
, options
) {
11668 if (Transaction
.isCoinbaseHash(txHash
)) {
11669 throw new Error('coinbase inputs not supported')
11672 var prevTxOut
= txHash
.toString('hex') + ':' + vout
11673 if (this.prevTxMap
[prevTxOut
] !== undefined) throw new Error('Duplicate TxOut: ' + prevTxOut
)
11677 // derive what we can from the scriptSig
11678 if (options
.script
!== undefined) {
11679 input
= expandInput(options
.script
, options
.witness
|| [])
11682 // if an input value was given, retain it
11683 if (options
.value
!== undefined) {
11684 input
.value
= options
.value
11687 // derive what we can from the previous transactions output script
11688 if (!input
.prevOutScript
&& options
.prevOutScript
) {
11691 if (!input
.pubKeys
&& !input
.signatures
) {
11692 var expanded
= expandOutput(options
.prevOutScript
)
11694 if (expanded
.pubKeys
) {
11695 input
.pubKeys
= expanded
.pubKeys
11696 input
.signatures
= expanded
.signatures
11699 prevOutType
= expanded
.scriptType
11702 input
.prevOutScript
= options
.prevOutScript
11703 input
.prevOutType
= prevOutType
|| bscript
.classifyOutput(options
.prevOutScript
)
11706 var vin
= this.tx
.addInput(txHash
, vout
, options
.sequence
, options
.scriptSig
)
11707 this.inputs
[vin
] = input
11708 this.prevTxMap
[prevTxOut
] = vin
11713 TransactionBuilder
.prototype.addOutput = function (scriptPubKey
, value
) {
11714 if (!this.__canModifyOutputs()) {
11715 throw new Error('No, this would invalidate signatures')
11718 // Attempt to get a script if it's a base58 address string
11719 if (typeof scriptPubKey
=== 'string') {
11720 scriptPubKey
= baddress
.toOutputScript(scriptPubKey
, this.network
)
11723 return this.tx
.addOutput(scriptPubKey
, value
)
11726 TransactionBuilder
.prototype.build = function () {
11727 return this.__build(false)
11729 TransactionBuilder
.prototype.buildIncomplete = function () {
11730 return this.__build(true)
11733 TransactionBuilder
.prototype.__build = function (allowIncomplete
) {
11734 if (!allowIncomplete
) {
11735 if (!this.tx
.ins
.length
) throw new Error('Transaction has no inputs')
11736 if (!this.tx
.outs
.length
) throw new Error('Transaction has no outputs')
11739 var tx
= this.tx
.clone()
11740 // Create script signatures from inputs
11741 this.inputs
.forEach(function (input
, i
) {
11742 var scriptType
= input
.witnessScriptType
|| input
.redeemScriptType
|| input
.prevOutType
11743 if (!scriptType
&& !allowIncomplete
) throw new Error('Transaction is not complete')
11744 var result
= buildInput(input
, allowIncomplete
)
11746 // skip if no result
11747 if (!allowIncomplete
) {
11748 if (SIGNABLE
.indexOf(result
.type
) === -1 && result
.type
!== bscript
.types
.P2WPKH
) {
11749 throw new Error(result
.type
+ ' not supported')
11753 tx
.setInputScript(i
, result
.script
)
11754 tx
.setWitness(i
, result
.witness
)
11757 if (!allowIncomplete
) {
11758 // do not rely on this, its merely a last resort
11759 if (this.__overMaximumFees(tx
.byteLength())) {
11760 throw new Error('Transaction has absurd fees')
11767 function canSign (input
) {
11768 return input
.prevOutScript
!== undefined &&
11769 input
.signScript
!== undefined &&
11770 input
.pubKeys
!== undefined &&
11771 input
.signatures
!== undefined &&
11772 input
.signatures
.length
=== input
.pubKeys
.length
&&
11773 input
.pubKeys
.length
> 0 &&
11774 input
.witness
!== undefined
11777 TransactionBuilder
.prototype.sign = function (vin
, keyPair
, redeemScript
, hashType
, witnessValue
, witnessScript
) {
11778 if (keyPair
.network
!== this.network
) throw new Error('Inconsistent network')
11779 if (!this.inputs
[vin
]) throw new Error('No input at index: ' + vin
)
11780 hashType
= hashType
|| Transaction
.SIGHASH_ALL
11782 var input
= this.inputs
[vin
]
11784 // if redeemScript was previously provided, enforce consistency
11785 if (input
.redeemScript
!== undefined &&
11787 !input
.redeemScript
.equals(redeemScript
)) {
11788 throw new Error('Inconsistent redeemScript')
11791 var kpPubKey
= keyPair
.getPublicKeyBuffer()
11792 if (!canSign(input
)) {
11793 prepareInput(input
, kpPubKey
, redeemScript
, witnessValue
, witnessScript
)
11794 if (!canSign(input
)) throw Error(input
.prevOutType
+ ' not supported')
11799 if (input
.witness
) {
11800 signatureHash
= this.tx
.hashForWitnessV0(vin
, input
.signScript
, witnessValue
, hashType
)
11802 signatureHash
= this.tx
.hashForSignature(vin
, input
.signScript
, hashType
)
11804 // enforce in order signing of public keys
11805 var signed
= input
.pubKeys
.some(function (pubKey
, i
) {
11806 if (!kpPubKey
.equals(pubKey
)) return false
11807 if (input
.signatures
[i
]) throw new Error('Signature already exists')
11809 input
.signatures
[i
] = keyPair
.sign(signatureHash
).toScriptSignature(hashType
)
11813 if (!signed
) throw new Error('Key pair cannot sign for this input')
11816 function signatureHashType (buffer
) {
11817 return buffer
.readUInt8(buffer
.length
- 1)
11820 TransactionBuilder
.prototype.__canModifyInputs = function () {
11821 return this.inputs
.every(function (input
) {
11823 if (input
.signatures
=== undefined) return true
11825 return input
.signatures
.every(function (signature
) {
11826 if (!signature
) return true
11827 var hashType
= signatureHashType(signature
)
11829 // if SIGHASH_ANYONECANPAY is set, signatures would not
11830 // be invalidated by more inputs
11831 return hashType
& Transaction
.SIGHASH_ANYONECANPAY
11836 TransactionBuilder
.prototype.__canModifyOutputs = function () {
11837 var nInputs
= this.tx
.ins
.length
11838 var nOutputs
= this.tx
.outs
.length
11840 return this.inputs
.every(function (input
) {
11841 if (input
.signatures
=== undefined) return true
11843 return input
.signatures
.every(function (signature
) {
11844 if (!signature
) return true
11845 var hashType
= signatureHashType(signature
)
11847 var hashTypeMod
= hashType
& 0x1f
11848 if (hashTypeMod
=== Transaction
.SIGHASH_NONE
) return true
11849 if (hashTypeMod
=== Transaction
.SIGHASH_SINGLE
) {
11850 // if SIGHASH_SINGLE is set, and nInputs > nOutputs
11851 // some signatures would be invalidated by the addition
11853 return nInputs
<= nOutputs
11859 TransactionBuilder
.prototype.__overMaximumFees = function (bytes
) {
11860 // not all inputs will have .value defined
11861 var incoming
= this.inputs
.reduce(function (a
, x
) { return a
+ (x
.value
>>> 0) }, 0)
11863 // but all outputs do, and if we have any input value
11864 // we can immediately determine if the outputs are too small
11865 var outgoing
= this.tx
.outs
.reduce(function (a
, x
) { return a
+ x
.value
}, 0)
11866 var fee
= incoming
- outgoing
11867 var feeRate
= fee
/ bytes
11869 return feeRate
> this.maximumFeeRate
11872 module
.exports
= TransactionBuilder
11874 },{"./address":42,"./crypto":45,"./ecpair":47,"./ecsignature":48,"./networks":51,"./script":52,"./transaction":76,"./types":78,"bitcoin-ops":40,"safe-buffer":98,"typeforce":109}],78:[function(require
,module
,exports
){
11875 var typeforce
= require('typeforce')
11877 var UINT31_MAX
= Math
.pow(2, 31) - 1
11878 function UInt31 (value
) {
11879 return typeforce
.UInt32(value
) && value
<= UINT31_MAX
11882 function BIP32Path (value
) {
11883 return typeforce
.String(value
) && value
.match(/^(m\/)?(\d+'?\/)*\d+'?$/)
11885 BIP32Path
.toJSON = function () { return 'BIP32 derivation path' }
11887 var SATOSHI_MAX
= 21 * 1e14
11888 function Satoshi (value
) {
11889 return typeforce
.UInt53(value
) && value
<= SATOSHI_MAX
11892 // external dependent types
11893 var BigInt
= typeforce
.quacksLike('BigInteger')
11894 var ECPoint
= typeforce
.quacksLike('Point')
11896 // exposed, external API
11897 var ECSignature
= typeforce
.compile({ r: BigInt
, s: BigInt
})
11898 var Network
= typeforce
.compile({
11899 messagePrefix: typeforce
.oneOf(typeforce
.Buffer
, typeforce
.String
),
11901 public: typeforce
.UInt32
,
11902 private: typeforce
.UInt32
11904 pubKeyHash: typeforce
.UInt8
,
11905 scriptHash: typeforce
.UInt8
,
11906 wif: typeforce
.UInt8
11909 // extend typeforce types with ours
11912 BIP32Path: BIP32Path
,
11913 Buffer256bit: typeforce
.BufferN(32),
11915 ECSignature: ECSignature
,
11916 Hash160bit: typeforce
.BufferN(20),
11917 Hash256bit: typeforce
.BufferN(32),
11923 for (var typeName
in typeforce
) {
11924 types
[typeName
] = typeforce
[typeName
]
11927 module
.exports
= types
11929 },{"typeforce":109}],79:[function(require
,module
,exports
){
11930 var basex
= require('base-x')
11931 var ALPHABET
= '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
11933 module
.exports
= basex(ALPHABET
)
11935 },{"base-x":34}],80:[function(require
,module
,exports
){
11936 (function (Buffer
){
11939 var base58
= require('bs58')
11940 var createHash
= require('create-hash')
11942 // SHA256(SHA256(buffer))
11943 function sha256x2 (buffer
) {
11944 var tmp
= createHash('sha256').update(buffer
).digest()
11945 return createHash('sha256').update(tmp
).digest()
11948 // Encode a buffer as a base58-check encoded string
11949 function encode (payload
) {
11950 var checksum
= sha256x2(payload
)
11952 return base58
.encode(Buffer
.concat([
11955 ], payload
.length
+ 4))
11958 function decodeRaw (buffer
) {
11959 var payload
= buffer
.slice(0, -4)
11960 var checksum
= buffer
.slice(-4)
11961 var newChecksum
= sha256x2(payload
)
11963 if (checksum
[0] ^ newChecksum
[0] |
11964 checksum
[1] ^ newChecksum
[1] |
11965 checksum
[2] ^ newChecksum
[2] |
11966 checksum
[3] ^ newChecksum
[3]) return
11971 // Decode a base58-check encoded string to a buffer, no result if checksum is wrong
11972 function decodeUnsafe (string
) {
11973 var buffer
= base58
.decodeUnsafe(string
)
11974 if (!buffer
) return
11976 return decodeRaw(buffer
)
11979 function decode (string
) {
11980 var buffer
= base58
.decode(string
)
11981 var payload
= decodeRaw(buffer
)
11982 if (!payload
) throw new Error('Invalid checksum')
11989 decodeUnsafe: decodeUnsafe
11992 }).call(this,require("buffer").Buffer
)
11993 },{"bs58":79,"buffer":4,"create-hash":82}],81:[function(require
,module
,exports
){
11994 var Buffer
= require('safe-buffer').Buffer
11995 var Transform
= require('stream').Transform
11996 var StringDecoder
= require('string_decoder').StringDecoder
11997 var inherits
= require('inherits')
11999 function CipherBase (hashMode
) {
12000 Transform
.call(this)
12001 this.hashMode
= typeof hashMode
=== 'string'
12002 if (this.hashMode
) {
12003 this[hashMode
] = this._finalOrDigest
12005 this.final
= this._finalOrDigest
12008 this.__final
= this._final
12011 this._decoder
= null
12012 this._encoding
= null
12014 inherits(CipherBase
, Transform
)
12016 CipherBase
.prototype.update = function (data
, inputEnc
, outputEnc
) {
12017 if (typeof data
=== 'string') {
12018 data
= Buffer
.from(data
, inputEnc
)
12021 var outData
= this._update(data
)
12022 if (this.hashMode
) return this
12025 outData
= this._toString(outData
, outputEnc
)
12031 CipherBase
.prototype.setAutoPadding = function () {}
12032 CipherBase
.prototype.getAuthTag = function () {
12033 throw new Error('trying to get auth tag in unsupported state')
12036 CipherBase
.prototype.setAuthTag = function () {
12037 throw new Error('trying to set auth tag in unsupported state')
12040 CipherBase
.prototype.setAAD = function () {
12041 throw new Error('trying to set aad in unsupported state')
12044 CipherBase
.prototype._transform = function (data
, _
, next
) {
12047 if (this.hashMode
) {
12050 this.push(this._update(data
))
12058 CipherBase
.prototype._flush = function (done
) {
12061 this.push(this.__final())
12068 CipherBase
.prototype._finalOrDigest = function (outputEnc
) {
12069 var outData
= this.__final() || Buffer
.alloc(0)
12071 outData
= this._toString(outData
, outputEnc
, true)
12076 CipherBase
.prototype._toString = function (value
, enc
, fin
) {
12077 if (!this._decoder
) {
12078 this._decoder
= new StringDecoder(enc
)
12079 this._encoding
= enc
12082 if (this._encoding
!== enc
) throw new Error('can\'t switch encodings')
12084 var out
= this._decoder
.write(value
)
12086 out
+= this._decoder
.end()
12092 module
.exports
= CipherBase
12094 },{"inherits":93,"safe-buffer":98,"stream":27,"string_decoder":28}],82:[function(require
,module
,exports
){
12095 (function (Buffer
){
12097 var inherits
= require('inherits')
12098 var md5
= require('./md5')
12099 var RIPEMD160
= require('ripemd160')
12100 var sha
= require('sha.js')
12102 var Base
= require('cipher-base')
12104 function HashNoConstructor (hash
) {
12105 Base
.call(this, 'digest')
12111 inherits(HashNoConstructor
, Base
)
12113 HashNoConstructor
.prototype._update = function (data
) {
12114 this.buffers
.push(data
)
12117 HashNoConstructor
.prototype._final = function () {
12118 var buf
= Buffer
.concat(this.buffers
)
12119 var r
= this._hash(buf
)
12120 this.buffers
= null
12125 function Hash (hash
) {
12126 Base
.call(this, 'digest')
12131 inherits(Hash
, Base
)
12133 Hash
.prototype._update = function (data
) {
12134 this._hash
.update(data
)
12137 Hash
.prototype._final = function () {
12138 return this._hash
.digest()
12141 module
.exports
= function createHash (alg
) {
12142 alg
= alg
.toLowerCase()
12143 if (alg
=== 'md5') return new HashNoConstructor(md5
)
12144 if (alg
=== 'rmd160' || alg
=== 'ripemd160') return new Hash(new RIPEMD160())
12146 return new Hash(sha(alg
))
12149 }).call(this,require("buffer").Buffer
)
12150 },{"./md5":84,"buffer":4,"cipher-base":81,"inherits":93,"ripemd160":97,"sha.js":100}],83:[function(require
,module
,exports
){
12151 (function (Buffer
){
12154 var zeroBuffer
= new Buffer(intSize
)
12160 function toArray (buf
) {
12161 if ((buf
.length
% intSize
) !== 0) {
12162 var len
= buf
.length
+ (intSize
- (buf
.length
% intSize
))
12163 buf
= Buffer
.concat([buf
, zeroBuffer
], len
)
12166 var arr
= new Array(buf
.length
>>> 2)
12167 for (var i
= 0, j
= 0; i
< buf
.length
; i
+= intSize
, j
++) {
12168 arr
[j
] = buf
.readInt32LE(i
)
12174 module
.exports
= function hash (buf
, fn
) {
12175 var arr
= fn(toArray(buf
), buf
.length
* charSize
)
12176 buf
= new Buffer(hashSize
)
12177 for (var i
= 0; i
< arr
.length
; i
++) {
12178 buf
.writeInt32LE(arr
[i
], i
<< 2, true)
12183 }).call(this,require("buffer").Buffer
)
12184 },{"buffer":4}],84:[function(require
,module
,exports
){
12187 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
12188 * Digest Algorithm, as defined in RFC 1321.
12189 * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
12190 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
12191 * Distributed under the BSD License
12192 * See http://pajhome.org.uk/crypt/md5 for more info.
12195 var makeHash
= require('./make-hash')
12198 * Calculate the MD5 of an array of little-endian words, and a bit length
12200 function core_md5 (x
, len
) {
12201 /* append padding */
12202 x
[len
>> 5] |= 0x80 << ((len
) % 32)
12203 x
[(((len
+ 64) >>> 9) << 4) + 14] = len
12207 var c
= -1732584194
12210 for (var i
= 0; i
< x
.length
; i
+= 16) {
12216 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 0], 7, -680876936)
12217 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 1], 12, -389564586)
12218 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 2], 17, 606105819)
12219 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 3], 22, -1044525330)
12220 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 4], 7, -176418897)
12221 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 5], 12, 1200080426)
12222 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 6], 17, -1473231341)
12223 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 7], 22, -45705983)
12224 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 8], 7, 1770035416)
12225 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 9], 12, -1958414417)
12226 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 10], 17, -42063)
12227 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 11], 22, -1990404162)
12228 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 12], 7, 1804603682)
12229 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 13], 12, -40341101)
12230 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 14], 17, -1502002290)
12231 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 15], 22, 1236535329)
12233 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 1], 5, -165796510)
12234 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 6], 9, -1069501632)
12235 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 11], 14, 643717713)
12236 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 0], 20, -373897302)
12237 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 5], 5, -701558691)
12238 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 10], 9, 38016083)
12239 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 15], 14, -660478335)
12240 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 4], 20, -405537848)
12241 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 9], 5, 568446438)
12242 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 14], 9, -1019803690)
12243 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 3], 14, -187363961)
12244 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 8], 20, 1163531501)
12245 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 13], 5, -1444681467)
12246 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 2], 9, -51403784)
12247 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 7], 14, 1735328473)
12248 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 12], 20, -1926607734)
12250 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 5], 4, -378558)
12251 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 8], 11, -2022574463)
12252 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 11], 16, 1839030562)
12253 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 14], 23, -35309556)
12254 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 1], 4, -1530992060)
12255 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 4], 11, 1272893353)
12256 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 7], 16, -155497632)
12257 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 10], 23, -1094730640)
12258 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 13], 4, 681279174)
12259 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 0], 11, -358537222)
12260 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 3], 16, -722521979)
12261 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 6], 23, 76029189)
12262 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 9], 4, -640364487)
12263 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 12], 11, -421815835)
12264 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 15], 16, 530742520)
12265 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 2], 23, -995338651)
12267 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 0], 6, -198630844)
12268 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 7], 10, 1126891415)
12269 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 14], 15, -1416354905)
12270 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 5], 21, -57434055)
12271 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 12], 6, 1700485571)
12272 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 3], 10, -1894986606)
12273 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 10], 15, -1051523)
12274 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 1], 21, -2054922799)
12275 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 8], 6, 1873313359)
12276 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 15], 10, -30611744)
12277 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 6], 15, -1560198380)
12278 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 13], 21, 1309151649)
12279 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 4], 6, -145523070)
12280 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 11], 10, -1120210379)
12281 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 2], 15, 718787259)
12282 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 9], 21, -343485551)
12284 a
= safe_add(a
, olda
)
12285 b
= safe_add(b
, oldb
)
12286 c
= safe_add(c
, oldc
)
12287 d
= safe_add(d
, oldd
)
12290 return [a
, b
, c
, d
]
12294 * These functions implement the four basic operations the algorithm uses.
12296 function md5_cmn (q
, a
, b
, x
, s
, t
) {
12297 return safe_add(bit_rol(safe_add(safe_add(a
, q
), safe_add(x
, t
)), s
), b
)
12300 function md5_ff (a
, b
, c
, d
, x
, s
, t
) {
12301 return md5_cmn((b
& c
) | ((~b
) & d
), a
, b
, x
, s
, t
)
12304 function md5_gg (a
, b
, c
, d
, x
, s
, t
) {
12305 return md5_cmn((b
& d
) | (c
& (~d
)), a
, b
, x
, s
, t
)
12308 function md5_hh (a
, b
, c
, d
, x
, s
, t
) {
12309 return md5_cmn(b
^ c
^ d
, a
, b
, x
, s
, t
)
12312 function md5_ii (a
, b
, c
, d
, x
, s
, t
) {
12313 return md5_cmn(c
^ (b
| (~d
)), a
, b
, x
, s
, t
)
12317 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
12318 * to work around bugs in some JS interpreters.
12320 function safe_add (x
, y
) {
12321 var lsw
= (x
& 0xFFFF) + (y
& 0xFFFF)
12322 var msw
= (x
>> 16) + (y
>> 16) + (lsw
>> 16)
12323 return (msw
<< 16) | (lsw
& 0xFFFF)
12327 * Bitwise rotate a 32-bit number to the left.
12329 function bit_rol (num
, cnt
) {
12330 return (num
<< cnt
) | (num
>>> (32 - cnt
))
12333 module
.exports
= function md5 (buf
) {
12334 return makeHash(buf
, core_md5
)
12337 },{"./make-hash":83}],85:[function(require
,module
,exports
){
12339 var inherits
= require('inherits')
12340 var Legacy
= require('./legacy')
12341 var Base
= require('cipher-base')
12342 var Buffer
= require('safe-buffer').Buffer
12343 var md5
= require('create-hash/md5')
12344 var RIPEMD160
= require('ripemd160')
12346 var sha
= require('sha.js')
12348 var ZEROS
= Buffer
.alloc(128)
12350 function Hmac (alg
, key
) {
12351 Base
.call(this, 'digest')
12352 if (typeof key
=== 'string') {
12353 key
= Buffer
.from(key
)
12356 var blocksize
= (alg
=== 'sha512' || alg
=== 'sha384') ? 128 : 64
12360 if (key
.length
> blocksize
) {
12361 var hash
= alg
=== 'rmd160' ? new RIPEMD160() : sha(alg
)
12362 key
= hash
.update(key
).digest()
12363 } else if (key
.length
< blocksize
) {
12364 key
= Buffer
.concat([key
, ZEROS
], blocksize
)
12367 var ipad
= this._ipad
= Buffer
.allocUnsafe(blocksize
)
12368 var opad
= this._opad
= Buffer
.allocUnsafe(blocksize
)
12370 for (var i
= 0; i
< blocksize
; i
++) {
12371 ipad
[i
] = key
[i
] ^ 0x36
12372 opad
[i
] = key
[i
] ^ 0x5C
12374 this._hash
= alg
=== 'rmd160' ? new RIPEMD160() : sha(alg
)
12375 this._hash
.update(ipad
)
12378 inherits(Hmac
, Base
)
12380 Hmac
.prototype._update = function (data
) {
12381 this._hash
.update(data
)
12384 Hmac
.prototype._final = function () {
12385 var h
= this._hash
.digest()
12386 var hash
= this._alg
=== 'rmd160' ? new RIPEMD160() : sha(this._alg
)
12387 return hash
.update(this._opad
).update(h
).digest()
12390 module
.exports
= function createHmac (alg
, key
) {
12391 alg
= alg
.toLowerCase()
12392 if (alg
=== 'rmd160' || alg
=== 'ripemd160') {
12393 return new Hmac('rmd160', key
)
12395 if (alg
=== 'md5') {
12396 return new Legacy(md5
, key
)
12398 return new Hmac(alg
, key
)
12401 },{"./legacy":86,"cipher-base":81,"create-hash/md5":84,"inherits":93,"ripemd160":97,"safe-buffer":98,"sha.js":100}],86:[function(require
,module
,exports
){
12403 var inherits
= require('inherits')
12404 var Buffer
= require('safe-buffer').Buffer
12406 var Base
= require('cipher-base')
12408 var ZEROS
= Buffer
.alloc(128)
12411 function Hmac (alg
, key
) {
12412 Base
.call(this, 'digest')
12413 if (typeof key
=== 'string') {
12414 key
= Buffer
.from(key
)
12420 if (key
.length
> blocksize
) {
12422 } else if (key
.length
< blocksize
) {
12423 key
= Buffer
.concat([key
, ZEROS
], blocksize
)
12426 var ipad
= this._ipad
= Buffer
.allocUnsafe(blocksize
)
12427 var opad
= this._opad
= Buffer
.allocUnsafe(blocksize
)
12429 for (var i
= 0; i
< blocksize
; i
++) {
12430 ipad
[i
] = key
[i
] ^ 0x36
12431 opad
[i
] = key
[i
] ^ 0x5C
12434 this._hash
= [ipad
]
12437 inherits(Hmac
, Base
)
12439 Hmac
.prototype._update = function (data
) {
12440 this._hash
.push(data
)
12443 Hmac
.prototype._final = function () {
12444 var h
= this._alg(Buffer
.concat(this._hash
))
12445 return this._alg(Buffer
.concat([this._opad
, h
]))
12447 module
.exports
= Hmac
12449 },{"cipher-base":81,"inherits":93,"safe-buffer":98}],87:[function(require
,module
,exports
){
12450 var assert
= require('assert')
12451 var BigInteger
= require('bigi')
12453 var Point
= require('./point')
12455 function Curve (p
, a
, b
, Gx
, Gy
, n
, h
) {
12459 this.G
= Point
.fromAffine(this, Gx
, Gy
)
12463 this.infinity
= new Point(this, null, null, BigInteger
.ZERO
)
12466 this.pOverFour
= p
.add(BigInteger
.ONE
).shiftRight(2)
12468 // determine size of p in bytes
12469 this.pLength
= Math
.floor((this.p
.bitLength() + 7) / 8)
12472 Curve
.prototype.pointFromX = function (isOdd
, x
) {
12473 var alpha
= x
.pow(3).add(this.a
.multiply(x
)).add(this.b
).mod(this.p
)
12474 var beta
= alpha
.modPow(this.pOverFour
, this.p
) // XXX: not compatible with all curves
12477 if (beta
.isEven() ^ !isOdd
) {
12478 y
= this.p
.subtract(y
) // -y % p
12481 return Point
.fromAffine(this, x
, y
)
12484 Curve
.prototype.isInfinity = function (Q
) {
12485 if (Q
=== this.infinity
) return true
12487 return Q
.z
.signum() === 0 && Q
.y
.signum() !== 0
12490 Curve
.prototype.isOnCurve = function (Q
) {
12491 if (this.isInfinity(Q
)) return true
12499 // Check that xQ and yQ are integers in the interval [0, p - 1]
12500 if (x
.signum() < 0 || x
.compareTo(p
) >= 0) return false
12501 if (y
.signum() < 0 || y
.compareTo(p
) >= 0) return false
12503 // and check that y^2 = x^3 + ax + b (mod p)
12504 var lhs
= y
.square().mod(p
)
12505 var rhs
= x
.pow(3).add(a
.multiply(x
)).add(b
).mod(p
)
12506 return lhs
.equals(rhs
)
12510 * Validate an elliptic curve point.
12512 * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive
12514 Curve
.prototype.validate = function (Q
) {
12516 assert(!this.isInfinity(Q
), 'Point is at infinity')
12517 assert(this.isOnCurve(Q
), 'Point is not on the curve')
12519 // Check nQ = O (where Q is a scalar multiple of G)
12520 var nQ
= Q
.multiply(this.n
)
12521 assert(this.isInfinity(nQ
), 'Point is not a scalar multiple of G')
12526 module
.exports
= Curve
12528 },{"./point":91,"assert":1,"bigi":37}],88:[function(require
,module
,exports
){
12531 "p": "fffffffdffffffffffffffffffffffff",
12532 "a": "fffffffdfffffffffffffffffffffffc",
12533 "b": "e87579c11079f43dd824993c2cee5ed3",
12534 "n": "fffffffe0000000075a30d1b9038a115",
12536 "Gx": "161ff7528b899b2d0c28607ca52c5b86",
12537 "Gy": "cf5ac8395bafeb13c02da292dded7a83"
12540 "p": "fffffffffffffffffffffffffffffffeffffac73",
12543 "n": "0100000000000000000001b8fa16dfab9aca16b6b3",
12545 "Gx": "3b4c382ce37aa192a4019e763036f4f5dd4d7ebb",
12546 "Gy": "938cf935318fdced6bc28286531733c3f03c4fee"
12549 "p": "ffffffffffffffffffffffffffffffff7fffffff",
12550 "a": "ffffffffffffffffffffffffffffffff7ffffffc",
12551 "b": "1c97befc54bd7a8b65acf89f81d4d4adc565fa45",
12552 "n": "0100000000000000000001f4c8f927aed3ca752257",
12554 "Gx": "4a96b5688ef573284664698968c38bb913cbfc82",
12555 "Gy": "23a628553168947d59dcc912042351377ac5fb32"
12558 "p": "fffffffffffffffffffffffffffffffffffffffeffffee37",
12561 "n": "fffffffffffffffffffffffe26f2fc170f69466a74defd8d",
12563 "Gx": "db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d",
12564 "Gy": "9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d"
12567 "p": "fffffffffffffffffffffffffffffffeffffffffffffffff",
12568 "a": "fffffffffffffffffffffffffffffffefffffffffffffffc",
12569 "b": "64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
12570 "n": "ffffffffffffffffffffffff99def836146bc9b1b4d22831",
12572 "Gx": "188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
12573 "Gy": "07192b95ffc8da78631011ed6b24cdd573f977a11e794811"
12576 "p": "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
12579 "n": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
12581 "Gx": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
12582 "Gy": "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
12585 "p": "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
12586 "a": "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
12587 "b": "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
12588 "n": "ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
12590 "Gx": "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
12591 "Gy": "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"
12595 },{}],89:[function(require
,module
,exports
){
12596 var Point
= require('./point')
12597 var Curve
= require('./curve')
12599 var getCurveByName
= require('./names')
12604 getCurveByName: getCurveByName
12607 },{"./curve":87,"./names":90,"./point":91}],90:[function(require
,module
,exports
){
12608 var BigInteger
= require('bigi')
12610 var curves
= require('./curves.json')
12611 var Curve
= require('./curve')
12613 function getCurveByName (name
) {
12614 var curve
= curves
[name
]
12615 if (!curve
) return null
12617 var p
= new BigInteger(curve
.p
, 16)
12618 var a
= new BigInteger(curve
.a
, 16)
12619 var b
= new BigInteger(curve
.b
, 16)
12620 var n
= new BigInteger(curve
.n
, 16)
12621 var h
= new BigInteger(curve
.h
, 16)
12622 var Gx
= new BigInteger(curve
.Gx
, 16)
12623 var Gy
= new BigInteger(curve
.Gy
, 16)
12625 return new Curve(p
, a
, b
, Gx
, Gy
, n
, h
)
12628 module
.exports
= getCurveByName
12630 },{"./curve":87,"./curves.json":88,"bigi":37}],91:[function(require
,module
,exports
){
12631 (function (Buffer
){
12632 var assert
= require('assert')
12633 var BigInteger
= require('bigi')
12635 var THREE
= BigInteger
.valueOf(3)
12637 function Point (curve
, x
, y
, z
) {
12638 assert
.notStrictEqual(z
, undefined, 'Missing Z coordinate')
12646 this.compressed
= true
12649 Object
.defineProperty(Point
.prototype, 'zInv', {
12651 if (this._zInv
=== null) {
12652 this._zInv
= this.z
.modInverse(this.curve
.p
)
12659 Object
.defineProperty(Point
.prototype, 'affineX', {
12661 return this.x
.multiply(this.zInv
).mod(this.curve
.p
)
12665 Object
.defineProperty(Point
.prototype, 'affineY', {
12667 return this.y
.multiply(this.zInv
).mod(this.curve
.p
)
12671 Point
.fromAffine = function (curve
, x
, y
) {
12672 return new Point(curve
, x
, y
, BigInteger
.ONE
)
12675 Point
.prototype.equals = function (other
) {
12676 if (other
=== this) return true
12677 if (this.curve
.isInfinity(this)) return this.curve
.isInfinity(other
)
12678 if (this.curve
.isInfinity(other
)) return this.curve
.isInfinity(this)
12680 // u = Y2 * Z1 - Y1 * Z2
12681 var u
= other
.y
.multiply(this.z
).subtract(this.y
.multiply(other
.z
)).mod(this.curve
.p
)
12683 if (u
.signum() !== 0) return false
12685 // v = X2 * Z1 - X1 * Z2
12686 var v
= other
.x
.multiply(this.z
).subtract(this.x
.multiply(other
.z
)).mod(this.curve
.p
)
12688 return v
.signum() === 0
12691 Point
.prototype.negate = function () {
12692 var y
= this.curve
.p
.subtract(this.y
)
12694 return new Point(this.curve
, this.x
, y
, this.z
)
12697 Point
.prototype.add = function (b
) {
12698 if (this.curve
.isInfinity(this)) return b
12699 if (this.curve
.isInfinity(b
)) return this
12706 // u = Y2 * Z1 - Y1 * Z2
12707 var u
= y2
.multiply(this.z
).subtract(y1
.multiply(b
.z
)).mod(this.curve
.p
)
12708 // v = X2 * Z1 - X1 * Z2
12709 var v
= x2
.multiply(this.z
).subtract(x1
.multiply(b
.z
)).mod(this.curve
.p
)
12711 if (v
.signum() === 0) {
12712 if (u
.signum() === 0) {
12713 return this.twice() // this == b, so double
12716 return this.curve
.infinity
// this = -b, so infinity
12719 var v2
= v
.square()
12720 var v3
= v2
.multiply(v
)
12721 var x1v2
= x1
.multiply(v2
)
12722 var zu2
= u
.square().multiply(this.z
)
12724 // x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)
12725 var x3
= zu2
.subtract(x1v2
.shiftLeft(1)).multiply(b
.z
).subtract(v3
).multiply(v
).mod(this.curve
.p
)
12726 // y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
12727 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
)
12728 // z3 = v^3 * z1 * z2
12729 var z3
= v3
.multiply(this.z
).multiply(b
.z
).mod(this.curve
.p
)
12731 return new Point(this.curve
, x3
, y3
, z3
)
12734 Point
.prototype.twice = function () {
12735 if (this.curve
.isInfinity(this)) return this
12736 if (this.y
.signum() === 0) return this.curve
.infinity
12741 var y1z1
= y1
.multiply(this.z
).mod(this.curve
.p
)
12742 var y1sqz1
= y1z1
.multiply(y1
).mod(this.curve
.p
)
12743 var a
= this.curve
.a
12745 // w = 3 * x1^2 + a * z1^2
12746 var w
= x1
.square().multiply(THREE
)
12748 if (a
.signum() !== 0) {
12749 w
= w
.add(this.z
.square().multiply(a
))
12752 w
= w
.mod(this.curve
.p
)
12753 // x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
12754 var x3
= w
.square().subtract(x1
.shiftLeft(3).multiply(y1sqz1
)).shiftLeft(1).multiply(y1z1
).mod(this.curve
.p
)
12755 // y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
12756 var y3
= w
.multiply(THREE
).multiply(x1
).subtract(y1sqz1
.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1
).subtract(w
.pow(3)).mod(this.curve
.p
)
12757 // z3 = 8 * (y1 * z1)^3
12758 var z3
= y1z1
.pow(3).shiftLeft(3).mod(this.curve
.p
)
12760 return new Point(this.curve
, x3
, y3
, z3
)
12763 // Simple NAF (Non-Adjacent Form) multiplication algorithm
12764 // TODO: modularize the multiplication algorithm
12765 Point
.prototype.multiply = function (k
) {
12766 if (this.curve
.isInfinity(this)) return this
12767 if (k
.signum() === 0) return this.curve
.infinity
12770 var h
= e
.multiply(THREE
)
12772 var neg
= this.negate()
12775 for (var i
= h
.bitLength() - 2; i
> 0; --i
) {
12776 var hBit
= h
.testBit(i
)
12777 var eBit
= e
.testBit(i
)
12781 if (hBit
!== eBit
) {
12782 R
= R
.add(hBit
? this : neg
)
12789 // Compute this*j + x*k (simultaneous multiplication)
12790 Point
.prototype.multiplyTwo = function (j
, x
, k
) {
12791 var i
= Math
.max(j
.bitLength(), k
.bitLength()) - 1
12792 var R
= this.curve
.infinity
12793 var both
= this.add(x
)
12796 var jBit
= j
.testBit(i
)
12797 var kBit
= k
.testBit(i
)
12816 Point
.prototype.getEncoded = function (compressed
) {
12817 if (compressed
== null) compressed
= this.compressed
12818 if (this.curve
.isInfinity(this)) return new Buffer('00', 'hex') // Infinity point encoded is simply '00'
12820 var x
= this.affineX
12821 var y
= this.affineY
12822 var byteLength
= this.curve
.pLength
12827 buffer
= new Buffer(1 + byteLength
)
12828 buffer
.writeUInt8(y
.isEven() ? 0x02 : 0x03, 0)
12832 buffer
= new Buffer(1 + byteLength
+ byteLength
)
12833 buffer
.writeUInt8(0x04, 0)
12835 y
.toBuffer(byteLength
).copy(buffer
, 1 + byteLength
)
12838 x
.toBuffer(byteLength
).copy(buffer
, 1)
12843 Point
.decodeFrom = function (curve
, buffer
) {
12844 var type
= buffer
.readUInt8(0)
12845 var compressed
= (type
!== 4)
12847 var byteLength
= Math
.floor((curve
.p
.bitLength() + 7) / 8)
12848 var x
= BigInteger
.fromBuffer(buffer
.slice(1, 1 + byteLength
))
12852 assert
.equal(buffer
.length
, byteLength
+ 1, 'Invalid sequence length')
12853 assert(type
=== 0x02 || type
=== 0x03, 'Invalid sequence tag')
12855 var isOdd
= (type
=== 0x03)
12856 Q
= curve
.pointFromX(isOdd
, x
)
12858 assert
.equal(buffer
.length
, 1 + byteLength
+ byteLength
, 'Invalid sequence length')
12860 var y
= BigInteger
.fromBuffer(buffer
.slice(1 + byteLength
))
12861 Q
= Point
.fromAffine(curve
, x
, y
)
12864 Q
.compressed
= compressed
12868 Point
.prototype.toString = function () {
12869 if (this.curve
.isInfinity(this)) return '(INFINITY)'
12871 return '(' + this.affineX
.toString() + ',' + this.affineY
.toString() + ')'
12874 module
.exports
= Point
12876 }).call(this,require("buffer").Buffer
)
12877 },{"assert":1,"bigi":37,"buffer":4}],92:[function(require
,module
,exports
){
12878 (function (Buffer
){
12880 var Transform
= require('stream').Transform
12881 var inherits
= require('inherits')
12883 function HashBase (blockSize
) {
12884 Transform
.call(this)
12886 this._block
= new Buffer(blockSize
)
12887 this._blockSize
= blockSize
12888 this._blockOffset
= 0
12889 this._length
= [0, 0, 0, 0]
12891 this._finalized
= false
12894 inherits(HashBase
, Transform
)
12896 HashBase
.prototype._transform = function (chunk
, encoding
, callback
) {
12899 if (encoding
!== 'buffer') chunk
= new Buffer(chunk
, encoding
)
12908 HashBase
.prototype._flush = function (callback
) {
12911 this.push(this._digest())
12919 HashBase
.prototype.update = function (data
, encoding
) {
12920 if (!Buffer
.isBuffer(data
) && typeof data
!== 'string') throw new TypeError('Data must be a string or a buffer')
12921 if (this._finalized
) throw new Error('Digest already called')
12922 if (!Buffer
.isBuffer(data
)) data
= new Buffer(data
, encoding
|| 'binary')
12925 var block
= this._block
12927 while (this._blockOffset
+ data
.length
- offset
>= this._blockSize
) {
12928 for (var i
= this._blockOffset
; i
< this._blockSize
;) block
[i
++] = data
[offset
++]
12930 this._blockOffset
= 0
12932 while (offset
< data
.length
) block
[this._blockOffset
++] = data
[offset
++]
12935 for (var j
= 0, carry
= data
.length
* 8; carry
> 0; ++j
) {
12936 this._length
[j
] += carry
12937 carry
= (this._length
[j
] / 0x0100000000) | 0
12938 if (carry
> 0) this._length
[j
] -= 0x0100000000 * carry
12944 HashBase
.prototype._update = function (data
) {
12945 throw new Error('_update is not implemented')
12948 HashBase
.prototype.digest = function (encoding
) {
12949 if (this._finalized
) throw new Error('Digest already called')
12950 this._finalized
= true
12952 var digest
= this._digest()
12953 if (encoding
!== undefined) digest
= digest
.toString(encoding
)
12957 HashBase
.prototype._digest = function () {
12958 throw new Error('_digest is not implemented')
12961 module
.exports
= HashBase
12963 }).call(this,require("buffer").Buffer
)
12964 },{"buffer":4,"inherits":93,"stream":27}],93:[function(require
,module
,exports
){
12965 arguments
[4][8][0].apply(exports
,arguments
)
12966 },{"dup":8}],94:[function(require
,module
,exports
){
12967 (function (Buffer
){
12968 // constant-space merkle root calculation algorithm
12969 module
.exports
= function fastRoot (values
, digestFn
) {
12970 if (!Array
.isArray(values
)) throw TypeError('Expected values Array')
12971 if (typeof digestFn
!== 'function') throw TypeError('Expected digest Function')
12973 var length
= values
.length
12974 var results
= values
.concat()
12976 while (length
> 1) {
12979 for (var i
= 0; i
< length
; i
+= 2, ++j
) {
12980 var left
= results
[i
]
12981 var right
= i
+ 1 === length
? left : results
[i
+ 1]
12982 var data
= Buffer
.concat([left
, right
])
12984 results
[j
] = digestFn(data
)
12993 }).call(this,require("buffer").Buffer
)
12994 },{"buffer":4}],95:[function(require
,module
,exports
){
12995 var OPS
= require('bitcoin-ops')
12997 function encodingLength (i
) {
12998 return i
< OPS
.OP_PUSHDATA1
? 1
13004 function encode (buffer
, number
, offset
) {
13005 var size
= encodingLength(number
)
13009 buffer
.writeUInt8(number
, offset
)
13012 } else if (size
=== 2) {
13013 buffer
.writeUInt8(OPS
.OP_PUSHDATA1
, offset
)
13014 buffer
.writeUInt8(number
, offset
+ 1)
13017 } else if (size
=== 3) {
13018 buffer
.writeUInt8(OPS
.OP_PUSHDATA2
, offset
)
13019 buffer
.writeUInt16LE(number
, offset
+ 1)
13023 buffer
.writeUInt8(OPS
.OP_PUSHDATA4
, offset
)
13024 buffer
.writeUInt32LE(number
, offset
+ 1)
13030 function decode (buffer
, offset
) {
13031 var opcode
= buffer
.readUInt8(offset
)
13035 if (opcode
< OPS
.OP_PUSHDATA1
) {
13040 } else if (opcode
=== OPS
.OP_PUSHDATA1
) {
13041 if (offset
+ 2 > buffer
.length
) return null
13042 number
= buffer
.readUInt8(offset
+ 1)
13046 } else if (opcode
=== OPS
.OP_PUSHDATA2
) {
13047 if (offset
+ 3 > buffer
.length
) return null
13048 number
= buffer
.readUInt16LE(offset
+ 1)
13053 if (offset
+ 5 > buffer
.length
) return null
13054 if (opcode
!== OPS
.OP_PUSHDATA4
) throw new Error('Unexpected opcode')
13056 number
= buffer
.readUInt32LE(offset
+ 1)
13068 encodingLength: encodingLength
,
13073 },{"bitcoin-ops":40}],96:[function(require
,module
,exports
){
13074 (function (process
,global
){
13077 function oldBrowser () {
13078 throw new Error('secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11')
13081 var Buffer
= require('safe-buffer').Buffer
13082 var crypto
= global
.crypto
|| global
.msCrypto
13084 if (crypto
&& crypto
.getRandomValues
) {
13085 module
.exports
= randomBytes
13087 module
.exports
= oldBrowser
13090 function randomBytes (size
, cb
) {
13091 // phantomjs needs to throw
13092 if (size
> 65536) throw new Error('requested too many random bytes')
13093 // in case browserify isn't using the Uint8Array version
13094 var rawBytes
= new global
.Uint8Array(size
)
13096 // This will not work in older browsers.
13097 // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
13098 if (size
> 0) { // getRandomValues fails on IE if size == 0
13099 crypto
.getRandomValues(rawBytes
)
13102 // XXX: phantomjs doesn't like a buffer being passed here
13103 var bytes
= Buffer
.from(rawBytes
.buffer
)
13105 if (typeof cb
=== 'function') {
13106 return process
.nextTick(function () {
13114 }).call(this,require('_process'),typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
13115 },{"_process":12,"safe-buffer":98}],97:[function(require
,module
,exports
){
13116 (function (Buffer
){
13118 var inherits
= require('inherits')
13119 var HashBase
= require('hash-base')
13121 function RIPEMD160 () {
13122 HashBase
.call(this, 64)
13125 this._a
= 0x67452301
13126 this._b
= 0xefcdab89
13127 this._c
= 0x98badcfe
13128 this._d
= 0x10325476
13129 this._e
= 0xc3d2e1f0
13132 inherits(RIPEMD160
, HashBase
)
13134 RIPEMD160
.prototype._update = function () {
13135 var m
= new Array(16)
13136 for (var i
= 0; i
< 16; ++i
) m
[i
] = this._block
.readInt32LE(i
* 4)
13144 // Mj = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
13146 // Sj = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8
13147 al
= fn1(al
, bl
, cl
, dl
, el
, m
[0], 0x00000000, 11); cl
= rotl(cl
, 10)
13148 el
= fn1(el
, al
, bl
, cl
, dl
, m
[1], 0x00000000, 14); bl
= rotl(bl
, 10)
13149 dl
= fn1(dl
, el
, al
, bl
, cl
, m
[2], 0x00000000, 15); al
= rotl(al
, 10)
13150 cl
= fn1(cl
, dl
, el
, al
, bl
, m
[3], 0x00000000, 12); el
= rotl(el
, 10)
13151 bl
= fn1(bl
, cl
, dl
, el
, al
, m
[4], 0x00000000, 5); dl
= rotl(dl
, 10)
13152 al
= fn1(al
, bl
, cl
, dl
, el
, m
[5], 0x00000000, 8); cl
= rotl(cl
, 10)
13153 el
= fn1(el
, al
, bl
, cl
, dl
, m
[6], 0x00000000, 7); bl
= rotl(bl
, 10)
13154 dl
= fn1(dl
, el
, al
, bl
, cl
, m
[7], 0x00000000, 9); al
= rotl(al
, 10)
13155 cl
= fn1(cl
, dl
, el
, al
, bl
, m
[8], 0x00000000, 11); el
= rotl(el
, 10)
13156 bl
= fn1(bl
, cl
, dl
, el
, al
, m
[9], 0x00000000, 13); dl
= rotl(dl
, 10)
13157 al
= fn1(al
, bl
, cl
, dl
, el
, m
[10], 0x00000000, 14); cl
= rotl(cl
, 10)
13158 el
= fn1(el
, al
, bl
, cl
, dl
, m
[11], 0x00000000, 15); bl
= rotl(bl
, 10)
13159 dl
= fn1(dl
, el
, al
, bl
, cl
, m
[12], 0x00000000, 6); al
= rotl(al
, 10)
13160 cl
= fn1(cl
, dl
, el
, al
, bl
, m
[13], 0x00000000, 7); el
= rotl(el
, 10)
13161 bl
= fn1(bl
, cl
, dl
, el
, al
, m
[14], 0x00000000, 9); dl
= rotl(dl
, 10)
13162 al
= fn1(al
, bl
, cl
, dl
, el
, m
[15], 0x00000000, 8); cl
= rotl(cl
, 10)
13164 // Mj = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8
13166 // Sj = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12
13167 el
= fn2(el
, al
, bl
, cl
, dl
, m
[7], 0x5a827999, 7); bl
= rotl(bl
, 10)
13168 dl
= fn2(dl
, el
, al
, bl
, cl
, m
[4], 0x5a827999, 6); al
= rotl(al
, 10)
13169 cl
= fn2(cl
, dl
, el
, al
, bl
, m
[13], 0x5a827999, 8); el
= rotl(el
, 10)
13170 bl
= fn2(bl
, cl
, dl
, el
, al
, m
[1], 0x5a827999, 13); dl
= rotl(dl
, 10)
13171 al
= fn2(al
, bl
, cl
, dl
, el
, m
[10], 0x5a827999, 11); cl
= rotl(cl
, 10)
13172 el
= fn2(el
, al
, bl
, cl
, dl
, m
[6], 0x5a827999, 9); bl
= rotl(bl
, 10)
13173 dl
= fn2(dl
, el
, al
, bl
, cl
, m
[15], 0x5a827999, 7); al
= rotl(al
, 10)
13174 cl
= fn2(cl
, dl
, el
, al
, bl
, m
[3], 0x5a827999, 15); el
= rotl(el
, 10)
13175 bl
= fn2(bl
, cl
, dl
, el
, al
, m
[12], 0x5a827999, 7); dl
= rotl(dl
, 10)
13176 al
= fn2(al
, bl
, cl
, dl
, el
, m
[0], 0x5a827999, 12); cl
= rotl(cl
, 10)
13177 el
= fn2(el
, al
, bl
, cl
, dl
, m
[9], 0x5a827999, 15); bl
= rotl(bl
, 10)
13178 dl
= fn2(dl
, el
, al
, bl
, cl
, m
[5], 0x5a827999, 9); al
= rotl(al
, 10)
13179 cl
= fn2(cl
, dl
, el
, al
, bl
, m
[2], 0x5a827999, 11); el
= rotl(el
, 10)
13180 bl
= fn2(bl
, cl
, dl
, el
, al
, m
[14], 0x5a827999, 7); dl
= rotl(dl
, 10)
13181 al
= fn2(al
, bl
, cl
, dl
, el
, m
[11], 0x5a827999, 13); cl
= rotl(cl
, 10)
13182 el
= fn2(el
, al
, bl
, cl
, dl
, m
[8], 0x5a827999, 12); bl
= rotl(bl
, 10)
13184 // Mj = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12
13186 // Sj = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5
13187 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[3], 0x6ed9eba1, 11); al
= rotl(al
, 10)
13188 cl
= fn3(cl
, dl
, el
, al
, bl
, m
[10], 0x6ed9eba1, 13); el
= rotl(el
, 10)
13189 bl
= fn3(bl
, cl
, dl
, el
, al
, m
[14], 0x6ed9eba1, 6); dl
= rotl(dl
, 10)
13190 al
= fn3(al
, bl
, cl
, dl
, el
, m
[4], 0x6ed9eba1, 7); cl
= rotl(cl
, 10)
13191 el
= fn3(el
, al
, bl
, cl
, dl
, m
[9], 0x6ed9eba1, 14); bl
= rotl(bl
, 10)
13192 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[15], 0x6ed9eba1, 9); al
= rotl(al
, 10)
13193 cl
= fn3(cl
, dl
, el
, al
, bl
, m
[8], 0x6ed9eba1, 13); el
= rotl(el
, 10)
13194 bl
= fn3(bl
, cl
, dl
, el
, al
, m
[1], 0x6ed9eba1, 15); dl
= rotl(dl
, 10)
13195 al
= fn3(al
, bl
, cl
, dl
, el
, m
[2], 0x6ed9eba1, 14); cl
= rotl(cl
, 10)
13196 el
= fn3(el
, al
, bl
, cl
, dl
, m
[7], 0x6ed9eba1, 8); bl
= rotl(bl
, 10)
13197 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[0], 0x6ed9eba1, 13); al
= rotl(al
, 10)
13198 cl
= fn3(cl
, dl
, el
, al
, bl
, m
[6], 0x6ed9eba1, 6); el
= rotl(el
, 10)
13199 bl
= fn3(bl
, cl
, dl
, el
, al
, m
[13], 0x6ed9eba1, 5); dl
= rotl(dl
, 10)
13200 al
= fn3(al
, bl
, cl
, dl
, el
, m
[11], 0x6ed9eba1, 12); cl
= rotl(cl
, 10)
13201 el
= fn3(el
, al
, bl
, cl
, dl
, m
[5], 0x6ed9eba1, 7); bl
= rotl(bl
, 10)
13202 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[12], 0x6ed9eba1, 5); al
= rotl(al
, 10)
13204 // Mj = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2
13206 // Sj = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12
13207 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[1], 0x8f1bbcdc, 11); el
= rotl(el
, 10)
13208 bl
= fn4(bl
, cl
, dl
, el
, al
, m
[9], 0x8f1bbcdc, 12); dl
= rotl(dl
, 10)
13209 al
= fn4(al
, bl
, cl
, dl
, el
, m
[11], 0x8f1bbcdc, 14); cl
= rotl(cl
, 10)
13210 el
= fn4(el
, al
, bl
, cl
, dl
, m
[10], 0x8f1bbcdc, 15); bl
= rotl(bl
, 10)
13211 dl
= fn4(dl
, el
, al
, bl
, cl
, m
[0], 0x8f1bbcdc, 14); al
= rotl(al
, 10)
13212 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[8], 0x8f1bbcdc, 15); el
= rotl(el
, 10)
13213 bl
= fn4(bl
, cl
, dl
, el
, al
, m
[12], 0x8f1bbcdc, 9); dl
= rotl(dl
, 10)
13214 al
= fn4(al
, bl
, cl
, dl
, el
, m
[4], 0x8f1bbcdc, 8); cl
= rotl(cl
, 10)
13215 el
= fn4(el
, al
, bl
, cl
, dl
, m
[13], 0x8f1bbcdc, 9); bl
= rotl(bl
, 10)
13216 dl
= fn4(dl
, el
, al
, bl
, cl
, m
[3], 0x8f1bbcdc, 14); al
= rotl(al
, 10)
13217 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[7], 0x8f1bbcdc, 5); el
= rotl(el
, 10)
13218 bl
= fn4(bl
, cl
, dl
, el
, al
, m
[15], 0x8f1bbcdc, 6); dl
= rotl(dl
, 10)
13219 al
= fn4(al
, bl
, cl
, dl
, el
, m
[14], 0x8f1bbcdc, 8); cl
= rotl(cl
, 10)
13220 el
= fn4(el
, al
, bl
, cl
, dl
, m
[5], 0x8f1bbcdc, 6); bl
= rotl(bl
, 10)
13221 dl
= fn4(dl
, el
, al
, bl
, cl
, m
[6], 0x8f1bbcdc, 5); al
= rotl(al
, 10)
13222 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[2], 0x8f1bbcdc, 12); el
= rotl(el
, 10)
13224 // Mj = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
13226 // Sj = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
13227 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[4], 0xa953fd4e, 9); dl
= rotl(dl
, 10)
13228 al
= fn5(al
, bl
, cl
, dl
, el
, m
[0], 0xa953fd4e, 15); cl
= rotl(cl
, 10)
13229 el
= fn5(el
, al
, bl
, cl
, dl
, m
[5], 0xa953fd4e, 5); bl
= rotl(bl
, 10)
13230 dl
= fn5(dl
, el
, al
, bl
, cl
, m
[9], 0xa953fd4e, 11); al
= rotl(al
, 10)
13231 cl
= fn5(cl
, dl
, el
, al
, bl
, m
[7], 0xa953fd4e, 6); el
= rotl(el
, 10)
13232 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[12], 0xa953fd4e, 8); dl
= rotl(dl
, 10)
13233 al
= fn5(al
, bl
, cl
, dl
, el
, m
[2], 0xa953fd4e, 13); cl
= rotl(cl
, 10)
13234 el
= fn5(el
, al
, bl
, cl
, dl
, m
[10], 0xa953fd4e, 12); bl
= rotl(bl
, 10)
13235 dl
= fn5(dl
, el
, al
, bl
, cl
, m
[14], 0xa953fd4e, 5); al
= rotl(al
, 10)
13236 cl
= fn5(cl
, dl
, el
, al
, bl
, m
[1], 0xa953fd4e, 12); el
= rotl(el
, 10)
13237 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[3], 0xa953fd4e, 13); dl
= rotl(dl
, 10)
13238 al
= fn5(al
, bl
, cl
, dl
, el
, m
[8], 0xa953fd4e, 14); cl
= rotl(cl
, 10)
13239 el
= fn5(el
, al
, bl
, cl
, dl
, m
[11], 0xa953fd4e, 11); bl
= rotl(bl
, 10)
13240 dl
= fn5(dl
, el
, al
, bl
, cl
, m
[6], 0xa953fd4e, 8); al
= rotl(al
, 10)
13241 cl
= fn5(cl
, dl
, el
, al
, bl
, m
[15], 0xa953fd4e, 5); el
= rotl(el
, 10)
13242 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[13], 0xa953fd4e, 6); dl
= rotl(dl
, 10)
13250 // M'j = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12
13252 // S'j = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6
13253 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[5], 0x50a28be6, 8); cr
= rotl(cr
, 10)
13254 er
= fn5(er
, ar
, br
, cr
, dr
, m
[14], 0x50a28be6, 9); br
= rotl(br
, 10)
13255 dr
= fn5(dr
, er
, ar
, br
, cr
, m
[7], 0x50a28be6, 9); ar
= rotl(ar
, 10)
13256 cr
= fn5(cr
, dr
, er
, ar
, br
, m
[0], 0x50a28be6, 11); er
= rotl(er
, 10)
13257 br
= fn5(br
, cr
, dr
, er
, ar
, m
[9], 0x50a28be6, 13); dr
= rotl(dr
, 10)
13258 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[2], 0x50a28be6, 15); cr
= rotl(cr
, 10)
13259 er
= fn5(er
, ar
, br
, cr
, dr
, m
[11], 0x50a28be6, 15); br
= rotl(br
, 10)
13260 dr
= fn5(dr
, er
, ar
, br
, cr
, m
[4], 0x50a28be6, 5); ar
= rotl(ar
, 10)
13261 cr
= fn5(cr
, dr
, er
, ar
, br
, m
[13], 0x50a28be6, 7); er
= rotl(er
, 10)
13262 br
= fn5(br
, cr
, dr
, er
, ar
, m
[6], 0x50a28be6, 7); dr
= rotl(dr
, 10)
13263 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[15], 0x50a28be6, 8); cr
= rotl(cr
, 10)
13264 er
= fn5(er
, ar
, br
, cr
, dr
, m
[8], 0x50a28be6, 11); br
= rotl(br
, 10)
13265 dr
= fn5(dr
, er
, ar
, br
, cr
, m
[1], 0x50a28be6, 14); ar
= rotl(ar
, 10)
13266 cr
= fn5(cr
, dr
, er
, ar
, br
, m
[10], 0x50a28be6, 14); er
= rotl(er
, 10)
13267 br
= fn5(br
, cr
, dr
, er
, ar
, m
[3], 0x50a28be6, 12); dr
= rotl(dr
, 10)
13268 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[12], 0x50a28be6, 6); cr
= rotl(cr
, 10)
13270 // M'j = 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2
13272 // S'j = 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11
13273 er
= fn4(er
, ar
, br
, cr
, dr
, m
[6], 0x5c4dd124, 9); br
= rotl(br
, 10)
13274 dr
= fn4(dr
, er
, ar
, br
, cr
, m
[11], 0x5c4dd124, 13); ar
= rotl(ar
, 10)
13275 cr
= fn4(cr
, dr
, er
, ar
, br
, m
[3], 0x5c4dd124, 15); er
= rotl(er
, 10)
13276 br
= fn4(br
, cr
, dr
, er
, ar
, m
[7], 0x5c4dd124, 7); dr
= rotl(dr
, 10)
13277 ar
= fn4(ar
, br
, cr
, dr
, er
, m
[0], 0x5c4dd124, 12); cr
= rotl(cr
, 10)
13278 er
= fn4(er
, ar
, br
, cr
, dr
, m
[13], 0x5c4dd124, 8); br
= rotl(br
, 10)
13279 dr
= fn4(dr
, er
, ar
, br
, cr
, m
[5], 0x5c4dd124, 9); ar
= rotl(ar
, 10)
13280 cr
= fn4(cr
, dr
, er
, ar
, br
, m
[10], 0x5c4dd124, 11); er
= rotl(er
, 10)
13281 br
= fn4(br
, cr
, dr
, er
, ar
, m
[14], 0x5c4dd124, 7); dr
= rotl(dr
, 10)
13282 ar
= fn4(ar
, br
, cr
, dr
, er
, m
[15], 0x5c4dd124, 7); cr
= rotl(cr
, 10)
13283 er
= fn4(er
, ar
, br
, cr
, dr
, m
[8], 0x5c4dd124, 12); br
= rotl(br
, 10)
13284 dr
= fn4(dr
, er
, ar
, br
, cr
, m
[12], 0x5c4dd124, 7); ar
= rotl(ar
, 10)
13285 cr
= fn4(cr
, dr
, er
, ar
, br
, m
[4], 0x5c4dd124, 6); er
= rotl(er
, 10)
13286 br
= fn4(br
, cr
, dr
, er
, ar
, m
[9], 0x5c4dd124, 15); dr
= rotl(dr
, 10)
13287 ar
= fn4(ar
, br
, cr
, dr
, er
, m
[1], 0x5c4dd124, 13); cr
= rotl(cr
, 10)
13288 er
= fn4(er
, ar
, br
, cr
, dr
, m
[2], 0x5c4dd124, 11); br
= rotl(br
, 10)
13290 // M'j = 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13
13292 // S'j = 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5
13293 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[15], 0x6d703ef3, 9); ar
= rotl(ar
, 10)
13294 cr
= fn3(cr
, dr
, er
, ar
, br
, m
[5], 0x6d703ef3, 7); er
= rotl(er
, 10)
13295 br
= fn3(br
, cr
, dr
, er
, ar
, m
[1], 0x6d703ef3, 15); dr
= rotl(dr
, 10)
13296 ar
= fn3(ar
, br
, cr
, dr
, er
, m
[3], 0x6d703ef3, 11); cr
= rotl(cr
, 10)
13297 er
= fn3(er
, ar
, br
, cr
, dr
, m
[7], 0x6d703ef3, 8); br
= rotl(br
, 10)
13298 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[14], 0x6d703ef3, 6); ar
= rotl(ar
, 10)
13299 cr
= fn3(cr
, dr
, er
, ar
, br
, m
[6], 0x6d703ef3, 6); er
= rotl(er
, 10)
13300 br
= fn3(br
, cr
, dr
, er
, ar
, m
[9], 0x6d703ef3, 14); dr
= rotl(dr
, 10)
13301 ar
= fn3(ar
, br
, cr
, dr
, er
, m
[11], 0x6d703ef3, 12); cr
= rotl(cr
, 10)
13302 er
= fn3(er
, ar
, br
, cr
, dr
, m
[8], 0x6d703ef3, 13); br
= rotl(br
, 10)
13303 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[12], 0x6d703ef3, 5); ar
= rotl(ar
, 10)
13304 cr
= fn3(cr
, dr
, er
, ar
, br
, m
[2], 0x6d703ef3, 14); er
= rotl(er
, 10)
13305 br
= fn3(br
, cr
, dr
, er
, ar
, m
[10], 0x6d703ef3, 13); dr
= rotl(dr
, 10)
13306 ar
= fn3(ar
, br
, cr
, dr
, er
, m
[0], 0x6d703ef3, 13); cr
= rotl(cr
, 10)
13307 er
= fn3(er
, ar
, br
, cr
, dr
, m
[4], 0x6d703ef3, 7); br
= rotl(br
, 10)
13308 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[13], 0x6d703ef3, 5); ar
= rotl(ar
, 10)
13310 // M'j = 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14
13312 // S'j = 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8
13313 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[8], 0x7a6d76e9, 15); er
= rotl(er
, 10)
13314 br
= fn2(br
, cr
, dr
, er
, ar
, m
[6], 0x7a6d76e9, 5); dr
= rotl(dr
, 10)
13315 ar
= fn2(ar
, br
, cr
, dr
, er
, m
[4], 0x7a6d76e9, 8); cr
= rotl(cr
, 10)
13316 er
= fn2(er
, ar
, br
, cr
, dr
, m
[1], 0x7a6d76e9, 11); br
= rotl(br
, 10)
13317 dr
= fn2(dr
, er
, ar
, br
, cr
, m
[3], 0x7a6d76e9, 14); ar
= rotl(ar
, 10)
13318 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[11], 0x7a6d76e9, 14); er
= rotl(er
, 10)
13319 br
= fn2(br
, cr
, dr
, er
, ar
, m
[15], 0x7a6d76e9, 6); dr
= rotl(dr
, 10)
13320 ar
= fn2(ar
, br
, cr
, dr
, er
, m
[0], 0x7a6d76e9, 14); cr
= rotl(cr
, 10)
13321 er
= fn2(er
, ar
, br
, cr
, dr
, m
[5], 0x7a6d76e9, 6); br
= rotl(br
, 10)
13322 dr
= fn2(dr
, er
, ar
, br
, cr
, m
[12], 0x7a6d76e9, 9); ar
= rotl(ar
, 10)
13323 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[2], 0x7a6d76e9, 12); er
= rotl(er
, 10)
13324 br
= fn2(br
, cr
, dr
, er
, ar
, m
[13], 0x7a6d76e9, 9); dr
= rotl(dr
, 10)
13325 ar
= fn2(ar
, br
, cr
, dr
, er
, m
[9], 0x7a6d76e9, 12); cr
= rotl(cr
, 10)
13326 er
= fn2(er
, ar
, br
, cr
, dr
, m
[7], 0x7a6d76e9, 5); br
= rotl(br
, 10)
13327 dr
= fn2(dr
, er
, ar
, br
, cr
, m
[10], 0x7a6d76e9, 15); ar
= rotl(ar
, 10)
13328 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[14], 0x7a6d76e9, 8); er
= rotl(er
, 10)
13330 // M'j = 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
13332 // S'j = 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
13333 br
= fn1(br
, cr
, dr
, er
, ar
, m
[12], 0x00000000, 8); dr
= rotl(dr
, 10)
13334 ar
= fn1(ar
, br
, cr
, dr
, er
, m
[15], 0x00000000, 5); cr
= rotl(cr
, 10)
13335 er
= fn1(er
, ar
, br
, cr
, dr
, m
[10], 0x00000000, 12); br
= rotl(br
, 10)
13336 dr
= fn1(dr
, er
, ar
, br
, cr
, m
[4], 0x00000000, 9); ar
= rotl(ar
, 10)
13337 cr
= fn1(cr
, dr
, er
, ar
, br
, m
[1], 0x00000000, 12); er
= rotl(er
, 10)
13338 br
= fn1(br
, cr
, dr
, er
, ar
, m
[5], 0x00000000, 5); dr
= rotl(dr
, 10)
13339 ar
= fn1(ar
, br
, cr
, dr
, er
, m
[8], 0x00000000, 14); cr
= rotl(cr
, 10)
13340 er
= fn1(er
, ar
, br
, cr
, dr
, m
[7], 0x00000000, 6); br
= rotl(br
, 10)
13341 dr
= fn1(dr
, er
, ar
, br
, cr
, m
[6], 0x00000000, 8); ar
= rotl(ar
, 10)
13342 cr
= fn1(cr
, dr
, er
, ar
, br
, m
[2], 0x00000000, 13); er
= rotl(er
, 10)
13343 br
= fn1(br
, cr
, dr
, er
, ar
, m
[13], 0x00000000, 6); dr
= rotl(dr
, 10)
13344 ar
= fn1(ar
, br
, cr
, dr
, er
, m
[14], 0x00000000, 5); cr
= rotl(cr
, 10)
13345 er
= fn1(er
, ar
, br
, cr
, dr
, m
[0], 0x00000000, 15); br
= rotl(br
, 10)
13346 dr
= fn1(dr
, er
, ar
, br
, cr
, m
[3], 0x00000000, 13); ar
= rotl(ar
, 10)
13347 cr
= fn1(cr
, dr
, er
, ar
, br
, m
[9], 0x00000000, 11); er
= rotl(er
, 10)
13348 br
= fn1(br
, cr
, dr
, er
, ar
, m
[11], 0x00000000, 11); dr
= rotl(dr
, 10)
13351 var t
= (this._b
+ cl
+ dr
) | 0
13352 this._b
= (this._c
+ dl
+ er
) | 0
13353 this._c
= (this._d
+ el
+ ar
) | 0
13354 this._d
= (this._e
+ al
+ br
) | 0
13355 this._e
= (this._a
+ bl
+ cr
) | 0
13359 RIPEMD160
.prototype._digest = function () {
13360 // create padding and handle blocks
13361 this._block
[this._blockOffset
++] = 0x80
13362 if (this._blockOffset
> 56) {
13363 this._block
.fill(0, this._blockOffset
, 64)
13365 this._blockOffset
= 0
13368 this._block
.fill(0, this._blockOffset
, 56)
13369 this._block
.writeUInt32LE(this._length
[0], 56)
13370 this._block
.writeUInt32LE(this._length
[1], 60)
13374 var buffer
= new Buffer(20)
13375 buffer
.writeInt32LE(this._a
, 0)
13376 buffer
.writeInt32LE(this._b
, 4)
13377 buffer
.writeInt32LE(this._c
, 8)
13378 buffer
.writeInt32LE(this._d
, 12)
13379 buffer
.writeInt32LE(this._e
, 16)
13383 function rotl (x
, n
) {
13384 return (x
<< n
) | (x
>>> (32 - n
))
13387 function fn1 (a
, b
, c
, d
, e
, m
, k
, s
) {
13388 return (rotl((a
+ (b
^ c
^ d
) + m
+ k
) | 0, s
) + e
) | 0
13391 function fn2 (a
, b
, c
, d
, e
, m
, k
, s
) {
13392 return (rotl((a
+ ((b
& c
) | ((~b
) & d
)) + m
+ k
) | 0, s
) + e
) | 0
13395 function fn3 (a
, b
, c
, d
, e
, m
, k
, s
) {
13396 return (rotl((a
+ ((b
| (~c
)) ^ d
) + m
+ k
) | 0, s
) + e
) | 0
13399 function fn4 (a
, b
, c
, d
, e
, m
, k
, s
) {
13400 return (rotl((a
+ ((b
& d
) | (c
& (~d
))) + m
+ k
) | 0, s
) + e
) | 0
13403 function fn5 (a
, b
, c
, d
, e
, m
, k
, s
) {
13404 return (rotl((a
+ (b
^ (c
| (~d
))) + m
+ k
) | 0, s
) + e
) | 0
13407 module
.exports
= RIPEMD160
13409 }).call(this,require("buffer").Buffer
)
13410 },{"buffer":4,"hash-base":92,"inherits":93}],98:[function(require
,module
,exports
){
13411 arguments
[4][26][0].apply(exports
,arguments
)
13412 },{"buffer":4,"dup":26}],99:[function(require
,module
,exports
){
13413 (function (Buffer
){
13414 // prototype class for hash functions
13415 function Hash (blockSize
, finalSize
) {
13416 this._block
= new Buffer(blockSize
)
13417 this._finalSize
= finalSize
13418 this._blockSize
= blockSize
13423 Hash
.prototype.update = function (data
, enc
) {
13424 if (typeof data
=== 'string') {
13425 enc
= enc
|| 'utf8'
13426 data
= new Buffer(data
, enc
)
13429 var l
= this._len
+= data
.length
13430 var s
= this._s
|| 0
13432 var buffer
= this._block
13435 var t
= Math
.min(data
.length
, f
+ this._blockSize
- (s
% this._blockSize
))
13438 for (var i
= 0; i
< ch
; i
++) {
13439 buffer
[(s
% this._blockSize
) + i
] = data
[i
+ f
]
13445 if ((s
% this._blockSize
) === 0) {
13446 this._update(buffer
)
13454 Hash
.prototype.digest = function (enc
) {
13455 // Suppose the length of the message M, in bits, is l
13456 var l
= this._len
* 8
13458 // Append the bit 1 to the end of the message
13459 this._block
[this._len
% this._blockSize
] = 0x80
13461 // and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
13462 this._block
.fill(0, this._len
% this._blockSize
+ 1)
13464 if (l
% (this._blockSize
* 8) >= this._finalSize
* 8) {
13465 this._update(this._block
)
13466 this._block
.fill(0)
13469 // to this append the block which is equal to the number l written in binary
13470 // TODO: handle case where l is > Math.pow(2, 29)
13471 this._block
.writeInt32BE(l
, this._blockSize
- 4)
13473 var hash
= this._update(this._block
) || this._hash()
13475 return enc
? hash
.toString(enc
) : hash
13478 Hash
.prototype._update = function () {
13479 throw new Error('_update must be implemented by subclass')
13482 module
.exports
= Hash
13484 }).call(this,require("buffer").Buffer
)
13485 },{"buffer":4}],100:[function(require
,module
,exports
){
13486 var exports
= module
.exports
= function SHA (algorithm
) {
13487 algorithm
= algorithm
.toLowerCase()
13489 var Algorithm
= exports
[algorithm
]
13490 if (!Algorithm
) throw new Error(algorithm
+ ' is not supported (we accept pull requests)')
13492 return new Algorithm()
13495 exports
.sha
= require('./sha')
13496 exports
.sha1
= require('./sha1')
13497 exports
.sha224
= require('./sha224')
13498 exports
.sha256
= require('./sha256')
13499 exports
.sha384
= require('./sha384')
13500 exports
.sha512
= require('./sha512')
13502 },{"./sha":101,"./sha1":102,"./sha224":103,"./sha256":104,"./sha384":105,"./sha512":106}],101:[function(require
,module
,exports
){
13503 (function (Buffer
){
13505 * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
13506 * in FIPS PUB 180-1
13507 * This source code is derived from sha1.js of the same repository.
13508 * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
13509 * operation was added.
13512 var inherits
= require('inherits')
13513 var Hash
= require('./hash')
13516 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
13519 var W
= new Array(80)
13525 Hash
.call(this, 64, 56)
13528 inherits(Sha
, Hash
)
13530 Sha
.prototype.init = function () {
13531 this._a
= 0x67452301
13532 this._b
= 0xefcdab89
13533 this._c
= 0x98badcfe
13534 this._d
= 0x10325476
13535 this._e
= 0xc3d2e1f0
13540 function rotl5 (num
) {
13541 return (num
<< 5) | (num
>>> 27)
13544 function rotl30 (num
) {
13545 return (num
<< 30) | (num
>>> 2)
13548 function ft (s
, b
, c
, d
) {
13549 if (s
=== 0) return (b
& c
) | ((~b
) & d
)
13550 if (s
=== 2) return (b
& c
) | (b
& d
) | (c
& d
)
13554 Sha
.prototype._update = function (M
) {
13557 var a
= this._a
| 0
13558 var b
= this._b
| 0
13559 var c
= this._c
| 0
13560 var d
= this._d
| 0
13561 var e
= this._e
| 0
13563 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
13564 for (; i
< 80; ++i
) W
[i
] = W
[i
- 3] ^ W
[i
- 8] ^ W
[i
- 14] ^ W
[i
- 16]
13566 for (var j
= 0; j
< 80; ++j
) {
13568 var t
= (rotl5(a
) + ft(s
, b
, c
, d
) + e
+ W
[j
] + K
[s
]) | 0
13577 this._a
= (a
+ this._a
) | 0
13578 this._b
= (b
+ this._b
) | 0
13579 this._c
= (c
+ this._c
) | 0
13580 this._d
= (d
+ this._d
) | 0
13581 this._e
= (e
+ this._e
) | 0
13584 Sha
.prototype._hash = function () {
13585 var H
= new Buffer(20)
13587 H
.writeInt32BE(this._a
| 0, 0)
13588 H
.writeInt32BE(this._b
| 0, 4)
13589 H
.writeInt32BE(this._c
| 0, 8)
13590 H
.writeInt32BE(this._d
| 0, 12)
13591 H
.writeInt32BE(this._e
| 0, 16)
13596 module
.exports
= Sha
13598 }).call(this,require("buffer").Buffer
)
13599 },{"./hash":99,"buffer":4,"inherits":93}],102:[function(require
,module
,exports
){
13600 (function (Buffer
){
13602 * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
13603 * in FIPS PUB 180-1
13604 * Version 2.1a Copyright Paul Johnston 2000 - 2002.
13605 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
13606 * Distributed under the BSD License
13607 * See http://pajhome.org.uk/crypt/md5 for details.
13610 var inherits
= require('inherits')
13611 var Hash
= require('./hash')
13614 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
13617 var W
= new Array(80)
13623 Hash
.call(this, 64, 56)
13626 inherits(Sha1
, Hash
)
13628 Sha1
.prototype.init = function () {
13629 this._a
= 0x67452301
13630 this._b
= 0xefcdab89
13631 this._c
= 0x98badcfe
13632 this._d
= 0x10325476
13633 this._e
= 0xc3d2e1f0
13638 function rotl1 (num
) {
13639 return (num
<< 1) | (num
>>> 31)
13642 function rotl5 (num
) {
13643 return (num
<< 5) | (num
>>> 27)
13646 function rotl30 (num
) {
13647 return (num
<< 30) | (num
>>> 2)
13650 function ft (s
, b
, c
, d
) {
13651 if (s
=== 0) return (b
& c
) | ((~b
) & d
)
13652 if (s
=== 2) return (b
& c
) | (b
& d
) | (c
& d
)
13656 Sha1
.prototype._update = function (M
) {
13659 var a
= this._a
| 0
13660 var b
= this._b
| 0
13661 var c
= this._c
| 0
13662 var d
= this._d
| 0
13663 var e
= this._e
| 0
13665 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
13666 for (; i
< 80; ++i
) W
[i
] = rotl1(W
[i
- 3] ^ W
[i
- 8] ^ W
[i
- 14] ^ W
[i
- 16])
13668 for (var j
= 0; j
< 80; ++j
) {
13670 var t
= (rotl5(a
) + ft(s
, b
, c
, d
) + e
+ W
[j
] + K
[s
]) | 0
13679 this._a
= (a
+ this._a
) | 0
13680 this._b
= (b
+ this._b
) | 0
13681 this._c
= (c
+ this._c
) | 0
13682 this._d
= (d
+ this._d
) | 0
13683 this._e
= (e
+ this._e
) | 0
13686 Sha1
.prototype._hash = function () {
13687 var H
= new Buffer(20)
13689 H
.writeInt32BE(this._a
| 0, 0)
13690 H
.writeInt32BE(this._b
| 0, 4)
13691 H
.writeInt32BE(this._c
| 0, 8)
13692 H
.writeInt32BE(this._d
| 0, 12)
13693 H
.writeInt32BE(this._e
| 0, 16)
13698 module
.exports
= Sha1
13700 }).call(this,require("buffer").Buffer
)
13701 },{"./hash":99,"buffer":4,"inherits":93}],103:[function(require
,module
,exports
){
13702 (function (Buffer
){
13704 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
13706 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
13707 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
13711 var inherits
= require('inherits')
13712 var Sha256
= require('./sha256')
13713 var Hash
= require('./hash')
13715 var W
= new Array(64)
13717 function Sha224 () {
13720 this._w
= W
// new Array(64)
13722 Hash
.call(this, 64, 56)
13725 inherits(Sha224
, Sha256
)
13727 Sha224
.prototype.init = function () {
13728 this._a
= 0xc1059ed8
13729 this._b
= 0x367cd507
13730 this._c
= 0x3070dd17
13731 this._d
= 0xf70e5939
13732 this._e
= 0xffc00b31
13733 this._f
= 0x68581511
13734 this._g
= 0x64f98fa7
13735 this._h
= 0xbefa4fa4
13740 Sha224
.prototype._hash = function () {
13741 var H
= new Buffer(28)
13743 H
.writeInt32BE(this._a
, 0)
13744 H
.writeInt32BE(this._b
, 4)
13745 H
.writeInt32BE(this._c
, 8)
13746 H
.writeInt32BE(this._d
, 12)
13747 H
.writeInt32BE(this._e
, 16)
13748 H
.writeInt32BE(this._f
, 20)
13749 H
.writeInt32BE(this._g
, 24)
13754 module
.exports
= Sha224
13756 }).call(this,require("buffer").Buffer
)
13757 },{"./hash":99,"./sha256":104,"buffer":4,"inherits":93}],104:[function(require
,module
,exports
){
13758 (function (Buffer
){
13760 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
13762 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
13763 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
13767 var inherits
= require('inherits')
13768 var Hash
= require('./hash')
13771 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
13772 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
13773 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
13774 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
13775 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
13776 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
13777 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
13778 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
13779 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
13780 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
13781 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
13782 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
13783 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
13784 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
13785 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
13786 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
13789 var W
= new Array(64)
13791 function Sha256 () {
13794 this._w
= W
// new Array(64)
13796 Hash
.call(this, 64, 56)
13799 inherits(Sha256
, Hash
)
13801 Sha256
.prototype.init = function () {
13802 this._a
= 0x6a09e667
13803 this._b
= 0xbb67ae85
13804 this._c
= 0x3c6ef372
13805 this._d
= 0xa54ff53a
13806 this._e
= 0x510e527f
13807 this._f
= 0x9b05688c
13808 this._g
= 0x1f83d9ab
13809 this._h
= 0x5be0cd19
13814 function ch (x
, y
, z
) {
13815 return z
^ (x
& (y
^ z
))
13818 function maj (x
, y
, z
) {
13819 return (x
& y
) | (z
& (x
| y
))
13822 function sigma0 (x
) {
13823 return (x
>>> 2 | x
<< 30) ^ (x
>>> 13 | x
<< 19) ^ (x
>>> 22 | x
<< 10)
13826 function sigma1 (x
) {
13827 return (x
>>> 6 | x
<< 26) ^ (x
>>> 11 | x
<< 21) ^ (x
>>> 25 | x
<< 7)
13830 function gamma0 (x
) {
13831 return (x
>>> 7 | x
<< 25) ^ (x
>>> 18 | x
<< 14) ^ (x
>>> 3)
13834 function gamma1 (x
) {
13835 return (x
>>> 17 | x
<< 15) ^ (x
>>> 19 | x
<< 13) ^ (x
>>> 10)
13838 Sha256
.prototype._update = function (M
) {
13841 var a
= this._a
| 0
13842 var b
= this._b
| 0
13843 var c
= this._c
| 0
13844 var d
= this._d
| 0
13845 var e
= this._e
| 0
13846 var f
= this._f
| 0
13847 var g
= this._g
| 0
13848 var h
= this._h
| 0
13850 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
13851 for (; i
< 64; ++i
) W
[i
] = (gamma1(W
[i
- 2]) + W
[i
- 7] + gamma0(W
[i
- 15]) + W
[i
- 16]) | 0
13853 for (var j
= 0; j
< 64; ++j
) {
13854 var T1
= (h
+ sigma1(e
) + ch(e
, f
, g
) + K
[j
] + W
[j
]) | 0
13855 var T2
= (sigma0(a
) + maj(a
, b
, c
)) | 0
13867 this._a
= (a
+ this._a
) | 0
13868 this._b
= (b
+ this._b
) | 0
13869 this._c
= (c
+ this._c
) | 0
13870 this._d
= (d
+ this._d
) | 0
13871 this._e
= (e
+ this._e
) | 0
13872 this._f
= (f
+ this._f
) | 0
13873 this._g
= (g
+ this._g
) | 0
13874 this._h
= (h
+ this._h
) | 0
13877 Sha256
.prototype._hash = function () {
13878 var H
= new Buffer(32)
13880 H
.writeInt32BE(this._a
, 0)
13881 H
.writeInt32BE(this._b
, 4)
13882 H
.writeInt32BE(this._c
, 8)
13883 H
.writeInt32BE(this._d
, 12)
13884 H
.writeInt32BE(this._e
, 16)
13885 H
.writeInt32BE(this._f
, 20)
13886 H
.writeInt32BE(this._g
, 24)
13887 H
.writeInt32BE(this._h
, 28)
13892 module
.exports
= Sha256
13894 }).call(this,require("buffer").Buffer
)
13895 },{"./hash":99,"buffer":4,"inherits":93}],105:[function(require
,module
,exports
){
13896 (function (Buffer
){
13897 var inherits
= require('inherits')
13898 var SHA512
= require('./sha512')
13899 var Hash
= require('./hash')
13901 var W
= new Array(160)
13903 function Sha384 () {
13907 Hash
.call(this, 128, 112)
13910 inherits(Sha384
, SHA512
)
13912 Sha384
.prototype.init = function () {
13913 this._ah
= 0xcbbb9d5d
13914 this._bh
= 0x629a292a
13915 this._ch
= 0x9159015a
13916 this._dh
= 0x152fecd8
13917 this._eh
= 0x67332667
13918 this._fh
= 0x8eb44a87
13919 this._gh
= 0xdb0c2e0d
13920 this._hh
= 0x47b5481d
13922 this._al
= 0xc1059ed8
13923 this._bl
= 0x367cd507
13924 this._cl
= 0x3070dd17
13925 this._dl
= 0xf70e5939
13926 this._el
= 0xffc00b31
13927 this._fl
= 0x68581511
13928 this._gl
= 0x64f98fa7
13929 this._hl
= 0xbefa4fa4
13934 Sha384
.prototype._hash = function () {
13935 var H
= new Buffer(48)
13937 function writeInt64BE (h
, l
, offset
) {
13938 H
.writeInt32BE(h
, offset
)
13939 H
.writeInt32BE(l
, offset
+ 4)
13942 writeInt64BE(this._ah
, this._al
, 0)
13943 writeInt64BE(this._bh
, this._bl
, 8)
13944 writeInt64BE(this._ch
, this._cl
, 16)
13945 writeInt64BE(this._dh
, this._dl
, 24)
13946 writeInt64BE(this._eh
, this._el
, 32)
13947 writeInt64BE(this._fh
, this._fl
, 40)
13952 module
.exports
= Sha384
13954 }).call(this,require("buffer").Buffer
)
13955 },{"./hash":99,"./sha512":106,"buffer":4,"inherits":93}],106:[function(require
,module
,exports
){
13956 (function (Buffer
){
13957 var inherits
= require('inherits')
13958 var Hash
= require('./hash')
13961 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
13962 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
13963 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
13964 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
13965 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
13966 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
13967 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
13968 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
13969 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
13970 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
13971 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
13972 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
13973 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
13974 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
13975 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
13976 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
13977 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
13978 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
13979 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
13980 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
13981 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
13982 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
13983 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
13984 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
13985 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
13986 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
13987 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
13988 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
13989 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
13990 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
13991 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
13992 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
13993 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
13994 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
13995 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
13996 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
13997 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
13998 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
13999 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
14000 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
14003 var W
= new Array(160)
14005 function Sha512 () {
14009 Hash
.call(this, 128, 112)
14012 inherits(Sha512
, Hash
)
14014 Sha512
.prototype.init = function () {
14015 this._ah
= 0x6a09e667
14016 this._bh
= 0xbb67ae85
14017 this._ch
= 0x3c6ef372
14018 this._dh
= 0xa54ff53a
14019 this._eh
= 0x510e527f
14020 this._fh
= 0x9b05688c
14021 this._gh
= 0x1f83d9ab
14022 this._hh
= 0x5be0cd19
14024 this._al
= 0xf3bcc908
14025 this._bl
= 0x84caa73b
14026 this._cl
= 0xfe94f82b
14027 this._dl
= 0x5f1d36f1
14028 this._el
= 0xade682d1
14029 this._fl
= 0x2b3e6c1f
14030 this._gl
= 0xfb41bd6b
14031 this._hl
= 0x137e2179
14036 function Ch (x
, y
, z
) {
14037 return z
^ (x
& (y
^ z
))
14040 function maj (x
, y
, z
) {
14041 return (x
& y
) | (z
& (x
| y
))
14044 function sigma0 (x
, xl
) {
14045 return (x
>>> 28 | xl
<< 4) ^ (xl
>>> 2 | x
<< 30) ^ (xl
>>> 7 | x
<< 25)
14048 function sigma1 (x
, xl
) {
14049 return (x
>>> 14 | xl
<< 18) ^ (x
>>> 18 | xl
<< 14) ^ (xl
>>> 9 | x
<< 23)
14052 function Gamma0 (x
, xl
) {
14053 return (x
>>> 1 | xl
<< 31) ^ (x
>>> 8 | xl
<< 24) ^ (x
>>> 7)
14056 function Gamma0l (x
, xl
) {
14057 return (x
>>> 1 | xl
<< 31) ^ (x
>>> 8 | xl
<< 24) ^ (x
>>> 7 | xl
<< 25)
14060 function Gamma1 (x
, xl
) {
14061 return (x
>>> 19 | xl
<< 13) ^ (xl
>>> 29 | x
<< 3) ^ (x
>>> 6)
14064 function Gamma1l (x
, xl
) {
14065 return (x
>>> 19 | xl
<< 13) ^ (xl
>>> 29 | x
<< 3) ^ (x
>>> 6 | xl
<< 26)
14068 function getCarry (a
, b
) {
14069 return (a
>>> 0) < (b
>>> 0) ? 1 : 0
14072 Sha512
.prototype._update = function (M
) {
14075 var ah
= this._ah
| 0
14076 var bh
= this._bh
| 0
14077 var ch
= this._ch
| 0
14078 var dh
= this._dh
| 0
14079 var eh
= this._eh
| 0
14080 var fh
= this._fh
| 0
14081 var gh
= this._gh
| 0
14082 var hh
= this._hh
| 0
14084 var al
= this._al
| 0
14085 var bl
= this._bl
| 0
14086 var cl
= this._cl
| 0
14087 var dl
= this._dl
| 0
14088 var el
= this._el
| 0
14089 var fl
= this._fl
| 0
14090 var gl
= this._gl
| 0
14091 var hl
= this._hl
| 0
14093 for (var i
= 0; i
< 32; i
+= 2) {
14094 W
[i
] = M
.readInt32BE(i
* 4)
14095 W
[i
+ 1] = M
.readInt32BE(i
* 4 + 4)
14097 for (; i
< 160; i
+= 2) {
14098 var xh
= W
[i
- 15 * 2]
14099 var xl
= W
[i
- 15 * 2 + 1]
14100 var gamma0
= Gamma0(xh
, xl
)
14101 var gamma0l
= Gamma0l(xl
, xh
)
14104 xl
= W
[i
- 2 * 2 + 1]
14105 var gamma1
= Gamma1(xh
, xl
)
14106 var gamma1l
= Gamma1l(xl
, xh
)
14108 // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
14109 var Wi7h
= W
[i
- 7 * 2]
14110 var Wi7l
= W
[i
- 7 * 2 + 1]
14112 var Wi16h
= W
[i
- 16 * 2]
14113 var Wi16l
= W
[i
- 16 * 2 + 1]
14115 var Wil
= (gamma0l
+ Wi7l
) | 0
14116 var Wih
= (gamma0
+ Wi7h
+ getCarry(Wil
, gamma0l
)) | 0
14117 Wil
= (Wil
+ gamma1l
) | 0
14118 Wih
= (Wih
+ gamma1
+ getCarry(Wil
, gamma1l
)) | 0
14119 Wil
= (Wil
+ Wi16l
) | 0
14120 Wih
= (Wih
+ Wi16h
+ getCarry(Wil
, Wi16l
)) | 0
14126 for (var j
= 0; j
< 160; j
+= 2) {
14130 var majh
= maj(ah
, bh
, ch
)
14131 var majl
= maj(al
, bl
, cl
)
14133 var sigma0h
= sigma0(ah
, al
)
14134 var sigma0l
= sigma0(al
, ah
)
14135 var sigma1h
= sigma1(eh
, el
)
14136 var sigma1l
= sigma1(el
, eh
)
14138 // t1 = h + sigma1 + ch + K[j] + W[j]
14142 var chh
= Ch(eh
, fh
, gh
)
14143 var chl
= Ch(el
, fl
, gl
)
14145 var t1l
= (hl
+ sigma1l
) | 0
14146 var t1h
= (hh
+ sigma1h
+ getCarry(t1l
, hl
)) | 0
14147 t1l
= (t1l
+ chl
) | 0
14148 t1h
= (t1h
+ chh
+ getCarry(t1l
, chl
)) | 0
14149 t1l
= (t1l
+ Kil
) | 0
14150 t1h
= (t1h
+ Kih
+ getCarry(t1l
, Kil
)) | 0
14151 t1l
= (t1l
+ Wil
) | 0
14152 t1h
= (t1h
+ Wih
+ getCarry(t1l
, Wil
)) | 0
14154 // t2 = sigma0 + maj
14155 var t2l
= (sigma0l
+ majl
) | 0
14156 var t2h
= (sigma0h
+ majh
+ getCarry(t2l
, sigma0l
)) | 0
14164 el
= (dl
+ t1l
) | 0
14165 eh
= (dh
+ t1h
+ getCarry(el
, dl
)) | 0
14172 al
= (t1l
+ t2l
) | 0
14173 ah
= (t1h
+ t2h
+ getCarry(al
, t1l
)) | 0
14176 this._al
= (this._al
+ al
) | 0
14177 this._bl
= (this._bl
+ bl
) | 0
14178 this._cl
= (this._cl
+ cl
) | 0
14179 this._dl
= (this._dl
+ dl
) | 0
14180 this._el
= (this._el
+ el
) | 0
14181 this._fl
= (this._fl
+ fl
) | 0
14182 this._gl
= (this._gl
+ gl
) | 0
14183 this._hl
= (this._hl
+ hl
) | 0
14185 this._ah
= (this._ah
+ ah
+ getCarry(this._al
, al
)) | 0
14186 this._bh
= (this._bh
+ bh
+ getCarry(this._bl
, bl
)) | 0
14187 this._ch
= (this._ch
+ ch
+ getCarry(this._cl
, cl
)) | 0
14188 this._dh
= (this._dh
+ dh
+ getCarry(this._dl
, dl
)) | 0
14189 this._eh
= (this._eh
+ eh
+ getCarry(this._el
, el
)) | 0
14190 this._fh
= (this._fh
+ fh
+ getCarry(this._fl
, fl
)) | 0
14191 this._gh
= (this._gh
+ gh
+ getCarry(this._gl
, gl
)) | 0
14192 this._hh
= (this._hh
+ hh
+ getCarry(this._hl
, hl
)) | 0
14195 Sha512
.prototype._hash = function () {
14196 var H
= new Buffer(64)
14198 function writeInt64BE (h
, l
, offset
) {
14199 H
.writeInt32BE(h
, offset
)
14200 H
.writeInt32BE(l
, offset
+ 4)
14203 writeInt64BE(this._ah
, this._al
, 0)
14204 writeInt64BE(this._bh
, this._bl
, 8)
14205 writeInt64BE(this._ch
, this._cl
, 16)
14206 writeInt64BE(this._dh
, this._dl
, 24)
14207 writeInt64BE(this._eh
, this._el
, 32)
14208 writeInt64BE(this._fh
, this._fl
, 40)
14209 writeInt64BE(this._gh
, this._gl
, 48)
14210 writeInt64BE(this._hh
, this._hl
, 56)
14215 module
.exports
= Sha512
14217 }).call(this,require("buffer").Buffer
)
14218 },{"./hash":99,"buffer":4,"inherits":93}],107:[function(require
,module
,exports
){
14219 var inherits
= require('inherits')
14220 var native = require('./native')
14222 function TfTypeError (type
, value
, valueTypeName
) {
14223 this.__error
= Error
.call(this)
14225 this.__value
= value
14226 this.__valueTypeName
= valueTypeName
14229 Object
.defineProperty(this, 'message', {
14232 if (message
) return message
14234 valueTypeName
= valueTypeName
|| getValueTypeName(value
)
14235 message
= tfErrorString(type
, value
, valueTypeName
)
14242 function TfPropertyTypeError (type
, property
, label
, value
, error
, valueTypeName
) {
14243 this.__error
= error
|| Error
.call(this)
14244 this.__label
= label
14245 this.__property
= property
14247 this.__value
= value
14248 this.__valueTypeName
= valueTypeName
14251 Object
.defineProperty(this, 'message', {
14254 if (message
) return message
14256 valueTypeName
= valueTypeName
|| getValueTypeName(value
)
14257 message
= tfPropertyErrorString(type
, label
, property
, value
, valueTypeName
)
14259 message
= 'Unexpected property "' + property
+ '"'
14267 // inherit from Error, assign stack
14268 [TfTypeError
, TfPropertyTypeError
].forEach(function (tfErrorType
) {
14269 inherits(tfErrorType
, Error
)
14270 Object
.defineProperty(tfErrorType
, 'stack', {
14271 get: function () { return this.__error
.stack
}
14275 function tfCustomError (expected
, actual
) {
14276 return new TfTypeError(expected
, {}, actual
)
14279 function tfSubError (e
, property
, label
) {
14281 if (e
instanceof TfPropertyTypeError
) {
14282 property
= property
+ '.' + e
.__property
14285 return new TfPropertyTypeError(
14286 e
.__type
, property
, label
, e
.__value
, e
.__error
, e
.__valueTypeName
14291 if (e
instanceof TfTypeError
) {
14292 return new TfPropertyTypeError(
14293 e
.__type
, property
, label
, e
.__value
, e
.__error
, e
.__valueTypeName
14300 function getTypeName (fn
) {
14301 return fn
.name
|| fn
.toString().match(/function (.*?)\s
*\(/)[1]
14304 function getValueTypeName (value
) {
14305 return native.Nil(value
) ? '' : getTypeName(value
.constructor)
14308 function getValue (value
) {
14309 if (native.Function(value
)) return ''
14310 if (native.String(value
)) return JSON
.stringify(value
)
14311 if (value
&& native.Object(value
)) return ''
14315 function tfJSON (type
) {
14316 if (native.Function(type
)) return type
.toJSON
? type
.toJSON() : getTypeName(type
)
14317 if (native.Array(type
)) return 'Array'
14318 if (type
&& native.Object(type
)) return 'Object'
14320 return type
!== undefined ? type : ''
14323 function tfErrorString (type
, value
, valueTypeName
) {
14324 var valueJson
= getValue(value
)
14326 return 'Expected ' + tfJSON(type
) + ', got' +
14327 (valueTypeName
!== '' ? ' ' + valueTypeName : '') +
14328 (valueJson
!== '' ? ' ' + valueJson : '')
14331 function tfPropertyErrorString (type
, label
, name
, value
, valueTypeName
) {
14332 var description
= '" of type '
14333 if (label
=== 'key') description
= '" with key type '
14335 return tfErrorString('property "' + tfJSON(name
) + description
+ tfJSON(type
), value
, valueTypeName
)
14339 TfTypeError: TfTypeError
,
14340 TfPropertyTypeError: TfPropertyTypeError
,
14341 tfCustomError: tfCustomError
,
14342 tfSubError: tfSubError
,
14344 getValueTypeName: getValueTypeName
14347 },{"./native":110,"inherits":93}],108:[function(require
,module
,exports
){
14348 (function (Buffer
){
14349 var NATIVE
= require('./native')
14350 var ERRORS
= require('./errors')
14352 function _Buffer (value
) {
14353 return Buffer
.isBuffer(value
)
14356 function Hex (value
) {
14357 return typeof value
=== 'string' && /^([0-9a-f]{2})+$/i.test(value
)
14360 function _LengthN (type
, length
) {
14361 var name
= type
.toJSON()
14363 function Length (value
) {
14364 if (!type(value
)) return false
14365 if (value
.length
=== length
) return true
14367 throw ERRORS
.tfCustomError(name
+ '(Length: ' + length
+ ')', name
+ '(Length: ' + value
.length
+ ')')
14369 Length
.toJSON = function () { return name
}
14374 var _ArrayN
= _LengthN
.bind(null, NATIVE
.Array
)
14375 var _BufferN
= _LengthN
.bind(null, _Buffer
)
14376 var _HexN
= _LengthN
.bind(null, Hex
)
14378 var UINT53_MAX
= Math
.pow(2, 53) - 1
14380 function Finite (value
) {
14381 return typeof value
=== 'number' && isFinite(value
)
14383 function Int8 (value
) { return ((value
<< 24) >> 24) === value
}
14384 function Int16 (value
) { return ((value
<< 16) >> 16) === value
}
14385 function Int32 (value
) { return (value
| 0) === value
}
14386 function UInt8 (value
) { return (value
& 0xff) === value
}
14387 function UInt16 (value
) { return (value
& 0xffff) === value
}
14388 function UInt32 (value
) { return (value
>>> 0) === value
}
14389 function UInt53 (value
) {
14390 return typeof value
=== 'number' &&
14392 value
<= UINT53_MAX
&&
14393 Math
.floor(value
) === value
14412 for (var typeName
in types
) {
14413 types
[typeName
].toJSON = function (t
) {
14415 }.bind(null, typeName
)
14418 module
.exports
= types
14420 }).call(this,{"isBuffer":require("../../../../../.nvm/versions/node/v6.0.0/lib/node_modules/browserify/node_modules/is-buffer/index.js")})
14421 },{"../../../../../.nvm/versions/node/v6.0.0/lib/node_modules/browserify/node_modules/is-buffer/index.js":9,"./errors":107,"./native":110}],109:[function(require
,module
,exports
){
14422 var ERRORS
= require('./errors')
14423 var NATIVE
= require('./native')
14426 var tfJSON
= ERRORS
.tfJSON
14427 var TfTypeError
= ERRORS
.TfTypeError
14428 var TfPropertyTypeError
= ERRORS
.TfPropertyTypeError
14429 var tfSubError
= ERRORS
.tfSubError
14430 var getValueTypeName
= ERRORS
.getValueTypeName
14433 arrayOf: function arrayOf (type
) {
14434 type
= compile(type
)
14436 function _arrayOf (array
, strict
) {
14437 if (!NATIVE
.Array(array
)) return false
14439 return array
.every(function (value
, i
) {
14441 return typeforce(type
, value
, strict
)
14443 throw tfSubError(e
, i
)
14447 _arrayOf
.toJSON = function () { return '[' + tfJSON(type
) + ']' }
14452 maybe: function maybe (type
) {
14453 type
= compile(type
)
14455 function _maybe (value
, strict
) {
14456 return NATIVE
.Nil(value
) || type(value
, strict
, maybe
)
14458 _maybe
.toJSON = function () { return '?' + tfJSON(type
) }
14463 map: function map (propertyType
, propertyKeyType
) {
14464 propertyType
= compile(propertyType
)
14465 if (propertyKeyType
) propertyKeyType
= compile(propertyKeyType
)
14467 function _map (value
, strict
) {
14468 if (!NATIVE
.Object(value
, strict
)) return false
14469 if (NATIVE
.Nil(value
, strict
)) return false
14471 for (var propertyName
in value
) {
14473 if (propertyKeyType
) {
14474 typeforce(propertyKeyType
, propertyName
, strict
)
14477 throw tfSubError(e
, propertyName
, 'key')
14481 var propertyValue
= value
[propertyName
]
14482 typeforce(propertyType
, propertyValue
, strict
)
14484 throw tfSubError(e
, propertyName
)
14491 if (propertyKeyType
) {
14492 _map
.toJSON = function () {
14493 return '{' + tfJSON(propertyKeyType
) + ': ' + tfJSON(propertyType
) + '}'
14496 _map
.toJSON = function () { return '{' + tfJSON(propertyType
) + '}' }
14502 object: function object (uncompiled
) {
14505 for (var typePropertyName
in uncompiled
) {
14506 type
[typePropertyName
] = compile(uncompiled
[typePropertyName
])
14509 function _object (value
, strict
) {
14510 if (!NATIVE
.Object(value
)) return false
14511 if (NATIVE
.Nil(value
)) return false
14516 for (propertyName
in type
) {
14517 var propertyType
= type
[propertyName
]
14518 var propertyValue
= value
[propertyName
]
14520 typeforce(propertyType
, propertyValue
, strict
)
14523 throw tfSubError(e
, propertyName
)
14527 for (propertyName
in value
) {
14528 if (type
[propertyName
]) continue
14530 throw new TfPropertyTypeError(undefined, propertyName
)
14536 _object
.toJSON = function () { return tfJSON(type
) }
14541 oneOf: function oneOf () {
14542 var types
= [].slice
.call(arguments
).map(compile
)
14544 function _oneOf (value
, strict
) {
14545 return types
.some(function (type
) {
14547 return typeforce(type
, value
, strict
)
14553 _oneOf
.toJSON = function () { return types
.map(tfJSON
).join('|') }
14558 quacksLike: function quacksLike (type
) {
14559 function _quacksLike (value
) {
14560 return type
=== getValueTypeName(value
)
14562 _quacksLike
.toJSON = function () { return type
}
14567 tuple: function tuple () {
14568 var types
= [].slice
.call(arguments
).map(compile
)
14570 function _tuple (values
, strict
) {
14571 return types
.every(function (type
, i
) {
14573 return typeforce(type
, values
[i
], strict
)
14575 throw tfSubError(e
, i
)
14577 }) && (!strict
|| values
.length
=== arguments
.length
)
14579 _tuple
.toJSON = function () { return '(' + types
.map(tfJSON
).join(', ') + ')' }
14584 value: function value (expected
) {
14585 function _value (actual
) {
14586 return actual
=== expected
14588 _value
.toJSON = function () { return expected
}
14594 function compile (type
) {
14595 if (NATIVE
.String(type
)) {
14596 if (type
[0] === '?') return TYPES
.maybe(compile(type
.slice(1)))
14598 return NATIVE
[type
] || TYPES
.quacksLike(type
)
14599 } else if (type
&& NATIVE
.Object(type
)) {
14600 if (NATIVE
.Array(type
)) return TYPES
.arrayOf(compile(type
[0]))
14602 return TYPES
.object(type
)
14603 } else if (NATIVE
.Function(type
)) {
14607 return TYPES
.value(type
)
14610 function typeforce (type
, value
, strict
, surrogate
) {
14611 if (NATIVE
.Function(type
)) {
14612 if (type(value
, strict
)) return true
14614 throw new TfTypeError(surrogate
|| type
, value
)
14618 return typeforce(compile(type
), value
, strict
)
14621 // assign types to typeforce function
14622 for (var typeName
in NATIVE
) {
14623 typeforce
[typeName
] = NATIVE
[typeName
]
14626 for (typeName
in TYPES
) {
14627 typeforce
[typeName
] = TYPES
[typeName
]
14630 var EXTRA
= require('./extra')
14631 for (typeName
in EXTRA
) {
14632 typeforce
[typeName
] = EXTRA
[typeName
]
14636 function __async (type
, value
, strict
, callback
) {
14637 // default to falsy strict if using shorthand overload
14638 if (typeof strict
=== 'function') return __async(type
, value
, false, strict
)
14641 typeforce(type
, value
, strict
)
14649 typeforce
.async
= __async
14650 typeforce
.compile
= compile
14651 typeforce
.TfTypeError
= TfTypeError
14652 typeforce
.TfPropertyTypeError
= TfPropertyTypeError
14654 module
.exports
= typeforce
14656 },{"./errors":107,"./extra":108,"./native":110}],110:[function(require
,module
,exports
){
14658 Array: function (value
) { return value
!== null && value
!== undefined && value
.constructor === Array
},
14659 Boolean: function (value
) { return typeof value
=== 'boolean' },
14660 Function: function (value
) { return typeof value
=== 'function' },
14661 Nil: function (value
) { return value
=== undefined || value
=== null },
14662 Number: function (value
) { return typeof value
=== 'number' },
14663 Object: function (value
) { return typeof value
=== 'object' },
14664 String: function (value
) { return typeof value
=== 'string' },
14665 '': function () { return true }
14669 types
.Null
= types
.Nil
14671 for (var typeName
in types
) {
14672 types
[typeName
].toJSON = function (t
) {
14674 }.bind(null, typeName
)
14677 module
.exports
= types
14679 },{}],111:[function(require
,module
,exports
){
14680 (function (Buffer
){
14683 // Number.MAX_SAFE_INTEGER
14684 var MAX_SAFE_INTEGER
= 9007199254740991
14686 function checkUInt53 (n
) {
14687 if (n
< 0 || n
> MAX_SAFE_INTEGER
|| n
% 1 !== 0) throw new RangeError('value out of range')
14690 function encode (number
, buffer
, offset
) {
14691 checkUInt53(number
)
14693 if (!buffer
) buffer
= new Buffer(encodingLength(number
))
14694 if (!Buffer
.isBuffer(buffer
)) throw new TypeError('buffer must be a Buffer instance')
14695 if (!offset
) offset
= 0
14698 if (number
< 0xfd) {
14699 buffer
.writeUInt8(number
, offset
)
14703 } else if (number
<= 0xffff) {
14704 buffer
.writeUInt8(0xfd, offset
)
14705 buffer
.writeUInt16LE(number
, offset
+ 1)
14709 } else if (number
<= 0xffffffff) {
14710 buffer
.writeUInt8(0xfe, offset
)
14711 buffer
.writeUInt32LE(number
, offset
+ 1)
14716 buffer
.writeUInt8(0xff, offset
)
14717 buffer
.writeUInt32LE(number
>>> 0, offset
+ 1)
14718 buffer
.writeUInt32LE((number
/ 0x100000000) | 0, offset
+ 5)
14725 function decode (buffer
, offset
) {
14726 if (!Buffer
.isBuffer(buffer
)) throw new TypeError('buffer must be a Buffer instance')
14727 if (!offset
) offset
= 0
14729 var first
= buffer
.readUInt8(offset
)
14732 if (first
< 0xfd) {
14737 } else if (first
=== 0xfd) {
14739 return buffer
.readUInt16LE(offset
+ 1)
14742 } else if (first
=== 0xfe) {
14744 return buffer
.readUInt32LE(offset
+ 1)
14749 var lo
= buffer
.readUInt32LE(offset
+ 1)
14750 var hi
= buffer
.readUInt32LE(offset
+ 5)
14751 var number
= hi
* 0x0100000000 + lo
14752 checkUInt53(number
)
14758 function encodingLength (number
) {
14759 checkUInt53(number
)
14763 : number
<= 0xffff ? 3
14764 : number
<= 0xffffffff ? 5
14769 module
.exports
= { encode: encode
, decode: decode
, encodingLength: encodingLength
}
14771 }).call(this,require("buffer").Buffer
)
14772 },{"buffer":4}],112:[function(require
,module
,exports
){
14773 (function (Buffer
){
14774 var bs58check
= require('bs58check')
14776 function decodeRaw (buffer
, version
) {
14777 // check version only if defined
14778 if (version
!== undefined && buffer
[0] !== version
) throw new Error('Invalid network version')
14781 if (buffer
.length
=== 33) {
14783 version: buffer
[0],
14784 privateKey: buffer
.slice(1, 33),
14790 if (buffer
.length
!== 34) throw new Error('Invalid WIF length')
14792 // invalid compression flag
14793 if (buffer
[33] !== 0x01) throw new Error('Invalid compression flag')
14796 version: buffer
[0],
14797 privateKey: buffer
.slice(1, 33),
14802 function encodeRaw (version
, privateKey
, compressed
) {
14803 var result
= new Buffer(compressed
? 34 : 33)
14805 result
.writeUInt8(version
, 0)
14806 privateKey
.copy(result
, 1)
14815 function decode (string
, version
) {
14816 return decodeRaw(bs58check
.decode(string
), version
)
14819 function encode (version
, privateKey
, compressed
) {
14820 if (typeof version
=== 'number') return bs58check
.encode(encodeRaw(version
, privateKey
, compressed
))
14822 return bs58check
.encode(
14825 version
.privateKey
,
14833 decodeRaw: decodeRaw
,
14835 encodeRaw: encodeRaw
14838 }).call(this,require("buffer").Buffer
)
14839 },{"bs58check":80,"buffer":4}]},{},[33])(33)