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',
9663 },{}],52:[function(require
,module
,exports
){
9664 var Buffer
= require('safe-buffer').Buffer
9665 var bip66
= require('bip66')
9666 var pushdata
= require('pushdata-bitcoin')
9667 var typeforce
= require('typeforce')
9668 var types
= require('./types')
9669 var scriptNumber
= require('./script_number')
9671 var OPS
= require('bitcoin-ops')
9672 var REVERSE_OPS
= require('bitcoin-ops/map')
9673 var OP_INT_BASE
= OPS
.OP_RESERVED
// OP_1 - 1
9675 function isOPInt (value
) {
9676 return types
.Number(value
) &&
9677 ((value
=== OPS
.OP_0
) ||
9678 (value
>= OPS
.OP_1
&& value
<= OPS
.OP_16
) ||
9679 (value
=== OPS
.OP_1NEGATE
))
9682 function isPushOnlyChunk (value
) {
9683 return types
.Buffer(value
) || isOPInt(value
)
9686 function isPushOnly (value
) {
9687 return types
.Array(value
) && value
.every(isPushOnlyChunk
)
9690 function compile (chunks
) {
9692 if (Buffer
.isBuffer(chunks
)) return chunks
9694 typeforce(types
.Array
, chunks
)
9696 var bufferSize
= chunks
.reduce(function (accum
, chunk
) {
9698 if (Buffer
.isBuffer(chunk
)) {
9699 // adhere to BIP62.3, minimal push policy
9700 if (chunk
.length
=== 1 && (chunk
[0] === 0x81 || (chunk
[0] >= 1 && chunk
[0] <= 16))) {
9704 return accum
+ pushdata
.encodingLength(chunk
.length
) + chunk
.length
9711 var buffer
= Buffer
.allocUnsafe(bufferSize
)
9714 chunks
.forEach(function (chunk
) {
9716 if (Buffer
.isBuffer(chunk
)) {
9717 // adhere to BIP62.3, minimal push policy
9718 if (chunk
.length
=== 1 && chunk
[0] >= 1 && chunk
[0] <= 16) {
9719 var opcode
= OP_INT_BASE
+ chunk
[0]
9720 buffer
.writeUInt8(opcode
, offset
)
9725 if (chunk
.length
=== 1 && chunk
[0] === 0x81) {
9726 buffer
.writeUInt8(OPS
.OP_1NEGATE
, offset
)
9731 offset
+= pushdata
.encode(buffer
, chunk
.length
, offset
)
9733 chunk
.copy(buffer
, offset
)
9734 offset
+= chunk
.length
9738 buffer
.writeUInt8(chunk
, offset
)
9743 if (offset
!== buffer
.length
) throw new Error('Could not decode chunks')
9747 function decompile (buffer
) {
9749 if (types
.Array(buffer
)) return buffer
9751 typeforce(types
.Buffer
, buffer
)
9756 while (i
< buffer
.length
) {
9757 var opcode
= buffer
[i
]
9760 if ((opcode
> OPS
.OP_0
) && (opcode
<= OPS
.OP_PUSHDATA4
)) {
9761 var d
= pushdata
.decode(buffer
, i
)
9763 // did reading a pushDataInt fail? empty script
9764 if (d
=== null) return []
9767 // attempt to read too much data? empty script
9768 if (i
+ d
.number
> buffer
.length
) return []
9770 var data
= buffer
.slice(i
, i
+ d
.number
)
9786 function toASM (chunks
) {
9787 if (Buffer
.isBuffer(chunks
)) {
9788 chunks
= decompile(chunks
)
9791 return chunks
.map(function (chunk
) {
9793 if (Buffer
.isBuffer(chunk
)) return chunk
.toString('hex')
9796 return REVERSE_OPS
[chunk
]
9800 function fromASM (asm
) {
9801 typeforce(types
.String
, asm
)
9803 return compile(asm
.split(' ').map(function (chunkStr
) {
9805 if (OPS
[chunkStr
] !== undefined) return OPS
[chunkStr
]
9806 typeforce(types
.Hex
, chunkStr
)
9809 return Buffer
.from(chunkStr
, 'hex')
9813 function toStack (chunks
) {
9814 chunks
= decompile(chunks
)
9815 typeforce(isPushOnly
, chunks
)
9817 return chunks
.map(function (op
) {
9818 if (Buffer
.isBuffer(op
)) return op
9819 if (op
=== OPS
.OP_0
) return Buffer
.allocUnsafe(0)
9821 return scriptNumber
.encode(op
- OP_INT_BASE
)
9825 function isCanonicalPubKey (buffer
) {
9826 if (!Buffer
.isBuffer(buffer
)) return false
9827 if (buffer
.length
< 33) return false
9829 switch (buffer
[0]) {
9832 return buffer
.length
=== 33
9834 return buffer
.length
=== 65
9840 function isDefinedHashType (hashType
) {
9841 var hashTypeMod
= hashType
& ~0x80
9843 // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
9844 return hashTypeMod
> 0x00 && hashTypeMod
< 0x04
9847 function isCanonicalSignature (buffer
) {
9848 if (!Buffer
.isBuffer(buffer
)) return false
9849 if (!isDefinedHashType(buffer
[buffer
.length
- 1])) return false
9851 return bip66
.check(buffer
.slice(0, -1))
9856 decompile: decompile
,
9861 number: require('./script_number'),
9863 isCanonicalPubKey: isCanonicalPubKey
,
9864 isCanonicalSignature: isCanonicalSignature
,
9865 isPushOnly: isPushOnly
,
9866 isDefinedHashType: isDefinedHashType
9869 var templates
= require('./templates')
9870 for (var key
in templates
) {
9871 module
.exports
[key
] = templates
[key
]
9874 },{"./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
){
9875 var Buffer
= require('safe-buffer').Buffer
9877 function decode (buffer
, maxLength
, minimal
) {
9878 maxLength
= maxLength
|| 4
9879 minimal
= minimal
=== undefined ? true : minimal
9881 var length
= buffer
.length
9882 if (length
=== 0) return 0
9883 if (length
> maxLength
) throw new TypeError('Script number overflow')
9885 if ((buffer
[length
- 1] & 0x7f) === 0) {
9886 if (length
<= 1 || (buffer
[length
- 2] & 0x80) === 0) throw new Error('Non-minimally encoded script number')
9892 var a
= buffer
.readUInt32LE(0)
9893 var b
= buffer
.readUInt8(4)
9895 if (b
& 0x80) return -(((b
& ~0x80) * 0x100000000) + a
)
9896 return (b
* 0x100000000) + a
9901 // 32-bit / 24-bit / 16-bit / 8-bit
9902 for (var i
= 0; i
< length
; ++i
) {
9903 result
|= buffer
[i
] << (8 * i
)
9906 if (buffer
[length
- 1] & 0x80) return -(result
& ~(0x80 << (8 * (length
- 1))))
9910 function scriptNumSize (i
) {
9911 return i
> 0x7fffffff ? 5
9919 function encode (number
) {
9920 var value
= Math
.abs(number
)
9921 var size
= scriptNumSize(value
)
9922 var buffer
= Buffer
.allocUnsafe(size
)
9923 var negative
= number
< 0
9925 for (var i
= 0; i
< size
; ++i
) {
9926 buffer
.writeUInt8(value
& 0xff, i
)
9930 if (buffer
[size
- 1] & 0x80) {
9931 buffer
.writeUInt8(negative
? 0x80 : 0x00, size
- 1)
9932 } else if (negative
) {
9933 buffer
[size
- 1] |= 0x80
9944 },{"safe-buffer":98}],54:[function(require
,module
,exports
){
9945 var decompile
= require('../script').decompile
9946 var multisig
= require('./multisig')
9947 var nullData
= require('./nulldata')
9948 var pubKey
= require('./pubkey')
9949 var pubKeyHash
= require('./pubkeyhash')
9950 var scriptHash
= require('./scripthash')
9951 var witnessPubKeyHash
= require('./witnesspubkeyhash')
9952 var witnessScriptHash
= require('./witnessscripthash')
9953 var witnessCommitment
= require('./witnesscommitment')
9956 MULTISIG: 'multisig',
9957 NONSTANDARD: 'nonstandard',
9958 NULLDATA: 'nulldata',
9960 P2PKH: 'pubkeyhash',
9962 P2WPKH: 'witnesspubkeyhash',
9963 P2WSH: 'witnessscripthash',
9964 WITNESS_COMMITMENT: 'witnesscommitment'
9967 function classifyOutput (script
) {
9968 if (witnessPubKeyHash
.output
.check(script
)) return types
.P2WPKH
9969 if (witnessScriptHash
.output
.check(script
)) return types
.P2WSH
9970 if (pubKeyHash
.output
.check(script
)) return types
.P2PKH
9971 if (scriptHash
.output
.check(script
)) return types
.P2SH
9973 // XXX: optimization, below functions .decompile before use
9974 var chunks
= decompile(script
)
9975 if (multisig
.output
.check(chunks
)) return types
.MULTISIG
9976 if (pubKey
.output
.check(chunks
)) return types
.P2PK
9977 if (witnessCommitment
.output
.check(chunks
)) return types
.WITNESS_COMMITMENT
9978 if (nullData
.output
.check(chunks
)) return types
.NULLDATA
9980 return types
.NONSTANDARD
9983 function classifyInput (script
, allowIncomplete
) {
9984 // XXX: optimization, below functions .decompile before use
9985 var chunks
= decompile(script
)
9987 if (pubKeyHash
.input
.check(chunks
)) return types
.P2PKH
9988 if (scriptHash
.input
.check(chunks
, allowIncomplete
)) return types
.P2SH
9989 if (multisig
.input
.check(chunks
, allowIncomplete
)) return types
.MULTISIG
9990 if (pubKey
.input
.check(chunks
)) return types
.P2PK
9992 return types
.NONSTANDARD
9995 function classifyWitness (script
, allowIncomplete
) {
9996 // XXX: optimization, below functions .decompile before use
9997 var chunks
= decompile(script
)
9999 if (witnessPubKeyHash
.input
.check(chunks
)) return types
.P2WPKH
10000 if (witnessScriptHash
.input
.check(chunks
, allowIncomplete
)) return types
.P2WSH
10002 return types
.NONSTANDARD
10006 classifyInput: classifyInput
,
10007 classifyOutput: classifyOutput
,
10008 classifyWitness: classifyWitness
,
10009 multisig: multisig
,
10010 nullData: nullData
,
10012 pubKeyHash: pubKeyHash
,
10013 scriptHash: scriptHash
,
10014 witnessPubKeyHash: witnessPubKeyHash
,
10015 witnessScriptHash: witnessScriptHash
,
10016 witnessCommitment: witnessCommitment
,
10020 },{"../script":52,"./multisig":55,"./nulldata":58,"./pubkey":59,"./pubkeyhash":62,"./scripthash":65,"./witnesscommitment":68,"./witnesspubkeyhash":70,"./witnessscripthash":73}],55:[function(require
,module
,exports
){
10022 input: require('./input'),
10023 output: require('./output')
10026 },{"./input":56,"./output":57}],56:[function(require
,module
,exports
){
10027 // OP_0 [signatures ...]
10029 var Buffer
= require('safe-buffer').Buffer
10030 var bscript
= require('../../script')
10031 var typeforce
= require('typeforce')
10032 var OPS
= require('bitcoin-ops')
10034 function partialSignature (value
) {
10035 return value
=== OPS
.OP_0
|| bscript
.isCanonicalSignature(value
)
10038 function check (script
, allowIncomplete
) {
10039 var chunks
= bscript
.decompile(script
)
10040 if (chunks
.length
< 2) return false
10041 if (chunks
[0] !== OPS
.OP_0
) return false
10043 if (allowIncomplete
) {
10044 return chunks
.slice(1).every(partialSignature
)
10047 return chunks
.slice(1).every(bscript
.isCanonicalSignature
)
10049 check
.toJSON = function () { return 'multisig input' }
10051 var EMPTY_BUFFER
= Buffer
.allocUnsafe(0)
10053 function encodeStack (signatures
, scriptPubKey
) {
10054 typeforce([partialSignature
], signatures
)
10056 if (scriptPubKey
) {
10057 var scriptData
= bscript
.multisig
.output
.decode(scriptPubKey
)
10059 if (signatures
.length
< scriptData
.m
) {
10060 throw new TypeError('Not enough signatures provided')
10063 if (signatures
.length
> scriptData
.pubKeys
.length
) {
10064 throw new TypeError('Too many signatures provided')
10068 return [].concat(EMPTY_BUFFER
, signatures
)
10071 function encode (signatures
, scriptPubKey
) {
10072 return bscript
.compile(encodeStack(signatures
, scriptPubKey
))
10075 function decodeStack (stack
, allowIncomplete
) {
10076 typeforce(check
, stack
, allowIncomplete
)
10077 return stack
.slice(1)
10080 function decode (buffer
, allowIncomplete
) {
10081 var stack
= bscript
.decompile(buffer
)
10082 return decodeStack(stack
, allowIncomplete
)
10088 decodeStack: decodeStack
,
10090 encodeStack: encodeStack
10093 },{"../../script":52,"bitcoin-ops":40,"safe-buffer":98,"typeforce":109}],57:[function(require
,module
,exports
){
10094 // m [pubKeys ...] n OP_CHECKMULTISIG
10096 var bscript
= require('../../script')
10097 var types
= require('../../types')
10098 var typeforce
= require('typeforce')
10099 var OPS
= require('bitcoin-ops')
10100 var OP_INT_BASE
= OPS
.OP_RESERVED
// OP_1 - 1
10102 function check (script
, allowIncomplete
) {
10103 var chunks
= bscript
.decompile(script
)
10105 if (chunks
.length
< 4) return false
10106 if (chunks
[chunks
.length
- 1] !== OPS
.OP_CHECKMULTISIG
) return false
10107 if (!types
.Number(chunks
[0])) return false
10108 if (!types
.Number(chunks
[chunks
.length
- 2])) return false
10109 var m
= chunks
[0] - OP_INT_BASE
10110 var n
= chunks
[chunks
.length
- 2] - OP_INT_BASE
10112 if (m
<= 0) return false
10113 if (n
> 16) return false
10114 if (m
> n
) return false
10115 if (n
!== chunks
.length
- 3) return false
10116 if (allowIncomplete
) return true
10118 var keys
= chunks
.slice(1, -2)
10119 return keys
.every(bscript
.isCanonicalPubKey
)
10121 check
.toJSON = function () { return 'multi-sig output' }
10123 function encode (m
, pubKeys
) {
10126 pubKeys: [bscript
.isCanonicalPubKey
]
10132 var n
= pubKeys
.length
10133 if (n
< m
) throw new TypeError('Not enough pubKeys provided')
10135 return bscript
.compile([].concat(
10139 OPS
.OP_CHECKMULTISIG
10143 function decode (buffer
, allowIncomplete
) {
10144 var chunks
= bscript
.decompile(buffer
)
10145 typeforce(check
, chunks
, allowIncomplete
)
10148 m: chunks
[0] - OP_INT_BASE
,
10149 pubKeys: chunks
.slice(1, -2)
10159 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],58:[function(require
,module
,exports
){
10160 // OP_RETURN {data}
10162 var bscript
= require('../script')
10163 var types
= require('../types')
10164 var typeforce
= require('typeforce')
10165 var OPS
= require('bitcoin-ops')
10167 function check (script
) {
10168 var buffer
= bscript
.compile(script
)
10170 return buffer
.length
> 1 &&
10171 buffer
[0] === OPS
.OP_RETURN
10173 check
.toJSON = function () { return 'null data output' }
10175 function encode (data
) {
10176 typeforce(types
.Buffer
, data
)
10178 return bscript
.compile([OPS
.OP_RETURN
, data
])
10181 function decode (buffer
) {
10182 typeforce(check
, buffer
)
10184 return buffer
.slice(2)
10195 },{"../script":52,"../types":78,"bitcoin-ops":40,"typeforce":109}],59:[function(require
,module
,exports
){
10196 arguments
[4][55][0].apply(exports
,arguments
)
10197 },{"./input":60,"./output":61,"dup":55}],60:[function(require
,module
,exports
){
10200 var bscript
= require('../../script')
10201 var types
= require('../../types')
10202 var typeforce
= require('typeforce')
10204 function check (script
) {
10205 var chunks
= bscript
.decompile(script
)
10207 return chunks
.length
=== 1 &&
10208 bscript
.isCanonicalSignature(chunks
[0])
10210 check
.toJSON = function () { return 'pubKey input' }
10212 function encodeStack (signature
) {
10213 typeforce(types
.Buffer
, signature
)
10217 function encode (signature
) {
10218 return bscript
.compile(encodeStack(signature
))
10221 function decodeStack (stack
) {
10222 typeforce(check
, stack
)
10226 function decode (buffer
) {
10227 var stack
= bscript
.decompile(buffer
)
10228 return decodeStack(stack
)
10234 decodeStack: decodeStack
,
10236 encodeStack: encodeStack
10239 },{"../../script":52,"../../types":78,"typeforce":109}],61:[function(require
,module
,exports
){
10240 // {pubKey} OP_CHECKSIG
10242 var bscript
= require('../../script')
10243 var typeforce
= require('typeforce')
10244 var OPS
= require('bitcoin-ops')
10246 function check (script
) {
10247 var chunks
= bscript
.decompile(script
)
10249 return chunks
.length
=== 2 &&
10250 bscript
.isCanonicalPubKey(chunks
[0]) &&
10251 chunks
[1] === OPS
.OP_CHECKSIG
10253 check
.toJSON = function () { return 'pubKey output' }
10255 function encode (pubKey
) {
10256 typeforce(bscript
.isCanonicalPubKey
, pubKey
)
10258 return bscript
.compile([pubKey
, OPS
.OP_CHECKSIG
])
10261 function decode (buffer
) {
10262 var chunks
= bscript
.decompile(buffer
)
10263 typeforce(check
, chunks
)
10274 },{"../../script":52,"bitcoin-ops":40,"typeforce":109}],62:[function(require
,module
,exports
){
10275 arguments
[4][55][0].apply(exports
,arguments
)
10276 },{"./input":63,"./output":64,"dup":55}],63:[function(require
,module
,exports
){
10277 // {signature} {pubKey}
10279 var bscript
= require('../../script')
10280 var types
= require('../../types')
10281 var typeforce
= require('typeforce')
10283 function check (script
) {
10284 var chunks
= bscript
.decompile(script
)
10286 return chunks
.length
=== 2 &&
10287 bscript
.isCanonicalSignature(chunks
[0]) &&
10288 bscript
.isCanonicalPubKey(chunks
[1])
10290 check
.toJSON = function () { return 'pubKeyHash input' }
10292 function encodeStack (signature
, pubKey
) {
10294 signature: types
.Buffer
, pubKey: types
.Buffer
10296 signature: signature
, pubKey: pubKey
10299 return [signature
, pubKey
]
10302 function encode (signature
, pubKey
) {
10303 return bscript
.compile(encodeStack(signature
, pubKey
))
10306 function decodeStack (stack
) {
10307 typeforce(check
, stack
)
10310 signature: stack
[0],
10315 function decode (buffer
) {
10316 var stack
= bscript
.decompile(buffer
)
10317 return decodeStack(stack
)
10323 decodeStack: decodeStack
,
10325 encodeStack: encodeStack
10328 },{"../../script":52,"../../types":78,"typeforce":109}],64:[function(require
,module
,exports
){
10329 // OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG
10331 var bscript
= require('../../script')
10332 var types
= require('../../types')
10333 var typeforce
= require('typeforce')
10334 var OPS
= require('bitcoin-ops')
10336 function check (script
) {
10337 var buffer
= bscript
.compile(script
)
10339 return buffer
.length
=== 25 &&
10340 buffer
[0] === OPS
.OP_DUP
&&
10341 buffer
[1] === OPS
.OP_HASH160
&&
10342 buffer
[2] === 0x14 &&
10343 buffer
[23] === OPS
.OP_EQUALVERIFY
&&
10344 buffer
[24] === OPS
.OP_CHECKSIG
10346 check
.toJSON = function () { return 'pubKeyHash output' }
10348 function encode (pubKeyHash
) {
10349 typeforce(types
.Hash160bit
, pubKeyHash
)
10351 return bscript
.compile([
10355 OPS
.OP_EQUALVERIFY
,
10360 function decode (buffer
) {
10361 typeforce(check
, buffer
)
10363 return buffer
.slice(3, 23)
10372 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],65:[function(require
,module
,exports
){
10373 arguments
[4][55][0].apply(exports
,arguments
)
10374 },{"./input":66,"./output":67,"dup":55}],66:[function(require
,module
,exports
){
10375 // <scriptSig> {serialized scriptPubKey script}
10377 var Buffer
= require('safe-buffer').Buffer
10378 var bscript
= require('../../script')
10379 var typeforce
= require('typeforce')
10381 function check (script
, allowIncomplete
) {
10382 var chunks
= bscript
.decompile(script
)
10383 if (chunks
.length
< 1) return false
10385 var lastChunk
= chunks
[chunks
.length
- 1]
10386 if (!Buffer
.isBuffer(lastChunk
)) return false
10388 var scriptSigChunks
= bscript
.decompile(bscript
.compile(chunks
.slice(0, -1)))
10389 var redeemScriptChunks
= bscript
.decompile(lastChunk
)
10391 // is redeemScript a valid script?
10392 if (redeemScriptChunks
.length
=== 0) return false
10394 // is redeemScriptSig push only?
10395 if (!bscript
.isPushOnly(scriptSigChunks
)) return false
10397 var inputType
= bscript
.classifyInput(scriptSigChunks
, allowIncomplete
)
10398 var outputType
= bscript
.classifyOutput(redeemScriptChunks
)
10399 if (chunks
.length
=== 1) {
10400 return outputType
=== bscript
.types
.P2WSH
|| outputType
=== bscript
.types
.P2WPKH
10402 return inputType
=== outputType
10404 check
.toJSON = function () { return 'scriptHash input' }
10406 function encodeStack (redeemScriptStack
, redeemScript
) {
10407 var serializedScriptPubKey
= bscript
.compile(redeemScript
)
10409 return [].concat(redeemScriptStack
, serializedScriptPubKey
)
10412 function encode (redeemScriptSig
, redeemScript
) {
10413 var redeemScriptStack
= bscript
.decompile(redeemScriptSig
)
10415 return bscript
.compile(encodeStack(redeemScriptStack
, redeemScript
))
10418 function decodeStack (stack
) {
10419 typeforce(check
, stack
)
10422 redeemScriptStack: stack
.slice(0, -1),
10423 redeemScript: stack
[stack
.length
- 1]
10427 function decode (buffer
) {
10428 var stack
= bscript
.decompile(buffer
)
10429 var result
= decodeStack(stack
)
10430 result
.redeemScriptSig
= bscript
.compile(result
.redeemScriptStack
)
10431 delete result
.redeemScriptStack
10438 decodeStack: decodeStack
,
10440 encodeStack: encodeStack
10443 },{"../../script":52,"safe-buffer":98,"typeforce":109}],67:[function(require
,module
,exports
){
10444 // OP_HASH160 {scriptHash} OP_EQUAL
10446 var bscript
= require('../../script')
10447 var types
= require('../../types')
10448 var typeforce
= require('typeforce')
10449 var OPS
= require('bitcoin-ops')
10451 function check (script
) {
10452 var buffer
= bscript
.compile(script
)
10454 return buffer
.length
=== 23 &&
10455 buffer
[0] === OPS
.OP_HASH160
&&
10456 buffer
[1] === 0x14 &&
10457 buffer
[22] === OPS
.OP_EQUAL
10459 check
.toJSON = function () { return 'scriptHash output' }
10461 function encode (scriptHash
) {
10462 typeforce(types
.Hash160bit
, scriptHash
)
10464 return bscript
.compile([OPS
.OP_HASH160
, scriptHash
, OPS
.OP_EQUAL
])
10467 function decode (buffer
) {
10468 typeforce(check
, buffer
)
10470 return buffer
.slice(2, 22)
10479 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],68:[function(require
,module
,exports
){
10481 output: require('./output')
10484 },{"./output":69}],69:[function(require
,module
,exports
){
10485 // OP_RETURN {aa21a9ed} {commitment}
10487 var Buffer
= require('safe-buffer').Buffer
10488 var bscript
= require('../../script')
10489 var types
= require('../../types')
10490 var typeforce
= require('typeforce')
10491 var OPS
= require('bitcoin-ops')
10493 var HEADER
= Buffer
.from('aa21a9ed', 'hex')
10495 function check (script
) {
10496 var buffer
= bscript
.compile(script
)
10498 return buffer
.length
> 37 &&
10499 buffer
[0] === OPS
.OP_RETURN
&&
10500 buffer
[1] === 0x24 &&
10501 buffer
.slice(2, 6).equals(HEADER
)
10504 check
.toJSON = function () { return 'Witness commitment output' }
10506 function encode (commitment
) {
10507 typeforce(types
.Hash256bit
, commitment
)
10509 var buffer
= Buffer
.allocUnsafe(36)
10510 HEADER
.copy(buffer
, 0)
10511 commitment
.copy(buffer
, 4)
10513 return bscript
.compile([OPS
.OP_RETURN
, buffer
])
10516 function decode (buffer
) {
10517 typeforce(check
, buffer
)
10519 return bscript
.decompile(buffer
)[1].slice(4, 36)
10528 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"safe-buffer":98,"typeforce":109}],70:[function(require
,module
,exports
){
10529 arguments
[4][55][0].apply(exports
,arguments
)
10530 },{"./input":71,"./output":72,"dup":55}],71:[function(require
,module
,exports
){
10531 // {signature} {pubKey}
10533 var pkh
= require('../pubkeyhash/input')
10537 decodeStack: pkh
.decodeStack
,
10538 encodeStack: pkh
.encodeStack
10541 },{"../pubkeyhash/input":63}],72:[function(require
,module
,exports
){
10542 // OP_0 {pubKeyHash}
10544 var bscript
= require('../../script')
10545 var types
= require('../../types')
10546 var typeforce
= require('typeforce')
10547 var OPS
= require('bitcoin-ops')
10549 function check (script
) {
10550 var buffer
= bscript
.compile(script
)
10552 return buffer
.length
=== 22 &&
10553 buffer
[0] === OPS
.OP_0
&&
10556 check
.toJSON = function () { return 'Witness pubKeyHash output' }
10558 function encode (pubKeyHash
) {
10559 typeforce(types
.Hash160bit
, pubKeyHash
)
10561 return bscript
.compile([OPS
.OP_0
, pubKeyHash
])
10564 function decode (buffer
) {
10565 typeforce(check
, buffer
)
10567 return buffer
.slice(2)
10576 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],73:[function(require
,module
,exports
){
10577 arguments
[4][55][0].apply(exports
,arguments
)
10578 },{"./input":74,"./output":75,"dup":55}],74:[function(require
,module
,exports
){
10579 // {signature} {pubKey}
10581 var p2sh
= require('../scripthash/input')
10585 decodeStack: p2sh
.decodeStack
,
10586 encodeStack: p2sh
.encodeStack
10589 },{"../scripthash/input":66}],75:[function(require
,module
,exports
){
10590 // OP_0 {scriptHash}
10592 var bscript
= require('../../script')
10593 var types
= require('../../types')
10594 var typeforce
= require('typeforce')
10595 var OPS
= require('bitcoin-ops')
10597 function check (script
) {
10598 var buffer
= bscript
.compile(script
)
10600 return buffer
.length
=== 34 &&
10601 buffer
[0] === OPS
.OP_0
&&
10604 check
.toJSON = function () { return 'Witness scriptHash output' }
10606 function encode (scriptHash
) {
10607 typeforce(types
.Hash256bit
, scriptHash
)
10609 return bscript
.compile([OPS
.OP_0
, scriptHash
])
10612 function decode (buffer
) {
10613 typeforce(check
, buffer
)
10615 return buffer
.slice(2)
10624 },{"../../script":52,"../../types":78,"bitcoin-ops":40,"typeforce":109}],76:[function(require
,module
,exports
){
10625 var Buffer
= require('safe-buffer').Buffer
10626 var bcrypto
= require('./crypto')
10627 var bscript
= require('./script')
10628 var bufferutils
= require('./bufferutils')
10629 var opcodes
= require('bitcoin-ops')
10630 var typeforce
= require('typeforce')
10631 var types
= require('./types')
10632 var varuint
= require('varuint-bitcoin')
10634 function varSliceSize (someScript
) {
10635 var length
= someScript
.length
10637 return varuint
.encodingLength(length
) + length
10640 function vectorSize (someVector
) {
10641 var length
= someVector
.length
10643 return varuint
.encodingLength(length
) + someVector
.reduce(function (sum
, witness
) {
10644 return sum
+ varSliceSize(witness
)
10648 function Transaction () {
10655 Transaction
.DEFAULT_SEQUENCE
= 0xffffffff
10656 Transaction
.SIGHASH_ALL
= 0x01
10657 Transaction
.SIGHASH_NONE
= 0x02
10658 Transaction
.SIGHASH_SINGLE
= 0x03
10659 Transaction
.SIGHASH_ANYONECANPAY
= 0x80
10660 Transaction
.ADVANCED_TRANSACTION_MARKER
= 0x00
10661 Transaction
.ADVANCED_TRANSACTION_FLAG
= 0x01
10663 var EMPTY_SCRIPT
= Buffer
.allocUnsafe(0)
10664 var EMPTY_WITNESS
= []
10665 var ZERO
= Buffer
.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
10666 var ONE
= Buffer
.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex')
10667 var VALUE_UINT64_MAX
= Buffer
.from('ffffffffffffffff', 'hex')
10668 var BLANK_OUTPUT
= {
10669 script: EMPTY_SCRIPT
,
10670 valueBuffer: VALUE_UINT64_MAX
10673 Transaction
.fromBuffer = function (buffer
, __noStrict
) {
10675 function readSlice (n
) {
10677 return buffer
.slice(offset
- n
, offset
)
10680 function readUInt32 () {
10681 var i
= buffer
.readUInt32LE(offset
)
10686 function readInt32 () {
10687 var i
= buffer
.readInt32LE(offset
)
10692 function readUInt64 () {
10693 var i
= bufferutils
.readUInt64LE(buffer
, offset
)
10698 function readVarInt () {
10699 var vi
= varuint
.decode(buffer
, offset
)
10700 offset
+= varuint
.decode
.bytes
10704 function readVarSlice () {
10705 return readSlice(readVarInt())
10708 function readVector () {
10709 var count
= readVarInt()
10711 for (var i
= 0; i
< count
; i
++) vector
.push(readVarSlice())
10715 var tx
= new Transaction()
10716 tx
.version
= readInt32()
10718 var marker
= buffer
.readUInt8(offset
)
10719 var flag
= buffer
.readUInt8(offset
+ 1)
10721 var hasWitnesses
= false
10722 if (marker
=== Transaction
.ADVANCED_TRANSACTION_MARKER
&&
10723 flag
=== Transaction
.ADVANCED_TRANSACTION_FLAG
) {
10725 hasWitnesses
= true
10728 var vinLen
= readVarInt()
10729 for (var i
= 0; i
< vinLen
; ++i
) {
10731 hash: readSlice(32),
10732 index: readUInt32(),
10733 script: readVarSlice(),
10734 sequence: readUInt32(),
10735 witness: EMPTY_WITNESS
10739 var voutLen
= readVarInt()
10740 for (i
= 0; i
< voutLen
; ++i
) {
10742 value: readUInt64(),
10743 script: readVarSlice()
10747 if (hasWitnesses
) {
10748 for (i
= 0; i
< vinLen
; ++i
) {
10749 tx
.ins
[i
].witness
= readVector()
10752 // was this pointless?
10753 if (!tx
.hasWitnesses()) throw new Error('Transaction has superfluous witness data')
10756 tx
.locktime
= readUInt32()
10758 if (__noStrict
) return tx
10759 if (offset
!== buffer
.length
) throw new Error('Transaction has unexpected data')
10764 Transaction
.fromHex = function (hex
) {
10765 return Transaction
.fromBuffer(Buffer
.from(hex
, 'hex'))
10768 Transaction
.isCoinbaseHash = function (buffer
) {
10769 typeforce(types
.Hash256bit
, buffer
)
10770 for (var i
= 0; i
< 32; ++i
) {
10771 if (buffer
[i
] !== 0) return false
10776 Transaction
.prototype.isCoinbase = function () {
10777 return this.ins
.length
=== 1 && Transaction
.isCoinbaseHash(this.ins
[0].hash
)
10780 Transaction
.prototype.addInput = function (hash
, index
, sequence
, scriptSig
) {
10781 typeforce(types
.tuple(
10784 types
.maybe(types
.UInt32
),
10785 types
.maybe(types
.Buffer
)
10788 if (types
.Null(sequence
)) {
10789 sequence
= Transaction
.DEFAULT_SEQUENCE
10792 // Add the input and return the input's index
10793 return (this.ins
.push({
10796 script: scriptSig
|| EMPTY_SCRIPT
,
10797 sequence: sequence
,
10798 witness: EMPTY_WITNESS
10802 Transaction
.prototype.addOutput = function (scriptPubKey
, value
) {
10803 typeforce(types
.tuple(types
.Buffer
, types
.Satoshi
), arguments
)
10805 // Add the output and return the output's index
10806 return (this.outs
.push({
10807 script: scriptPubKey
,
10812 Transaction
.prototype.hasWitnesses = function () {
10813 return this.ins
.some(function (x
) {
10814 return x
.witness
.length
!== 0
10818 Transaction
.prototype.weight = function () {
10819 var base
= this.__byteLength(false)
10820 var total
= this.__byteLength(true)
10821 return base
* 3 + total
10824 Transaction
.prototype.virtualSize = function () {
10825 return Math
.ceil(this.weight() / 4)
10828 Transaction
.prototype.byteLength = function () {
10829 return this.__byteLength(true)
10832 Transaction
.prototype.__byteLength = function (__allowWitness
) {
10833 var hasWitnesses
= __allowWitness
&& this.hasWitnesses()
10836 (hasWitnesses
? 10 : 8) +
10837 varuint
.encodingLength(this.ins
.length
) +
10838 varuint
.encodingLength(this.outs
.length
) +
10839 this.ins
.reduce(function (sum
, input
) { return sum
+ 40 + varSliceSize(input
.script
) }, 0) +
10840 this.outs
.reduce(function (sum
, output
) { return sum
+ 8 + varSliceSize(output
.script
) }, 0) +
10841 (hasWitnesses
? this.ins
.reduce(function (sum
, input
) { return sum
+ vectorSize(input
.witness
) }, 0) : 0)
10845 Transaction
.prototype.clone = function () {
10846 var newTx
= new Transaction()
10847 newTx
.version
= this.version
10848 newTx
.locktime
= this.locktime
10850 newTx
.ins
= this.ins
.map(function (txIn
) {
10854 script: txIn
.script
,
10855 sequence: txIn
.sequence
,
10856 witness: txIn
.witness
10860 newTx
.outs
= this.outs
.map(function (txOut
) {
10862 script: txOut
.script
,
10871 * Hash transaction for signing a specific input.
10873 * Bitcoin uses a different hash for each signed transaction input.
10874 * This method copies the transaction, makes the necessary changes based on the
10875 * hashType, and then hashes the result.
10876 * This hash can then be used to sign the provided transaction input.
10878 Transaction
.prototype.hashForSignature = function (inIndex
, prevOutScript
, hashType
) {
10879 typeforce(types
.tuple(types
.UInt32
, types
.Buffer
, /* types.UInt8 */ types
.Number
), arguments
)
10881 // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L29
10882 if (inIndex
>= this.ins
.length
) return ONE
10884 // ignore OP_CODESEPARATOR
10885 var ourScript
= bscript
.compile(bscript
.decompile(prevOutScript
).filter(function (x
) {
10886 return x
!== opcodes
.OP_CODESEPARATOR
10889 var txTmp
= this.clone()
10891 // SIGHASH_NONE: ignore all outputs? (wildcard payee)
10892 if ((hashType
& 0x1f) === Transaction
.SIGHASH_NONE
) {
10895 // ignore sequence numbers (except at inIndex)
10896 txTmp
.ins
.forEach(function (input
, i
) {
10897 if (i
=== inIndex
) return
10902 // SIGHASH_SINGLE: ignore all outputs, except at the same index?
10903 } else if ((hashType
& 0x1f) === Transaction
.SIGHASH_SINGLE
) {
10904 // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L60
10905 if (inIndex
>= this.outs
.length
) return ONE
10907 // truncate outputs after
10908 txTmp
.outs
.length
= inIndex
+ 1
10910 // "blank" outputs before
10911 for (var i
= 0; i
< inIndex
; i
++) {
10912 txTmp
.outs
[i
] = BLANK_OUTPUT
10915 // ignore sequence numbers (except at inIndex)
10916 txTmp
.ins
.forEach(function (input
, y
) {
10917 if (y
=== inIndex
) return
10923 // SIGHASH_ANYONECANPAY: ignore inputs entirely?
10924 if (hashType
& Transaction
.SIGHASH_ANYONECANPAY
) {
10925 txTmp
.ins
= [txTmp
.ins
[inIndex
]]
10926 txTmp
.ins
[0].script
= ourScript
10928 // SIGHASH_ALL: only ignore input scripts
10930 // "blank" others input scripts
10931 txTmp
.ins
.forEach(function (input
) { input
.script
= EMPTY_SCRIPT
})
10932 txTmp
.ins
[inIndex
].script
= ourScript
10935 // serialize and hash
10936 var buffer
= Buffer
.allocUnsafe(txTmp
.__byteLength(false) + 4)
10937 buffer
.writeInt32LE(hashType
, buffer
.length
- 4)
10938 txTmp
.__toBuffer(buffer
, 0, false)
10940 return bcrypto
.hash256(buffer
)
10943 Transaction
.prototype.hashForWitnessV0 = function (inIndex
, prevOutScript
, value
, hashType
) {
10944 typeforce(types
.tuple(types
.UInt32
, types
.Buffer
, types
.Satoshi
, types
.UInt32
), arguments
)
10946 var tbuffer
, toffset
10947 function writeSlice (slice
) { toffset
+= slice
.copy(tbuffer
, toffset
) }
10948 function writeUInt32 (i
) { toffset
= tbuffer
.writeUInt32LE(i
, toffset
) }
10949 function writeUInt64 (i
) { toffset
= bufferutils
.writeUInt64LE(tbuffer
, i
, toffset
) }
10950 function writeVarInt (i
) {
10951 varuint
.encode(i
, tbuffer
, toffset
)
10952 toffset
+= varuint
.encode
.bytes
10954 function writeVarSlice (slice
) { writeVarInt(slice
.length
); writeSlice(slice
) }
10956 var hashOutputs
= ZERO
10957 var hashPrevouts
= ZERO
10958 var hashSequence
= ZERO
10960 if (!(hashType
& Transaction
.SIGHASH_ANYONECANPAY
)) {
10961 tbuffer
= Buffer
.allocUnsafe(36 * this.ins
.length
)
10964 this.ins
.forEach(function (txIn
) {
10965 writeSlice(txIn
.hash
)
10966 writeUInt32(txIn
.index
)
10969 hashPrevouts
= bcrypto
.hash256(tbuffer
)
10972 if (!(hashType
& Transaction
.SIGHASH_ANYONECANPAY
) &&
10973 (hashType
& 0x1f) !== Transaction
.SIGHASH_SINGLE
&&
10974 (hashType
& 0x1f) !== Transaction
.SIGHASH_NONE
) {
10975 tbuffer
= Buffer
.allocUnsafe(4 * this.ins
.length
)
10978 this.ins
.forEach(function (txIn
) {
10979 writeUInt32(txIn
.sequence
)
10982 hashSequence
= bcrypto
.hash256(tbuffer
)
10985 if ((hashType
& 0x1f) !== Transaction
.SIGHASH_SINGLE
&&
10986 (hashType
& 0x1f) !== Transaction
.SIGHASH_NONE
) {
10987 var txOutsSize
= this.outs
.reduce(function (sum
, output
) {
10988 return sum
+ 8 + varSliceSize(output
.script
)
10991 tbuffer
= Buffer
.allocUnsafe(txOutsSize
)
10994 this.outs
.forEach(function (out
) {
10995 writeUInt64(out
.value
)
10996 writeVarSlice(out
.script
)
10999 hashOutputs
= bcrypto
.hash256(tbuffer
)
11000 } else if ((hashType
& 0x1f) === Transaction
.SIGHASH_SINGLE
&& inIndex
< this.outs
.length
) {
11001 var output
= this.outs
[inIndex
]
11003 tbuffer
= Buffer
.allocUnsafe(8 + varSliceSize(output
.script
))
11005 writeUInt64(output
.value
)
11006 writeVarSlice(output
.script
)
11008 hashOutputs
= bcrypto
.hash256(tbuffer
)
11011 tbuffer
= Buffer
.allocUnsafe(156 + varSliceSize(prevOutScript
))
11014 var input
= this.ins
[inIndex
]
11015 writeUInt32(this.version
)
11016 writeSlice(hashPrevouts
)
11017 writeSlice(hashSequence
)
11018 writeSlice(input
.hash
)
11019 writeUInt32(input
.index
)
11020 writeVarSlice(prevOutScript
)
11022 writeUInt32(input
.sequence
)
11023 writeSlice(hashOutputs
)
11024 writeUInt32(this.locktime
)
11025 writeUInt32(hashType
)
11026 return bcrypto
.hash256(tbuffer
)
11029 Transaction
.prototype.getHash = function () {
11030 return bcrypto
.hash256(this.__toBuffer(undefined, undefined, false))
11033 Transaction
.prototype.getId = function () {
11034 // transaction hash's are displayed in reverse order
11035 return this.getHash().reverse().toString('hex')
11038 Transaction
.prototype.toBuffer = function (buffer
, initialOffset
) {
11039 return this.__toBuffer(buffer
, initialOffset
, true)
11042 Transaction
.prototype.__toBuffer = function (buffer
, initialOffset
, __allowWitness
) {
11043 if (!buffer
) buffer
= Buffer
.allocUnsafe(this.__byteLength(__allowWitness
))
11045 var offset
= initialOffset
|| 0
11046 function writeSlice (slice
) { offset
+= slice
.copy(buffer
, offset
) }
11047 function writeUInt8 (i
) { offset
= buffer
.writeUInt8(i
, offset
) }
11048 function writeUInt32 (i
) { offset
= buffer
.writeUInt32LE(i
, offset
) }
11049 function writeInt32 (i
) { offset
= buffer
.writeInt32LE(i
, offset
) }
11050 function writeUInt64 (i
) { offset
= bufferutils
.writeUInt64LE(buffer
, i
, offset
) }
11051 function writeVarInt (i
) {
11052 varuint
.encode(i
, buffer
, offset
)
11053 offset
+= varuint
.encode
.bytes
11055 function writeVarSlice (slice
) { writeVarInt(slice
.length
); writeSlice(slice
) }
11056 function writeVector (vector
) { writeVarInt(vector
.length
); vector
.forEach(writeVarSlice
) }
11058 writeInt32(this.version
)
11060 var hasWitnesses
= __allowWitness
&& this.hasWitnesses()
11062 if (hasWitnesses
) {
11063 writeUInt8(Transaction
.ADVANCED_TRANSACTION_MARKER
)
11064 writeUInt8(Transaction
.ADVANCED_TRANSACTION_FLAG
)
11067 writeVarInt(this.ins
.length
)
11069 this.ins
.forEach(function (txIn
) {
11070 writeSlice(txIn
.hash
)
11071 writeUInt32(txIn
.index
)
11072 writeVarSlice(txIn
.script
)
11073 writeUInt32(txIn
.sequence
)
11076 writeVarInt(this.outs
.length
)
11077 this.outs
.forEach(function (txOut
) {
11078 if (!txOut
.valueBuffer
) {
11079 writeUInt64(txOut
.value
)
11081 writeSlice(txOut
.valueBuffer
)
11084 writeVarSlice(txOut
.script
)
11087 if (hasWitnesses
) {
11088 this.ins
.forEach(function (input
) {
11089 writeVector(input
.witness
)
11093 writeUInt32(this.locktime
)
11095 // avoid slicing unless necessary
11096 if (initialOffset
!== undefined) return buffer
.slice(initialOffset
, offset
)
11100 Transaction
.prototype.toHex = function () {
11101 return this.toBuffer().toString('hex')
11104 Transaction
.prototype.setInputScript = function (index
, scriptSig
) {
11105 typeforce(types
.tuple(types
.Number
, types
.Buffer
), arguments
)
11107 this.ins
[index
].script
= scriptSig
11110 Transaction
.prototype.setWitness = function (index
, witness
) {
11111 typeforce(types
.tuple(types
.Number
, [types
.Buffer
]), arguments
)
11113 this.ins
[index
].witness
= witness
11116 module
.exports
= Transaction
11118 },{"./bufferutils":44,"./crypto":45,"./script":52,"./types":78,"bitcoin-ops":40,"safe-buffer":98,"typeforce":109,"varuint-bitcoin":111}],77:[function(require
,module
,exports
){
11119 var Buffer
= require('safe-buffer').Buffer
11120 var baddress
= require('./address')
11121 var bcrypto
= require('./crypto')
11122 var bscript
= require('./script')
11123 var networks
= require('./networks')
11124 var ops
= require('bitcoin-ops')
11125 var typeforce
= require('typeforce')
11126 var types
= require('./types')
11127 var scriptTypes
= bscript
.types
11128 var SIGNABLE
= [bscript
.types
.P2PKH
, bscript
.types
.P2PK
, bscript
.types
.MULTISIG
]
11129 var P2SH
= SIGNABLE
.concat([bscript
.types
.P2WPKH
, bscript
.types
.P2WSH
])
11131 var ECPair
= require('./ecpair')
11132 var ECSignature
= require('./ecsignature')
11133 var Transaction
= require('./transaction')
11135 function extractChunks (type
, chunks
, script
) {
11137 var signatures
= []
11139 case scriptTypes
.P2PKH:
11140 // if (redeemScript) throw new Error('Nonstandard... P2SH(P2PKH)')
11141 pubKeys
= chunks
.slice(1)
11142 signatures
= chunks
.slice(0, 1)
11145 case scriptTypes
.P2PK:
11146 pubKeys
[0] = script
? bscript
.pubKey
.output
.decode(script
) : undefined
11147 signatures
= chunks
.slice(0, 1)
11150 case scriptTypes
.MULTISIG:
11152 var multisig
= bscript
.multisig
.output
.decode(script
)
11153 pubKeys
= multisig
.pubKeys
11156 signatures
= chunks
.slice(1).map(function (chunk
) {
11157 return chunk
.length
=== 0 ? undefined : chunk
11164 signatures: signatures
11167 function expandInput (scriptSig
, witnessStack
) {
11168 if (scriptSig
.length
=== 0 && witnessStack
.length
=== 0) return {}
11176 var witnessScriptType
11177 var redeemScriptType
11178 var witness
= false
11184 var scriptSigChunks
= bscript
.decompile(scriptSig
)
11185 var sigType
= bscript
.classifyInput(scriptSigChunks
, true)
11186 if (sigType
=== scriptTypes
.P2SH
) {
11188 redeemScript
= scriptSigChunks
[scriptSigChunks
.length
- 1]
11189 redeemScriptType
= bscript
.classifyOutput(redeemScript
)
11190 prevOutScript
= bscript
.scriptHash
.output
.encode(bcrypto
.hash160(redeemScript
))
11191 prevOutType
= scriptTypes
.P2SH
11192 script
= redeemScript
11195 var classifyWitness
= bscript
.classifyWitness(witnessStack
)
11196 if (classifyWitness
=== scriptTypes
.P2WSH
) {
11197 witnessScript
= witnessStack
[witnessStack
.length
- 1]
11198 witnessScriptType
= bscript
.classifyOutput(witnessScript
)
11200 if (scriptSig
.length
=== 0) {
11201 prevOutScript
= bscript
.witnessScriptHash
.output
.encode(bcrypto
.sha256(witnessScript
))
11202 prevOutType
= scriptTypes
.P2WSH
11203 if (typeof redeemScript
!== 'undefined') {
11204 throw new Error('Redeem script given when unnecessary')
11208 if (!redeemScript
) {
11209 throw new Error('No redeemScript provided for P2WSH, but scriptSig non-empty')
11211 witnessProgram
= bscript
.witnessScriptHash
.output
.encode(bcrypto
.sha256(witnessScript
))
11212 if (!redeemScript
.equals(witnessProgram
)) {
11213 throw new Error('Redeem script didn\'t match witnessScript')
11217 if (SIGNABLE
.indexOf(bscript
.classifyOutput(witnessScript
)) === -1) {
11218 throw new Error('unsupported witness script')
11220 script
= witnessScript
11221 scriptType
= witnessScriptType
11222 chunks
= witnessStack
.slice(0, -1)
11223 } else if (classifyWitness
=== scriptTypes
.P2WPKH
) {
11224 var key
= witnessStack
[witnessStack
.length
- 1]
11225 var keyHash
= bcrypto
.hash160(key
)
11226 if (scriptSig
.length
=== 0) {
11227 prevOutScript
= bscript
.witnessPubKeyHash
.output
.encode(keyHash
)
11228 prevOutType
= scriptTypes
.P2WPKH
11229 if (typeof redeemScript
!== 'undefined') {
11230 throw new Error('Redeem script given when unnecessary')
11233 if (!redeemScript
) {
11234 throw new Error('No redeemScript provided for P2WPKH, but scriptSig wasn\'t empty')
11236 witnessProgram
= bscript
.witnessPubKeyHash
.output
.encode(keyHash
)
11237 if (!redeemScript
.equals(witnessProgram
)) {
11238 throw new Error('Redeem script did not have the right witness program')
11242 scriptType
= scriptTypes
.P2PKH
11243 chunks
= witnessStack
11244 } else if (redeemScript
) {
11245 if (P2SH
.indexOf(redeemScriptType
) === -1) {
11246 throw new Error('Bad redeemscript!')
11249 script
= redeemScript
11250 scriptType
= redeemScriptType
11251 chunks
= scriptSigChunks
.slice(0, -1)
11253 prevOutType
= scriptType
= bscript
.classifyInput(scriptSig
)
11254 chunks
= scriptSigChunks
11257 var expanded
= extractChunks(scriptType
, chunks
, script
)
11260 pubKeys: expanded
.pubKeys
,
11261 signatures: expanded
.signatures
,
11262 prevOutScript: prevOutScript
,
11263 prevOutType: prevOutType
,
11264 signType: scriptType
,
11265 signScript: script
,
11266 witness: Boolean(witness
)
11270 result
.redeemScript
= redeemScript
11271 result
.redeemScriptType
= redeemScriptType
11275 result
.witnessScript
= witnessScript
11276 result
.witnessScriptType
= witnessScriptType
11282 // could be done in expandInput, but requires the original Transaction for hashForSignature
11283 function fixMultisigOrder (input
, transaction
, vin
) {
11284 if (input
.redeemScriptType
!== scriptTypes
.MULTISIG
|| !input
.redeemScript
) return
11285 if (input
.pubKeys
.length
=== input
.signatures
.length
) return
11287 var unmatched
= input
.signatures
.concat()
11289 input
.signatures
= input
.pubKeys
.map(function (pubKey
) {
11290 var keyPair
= ECPair
.fromPublicKeyBuffer(pubKey
)
11293 // check for a signature
11294 unmatched
.some(function (signature
, i
) {
11295 // skip if undefined || OP_0
11296 if (!signature
) return false
11298 // TODO: avoid O(n) hashForSignature
11299 var parsed
= ECSignature
.parseScriptSignature(signature
)
11300 var hash
= transaction
.hashForSignature(vin
, input
.redeemScript
, parsed
.hashType
)
11302 // skip if signature does not match pubKey
11303 if (!keyPair
.verify(hash
, parsed
.signature
)) return false
11305 // remove matched signature from unmatched
11306 unmatched
[i
] = undefined
11316 function expandOutput (script
, scriptType
, ourPubKey
) {
11317 typeforce(types
.Buffer
, script
)
11319 var scriptChunks
= bscript
.decompile(script
)
11321 scriptType
= bscript
.classifyOutput(script
)
11326 switch (scriptType
) {
11327 // does our hash160(pubKey) match the output scripts?
11328 case scriptTypes
.P2PKH:
11329 if (!ourPubKey
) break
11331 var pkh1
= scriptChunks
[2]
11332 var pkh2
= bcrypto
.hash160(ourPubKey
)
11333 if (pkh1
.equals(pkh2
)) pubKeys
= [ourPubKey
]
11336 // does our hash160(pubKey) match the output scripts?
11337 case scriptTypes
.P2WPKH:
11338 if (!ourPubKey
) break
11340 var wpkh1
= scriptChunks
[1]
11341 var wpkh2
= bcrypto
.hash160(ourPubKey
)
11342 if (wpkh1
.equals(wpkh2
)) pubKeys
= [ourPubKey
]
11345 case scriptTypes
.P2PK:
11346 pubKeys
= scriptChunks
.slice(0, 1)
11349 case scriptTypes
.MULTISIG:
11350 pubKeys
= scriptChunks
.slice(1, -2)
11353 default: return { scriptType: scriptType
}
11358 scriptType: scriptType
,
11359 signatures: pubKeys
.map(function () { return undefined })
11363 function checkP2shInput (input
, redeemScriptHash
) {
11364 if (input
.prevOutType
) {
11365 if (input
.prevOutType
!== scriptTypes
.P2SH
) throw new Error('PrevOutScript must be P2SH')
11367 var prevOutScriptScriptHash
= bscript
.decompile(input
.prevOutScript
)[1]
11368 if (!prevOutScriptScriptHash
.equals(redeemScriptHash
)) throw new Error('Inconsistent hash160(RedeemScript)')
11372 function checkP2WSHInput (input
, witnessScriptHash
) {
11373 if (input
.prevOutType
) {
11374 if (input
.prevOutType
!== scriptTypes
.P2WSH
) throw new Error('PrevOutScript must be P2WSH')
11376 var scriptHash
= bscript
.decompile(input
.prevOutScript
)[1]
11377 if (!scriptHash
.equals(witnessScriptHash
)) throw new Error('Inconsistent sha25(WitnessScript)')
11381 function prepareInput (input
, kpPubKey
, redeemScript
, witnessValue
, witnessScript
) {
11388 var redeemScriptHash
11390 var witness
= false
11393 var witnessScriptHash
11398 if (redeemScript
&& witnessScript
) {
11399 redeemScriptHash
= bcrypto
.hash160(redeemScript
)
11400 witnessScriptHash
= bcrypto
.sha256(witnessScript
)
11401 checkP2shInput(input
, redeemScriptHash
)
11403 if (!redeemScript
.equals(bscript
.witnessScriptHash
.output
.encode(witnessScriptHash
))) throw new Error('Witness script inconsistent with redeem script')
11405 expanded
= expandOutput(witnessScript
, undefined, kpPubKey
)
11406 if (!expanded
.pubKeys
) throw new Error('WitnessScript not supported "' + bscript
.toASM(redeemScript
) + '"')
11407 prevOutType
= bscript
.types
.P2SH
11408 prevOutScript
= bscript
.scriptHash
.output
.encode(redeemScriptHash
)
11409 p2sh
= witness
= p2wsh
= true
11410 p2shType
= bscript
.types
.P2WSH
11411 signType
= witnessType
= expanded
.scriptType
11412 signScript
= witnessScript
11413 } else if (redeemScript
) {
11414 redeemScriptHash
= bcrypto
.hash160(redeemScript
)
11415 checkP2shInput(input
, redeemScriptHash
)
11417 expanded
= expandOutput(redeemScript
, undefined, kpPubKey
)
11418 if (!expanded
.pubKeys
) throw new Error('RedeemScript not supported "' + bscript
.toASM(redeemScript
) + '"')
11420 prevOutType
= bscript
.types
.P2SH
11421 prevOutScript
= bscript
.scriptHash
.output
.encode(redeemScriptHash
)
11423 signType
= p2shType
= expanded
.scriptType
11424 signScript
= redeemScript
11425 witness
= signType
=== bscript
.types
.P2WPKH
11426 } else if (witnessScript
) {
11427 witnessScriptHash
= bcrypto
.sha256(witnessScript
)
11428 checkP2WSHInput(input
, witnessScriptHash
)
11430 expanded
= expandOutput(witnessScript
, undefined, kpPubKey
)
11431 if (!expanded
.pubKeys
) throw new Error('WitnessScript not supported "' + bscript
.toASM(redeemScript
) + '"')
11433 prevOutType
= bscript
.types
.P2WSH
11434 prevOutScript
= bscript
.witnessScriptHash
.output
.encode(witnessScriptHash
)
11435 witness
= p2wsh
= true
11436 signType
= witnessType
= expanded
.scriptType
11437 signScript
= witnessScript
11438 } else if (input
.prevOutType
) {
11439 // embedded scripts are not possible without a redeemScript
11440 if (input
.prevOutType
=== scriptTypes
.P2SH
||
11441 input
.prevOutType
=== scriptTypes
.P2WSH
) {
11442 throw new Error('PrevOutScript is ' + input
.prevOutType
+ ', requires redeemScript')
11445 prevOutType
= input
.prevOutType
11446 prevOutScript
= input
.prevOutScript
11447 expanded
= expandOutput(input
.prevOutScript
, input
.prevOutType
, kpPubKey
)
11448 if (!expanded
.pubKeys
) return
11450 witness
= (input
.prevOutType
=== scriptTypes
.P2WPKH
)
11451 signType
= prevOutType
11452 signScript
= prevOutScript
11454 prevOutScript
= bscript
.pubKeyHash
.output
.encode(bcrypto
.hash160(kpPubKey
))
11455 expanded
= expandOutput(prevOutScript
, scriptTypes
.P2PKH
, kpPubKey
)
11456 prevOutType
= scriptTypes
.P2PKH
11458 signType
= prevOutType
11459 signScript
= prevOutScript
11462 if (witness
&& !types
.Satoshi(witnessValue
)) {
11463 throw new Error('Input was witness but not given witness value')
11466 if (signType
=== scriptTypes
.P2WPKH
) {
11467 signScript
= bscript
.pubKeyHash
.output
.encode(bscript
.witnessPubKeyHash
.output
.decode(signScript
))
11471 input
.redeemScript
= redeemScript
11472 input
.redeemScriptType
= p2shType
11476 input
.witnessScript
= witnessScript
11477 input
.witnessScriptType
= witnessType
11480 input
.pubKeys
= expanded
.pubKeys
11481 input
.signatures
= expanded
.signatures
11482 input
.signScript
= signScript
11483 input
.signType
= signType
11484 input
.prevOutScript
= prevOutScript
11485 input
.prevOutType
= prevOutType
11486 input
.witness
= witness
11489 function buildStack (type
, signatures
, pubKeys
, allowIncomplete
) {
11490 if (type
=== scriptTypes
.P2PKH
) {
11491 if (signatures
.length
=== 1 && Buffer
.isBuffer(signatures
[0]) && pubKeys
.length
=== 1) return bscript
.pubKeyHash
.input
.encodeStack(signatures
[0], pubKeys
[0])
11492 } else if (type
=== scriptTypes
.P2PK
) {
11493 if (signatures
.length
=== 1 && Buffer
.isBuffer(signatures
[0])) return bscript
.pubKey
.input
.encodeStack(signatures
[0])
11494 } else if (type
=== scriptTypes
.MULTISIG
) {
11495 if (signatures
.length
> 0) {
11496 signatures
= signatures
.map(function (signature
) {
11497 return signature
|| ops
.OP_0
11499 if (!allowIncomplete
) {
11500 // remove blank signatures
11501 signatures
= signatures
.filter(function (x
) { return x
!== ops
.OP_0
})
11504 return bscript
.multisig
.input
.encodeStack(signatures
/* see if it's necessary first */)
11507 throw new Error('Not yet supported')
11510 if (!allowIncomplete
) throw new Error('Not enough signatures provided')
11515 function buildInput (input
, allowIncomplete
) {
11516 var scriptType
= input
.prevOutType
11519 if (SIGNABLE
.indexOf(scriptType
) !== -1) {
11520 sig
= buildStack(scriptType
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11524 if (scriptType
=== bscript
.types
.P2SH
) {
11525 // We can remove this error later when we have a guarantee prepareInput
11526 // rejects unsignable scripts - it MUST be signable at this point.
11527 if (P2SH
.indexOf(input
.redeemScriptType
) === -1) {
11528 throw new Error('Impossible to sign this type')
11531 if (SIGNABLE
.indexOf(input
.redeemScriptType
) !== -1) {
11532 sig
= buildStack(input
.redeemScriptType
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11534 // If it wasn't SIGNABLE, it's witness, defer to that
11535 scriptType
= input
.redeemScriptType
11538 if (scriptType
=== bscript
.types
.P2WPKH
) {
11539 // P2WPKH is a special case of P2PKH
11540 witness
= buildStack(bscript
.types
.P2PKH
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11541 } else if (scriptType
=== bscript
.types
.P2WSH
) {
11542 // We can remove this check later
11543 if (SIGNABLE
.indexOf(input
.witnessScriptType
) !== -1) {
11544 witness
= buildStack(input
.witnessScriptType
, input
.signatures
, input
.pubKeys
, allowIncomplete
)
11545 witness
.push(input
.witnessScript
)
11547 // We can remove this error later when we have a guarantee prepareInput
11548 // rejects unsignble scripts - it MUST be signable at this point.
11552 scriptType
= input
.witnessScriptType
11555 // append redeemScript if necessary
11557 sig
.push(input
.redeemScript
)
11562 script: bscript
.compile(sig
),
11567 function TransactionBuilder (network
, maximumFeeRate
) {
11568 this.prevTxMap
= {}
11569 this.network
= network
|| networks
.bitcoin
11571 // WARNING: This is __NOT__ to be relied on, its just another potential safety mechanism (safety in-depth)
11572 this.maximumFeeRate
= maximumFeeRate
|| 1000
11575 this.tx
= new Transaction()
11578 TransactionBuilder
.prototype.setLockTime = function (locktime
) {
11579 typeforce(types
.UInt32
, locktime
)
11581 // if any signatures exist, throw
11582 if (this.inputs
.some(function (input
) {
11583 if (!input
.signatures
) return false
11585 return input
.signatures
.some(function (s
) { return s
})
11587 throw new Error('No, this would invalidate signatures')
11590 this.tx
.locktime
= locktime
11593 TransactionBuilder
.prototype.setVersion = function (version
) {
11594 typeforce(types
.UInt32
, version
)
11596 // XXX: this might eventually become more complex depending on what the versions represent
11597 this.tx
.version
= version
11600 TransactionBuilder
.fromTransaction = function (transaction
, network
) {
11601 var txb
= new TransactionBuilder(network
)
11603 // Copy transaction fields
11604 txb
.setVersion(transaction
.version
)
11605 txb
.setLockTime(transaction
.locktime
)
11607 // Copy outputs (done first to avoid signature invalidation)
11608 transaction
.outs
.forEach(function (txOut
) {
11609 txb
.addOutput(txOut
.script
, txOut
.value
)
11613 transaction
.ins
.forEach(function (txIn
) {
11614 txb
.__addInputUnsafe(txIn
.hash
, txIn
.index
, {
11615 sequence: txIn
.sequence
,
11616 script: txIn
.script
,
11617 witness: txIn
.witness
11621 // fix some things not possible through the public API
11622 txb
.inputs
.forEach(function (input
, i
) {
11623 fixMultisigOrder(input
, transaction
, i
)
11629 TransactionBuilder
.prototype.addInput = function (txHash
, vout
, sequence
, prevOutScript
) {
11630 if (!this.__canModifyInputs()) {
11631 throw new Error('No, this would invalidate signatures')
11636 // is it a hex string?
11637 if (typeof txHash
=== 'string') {
11638 // transaction hashs's are displayed in reverse order, un-reverse it
11639 txHash
= Buffer
.from(txHash
, 'hex').reverse()
11641 // is it a Transaction object?
11642 } else if (txHash
instanceof Transaction
) {
11643 var txOut
= txHash
.outs
[vout
]
11644 prevOutScript
= txOut
.script
11645 value
= txOut
.value
11647 txHash
= txHash
.getHash()
11650 return this.__addInputUnsafe(txHash
, vout
, {
11651 sequence: sequence
,
11652 prevOutScript: prevOutScript
,
11657 TransactionBuilder
.prototype.__addInputUnsafe = function (txHash
, vout
, options
) {
11658 if (Transaction
.isCoinbaseHash(txHash
)) {
11659 throw new Error('coinbase inputs not supported')
11662 var prevTxOut
= txHash
.toString('hex') + ':' + vout
11663 if (this.prevTxMap
[prevTxOut
] !== undefined) throw new Error('Duplicate TxOut: ' + prevTxOut
)
11667 // derive what we can from the scriptSig
11668 if (options
.script
!== undefined) {
11669 input
= expandInput(options
.script
, options
.witness
|| [])
11672 // if an input value was given, retain it
11673 if (options
.value
!== undefined) {
11674 input
.value
= options
.value
11677 // derive what we can from the previous transactions output script
11678 if (!input
.prevOutScript
&& options
.prevOutScript
) {
11681 if (!input
.pubKeys
&& !input
.signatures
) {
11682 var expanded
= expandOutput(options
.prevOutScript
)
11684 if (expanded
.pubKeys
) {
11685 input
.pubKeys
= expanded
.pubKeys
11686 input
.signatures
= expanded
.signatures
11689 prevOutType
= expanded
.scriptType
11692 input
.prevOutScript
= options
.prevOutScript
11693 input
.prevOutType
= prevOutType
|| bscript
.classifyOutput(options
.prevOutScript
)
11696 var vin
= this.tx
.addInput(txHash
, vout
, options
.sequence
, options
.scriptSig
)
11697 this.inputs
[vin
] = input
11698 this.prevTxMap
[prevTxOut
] = vin
11703 TransactionBuilder
.prototype.addOutput = function (scriptPubKey
, value
) {
11704 if (!this.__canModifyOutputs()) {
11705 throw new Error('No, this would invalidate signatures')
11708 // Attempt to get a script if it's a base58 address string
11709 if (typeof scriptPubKey
=== 'string') {
11710 scriptPubKey
= baddress
.toOutputScript(scriptPubKey
, this.network
)
11713 return this.tx
.addOutput(scriptPubKey
, value
)
11716 TransactionBuilder
.prototype.build = function () {
11717 return this.__build(false)
11719 TransactionBuilder
.prototype.buildIncomplete = function () {
11720 return this.__build(true)
11723 TransactionBuilder
.prototype.__build = function (allowIncomplete
) {
11724 if (!allowIncomplete
) {
11725 if (!this.tx
.ins
.length
) throw new Error('Transaction has no inputs')
11726 if (!this.tx
.outs
.length
) throw new Error('Transaction has no outputs')
11729 var tx
= this.tx
.clone()
11730 // Create script signatures from inputs
11731 this.inputs
.forEach(function (input
, i
) {
11732 var scriptType
= input
.witnessScriptType
|| input
.redeemScriptType
|| input
.prevOutType
11733 if (!scriptType
&& !allowIncomplete
) throw new Error('Transaction is not complete')
11734 var result
= buildInput(input
, allowIncomplete
)
11736 // skip if no result
11737 if (!allowIncomplete
) {
11738 if (SIGNABLE
.indexOf(result
.type
) === -1 && result
.type
!== bscript
.types
.P2WPKH
) {
11739 throw new Error(result
.type
+ ' not supported')
11743 tx
.setInputScript(i
, result
.script
)
11744 tx
.setWitness(i
, result
.witness
)
11747 if (!allowIncomplete
) {
11748 // do not rely on this, its merely a last resort
11749 if (this.__overMaximumFees(tx
.byteLength())) {
11750 throw new Error('Transaction has absurd fees')
11757 function canSign (input
) {
11758 return input
.prevOutScript
!== undefined &&
11759 input
.signScript
!== undefined &&
11760 input
.pubKeys
!== undefined &&
11761 input
.signatures
!== undefined &&
11762 input
.signatures
.length
=== input
.pubKeys
.length
&&
11763 input
.pubKeys
.length
> 0 &&
11764 input
.witness
!== undefined
11767 TransactionBuilder
.prototype.sign = function (vin
, keyPair
, redeemScript
, hashType
, witnessValue
, witnessScript
) {
11768 if (keyPair
.network
!== this.network
) throw new Error('Inconsistent network')
11769 if (!this.inputs
[vin
]) throw new Error('No input at index: ' + vin
)
11770 hashType
= hashType
|| Transaction
.SIGHASH_ALL
11772 var input
= this.inputs
[vin
]
11774 // if redeemScript was previously provided, enforce consistency
11775 if (input
.redeemScript
!== undefined &&
11777 !input
.redeemScript
.equals(redeemScript
)) {
11778 throw new Error('Inconsistent redeemScript')
11781 var kpPubKey
= keyPair
.getPublicKeyBuffer()
11782 if (!canSign(input
)) {
11783 prepareInput(input
, kpPubKey
, redeemScript
, witnessValue
, witnessScript
)
11784 if (!canSign(input
)) throw Error(input
.prevOutType
+ ' not supported')
11789 if (input
.witness
) {
11790 signatureHash
= this.tx
.hashForWitnessV0(vin
, input
.signScript
, witnessValue
, hashType
)
11792 signatureHash
= this.tx
.hashForSignature(vin
, input
.signScript
, hashType
)
11794 // enforce in order signing of public keys
11795 var signed
= input
.pubKeys
.some(function (pubKey
, i
) {
11796 if (!kpPubKey
.equals(pubKey
)) return false
11797 if (input
.signatures
[i
]) throw new Error('Signature already exists')
11799 input
.signatures
[i
] = keyPair
.sign(signatureHash
).toScriptSignature(hashType
)
11803 if (!signed
) throw new Error('Key pair cannot sign for this input')
11806 function signatureHashType (buffer
) {
11807 return buffer
.readUInt8(buffer
.length
- 1)
11810 TransactionBuilder
.prototype.__canModifyInputs = function () {
11811 return this.inputs
.every(function (input
) {
11813 if (input
.signatures
=== undefined) return true
11815 return input
.signatures
.every(function (signature
) {
11816 if (!signature
) return true
11817 var hashType
= signatureHashType(signature
)
11819 // if SIGHASH_ANYONECANPAY is set, signatures would not
11820 // be invalidated by more inputs
11821 return hashType
& Transaction
.SIGHASH_ANYONECANPAY
11826 TransactionBuilder
.prototype.__canModifyOutputs = function () {
11827 var nInputs
= this.tx
.ins
.length
11828 var nOutputs
= this.tx
.outs
.length
11830 return this.inputs
.every(function (input
) {
11831 if (input
.signatures
=== undefined) return true
11833 return input
.signatures
.every(function (signature
) {
11834 if (!signature
) return true
11835 var hashType
= signatureHashType(signature
)
11837 var hashTypeMod
= hashType
& 0x1f
11838 if (hashTypeMod
=== Transaction
.SIGHASH_NONE
) return true
11839 if (hashTypeMod
=== Transaction
.SIGHASH_SINGLE
) {
11840 // if SIGHASH_SINGLE is set, and nInputs > nOutputs
11841 // some signatures would be invalidated by the addition
11843 return nInputs
<= nOutputs
11849 TransactionBuilder
.prototype.__overMaximumFees = function (bytes
) {
11850 // not all inputs will have .value defined
11851 var incoming
= this.inputs
.reduce(function (a
, x
) { return a
+ (x
.value
>>> 0) }, 0)
11853 // but all outputs do, and if we have any input value
11854 // we can immediately determine if the outputs are too small
11855 var outgoing
= this.tx
.outs
.reduce(function (a
, x
) { return a
+ x
.value
}, 0)
11856 var fee
= incoming
- outgoing
11857 var feeRate
= fee
/ bytes
11859 return feeRate
> this.maximumFeeRate
11862 module
.exports
= TransactionBuilder
11864 },{"./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
){
11865 var typeforce
= require('typeforce')
11867 var UINT31_MAX
= Math
.pow(2, 31) - 1
11868 function UInt31 (value
) {
11869 return typeforce
.UInt32(value
) && value
<= UINT31_MAX
11872 function BIP32Path (value
) {
11873 return typeforce
.String(value
) && value
.match(/^(m\/)?(\d+'?\/)*\d+'?$/)
11875 BIP32Path
.toJSON = function () { return 'BIP32 derivation path' }
11877 var SATOSHI_MAX
= 21 * 1e14
11878 function Satoshi (value
) {
11879 return typeforce
.UInt53(value
) && value
<= SATOSHI_MAX
11882 // external dependent types
11883 var BigInt
= typeforce
.quacksLike('BigInteger')
11884 var ECPoint
= typeforce
.quacksLike('Point')
11886 // exposed, external API
11887 var ECSignature
= typeforce
.compile({ r: BigInt
, s: BigInt
})
11888 var Network
= typeforce
.compile({
11889 messagePrefix: typeforce
.oneOf(typeforce
.Buffer
, typeforce
.String
),
11891 public: typeforce
.UInt32
,
11892 private: typeforce
.UInt32
11894 pubKeyHash: typeforce
.UInt8
,
11895 scriptHash: typeforce
.UInt8
,
11896 wif: typeforce
.UInt8
11899 // extend typeforce types with ours
11902 BIP32Path: BIP32Path
,
11903 Buffer256bit: typeforce
.BufferN(32),
11905 ECSignature: ECSignature
,
11906 Hash160bit: typeforce
.BufferN(20),
11907 Hash256bit: typeforce
.BufferN(32),
11913 for (var typeName
in typeforce
) {
11914 types
[typeName
] = typeforce
[typeName
]
11917 module
.exports
= types
11919 },{"typeforce":109}],79:[function(require
,module
,exports
){
11920 var basex
= require('base-x')
11921 var ALPHABET
= '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
11923 module
.exports
= basex(ALPHABET
)
11925 },{"base-x":34}],80:[function(require
,module
,exports
){
11926 (function (Buffer
){
11929 var base58
= require('bs58')
11930 var createHash
= require('create-hash')
11932 // SHA256(SHA256(buffer))
11933 function sha256x2 (buffer
) {
11934 var tmp
= createHash('sha256').update(buffer
).digest()
11935 return createHash('sha256').update(tmp
).digest()
11938 // Encode a buffer as a base58-check encoded string
11939 function encode (payload
) {
11940 var checksum
= sha256x2(payload
)
11942 return base58
.encode(Buffer
.concat([
11945 ], payload
.length
+ 4))
11948 function decodeRaw (buffer
) {
11949 var payload
= buffer
.slice(0, -4)
11950 var checksum
= buffer
.slice(-4)
11951 var newChecksum
= sha256x2(payload
)
11953 if (checksum
[0] ^ newChecksum
[0] |
11954 checksum
[1] ^ newChecksum
[1] |
11955 checksum
[2] ^ newChecksum
[2] |
11956 checksum
[3] ^ newChecksum
[3]) return
11961 // Decode a base58-check encoded string to a buffer, no result if checksum is wrong
11962 function decodeUnsafe (string
) {
11963 var buffer
= base58
.decodeUnsafe(string
)
11964 if (!buffer
) return
11966 return decodeRaw(buffer
)
11969 function decode (string
) {
11970 var buffer
= base58
.decode(string
)
11971 var payload
= decodeRaw(buffer
)
11972 if (!payload
) throw new Error('Invalid checksum')
11979 decodeUnsafe: decodeUnsafe
11982 }).call(this,require("buffer").Buffer
)
11983 },{"bs58":79,"buffer":4,"create-hash":82}],81:[function(require
,module
,exports
){
11984 var Buffer
= require('safe-buffer').Buffer
11985 var Transform
= require('stream').Transform
11986 var StringDecoder
= require('string_decoder').StringDecoder
11987 var inherits
= require('inherits')
11989 function CipherBase (hashMode
) {
11990 Transform
.call(this)
11991 this.hashMode
= typeof hashMode
=== 'string'
11992 if (this.hashMode
) {
11993 this[hashMode
] = this._finalOrDigest
11995 this.final
= this._finalOrDigest
11998 this.__final
= this._final
12001 this._decoder
= null
12002 this._encoding
= null
12004 inherits(CipherBase
, Transform
)
12006 CipherBase
.prototype.update = function (data
, inputEnc
, outputEnc
) {
12007 if (typeof data
=== 'string') {
12008 data
= Buffer
.from(data
, inputEnc
)
12011 var outData
= this._update(data
)
12012 if (this.hashMode
) return this
12015 outData
= this._toString(outData
, outputEnc
)
12021 CipherBase
.prototype.setAutoPadding = function () {}
12022 CipherBase
.prototype.getAuthTag = function () {
12023 throw new Error('trying to get auth tag in unsupported state')
12026 CipherBase
.prototype.setAuthTag = function () {
12027 throw new Error('trying to set auth tag in unsupported state')
12030 CipherBase
.prototype.setAAD = function () {
12031 throw new Error('trying to set aad in unsupported state')
12034 CipherBase
.prototype._transform = function (data
, _
, next
) {
12037 if (this.hashMode
) {
12040 this.push(this._update(data
))
12048 CipherBase
.prototype._flush = function (done
) {
12051 this.push(this.__final())
12058 CipherBase
.prototype._finalOrDigest = function (outputEnc
) {
12059 var outData
= this.__final() || Buffer
.alloc(0)
12061 outData
= this._toString(outData
, outputEnc
, true)
12066 CipherBase
.prototype._toString = function (value
, enc
, fin
) {
12067 if (!this._decoder
) {
12068 this._decoder
= new StringDecoder(enc
)
12069 this._encoding
= enc
12072 if (this._encoding
!== enc
) throw new Error('can\'t switch encodings')
12074 var out
= this._decoder
.write(value
)
12076 out
+= this._decoder
.end()
12082 module
.exports
= CipherBase
12084 },{"inherits":93,"safe-buffer":98,"stream":27,"string_decoder":28}],82:[function(require
,module
,exports
){
12085 (function (Buffer
){
12087 var inherits
= require('inherits')
12088 var md5
= require('./md5')
12089 var RIPEMD160
= require('ripemd160')
12090 var sha
= require('sha.js')
12092 var Base
= require('cipher-base')
12094 function HashNoConstructor (hash
) {
12095 Base
.call(this, 'digest')
12101 inherits(HashNoConstructor
, Base
)
12103 HashNoConstructor
.prototype._update = function (data
) {
12104 this.buffers
.push(data
)
12107 HashNoConstructor
.prototype._final = function () {
12108 var buf
= Buffer
.concat(this.buffers
)
12109 var r
= this._hash(buf
)
12110 this.buffers
= null
12115 function Hash (hash
) {
12116 Base
.call(this, 'digest')
12121 inherits(Hash
, Base
)
12123 Hash
.prototype._update = function (data
) {
12124 this._hash
.update(data
)
12127 Hash
.prototype._final = function () {
12128 return this._hash
.digest()
12131 module
.exports
= function createHash (alg
) {
12132 alg
= alg
.toLowerCase()
12133 if (alg
=== 'md5') return new HashNoConstructor(md5
)
12134 if (alg
=== 'rmd160' || alg
=== 'ripemd160') return new Hash(new RIPEMD160())
12136 return new Hash(sha(alg
))
12139 }).call(this,require("buffer").Buffer
)
12140 },{"./md5":84,"buffer":4,"cipher-base":81,"inherits":93,"ripemd160":97,"sha.js":100}],83:[function(require
,module
,exports
){
12141 (function (Buffer
){
12144 var zeroBuffer
= new Buffer(intSize
)
12150 function toArray (buf
) {
12151 if ((buf
.length
% intSize
) !== 0) {
12152 var len
= buf
.length
+ (intSize
- (buf
.length
% intSize
))
12153 buf
= Buffer
.concat([buf
, zeroBuffer
], len
)
12156 var arr
= new Array(buf
.length
>>> 2)
12157 for (var i
= 0, j
= 0; i
< buf
.length
; i
+= intSize
, j
++) {
12158 arr
[j
] = buf
.readInt32LE(i
)
12164 module
.exports
= function hash (buf
, fn
) {
12165 var arr
= fn(toArray(buf
), buf
.length
* charSize
)
12166 buf
= new Buffer(hashSize
)
12167 for (var i
= 0; i
< arr
.length
; i
++) {
12168 buf
.writeInt32LE(arr
[i
], i
<< 2, true)
12173 }).call(this,require("buffer").Buffer
)
12174 },{"buffer":4}],84:[function(require
,module
,exports
){
12177 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
12178 * Digest Algorithm, as defined in RFC 1321.
12179 * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
12180 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
12181 * Distributed under the BSD License
12182 * See http://pajhome.org.uk/crypt/md5 for more info.
12185 var makeHash
= require('./make-hash')
12188 * Calculate the MD5 of an array of little-endian words, and a bit length
12190 function core_md5 (x
, len
) {
12191 /* append padding */
12192 x
[len
>> 5] |= 0x80 << ((len
) % 32)
12193 x
[(((len
+ 64) >>> 9) << 4) + 14] = len
12197 var c
= -1732584194
12200 for (var i
= 0; i
< x
.length
; i
+= 16) {
12206 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 0], 7, -680876936)
12207 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 1], 12, -389564586)
12208 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 2], 17, 606105819)
12209 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 3], 22, -1044525330)
12210 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 4], 7, -176418897)
12211 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 5], 12, 1200080426)
12212 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 6], 17, -1473231341)
12213 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 7], 22, -45705983)
12214 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 8], 7, 1770035416)
12215 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 9], 12, -1958414417)
12216 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 10], 17, -42063)
12217 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 11], 22, -1990404162)
12218 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 12], 7, 1804603682)
12219 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 13], 12, -40341101)
12220 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 14], 17, -1502002290)
12221 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 15], 22, 1236535329)
12223 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 1], 5, -165796510)
12224 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 6], 9, -1069501632)
12225 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 11], 14, 643717713)
12226 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 0], 20, -373897302)
12227 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 5], 5, -701558691)
12228 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 10], 9, 38016083)
12229 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 15], 14, -660478335)
12230 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 4], 20, -405537848)
12231 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 9], 5, 568446438)
12232 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 14], 9, -1019803690)
12233 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 3], 14, -187363961)
12234 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 8], 20, 1163531501)
12235 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 13], 5, -1444681467)
12236 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 2], 9, -51403784)
12237 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 7], 14, 1735328473)
12238 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 12], 20, -1926607734)
12240 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 5], 4, -378558)
12241 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 8], 11, -2022574463)
12242 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 11], 16, 1839030562)
12243 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 14], 23, -35309556)
12244 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 1], 4, -1530992060)
12245 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 4], 11, 1272893353)
12246 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 7], 16, -155497632)
12247 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 10], 23, -1094730640)
12248 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 13], 4, 681279174)
12249 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 0], 11, -358537222)
12250 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 3], 16, -722521979)
12251 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 6], 23, 76029189)
12252 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 9], 4, -640364487)
12253 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 12], 11, -421815835)
12254 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 15], 16, 530742520)
12255 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 2], 23, -995338651)
12257 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 0], 6, -198630844)
12258 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 7], 10, 1126891415)
12259 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 14], 15, -1416354905)
12260 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 5], 21, -57434055)
12261 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 12], 6, 1700485571)
12262 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 3], 10, -1894986606)
12263 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 10], 15, -1051523)
12264 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 1], 21, -2054922799)
12265 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 8], 6, 1873313359)
12266 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 15], 10, -30611744)
12267 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 6], 15, -1560198380)
12268 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 13], 21, 1309151649)
12269 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 4], 6, -145523070)
12270 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 11], 10, -1120210379)
12271 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 2], 15, 718787259)
12272 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 9], 21, -343485551)
12274 a
= safe_add(a
, olda
)
12275 b
= safe_add(b
, oldb
)
12276 c
= safe_add(c
, oldc
)
12277 d
= safe_add(d
, oldd
)
12280 return [a
, b
, c
, d
]
12284 * These functions implement the four basic operations the algorithm uses.
12286 function md5_cmn (q
, a
, b
, x
, s
, t
) {
12287 return safe_add(bit_rol(safe_add(safe_add(a
, q
), safe_add(x
, t
)), s
), b
)
12290 function md5_ff (a
, b
, c
, d
, x
, s
, t
) {
12291 return md5_cmn((b
& c
) | ((~b
) & d
), a
, b
, x
, s
, t
)
12294 function md5_gg (a
, b
, c
, d
, x
, s
, t
) {
12295 return md5_cmn((b
& d
) | (c
& (~d
)), a
, b
, x
, s
, t
)
12298 function md5_hh (a
, b
, c
, d
, x
, s
, t
) {
12299 return md5_cmn(b
^ c
^ d
, a
, b
, x
, s
, t
)
12302 function md5_ii (a
, b
, c
, d
, x
, s
, t
) {
12303 return md5_cmn(c
^ (b
| (~d
)), a
, b
, x
, s
, t
)
12307 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
12308 * to work around bugs in some JS interpreters.
12310 function safe_add (x
, y
) {
12311 var lsw
= (x
& 0xFFFF) + (y
& 0xFFFF)
12312 var msw
= (x
>> 16) + (y
>> 16) + (lsw
>> 16)
12313 return (msw
<< 16) | (lsw
& 0xFFFF)
12317 * Bitwise rotate a 32-bit number to the left.
12319 function bit_rol (num
, cnt
) {
12320 return (num
<< cnt
) | (num
>>> (32 - cnt
))
12323 module
.exports
= function md5 (buf
) {
12324 return makeHash(buf
, core_md5
)
12327 },{"./make-hash":83}],85:[function(require
,module
,exports
){
12329 var inherits
= require('inherits')
12330 var Legacy
= require('./legacy')
12331 var Base
= require('cipher-base')
12332 var Buffer
= require('safe-buffer').Buffer
12333 var md5
= require('create-hash/md5')
12334 var RIPEMD160
= require('ripemd160')
12336 var sha
= require('sha.js')
12338 var ZEROS
= Buffer
.alloc(128)
12340 function Hmac (alg
, key
) {
12341 Base
.call(this, 'digest')
12342 if (typeof key
=== 'string') {
12343 key
= Buffer
.from(key
)
12346 var blocksize
= (alg
=== 'sha512' || alg
=== 'sha384') ? 128 : 64
12350 if (key
.length
> blocksize
) {
12351 var hash
= alg
=== 'rmd160' ? new RIPEMD160() : sha(alg
)
12352 key
= hash
.update(key
).digest()
12353 } else if (key
.length
< blocksize
) {
12354 key
= Buffer
.concat([key
, ZEROS
], blocksize
)
12357 var ipad
= this._ipad
= Buffer
.allocUnsafe(blocksize
)
12358 var opad
= this._opad
= Buffer
.allocUnsafe(blocksize
)
12360 for (var i
= 0; i
< blocksize
; i
++) {
12361 ipad
[i
] = key
[i
] ^ 0x36
12362 opad
[i
] = key
[i
] ^ 0x5C
12364 this._hash
= alg
=== 'rmd160' ? new RIPEMD160() : sha(alg
)
12365 this._hash
.update(ipad
)
12368 inherits(Hmac
, Base
)
12370 Hmac
.prototype._update = function (data
) {
12371 this._hash
.update(data
)
12374 Hmac
.prototype._final = function () {
12375 var h
= this._hash
.digest()
12376 var hash
= this._alg
=== 'rmd160' ? new RIPEMD160() : sha(this._alg
)
12377 return hash
.update(this._opad
).update(h
).digest()
12380 module
.exports
= function createHmac (alg
, key
) {
12381 alg
= alg
.toLowerCase()
12382 if (alg
=== 'rmd160' || alg
=== 'ripemd160') {
12383 return new Hmac('rmd160', key
)
12385 if (alg
=== 'md5') {
12386 return new Legacy(md5
, key
)
12388 return new Hmac(alg
, key
)
12391 },{"./legacy":86,"cipher-base":81,"create-hash/md5":84,"inherits":93,"ripemd160":97,"safe-buffer":98,"sha.js":100}],86:[function(require
,module
,exports
){
12393 var inherits
= require('inherits')
12394 var Buffer
= require('safe-buffer').Buffer
12396 var Base
= require('cipher-base')
12398 var ZEROS
= Buffer
.alloc(128)
12401 function Hmac (alg
, key
) {
12402 Base
.call(this, 'digest')
12403 if (typeof key
=== 'string') {
12404 key
= Buffer
.from(key
)
12410 if (key
.length
> blocksize
) {
12412 } else if (key
.length
< blocksize
) {
12413 key
= Buffer
.concat([key
, ZEROS
], blocksize
)
12416 var ipad
= this._ipad
= Buffer
.allocUnsafe(blocksize
)
12417 var opad
= this._opad
= Buffer
.allocUnsafe(blocksize
)
12419 for (var i
= 0; i
< blocksize
; i
++) {
12420 ipad
[i
] = key
[i
] ^ 0x36
12421 opad
[i
] = key
[i
] ^ 0x5C
12424 this._hash
= [ipad
]
12427 inherits(Hmac
, Base
)
12429 Hmac
.prototype._update = function (data
) {
12430 this._hash
.push(data
)
12433 Hmac
.prototype._final = function () {
12434 var h
= this._alg(Buffer
.concat(this._hash
))
12435 return this._alg(Buffer
.concat([this._opad
, h
]))
12437 module
.exports
= Hmac
12439 },{"cipher-base":81,"inherits":93,"safe-buffer":98}],87:[function(require
,module
,exports
){
12440 var assert
= require('assert')
12441 var BigInteger
= require('bigi')
12443 var Point
= require('./point')
12445 function Curve (p
, a
, b
, Gx
, Gy
, n
, h
) {
12449 this.G
= Point
.fromAffine(this, Gx
, Gy
)
12453 this.infinity
= new Point(this, null, null, BigInteger
.ZERO
)
12456 this.pOverFour
= p
.add(BigInteger
.ONE
).shiftRight(2)
12458 // determine size of p in bytes
12459 this.pLength
= Math
.floor((this.p
.bitLength() + 7) / 8)
12462 Curve
.prototype.pointFromX = function (isOdd
, x
) {
12463 var alpha
= x
.pow(3).add(this.a
.multiply(x
)).add(this.b
).mod(this.p
)
12464 var beta
= alpha
.modPow(this.pOverFour
, this.p
) // XXX: not compatible with all curves
12467 if (beta
.isEven() ^ !isOdd
) {
12468 y
= this.p
.subtract(y
) // -y % p
12471 return Point
.fromAffine(this, x
, y
)
12474 Curve
.prototype.isInfinity = function (Q
) {
12475 if (Q
=== this.infinity
) return true
12477 return Q
.z
.signum() === 0 && Q
.y
.signum() !== 0
12480 Curve
.prototype.isOnCurve = function (Q
) {
12481 if (this.isInfinity(Q
)) return true
12489 // Check that xQ and yQ are integers in the interval [0, p - 1]
12490 if (x
.signum() < 0 || x
.compareTo(p
) >= 0) return false
12491 if (y
.signum() < 0 || y
.compareTo(p
) >= 0) return false
12493 // and check that y^2 = x^3 + ax + b (mod p)
12494 var lhs
= y
.square().mod(p
)
12495 var rhs
= x
.pow(3).add(a
.multiply(x
)).add(b
).mod(p
)
12496 return lhs
.equals(rhs
)
12500 * Validate an elliptic curve point.
12502 * See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive
12504 Curve
.prototype.validate = function (Q
) {
12506 assert(!this.isInfinity(Q
), 'Point is at infinity')
12507 assert(this.isOnCurve(Q
), 'Point is not on the curve')
12509 // Check nQ = O (where Q is a scalar multiple of G)
12510 var nQ
= Q
.multiply(this.n
)
12511 assert(this.isInfinity(nQ
), 'Point is not a scalar multiple of G')
12516 module
.exports
= Curve
12518 },{"./point":91,"assert":1,"bigi":37}],88:[function(require
,module
,exports
){
12521 "p": "fffffffdffffffffffffffffffffffff",
12522 "a": "fffffffdfffffffffffffffffffffffc",
12523 "b": "e87579c11079f43dd824993c2cee5ed3",
12524 "n": "fffffffe0000000075a30d1b9038a115",
12526 "Gx": "161ff7528b899b2d0c28607ca52c5b86",
12527 "Gy": "cf5ac8395bafeb13c02da292dded7a83"
12530 "p": "fffffffffffffffffffffffffffffffeffffac73",
12533 "n": "0100000000000000000001b8fa16dfab9aca16b6b3",
12535 "Gx": "3b4c382ce37aa192a4019e763036f4f5dd4d7ebb",
12536 "Gy": "938cf935318fdced6bc28286531733c3f03c4fee"
12539 "p": "ffffffffffffffffffffffffffffffff7fffffff",
12540 "a": "ffffffffffffffffffffffffffffffff7ffffffc",
12541 "b": "1c97befc54bd7a8b65acf89f81d4d4adc565fa45",
12542 "n": "0100000000000000000001f4c8f927aed3ca752257",
12544 "Gx": "4a96b5688ef573284664698968c38bb913cbfc82",
12545 "Gy": "23a628553168947d59dcc912042351377ac5fb32"
12548 "p": "fffffffffffffffffffffffffffffffffffffffeffffee37",
12551 "n": "fffffffffffffffffffffffe26f2fc170f69466a74defd8d",
12553 "Gx": "db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d",
12554 "Gy": "9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d"
12557 "p": "fffffffffffffffffffffffffffffffeffffffffffffffff",
12558 "a": "fffffffffffffffffffffffffffffffefffffffffffffffc",
12559 "b": "64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
12560 "n": "ffffffffffffffffffffffff99def836146bc9b1b4d22831",
12562 "Gx": "188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
12563 "Gy": "07192b95ffc8da78631011ed6b24cdd573f977a11e794811"
12566 "p": "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
12569 "n": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
12571 "Gx": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
12572 "Gy": "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
12575 "p": "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
12576 "a": "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
12577 "b": "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
12578 "n": "ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
12580 "Gx": "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
12581 "Gy": "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"
12585 },{}],89:[function(require
,module
,exports
){
12586 var Point
= require('./point')
12587 var Curve
= require('./curve')
12589 var getCurveByName
= require('./names')
12594 getCurveByName: getCurveByName
12597 },{"./curve":87,"./names":90,"./point":91}],90:[function(require
,module
,exports
){
12598 var BigInteger
= require('bigi')
12600 var curves
= require('./curves.json')
12601 var Curve
= require('./curve')
12603 function getCurveByName (name
) {
12604 var curve
= curves
[name
]
12605 if (!curve
) return null
12607 var p
= new BigInteger(curve
.p
, 16)
12608 var a
= new BigInteger(curve
.a
, 16)
12609 var b
= new BigInteger(curve
.b
, 16)
12610 var n
= new BigInteger(curve
.n
, 16)
12611 var h
= new BigInteger(curve
.h
, 16)
12612 var Gx
= new BigInteger(curve
.Gx
, 16)
12613 var Gy
= new BigInteger(curve
.Gy
, 16)
12615 return new Curve(p
, a
, b
, Gx
, Gy
, n
, h
)
12618 module
.exports
= getCurveByName
12620 },{"./curve":87,"./curves.json":88,"bigi":37}],91:[function(require
,module
,exports
){
12621 (function (Buffer
){
12622 var assert
= require('assert')
12623 var BigInteger
= require('bigi')
12625 var THREE
= BigInteger
.valueOf(3)
12627 function Point (curve
, x
, y
, z
) {
12628 assert
.notStrictEqual(z
, undefined, 'Missing Z coordinate')
12636 this.compressed
= true
12639 Object
.defineProperty(Point
.prototype, 'zInv', {
12641 if (this._zInv
=== null) {
12642 this._zInv
= this.z
.modInverse(this.curve
.p
)
12649 Object
.defineProperty(Point
.prototype, 'affineX', {
12651 return this.x
.multiply(this.zInv
).mod(this.curve
.p
)
12655 Object
.defineProperty(Point
.prototype, 'affineY', {
12657 return this.y
.multiply(this.zInv
).mod(this.curve
.p
)
12661 Point
.fromAffine = function (curve
, x
, y
) {
12662 return new Point(curve
, x
, y
, BigInteger
.ONE
)
12665 Point
.prototype.equals = function (other
) {
12666 if (other
=== this) return true
12667 if (this.curve
.isInfinity(this)) return this.curve
.isInfinity(other
)
12668 if (this.curve
.isInfinity(other
)) return this.curve
.isInfinity(this)
12670 // u = Y2 * Z1 - Y1 * Z2
12671 var u
= other
.y
.multiply(this.z
).subtract(this.y
.multiply(other
.z
)).mod(this.curve
.p
)
12673 if (u
.signum() !== 0) return false
12675 // v = X2 * Z1 - X1 * Z2
12676 var v
= other
.x
.multiply(this.z
).subtract(this.x
.multiply(other
.z
)).mod(this.curve
.p
)
12678 return v
.signum() === 0
12681 Point
.prototype.negate = function () {
12682 var y
= this.curve
.p
.subtract(this.y
)
12684 return new Point(this.curve
, this.x
, y
, this.z
)
12687 Point
.prototype.add = function (b
) {
12688 if (this.curve
.isInfinity(this)) return b
12689 if (this.curve
.isInfinity(b
)) return this
12696 // u = Y2 * Z1 - Y1 * Z2
12697 var u
= y2
.multiply(this.z
).subtract(y1
.multiply(b
.z
)).mod(this.curve
.p
)
12698 // v = X2 * Z1 - X1 * Z2
12699 var v
= x2
.multiply(this.z
).subtract(x1
.multiply(b
.z
)).mod(this.curve
.p
)
12701 if (v
.signum() === 0) {
12702 if (u
.signum() === 0) {
12703 return this.twice() // this == b, so double
12706 return this.curve
.infinity
// this = -b, so infinity
12709 var v2
= v
.square()
12710 var v3
= v2
.multiply(v
)
12711 var x1v2
= x1
.multiply(v2
)
12712 var zu2
= u
.square().multiply(this.z
)
12714 // x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)
12715 var x3
= zu2
.subtract(x1v2
.shiftLeft(1)).multiply(b
.z
).subtract(v3
).multiply(v
).mod(this.curve
.p
)
12716 // y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
12717 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
)
12718 // z3 = v^3 * z1 * z2
12719 var z3
= v3
.multiply(this.z
).multiply(b
.z
).mod(this.curve
.p
)
12721 return new Point(this.curve
, x3
, y3
, z3
)
12724 Point
.prototype.twice = function () {
12725 if (this.curve
.isInfinity(this)) return this
12726 if (this.y
.signum() === 0) return this.curve
.infinity
12731 var y1z1
= y1
.multiply(this.z
).mod(this.curve
.p
)
12732 var y1sqz1
= y1z1
.multiply(y1
).mod(this.curve
.p
)
12733 var a
= this.curve
.a
12735 // w = 3 * x1^2 + a * z1^2
12736 var w
= x1
.square().multiply(THREE
)
12738 if (a
.signum() !== 0) {
12739 w
= w
.add(this.z
.square().multiply(a
))
12742 w
= w
.mod(this.curve
.p
)
12743 // x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
12744 var x3
= w
.square().subtract(x1
.shiftLeft(3).multiply(y1sqz1
)).shiftLeft(1).multiply(y1z1
).mod(this.curve
.p
)
12745 // y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
12746 var y3
= w
.multiply(THREE
).multiply(x1
).subtract(y1sqz1
.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1
).subtract(w
.pow(3)).mod(this.curve
.p
)
12747 // z3 = 8 * (y1 * z1)^3
12748 var z3
= y1z1
.pow(3).shiftLeft(3).mod(this.curve
.p
)
12750 return new Point(this.curve
, x3
, y3
, z3
)
12753 // Simple NAF (Non-Adjacent Form) multiplication algorithm
12754 // TODO: modularize the multiplication algorithm
12755 Point
.prototype.multiply = function (k
) {
12756 if (this.curve
.isInfinity(this)) return this
12757 if (k
.signum() === 0) return this.curve
.infinity
12760 var h
= e
.multiply(THREE
)
12762 var neg
= this.negate()
12765 for (var i
= h
.bitLength() - 2; i
> 0; --i
) {
12766 var hBit
= h
.testBit(i
)
12767 var eBit
= e
.testBit(i
)
12771 if (hBit
!== eBit
) {
12772 R
= R
.add(hBit
? this : neg
)
12779 // Compute this*j + x*k (simultaneous multiplication)
12780 Point
.prototype.multiplyTwo = function (j
, x
, k
) {
12781 var i
= Math
.max(j
.bitLength(), k
.bitLength()) - 1
12782 var R
= this.curve
.infinity
12783 var both
= this.add(x
)
12786 var jBit
= j
.testBit(i
)
12787 var kBit
= k
.testBit(i
)
12806 Point
.prototype.getEncoded = function (compressed
) {
12807 if (compressed
== null) compressed
= this.compressed
12808 if (this.curve
.isInfinity(this)) return new Buffer('00', 'hex') // Infinity point encoded is simply '00'
12810 var x
= this.affineX
12811 var y
= this.affineY
12812 var byteLength
= this.curve
.pLength
12817 buffer
= new Buffer(1 + byteLength
)
12818 buffer
.writeUInt8(y
.isEven() ? 0x02 : 0x03, 0)
12822 buffer
= new Buffer(1 + byteLength
+ byteLength
)
12823 buffer
.writeUInt8(0x04, 0)
12825 y
.toBuffer(byteLength
).copy(buffer
, 1 + byteLength
)
12828 x
.toBuffer(byteLength
).copy(buffer
, 1)
12833 Point
.decodeFrom = function (curve
, buffer
) {
12834 var type
= buffer
.readUInt8(0)
12835 var compressed
= (type
!== 4)
12837 var byteLength
= Math
.floor((curve
.p
.bitLength() + 7) / 8)
12838 var x
= BigInteger
.fromBuffer(buffer
.slice(1, 1 + byteLength
))
12842 assert
.equal(buffer
.length
, byteLength
+ 1, 'Invalid sequence length')
12843 assert(type
=== 0x02 || type
=== 0x03, 'Invalid sequence tag')
12845 var isOdd
= (type
=== 0x03)
12846 Q
= curve
.pointFromX(isOdd
, x
)
12848 assert
.equal(buffer
.length
, 1 + byteLength
+ byteLength
, 'Invalid sequence length')
12850 var y
= BigInteger
.fromBuffer(buffer
.slice(1 + byteLength
))
12851 Q
= Point
.fromAffine(curve
, x
, y
)
12854 Q
.compressed
= compressed
12858 Point
.prototype.toString = function () {
12859 if (this.curve
.isInfinity(this)) return '(INFINITY)'
12861 return '(' + this.affineX
.toString() + ',' + this.affineY
.toString() + ')'
12864 module
.exports
= Point
12866 }).call(this,require("buffer").Buffer
)
12867 },{"assert":1,"bigi":37,"buffer":4}],92:[function(require
,module
,exports
){
12868 (function (Buffer
){
12870 var Transform
= require('stream').Transform
12871 var inherits
= require('inherits')
12873 function HashBase (blockSize
) {
12874 Transform
.call(this)
12876 this._block
= new Buffer(blockSize
)
12877 this._blockSize
= blockSize
12878 this._blockOffset
= 0
12879 this._length
= [0, 0, 0, 0]
12881 this._finalized
= false
12884 inherits(HashBase
, Transform
)
12886 HashBase
.prototype._transform = function (chunk
, encoding
, callback
) {
12889 if (encoding
!== 'buffer') chunk
= new Buffer(chunk
, encoding
)
12898 HashBase
.prototype._flush = function (callback
) {
12901 this.push(this._digest())
12909 HashBase
.prototype.update = function (data
, encoding
) {
12910 if (!Buffer
.isBuffer(data
) && typeof data
!== 'string') throw new TypeError('Data must be a string or a buffer')
12911 if (this._finalized
) throw new Error('Digest already called')
12912 if (!Buffer
.isBuffer(data
)) data
= new Buffer(data
, encoding
|| 'binary')
12915 var block
= this._block
12917 while (this._blockOffset
+ data
.length
- offset
>= this._blockSize
) {
12918 for (var i
= this._blockOffset
; i
< this._blockSize
;) block
[i
++] = data
[offset
++]
12920 this._blockOffset
= 0
12922 while (offset
< data
.length
) block
[this._blockOffset
++] = data
[offset
++]
12925 for (var j
= 0, carry
= data
.length
* 8; carry
> 0; ++j
) {
12926 this._length
[j
] += carry
12927 carry
= (this._length
[j
] / 0x0100000000) | 0
12928 if (carry
> 0) this._length
[j
] -= 0x0100000000 * carry
12934 HashBase
.prototype._update = function (data
) {
12935 throw new Error('_update is not implemented')
12938 HashBase
.prototype.digest = function (encoding
) {
12939 if (this._finalized
) throw new Error('Digest already called')
12940 this._finalized
= true
12942 var digest
= this._digest()
12943 if (encoding
!== undefined) digest
= digest
.toString(encoding
)
12947 HashBase
.prototype._digest = function () {
12948 throw new Error('_digest is not implemented')
12951 module
.exports
= HashBase
12953 }).call(this,require("buffer").Buffer
)
12954 },{"buffer":4,"inherits":93,"stream":27}],93:[function(require
,module
,exports
){
12955 arguments
[4][8][0].apply(exports
,arguments
)
12956 },{"dup":8}],94:[function(require
,module
,exports
){
12957 (function (Buffer
){
12958 // constant-space merkle root calculation algorithm
12959 module
.exports
= function fastRoot (values
, digestFn
) {
12960 if (!Array
.isArray(values
)) throw TypeError('Expected values Array')
12961 if (typeof digestFn
!== 'function') throw TypeError('Expected digest Function')
12963 var length
= values
.length
12964 var results
= values
.concat()
12966 while (length
> 1) {
12969 for (var i
= 0; i
< length
; i
+= 2, ++j
) {
12970 var left
= results
[i
]
12971 var right
= i
+ 1 === length
? left : results
[i
+ 1]
12972 var data
= Buffer
.concat([left
, right
])
12974 results
[j
] = digestFn(data
)
12983 }).call(this,require("buffer").Buffer
)
12984 },{"buffer":4}],95:[function(require
,module
,exports
){
12985 var OPS
= require('bitcoin-ops')
12987 function encodingLength (i
) {
12988 return i
< OPS
.OP_PUSHDATA1
? 1
12994 function encode (buffer
, number
, offset
) {
12995 var size
= encodingLength(number
)
12999 buffer
.writeUInt8(number
, offset
)
13002 } else if (size
=== 2) {
13003 buffer
.writeUInt8(OPS
.OP_PUSHDATA1
, offset
)
13004 buffer
.writeUInt8(number
, offset
+ 1)
13007 } else if (size
=== 3) {
13008 buffer
.writeUInt8(OPS
.OP_PUSHDATA2
, offset
)
13009 buffer
.writeUInt16LE(number
, offset
+ 1)
13013 buffer
.writeUInt8(OPS
.OP_PUSHDATA4
, offset
)
13014 buffer
.writeUInt32LE(number
, offset
+ 1)
13020 function decode (buffer
, offset
) {
13021 var opcode
= buffer
.readUInt8(offset
)
13025 if (opcode
< OPS
.OP_PUSHDATA1
) {
13030 } else if (opcode
=== OPS
.OP_PUSHDATA1
) {
13031 if (offset
+ 2 > buffer
.length
) return null
13032 number
= buffer
.readUInt8(offset
+ 1)
13036 } else if (opcode
=== OPS
.OP_PUSHDATA2
) {
13037 if (offset
+ 3 > buffer
.length
) return null
13038 number
= buffer
.readUInt16LE(offset
+ 1)
13043 if (offset
+ 5 > buffer
.length
) return null
13044 if (opcode
!== OPS
.OP_PUSHDATA4
) throw new Error('Unexpected opcode')
13046 number
= buffer
.readUInt32LE(offset
+ 1)
13058 encodingLength: encodingLength
,
13063 },{"bitcoin-ops":40}],96:[function(require
,module
,exports
){
13064 (function (process
,global
){
13067 function oldBrowser () {
13068 throw new Error('secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11')
13071 var Buffer
= require('safe-buffer').Buffer
13072 var crypto
= global
.crypto
|| global
.msCrypto
13074 if (crypto
&& crypto
.getRandomValues
) {
13075 module
.exports
= randomBytes
13077 module
.exports
= oldBrowser
13080 function randomBytes (size
, cb
) {
13081 // phantomjs needs to throw
13082 if (size
> 65536) throw new Error('requested too many random bytes')
13083 // in case browserify isn't using the Uint8Array version
13084 var rawBytes
= new global
.Uint8Array(size
)
13086 // This will not work in older browsers.
13087 // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
13088 if (size
> 0) { // getRandomValues fails on IE if size == 0
13089 crypto
.getRandomValues(rawBytes
)
13092 // XXX: phantomjs doesn't like a buffer being passed here
13093 var bytes
= Buffer
.from(rawBytes
.buffer
)
13095 if (typeof cb
=== 'function') {
13096 return process
.nextTick(function () {
13104 }).call(this,require('_process'),typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
13105 },{"_process":12,"safe-buffer":98}],97:[function(require
,module
,exports
){
13106 (function (Buffer
){
13108 var inherits
= require('inherits')
13109 var HashBase
= require('hash-base')
13111 function RIPEMD160 () {
13112 HashBase
.call(this, 64)
13115 this._a
= 0x67452301
13116 this._b
= 0xefcdab89
13117 this._c
= 0x98badcfe
13118 this._d
= 0x10325476
13119 this._e
= 0xc3d2e1f0
13122 inherits(RIPEMD160
, HashBase
)
13124 RIPEMD160
.prototype._update = function () {
13125 var m
= new Array(16)
13126 for (var i
= 0; i
< 16; ++i
) m
[i
] = this._block
.readInt32LE(i
* 4)
13134 // Mj = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
13136 // Sj = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8
13137 al
= fn1(al
, bl
, cl
, dl
, el
, m
[0], 0x00000000, 11); cl
= rotl(cl
, 10)
13138 el
= fn1(el
, al
, bl
, cl
, dl
, m
[1], 0x00000000, 14); bl
= rotl(bl
, 10)
13139 dl
= fn1(dl
, el
, al
, bl
, cl
, m
[2], 0x00000000, 15); al
= rotl(al
, 10)
13140 cl
= fn1(cl
, dl
, el
, al
, bl
, m
[3], 0x00000000, 12); el
= rotl(el
, 10)
13141 bl
= fn1(bl
, cl
, dl
, el
, al
, m
[4], 0x00000000, 5); dl
= rotl(dl
, 10)
13142 al
= fn1(al
, bl
, cl
, dl
, el
, m
[5], 0x00000000, 8); cl
= rotl(cl
, 10)
13143 el
= fn1(el
, al
, bl
, cl
, dl
, m
[6], 0x00000000, 7); bl
= rotl(bl
, 10)
13144 dl
= fn1(dl
, el
, al
, bl
, cl
, m
[7], 0x00000000, 9); al
= rotl(al
, 10)
13145 cl
= fn1(cl
, dl
, el
, al
, bl
, m
[8], 0x00000000, 11); el
= rotl(el
, 10)
13146 bl
= fn1(bl
, cl
, dl
, el
, al
, m
[9], 0x00000000, 13); dl
= rotl(dl
, 10)
13147 al
= fn1(al
, bl
, cl
, dl
, el
, m
[10], 0x00000000, 14); cl
= rotl(cl
, 10)
13148 el
= fn1(el
, al
, bl
, cl
, dl
, m
[11], 0x00000000, 15); bl
= rotl(bl
, 10)
13149 dl
= fn1(dl
, el
, al
, bl
, cl
, m
[12], 0x00000000, 6); al
= rotl(al
, 10)
13150 cl
= fn1(cl
, dl
, el
, al
, bl
, m
[13], 0x00000000, 7); el
= rotl(el
, 10)
13151 bl
= fn1(bl
, cl
, dl
, el
, al
, m
[14], 0x00000000, 9); dl
= rotl(dl
, 10)
13152 al
= fn1(al
, bl
, cl
, dl
, el
, m
[15], 0x00000000, 8); cl
= rotl(cl
, 10)
13154 // Mj = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8
13156 // Sj = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12
13157 el
= fn2(el
, al
, bl
, cl
, dl
, m
[7], 0x5a827999, 7); bl
= rotl(bl
, 10)
13158 dl
= fn2(dl
, el
, al
, bl
, cl
, m
[4], 0x5a827999, 6); al
= rotl(al
, 10)
13159 cl
= fn2(cl
, dl
, el
, al
, bl
, m
[13], 0x5a827999, 8); el
= rotl(el
, 10)
13160 bl
= fn2(bl
, cl
, dl
, el
, al
, m
[1], 0x5a827999, 13); dl
= rotl(dl
, 10)
13161 al
= fn2(al
, bl
, cl
, dl
, el
, m
[10], 0x5a827999, 11); cl
= rotl(cl
, 10)
13162 el
= fn2(el
, al
, bl
, cl
, dl
, m
[6], 0x5a827999, 9); bl
= rotl(bl
, 10)
13163 dl
= fn2(dl
, el
, al
, bl
, cl
, m
[15], 0x5a827999, 7); al
= rotl(al
, 10)
13164 cl
= fn2(cl
, dl
, el
, al
, bl
, m
[3], 0x5a827999, 15); el
= rotl(el
, 10)
13165 bl
= fn2(bl
, cl
, dl
, el
, al
, m
[12], 0x5a827999, 7); dl
= rotl(dl
, 10)
13166 al
= fn2(al
, bl
, cl
, dl
, el
, m
[0], 0x5a827999, 12); cl
= rotl(cl
, 10)
13167 el
= fn2(el
, al
, bl
, cl
, dl
, m
[9], 0x5a827999, 15); bl
= rotl(bl
, 10)
13168 dl
= fn2(dl
, el
, al
, bl
, cl
, m
[5], 0x5a827999, 9); al
= rotl(al
, 10)
13169 cl
= fn2(cl
, dl
, el
, al
, bl
, m
[2], 0x5a827999, 11); el
= rotl(el
, 10)
13170 bl
= fn2(bl
, cl
, dl
, el
, al
, m
[14], 0x5a827999, 7); dl
= rotl(dl
, 10)
13171 al
= fn2(al
, bl
, cl
, dl
, el
, m
[11], 0x5a827999, 13); cl
= rotl(cl
, 10)
13172 el
= fn2(el
, al
, bl
, cl
, dl
, m
[8], 0x5a827999, 12); bl
= rotl(bl
, 10)
13174 // Mj = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12
13176 // Sj = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5
13177 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[3], 0x6ed9eba1, 11); al
= rotl(al
, 10)
13178 cl
= fn3(cl
, dl
, el
, al
, bl
, m
[10], 0x6ed9eba1, 13); el
= rotl(el
, 10)
13179 bl
= fn3(bl
, cl
, dl
, el
, al
, m
[14], 0x6ed9eba1, 6); dl
= rotl(dl
, 10)
13180 al
= fn3(al
, bl
, cl
, dl
, el
, m
[4], 0x6ed9eba1, 7); cl
= rotl(cl
, 10)
13181 el
= fn3(el
, al
, bl
, cl
, dl
, m
[9], 0x6ed9eba1, 14); bl
= rotl(bl
, 10)
13182 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[15], 0x6ed9eba1, 9); al
= rotl(al
, 10)
13183 cl
= fn3(cl
, dl
, el
, al
, bl
, m
[8], 0x6ed9eba1, 13); el
= rotl(el
, 10)
13184 bl
= fn3(bl
, cl
, dl
, el
, al
, m
[1], 0x6ed9eba1, 15); dl
= rotl(dl
, 10)
13185 al
= fn3(al
, bl
, cl
, dl
, el
, m
[2], 0x6ed9eba1, 14); cl
= rotl(cl
, 10)
13186 el
= fn3(el
, al
, bl
, cl
, dl
, m
[7], 0x6ed9eba1, 8); bl
= rotl(bl
, 10)
13187 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[0], 0x6ed9eba1, 13); al
= rotl(al
, 10)
13188 cl
= fn3(cl
, dl
, el
, al
, bl
, m
[6], 0x6ed9eba1, 6); el
= rotl(el
, 10)
13189 bl
= fn3(bl
, cl
, dl
, el
, al
, m
[13], 0x6ed9eba1, 5); dl
= rotl(dl
, 10)
13190 al
= fn3(al
, bl
, cl
, dl
, el
, m
[11], 0x6ed9eba1, 12); cl
= rotl(cl
, 10)
13191 el
= fn3(el
, al
, bl
, cl
, dl
, m
[5], 0x6ed9eba1, 7); bl
= rotl(bl
, 10)
13192 dl
= fn3(dl
, el
, al
, bl
, cl
, m
[12], 0x6ed9eba1, 5); al
= rotl(al
, 10)
13194 // Mj = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2
13196 // Sj = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12
13197 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[1], 0x8f1bbcdc, 11); el
= rotl(el
, 10)
13198 bl
= fn4(bl
, cl
, dl
, el
, al
, m
[9], 0x8f1bbcdc, 12); dl
= rotl(dl
, 10)
13199 al
= fn4(al
, bl
, cl
, dl
, el
, m
[11], 0x8f1bbcdc, 14); cl
= rotl(cl
, 10)
13200 el
= fn4(el
, al
, bl
, cl
, dl
, m
[10], 0x8f1bbcdc, 15); bl
= rotl(bl
, 10)
13201 dl
= fn4(dl
, el
, al
, bl
, cl
, m
[0], 0x8f1bbcdc, 14); al
= rotl(al
, 10)
13202 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[8], 0x8f1bbcdc, 15); el
= rotl(el
, 10)
13203 bl
= fn4(bl
, cl
, dl
, el
, al
, m
[12], 0x8f1bbcdc, 9); dl
= rotl(dl
, 10)
13204 al
= fn4(al
, bl
, cl
, dl
, el
, m
[4], 0x8f1bbcdc, 8); cl
= rotl(cl
, 10)
13205 el
= fn4(el
, al
, bl
, cl
, dl
, m
[13], 0x8f1bbcdc, 9); bl
= rotl(bl
, 10)
13206 dl
= fn4(dl
, el
, al
, bl
, cl
, m
[3], 0x8f1bbcdc, 14); al
= rotl(al
, 10)
13207 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[7], 0x8f1bbcdc, 5); el
= rotl(el
, 10)
13208 bl
= fn4(bl
, cl
, dl
, el
, al
, m
[15], 0x8f1bbcdc, 6); dl
= rotl(dl
, 10)
13209 al
= fn4(al
, bl
, cl
, dl
, el
, m
[14], 0x8f1bbcdc, 8); cl
= rotl(cl
, 10)
13210 el
= fn4(el
, al
, bl
, cl
, dl
, m
[5], 0x8f1bbcdc, 6); bl
= rotl(bl
, 10)
13211 dl
= fn4(dl
, el
, al
, bl
, cl
, m
[6], 0x8f1bbcdc, 5); al
= rotl(al
, 10)
13212 cl
= fn4(cl
, dl
, el
, al
, bl
, m
[2], 0x8f1bbcdc, 12); el
= rotl(el
, 10)
13214 // Mj = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
13216 // Sj = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
13217 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[4], 0xa953fd4e, 9); dl
= rotl(dl
, 10)
13218 al
= fn5(al
, bl
, cl
, dl
, el
, m
[0], 0xa953fd4e, 15); cl
= rotl(cl
, 10)
13219 el
= fn5(el
, al
, bl
, cl
, dl
, m
[5], 0xa953fd4e, 5); bl
= rotl(bl
, 10)
13220 dl
= fn5(dl
, el
, al
, bl
, cl
, m
[9], 0xa953fd4e, 11); al
= rotl(al
, 10)
13221 cl
= fn5(cl
, dl
, el
, al
, bl
, m
[7], 0xa953fd4e, 6); el
= rotl(el
, 10)
13222 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[12], 0xa953fd4e, 8); dl
= rotl(dl
, 10)
13223 al
= fn5(al
, bl
, cl
, dl
, el
, m
[2], 0xa953fd4e, 13); cl
= rotl(cl
, 10)
13224 el
= fn5(el
, al
, bl
, cl
, dl
, m
[10], 0xa953fd4e, 12); bl
= rotl(bl
, 10)
13225 dl
= fn5(dl
, el
, al
, bl
, cl
, m
[14], 0xa953fd4e, 5); al
= rotl(al
, 10)
13226 cl
= fn5(cl
, dl
, el
, al
, bl
, m
[1], 0xa953fd4e, 12); el
= rotl(el
, 10)
13227 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[3], 0xa953fd4e, 13); dl
= rotl(dl
, 10)
13228 al
= fn5(al
, bl
, cl
, dl
, el
, m
[8], 0xa953fd4e, 14); cl
= rotl(cl
, 10)
13229 el
= fn5(el
, al
, bl
, cl
, dl
, m
[11], 0xa953fd4e, 11); bl
= rotl(bl
, 10)
13230 dl
= fn5(dl
, el
, al
, bl
, cl
, m
[6], 0xa953fd4e, 8); al
= rotl(al
, 10)
13231 cl
= fn5(cl
, dl
, el
, al
, bl
, m
[15], 0xa953fd4e, 5); el
= rotl(el
, 10)
13232 bl
= fn5(bl
, cl
, dl
, el
, al
, m
[13], 0xa953fd4e, 6); dl
= rotl(dl
, 10)
13240 // M'j = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12
13242 // S'j = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6
13243 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[5], 0x50a28be6, 8); cr
= rotl(cr
, 10)
13244 er
= fn5(er
, ar
, br
, cr
, dr
, m
[14], 0x50a28be6, 9); br
= rotl(br
, 10)
13245 dr
= fn5(dr
, er
, ar
, br
, cr
, m
[7], 0x50a28be6, 9); ar
= rotl(ar
, 10)
13246 cr
= fn5(cr
, dr
, er
, ar
, br
, m
[0], 0x50a28be6, 11); er
= rotl(er
, 10)
13247 br
= fn5(br
, cr
, dr
, er
, ar
, m
[9], 0x50a28be6, 13); dr
= rotl(dr
, 10)
13248 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[2], 0x50a28be6, 15); cr
= rotl(cr
, 10)
13249 er
= fn5(er
, ar
, br
, cr
, dr
, m
[11], 0x50a28be6, 15); br
= rotl(br
, 10)
13250 dr
= fn5(dr
, er
, ar
, br
, cr
, m
[4], 0x50a28be6, 5); ar
= rotl(ar
, 10)
13251 cr
= fn5(cr
, dr
, er
, ar
, br
, m
[13], 0x50a28be6, 7); er
= rotl(er
, 10)
13252 br
= fn5(br
, cr
, dr
, er
, ar
, m
[6], 0x50a28be6, 7); dr
= rotl(dr
, 10)
13253 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[15], 0x50a28be6, 8); cr
= rotl(cr
, 10)
13254 er
= fn5(er
, ar
, br
, cr
, dr
, m
[8], 0x50a28be6, 11); br
= rotl(br
, 10)
13255 dr
= fn5(dr
, er
, ar
, br
, cr
, m
[1], 0x50a28be6, 14); ar
= rotl(ar
, 10)
13256 cr
= fn5(cr
, dr
, er
, ar
, br
, m
[10], 0x50a28be6, 14); er
= rotl(er
, 10)
13257 br
= fn5(br
, cr
, dr
, er
, ar
, m
[3], 0x50a28be6, 12); dr
= rotl(dr
, 10)
13258 ar
= fn5(ar
, br
, cr
, dr
, er
, m
[12], 0x50a28be6, 6); cr
= rotl(cr
, 10)
13260 // M'j = 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2
13262 // S'j = 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11
13263 er
= fn4(er
, ar
, br
, cr
, dr
, m
[6], 0x5c4dd124, 9); br
= rotl(br
, 10)
13264 dr
= fn4(dr
, er
, ar
, br
, cr
, m
[11], 0x5c4dd124, 13); ar
= rotl(ar
, 10)
13265 cr
= fn4(cr
, dr
, er
, ar
, br
, m
[3], 0x5c4dd124, 15); er
= rotl(er
, 10)
13266 br
= fn4(br
, cr
, dr
, er
, ar
, m
[7], 0x5c4dd124, 7); dr
= rotl(dr
, 10)
13267 ar
= fn4(ar
, br
, cr
, dr
, er
, m
[0], 0x5c4dd124, 12); cr
= rotl(cr
, 10)
13268 er
= fn4(er
, ar
, br
, cr
, dr
, m
[13], 0x5c4dd124, 8); br
= rotl(br
, 10)
13269 dr
= fn4(dr
, er
, ar
, br
, cr
, m
[5], 0x5c4dd124, 9); ar
= rotl(ar
, 10)
13270 cr
= fn4(cr
, dr
, er
, ar
, br
, m
[10], 0x5c4dd124, 11); er
= rotl(er
, 10)
13271 br
= fn4(br
, cr
, dr
, er
, ar
, m
[14], 0x5c4dd124, 7); dr
= rotl(dr
, 10)
13272 ar
= fn4(ar
, br
, cr
, dr
, er
, m
[15], 0x5c4dd124, 7); cr
= rotl(cr
, 10)
13273 er
= fn4(er
, ar
, br
, cr
, dr
, m
[8], 0x5c4dd124, 12); br
= rotl(br
, 10)
13274 dr
= fn4(dr
, er
, ar
, br
, cr
, m
[12], 0x5c4dd124, 7); ar
= rotl(ar
, 10)
13275 cr
= fn4(cr
, dr
, er
, ar
, br
, m
[4], 0x5c4dd124, 6); er
= rotl(er
, 10)
13276 br
= fn4(br
, cr
, dr
, er
, ar
, m
[9], 0x5c4dd124, 15); dr
= rotl(dr
, 10)
13277 ar
= fn4(ar
, br
, cr
, dr
, er
, m
[1], 0x5c4dd124, 13); cr
= rotl(cr
, 10)
13278 er
= fn4(er
, ar
, br
, cr
, dr
, m
[2], 0x5c4dd124, 11); br
= rotl(br
, 10)
13280 // M'j = 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13
13282 // S'j = 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5
13283 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[15], 0x6d703ef3, 9); ar
= rotl(ar
, 10)
13284 cr
= fn3(cr
, dr
, er
, ar
, br
, m
[5], 0x6d703ef3, 7); er
= rotl(er
, 10)
13285 br
= fn3(br
, cr
, dr
, er
, ar
, m
[1], 0x6d703ef3, 15); dr
= rotl(dr
, 10)
13286 ar
= fn3(ar
, br
, cr
, dr
, er
, m
[3], 0x6d703ef3, 11); cr
= rotl(cr
, 10)
13287 er
= fn3(er
, ar
, br
, cr
, dr
, m
[7], 0x6d703ef3, 8); br
= rotl(br
, 10)
13288 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[14], 0x6d703ef3, 6); ar
= rotl(ar
, 10)
13289 cr
= fn3(cr
, dr
, er
, ar
, br
, m
[6], 0x6d703ef3, 6); er
= rotl(er
, 10)
13290 br
= fn3(br
, cr
, dr
, er
, ar
, m
[9], 0x6d703ef3, 14); dr
= rotl(dr
, 10)
13291 ar
= fn3(ar
, br
, cr
, dr
, er
, m
[11], 0x6d703ef3, 12); cr
= rotl(cr
, 10)
13292 er
= fn3(er
, ar
, br
, cr
, dr
, m
[8], 0x6d703ef3, 13); br
= rotl(br
, 10)
13293 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[12], 0x6d703ef3, 5); ar
= rotl(ar
, 10)
13294 cr
= fn3(cr
, dr
, er
, ar
, br
, m
[2], 0x6d703ef3, 14); er
= rotl(er
, 10)
13295 br
= fn3(br
, cr
, dr
, er
, ar
, m
[10], 0x6d703ef3, 13); dr
= rotl(dr
, 10)
13296 ar
= fn3(ar
, br
, cr
, dr
, er
, m
[0], 0x6d703ef3, 13); cr
= rotl(cr
, 10)
13297 er
= fn3(er
, ar
, br
, cr
, dr
, m
[4], 0x6d703ef3, 7); br
= rotl(br
, 10)
13298 dr
= fn3(dr
, er
, ar
, br
, cr
, m
[13], 0x6d703ef3, 5); ar
= rotl(ar
, 10)
13300 // M'j = 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14
13302 // S'j = 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8
13303 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[8], 0x7a6d76e9, 15); er
= rotl(er
, 10)
13304 br
= fn2(br
, cr
, dr
, er
, ar
, m
[6], 0x7a6d76e9, 5); dr
= rotl(dr
, 10)
13305 ar
= fn2(ar
, br
, cr
, dr
, er
, m
[4], 0x7a6d76e9, 8); cr
= rotl(cr
, 10)
13306 er
= fn2(er
, ar
, br
, cr
, dr
, m
[1], 0x7a6d76e9, 11); br
= rotl(br
, 10)
13307 dr
= fn2(dr
, er
, ar
, br
, cr
, m
[3], 0x7a6d76e9, 14); ar
= rotl(ar
, 10)
13308 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[11], 0x7a6d76e9, 14); er
= rotl(er
, 10)
13309 br
= fn2(br
, cr
, dr
, er
, ar
, m
[15], 0x7a6d76e9, 6); dr
= rotl(dr
, 10)
13310 ar
= fn2(ar
, br
, cr
, dr
, er
, m
[0], 0x7a6d76e9, 14); cr
= rotl(cr
, 10)
13311 er
= fn2(er
, ar
, br
, cr
, dr
, m
[5], 0x7a6d76e9, 6); br
= rotl(br
, 10)
13312 dr
= fn2(dr
, er
, ar
, br
, cr
, m
[12], 0x7a6d76e9, 9); ar
= rotl(ar
, 10)
13313 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[2], 0x7a6d76e9, 12); er
= rotl(er
, 10)
13314 br
= fn2(br
, cr
, dr
, er
, ar
, m
[13], 0x7a6d76e9, 9); dr
= rotl(dr
, 10)
13315 ar
= fn2(ar
, br
, cr
, dr
, er
, m
[9], 0x7a6d76e9, 12); cr
= rotl(cr
, 10)
13316 er
= fn2(er
, ar
, br
, cr
, dr
, m
[7], 0x7a6d76e9, 5); br
= rotl(br
, 10)
13317 dr
= fn2(dr
, er
, ar
, br
, cr
, m
[10], 0x7a6d76e9, 15); ar
= rotl(ar
, 10)
13318 cr
= fn2(cr
, dr
, er
, ar
, br
, m
[14], 0x7a6d76e9, 8); er
= rotl(er
, 10)
13320 // M'j = 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
13322 // S'j = 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
13323 br
= fn1(br
, cr
, dr
, er
, ar
, m
[12], 0x00000000, 8); dr
= rotl(dr
, 10)
13324 ar
= fn1(ar
, br
, cr
, dr
, er
, m
[15], 0x00000000, 5); cr
= rotl(cr
, 10)
13325 er
= fn1(er
, ar
, br
, cr
, dr
, m
[10], 0x00000000, 12); br
= rotl(br
, 10)
13326 dr
= fn1(dr
, er
, ar
, br
, cr
, m
[4], 0x00000000, 9); ar
= rotl(ar
, 10)
13327 cr
= fn1(cr
, dr
, er
, ar
, br
, m
[1], 0x00000000, 12); er
= rotl(er
, 10)
13328 br
= fn1(br
, cr
, dr
, er
, ar
, m
[5], 0x00000000, 5); dr
= rotl(dr
, 10)
13329 ar
= fn1(ar
, br
, cr
, dr
, er
, m
[8], 0x00000000, 14); cr
= rotl(cr
, 10)
13330 er
= fn1(er
, ar
, br
, cr
, dr
, m
[7], 0x00000000, 6); br
= rotl(br
, 10)
13331 dr
= fn1(dr
, er
, ar
, br
, cr
, m
[6], 0x00000000, 8); ar
= rotl(ar
, 10)
13332 cr
= fn1(cr
, dr
, er
, ar
, br
, m
[2], 0x00000000, 13); er
= rotl(er
, 10)
13333 br
= fn1(br
, cr
, dr
, er
, ar
, m
[13], 0x00000000, 6); dr
= rotl(dr
, 10)
13334 ar
= fn1(ar
, br
, cr
, dr
, er
, m
[14], 0x00000000, 5); cr
= rotl(cr
, 10)
13335 er
= fn1(er
, ar
, br
, cr
, dr
, m
[0], 0x00000000, 15); br
= rotl(br
, 10)
13336 dr
= fn1(dr
, er
, ar
, br
, cr
, m
[3], 0x00000000, 13); ar
= rotl(ar
, 10)
13337 cr
= fn1(cr
, dr
, er
, ar
, br
, m
[9], 0x00000000, 11); er
= rotl(er
, 10)
13338 br
= fn1(br
, cr
, dr
, er
, ar
, m
[11], 0x00000000, 11); dr
= rotl(dr
, 10)
13341 var t
= (this._b
+ cl
+ dr
) | 0
13342 this._b
= (this._c
+ dl
+ er
) | 0
13343 this._c
= (this._d
+ el
+ ar
) | 0
13344 this._d
= (this._e
+ al
+ br
) | 0
13345 this._e
= (this._a
+ bl
+ cr
) | 0
13349 RIPEMD160
.prototype._digest = function () {
13350 // create padding and handle blocks
13351 this._block
[this._blockOffset
++] = 0x80
13352 if (this._blockOffset
> 56) {
13353 this._block
.fill(0, this._blockOffset
, 64)
13355 this._blockOffset
= 0
13358 this._block
.fill(0, this._blockOffset
, 56)
13359 this._block
.writeUInt32LE(this._length
[0], 56)
13360 this._block
.writeUInt32LE(this._length
[1], 60)
13364 var buffer
= new Buffer(20)
13365 buffer
.writeInt32LE(this._a
, 0)
13366 buffer
.writeInt32LE(this._b
, 4)
13367 buffer
.writeInt32LE(this._c
, 8)
13368 buffer
.writeInt32LE(this._d
, 12)
13369 buffer
.writeInt32LE(this._e
, 16)
13373 function rotl (x
, n
) {
13374 return (x
<< n
) | (x
>>> (32 - n
))
13377 function fn1 (a
, b
, c
, d
, e
, m
, k
, s
) {
13378 return (rotl((a
+ (b
^ c
^ d
) + m
+ k
) | 0, s
) + e
) | 0
13381 function fn2 (a
, b
, c
, d
, e
, m
, k
, s
) {
13382 return (rotl((a
+ ((b
& c
) | ((~b
) & d
)) + m
+ k
) | 0, s
) + e
) | 0
13385 function fn3 (a
, b
, c
, d
, e
, m
, k
, s
) {
13386 return (rotl((a
+ ((b
| (~c
)) ^ d
) + m
+ k
) | 0, s
) + e
) | 0
13389 function fn4 (a
, b
, c
, d
, e
, m
, k
, s
) {
13390 return (rotl((a
+ ((b
& d
) | (c
& (~d
))) + m
+ k
) | 0, s
) + e
) | 0
13393 function fn5 (a
, b
, c
, d
, e
, m
, k
, s
) {
13394 return (rotl((a
+ (b
^ (c
| (~d
))) + m
+ k
) | 0, s
) + e
) | 0
13397 module
.exports
= RIPEMD160
13399 }).call(this,require("buffer").Buffer
)
13400 },{"buffer":4,"hash-base":92,"inherits":93}],98:[function(require
,module
,exports
){
13401 arguments
[4][26][0].apply(exports
,arguments
)
13402 },{"buffer":4,"dup":26}],99:[function(require
,module
,exports
){
13403 (function (Buffer
){
13404 // prototype class for hash functions
13405 function Hash (blockSize
, finalSize
) {
13406 this._block
= new Buffer(blockSize
)
13407 this._finalSize
= finalSize
13408 this._blockSize
= blockSize
13413 Hash
.prototype.update = function (data
, enc
) {
13414 if (typeof data
=== 'string') {
13415 enc
= enc
|| 'utf8'
13416 data
= new Buffer(data
, enc
)
13419 var l
= this._len
+= data
.length
13420 var s
= this._s
|| 0
13422 var buffer
= this._block
13425 var t
= Math
.min(data
.length
, f
+ this._blockSize
- (s
% this._blockSize
))
13428 for (var i
= 0; i
< ch
; i
++) {
13429 buffer
[(s
% this._blockSize
) + i
] = data
[i
+ f
]
13435 if ((s
% this._blockSize
) === 0) {
13436 this._update(buffer
)
13444 Hash
.prototype.digest = function (enc
) {
13445 // Suppose the length of the message M, in bits, is l
13446 var l
= this._len
* 8
13448 // Append the bit 1 to the end of the message
13449 this._block
[this._len
% this._blockSize
] = 0x80
13451 // and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
13452 this._block
.fill(0, this._len
% this._blockSize
+ 1)
13454 if (l
% (this._blockSize
* 8) >= this._finalSize
* 8) {
13455 this._update(this._block
)
13456 this._block
.fill(0)
13459 // to this append the block which is equal to the number l written in binary
13460 // TODO: handle case where l is > Math.pow(2, 29)
13461 this._block
.writeInt32BE(l
, this._blockSize
- 4)
13463 var hash
= this._update(this._block
) || this._hash()
13465 return enc
? hash
.toString(enc
) : hash
13468 Hash
.prototype._update = function () {
13469 throw new Error('_update must be implemented by subclass')
13472 module
.exports
= Hash
13474 }).call(this,require("buffer").Buffer
)
13475 },{"buffer":4}],100:[function(require
,module
,exports
){
13476 var exports
= module
.exports
= function SHA (algorithm
) {
13477 algorithm
= algorithm
.toLowerCase()
13479 var Algorithm
= exports
[algorithm
]
13480 if (!Algorithm
) throw new Error(algorithm
+ ' is not supported (we accept pull requests)')
13482 return new Algorithm()
13485 exports
.sha
= require('./sha')
13486 exports
.sha1
= require('./sha1')
13487 exports
.sha224
= require('./sha224')
13488 exports
.sha256
= require('./sha256')
13489 exports
.sha384
= require('./sha384')
13490 exports
.sha512
= require('./sha512')
13492 },{"./sha":101,"./sha1":102,"./sha224":103,"./sha256":104,"./sha384":105,"./sha512":106}],101:[function(require
,module
,exports
){
13493 (function (Buffer
){
13495 * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
13496 * in FIPS PUB 180-1
13497 * This source code is derived from sha1.js of the same repository.
13498 * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
13499 * operation was added.
13502 var inherits
= require('inherits')
13503 var Hash
= require('./hash')
13506 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
13509 var W
= new Array(80)
13515 Hash
.call(this, 64, 56)
13518 inherits(Sha
, Hash
)
13520 Sha
.prototype.init = function () {
13521 this._a
= 0x67452301
13522 this._b
= 0xefcdab89
13523 this._c
= 0x98badcfe
13524 this._d
= 0x10325476
13525 this._e
= 0xc3d2e1f0
13530 function rotl5 (num
) {
13531 return (num
<< 5) | (num
>>> 27)
13534 function rotl30 (num
) {
13535 return (num
<< 30) | (num
>>> 2)
13538 function ft (s
, b
, c
, d
) {
13539 if (s
=== 0) return (b
& c
) | ((~b
) & d
)
13540 if (s
=== 2) return (b
& c
) | (b
& d
) | (c
& d
)
13544 Sha
.prototype._update = function (M
) {
13547 var a
= this._a
| 0
13548 var b
= this._b
| 0
13549 var c
= this._c
| 0
13550 var d
= this._d
| 0
13551 var e
= this._e
| 0
13553 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
13554 for (; i
< 80; ++i
) W
[i
] = W
[i
- 3] ^ W
[i
- 8] ^ W
[i
- 14] ^ W
[i
- 16]
13556 for (var j
= 0; j
< 80; ++j
) {
13558 var t
= (rotl5(a
) + ft(s
, b
, c
, d
) + e
+ W
[j
] + K
[s
]) | 0
13567 this._a
= (a
+ this._a
) | 0
13568 this._b
= (b
+ this._b
) | 0
13569 this._c
= (c
+ this._c
) | 0
13570 this._d
= (d
+ this._d
) | 0
13571 this._e
= (e
+ this._e
) | 0
13574 Sha
.prototype._hash = function () {
13575 var H
= new Buffer(20)
13577 H
.writeInt32BE(this._a
| 0, 0)
13578 H
.writeInt32BE(this._b
| 0, 4)
13579 H
.writeInt32BE(this._c
| 0, 8)
13580 H
.writeInt32BE(this._d
| 0, 12)
13581 H
.writeInt32BE(this._e
| 0, 16)
13586 module
.exports
= Sha
13588 }).call(this,require("buffer").Buffer
)
13589 },{"./hash":99,"buffer":4,"inherits":93}],102:[function(require
,module
,exports
){
13590 (function (Buffer
){
13592 * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
13593 * in FIPS PUB 180-1
13594 * Version 2.1a Copyright Paul Johnston 2000 - 2002.
13595 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
13596 * Distributed under the BSD License
13597 * See http://pajhome.org.uk/crypt/md5 for details.
13600 var inherits
= require('inherits')
13601 var Hash
= require('./hash')
13604 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
13607 var W
= new Array(80)
13613 Hash
.call(this, 64, 56)
13616 inherits(Sha1
, Hash
)
13618 Sha1
.prototype.init = function () {
13619 this._a
= 0x67452301
13620 this._b
= 0xefcdab89
13621 this._c
= 0x98badcfe
13622 this._d
= 0x10325476
13623 this._e
= 0xc3d2e1f0
13628 function rotl1 (num
) {
13629 return (num
<< 1) | (num
>>> 31)
13632 function rotl5 (num
) {
13633 return (num
<< 5) | (num
>>> 27)
13636 function rotl30 (num
) {
13637 return (num
<< 30) | (num
>>> 2)
13640 function ft (s
, b
, c
, d
) {
13641 if (s
=== 0) return (b
& c
) | ((~b
) & d
)
13642 if (s
=== 2) return (b
& c
) | (b
& d
) | (c
& d
)
13646 Sha1
.prototype._update = function (M
) {
13649 var a
= this._a
| 0
13650 var b
= this._b
| 0
13651 var c
= this._c
| 0
13652 var d
= this._d
| 0
13653 var e
= this._e
| 0
13655 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
13656 for (; i
< 80; ++i
) W
[i
] = rotl1(W
[i
- 3] ^ W
[i
- 8] ^ W
[i
- 14] ^ W
[i
- 16])
13658 for (var j
= 0; j
< 80; ++j
) {
13660 var t
= (rotl5(a
) + ft(s
, b
, c
, d
) + e
+ W
[j
] + K
[s
]) | 0
13669 this._a
= (a
+ this._a
) | 0
13670 this._b
= (b
+ this._b
) | 0
13671 this._c
= (c
+ this._c
) | 0
13672 this._d
= (d
+ this._d
) | 0
13673 this._e
= (e
+ this._e
) | 0
13676 Sha1
.prototype._hash = function () {
13677 var H
= new Buffer(20)
13679 H
.writeInt32BE(this._a
| 0, 0)
13680 H
.writeInt32BE(this._b
| 0, 4)
13681 H
.writeInt32BE(this._c
| 0, 8)
13682 H
.writeInt32BE(this._d
| 0, 12)
13683 H
.writeInt32BE(this._e
| 0, 16)
13688 module
.exports
= Sha1
13690 }).call(this,require("buffer").Buffer
)
13691 },{"./hash":99,"buffer":4,"inherits":93}],103:[function(require
,module
,exports
){
13692 (function (Buffer
){
13694 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
13696 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
13697 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
13701 var inherits
= require('inherits')
13702 var Sha256
= require('./sha256')
13703 var Hash
= require('./hash')
13705 var W
= new Array(64)
13707 function Sha224 () {
13710 this._w
= W
// new Array(64)
13712 Hash
.call(this, 64, 56)
13715 inherits(Sha224
, Sha256
)
13717 Sha224
.prototype.init = function () {
13718 this._a
= 0xc1059ed8
13719 this._b
= 0x367cd507
13720 this._c
= 0x3070dd17
13721 this._d
= 0xf70e5939
13722 this._e
= 0xffc00b31
13723 this._f
= 0x68581511
13724 this._g
= 0x64f98fa7
13725 this._h
= 0xbefa4fa4
13730 Sha224
.prototype._hash = function () {
13731 var H
= new Buffer(28)
13733 H
.writeInt32BE(this._a
, 0)
13734 H
.writeInt32BE(this._b
, 4)
13735 H
.writeInt32BE(this._c
, 8)
13736 H
.writeInt32BE(this._d
, 12)
13737 H
.writeInt32BE(this._e
, 16)
13738 H
.writeInt32BE(this._f
, 20)
13739 H
.writeInt32BE(this._g
, 24)
13744 module
.exports
= Sha224
13746 }).call(this,require("buffer").Buffer
)
13747 },{"./hash":99,"./sha256":104,"buffer":4,"inherits":93}],104:[function(require
,module
,exports
){
13748 (function (Buffer
){
13750 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
13752 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
13753 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
13757 var inherits
= require('inherits')
13758 var Hash
= require('./hash')
13761 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
13762 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
13763 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
13764 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
13765 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
13766 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
13767 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
13768 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
13769 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
13770 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
13771 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
13772 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
13773 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
13774 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
13775 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
13776 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
13779 var W
= new Array(64)
13781 function Sha256 () {
13784 this._w
= W
// new Array(64)
13786 Hash
.call(this, 64, 56)
13789 inherits(Sha256
, Hash
)
13791 Sha256
.prototype.init = function () {
13792 this._a
= 0x6a09e667
13793 this._b
= 0xbb67ae85
13794 this._c
= 0x3c6ef372
13795 this._d
= 0xa54ff53a
13796 this._e
= 0x510e527f
13797 this._f
= 0x9b05688c
13798 this._g
= 0x1f83d9ab
13799 this._h
= 0x5be0cd19
13804 function ch (x
, y
, z
) {
13805 return z
^ (x
& (y
^ z
))
13808 function maj (x
, y
, z
) {
13809 return (x
& y
) | (z
& (x
| y
))
13812 function sigma0 (x
) {
13813 return (x
>>> 2 | x
<< 30) ^ (x
>>> 13 | x
<< 19) ^ (x
>>> 22 | x
<< 10)
13816 function sigma1 (x
) {
13817 return (x
>>> 6 | x
<< 26) ^ (x
>>> 11 | x
<< 21) ^ (x
>>> 25 | x
<< 7)
13820 function gamma0 (x
) {
13821 return (x
>>> 7 | x
<< 25) ^ (x
>>> 18 | x
<< 14) ^ (x
>>> 3)
13824 function gamma1 (x
) {
13825 return (x
>>> 17 | x
<< 15) ^ (x
>>> 19 | x
<< 13) ^ (x
>>> 10)
13828 Sha256
.prototype._update = function (M
) {
13831 var a
= this._a
| 0
13832 var b
= this._b
| 0
13833 var c
= this._c
| 0
13834 var d
= this._d
| 0
13835 var e
= this._e
| 0
13836 var f
= this._f
| 0
13837 var g
= this._g
| 0
13838 var h
= this._h
| 0
13840 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
13841 for (; i
< 64; ++i
) W
[i
] = (gamma1(W
[i
- 2]) + W
[i
- 7] + gamma0(W
[i
- 15]) + W
[i
- 16]) | 0
13843 for (var j
= 0; j
< 64; ++j
) {
13844 var T1
= (h
+ sigma1(e
) + ch(e
, f
, g
) + K
[j
] + W
[j
]) | 0
13845 var T2
= (sigma0(a
) + maj(a
, b
, c
)) | 0
13857 this._a
= (a
+ this._a
) | 0
13858 this._b
= (b
+ this._b
) | 0
13859 this._c
= (c
+ this._c
) | 0
13860 this._d
= (d
+ this._d
) | 0
13861 this._e
= (e
+ this._e
) | 0
13862 this._f
= (f
+ this._f
) | 0
13863 this._g
= (g
+ this._g
) | 0
13864 this._h
= (h
+ this._h
) | 0
13867 Sha256
.prototype._hash = function () {
13868 var H
= new Buffer(32)
13870 H
.writeInt32BE(this._a
, 0)
13871 H
.writeInt32BE(this._b
, 4)
13872 H
.writeInt32BE(this._c
, 8)
13873 H
.writeInt32BE(this._d
, 12)
13874 H
.writeInt32BE(this._e
, 16)
13875 H
.writeInt32BE(this._f
, 20)
13876 H
.writeInt32BE(this._g
, 24)
13877 H
.writeInt32BE(this._h
, 28)
13882 module
.exports
= Sha256
13884 }).call(this,require("buffer").Buffer
)
13885 },{"./hash":99,"buffer":4,"inherits":93}],105:[function(require
,module
,exports
){
13886 (function (Buffer
){
13887 var inherits
= require('inherits')
13888 var SHA512
= require('./sha512')
13889 var Hash
= require('./hash')
13891 var W
= new Array(160)
13893 function Sha384 () {
13897 Hash
.call(this, 128, 112)
13900 inherits(Sha384
, SHA512
)
13902 Sha384
.prototype.init = function () {
13903 this._ah
= 0xcbbb9d5d
13904 this._bh
= 0x629a292a
13905 this._ch
= 0x9159015a
13906 this._dh
= 0x152fecd8
13907 this._eh
= 0x67332667
13908 this._fh
= 0x8eb44a87
13909 this._gh
= 0xdb0c2e0d
13910 this._hh
= 0x47b5481d
13912 this._al
= 0xc1059ed8
13913 this._bl
= 0x367cd507
13914 this._cl
= 0x3070dd17
13915 this._dl
= 0xf70e5939
13916 this._el
= 0xffc00b31
13917 this._fl
= 0x68581511
13918 this._gl
= 0x64f98fa7
13919 this._hl
= 0xbefa4fa4
13924 Sha384
.prototype._hash = function () {
13925 var H
= new Buffer(48)
13927 function writeInt64BE (h
, l
, offset
) {
13928 H
.writeInt32BE(h
, offset
)
13929 H
.writeInt32BE(l
, offset
+ 4)
13932 writeInt64BE(this._ah
, this._al
, 0)
13933 writeInt64BE(this._bh
, this._bl
, 8)
13934 writeInt64BE(this._ch
, this._cl
, 16)
13935 writeInt64BE(this._dh
, this._dl
, 24)
13936 writeInt64BE(this._eh
, this._el
, 32)
13937 writeInt64BE(this._fh
, this._fl
, 40)
13942 module
.exports
= Sha384
13944 }).call(this,require("buffer").Buffer
)
13945 },{"./hash":99,"./sha512":106,"buffer":4,"inherits":93}],106:[function(require
,module
,exports
){
13946 (function (Buffer
){
13947 var inherits
= require('inherits')
13948 var Hash
= require('./hash')
13951 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
13952 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
13953 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
13954 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
13955 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
13956 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
13957 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
13958 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
13959 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
13960 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
13961 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
13962 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
13963 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
13964 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
13965 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
13966 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
13967 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
13968 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
13969 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
13970 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
13971 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
13972 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
13973 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
13974 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
13975 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
13976 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
13977 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
13978 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
13979 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
13980 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
13981 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
13982 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
13983 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
13984 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
13985 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
13986 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
13987 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
13988 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
13989 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
13990 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
13993 var W
= new Array(160)
13995 function Sha512 () {
13999 Hash
.call(this, 128, 112)
14002 inherits(Sha512
, Hash
)
14004 Sha512
.prototype.init = function () {
14005 this._ah
= 0x6a09e667
14006 this._bh
= 0xbb67ae85
14007 this._ch
= 0x3c6ef372
14008 this._dh
= 0xa54ff53a
14009 this._eh
= 0x510e527f
14010 this._fh
= 0x9b05688c
14011 this._gh
= 0x1f83d9ab
14012 this._hh
= 0x5be0cd19
14014 this._al
= 0xf3bcc908
14015 this._bl
= 0x84caa73b
14016 this._cl
= 0xfe94f82b
14017 this._dl
= 0x5f1d36f1
14018 this._el
= 0xade682d1
14019 this._fl
= 0x2b3e6c1f
14020 this._gl
= 0xfb41bd6b
14021 this._hl
= 0x137e2179
14026 function Ch (x
, y
, z
) {
14027 return z
^ (x
& (y
^ z
))
14030 function maj (x
, y
, z
) {
14031 return (x
& y
) | (z
& (x
| y
))
14034 function sigma0 (x
, xl
) {
14035 return (x
>>> 28 | xl
<< 4) ^ (xl
>>> 2 | x
<< 30) ^ (xl
>>> 7 | x
<< 25)
14038 function sigma1 (x
, xl
) {
14039 return (x
>>> 14 | xl
<< 18) ^ (x
>>> 18 | xl
<< 14) ^ (xl
>>> 9 | x
<< 23)
14042 function Gamma0 (x
, xl
) {
14043 return (x
>>> 1 | xl
<< 31) ^ (x
>>> 8 | xl
<< 24) ^ (x
>>> 7)
14046 function Gamma0l (x
, xl
) {
14047 return (x
>>> 1 | xl
<< 31) ^ (x
>>> 8 | xl
<< 24) ^ (x
>>> 7 | xl
<< 25)
14050 function Gamma1 (x
, xl
) {
14051 return (x
>>> 19 | xl
<< 13) ^ (xl
>>> 29 | x
<< 3) ^ (x
>>> 6)
14054 function Gamma1l (x
, xl
) {
14055 return (x
>>> 19 | xl
<< 13) ^ (xl
>>> 29 | x
<< 3) ^ (x
>>> 6 | xl
<< 26)
14058 function getCarry (a
, b
) {
14059 return (a
>>> 0) < (b
>>> 0) ? 1 : 0
14062 Sha512
.prototype._update = function (M
) {
14065 var ah
= this._ah
| 0
14066 var bh
= this._bh
| 0
14067 var ch
= this._ch
| 0
14068 var dh
= this._dh
| 0
14069 var eh
= this._eh
| 0
14070 var fh
= this._fh
| 0
14071 var gh
= this._gh
| 0
14072 var hh
= this._hh
| 0
14074 var al
= this._al
| 0
14075 var bl
= this._bl
| 0
14076 var cl
= this._cl
| 0
14077 var dl
= this._dl
| 0
14078 var el
= this._el
| 0
14079 var fl
= this._fl
| 0
14080 var gl
= this._gl
| 0
14081 var hl
= this._hl
| 0
14083 for (var i
= 0; i
< 32; i
+= 2) {
14084 W
[i
] = M
.readInt32BE(i
* 4)
14085 W
[i
+ 1] = M
.readInt32BE(i
* 4 + 4)
14087 for (; i
< 160; i
+= 2) {
14088 var xh
= W
[i
- 15 * 2]
14089 var xl
= W
[i
- 15 * 2 + 1]
14090 var gamma0
= Gamma0(xh
, xl
)
14091 var gamma0l
= Gamma0l(xl
, xh
)
14094 xl
= W
[i
- 2 * 2 + 1]
14095 var gamma1
= Gamma1(xh
, xl
)
14096 var gamma1l
= Gamma1l(xl
, xh
)
14098 // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
14099 var Wi7h
= W
[i
- 7 * 2]
14100 var Wi7l
= W
[i
- 7 * 2 + 1]
14102 var Wi16h
= W
[i
- 16 * 2]
14103 var Wi16l
= W
[i
- 16 * 2 + 1]
14105 var Wil
= (gamma0l
+ Wi7l
) | 0
14106 var Wih
= (gamma0
+ Wi7h
+ getCarry(Wil
, gamma0l
)) | 0
14107 Wil
= (Wil
+ gamma1l
) | 0
14108 Wih
= (Wih
+ gamma1
+ getCarry(Wil
, gamma1l
)) | 0
14109 Wil
= (Wil
+ Wi16l
) | 0
14110 Wih
= (Wih
+ Wi16h
+ getCarry(Wil
, Wi16l
)) | 0
14116 for (var j
= 0; j
< 160; j
+= 2) {
14120 var majh
= maj(ah
, bh
, ch
)
14121 var majl
= maj(al
, bl
, cl
)
14123 var sigma0h
= sigma0(ah
, al
)
14124 var sigma0l
= sigma0(al
, ah
)
14125 var sigma1h
= sigma1(eh
, el
)
14126 var sigma1l
= sigma1(el
, eh
)
14128 // t1 = h + sigma1 + ch + K[j] + W[j]
14132 var chh
= Ch(eh
, fh
, gh
)
14133 var chl
= Ch(el
, fl
, gl
)
14135 var t1l
= (hl
+ sigma1l
) | 0
14136 var t1h
= (hh
+ sigma1h
+ getCarry(t1l
, hl
)) | 0
14137 t1l
= (t1l
+ chl
) | 0
14138 t1h
= (t1h
+ chh
+ getCarry(t1l
, chl
)) | 0
14139 t1l
= (t1l
+ Kil
) | 0
14140 t1h
= (t1h
+ Kih
+ getCarry(t1l
, Kil
)) | 0
14141 t1l
= (t1l
+ Wil
) | 0
14142 t1h
= (t1h
+ Wih
+ getCarry(t1l
, Wil
)) | 0
14144 // t2 = sigma0 + maj
14145 var t2l
= (sigma0l
+ majl
) | 0
14146 var t2h
= (sigma0h
+ majh
+ getCarry(t2l
, sigma0l
)) | 0
14154 el
= (dl
+ t1l
) | 0
14155 eh
= (dh
+ t1h
+ getCarry(el
, dl
)) | 0
14162 al
= (t1l
+ t2l
) | 0
14163 ah
= (t1h
+ t2h
+ getCarry(al
, t1l
)) | 0
14166 this._al
= (this._al
+ al
) | 0
14167 this._bl
= (this._bl
+ bl
) | 0
14168 this._cl
= (this._cl
+ cl
) | 0
14169 this._dl
= (this._dl
+ dl
) | 0
14170 this._el
= (this._el
+ el
) | 0
14171 this._fl
= (this._fl
+ fl
) | 0
14172 this._gl
= (this._gl
+ gl
) | 0
14173 this._hl
= (this._hl
+ hl
) | 0
14175 this._ah
= (this._ah
+ ah
+ getCarry(this._al
, al
)) | 0
14176 this._bh
= (this._bh
+ bh
+ getCarry(this._bl
, bl
)) | 0
14177 this._ch
= (this._ch
+ ch
+ getCarry(this._cl
, cl
)) | 0
14178 this._dh
= (this._dh
+ dh
+ getCarry(this._dl
, dl
)) | 0
14179 this._eh
= (this._eh
+ eh
+ getCarry(this._el
, el
)) | 0
14180 this._fh
= (this._fh
+ fh
+ getCarry(this._fl
, fl
)) | 0
14181 this._gh
= (this._gh
+ gh
+ getCarry(this._gl
, gl
)) | 0
14182 this._hh
= (this._hh
+ hh
+ getCarry(this._hl
, hl
)) | 0
14185 Sha512
.prototype._hash = function () {
14186 var H
= new Buffer(64)
14188 function writeInt64BE (h
, l
, offset
) {
14189 H
.writeInt32BE(h
, offset
)
14190 H
.writeInt32BE(l
, offset
+ 4)
14193 writeInt64BE(this._ah
, this._al
, 0)
14194 writeInt64BE(this._bh
, this._bl
, 8)
14195 writeInt64BE(this._ch
, this._cl
, 16)
14196 writeInt64BE(this._dh
, this._dl
, 24)
14197 writeInt64BE(this._eh
, this._el
, 32)
14198 writeInt64BE(this._fh
, this._fl
, 40)
14199 writeInt64BE(this._gh
, this._gl
, 48)
14200 writeInt64BE(this._hh
, this._hl
, 56)
14205 module
.exports
= Sha512
14207 }).call(this,require("buffer").Buffer
)
14208 },{"./hash":99,"buffer":4,"inherits":93}],107:[function(require
,module
,exports
){
14209 var inherits
= require('inherits')
14210 var native = require('./native')
14212 function TfTypeError (type
, value
, valueTypeName
) {
14213 this.__error
= Error
.call(this)
14215 this.__value
= value
14216 this.__valueTypeName
= valueTypeName
14219 Object
.defineProperty(this, 'message', {
14222 if (message
) return message
14224 valueTypeName
= valueTypeName
|| getValueTypeName(value
)
14225 message
= tfErrorString(type
, value
, valueTypeName
)
14232 function TfPropertyTypeError (type
, property
, label
, value
, error
, valueTypeName
) {
14233 this.__error
= error
|| Error
.call(this)
14234 this.__label
= label
14235 this.__property
= property
14237 this.__value
= value
14238 this.__valueTypeName
= valueTypeName
14241 Object
.defineProperty(this, 'message', {
14244 if (message
) return message
14246 valueTypeName
= valueTypeName
|| getValueTypeName(value
)
14247 message
= tfPropertyErrorString(type
, label
, property
, value
, valueTypeName
)
14249 message
= 'Unexpected property "' + property
+ '"'
14257 // inherit from Error, assign stack
14258 [TfTypeError
, TfPropertyTypeError
].forEach(function (tfErrorType
) {
14259 inherits(tfErrorType
, Error
)
14260 Object
.defineProperty(tfErrorType
, 'stack', {
14261 get: function () { return this.__error
.stack
}
14265 function tfCustomError (expected
, actual
) {
14266 return new TfTypeError(expected
, {}, actual
)
14269 function tfSubError (e
, property
, label
) {
14271 if (e
instanceof TfPropertyTypeError
) {
14272 property
= property
+ '.' + e
.__property
14275 return new TfPropertyTypeError(
14276 e
.__type
, property
, label
, e
.__value
, e
.__error
, e
.__valueTypeName
14281 if (e
instanceof TfTypeError
) {
14282 return new TfPropertyTypeError(
14283 e
.__type
, property
, label
, e
.__value
, e
.__error
, e
.__valueTypeName
14290 function getTypeName (fn
) {
14291 return fn
.name
|| fn
.toString().match(/function (.*?)\s
*\(/)[1]
14294 function getValueTypeName (value
) {
14295 return native.Nil(value
) ? '' : getTypeName(value
.constructor)
14298 function getValue (value
) {
14299 if (native.Function(value
)) return ''
14300 if (native.String(value
)) return JSON
.stringify(value
)
14301 if (value
&& native.Object(value
)) return ''
14305 function tfJSON (type
) {
14306 if (native.Function(type
)) return type
.toJSON
? type
.toJSON() : getTypeName(type
)
14307 if (native.Array(type
)) return 'Array'
14308 if (type
&& native.Object(type
)) return 'Object'
14310 return type
!== undefined ? type : ''
14313 function tfErrorString (type
, value
, valueTypeName
) {
14314 var valueJson
= getValue(value
)
14316 return 'Expected ' + tfJSON(type
) + ', got' +
14317 (valueTypeName
!== '' ? ' ' + valueTypeName : '') +
14318 (valueJson
!== '' ? ' ' + valueJson : '')
14321 function tfPropertyErrorString (type
, label
, name
, value
, valueTypeName
) {
14322 var description
= '" of type '
14323 if (label
=== 'key') description
= '" with key type '
14325 return tfErrorString('property "' + tfJSON(name
) + description
+ tfJSON(type
), value
, valueTypeName
)
14329 TfTypeError: TfTypeError
,
14330 TfPropertyTypeError: TfPropertyTypeError
,
14331 tfCustomError: tfCustomError
,
14332 tfSubError: tfSubError
,
14334 getValueTypeName: getValueTypeName
14337 },{"./native":110,"inherits":93}],108:[function(require
,module
,exports
){
14338 (function (Buffer
){
14339 var NATIVE
= require('./native')
14340 var ERRORS
= require('./errors')
14342 function _Buffer (value
) {
14343 return Buffer
.isBuffer(value
)
14346 function Hex (value
) {
14347 return typeof value
=== 'string' && /^([0-9a-f]{2})+$/i.test(value
)
14350 function _LengthN (type
, length
) {
14351 var name
= type
.toJSON()
14353 function Length (value
) {
14354 if (!type(value
)) return false
14355 if (value
.length
=== length
) return true
14357 throw ERRORS
.tfCustomError(name
+ '(Length: ' + length
+ ')', name
+ '(Length: ' + value
.length
+ ')')
14359 Length
.toJSON = function () { return name
}
14364 var _ArrayN
= _LengthN
.bind(null, NATIVE
.Array
)
14365 var _BufferN
= _LengthN
.bind(null, _Buffer
)
14366 var _HexN
= _LengthN
.bind(null, Hex
)
14368 var UINT53_MAX
= Math
.pow(2, 53) - 1
14370 function Finite (value
) {
14371 return typeof value
=== 'number' && isFinite(value
)
14373 function Int8 (value
) { return ((value
<< 24) >> 24) === value
}
14374 function Int16 (value
) { return ((value
<< 16) >> 16) === value
}
14375 function Int32 (value
) { return (value
| 0) === value
}
14376 function UInt8 (value
) { return (value
& 0xff) === value
}
14377 function UInt16 (value
) { return (value
& 0xffff) === value
}
14378 function UInt32 (value
) { return (value
>>> 0) === value
}
14379 function UInt53 (value
) {
14380 return typeof value
=== 'number' &&
14382 value
<= UINT53_MAX
&&
14383 Math
.floor(value
) === value
14402 for (var typeName
in types
) {
14403 types
[typeName
].toJSON = function (t
) {
14405 }.bind(null, typeName
)
14408 module
.exports
= types
14410 }).call(this,{"isBuffer":require("../../../../../.nvm/versions/node/v6.0.0/lib/node_modules/browserify/node_modules/is-buffer/index.js")})
14411 },{"../../../../../.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
){
14412 var ERRORS
= require('./errors')
14413 var NATIVE
= require('./native')
14416 var tfJSON
= ERRORS
.tfJSON
14417 var TfTypeError
= ERRORS
.TfTypeError
14418 var TfPropertyTypeError
= ERRORS
.TfPropertyTypeError
14419 var tfSubError
= ERRORS
.tfSubError
14420 var getValueTypeName
= ERRORS
.getValueTypeName
14423 arrayOf: function arrayOf (type
) {
14424 type
= compile(type
)
14426 function _arrayOf (array
, strict
) {
14427 if (!NATIVE
.Array(array
)) return false
14429 return array
.every(function (value
, i
) {
14431 return typeforce(type
, value
, strict
)
14433 throw tfSubError(e
, i
)
14437 _arrayOf
.toJSON = function () { return '[' + tfJSON(type
) + ']' }
14442 maybe: function maybe (type
) {
14443 type
= compile(type
)
14445 function _maybe (value
, strict
) {
14446 return NATIVE
.Nil(value
) || type(value
, strict
, maybe
)
14448 _maybe
.toJSON = function () { return '?' + tfJSON(type
) }
14453 map: function map (propertyType
, propertyKeyType
) {
14454 propertyType
= compile(propertyType
)
14455 if (propertyKeyType
) propertyKeyType
= compile(propertyKeyType
)
14457 function _map (value
, strict
) {
14458 if (!NATIVE
.Object(value
, strict
)) return false
14459 if (NATIVE
.Nil(value
, strict
)) return false
14461 for (var propertyName
in value
) {
14463 if (propertyKeyType
) {
14464 typeforce(propertyKeyType
, propertyName
, strict
)
14467 throw tfSubError(e
, propertyName
, 'key')
14471 var propertyValue
= value
[propertyName
]
14472 typeforce(propertyType
, propertyValue
, strict
)
14474 throw tfSubError(e
, propertyName
)
14481 if (propertyKeyType
) {
14482 _map
.toJSON = function () {
14483 return '{' + tfJSON(propertyKeyType
) + ': ' + tfJSON(propertyType
) + '}'
14486 _map
.toJSON = function () { return '{' + tfJSON(propertyType
) + '}' }
14492 object: function object (uncompiled
) {
14495 for (var typePropertyName
in uncompiled
) {
14496 type
[typePropertyName
] = compile(uncompiled
[typePropertyName
])
14499 function _object (value
, strict
) {
14500 if (!NATIVE
.Object(value
)) return false
14501 if (NATIVE
.Nil(value
)) return false
14506 for (propertyName
in type
) {
14507 var propertyType
= type
[propertyName
]
14508 var propertyValue
= value
[propertyName
]
14510 typeforce(propertyType
, propertyValue
, strict
)
14513 throw tfSubError(e
, propertyName
)
14517 for (propertyName
in value
) {
14518 if (type
[propertyName
]) continue
14520 throw new TfPropertyTypeError(undefined, propertyName
)
14526 _object
.toJSON = function () { return tfJSON(type
) }
14531 oneOf: function oneOf () {
14532 var types
= [].slice
.call(arguments
).map(compile
)
14534 function _oneOf (value
, strict
) {
14535 return types
.some(function (type
) {
14537 return typeforce(type
, value
, strict
)
14543 _oneOf
.toJSON = function () { return types
.map(tfJSON
).join('|') }
14548 quacksLike: function quacksLike (type
) {
14549 function _quacksLike (value
) {
14550 return type
=== getValueTypeName(value
)
14552 _quacksLike
.toJSON = function () { return type
}
14557 tuple: function tuple () {
14558 var types
= [].slice
.call(arguments
).map(compile
)
14560 function _tuple (values
, strict
) {
14561 return types
.every(function (type
, i
) {
14563 return typeforce(type
, values
[i
], strict
)
14565 throw tfSubError(e
, i
)
14567 }) && (!strict
|| values
.length
=== arguments
.length
)
14569 _tuple
.toJSON = function () { return '(' + types
.map(tfJSON
).join(', ') + ')' }
14574 value: function value (expected
) {
14575 function _value (actual
) {
14576 return actual
=== expected
14578 _value
.toJSON = function () { return expected
}
14584 function compile (type
) {
14585 if (NATIVE
.String(type
)) {
14586 if (type
[0] === '?') return TYPES
.maybe(compile(type
.slice(1)))
14588 return NATIVE
[type
] || TYPES
.quacksLike(type
)
14589 } else if (type
&& NATIVE
.Object(type
)) {
14590 if (NATIVE
.Array(type
)) return TYPES
.arrayOf(compile(type
[0]))
14592 return TYPES
.object(type
)
14593 } else if (NATIVE
.Function(type
)) {
14597 return TYPES
.value(type
)
14600 function typeforce (type
, value
, strict
, surrogate
) {
14601 if (NATIVE
.Function(type
)) {
14602 if (type(value
, strict
)) return true
14604 throw new TfTypeError(surrogate
|| type
, value
)
14608 return typeforce(compile(type
), value
, strict
)
14611 // assign types to typeforce function
14612 for (var typeName
in NATIVE
) {
14613 typeforce
[typeName
] = NATIVE
[typeName
]
14616 for (typeName
in TYPES
) {
14617 typeforce
[typeName
] = TYPES
[typeName
]
14620 var EXTRA
= require('./extra')
14621 for (typeName
in EXTRA
) {
14622 typeforce
[typeName
] = EXTRA
[typeName
]
14626 function __async (type
, value
, strict
, callback
) {
14627 // default to falsy strict if using shorthand overload
14628 if (typeof strict
=== 'function') return __async(type
, value
, false, strict
)
14631 typeforce(type
, value
, strict
)
14639 typeforce
.async
= __async
14640 typeforce
.compile
= compile
14641 typeforce
.TfTypeError
= TfTypeError
14642 typeforce
.TfPropertyTypeError
= TfPropertyTypeError
14644 module
.exports
= typeforce
14646 },{"./errors":107,"./extra":108,"./native":110}],110:[function(require
,module
,exports
){
14648 Array: function (value
) { return value
!== null && value
!== undefined && value
.constructor === Array
},
14649 Boolean: function (value
) { return typeof value
=== 'boolean' },
14650 Function: function (value
) { return typeof value
=== 'function' },
14651 Nil: function (value
) { return value
=== undefined || value
=== null },
14652 Number: function (value
) { return typeof value
=== 'number' },
14653 Object: function (value
) { return typeof value
=== 'object' },
14654 String: function (value
) { return typeof value
=== 'string' },
14655 '': function () { return true }
14659 types
.Null
= types
.Nil
14661 for (var typeName
in types
) {
14662 types
[typeName
].toJSON = function (t
) {
14664 }.bind(null, typeName
)
14667 module
.exports
= types
14669 },{}],111:[function(require
,module
,exports
){
14670 (function (Buffer
){
14673 // Number.MAX_SAFE_INTEGER
14674 var MAX_SAFE_INTEGER
= 9007199254740991
14676 function checkUInt53 (n
) {
14677 if (n
< 0 || n
> MAX_SAFE_INTEGER
|| n
% 1 !== 0) throw new RangeError('value out of range')
14680 function encode (number
, buffer
, offset
) {
14681 checkUInt53(number
)
14683 if (!buffer
) buffer
= new Buffer(encodingLength(number
))
14684 if (!Buffer
.isBuffer(buffer
)) throw new TypeError('buffer must be a Buffer instance')
14685 if (!offset
) offset
= 0
14688 if (number
< 0xfd) {
14689 buffer
.writeUInt8(number
, offset
)
14693 } else if (number
<= 0xffff) {
14694 buffer
.writeUInt8(0xfd, offset
)
14695 buffer
.writeUInt16LE(number
, offset
+ 1)
14699 } else if (number
<= 0xffffffff) {
14700 buffer
.writeUInt8(0xfe, offset
)
14701 buffer
.writeUInt32LE(number
, offset
+ 1)
14706 buffer
.writeUInt8(0xff, offset
)
14707 buffer
.writeUInt32LE(number
>>> 0, offset
+ 1)
14708 buffer
.writeUInt32LE((number
/ 0x100000000) | 0, offset
+ 5)
14715 function decode (buffer
, offset
) {
14716 if (!Buffer
.isBuffer(buffer
)) throw new TypeError('buffer must be a Buffer instance')
14717 if (!offset
) offset
= 0
14719 var first
= buffer
.readUInt8(offset
)
14722 if (first
< 0xfd) {
14727 } else if (first
=== 0xfd) {
14729 return buffer
.readUInt16LE(offset
+ 1)
14732 } else if (first
=== 0xfe) {
14734 return buffer
.readUInt32LE(offset
+ 1)
14739 var lo
= buffer
.readUInt32LE(offset
+ 1)
14740 var hi
= buffer
.readUInt32LE(offset
+ 5)
14741 var number
= hi
* 0x0100000000 + lo
14742 checkUInt53(number
)
14748 function encodingLength (number
) {
14749 checkUInt53(number
)
14753 : number
<= 0xffff ? 3
14754 : number
<= 0xffffffff ? 5
14759 module
.exports
= { encode: encode
, decode: decode
, encodingLength: encodingLength
}
14761 }).call(this,require("buffer").Buffer
)
14762 },{"buffer":4}],112:[function(require
,module
,exports
){
14763 (function (Buffer
){
14764 var bs58check
= require('bs58check')
14766 function decodeRaw (buffer
, version
) {
14767 // check version only if defined
14768 if (version
!== undefined && buffer
[0] !== version
) throw new Error('Invalid network version')
14771 if (buffer
.length
=== 33) {
14773 version: buffer
[0],
14774 privateKey: buffer
.slice(1, 33),
14780 if (buffer
.length
!== 34) throw new Error('Invalid WIF length')
14782 // invalid compression flag
14783 if (buffer
[33] !== 0x01) throw new Error('Invalid compression flag')
14786 version: buffer
[0],
14787 privateKey: buffer
.slice(1, 33),
14792 function encodeRaw (version
, privateKey
, compressed
) {
14793 var result
= new Buffer(compressed
? 34 : 33)
14795 result
.writeUInt8(version
, 0)
14796 privateKey
.copy(result
, 1)
14805 function decode (string
, version
) {
14806 return decodeRaw(bs58check
.decode(string
), version
)
14809 function encode (version
, privateKey
, compressed
) {
14810 if (typeof version
=== 'number') return bs58check
.encode(encodeRaw(version
, privateKey
, compressed
))
14812 return bs58check
.encode(
14815 version
.privateKey
,
14823 decodeRaw: decodeRaw
,
14825 encodeRaw: encodeRaw
14828 }).call(this,require("buffer").Buffer
)
14829 },{"bs58check":80,"buffer":4}]},{},[33])(33)