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
.ethUtil
= 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/":30}],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
, j
, 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, j
= 0; i
< l
; i
+= 4, j
+= 3) {
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
){
617 var buffer
= require('buffer');
618 var Buffer
= buffer
.Buffer
;
619 var SlowBuffer
= buffer
.SlowBuffer
;
620 var MAX_LEN
= buffer
.kMaxLength
|| 2147483647;
621 exports
.alloc
= function alloc(size
, fill
, encoding
) {
622 if (typeof Buffer
.alloc
=== 'function') {
623 return Buffer
.alloc(size
, fill
, encoding
);
625 if (typeof encoding
=== 'number') {
626 throw new TypeError('encoding must not be number');
628 if (typeof size
!== 'number') {
629 throw new TypeError('size must be a number');
631 if (size
> MAX_LEN
) {
632 throw new RangeError('size is too large');
636 if (_fill
=== undefined) {
640 var buf
= new Buffer(size
);
641 if (typeof _fill
=== 'string') {
642 var fillBuf
= new Buffer(_fill
, enc
);
643 var flen
= fillBuf
.length
;
646 buf
[i
] = fillBuf
[i
% flen
];
653 exports
.allocUnsafe
= function allocUnsafe(size
) {
654 if (typeof Buffer
.allocUnsafe
=== 'function') {
655 return Buffer
.allocUnsafe(size
);
657 if (typeof size
!== 'number') {
658 throw new TypeError('size must be a number');
660 if (size
> MAX_LEN
) {
661 throw new RangeError('size is too large');
663 return new Buffer(size
);
665 exports
.from = function from(value
, encodingOrOffset
, length
) {
666 if (typeof Buffer
.from === 'function' && (!global
.Uint8Array
|| Uint8Array
.from !== Buffer
.from)) {
667 return Buffer
.from(value
, encodingOrOffset
, length
);
669 if (typeof value
=== 'number') {
670 throw new TypeError('"value" argument must not be a number');
672 if (typeof value
=== 'string') {
673 return new Buffer(value
, encodingOrOffset
);
675 if (typeof ArrayBuffer
!== 'undefined' && value
instanceof ArrayBuffer
) {
676 var offset
= encodingOrOffset
;
677 if (arguments
.length
=== 1) {
678 return new Buffer(value
);
680 if (typeof offset
=== 'undefined') {
684 if (typeof len
=== 'undefined') {
685 len
= value
.byteLength
- offset
;
687 if (offset
>= value
.byteLength
) {
688 throw new RangeError('\'offset\' is out of bounds');
690 if (len
> value
.byteLength
- offset
) {
691 throw new RangeError('\'length\' is out of bounds');
693 return new Buffer(value
.slice(offset
, offset
+ len
));
695 if (Buffer
.isBuffer(value
)) {
696 var out
= new Buffer(value
.length
);
697 value
.copy(out
, 0, 0, value
.length
);
701 if (Array
.isArray(value
) || (typeof ArrayBuffer
!== 'undefined' && value
.buffer
instanceof ArrayBuffer
) || 'length' in value
) {
702 return new Buffer(value
);
704 if (value
.type
=== 'Buffer' && Array
.isArray(value
.data
)) {
705 return new Buffer(value
.data
);
709 throw new TypeError('First argument must be a string, Buffer, ' + 'ArrayBuffer, Array, or array-like object.');
711 exports
.allocUnsafeSlow
= function allocUnsafeSlow(size
) {
712 if (typeof Buffer
.allocUnsafeSlow
=== 'function') {
713 return Buffer
.allocUnsafeSlow(size
);
715 if (typeof size
!== 'number') {
716 throw new TypeError('size must be a number');
718 if (size
>= MAX_LEN
) {
719 throw new RangeError('size is too large');
721 return new SlowBuffer(size
);
724 }).call(this,typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
725 },{"buffer":5}],5:[function(require
,module
,exports
){
727 * The buffer module from node.js, for the browser.
729 * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
732 /* eslint-disable no-proto */
736 var base64
= require('base64-js')
737 var ieee754
= require('ieee754')
739 exports
.Buffer
= Buffer
740 exports
.SlowBuffer
= SlowBuffer
741 exports
.INSPECT_MAX_BYTES
= 50
743 var K_MAX_LENGTH
= 0x7fffffff
744 exports
.kMaxLength
= K_MAX_LENGTH
747 * If `Buffer.TYPED_ARRAY_SUPPORT`:
748 * === true Use Uint8Array implementation (fastest)
749 * === false Print warning and recommend using `buffer` v4.x which has an Object
750 * implementation (most compatible, even IE6)
752 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
753 * Opera 11.6+, iOS 4.2+.
755 * We report that the browser does not support typed arrays if the are not subclassable
756 * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
757 * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
758 * for __proto__ and has a buggy typed array implementation.
760 Buffer
.TYPED_ARRAY_SUPPORT
= typedArraySupport()
762 if (!Buffer
.TYPED_ARRAY_SUPPORT
&& typeof console
!== 'undefined' &&
763 typeof console
.error
=== 'function') {
765 'This browser lacks typed array (Uint8Array) support which is required by ' +
766 '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
770 function typedArraySupport () {
771 // Can typed array instances can be augmented?
773 var arr
= new Uint8Array(1)
774 arr
.__proto__
= {__proto__: Uint8Array
.prototype, foo: function () { return 42 }}
775 return arr
.foo() === 42
781 function createBuffer (length
) {
782 if (length
> K_MAX_LENGTH
) {
783 throw new RangeError('Invalid typed array length')
785 // Return an augmented `Uint8Array` instance
786 var buf
= new Uint8Array(length
)
787 buf
.__proto__
= Buffer
.prototype
792 * The Buffer constructor returns instances of `Uint8Array` that have their
793 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
794 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
795 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
796 * returns a single octet.
798 * The `Uint8Array` prototype remains unmodified.
801 function Buffer (arg
, encodingOrOffset
, length
) {
803 if (typeof arg
=== 'number') {
804 if (typeof encodingOrOffset
=== 'string') {
806 'If encoding is specified then the first argument must be a string'
809 return allocUnsafe(arg
)
811 return from(arg
, encodingOrOffset
, length
)
814 // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
815 if (typeof Symbol
!== 'undefined' && Symbol
.species
&&
816 Buffer
[Symbol
.species
] === Buffer
) {
817 Object
.defineProperty(Buffer
, Symbol
.species
, {
825 Buffer
.poolSize
= 8192 // not used by this implementation
827 function from (value
, encodingOrOffset
, length
) {
828 if (typeof value
=== 'number') {
829 throw new TypeError('"value" argument must not be a number')
832 if (value
instanceof ArrayBuffer
) {
833 return fromArrayBuffer(value
, encodingOrOffset
, length
)
836 if (typeof value
=== 'string') {
837 return fromString(value
, encodingOrOffset
)
840 return fromObject(value
)
844 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
845 * if value is a number.
846 * Buffer.from(str[, encoding])
848 * Buffer.from(buffer)
849 * Buffer.from(arrayBuffer[, byteOffset[, length]])
851 Buffer
.from = function (value
, encodingOrOffset
, length
) {
852 return from(value
, encodingOrOffset
, length
)
855 // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
856 // https://github.com/feross/buffer/pull/148
857 Buffer
.prototype.__proto__
= Uint8Array
.prototype
858 Buffer
.__proto__
= Uint8Array
860 function assertSize (size
) {
861 if (typeof size
!== 'number') {
862 throw new TypeError('"size" argument must be a number')
863 } else if (size
< 0) {
864 throw new RangeError('"size" argument must not be negative')
868 function alloc (size
, fill
, encoding
) {
871 return createBuffer(size
)
873 if (fill
!== undefined) {
874 // Only pay attention to encoding if it's a string. This
875 // prevents accidentally sending in a number that would
876 // be interpretted as a start offset.
877 return typeof encoding
=== 'string'
878 ? createBuffer(size
).fill(fill
, encoding
)
879 : createBuffer(size
).fill(fill
)
881 return createBuffer(size
)
885 * Creates a new filled Buffer instance.
886 * alloc(size[, fill[, encoding]])
888 Buffer
.alloc = function (size
, fill
, encoding
) {
889 return alloc(size
, fill
, encoding
)
892 function allocUnsafe (size
) {
894 return createBuffer(size
< 0 ? 0 : checked(size
) | 0)
898 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
900 Buffer
.allocUnsafe = function (size
) {
901 return allocUnsafe(size
)
904 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
906 Buffer
.allocUnsafeSlow = function (size
) {
907 return allocUnsafe(size
)
910 function fromString (string
, encoding
) {
911 if (typeof encoding
!== 'string' || encoding
=== '') {
915 if (!Buffer
.isEncoding(encoding
)) {
916 throw new TypeError('"encoding" must be a valid string encoding')
919 var length
= byteLength(string
, encoding
) | 0
920 var buf
= createBuffer(length
)
922 var actual
= buf
.write(string
, encoding
)
924 if (actual
!== length
) {
925 // Writing a hex string, for example, that contains invalid characters will
926 // cause everything after the first invalid character to be ignored. (e.g.
927 // 'abxxcd' will be treated as 'ab')
928 buf
= buf
.slice(0, actual
)
934 function fromArrayLike (array
) {
935 var length
= array
.length
< 0 ? 0 : checked(array
.length
) | 0
936 var buf
= createBuffer(length
)
937 for (var i
= 0; i
< length
; i
+= 1) {
938 buf
[i
] = array
[i
] & 255
943 function fromArrayBuffer (array
, byteOffset
, length
) {
944 if (byteOffset
< 0 || array
.byteLength
< byteOffset
) {
945 throw new RangeError('\'offset\' is out of bounds')
948 if (array
.byteLength
< byteOffset
+ (length
|| 0)) {
949 throw new RangeError('\'length\' is out of bounds')
953 if (byteOffset
=== undefined && length
=== undefined) {
954 buf
= new Uint8Array(array
)
955 } else if (length
=== undefined) {
956 buf
= new Uint8Array(array
, byteOffset
)
958 buf
= new Uint8Array(array
, byteOffset
, length
)
961 // Return an augmented `Uint8Array` instance
962 buf
.__proto__
= Buffer
.prototype
966 function fromObject (obj
) {
967 if (Buffer
.isBuffer(obj
)) {
968 var len
= checked(obj
.length
) | 0
969 var buf
= createBuffer(len
)
971 if (buf
.length
=== 0) {
975 obj
.copy(buf
, 0, 0, len
)
980 if (ArrayBuffer
.isView(obj
) || 'length' in obj
) {
981 if (typeof obj
.length
!== 'number' || isnan(obj
.length
)) {
982 return createBuffer(0)
984 return fromArrayLike(obj
)
987 if (obj
.type
=== 'Buffer' && Array
.isArray(obj
.data
)) {
988 return fromArrayLike(obj
.data
)
992 throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
995 function checked (length
) {
996 // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
997 // length is NaN (which is otherwise coerced to zero.)
998 if (length
>= K_MAX_LENGTH
) {
999 throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
1000 'size: 0x' + K_MAX_LENGTH
.toString(16) + ' bytes')
1005 function SlowBuffer (length
) {
1006 if (+length
!= length
) { // eslint-disable-line eqeqeq
1009 return Buffer
.alloc(+length
)
1012 Buffer
.isBuffer
= function isBuffer (b
) {
1013 return b
!= null && b
._isBuffer
=== true
1016 Buffer
.compare
= function compare (a
, b
) {
1017 if (!Buffer
.isBuffer(a
) || !Buffer
.isBuffer(b
)) {
1018 throw new TypeError('Arguments must be Buffers')
1021 if (a
=== b
) return 0
1026 for (var i
= 0, len
= Math
.min(x
, y
); i
< len
; ++i
) {
1027 if (a
[i
] !== b
[i
]) {
1034 if (x
< y
) return -1
1039 Buffer
.isEncoding
= function isEncoding (encoding
) {
1040 switch (String(encoding
).toLowerCase()) {
1058 Buffer
.concat
= function concat (list
, length
) {
1059 if (!Array
.isArray(list
)) {
1060 throw new TypeError('"list" argument must be an Array of Buffers')
1063 if (list
.length
=== 0) {
1064 return Buffer
.alloc(0)
1068 if (length
=== undefined) {
1070 for (i
= 0; i
< list
.length
; ++i
) {
1071 length
+= list
[i
].length
1075 var buffer
= Buffer
.allocUnsafe(length
)
1077 for (i
= 0; i
< list
.length
; ++i
) {
1079 if (!Buffer
.isBuffer(buf
)) {
1080 throw new TypeError('"list" argument must be an Array of Buffers')
1082 buf
.copy(buffer
, pos
)
1088 function byteLength (string
, encoding
) {
1089 if (Buffer
.isBuffer(string
)) {
1090 return string
.length
1092 if (ArrayBuffer
.isView(string
) || string
instanceof ArrayBuffer
) {
1093 return string
.byteLength
1095 if (typeof string
!== 'string') {
1096 string
= '' + string
1099 var len
= string
.length
1100 if (len
=== 0) return 0
1102 // Use a for loop to avoid recursion
1103 var loweredCase
= false
1113 return utf8ToBytes(string
).length
1122 return base64ToBytes(string
).length
1124 if (loweredCase
) return utf8ToBytes(string
).length
// assume utf8
1125 encoding
= ('' + encoding
).toLowerCase()
1130 Buffer
.byteLength
= byteLength
1132 function slowToString (encoding
, start
, end
) {
1133 var loweredCase
= false
1135 // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
1136 // property of a typed array.
1138 // This behaves neither like String nor Uint8Array in that we set start/end
1139 // to their upper/lower bounds if the value passed is out of range.
1140 // undefined is handled specially as per ECMA-262 6th Edition,
1141 // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
1142 if (start
=== undefined || start
< 0) {
1145 // Return early if start > this.length. Done here to prevent potential uint32
1146 // coercion fail below.
1147 if (start
> this.length
) {
1151 if (end
=== undefined || end
> this.length
) {
1159 // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
1167 if (!encoding
) encoding
= 'utf8'
1172 return hexSlice(this, start
, end
)
1176 return utf8Slice(this, start
, end
)
1179 return asciiSlice(this, start
, end
)
1183 return latin1Slice(this, start
, end
)
1186 return base64Slice(this, start
, end
)
1192 return utf16leSlice(this, start
, end
)
1195 if (loweredCase
) throw new TypeError('Unknown encoding: ' + encoding
)
1196 encoding
= (encoding
+ '').toLowerCase()
1202 // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
1203 // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
1204 // reliably in a browserify context because there could be multiple different
1205 // copies of the 'buffer' package in use. This method works even for Buffer
1206 // instances that were created from another copy of the `buffer` package.
1207 // See: https://github.com/feross/buffer/issues/154
1208 Buffer
.prototype._isBuffer
= true
1210 function swap (b
, n
, m
) {
1216 Buffer
.prototype.swap16
= function swap16 () {
1217 var len
= this.length
1218 if (len
% 2 !== 0) {
1219 throw new RangeError('Buffer size must be a multiple of 16-bits')
1221 for (var i
= 0; i
< len
; i
+= 2) {
1222 swap(this, i
, i
+ 1)
1227 Buffer
.prototype.swap32
= function swap32 () {
1228 var len
= this.length
1229 if (len
% 4 !== 0) {
1230 throw new RangeError('Buffer size must be a multiple of 32-bits')
1232 for (var i
= 0; i
< len
; i
+= 4) {
1233 swap(this, i
, i
+ 3)
1234 swap(this, i
+ 1, i
+ 2)
1239 Buffer
.prototype.swap64
= function swap64 () {
1240 var len
= this.length
1241 if (len
% 8 !== 0) {
1242 throw new RangeError('Buffer size must be a multiple of 64-bits')
1244 for (var i
= 0; i
< len
; i
+= 8) {
1245 swap(this, i
, i
+ 7)
1246 swap(this, i
+ 1, i
+ 6)
1247 swap(this, i
+ 2, i
+ 5)
1248 swap(this, i
+ 3, i
+ 4)
1253 Buffer
.prototype.toString
= function toString () {
1254 var length
= this.length
1255 if (length
=== 0) return ''
1256 if (arguments
.length
=== 0) return utf8Slice(this, 0, length
)
1257 return slowToString
.apply(this, arguments
)
1260 Buffer
.prototype.equals
= function equals (b
) {
1261 if (!Buffer
.isBuffer(b
)) throw new TypeError('Argument must be a Buffer')
1262 if (this === b
) return true
1263 return Buffer
.compare(this, b
) === 0
1266 Buffer
.prototype.inspect
= function inspect () {
1268 var max
= exports
.INSPECT_MAX_BYTES
1269 if (this.length
> 0) {
1270 str
= this.toString('hex', 0, max
).match(/.{2}/g).join(' ')
1271 if (this.length
> max
) str
+= ' ... '
1273 return '<Buffer ' + str
+ '>'
1276 Buffer
.prototype.compare
= function compare (target
, start
, end
, thisStart
, thisEnd
) {
1277 if (!Buffer
.isBuffer(target
)) {
1278 throw new TypeError('Argument must be a Buffer')
1281 if (start
=== undefined) {
1284 if (end
=== undefined) {
1285 end
= target
? target
.length : 0
1287 if (thisStart
=== undefined) {
1290 if (thisEnd
=== undefined) {
1291 thisEnd
= this.length
1294 if (start
< 0 || end
> target
.length
|| thisStart
< 0 || thisEnd
> this.length
) {
1295 throw new RangeError('out of range index')
1298 if (thisStart
>= thisEnd
&& start
>= end
) {
1301 if (thisStart
>= thisEnd
) {
1313 if (this === target
) return 0
1315 var x
= thisEnd
- thisStart
1317 var len
= Math
.min(x
, y
)
1319 var thisCopy
= this.slice(thisStart
, thisEnd
)
1320 var targetCopy
= target
.slice(start
, end
)
1322 for (var i
= 0; i
< len
; ++i
) {
1323 if (thisCopy
[i
] !== targetCopy
[i
]) {
1330 if (x
< y
) return -1
1335 // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
1336 // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
1339 // - buffer - a Buffer to search
1340 // - val - a string, Buffer, or number
1341 // - byteOffset - an index into `buffer`; will be clamped to an int32
1342 // - encoding - an optional encoding, relevant is val is a string
1343 // - dir - true for indexOf, false for lastIndexOf
1344 function bidirectionalIndexOf (buffer
, val
, byteOffset
, encoding
, dir
) {
1345 // Empty buffer means no match
1346 if (buffer
.length
=== 0) return -1
1348 // Normalize byteOffset
1349 if (typeof byteOffset
=== 'string') {
1350 encoding
= byteOffset
1352 } else if (byteOffset
> 0x7fffffff) {
1353 byteOffset
= 0x7fffffff
1354 } else if (byteOffset
< -0x80000000) {
1355 byteOffset
= -0x80000000
1357 byteOffset
= +byteOffset
// Coerce to Number.
1358 if (isNaN(byteOffset
)) {
1359 // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
1360 byteOffset
= dir
? 0 : (buffer
.length
- 1)
1363 // Normalize byteOffset: negative offsets start from the end of the buffer
1364 if (byteOffset
< 0) byteOffset
= buffer
.length
+ byteOffset
1365 if (byteOffset
>= buffer
.length
) {
1367 else byteOffset
= buffer
.length
- 1
1368 } else if (byteOffset
< 0) {
1369 if (dir
) byteOffset
= 0
1374 if (typeof val
=== 'string') {
1375 val
= Buffer
.from(val
, encoding
)
1378 // Finally, search either indexOf (if dir is true) or lastIndexOf
1379 if (Buffer
.isBuffer(val
)) {
1380 // Special case: looking for empty string/buffer always fails
1381 if (val
.length
=== 0) {
1384 return arrayIndexOf(buffer
, val
, byteOffset
, encoding
, dir
)
1385 } else if (typeof val
=== 'number') {
1386 val
= val
& 0xFF // Search for a byte value [0-255]
1387 if (typeof Uint8Array
.prototype.indexOf
=== 'function') {
1389 return Uint8Array
.prototype.indexOf
.call(buffer
, val
, byteOffset
)
1391 return Uint8Array
.prototype.lastIndexOf
.call(buffer
, val
, byteOffset
)
1394 return arrayIndexOf(buffer
, [ val
], byteOffset
, encoding
, dir
)
1397 throw new TypeError('val must be string, number or Buffer')
1400 function arrayIndexOf (arr
, val
, byteOffset
, encoding
, dir
) {
1402 var arrLength
= arr
.length
1403 var valLength
= val
.length
1405 if (encoding
!== undefined) {
1406 encoding
= String(encoding
).toLowerCase()
1407 if (encoding
=== 'ucs2' || encoding
=== 'ucs-2' ||
1408 encoding
=== 'utf16le' || encoding
=== 'utf-16le') {
1409 if (arr
.length
< 2 || val
.length
< 2) {
1419 function read (buf
, i
) {
1420 if (indexSize
=== 1) {
1423 return buf
.readUInt16BE(i
* indexSize
)
1430 for (i
= byteOffset
; i
< arrLength
; i
++) {
1431 if (read(arr
, i
) === read(val
, foundIndex
=== -1 ? 0 : i
- foundIndex
)) {
1432 if (foundIndex
=== -1) foundIndex
= i
1433 if (i
- foundIndex
+ 1 === valLength
) return foundIndex
* indexSize
1435 if (foundIndex
!== -1) i
-= i
- foundIndex
1440 if (byteOffset
+ valLength
> arrLength
) byteOffset
= arrLength
- valLength
1441 for (i
= byteOffset
; i
>= 0; i
--) {
1443 for (var j
= 0; j
< valLength
; j
++) {
1444 if (read(arr
, i
+ j
) !== read(val
, j
)) {
1456 Buffer
.prototype.includes
= function includes (val
, byteOffset
, encoding
) {
1457 return this.indexOf(val
, byteOffset
, encoding
) !== -1
1460 Buffer
.prototype.indexOf
= function indexOf (val
, byteOffset
, encoding
) {
1461 return bidirectionalIndexOf(this, val
, byteOffset
, encoding
, true)
1464 Buffer
.prototype.lastIndexOf
= function lastIndexOf (val
, byteOffset
, encoding
) {
1465 return bidirectionalIndexOf(this, val
, byteOffset
, encoding
, false)
1468 function hexWrite (buf
, string
, offset
, length
) {
1469 offset
= Number(offset
) || 0
1470 var remaining
= buf
.length
- offset
1474 length
= Number(length
)
1475 if (length
> remaining
) {
1480 // must be an even number of digits
1481 var strLen
= string
.length
1482 if (strLen
% 2 !== 0) throw new TypeError('Invalid hex string')
1484 if (length
> strLen
/ 2) {
1487 for (var i
= 0; i
< length
; ++i
) {
1488 var parsed
= parseInt(string
.substr(i
* 2, 2), 16)
1489 if (isNaN(parsed
)) return i
1490 buf
[offset
+ i
] = parsed
1495 function utf8Write (buf
, string
, offset
, length
) {
1496 return blitBuffer(utf8ToBytes(string
, buf
.length
- offset
), buf
, offset
, length
)
1499 function asciiWrite (buf
, string
, offset
, length
) {
1500 return blitBuffer(asciiToBytes(string
), buf
, offset
, length
)
1503 function latin1Write (buf
, string
, offset
, length
) {
1504 return asciiWrite(buf
, string
, offset
, length
)
1507 function base64Write (buf
, string
, offset
, length
) {
1508 return blitBuffer(base64ToBytes(string
), buf
, offset
, length
)
1511 function ucs2Write (buf
, string
, offset
, length
) {
1512 return blitBuffer(utf16leToBytes(string
, buf
.length
- offset
), buf
, offset
, length
)
1515 Buffer
.prototype.write
= function write (string
, offset
, length
, encoding
) {
1516 // Buffer#write(string)
1517 if (offset
=== undefined) {
1519 length
= this.length
1521 // Buffer#write(string, encoding)
1522 } else if (length
=== undefined && typeof offset
=== 'string') {
1524 length
= this.length
1526 // Buffer#write(string, offset[, length][, encoding])
1527 } else if (isFinite(offset
)) {
1528 offset
= offset
>>> 0
1529 if (isFinite(length
)) {
1530 length
= length
>>> 0
1531 if (encoding
=== undefined) encoding
= 'utf8'
1538 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
1542 var remaining
= this.length
- offset
1543 if (length
=== undefined || length
> remaining
) length
= remaining
1545 if ((string
.length
> 0 && (length
< 0 || offset
< 0)) || offset
> this.length
) {
1546 throw new RangeError('Attempt to write outside buffer bounds')
1549 if (!encoding
) encoding
= 'utf8'
1551 var loweredCase
= false
1555 return hexWrite(this, string
, offset
, length
)
1559 return utf8Write(this, string
, offset
, length
)
1562 return asciiWrite(this, string
, offset
, length
)
1566 return latin1Write(this, string
, offset
, length
)
1569 // Warning: maxLength not taken into account in base64Write
1570 return base64Write(this, string
, offset
, length
)
1576 return ucs2Write(this, string
, offset
, length
)
1579 if (loweredCase
) throw new TypeError('Unknown encoding: ' + encoding
)
1580 encoding
= ('' + encoding
).toLowerCase()
1586 Buffer
.prototype.toJSON
= function toJSON () {
1589 data: Array
.prototype.slice
.call(this._arr
|| this, 0)
1593 function base64Slice (buf
, start
, end
) {
1594 if (start
=== 0 && end
=== buf
.length
) {
1595 return base64
.fromByteArray(buf
)
1597 return base64
.fromByteArray(buf
.slice(start
, end
))
1601 function utf8Slice (buf
, start
, end
) {
1602 end
= Math
.min(buf
.length
, end
)
1607 var firstByte
= buf
[i
]
1608 var codePoint
= null
1609 var bytesPerSequence
= (firstByte
> 0xEF) ? 4
1610 : (firstByte
> 0xDF) ? 3
1611 : (firstByte
> 0xBF) ? 2
1614 if (i
+ bytesPerSequence
<= end
) {
1615 var secondByte
, thirdByte
, fourthByte
, tempCodePoint
1617 switch (bytesPerSequence
) {
1619 if (firstByte
< 0x80) {
1620 codePoint
= firstByte
1624 secondByte
= buf
[i
+ 1]
1625 if ((secondByte
& 0xC0) === 0x80) {
1626 tempCodePoint
= (firstByte
& 0x1F) << 0x6 | (secondByte
& 0x3F)
1627 if (tempCodePoint
> 0x7F) {
1628 codePoint
= tempCodePoint
1633 secondByte
= buf
[i
+ 1]
1634 thirdByte
= buf
[i
+ 2]
1635 if ((secondByte
& 0xC0) === 0x80 && (thirdByte
& 0xC0) === 0x80) {
1636 tempCodePoint
= (firstByte
& 0xF) << 0xC | (secondByte
& 0x3F) << 0x6 | (thirdByte
& 0x3F)
1637 if (tempCodePoint
> 0x7FF && (tempCodePoint
< 0xD800 || tempCodePoint
> 0xDFFF)) {
1638 codePoint
= tempCodePoint
1643 secondByte
= buf
[i
+ 1]
1644 thirdByte
= buf
[i
+ 2]
1645 fourthByte
= buf
[i
+ 3]
1646 if ((secondByte
& 0xC0) === 0x80 && (thirdByte
& 0xC0) === 0x80 && (fourthByte
& 0xC0) === 0x80) {
1647 tempCodePoint
= (firstByte
& 0xF) << 0x12 | (secondByte
& 0x3F) << 0xC | (thirdByte
& 0x3F) << 0x6 | (fourthByte
& 0x3F)
1648 if (tempCodePoint
> 0xFFFF && tempCodePoint
< 0x110000) {
1649 codePoint
= tempCodePoint
1655 if (codePoint
=== null) {
1656 // we did not generate a valid codePoint so insert a
1657 // replacement char (U+FFFD) and advance only 1 byte
1659 bytesPerSequence
= 1
1660 } else if (codePoint
> 0xFFFF) {
1661 // encode to utf16 (surrogate pair dance)
1662 codePoint
-= 0x10000
1663 res
.push(codePoint
>>> 10 & 0x3FF | 0xD800)
1664 codePoint
= 0xDC00 | codePoint
& 0x3FF
1668 i
+= bytesPerSequence
1671 return decodeCodePointsArray(res
)
1674 // Based on http://stackoverflow.com/a/22747272/680742, the browser with
1675 // the lowest limit is Chrome, with 0x10000 args.
1676 // We go 1 magnitude less, for safety
1677 var MAX_ARGUMENTS_LENGTH
= 0x1000
1679 function decodeCodePointsArray (codePoints
) {
1680 var len
= codePoints
.length
1681 if (len
<= MAX_ARGUMENTS_LENGTH
) {
1682 return String
.fromCharCode
.apply(String
, codePoints
) // avoid extra slice()
1685 // Decode in chunks to avoid "call stack size exceeded".
1689 res
+= String
.fromCharCode
.apply(
1691 codePoints
.slice(i
, i
+= MAX_ARGUMENTS_LENGTH
)
1697 function asciiSlice (buf
, start
, end
) {
1699 end
= Math
.min(buf
.length
, end
)
1701 for (var i
= start
; i
< end
; ++i
) {
1702 ret
+= String
.fromCharCode(buf
[i
] & 0x7F)
1707 function latin1Slice (buf
, start
, end
) {
1709 end
= Math
.min(buf
.length
, end
)
1711 for (var i
= start
; i
< end
; ++i
) {
1712 ret
+= String
.fromCharCode(buf
[i
])
1717 function hexSlice (buf
, start
, end
) {
1718 var len
= buf
.length
1720 if (!start
|| start
< 0) start
= 0
1721 if (!end
|| end
< 0 || end
> len
) end
= len
1724 for (var i
= start
; i
< end
; ++i
) {
1725 out
+= toHex(buf
[i
])
1730 function utf16leSlice (buf
, start
, end
) {
1731 var bytes
= buf
.slice(start
, end
)
1733 for (var i
= 0; i
< bytes
.length
; i
+= 2) {
1734 res
+= String
.fromCharCode(bytes
[i
] + (bytes
[i
+ 1] * 256))
1739 Buffer
.prototype.slice
= function slice (start
, end
) {
1740 var len
= this.length
1742 end
= end
=== undefined ? len : ~~end
1746 if (start
< 0) start
= 0
1747 } else if (start
> len
) {
1753 if (end
< 0) end
= 0
1754 } else if (end
> len
) {
1758 if (end
< start
) end
= start
1760 var newBuf
= this.subarray(start
, end
)
1761 // Return an augmented `Uint8Array` instance
1762 newBuf
.__proto__
= Buffer
.prototype
1767 * Need to make sure that buffer isn't trying to write out of bounds.
1769 function checkOffset (offset
, ext
, length
) {
1770 if ((offset
% 1) !== 0 || offset
< 0) throw new RangeError('offset is not uint')
1771 if (offset
+ ext
> length
) throw new RangeError('Trying to access beyond buffer length')
1774 Buffer
.prototype.readUIntLE
= function readUIntLE (offset
, byteLength
, noAssert
) {
1775 offset
= offset
>>> 0
1776 byteLength
= byteLength
>>> 0
1777 if (!noAssert
) checkOffset(offset
, byteLength
, this.length
)
1779 var val
= this[offset
]
1782 while (++i
< byteLength
&& (mul
*= 0x100)) {
1783 val
+= this[offset
+ i
] * mul
1789 Buffer
.prototype.readUIntBE
= function readUIntBE (offset
, byteLength
, noAssert
) {
1790 offset
= offset
>>> 0
1791 byteLength
= byteLength
>>> 0
1793 checkOffset(offset
, byteLength
, this.length
)
1796 var val
= this[offset
+ --byteLength
]
1798 while (byteLength
> 0 && (mul
*= 0x100)) {
1799 val
+= this[offset
+ --byteLength
] * mul
1805 Buffer
.prototype.readUInt8
= function readUInt8 (offset
, noAssert
) {
1806 offset
= offset
>>> 0
1807 if (!noAssert
) checkOffset(offset
, 1, this.length
)
1811 Buffer
.prototype.readUInt16LE
= function readUInt16LE (offset
, noAssert
) {
1812 offset
= offset
>>> 0
1813 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1814 return this[offset
] | (this[offset
+ 1] << 8)
1817 Buffer
.prototype.readUInt16BE
= function readUInt16BE (offset
, noAssert
) {
1818 offset
= offset
>>> 0
1819 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1820 return (this[offset
] << 8) | this[offset
+ 1]
1823 Buffer
.prototype.readUInt32LE
= function readUInt32LE (offset
, noAssert
) {
1824 offset
= offset
>>> 0
1825 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1827 return ((this[offset
]) |
1828 (this[offset
+ 1] << 8) |
1829 (this[offset
+ 2] << 16)) +
1830 (this[offset
+ 3] * 0x1000000)
1833 Buffer
.prototype.readUInt32BE
= function readUInt32BE (offset
, noAssert
) {
1834 offset
= offset
>>> 0
1835 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1837 return (this[offset
] * 0x1000000) +
1838 ((this[offset
+ 1] << 16) |
1839 (this[offset
+ 2] << 8) |
1843 Buffer
.prototype.readIntLE
= function readIntLE (offset
, byteLength
, noAssert
) {
1844 offset
= offset
>>> 0
1845 byteLength
= byteLength
>>> 0
1846 if (!noAssert
) checkOffset(offset
, byteLength
, this.length
)
1848 var val
= this[offset
]
1851 while (++i
< byteLength
&& (mul
*= 0x100)) {
1852 val
+= this[offset
+ i
] * mul
1856 if (val
>= mul
) val
-= Math
.pow(2, 8 * byteLength
)
1861 Buffer
.prototype.readIntBE
= function readIntBE (offset
, byteLength
, noAssert
) {
1862 offset
= offset
>>> 0
1863 byteLength
= byteLength
>>> 0
1864 if (!noAssert
) checkOffset(offset
, byteLength
, this.length
)
1868 var val
= this[offset
+ --i
]
1869 while (i
> 0 && (mul
*= 0x100)) {
1870 val
+= this[offset
+ --i
] * mul
1874 if (val
>= mul
) val
-= Math
.pow(2, 8 * byteLength
)
1879 Buffer
.prototype.readInt8
= function readInt8 (offset
, noAssert
) {
1880 offset
= offset
>>> 0
1881 if (!noAssert
) checkOffset(offset
, 1, this.length
)
1882 if (!(this[offset
] & 0x80)) return (this[offset
])
1883 return ((0xff - this[offset
] + 1) * -1)
1886 Buffer
.prototype.readInt16LE
= function readInt16LE (offset
, noAssert
) {
1887 offset
= offset
>>> 0
1888 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1889 var val
= this[offset
] | (this[offset
+ 1] << 8)
1890 return (val
& 0x8000) ? val
| 0xFFFF0000 : val
1893 Buffer
.prototype.readInt16BE
= function readInt16BE (offset
, noAssert
) {
1894 offset
= offset
>>> 0
1895 if (!noAssert
) checkOffset(offset
, 2, this.length
)
1896 var val
= this[offset
+ 1] | (this[offset
] << 8)
1897 return (val
& 0x8000) ? val
| 0xFFFF0000 : val
1900 Buffer
.prototype.readInt32LE
= function readInt32LE (offset
, noAssert
) {
1901 offset
= offset
>>> 0
1902 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1904 return (this[offset
]) |
1905 (this[offset
+ 1] << 8) |
1906 (this[offset
+ 2] << 16) |
1907 (this[offset
+ 3] << 24)
1910 Buffer
.prototype.readInt32BE
= function readInt32BE (offset
, noAssert
) {
1911 offset
= offset
>>> 0
1912 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1914 return (this[offset
] << 24) |
1915 (this[offset
+ 1] << 16) |
1916 (this[offset
+ 2] << 8) |
1920 Buffer
.prototype.readFloatLE
= function readFloatLE (offset
, noAssert
) {
1921 offset
= offset
>>> 0
1922 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1923 return ieee754
.read(this, offset
, true, 23, 4)
1926 Buffer
.prototype.readFloatBE
= function readFloatBE (offset
, noAssert
) {
1927 offset
= offset
>>> 0
1928 if (!noAssert
) checkOffset(offset
, 4, this.length
)
1929 return ieee754
.read(this, offset
, false, 23, 4)
1932 Buffer
.prototype.readDoubleLE
= function readDoubleLE (offset
, noAssert
) {
1933 offset
= offset
>>> 0
1934 if (!noAssert
) checkOffset(offset
, 8, this.length
)
1935 return ieee754
.read(this, offset
, true, 52, 8)
1938 Buffer
.prototype.readDoubleBE
= function readDoubleBE (offset
, noAssert
) {
1939 offset
= offset
>>> 0
1940 if (!noAssert
) checkOffset(offset
, 8, this.length
)
1941 return ieee754
.read(this, offset
, false, 52, 8)
1944 function checkInt (buf
, value
, offset
, ext
, max
, min
) {
1945 if (!Buffer
.isBuffer(buf
)) throw new TypeError('"buffer" argument must be a Buffer instance')
1946 if (value
> max
|| value
< min
) throw new RangeError('"value" argument is out of bounds')
1947 if (offset
+ ext
> buf
.length
) throw new RangeError('Index out of range')
1950 Buffer
.prototype.writeUIntLE
= function writeUIntLE (value
, offset
, byteLength
, noAssert
) {
1952 offset
= offset
>>> 0
1953 byteLength
= byteLength
>>> 0
1955 var maxBytes
= Math
.pow(2, 8 * byteLength
) - 1
1956 checkInt(this, value
, offset
, byteLength
, maxBytes
, 0)
1961 this[offset
] = value
& 0xFF
1962 while (++i
< byteLength
&& (mul
*= 0x100)) {
1963 this[offset
+ i
] = (value
/ mul
) & 0xFF
1966 return offset
+ byteLength
1969 Buffer
.prototype.writeUIntBE
= function writeUIntBE (value
, offset
, byteLength
, noAssert
) {
1971 offset
= offset
>>> 0
1972 byteLength
= byteLength
>>> 0
1974 var maxBytes
= Math
.pow(2, 8 * byteLength
) - 1
1975 checkInt(this, value
, offset
, byteLength
, maxBytes
, 0)
1978 var i
= byteLength
- 1
1980 this[offset
+ i
] = value
& 0xFF
1981 while (--i
>= 0 && (mul
*= 0x100)) {
1982 this[offset
+ i
] = (value
/ mul
) & 0xFF
1985 return offset
+ byteLength
1988 Buffer
.prototype.writeUInt8
= function writeUInt8 (value
, offset
, noAssert
) {
1990 offset
= offset
>>> 0
1991 if (!noAssert
) checkInt(this, value
, offset
, 1, 0xff, 0)
1992 this[offset
] = (value
& 0xff)
1996 Buffer
.prototype.writeUInt16LE
= function writeUInt16LE (value
, offset
, noAssert
) {
1998 offset
= offset
>>> 0
1999 if (!noAssert
) checkInt(this, value
, offset
, 2, 0xffff, 0)
2000 this[offset
] = (value
& 0xff)
2001 this[offset
+ 1] = (value
>>> 8)
2005 Buffer
.prototype.writeUInt16BE
= function writeUInt16BE (value
, offset
, noAssert
) {
2007 offset
= offset
>>> 0
2008 if (!noAssert
) checkInt(this, value
, offset
, 2, 0xffff, 0)
2009 this[offset
] = (value
>>> 8)
2010 this[offset
+ 1] = (value
& 0xff)
2014 Buffer
.prototype.writeUInt32LE
= function writeUInt32LE (value
, offset
, noAssert
) {
2016 offset
= offset
>>> 0
2017 if (!noAssert
) checkInt(this, value
, offset
, 4, 0xffffffff, 0)
2018 this[offset
+ 3] = (value
>>> 24)
2019 this[offset
+ 2] = (value
>>> 16)
2020 this[offset
+ 1] = (value
>>> 8)
2021 this[offset
] = (value
& 0xff)
2025 Buffer
.prototype.writeUInt32BE
= function writeUInt32BE (value
, offset
, noAssert
) {
2027 offset
= offset
>>> 0
2028 if (!noAssert
) checkInt(this, value
, offset
, 4, 0xffffffff, 0)
2029 this[offset
] = (value
>>> 24)
2030 this[offset
+ 1] = (value
>>> 16)
2031 this[offset
+ 2] = (value
>>> 8)
2032 this[offset
+ 3] = (value
& 0xff)
2036 Buffer
.prototype.writeIntLE
= function writeIntLE (value
, offset
, byteLength
, noAssert
) {
2038 offset
= offset
>>> 0
2040 var limit
= Math
.pow(2, (8 * byteLength
) - 1)
2042 checkInt(this, value
, offset
, byteLength
, limit
- 1, -limit
)
2048 this[offset
] = value
& 0xFF
2049 while (++i
< byteLength
&& (mul
*= 0x100)) {
2050 if (value
< 0 && sub
=== 0 && this[offset
+ i
- 1] !== 0) {
2053 this[offset
+ i
] = ((value
/ mul
) >> 0) - sub
& 0xFF
2056 return offset
+ byteLength
2059 Buffer
.prototype.writeIntBE
= function writeIntBE (value
, offset
, byteLength
, noAssert
) {
2061 offset
= offset
>>> 0
2063 var limit
= Math
.pow(2, (8 * byteLength
) - 1)
2065 checkInt(this, value
, offset
, byteLength
, limit
- 1, -limit
)
2068 var i
= byteLength
- 1
2071 this[offset
+ i
] = value
& 0xFF
2072 while (--i
>= 0 && (mul
*= 0x100)) {
2073 if (value
< 0 && sub
=== 0 && this[offset
+ i
+ 1] !== 0) {
2076 this[offset
+ i
] = ((value
/ mul
) >> 0) - sub
& 0xFF
2079 return offset
+ byteLength
2082 Buffer
.prototype.writeInt8
= function writeInt8 (value
, offset
, noAssert
) {
2084 offset
= offset
>>> 0
2085 if (!noAssert
) checkInt(this, value
, offset
, 1, 0x7f, -0x80)
2086 if (value
< 0) value
= 0xff + value
+ 1
2087 this[offset
] = (value
& 0xff)
2091 Buffer
.prototype.writeInt16LE
= function writeInt16LE (value
, offset
, noAssert
) {
2093 offset
= offset
>>> 0
2094 if (!noAssert
) checkInt(this, value
, offset
, 2, 0x7fff, -0x8000)
2095 this[offset
] = (value
& 0xff)
2096 this[offset
+ 1] = (value
>>> 8)
2100 Buffer
.prototype.writeInt16BE
= function writeInt16BE (value
, offset
, noAssert
) {
2102 offset
= offset
>>> 0
2103 if (!noAssert
) checkInt(this, value
, offset
, 2, 0x7fff, -0x8000)
2104 this[offset
] = (value
>>> 8)
2105 this[offset
+ 1] = (value
& 0xff)
2109 Buffer
.prototype.writeInt32LE
= function writeInt32LE (value
, offset
, noAssert
) {
2111 offset
= offset
>>> 0
2112 if (!noAssert
) checkInt(this, value
, offset
, 4, 0x7fffffff, -0x80000000)
2113 this[offset
] = (value
& 0xff)
2114 this[offset
+ 1] = (value
>>> 8)
2115 this[offset
+ 2] = (value
>>> 16)
2116 this[offset
+ 3] = (value
>>> 24)
2120 Buffer
.prototype.writeInt32BE
= function writeInt32BE (value
, offset
, noAssert
) {
2122 offset
= offset
>>> 0
2123 if (!noAssert
) checkInt(this, value
, offset
, 4, 0x7fffffff, -0x80000000)
2124 if (value
< 0) value
= 0xffffffff + value
+ 1
2125 this[offset
] = (value
>>> 24)
2126 this[offset
+ 1] = (value
>>> 16)
2127 this[offset
+ 2] = (value
>>> 8)
2128 this[offset
+ 3] = (value
& 0xff)
2132 function checkIEEE754 (buf
, value
, offset
, ext
, max
, min
) {
2133 if (offset
+ ext
> buf
.length
) throw new RangeError('Index out of range')
2134 if (offset
< 0) throw new RangeError('Index out of range')
2137 function writeFloat (buf
, value
, offset
, littleEndian
, noAssert
) {
2139 offset
= offset
>>> 0
2141 checkIEEE754(buf
, value
, offset
, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
2143 ieee754
.write(buf
, value
, offset
, littleEndian
, 23, 4)
2147 Buffer
.prototype.writeFloatLE
= function writeFloatLE (value
, offset
, noAssert
) {
2148 return writeFloat(this, value
, offset
, true, noAssert
)
2151 Buffer
.prototype.writeFloatBE
= function writeFloatBE (value
, offset
, noAssert
) {
2152 return writeFloat(this, value
, offset
, false, noAssert
)
2155 function writeDouble (buf
, value
, offset
, littleEndian
, noAssert
) {
2157 offset
= offset
>>> 0
2159 checkIEEE754(buf
, value
, offset
, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
2161 ieee754
.write(buf
, value
, offset
, littleEndian
, 52, 8)
2165 Buffer
.prototype.writeDoubleLE
= function writeDoubleLE (value
, offset
, noAssert
) {
2166 return writeDouble(this, value
, offset
, true, noAssert
)
2169 Buffer
.prototype.writeDoubleBE
= function writeDoubleBE (value
, offset
, noAssert
) {
2170 return writeDouble(this, value
, offset
, false, noAssert
)
2173 // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
2174 Buffer
.prototype.copy
= function copy (target
, targetStart
, start
, end
) {
2175 if (!start
) start
= 0
2176 if (!end
&& end
!== 0) end
= this.length
2177 if (targetStart
>= target
.length
) targetStart
= target
.length
2178 if (!targetStart
) targetStart
= 0
2179 if (end
> 0 && end
< start
) end
= start
2181 // Copy 0 bytes; we're done
2182 if (end
=== start
) return 0
2183 if (target
.length
=== 0 || this.length
=== 0) return 0
2185 // Fatal error conditions
2186 if (targetStart
< 0) {
2187 throw new RangeError('targetStart out of bounds')
2189 if (start
< 0 || start
>= this.length
) throw new RangeError('sourceStart out of bounds')
2190 if (end
< 0) throw new RangeError('sourceEnd out of bounds')
2193 if (end
> this.length
) end
= this.length
2194 if (target
.length
- targetStart
< end
- start
) {
2195 end
= target
.length
- targetStart
+ start
2198 var len
= end
- start
2201 if (this === target
&& start
< targetStart
&& targetStart
< end
) {
2202 // descending copy from end
2203 for (i
= len
- 1; i
>= 0; --i
) {
2204 target
[i
+ targetStart
] = this[i
+ start
]
2206 } else if (len
< 1000) {
2207 // ascending copy from start
2208 for (i
= 0; i
< len
; ++i
) {
2209 target
[i
+ targetStart
] = this[i
+ start
]
2212 Uint8Array
.prototype.set.call(
2214 this.subarray(start
, start
+ len
),
2223 // buffer.fill(number[, offset[, end]])
2224 // buffer.fill(buffer[, offset[, end]])
2225 // buffer.fill(string[, offset[, end]][, encoding])
2226 Buffer
.prototype.fill
= function fill (val
, start
, end
, encoding
) {
2227 // Handle string cases:
2228 if (typeof val
=== 'string') {
2229 if (typeof start
=== 'string') {
2233 } else if (typeof end
=== 'string') {
2237 if (val
.length
=== 1) {
2238 var code
= val
.charCodeAt(0)
2243 if (encoding
!== undefined && typeof encoding
!== 'string') {
2244 throw new TypeError('encoding must be a string')
2246 if (typeof encoding
=== 'string' && !Buffer
.isEncoding(encoding
)) {
2247 throw new TypeError('Unknown encoding: ' + encoding
)
2249 } else if (typeof val
=== 'number') {
2253 // Invalid ranges are not set to a default, so can range check early.
2254 if (start
< 0 || this.length
< start
|| this.length
< end
) {
2255 throw new RangeError('Out of range index')
2263 end
= end
=== undefined ? this.length : end
>>> 0
2268 if (typeof val
=== 'number') {
2269 for (i
= start
; i
< end
; ++i
) {
2273 var bytes
= Buffer
.isBuffer(val
)
2275 : new Buffer(val
, encoding
)
2276 var len
= bytes
.length
2277 for (i
= 0; i
< end
- start
; ++i
) {
2278 this[i
+ start
] = bytes
[i
% len
]
2288 var INVALID_BASE64_RE
= /[^+/0-9A
-Za
-z
-_
]/g
2290 function base64clean (str
) {
2291 // Node strips out invalid characters like \n and \t from the string, base64-js does not
2292 str
= stringtrim(str
).replace(INVALID_BASE64_RE
, '')
2293 // Node converts strings with length < 2 to ''
2294 if (str
.length
< 2) return ''
2295 // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
2296 while (str
.length
% 4 !== 0) {
2302 function stringtrim (str
) {
2303 if (str
.trim
) return str
.trim()
2304 return str
.replace(/^\s+|\s+$/g, '')
2307 function toHex (n
) {
2308 if (n
< 16) return '0' + n
.toString(16)
2309 return n
.toString(16)
2312 function utf8ToBytes (string
, units
) {
2313 units
= units
|| Infinity
2315 var length
= string
.length
2316 var leadSurrogate
= null
2319 for (var i
= 0; i
< length
; ++i
) {
2320 codePoint
= string
.charCodeAt(i
)
2322 // is surrogate component
2323 if (codePoint
> 0xD7FF && codePoint
< 0xE000) {
2324 // last char was a lead
2325 if (!leadSurrogate
) {
2327 if (codePoint
> 0xDBFF) {
2329 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2331 } else if (i
+ 1 === length
) {
2333 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2338 leadSurrogate
= codePoint
2344 if (codePoint
< 0xDC00) {
2345 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2346 leadSurrogate
= codePoint
2350 // valid surrogate pair
2351 codePoint
= (leadSurrogate
- 0xD800 << 10 | codePoint
- 0xDC00) + 0x10000
2352 } else if (leadSurrogate
) {
2353 // valid bmp char, but last char was a lead
2354 if ((units
-= 3) > -1) bytes
.push(0xEF, 0xBF, 0xBD)
2357 leadSurrogate
= null
2360 if (codePoint
< 0x80) {
2361 if ((units
-= 1) < 0) break
2362 bytes
.push(codePoint
)
2363 } else if (codePoint
< 0x800) {
2364 if ((units
-= 2) < 0) break
2366 codePoint
>> 0x6 | 0xC0,
2367 codePoint
& 0x3F | 0x80
2369 } else if (codePoint
< 0x10000) {
2370 if ((units
-= 3) < 0) break
2372 codePoint
>> 0xC | 0xE0,
2373 codePoint
>> 0x6 & 0x3F | 0x80,
2374 codePoint
& 0x3F | 0x80
2376 } else if (codePoint
< 0x110000) {
2377 if ((units
-= 4) < 0) break
2379 codePoint
>> 0x12 | 0xF0,
2380 codePoint
>> 0xC & 0x3F | 0x80,
2381 codePoint
>> 0x6 & 0x3F | 0x80,
2382 codePoint
& 0x3F | 0x80
2385 throw new Error('Invalid code point')
2392 function asciiToBytes (str
) {
2394 for (var i
= 0; i
< str
.length
; ++i
) {
2395 // Node's code seems to be doing this and not & 0x7F..
2396 byteArray
.push(str
.charCodeAt(i
) & 0xFF)
2401 function utf16leToBytes (str
, units
) {
2404 for (var i
= 0; i
< str
.length
; ++i
) {
2405 if ((units
-= 2) < 0) break
2407 c
= str
.charCodeAt(i
)
2417 function base64ToBytes (str
) {
2418 return base64
.toByteArray(base64clean(str
))
2421 function blitBuffer (src
, dst
, offset
, length
) {
2422 for (var i
= 0; i
< length
; ++i
) {
2423 if ((i
+ offset
>= dst
.length
) || (i
>= src
.length
)) break
2424 dst
[i
+ offset
] = src
[i
]
2429 function isnan (val
) {
2430 return val
!== val
// eslint-disable-line no-self-compare
2433 },{"base64-js":2,"ieee754":8}],6:[function(require
,module
,exports
){
2435 // Copyright Joyent, Inc. and other Node contributors.
2437 // Permission is hereby granted, free of charge, to any person obtaining a
2438 // copy of this software and associated documentation files (the
2439 // "Software"), to deal in the Software without restriction, including
2440 // without limitation the rights to use, copy, modify, merge, publish,
2441 // distribute, sublicense, and/or sell copies of the Software, and to permit
2442 // persons to whom the Software is furnished to do so, subject to the
2443 // following conditions:
2445 // The above copyright notice and this permission notice shall be included
2446 // in all copies or substantial portions of the Software.
2448 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2449 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2450 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2451 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2452 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2453 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2454 // USE OR OTHER DEALINGS IN THE SOFTWARE.
2456 // NOTE: These type checking functions intentionally don't use `instanceof`
2457 // because it is fragile and can be easily faked with `Object.create()`.
2459 function isArray(arg
) {
2460 if (Array
.isArray
) {
2461 return Array
.isArray(arg
);
2463 return objectToString(arg
) === '[object Array]';
2465 exports
.isArray
= isArray
;
2467 function isBoolean(arg
) {
2468 return typeof arg
=== 'boolean';
2470 exports
.isBoolean
= isBoolean
;
2472 function isNull(arg
) {
2473 return arg
=== null;
2475 exports
.isNull
= isNull
;
2477 function isNullOrUndefined(arg
) {
2480 exports
.isNullOrUndefined
= isNullOrUndefined
;
2482 function isNumber(arg
) {
2483 return typeof arg
=== 'number';
2485 exports
.isNumber
= isNumber
;
2487 function isString(arg
) {
2488 return typeof arg
=== 'string';
2490 exports
.isString
= isString
;
2492 function isSymbol(arg
) {
2493 return typeof arg
=== 'symbol';
2495 exports
.isSymbol
= isSymbol
;
2497 function isUndefined(arg
) {
2498 return arg
=== void 0;
2500 exports
.isUndefined
= isUndefined
;
2502 function isRegExp(re
) {
2503 return objectToString(re
) === '[object RegExp]';
2505 exports
.isRegExp
= isRegExp
;
2507 function isObject(arg
) {
2508 return typeof arg
=== 'object' && arg
!== null;
2510 exports
.isObject
= isObject
;
2512 function isDate(d
) {
2513 return objectToString(d
) === '[object Date]';
2515 exports
.isDate
= isDate
;
2517 function isError(e
) {
2518 return (objectToString(e
) === '[object Error]' || e
instanceof Error
);
2520 exports
.isError
= isError
;
2522 function isFunction(arg
) {
2523 return typeof arg
=== 'function';
2525 exports
.isFunction
= isFunction
;
2527 function isPrimitive(arg
) {
2528 return arg
=== null ||
2529 typeof arg
=== 'boolean' ||
2530 typeof arg
=== 'number' ||
2531 typeof arg
=== 'string' ||
2532 typeof arg
=== 'symbol' || // ES6 symbol
2533 typeof arg
=== 'undefined';
2535 exports
.isPrimitive
= isPrimitive
;
2537 exports
.isBuffer
= Buffer
.isBuffer
;
2539 function objectToString(o
) {
2540 return Object
.prototype.toString
.call(o
);
2543 }).call(this,{"isBuffer":require("../../is-buffer/index.js")})
2544 },{"../../is-buffer/index.js":10}],7:[function(require
,module
,exports
){
2545 // Copyright Joyent, Inc. and other Node contributors.
2547 // Permission is hereby granted, free of charge, to any person obtaining a
2548 // copy of this software and associated documentation files (the
2549 // "Software"), to deal in the Software without restriction, including
2550 // without limitation the rights to use, copy, modify, merge, publish,
2551 // distribute, sublicense, and/or sell copies of the Software, and to permit
2552 // persons to whom the Software is furnished to do so, subject to the
2553 // following conditions:
2555 // The above copyright notice and this permission notice shall be included
2556 // in all copies or substantial portions of the Software.
2558 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2559 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2560 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2561 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2562 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2563 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2564 // USE OR OTHER DEALINGS IN THE SOFTWARE.
2566 function EventEmitter() {
2567 this._events
= this._events
|| {};
2568 this._maxListeners
= this._maxListeners
|| undefined;
2570 module
.exports
= EventEmitter
;
2572 // Backwards-compat with node 0.10.x
2573 EventEmitter
.EventEmitter
= EventEmitter
;
2575 EventEmitter
.prototype._events
= undefined;
2576 EventEmitter
.prototype._maxListeners
= undefined;
2578 // By default EventEmitters will print a warning if more than 10 listeners are
2579 // added to it. This is a useful default which helps finding memory leaks.
2580 EventEmitter
.defaultMaxListeners
= 10;
2582 // Obviously not all Emitters should be limited to 10. This function allows
2583 // that to be increased. Set to zero for unlimited.
2584 EventEmitter
.prototype.setMaxListeners = function(n
) {
2585 if (!isNumber(n
) || n
< 0 || isNaN(n
))
2586 throw TypeError('n must be a positive number');
2587 this._maxListeners
= n
;
2591 EventEmitter
.prototype.emit = function(type
) {
2592 var er
, handler
, len
, args
, i
, listeners
;
2597 // If there is no 'error' event listener then throw.
2598 if (type
=== 'error') {
2599 if (!this._events
.error
||
2600 (isObject(this._events
.error
) && !this._events
.error
.length
)) {
2602 if (er
instanceof Error
) {
2603 throw er
; // Unhandled 'error' event
2605 // At least give some kind of context to the user
2606 var err
= new Error('Uncaught, unspecified "error" event. (' + er
+ ')');
2613 handler
= this._events
[type
];
2615 if (isUndefined(handler
))
2618 if (isFunction(handler
)) {
2619 switch (arguments
.length
) {
2625 handler
.call(this, arguments
[1]);
2628 handler
.call(this, arguments
[1], arguments
[2]);
2632 args
= Array
.prototype.slice
.call(arguments
, 1);
2633 handler
.apply(this, args
);
2635 } else if (isObject(handler
)) {
2636 args
= Array
.prototype.slice
.call(arguments
, 1);
2637 listeners
= handler
.slice();
2638 len
= listeners
.length
;
2639 for (i
= 0; i
< len
; i
++)
2640 listeners
[i
].apply(this, args
);
2646 EventEmitter
.prototype.addListener = function(type
, listener
) {
2649 if (!isFunction(listener
))
2650 throw TypeError('listener must be a function');
2655 // To avoid recursion in the case that type === "newListener"! Before
2656 // adding it to the listeners, first emit "newListener".
2657 if (this._events
.newListener
)
2658 this.emit('newListener', type
,
2659 isFunction(listener
.listener
) ?
2660 listener
.listener : listener
);
2662 if (!this._events
[type
])
2663 // Optimize the case of one listener. Don't need the extra array object.
2664 this._events
[type
] = listener
;
2665 else if (isObject(this._events
[type
]))
2666 // If we've already got an array, just append.
2667 this._events
[type
].push(listener
);
2669 // Adding the second element, need to change to array.
2670 this._events
[type
] = [this._events
[type
], listener
];
2672 // Check for listener leak
2673 if (isObject(this._events
[type
]) && !this._events
[type
].warned
) {
2674 if (!isUndefined(this._maxListeners
)) {
2675 m
= this._maxListeners
;
2677 m
= EventEmitter
.defaultMaxListeners
;
2680 if (m
&& m
> 0 && this._events
[type
].length
> m
) {
2681 this._events
[type
].warned
= true;
2682 console
.error('(node) warning: possible EventEmitter memory ' +
2683 'leak detected. %d listeners added. ' +
2684 'Use emitter.setMaxListeners() to increase limit.',
2685 this._events
[type
].length
);
2686 if (typeof console
.trace
=== 'function') {
2687 // not supported in IE 10
2696 EventEmitter
.prototype.on
= EventEmitter
.prototype.addListener
;
2698 EventEmitter
.prototype.once = function(type
, listener
) {
2699 if (!isFunction(listener
))
2700 throw TypeError('listener must be a function');
2705 this.removeListener(type
, g
);
2709 listener
.apply(this, arguments
);
2713 g
.listener
= listener
;
2719 // emits a 'removeListener' event iff the listener was removed
2720 EventEmitter
.prototype.removeListener = function(type
, listener
) {
2721 var list
, position
, length
, i
;
2723 if (!isFunction(listener
))
2724 throw TypeError('listener must be a function');
2726 if (!this._events
|| !this._events
[type
])
2729 list
= this._events
[type
];
2730 length
= list
.length
;
2733 if (list
=== listener
||
2734 (isFunction(list
.listener
) && list
.listener
=== listener
)) {
2735 delete this._events
[type
];
2736 if (this._events
.removeListener
)
2737 this.emit('removeListener', type
, listener
);
2739 } else if (isObject(list
)) {
2740 for (i
= length
; i
-- > 0;) {
2741 if (list
[i
] === listener
||
2742 (list
[i
].listener
&& list
[i
].listener
=== listener
)) {
2751 if (list
.length
=== 1) {
2753 delete this._events
[type
];
2755 list
.splice(position
, 1);
2758 if (this._events
.removeListener
)
2759 this.emit('removeListener', type
, listener
);
2765 EventEmitter
.prototype.removeAllListeners = function(type
) {
2771 // not listening for removeListener, no need to emit
2772 if (!this._events
.removeListener
) {
2773 if (arguments
.length
=== 0)
2775 else if (this._events
[type
])
2776 delete this._events
[type
];
2780 // emit removeListener for all listeners on all events
2781 if (arguments
.length
=== 0) {
2782 for (key
in this._events
) {
2783 if (key
=== 'removeListener') continue;
2784 this.removeAllListeners(key
);
2786 this.removeAllListeners('removeListener');
2791 listeners
= this._events
[type
];
2793 if (isFunction(listeners
)) {
2794 this.removeListener(type
, listeners
);
2795 } else if (listeners
) {
2797 while (listeners
.length
)
2798 this.removeListener(type
, listeners
[listeners
.length
- 1]);
2800 delete this._events
[type
];
2805 EventEmitter
.prototype.listeners = function(type
) {
2807 if (!this._events
|| !this._events
[type
])
2809 else if (isFunction(this._events
[type
]))
2810 ret
= [this._events
[type
]];
2812 ret
= this._events
[type
].slice();
2816 EventEmitter
.prototype.listenerCount = function(type
) {
2818 var evlistener
= this._events
[type
];
2820 if (isFunction(evlistener
))
2822 else if (evlistener
)
2823 return evlistener
.length
;
2828 EventEmitter
.listenerCount = function(emitter
, type
) {
2829 return emitter
.listenerCount(type
);
2832 function isFunction(arg
) {
2833 return typeof arg
=== 'function';
2836 function isNumber(arg
) {
2837 return typeof arg
=== 'number';
2840 function isObject(arg
) {
2841 return typeof arg
=== 'object' && arg
!== null;
2844 function isUndefined(arg
) {
2845 return arg
=== void 0;
2848 },{}],8:[function(require
,module
,exports
){
2849 exports
.read = function (buffer
, offset
, isLE
, mLen
, nBytes
) {
2851 var eLen
= nBytes
* 8 - mLen
- 1
2852 var eMax
= (1 << eLen
) - 1
2853 var eBias
= eMax
>> 1
2855 var i
= isLE
? (nBytes
- 1) : 0
2856 var d
= isLE
? -1 : 1
2857 var s
= buffer
[offset
+ i
]
2861 e
= s
& ((1 << (-nBits
)) - 1)
2864 for (; nBits
> 0; e
= e
* 256 + buffer
[offset
+ i
], i
+= d
, nBits
-= 8) {}
2866 m
= e
& ((1 << (-nBits
)) - 1)
2869 for (; nBits
> 0; m
= m
* 256 + buffer
[offset
+ i
], i
+= d
, nBits
-= 8) {}
2873 } else if (e
=== eMax
) {
2874 return m
? NaN : ((s
? -1 : 1) * Infinity
)
2876 m
= m
+ Math
.pow(2, mLen
)
2879 return (s
? -1 : 1) * m
* Math
.pow(2, e
- mLen
)
2882 exports
.write = function (buffer
, value
, offset
, isLE
, mLen
, nBytes
) {
2884 var eLen
= nBytes
* 8 - mLen
- 1
2885 var eMax
= (1 << eLen
) - 1
2886 var eBias
= eMax
>> 1
2887 var rt
= (mLen
=== 23 ? Math
.pow(2, -24) - Math
.pow(2, -77) : 0)
2888 var i
= isLE
? 0 : (nBytes
- 1)
2889 var d
= isLE
? 1 : -1
2890 var s
= value
< 0 || (value
=== 0 && 1 / value
< 0) ? 1 : 0
2892 value
= Math
.abs(value
)
2894 if (isNaN(value
) || value
=== Infinity
) {
2895 m
= isNaN(value
) ? 1 : 0
2898 e
= Math
.floor(Math
.log(value
) / Math
.LN2
)
2899 if (value
* (c
= Math
.pow(2, -e
)) < 1) {
2903 if (e
+ eBias
>= 1) {
2906 value
+= rt
* Math
.pow(2, 1 - eBias
)
2908 if (value
* c
>= 2) {
2913 if (e
+ eBias
>= eMax
) {
2916 } else if (e
+ eBias
>= 1) {
2917 m
= (value
* c
- 1) * Math
.pow(2, mLen
)
2920 m
= value
* Math
.pow(2, eBias
- 1) * Math
.pow(2, mLen
)
2925 for (; mLen
>= 8; buffer
[offset
+ i
] = m
& 0xff, i
+= d
, m
/= 256, mLen
-= 8) {}
2929 for (; eLen
> 0; buffer
[offset
+ i
] = e
& 0xff, i
+= d
, e
/= 256, eLen
-= 8) {}
2931 buffer
[offset
+ i
- d
] |= s
* 128
2934 },{}],9:[function(require
,module
,exports
){
2935 if (typeof Object
.create
=== 'function') {
2936 // implementation from standard node.js 'util' module
2937 module
.exports
= function inherits(ctor
, superCtor
) {
2938 ctor
.super_
= superCtor
2939 ctor
.prototype = Object
.create(superCtor
.prototype, {
2949 // old school shim for old browsers
2950 module
.exports
= function inherits(ctor
, superCtor
) {
2951 ctor
.super_
= superCtor
2952 var TempCtor = function () {}
2953 TempCtor
.prototype = superCtor
.prototype
2954 ctor
.prototype = new TempCtor()
2955 ctor
.prototype.constructor = ctor
2959 },{}],10:[function(require
,module
,exports
){
2961 * Determine if an object is a Buffer
2963 * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
2967 // The _isBuffer check is for Safari 5-7 support, because it's missing
2968 // Object.prototype.constructor. Remove this eventually
2969 module
.exports = function (obj
) {
2970 return obj
!= null && (isBuffer(obj
) || isSlowBuffer(obj
) || !!obj
._isBuffer
)
2973 function isBuffer (obj
) {
2974 return !!obj
.constructor && typeof obj
.constructor.isBuffer
=== 'function' && obj
.constructor.isBuffer(obj
)
2977 // For Node v0.10 support. Remove this eventually.
2978 function isSlowBuffer (obj
) {
2979 return typeof obj
.readFloatLE
=== 'function' && typeof obj
.slice
=== 'function' && isBuffer(obj
.slice(0, 0))
2982 },{}],11:[function(require
,module
,exports
){
2983 var toString
= {}.toString
;
2985 module
.exports
= Array
.isArray
|| function (arr
) {
2986 return toString
.call(arr
) == '[object Array]';
2989 },{}],12:[function(require
,module
,exports
){
2990 (function (process
){
2993 if (!process
.version
||
2994 process
.version
.indexOf('v0.') === 0 ||
2995 process
.version
.indexOf('v1.') === 0 && process
.version
.indexOf('v1.8.') !== 0) {
2996 module
.exports
= nextTick
;
2998 module
.exports
= process
.nextTick
;
3001 function nextTick(fn
, arg1
, arg2
, arg3
) {
3002 if (typeof fn
!== 'function') {
3003 throw new TypeError('"callback" argument must be a function');
3005 var len
= arguments
.length
;
3010 return process
.nextTick(fn
);
3012 return process
.nextTick(function afterTickOne() {
3013 fn
.call(null, arg1
);
3016 return process
.nextTick(function afterTickTwo() {
3017 fn
.call(null, arg1
, arg2
);
3020 return process
.nextTick(function afterTickThree() {
3021 fn
.call(null, arg1
, arg2
, arg3
);
3024 args
= new Array(len
- 1);
3026 while (i
< args
.length
) {
3027 args
[i
++] = arguments
[i
];
3029 return process
.nextTick(function afterTick() {
3030 fn
.apply(null, args
);
3035 }).call(this,require('_process'))
3036 },{"_process":13}],13:[function(require
,module
,exports
){
3037 // shim for using process in browser
3038 var process
= module
.exports
= {};
3040 // cached from whatever global is present so that test runners that stub it
3041 // don't break things. But we need to wrap it in a try catch in case it is
3042 // wrapped in strict mode code which doesn't define any globals. It's inside a
3043 // function because try/catches deoptimize in certain engines.
3045 var cachedSetTimeout
;
3046 var cachedClearTimeout
;
3048 function defaultSetTimout() {
3049 throw new Error('setTimeout has not been defined');
3051 function defaultClearTimeout () {
3052 throw new Error('clearTimeout has not been defined');
3056 if (typeof setTimeout
=== 'function') {
3057 cachedSetTimeout
= setTimeout
;
3059 cachedSetTimeout
= defaultSetTimout
;
3062 cachedSetTimeout
= defaultSetTimout
;
3065 if (typeof clearTimeout
=== 'function') {
3066 cachedClearTimeout
= clearTimeout
;
3068 cachedClearTimeout
= defaultClearTimeout
;
3071 cachedClearTimeout
= defaultClearTimeout
;
3074 function runTimeout(fun
) {
3075 if (cachedSetTimeout
=== setTimeout
) {
3076 //normal enviroments in sane situations
3077 return setTimeout(fun
, 0);
3079 // if setTimeout wasn't available but was latter defined
3080 if ((cachedSetTimeout
=== defaultSetTimout
|| !cachedSetTimeout
) && setTimeout
) {
3081 cachedSetTimeout
= setTimeout
;
3082 return setTimeout(fun
, 0);
3085 // when when somebody has screwed with setTimeout but no I.E. maddness
3086 return cachedSetTimeout(fun
, 0);
3089 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
3090 return cachedSetTimeout
.call(null, fun
, 0);
3092 // 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
3093 return cachedSetTimeout
.call(this, fun
, 0);
3099 function runClearTimeout(marker
) {
3100 if (cachedClearTimeout
=== clearTimeout
) {
3101 //normal enviroments in sane situations
3102 return clearTimeout(marker
);
3104 // if clearTimeout wasn't available but was latter defined
3105 if ((cachedClearTimeout
=== defaultClearTimeout
|| !cachedClearTimeout
) && clearTimeout
) {
3106 cachedClearTimeout
= clearTimeout
;
3107 return clearTimeout(marker
);
3110 // when when somebody has screwed with setTimeout but no I.E. maddness
3111 return cachedClearTimeout(marker
);
3114 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
3115 return cachedClearTimeout
.call(null, marker
);
3117 // 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.
3118 // Some versions of I.E. have different rules for clearTimeout vs setTimeout
3119 return cachedClearTimeout
.call(this, marker
);
3127 var draining
= false;
3129 var queueIndex
= -1;
3131 function cleanUpNextTick() {
3132 if (!draining
|| !currentQueue
) {
3136 if (currentQueue
.length
) {
3137 queue
= currentQueue
.concat(queue
);
3146 function drainQueue() {
3150 var timeout
= runTimeout(cleanUpNextTick
);
3153 var len
= queue
.length
;
3155 currentQueue
= queue
;
3157 while (++queueIndex
< len
) {
3159 currentQueue
[queueIndex
].run();
3165 currentQueue
= null;
3167 runClearTimeout(timeout
);
3170 process
.nextTick = function (fun
) {
3171 var args
= new Array(arguments
.length
- 1);
3172 if (arguments
.length
> 1) {
3173 for (var i
= 1; i
< arguments
.length
; i
++) {
3174 args
[i
- 1] = arguments
[i
];
3177 queue
.push(new Item(fun
, args
));
3178 if (queue
.length
=== 1 && !draining
) {
3179 runTimeout(drainQueue
);
3183 // v8 likes predictible objects
3184 function Item(fun
, array
) {
3188 Item
.prototype.run = function () {
3189 this.fun
.apply(null, this.array
);
3191 process
.title
= 'browser';
3192 process
.browser
= true;
3195 process
.version
= ''; // empty string to avoid regexp issues
3196 process
.versions
= {};
3201 process
.addListener
= noop
;
3202 process
.once
= noop
;
3204 process
.removeListener
= noop
;
3205 process
.removeAllListeners
= noop
;
3206 process
.emit
= noop
;
3208 process
.binding = function (name
) {
3209 throw new Error('process.binding is not supported');
3212 process
.cwd = function () { return '/' };
3213 process
.chdir = function (dir
) {
3214 throw new Error('process.chdir is not supported');
3216 process
.umask = function() { return 0; };
3218 },{}],14:[function(require
,module
,exports
){
3219 module
.exports
= require("./lib/_stream_duplex.js")
3221 },{"./lib/_stream_duplex.js":15}],15:[function(require
,module
,exports
){
3222 // a duplex stream is just a stream that is both readable and writable.
3223 // Since JS doesn't have multiple prototypal inheritance, this class
3224 // prototypally inherits from Readable, and then parasitically from
3231 var objectKeys
= Object
.keys
|| function (obj
) {
3233 for (var key
in obj
) {
3239 module.exports = Duplex;
3242 var processNextTick
= require('process-nextick-args');
3246 var util
= require('core-util-is');
3247 util
.inherits
= require('inherits');
3250 var Readable = require('./_stream_readable');
3251 var Writable = require('./_stream_writable');
3253 util.inherits(Duplex, Readable);
3255 var keys = objectKeys(Writable.prototype);
3256 for (var v = 0; v < keys.length; v++) {
3257 var method = keys[v];
3258 if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
3261 function Duplex(options) {
3262 if (!(this instanceof Duplex)) return new Duplex(options);
3264 Readable.call(this, options);
3265 Writable.call(this, options);
3267 if (options && options.readable === false) this.readable = false;
3269 if (options && options.writable === false) this.writable = false;
3271 this.allowHalfOpen = true;
3272 if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
3274 this.once('end', onend);
3277 // the no-half-open enforcer
3279 // if we allow half-open state, or if the writable side ended,
3281 if (this.allowHalfOpen || this._writableState.ended) return;
3283 // no more data can be written.
3284 // But allow more writes to happen in this tick.
3285 processNextTick(onEndNT, this);
3288 function onEndNT(self) {
3292 function forEach(xs, f) {
3293 for (var i = 0, l = xs.length; i < l; i++) {
3297 },{"./_stream_readable":17,"./_stream_writable":19,"core-util-is":6,"inherits":9,"process-nextick-args":12}],16:[function(require,module,exports){
3298 // a passthrough stream.
3299 // basically just the most minimal sort of Transform stream.
3300 // Every written chunk gets output as-is.
3304 module.exports = PassThrough;
3306 var Transform = require('./_stream_transform');
3309 var util
= require('core-util-is');
3310 util
.inherits
= require('inherits');
3313 util.inherits(PassThrough, Transform);
3315 function PassThrough(options) {
3316 if (!(this instanceof PassThrough)) return new PassThrough(options);
3318 Transform.call(this, options);
3321 PassThrough.prototype._transform = function (chunk, encoding, cb) {
3324 },{"./_stream_transform":18,"core-util-is":6,"inherits":9}],17:[function(require,module,exports){
3325 (function (process){
3328 module.exports = Readable;
3331 var processNextTick
= require('process-nextick-args');
3335 var isArray
= require('isarray');
3342 Readable.ReadableState = ReadableState;
3345 var EE
= require('events').EventEmitter
;
3347 var EElistenerCount = function (emitter
, type
) {
3348 return emitter
.listeners(type
).length
;
3356 Stream
= require('st' + 'ream');
3357 } catch (_
) {} finally {
3358 if (!Stream
) Stream
= require('events').EventEmitter
;
3363 var Buffer = require('buffer').Buffer;
3365 var bufferShim
= require('buffer-shims');
3369 var util
= require('core-util-is');
3370 util
.inherits
= require('inherits');
3374 var debugUtil
= require('util');
3376 if (debugUtil
&& debugUtil
.debuglog
) {
3377 debug
= debugUtil
.debuglog('stream');
3379 debug = function () {};
3383 var BufferList = require('./internal/streams/BufferList');
3386 util.inherits(Readable, Stream);
3388 function prependListener(emitter, event, fn) {
3389 // Sadly this is not cacheable as some libraries bundle their own
3390 // event emitter implementation with them.
3391 if (typeof emitter.prependListener === 'function') {
3392 return emitter.prependListener(event, fn);
3394 // This is a hack to make sure that our error handler is attached before any
3395 // userland ones. NEVER DO THIS. This is here only because this code needs
3396 // to continue to work with older versions of Node.js that do not include
3397 // the prependListener() method. The goal is to eventually remove this hack.
3398 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]];
3402 function ReadableState(options, stream) {
3403 Duplex = Duplex || require('./_stream_duplex');
3405 options = options || {};
3407 // object stream flag. Used to make read(n) ignore n and to
3408 // make all the buffer merging and length checks go away
3409 this.objectMode = !!options.objectMode;
3411 if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
3413 // the point at which it stops calling _read() to fill the buffer
3414 // Note: 0 is a valid value, means "don't call _read preemptively ever"
3415 var hwm = options.highWaterMark;
3416 var defaultHwm = this.objectMode ? 16 : 16 * 1024;
3417 this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
3420 this.highWaterMark = ~ ~this.highWaterMark;
3422 // A linked list is used to store data chunks instead of an array because the
3423 // linked list can remove elements from the beginning faster than
3425 this.buffer = new BufferList();
3428 this.pipesCount = 0;
3429 this.flowing = null;
3431 this.endEmitted = false;
3432 this.reading = false;
3434 // a flag to be able to tell if the onwrite cb is called immediately,
3435 // or on a later tick. We set this to true at first, because any
3436 // actions that shouldn't happen until "later" should generally also
3437 // not happen before the first write call.
3440 // whenever we return null, then we set a flag to say
3441 // that we're awaiting a 'readable' event emission.
3442 this.needReadable = false;
3443 this.emittedReadable = false;
3444 this.readableListening = false;
3445 this.resumeScheduled = false;
3447 // Crypto is kind of old and crusty. Historically, its default string
3448 // encoding is 'binary' so we have to make this configurable.
3449 // Everything else in the universe uses 'utf8', though.
3450 this.defaultEncoding = options.defaultEncoding || 'utf8';
3452 // when piping, we only care about 'readable' events that happen
3453 // after read()ing all the bytes and not getting any pushback.
3454 this.ranOut = false;
3456 // the number of writers that are awaiting a drain event in .pipe()s
3457 this.awaitDrain = 0;
3459 // if true, a maybeReadMore has been scheduled
3460 this.readingMore = false;
3462 this.decoder = null;
3463 this.encoding = null;
3464 if (options.encoding) {
3465 if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
3466 this.decoder = new StringDecoder(options.encoding);
3467 this.encoding = options.encoding;
3471 function Readable(options) {
3472 Duplex = Duplex || require('./_stream_duplex');
3474 if (!(this instanceof Readable)) return new Readable(options);
3476 this._readableState = new ReadableState(options, this);
3479 this.readable = true;
3481 if (options && typeof options.read === 'function') this._read = options.read;
3486 // Manually shove something into the read() buffer.
3487 // This returns true if the highWaterMark has not been hit yet,
3488 // similar to how Writable.write() returns true if you should
3489 // write() some more.
3490 Readable.prototype.push = function (chunk, encoding) {
3491 var state = this._readableState;
3493 if (!state.objectMode && typeof chunk === 'string') {
3494 encoding = encoding || state.defaultEncoding;
3495 if (encoding !== state.encoding) {
3496 chunk = bufferShim.from(chunk, encoding);
3501 return readableAddChunk(this, state, chunk, encoding, false);
3504 // Unshift should *always* be something directly out of read()
3505 Readable.prototype.unshift = function (chunk) {
3506 var state = this._readableState;
3507 return readableAddChunk(this, state, chunk, '', true);
3510 Readable.prototype.isPaused = function () {
3511 return this._readableState.flowing === false;
3514 function readableAddChunk(stream, state, chunk, encoding, addToFront) {
3515 var er = chunkInvalid(state, chunk);
3517 stream.emit('error', er);
3518 } else if (chunk === null) {
3519 state.reading = false;
3520 onEofChunk(stream, state);
3521 } else if (state.objectMode || chunk && chunk.length > 0) {
3522 if (state.ended && !addToFront) {
3523 var e = new Error('stream.push() after EOF');
3524 stream.emit('error', e);
3525 } else if (state.endEmitted && addToFront) {
3526 var _e = new Error('stream.unshift() after end event');
3527 stream.emit('error', _e);
3530 if (state.decoder && !addToFront && !encoding) {
3531 chunk = state.decoder.write(chunk);
3532 skipAdd = !state.objectMode && chunk.length === 0;
3535 if (!addToFront) state.reading = false;
3537 // Don't add to the buffer if we've decoded to an empty string chunk and
3538 // we're not in object mode
3540 // if we want the data now, just emit it.
3541 if (state.flowing && state.length === 0 && !state.sync) {
3542 stream.emit('data', chunk);
3545 // update the buffer info.
3546 state.length += state.objectMode ? 1 : chunk.length;
3547 if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
3549 if (state.needReadable) emitReadable(stream);
3553 maybeReadMore(stream, state);
3555 } else if (!addToFront) {
3556 state.reading = false;
3559 return needMoreData(state);
3562 // if it's past the high water mark, we can push in some more.
3563 // Also, if we have no data yet, we can stand some
3564 // more bytes. This is to work around cases where hwm=0,
3565 // such as the repl. Also, if the push() triggered a
3566 // readable event, and the user called read(largeNumber) such that
3567 // needReadable was set, then we ought to push more, so that another
3568 // 'readable' event will be triggered.
3569 function needMoreData(state) {
3570 return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
3573 // backwards compatibility.
3574 Readable.prototype.setEncoding = function (enc) {
3575 if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
3576 this._readableState.decoder = new StringDecoder(enc);
3577 this._readableState.encoding = enc;
3581 // Don't raise the hwm > 8MB
3582 var MAX_HWM = 0x800000;
3583 function computeNewHighWaterMark(n) {
3587 // Get the next highest power of 2 to prevent increasing hwm excessively in
3600 // This function is designed to be inlinable, so please take care when making
3601 // changes to the function body.
3602 function howMuchToRead(n, state) {
3603 if (n <= 0 || state.length === 0 && state.ended) return 0;
3604 if (state.objectMode) return 1;
3606 // Only flow one buffer at a time
3607 if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
3609 // If we're asking for more than the current hwm, then raise the hwm.
3610 if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
3611 if (n <= state.length) return n;
3612 // Don't have enough
3614 state.needReadable = true;
3617 return state.length;
3620 // you can override either this method, or the async _read(n) below.
3621 Readable.prototype.read = function (n) {
3623 n = parseInt(n, 10);
3624 var state = this._readableState;
3627 if (n !== 0) state.emittedReadable = false;
3629 // if we're doing read(0) to trigger a readable event, but we
3630 // already have a bunch of data in the buffer, then just trigger
3631 // the 'readable' event and move on.
3632 if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
3633 debug('read: emitReadable', state.length, state.ended);
3634 if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
3638 n = howMuchToRead(n, state);
3640 // if we've ended, and we're now clear, then finish it up.
3641 if (n === 0 && state.ended) {
3642 if (state.length === 0) endReadable(this);
3646 // All the actual chunk generation logic needs to be
3647 // *below* the call to _read. The reason is that in certain
3648 // synthetic stream cases, such as passthrough streams, _read
3649 // may be a completely synchronous operation which may change
3650 // the state of the read buffer, providing enough data when
3651 // before there was *not* enough.
3653 // So, the steps are:
3654 // 1. Figure out what the state of things will be after we do
3655 // a read from the buffer.
3657 // 2. If that resulting state will trigger a _read, then call _read.
3658 // Note that this may be asynchronous, or synchronous. Yes, it is
3659 // deeply ugly to write APIs this way, but that still doesn't mean
3660 // that the Readable class should behave improperly, as streams are
3661 // designed to be sync/async agnostic.
3662 // Take note if the _read call is sync or async (ie, if the read call
3663 // has returned yet), so that we know whether or not it's safe to emit
3666 // 3. Actually pull the requested chunks out of the buffer and return.
3668 // if we need a readable event, then we need to do some reading.
3669 var doRead = state.needReadable;
3670 debug('need readable', doRead);
3672 // if we currently have less than the highWaterMark, then also read some
3673 if (state.length === 0 || state.length - n < state.highWaterMark) {
3675 debug('length less than watermark', doRead);
3678 // however, if we've ended, then there's no point, and if we're already
3679 // reading, then it's unnecessary.
3680 if (state.ended || state.reading) {
3682 debug('reading or ended', doRead);
3683 } else if (doRead) {
3685 state.reading = true;
3687 // if the length is currently zero, then we *need* a readable event.
3688 if (state.length === 0) state.needReadable = true;
3689 // call internal read method
3690 this._read(state.highWaterMark);
3692 // If _read pushed data synchronously, then `reading` will be false,
3693 // and we need to re-evaluate how much data we can return to the user.
3694 if (!state.reading) n = howMuchToRead(nOrig, state);
3698 if (n > 0) ret = fromList(n, state);else ret = null;
3701 state.needReadable = true;
3707 if (state.length === 0) {
3708 // If we have nothing in the buffer, then we want to know
3709 // as soon as we *do* get something into the buffer.
3710 if (!state.ended) state.needReadable = true;
3712 // If we tried to read() past the EOF, then emit end on the next tick.
3713 if (nOrig !== n && state.ended) endReadable(this);
3716 if (ret !== null) this.emit('data', ret);
3721 function chunkInvalid(state, chunk) {
3723 if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
3724 er = new TypeError('Invalid non-string/buffer chunk');
3729 function onEofChunk(stream, state) {
3730 if (state.ended) return;
3731 if (state.decoder) {
3732 var chunk = state.decoder.end();
3733 if (chunk && chunk.length) {
3734 state.buffer.push(chunk);
3735 state.length += state.objectMode ? 1 : chunk.length;
3740 // emit 'readable' now to make sure it gets picked up.
3741 emitReadable(stream);
3744 // Don't emit readable right away in sync mode, because this can trigger
3745 // another read() call => stack overflow. This way, it might trigger
3746 // a nextTick recursion warning, but that's not so bad.
3747 function emitReadable(stream) {
3748 var state = stream._readableState;
3749 state.needReadable = false;
3750 if (!state.emittedReadable) {
3751 debug('emitReadable', state.flowing);
3752 state.emittedReadable = true;
3753 if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);
3757 function emitReadable_(stream) {
3758 debug('emit readable');
3759 stream.emit('readable');
3763 // at this point, the user has presumably seen the 'readable' event,
3764 // and called read() to consume some data. that may have triggered
3765 // in turn another _read(n) call, in which case reading = true if
3766 // it's in progress.
3767 // However, if we're not ended, or reading, and the length < hwm,
3768 // then go ahead and try to read some more preemptively.
3769 function maybeReadMore(stream, state) {
3770 if (!state.readingMore) {
3771 state.readingMore = true;
3772 processNextTick(maybeReadMore_, stream, state);
3776 function maybeReadMore_(stream, state) {
3777 var len = state.length;
3778 while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
3779 debug('maybeReadMore read 0');
3781 if (len === state.length)
3782 // didn't get any data, stop spinning.
3783 break;else len = state.length;
3785 state.readingMore = false;
3788 // abstract method. to be overridden in specific implementation classes.
3789 // call cb(er, data) where data is <= n in length.
3790 // for virtual (non-string, non-buffer) streams, "length" is somewhat
3791 // arbitrary, and perhaps not very meaningful.
3792 Readable.prototype._read = function (n) {
3793 this.emit('error', new Error('_read() is not implemented'));
3796 Readable.prototype.pipe = function (dest, pipeOpts) {
3798 var state = this._readableState;
3800 switch (state.pipesCount) {
3805 state.pipes = [state.pipes, dest];
3808 state.pipes.push(dest);
3811 state.pipesCount += 1;
3812 debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
3814 var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
3816 var endFn = doEnd ? onend : cleanup;
3817 if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);
3819 dest.on('unpipe', onunpipe);
3820 function onunpipe(readable) {
3822 if (readable === src) {
3832 // when the dest drains, it reduces the awaitDrain counter
3833 // on the source. This would be more elegant with a .once()
3834 // handler in flow(), but adding and removing repeatedly is
3836 var ondrain = pipeOnDrain(src);
3837 dest.on('drain', ondrain);
3839 var cleanedUp = false;
3840 function cleanup() {
3842 // cleanup event handlers once the pipe is broken
3843 dest.removeListener('close', onclose);
3844 dest.removeListener('finish', onfinish);
3845 dest.removeListener('drain', ondrain);
3846 dest.removeListener('error', onerror);
3847 dest.removeListener('unpipe', onunpipe);
3848 src.removeListener('end', onend);
3849 src.removeListener('end', cleanup);
3850 src.removeListener('data', ondata);
3854 // if the reader is waiting for a drain event from this
3855 // specific writer, then it would cause it to never start
3857 // So, if this is awaiting a drain, then we just call it now.
3858 // If we don't know, then assume that we are waiting for one.
3859 if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
3862 // If the user pushes more data while we're writing to dest then we'll end up
3863 // in ondata again. However, we only want to increase awaitDrain once because
3864 // dest will only emit one 'drain' event for the multiple writes.
3865 // => Introduce a guard on increasing awaitDrain.
3866 var increasedAwaitDrain = false;
3867 src.on('data', ondata);
3868 function ondata(chunk) {
3870 increasedAwaitDrain = false;
3871 var ret = dest.write(chunk);
3872 if (false === ret && !increasedAwaitDrain) {
3873 // If the user unpiped during `dest.write()`, it is possible
3874 // to get stuck in a permanently paused state if that write
3875 // also returned false.
3876 // => Check whether `dest` is still a piping destination.
3877 if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
3878 debug('false write response, pause', src._readableState.awaitDrain);
3879 src._readableState.awaitDrain++;
3880 increasedAwaitDrain = true;
3886 // if the dest has an error, then stop piping into it.
3887 // however, don't suppress the throwing behavior for this.
3888 function onerror(er) {
3889 debug('onerror', er);
3891 dest.removeListener('error', onerror);
3892 if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
3895 // Make sure our error handler is attached before userland ones.
3896 prependListener(dest, 'error', onerror);
3898 // Both close and finish should trigger unpipe, but only once.
3899 function onclose() {
3900 dest.removeListener('finish', onfinish);
3903 dest.once('close', onclose);
3904 function onfinish() {
3906 dest.removeListener('close', onclose);
3909 dest.once('finish', onfinish);
3916 // tell the dest that it's being piped to
3917 dest.emit('pipe', src);
3919 // start the flow if it hasn't been started already.
3920 if (!state.flowing) {
3921 debug('pipe resume');
3928 function pipeOnDrain(src) {
3929 return function () {
3930 var state = src._readableState;
3931 debug('pipeOnDrain', state.awaitDrain);
3932 if (state.awaitDrain) state.awaitDrain--;
3933 if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
3934 state.flowing = true;
3940 Readable.prototype.unpipe = function (dest) {
3941 var state = this._readableState;
3943 // if we're not piping anywhere, then do nothing.
3944 if (state.pipesCount === 0) return this;
3946 // just one destination. most common case.
3947 if (state.pipesCount === 1) {
3948 // passed in one, but it's not the right one.
3949 if (dest && dest !== state.pipes) return this;
3951 if (!dest) dest = state.pipes;
3955 state.pipesCount = 0;
3956 state.flowing = false;
3957 if (dest) dest.emit('unpipe', this);
3961 // slow case. multiple pipe destinations.
3965 var dests = state.pipes;
3966 var len = state.pipesCount;
3968 state.pipesCount = 0;
3969 state.flowing = false;
3971 for (var i = 0; i < len; i++) {
3972 dests[i].emit('unpipe', this);
3976 // try to find the right one.
3977 var index = indexOf(state.pipes, dest);
3978 if (index === -1) return this;
3980 state.pipes.splice(index, 1);
3981 state.pipesCount -= 1;
3982 if (state.pipesCount === 1) state.pipes = state.pipes[0];
3984 dest.emit('unpipe', this);
3989 // set up data events if they are asked for
3990 // Ensure readable listeners eventually get something
3991 Readable.prototype.on = function (ev, fn) {
3992 var res = Stream.prototype.on.call(this, ev, fn);
3994 if (ev === 'data') {
3995 // Start flowing on next tick if stream isn't explicitly paused
3996 if (this._readableState.flowing !== false) this.resume();
3997 } else if (ev === 'readable') {
3998 var state = this._readableState;
3999 if (!state.endEmitted && !state.readableListening) {
4000 state.readableListening = state.needReadable = true;
4001 state.emittedReadable = false;
4002 if (!state.reading) {
4003 processNextTick(nReadingNextTick, this);
4004 } else if (state.length) {
4005 emitReadable(this, state);
4012 Readable.prototype.addListener = Readable.prototype.on;
4014 function nReadingNextTick(self) {
4015 debug('readable nexttick read 0');
4019 // pause() and resume() are remnants of the legacy readable stream API
4020 // If the user uses them, then switch into old mode.
4021 Readable.prototype.resume = function () {
4022 var state = this._readableState;
4023 if (!state.flowing) {
4025 state.flowing = true;
4026 resume(this, state);
4031 function resume(stream, state) {
4032 if (!state.resumeScheduled) {
4033 state.resumeScheduled = true;
4034 processNextTick(resume_, stream, state);
4038 function resume_(stream, state) {
4039 if (!state.reading) {
4040 debug('resume read 0');
4044 state.resumeScheduled = false;
4045 state.awaitDrain = 0;
4046 stream.emit('resume');
4048 if (state.flowing && !state.reading) stream.read(0);
4051 Readable.prototype.pause = function () {
4052 debug('call pause flowing=%j', this._readableState.flowing);
4053 if (false !== this._readableState.flowing) {
4055 this._readableState.flowing = false;
4061 function flow(stream) {
4062 var state = stream._readableState;
4063 debug('flow', state.flowing);
4064 while (state.flowing && stream.read() !== null) {}
4067 // wrap an old-style stream as the async data source.
4068 // This is *not* part of the readable stream interface.
4069 // It is an ugly unfortunate mess of history.
4070 Readable.prototype.wrap = function (stream) {
4071 var state = this._readableState;
4075 stream.on('end', function () {
4076 debug('wrapped end');
4077 if (state.decoder && !state.ended) {
4078 var chunk = state.decoder.end();
4079 if (chunk && chunk.length) self.push(chunk);
4085 stream.on('data', function (chunk) {
4086 debug('wrapped data');
4087 if (state.decoder) chunk = state.decoder.write(chunk);
4089 // don't skip over falsy values in objectMode
4090 if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
4092 var ret = self.push(chunk);
4099 // proxy all the other methods.
4100 // important when wrapping filters and duplexes.
4101 for (var i in stream) {
4102 if (this[i] === undefined && typeof stream[i] === 'function') {
4103 this[i] = function (method) {
4104 return function () {
4105 return stream[method].apply(stream, arguments);
4111 // proxy certain important events.
4112 var events = ['error', 'close', 'destroy', 'pause', 'resume'];
4113 forEach(events, function (ev) {
4114 stream.on(ev, self.emit.bind(self, ev));
4117 // when we try to consume some more bytes, simply unpause the
4118 // underlying stream.
4119 self._read = function (n) {
4120 debug('wrapped _read', n);
4130 // exposed for testing purposes only.
4131 Readable._fromList = fromList;
4133 // Pluck off n bytes from an array of buffers.
4134 // Length is the combined lengths of all the buffers in the list.
4135 // This function is designed to be inlinable, so please take care when making
4136 // changes to the function body.
4137 function fromList(n, state) {
4139 if (state.length === 0) return null;
4142 if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
4143 // read it all, truncate the list
4144 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);
4145 state.buffer.clear();
4147 // read part of list
4148 ret = fromListPartial(n, state.buffer, state.decoder);
4154 // Extracts only enough buffered data to satisfy the amount requested.
4155 // This function is designed to be inlinable, so please take care when making
4156 // changes to the function body.
4157 function fromListPartial(n, list, hasStrings) {
4159 if (n < list.head.data.length) {
4160 // slice is the same for buffers and strings
4161 ret = list.head.data.slice(0, n);
4162 list.head.data = list.head.data.slice(n);
4163 } else if (n === list.head.data.length) {
4164 // first chunk is a perfect match
4167 // result spans more than one buffer
4168 ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
4173 // Copies a specified amount of characters from the list of buffered data
4175 // This function is designed to be inlinable, so please take care when making
4176 // changes to the function body.
4177 function copyFromBufferString(n, list) {
4182 while (p = p.next) {
4184 var nb = n > str.length ? str.length : n;
4185 if (nb === str.length) ret += str;else ret += str.slice(0, n);
4188 if (nb === str.length) {
4190 if (p.next) list.head = p.next;else list.head = list.tail = null;
4193 p.data = str.slice(nb);
4203 // Copies a specified amount of bytes from the list of buffered data chunks.
4204 // This function is designed to be inlinable, so please take care when making
4205 // changes to the function body.
4206 function copyFromBuffer(n, list) {
4207 var ret = bufferShim.allocUnsafe(n);
4212 while (p = p.next) {
4214 var nb = n > buf.length ? buf.length : n;
4215 buf.copy(ret, ret.length - n, 0, nb);
4218 if (nb === buf.length) {
4220 if (p.next) list.head = p.next;else list.head = list.tail = null;
4223 p.data = buf.slice(nb);
4233 function endReadable(stream) {
4234 var state = stream._readableState;
4236 // If we get here before consuming all the bytes, then that is a
4237 // bug in node. Should never happen.
4238 if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
4240 if (!state.endEmitted) {
4242 processNextTick(endReadableNT, state, stream);
4246 function endReadableNT(state, stream) {
4247 // Check that we didn't get one last unshift.
4248 if (!state.endEmitted && state.length === 0) {
4249 state.endEmitted = true;
4250 stream.readable = false;
4255 function forEach(xs, f) {
4256 for (var i = 0, l = xs.length; i < l; i++) {
4261 function indexOf(xs, x) {
4262 for (var i = 0, l = xs.length; i < l; i++) {
4263 if (xs[i] === x) return i;
4267 }).call(this,require('_process'))
4268 },{"./_stream_duplex":15,"./internal/streams/BufferList":20,"_process":13,"buffer":5,"buffer-shims":4,"core-util-is":6,"events":7,"inherits":9,"isarray":11,"process-nextick-args":12,"string_decoder/":26,"util":3}],18:[function(require,module,exports){
4269 // a transform stream is a readable/writable stream where you do
4270 // something with the data. Sometimes it's called a "filter",
4271 // but that's not a great name for it, since that implies a thing where
4272 // some bits pass through, and others are simply ignored. (That would
4273 // be a valid example of a transform, of course.)
4275 // While the output is causally related to the input, it's not a
4276 // necessarily symmetric or synchronous transformation. For example,
4277 // a zlib stream might take multiple plain-text writes(), and then
4278 // emit a single compressed chunk some time in the future.
4280 // Here's how this works:
4282 // The Transform stream has all the aspects of the readable and writable
4283 // stream classes. When you write(chunk), that calls _write(chunk,cb)
4284 // internally, and returns false if there's a lot of pending writes
4285 // buffered up. When you call read(), that calls _read(n) until
4286 // there's enough pending readable data buffered up.
4288 // In a transform stream, the written data is placed in a buffer. When
4289 // _read(n) is called, it transforms the queued up data, calling the
4290 // buffered _write cb's as it consumes chunks. If consuming a single
4291 // written chunk would result in multiple output chunks, then the first
4292 // outputted bit calls the readcb, and subsequent chunks just go into
4293 // the read buffer, and will cause it to emit 'readable' if necessary.
4295 // This way, back-pressure is actually determined by the reading side,
4296 // since _read has to be called to start processing a new chunk. However,
4297 // a pathological inflate type of transform can cause excessive buffering
4298 // here. For example, imagine a stream where every byte of input is
4299 // interpreted as an integer from 0-255, and then results in that many
4300 // bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
4301 // 1kb of data being output. In this case, you could write a very small
4302 // amount of input, and end up with a very large amount of output. In
4303 // such a pathological inflating mechanism, there'd be no way to tell
4304 // the system to stop doing the transform. A single 4MB write could
4305 // cause the system to run out of memory.
4307 // However, even in such a pathological case, only a single written chunk
4308 // would be consumed, and then the rest would wait (un-transformed) until
4309 // the results of the previous transformed chunk were consumed.
4313 module.exports = Transform;
4315 var Duplex = require('./_stream_duplex');
4318 var util
= require('core-util-is');
4319 util
.inherits
= require('inherits');
4322 util.inherits(Transform, Duplex);
4324 function TransformState(stream) {
4325 this.afterTransform = function (er, data) {
4326 return afterTransform(stream, er, data);
4329 this.needTransform = false;
4330 this.transforming = false;
4331 this.writecb = null;
4332 this.writechunk = null;
4333 this.writeencoding = null;
4336 function afterTransform(stream, er, data) {
4337 var ts = stream._transformState;
4338 ts.transforming = false;
4340 var cb = ts.writecb;
4342 if (!cb) return stream.emit('error', new Error('no writecb in Transform class'));
4344 ts.writechunk = null;
4347 if (data !== null && data !== undefined) stream.push(data);
4351 var rs = stream._readableState;
4353 if (rs.needReadable || rs.length < rs.highWaterMark) {
4354 stream._read(rs.highWaterMark);
4358 function Transform(options) {
4359 if (!(this instanceof Transform)) return new Transform(options);
4361 Duplex.call(this, options);
4363 this._transformState = new TransformState(this);
4367 // start out asking for a readable event once data is transformed.
4368 this._readableState.needReadable = true;
4370 // we have implemented the _read method, and done the other things
4371 // that Readable wants before the first _read call, so unset the
4373 this._readableState.sync = false;
4376 if (typeof options.transform === 'function') this._transform = options.transform;
4378 if (typeof options.flush === 'function') this._flush = options.flush;
4381 // When the writable side finishes, then flush out anything remaining.
4382 this.once('prefinish', function () {
4383 if (typeof this._flush === 'function') this._flush(function (er, data) {
4384 done(stream, er, data);
4385 });else done(stream);
4389 Transform.prototype.push = function (chunk, encoding) {
4390 this._transformState.needTransform = false;
4391 return Duplex.prototype.push.call(this, chunk, encoding);
4394 // This is the part where you do stuff!
4395 // override this function in implementation classes.
4396 // 'chunk' is an input chunk.
4398 // Call `push(newChunk)` to pass along transformed output
4399 // to the readable side. You may call 'push' zero or more times.
4401 // Call `cb(err)` when you are done with this chunk. If you pass
4402 // an error, then that'll put the hurt on the whole operation. If you
4403 // never call cb(), then you'll never get another chunk.
4404 Transform.prototype._transform = function (chunk, encoding, cb) {
4405 throw new Error('_transform() is not implemented');
4408 Transform.prototype._write = function (chunk, encoding, cb) {
4409 var ts = this._transformState;
4411 ts.writechunk = chunk;
4412 ts.writeencoding = encoding;
4413 if (!ts.transforming) {
4414 var rs = this._readableState;
4415 if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
4419 // Doesn't matter what the args are here.
4420 // _transform does all the work.
4421 // That we got here means that the readable side wants more data.
4422 Transform.prototype._read = function (n) {
4423 var ts = this._transformState;
4425 if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
4426 ts.transforming = true;
4427 this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
4429 // mark that we need a transform, so that any data that comes in
4430 // will get processed, now that we've asked for it.
4431 ts.needTransform = true;
4435 function done(stream, er, data) {
4436 if (er) return stream.emit('error', er);
4438 if (data !== null && data !== undefined) stream.push(data);
4440 // if there's nothing in the write buffer, then that means
4441 // that nothing more will ever be provided
4442 var ws = stream._writableState;
4443 var ts = stream._transformState;
4445 if (ws.length) throw new Error('Calling transform done when ws.length != 0');
4447 if (ts.transforming) throw new Error('Calling transform done when still transforming');
4449 return stream.push(null);
4451 },{"./_stream_duplex":15,"core-util-is":6,"inherits":9}],19:[function(require,module,exports){
4452 (function (process){
4453 // A bit simpler than readable streams.
4454 // Implement an async ._write(chunk, encoding, cb), and it'll handle all
4455 // the drain event emission and buffering.
4459 module.exports = Writable;
4462 var processNextTick
= require('process-nextick-args');
4466 var asyncWrite
= !process
.browser
&& ['v0.10', 'v0.9.'].indexOf(process
.version
.slice(0, 5)) > -1 ? setImmediate : processNextTick
;
4473 Writable.WritableState = WritableState;
4476 var util
= require('core-util-is');
4477 util
.inherits
= require('inherits');
4481 var internalUtil
= {
4482 deprecate: require('util-deprecate')
4490 Stream
= require('st' + 'ream');
4491 } catch (_
) {} finally {
4492 if (!Stream
) Stream
= require('events').EventEmitter
;
4497 var Buffer = require('buffer').Buffer;
4499 var bufferShim
= require('buffer-shims');
4502 util.inherits(Writable, Stream);
4506 function WriteReq(chunk, encoding, cb) {
4508 this.encoding = encoding;
4513 function WritableState(options, stream) {
4514 Duplex = Duplex || require('./_stream_duplex');
4516 options = options || {};
4518 // object stream flag to indicate whether or not this stream
4519 // contains buffers or objects.
4520 this.objectMode = !!options.objectMode;
4522 if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
4524 // the point at which write() starts returning false
4525 // Note: 0 is a valid value, means that we always return false if
4526 // the entire buffer is not flushed immediately on write()
4527 var hwm = options.highWaterMark;
4528 var defaultHwm = this.objectMode ? 16 : 16 * 1024;
4529 this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
4532 this.highWaterMark = ~ ~this.highWaterMark;
4534 // drain event flag.
4535 this.needDrain = false;
4536 // at the start of calling end()
4537 this.ending = false;
4538 // when end() has been called, and returned
4540 // when 'finish' is emitted
4541 this.finished = false;
4543 // should we decode strings into buffers before passing to _write?
4544 // this is here so that some node-core streams can optimize string
4545 // handling at a lower level.
4546 var noDecode = options.decodeStrings === false;
4547 this.decodeStrings = !noDecode;
4549 // Crypto is kind of old and crusty. Historically, its default string
4550 // encoding is 'binary' so we have to make this configurable.
4551 // Everything else in the universe uses 'utf8', though.
4552 this.defaultEncoding = options.defaultEncoding || 'utf8';
4554 // not an actual buffer we keep track of, but a measurement
4555 // of how much we're waiting to get pushed to some underlying
4559 // a flag to see when we're in the middle of a write.
4560 this.writing = false;
4562 // when true all writes will be buffered until .uncork() call
4565 // a flag to be able to tell if the onwrite cb is called immediately,
4566 // or on a later tick. We set this to true at first, because any
4567 // actions that shouldn't happen until "later" should generally also
4568 // not happen before the first write call.
4571 // a flag to know if we're processing previously buffered items, which
4572 // may call the _write() callback in the same tick, so that we don't
4573 // end up in an overlapped onwrite situation.
4574 this.bufferProcessing = false;
4576 // the callback that's passed to _write(chunk,cb)
4577 this.onwrite = function (er) {
4578 onwrite(stream, er);
4581 // the callback that the user supplies to write(chunk,encoding,cb)
4582 this.writecb = null;
4584 // the amount that is being written when _write is called.
4587 this.bufferedRequest = null;
4588 this.lastBufferedRequest = null;
4590 // number of pending user-supplied write callbacks
4591 // this must be 0 before 'finish' can be emitted
4594 // emit prefinish if the only thing we're waiting for is _write cbs
4595 // This is relevant for synchronous Transform streams
4596 this.prefinished = false;
4598 // True if the error was already emitted and should not be thrown again
4599 this.errorEmitted = false;
4601 // count buffered requests
4602 this.bufferedRequestCount = 0;
4604 // allocate the first CorkedRequest, there is always
4605 // one allocated and free to use, and we maintain at most two
4606 this.corkedRequestsFree = new CorkedRequest(this);
4609 WritableState.prototype.getBuffer = function getBuffer() {
4610 var current = this.bufferedRequest;
4614 current = current.next;
4621 Object.defineProperty(WritableState.prototype, 'buffer', {
4622 get: internalUtil.deprecate(function () {
4623 return this.getBuffer();
4624 }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
4629 // Test _writableState for inheritance to account for Duplex streams,
4630 // whose prototype chain only points to Readable.
4631 var realHasInstance;
4632 if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
4633 realHasInstance = Function.prototype[Symbol.hasInstance];
4634 Object.defineProperty(Writable, Symbol.hasInstance, {
4635 value: function (object) {
4636 if (realHasInstance.call(this, object)) return true;
4638 return object && object._writableState instanceof WritableState;
4642 realHasInstance = function (object) {
4643 return object instanceof this;
4647 function Writable(options) {
4648 Duplex = Duplex || require('./_stream_duplex');
4650 // Writable ctor is applied to Duplexes, too.
4651 // `realHasInstance` is necessary because using plain `instanceof`
4652 // would return false, as no `_writableState` property is attached.
4654 // Trying to use the custom `instanceof` for Writable here will also break the
4655 // Node.js LazyTransform implementation, which has a non-trivial getter for
4656 // `_writableState` that would lead to infinite recursion.
4657 if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
4658 return new Writable(options);
4661 this._writableState = new WritableState(options, this);
4664 this.writable = true;
4667 if (typeof options.write === 'function') this._write = options.write;
4669 if (typeof options.writev === 'function') this._writev = options.writev;
4675 // Otherwise people can pipe Writable streams, which is just wrong.
4676 Writable.prototype.pipe = function () {
4677 this.emit('error', new Error('Cannot pipe, not readable'));
4680 function writeAfterEnd(stream, cb) {
4681 var er = new Error('write after end');
4682 // TODO: defer error events consistently everywhere, not just the cb
4683 stream.emit('error', er);
4684 processNextTick(cb, er);
4687 // If we get something that is not a buffer, string, null, or undefined,
4688 // and we're not in objectMode, then that's an error.
4689 // Otherwise stream chunks are all considered to be of length=1, and the
4690 // watermarks determine how many objects to keep in the buffer, rather than
4691 // how many bytes or characters.
4692 function validChunk(stream, state, chunk, cb) {
4695 // Always throw error if a null is written
4696 // if we are not in object mode then throw
4697 // if it is not a buffer, string, or undefined.
4698 if (chunk === null) {
4699 er = new TypeError('May not write null values to stream');
4700 } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
4701 er = new TypeError('Invalid non-string/buffer chunk');
4704 stream.emit('error', er);
4705 processNextTick(cb, er);
4711 Writable.prototype.write = function (chunk, encoding, cb) {
4712 var state = this._writableState;
4715 if (typeof encoding === 'function') {
4720 if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
4722 if (typeof cb !== 'function') cb = nop;
4724 if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) {
4726 ret = writeOrBuffer(this, state, chunk, encoding, cb);
4732 Writable.prototype.cork = function () {
4733 var state = this._writableState;
4738 Writable.prototype.uncork = function () {
4739 var state = this._writableState;
4744 if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
4748 Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
4749 // node::ParseEncoding() requires lower case.
4750 if (typeof encoding === 'string') encoding = encoding.toLowerCase();
4751 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);
4752 this._writableState.defaultEncoding = encoding;
4756 function decodeChunk(state, chunk, encoding) {
4757 if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
4758 chunk = bufferShim.from(chunk, encoding);
4763 // if we're already writing something, then just put this
4764 // in the queue, and wait our turn. Otherwise, call _write
4765 // If we return false, then we need a drain event, so set that flag.
4766 function writeOrBuffer(stream, state, chunk, encoding, cb) {
4767 chunk = decodeChunk(state, chunk, encoding);
4769 if (Buffer.isBuffer(chunk)) encoding = 'buffer';
4770 var len = state.objectMode ? 1 : chunk.length;
4772 state.length += len;
4774 var ret = state.length < state.highWaterMark;
4775 // we must ensure that previous needDrain will not be reset to false.
4776 if (!ret) state.needDrain = true;
4778 if (state.writing || state.corked) {
4779 var last = state.lastBufferedRequest;
4780 state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);
4782 last.next = state.lastBufferedRequest;
4784 state.bufferedRequest = state.lastBufferedRequest;
4786 state.bufferedRequestCount += 1;
4788 doWrite(stream, state, false, len, chunk, encoding, cb);
4794 function doWrite(stream, state, writev, len, chunk, encoding, cb) {
4795 state.writelen = len;
4797 state.writing = true;
4799 if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
4803 function onwriteError(stream, state, sync, er, cb) {
4805 if (sync) processNextTick(cb, er);else cb(er);
4807 stream._writableState.errorEmitted = true;
4808 stream.emit('error', er);
4811 function onwriteStateUpdate(state) {
4812 state.writing = false;
4813 state.writecb = null;
4814 state.length -= state.writelen;
4818 function onwrite(stream, er) {
4819 var state = stream._writableState;
4820 var sync = state.sync;
4821 var cb = state.writecb;
4823 onwriteStateUpdate(state);
4825 if (er) onwriteError(stream, state, sync, er, cb);else {
4826 // Check if we're actually ready to finish, but don't emit yet
4827 var finished = needFinish(state);
4829 if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
4830 clearBuffer(stream, state);
4835 asyncWrite(afterWrite
, stream
, state
, finished
, cb
);
4838 afterWrite(stream, state, finished, cb);
4843 function afterWrite(stream, state, finished, cb) {
4844 if (!finished) onwriteDrain(stream, state);
4847 finishMaybe(stream, state);
4850 // Must force callback to be called on nextTick, so that we don't
4851 // emit 'drain' before the write() consumer gets the 'false' return
4852 // value, and has a chance to attach a 'drain' listener.
4853 function onwriteDrain(stream, state) {
4854 if (state.length === 0 && state.needDrain) {
4855 state.needDrain = false;
4856 stream.emit('drain');
4860 // if there's something in the buffer waiting, then process it
4861 function clearBuffer(stream, state) {
4862 state.bufferProcessing = true;
4863 var entry = state.bufferedRequest;
4865 if (stream._writev && entry && entry.next) {
4866 // Fast case, write everything using _writev()
4867 var l = state.bufferedRequestCount;
4868 var buffer = new Array(l);
4869 var holder = state.corkedRequestsFree;
4870 holder.entry = entry;
4874 buffer[count] = entry;
4879 doWrite(stream, state, true, state.length, buffer, '', holder.finish);
4881 // doWrite is almost always async, defer these to save a bit of time
4882 // as the hot path ends with doWrite
4884 state.lastBufferedRequest = null;
4886 state.corkedRequestsFree = holder.next;
4889 state.corkedRequestsFree = new CorkedRequest(state);
4892 // Slow case, write chunks one-by-one
4894 var chunk = entry.chunk;
4895 var encoding = entry.encoding;
4896 var cb = entry.callback;
4897 var len = state.objectMode ? 1 : chunk.length;
4899 doWrite(stream, state, false, len, chunk, encoding, cb);
4901 // if we didn't call the onwrite immediately, then
4902 // it means that we need to wait until it does.
4903 // also, that means that the chunk and cb are currently
4904 // being processed, so move the buffer counter past them.
4905 if (state.writing) {
4910 if (entry === null) state.lastBufferedRequest = null;
4913 state.bufferedRequestCount = 0;
4914 state.bufferedRequest = entry;
4915 state.bufferProcessing = false;
4918 Writable.prototype._write = function (chunk, encoding, cb) {
4919 cb(new Error('_write() is not implemented'));
4922 Writable.prototype._writev = null;
4924 Writable.prototype.end = function (chunk, encoding, cb) {
4925 var state = this._writableState;
4927 if (typeof chunk === 'function') {
4931 } else if (typeof encoding === 'function') {
4936 if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
4938 // .end() fully uncorks
4944 // ignore unnecessary end() calls.
4945 if (!state.ending && !state.finished) endWritable(this, state, cb);
4948 function needFinish(state) {
4949 return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
4952 function prefinish(stream, state) {
4953 if (!state.prefinished) {
4954 state.prefinished = true;
4955 stream.emit('prefinish');
4959 function finishMaybe(stream, state) {
4960 var need = needFinish(state);
4962 if (state.pendingcb === 0) {
4963 prefinish(stream, state);
4964 state.finished = true;
4965 stream.emit('finish');
4967 prefinish(stream, state);
4973 function endWritable(stream, state, cb) {
4974 state.ending = true;
4975 finishMaybe(stream, state);
4977 if (state.finished) processNextTick(cb);else stream.once('finish', cb);
4980 stream.writable = false;
4983 // It seems a linked list but it is not
4984 // there will be only 2 of these for each stream
4985 function CorkedRequest(state) {
4991 this.finish = function (err) {
4992 var entry = _this.entry;
4995 var cb = entry.callback;
5000 if (state.corkedRequestsFree) {
5001 state.corkedRequestsFree.next = _this;
5003 state.corkedRequestsFree = _this;
5007 }).call(this,require('_process'))
5008 },{"./_stream_duplex":15,"_process":13,"buffer":5,"buffer-shims":4,"core-util-is":6,"events":7,"inherits":9,"process-nextick-args":12,"util-deprecate":27}],20:[function(require,module,exports){
5011 var Buffer = require('buffer').Buffer;
5013 var bufferShim
= require('buffer-shims');
5016 module.exports = BufferList;
5018 function BufferList() {
5024 BufferList.prototype.push = function (v) {
5025 var entry = { data: v, next: null };
5026 if (this.length > 0) this.tail.next = entry;else this.head = entry;
5031 BufferList.prototype.unshift = function (v) {
5032 var entry = { data: v, next: this.head };
5033 if (this.length === 0) this.tail = entry;
5038 BufferList.prototype.shift = function () {
5039 if (this.length === 0) return;
5040 var ret = this.head.data;
5041 if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
5046 BufferList.prototype.clear = function () {
5047 this.head = this.tail = null;
5051 BufferList.prototype.join = function (s) {
5052 if (this.length === 0) return '';
5054 var ret = '' + p.data;
5055 while (p = p.next) {
5060 BufferList.prototype.concat = function (n) {
5061 if (this.length === 0) return bufferShim.alloc(0);
5062 if (this.length === 1) return this.head.data;
5063 var ret = bufferShim.allocUnsafe(n >>> 0);
5067 p.data.copy(ret, i);
5073 },{"buffer":5,"buffer-shims":4}],21:[function(require,module,exports){
5074 module.exports = require("./lib/_stream_passthrough.js")
5076 },{"./lib/_stream_passthrough.js":16}],22:[function(require,module,exports){
5077 (function (process){
5078 var Stream = (function (){
5080 return require('st' + 'ream'); // hack to fix a circular dependency issue when used with browserify
5083 exports = module.exports = require('./lib/_stream_readable.js');
5084 exports.Stream = Stream || exports;
5085 exports.Readable = exports;
5086 exports.Writable = require('./lib/_stream_writable.js');
5087 exports.Duplex = require('./lib/_stream_duplex.js');
5088 exports.Transform = require('./lib/_stream_transform.js');
5089 exports.PassThrough = require('./lib/_stream_passthrough.js');
5091 if (!process.browser && process.env.READABLE_STREAM === 'disable' && Stream) {
5092 module.exports = Stream;
5095 }).call(this,require('_process'))
5096 },{"./lib/_stream_duplex.js":15,"./lib/_stream_passthrough.js":16,"./lib/_stream_readable.js":17,"./lib/_stream_transform.js":18,"./lib/_stream_writable.js":19,"_process":13}],23:[function(require,module,exports){
5097 module.exports = require("./lib/_stream_transform.js")
5099 },{"./lib/_stream_transform.js":18}],24:[function(require,module,exports){
5100 module.exports = require("./lib/_stream_writable.js")
5102 },{"./lib/_stream_writable.js":19}],25:[function(require,module,exports){
5103 // Copyright Joyent, Inc. and other Node contributors.
5105 // Permission is hereby granted, free of charge, to any person obtaining a
5106 // copy of this software and associated documentation files (the
5107 // "Software"), to deal in the Software without restriction, including
5108 // without limitation the rights to use, copy, modify, merge, publish,
5109 // distribute, sublicense, and/or sell copies of the Software, and to permit
5110 // persons to whom the Software is furnished to do so, subject to the
5111 // following conditions:
5113 // The above copyright notice and this permission notice shall be included
5114 // in all copies or substantial portions of the Software.
5116 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
5117 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
5118 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
5119 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
5120 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
5121 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
5122 // USE OR OTHER DEALINGS IN THE SOFTWARE.
5124 module.exports = Stream;
5126 var EE = require('events').EventEmitter;
5127 var inherits = require('inherits');
5129 inherits(Stream, EE);
5130 Stream.Readable = require('readable-stream/readable.js');
5131 Stream.Writable = require('readable-stream/writable.js');
5132 Stream.Duplex = require('readable-stream/duplex.js');
5133 Stream.Transform = require('readable-stream/transform.js');
5134 Stream.PassThrough = require('readable-stream/passthrough.js');
5136 // Backwards-compat with node 0.4.x
5137 Stream.Stream = Stream;
5141 // old-style streams. Note that the pipe method (the only relevant
5142 // part of this class) is overridden in the Readable class.
5148 Stream.prototype.pipe = function(dest, options) {
5151 function ondata(chunk) {
5152 if (dest.writable) {
5153 if (false === dest.write(chunk) && source.pause) {
5159 source.on('data', ondata);
5161 function ondrain() {
5162 if (source.readable && source.resume) {
5167 dest.on('drain', ondrain);
5169 // If the 'end' option is not supplied, dest.end() will be called when
5170 // source gets the 'end' or 'close' events. Only dest.end() once.
5171 if (!dest._isStdio && (!options || options.end !== false)) {
5172 source.on('end', onend);
5173 source.on('close', onclose);
5176 var didOnEnd = false;
5178 if (didOnEnd) return;
5185 function onclose() {
5186 if (didOnEnd) return;
5189 if (typeof dest.destroy === 'function') dest.destroy();
5192 // don't leave dangling pipes when there are errors.
5193 function onerror(er) {
5195 if (EE.listenerCount(this, 'error') === 0) {
5196 throw er; // Unhandled stream error in pipe.
5200 source.on('error', onerror);
5201 dest.on('error', onerror);
5203 // remove all the event listeners that were added.
5204 function cleanup() {
5205 source.removeListener('data', ondata);
5206 dest.removeListener('drain', ondrain);
5208 source.removeListener('end', onend);
5209 source.removeListener('close', onclose);
5211 source.removeListener('error', onerror);
5212 dest.removeListener('error', onerror);
5214 source.removeListener('end', cleanup);
5215 source.removeListener('close', cleanup);
5217 dest.removeListener('close', cleanup);
5220 source.on('end', cleanup);
5221 source.on('close', cleanup);
5223 dest.on('close', cleanup);
5225 dest.emit('pipe', source);
5227 // Allow for unix-like usage: A.pipe(B).pipe(C)
5231 },{"events":7,"inherits":9,"readable-stream/duplex.js":14,"readable-stream/passthrough.js":21,"readable-stream/readable.js":22,"readable-stream/transform.js":23,"readable-stream/writable.js":24}],26:[function(require,module,exports){
5232 // Copyright Joyent, Inc. and other Node contributors.
5234 // Permission is hereby granted, free of charge, to any person obtaining a
5235 // copy of this software and associated documentation files (the
5236 // "Software"), to deal in the Software without restriction, including
5237 // without limitation the rights to use, copy, modify, merge, publish,
5238 // distribute, sublicense, and/or sell copies of the Software, and to permit
5239 // persons to whom the Software is furnished to do so, subject to the
5240 // following conditions:
5242 // The above copyright notice and this permission notice shall be included
5243 // in all copies or substantial portions of the Software.
5245 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
5246 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
5247 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
5248 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
5249 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
5250 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
5251 // USE OR OTHER DEALINGS IN THE SOFTWARE.
5253 var Buffer = require('buffer').Buffer;
5255 var isBufferEncoding = Buffer.isEncoding
5256 || function(encoding) {
5257 switch (encoding && encoding.toLowerCase()) {
5258 case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
5259 default: return false;
5264 function assertEncoding(encoding) {
5265 if (encoding && !isBufferEncoding(encoding)) {
5266 throw new Error('Unknown encoding: ' + encoding);
5270 // StringDecoder provides an interface for efficiently splitting a series of
5271 // buffers into a series of JS strings without breaking apart multi-byte
5272 // characters. CESU-8 is handled as part of the UTF-8 encoding.
5274 // @TODO Handling all encodings inside a single object makes it very difficult
5275 // to reason about this code, so it should be split up in the future.
5276 // @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
5277 // points as used by CESU-8.
5278 var StringDecoder = exports.StringDecoder = function(encoding) {
5279 this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
5280 assertEncoding(encoding);
5281 switch (this.encoding) {
5283 // CESU-8 represents each of Surrogate Pair by 3-bytes
5284 this.surrogateSize = 3;
5288 // UTF-16 represents each of Surrogate Pair by 2-bytes
5289 this.surrogateSize = 2;
5290 this.detectIncompleteChar = utf16DetectIncompleteChar;
5293 // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
5294 this.surrogateSize = 3;
5295 this.detectIncompleteChar = base64DetectIncompleteChar;
5298 this.write = passThroughWrite;
5302 // Enough space to store all bytes of a single character. UTF-8 needs 4
5303 // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
5304 this.charBuffer = new Buffer(6);
5305 // Number of bytes received for the current incomplete multi-byte character.
5306 this.charReceived = 0;
5307 // Number of bytes expected for the current incomplete multi-byte character.
5308 this.charLength = 0;
5312 // write decodes the given buffer and returns it as JS string that is
5313 // guaranteed to not contain any partial multi-byte characters. Any partial
5314 // character found at the end of the buffer is buffered up, and will be
5315 // returned when calling write again with the remaining bytes.
5317 // Note: Converting a Buffer containing an orphan surrogate to a String
5318 // currently works, but converting a String to a Buffer (via `new Buffer`, or
5319 // Buffer#write) will replace incomplete surrogates with the unicode
5320 // replacement character. See https://codereview.chromium.org/121173009/ .
5321 StringDecoder.prototype.write = function(buffer) {
5323 // if our last write ended with an incomplete multibyte character
5324 while (this.charLength) {
5325 // determine how many remaining bytes this buffer has to offer for this char
5326 var available = (buffer.length >= this.charLength - this.charReceived) ?
5327 this.charLength - this.charReceived :
5330 // add the new bytes to the char buffer
5331 buffer.copy(this.charBuffer, this.charReceived, 0, available);
5332 this.charReceived += available;
5334 if (this.charReceived < this.charLength) {
5335 // still not enough chars in this buffer? wait for more ...
5339 // remove bytes belonging to the current character from the buffer
5340 buffer = buffer.slice(available, buffer.length);
5342 // get the character that was split
5343 charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
5345 // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
5346 var charCode = charStr.charCodeAt(charStr.length - 1);
5347 if (charCode >= 0xD800 && charCode <= 0xDBFF) {
5348 this.charLength += this.surrogateSize;
5352 this.charReceived = this.charLength = 0;
5354 // if there are no more bytes in this buffer, just emit our char
5355 if (buffer.length === 0) {
5361 // determine and set charLength / charReceived
5362 this.detectIncompleteChar(buffer);
5364 var end = buffer.length;
5365 if (this.charLength) {
5366 // buffer the incomplete character bytes we got
5367 buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
5368 end -= this.charReceived;
5371 charStr += buffer.toString(this.encoding, 0, end);
5373 var end = charStr.length - 1;
5374 var charCode = charStr.charCodeAt(end);
5375 // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
5376 if (charCode >= 0xD800 && charCode <= 0xDBFF) {
5377 var size = this.surrogateSize;
5378 this.charLength += size;
5379 this.charReceived += size;
5380 this.charBuffer.copy(this.charBuffer, size, 0, size);
5381 buffer.copy(this.charBuffer, 0, 0, size);
5382 return charStr.substring(0, end);
5385 // or just emit the charStr
5389 // detectIncompleteChar determines if there is an incomplete UTF-8 character at
5390 // the end of the given buffer. If so, it sets this.charLength to the byte
5391 // length that character, and sets this.charReceived to the number of bytes
5392 // that are available for this character.
5393 StringDecoder.prototype.detectIncompleteChar = function(buffer) {
5394 // determine how many bytes we have to check at the end of this buffer
5395 var i = (buffer.length >= 3) ? 3 : buffer.length;
5397 // Figure out if one of the last i bytes of our buffer announces an
5399 for (; i > 0; i--) {
5400 var c = buffer[buffer.length - i];
5402 // See http://en.wikipedia.org/wiki/UTF-8#Description
5405 if (i == 1 && c >> 5 == 0x06) {
5406 this.charLength = 2;
5411 if (i <= 2 && c >> 4 == 0x0E) {
5412 this.charLength = 3;
5417 if (i <= 3 && c >> 3 == 0x1E) {
5418 this.charLength = 4;
5422 this.charReceived = i;
5425 StringDecoder.prototype.end = function(buffer) {
5427 if (buffer && buffer.length)
5428 res = this.write(buffer);
5430 if (this.charReceived) {
5431 var cr = this.charReceived;
5432 var buf = this.charBuffer;
5433 var enc = this.encoding;
5434 res += buf.slice(0, cr).toString(enc);
5440 function passThroughWrite(buffer) {
5441 return buffer.toString(this.encoding);
5444 function utf16DetectIncompleteChar(buffer) {
5445 this.charReceived = buffer.length % 2;
5446 this.charLength = this.charReceived ? 2 : 0;
5449 function base64DetectIncompleteChar(buffer) {
5450 this.charReceived = buffer.length % 3;
5451 this.charLength = this.charReceived ? 3 : 0;
5454 },{"buffer":5}],27:[function(require,module,exports){
5461 module
.exports
= deprecate
;
5464 * Mark that a method should not be used.
5465 * Returns a modified function which warns once by default.
5467 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
5469 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
5470 * will throw an Error when invoked.
5472 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
5473 * will invoke `console.trace()` instead of `console.error()`.
5475 * @param {Function} fn - the function to deprecate
5476 * @param {String} msg - the string to print to the console when `fn` is invoked
5477 * @returns {Function} a new "deprecated" version of `fn`
5481 function deprecate (fn
, msg
) {
5482 if (config('noDeprecation')) {
5487 function deprecated() {
5489 if (config('throwDeprecation')) {
5490 throw new Error(msg
);
5491 } else if (config('traceDeprecation')) {
5498 return fn
.apply(this, arguments
);
5505 * Checks `localStorage` for boolean values for the given `name`.
5507 * @param {String} name
5508 * @returns {Boolean}
5512 function config (name
) {
5513 // accessing global.localStorage can trigger a DOMException in sandboxed iframes
5515 if (!global
.localStorage
) return false;
5519 var val
= global
.localStorage
[name
];
5520 if (null == val
) return false;
5521 return String(val
).toLowerCase() === 'true';
5524 }).call(this,typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
5525 },{}],28:[function(require
,module
,exports
){
5526 arguments
[4][9][0].apply(exports
,arguments
)
5527 },{"dup":9}],29:[function(require
,module
,exports
){
5528 module
.exports
= function isBuffer(arg
) {
5529 return arg
&& typeof arg
=== 'object'
5530 && typeof arg
.copy
=== 'function'
5531 && typeof arg
.fill
=== 'function'
5532 && typeof arg
.readUInt8
=== 'function';
5534 },{}],30:[function(require
,module
,exports
){
5535 (function (process
,global
){
5536 // Copyright Joyent, Inc. and other Node contributors.
5538 // Permission is hereby granted, free of charge, to any person obtaining a
5539 // copy of this software and associated documentation files (the
5540 // "Software"), to deal in the Software without restriction, including
5541 // without limitation the rights to use, copy, modify, merge, publish,
5542 // distribute, sublicense, and/or sell copies of the Software, and to permit
5543 // persons to whom the Software is furnished to do so, subject to the
5544 // following conditions:
5546 // The above copyright notice and this permission notice shall be included
5547 // in all copies or substantial portions of the Software.
5549 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
5550 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
5551 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
5552 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
5553 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
5554 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
5555 // USE OR OTHER DEALINGS IN THE SOFTWARE.
5557 var formatRegExp
= /%[sdj%]/g;
5558 exports
.format = function(f
) {
5561 for (var i
= 0; i
< arguments
.length
; i
++) {
5562 objects
.push(inspect(arguments
[i
]));
5564 return objects
.join(' ');
5568 var args
= arguments
;
5569 var len
= args
.length
;
5570 var str
= String(f
).replace(formatRegExp
, function(x
) {
5571 if (x
=== '%%') return '%';
5572 if (i
>= len
) return x
;
5574 case '%s': return String(args
[i
++]);
5575 case '%d': return Number(args
[i
++]);
5578 return JSON
.stringify(args
[i
++]);
5580 return '[Circular]';
5586 for (var x
= args
[i
]; i
< len
; x
= args
[++i
]) {
5587 if (isNull(x
) || !isObject(x
)) {
5590 str
+= ' ' + inspect(x
);
5597 // Mark that a method should not be used.
5598 // Returns a modified function which warns once by default.
5599 // If --no-deprecation is set, then it is a no-op.
5600 exports
.deprecate = function(fn
, msg
) {
5601 // Allow for deprecating things in the process of starting up.
5602 if (isUndefined(global
.process
)) {
5604 return exports
.deprecate(fn
, msg
).apply(this, arguments
);
5608 if (process
.noDeprecation
=== true) {
5613 function deprecated() {
5615 if (process
.throwDeprecation
) {
5616 throw new Error(msg
);
5617 } else if (process
.traceDeprecation
) {
5624 return fn
.apply(this, arguments
);
5633 exports
.debuglog = function(set) {
5634 if (isUndefined(debugEnviron
))
5635 debugEnviron
= process
.env
.NODE_DEBUG
|| '';
5636 set = set.toUpperCase();
5638 if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron
)) {
5639 var pid
= process
.pid
;
5640 debugs
[set] = function() {
5641 var msg
= exports
.format
.apply(exports
, arguments
);
5642 console
.error('%s %d: %s', set, pid
, msg
);
5645 debugs
[set] = function() {};
5653 * Echos the value of a value. Trys to print the value out
5654 * in the best way possible given the different types.
5656 * @param {Object} obj The object to print out.
5657 * @param {Object} opts Optional options object that alters the output.
5659 /* legacy: obj, showHidden, depth, colors*/
5660 function inspect(obj
, opts
) {
5664 stylize: stylizeNoColor
5667 if (arguments
.length
>= 3) ctx
.depth
= arguments
[2];
5668 if (arguments
.length
>= 4) ctx
.colors
= arguments
[3];
5669 if (isBoolean(opts
)) {
5671 ctx
.showHidden
= opts
;
5673 // got an "options" object
5674 exports
._extend(ctx
, opts
);
5676 // set default options
5677 if (isUndefined(ctx
.showHidden
)) ctx
.showHidden
= false;
5678 if (isUndefined(ctx
.depth
)) ctx
.depth
= 2;
5679 if (isUndefined(ctx
.colors
)) ctx
.colors
= false;
5680 if (isUndefined(ctx
.customInspect
)) ctx
.customInspect
= true;
5681 if (ctx
.colors
) ctx
.stylize
= stylizeWithColor
;
5682 return formatValue(ctx
, obj
, ctx
.depth
);
5684 exports
.inspect
= inspect
;
5687 // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
5691 'underline' : [4, 24],
5692 'inverse' : [7, 27],
5699 'magenta' : [35, 39],
5704 // Don't use 'blue' not visible on cmd.exe
5708 'boolean': 'yellow',
5709 'undefined': 'grey',
5713 // "name": intentionally not styling
5718 function stylizeWithColor(str
, styleType
) {
5719 var style
= inspect
.styles
[styleType
];
5722 return '\u001b[' + inspect
.colors
[style
][0] + 'm' + str
+
5723 '\u001b[' + inspect
.colors
[style
][1] + 'm';
5730 function stylizeNoColor(str
, styleType
) {
5735 function arrayToHash(array
) {
5738 array
.forEach(function(val
, idx
) {
5746 function formatValue(ctx
, value
, recurseTimes
) {
5747 // Provide a hook for user-specified inspect functions.
5748 // Check that value is an object with an inspect function on it
5749 if (ctx
.customInspect
&&
5751 isFunction(value
.inspect
) &&
5752 // Filter out the util module, it's inspect function is special
5753 value
.inspect
!== exports
.inspect
&&
5754 // Also filter out any prototype objects using the circular check.
5755 !(value
.constructor && value
.constructor.prototype === value
)) {
5756 var ret
= value
.inspect(recurseTimes
, ctx
);
5757 if (!isString(ret
)) {
5758 ret
= formatValue(ctx
, ret
, recurseTimes
);
5763 // Primitive types cannot have properties
5764 var primitive
= formatPrimitive(ctx
, value
);
5769 // Look up the keys of the object.
5770 var keys
= Object
.keys(value
);
5771 var visibleKeys
= arrayToHash(keys
);
5773 if (ctx
.showHidden
) {
5774 keys
= Object
.getOwnPropertyNames(value
);
5777 // IE doesn't make error fields non-enumerable
5778 // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
5780 && (keys
.indexOf('message') >= 0 || keys
.indexOf('description') >= 0)) {
5781 return formatError(value
);
5784 // Some type of object without properties can be shortcutted.
5785 if (keys
.length
=== 0) {
5786 if (isFunction(value
)) {
5787 var name
= value
.name
? ': ' + value
.name : '';
5788 return ctx
.stylize('[Function' + name
+ ']', 'special');
5790 if (isRegExp(value
)) {
5791 return ctx
.stylize(RegExp
.prototype.toString
.call(value
), 'regexp');
5793 if (isDate(value
)) {
5794 return ctx
.stylize(Date
.prototype.toString
.call(value
), 'date');
5796 if (isError(value
)) {
5797 return formatError(value
);
5801 var base
= '', array
= false, braces
= ['{', '}'];
5803 // Make Array say that they are Array
5804 if (isArray(value
)) {
5806 braces
= ['[', ']'];
5809 // Make functions say that they are functions
5810 if (isFunction(value
)) {
5811 var n
= value
.name
? ': ' + value
.name : '';
5812 base
= ' [Function' + n
+ ']';
5815 // Make RegExps say that they are RegExps
5816 if (isRegExp(value
)) {
5817 base
= ' ' + RegExp
.prototype.toString
.call(value
);
5820 // Make dates with properties first say the date
5821 if (isDate(value
)) {
5822 base
= ' ' + Date
.prototype.toUTCString
.call(value
);
5825 // Make error with message first say the error
5826 if (isError(value
)) {
5827 base
= ' ' + formatError(value
);
5830 if (keys
.length
=== 0 && (!array
|| value
.length
== 0)) {
5831 return braces
[0] + base
+ braces
[1];
5834 if (recurseTimes
< 0) {
5835 if (isRegExp(value
)) {
5836 return ctx
.stylize(RegExp
.prototype.toString
.call(value
), 'regexp');
5838 return ctx
.stylize('[Object]', 'special');
5842 ctx
.seen
.push(value
);
5846 output
= formatArray(ctx
, value
, recurseTimes
, visibleKeys
, keys
);
5848 output
= keys
.map(function(key
) {
5849 return formatProperty(ctx
, value
, recurseTimes
, visibleKeys
, key
, array
);
5855 return reduceToSingleString(output
, base
, braces
);
5859 function formatPrimitive(ctx
, value
) {
5860 if (isUndefined(value
))
5861 return ctx
.stylize('undefined', 'undefined');
5862 if (isString(value
)) {
5863 var simple
= '\'' + JSON
.stringify(value
).replace(/^"|"$/g, '')
5864 .replace(/'/g, "\\'")
5865 .replace(/\\"/g
, '"') + '\'';
5866 return ctx
.stylize(simple
, 'string');
5868 if (isNumber(value
))
5869 return ctx
.stylize('' + value
, 'number');
5870 if (isBoolean(value
))
5871 return ctx
.stylize('' + value
, 'boolean');
5872 // For some reason typeof null is "object", so special case here.
5874 return ctx
.stylize('null', 'null');
5878 function formatError(value
) {
5879 return '[' + Error
.prototype.toString
.call(value
) + ']';
5883 function formatArray(ctx
, value
, recurseTimes
, visibleKeys
, keys
) {
5885 for (var i
= 0, l
= value
.length
; i
< l
; ++i
) {
5886 if (hasOwnProperty(value
, String(i
))) {
5887 output
.push(formatProperty(ctx
, value
, recurseTimes
, visibleKeys
,
5893 keys
.forEach(function(key
) {
5894 if (!key
.match(/^\d+$/)) {
5895 output
.push(formatProperty(ctx
, value
, recurseTimes
, visibleKeys
,
5903 function formatProperty(ctx
, value
, recurseTimes
, visibleKeys
, key
, array
) {
5904 var name
, str
, desc
;
5905 desc
= Object
.getOwnPropertyDescriptor(value
, key
) || { value: value
[key
] };
5908 str
= ctx
.stylize('[Getter/Setter]', 'special');
5910 str
= ctx
.stylize('[Getter]', 'special');
5914 str
= ctx
.stylize('[Setter]', 'special');
5917 if (!hasOwnProperty(visibleKeys
, key
)) {
5918 name
= '[' + key
+ ']';
5921 if (ctx
.seen
.indexOf(desc
.value
) < 0) {
5922 if (isNull(recurseTimes
)) {
5923 str
= formatValue(ctx
, desc
.value
, null);
5925 str
= formatValue(ctx
, desc
.value
, recurseTimes
- 1);
5927 if (str
.indexOf('\n') > -1) {
5929 str
= str
.split('\n').map(function(line
) {
5931 }).join('\n').substr(2);
5933 str
= '\n' + str
.split('\n').map(function(line
) {
5939 str
= ctx
.stylize('[Circular]', 'special');
5942 if (isUndefined(name
)) {
5943 if (array
&& key
.match(/^\d+$/)) {
5946 name
= JSON
.stringify('' + key
);
5947 if (name
.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
5948 name
= name
.substr(1, name
.length
- 2);
5949 name
= ctx
.stylize(name
, 'name');
5951 name
= name
.replace(/'/g, "\\'")
5952 .replace(/\\"/g
, '"')
5953 .replace(/(^"|"$)/g, "'");
5954 name
= ctx
.stylize(name
, 'string');
5958 return name
+ ': ' + str
;
5962 function reduceToSingleString(output
, base
, braces
) {
5963 var numLinesEst
= 0;
5964 var length
= output
.reduce(function(prev
, cur
) {
5966 if (cur
.indexOf('\n') >= 0) numLinesEst
++;
5967 return prev
+ cur
.replace(/\u001b\[\d\d?m/g, '').length
+ 1;
5972 (base
=== '' ? '' : base
+ '\n ') +
5974 output
.join(',\n ') +
5979 return braces
[0] + base
+ ' ' + output
.join(', ') + ' ' + braces
[1];
5983 // NOTE: These type checking functions intentionally don't use `instanceof`
5984 // because it is fragile and can be easily faked with `Object.create()`.
5985 function isArray(ar
) {
5986 return Array
.isArray(ar
);
5988 exports
.isArray
= isArray
;
5990 function isBoolean(arg
) {
5991 return typeof arg
=== 'boolean';
5993 exports
.isBoolean
= isBoolean
;
5995 function isNull(arg
) {
5996 return arg
=== null;
5998 exports
.isNull
= isNull
;
6000 function isNullOrUndefined(arg
) {
6003 exports
.isNullOrUndefined
= isNullOrUndefined
;
6005 function isNumber(arg
) {
6006 return typeof arg
=== 'number';
6008 exports
.isNumber
= isNumber
;
6010 function isString(arg
) {
6011 return typeof arg
=== 'string';
6013 exports
.isString
= isString
;
6015 function isSymbol(arg
) {
6016 return typeof arg
=== 'symbol';
6018 exports
.isSymbol
= isSymbol
;
6020 function isUndefined(arg
) {
6021 return arg
=== void 0;
6023 exports
.isUndefined
= isUndefined
;
6025 function isRegExp(re
) {
6026 return isObject(re
) && objectToString(re
) === '[object RegExp]';
6028 exports
.isRegExp
= isRegExp
;
6030 function isObject(arg
) {
6031 return typeof arg
=== 'object' && arg
!== null;
6033 exports
.isObject
= isObject
;
6035 function isDate(d
) {
6036 return isObject(d
) && objectToString(d
) === '[object Date]';
6038 exports
.isDate
= isDate
;
6040 function isError(e
) {
6041 return isObject(e
) &&
6042 (objectToString(e
) === '[object Error]' || e
instanceof Error
);
6044 exports
.isError
= isError
;
6046 function isFunction(arg
) {
6047 return typeof arg
=== 'function';
6049 exports
.isFunction
= isFunction
;
6051 function isPrimitive(arg
) {
6052 return arg
=== null ||
6053 typeof arg
=== 'boolean' ||
6054 typeof arg
=== 'number' ||
6055 typeof arg
=== 'string' ||
6056 typeof arg
=== 'symbol' || // ES6 symbol
6057 typeof arg
=== 'undefined';
6059 exports
.isPrimitive
= isPrimitive
;
6061 exports
.isBuffer
= require('./support/isBuffer');
6063 function objectToString(o
) {
6064 return Object
.prototype.toString
.call(o
);
6069 return n
< 10 ? '0' + n
.toString(10) : n
.toString(10);
6073 var months
= ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
6074 'Oct', 'Nov', 'Dec'];
6077 function timestamp() {
6079 var time
= [pad(d
.getHours()),
6080 pad(d
.getMinutes()),
6081 pad(d
.getSeconds())].join(':');
6082 return [d
.getDate(), months
[d
.getMonth()], time
].join(' ');
6086 // log is just a thin wrapper to console.log that prepends a timestamp
6087 exports
.log = function() {
6088 console
.log('%s - %s', timestamp(), exports
.format
.apply(exports
, arguments
));
6093 * Inherit the prototype methods from one constructor into another.
6095 * The Function.prototype.inherits from lang.js rewritten as a standalone
6096 * function (not on Function.prototype). NOTE: If this file is to be loaded
6097 * during bootstrapping this function needs to be rewritten using some native
6098 * functions as prototype setup using normal JavaScript does not work as
6099 * expected during bootstrapping (see mirror.js in r114903).
6101 * @param {function} ctor Constructor function which needs to inherit the
6103 * @param {function} superCtor Constructor function to inherit prototype from.
6105 exports
.inherits
= require('inherits');
6107 exports
._extend = function(origin
, add
) {
6108 // Don't do anything if add isn't an object
6109 if (!add
|| !isObject(add
)) return origin
;
6111 var keys
= Object
.keys(add
);
6112 var i
= keys
.length
;
6114 origin
[keys
[i
]] = add
[keys
[i
]];
6119 function hasOwnProperty(obj
, prop
) {
6120 return Object
.prototype.hasOwnProperty
.call(obj
, prop
);
6123 }).call(this,require('_process'),typeof global
!== "undefined" ? global : typeof self
!== "undefined" ? self : typeof window
!== "undefined" ? window : {})
6124 },{"./support/isBuffer":29,"_process":13,"inherits":28}],31:[function(require
,module
,exports
){
6126 const createKeccakHash
= require('keccak')
6127 const secp256k1
= require('secp256k1')
6128 const assert
= require('assert')
6129 const rlp
= require('rlp')
6130 const BN
= require('bn.js')
6131 const createHash
= require('create-hash')
6132 Object
.assign(exports
, require('ethjs-util'))
6135 * the max integer that this VM can handle (a ```BN```)
6136 * @var {BN} MAX_INTEGER
6138 exports
.MAX_INTEGER
= new BN('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)
6141 * 2^256 (a ```BN```)
6142 * @var {BN} TWO_POW256
6144 exports
.TWO_POW256
= new BN('10000000000000000000000000000000000000000000000000000000000000000', 16)
6147 * SHA3-256 hash of null (a ```String```)
6148 * @var {String} SHA3_NULL_S
6150 exports
.SHA3_NULL_S
= 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
6153 * SHA3-256 hash of null (a ```Buffer```)
6154 * @var {Buffer} SHA3_NULL
6156 exports
.SHA3_NULL
= Buffer
.from(exports
.SHA3_NULL_S
, 'hex')
6159 * SHA3-256 of an RLP of an empty array (a ```String```)
6160 * @var {String} SHA3_RLP_ARRAY_S
6162 exports
.SHA3_RLP_ARRAY_S
= '1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347'
6165 * SHA3-256 of an RLP of an empty array (a ```Buffer```)
6166 * @var {Buffer} SHA3_RLP_ARRAY
6168 exports
.SHA3_RLP_ARRAY
= Buffer
.from(exports
.SHA3_RLP_ARRAY_S
, 'hex')
6171 * SHA3-256 hash of the RLP of null (a ```String```)
6172 * @var {String} SHA3_RLP_S
6174 exports
.SHA3_RLP_S
= '56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421'
6177 * SHA3-256 hash of the RLP of null (a ```Buffer```)
6178 * @var {Buffer} SHA3_RLP
6180 exports
.SHA3_RLP
= Buffer
.from(exports
.SHA3_RLP_S
, 'hex')
6183 * [`BN`](https://github.com/indutny/bn.js)
6189 * [`rlp`](https://github.com/ethereumjs/rlp)
6195 * [`secp256k1`](https://github.com/cryptocoinjs/secp256k1-node/)
6198 exports
.secp256k1
= secp256k1
6201 * Returns a buffer filled with 0s
6203 * @param {Number} bytes the number of bytes the buffer should be
6206 exports
.zeros = function (bytes
) {
6207 return Buffer
.allocUnsafe(bytes
).fill(0)
6211 * Left Pads an `Array` or `Buffer` with leading zeros till it has `length` bytes.
6212 * Or it truncates the beginning if it exceeds.
6213 * @method lsetLength
6214 * @param {Buffer|Array} msg the value to pad
6215 * @param {Number} length the number of bytes the output should be
6216 * @param {Boolean} [right=false] whether to start padding form the left or right
6217 * @return {Buffer|Array}
6219 exports
.setLengthLeft
= exports
.setLength = function (msg
, length
, right
) {
6220 var buf
= exports
.zeros(length
)
6221 msg
= exports
.toBuffer(msg
)
6223 if (msg
.length
< length
) {
6227 return msg
.slice(0, length
)
6229 if (msg
.length
< length
) {
6230 msg
.copy(buf
, length
- msg
.length
)
6233 return msg
.slice(-length
)
6238 * Right Pads an `Array` or `Buffer` with leading zeros till it has `length` bytes.
6239 * Or it truncates the beginning if it exceeds.
6240 * @param {Buffer|Array} msg the value to pad
6241 * @param {Number} length the number of bytes the output should be
6242 * @return {Buffer|Array}
6244 exports
.setLengthRight = function (msg
, length
) {
6245 return exports
.setLength(msg
, length
, true)
6249 * Trims leading zeros from a `Buffer` or an `Array`
6250 * @param {Buffer|Array|String} a
6251 * @return {Buffer|Array|String}
6253 exports
.unpad
= exports
.stripZeros = function (a
) {
6254 a
= exports
.stripHexPrefix(a
)
6256 while (a
.length
> 0 && first
.toString() === '0') {
6263 * Attempts to turn a value into a `Buffer`. As input it supports `Buffer`, `String`, `Number`, null/undefined, `BN` and other objects with a `toArray()` method.
6264 * @param {*} v the value
6266 exports
.toBuffer = function (v
) {
6267 if (!Buffer
.isBuffer(v
)) {
6268 if (Array
.isArray(v
)) {
6270 } else if (typeof v
=== 'string') {
6271 if (exports
.isHexPrefixed(v
)) {
6272 v
= Buffer
.from(exports
.padToEven(exports
.stripHexPrefix(v
)), 'hex')
6276 } else if (typeof v
=== 'number') {
6277 v
= exports
.intToBuffer(v
)
6278 } else if (v
=== null || v
=== undefined) {
6279 v
= Buffer
.allocUnsafe(0)
6280 } else if (v
.toArray
) {
6281 // converts a BN to a Buffer
6282 v
= Buffer
.from(v
.toArray())
6284 throw new Error('invalid type')
6291 * Converts a `Buffer` to a `Number`
6292 * @param {Buffer} buf
6294 * @throws If the input number exceeds 53 bits.
6296 exports
.bufferToInt = function (buf
) {
6297 return new BN(exports
.toBuffer(buf
)).toNumber()
6301 * Converts a `Buffer` into a hex `String`
6302 * @param {Buffer} buf
6305 exports
.bufferToHex = function (buf
) {
6306 buf
= exports
.toBuffer(buf
)
6307 return '0x' + buf
.toString('hex')
6311 * Interprets a `Buffer` as a signed integer and returns a `BN`. Assumes 256-bit numbers.
6312 * @param {Buffer} num
6315 exports
.fromSigned = function (num
) {
6316 return new BN(num
).fromTwos(256)
6320 * Converts a `BN` to an unsigned integer and returns it as a `Buffer`. Assumes 256-bit numbers.
6324 exports
.toUnsigned = function (num
) {
6325 return Buffer
.from(num
.toTwos(256).toArray())
6329 * Creates SHA-3 hash of the input
6330 * @param {Buffer|Array|String|Number} a the input data
6331 * @param {Number} [bits=256] the SHA width
6334 exports
.sha3 = function (a
, bits
) {
6335 a
= exports
.toBuffer(a
)
6336 if (!bits
) bits
= 256
6338 return createKeccakHash('keccak' + bits
).update(a
).digest()
6342 * Creates SHA256 hash of the input
6343 * @param {Buffer|Array|String|Number} a the input data
6346 exports
.sha256 = function (a
) {
6347 a
= exports
.toBuffer(a
)
6348 return createHash('sha256').update(a
).digest()
6352 * Creates RIPEMD160 hash of the input
6353 * @param {Buffer|Array|String|Number} a the input data
6354 * @param {Boolean} padded whether it should be padded to 256 bits or not
6357 exports
.ripemd160 = function (a
, padded
) {
6358 a
= exports
.toBuffer(a
)
6359 var hash
= createHash('rmd160').update(a
).digest()
6360 if (padded
=== true) {
6361 return exports
.setLength(hash
, 32)
6368 * Creates SHA-3 hash of the RLP encoded version of the input
6369 * @param {Buffer|Array|String|Number} a the input data
6372 exports
.rlphash = function (a
) {
6373 return exports
.sha3(rlp
.encode(a
))
6377 * Checks if the private key satisfies the rules of the curve secp256k1.
6378 * @param {Buffer} privateKey
6381 exports
.isValidPrivate = function (privateKey
) {
6382 return secp256k1
.privateKeyVerify(privateKey
)
6386 * Checks if the public key satisfies the rules of the curve secp256k1
6387 * and the requirements of Ethereum.
6388 * @param {Buffer} publicKey The two points of an uncompressed key, unless sanitize is enabled
6389 * @param {Boolean} [sanitize=false] Accept public keys in other formats
6392 exports
.isValidPublic = function (publicKey
, sanitize
) {
6393 if (publicKey
.length
=== 64) {
6394 // Convert to SEC1 for secp256k1
6395 return secp256k1
.publicKeyVerify(Buffer
.concat([ Buffer
.from([4]), publicKey
]))
6402 return secp256k1
.publicKeyVerify(publicKey
)
6406 * Returns the ethereum address of a given public key.
6407 * Accepts "Ethereum public keys" and SEC1 encoded keys.
6408 * @param {Buffer} pubKey The two points of an uncompressed key, unless sanitize is enabled
6409 * @param {Boolean} [sanitize=false] Accept public keys in other formats
6412 exports
.pubToAddress
= exports
.publicToAddress = function (pubKey
, sanitize
) {
6413 pubKey
= exports
.toBuffer(pubKey
)
6414 if (sanitize
&& (pubKey
.length
!== 64)) {
6415 pubKey
= secp256k1
.publicKeyConvert(pubKey
, false).slice(1)
6417 assert(pubKey
.length
=== 64)
6418 // Only take the lower 160bits of the hash
6419 return exports
.sha3(pubKey
).slice(-20)
6423 * Returns the ethereum public key of a given private key
6424 * @param {Buffer} privateKey A private key must be 256 bits wide
6427 var privateToPublic
= exports
.privateToPublic = function (privateKey
) {
6428 privateKey
= exports
.toBuffer(privateKey
)
6429 // skip the type flag and use the X, Y points
6430 return secp256k1
.publicKeyCreate(privateKey
, false).slice(1)
6434 * Converts a public key to the Ethereum format.
6435 * @param {Buffer} publicKey
6438 exports
.importPublic = function (publicKey
) {
6439 publicKey
= exports
.toBuffer(publicKey
)
6440 if (publicKey
.length
!== 64) {
6441 publicKey
= secp256k1
.publicKeyConvert(publicKey
, false).slice(1)
6448 * @param {Buffer} msgHash
6449 * @param {Buffer} privateKey
6452 exports
.ecsign = function (msgHash
, privateKey
) {
6453 var sig
= secp256k1
.sign(msgHash
, privateKey
)
6456 ret
.r
= sig
.signature
.slice(0, 32)
6457 ret
.s
= sig
.signature
.slice(32, 64)
6458 ret
.v
= sig
.recovery
+ 27
6463 * Returns the keccak-256 hash of `message`, prefixed with the header used by the `eth_sign` RPC call.
6464 * The output of this function can be fed into `ecsign` to produce the same signature as the `eth_sign`
6465 * call for a given `message`, or fed to `ecrecover` along with a signature to recover the public key
6466 * used to produce the signature.
6468 * @returns {Buffer} hash
6470 exports
.hashPersonalMessage = function (message
) {
6471 var prefix
= exports
.toBuffer('\u0019Ethereum Signed Message:\n' + message
.length
.toString())
6472 return exports
.sha3(Buffer
.concat([prefix
, message
]))
6476 * ECDSA public key recovery from signature
6477 * @param {Buffer} msgHash
6481 * @return {Buffer} publicKey
6483 exports
.ecrecover = function (msgHash
, v
, r
, s
) {
6484 var signature
= Buffer
.concat([exports
.setLength(r
, 32), exports
.setLength(s
, 32)], 64)
6485 var recovery
= v
- 27
6486 if (recovery
!== 0 && recovery
!== 1) {
6487 throw new Error('Invalid signature v value')
6489 var senderPubKey
= secp256k1
.recover(msgHash
, signature
, recovery
)
6490 return secp256k1
.publicKeyConvert(senderPubKey
, false).slice(1)
6494 * Convert signature parameters into the format of `eth_sign` RPC method
6498 * @return {String} sig
6500 exports
.toRpcSig = function (v
, r
, s
) {
6501 // NOTE: with potential introduction of chainId this might need to be updated
6502 if (v
!== 27 && v
!== 28) {
6503 throw new Error('Invalid recovery id')
6506 // geth (and the RPC eth_sign method) uses the 65 byte format used by Bitcoin
6507 // FIXME: this might change in the future - https://github.com/ethereum/go-ethereum/issues/2053
6508 return exports
.bufferToHex(Buffer
.concat([
6509 exports
.setLengthLeft(r
, 32),
6510 exports
.setLengthLeft(s
, 32),
6511 exports
.toBuffer(v
- 27)
6516 * Convert signature format of the `eth_sign` RPC method to signature parameters
6517 * NOTE: all because of a bug in geth: https://github.com/ethereum/go-ethereum/issues/2053
6518 * @param {String} sig
6521 exports
.fromRpcSig = function (sig
) {
6522 sig
= exports
.toBuffer(sig
)
6524 // NOTE: with potential introduction of chainId this might need to be updated
6525 if (sig
.length
!== 65) {
6526 throw new Error('Invalid signature length')
6530 // support both versions of `eth_sign` responses
6537 r: sig
.slice(0, 32),
6538 s: sig
.slice(32, 64)
6543 * Returns the ethereum address of a given private key
6544 * @param {Buffer} privateKey A private key must be 256 bits wide
6547 exports
.privateToAddress = function (privateKey
) {
6548 return exports
.publicToAddress(privateToPublic(privateKey
))
6552 * Checks if the address is a valid. Accepts checksummed addresses too
6553 * @param {String} address
6556 exports
.isValidAddress = function (address
) {
6557 return /^0x[0-9a-fA-F]{40}$/i.test(address
)
6561 * Returns a checksummed address
6562 * @param {String} address
6565 exports
.toChecksumAddress = function (address
) {
6566 address
= exports
.stripHexPrefix(address
).toLowerCase()
6567 var hash
= exports
.sha3(address
).toString('hex')
6570 for (var i
= 0; i
< address
.length
; i
++) {
6571 if (parseInt(hash
[i
], 16) >= 8) {
6572 ret
+= address
[i
].toUpperCase()
6582 * Checks if the address is a valid checksummed address
6583 * @param {Buffer} address
6586 exports
.isValidChecksumAddress = function (address
) {
6587 return exports
.isValidAddress(address
) && (exports
.toChecksumAddress(address
) === address
)
6591 * Generates an address of a newly created contract
6592 * @param {Buffer} from the address which is creating this new address
6593 * @param {Buffer} nonce the nonce of the from account
6596 exports
.generateAddress = function (from, nonce
) {
6597 from = exports
.toBuffer(from)
6598 nonce
= new BN(nonce
)
6600 if (nonce
.isZero()) {
6601 // in RLP we want to encode null in the case of zero nonce
6602 // read the RLP documentation for an answer if you dare
6605 nonce
= Buffer
.from(nonce
.toArray())
6608 // Only take the lower 160bits of the hash
6609 return exports
.rlphash([from, nonce
]).slice(-20)
6613 * Returns true if the supplied address belongs to a precompiled account
6614 * @param {Buffer|String} address
6617 exports
.isPrecompiled = function (address
) {
6618 var a
= exports
.unpad(address
)
6619 return a
.length
=== 1 && a
[0] > 0 && a
[0] < 5
6623 * Adds "0x" to a given `String` if it does not already start with "0x"
6624 * @param {String} str
6627 exports
.addHexPrefix = function (str
) {
6628 if (typeof str
!== 'string') {
6632 return exports
.isHexPrefixed(str
) ? str : '0x' + str
6636 * Validate ECDSA signature
6637 * @method isValidSignature
6641 * @param {Boolean} [homestead=true]
6645 exports
.isValidSignature = function (v
, r
, s
, homestead
) {
6646 const SECP256K1_N_DIV_2
= new BN('7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0', 16)
6647 const SECP256K1_N
= new BN('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 16)
6649 if (r
.length
!== 32 || s
.length
!== 32) {
6653 if (v
!== 27 && v
!== 28) {
6660 if (r
.isZero() || r
.gt(SECP256K1_N
) || s
.isZero() || s
.gt(SECP256K1_N
)) {
6664 if ((homestead
=== false) && (new BN(s
).cmp(SECP256K1_N_DIV_2
) === 1)) {
6672 * Converts a `Buffer` or `Array` to JSON
6673 * @param {Buffer|Array} ba
6674 * @return {Array|String|null}
6676 exports
.baToJSON = function (ba
) {
6677 if (Buffer
.isBuffer(ba
)) {
6678 return '0x' + ba
.toString('hex')
6679 } else if (ba
instanceof Array
) {
6681 for (var i
= 0; i
< ba
.length
; i
++) {
6682 array
.push(exports
.baToJSON(ba
[i
]))
6689 * Defines properties on a `Object`. It make the assumption that underlying data is binary.
6690 * @param {Object} self the `Object` to define properties on
6691 * @param {Array} fields an array fields to define. Fields can contain:
6692 * * `name` - the name of the properties
6693 * * `length` - the number of bytes the field can have
6694 * * `allowLess` - if the field can be less than the length
6696 * @param {*} data data to be validated against the definitions
6698 exports
.defineProperties = function (self
, fields
, data
) {
6702 // attach the `toJSON`
6703 self
.toJSON = function (label
) {
6706 self
._fields
.forEach(function (field
) {
6707 obj
[field
] = '0x' + self
[field
].toString('hex')
6711 return exports
.baToJSON(this.raw
)
6714 self
.serialize
= function serialize () {
6715 return rlp
.encode(self
.raw
)
6718 fields
.forEach(function (field
, i
) {
6719 self
._fields
.push(field
.name
)
6720 function getter () {
6723 function setter (v
) {
6724 v
= exports
.toBuffer(v
)
6726 if (v
.toString('hex') === '00' && !field
.allowZero
) {
6727 v
= Buffer
.allocUnsafe(0)
6730 if (field
.allowLess
&& field
.length
) {
6731 v
= exports
.stripZeros(v
)
6732 assert(field
.length
>= v
.length
, 'The field ' + field
.name
+ ' must not have more ' + field
.length
+ ' bytes')
6733 } else if (!(field
.allowZero
&& v
.length
=== 0) && field
.length
) {
6734 assert(field
.length
=== v
.length
, 'The field ' + field
.name
+ ' must have byte length of ' + field
.length
)
6740 Object
.defineProperty(self
, field
.name
, {
6747 if (field
.default) {
6748 self
[field
.name
] = field
.default
6753 Object
.defineProperty(self
, field
.alias
, {
6762 // if the constuctor is passed data
6764 if (typeof data
=== 'string') {
6765 data
= Buffer
.from(exports
.stripHexPrefix(data
), 'hex')
6768 if (Buffer
.isBuffer(data
)) {
6769 data
= rlp
.decode(data
)
6772 if (Array
.isArray(data
)) {
6773 if (data
.length
> self
._fields
.length
) {
6774 throw (new Error('wrong number of fields in data'))
6777 // make sure all the items are buffers
6778 data
.forEach(function (d
, i
) {
6779 self
[self
._fields
[i
]] = exports
.toBuffer(d
)
6781 } else if (typeof data
=== 'object') {
6782 const keys
= Object
.keys(data
)
6783 fields
.forEach(function (field
) {
6784 if (keys
.indexOf(field
.name
) !== -1) self
[field
.name
] = data
[field
.name
]
6785 if (keys
.indexOf(field
.alias
) !== -1) self
[field
.alias
] = data
[field
.alias
]
6788 throw new Error('invalid data')
6793 }).call(this,require("buffer").Buffer
)
6794 },{"assert":1,"bn.js":33,"buffer":5,"create-hash":36,"ethjs-util":56,"keccak":65,"rlp":72,"secp256k1":73}],32:[function(require
,module
,exports
){
6796 // Reference https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
6797 // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
6798 // NOTE: SIGHASH byte ignored AND restricted, truncate before use
6800 function check (buffer
) {
6801 if (buffer
.length
< 8) return false
6802 if (buffer
.length
> 72) return false
6803 if (buffer
[0] !== 0x30) return false
6804 if (buffer
[1] !== buffer
.length
- 2) return false
6805 if (buffer
[2] !== 0x02) return false
6807 var lenR
= buffer
[3]
6808 if (lenR
=== 0) return false
6809 if (5 + lenR
>= buffer
.length
) return false
6810 if (buffer
[4 + lenR
] !== 0x02) return false
6812 var lenS
= buffer
[5 + lenR
]
6813 if (lenS
=== 0) return false
6814 if ((6 + lenR
+ lenS
) !== buffer
.length
) return false
6816 if (buffer
[4] & 0x80) return false
6817 if (lenR
> 1 && (buffer
[4] === 0x00) && !(buffer
[5] & 0x80)) return false
6819 if (buffer
[lenR
+ 6] & 0x80) return false
6820 if (lenS
> 1 && (buffer
[lenR
+ 6] === 0x00) && !(buffer
[lenR
+ 7] & 0x80)) return false
6824 function decode (buffer
) {
6825 if (buffer
.length
< 8) throw new Error('DER sequence length is too short')
6826 if (buffer
.length
> 72) throw new Error('DER sequence length is too long')
6827 if (buffer
[0] !== 0x30) throw new Error('Expected DER sequence')
6828 if (buffer
[1] !== buffer
.length
- 2) throw new Error('DER sequence length is invalid')
6829 if (buffer
[2] !== 0x02) throw new Error('Expected DER integer')
6831 var lenR
= buffer
[3]
6832 if (lenR
=== 0) throw new Error('R length is zero')
6833 if (5 + lenR
>= buffer
.length
) throw new Error('R length is too long')
6834 if (buffer
[4 + lenR
] !== 0x02) throw new Error('Expected DER integer (2)')
6836 var lenS
= buffer
[5 + lenR
]
6837 if (lenS
=== 0) throw new Error('S length is zero')
6838 if ((6 + lenR
+ lenS
) !== buffer
.length
) throw new Error('S length is invalid')
6840 if (buffer
[4] & 0x80) throw new Error('R value is negative')
6841 if (lenR
> 1 && (buffer
[4] === 0x00) && !(buffer
[5] & 0x80)) throw new Error('R value excessively padded')
6843 if (buffer
[lenR
+ 6] & 0x80) throw new Error('S value is negative')
6844 if (lenS
> 1 && (buffer
[lenR
+ 6] === 0x00) && !(buffer
[lenR
+ 7] & 0x80)) throw new Error('S value excessively padded')
6846 // non-BIP66 - extract R, S values
6848 r: buffer
.slice(4, 4 + lenR
),
6849 s: buffer
.slice(6 + lenR
)
6854 * Expects r and s to be positive DER integers.
6856 * The DER format uses the most significant bit as a sign bit (& 0x80).
6857 * If the significant bit is set AND the integer is positive, a 0x00 is prepended.
6873 * -62300 => 0xff0ca4
6875 function encode (r
, s
) {
6878 if (lenR
=== 0) throw new Error('R length is zero')
6879 if (lenS
=== 0) throw new Error('S length is zero')
6880 if (lenR
> 33) throw new Error('R length is too long')
6881 if (lenS
> 33) throw new Error('S length is too long')
6882 if (r
[0] & 0x80) throw new Error('R value is negative')
6883 if (s
[0] & 0x80) throw new Error('S value is negative')
6884 if (lenR
> 1 && (r
[0] === 0x00) && !(r
[1] & 0x80)) throw new Error('R value excessively padded')
6885 if (lenS
> 1 && (s
[0] === 0x00) && !(s
[1] & 0x80)) throw new Error('S value excessively padded')
6887 var signature
= new Buffer(6 + lenR
+ lenS
)
6889 // 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
6891 signature
[1] = signature
.length
- 2
6893 signature
[3] = r
.length
6894 r
.copy(signature
, 4)
6895 signature
[4 + lenR
] = 0x02
6896 signature
[5 + lenR
] = s
.length
6897 s
.copy(signature
, 6 + lenR
)
6908 }).call(this,require("buffer").Buffer
)
6909 },{"buffer":5}],33:[function(require
,module
,exports
){
6910 (function (module
, exports
) {
6914 function assert (val
, msg
) {
6915 if (!val
) throw new Error(msg
|| 'Assertion failed');
6918 // Could use `inherits` module, but don't want to move from single file
6919 // architecture yet.
6920 function inherits (ctor
, superCtor
) {
6921 ctor
.super_
= superCtor
;
6922 var TempCtor = function () {};
6923 TempCtor
.prototype = superCtor
.prototype;
6924 ctor
.prototype = new TempCtor();
6925 ctor
.prototype.constructor = ctor
;
6930 function BN (number
, base
, endian
) {
6931 if (BN
.isBN(number
)) {
6939 // Reduction context
6942 if (number
!== null) {
6943 if (base
=== 'le' || base
=== 'be') {
6948 this._init(number
|| 0, base
|| 10, endian
|| 'be');
6951 if (typeof module
=== 'object') {
6952 module
.exports
= BN
;
6962 Buffer
= require('buf' + 'fer').Buffer
;
6966 BN
.isBN
= function isBN (num
) {
6967 if (num
instanceof BN
) {
6971 return num
!== null && typeof num
=== 'object' &&
6972 num
.constructor.wordSize
=== BN
.wordSize
&& Array
.isArray(num
.words
);
6975 BN
.max
= function max (left
, right
) {
6976 if (left
.cmp(right
) > 0) return left
;
6980 BN
.min
= function min (left
, right
) {
6981 if (left
.cmp(right
) < 0) return left
;
6985 BN
.prototype._init
= function init (number
, base
, endian
) {
6986 if (typeof number
=== 'number') {
6987 return this._initNumber(number
, base
, endian
);
6990 if (typeof number
=== 'object') {
6991 return this._initArray(number
, base
, endian
);
6994 if (base
=== 'hex') {
6997 assert(base
=== (base
| 0) && base
>= 2 && base
<= 36);
6999 number
= number
.toString().replace(/\s+/g, '');
7001 if (number
[0] === '-') {
7006 this._parseHex(number
, start
);
7008 this._parseBase(number
, base
, start
);
7011 if (number
[0] === '-') {
7017 if (endian
!== 'le') return;
7019 this._initArray(this.toArray(), base
, endian
);
7022 BN
.prototype._initNumber
= function _initNumber (number
, base
, endian
) {
7027 if (number
< 0x4000000) {
7028 this.words
= [ number
& 0x3ffffff ];
7030 } else if (number
< 0x10000000000000) {
7033 (number
/ 0x4000000) & 0x3ffffff
7037 assert(number
< 0x20000000000000); // 2 ^ 53 (unsafe)
7040 (number
/ 0x4000000) & 0x3ffffff,
7046 if (endian
!== 'le') return;
7048 // Reverse the bytes
7049 this._initArray(this.toArray(), base
, endian
);
7052 BN
.prototype._initArray
= function _initArray (number
, base
, endian
) {
7053 // Perhaps a Uint8Array
7054 assert(typeof number
.length
=== 'number');
7055 if (number
.length
<= 0) {
7061 this.length
= Math
.ceil(number
.length
/ 3);
7062 this.words
= new Array(this.length
);
7063 for (var i
= 0; i
< this.length
; i
++) {
7069 if (endian
=== 'be') {
7070 for (i
= number
.length
- 1, j
= 0; i
>= 0; i
-= 3) {
7071 w
= number
[i
] | (number
[i
- 1] << 8) | (number
[i
- 2] << 16);
7072 this.words
[j
] |= (w
<< off
) & 0x3ffffff;
7073 this.words
[j
+ 1] = (w
>>> (26 - off
)) & 0x3ffffff;
7080 } else if (endian
=== 'le') {
7081 for (i
= 0, j
= 0; i
< number
.length
; i
+= 3) {
7082 w
= number
[i
] | (number
[i
+ 1] << 8) | (number
[i
+ 2] << 16);
7083 this.words
[j
] |= (w
<< off
) & 0x3ffffff;
7084 this.words
[j
+ 1] = (w
>>> (26 - off
)) & 0x3ffffff;
7092 return this.strip();
7095 function parseHex (str
, start
, end
) {
7097 var len
= Math
.min(str
.length
, end
);
7098 for (var i
= start
; i
< len
; i
++) {
7099 var c
= str
.charCodeAt(i
) - 48;
7104 if (c
>= 49 && c
<= 54) {
7108 } else if (c
>= 17 && c
<= 22) {
7119 BN
.prototype._parseHex
= function _parseHex (number
, start
) {
7120 // Create possibly bigger array to ensure that it fits the number
7121 this.length
= Math
.ceil((number
.length
- start
) / 6);
7122 this.words
= new Array(this.length
);
7123 for (var i
= 0; i
< this.length
; i
++) {
7128 // Scan 24-bit chunks and add them to the number
7130 for (i
= number
.length
- 6, j
= 0; i
>= start
; i
-= 6) {
7131 w
= parseHex(number
, i
, i
+ 6);
7132 this.words
[j
] |= (w
<< off
) & 0x3ffffff;
7133 // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
7134 this.words
[j
+ 1] |= w
>>> (26 - off
) & 0x3fffff;
7141 if (i
+ 6 !== start
) {
7142 w
= parseHex(number
, start
, i
+ 6);
7143 this.words
[j
] |= (w
<< off
) & 0x3ffffff;
7144 this.words
[j
+ 1] |= w
>>> (26 - off
) & 0x3fffff;
7149 function parseBase (str
, start
, end
, mul
) {
7151 var len
= Math
.min(str
.length
, end
);
7152 for (var i
= start
; i
< len
; i
++) {
7153 var c
= str
.charCodeAt(i
) - 48;
7162 } else if (c
>= 17) {
7173 BN
.prototype._parseBase
= function _parseBase (number
, base
, start
) {
7174 // Initialize as zero
7178 // Find length of limb in base
7179 for (var limbLen
= 0, limbPow
= 1; limbPow
<= 0x3ffffff; limbPow
*= base
) {
7183 limbPow
= (limbPow
/ base
) | 0;
7185 var total
= number
.length
- start
;
7186 var mod
= total
% limbLen
;
7187 var end
= Math
.min(total
, total
- mod
) + start
;
7190 for (var i
= start
; i
< end
; i
+= limbLen
) {
7191 word
= parseBase(number
, i
, i
+ limbLen
, base
);
7193 this.imuln(limbPow
);
7194 if (this.words
[0] + word
< 0x4000000) {
7195 this.words
[0] += word
;
7203 word
= parseBase(number
, i
, number
.length
, base
);
7205 for (i
= 0; i
< mod
; i
++) {
7210 if (this.words
[0] + word
< 0x4000000) {
7211 this.words
[0] += word
;
7218 BN
.prototype.copy
= function copy (dest
) {
7219 dest
.words
= new Array(this.length
);
7220 for (var i
= 0; i
< this.length
; i
++) {
7221 dest
.words
[i
] = this.words
[i
];
7223 dest
.length
= this.length
;
7224 dest
.negative
= this.negative
;
7225 dest
.red
= this.red
;
7228 BN
.prototype.clone
= function clone () {
7229 var r
= new BN(null);
7234 BN
.prototype._expand
= function _expand (size
) {
7235 while (this.length
< size
) {
7236 this.words
[this.length
++] = 0;
7241 // Remove leading `0` from `this`
7242 BN
.prototype.strip
= function strip () {
7243 while (this.length
> 1 && this.words
[this.length
- 1] === 0) {
7246 return this._normSign();
7249 BN
.prototype._normSign
= function _normSign () {
7251 if (this.length
=== 1 && this.words
[0] === 0) {
7257 BN
.prototype.inspect
= function inspect () {
7258 return (this.red
? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
7264 var groupSizes = [];
7265 var groupBases = [];
7269 while (++i < BN.wordSize) {
7278 while (++base < 36 + 1) {
7281 while (groupBase < (1 << BN.wordSize) / base) {
7285 groupSizes[base] = groupSize;
7286 groupBases[base] = groupBase;
7309 '00000000000000000',
7310 '000000000000000000',
7311 '0000000000000000000',
7312 '00000000000000000000',
7313 '000000000000000000000',
7314 '0000000000000000000000',
7315 '00000000000000000000000',
7316 '000000000000000000000000',
7317 '0000000000000000000000000'
7322 25, 16, 12, 11, 10, 9, 8,
7323 8, 7, 7, 7, 7, 6, 6,
7324 6, 6, 6, 6, 6, 5, 5,
7325 5, 5, 5, 5, 5, 5, 5,
7331 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
7332 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
7333 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
7334 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
7335 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
7338 BN
.prototype.toString
= function toString (base
, padding
) {
7340 padding
= padding
| 0 || 1;
7343 if (base
=== 16 || base
=== 'hex') {
7347 for (var i
= 0; i
< this.length
; i
++) {
7348 var w
= this.words
[i
];
7349 var word
= (((w
<< off
) | carry
) & 0xffffff).toString(16);
7350 carry
= (w
>>> (24 - off
)) & 0xffffff;
7351 if (carry
!== 0 || i
!== this.length
- 1) {
7352 out
= zeros
[6 - word
.length
] + word
+ out
;
7363 out
= carry
.toString(16) + out
;
7365 while (out
.length
% padding
!== 0) {
7368 if (this.negative
!== 0) {
7374 if (base
=== (base
| 0) && base
>= 2 && base
<= 36) {
7375 // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
7376 var groupSize
= groupSizes
[base
];
7377 // var groupBase = Math.pow(base, groupSize);
7378 var groupBase
= groupBases
[base
];
7380 var c
= this.clone();
7382 while (!c
.isZero()) {
7383 var r
= c
.modn(groupBase
).toString(base
);
7384 c
= c
.idivn(groupBase
);
7387 out
= zeros
[groupSize
- r
.length
] + r
+ out
;
7392 if (this.isZero()) {
7395 while (out
.length
% padding
!== 0) {
7398 if (this.negative
!== 0) {
7404 assert(false, 'Base should be between 2 and 36');
7407 BN
.prototype.toNumber
= function toNumber () {
7408 var ret
= this.words
[0];
7409 if (this.length
=== 2) {
7410 ret
+= this.words
[1] * 0x4000000;
7411 } else if (this.length
=== 3 && this.words
[2] === 0x01) {
7412 // NOTE: at this stage it is known that the top bit is set
7413 ret
+= 0x10000000000000 + (this.words
[1] * 0x4000000);
7414 } else if (this.length
> 2) {
7415 assert(false, 'Number can only safely store up to 53 bits');
7417 return (this.negative
!== 0) ? -ret : ret
;
7420 BN
.prototype.toJSON
= function toJSON () {
7421 return this.toString(16);
7424 BN
.prototype.toBuffer
= function toBuffer (endian
, length
) {
7425 assert(typeof Buffer
!== 'undefined');
7426 return this.toArrayLike(Buffer
, endian
, length
);
7429 BN
.prototype.toArray
= function toArray (endian
, length
) {
7430 return this.toArrayLike(Array
, endian
, length
);
7433 BN
.prototype.toArrayLike
= function toArrayLike (ArrayType
, endian
, length
) {
7434 var byteLength
= this.byteLength();
7435 var reqLength
= length
|| Math
.max(1, byteLength
);
7436 assert(byteLength
<= reqLength
, 'byte array longer than desired length');
7437 assert(reqLength
> 0, 'Requested array length <= 0');
7440 var littleEndian
= endian
=== 'le';
7441 var res
= new ArrayType(reqLength
);
7444 var q
= this.clone();
7445 if (!littleEndian
) {
7446 // Assume big-endian
7447 for (i
= 0; i
< reqLength
- byteLength
; i
++) {
7451 for (i
= 0; !q
.isZero(); i
++) {
7455 res
[reqLength
- i
- 1] = b
;
7458 for (i
= 0; !q
.isZero(); i
++) {
7465 for (; i
< reqLength
; i
++) {
7474 BN
.prototype._countBits
= function _countBits (w
) {
7475 return 32 - Math
.clz32(w
);
7478 BN
.prototype._countBits
= function _countBits (w
) {
7501 BN
.prototype._zeroBits
= function _zeroBits (w
) {
7503 if (w
=== 0) return 26;
7507 if ((t
& 0x1fff) === 0) {
7511 if ((t
& 0x7f) === 0) {
7515 if ((t
& 0xf) === 0) {
7519 if ((t
& 0x3) === 0) {
7523 if ((t
& 0x1) === 0) {
7529 // Return number of used bits in a BN
7530 BN
.prototype.bitLength
= function bitLength () {
7531 var w
= this.words
[this.length
- 1];
7532 var hi
= this._countBits(w
);
7533 return (this.length
- 1) * 26 + hi
;
7536 function toBitArray (num
) {
7537 var w
= new Array(num
.bitLength());
7539 for (var bit
= 0; bit
< w
.length
; bit
++) {
7540 var off
= (bit
/ 26) | 0;
7541 var wbit
= bit
% 26;
7543 w
[bit
] = (num
.words
[off
] & (1 << wbit
)) >>> wbit
;
7549 // Number of trailing zero bits
7550 BN
.prototype.zeroBits
= function zeroBits () {
7551 if (this.isZero()) return 0;
7554 for (var i
= 0; i
< this.length
; i
++) {
7555 var b
= this._zeroBits(this.words
[i
]);
7557 if (b
!== 26) break;
7562 BN
.prototype.byteLength
= function byteLength () {
7563 return Math
.ceil(this.bitLength() / 8);
7566 BN
.prototype.toTwos
= function toTwos (width
) {
7567 if (this.negative
!== 0) {
7568 return this.abs().inotn(width
).iaddn(1);
7570 return this.clone();
7573 BN
.prototype.fromTwos
= function fromTwos (width
) {
7574 if (this.testn(width
- 1)) {
7575 return this.notn(width
).iaddn(1).ineg();
7577 return this.clone();
7580 BN
.prototype.isNeg
= function isNeg () {
7581 return this.negative
!== 0;
7584 // Return negative clone of `this`
7585 BN
.prototype.neg
= function neg () {
7586 return this.clone().ineg();
7589 BN
.prototype.ineg
= function ineg () {
7590 if (!this.isZero()) {
7597 // Or `num` with `this` in-place
7598 BN
.prototype.iuor
= function iuor (num
) {
7599 while (this.length
< num
.length
) {
7600 this.words
[this.length
++] = 0;
7603 for (var i
= 0; i
< num
.length
; i
++) {
7604 this.words
[i
] = this.words
[i
] | num
.words
[i
];
7607 return this.strip();
7610 BN
.prototype.ior
= function ior (num
) {
7611 assert((this.negative
| num
.negative
) === 0);
7612 return this.iuor(num
);
7615 // Or `num` with `this`
7616 BN
.prototype.or
= function or (num
) {
7617 if (this.length
> num
.length
) return this.clone().ior(num
);
7618 return num
.clone().ior(this);
7621 BN
.prototype.uor
= function uor (num
) {
7622 if (this.length
> num
.length
) return this.clone().iuor(num
);
7623 return num
.clone().iuor(this);
7626 // And `num` with `this` in-place
7627 BN
.prototype.iuand
= function iuand (num
) {
7628 // b = min-length(num, this)
7630 if (this.length
> num
.length
) {
7636 for (var i
= 0; i
< b
.length
; i
++) {
7637 this.words
[i
] = this.words
[i
] & num
.words
[i
];
7640 this.length
= b
.length
;
7642 return this.strip();
7645 BN
.prototype.iand
= function iand (num
) {
7646 assert((this.negative
| num
.negative
) === 0);
7647 return this.iuand(num
);
7650 // And `num` with `this`
7651 BN
.prototype.and
= function and (num
) {
7652 if (this.length
> num
.length
) return this.clone().iand(num
);
7653 return num
.clone().iand(this);
7656 BN
.prototype.uand
= function uand (num
) {
7657 if (this.length
> num
.length
) return this.clone().iuand(num
);
7658 return num
.clone().iuand(this);
7661 // Xor `num` with `this` in-place
7662 BN
.prototype.iuxor
= function iuxor (num
) {
7663 // a.length > b.length
7666 if (this.length
> num
.length
) {
7674 for (var i
= 0; i
< b
.length
; i
++) {
7675 this.words
[i
] = a
.words
[i
] ^ b
.words
[i
];
7679 for (; i
< a
.length
; i
++) {
7680 this.words
[i
] = a
.words
[i
];
7684 this.length
= a
.length
;
7686 return this.strip();
7689 BN
.prototype.ixor
= function ixor (num
) {
7690 assert((this.negative
| num
.negative
) === 0);
7691 return this.iuxor(num
);
7694 // Xor `num` with `this`
7695 BN
.prototype.xor
= function xor (num
) {
7696 if (this.length
> num
.length
) return this.clone().ixor(num
);
7697 return num
.clone().ixor(this);
7700 BN
.prototype.uxor
= function uxor (num
) {
7701 if (this.length
> num
.length
) return this.clone().iuxor(num
);
7702 return num
.clone().iuxor(this);
7705 // Not ``this`` with ``width`` bitwidth
7706 BN
.prototype.inotn
= function inotn (width
) {
7707 assert(typeof width
=== 'number' && width
>= 0);
7709 var bytesNeeded
= Math
.ceil(width
/ 26) | 0;
7710 var bitsLeft
= width
% 26;
7712 // Extend the buffer with leading zeroes
7713 this._expand(bytesNeeded
);
7719 // Handle complete words
7720 for (var i
= 0; i
< bytesNeeded
; i
++) {
7721 this.words
[i
] = ~this.words
[i
] & 0x3ffffff;
7724 // Handle the residue
7726 this.words
[i
] = ~this.words
[i
] & (0x3ffffff >> (26 - bitsLeft
));
7729 // And remove leading zeroes
7730 return this.strip();
7733 BN
.prototype.notn
= function notn (width
) {
7734 return this.clone().inotn(width
);
7737 // Set `bit` of `this`
7738 BN
.prototype.setn
= function setn (bit
, val
) {
7739 assert(typeof bit
=== 'number' && bit
>= 0);
7741 var off
= (bit
/ 26) | 0;
7742 var wbit
= bit
% 26;
7744 this._expand(off
+ 1);
7747 this.words
[off
] = this.words
[off
] | (1 << wbit
);
7749 this.words
[off
] = this.words
[off
] & ~(1 << wbit
);
7752 return this.strip();
7755 // Add `num` to `this` in-place
7756 BN
.prototype.iadd
= function iadd (num
) {
7759 // negative + positive
7760 if (this.negative
!== 0 && num
.negative
=== 0) {
7764 return this._normSign();
7766 // positive + negative
7767 } else if (this.negative
=== 0 && num
.negative
!== 0) {
7771 return r
._normSign();
7774 // a.length > b.length
7776 if (this.length
> num
.length
) {
7785 for (var i
= 0; i
< b
.length
; i
++) {
7786 r
= (a
.words
[i
] | 0) + (b
.words
[i
] | 0) + carry
;
7787 this.words
[i
] = r
& 0x3ffffff;
7790 for (; carry
!== 0 && i
< a
.length
; i
++) {
7791 r
= (a
.words
[i
] | 0) + carry
;
7792 this.words
[i
] = r
& 0x3ffffff;
7796 this.length
= a
.length
;
7798 this.words
[this.length
] = carry
;
7800 // Copy the rest of the words
7801 } else if (a
!== this) {
7802 for (; i
< a
.length
; i
++) {
7803 this.words
[i
] = a
.words
[i
];
7810 // Add `num` to `this`
7811 BN
.prototype.add
= function add (num
) {
7813 if (num
.negative
!== 0 && this.negative
=== 0) {
7815 res
= this.sub(num
);
7818 } else if (num
.negative
=== 0 && this.negative
!== 0) {
7820 res
= num
.sub(this);
7825 if (this.length
> num
.length
) return this.clone().iadd(num
);
7827 return num
.clone().iadd(this);
7830 // Subtract `num` from `this` in-place
7831 BN
.prototype.isub
= function isub (num
) {
7832 // this - (-num) = this + num
7833 if (num
.negative
!== 0) {
7835 var r
= this.iadd(num
);
7837 return r
._normSign();
7839 // -this - num = -(this + num)
7840 } else if (this.negative
!== 0) {
7844 return this._normSign();
7847 // At this point both numbers are positive
7848 var cmp
= this.cmp(num
);
7850 // Optimization - zeroify
7869 for (var i
= 0; i
< b
.length
; i
++) {
7870 r
= (a
.words
[i
] | 0) - (b
.words
[i
] | 0) + carry
;
7872 this.words
[i
] = r
& 0x3ffffff;
7874 for (; carry
!== 0 && i
< a
.length
; i
++) {
7875 r
= (a
.words
[i
] | 0) + carry
;
7877 this.words
[i
] = r
& 0x3ffffff;
7880 // Copy rest of the words
7881 if (carry
=== 0 && i
< a
.length
&& a
!== this) {
7882 for (; i
< a
.length
; i
++) {
7883 this.words
[i
] = a
.words
[i
];
7887 this.length
= Math
.max(this.length
, i
);
7893 return this.strip();
7896 // Subtract `num` from `this`
7897 BN
.prototype.sub
= function sub (num
) {
7898 return this.clone().isub(num
);
7901 function smallMulTo (self
, num
, out
) {
7902 out
.negative
= num
.negative
^ self
.negative
;
7903 var len
= (self
.length
+ num
.length
) | 0;
7905 len
= (len
- 1) | 0;
7907 // Peel one iteration (compiler can't do it, because of code complexity)
7908 var a
= self
.words
[0] | 0;
7909 var b
= num
.words
[0] | 0;
7912 var lo
= r
& 0x3ffffff;
7913 var carry
= (r
/ 0x4000000) | 0;
7916 for (var k
= 1; k
< len
; k
++) {
7917 // Sum all words with the same `i + j = k` and accumulate `ncarry`,
7918 // note that ncarry could be >= 0x3ffffff
7919 var ncarry
= carry
>>> 26;
7920 var rword
= carry
& 0x3ffffff;
7921 var maxJ
= Math
.min(k
, num
.length
- 1);
7922 for (var j
= Math
.max(0, k
- self
.length
+ 1); j
<= maxJ
; j
++) {
7923 var i
= (k
- j
) | 0;
7924 a
= self
.words
[i
] | 0;
7925 b
= num
.words
[j
] | 0;
7927 ncarry
+= (r
/ 0x4000000) | 0;
7928 rword
= r
& 0x3ffffff;
7930 out
.words
[k
] = rword
| 0;
7934 out
.words
[k
] = carry
| 0;
7942 // TODO(indutny): it may be reasonable to omit it for users who don't need
7943 // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
7944 // multiplication (like elliptic secp256k1).
7945 var comb10MulTo
= function comb10MulTo (self
, num
, out
) {
7954 var al0
= a0
& 0x1fff;
7955 var ah0
= a0
>>> 13;
7957 var al1
= a1
& 0x1fff;
7958 var ah1
= a1
>>> 13;
7960 var al2
= a2
& 0x1fff;
7961 var ah2
= a2
>>> 13;
7963 var al3
= a3
& 0x1fff;
7964 var ah3
= a3
>>> 13;
7966 var al4
= a4
& 0x1fff;
7967 var ah4
= a4
>>> 13;
7969 var al5
= a5
& 0x1fff;
7970 var ah5
= a5
>>> 13;
7972 var al6
= a6
& 0x1fff;
7973 var ah6
= a6
>>> 13;
7975 var al7
= a7
& 0x1fff;
7976 var ah7
= a7
>>> 13;
7978 var al8
= a8
& 0x1fff;
7979 var ah8
= a8
>>> 13;
7981 var al9
= a9
& 0x1fff;
7982 var ah9
= a9
>>> 13;
7984 var bl0
= b0
& 0x1fff;
7985 var bh0
= b0
>>> 13;
7987 var bl1
= b1
& 0x1fff;
7988 var bh1
= b1
>>> 13;
7990 var bl2
= b2
& 0x1fff;
7991 var bh2
= b2
>>> 13;
7993 var bl3
= b3
& 0x1fff;
7994 var bh3
= b3
>>> 13;
7996 var bl4
= b4
& 0x1fff;
7997 var bh4
= b4
>>> 13;
7999 var bl5
= b5
& 0x1fff;
8000 var bh5
= b5
>>> 13;
8002 var bl6
= b6
& 0x1fff;
8003 var bh6
= b6
>>> 13;
8005 var bl7
= b7
& 0x1fff;
8006 var bh7
= b7
>>> 13;
8008 var bl8
= b8
& 0x1fff;
8009 var bh8
= b8
>>> 13;
8011 var bl9
= b9
& 0x1fff;
8012 var bh9
= b9
>>> 13;
8014 out
.negative
= self
.negative
^ num
.negative
;
8017 lo
= Math
.imul(al0
, bl0
);
8018 mid
= Math
.imul(al0
, bh0
);
8019 mid
= (mid
+ Math
.imul(ah0
, bl0
)) | 0;
8020 hi
= Math
.imul(ah0
, bh0
);
8021 var w0
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8022 c
= (((hi
+ (mid
>>> 13)) | 0) + (w0
>>> 26)) | 0;
8025 lo
= Math
.imul(al1
, bl0
);
8026 mid
= Math
.imul(al1
, bh0
);
8027 mid
= (mid
+ Math
.imul(ah1
, bl0
)) | 0;
8028 hi
= Math
.imul(ah1
, bh0
);
8029 lo
= (lo
+ Math
.imul(al0
, bl1
)) | 0;
8030 mid
= (mid
+ Math
.imul(al0
, bh1
)) | 0;
8031 mid
= (mid
+ Math
.imul(ah0
, bl1
)) | 0;
8032 hi
= (hi
+ Math
.imul(ah0
, bh1
)) | 0;
8033 var w1
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8034 c
= (((hi
+ (mid
>>> 13)) | 0) + (w1
>>> 26)) | 0;
8037 lo
= Math
.imul(al2
, bl0
);
8038 mid
= Math
.imul(al2
, bh0
);
8039 mid
= (mid
+ Math
.imul(ah2
, bl0
)) | 0;
8040 hi
= Math
.imul(ah2
, bh0
);
8041 lo
= (lo
+ Math
.imul(al1
, bl1
)) | 0;
8042 mid
= (mid
+ Math
.imul(al1
, bh1
)) | 0;
8043 mid
= (mid
+ Math
.imul(ah1
, bl1
)) | 0;
8044 hi
= (hi
+ Math
.imul(ah1
, bh1
)) | 0;
8045 lo
= (lo
+ Math
.imul(al0
, bl2
)) | 0;
8046 mid
= (mid
+ Math
.imul(al0
, bh2
)) | 0;
8047 mid
= (mid
+ Math
.imul(ah0
, bl2
)) | 0;
8048 hi
= (hi
+ Math
.imul(ah0
, bh2
)) | 0;
8049 var w2
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8050 c
= (((hi
+ (mid
>>> 13)) | 0) + (w2
>>> 26)) | 0;
8053 lo
= Math
.imul(al3
, bl0
);
8054 mid
= Math
.imul(al3
, bh0
);
8055 mid
= (mid
+ Math
.imul(ah3
, bl0
)) | 0;
8056 hi
= Math
.imul(ah3
, bh0
);
8057 lo
= (lo
+ Math
.imul(al2
, bl1
)) | 0;
8058 mid
= (mid
+ Math
.imul(al2
, bh1
)) | 0;
8059 mid
= (mid
+ Math
.imul(ah2
, bl1
)) | 0;
8060 hi
= (hi
+ Math
.imul(ah2
, bh1
)) | 0;
8061 lo
= (lo
+ Math
.imul(al1
, bl2
)) | 0;
8062 mid
= (mid
+ Math
.imul(al1
, bh2
)) | 0;
8063 mid
= (mid
+ Math
.imul(ah1
, bl2
)) | 0;
8064 hi
= (hi
+ Math
.imul(ah1
, bh2
)) | 0;
8065 lo
= (lo
+ Math
.imul(al0
, bl3
)) | 0;
8066 mid
= (mid
+ Math
.imul(al0
, bh3
)) | 0;
8067 mid
= (mid
+ Math
.imul(ah0
, bl3
)) | 0;
8068 hi
= (hi
+ Math
.imul(ah0
, bh3
)) | 0;
8069 var w3
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8070 c
= (((hi
+ (mid
>>> 13)) | 0) + (w3
>>> 26)) | 0;
8073 lo
= Math
.imul(al4
, bl0
);
8074 mid
= Math
.imul(al4
, bh0
);
8075 mid
= (mid
+ Math
.imul(ah4
, bl0
)) | 0;
8076 hi
= Math
.imul(ah4
, bh0
);
8077 lo
= (lo
+ Math
.imul(al3
, bl1
)) | 0;
8078 mid
= (mid
+ Math
.imul(al3
, bh1
)) | 0;
8079 mid
= (mid
+ Math
.imul(ah3
, bl1
)) | 0;
8080 hi
= (hi
+ Math
.imul(ah3
, bh1
)) | 0;
8081 lo
= (lo
+ Math
.imul(al2
, bl2
)) | 0;
8082 mid
= (mid
+ Math
.imul(al2
, bh2
)) | 0;
8083 mid
= (mid
+ Math
.imul(ah2
, bl2
)) | 0;
8084 hi
= (hi
+ Math
.imul(ah2
, bh2
)) | 0;
8085 lo
= (lo
+ Math
.imul(al1
, bl3
)) | 0;
8086 mid
= (mid
+ Math
.imul(al1
, bh3
)) | 0;
8087 mid
= (mid
+ Math
.imul(ah1
, bl3
)) | 0;
8088 hi
= (hi
+ Math
.imul(ah1
, bh3
)) | 0;
8089 lo
= (lo
+ Math
.imul(al0
, bl4
)) | 0;
8090 mid
= (mid
+ Math
.imul(al0
, bh4
)) | 0;
8091 mid
= (mid
+ Math
.imul(ah0
, bl4
)) | 0;
8092 hi
= (hi
+ Math
.imul(ah0
, bh4
)) | 0;
8093 var w4
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8094 c
= (((hi
+ (mid
>>> 13)) | 0) + (w4
>>> 26)) | 0;
8097 lo
= Math
.imul(al5
, bl0
);
8098 mid
= Math
.imul(al5
, bh0
);
8099 mid
= (mid
+ Math
.imul(ah5
, bl0
)) | 0;
8100 hi
= Math
.imul(ah5
, bh0
);
8101 lo
= (lo
+ Math
.imul(al4
, bl1
)) | 0;
8102 mid
= (mid
+ Math
.imul(al4
, bh1
)) | 0;
8103 mid
= (mid
+ Math
.imul(ah4
, bl1
)) | 0;
8104 hi
= (hi
+ Math
.imul(ah4
, bh1
)) | 0;
8105 lo
= (lo
+ Math
.imul(al3
, bl2
)) | 0;
8106 mid
= (mid
+ Math
.imul(al3
, bh2
)) | 0;
8107 mid
= (mid
+ Math
.imul(ah3
, bl2
)) | 0;
8108 hi
= (hi
+ Math
.imul(ah3
, bh2
)) | 0;
8109 lo
= (lo
+ Math
.imul(al2
, bl3
)) | 0;
8110 mid
= (mid
+ Math
.imul(al2
, bh3
)) | 0;
8111 mid
= (mid
+ Math
.imul(ah2
, bl3
)) | 0;
8112 hi
= (hi
+ Math
.imul(ah2
, bh3
)) | 0;
8113 lo
= (lo
+ Math
.imul(al1
, bl4
)) | 0;
8114 mid
= (mid
+ Math
.imul(al1
, bh4
)) | 0;
8115 mid
= (mid
+ Math
.imul(ah1
, bl4
)) | 0;
8116 hi
= (hi
+ Math
.imul(ah1
, bh4
)) | 0;
8117 lo
= (lo
+ Math
.imul(al0
, bl5
)) | 0;
8118 mid
= (mid
+ Math
.imul(al0
, bh5
)) | 0;
8119 mid
= (mid
+ Math
.imul(ah0
, bl5
)) | 0;
8120 hi
= (hi
+ Math
.imul(ah0
, bh5
)) | 0;
8121 var w5
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8122 c
= (((hi
+ (mid
>>> 13)) | 0) + (w5
>>> 26)) | 0;
8125 lo
= Math
.imul(al6
, bl0
);
8126 mid
= Math
.imul(al6
, bh0
);
8127 mid
= (mid
+ Math
.imul(ah6
, bl0
)) | 0;
8128 hi
= Math
.imul(ah6
, bh0
);
8129 lo
= (lo
+ Math
.imul(al5
, bl1
)) | 0;
8130 mid
= (mid
+ Math
.imul(al5
, bh1
)) | 0;
8131 mid
= (mid
+ Math
.imul(ah5
, bl1
)) | 0;
8132 hi
= (hi
+ Math
.imul(ah5
, bh1
)) | 0;
8133 lo
= (lo
+ Math
.imul(al4
, bl2
)) | 0;
8134 mid
= (mid
+ Math
.imul(al4
, bh2
)) | 0;
8135 mid
= (mid
+ Math
.imul(ah4
, bl2
)) | 0;
8136 hi
= (hi
+ Math
.imul(ah4
, bh2
)) | 0;
8137 lo
= (lo
+ Math
.imul(al3
, bl3
)) | 0;
8138 mid
= (mid
+ Math
.imul(al3
, bh3
)) | 0;
8139 mid
= (mid
+ Math
.imul(ah3
, bl3
)) | 0;
8140 hi
= (hi
+ Math
.imul(ah3
, bh3
)) | 0;
8141 lo
= (lo
+ Math
.imul(al2
, bl4
)) | 0;
8142 mid
= (mid
+ Math
.imul(al2
, bh4
)) | 0;
8143 mid
= (mid
+ Math
.imul(ah2
, bl4
)) | 0;
8144 hi
= (hi
+ Math
.imul(ah2
, bh4
)) | 0;
8145 lo
= (lo
+ Math
.imul(al1
, bl5
)) | 0;
8146 mid
= (mid
+ Math
.imul(al1
, bh5
)) | 0;
8147 mid
= (mid
+ Math
.imul(ah1
, bl5
)) | 0;
8148 hi
= (hi
+ Math
.imul(ah1
, bh5
)) | 0;
8149 lo
= (lo
+ Math
.imul(al0
, bl6
)) | 0;
8150 mid
= (mid
+ Math
.imul(al0
, bh6
)) | 0;
8151 mid
= (mid
+ Math
.imul(ah0
, bl6
)) | 0;
8152 hi
= (hi
+ Math
.imul(ah0
, bh6
)) | 0;
8153 var w6
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8154 c
= (((hi
+ (mid
>>> 13)) | 0) + (w6
>>> 26)) | 0;
8157 lo
= Math
.imul(al7
, bl0
);
8158 mid
= Math
.imul(al7
, bh0
);
8159 mid
= (mid
+ Math
.imul(ah7
, bl0
)) | 0;
8160 hi
= Math
.imul(ah7
, bh0
);
8161 lo
= (lo
+ Math
.imul(al6
, bl1
)) | 0;
8162 mid
= (mid
+ Math
.imul(al6
, bh1
)) | 0;
8163 mid
= (mid
+ Math
.imul(ah6
, bl1
)) | 0;
8164 hi
= (hi
+ Math
.imul(ah6
, bh1
)) | 0;
8165 lo
= (lo
+ Math
.imul(al5
, bl2
)) | 0;
8166 mid
= (mid
+ Math
.imul(al5
, bh2
)) | 0;
8167 mid
= (mid
+ Math
.imul(ah5
, bl2
)) | 0;
8168 hi
= (hi
+ Math
.imul(ah5
, bh2
)) | 0;
8169 lo
= (lo
+ Math
.imul(al4
, bl3
)) | 0;
8170 mid
= (mid
+ Math
.imul(al4
, bh3
)) | 0;
8171 mid
= (mid
+ Math
.imul(ah4
, bl3
)) | 0;
8172 hi
= (hi
+ Math
.imul(ah4
, bh3
)) | 0;
8173 lo
= (lo
+ Math
.imul(al3
, bl4
)) | 0;
8174 mid
= (mid
+ Math
.imul(al3
, bh4
)) | 0;
8175 mid
= (mid
+ Math
.imul(ah3
, bl4
)) | 0;
8176 hi
= (hi
+ Math
.imul(ah3
, bh4
)) | 0;
8177 lo
= (lo
+ Math
.imul(al2
, bl5
)) | 0;
8178 mid
= (mid
+ Math
.imul(al2
, bh5
)) | 0;
8179 mid
= (mid
+ Math
.imul(ah2
, bl5
)) | 0;
8180 hi
= (hi
+ Math
.imul(ah2
, bh5
)) | 0;
8181 lo
= (lo
+ Math
.imul(al1
, bl6
)) | 0;
8182 mid
= (mid
+ Math
.imul(al1
, bh6
)) | 0;
8183 mid
= (mid
+ Math
.imul(ah1
, bl6
)) | 0;
8184 hi
= (hi
+ Math
.imul(ah1
, bh6
)) | 0;
8185 lo
= (lo
+ Math
.imul(al0
, bl7
)) | 0;
8186 mid
= (mid
+ Math
.imul(al0
, bh7
)) | 0;
8187 mid
= (mid
+ Math
.imul(ah0
, bl7
)) | 0;
8188 hi
= (hi
+ Math
.imul(ah0
, bh7
)) | 0;
8189 var w7
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8190 c
= (((hi
+ (mid
>>> 13)) | 0) + (w7
>>> 26)) | 0;
8193 lo
= Math
.imul(al8
, bl0
);
8194 mid
= Math
.imul(al8
, bh0
);
8195 mid
= (mid
+ Math
.imul(ah8
, bl0
)) | 0;
8196 hi
= Math
.imul(ah8
, bh0
);
8197 lo
= (lo
+ Math
.imul(al7
, bl1
)) | 0;
8198 mid
= (mid
+ Math
.imul(al7
, bh1
)) | 0;
8199 mid
= (mid
+ Math
.imul(ah7
, bl1
)) | 0;
8200 hi
= (hi
+ Math
.imul(ah7
, bh1
)) | 0;
8201 lo
= (lo
+ Math
.imul(al6
, bl2
)) | 0;
8202 mid
= (mid
+ Math
.imul(al6
, bh2
)) | 0;
8203 mid
= (mid
+ Math
.imul(ah6
, bl2
)) | 0;
8204 hi
= (hi
+ Math
.imul(ah6
, bh2
)) | 0;
8205 lo
= (lo
+ Math
.imul(al5
, bl3
)) | 0;
8206 mid
= (mid
+ Math
.imul(al5
, bh3
)) | 0;
8207 mid
= (mid
+ Math
.imul(ah5
, bl3
)) | 0;
8208 hi
= (hi
+ Math
.imul(ah5
, bh3
)) | 0;
8209 lo
= (lo
+ Math
.imul(al4
, bl4
)) | 0;
8210 mid
= (mid
+ Math
.imul(al4
, bh4
)) | 0;
8211 mid
= (mid
+ Math
.imul(ah4
, bl4
)) | 0;
8212 hi
= (hi
+ Math
.imul(ah4
, bh4
)) | 0;
8213 lo
= (lo
+ Math
.imul(al3
, bl5
)) | 0;
8214 mid
= (mid
+ Math
.imul(al3
, bh5
)) | 0;
8215 mid
= (mid
+ Math
.imul(ah3
, bl5
)) | 0;
8216 hi
= (hi
+ Math
.imul(ah3
, bh5
)) | 0;
8217 lo
= (lo
+ Math
.imul(al2
, bl6
)) | 0;
8218 mid
= (mid
+ Math
.imul(al2
, bh6
)) | 0;
8219 mid
= (mid
+ Math
.imul(ah2
, bl6
)) | 0;
8220 hi
= (hi
+ Math
.imul(ah2
, bh6
)) | 0;
8221 lo
= (lo
+ Math
.imul(al1
, bl7
)) | 0;
8222 mid
= (mid
+ Math
.imul(al1
, bh7
)) | 0;
8223 mid
= (mid
+ Math
.imul(ah1
, bl7
)) | 0;
8224 hi
= (hi
+ Math
.imul(ah1
, bh7
)) | 0;
8225 lo
= (lo
+ Math
.imul(al0
, bl8
)) | 0;
8226 mid
= (mid
+ Math
.imul(al0
, bh8
)) | 0;
8227 mid
= (mid
+ Math
.imul(ah0
, bl8
)) | 0;
8228 hi
= (hi
+ Math
.imul(ah0
, bh8
)) | 0;
8229 var w8
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8230 c
= (((hi
+ (mid
>>> 13)) | 0) + (w8
>>> 26)) | 0;
8233 lo
= Math
.imul(al9
, bl0
);
8234 mid
= Math
.imul(al9
, bh0
);
8235 mid
= (mid
+ Math
.imul(ah9
, bl0
)) | 0;
8236 hi
= Math
.imul(ah9
, bh0
);
8237 lo
= (lo
+ Math
.imul(al8
, bl1
)) | 0;
8238 mid
= (mid
+ Math
.imul(al8
, bh1
)) | 0;
8239 mid
= (mid
+ Math
.imul(ah8
, bl1
)) | 0;
8240 hi
= (hi
+ Math
.imul(ah8
, bh1
)) | 0;
8241 lo
= (lo
+ Math
.imul(al7
, bl2
)) | 0;
8242 mid
= (mid
+ Math
.imul(al7
, bh2
)) | 0;
8243 mid
= (mid
+ Math
.imul(ah7
, bl2
)) | 0;
8244 hi
= (hi
+ Math
.imul(ah7
, bh2
)) | 0;
8245 lo
= (lo
+ Math
.imul(al6
, bl3
)) | 0;
8246 mid
= (mid
+ Math
.imul(al6
, bh3
)) | 0;
8247 mid
= (mid
+ Math
.imul(ah6
, bl3
)) | 0;
8248 hi
= (hi
+ Math
.imul(ah6
, bh3
)) | 0;
8249 lo
= (lo
+ Math
.imul(al5
, bl4
)) | 0;
8250 mid
= (mid
+ Math
.imul(al5
, bh4
)) | 0;
8251 mid
= (mid
+ Math
.imul(ah5
, bl4
)) | 0;
8252 hi
= (hi
+ Math
.imul(ah5
, bh4
)) | 0;
8253 lo
= (lo
+ Math
.imul(al4
, bl5
)) | 0;
8254 mid
= (mid
+ Math
.imul(al4
, bh5
)) | 0;
8255 mid
= (mid
+ Math
.imul(ah4
, bl5
)) | 0;
8256 hi
= (hi
+ Math
.imul(ah4
, bh5
)) | 0;
8257 lo
= (lo
+ Math
.imul(al3
, bl6
)) | 0;
8258 mid
= (mid
+ Math
.imul(al3
, bh6
)) | 0;
8259 mid
= (mid
+ Math
.imul(ah3
, bl6
)) | 0;
8260 hi
= (hi
+ Math
.imul(ah3
, bh6
)) | 0;
8261 lo
= (lo
+ Math
.imul(al2
, bl7
)) | 0;
8262 mid
= (mid
+ Math
.imul(al2
, bh7
)) | 0;
8263 mid
= (mid
+ Math
.imul(ah2
, bl7
)) | 0;
8264 hi
= (hi
+ Math
.imul(ah2
, bh7
)) | 0;
8265 lo
= (lo
+ Math
.imul(al1
, bl8
)) | 0;
8266 mid
= (mid
+ Math
.imul(al1
, bh8
)) | 0;
8267 mid
= (mid
+ Math
.imul(ah1
, bl8
)) | 0;
8268 hi
= (hi
+ Math
.imul(ah1
, bh8
)) | 0;
8269 lo
= (lo
+ Math
.imul(al0
, bl9
)) | 0;
8270 mid
= (mid
+ Math
.imul(al0
, bh9
)) | 0;
8271 mid
= (mid
+ Math
.imul(ah0
, bl9
)) | 0;
8272 hi
= (hi
+ Math
.imul(ah0
, bh9
)) | 0;
8273 var w9
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8274 c
= (((hi
+ (mid
>>> 13)) | 0) + (w9
>>> 26)) | 0;
8277 lo
= Math
.imul(al9
, bl1
);
8278 mid
= Math
.imul(al9
, bh1
);
8279 mid
= (mid
+ Math
.imul(ah9
, bl1
)) | 0;
8280 hi
= Math
.imul(ah9
, bh1
);
8281 lo
= (lo
+ Math
.imul(al8
, bl2
)) | 0;
8282 mid
= (mid
+ Math
.imul(al8
, bh2
)) | 0;
8283 mid
= (mid
+ Math
.imul(ah8
, bl2
)) | 0;
8284 hi
= (hi
+ Math
.imul(ah8
, bh2
)) | 0;
8285 lo
= (lo
+ Math
.imul(al7
, bl3
)) | 0;
8286 mid
= (mid
+ Math
.imul(al7
, bh3
)) | 0;
8287 mid
= (mid
+ Math
.imul(ah7
, bl3
)) | 0;
8288 hi
= (hi
+ Math
.imul(ah7
, bh3
)) | 0;
8289 lo
= (lo
+ Math
.imul(al6
, bl4
)) | 0;
8290 mid
= (mid
+ Math
.imul(al6
, bh4
)) | 0;
8291 mid
= (mid
+ Math
.imul(ah6
, bl4
)) | 0;
8292 hi
= (hi
+ Math
.imul(ah6
, bh4
)) | 0;
8293 lo
= (lo
+ Math
.imul(al5
, bl5
)) | 0;
8294 mid
= (mid
+ Math
.imul(al5
, bh5
)) | 0;
8295 mid
= (mid
+ Math
.imul(ah5
, bl5
)) | 0;
8296 hi
= (hi
+ Math
.imul(ah5
, bh5
)) | 0;
8297 lo
= (lo
+ Math
.imul(al4
, bl6
)) | 0;
8298 mid
= (mid
+ Math
.imul(al4
, bh6
)) | 0;
8299 mid
= (mid
+ Math
.imul(ah4
, bl6
)) | 0;
8300 hi
= (hi
+ Math
.imul(ah4
, bh6
)) | 0;
8301 lo
= (lo
+ Math
.imul(al3
, bl7
)) | 0;
8302 mid
= (mid
+ Math
.imul(al3
, bh7
)) | 0;
8303 mid
= (mid
+ Math
.imul(ah3
, bl7
)) | 0;
8304 hi
= (hi
+ Math
.imul(ah3
, bh7
)) | 0;
8305 lo
= (lo
+ Math
.imul(al2
, bl8
)) | 0;
8306 mid
= (mid
+ Math
.imul(al2
, bh8
)) | 0;
8307 mid
= (mid
+ Math
.imul(ah2
, bl8
)) | 0;
8308 hi
= (hi
+ Math
.imul(ah2
, bh8
)) | 0;
8309 lo
= (lo
+ Math
.imul(al1
, bl9
)) | 0;
8310 mid
= (mid
+ Math
.imul(al1
, bh9
)) | 0;
8311 mid
= (mid
+ Math
.imul(ah1
, bl9
)) | 0;
8312 hi
= (hi
+ Math
.imul(ah1
, bh9
)) | 0;
8313 var w10
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8314 c
= (((hi
+ (mid
>>> 13)) | 0) + (w10
>>> 26)) | 0;
8317 lo
= Math
.imul(al9
, bl2
);
8318 mid
= Math
.imul(al9
, bh2
);
8319 mid
= (mid
+ Math
.imul(ah9
, bl2
)) | 0;
8320 hi
= Math
.imul(ah9
, bh2
);
8321 lo
= (lo
+ Math
.imul(al8
, bl3
)) | 0;
8322 mid
= (mid
+ Math
.imul(al8
, bh3
)) | 0;
8323 mid
= (mid
+ Math
.imul(ah8
, bl3
)) | 0;
8324 hi
= (hi
+ Math
.imul(ah8
, bh3
)) | 0;
8325 lo
= (lo
+ Math
.imul(al7
, bl4
)) | 0;
8326 mid
= (mid
+ Math
.imul(al7
, bh4
)) | 0;
8327 mid
= (mid
+ Math
.imul(ah7
, bl4
)) | 0;
8328 hi
= (hi
+ Math
.imul(ah7
, bh4
)) | 0;
8329 lo
= (lo
+ Math
.imul(al6
, bl5
)) | 0;
8330 mid
= (mid
+ Math
.imul(al6
, bh5
)) | 0;
8331 mid
= (mid
+ Math
.imul(ah6
, bl5
)) | 0;
8332 hi
= (hi
+ Math
.imul(ah6
, bh5
)) | 0;
8333 lo
= (lo
+ Math
.imul(al5
, bl6
)) | 0;
8334 mid
= (mid
+ Math
.imul(al5
, bh6
)) | 0;
8335 mid
= (mid
+ Math
.imul(ah5
, bl6
)) | 0;
8336 hi
= (hi
+ Math
.imul(ah5
, bh6
)) | 0;
8337 lo
= (lo
+ Math
.imul(al4
, bl7
)) | 0;
8338 mid
= (mid
+ Math
.imul(al4
, bh7
)) | 0;
8339 mid
= (mid
+ Math
.imul(ah4
, bl7
)) | 0;
8340 hi
= (hi
+ Math
.imul(ah4
, bh7
)) | 0;
8341 lo
= (lo
+ Math
.imul(al3
, bl8
)) | 0;
8342 mid
= (mid
+ Math
.imul(al3
, bh8
)) | 0;
8343 mid
= (mid
+ Math
.imul(ah3
, bl8
)) | 0;
8344 hi
= (hi
+ Math
.imul(ah3
, bh8
)) | 0;
8345 lo
= (lo
+ Math
.imul(al2
, bl9
)) | 0;
8346 mid
= (mid
+ Math
.imul(al2
, bh9
)) | 0;
8347 mid
= (mid
+ Math
.imul(ah2
, bl9
)) | 0;
8348 hi
= (hi
+ Math
.imul(ah2
, bh9
)) | 0;
8349 var w11
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8350 c
= (((hi
+ (mid
>>> 13)) | 0) + (w11
>>> 26)) | 0;
8353 lo
= Math
.imul(al9
, bl3
);
8354 mid
= Math
.imul(al9
, bh3
);
8355 mid
= (mid
+ Math
.imul(ah9
, bl3
)) | 0;
8356 hi
= Math
.imul(ah9
, bh3
);
8357 lo
= (lo
+ Math
.imul(al8
, bl4
)) | 0;
8358 mid
= (mid
+ Math
.imul(al8
, bh4
)) | 0;
8359 mid
= (mid
+ Math
.imul(ah8
, bl4
)) | 0;
8360 hi
= (hi
+ Math
.imul(ah8
, bh4
)) | 0;
8361 lo
= (lo
+ Math
.imul(al7
, bl5
)) | 0;
8362 mid
= (mid
+ Math
.imul(al7
, bh5
)) | 0;
8363 mid
= (mid
+ Math
.imul(ah7
, bl5
)) | 0;
8364 hi
= (hi
+ Math
.imul(ah7
, bh5
)) | 0;
8365 lo
= (lo
+ Math
.imul(al6
, bl6
)) | 0;
8366 mid
= (mid
+ Math
.imul(al6
, bh6
)) | 0;
8367 mid
= (mid
+ Math
.imul(ah6
, bl6
)) | 0;
8368 hi
= (hi
+ Math
.imul(ah6
, bh6
)) | 0;
8369 lo
= (lo
+ Math
.imul(al5
, bl7
)) | 0;
8370 mid
= (mid
+ Math
.imul(al5
, bh7
)) | 0;
8371 mid
= (mid
+ Math
.imul(ah5
, bl7
)) | 0;
8372 hi
= (hi
+ Math
.imul(ah5
, bh7
)) | 0;
8373 lo
= (lo
+ Math
.imul(al4
, bl8
)) | 0;
8374 mid
= (mid
+ Math
.imul(al4
, bh8
)) | 0;
8375 mid
= (mid
+ Math
.imul(ah4
, bl8
)) | 0;
8376 hi
= (hi
+ Math
.imul(ah4
, bh8
)) | 0;
8377 lo
= (lo
+ Math
.imul(al3
, bl9
)) | 0;
8378 mid
= (mid
+ Math
.imul(al3
, bh9
)) | 0;
8379 mid
= (mid
+ Math
.imul(ah3
, bl9
)) | 0;
8380 hi
= (hi
+ Math
.imul(ah3
, bh9
)) | 0;
8381 var w12
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8382 c
= (((hi
+ (mid
>>> 13)) | 0) + (w12
>>> 26)) | 0;
8385 lo
= Math
.imul(al9
, bl4
);
8386 mid
= Math
.imul(al9
, bh4
);
8387 mid
= (mid
+ Math
.imul(ah9
, bl4
)) | 0;
8388 hi
= Math
.imul(ah9
, bh4
);
8389 lo
= (lo
+ Math
.imul(al8
, bl5
)) | 0;
8390 mid
= (mid
+ Math
.imul(al8
, bh5
)) | 0;
8391 mid
= (mid
+ Math
.imul(ah8
, bl5
)) | 0;
8392 hi
= (hi
+ Math
.imul(ah8
, bh5
)) | 0;
8393 lo
= (lo
+ Math
.imul(al7
, bl6
)) | 0;
8394 mid
= (mid
+ Math
.imul(al7
, bh6
)) | 0;
8395 mid
= (mid
+ Math
.imul(ah7
, bl6
)) | 0;
8396 hi
= (hi
+ Math
.imul(ah7
, bh6
)) | 0;
8397 lo
= (lo
+ Math
.imul(al6
, bl7
)) | 0;
8398 mid
= (mid
+ Math
.imul(al6
, bh7
)) | 0;
8399 mid
= (mid
+ Math
.imul(ah6
, bl7
)) | 0;
8400 hi
= (hi
+ Math
.imul(ah6
, bh7
)) | 0;
8401 lo
= (lo
+ Math
.imul(al5
, bl8
)) | 0;
8402 mid
= (mid
+ Math
.imul(al5
, bh8
)) | 0;
8403 mid
= (mid
+ Math
.imul(ah5
, bl8
)) | 0;
8404 hi
= (hi
+ Math
.imul(ah5
, bh8
)) | 0;
8405 lo
= (lo
+ Math
.imul(al4
, bl9
)) | 0;
8406 mid
= (mid
+ Math
.imul(al4
, bh9
)) | 0;
8407 mid
= (mid
+ Math
.imul(ah4
, bl9
)) | 0;
8408 hi
= (hi
+ Math
.imul(ah4
, bh9
)) | 0;
8409 var w13
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8410 c
= (((hi
+ (mid
>>> 13)) | 0) + (w13
>>> 26)) | 0;
8413 lo
= Math
.imul(al9
, bl5
);
8414 mid
= Math
.imul(al9
, bh5
);
8415 mid
= (mid
+ Math
.imul(ah9
, bl5
)) | 0;
8416 hi
= Math
.imul(ah9
, bh5
);
8417 lo
= (lo
+ Math
.imul(al8
, bl6
)) | 0;
8418 mid
= (mid
+ Math
.imul(al8
, bh6
)) | 0;
8419 mid
= (mid
+ Math
.imul(ah8
, bl6
)) | 0;
8420 hi
= (hi
+ Math
.imul(ah8
, bh6
)) | 0;
8421 lo
= (lo
+ Math
.imul(al7
, bl7
)) | 0;
8422 mid
= (mid
+ Math
.imul(al7
, bh7
)) | 0;
8423 mid
= (mid
+ Math
.imul(ah7
, bl7
)) | 0;
8424 hi
= (hi
+ Math
.imul(ah7
, bh7
)) | 0;
8425 lo
= (lo
+ Math
.imul(al6
, bl8
)) | 0;
8426 mid
= (mid
+ Math
.imul(al6
, bh8
)) | 0;
8427 mid
= (mid
+ Math
.imul(ah6
, bl8
)) | 0;
8428 hi
= (hi
+ Math
.imul(ah6
, bh8
)) | 0;
8429 lo
= (lo
+ Math
.imul(al5
, bl9
)) | 0;
8430 mid
= (mid
+ Math
.imul(al5
, bh9
)) | 0;
8431 mid
= (mid
+ Math
.imul(ah5
, bl9
)) | 0;
8432 hi
= (hi
+ Math
.imul(ah5
, bh9
)) | 0;
8433 var w14
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8434 c
= (((hi
+ (mid
>>> 13)) | 0) + (w14
>>> 26)) | 0;
8437 lo
= Math
.imul(al9
, bl6
);
8438 mid
= Math
.imul(al9
, bh6
);
8439 mid
= (mid
+ Math
.imul(ah9
, bl6
)) | 0;
8440 hi
= Math
.imul(ah9
, bh6
);
8441 lo
= (lo
+ Math
.imul(al8
, bl7
)) | 0;
8442 mid
= (mid
+ Math
.imul(al8
, bh7
)) | 0;
8443 mid
= (mid
+ Math
.imul(ah8
, bl7
)) | 0;
8444 hi
= (hi
+ Math
.imul(ah8
, bh7
)) | 0;
8445 lo
= (lo
+ Math
.imul(al7
, bl8
)) | 0;
8446 mid
= (mid
+ Math
.imul(al7
, bh8
)) | 0;
8447 mid
= (mid
+ Math
.imul(ah7
, bl8
)) | 0;
8448 hi
= (hi
+ Math
.imul(ah7
, bh8
)) | 0;
8449 lo
= (lo
+ Math
.imul(al6
, bl9
)) | 0;
8450 mid
= (mid
+ Math
.imul(al6
, bh9
)) | 0;
8451 mid
= (mid
+ Math
.imul(ah6
, bl9
)) | 0;
8452 hi
= (hi
+ Math
.imul(ah6
, bh9
)) | 0;
8453 var w15
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8454 c
= (((hi
+ (mid
>>> 13)) | 0) + (w15
>>> 26)) | 0;
8457 lo
= Math
.imul(al9
, bl7
);
8458 mid
= Math
.imul(al9
, bh7
);
8459 mid
= (mid
+ Math
.imul(ah9
, bl7
)) | 0;
8460 hi
= Math
.imul(ah9
, bh7
);
8461 lo
= (lo
+ Math
.imul(al8
, bl8
)) | 0;
8462 mid
= (mid
+ Math
.imul(al8
, bh8
)) | 0;
8463 mid
= (mid
+ Math
.imul(ah8
, bl8
)) | 0;
8464 hi
= (hi
+ Math
.imul(ah8
, bh8
)) | 0;
8465 lo
= (lo
+ Math
.imul(al7
, bl9
)) | 0;
8466 mid
= (mid
+ Math
.imul(al7
, bh9
)) | 0;
8467 mid
= (mid
+ Math
.imul(ah7
, bl9
)) | 0;
8468 hi
= (hi
+ Math
.imul(ah7
, bh9
)) | 0;
8469 var w16
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8470 c
= (((hi
+ (mid
>>> 13)) | 0) + (w16
>>> 26)) | 0;
8473 lo
= Math
.imul(al9
, bl8
);
8474 mid
= Math
.imul(al9
, bh8
);
8475 mid
= (mid
+ Math
.imul(ah9
, bl8
)) | 0;
8476 hi
= Math
.imul(ah9
, bh8
);
8477 lo
= (lo
+ Math
.imul(al8
, bl9
)) | 0;
8478 mid
= (mid
+ Math
.imul(al8
, bh9
)) | 0;
8479 mid
= (mid
+ Math
.imul(ah8
, bl9
)) | 0;
8480 hi
= (hi
+ Math
.imul(ah8
, bh9
)) | 0;
8481 var w17
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8482 c
= (((hi
+ (mid
>>> 13)) | 0) + (w17
>>> 26)) | 0;
8485 lo
= Math
.imul(al9
, bl9
);
8486 mid
= Math
.imul(al9
, bh9
);
8487 mid
= (mid
+ Math
.imul(ah9
, bl9
)) | 0;
8488 hi
= Math
.imul(ah9
, bh9
);
8489 var w18
= (((c
+ lo
) | 0) + ((mid
& 0x1fff) << 13)) | 0;
8490 c
= (((hi
+ (mid
>>> 13)) | 0) + (w18
>>> 26)) | 0;
8520 comb10MulTo
= smallMulTo
;
8523 function bigMulTo (self
, num
, out
) {
8524 out
.negative
= num
.negative
^ self
.negative
;
8525 out
.length
= self
.length
+ num
.length
;
8529 for (var k
= 0; k
< out
.length
- 1; k
++) {
8530 // Sum all words with the same `i + j = k` and accumulate `ncarry`,
8531 // note that ncarry could be >= 0x3ffffff
8532 var ncarry
= hncarry
;
8534 var rword
= carry
& 0x3ffffff;
8535 var maxJ
= Math
.min(k
, num
.length
- 1);
8536 for (var j
= Math
.max(0, k
- self
.length
+ 1); j
<= maxJ
; j
++) {
8538 var a
= self
.words
[i
] | 0;
8539 var b
= num
.words
[j
] | 0;
8542 var lo
= r
& 0x3ffffff;
8543 ncarry
= (ncarry
+ ((r
/ 0x4000000) | 0)) | 0;
8544 lo
= (lo
+ rword
) | 0;
8545 rword
= lo
& 0x3ffffff;
8546 ncarry
= (ncarry
+ (lo
>>> 26)) | 0;
8548 hncarry
+= ncarry
>>> 26;
8549 ncarry
&= 0x3ffffff;
8551 out
.words
[k
] = rword
;
8556 out
.words
[k
] = carry
;
8564 function jumboMulTo (self
, num
, out
) {
8565 var fftm
= new FFTM();
8566 return fftm
.mulp(self
, num
, out
);
8569 BN
.prototype.mulTo
= function mulTo (num
, out
) {
8571 var len
= this.length
+ num
.length
;
8572 if (this.length
=== 10 && num
.length
=== 10) {
8573 res
= comb10MulTo(this, num
, out
);
8574 } else if (len
< 63) {
8575 res
= smallMulTo(this, num
, out
);
8576 } else if (len
< 1024) {
8577 res
= bigMulTo(this, num
, out
);
8579 res
= jumboMulTo(this, num
, out
);
8585 // Cooley-Tukey algorithm for FFT
8586 // slightly revisited to rely on looping instead of recursion
8588 function FFTM (x
, y
) {
8593 FFTM
.prototype.makeRBT
= function makeRBT (N
) {
8594 var t
= new Array(N
);
8595 var l
= BN
.prototype._countBits(N
) - 1;
8596 for (var i
= 0; i
< N
; i
++) {
8597 t
[i
] = this.revBin(i
, l
, N
);
8603 // Returns binary-reversed representation of `x`
8604 FFTM
.prototype.revBin
= function revBin (x
, l
, N
) {
8605 if (x
=== 0 || x
=== N
- 1) return x
;
8608 for (var i
= 0; i
< l
; i
++) {
8609 rb
|= (x
& 1) << (l
- i
- 1);
8616 // Performs "tweedling" phase, therefore 'emulating'
8617 // behaviour of the recursive algorithm
8618 FFTM
.prototype.permute
= function permute (rbt
, rws
, iws
, rtws
, itws
, N
) {
8619 for (var i
= 0; i
< N
; i
++) {
8620 rtws
[i
] = rws
[rbt
[i
]];
8621 itws
[i
] = iws
[rbt
[i
]];
8625 FFTM
.prototype.transform
= function transform (rws
, iws
, rtws
, itws
, N
, rbt
) {
8626 this.permute(rbt
, rws
, iws
, rtws
, itws
, N
);
8628 for (var s
= 1; s
< N
; s
<<= 1) {
8631 var rtwdf
= Math
.cos(2 * Math
.PI
/ l
);
8632 var itwdf
= Math
.sin(2 * Math
.PI
/ l
);
8634 for (var p
= 0; p
< N
; p
+= l
) {
8638 for (var j
= 0; j
< s
; j
++) {
8639 var re
= rtws
[p
+ j
];
8640 var ie
= itws
[p
+ j
];
8642 var ro
= rtws
[p
+ j
+ s
];
8643 var io
= itws
[p
+ j
+ s
];
8645 var rx
= rtwdf_
* ro
- itwdf_
* io
;
8647 io
= rtwdf_
* io
+ itwdf_
* ro
;
8650 rtws
[p
+ j
] = re
+ ro
;
8651 itws
[p
+ j
] = ie
+ io
;
8653 rtws
[p
+ j
+ s
] = re
- ro
;
8654 itws
[p
+ j
+ s
] = ie
- io
;
8656 /* jshint maxdepth : false */
8658 rx
= rtwdf
* rtwdf_
- itwdf
* itwdf_
;
8660 itwdf_
= rtwdf
* itwdf_
+ itwdf
* rtwdf_
;
8668 FFTM
.prototype.guessLen13b
= function guessLen13b (n
, m
) {
8669 var N
= Math
.max(m
, n
) | 1;
8672 for (N
= N
/ 2 | 0; N
; N
= N
>>> 1) {
8676 return 1 << i
+ 1 + odd
;
8679 FFTM
.prototype.conjugate
= function conjugate (rws
, iws
, N
) {
8682 for (var i
= 0; i
< N
/ 2; i
++) {
8685 rws
[i
] = rws
[N
- i
- 1];
8690 iws
[i
] = -iws
[N
- i
- 1];
8691 iws
[N
- i
- 1] = -t
;
8695 FFTM
.prototype.normalize13b
= function normalize13b (ws
, N
) {
8697 for (var i
= 0; i
< N
/ 2; i
++) {
8698 var w
= Math
.round(ws
[2 * i
+ 1] / N
) * 0x2000 +
8699 Math
.round(ws
[2 * i
] / N
) +
8702 ws
[i
] = w
& 0x3ffffff;
8704 if (w
< 0x4000000) {
8707 carry
= w
/ 0x4000000 | 0;
8714 FFTM
.prototype.convert13b
= function convert13b (ws
, len
, rws
, N
) {
8716 for (var i
= 0; i
< len
; i
++) {
8717 carry
= carry
+ (ws
[i
] | 0);
8719 rws
[2 * i
] = carry
& 0x1fff; carry
= carry
>>> 13;
8720 rws
[2 * i
+ 1] = carry
& 0x1fff; carry
= carry
>>> 13;
8724 for (i
= 2 * len
; i
< N
; ++i
) {
8728 assert(carry
=== 0);
8729 assert((carry
& ~0x1fff) === 0);
8732 FFTM
.prototype.stub
= function stub (N
) {
8733 var ph
= new Array(N
);
8734 for (var i
= 0; i
< N
; i
++) {
8741 FFTM
.prototype.mulp
= function mulp (x
, y
, out
) {
8742 var N
= 2 * this.guessLen13b(x
.length
, y
.length
);
8744 var rbt
= this.makeRBT(N
);
8746 var _
= this.stub(N
);
8748 var rws
= new Array(N
);
8749 var rwst
= new Array(N
);
8750 var iwst
= new Array(N
);
8752 var nrws
= new Array(N
);
8753 var nrwst
= new Array(N
);
8754 var niwst
= new Array(N
);
8756 var rmws
= out
.words
;
8759 this.convert13b(x
.words
, x
.length
, rws
, N
);
8760 this.convert13b(y
.words
, y
.length
, nrws
, N
);
8762 this.transform(rws
, _
, rwst
, iwst
, N
, rbt
);
8763 this.transform(nrws
, _
, nrwst
, niwst
, N
, rbt
);
8765 for (var i
= 0; i
< N
; i
++) {
8766 var rx
= rwst
[i
] * nrwst
[i
] - iwst
[i
] * niwst
[i
];
8767 iwst
[i
] = rwst
[i
] * niwst
[i
] + iwst
[i
] * nrwst
[i
];
8771 this.conjugate(rwst
, iwst
, N
);
8772 this.transform(rwst
, iwst
, rmws
, _
, N
, rbt
);
8773 this.conjugate(rmws
, _
, N
);
8774 this.normalize13b(rmws
, N
);
8776 out
.negative
= x
.negative
^ y
.negative
;
8777 out
.length
= x
.length
+ y
.length
;
8781 // Multiply `this` by `num`
8782 BN
.prototype.mul
= function mul (num
) {
8783 var out
= new BN(null);
8784 out
.words
= new Array(this.length
+ num
.length
);
8785 return this.mulTo(num
, out
);
8788 // Multiply employing FFT
8789 BN
.prototype.mulf
= function mulf (num
) {
8790 var out
= new BN(null);
8791 out
.words
= new Array(this.length
+ num
.length
);
8792 return jumboMulTo(this, num
, out
);
8795 // In-place Multiplication
8796 BN
.prototype.imul
= function imul (num
) {
8797 return this.clone().mulTo(num
, this);
8800 BN
.prototype.imuln
= function imuln (num
) {
8801 assert(typeof num
=== 'number');
8802 assert(num
< 0x4000000);
8806 for (var i
= 0; i
< this.length
; i
++) {
8807 var w
= (this.words
[i
] | 0) * num
;
8808 var lo
= (w
& 0x3ffffff) + (carry
& 0x3ffffff);
8810 carry
+= (w
/ 0x4000000) | 0;
8811 // NOTE: lo is 27bit maximum
8813 this.words
[i
] = lo
& 0x3ffffff;
8817 this.words
[i
] = carry
;
8824 BN
.prototype.muln
= function muln (num
) {
8825 return this.clone().imuln(num
);
8829 BN
.prototype.sqr
= function sqr () {
8830 return this.mul(this);
8833 // `this` * `this` in-place
8834 BN
.prototype.isqr
= function isqr () {
8835 return this.imul(this.clone());
8838 // Math.pow(`this`, `num`)
8839 BN
.prototype.pow
= function pow (num
) {
8840 var w
= toBitArray(num
);
8841 if (w
.length
=== 0) return new BN(1);
8843 // Skip leading zeroes
8845 for (var i
= 0; i
< w
.length
; i
++, res
= res
.sqr()) {
8846 if (w
[i
] !== 0) break;
8849 if (++i
< w
.length
) {
8850 for (var q
= res
.sqr(); i
< w
.length
; i
++, q
= q
.sqr()) {
8851 if (w
[i
] === 0) continue;
8860 // Shift-left in-place
8861 BN
.prototype.iushln
= function iushln (bits
) {
8862 assert(typeof bits
=== 'number' && bits
>= 0);
8864 var s
= (bits
- r
) / 26;
8865 var carryMask
= (0x3ffffff >>> (26 - r
)) << (26 - r
);
8871 for (i
= 0; i
< this.length
; i
++) {
8872 var newCarry
= this.words
[i
] & carryMask
;
8873 var c
= ((this.words
[i
] | 0) - newCarry
) << r
;
8874 this.words
[i
] = c
| carry
;
8875 carry
= newCarry
>>> (26 - r
);
8879 this.words
[i
] = carry
;
8885 for (i
= this.length
- 1; i
>= 0; i
--) {
8886 this.words
[i
+ s
] = this.words
[i
];
8889 for (i
= 0; i
< s
; i
++) {
8896 return this.strip();
8899 BN
.prototype.ishln
= function ishln (bits
) {
8900 // TODO(indutny): implement me
8901 assert(this.negative
=== 0);
8902 return this.iushln(bits
);
8905 // Shift-right in-place
8906 // NOTE: `hint` is a lowest bit before trailing zeroes
8907 // NOTE: if `extended` is present - it will be filled with destroyed bits
8908 BN
.prototype.iushrn
= function iushrn (bits
, hint
, extended
) {
8909 assert(typeof bits
=== 'number' && bits
>= 0);
8912 h
= (hint
- (hint
% 26)) / 26;
8918 var s
= Math
.min((bits
- r
) / 26, this.length
);
8919 var mask
= 0x3ffffff ^ ((0x3ffffff >>> r
) << r
);
8920 var maskedWords
= extended
;
8925 // Extended mode, copy masked part
8927 for (var i
= 0; i
< s
; i
++) {
8928 maskedWords
.words
[i
] = this.words
[i
];
8930 maskedWords
.length
= s
;
8934 // No-op, we should not move anything at all
8935 } else if (this.length
> s
) {
8937 for (i
= 0; i
< this.length
; i
++) {
8938 this.words
[i
] = this.words
[i
+ s
];
8946 for (i
= this.length
- 1; i
>= 0 && (carry
!== 0 || i
>= h
); i
--) {
8947 var word
= this.words
[i
] | 0;
8948 this.words
[i
] = (carry
<< (26 - r
)) | (word
>>> r
);
8949 carry
= word
& mask
;
8952 // Push carried bits as a mask
8953 if (maskedWords
&& carry
!== 0) {
8954 maskedWords
.words
[maskedWords
.length
++] = carry
;
8957 if (this.length
=== 0) {
8962 return this.strip();
8965 BN
.prototype.ishrn
= function ishrn (bits
, hint
, extended
) {
8966 // TODO(indutny): implement me
8967 assert(this.negative
=== 0);
8968 return this.iushrn(bits
, hint
, extended
);
8972 BN
.prototype.shln
= function shln (bits
) {
8973 return this.clone().ishln(bits
);
8976 BN
.prototype.ushln
= function ushln (bits
) {
8977 return this.clone().iushln(bits
);
8981 BN
.prototype.shrn
= function shrn (bits
) {
8982 return this.clone().ishrn(bits
);
8985 BN
.prototype.ushrn
= function ushrn (bits
) {
8986 return this.clone().iushrn(bits
);
8989 // Test if n bit is set
8990 BN
.prototype.testn
= function testn (bit
) {
8991 assert(typeof bit
=== 'number' && bit
>= 0);
8993 var s
= (bit
- r
) / 26;
8996 // Fast case: bit is much higher than all existing words
8997 if (this.length
<= s
) return false;
8999 // Check bit and return
9000 var w
= this.words
[s
];
9005 // Return only lowers bits of number (in-place)
9006 BN
.prototype.imaskn
= function imaskn (bits
) {
9007 assert(typeof bits
=== 'number' && bits
>= 0);
9009 var s
= (bits
- r
) / 26;
9011 assert(this.negative
=== 0, 'imaskn works only with positive numbers');
9013 if (this.length
<= s
) {
9020 this.length
= Math
.min(s
, this.length
);
9023 var mask
= 0x3ffffff ^ ((0x3ffffff >>> r
) << r
);
9024 this.words
[this.length
- 1] &= mask
;
9027 return this.strip();
9030 // Return only lowers bits of number
9031 BN
.prototype.maskn
= function maskn (bits
) {
9032 return this.clone().imaskn(bits
);
9035 // Add plain number `num` to `this`
9036 BN
.prototype.iaddn
= function iaddn (num
) {
9037 assert(typeof num
=== 'number');
9038 assert(num
< 0x4000000);
9039 if (num
< 0) return this.isubn(-num
);
9041 // Possible sign change
9042 if (this.negative
!== 0) {
9043 if (this.length
=== 1 && (this.words
[0] | 0) < num
) {
9044 this.words
[0] = num
- (this.words
[0] | 0);
9055 // Add without checks
9056 return this._iaddn(num
);
9059 BN
.prototype._iaddn
= function _iaddn (num
) {
9060 this.words
[0] += num
;
9063 for (var i
= 0; i
< this.length
&& this.words
[i
] >= 0x4000000; i
++) {
9064 this.words
[i
] -= 0x4000000;
9065 if (i
=== this.length
- 1) {
9066 this.words
[i
+ 1] = 1;
9068 this.words
[i
+ 1]++;
9071 this.length
= Math
.max(this.length
, i
+ 1);
9076 // Subtract plain number `num` from `this`
9077 BN
.prototype.isubn
= function isubn (num
) {
9078 assert(typeof num
=== 'number');
9079 assert(num
< 0x4000000);
9080 if (num
< 0) return this.iaddn(-num
);
9082 if (this.negative
!== 0) {
9089 this.words
[0] -= num
;
9091 if (this.length
=== 1 && this.words
[0] < 0) {
9092 this.words
[0] = -this.words
[0];
9096 for (var i
= 0; i
< this.length
&& this.words
[i
] < 0; i
++) {
9097 this.words
[i
] += 0x4000000;
9098 this.words
[i
+ 1] -= 1;
9102 return this.strip();
9105 BN
.prototype.addn
= function addn (num
) {
9106 return this.clone().iaddn(num
);
9109 BN
.prototype.subn
= function subn (num
) {
9110 return this.clone().isubn(num
);
9113 BN
.prototype.iabs
= function iabs () {
9119 BN
.prototype.abs
= function abs () {
9120 return this.clone().iabs();
9123 BN
.prototype._ishlnsubmul
= function _ishlnsubmul (num
, mul
, shift
) {
9124 var len
= num
.length
+ shift
;
9131 for (i
= 0; i
< num
.length
; i
++) {
9132 w
= (this.words
[i
+ shift
] | 0) + carry
;
9133 var right
= (num
.words
[i
] | 0) * mul
;
9134 w
-= right
& 0x3ffffff;
9135 carry
= (w
>> 26) - ((right
/ 0x4000000) | 0);
9136 this.words
[i
+ shift
] = w
& 0x3ffffff;
9138 for (; i
< this.length
- shift
; i
++) {
9139 w
= (this.words
[i
+ shift
] | 0) + carry
;
9141 this.words
[i
+ shift
] = w
& 0x3ffffff;
9144 if (carry
=== 0) return this.strip();
9146 // Subtraction overflow
9147 assert(carry
=== -1);
9149 for (i
= 0; i
< this.length
; i
++) {
9150 w
= -(this.words
[i
] | 0) + carry
;
9152 this.words
[i
] = w
& 0x3ffffff;
9156 return this.strip();
9159 BN
.prototype._wordDiv
= function _wordDiv (num
, mode
) {
9160 var shift
= this.length
- num
.length
;
9162 var a
= this.clone();
9166 var bhi
= b
.words
[b
.length
- 1] | 0;
9167 var bhiBits
= this._countBits(bhi
);
9168 shift
= 26 - bhiBits
;
9172 bhi
= b
.words
[b
.length
- 1] | 0;
9175 // Initialize quotient
9176 var m
= a
.length
- b
.length
;
9179 if (mode
!== 'mod') {
9182 q
.words
= new Array(q
.length
);
9183 for (var i
= 0; i
< q
.length
; i
++) {
9188 var diff
= a
.clone()._ishlnsubmul(b
, 1, m
);
9189 if (diff
.negative
=== 0) {
9196 for (var j
= m
- 1; j
>= 0; j
--) {
9197 var qj
= (a
.words
[b
.length
+ j
] | 0) * 0x4000000 +
9198 (a
.words
[b
.length
+ j
- 1] | 0);
9200 // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
9202 qj
= Math
.min((qj
/ bhi
) | 0, 0x3ffffff);
9204 a
._ishlnsubmul(b
, qj
, j
);
9205 while (a
.negative
!== 0) {
9208 a
._ishlnsubmul(b
, 1, j
);
9223 if (mode
!== 'div' && shift
!== 0) {
9233 // NOTE: 1) `mode` can be set to `mod` to request mod only,
9234 // to `div` to request div only, or be absent to
9235 // request both div & mod
9236 // 2) `positive` is true if unsigned mod is requested
9237 BN
.prototype.divmod
= function divmod (num
, mode
, positive
) {
9238 assert(!num
.isZero());
9240 if (this.isZero()) {
9248 if (this.negative
!== 0 && num
.negative
=== 0) {
9249 res
= this.neg().divmod(num
, mode
);
9251 if (mode
!== 'mod') {
9252 div
= res
.div
.neg();
9255 if (mode
!== 'div') {
9256 mod
= res
.mod
.neg();
9257 if (positive
&& mod
.negative
!== 0) {
9268 if (this.negative
=== 0 && num
.negative
!== 0) {
9269 res
= this.divmod(num
.neg(), mode
);
9271 if (mode
!== 'mod') {
9272 div
= res
.div
.neg();
9281 if ((this.negative
& num
.negative
) !== 0) {
9282 res
= this.neg().divmod(num
.neg(), mode
);
9284 if (mode
!== 'div') {
9285 mod
= res
.mod
.neg();
9286 if (positive
&& mod
.negative
!== 0) {
9297 // Both numbers are positive at this point
9299 // Strip both numbers to approximate shift value
9300 if (num
.length
> this.length
|| this.cmp(num
) < 0) {
9307 // Very short reduction
9308 if (num
.length
=== 1) {
9309 if (mode
=== 'div') {
9311 div: this.divn(num
.words
[0]),
9316 if (mode
=== 'mod') {
9319 mod: new BN(this.modn(num
.words
[0]))
9324 div: this.divn(num
.words
[0]),
9325 mod: new BN(this.modn(num
.words
[0]))
9329 return this._wordDiv(num
, mode
);
9332 // Find `this` / `num`
9333 BN
.prototype.div
= function div (num
) {
9334 return this.divmod(num
, 'div', false).div
;
9337 // Find `this` % `num`
9338 BN
.prototype.mod
= function mod (num
) {
9339 return this.divmod(num
, 'mod', false).mod
;
9342 BN
.prototype.umod
= function umod (num
) {
9343 return this.divmod(num
, 'mod', true).mod
;
9346 // Find Round(`this` / `num`)
9347 BN
.prototype.divRound
= function divRound (num
) {
9348 var dm
= this.divmod(num
);
9350 // Fast case - exact division
9351 if (dm
.mod
.isZero()) return dm
.div
;
9353 var mod
= dm
.div
.negative
!== 0 ? dm
.mod
.isub(num
) : dm
.mod
;
9355 var half
= num
.ushrn(1);
9356 var r2
= num
.andln(1);
9357 var cmp
= mod
.cmp(half
);
9360 if (cmp
< 0 || r2
=== 1 && cmp
=== 0) return dm
.div
;
9363 return dm
.div
.negative
!== 0 ? dm
.div
.isubn(1) : dm
.div
.iaddn(1);
9366 BN
.prototype.modn
= function modn (num
) {
9367 assert(num
<= 0x3ffffff);
9368 var p
= (1 << 26) % num
;
9371 for (var i
= this.length
- 1; i
>= 0; i
--) {
9372 acc
= (p
* acc
+ (this.words
[i
] | 0)) % num
;
9378 // In-place division by number
9379 BN
.prototype.idivn
= function idivn (num
) {
9380 assert(num
<= 0x3ffffff);
9383 for (var i
= this.length
- 1; i
>= 0; i
--) {
9384 var w
= (this.words
[i
] | 0) + carry
* 0x4000000;
9385 this.words
[i
] = (w
/ num
) | 0;
9389 return this.strip();
9392 BN
.prototype.divn
= function divn (num
) {
9393 return this.clone().idivn(num
);
9396 BN
.prototype.egcd
= function egcd (p
) {
9397 assert(p
.negative
=== 0);
9398 assert(!p
.isZero());
9403 if (x
.negative
!== 0) {
9409 // A * x + B * y = x
9413 // C * x + D * y = y
9419 while (x
.isEven() && y
.isEven()) {
9428 while (!x
.isZero()) {
9429 for (var i
= 0, im
= 1; (x
.words
[0] & im
) === 0 && i
< 26; ++i
, im
<<= 1);
9433 if (A
.isOdd() || B
.isOdd()) {
9443 for (var j
= 0, jm
= 1; (y
.words
[0] & jm
) === 0 && j
< 26; ++j
, jm
<<= 1);
9447 if (C
.isOdd() || D
.isOdd()) {
9457 if (x
.cmp(y
) >= 0) {
9475 // This is reduced incarnation of the binary EEA
9476 // above, designated to invert members of the
9477 // _prime_ fields F(p) at a maximal speed
9478 BN
.prototype._invmp
= function _invmp (p
) {
9479 assert(p
.negative
=== 0);
9480 assert(!p
.isZero());
9485 if (a
.negative
!== 0) {
9494 var delta
= b
.clone();
9496 while (a
.cmpn(1) > 0 && b
.cmpn(1) > 0) {
9497 for (var i
= 0, im
= 1; (a
.words
[0] & im
) === 0 && i
< 26; ++i
, im
<<= 1);
9509 for (var j
= 0, jm
= 1; (b
.words
[0] & jm
) === 0 && j
< 26; ++j
, jm
<<= 1);
9521 if (a
.cmp(b
) >= 0) {
9531 if (a
.cmpn(1) === 0) {
9537 if (res
.cmpn(0) < 0) {
9544 BN
.prototype.gcd
= function gcd (num
) {
9545 if (this.isZero()) return num
.abs();
9546 if (num
.isZero()) return this.abs();
9548 var a
= this.clone();
9549 var b
= num
.clone();
9553 // Remove common factor of two
9554 for (var shift
= 0; a
.isEven() && b
.isEven(); shift
++) {
9560 while (a
.isEven()) {
9563 while (b
.isEven()) {
9569 // Swap `a` and `b` to make `a` always bigger than `b`
9573 } else if (r
=== 0 || b
.cmpn(1) === 0) {
9580 return b
.iushln(shift
);
9583 // Invert number in the field F(num)
9584 BN
.prototype.invm
= function invm (num
) {
9585 return this.egcd(num
).a
.umod(num
);
9588 BN
.prototype.isEven
= function isEven () {
9589 return (this.words
[0] & 1) === 0;
9592 BN
.prototype.isOdd
= function isOdd () {
9593 return (this.words
[0] & 1) === 1;
9596 // And first word and num
9597 BN
.prototype.andln
= function andln (num
) {
9598 return this.words
[0] & num
;
9601 // Increment at the bit position in-line
9602 BN
.prototype.bincn
= function bincn (bit
) {
9603 assert(typeof bit
=== 'number');
9605 var s
= (bit
- r
) / 26;
9608 // Fast case: bit is much higher than all existing words
9609 if (this.length
<= s
) {
9610 this._expand(s
+ 1);
9615 // Add bit and propagate, if needed
9617 for (var i
= s
; carry
!== 0 && i
< this.length
; i
++) {
9618 var w
= this.words
[i
] | 0;
9625 this.words
[i
] = carry
;
9631 BN
.prototype.isZero
= function isZero () {
9632 return this.length
=== 1 && this.words
[0] === 0;
9635 BN
.prototype.cmpn
= function cmpn (num
) {
9636 var negative
= num
< 0;
9638 if (this.negative
!== 0 && !negative
) return -1;
9639 if (this.negative
=== 0 && negative
) return 1;
9644 if (this.length
> 1) {
9651 assert(num
<= 0x3ffffff, 'Number is too big');
9653 var w
= this.words
[0] | 0;
9654 res
= w
=== num
? 0 : w
< num
? -1 : 1;
9656 if (this.negative
!== 0) return -res
| 0;
9660 // Compare two numbers and return:
9661 // 1 - if `this` > `num`
9662 // 0 - if `this` == `num`
9663 // -1 - if `this` < `num`
9664 BN
.prototype.cmp
= function cmp (num
) {
9665 if (this.negative
!== 0 && num
.negative
=== 0) return -1;
9666 if (this.negative
=== 0 && num
.negative
!== 0) return 1;
9668 var res
= this.ucmp(num
);
9669 if (this.negative
!== 0) return -res
| 0;
9673 // Unsigned comparison
9674 BN
.prototype.ucmp
= function ucmp (num
) {
9675 // At this point both numbers have the same sign
9676 if (this.length
> num
.length
) return 1;
9677 if (this.length
< num
.length
) return -1;
9680 for (var i
= this.length
- 1; i
>= 0; i
--) {
9681 var a
= this.words
[i
] | 0;
9682 var b
= num
.words
[i
] | 0;
9684 if (a
=== b
) continue;
9695 BN
.prototype.gtn
= function gtn (num
) {
9696 return this.cmpn(num
) === 1;
9699 BN
.prototype.gt
= function gt (num
) {
9700 return this.cmp(num
) === 1;
9703 BN
.prototype.gten
= function gten (num
) {
9704 return this.cmpn(num
) >= 0;
9707 BN
.prototype.gte
= function gte (num
) {
9708 return this.cmp(num
) >= 0;
9711 BN
.prototype.ltn
= function ltn (num
) {
9712 return this.cmpn(num
) === -1;
9715 BN
.prototype.lt
= function lt (num
) {
9716 return this.cmp(num
) === -1;
9719 BN
.prototype.lten
= function lten (num
) {
9720 return this.cmpn(num
) <= 0;
9723 BN
.prototype.lte
= function lte (num
) {
9724 return this.cmp(num
) <= 0;
9727 BN
.prototype.eqn
= function eqn (num
) {
9728 return this.cmpn(num
) === 0;
9731 BN
.prototype.eq
= function eq (num
) {
9732 return this.cmp(num
) === 0;
9736 // A reduce context, could be using montgomery or something better, depending
9737 // on the `m` itself.
9739 BN
.red
= function red (num
) {
9740 return new Red(num
);
9743 BN
.prototype.toRed
= function toRed (ctx
) {
9744 assert(!this.red
, 'Already a number in reduction context');
9745 assert(this.negative
=== 0, 'red works only with positives');
9746 return ctx
.convertTo(this)._forceRed(ctx
);
9749 BN
.prototype.fromRed
= function fromRed () {
9750 assert(this.red
, 'fromRed works only with numbers in reduction context');
9751 return this.red
.convertFrom(this);
9754 BN
.prototype._forceRed
= function _forceRed (ctx
) {
9759 BN
.prototype.forceRed
= function forceRed (ctx
) {
9760 assert(!this.red
, 'Already a number in reduction context');
9761 return this._forceRed(ctx
);
9764 BN
.prototype.redAdd
= function redAdd (num
) {
9765 assert(this.red
, 'redAdd works only with red numbers');
9766 return this.red
.add(this, num
);
9769 BN
.prototype.redIAdd
= function redIAdd (num
) {
9770 assert(this.red
, 'redIAdd works only with red numbers');
9771 return this.red
.iadd(this, num
);
9774 BN
.prototype.redSub
= function redSub (num
) {
9775 assert(this.red
, 'redSub works only with red numbers');
9776 return this.red
.sub(this, num
);
9779 BN
.prototype.redISub
= function redISub (num
) {
9780 assert(this.red
, 'redISub works only with red numbers');
9781 return this.red
.isub(this, num
);
9784 BN
.prototype.redShl
= function redShl (num
) {
9785 assert(this.red
, 'redShl works only with red numbers');
9786 return this.red
.shl(this, num
);
9789 BN
.prototype.redMul
= function redMul (num
) {
9790 assert(this.red
, 'redMul works only with red numbers');
9791 this.red
._verify2(this, num
);
9792 return this.red
.mul(this, num
);
9795 BN
.prototype.redIMul
= function redIMul (num
) {
9796 assert(this.red
, 'redMul works only with red numbers');
9797 this.red
._verify2(this, num
);
9798 return this.red
.imul(this, num
);
9801 BN
.prototype.redSqr
= function redSqr () {
9802 assert(this.red
, 'redSqr works only with red numbers');
9803 this.red
._verify1(this);
9804 return this.red
.sqr(this);
9807 BN
.prototype.redISqr
= function redISqr () {
9808 assert(this.red
, 'redISqr works only with red numbers');
9809 this.red
._verify1(this);
9810 return this.red
.isqr(this);
9813 // Square root over p
9814 BN
.prototype.redSqrt
= function redSqrt () {
9815 assert(this.red
, 'redSqrt works only with red numbers');
9816 this.red
._verify1(this);
9817 return this.red
.sqrt(this);
9820 BN
.prototype.redInvm
= function redInvm () {
9821 assert(this.red
, 'redInvm works only with red numbers');
9822 this.red
._verify1(this);
9823 return this.red
.invm(this);
9826 // Return negative clone of `this` % `red modulo`
9827 BN
.prototype.redNeg
= function redNeg () {
9828 assert(this.red
, 'redNeg works only with red numbers');
9829 this.red
._verify1(this);
9830 return this.red
.neg(this);
9833 BN
.prototype.redPow
= function redPow (num
) {
9834 assert(this.red
&& !num
.red
, 'redPow(normalNum)');
9835 this.red
._verify1(this);
9836 return this.red
.pow(this, num
);
9839 // Prime numbers with efficient reduction
9847 // Pseudo-Mersenne prime
9848 function MPrime (name
, p
) {
9851 this.p
= new BN(p
, 16);
9852 this.n
= this.p
.bitLength();
9853 this.k
= new BN(1).iushln(this.n
).isub(this.p
);
9855 this.tmp
= this._tmp();
9858 MPrime
.prototype._tmp
= function _tmp () {
9859 var tmp
= new BN(null);
9860 tmp
.words
= new Array(Math
.ceil(this.n
/ 13));
9864 MPrime
.prototype.ireduce
= function ireduce (num
) {
9865 // Assumes that `num` is less than `P^2`
9866 // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
9871 this.split(r
, this.tmp
);
9873 r
= r
.iadd(this.tmp
);
9874 rlen
= r
.bitLength();
9875 } while (rlen
> this.n
);
9877 var cmp
= rlen
< this.n
? -1 : r
.ucmp(this.p
);
9881 } else if (cmp
> 0) {
9890 MPrime
.prototype.split
= function split (input
, out
) {
9891 input
.iushrn(this.n
, 0, out
);
9894 MPrime
.prototype.imulK
= function imulK (num
) {
9895 return num
.imul(this.k
);
9902 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
9904 inherits(K256
, MPrime
);
9906 K256
.prototype.split
= function split (input
, output
) {
9907 // 256 = 9 * 26 + 22
9908 var mask
= 0x3fffff;
9910 var outLen
= Math
.min(input
.length
, 9);
9911 for (var i
= 0; i
< outLen
; i
++) {
9912 output
.words
[i
] = input
.words
[i
];
9914 output
.length
= outLen
;
9916 if (input
.length
<= 9) {
9923 var prev
= input
.words
[9];
9924 output
.words
[output
.length
++] = prev
& mask
;
9926 for (i
= 10; i
< input
.length
; i
++) {
9927 var next
= input
.words
[i
] | 0;
9928 input
.words
[i
- 10] = ((next
& mask
) << 4) | (prev
>>> 22);
9932 input
.words
[i
- 10] = prev
;
9933 if (prev
=== 0 && input
.length
> 10) {
9940 K256
.prototype.imulK
= function imulK (num
) {
9941 // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
9942 num
.words
[num
.length
] = 0;
9943 num
.words
[num
.length
+ 1] = 0;
9946 // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
9948 for (var i
= 0; i
< num
.length
; i
++) {
9949 var w
= num
.words
[i
] | 0;
9951 num
.words
[i
] = lo
& 0x3ffffff;
9952 lo
= w
* 0x40 + ((lo
/ 0x4000000) | 0);
9955 // Fast length reduction
9956 if (num
.words
[num
.length
- 1] === 0) {
9958 if (num
.words
[num
.length
- 1] === 0) {
9969 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
9971 inherits(P224
, MPrime
);
9977 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
9979 inherits(P192
, MPrime
);
9981 function P25519 () {
9986 '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
9988 inherits(P25519
, MPrime
);
9990 P25519
.prototype.imulK
= function imulK (num
) {
9993 for (var i
= 0; i
< num
.length
; i
++) {
9994 var hi
= (num
.words
[i
] | 0) * 0x13 + carry
;
9995 var lo
= hi
& 0x3ffffff;
10002 num
.words
[num
.length
++] = carry
;
10007 // Exported mostly for testing purposes, use plain name instead
10008 BN
._prime
= function prime (name
) {
10009 // Cached version of prime
10010 if (primes
[name
]) return primes
[name
];
10013 if (name
=== 'k256') {
10014 prime
= new K256();
10015 } else if (name
=== 'p224') {
10016 prime
= new P224();
10017 } else if (name
=== 'p192') {
10018 prime
= new P192();
10019 } else if (name
=== 'p25519') {
10020 prime
= new P25519();
10022 throw new Error('Unknown prime ' + name
);
10024 primes
[name
] = prime
;
10030 // Base reduction engine
10033 if (typeof m
=== 'string') {
10034 var prime
= BN
._prime(m
);
10036 this.prime
= prime
;
10038 assert(m
.gtn(1), 'modulus must be greater than 1');
10044 Red
.prototype._verify1
= function _verify1 (a
) {
10045 assert(a
.negative
=== 0, 'red works only with positives');
10046 assert(a
.red
, 'red works only with red numbers');
10049 Red
.prototype._verify2
= function _verify2 (a
, b
) {
10050 assert((a
.negative
| b
.negative
) === 0, 'red works only with positives');
10051 assert(a
.red
&& a
.red
=== b
.red
,
10052 'red works only with red numbers');
10055 Red
.prototype.imod
= function imod (a
) {
10056 if (this.prime
) return this.prime
.ireduce(a
)._forceRed(this);
10057 return a
.umod(this.m
)._forceRed(this);
10060 Red
.prototype.neg
= function neg (a
) {
10065 return this.m
.sub(a
)._forceRed(this);
10068 Red
.prototype.add
= function add (a
, b
) {
10069 this._verify2(a
, b
);
10071 var res
= a
.add(b
);
10072 if (res
.cmp(this.m
) >= 0) {
10075 return res
._forceRed(this);
10078 Red
.prototype.iadd
= function iadd (a
, b
) {
10079 this._verify2(a
, b
);
10081 var res
= a
.iadd(b
);
10082 if (res
.cmp(this.m
) >= 0) {
10088 Red
.prototype.sub
= function sub (a
, b
) {
10089 this._verify2(a
, b
);
10091 var res
= a
.sub(b
);
10092 if (res
.cmpn(0) < 0) {
10095 return res
._forceRed(this);
10098 Red
.prototype.isub
= function isub (a
, b
) {
10099 this._verify2(a
, b
);
10101 var res
= a
.isub(b
);
10102 if (res
.cmpn(0) < 0) {
10108 Red
.prototype.shl
= function shl (a
, num
) {
10110 return this.imod(a
.ushln(num
));
10113 Red
.prototype.imul
= function imul (a
, b
) {
10114 this._verify2(a
, b
);
10115 return this.imod(a
.imul(b
));
10118 Red
.prototype.mul
= function mul (a
, b
) {
10119 this._verify2(a
, b
);
10120 return this.imod(a
.mul(b
));
10123 Red
.prototype.isqr
= function isqr (a
) {
10124 return this.imul(a
, a
.clone());
10127 Red
.prototype.sqr
= function sqr (a
) {
10128 return this.mul(a
, a
);
10131 Red
.prototype.sqrt
= function sqrt (a
) {
10132 if (a
.isZero()) return a
.clone();
10134 var mod3
= this.m
.andln(3);
10135 assert(mod3
% 2 === 1);
10139 var pow
= this.m
.add(new BN(1)).iushrn(2);
10140 return this.pow(a
, pow
);
10143 // Tonelli-Shanks algorithm (Totally unoptimized and slow)
10145 // Find Q and S, that Q * 2 ^ S = (P - 1)
10146 var q
= this.m
.subn(1);
10148 while (!q
.isZero() && q
.andln(1) === 0) {
10152 assert(!q
.isZero());
10154 var one
= new BN(1).toRed(this);
10155 var nOne
= one
.redNeg();
10157 // Find quadratic non-residue
10158 // NOTE: Max is such because of generalized Riemann hypothesis.
10159 var lpow
= this.m
.subn(1).iushrn(1);
10160 var z
= this.m
.bitLength();
10161 z
= new BN(2 * z
* z
).toRed(this);
10163 while (this.pow(z
, lpow
).cmp(nOne
) !== 0) {
10167 var c
= this.pow(z
, q
);
10168 var r
= this.pow(a
, q
.addn(1).iushrn(1));
10169 var t
= this.pow(a
, q
);
10171 while (t
.cmp(one
) !== 0) {
10173 for (var i
= 0; tmp
.cmp(one
) !== 0; i
++) {
10174 tmp
= tmp
.redSqr();
10177 var b
= this.pow(c
, new BN(1).iushln(m
- i
- 1));
10188 Red
.prototype.invm
= function invm (a
) {
10189 var inv
= a
._invmp(this.m
);
10190 if (inv
.negative
!== 0) {
10192 return this.imod(inv
).redNeg();
10194 return this.imod(inv
);
10198 Red
.prototype.pow
= function pow (a
, num
) {
10199 if (num
.isZero()) return new BN(1);
10200 if (num
.cmpn(1) === 0) return a
.clone();
10202 var windowSize
= 4;
10203 var wnd
= new Array(1 << windowSize
);
10204 wnd
[0] = new BN(1).toRed(this);
10206 for (var i
= 2; i
< wnd
.length
; i
++) {
10207 wnd
[i
] = this.mul(wnd
[i
- 1], a
);
10212 var currentLen
= 0;
10213 var start
= num
.bitLength() % 26;
10218 for (i
= num
.length
- 1; i
>= 0; i
--) {
10219 var word
= num
.words
[i
];
10220 for (var j
= start
- 1; j
>= 0; j
--) {
10221 var bit
= (word
>> j
) & 1;
10222 if (res
!== wnd
[0]) {
10223 res
= this.sqr(res
);
10226 if (bit
=== 0 && current
=== 0) {
10234 if (currentLen
!== windowSize
&& (i
!== 0 || j
!== 0)) continue;
10236 res
= this.mul(res
, wnd
[current
]);
10246 Red
.prototype.convertTo
= function convertTo (num
) {
10247 var r
= num
.umod(this.m
);
10249 return r
=== num
? r
.clone() : r
;
10252 Red
.prototype.convertFrom
= function convertFrom (num
) {
10253 var res
= num
.clone();
10259 // Montgomery method engine
10262 BN
.mont
= function mont (num
) {
10263 return new Mont(num
);
10266 function Mont (m
) {
10269 this.shift
= this.m
.bitLength();
10270 if (this.shift
% 26 !== 0) {
10271 this.shift
+= 26 - (this.shift
% 26);
10274 this.r
= new BN(1).iushln(this.shift
);
10275 this.r2
= this.imod(this.r
.sqr());
10276 this.rinv
= this.r
._invmp(this.m
);
10278 this.minv
= this.rinv
.mul(this.r
).isubn(1).div(this.m
);
10279 this.minv
= this.minv
.umod(this.r
);
10280 this.minv
= this.r
.sub(this.minv
);
10282 inherits(Mont
, Red
);
10284 Mont
.prototype.convertTo
= function convertTo (num
) {
10285 return this.imod(num
.ushln(this.shift
));
10288 Mont
.prototype.convertFrom
= function convertFrom (num
) {
10289 var r
= this.imod(num
.mul(this.rinv
));
10294 Mont
.prototype.imul
= function imul (a
, b
) {
10295 if (a
.isZero() || b
.isZero()) {
10302 var c
= t
.maskn(this.shift
).mul(this.minv
).imaskn(this.shift
).mul(this.m
);
10303 var u
= t
.isub(c
).iushrn(this.shift
);
10306 if (u
.cmp(this.m
) >= 0) {
10307 res
= u
.isub(this.m
);
10308 } else if (u
.cmpn(0) < 0) {
10309 res
= u
.iadd(this.m
);
10312 return res
._forceRed(this);
10315 Mont
.prototype.mul
= function mul (a
, b
) {
10316 if (a
.isZero() || b
.isZero()) return new BN(0)._forceRed(this);
10319 var c
= t
.maskn(this.shift
).mul(this.minv
).imaskn(this.shift
).mul(this.m
);
10320 var u
= t
.isub(c
).iushrn(this.shift
);
10322 if (u
.cmp(this.m
) >= 0) {
10323 res
= u
.isub(this.m
);
10324 } else if (u
.cmpn(0) < 0) {
10325 res
= u
.iadd(this.m
);
10328 return res
._forceRed(this);
10331 Mont
.prototype.invm
= function invm (a
) {
10332 // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
10333 var res
= this.imod(a
._invmp(this.m
).mul(this.r2
));
10334 return res
._forceRed(this);
10336 })(typeof module
=== 'undefined' || module
, this);
10338 },{}],34:[function(require
,module
,exports
){
10341 module
.exports
= function rand(len
) {
10343 r
= new Rand(null);
10345 return r
.generate(len
);
10348 function Rand(rand
) {
10351 module
.exports
.Rand
= Rand
;
10353 Rand
.prototype.generate
= function generate(len
) {
10354 return this._rand(len
);
10357 if (typeof self
=== 'object') {
10358 if (self
.crypto
&& self
.crypto
.getRandomValues
) {
10360 Rand
.prototype._rand
= function _rand(n
) {
10361 var arr
= new Uint8Array(n
);
10362 self
.crypto
.getRandomValues(arr
);
10365 } else if (self
.msCrypto
&& self
.msCrypto
.getRandomValues
) {
10367 Rand
.prototype._rand
= function _rand(n
) {
10368 var arr
= new Uint8Array(n
);
10369 self
.msCrypto
.getRandomValues(arr
);
10374 Rand
.prototype._rand = function() {
10375 throw new Error('Not implemented yet');
10379 // Node.js or Web worker with no crypto support
10381 var crypto
= require('crypto');
10383 Rand
.prototype._rand
= function _rand(n
) {
10384 return crypto
.randomBytes(n
);
10387 // Emulate crypto API using randy
10388 Rand
.prototype._rand
= function _rand(n
) {
10389 var res
= new Uint8Array(n
);
10390 for (var i
= 0; i
< res
.length
; i
++)
10391 res
[i
] = this.rand
.getByte();
10397 },{"crypto":3}],35:[function(require
,module
,exports
){
10398 (function (Buffer
){
10399 var Transform
= require('stream').Transform
10400 var inherits
= require('inherits')
10401 var StringDecoder
= require('string_decoder').StringDecoder
10402 module
.exports
= CipherBase
10403 inherits(CipherBase
, Transform
)
10404 function CipherBase (hashMode
) {
10405 Transform
.call(this)
10406 this.hashMode
= typeof hashMode
=== 'string'
10407 if (this.hashMode
) {
10408 this[hashMode
] = this._finalOrDigest
10410 this.final
= this._finalOrDigest
10412 this._decoder
= null
10413 this._encoding
= null
10415 CipherBase
.prototype.update = function (data
, inputEnc
, outputEnc
) {
10416 if (typeof data
=== 'string') {
10417 data
= new Buffer(data
, inputEnc
)
10419 var outData
= this._update(data
)
10420 if (this.hashMode
) {
10424 outData
= this._toString(outData
, outputEnc
)
10429 CipherBase
.prototype.setAutoPadding = function () {}
10431 CipherBase
.prototype.getAuthTag = function () {
10432 throw new Error('trying to get auth tag in unsupported state')
10435 CipherBase
.prototype.setAuthTag = function () {
10436 throw new Error('trying to set auth tag in unsupported state')
10439 CipherBase
.prototype.setAAD = function () {
10440 throw new Error('trying to set aad in unsupported state')
10443 CipherBase
.prototype._transform = function (data
, _
, next
) {
10446 if (this.hashMode
) {
10449 this.push(this._update(data
))
10457 CipherBase
.prototype._flush = function (done
) {
10460 this.push(this._final())
10467 CipherBase
.prototype._finalOrDigest = function (outputEnc
) {
10468 var outData
= this._final() || new Buffer('')
10470 outData
= this._toString(outData
, outputEnc
, true)
10475 CipherBase
.prototype._toString = function (value
, enc
, fin
) {
10476 if (!this._decoder
) {
10477 this._decoder
= new StringDecoder(enc
)
10478 this._encoding
= enc
10480 if (this._encoding
!== enc
) {
10481 throw new Error('can\'t switch encodings')
10483 var out
= this._decoder
.write(value
)
10485 out
+= this._decoder
.end()
10490 }).call(this,require("buffer").Buffer
)
10491 },{"buffer":5,"inherits":63,"stream":25,"string_decoder":26}],36:[function(require
,module
,exports
){
10492 (function (Buffer
){
10494 var inherits
= require('inherits')
10495 var md5
= require('./md5')
10496 var rmd160
= require('ripemd160')
10497 var sha
= require('sha.js')
10499 var Base
= require('cipher-base')
10501 function HashNoConstructor(hash
) {
10502 Base
.call(this, 'digest')
10508 inherits(HashNoConstructor
, Base
)
10510 HashNoConstructor
.prototype._update = function (data
) {
10511 this.buffers
.push(data
)
10514 HashNoConstructor
.prototype._final = function () {
10515 var buf
= Buffer
.concat(this.buffers
)
10516 var r
= this._hash(buf
)
10517 this.buffers
= null
10522 function Hash(hash
) {
10523 Base
.call(this, 'digest')
10528 inherits(Hash
, Base
)
10530 Hash
.prototype._update = function (data
) {
10531 this._hash
.update(data
)
10534 Hash
.prototype._final = function () {
10535 return this._hash
.digest()
10538 module
.exports
= function createHash (alg
) {
10539 alg
= alg
.toLowerCase()
10540 if ('md5' === alg
) return new HashNoConstructor(md5
)
10541 if ('rmd160' === alg
|| 'ripemd160' === alg
) return new HashNoConstructor(rmd160
)
10543 return new Hash(sha(alg
))
10546 }).call(this,require("buffer").Buffer
)
10547 },{"./md5":38,"buffer":5,"cipher-base":35,"inherits":63,"ripemd160":71,"sha.js":80}],37:[function(require
,module
,exports
){
10548 (function (Buffer
){
10551 var zeroBuffer
= new Buffer(intSize
); zeroBuffer
.fill(0);
10554 function toArray(buf
, bigEndian
) {
10555 if ((buf
.length
% intSize
) !== 0) {
10556 var len
= buf
.length
+ (intSize
- (buf
.length
% intSize
));
10557 buf
= Buffer
.concat([buf
, zeroBuffer
], len
);
10561 var fn
= bigEndian
? buf
.readInt32BE : buf
.readInt32LE
;
10562 for (var i
= 0; i
< buf
.length
; i
+= intSize
) {
10563 arr
.push(fn
.call(buf
, i
));
10568 function toBuffer(arr
, size
, bigEndian
) {
10569 var buf
= new Buffer(size
);
10570 var fn
= bigEndian
? buf
.writeInt32BE : buf
.writeInt32LE
;
10571 for (var i
= 0; i
< arr
.length
; i
++) {
10572 fn
.call(buf
, arr
[i
], i
* 4, true);
10577 function hash(buf
, fn
, hashSize
, bigEndian
) {
10578 if (!Buffer
.isBuffer(buf
)) buf
= new Buffer(buf
);
10579 var arr
= fn(toArray(buf
, bigEndian
), buf
.length
* chrsz
);
10580 return toBuffer(arr
, hashSize
, bigEndian
);
10582 exports
.hash
= hash
;
10583 }).call(this,require("buffer").Buffer
)
10584 },{"buffer":5}],38:[function(require
,module
,exports
){
10587 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
10588 * Digest Algorithm, as defined in RFC 1321.
10589 * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
10590 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
10591 * Distributed under the BSD License
10592 * See http://pajhome.org.uk/crypt/md5 for more info.
10595 var helpers
= require('./helpers');
10598 * Calculate the MD5 of an array of little-endian words, and a bit length
10600 function core_md5(x
, len
)
10602 /* append padding */
10603 x
[len
>> 5] |= 0x80 << ((len
) % 32);
10604 x
[(((len
+ 64) >>> 9) << 4) + 14] = len
;
10606 var a
= 1732584193;
10607 var b
= -271733879;
10608 var c
= -1732584194;
10611 for(var i
= 0; i
< x
.length
; i
+= 16)
10618 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 0], 7 , -680876936);
10619 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 1], 12, -389564586);
10620 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 2], 17, 606105819);
10621 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 3], 22, -1044525330);
10622 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 4], 7 , -176418897);
10623 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 5], 12, 1200080426);
10624 c
= md5_ff(c
, d
, a
, b
, x
[i
+ 6], 17, -1473231341);
10625 b
= md5_ff(b
, c
, d
, a
, x
[i
+ 7], 22, -45705983);
10626 a
= md5_ff(a
, b
, c
, d
, x
[i
+ 8], 7 , 1770035416);
10627 d
= md5_ff(d
, a
, b
, c
, x
[i
+ 9], 12, -1958414417);
10628 c
= md5_ff(c
, d
, a
, b
, x
[i
+10], 17, -42063);
10629 b
= md5_ff(b
, c
, d
, a
, x
[i
+11], 22, -1990404162);
10630 a
= md5_ff(a
, b
, c
, d
, x
[i
+12], 7 , 1804603682);
10631 d
= md5_ff(d
, a
, b
, c
, x
[i
+13], 12, -40341101);
10632 c
= md5_ff(c
, d
, a
, b
, x
[i
+14], 17, -1502002290);
10633 b
= md5_ff(b
, c
, d
, a
, x
[i
+15], 22, 1236535329);
10635 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 1], 5 , -165796510);
10636 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 6], 9 , -1069501632);
10637 c
= md5_gg(c
, d
, a
, b
, x
[i
+11], 14, 643717713);
10638 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 0], 20, -373897302);
10639 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 5], 5 , -701558691);
10640 d
= md5_gg(d
, a
, b
, c
, x
[i
+10], 9 , 38016083);
10641 c
= md5_gg(c
, d
, a
, b
, x
[i
+15], 14, -660478335);
10642 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 4], 20, -405537848);
10643 a
= md5_gg(a
, b
, c
, d
, x
[i
+ 9], 5 , 568446438);
10644 d
= md5_gg(d
, a
, b
, c
, x
[i
+14], 9 , -1019803690);
10645 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 3], 14, -187363961);
10646 b
= md5_gg(b
, c
, d
, a
, x
[i
+ 8], 20, 1163531501);
10647 a
= md5_gg(a
, b
, c
, d
, x
[i
+13], 5 , -1444681467);
10648 d
= md5_gg(d
, a
, b
, c
, x
[i
+ 2], 9 , -51403784);
10649 c
= md5_gg(c
, d
, a
, b
, x
[i
+ 7], 14, 1735328473);
10650 b
= md5_gg(b
, c
, d
, a
, x
[i
+12], 20, -1926607734);
10652 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 5], 4 , -378558);
10653 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 8], 11, -2022574463);
10654 c
= md5_hh(c
, d
, a
, b
, x
[i
+11], 16, 1839030562);
10655 b
= md5_hh(b
, c
, d
, a
, x
[i
+14], 23, -35309556);
10656 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 1], 4 , -1530992060);
10657 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 4], 11, 1272893353);
10658 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 7], 16, -155497632);
10659 b
= md5_hh(b
, c
, d
, a
, x
[i
+10], 23, -1094730640);
10660 a
= md5_hh(a
, b
, c
, d
, x
[i
+13], 4 , 681279174);
10661 d
= md5_hh(d
, a
, b
, c
, x
[i
+ 0], 11, -358537222);
10662 c
= md5_hh(c
, d
, a
, b
, x
[i
+ 3], 16, -722521979);
10663 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 6], 23, 76029189);
10664 a
= md5_hh(a
, b
, c
, d
, x
[i
+ 9], 4 , -640364487);
10665 d
= md5_hh(d
, a
, b
, c
, x
[i
+12], 11, -421815835);
10666 c
= md5_hh(c
, d
, a
, b
, x
[i
+15], 16, 530742520);
10667 b
= md5_hh(b
, c
, d
, a
, x
[i
+ 2], 23, -995338651);
10669 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 0], 6 , -198630844);
10670 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 7], 10, 1126891415);
10671 c
= md5_ii(c
, d
, a
, b
, x
[i
+14], 15, -1416354905);
10672 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 5], 21, -57434055);
10673 a
= md5_ii(a
, b
, c
, d
, x
[i
+12], 6 , 1700485571);
10674 d
= md5_ii(d
, a
, b
, c
, x
[i
+ 3], 10, -1894986606);
10675 c
= md5_ii(c
, d
, a
, b
, x
[i
+10], 15, -1051523);
10676 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 1], 21, -2054922799);
10677 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 8], 6 , 1873313359);
10678 d
= md5_ii(d
, a
, b
, c
, x
[i
+15], 10, -30611744);
10679 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 6], 15, -1560198380);
10680 b
= md5_ii(b
, c
, d
, a
, x
[i
+13], 21, 1309151649);
10681 a
= md5_ii(a
, b
, c
, d
, x
[i
+ 4], 6 , -145523070);
10682 d
= md5_ii(d
, a
, b
, c
, x
[i
+11], 10, -1120210379);
10683 c
= md5_ii(c
, d
, a
, b
, x
[i
+ 2], 15, 718787259);
10684 b
= md5_ii(b
, c
, d
, a
, x
[i
+ 9], 21, -343485551);
10686 a
= safe_add(a
, olda
);
10687 b
= safe_add(b
, oldb
);
10688 c
= safe_add(c
, oldc
);
10689 d
= safe_add(d
, oldd
);
10691 return Array(a
, b
, c
, d
);
10696 * These functions implement the four basic operations the algorithm uses.
10698 function md5_cmn(q
, a
, b
, x
, s
, t
)
10700 return safe_add(bit_rol(safe_add(safe_add(a
, q
), safe_add(x
, t
)), s
),b
);
10702 function md5_ff(a
, b
, c
, d
, x
, s
, t
)
10704 return md5_cmn((b
& c
) | ((~b
) & d
), a
, b
, x
, s
, t
);
10706 function md5_gg(a
, b
, c
, d
, x
, s
, t
)
10708 return md5_cmn((b
& d
) | (c
& (~d
)), a
, b
, x
, s
, t
);
10710 function md5_hh(a
, b
, c
, d
, x
, s
, t
)
10712 return md5_cmn(b
^ c
^ d
, a
, b
, x
, s
, t
);
10714 function md5_ii(a
, b
, c
, d
, x
, s
, t
)
10716 return md5_cmn(c
^ (b
| (~d
)), a
, b
, x
, s
, t
);
10720 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
10721 * to work around bugs in some JS interpreters.
10723 function safe_add(x
, y
)
10725 var lsw
= (x
& 0xFFFF) + (y
& 0xFFFF);
10726 var msw
= (x
>> 16) + (y
>> 16) + (lsw
>> 16);
10727 return (msw
<< 16) | (lsw
& 0xFFFF);
10731 * Bitwise rotate a 32-bit number to the left.
10733 function bit_rol(num
, cnt
)
10735 return (num
<< cnt
) | (num
>>> (32 - cnt
));
10738 module
.exports
= function md5(buf
) {
10739 return helpers
.hash(buf
, core_md5
, 16);
10741 },{"./helpers":37}],39:[function(require
,module
,exports
){
10744 var elliptic
= exports
;
10746 elliptic
.version
= require('../package.json').version
;
10747 elliptic
.utils
= require('./elliptic/utils');
10748 elliptic
.rand
= require('brorand');
10749 elliptic
.hmacDRBG
= require('./elliptic/hmac-drbg');
10750 elliptic
.curve
= require('./elliptic/curve');
10751 elliptic
.curves
= require('./elliptic/curves');
10754 elliptic
.ec
= require('./elliptic/ec');
10755 elliptic
.eddsa
= require('./elliptic/eddsa');
10757 },{"../package.json":55,"./elliptic/curve":42,"./elliptic/curves":45,"./elliptic/ec":46,"./elliptic/eddsa":49,"./elliptic/hmac-drbg":52,"./elliptic/utils":54,"brorand":34}],40:[function(require
,module
,exports
){
10760 var BN
= require('bn.js');
10761 var elliptic
= require('../../elliptic');
10762 var utils
= elliptic
.utils
;
10763 var getNAF
= utils
.getNAF
;
10764 var getJSF
= utils
.getJSF
;
10765 var assert
= utils
.assert
;
10767 function BaseCurve(type
, conf
) {
10769 this.p
= new BN(conf
.p
, 16);
10771 // Use Montgomery, when there is no fast reduction for the prime
10772 this.red
= conf
.prime
? BN
.red(conf
.prime
) : BN
.mont(this.p
);
10774 // Useful for many curves
10775 this.zero
= new BN(0).toRed(this.red
);
10776 this.one
= new BN(1).toRed(this.red
);
10777 this.two
= new BN(2).toRed(this.red
);
10779 // Curve configuration, optional
10780 this.n
= conf
.n
&& new BN(conf
.n
, 16);
10781 this.g
= conf
.g
&& this.pointFromJSON(conf
.g
, conf
.gRed
);
10783 // Temporary arrays
10784 this._wnafT1
= new Array(4);
10785 this._wnafT2
= new Array(4);
10786 this._wnafT3
= new Array(4);
10787 this._wnafT4
= new Array(4);
10789 // Generalized Greg Maxwell's trick
10790 var adjustCount
= this.n
&& this.p
.div(this.n
);
10791 if (!adjustCount
|| adjustCount
.cmpn(100) > 0) {
10794 this._maxwellTrick
= true;
10795 this.redN
= this.n
.toRed(this.red
);
10798 module
.exports
= BaseCurve
;
10800 BaseCurve
.prototype.point
= function point() {
10801 throw new Error('Not implemented');
10804 BaseCurve
.prototype.validate
= function validate() {
10805 throw new Error('Not implemented');
10808 BaseCurve
.prototype._fixedNafMul
= function _fixedNafMul(p
, k
) {
10809 assert(p
.precomputed
);
10810 var doubles
= p
._getDoubles();
10812 var naf
= getNAF(k
, 1);
10813 var I
= (1 << (doubles
.step
+ 1)) - (doubles
.step
% 2 === 0 ? 2 : 1);
10816 // Translate into more windowed form
10818 for (var j
= 0; j
< naf
.length
; j
+= doubles
.step
) {
10820 for (var k
= j
+ doubles
.step
- 1; k
>= j
; k
--)
10821 nafW
= (nafW
<< 1) + naf
[k
];
10825 var a
= this.jpoint(null, null, null);
10826 var b
= this.jpoint(null, null, null);
10827 for (var i
= I
; i
> 0; i
--) {
10828 for (var j
= 0; j
< repr
.length
; j
++) {
10829 var nafW
= repr
[j
];
10831 b
= b
.mixedAdd(doubles
.points
[j
]);
10832 else if (nafW
=== -i
)
10833 b
= b
.mixedAdd(doubles
.points
[j
].neg());
10840 BaseCurve
.prototype._wnafMul
= function _wnafMul(p
, k
) {
10843 // Precompute window
10844 var nafPoints
= p
._getNAFPoints(w
);
10846 var wnd
= nafPoints
.points
;
10849 var naf
= getNAF(k
, w
);
10851 // Add `this`*(N+1) for every w-NAF index
10852 var acc
= this.jpoint(null, null, null);
10853 for (var i
= naf
.length
- 1; i
>= 0; i
--) {
10855 for (var k
= 0; i
>= 0 && naf
[i
] === 0; i
--)
10865 if (p
.type
=== 'affine') {
10868 acc
= acc
.mixedAdd(wnd
[(z
- 1) >> 1]);
10870 acc
= acc
.mixedAdd(wnd
[(-z
- 1) >> 1].neg());
10874 acc
= acc
.add(wnd
[(z
- 1) >> 1]);
10876 acc
= acc
.add(wnd
[(-z
- 1) >> 1].neg());
10879 return p
.type
=== 'affine' ? acc
.toP() : acc
;
10882 BaseCurve
.prototype._wnafMulAdd
= function _wnafMulAdd(defW
,
10887 var wndWidth
= this._wnafT1
;
10888 var wnd
= this._wnafT2
;
10889 var naf
= this._wnafT3
;
10893 for (var i
= 0; i
< len
; i
++) {
10895 var nafPoints
= p
._getNAFPoints(defW
);
10896 wndWidth
[i
] = nafPoints
.wnd
;
10897 wnd
[i
] = nafPoints
.points
;
10900 // Comb small window NAFs
10901 for (var i
= len
- 1; i
>= 1; i
-= 2) {
10904 if (wndWidth
[a
] !== 1 || wndWidth
[b
] !== 1) {
10905 naf
[a
] = getNAF(coeffs
[a
], wndWidth
[a
]);
10906 naf
[b
] = getNAF(coeffs
[b
], wndWidth
[b
]);
10907 max
= Math
.max(naf
[a
].length
, max
);
10908 max
= Math
.max(naf
[b
].length
, max
);
10919 // Try to avoid Projective points, if possible
10920 if (points
[a
].y
.cmp(points
[b
].y
) === 0) {
10921 comb
[1] = points
[a
].add(points
[b
]);
10922 comb
[2] = points
[a
].toJ().mixedAdd(points
[b
].neg());
10923 } else if (points
[a
].y
.cmp(points
[b
].y
.redNeg()) === 0) {
10924 comb
[1] = points
[a
].toJ().mixedAdd(points
[b
]);
10925 comb
[2] = points
[a
].add(points
[b
].neg());
10927 comb
[1] = points
[a
].toJ().mixedAdd(points
[b
]);
10928 comb
[2] = points
[a
].toJ().mixedAdd(points
[b
].neg());
10943 var jsf
= getJSF(coeffs
[a
], coeffs
[b
]);
10944 max
= Math
.max(jsf
[0].length
, max
);
10945 naf
[a
] = new Array(max
);
10946 naf
[b
] = new Array(max
);
10947 for (var j
= 0; j
< max
; j
++) {
10948 var ja
= jsf
[0][j
] | 0;
10949 var jb
= jsf
[1][j
] | 0;
10951 naf
[a
][j
] = index
[(ja
+ 1) * 3 + (jb
+ 1)];
10957 var acc
= this.jpoint(null, null, null);
10958 var tmp
= this._wnafT4
;
10959 for (var i
= max
; i
>= 0; i
--) {
10964 for (var j
= 0; j
< len
; j
++) {
10965 tmp
[j
] = naf
[j
][i
] | 0;
10980 for (var j
= 0; j
< len
; j
++) {
10986 p
= wnd
[j
][(z
- 1) >> 1];
10988 p
= wnd
[j
][(-z
- 1) >> 1].neg();
10990 if (p
.type
=== 'affine')
10991 acc
= acc
.mixedAdd(p
);
10996 // Zeroify references
10997 for (var i
= 0; i
< len
; i
++)
11000 if (jacobianResult
)
11006 function BasePoint(curve
, type
) {
11007 this.curve
= curve
;
11009 this.precomputed
= null;
11011 BaseCurve
.BasePoint
= BasePoint
;
11013 BasePoint
.prototype.eq
= function eq(/*other*/) {
11014 throw new Error('Not implemented');
11017 BasePoint
.prototype.validate
= function validate() {
11018 return this.curve
.validate(this);
11021 BaseCurve
.prototype.decodePoint
= function decodePoint(bytes
, enc
) {
11022 bytes
= utils
.toArray(bytes
, enc
);
11024 var len
= this.p
.byteLength();
11026 // uncompressed, hybrid-odd, hybrid-even
11027 if ((bytes
[0] === 0x04 || bytes
[0] === 0x06 || bytes
[0] === 0x07) &&
11028 bytes
.length
- 1 === 2 * len
) {
11029 if (bytes
[0] === 0x06)
11030 assert(bytes
[bytes
.length
- 1] % 2 === 0);
11031 else if (bytes
[0] === 0x07)
11032 assert(bytes
[bytes
.length
- 1] % 2 === 1);
11034 var res
= this.point(bytes
.slice(1, 1 + len
),
11035 bytes
.slice(1 + len
, 1 + 2 * len
));
11038 } else if ((bytes
[0] === 0x02 || bytes
[0] === 0x03) &&
11039 bytes
.length
- 1 === len
) {
11040 return this.pointFromX(bytes
.slice(1, 1 + len
), bytes
[0] === 0x03);
11042 throw new Error('Unknown point format');
11045 BasePoint
.prototype.encodeCompressed
= function encodeCompressed(enc
) {
11046 return this.encode(enc
, true);
11049 BasePoint
.prototype._encode
= function _encode(compact
) {
11050 var len
= this.curve
.p
.byteLength();
11051 var x
= this.getX().toArray('be', len
);
11054 return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x
);
11056 return [ 0x04 ].concat(x
, this.getY().toArray('be', len
)) ;
11059 BasePoint
.prototype.encode
= function encode(enc
, compact
) {
11060 return utils
.encode(this._encode(compact
), enc
);
11063 BasePoint
.prototype.precompute
= function precompute(power
) {
11064 if (this.precomputed
)
11067 var precomputed
= {
11072 precomputed
.naf
= this._getNAFPoints(8);
11073 precomputed
.doubles
= this._getDoubles(4, power
);
11074 precomputed
.beta
= this._getBeta();
11075 this.precomputed
= precomputed
;
11080 BasePoint
.prototype._hasDoubles
= function _hasDoubles(k
) {
11081 if (!this.precomputed
)
11084 var doubles
= this.precomputed
.doubles
;
11088 return doubles
.points
.length
>= Math
.ceil((k
.bitLength() + 1) / doubles
.step
);
11091 BasePoint
.prototype._getDoubles
= function _getDoubles(step
, power
) {
11092 if (this.precomputed
&& this.precomputed
.doubles
)
11093 return this.precomputed
.doubles
;
11095 var doubles
= [ this ];
11097 for (var i
= 0; i
< power
; i
+= step
) {
11098 for (var j
= 0; j
< step
; j
++)
11108 BasePoint
.prototype._getNAFPoints
= function _getNAFPoints(wnd
) {
11109 if (this.precomputed
&& this.precomputed
.naf
)
11110 return this.precomputed
.naf
;
11112 var res
= [ this ];
11113 var max
= (1 << wnd
) - 1;
11114 var dbl
= max
=== 1 ? null : this.dbl();
11115 for (var i
= 1; i
< max
; i
++)
11116 res
[i
] = res
[i
- 1].add(dbl
);
11123 BasePoint
.prototype._getBeta
= function _getBeta() {
11127 BasePoint
.prototype.dblp
= function dblp(k
) {
11129 for (var i
= 0; i
< k
; i
++)
11134 },{"../../elliptic":39,"bn.js":33}],41:[function(require
,module
,exports
){
11137 var curve
= require('../curve');
11138 var elliptic
= require('../../elliptic');
11139 var BN
= require('bn.js');
11140 var inherits
= require('inherits');
11141 var Base
= curve
.base
;
11143 var assert
= elliptic
.utils
.assert
;
11145 function EdwardsCurve(conf
) {
11146 // NOTE: Important as we are creating point in Base.call()
11147 this.twisted
= (conf
.a
| 0) !== 1;
11148 this.mOneA
= this.twisted
&& (conf
.a
| 0) === -1;
11149 this.extended
= this.mOneA
;
11151 Base
.call(this, 'edwards', conf
);
11153 this.a
= new BN(conf
.a
, 16).umod(this.red
.m
);
11154 this.a
= this.a
.toRed(this.red
);
11155 this.c
= new BN(conf
.c
, 16).toRed(this.red
);
11156 this.c2
= this.c
.redSqr();
11157 this.d
= new BN(conf
.d
, 16).toRed(this.red
);
11158 this.dd
= this.d
.redAdd(this.d
);
11160 assert(!this.twisted
|| this.c
.fromRed().cmpn(1) === 0);
11161 this.oneC
= (conf
.c
| 0) === 1;
11163 inherits(EdwardsCurve
, Base
);
11164 module
.exports
= EdwardsCurve
;
11166 EdwardsCurve
.prototype._mulA
= function _mulA(num
) {
11168 return num
.redNeg();
11170 return this.a
.redMul(num
);
11173 EdwardsCurve
.prototype._mulC
= function _mulC(num
) {
11177 return this.c
.redMul(num
);
11180 // Just for compatibility with Short curve
11181 EdwardsCurve
.prototype.jpoint
= function jpoint(x
, y
, z
, t
) {
11182 return this.point(x
, y
, z
, t
);
11185 EdwardsCurve
.prototype.pointFromX
= function pointFromX(x
, odd
) {
11188 x
= x
.toRed(this.red
);
11190 var x2
= x
.redSqr();
11191 var rhs
= this.c2
.redSub(this.a
.redMul(x2
));
11192 var lhs
= this.one
.redSub(this.c2
.redMul(this.d
).redMul(x2
));
11194 var y2
= rhs
.redMul(lhs
.redInvm());
11195 var y
= y2
.redSqrt();
11196 if (y
.redSqr().redSub(y2
).cmp(this.zero
) !== 0)
11197 throw new Error('invalid point');
11199 var isOdd
= y
.fromRed().isOdd();
11200 if (odd
&& !isOdd
|| !odd
&& isOdd
)
11203 return this.point(x
, y
);
11206 EdwardsCurve
.prototype.pointFromY
= function pointFromY(y
, odd
) {
11209 y
= y
.toRed(this.red
);
11211 // x^2 = (y^2 - 1) / (d y^2 + 1)
11212 var y2
= y
.redSqr();
11213 var lhs
= y2
.redSub(this.one
);
11214 var rhs
= y2
.redMul(this.d
).redAdd(this.one
);
11215 var x2
= lhs
.redMul(rhs
.redInvm());
11217 if (x2
.cmp(this.zero
) === 0) {
11219 throw new Error('invalid point');
11221 return this.point(this.zero
, y
);
11224 var x
= x2
.redSqrt();
11225 if (x
.redSqr().redSub(x2
).cmp(this.zero
) !== 0)
11226 throw new Error('invalid point');
11228 if (x
.isOdd() !== odd
)
11231 return this.point(x
, y
);
11234 EdwardsCurve
.prototype.validate
= function validate(point
) {
11235 if (point
.isInfinity())
11238 // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)
11241 var x2
= point
.x
.redSqr();
11242 var y2
= point
.y
.redSqr();
11243 var lhs
= x2
.redMul(this.a
).redAdd(y2
);
11244 var rhs
= this.c2
.redMul(this.one
.redAdd(this.d
.redMul(x2
).redMul(y2
)));
11246 return lhs
.cmp(rhs
) === 0;
11249 function Point(curve
, x
, y
, z
, t
) {
11250 Base
.BasePoint
.call(this, curve
, 'projective');
11251 if (x
=== null && y
=== null && z
=== null) {
11252 this.x
= this.curve
.zero
;
11253 this.y
= this.curve
.one
;
11254 this.z
= this.curve
.one
;
11255 this.t
= this.curve
.zero
;
11258 this.x
= new BN(x
, 16);
11259 this.y
= new BN(y
, 16);
11260 this.z
= z
? new BN(z
, 16) : this.curve
.one
;
11261 this.t
= t
&& new BN(t
, 16);
11263 this.x
= this.x
.toRed(this.curve
.red
);
11265 this.y
= this.y
.toRed(this.curve
.red
);
11267 this.z
= this.z
.toRed(this.curve
.red
);
11268 if (this.t
&& !this.t
.red
)
11269 this.t
= this.t
.toRed(this.curve
.red
);
11270 this.zOne
= this.z
=== this.curve
.one
;
11272 // Use extended coordinates
11273 if (this.curve
.extended
&& !this.t
) {
11274 this.t
= this.x
.redMul(this.y
);
11276 this.t
= this.t
.redMul(this.z
.redInvm());
11280 inherits(Point
, Base
.BasePoint
);
11282 EdwardsCurve
.prototype.pointFromJSON
= function pointFromJSON(obj
) {
11283 return Point
.fromJSON(this, obj
);
11286 EdwardsCurve
.prototype.point
= function point(x
, y
, z
, t
) {
11287 return new Point(this, x
, y
, z
, t
);
11290 Point
.fromJSON
= function fromJSON(curve
, obj
) {
11291 return new Point(curve
, obj
[0], obj
[1], obj
[2]);
11294 Point
.prototype.inspect
= function inspect() {
11295 if (this.isInfinity())
11296 return '<EC Point Infinity>';
11297 return '<EC Point x: ' + this.x
.fromRed().toString(16, 2) +
11298 ' y: ' + this.y
.fromRed().toString(16, 2) +
11299 ' z: ' + this.z
.fromRed().toString(16, 2) + '>';
11302 Point
.prototype.isInfinity
= function isInfinity() {
11303 // XXX This code assumes that zero is always zero in red
11304 return this.x
.cmpn(0) === 0 &&
11305 this.y
.cmp(this.z
) === 0;
11308 Point
.prototype._extDbl
= function _extDbl() {
11309 // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
11310 // #doubling-dbl-2008-hwcd
11314 var a
= this.x
.redSqr();
11316 var b
= this.y
.redSqr();
11318 var c
= this.z
.redSqr();
11321 var d
= this.curve
._mulA(a
);
11322 // E = (X1 + Y1)^2 - A - B
11323 var e
= this.x
.redAdd(this.y
).redSqr().redISub(a
).redISub(b
);
11325 var g
= d
.redAdd(b
);
11327 var f
= g
.redSub(c
);
11329 var h
= d
.redSub(b
);
11331 var nx
= e
.redMul(f
);
11333 var ny
= g
.redMul(h
);
11335 var nt
= e
.redMul(h
);
11337 var nz
= f
.redMul(g
);
11338 return this.curve
.point(nx
, ny
, nz
, nt
);
11341 Point
.prototype._projDbl
= function _projDbl() {
11342 // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
11343 // #doubling-dbl-2008-bbjlp
11344 // #doubling-dbl-2007-bl
11346 // Generally 3M + 4S or 2M + 4S
11349 var b
= this.x
.redAdd(this.y
).redSqr();
11351 var c
= this.x
.redSqr();
11353 var d
= this.y
.redSqr();
11358 if (this.curve
.twisted
) {
11360 var e
= this.curve
._mulA(c
);
11362 var f
= e
.redAdd(d
);
11364 // X3 = (B - C - D) * (F - 2)
11365 nx
= b
.redSub(c
).redSub(d
).redMul(f
.redSub(this.curve
.two
));
11366 // Y3 = F * (E - D)
11367 ny
= f
.redMul(e
.redSub(d
));
11368 // Z3 = F^2 - 2 * F
11369 nz
= f
.redSqr().redSub(f
).redSub(f
);
11372 var h
= this.z
.redSqr();
11374 var j
= f
.redSub(h
).redISub(h
);
11376 nx
= b
.redSub(c
).redISub(d
).redMul(j
);
11377 // Y3 = F * (E - D)
11378 ny
= f
.redMul(e
.redSub(d
));
11384 var e
= c
.redAdd(d
);
11386 var h
= this.curve
._mulC(this.c
.redMul(this.z
)).redSqr();
11388 var j
= e
.redSub(h
).redSub(h
);
11389 // X3 = c * (B - E) * J
11390 nx
= this.curve
._mulC(b
.redISub(e
)).redMul(j
);
11391 // Y3 = c * E * (C - D)
11392 ny
= this.curve
._mulC(e
).redMul(c
.redISub(d
));
11396 return this.curve
.point(nx
, ny
, nz
);
11399 Point
.prototype.dbl
= function dbl() {
11400 if (this.isInfinity())
11403 // Double in extended coordinates
11404 if (this.curve
.extended
)
11405 return this._extDbl();
11407 return this._projDbl();
11410 Point
.prototype._extAdd
= function _extAdd(p
) {
11411 // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
11412 // #addition-add-2008-hwcd-3
11415 // A = (Y1 - X1) * (Y2 - X2)
11416 var a
= this.y
.redSub(this.x
).redMul(p
.y
.redSub(p
.x
));
11417 // B = (Y1 + X1) * (Y2 + X2)
11418 var b
= this.y
.redAdd(this.x
).redMul(p
.y
.redAdd(p
.x
));
11420 var c
= this.t
.redMul(this.curve
.dd
).redMul(p
.t
);
11422 var d
= this.z
.redMul(p
.z
.redAdd(p
.z
));
11424 var e
= b
.redSub(a
);
11426 var f
= d
.redSub(c
);
11428 var g
= d
.redAdd(c
);
11430 var h
= b
.redAdd(a
);
11432 var nx
= e
.redMul(f
);
11434 var ny
= g
.redMul(h
);
11436 var nt
= e
.redMul(h
);
11438 var nz
= f
.redMul(g
);
11439 return this.curve
.point(nx
, ny
, nz
, nt
);
11442 Point
.prototype._projAdd
= function _projAdd(p
) {
11443 // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
11444 // #addition-add-2008-bbjlp
11445 // #addition-add-2007-bl
11449 var a
= this.z
.redMul(p
.z
);
11451 var b
= a
.redSqr();
11453 var c
= this.x
.redMul(p
.x
);
11455 var d
= this.y
.redMul(p
.y
);
11457 var e
= this.curve
.d
.redMul(c
).redMul(d
);
11459 var f
= b
.redSub(e
);
11461 var g
= b
.redAdd(e
);
11462 // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)
11463 var tmp
= this.x
.redAdd(this.y
).redMul(p
.x
.redAdd(p
.y
)).redISub(c
).redISub(d
);
11464 var nx
= a
.redMul(f
).redMul(tmp
);
11467 if (this.curve
.twisted
) {
11468 // Y3 = A * G * (D - a * C)
11469 ny
= a
.redMul(g
).redMul(d
.redSub(this.curve
._mulA(c
)));
11473 // Y3 = A * G * (D - C)
11474 ny
= a
.redMul(g
).redMul(d
.redSub(c
));
11476 nz
= this.curve
._mulC(f
).redMul(g
);
11478 return this.curve
.point(nx
, ny
, nz
);
11481 Point
.prototype.add
= function add(p
) {
11482 if (this.isInfinity())
11484 if (p
.isInfinity())
11487 if (this.curve
.extended
)
11488 return this._extAdd(p
);
11490 return this._projAdd(p
);
11493 Point
.prototype.mul
= function mul(k
) {
11494 if (this._hasDoubles(k
))
11495 return this.curve
._fixedNafMul(this, k
);
11497 return this.curve
._wnafMul(this, k
);
11500 Point
.prototype.mulAdd
= function mulAdd(k1
, p
, k2
) {
11501 return this.curve
._wnafMulAdd(1, [ this, p
], [ k1
, k2
], 2, false);
11504 Point
.prototype.jmulAdd
= function jmulAdd(k1
, p
, k2
) {
11505 return this.curve
._wnafMulAdd(1, [ this, p
], [ k1
, k2
], 2, true);
11508 Point
.prototype.normalize
= function normalize() {
11512 // Normalize coordinates
11513 var zi
= this.z
.redInvm();
11514 this.x
= this.x
.redMul(zi
);
11515 this.y
= this.y
.redMul(zi
);
11517 this.t
= this.t
.redMul(zi
);
11518 this.z
= this.curve
.one
;
11523 Point
.prototype.neg
= function neg() {
11524 return this.curve
.point(this.x
.redNeg(),
11527 this.t
&& this.t
.redNeg());
11530 Point
.prototype.getX
= function getX() {
11532 return this.x
.fromRed();
11535 Point
.prototype.getY
= function getY() {
11537 return this.y
.fromRed();
11540 Point
.prototype.eq
= function eq(other
) {
11541 return this === other
||
11542 this.getX().cmp(other
.getX()) === 0 &&
11543 this.getY().cmp(other
.getY()) === 0;
11546 Point
.prototype.eqXToP
= function eqXToP(x
) {
11547 var rx
= x
.toRed(this.curve
.red
).redMul(this.z
);
11548 if (this.x
.cmp(rx
) === 0)
11551 var xc
= x
.clone();
11552 var t
= this.curve
.redN
.redMul(this.z
);
11554 xc
.iadd(this.curve
.n
);
11555 if (xc
.cmp(this.curve
.p
) >= 0)
11559 if (this.x
.cmp(rx
) === 0)
11565 // Compatibility with BaseCurve
11566 Point
.prototype.toP
= Point
.prototype.normalize
;
11567 Point
.prototype.mixedAdd
= Point
.prototype.add
;
11569 },{"../../elliptic":39,"../curve":42,"bn.js":33,"inherits":63}],42:[function(require
,module
,exports
){
11572 var curve
= exports
;
11574 curve
.base
= require('./base');
11575 curve
.short = require('./short');
11576 curve
.mont
= require('./mont');
11577 curve
.edwards
= require('./edwards');
11579 },{"./base":40,"./edwards":41,"./mont":43,"./short":44}],43:[function(require
,module
,exports
){
11582 var curve
= require('../curve');
11583 var BN
= require('bn.js');
11584 var inherits
= require('inherits');
11585 var Base
= curve
.base
;
11587 var elliptic
= require('../../elliptic');
11588 var utils
= elliptic
.utils
;
11590 function MontCurve(conf
) {
11591 Base
.call(this, 'mont', conf
);
11593 this.a
= new BN(conf
.a
, 16).toRed(this.red
);
11594 this.b
= new BN(conf
.b
, 16).toRed(this.red
);
11595 this.i4
= new BN(4).toRed(this.red
).redInvm();
11596 this.two
= new BN(2).toRed(this.red
);
11597 this.a24
= this.i4
.redMul(this.a
.redAdd(this.two
));
11599 inherits(MontCurve
, Base
);
11600 module
.exports
= MontCurve
;
11602 MontCurve
.prototype.validate
= function validate(point
) {
11603 var x
= point
.normalize().x
;
11604 var x2
= x
.redSqr();
11605 var rhs
= x2
.redMul(x
).redAdd(x2
.redMul(this.a
)).redAdd(x
);
11606 var y
= rhs
.redSqrt();
11608 return y
.redSqr().cmp(rhs
) === 0;
11611 function Point(curve
, x
, z
) {
11612 Base
.BasePoint
.call(this, curve
, 'projective');
11613 if (x
=== null && z
=== null) {
11614 this.x
= this.curve
.one
;
11615 this.z
= this.curve
.zero
;
11617 this.x
= new BN(x
, 16);
11618 this.z
= new BN(z
, 16);
11620 this.x
= this.x
.toRed(this.curve
.red
);
11622 this.z
= this.z
.toRed(this.curve
.red
);
11625 inherits(Point
, Base
.BasePoint
);
11627 MontCurve
.prototype.decodePoint
= function decodePoint(bytes
, enc
) {
11628 return this.point(utils
.toArray(bytes
, enc
), 1);
11631 MontCurve
.prototype.point
= function point(x
, z
) {
11632 return new Point(this, x
, z
);
11635 MontCurve
.prototype.pointFromJSON
= function pointFromJSON(obj
) {
11636 return Point
.fromJSON(this, obj
);
11639 Point
.prototype.precompute
= function precompute() {
11643 Point
.prototype._encode
= function _encode() {
11644 return this.getX().toArray('be', this.curve
.p
.byteLength());
11647 Point
.fromJSON
= function fromJSON(curve
, obj
) {
11648 return new Point(curve
, obj
[0], obj
[1] || curve
.one
);
11651 Point
.prototype.inspect
= function inspect() {
11652 if (this.isInfinity())
11653 return '<EC Point Infinity>';
11654 return '<EC Point x: ' + this.x
.fromRed().toString(16, 2) +
11655 ' z: ' + this.z
.fromRed().toString(16, 2) + '>';
11658 Point
.prototype.isInfinity
= function isInfinity() {
11659 // XXX This code assumes that zero is always zero in red
11660 return this.z
.cmpn(0) === 0;
11663 Point
.prototype.dbl
= function dbl() {
11664 // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3
11668 var a
= this.x
.redAdd(this.z
);
11670 var aa
= a
.redSqr();
11672 var b
= this.x
.redSub(this.z
);
11674 var bb
= b
.redSqr();
11676 var c
= aa
.redSub(bb
);
11678 var nx
= aa
.redMul(bb
);
11679 // Z3 = C * (BB + A24 * C)
11680 var nz
= c
.redMul(bb
.redAdd(this.curve
.a24
.redMul(c
)));
11681 return this.curve
.point(nx
, nz
);
11684 Point
.prototype.add
= function add() {
11685 throw new Error('Not supported on Montgomery curve');
11688 Point
.prototype.diffAdd
= function diffAdd(p
, diff
) {
11689 // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3
11693 var a
= this.x
.redAdd(this.z
);
11695 var b
= this.x
.redSub(this.z
);
11697 var c
= p
.x
.redAdd(p
.z
);
11699 var d
= p
.x
.redSub(p
.z
);
11701 var da
= d
.redMul(a
);
11703 var cb
= c
.redMul(b
);
11704 // X5 = Z1 * (DA + CB)^2
11705 var nx
= diff
.z
.redMul(da
.redAdd(cb
).redSqr());
11706 // Z5 = X1 * (DA - CB)^2
11707 var nz
= diff
.x
.redMul(da
.redISub(cb
).redSqr());
11708 return this.curve
.point(nx
, nz
);
11711 Point
.prototype.mul
= function mul(k
) {
11713 var a
= this; // (N / 2) * Q + Q
11714 var b
= this.curve
.point(null, null); // (N / 2) * Q
11717 for (var bits
= []; t
.cmpn(0) !== 0; t
.iushrn(1))
11718 bits
.push(t
.andln(1));
11720 for (var i
= bits
.length
- 1; i
>= 0; i
--) {
11721 if (bits
[i
] === 0) {
11722 // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q
11723 a
= a
.diffAdd(b
, c
);
11724 // N * Q = 2 * ((N / 2) * Q + Q))
11727 // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)
11728 b
= a
.diffAdd(b
, c
);
11729 // N * Q + Q = 2 * ((N / 2) * Q + Q)
11736 Point
.prototype.mulAdd
= function mulAdd() {
11737 throw new Error('Not supported on Montgomery curve');
11740 Point
.prototype.jumlAdd
= function jumlAdd() {
11741 throw new Error('Not supported on Montgomery curve');
11744 Point
.prototype.eq
= function eq(other
) {
11745 return this.getX().cmp(other
.getX()) === 0;
11748 Point
.prototype.normalize
= function normalize() {
11749 this.x
= this.x
.redMul(this.z
.redInvm());
11750 this.z
= this.curve
.one
;
11754 Point
.prototype.getX
= function getX() {
11755 // Normalize coordinates
11758 return this.x
.fromRed();
11761 },{"../../elliptic":39,"../curve":42,"bn.js":33,"inherits":63}],44:[function(require
,module
,exports
){
11764 var curve
= require('../curve');
11765 var elliptic
= require('../../elliptic');
11766 var BN
= require('bn.js');
11767 var inherits
= require('inherits');
11768 var Base
= curve
.base
;
11770 var assert
= elliptic
.utils
.assert
;
11772 function ShortCurve(conf
) {
11773 Base
.call(this, 'short', conf
);
11775 this.a
= new BN(conf
.a
, 16).toRed(this.red
);
11776 this.b
= new BN(conf
.b
, 16).toRed(this.red
);
11777 this.tinv
= this.two
.redInvm();
11779 this.zeroA
= this.a
.fromRed().cmpn(0) === 0;
11780 this.threeA
= this.a
.fromRed().sub(this.p
).cmpn(-3) === 0;
11782 // If the curve is endomorphic, precalculate beta and lambda
11783 this.endo
= this._getEndomorphism(conf
);
11784 this._endoWnafT1
= new Array(4);
11785 this._endoWnafT2
= new Array(4);
11787 inherits(ShortCurve
, Base
);
11788 module
.exports
= ShortCurve
;
11790 ShortCurve
.prototype._getEndomorphism
= function _getEndomorphism(conf
) {
11791 // No efficient endomorphism
11792 if (!this.zeroA
|| !this.g
|| !this.n
|| this.p
.modn(3) !== 1)
11795 // Compute beta and lambda, that lambda * P = (beta * Px; Py)
11799 beta
= new BN(conf
.beta
, 16).toRed(this.red
);
11801 var betas
= this._getEndoRoots(this.p
);
11802 // Choose the smallest beta
11803 beta
= betas
[0].cmp(betas
[1]) < 0 ? betas
[0] : betas
[1];
11804 beta
= beta
.toRed(this.red
);
11807 lambda
= new BN(conf
.lambda
, 16);
11809 // Choose the lambda that is matching selected beta
11810 var lambdas
= this._getEndoRoots(this.n
);
11811 if (this.g
.mul(lambdas
[0]).x
.cmp(this.g
.x
.redMul(beta
)) === 0) {
11812 lambda
= lambdas
[0];
11814 lambda
= lambdas
[1];
11815 assert(this.g
.mul(lambda
).x
.cmp(this.g
.x
.redMul(beta
)) === 0);
11819 // Get basis vectors, used for balanced length-two representation
11822 basis
= conf
.basis
.map(function(vec
) {
11824 a: new BN(vec
.a
, 16),
11825 b: new BN(vec
.b
, 16)
11829 basis
= this._getEndoBasis(lambda
);
11839 ShortCurve
.prototype._getEndoRoots
= function _getEndoRoots(num
) {
11840 // Find roots of for x^2 + x + 1 in F
11841 // Root = (-1 +- Sqrt(-3)) / 2
11843 var red
= num
=== this.p
? this.red : BN
.mont(num
);
11844 var tinv
= new BN(2).toRed(red
).redInvm();
11845 var ntinv
= tinv
.redNeg();
11847 var s
= new BN(3).toRed(red
).redNeg().redSqrt().redMul(tinv
);
11849 var l1
= ntinv
.redAdd(s
).fromRed();
11850 var l2
= ntinv
.redSub(s
).fromRed();
11854 ShortCurve
.prototype._getEndoBasis
= function _getEndoBasis(lambda
) {
11855 // aprxSqrt >= sqrt(this.n)
11856 var aprxSqrt
= this.n
.ushrn(Math
.floor(this.n
.bitLength() / 2));
11859 // Run EGCD, until r(L + 1) < aprxSqrt
11861 var v
= this.n
.clone();
11862 var x1
= new BN(1);
11863 var y1
= new BN(0);
11864 var x2
= new BN(0);
11865 var y2
= new BN(1);
11867 // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)
11881 while (u
.cmpn(0) !== 0) {
11883 r
= v
.sub(q
.mul(u
));
11884 x
= x2
.sub(q
.mul(x1
));
11885 var y
= y2
.sub(q
.mul(y1
));
11887 if (!a1
&& r
.cmp(aprxSqrt
) < 0) {
11892 } else if (a1
&& ++i
=== 2) {
11907 var len1
= a1
.sqr().add(b1
.sqr());
11908 var len2
= a2
.sqr().add(b2
.sqr());
11909 if (len2
.cmp(len1
) >= 0) {
11930 ShortCurve
.prototype._endoSplit
= function _endoSplit(k
) {
11931 var basis
= this.endo
.basis
;
11935 var c1
= v2
.b
.mul(k
).divRound(this.n
);
11936 var c2
= v1
.b
.neg().mul(k
).divRound(this.n
);
11938 var p1
= c1
.mul(v1
.a
);
11939 var p2
= c2
.mul(v2
.a
);
11940 var q1
= c1
.mul(v1
.b
);
11941 var q2
= c2
.mul(v2
.b
);
11943 // Calculate answer
11944 var k1
= k
.sub(p1
).sub(p2
);
11945 var k2
= q1
.add(q2
).neg();
11946 return { k1: k1
, k2: k2
};
11949 ShortCurve
.prototype.pointFromX
= function pointFromX(x
, odd
) {
11952 x
= x
.toRed(this.red
);
11954 var y2
= x
.redSqr().redMul(x
).redIAdd(x
.redMul(this.a
)).redIAdd(this.b
);
11955 var y
= y2
.redSqrt();
11956 if (y
.redSqr().redSub(y2
).cmp(this.zero
) !== 0)
11957 throw new Error('invalid point');
11959 // XXX Is there any way to tell if the number is odd without converting it
11960 // to non-red form?
11961 var isOdd
= y
.fromRed().isOdd();
11962 if (odd
&& !isOdd
|| !odd
&& isOdd
)
11965 return this.point(x
, y
);
11968 ShortCurve
.prototype.validate
= function validate(point
) {
11975 var ax
= this.a
.redMul(x
);
11976 var rhs
= x
.redSqr().redMul(x
).redIAdd(ax
).redIAdd(this.b
);
11977 return y
.redSqr().redISub(rhs
).cmpn(0) === 0;
11980 ShortCurve
.prototype._endoWnafMulAdd
=
11981 function _endoWnafMulAdd(points
, coeffs
, jacobianResult
) {
11982 var npoints
= this._endoWnafT1
;
11983 var ncoeffs
= this._endoWnafT2
;
11984 for (var i
= 0; i
< points
.length
; i
++) {
11985 var split
= this._endoSplit(coeffs
[i
]);
11987 var beta
= p
._getBeta();
11989 if (split
.k1
.negative
) {
11993 if (split
.k2
.negative
) {
11995 beta
= beta
.neg(true);
11998 npoints
[i
* 2] = p
;
11999 npoints
[i
* 2 + 1] = beta
;
12000 ncoeffs
[i
* 2] = split
.k1
;
12001 ncoeffs
[i
* 2 + 1] = split
.k2
;
12003 var res
= this._wnafMulAdd(1, npoints
, ncoeffs
, i
* 2, jacobianResult
);
12005 // Clean-up references to points and coefficients
12006 for (var j
= 0; j
< i
* 2; j
++) {
12013 function Point(curve
, x
, y
, isRed
) {
12014 Base
.BasePoint
.call(this, curve
, 'affine');
12015 if (x
=== null && y
=== null) {
12020 this.x
= new BN(x
, 16);
12021 this.y
= new BN(y
, 16);
12022 // Force redgomery representation when loading from JSON
12024 this.x
.forceRed(this.curve
.red
);
12025 this.y
.forceRed(this.curve
.red
);
12028 this.x
= this.x
.toRed(this.curve
.red
);
12030 this.y
= this.y
.toRed(this.curve
.red
);
12034 inherits(Point
, Base
.BasePoint
);
12036 ShortCurve
.prototype.point
= function point(x
, y
, isRed
) {
12037 return new Point(this, x
, y
, isRed
);
12040 ShortCurve
.prototype.pointFromJSON
= function pointFromJSON(obj
, red
) {
12041 return Point
.fromJSON(this, obj
, red
);
12044 Point
.prototype._getBeta
= function _getBeta() {
12045 if (!this.curve
.endo
)
12048 var pre
= this.precomputed
;
12049 if (pre
&& pre
.beta
)
12052 var beta
= this.curve
.point(this.x
.redMul(this.curve
.endo
.beta
), this.y
);
12054 var curve
= this.curve
;
12055 var endoMul = function(p
) {
12056 return curve
.point(p
.x
.redMul(curve
.endo
.beta
), p
.y
);
12059 beta
.precomputed
= {
12063 points: pre
.naf
.points
.map(endoMul
)
12065 doubles: pre
.doubles
&& {
12066 step: pre
.doubles
.step
,
12067 points: pre
.doubles
.points
.map(endoMul
)
12074 Point
.prototype.toJSON
= function toJSON() {
12075 if (!this.precomputed
)
12076 return [ this.x
, this.y
];
12078 return [ this.x
, this.y
, this.precomputed
&& {
12079 doubles: this.precomputed
.doubles
&& {
12080 step: this.precomputed
.doubles
.step
,
12081 points: this.precomputed
.doubles
.points
.slice(1)
12083 naf: this.precomputed
.naf
&& {
12084 wnd: this.precomputed
.naf
.wnd
,
12085 points: this.precomputed
.naf
.points
.slice(1)
12090 Point
.fromJSON
= function fromJSON(curve
, obj
, red
) {
12091 if (typeof obj
=== 'string')
12092 obj
= JSON
.parse(obj
);
12093 var res
= curve
.point(obj
[0], obj
[1], red
);
12097 function obj2point(obj
) {
12098 return curve
.point(obj
[0], obj
[1], red
);
12102 res
.precomputed
= {
12104 doubles: pre
.doubles
&& {
12105 step: pre
.doubles
.step
,
12106 points: [ res
].concat(pre
.doubles
.points
.map(obj2point
))
12110 points: [ res
].concat(pre
.naf
.points
.map(obj2point
))
12116 Point
.prototype.inspect
= function inspect() {
12117 if (this.isInfinity())
12118 return '<EC Point Infinity>';
12119 return '<EC Point x: ' + this.x
.fromRed().toString(16, 2) +
12120 ' y: ' + this.y
.fromRed().toString(16, 2) + '>';
12123 Point
.prototype.isInfinity
= function isInfinity() {
12127 Point
.prototype.add
= function add(p
) {
12141 if (this.neg().eq(p
))
12142 return this.curve
.point(null, null);
12145 if (this.x
.cmp(p
.x
) === 0)
12146 return this.curve
.point(null, null);
12148 var c
= this.y
.redSub(p
.y
);
12149 if (c
.cmpn(0) !== 0)
12150 c
= c
.redMul(this.x
.redSub(p
.x
).redInvm());
12151 var nx
= c
.redSqr().redISub(this.x
).redISub(p
.x
);
12152 var ny
= c
.redMul(this.x
.redSub(nx
)).redISub(this.y
);
12153 return this.curve
.point(nx
, ny
);
12156 Point
.prototype.dbl
= function dbl() {
12161 var ys1
= this.y
.redAdd(this.y
);
12162 if (ys1
.cmpn(0) === 0)
12163 return this.curve
.point(null, null);
12165 var a
= this.curve
.a
;
12167 var x2
= this.x
.redSqr();
12168 var dyinv
= ys1
.redInvm();
12169 var c
= x2
.redAdd(x2
).redIAdd(x2
).redIAdd(a
).redMul(dyinv
);
12171 var nx
= c
.redSqr().redISub(this.x
.redAdd(this.x
));
12172 var ny
= c
.redMul(this.x
.redSub(nx
)).redISub(this.y
);
12173 return this.curve
.point(nx
, ny
);
12176 Point
.prototype.getX
= function getX() {
12177 return this.x
.fromRed();
12180 Point
.prototype.getY
= function getY() {
12181 return this.y
.fromRed();
12184 Point
.prototype.mul
= function mul(k
) {
12187 if (this._hasDoubles(k
))
12188 return this.curve
._fixedNafMul(this, k
);
12189 else if (this.curve
.endo
)
12190 return this.curve
._endoWnafMulAdd([ this ], [ k
]);
12192 return this.curve
._wnafMul(this, k
);
12195 Point
.prototype.mulAdd
= function mulAdd(k1
, p2
, k2
) {
12196 var points
= [ this, p2
];
12197 var coeffs
= [ k1
, k2
];
12198 if (this.curve
.endo
)
12199 return this.curve
._endoWnafMulAdd(points
, coeffs
);
12201 return this.curve
._wnafMulAdd(1, points
, coeffs
, 2);
12204 Point
.prototype.jmulAdd
= function jmulAdd(k1
, p2
, k2
) {
12205 var points
= [ this, p2
];
12206 var coeffs
= [ k1
, k2
];
12207 if (this.curve
.endo
)
12208 return this.curve
._endoWnafMulAdd(points
, coeffs
, true);
12210 return this.curve
._wnafMulAdd(1, points
, coeffs
, 2, true);
12213 Point
.prototype.eq
= function eq(p
) {
12214 return this === p
||
12215 this.inf
=== p
.inf
&&
12216 (this.inf
|| this.x
.cmp(p
.x
) === 0 && this.y
.cmp(p
.y
) === 0);
12219 Point
.prototype.neg
= function neg(_precompute
) {
12223 var res
= this.curve
.point(this.x
, this.y
.redNeg());
12224 if (_precompute
&& this.precomputed
) {
12225 var pre
= this.precomputed
;
12226 var negate = function(p
) {
12229 res
.precomputed
= {
12232 points: pre
.naf
.points
.map(negate
)
12234 doubles: pre
.doubles
&& {
12235 step: pre
.doubles
.step
,
12236 points: pre
.doubles
.points
.map(negate
)
12243 Point
.prototype.toJ
= function toJ() {
12245 return this.curve
.jpoint(null, null, null);
12247 var res
= this.curve
.jpoint(this.x
, this.y
, this.curve
.one
);
12251 function JPoint(curve
, x
, y
, z
) {
12252 Base
.BasePoint
.call(this, curve
, 'jacobian');
12253 if (x
=== null && y
=== null && z
=== null) {
12254 this.x
= this.curve
.one
;
12255 this.y
= this.curve
.one
;
12256 this.z
= new BN(0);
12258 this.x
= new BN(x
, 16);
12259 this.y
= new BN(y
, 16);
12260 this.z
= new BN(z
, 16);
12263 this.x
= this.x
.toRed(this.curve
.red
);
12265 this.y
= this.y
.toRed(this.curve
.red
);
12267 this.z
= this.z
.toRed(this.curve
.red
);
12269 this.zOne
= this.z
=== this.curve
.one
;
12271 inherits(JPoint
, Base
.BasePoint
);
12273 ShortCurve
.prototype.jpoint
= function jpoint(x
, y
, z
) {
12274 return new JPoint(this, x
, y
, z
);
12277 JPoint
.prototype.toP
= function toP() {
12278 if (this.isInfinity())
12279 return this.curve
.point(null, null);
12281 var zinv
= this.z
.redInvm();
12282 var zinv2
= zinv
.redSqr();
12283 var ax
= this.x
.redMul(zinv2
);
12284 var ay
= this.y
.redMul(zinv2
).redMul(zinv
);
12286 return this.curve
.point(ax
, ay
);
12289 JPoint
.prototype.neg
= function neg() {
12290 return this.curve
.jpoint(this.x
, this.y
.redNeg(), this.z
);
12293 JPoint
.prototype.add
= function add(p
) {
12295 if (this.isInfinity())
12299 if (p
.isInfinity())
12303 var pz2
= p
.z
.redSqr();
12304 var z2
= this.z
.redSqr();
12305 var u1
= this.x
.redMul(pz2
);
12306 var u2
= p
.x
.redMul(z2
);
12307 var s1
= this.y
.redMul(pz2
.redMul(p
.z
));
12308 var s2
= p
.y
.redMul(z2
.redMul(this.z
));
12310 var h
= u1
.redSub(u2
);
12311 var r
= s1
.redSub(s2
);
12312 if (h
.cmpn(0) === 0) {
12313 if (r
.cmpn(0) !== 0)
12314 return this.curve
.jpoint(null, null, null);
12319 var h2
= h
.redSqr();
12320 var h3
= h2
.redMul(h
);
12321 var v
= u1
.redMul(h2
);
12323 var nx
= r
.redSqr().redIAdd(h3
).redISub(v
).redISub(v
);
12324 var ny
= r
.redMul(v
.redISub(nx
)).redISub(s1
.redMul(h3
));
12325 var nz
= this.z
.redMul(p
.z
).redMul(h
);
12327 return this.curve
.jpoint(nx
, ny
, nz
);
12330 JPoint
.prototype.mixedAdd
= function mixedAdd(p
) {
12332 if (this.isInfinity())
12336 if (p
.isInfinity())
12340 var z2
= this.z
.redSqr();
12342 var u2
= p
.x
.redMul(z2
);
12344 var s2
= p
.y
.redMul(z2
).redMul(this.z
);
12346 var h
= u1
.redSub(u2
);
12347 var r
= s1
.redSub(s2
);
12348 if (h
.cmpn(0) === 0) {
12349 if (r
.cmpn(0) !== 0)
12350 return this.curve
.jpoint(null, null, null);
12355 var h2
= h
.redSqr();
12356 var h3
= h2
.redMul(h
);
12357 var v
= u1
.redMul(h2
);
12359 var nx
= r
.redSqr().redIAdd(h3
).redISub(v
).redISub(v
);
12360 var ny
= r
.redMul(v
.redISub(nx
)).redISub(s1
.redMul(h3
));
12361 var nz
= this.z
.redMul(h
);
12363 return this.curve
.jpoint(nx
, ny
, nz
);
12366 JPoint
.prototype.dblp
= function dblp(pow
) {
12369 if (this.isInfinity())
12374 if (this.curve
.zeroA
|| this.curve
.threeA
) {
12376 for (var i
= 0; i
< pow
; i
++)
12381 // 1M + 2S + 1A + N * (4S + 5M + 8A)
12382 // N = 1 => 6M + 6S + 9A
12383 var a
= this.curve
.a
;
12384 var tinv
= this.curve
.tinv
;
12389 var jz4
= jz
.redSqr().redSqr();
12392 var jyd
= jy
.redAdd(jy
);
12393 for (var i
= 0; i
< pow
; i
++) {
12394 var jx2
= jx
.redSqr();
12395 var jyd2
= jyd
.redSqr();
12396 var jyd4
= jyd2
.redSqr();
12397 var c
= jx2
.redAdd(jx2
).redIAdd(jx2
).redIAdd(a
.redMul(jz4
));
12399 var t1
= jx
.redMul(jyd2
);
12400 var nx
= c
.redSqr().redISub(t1
.redAdd(t1
));
12401 var t2
= t1
.redISub(nx
);
12402 var dny
= c
.redMul(t2
);
12403 dny
= dny
.redIAdd(dny
).redISub(jyd4
);
12404 var nz
= jyd
.redMul(jz
);
12406 jz4
= jz4
.redMul(jyd4
);
12413 return this.curve
.jpoint(jx
, jyd
.redMul(tinv
), jz
);
12416 JPoint
.prototype.dbl
= function dbl() {
12417 if (this.isInfinity())
12420 if (this.curve
.zeroA
)
12421 return this._zeroDbl();
12422 else if (this.curve
.threeA
)
12423 return this._threeDbl();
12425 return this._dbl();
12428 JPoint
.prototype._zeroDbl
= function _zeroDbl() {
12434 // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
12435 // #doubling-mdbl-2007-bl
12439 var xx
= this.x
.redSqr();
12441 var yy
= this.y
.redSqr();
12443 var yyyy
= yy
.redSqr();
12444 // S = 2 * ((X1 + YY)^2 - XX - YYYY)
12445 var s
= this.x
.redAdd(yy
).redSqr().redISub(xx
).redISub(yyyy
);
12447 // M = 3 * XX + a; a = 0
12448 var m
= xx
.redAdd(xx
).redIAdd(xx
);
12450 var t
= m
.redSqr().redISub(s
).redISub(s
);
12453 var yyyy8
= yyyy
.redIAdd(yyyy
);
12454 yyyy8
= yyyy8
.redIAdd(yyyy8
);
12455 yyyy8
= yyyy8
.redIAdd(yyyy8
);
12459 // Y3 = M * (S - T) - 8 * YYYY
12460 ny
= m
.redMul(s
.redISub(t
)).redISub(yyyy8
);
12462 nz
= this.y
.redAdd(this.y
);
12464 // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
12465 // #doubling-dbl-2009-l
12469 var a
= this.x
.redSqr();
12471 var b
= this.y
.redSqr();
12473 var c
= b
.redSqr();
12474 // D = 2 * ((X1 + B)^2 - A - C)
12475 var d
= this.x
.redAdd(b
).redSqr().redISub(a
).redISub(c
);
12478 var e
= a
.redAdd(a
).redIAdd(a
);
12480 var f
= e
.redSqr();
12483 var c8
= c
.redIAdd(c
);
12484 c8
= c8
.redIAdd(c8
);
12485 c8
= c8
.redIAdd(c8
);
12488 nx
= f
.redISub(d
).redISub(d
);
12489 // Y3 = E * (D - X3) - 8 * C
12490 ny
= e
.redMul(d
.redISub(nx
)).redISub(c8
);
12491 // Z3 = 2 * Y1 * Z1
12492 nz
= this.y
.redMul(this.z
);
12493 nz
= nz
.redIAdd(nz
);
12496 return this.curve
.jpoint(nx
, ny
, nz
);
12499 JPoint
.prototype._threeDbl
= function _threeDbl() {
12505 // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html
12506 // #doubling-mdbl-2007-bl
12510 var xx
= this.x
.redSqr();
12512 var yy
= this.y
.redSqr();
12514 var yyyy
= yy
.redSqr();
12515 // S = 2 * ((X1 + YY)^2 - XX - YYYY)
12516 var s
= this.x
.redAdd(yy
).redSqr().redISub(xx
).redISub(yyyy
);
12519 var m
= xx
.redAdd(xx
).redIAdd(xx
).redIAdd(this.curve
.a
);
12521 var t
= m
.redSqr().redISub(s
).redISub(s
);
12524 // Y3 = M * (S - T) - 8 * YYYY
12525 var yyyy8
= yyyy
.redIAdd(yyyy
);
12526 yyyy8
= yyyy8
.redIAdd(yyyy8
);
12527 yyyy8
= yyyy8
.redIAdd(yyyy8
);
12528 ny
= m
.redMul(s
.redISub(t
)).redISub(yyyy8
);
12530 nz
= this.y
.redAdd(this.y
);
12532 // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
12536 var delta
= this.z
.redSqr();
12538 var gamma
= this.y
.redSqr();
12539 // beta = X1 * gamma
12540 var beta
= this.x
.redMul(gamma
);
12541 // alpha = 3 * (X1 - delta) * (X1 + delta)
12542 var alpha
= this.x
.redSub(delta
).redMul(this.x
.redAdd(delta
));
12543 alpha
= alpha
.redAdd(alpha
).redIAdd(alpha
);
12544 // X3 = alpha^2 - 8 * beta
12545 var beta4
= beta
.redIAdd(beta
);
12546 beta4
= beta4
.redIAdd(beta4
);
12547 var beta8
= beta4
.redAdd(beta4
);
12548 nx
= alpha
.redSqr().redISub(beta8
);
12549 // Z3 = (Y1 + Z1)^2 - gamma - delta
12550 nz
= this.y
.redAdd(this.z
).redSqr().redISub(gamma
).redISub(delta
);
12551 // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2
12552 var ggamma8
= gamma
.redSqr();
12553 ggamma8
= ggamma8
.redIAdd(ggamma8
);
12554 ggamma8
= ggamma8
.redIAdd(ggamma8
);
12555 ggamma8
= ggamma8
.redIAdd(ggamma8
);
12556 ny
= alpha
.redMul(beta4
.redISub(nx
)).redISub(ggamma8
);
12559 return this.curve
.jpoint(nx
, ny
, nz
);
12562 JPoint
.prototype._dbl
= function _dbl() {
12563 var a
= this.curve
.a
;
12569 var jz4
= jz
.redSqr().redSqr();
12571 var jx2
= jx
.redSqr();
12572 var jy2
= jy
.redSqr();
12574 var c
= jx2
.redAdd(jx2
).redIAdd(jx2
).redIAdd(a
.redMul(jz4
));
12576 var jxd4
= jx
.redAdd(jx
);
12577 jxd4
= jxd4
.redIAdd(jxd4
);
12578 var t1
= jxd4
.redMul(jy2
);
12579 var nx
= c
.redSqr().redISub(t1
.redAdd(t1
));
12580 var t2
= t1
.redISub(nx
);
12582 var jyd8
= jy2
.redSqr();
12583 jyd8
= jyd8
.redIAdd(jyd8
);
12584 jyd8
= jyd8
.redIAdd(jyd8
);
12585 jyd8
= jyd8
.redIAdd(jyd8
);
12586 var ny
= c
.redMul(t2
).redISub(jyd8
);
12587 var nz
= jy
.redAdd(jy
).redMul(jz
);
12589 return this.curve
.jpoint(nx
, ny
, nz
);
12592 JPoint
.prototype.trpl
= function trpl() {
12593 if (!this.curve
.zeroA
)
12594 return this.dbl().add(this);
12596 // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl
12600 var xx
= this.x
.redSqr();
12602 var yy
= this.y
.redSqr();
12604 var zz
= this.z
.redSqr();
12606 var yyyy
= yy
.redSqr();
12607 // M = 3 * XX + a * ZZ2; a = 0
12608 var m
= xx
.redAdd(xx
).redIAdd(xx
);
12610 var mm
= m
.redSqr();
12611 // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM
12612 var e
= this.x
.redAdd(yy
).redSqr().redISub(xx
).redISub(yyyy
);
12614 e
= e
.redAdd(e
).redIAdd(e
);
12617 var ee
= e
.redSqr();
12619 var t
= yyyy
.redIAdd(yyyy
);
12623 // U = (M + E)^2 - MM - EE - T
12624 var u
= m
.redIAdd(e
).redSqr().redISub(mm
).redISub(ee
).redISub(t
);
12625 // X3 = 4 * (X1 * EE - 4 * YY * U)
12626 var yyu4
= yy
.redMul(u
);
12627 yyu4
= yyu4
.redIAdd(yyu4
);
12628 yyu4
= yyu4
.redIAdd(yyu4
);
12629 var nx
= this.x
.redMul(ee
).redISub(yyu4
);
12630 nx
= nx
.redIAdd(nx
);
12631 nx
= nx
.redIAdd(nx
);
12632 // Y3 = 8 * Y1 * (U * (T - U) - E * EE)
12633 var ny
= this.y
.redMul(u
.redMul(t
.redISub(u
)).redISub(e
.redMul(ee
)));
12634 ny
= ny
.redIAdd(ny
);
12635 ny
= ny
.redIAdd(ny
);
12636 ny
= ny
.redIAdd(ny
);
12637 // Z3 = (Z1 + E)^2 - ZZ - EE
12638 var nz
= this.z
.redAdd(e
).redSqr().redISub(zz
).redISub(ee
);
12640 return this.curve
.jpoint(nx
, ny
, nz
);
12643 JPoint
.prototype.mul
= function mul(k
, kbase
) {
12644 k
= new BN(k
, kbase
);
12646 return this.curve
._wnafMul(this, k
);
12649 JPoint
.prototype.eq
= function eq(p
) {
12650 if (p
.type
=== 'affine')
12651 return this.eq(p
.toJ());
12656 // x1 * z2^2 == x2 * z1^2
12657 var z2
= this.z
.redSqr();
12658 var pz2
= p
.z
.redSqr();
12659 if (this.x
.redMul(pz2
).redISub(p
.x
.redMul(z2
)).cmpn(0) !== 0)
12662 // y1 * z2^3 == y2 * z1^3
12663 var z3
= z2
.redMul(this.z
);
12664 var pz3
= pz2
.redMul(p
.z
);
12665 return this.y
.redMul(pz3
).redISub(p
.y
.redMul(z3
)).cmpn(0) === 0;
12668 JPoint
.prototype.eqXToP
= function eqXToP(x
) {
12669 var zs
= this.z
.redSqr();
12670 var rx
= x
.toRed(this.curve
.red
).redMul(zs
);
12671 if (this.x
.cmp(rx
) === 0)
12674 var xc
= x
.clone();
12675 var t
= this.curve
.redN
.redMul(zs
);
12677 xc
.iadd(this.curve
.n
);
12678 if (xc
.cmp(this.curve
.p
) >= 0)
12682 if (this.x
.cmp(rx
) === 0)
12688 JPoint
.prototype.inspect
= function inspect() {
12689 if (this.isInfinity())
12690 return '<EC JPoint Infinity>';
12691 return '<EC JPoint x: ' + this.x
.toString(16, 2) +
12692 ' y: ' + this.y
.toString(16, 2) +
12693 ' z: ' + this.z
.toString(16, 2) + '>';
12696 JPoint
.prototype.isInfinity
= function isInfinity() {
12697 // XXX This code assumes that zero is always zero in red
12698 return this.z
.cmpn(0) === 0;
12701 },{"../../elliptic":39,"../curve":42,"bn.js":33,"inherits":63}],45:[function(require
,module
,exports
){
12704 var curves
= exports
;
12706 var hash
= require('hash.js');
12707 var elliptic
= require('../elliptic');
12709 var assert
= elliptic
.utils
.assert
;
12711 function PresetCurve(options
) {
12712 if (options
.type
=== 'short')
12713 this.curve
= new elliptic
.curve
.short(options
);
12714 else if (options
.type
=== 'edwards')
12715 this.curve
= new elliptic
.curve
.edwards(options
);
12717 this.curve
= new elliptic
.curve
.mont(options
);
12718 this.g
= this.curve
.g
;
12719 this.n
= this.curve
.n
;
12720 this.hash
= options
.hash
;
12722 assert(this.g
.validate(), 'Invalid curve');
12723 assert(this.g
.mul(this.n
).isInfinity(), 'Invalid curve, G*N != O');
12725 curves
.PresetCurve
= PresetCurve
;
12727 function defineCurve(name
, options
) {
12728 Object
.defineProperty(curves
, name
, {
12729 configurable: true,
12732 var curve
= new PresetCurve(options
);
12733 Object
.defineProperty(curves
, name
, {
12734 configurable: true,
12743 defineCurve('p192', {
12746 p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',
12747 a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',
12748 b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',
12749 n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',
12753 '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',
12754 '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811'
12758 defineCurve('p224', {
12761 p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',
12762 a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',
12763 b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',
12764 n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',
12768 'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',
12769 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34'
12773 defineCurve('p256', {
12776 p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',
12777 a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',
12778 b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',
12779 n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',
12783 '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',
12784 '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5'
12788 defineCurve('p384', {
12791 p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
12792 'fffffffe ffffffff 00000000 00000000 ffffffff',
12793 a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
12794 'fffffffe ffffffff 00000000 00000000 fffffffc',
12795 b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +
12796 '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',
12797 n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +
12798 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',
12802 'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +
12803 '5502f25d bf55296c 3a545e38 72760ab7',
12804 '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +
12805 '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f'
12809 defineCurve('p521', {
12812 p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
12813 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
12814 'ffffffff ffffffff ffffffff ffffffff ffffffff',
12815 a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
12816 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
12817 'ffffffff ffffffff ffffffff ffffffff fffffffc',
12818 b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +
12819 '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +
12820 '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',
12821 n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
12822 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +
12823 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',
12827 '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +
12828 '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +
12829 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',
12830 '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +
12831 '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +
12832 '3fad0761 353c7086 a272c240 88be9476 9fd16650'
12836 defineCurve('curve25519', {
12839 p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
12842 n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
12850 defineCurve('ed25519', {
12853 p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
12856 // -121665 * (121666^(-1)) (mod P)
12857 d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',
12858 n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
12862 '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',
12865 '6666666666666666666666666666666666666666666666666666666666666658'
12871 pre
= require('./precomputed/secp256k1');
12876 defineCurve('secp256k1', {
12879 p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',
12882 n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',
12886 // Precomputed endomorphism
12887 beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
12888 lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
12891 a: '3086d221a7d46bcde86c90e49284eb15',
12892 b: '-e4437ed6010e88286f547fa90abfe4c3'
12895 a: '114ca50f7a8e2f3f657c1108d9d44cfd8',
12896 b: '3086d221a7d46bcde86c90e49284eb15'
12902 '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
12903 '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
12908 },{"../elliptic":39,"./precomputed/secp256k1":53,"hash.js":57}],46:[function(require
,module
,exports
){
12911 var BN
= require('bn.js');
12912 var elliptic
= require('../../elliptic');
12913 var utils
= elliptic
.utils
;
12914 var assert
= utils
.assert
;
12916 var KeyPair
= require('./key');
12917 var Signature
= require('./signature');
12919 function EC(options
) {
12920 if (!(this instanceof EC
))
12921 return new EC(options
);
12923 // Shortcut `elliptic.ec(curve-name)`
12924 if (typeof options
=== 'string') {
12925 assert(elliptic
.curves
.hasOwnProperty(options
), 'Unknown curve ' + options
);
12927 options
= elliptic
.curves
[options
];
12930 // Shortcut for `elliptic.ec(elliptic.curves.curveName)`
12931 if (options
instanceof elliptic
.curves
.PresetCurve
)
12932 options
= { curve: options
};
12934 this.curve
= options
.curve
.curve
;
12935 this.n
= this.curve
.n
;
12936 this.nh
= this.n
.ushrn(1);
12937 this.g
= this.curve
.g
;
12940 this.g
= options
.curve
.g
;
12941 this.g
.precompute(options
.curve
.n
.bitLength() + 1);
12943 // Hash for function for DRBG
12944 this.hash
= options
.hash
|| options
.curve
.hash
;
12946 module
.exports
= EC
;
12948 EC
.prototype.keyPair
= function keyPair(options
) {
12949 return new KeyPair(this, options
);
12952 EC
.prototype.keyFromPrivate
= function keyFromPrivate(priv
, enc
) {
12953 return KeyPair
.fromPrivate(this, priv
, enc
);
12956 EC
.prototype.keyFromPublic
= function keyFromPublic(pub
, enc
) {
12957 return KeyPair
.fromPublic(this, pub
, enc
);
12960 EC
.prototype.genKeyPair
= function genKeyPair(options
) {
12964 // Instantiate Hmac_DRBG
12965 var drbg
= new elliptic
.hmacDRBG({
12967 pers: options
.pers
,
12968 entropy: options
.entropy
|| elliptic
.rand(this.hash
.hmacStrength
),
12969 nonce: this.n
.toArray()
12972 var bytes
= this.n
.byteLength();
12973 var ns2
= this.n
.sub(new BN(2));
12975 var priv
= new BN(drbg
.generate(bytes
));
12976 if (priv
.cmp(ns2
) > 0)
12980 return this.keyFromPrivate(priv
);
12984 EC
.prototype._truncateToN
= function truncateToN(msg
, truncOnly
) {
12985 var delta
= msg
.byteLength() * 8 - this.n
.bitLength();
12987 msg
= msg
.ushrn(delta
);
12988 if (!truncOnly
&& msg
.cmp(this.n
) >= 0)
12989 return msg
.sub(this.n
);
12994 EC
.prototype.sign
= function sign(msg
, key
, enc
, options
) {
12995 if (typeof enc
=== 'object') {
13002 key
= this.keyFromPrivate(key
, enc
);
13003 msg
= this._truncateToN(new BN(msg
, 16));
13005 // Zero-extend key to provide enough entropy
13006 var bytes
= this.n
.byteLength();
13007 var bkey
= key
.getPrivate().toArray('be', bytes
);
13009 // Zero-extend nonce to have the same byte size as N
13010 var nonce
= msg
.toArray('be', bytes
);
13012 // Instantiate Hmac_DRBG
13013 var drbg
= new elliptic
.hmacDRBG({
13017 pers: options
.pers
,
13018 persEnc: options
.persEnc
13021 // Number of bytes to generate
13022 var ns1
= this.n
.sub(new BN(1));
13024 for (var iter
= 0; true; iter
++) {
13025 var k
= options
.k
?
13027 new BN(drbg
.generate(this.n
.byteLength()));
13028 k
= this._truncateToN(k
, true);
13029 if (k
.cmpn(1) <= 0 || k
.cmp(ns1
) >= 0)
13032 var kp
= this.g
.mul(k
);
13033 if (kp
.isInfinity())
13036 var kpX
= kp
.getX();
13037 var r
= kpX
.umod(this.n
);
13038 if (r
.cmpn(0) === 0)
13041 var s
= k
.invm(this.n
).mul(r
.mul(key
.getPrivate()).iadd(msg
));
13042 s
= s
.umod(this.n
);
13043 if (s
.cmpn(0) === 0)
13046 var recoveryParam
= (kp
.getY().isOdd() ? 1 : 0) |
13047 (kpX
.cmp(r
) !== 0 ? 2 : 0);
13049 // Use complement of `s`, if it is > `n / 2`
13050 if (options
.canonical
&& s
.cmp(this.nh
) > 0) {
13052 recoveryParam
^= 1;
13055 return new Signature({ r: r
, s: s
, recoveryParam: recoveryParam
});
13059 EC
.prototype.verify
= function verify(msg
, signature
, key
, enc
) {
13060 msg
= this._truncateToN(new BN(msg
, 16));
13061 key
= this.keyFromPublic(key
, enc
);
13062 signature
= new Signature(signature
, 'hex');
13064 // Perform primitive values validation
13065 var r
= signature
.r
;
13066 var s
= signature
.s
;
13067 if (r
.cmpn(1) < 0 || r
.cmp(this.n
) >= 0)
13069 if (s
.cmpn(1) < 0 || s
.cmp(this.n
) >= 0)
13072 // Validate signature
13073 var sinv
= s
.invm(this.n
);
13074 var u1
= sinv
.mul(msg
).umod(this.n
);
13075 var u2
= sinv
.mul(r
).umod(this.n
);
13077 if (!this.curve
._maxwellTrick
) {
13078 var p
= this.g
.mulAdd(u1
, key
.getPublic(), u2
);
13079 if (p
.isInfinity())
13082 return p
.getX().umod(this.n
).cmp(r
) === 0;
13085 // NOTE: Greg Maxwell's trick, inspired by:
13086 // https://git.io/vad3K
13088 var p
= this.g
.jmulAdd(u1
, key
.getPublic(), u2
);
13089 if (p
.isInfinity())
13092 // Compare `p.x` of Jacobian point with `r`,
13093 // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the
13094 // inverse of `p.z^2`
13095 return p
.eqXToP(r
);
13098 EC
.prototype.recoverPubKey = function(msg
, signature
, j
, enc
) {
13099 assert((3 & j
) === j
, 'The recovery param is more than two bits');
13100 signature
= new Signature(signature
, enc
);
13103 var e
= new BN(msg
);
13104 var r
= signature
.r
;
13105 var s
= signature
.s
;
13107 // A set LSB signifies that the y-coordinate is odd
13108 var isYOdd
= j
& 1;
13109 var isSecondKey
= j
>> 1;
13110 if (r
.cmp(this.curve
.p
.umod(this.curve
.n
)) >= 0 && isSecondKey
)
13111 throw new Error('Unable to find sencond key candinate');
13113 // 1.1. Let x = r + jn.
13115 r
= this.curve
.pointFromX(r
.add(this.curve
.n
), isYOdd
);
13117 r
= this.curve
.pointFromX(r
, isYOdd
);
13119 var rInv
= signature
.r
.invm(n
);
13120 var s1
= n
.sub(e
).mul(rInv
).umod(n
);
13121 var s2
= s
.mul(rInv
).umod(n
);
13123 // 1.6.1 Compute Q = r^-1 (sR - eG)
13124 // Q = r^-1 (sR + -eG)
13125 return this.g
.mulAdd(s1
, r
, s2
);
13128 EC
.prototype.getKeyRecoveryParam = function(e
, signature
, Q
, enc
) {
13129 signature
= new Signature(signature
, enc
);
13130 if (signature
.recoveryParam
!== null)
13131 return signature
.recoveryParam
;
13133 for (var i
= 0; i
< 4; i
++) {
13136 Qprime
= this.recoverPubKey(e
, signature
, i
);
13144 throw new Error('Unable to find valid recovery factor');
13147 },{"../../elliptic":39,"./key":47,"./signature":48,"bn.js":33}],47:[function(require
,module
,exports
){
13150 var BN
= require('bn.js');
13151 var elliptic
= require('../../elliptic');
13152 var utils
= elliptic
.utils
;
13153 var assert
= utils
.assert
;
13155 function KeyPair(ec
, options
) {
13160 // KeyPair(ec, { priv: ..., pub: ... })
13162 this._importPrivate(options
.priv
, options
.privEnc
);
13164 this._importPublic(options
.pub
, options
.pubEnc
);
13166 module
.exports
= KeyPair
;
13168 KeyPair
.fromPublic
= function fromPublic(ec
, pub
, enc
) {
13169 if (pub
instanceof KeyPair
)
13172 return new KeyPair(ec
, {
13178 KeyPair
.fromPrivate
= function fromPrivate(ec
, priv
, enc
) {
13179 if (priv
instanceof KeyPair
)
13182 return new KeyPair(ec
, {
13188 KeyPair
.prototype.validate
= function validate() {
13189 var pub
= this.getPublic();
13191 if (pub
.isInfinity())
13192 return { result: false, reason: 'Invalid public key' };
13193 if (!pub
.validate())
13194 return { result: false, reason: 'Public key is not a point' };
13195 if (!pub
.mul(this.ec
.curve
.n
).isInfinity())
13196 return { result: false, reason: 'Public key * N != O' };
13198 return { result: true, reason: null };
13201 KeyPair
.prototype.getPublic
= function getPublic(compact
, enc
) {
13202 // compact is optional argument
13203 if (typeof compact
=== 'string') {
13209 this.pub
= this.ec
.g
.mul(this.priv
);
13214 return this.pub
.encode(enc
, compact
);
13217 KeyPair
.prototype.getPrivate
= function getPrivate(enc
) {
13219 return this.priv
.toString(16, 2);
13224 KeyPair
.prototype._importPrivate
= function _importPrivate(key
, enc
) {
13225 this.priv
= new BN(key
, enc
|| 16);
13227 // Ensure that the priv won't be bigger than n, otherwise we may fail
13228 // in fixed multiplication method
13229 this.priv
= this.priv
.umod(this.ec
.curve
.n
);
13232 KeyPair
.prototype._importPublic
= function _importPublic(key
, enc
) {
13233 if (key
.x
|| key
.y
) {
13234 // Montgomery points only have an `x` coordinate.
13235 // Weierstrass/Edwards points on the other hand have both `x` and
13236 // `y` coordinates.
13237 if (this.ec
.curve
.type
=== 'mont') {
13238 assert(key
.x
, 'Need x coordinate');
13239 } else if (this.ec
.curve
.type
=== 'short' ||
13240 this.ec
.curve
.type
=== 'edwards') {
13241 assert(key
.x
&& key
.y
, 'Need both x and y coordinate');
13243 this.pub
= this.ec
.curve
.point(key
.x
, key
.y
);
13246 this.pub
= this.ec
.curve
.decodePoint(key
, enc
);
13250 KeyPair
.prototype.derive
= function derive(pub
) {
13251 return pub
.mul(this.priv
).getX();
13255 KeyPair
.prototype.sign
= function sign(msg
, enc
, options
) {
13256 return this.ec
.sign(msg
, this, enc
, options
);
13259 KeyPair
.prototype.verify
= function verify(msg
, signature
) {
13260 return this.ec
.verify(msg
, signature
, this);
13263 KeyPair
.prototype.inspect
= function inspect() {
13264 return '<Key priv: ' + (this.priv
&& this.priv
.toString(16, 2)) +
13265 ' pub: ' + (this.pub
&& this.pub
.inspect()) + ' >';
13268 },{"../../elliptic":39,"bn.js":33}],48:[function(require
,module
,exports
){
13271 var BN
= require('bn.js');
13273 var elliptic
= require('../../elliptic');
13274 var utils
= elliptic
.utils
;
13275 var assert
= utils
.assert
;
13277 function Signature(options
, enc
) {
13278 if (options
instanceof Signature
)
13281 if (this._importDER(options
, enc
))
13284 assert(options
.r
&& options
.s
, 'Signature without r or s');
13285 this.r
= new BN(options
.r
, 16);
13286 this.s
= new BN(options
.s
, 16);
13287 if (options
.recoveryParam
=== undefined)
13288 this.recoveryParam
= null;
13290 this.recoveryParam
= options
.recoveryParam
;
13292 module
.exports
= Signature
;
13294 function Position() {
13298 function getLength(buf
, p
) {
13299 var initial
= buf
[p
.place
++];
13300 if (!(initial
& 0x80)) {
13303 var octetLen
= initial
& 0xf;
13305 for (var i
= 0, off
= p
.place
; i
< octetLen
; i
++, off
++) {
13313 function rmPadding(buf
) {
13315 var len
= buf
.length
- 1;
13316 while (!buf
[i
] && !(buf
[i
+ 1] & 0x80) && i
< len
) {
13322 return buf
.slice(i
);
13325 Signature
.prototype._importDER
= function _importDER(data
, enc
) {
13326 data
= utils
.toArray(data
, enc
);
13327 var p
= new Position();
13328 if (data
[p
.place
++] !== 0x30) {
13331 var len
= getLength(data
, p
);
13332 if ((len
+ p
.place
) !== data
.length
) {
13335 if (data
[p
.place
++] !== 0x02) {
13338 var rlen
= getLength(data
, p
);
13339 var r
= data
.slice(p
.place
, rlen
+ p
.place
);
13341 if (data
[p
.place
++] !== 0x02) {
13344 var slen
= getLength(data
, p
);
13345 if (data
.length
!== slen
+ p
.place
) {
13348 var s
= data
.slice(p
.place
, slen
+ p
.place
);
13349 if (r
[0] === 0 && (r
[1] & 0x80)) {
13352 if (s
[0] === 0 && (s
[1] & 0x80)) {
13356 this.r
= new BN(r
);
13357 this.s
= new BN(s
);
13358 this.recoveryParam
= null;
13363 function constructLength(arr
, len
) {
13368 var octets
= 1 + (Math
.log(len
) / Math
.LN2
>>> 3);
13369 arr
.push(octets
| 0x80);
13371 arr
.push((len
>>> (octets
<< 3)) & 0xff);
13376 Signature
.prototype.toDER
= function toDER(enc
) {
13377 var r
= this.r
.toArray();
13378 var s
= this.s
.toArray();
13382 r
= [ 0 ].concat(r
);
13385 s
= [ 0 ].concat(s
);
13390 while (!s
[0] && !(s
[1] & 0x80)) {
13393 var arr
= [ 0x02 ];
13394 constructLength(arr
, r
.length
);
13395 arr
= arr
.concat(r
);
13397 constructLength(arr
, s
.length
);
13398 var backHalf
= arr
.concat(s
);
13399 var res
= [ 0x30 ];
13400 constructLength(res
, backHalf
.length
);
13401 res
= res
.concat(backHalf
);
13402 return utils
.encode(res
, enc
);
13405 },{"../../elliptic":39,"bn.js":33}],49:[function(require
,module
,exports
){
13408 var hash
= require('hash.js');
13409 var elliptic
= require('../../elliptic');
13410 var utils
= elliptic
.utils
;
13411 var assert
= utils
.assert
;
13412 var parseBytes
= utils
.parseBytes
;
13413 var KeyPair
= require('./key');
13414 var Signature
= require('./signature');
13416 function EDDSA(curve
) {
13417 assert(curve
=== 'ed25519', 'only tested with ed25519 so far');
13419 if (!(this instanceof EDDSA
))
13420 return new EDDSA(curve
);
13422 var curve
= elliptic
.curves
[curve
].curve
;
13423 this.curve
= curve
;
13425 this.g
.precompute(curve
.n
.bitLength() + 1);
13427 this.pointClass
= curve
.point().constructor;
13428 this.encodingLength
= Math
.ceil(curve
.n
.bitLength() / 8);
13429 this.hash
= hash
.sha512
;
13432 module
.exports
= EDDSA
;
13435 * @param {Array|String} message - message bytes
13436 * @param {Array|String|KeyPair} secret - secret bytes or a keypair
13437 * @returns {Signature} - signature
13439 EDDSA
.prototype.sign
= function sign(message
, secret
) {
13440 message
= parseBytes(message
);
13441 var key
= this.keyFromSecret(secret
);
13442 var r
= this.hashInt(key
.messagePrefix(), message
);
13443 var R
= this.g
.mul(r
);
13444 var Rencoded
= this.encodePoint(R
);
13445 var s_
= this.hashInt(Rencoded
, key
.pubBytes(), message
)
13447 var S
= r
.add(s_
).umod(this.curve
.n
);
13448 return this.makeSignature({ R: R
, S: S
, Rencoded: Rencoded
});
13452 * @param {Array} message - message bytes
13453 * @param {Array|String|Signature} sig - sig bytes
13454 * @param {Array|String|Point|KeyPair} pub - public key
13455 * @returns {Boolean} - true if public key matches sig of message
13457 EDDSA
.prototype.verify
= function verify(message
, sig
, pub
) {
13458 message
= parseBytes(message
);
13459 sig
= this.makeSignature(sig
);
13460 var key
= this.keyFromPublic(pub
);
13461 var h
= this.hashInt(sig
.Rencoded(), key
.pubBytes(), message
);
13462 var SG
= this.g
.mul(sig
.S());
13463 var RplusAh
= sig
.R().add(key
.pub().mul(h
));
13464 return RplusAh
.eq(SG
);
13467 EDDSA
.prototype.hashInt
= function hashInt() {
13468 var hash
= this.hash();
13469 for (var i
= 0; i
< arguments
.length
; i
++)
13470 hash
.update(arguments
[i
]);
13471 return utils
.intFromLE(hash
.digest()).umod(this.curve
.n
);
13474 EDDSA
.prototype.keyFromPublic
= function keyFromPublic(pub
) {
13475 return KeyPair
.fromPublic(this, pub
);
13478 EDDSA
.prototype.keyFromSecret
= function keyFromSecret(secret
) {
13479 return KeyPair
.fromSecret(this, secret
);
13482 EDDSA
.prototype.makeSignature
= function makeSignature(sig
) {
13483 if (sig
instanceof Signature
)
13485 return new Signature(this, sig
);
13489 * * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
13491 * EDDSA defines methods for encoding and decoding points and integers. These are
13492 * helper convenience methods, that pass along to utility functions implied
13496 EDDSA
.prototype.encodePoint
= function encodePoint(point
) {
13497 var enc
= point
.getY().toArray('le', this.encodingLength
);
13498 enc
[this.encodingLength
- 1] |= point
.getX().isOdd() ? 0x80 : 0;
13502 EDDSA
.prototype.decodePoint
= function decodePoint(bytes
) {
13503 bytes
= utils
.parseBytes(bytes
);
13505 var lastIx
= bytes
.length
- 1;
13506 var normed
= bytes
.slice(0, lastIx
).concat(bytes
[lastIx
] & ~0x80);
13507 var xIsOdd
= (bytes
[lastIx
] & 0x80) !== 0;
13509 var y
= utils
.intFromLE(normed
);
13510 return this.curve
.pointFromY(y
, xIsOdd
);
13513 EDDSA
.prototype.encodeInt
= function encodeInt(num
) {
13514 return num
.toArray('le', this.encodingLength
);
13517 EDDSA
.prototype.decodeInt
= function decodeInt(bytes
) {
13518 return utils
.intFromLE(bytes
);
13521 EDDSA
.prototype.isPoint
= function isPoint(val
) {
13522 return val
instanceof this.pointClass
;
13525 },{"../../elliptic":39,"./key":50,"./signature":51,"hash.js":57}],50:[function(require
,module
,exports
){
13528 var elliptic
= require('../../elliptic');
13529 var utils
= elliptic
.utils
;
13530 var assert
= utils
.assert
;
13531 var parseBytes
= utils
.parseBytes
;
13532 var cachedProperty
= utils
.cachedProperty
;
13535 * @param {EDDSA} eddsa - instance
13536 * @param {Object} params - public/private key parameters
13538 * @param {Array<Byte>} [params.secret] - secret seed bytes
13539 * @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
13540 * @param {Array<Byte>} [params.pub] - public key point encoded as bytes
13543 function KeyPair(eddsa
, params
) {
13544 this.eddsa
= eddsa
;
13545 this._secret
= parseBytes(params
.secret
);
13546 if (eddsa
.isPoint(params
.pub
))
13547 this._pub
= params
.pub
;
13549 this._pubBytes
= parseBytes(params
.pub
);
13552 KeyPair
.fromPublic
= function fromPublic(eddsa
, pub
) {
13553 if (pub
instanceof KeyPair
)
13555 return new KeyPair(eddsa
, { pub: pub
});
13558 KeyPair
.fromSecret
= function fromSecret(eddsa
, secret
) {
13559 if (secret
instanceof KeyPair
)
13561 return new KeyPair(eddsa
, { secret: secret
});
13564 KeyPair
.prototype.secret
= function secret() {
13565 return this._secret
;
13568 cachedProperty(KeyPair
, 'pubBytes', function pubBytes() {
13569 return this.eddsa
.encodePoint(this.pub());
13572 cachedProperty(KeyPair
, 'pub', function pub() {
13573 if (this._pubBytes
)
13574 return this.eddsa
.decodePoint(this._pubBytes
);
13575 return this.eddsa
.g
.mul(this.priv());
13578 cachedProperty(KeyPair
, 'privBytes', function privBytes() {
13579 var eddsa
= this.eddsa
;
13580 var hash
= this.hash();
13581 var lastIx
= eddsa
.encodingLength
- 1;
13583 var a
= hash
.slice(0, eddsa
.encodingLength
);
13591 cachedProperty(KeyPair
, 'priv', function priv() {
13592 return this.eddsa
.decodeInt(this.privBytes());
13595 cachedProperty(KeyPair
, 'hash', function hash() {
13596 return this.eddsa
.hash().update(this.secret()).digest();
13599 cachedProperty(KeyPair
, 'messagePrefix', function messagePrefix() {
13600 return this.hash().slice(this.eddsa
.encodingLength
);
13603 KeyPair
.prototype.sign
= function sign(message
) {
13604 assert(this._secret
, 'KeyPair can only verify');
13605 return this.eddsa
.sign(message
, this);
13608 KeyPair
.prototype.verify
= function verify(message
, sig
) {
13609 return this.eddsa
.verify(message
, sig
, this);
13612 KeyPair
.prototype.getSecret
= function getSecret(enc
) {
13613 assert(this._secret
, 'KeyPair is public only');
13614 return utils
.encode(this.secret(), enc
);
13617 KeyPair
.prototype.getPublic
= function getPublic(enc
) {
13618 return utils
.encode(this.pubBytes(), enc
);
13621 module
.exports
= KeyPair
;
13623 },{"../../elliptic":39}],51:[function(require
,module
,exports
){
13626 var BN
= require('bn.js');
13627 var elliptic
= require('../../elliptic');
13628 var utils
= elliptic
.utils
;
13629 var assert
= utils
.assert
;
13630 var cachedProperty
= utils
.cachedProperty
;
13631 var parseBytes
= utils
.parseBytes
;
13634 * @param {EDDSA} eddsa - eddsa instance
13635 * @param {Array<Bytes>|Object} sig -
13636 * @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
13637 * @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
13638 * @param {Array<Bytes>} [sig.Rencoded] - R point encoded
13639 * @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
13641 function Signature(eddsa
, sig
) {
13642 this.eddsa
= eddsa
;
13644 if (typeof sig
!== 'object')
13645 sig
= parseBytes(sig
);
13647 if (Array
.isArray(sig
)) {
13649 R: sig
.slice(0, eddsa
.encodingLength
),
13650 S: sig
.slice(eddsa
.encodingLength
)
13654 assert(sig
.R
&& sig
.S
, 'Signature without R or S');
13656 if (eddsa
.isPoint(sig
.R
))
13658 if (sig
.S
instanceof BN
)
13661 this._Rencoded
= Array
.isArray(sig
.R
) ? sig
.R : sig
.Rencoded
;
13662 this._Sencoded
= Array
.isArray(sig
.S
) ? sig
.S : sig
.Sencoded
;
13665 cachedProperty(Signature
, 'S', function S() {
13666 return this.eddsa
.decodeInt(this.Sencoded());
13669 cachedProperty(Signature
, 'R', function R() {
13670 return this.eddsa
.decodePoint(this.Rencoded());
13673 cachedProperty(Signature
, 'Rencoded', function Rencoded() {
13674 return this.eddsa
.encodePoint(this.R());
13677 cachedProperty(Signature
, 'Sencoded', function Sencoded() {
13678 return this.eddsa
.encodeInt(this.S());
13681 Signature
.prototype.toBytes
= function toBytes() {
13682 return this.Rencoded().concat(this.Sencoded());
13685 Signature
.prototype.toHex
= function toHex() {
13686 return utils
.encode(this.toBytes(), 'hex').toUpperCase();
13689 module
.exports
= Signature
;
13691 },{"../../elliptic":39,"bn.js":33}],52:[function(require
,module
,exports
){
13694 var hash
= require('hash.js');
13695 var elliptic
= require('../elliptic');
13696 var utils
= elliptic
.utils
;
13697 var assert
= utils
.assert
;
13699 function HmacDRBG(options
) {
13700 if (!(this instanceof HmacDRBG
))
13701 return new HmacDRBG(options
);
13702 this.hash
= options
.hash
;
13703 this.predResist
= !!options
.predResist
;
13705 this.outLen
= this.hash
.outSize
;
13706 this.minEntropy
= options
.minEntropy
|| this.hash
.hmacStrength
;
13708 this.reseed
= null;
13709 this.reseedInterval
= null;
13713 var entropy
= utils
.toArray(options
.entropy
, options
.entropyEnc
);
13714 var nonce
= utils
.toArray(options
.nonce
, options
.nonceEnc
);
13715 var pers
= utils
.toArray(options
.pers
, options
.persEnc
);
13716 assert(entropy
.length
>= (this.minEntropy
/ 8),
13717 'Not enough entropy. Minimum is: ' + this.minEntropy
+ ' bits');
13718 this._init(entropy
, nonce
, pers
);
13720 module
.exports
= HmacDRBG
;
13722 HmacDRBG
.prototype._init
= function init(entropy
, nonce
, pers
) {
13723 var seed
= entropy
.concat(nonce
).concat(pers
);
13725 this.K
= new Array(this.outLen
/ 8);
13726 this.V
= new Array(this.outLen
/ 8);
13727 for (var i
= 0; i
< this.V
.length
; i
++) {
13732 this._update(seed
);
13734 this.reseedInterval
= 0x1000000000000; // 2^48
13737 HmacDRBG
.prototype._hmac
= function hmac() {
13738 return new hash
.hmac(this.hash
, this.K
);
13741 HmacDRBG
.prototype._update
= function update(seed
) {
13742 var kmac
= this._hmac()
13746 kmac
= kmac
.update(seed
);
13747 this.K
= kmac
.digest();
13748 this.V
= this._hmac().update(this.V
).digest();
13752 this.K
= this._hmac()
13757 this.V
= this._hmac().update(this.V
).digest();
13760 HmacDRBG
.prototype.reseed
= function reseed(entropy
, entropyEnc
, add
, addEnc
) {
13761 // Optional entropy enc
13762 if (typeof entropyEnc
!== 'string') {
13768 entropy
= utils
.toBuffer(entropy
, entropyEnc
);
13769 add
= utils
.toBuffer(add
, addEnc
);
13771 assert(entropy
.length
>= (this.minEntropy
/ 8),
13772 'Not enough entropy. Minimum is: ' + this.minEntropy
+ ' bits');
13774 this._update(entropy
.concat(add
|| []));
13778 HmacDRBG
.prototype.generate
= function generate(len
, enc
, add
, addEnc
) {
13779 if (this.reseed
> this.reseedInterval
)
13780 throw new Error('Reseed is required');
13782 // Optional encoding
13783 if (typeof enc
!== 'string') {
13789 // Optional additional data
13791 add
= utils
.toArray(add
, addEnc
);
13796 while (temp
.length
< len
) {
13797 this.V
= this._hmac().update(this.V
).digest();
13798 temp
= temp
.concat(this.V
);
13801 var res
= temp
.slice(0, len
);
13804 return utils
.encode(res
, enc
);
13807 },{"../elliptic":39,"hash.js":57}],53:[function(require
,module
,exports
){
13813 'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a',
13814 'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'
13817 '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508',
13818 '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'
13821 '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739',
13822 'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'
13825 '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640',
13826 '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'
13829 '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c',
13830 '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'
13833 '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda',
13834 '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'
13837 'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa',
13838 '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'
13841 '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0',
13842 'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'
13845 'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d',
13846 '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'
13849 'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d',
13850 'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'
13853 'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1',
13854 '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'
13857 '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0',
13858 '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'
13861 '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047',
13862 '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'
13865 '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862',
13866 '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'
13869 '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7',
13870 '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'
13873 '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd',
13874 '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'
13877 '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83',
13878 '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'
13881 '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a',
13882 '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'
13885 '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8',
13886 'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'
13889 'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d',
13890 '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'
13893 'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725',
13894 '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'
13897 '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754',
13898 '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'
13901 '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c',
13902 '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'
13905 'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6',
13906 '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'
13909 '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39',
13910 'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'
13913 'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891',
13914 '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'
13917 'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b',
13918 'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'
13921 'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03',
13922 '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'
13925 'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d',
13926 'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'
13929 'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070',
13930 '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'
13933 '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4',
13934 'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'
13937 '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da',
13938 '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'
13941 'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11',
13942 '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'
13945 '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e',
13946 'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'
13949 'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41',
13950 '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'
13953 'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef',
13954 '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'
13957 'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8',
13958 'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'
13961 '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d',
13962 '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'
13965 '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96',
13966 '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'
13969 '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd',
13970 'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'
13973 '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5',
13974 '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'
13977 'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266',
13978 '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'
13981 '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71',
13982 '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'
13985 '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac',
13986 'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'
13989 '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751',
13990 '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'
13993 'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e',
13994 '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'
13997 '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241',
13998 'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'
14001 'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3',
14002 'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'
14005 'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f',
14006 '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'
14009 '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19',
14010 'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'
14013 '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be',
14014 'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'
14017 'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9',
14018 '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'
14021 'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2',
14022 '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'
14025 'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13',
14026 '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'
14029 '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c',
14030 'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'
14033 '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba',
14034 '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'
14037 'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151',
14038 'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'
14041 '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073',
14042 'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'
14045 '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458',
14046 '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'
14049 '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b',
14050 '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'
14053 'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366',
14054 'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'
14057 '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa',
14058 '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'
14061 '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0',
14062 '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'
14065 'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787',
14066 '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'
14069 'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e',
14070 'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82'
14078 'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',
14079 '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'
14082 '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4',
14083 'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'
14086 '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc',
14087 '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'
14090 'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe',
14091 'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'
14094 '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb',
14095 'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'
14098 'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8',
14099 'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'
14102 'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e',
14103 '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'
14106 'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34',
14107 '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'
14110 '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c',
14111 '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'
14114 '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5',
14115 '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'
14118 '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f',
14119 '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'
14122 '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714',
14123 '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'
14126 'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729',
14127 'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'
14130 'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db',
14131 '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'
14134 '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4',
14135 'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'
14138 '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5',
14139 'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'
14142 '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479',
14143 '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'
14146 '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d',
14147 '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'
14150 '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f',
14151 '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'
14154 '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb',
14155 'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'
14158 'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9',
14159 'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'
14162 '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963',
14163 '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'
14166 '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74',
14167 '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'
14170 'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530',
14171 'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'
14174 '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b',
14175 '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'
14178 'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247',
14179 'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'
14182 'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1',
14183 'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'
14186 '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120',
14187 '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'
14190 '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435',
14191 '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'
14194 '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18',
14195 '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'
14198 'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8',
14199 '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'
14202 '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb',
14203 '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'
14206 'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f',
14207 '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'
14210 '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143',
14211 'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'
14214 '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba',
14215 'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'
14218 'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45',
14219 'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'
14222 '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a',
14223 '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'
14226 '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e',
14227 'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'
14230 'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8',
14231 'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'
14234 '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c',
14235 '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'
14238 '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519',
14239 'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'
14242 '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab',
14243 '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'
14246 '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca',
14247 'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'
14250 'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf',
14251 '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'
14254 '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610',
14255 '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'
14258 '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4',
14259 'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'
14262 '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c',
14263 'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'
14266 'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940',
14267 'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'
14270 'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980',
14271 'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'
14274 '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3',
14275 '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'
14278 '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf',
14279 '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'
14282 'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63',
14283 '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'
14286 'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448',
14287 'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'
14290 '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf',
14291 '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'
14294 '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5',
14295 '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'
14298 'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6',
14299 '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'
14302 '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5',
14303 '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'
14306 'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99',
14307 'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'
14310 '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51',
14311 'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'
14314 '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5',
14315 '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'
14318 'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5',
14319 '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'
14322 'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997',
14323 '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'
14326 '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881',
14327 '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'
14330 '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5',
14331 '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'
14334 '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66',
14335 'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'
14338 '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726',
14339 'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'
14342 '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede',
14343 '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'
14346 '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94',
14347 '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'
14350 '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31',
14351 '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'
14354 '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51',
14355 'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'
14358 'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252',
14359 'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'
14362 '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5',
14363 'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'
14366 'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b',
14367 '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'
14370 'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4',
14371 '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'
14374 'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f',
14375 '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'
14378 'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889',
14379 '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'
14382 '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246',
14383 'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'
14386 '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984',
14387 '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'
14390 '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a',
14391 'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'
14394 'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030',
14395 'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'
14398 'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197',
14399 '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'
14402 'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593',
14403 'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'
14406 'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef',
14407 '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'
14410 '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38',
14411 '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'
14414 'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a',
14415 '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'
14418 'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111',
14419 '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'
14422 '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502',
14423 '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'
14426 '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea',
14427 'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'
14430 'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26',
14431 '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'
14434 'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986',
14435 '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'
14438 'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e',
14439 '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'
14442 '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4',
14443 '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'
14446 'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda',
14447 'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'
14450 '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859',
14451 'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'
14454 'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f',
14455 'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'
14458 'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c',
14459 '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'
14462 '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942',
14463 'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'
14466 'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a',
14467 '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'
14470 'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80',
14471 '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'
14474 'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d',
14475 '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'
14478 '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1',
14479 'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'
14482 '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63',
14483 'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'
14486 'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352',
14487 '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'
14490 '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193',
14491 'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'
14494 '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00',
14495 '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'
14498 '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58',
14499 'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'
14502 'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7',
14503 'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'
14506 '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8',
14507 'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'
14510 '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e',
14511 '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'
14514 '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d',
14515 'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'
14518 '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b',
14519 '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'
14522 'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f',
14523 'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'
14526 '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6',
14527 '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'
14530 'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297',
14531 '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'
14534 '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a',
14535 '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'
14538 'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c',
14539 'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'
14542 'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52',
14543 '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'
14546 'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb',
14547 'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'
14550 '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065',
14551 'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'
14554 '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917',
14555 '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'
14558 '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9',
14559 'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'
14562 '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3',
14563 '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'
14566 '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57',
14567 '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'
14570 '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66',
14571 'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'
14574 '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8',
14575 '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'
14578 '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721',
14579 '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'
14582 '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180',
14583 '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9'
14589 },{}],54:[function(require
,module
,exports
){
14592 var utils
= exports
;
14593 var BN
= require('bn.js');
14595 utils
.assert
= function assert(val
, msg
) {
14597 throw new Error(msg
|| 'Assertion failed');
14600 function toArray(msg
, enc
) {
14601 if (Array
.isArray(msg
))
14602 return msg
.slice();
14606 if (typeof msg
!== 'string') {
14607 for (var i
= 0; i
< msg
.length
; i
++)
14608 res
[i
] = msg
[i
] | 0;
14612 for (var i
= 0; i
< msg
.length
; i
++) {
14613 var c
= msg
.charCodeAt(i
);
14621 } else if (enc
=== 'hex') {
14622 msg
= msg
.replace(/[^a-z0-9]+/ig, '');
14623 if (msg
.length
% 2 !== 0)
14625 for (var i
= 0; i
< msg
.length
; i
+= 2)
14626 res
.push(parseInt(msg
[i
] + msg
[i
+ 1], 16));
14630 utils
.toArray
= toArray
;
14632 function zero2(word
) {
14633 if (word
.length
=== 1)
14638 utils
.zero2
= zero2
;
14640 function toHex(msg
) {
14642 for (var i
= 0; i
< msg
.length
; i
++)
14643 res
+= zero2(msg
[i
].toString(16));
14646 utils
.toHex
= toHex
;
14648 utils
.encode
= function encode(arr
, enc
) {
14655 // Represent num in a w-NAF form
14656 function getNAF(num
, w
) {
14658 var ws
= 1 << (w
+ 1);
14659 var k
= num
.clone();
14660 while (k
.cmpn(1) >= 0) {
14663 var mod
= k
.andln(ws
- 1);
14664 if (mod
> (ws
>> 1) - 1)
14665 z
= (ws
>> 1) - mod
;
14674 // Optimization, shift by word if possible
14675 var shift
= (k
.cmpn(0) !== 0 && k
.andln(ws
- 1) === 0) ? (w
+ 1) : 1;
14676 for (var i
= 1; i
< shift
; i
++)
14683 utils
.getNAF
= getNAF
;
14685 // Represent k1, k2 in a Joint Sparse Form
14686 function getJSF(k1
, k2
) {
14696 while (k1
.cmpn(-d1
) > 0 || k2
.cmpn(-d2
) > 0) {
14699 var m14
= (k1
.andln(3) + d1
) & 3;
14700 var m24
= (k2
.andln(3) + d2
) & 3;
14706 if ((m14
& 1) === 0) {
14709 var m8
= (k1
.andln(7) + d1
) & 7;
14710 if ((m8
=== 3 || m8
=== 5) && m24
=== 2)
14718 if ((m24
& 1) === 0) {
14721 var m8
= (k2
.andln(7) + d2
) & 7;
14722 if ((m8
=== 3 || m8
=== 5) && m14
=== 2)
14730 if (2 * d1
=== u1
+ 1)
14732 if (2 * d2
=== u2
+ 1)
14740 utils
.getJSF
= getJSF
;
14742 function cachedProperty(obj
, name
, computer
) {
14743 var key
= '_' + name
;
14744 obj
.prototype[name
] = function cachedProperty() {
14745 return this[key
] !== undefined ? this[key
] :
14746 this[key
] = computer
.call(this);
14749 utils
.cachedProperty
= cachedProperty
;
14751 function parseBytes(bytes
) {
14752 return typeof bytes
=== 'string' ? utils
.toArray(bytes
, 'hex') :
14755 utils
.parseBytes
= parseBytes
;
14757 function intFromLE(bytes
) {
14758 return new BN(bytes
, 'hex', 'le');
14760 utils
.intFromLE
= intFromLE
;
14763 },{"bn.js":33}],55:[function(require
,module
,exports
){
14768 "raw": "elliptic@^6.2.3",
14770 "escapedName": "elliptic",
14771 "name": "elliptic",
14772 "rawSpec": "^6.2.3",
14773 "spec": ">=6.2.3 <7.0.0",
14776 "/home/user/ethereum/ethereumjs-util/node_modules/secp256k1"
14779 "_from": "elliptic@>=6.2.3 <7.0.0",
14780 "_id": "elliptic@6.3.3",
14782 "_location": "/elliptic",
14783 "_nodeVersion": "7.0.0",
14784 "_npmOperationalInternal": {
14785 "host": "packages-18-east.internal.npmjs.com",
14786 "tmp": "tmp/elliptic-6.3.3.tgz_1486422837740_0.10658654430881143"
14790 "email": "fedor@indutny.com"
14792 "_npmVersion": "3.10.8",
14793 "_phantomChildren": {},
14795 "raw": "elliptic@^6.2.3",
14797 "escapedName": "elliptic",
14798 "name": "elliptic",
14799 "rawSpec": "^6.2.3",
14800 "spec": ">=6.2.3 <7.0.0",
14804 "/browserify-sign",
14808 "_resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.3.3.tgz",
14809 "_shasum": "5482d9646d54bcb89fd7d994fc9e2e9568876e3f",
14810 "_shrinkwrap": null,
14811 "_spec": "elliptic@^6.2.3",
14812 "_where": "/home/user/ethereum/ethereumjs-util/node_modules/secp256k1",
14814 "name": "Fedor Indutny",
14815 "email": "fedor@indutny.com"
14818 "url": "https://github.com/indutny/elliptic/issues"
14822 "brorand": "^1.0.1",
14823 "hash.js": "^1.0.0",
14824 "inherits": "^2.0.1"
14826 "description": "EC cryptography",
14827 "devDependencies": {
14829 "coveralls": "^2.11.3",
14831 "grunt-browserify": "^5.0.0",
14832 "grunt-cli": "^1.2.0",
14833 "grunt-contrib-connect": "^1.0.0",
14834 "grunt-contrib-copy": "^1.0.0",
14835 "grunt-contrib-uglify": "^1.0.1",
14836 "grunt-mocha-istanbul": "^3.0.1",
14837 "grunt-saucelabs": "^8.6.2",
14838 "istanbul": "^0.4.2",
14840 "jshint": "^2.6.0",
14845 "shasum": "5482d9646d54bcb89fd7d994fc9e2e9568876e3f",
14846 "tarball": "https://registry.npmjs.org/elliptic/-/elliptic-6.3.3.tgz"
14851 "gitHead": "63aee8d697e9b7fac37ece24222029117a890a7e",
14852 "homepage": "https://github.com/indutny/elliptic",
14860 "main": "lib/elliptic.js",
14864 "email": "fedor@indutny.com"
14867 "name": "elliptic",
14868 "optionalDependencies": {},
14869 "readme": "ERROR: No README data found!",
14872 "url": "git+ssh://git@github.com/indutny/elliptic.git"
14875 "jscs": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
14876 "jshint": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js",
14877 "lint": "npm run jscs && npm run jshint",
14878 "test": "npm run lint && npm run unit",
14879 "unit": "istanbul test _mocha --reporter=spec test/index.js",
14880 "version": "grunt dist && git add dist/"
14885 },{}],56:[function(require
,module
,exports
){
14886 (function (Buffer
){
14889 var isHexPrefixed
= require('is-hex-prefixed');
14890 var stripHexPrefix
= require('strip-hex-prefix');
14893 * Pads a `String` to have an even length
14894 * @param {String} value
14895 * @return {String} output
14897 function padToEven(value
) {
14898 var a
= value
; // eslint-disable-line
14900 if (typeof a
!== 'string') {
14901 throw new Error('[ethjs-util] while padding to even, value must be string, is currently ' + typeof a
+ ', while padToEven.');
14904 if (a
.length
% 2) {
14912 * Converts a `Number` into a hex `String`
14913 * @param {Number} i
14916 function intToHex(i
) {
14917 var hex
= i
.toString(16); // eslint-disable-line
14919 return '0x' + padToEven(hex
);
14923 * Converts an `Number` to a `Buffer`
14924 * @param {Number} i
14927 function intToBuffer(i
) {
14928 var hex
= intToHex(i
);
14930 return new Buffer(hex
.slice(2), 'hex');
14934 * Get the binary size of a string
14935 * @param {String} str
14938 function getBinarySize(str
) {
14939 if (typeof str
!== 'string') {
14940 throw new Error('[ethjs-util] while getting binary size, method getBinarySize requires input \'str\' to be type String, got \'' + typeof str
+ '\'.');
14943 return Buffer
.byteLength(str
, 'utf8');
14947 * Returns TRUE if the first specified array contains all elements
14948 * from the second one. FALSE otherwise.
14950 * @param {array} superset
14951 * @param {array} subset
14953 * @returns {boolean}
14955 function arrayContainsArray(superset
, subset
, some
) {
14956 if (Array
.isArray(superset
) !== true) {
14957 throw new Error('[ethjs-util] method arrayContainsArray requires input \'superset\' to be an array got type \'' + typeof superset
+ '\'');
14959 if (Array
.isArray(subset
) !== true) {
14960 throw new Error('[ethjs-util] method arrayContainsArray requires input \'subset\' to be an array got type \'' + typeof subset
+ '\'');
14963 return subset
[Boolean(some
) && 'some' || 'every'](function (value
) {
14964 return superset
.indexOf(value
) >= 0;
14969 * Should be called to get utf8 from it's hex representation
14972 * @param {String} string in hex
14973 * @returns {String} ascii string representation of hex value
14975 function toUtf8(hex
) {
14976 var bufferValue
= new Buffer(padToEven(stripHexPrefix(hex
).replace(/^0+|0+$/g, '')), 'hex');
14978 return bufferValue
.toString('utf8');
14982 * Should be called to get ascii from it's hex representation
14985 * @param {String} string in hex
14986 * @returns {String} ascii string representation of hex value
14988 function toAscii(hex
) {
14989 var str
= ''; // eslint-disable-line
14991 l
= hex
.length
; // eslint-disable-line
14993 if (hex
.substring(0, 2) === '0x') {
14997 for (; i
< l
; i
+= 2) {
14998 var code
= parseInt(hex
.substr(i
, 2), 16);
14999 str
+= String
.fromCharCode(code
);
15006 * Should be called to get hex representation (prefixed by 0x) of utf8 string
15009 * @param {String} string
15010 * @param {Number} optional padding
15011 * @returns {String} hex representation of input string
15013 function fromUtf8(stringValue
) {
15014 var str
= new Buffer(stringValue
, 'utf8');
15016 return '0x' + padToEven(str
.toString('hex')).replace(/^0+|0+$/g, '');
15020 * Should be called to get hex representation (prefixed by 0x) of ascii string
15022 * @method fromAscii
15023 * @param {String} string
15024 * @param {Number} optional padding
15025 * @returns {String} hex representation of input string
15027 function fromAscii(stringValue
) {
15028 var hex
= ''; // eslint-disable-line
15029 for (var i
= 0; i
< stringValue
.length
; i
++) {
15030 // eslint-disable-line
15031 var code
= stringValue
.charCodeAt(i
);
15032 var n
= code
.toString(16);
15033 hex
+= n
.length
< 2 ? '0' + n : n
;
15040 * getKeys([{a: 1, b: 2}, {a: 3, b: 4}], 'a') => [1, 3]
15042 * @method getKeys get specific key from inner object array of objects
15043 * @param {String} params
15044 * @param {String} key
15045 * @param {Boolean} allowEmpty
15046 * @returns {Array} output just a simple array of output keys
15048 function getKeys(params
, key
, allowEmpty
) {
15049 if (!Array
.isArray(params
)) {
15050 throw new Error('[ethjs-util] method getKeys expecting type Array as \'params\' input, got \'' + typeof params
+ '\'');
15052 if (typeof key
!== 'string') {
15053 throw new Error('[ethjs-util] method getKeys expecting type String for input \'key\' got \'' + typeof key
+ '\'.');
15056 var result
= []; // eslint-disable-line
15058 for (var i
= 0; i
< params
.length
; i
++) {
15059 // eslint-disable-line
15060 var value
= params
[i
][key
]; // eslint-disable-line
15061 if (allowEmpty
&& !value
) {
15063 } else if (typeof value
!== 'string') {
15064 throw new Error('invalid abi');
15066 result
.push(value
);
15073 * Is the string a hex string.
15075 * @method check if string is hex string of specific length
15076 * @param {String} value
15077 * @param {Number} length
15078 * @returns {Boolean} output the string is a hex string
15080 function isHexString(value
, length
) {
15081 if (typeof value
!== 'string' || !value
.match(/^0x[0-9A-Fa-f]*$/)) {
15085 if (length
&& value
.length
!== 2 + 2 * length
) {
15093 arrayContainsArray: arrayContainsArray
,
15094 intToBuffer: intToBuffer
,
15095 getBinarySize: getBinarySize
,
15096 isHexPrefixed: isHexPrefixed
,
15097 stripHexPrefix: stripHexPrefix
,
15098 padToEven: padToEven
,
15099 intToHex: intToHex
,
15100 fromAscii: fromAscii
,
15101 fromUtf8: fromUtf8
,
15105 isHexString: isHexString
15107 }).call(this,require("buffer").Buffer
)
15108 },{"buffer":5,"is-hex-prefixed":64,"strip-hex-prefix":87}],57:[function(require
,module
,exports
){
15109 var hash
= exports
;
15111 hash
.utils
= require('./hash/utils');
15112 hash
.common
= require('./hash/common');
15113 hash
.sha
= require('./hash/sha');
15114 hash
.ripemd
= require('./hash/ripemd');
15115 hash
.hmac
= require('./hash/hmac');
15117 // Proxy hash functions to the main object
15118 hash
.sha1
= hash
.sha
.sha1
;
15119 hash
.sha256
= hash
.sha
.sha256
;
15120 hash
.sha224
= hash
.sha
.sha224
;
15121 hash
.sha384
= hash
.sha
.sha384
;
15122 hash
.sha512
= hash
.sha
.sha512
;
15123 hash
.ripemd160
= hash
.ripemd
.ripemd160
;
15125 },{"./hash/common":58,"./hash/hmac":59,"./hash/ripemd":60,"./hash/sha":61,"./hash/utils":62}],58:[function(require
,module
,exports
){
15126 var hash
= require('../hash');
15127 var utils
= hash
.utils
;
15128 var assert
= utils
.assert
;
15130 function BlockHash() {
15131 this.pending
= null;
15132 this.pendingTotal
= 0;
15133 this.blockSize
= this.constructor.blockSize
;
15134 this.outSize
= this.constructor.outSize
;
15135 this.hmacStrength
= this.constructor.hmacStrength
;
15136 this.padLength
= this.constructor.padLength
/ 8;
15137 this.endian
= 'big';
15139 this._delta8
= this.blockSize
/ 8;
15140 this._delta32
= this.blockSize
/ 32;
15142 exports
.BlockHash
= BlockHash
;
15144 BlockHash
.prototype.update
= function update(msg
, enc
) {
15145 // Convert message to array, pad it, and join into 32bit blocks
15146 msg
= utils
.toArray(msg
, enc
);
15148 this.pending
= msg
;
15150 this.pending
= this.pending
.concat(msg
);
15151 this.pendingTotal
+= msg
.length
;
15153 // Enough data, try updating
15154 if (this.pending
.length
>= this._delta8
) {
15155 msg
= this.pending
;
15157 // Process pending data in blocks
15158 var r
= msg
.length
% this._delta8
;
15159 this.pending
= msg
.slice(msg
.length
- r
, msg
.length
);
15160 if (this.pending
.length
=== 0)
15161 this.pending
= null;
15163 msg
= utils
.join32(msg
, 0, msg
.length
- r
, this.endian
);
15164 for (var i
= 0; i
< msg
.length
; i
+= this._delta32
)
15165 this._update(msg
, i
, i
+ this._delta32
);
15171 BlockHash
.prototype.digest
= function digest(enc
) {
15172 this.update(this._pad());
15173 assert(this.pending
=== null);
15175 return this._digest(enc
);
15178 BlockHash
.prototype._pad
= function pad() {
15179 var len
= this.pendingTotal
;
15180 var bytes
= this._delta8
;
15181 var k
= bytes
- ((len
+ this.padLength
) % bytes
);
15182 var res
= new Array(k
+ this.padLength
);
15184 for (var i
= 1; i
< k
; i
++)
15189 if (this.endian
=== 'big') {
15190 for (var t
= 8; t
< this.padLength
; t
++)
15197 res
[i
++] = (len
>>> 24) & 0xff;
15198 res
[i
++] = (len
>>> 16) & 0xff;
15199 res
[i
++] = (len
>>> 8) & 0xff;
15200 res
[i
++] = len
& 0xff;
15202 res
[i
++] = len
& 0xff;
15203 res
[i
++] = (len
>>> 8) & 0xff;
15204 res
[i
++] = (len
>>> 16) & 0xff;
15205 res
[i
++] = (len
>>> 24) & 0xff;
15211 for (var t
= 8; t
< this.padLength
; t
++)
15218 },{"../hash":57}],59:[function(require
,module
,exports
){
15219 var hmac
= exports
;
15221 var hash
= require('../hash');
15222 var utils
= hash
.utils
;
15223 var assert
= utils
.assert
;
15225 function Hmac(hash
, key
, enc
) {
15226 if (!(this instanceof Hmac
))
15227 return new Hmac(hash
, key
, enc
);
15229 this.blockSize
= hash
.blockSize
/ 8;
15230 this.outSize
= hash
.outSize
/ 8;
15234 this._init(utils
.toArray(key
, enc
));
15236 module
.exports
= Hmac
;
15238 Hmac
.prototype._init
= function init(key
) {
15239 // Shorten key, if needed
15240 if (key
.length
> this.blockSize
)
15241 key
= new this.Hash().update(key
).digest();
15242 assert(key
.length
<= this.blockSize
);
15244 // Add padding to key
15245 for (var i
= key
.length
; i
< this.blockSize
; i
++)
15248 for (var i
= 0; i
< key
.length
; i
++)
15250 this.inner
= new this.Hash().update(key
);
15252 // 0x36 ^ 0x5c = 0x6a
15253 for (var i
= 0; i
< key
.length
; i
++)
15255 this.outer
= new this.Hash().update(key
);
15258 Hmac
.prototype.update
= function update(msg
, enc
) {
15259 this.inner
.update(msg
, enc
);
15263 Hmac
.prototype.digest
= function digest(enc
) {
15264 this.outer
.update(this.inner
.digest());
15265 return this.outer
.digest(enc
);
15268 },{"../hash":57}],60:[function(require
,module
,exports
){
15269 var hash
= require('../hash');
15270 var utils
= hash
.utils
;
15272 var rotl32
= utils
.rotl32
;
15273 var sum32
= utils
.sum32
;
15274 var sum32_3
= utils
.sum32_3
;
15275 var sum32_4
= utils
.sum32_4
;
15276 var BlockHash
= hash
.common
.BlockHash
;
15278 function RIPEMD160() {
15279 if (!(this instanceof RIPEMD160
))
15280 return new RIPEMD160();
15282 BlockHash
.call(this);
15284 this.h
= [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];
15285 this.endian
= 'little';
15287 utils
.inherits(RIPEMD160
, BlockHash
);
15288 exports
.ripemd160
= RIPEMD160
;
15290 RIPEMD160
.blockSize
= 512;
15291 RIPEMD160
.outSize
= 160;
15292 RIPEMD160
.hmacStrength
= 192;
15293 RIPEMD160
.padLength
= 64;
15295 RIPEMD160
.prototype._update
= function update(msg
, start
) {
15306 for (var j
= 0; j
< 80; j
++) {
15309 sum32_4(A
, f(j
, B
, C
, D
), msg
[r
[j
] + start
], K(j
)),
15319 sum32_4(Ah
, f(79 - j
, Bh
, Ch
, Dh
), msg
[rh
[j
] + start
], Kh(j
)),
15324 Dh
= rotl32(Ch
, 10);
15328 T
= sum32_3(this.h
[1], C
, Dh
);
15329 this.h
[1] = sum32_3(this.h
[2], D
, Eh
);
15330 this.h
[2] = sum32_3(this.h
[3], E
, Ah
);
15331 this.h
[3] = sum32_3(this.h
[4], A
, Bh
);
15332 this.h
[4] = sum32_3(this.h
[0], B
, Ch
);
15336 RIPEMD160
.prototype._digest
= function digest(enc
) {
15338 return utils
.toHex32(this.h
, 'little');
15340 return utils
.split32(this.h
, 'little');
15343 function f(j
, x
, y
, z
) {
15347 return (x
& y
) | ((~x
) & z
);
15349 return (x
| (~y
)) ^ z
;
15351 return (x
& z
) | (y
& (~z
));
15353 return x
^ (y
| (~z
));
15383 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
15384 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
15385 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
15386 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
15387 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
15391 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
15392 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15393 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
15394 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
15395 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
15399 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
15400 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
15401 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
15402 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
15403 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
15407 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
15408 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
15409 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15410 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
15411 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
15414 },{"../hash":57}],61:[function(require
,module
,exports
){
15415 var hash
= require('../hash');
15416 var utils
= hash
.utils
;
15417 var assert
= utils
.assert
;
15419 var rotr32
= utils
.rotr32
;
15420 var rotl32
= utils
.rotl32
;
15421 var sum32
= utils
.sum32
;
15422 var sum32_4
= utils
.sum32_4
;
15423 var sum32_5
= utils
.sum32_5
;
15424 var rotr64_hi
= utils
.rotr64_hi
;
15425 var rotr64_lo
= utils
.rotr64_lo
;
15426 var shr64_hi
= utils
.shr64_hi
;
15427 var shr64_lo
= utils
.shr64_lo
;
15428 var sum64
= utils
.sum64
;
15429 var sum64_hi
= utils
.sum64_hi
;
15430 var sum64_lo
= utils
.sum64_lo
;
15431 var sum64_4_hi
= utils
.sum64_4_hi
;
15432 var sum64_4_lo
= utils
.sum64_4_lo
;
15433 var sum64_5_hi
= utils
.sum64_5_hi
;
15434 var sum64_5_lo
= utils
.sum64_5_lo
;
15435 var BlockHash
= hash
.common
.BlockHash
;
15438 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
15439 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
15440 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
15441 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
15442 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
15443 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
15444 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
15445 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
15446 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
15447 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
15448 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
15449 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
15450 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
15451 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
15452 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
15453 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
15457 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
15458 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
15459 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
15460 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
15461 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
15462 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
15463 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
15464 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
15465 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
15466 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
15467 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
15468 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
15469 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
15470 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
15471 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
15472 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
15473 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
15474 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
15475 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
15476 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
15477 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
15478 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
15479 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
15480 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
15481 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
15482 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
15483 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
15484 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
15485 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
15486 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
15487 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
15488 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
15489 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
15490 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
15491 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
15492 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
15493 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
15494 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
15495 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
15496 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
15500 0x5A827999, 0x6ED9EBA1,
15501 0x8F1BBCDC, 0xCA62C1D6
15504 function SHA256() {
15505 if (!(this instanceof SHA256
))
15506 return new SHA256();
15508 BlockHash
.call(this);
15509 this.h
= [ 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
15510 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 ];
15512 this.W
= new Array(64);
15514 utils
.inherits(SHA256
, BlockHash
);
15515 exports
.sha256
= SHA256
;
15517 SHA256
.blockSize
= 512;
15518 SHA256
.outSize
= 256;
15519 SHA256
.hmacStrength
= 192;
15520 SHA256
.padLength
= 64;
15522 SHA256
.prototype._update
= function _update(msg
, start
) {
15525 for (var i
= 0; i
< 16; i
++)
15526 W
[i
] = msg
[start
+ i
];
15527 for (; i
< W
.length
; i
++)
15528 W
[i
] = sum32_4(g1_256(W
[i
- 2]), W
[i
- 7], g0_256(W
[i
- 15]), W
[i
- 16]);
15539 assert(this.k
.length
=== W
.length
);
15540 for (var i
= 0; i
< W
.length
; i
++) {
15541 var T1
= sum32_5(h
, s1_256(e
), ch32(e
, f
, g
), this.k
[i
], W
[i
]);
15542 var T2
= sum32(s0_256(a
), maj32(a
, b
, c
));
15553 this.h
[0] = sum32(this.h
[0], a
);
15554 this.h
[1] = sum32(this.h
[1], b
);
15555 this.h
[2] = sum32(this.h
[2], c
);
15556 this.h
[3] = sum32(this.h
[3], d
);
15557 this.h
[4] = sum32(this.h
[4], e
);
15558 this.h
[5] = sum32(this.h
[5], f
);
15559 this.h
[6] = sum32(this.h
[6], g
);
15560 this.h
[7] = sum32(this.h
[7], h
);
15563 SHA256
.prototype._digest
= function digest(enc
) {
15565 return utils
.toHex32(this.h
, 'big');
15567 return utils
.split32(this.h
, 'big');
15570 function SHA224() {
15571 if (!(this instanceof SHA224
))
15572 return new SHA224();
15575 this.h
= [ 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
15576 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ];
15578 utils
.inherits(SHA224
, SHA256
);
15579 exports
.sha224
= SHA224
;
15581 SHA224
.blockSize
= 512;
15582 SHA224
.outSize
= 224;
15583 SHA224
.hmacStrength
= 192;
15584 SHA224
.padLength
= 64;
15586 SHA224
.prototype._digest
= function digest(enc
) {
15587 // Just truncate output
15589 return utils
.toHex32(this.h
.slice(0, 7), 'big');
15591 return utils
.split32(this.h
.slice(0, 7), 'big');
15594 function SHA512() {
15595 if (!(this instanceof SHA512
))
15596 return new SHA512();
15598 BlockHash
.call(this);
15599 this.h
= [ 0x6a09e667, 0xf3bcc908,
15600 0xbb67ae85, 0x84caa73b,
15601 0x3c6ef372, 0xfe94f82b,
15602 0xa54ff53a, 0x5f1d36f1,
15603 0x510e527f, 0xade682d1,
15604 0x9b05688c, 0x2b3e6c1f,
15605 0x1f83d9ab, 0xfb41bd6b,
15606 0x5be0cd19, 0x137e2179 ];
15608 this.W
= new Array(160);
15610 utils
.inherits(SHA512
, BlockHash
);
15611 exports
.sha512
= SHA512
;
15613 SHA512
.blockSize
= 1024;
15614 SHA512
.outSize
= 512;
15615 SHA512
.hmacStrength
= 192;
15616 SHA512
.padLength
= 128;
15618 SHA512
.prototype._prepareBlock
= function _prepareBlock(msg
, start
) {
15621 // 32 x 32bit words
15622 for (var i
= 0; i
< 32; i
++)
15623 W
[i
] = msg
[start
+ i
];
15624 for (; i
< W
.length
; i
+= 2) {
15625 var c0_hi
= g1_512_hi(W
[i
- 4], W
[i
- 3]); // i - 2
15626 var c0_lo
= g1_512_lo(W
[i
- 4], W
[i
- 3]);
15627 var c1_hi
= W
[i
- 14]; // i - 7
15628 var c1_lo
= W
[i
- 13];
15629 var c2_hi
= g0_512_hi(W
[i
- 30], W
[i
- 29]); // i - 15
15630 var c2_lo
= g0_512_lo(W
[i
- 30], W
[i
- 29]);
15631 var c3_hi
= W
[i
- 32]; // i - 16
15632 var c3_lo
= W
[i
- 31];
15634 W
[i
] = sum64_4_hi(c0_hi
, c0_lo
,
15638 W
[i
+ 1] = sum64_4_lo(c0_hi
, c0_lo
,
15645 SHA512
.prototype._update
= function _update(msg
, start
) {
15646 this._prepareBlock(msg
, start
);
15650 var ah
= this.h
[0];
15651 var al
= this.h
[1];
15652 var bh
= this.h
[2];
15653 var bl
= this.h
[3];
15654 var ch
= this.h
[4];
15655 var cl
= this.h
[5];
15656 var dh
= this.h
[6];
15657 var dl
= this.h
[7];
15658 var eh
= this.h
[8];
15659 var el
= this.h
[9];
15660 var fh
= this.h
[10];
15661 var fl
= this.h
[11];
15662 var gh
= this.h
[12];
15663 var gl
= this.h
[13];
15664 var hh
= this.h
[14];
15665 var hl
= this.h
[15];
15667 assert(this.k
.length
=== W
.length
);
15668 for (var i
= 0; i
< W
.length
; i
+= 2) {
15671 var c1_hi
= s1_512_hi(eh
, el
);
15672 var c1_lo
= s1_512_lo(eh
, el
);
15673 var c2_hi
= ch64_hi(eh
, el
, fh
, fl
, gh
, gl
);
15674 var c2_lo
= ch64_lo(eh
, el
, fh
, fl
, gh
, gl
);
15675 var c3_hi
= this.k
[i
];
15676 var c3_lo
= this.k
[i
+ 1];
15678 var c4_lo
= W
[i
+ 1];
15680 var T1_hi
= sum64_5_hi(c0_hi
, c0_lo
,
15685 var T1_lo
= sum64_5_lo(c0_hi
, c0_lo
,
15691 var c0_hi
= s0_512_hi(ah
, al
);
15692 var c0_lo
= s0_512_lo(ah
, al
);
15693 var c1_hi
= maj64_hi(ah
, al
, bh
, bl
, ch
, cl
);
15694 var c1_lo
= maj64_lo(ah
, al
, bh
, bl
, ch
, cl
);
15696 var T2_hi
= sum64_hi(c0_hi
, c0_lo
, c1_hi
, c1_lo
);
15697 var T2_lo
= sum64_lo(c0_hi
, c0_lo
, c1_hi
, c1_lo
);
15708 eh
= sum64_hi(dh
, dl
, T1_hi
, T1_lo
);
15709 el
= sum64_lo(dl
, dl
, T1_hi
, T1_lo
);
15720 ah
= sum64_hi(T1_hi
, T1_lo
, T2_hi
, T2_lo
);
15721 al
= sum64_lo(T1_hi
, T1_lo
, T2_hi
, T2_lo
);
15724 sum64(this.h
, 0, ah
, al
);
15725 sum64(this.h
, 2, bh
, bl
);
15726 sum64(this.h
, 4, ch
, cl
);
15727 sum64(this.h
, 6, dh
, dl
);
15728 sum64(this.h
, 8, eh
, el
);
15729 sum64(this.h
, 10, fh
, fl
);
15730 sum64(this.h
, 12, gh
, gl
);
15731 sum64(this.h
, 14, hh
, hl
);
15734 SHA512
.prototype._digest
= function digest(enc
) {
15736 return utils
.toHex32(this.h
, 'big');
15738 return utils
.split32(this.h
, 'big');
15741 function SHA384() {
15742 if (!(this instanceof SHA384
))
15743 return new SHA384();
15746 this.h
= [ 0xcbbb9d5d, 0xc1059ed8,
15747 0x629a292a, 0x367cd507,
15748 0x9159015a, 0x3070dd17,
15749 0x152fecd8, 0xf70e5939,
15750 0x67332667, 0xffc00b31,
15751 0x8eb44a87, 0x68581511,
15752 0xdb0c2e0d, 0x64f98fa7,
15753 0x47b5481d, 0xbefa4fa4 ];
15755 utils
.inherits(SHA384
, SHA512
);
15756 exports
.sha384
= SHA384
;
15758 SHA384
.blockSize
= 1024;
15759 SHA384
.outSize
= 384;
15760 SHA384
.hmacStrength
= 192;
15761 SHA384
.padLength
= 128;
15763 SHA384
.prototype._digest
= function digest(enc
) {
15765 return utils
.toHex32(this.h
.slice(0, 12), 'big');
15767 return utils
.split32(this.h
.slice(0, 12), 'big');
15771 if (!(this instanceof SHA1
))
15774 BlockHash
.call(this);
15775 this.h
= [ 0x67452301, 0xefcdab89, 0x98badcfe,
15776 0x10325476, 0xc3d2e1f0 ];
15777 this.W
= new Array(80);
15780 utils
.inherits(SHA1
, BlockHash
);
15781 exports
.sha1
= SHA1
;
15783 SHA1
.blockSize
= 512;
15784 SHA1
.outSize
= 160;
15785 SHA1
.hmacStrength
= 80;
15786 SHA1
.padLength
= 64;
15788 SHA1
.prototype._update
= function _update(msg
, start
) {
15791 for (var i
= 0; i
< 16; i
++)
15792 W
[i
] = msg
[start
+ i
];
15794 for(; i
< W
.length
; i
++)
15795 W
[i
] = rotl32(W
[i
- 3] ^ W
[i
- 8] ^ W
[i
- 14] ^ W
[i
- 16], 1);
15803 for (var i
= 0; i
< W
.length
; i
++) {
15804 var s
= ~~(i
/ 20);
15805 var t
= sum32_5(rotl32(a
, 5), ft_1(s
, b
, c
, d
), e
, W
[i
], sha1_K
[s
]);
15813 this.h
[0] = sum32(this.h
[0], a
);
15814 this.h
[1] = sum32(this.h
[1], b
);
15815 this.h
[2] = sum32(this.h
[2], c
);
15816 this.h
[3] = sum32(this.h
[3], d
);
15817 this.h
[4] = sum32(this.h
[4], e
);
15820 SHA1
.prototype._digest
= function digest(enc
) {
15822 return utils
.toHex32(this.h
, 'big');
15824 return utils
.split32(this.h
, 'big');
15827 function ch32(x
, y
, z
) {
15828 return (x
& y
) ^ ((~x
) & z
);
15831 function maj32(x
, y
, z
) {
15832 return (x
& y
) ^ (x
& z
) ^ (y
& z
);
15835 function p32(x
, y
, z
) {
15839 function s0_256(x
) {
15840 return rotr32(x
, 2) ^ rotr32(x
, 13) ^ rotr32(x
, 22);
15843 function s1_256(x
) {
15844 return rotr32(x
, 6) ^ rotr32(x
, 11) ^ rotr32(x
, 25);
15847 function g0_256(x
) {
15848 return rotr32(x
, 7) ^ rotr32(x
, 18) ^ (x
>>> 3);
15851 function g1_256(x
) {
15852 return rotr32(x
, 17) ^ rotr32(x
, 19) ^ (x
>>> 10);
15855 function ft_1(s
, x
, y
, z
) {
15857 return ch32(x
, y
, z
);
15858 if (s
=== 1 || s
=== 3)
15859 return p32(x
, y
, z
);
15861 return maj32(x
, y
, z
);
15864 function ch64_hi(xh
, xl
, yh
, yl
, zh
, zl
) {
15865 var r
= (xh
& yh
) ^ ((~xh
) & zh
);
15871 function ch64_lo(xh
, xl
, yh
, yl
, zh
, zl
) {
15872 var r
= (xl
& yl
) ^ ((~xl
) & zl
);
15878 function maj64_hi(xh
, xl
, yh
, yl
, zh
, zl
) {
15879 var r
= (xh
& yh
) ^ (xh
& zh
) ^ (yh
& zh
);
15885 function maj64_lo(xh
, xl
, yh
, yl
, zh
, zl
) {
15886 var r
= (xl
& yl
) ^ (xl
& zl
) ^ (yl
& zl
);
15892 function s0_512_hi(xh
, xl
) {
15893 var c0_hi
= rotr64_hi(xh
, xl
, 28);
15894 var c1_hi
= rotr64_hi(xl
, xh
, 2); // 34
15895 var c2_hi
= rotr64_hi(xl
, xh
, 7); // 39
15897 var r
= c0_hi
^ c1_hi
^ c2_hi
;
15903 function s0_512_lo(xh
, xl
) {
15904 var c0_lo
= rotr64_lo(xh
, xl
, 28);
15905 var c1_lo
= rotr64_lo(xl
, xh
, 2); // 34
15906 var c2_lo
= rotr64_lo(xl
, xh
, 7); // 39
15908 var r
= c0_lo
^ c1_lo
^ c2_lo
;
15914 function s1_512_hi(xh
, xl
) {
15915 var c0_hi
= rotr64_hi(xh
, xl
, 14);
15916 var c1_hi
= rotr64_hi(xh
, xl
, 18);
15917 var c2_hi
= rotr64_hi(xl
, xh
, 9); // 41
15919 var r
= c0_hi
^ c1_hi
^ c2_hi
;
15925 function s1_512_lo(xh
, xl
) {
15926 var c0_lo
= rotr64_lo(xh
, xl
, 14);
15927 var c1_lo
= rotr64_lo(xh
, xl
, 18);
15928 var c2_lo
= rotr64_lo(xl
, xh
, 9); // 41
15930 var r
= c0_lo
^ c1_lo
^ c2_lo
;
15936 function g0_512_hi(xh
, xl
) {
15937 var c0_hi
= rotr64_hi(xh
, xl
, 1);
15938 var c1_hi
= rotr64_hi(xh
, xl
, 8);
15939 var c2_hi
= shr64_hi(xh
, xl
, 7);
15941 var r
= c0_hi
^ c1_hi
^ c2_hi
;
15947 function g0_512_lo(xh
, xl
) {
15948 var c0_lo
= rotr64_lo(xh
, xl
, 1);
15949 var c1_lo
= rotr64_lo(xh
, xl
, 8);
15950 var c2_lo
= shr64_lo(xh
, xl
, 7);
15952 var r
= c0_lo
^ c1_lo
^ c2_lo
;
15958 function g1_512_hi(xh
, xl
) {
15959 var c0_hi
= rotr64_hi(xh
, xl
, 19);
15960 var c1_hi
= rotr64_hi(xl
, xh
, 29); // 61
15961 var c2_hi
= shr64_hi(xh
, xl
, 6);
15963 var r
= c0_hi
^ c1_hi
^ c2_hi
;
15969 function g1_512_lo(xh
, xl
) {
15970 var c0_lo
= rotr64_lo(xh
, xl
, 19);
15971 var c1_lo
= rotr64_lo(xl
, xh
, 29); // 61
15972 var c2_lo
= shr64_lo(xh
, xl
, 6);
15974 var r
= c0_lo
^ c1_lo
^ c2_lo
;
15980 },{"../hash":57}],62:[function(require
,module
,exports
){
15981 var utils
= exports
;
15982 var inherits
= require('inherits');
15984 function toArray(msg
, enc
) {
15985 if (Array
.isArray(msg
))
15986 return msg
.slice();
15990 if (typeof msg
=== 'string') {
15992 for (var i
= 0; i
< msg
.length
; i
++) {
15993 var c
= msg
.charCodeAt(i
);
16001 } else if (enc
=== 'hex') {
16002 msg
= msg
.replace(/[^a-z0-9]+/ig, '');
16003 if (msg
.length
% 2 !== 0)
16005 for (var i
= 0; i
< msg
.length
; i
+= 2)
16006 res
.push(parseInt(msg
[i
] + msg
[i
+ 1], 16));
16009 for (var i
= 0; i
< msg
.length
; i
++)
16010 res
[i
] = msg
[i
] | 0;
16014 utils
.toArray
= toArray
;
16016 function toHex(msg
) {
16018 for (var i
= 0; i
< msg
.length
; i
++)
16019 res
+= zero2(msg
[i
].toString(16));
16022 utils
.toHex
= toHex
;
16024 function htonl(w
) {
16025 var res
= (w
>>> 24) |
16026 ((w
>>> 8) & 0xff00) |
16027 ((w
<< 8) & 0xff0000) |
16028 ((w
& 0xff) << 24);
16031 utils
.htonl
= htonl
;
16033 function toHex32(msg
, endian
) {
16035 for (var i
= 0; i
< msg
.length
; i
++) {
16037 if (endian
=== 'little')
16039 res
+= zero8(w
.toString(16));
16043 utils
.toHex32
= toHex32
;
16045 function zero2(word
) {
16046 if (word
.length
=== 1)
16051 utils
.zero2
= zero2
;
16053 function zero8(word
) {
16054 if (word
.length
=== 7)
16056 else if (word
.length
=== 6)
16057 return '00' + word
;
16058 else if (word
.length
=== 5)
16059 return '000' + word
;
16060 else if (word
.length
=== 4)
16061 return '0000' + word
;
16062 else if (word
.length
=== 3)
16063 return '00000' + word
;
16064 else if (word
.length
=== 2)
16065 return '000000' + word
;
16066 else if (word
.length
=== 1)
16067 return '0000000' + word
;
16071 utils
.zero8
= zero8
;
16073 function join32(msg
, start
, end
, endian
) {
16074 var len
= end
- start
;
16075 assert(len
% 4 === 0);
16076 var res
= new Array(len
/ 4);
16077 for (var i
= 0, k
= start
; i
< res
.length
; i
++, k
+= 4) {
16079 if (endian
=== 'big')
16080 w
= (msg
[k
] << 24) | (msg
[k
+ 1] << 16) | (msg
[k
+ 2] << 8) | msg
[k
+ 3];
16082 w
= (msg
[k
+ 3] << 24) | (msg
[k
+ 2] << 16) | (msg
[k
+ 1] << 8) | msg
[k
];
16087 utils
.join32
= join32
;
16089 function split32(msg
, endian
) {
16090 var res
= new Array(msg
.length
* 4);
16091 for (var i
= 0, k
= 0; i
< msg
.length
; i
++, k
+= 4) {
16093 if (endian
=== 'big') {
16095 res
[k
+ 1] = (m
>>> 16) & 0xff;
16096 res
[k
+ 2] = (m
>>> 8) & 0xff;
16097 res
[k
+ 3] = m
& 0xff;
16099 res
[k
+ 3] = m
>>> 24;
16100 res
[k
+ 2] = (m
>>> 16) & 0xff;
16101 res
[k
+ 1] = (m
>>> 8) & 0xff;
16107 utils
.split32
= split32
;
16109 function rotr32(w
, b
) {
16110 return (w
>>> b
) | (w
<< (32 - b
));
16112 utils
.rotr32
= rotr32
;
16114 function rotl32(w
, b
) {
16115 return (w
<< b
) | (w
>>> (32 - b
));
16117 utils
.rotl32
= rotl32
;
16119 function sum32(a
, b
) {
16120 return (a
+ b
) >>> 0;
16122 utils
.sum32
= sum32
;
16124 function sum32_3(a
, b
, c
) {
16125 return (a
+ b
+ c
) >>> 0;
16127 utils
.sum32_3
= sum32_3
;
16129 function sum32_4(a
, b
, c
, d
) {
16130 return (a
+ b
+ c
+ d
) >>> 0;
16132 utils
.sum32_4
= sum32_4
;
16134 function sum32_5(a
, b
, c
, d
, e
) {
16135 return (a
+ b
+ c
+ d
+ e
) >>> 0;
16137 utils
.sum32_5
= sum32_5
;
16139 function assert(cond
, msg
) {
16141 throw new Error(msg
|| 'Assertion failed');
16143 utils
.assert
= assert
;
16145 utils
.inherits
= inherits
;
16147 function sum64(buf
, pos
, ah
, al
) {
16149 var bl
= buf
[pos
+ 1];
16151 var lo
= (al
+ bl
) >>> 0;
16152 var hi
= (lo
< al
? 1 : 0) + ah
+ bh
;
16153 buf
[pos
] = hi
>>> 0;
16156 exports
.sum64
= sum64
;
16158 function sum64_hi(ah
, al
, bh
, bl
) {
16159 var lo
= (al
+ bl
) >>> 0;
16160 var hi
= (lo
< al
? 1 : 0) + ah
+ bh
;
16163 exports
.sum64_hi
= sum64_hi
;
16165 function sum64_lo(ah
, al
, bh
, bl
) {
16169 exports
.sum64_lo
= sum64_lo
;
16171 function sum64_4_hi(ah
, al
, bh
, bl
, ch
, cl
, dh
, dl
) {
16174 lo
= (lo
+ bl
) >>> 0;
16175 carry
+= lo
< al
? 1 : 0;
16176 lo
= (lo
+ cl
) >>> 0;
16177 carry
+= lo
< cl
? 1 : 0;
16178 lo
= (lo
+ dl
) >>> 0;
16179 carry
+= lo
< dl
? 1 : 0;
16181 var hi
= ah
+ bh
+ ch
+ dh
+ carry
;
16184 exports
.sum64_4_hi
= sum64_4_hi
;
16186 function sum64_4_lo(ah
, al
, bh
, bl
, ch
, cl
, dh
, dl
) {
16187 var lo
= al
+ bl
+ cl
+ dl
;
16190 exports
.sum64_4_lo
= sum64_4_lo
;
16192 function sum64_5_hi(ah
, al
, bh
, bl
, ch
, cl
, dh
, dl
, eh
, el
) {
16195 lo
= (lo
+ bl
) >>> 0;
16196 carry
+= lo
< al
? 1 : 0;
16197 lo
= (lo
+ cl
) >>> 0;
16198 carry
+= lo
< cl
? 1 : 0;
16199 lo
= (lo
+ dl
) >>> 0;
16200 carry
+= lo
< dl
? 1 : 0;
16201 lo
= (lo
+ el
) >>> 0;
16202 carry
+= lo
< el
? 1 : 0;
16204 var hi
= ah
+ bh
+ ch
+ dh
+ eh
+ carry
;
16207 exports
.sum64_5_hi
= sum64_5_hi
;
16209 function sum64_5_lo(ah
, al
, bh
, bl
, ch
, cl
, dh
, dl
, eh
, el
) {
16210 var lo
= al
+ bl
+ cl
+ dl
+ el
;
16214 exports
.sum64_5_lo
= sum64_5_lo
;
16216 function rotr64_hi(ah
, al
, num
) {
16217 var r
= (al
<< (32 - num
)) | (ah
>>> num
);
16220 exports
.rotr64_hi
= rotr64_hi
;
16222 function rotr64_lo(ah
, al
, num
) {
16223 var r
= (ah
<< (32 - num
)) | (al
>>> num
);
16226 exports
.rotr64_lo
= rotr64_lo
;
16228 function shr64_hi(ah
, al
, num
) {
16231 exports
.shr64_hi
= shr64_hi
;
16233 function shr64_lo(ah
, al
, num
) {
16234 var r
= (ah
<< (32 - num
)) | (al
>>> num
);
16237 exports
.shr64_lo
= shr64_lo
;
16239 },{"inherits":63}],63:[function(require
,module
,exports
){
16240 arguments
[4][9][0].apply(exports
,arguments
)
16241 },{"dup":9}],64:[function(require
,module
,exports
){
16243 * Returns a `Boolean` on whether or not the a `String` starts with '0x'
16244 * @param {String} str the string input value
16245 * @return {Boolean} a boolean if it is or is not hex prefixed
16246 * @throws if the str input is not a string
16248 module
.exports
= function isHexPrefixed(str
) {
16249 if (typeof str
!== 'string') {
16250 throw new Error("[is-hex-prefixed] value must be type 'string', is currently type " + (typeof str
) + ", while checking isHexPrefixed.");
16253 return str
.slice(0, 2) === '0x';
16256 },{}],65:[function(require
,module
,exports
){
16258 module
.exports
= require('./lib/api')(require('./lib/keccak'))
16260 },{"./lib/api":66,"./lib/keccak":70}],66:[function(require
,module
,exports
){
16262 var createKeccak
= require('./keccak')
16263 var createShake
= require('./shake')
16265 module
.exports = function (KeccakState
) {
16266 var Keccak
= createKeccak(KeccakState
)
16267 var Shake
= createShake(KeccakState
)
16269 return function (algorithm
, options
) {
16270 var hash
= typeof algorithm
=== 'string' ? algorithm
.toLowerCase() : algorithm
16272 case 'keccak224': return new Keccak(1152, 448, null, 224, options
)
16273 case 'keccak256': return new Keccak(1088, 512, null, 256, options
)
16274 case 'keccak384': return new Keccak(832, 768, null, 384, options
)
16275 case 'keccak512': return new Keccak(576, 1024, null, 512, options
)
16277 case 'sha3-224': return new Keccak(1152, 448, 0x06, 224, options
)
16278 case 'sha3-256': return new Keccak(1088, 512, 0x06, 256, options
)
16279 case 'sha3-384': return new Keccak(832, 768, 0x06, 384, options
)
16280 case 'sha3-512': return new Keccak(576, 1024, 0x06, 512, options
)
16282 case 'shake128': return new Shake(1344, 256, 0x1f, options
)
16283 case 'shake256': return new Shake(1088, 512, 0x1f, options
)
16285 default: throw new Error('Invald algorithm: ' + algorithm
)
16290 },{"./keccak":67,"./shake":68}],67:[function(require
,module
,exports
){
16291 (function (Buffer
){
16293 var Transform
= require('stream').Transform
16294 var inherits
= require('inherits')
16296 module
.exports = function (KeccakState
) {
16297 function Keccak (rate
, capacity
, delimitedSuffix
, hashBitLength
, options
) {
16298 Transform
.call(this, options
)
16301 this._capacity
= capacity
16302 this._delimitedSuffix
= delimitedSuffix
16303 this._hashBitLength
= hashBitLength
16304 this._options
= options
16306 this._state
= new KeccakState()
16307 this._state
.initialize(rate
, capacity
)
16308 this._finalized
= false
16311 inherits(Keccak
, Transform
)
16313 Keccak
.prototype._transform = function (chunk
, encoding
, callback
) {
16316 this.update(chunk
, encoding
)
16324 Keccak
.prototype._flush = function (callback
) {
16327 this.push(this.digest())
16335 Keccak
.prototype.update = function (data
, encoding
) {
16336 if (!Buffer
.isBuffer(data
) && typeof data
!== 'string') throw new TypeError('Data must be a string or a buffer')
16337 if (this._finalized
) throw new Error('Digest already called')
16338 if (!Buffer
.isBuffer(data
)) data
= Buffer
.from(data
, encoding
)
16340 this._state
.absorb(data
)
16345 Keccak
.prototype.digest = function (encoding
) {
16346 if (this._finalized
) throw new Error('Digest already called')
16347 this._finalized
= true
16349 if (this._delimitedSuffix
) this._state
.absorbLastFewBits(this._delimitedSuffix
)
16350 var digest
= this._state
.squeeze(this._hashBitLength
/ 8)
16351 if (encoding
!== undefined) digest
= digest
.toString(encoding
)
16358 // remove result from memory
16359 Keccak
.prototype._resetState = function () {
16360 this._state
.initialize(this._rate
, this._capacity
)
16364 // because sometimes we need hash right now and little later
16365 Keccak
.prototype._clone = function () {
16366 var clone
= new Keccak(this._rate
, this._capacity
, this._delimitedSuffix
, this._hashBitLength
, this._options
)
16367 this._state
.copy(clone
._state
)
16368 clone
._finalized
= this._finalized
16376 }).call(this,require("buffer").Buffer
)
16377 },{"buffer":5,"inherits":63,"stream":25}],68:[function(require
,module
,exports
){
16378 (function (Buffer
){
16380 var Transform
= require('stream').Transform
16381 var inherits
= require('inherits')
16383 module
.exports = function (KeccakState
) {
16384 function Shake (rate
, capacity
, delimitedSuffix
, options
) {
16385 Transform
.call(this, options
)
16388 this._capacity
= capacity
16389 this._delimitedSuffix
= delimitedSuffix
16390 this._options
= options
16392 this._state
= new KeccakState()
16393 this._state
.initialize(rate
, capacity
)
16394 this._finalized
= false
16397 inherits(Shake
, Transform
)
16399 Shake
.prototype._transform = function (chunk
, encoding
, callback
) {
16402 this.update(chunk
, encoding
)
16410 Shake
.prototype._flush = function () {}
16412 Shake
.prototype._read = function (size
) {
16413 this.push(this.squeeze(size
))
16416 Shake
.prototype.update = function (data
, encoding
) {
16417 if (!Buffer
.isBuffer(data
) && typeof data
!== 'string') throw new TypeError('Data must be a string or a buffer')
16418 if (this._finalized
) throw new Error('Squeeze already called')
16419 if (!Buffer
.isBuffer(data
)) data
= Buffer
.from(data
, encoding
)
16421 this._state
.absorb(data
)
16426 Shake
.prototype.squeeze = function (dataByteLength
, encoding
) {
16427 if (!this._finalized
) {
16428 this._finalized
= true
16429 this._state
.absorbLastFewBits(this._delimitedSuffix
)
16432 var data
= this._state
.squeeze(dataByteLength
)
16433 if (encoding
!== undefined) data
= data
.toString(encoding
)
16438 Shake
.prototype._resetState = function () {
16439 this._state
.initialize(this._rate
, this._capacity
)
16443 Shake
.prototype._clone = function () {
16444 var clone
= new Shake(this._rate
, this._capacity
, this._delimitedSuffix
, this._options
)
16445 this._state
.copy(clone
._state
)
16446 clone
._finalized
= this._finalized
16454 }).call(this,require("buffer").Buffer
)
16455 },{"buffer":5,"inherits":63,"stream":25}],69:[function(require
,module
,exports
){
16457 var P1600_ROUND_CONSTANTS
= [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648]
16459 exports
.p1600 = function (s
) {
16460 for (var round
= 0; round
< 24; ++round
) {
16462 var lo0
= s
[0] ^ s
[10] ^ s
[20] ^ s
[30] ^ s
[40]
16463 var hi0
= s
[1] ^ s
[11] ^ s
[21] ^ s
[31] ^ s
[41]
16464 var lo1
= s
[2] ^ s
[12] ^ s
[22] ^ s
[32] ^ s
[42]
16465 var hi1
= s
[3] ^ s
[13] ^ s
[23] ^ s
[33] ^ s
[43]
16466 var lo2
= s
[4] ^ s
[14] ^ s
[24] ^ s
[34] ^ s
[44]
16467 var hi2
= s
[5] ^ s
[15] ^ s
[25] ^ s
[35] ^ s
[45]
16468 var lo3
= s
[6] ^ s
[16] ^ s
[26] ^ s
[36] ^ s
[46]
16469 var hi3
= s
[7] ^ s
[17] ^ s
[27] ^ s
[37] ^ s
[47]
16470 var lo4
= s
[8] ^ s
[18] ^ s
[28] ^ s
[38] ^ s
[48]
16471 var hi4
= s
[9] ^ s
[19] ^ s
[29] ^ s
[39] ^ s
[49]
16473 var lo
= lo4
^ (lo1
<< 1 | hi1
>>> 31)
16474 var hi
= hi4
^ (hi1
<< 1 | lo1
>>> 31)
16475 var t1slo0
= s
[0] ^ lo
16476 var t1shi0
= s
[1] ^ hi
16477 var t1slo5
= s
[10] ^ lo
16478 var t1shi5
= s
[11] ^ hi
16479 var t1slo10
= s
[20] ^ lo
16480 var t1shi10
= s
[21] ^ hi
16481 var t1slo15
= s
[30] ^ lo
16482 var t1shi15
= s
[31] ^ hi
16483 var t1slo20
= s
[40] ^ lo
16484 var t1shi20
= s
[41] ^ hi
16485 lo
= lo0
^ (lo2
<< 1 | hi2
>>> 31)
16486 hi
= hi0
^ (hi2
<< 1 | lo2
>>> 31)
16487 var t1slo1
= s
[2] ^ lo
16488 var t1shi1
= s
[3] ^ hi
16489 var t1slo6
= s
[12] ^ lo
16490 var t1shi6
= s
[13] ^ hi
16491 var t1slo11
= s
[22] ^ lo
16492 var t1shi11
= s
[23] ^ hi
16493 var t1slo16
= s
[32] ^ lo
16494 var t1shi16
= s
[33] ^ hi
16495 var t1slo21
= s
[42] ^ lo
16496 var t1shi21
= s
[43] ^ hi
16497 lo
= lo1
^ (lo3
<< 1 | hi3
>>> 31)
16498 hi
= hi1
^ (hi3
<< 1 | lo3
>>> 31)
16499 var t1slo2
= s
[4] ^ lo
16500 var t1shi2
= s
[5] ^ hi
16501 var t1slo7
= s
[14] ^ lo
16502 var t1shi7
= s
[15] ^ hi
16503 var t1slo12
= s
[24] ^ lo
16504 var t1shi12
= s
[25] ^ hi
16505 var t1slo17
= s
[34] ^ lo
16506 var t1shi17
= s
[35] ^ hi
16507 var t1slo22
= s
[44] ^ lo
16508 var t1shi22
= s
[45] ^ hi
16509 lo
= lo2
^ (lo4
<< 1 | hi4
>>> 31)
16510 hi
= hi2
^ (hi4
<< 1 | lo4
>>> 31)
16511 var t1slo3
= s
[6] ^ lo
16512 var t1shi3
= s
[7] ^ hi
16513 var t1slo8
= s
[16] ^ lo
16514 var t1shi8
= s
[17] ^ hi
16515 var t1slo13
= s
[26] ^ lo
16516 var t1shi13
= s
[27] ^ hi
16517 var t1slo18
= s
[36] ^ lo
16518 var t1shi18
= s
[37] ^ hi
16519 var t1slo23
= s
[46] ^ lo
16520 var t1shi23
= s
[47] ^ hi
16521 lo
= lo3
^ (lo0
<< 1 | hi0
>>> 31)
16522 hi
= hi3
^ (hi0
<< 1 | lo0
>>> 31)
16523 var t1slo4
= s
[8] ^ lo
16524 var t1shi4
= s
[9] ^ hi
16525 var t1slo9
= s
[18] ^ lo
16526 var t1shi9
= s
[19] ^ hi
16527 var t1slo14
= s
[28] ^ lo
16528 var t1shi14
= s
[29] ^ hi
16529 var t1slo19
= s
[38] ^ lo
16530 var t1shi19
= s
[39] ^ hi
16531 var t1slo24
= s
[48] ^ lo
16532 var t1shi24
= s
[49] ^ hi
16535 var t2slo0
= t1slo0
16536 var t2shi0
= t1shi0
16537 var t2slo16
= (t1shi5
<< 4 | t1slo5
>>> 28)
16538 var t2shi16
= (t1slo5
<< 4 | t1shi5
>>> 28)
16539 var t2slo7
= (t1slo10
<< 3 | t1shi10
>>> 29)
16540 var t2shi7
= (t1shi10
<< 3 | t1slo10
>>> 29)
16541 var t2slo23
= (t1shi15
<< 9 | t1slo15
>>> 23)
16542 var t2shi23
= (t1slo15
<< 9 | t1shi15
>>> 23)
16543 var t2slo14
= (t1slo20
<< 18 | t1shi20
>>> 14)
16544 var t2shi14
= (t1shi20
<< 18 | t1slo20
>>> 14)
16545 var t2slo10
= (t1slo1
<< 1 | t1shi1
>>> 31)
16546 var t2shi10
= (t1shi1
<< 1 | t1slo1
>>> 31)
16547 var t2slo1
= (t1shi6
<< 12 | t1slo6
>>> 20)
16548 var t2shi1
= (t1slo6
<< 12 | t1shi6
>>> 20)
16549 var t2slo17
= (t1slo11
<< 10 | t1shi11
>>> 22)
16550 var t2shi17
= (t1shi11
<< 10 | t1slo11
>>> 22)
16551 var t2slo8
= (t1shi16
<< 13 | t1slo16
>>> 19)
16552 var t2shi8
= (t1slo16
<< 13 | t1shi16
>>> 19)
16553 var t2slo24
= (t1slo21
<< 2 | t1shi21
>>> 30)
16554 var t2shi24
= (t1shi21
<< 2 | t1slo21
>>> 30)
16555 var t2slo20
= (t1shi2
<< 30 | t1slo2
>>> 2)
16556 var t2shi20
= (t1slo2
<< 30 | t1shi2
>>> 2)
16557 var t2slo11
= (t1slo7
<< 6 | t1shi7
>>> 26)
16558 var t2shi11
= (t1shi7
<< 6 | t1slo7
>>> 26)
16559 var t2slo2
= (t1shi12
<< 11 | t1slo12
>>> 21)
16560 var t2shi2
= (t1slo12
<< 11 | t1shi12
>>> 21)
16561 var t2slo18
= (t1slo17
<< 15 | t1shi17
>>> 17)
16562 var t2shi18
= (t1shi17
<< 15 | t1slo17
>>> 17)
16563 var t2slo9
= (t1shi22
<< 29 | t1slo22
>>> 3)
16564 var t2shi9
= (t1slo22
<< 29 | t1shi22
>>> 3)
16565 var t2slo5
= (t1slo3
<< 28 | t1shi3
>>> 4)
16566 var t2shi5
= (t1shi3
<< 28 | t1slo3
>>> 4)
16567 var t2slo21
= (t1shi8
<< 23 | t1slo8
>>> 9)
16568 var t2shi21
= (t1slo8
<< 23 | t1shi8
>>> 9)
16569 var t2slo12
= (t1slo13
<< 25 | t1shi13
>>> 7)
16570 var t2shi12
= (t1shi13
<< 25 | t1slo13
>>> 7)
16571 var t2slo3
= (t1slo18
<< 21 | t1shi18
>>> 11)
16572 var t2shi3
= (t1shi18
<< 21 | t1slo18
>>> 11)
16573 var t2slo19
= (t1shi23
<< 24 | t1slo23
>>> 8)
16574 var t2shi19
= (t1slo23
<< 24 | t1shi23
>>> 8)
16575 var t2slo15
= (t1slo4
<< 27 | t1shi4
>>> 5)
16576 var t2shi15
= (t1shi4
<< 27 | t1slo4
>>> 5)
16577 var t2slo6
= (t1slo9
<< 20 | t1shi9
>>> 12)
16578 var t2shi6
= (t1shi9
<< 20 | t1slo9
>>> 12)
16579 var t2slo22
= (t1shi14
<< 7 | t1slo14
>>> 25)
16580 var t2shi22
= (t1slo14
<< 7 | t1shi14
>>> 25)
16581 var t2slo13
= (t1slo19
<< 8 | t1shi19
>>> 24)
16582 var t2shi13
= (t1shi19
<< 8 | t1slo19
>>> 24)
16583 var t2slo4
= (t1slo24
<< 14 | t1shi24
>>> 18)
16584 var t2shi4
= (t1shi24
<< 14 | t1slo24
>>> 18)
16587 s
[0] = t2slo0
^ (~t2slo1
& t2slo2
)
16588 s
[1] = t2shi0
^ (~t2shi1
& t2shi2
)
16589 s
[10] = t2slo5
^ (~t2slo6
& t2slo7
)
16590 s
[11] = t2shi5
^ (~t2shi6
& t2shi7
)
16591 s
[20] = t2slo10
^ (~t2slo11
& t2slo12
)
16592 s
[21] = t2shi10
^ (~t2shi11
& t2shi12
)
16593 s
[30] = t2slo15
^ (~t2slo16
& t2slo17
)
16594 s
[31] = t2shi15
^ (~t2shi16
& t2shi17
)
16595 s
[40] = t2slo20
^ (~t2slo21
& t2slo22
)
16596 s
[41] = t2shi20
^ (~t2shi21
& t2shi22
)
16597 s
[2] = t2slo1
^ (~t2slo2
& t2slo3
)
16598 s
[3] = t2shi1
^ (~t2shi2
& t2shi3
)
16599 s
[12] = t2slo6
^ (~t2slo7
& t2slo8
)
16600 s
[13] = t2shi6
^ (~t2shi7
& t2shi8
)
16601 s
[22] = t2slo11
^ (~t2slo12
& t2slo13
)
16602 s
[23] = t2shi11
^ (~t2shi12
& t2shi13
)
16603 s
[32] = t2slo16
^ (~t2slo17
& t2slo18
)
16604 s
[33] = t2shi16
^ (~t2shi17
& t2shi18
)
16605 s
[42] = t2slo21
^ (~t2slo22
& t2slo23
)
16606 s
[43] = t2shi21
^ (~t2shi22
& t2shi23
)
16607 s
[4] = t2slo2
^ (~t2slo3
& t2slo4
)
16608 s
[5] = t2shi2
^ (~t2shi3
& t2shi4
)
16609 s
[14] = t2slo7
^ (~t2slo8
& t2slo9
)
16610 s
[15] = t2shi7
^ (~t2shi8
& t2shi9
)
16611 s
[24] = t2slo12
^ (~t2slo13
& t2slo14
)
16612 s
[25] = t2shi12
^ (~t2shi13
& t2shi14
)
16613 s
[34] = t2slo17
^ (~t2slo18
& t2slo19
)
16614 s
[35] = t2shi17
^ (~t2shi18
& t2shi19
)
16615 s
[44] = t2slo22
^ (~t2slo23
& t2slo24
)
16616 s
[45] = t2shi22
^ (~t2shi23
& t2shi24
)
16617 s
[6] = t2slo3
^ (~t2slo4
& t2slo0
)
16618 s
[7] = t2shi3
^ (~t2shi4
& t2shi0
)
16619 s
[16] = t2slo8
^ (~t2slo9
& t2slo5
)
16620 s
[17] = t2shi8
^ (~t2shi9
& t2shi5
)
16621 s
[26] = t2slo13
^ (~t2slo14
& t2slo10
)
16622 s
[27] = t2shi13
^ (~t2shi14
& t2shi10
)
16623 s
[36] = t2slo18
^ (~t2slo19
& t2slo15
)
16624 s
[37] = t2shi18
^ (~t2shi19
& t2shi15
)
16625 s
[46] = t2slo23
^ (~t2slo24
& t2slo20
)
16626 s
[47] = t2shi23
^ (~t2shi24
& t2shi20
)
16627 s
[8] = t2slo4
^ (~t2slo0
& t2slo1
)
16628 s
[9] = t2shi4
^ (~t2shi0
& t2shi1
)
16629 s
[18] = t2slo9
^ (~t2slo5
& t2slo6
)
16630 s
[19] = t2shi9
^ (~t2shi5
& t2shi6
)
16631 s
[28] = t2slo14
^ (~t2slo10
& t2slo11
)
16632 s
[29] = t2shi14
^ (~t2shi10
& t2shi11
)
16633 s
[38] = t2slo19
^ (~t2slo15
& t2slo16
)
16634 s
[39] = t2shi19
^ (~t2shi15
& t2shi16
)
16635 s
[48] = t2slo24
^ (~t2slo20
& t2slo21
)
16636 s
[49] = t2shi24
^ (~t2shi20
& t2shi21
)
16639 s
[0] ^= P1600_ROUND_CONSTANTS
[round
* 2]
16640 s
[1] ^= P1600_ROUND_CONSTANTS
[round
* 2 + 1]
16644 },{}],70:[function(require
,module
,exports
){
16645 (function (Buffer
){
16647 var keccakState
= require('./keccak-state-unroll')
16649 function Keccak () {
16650 // much faster than `new Array(50)`
16659 this.blockSize
= null
16661 this.squeezing
= false
16664 Keccak
.prototype.initialize = function (rate
, capacity
) {
16665 for (var i
= 0; i
< 50; ++i
) this.state
[i
] = 0
16666 this.blockSize
= rate
/ 8
16668 this.squeezing
= false
16671 Keccak
.prototype.absorb = function (data
) {
16672 for (var i
= 0; i
< data
.length
; ++i
) {
16673 this.state
[~~(this.count
/ 4)] ^= data
[i
] << (8 * (this.count
% 4))
16675 if (this.count
=== this.blockSize
) {
16676 keccakState
.p1600(this.state
)
16682 Keccak
.prototype.absorbLastFewBits = function (bits
) {
16683 this.state
[~~(this.count
/ 4)] ^= bits
<< (8 * (this.count
% 4))
16684 if ((bits
& 0x80) !== 0 && this.count
=== (this.blockSize
- 1)) keccakState
.p1600(this.state
)
16685 this.state
[~~((this.blockSize
- 1) / 4)] ^= 0x80 << (8 * ((this.blockSize
- 1) % 4))
16686 keccakState
.p1600(this.state
)
16688 this.squeezing
= true
16691 Keccak
.prototype.squeeze = function (length
) {
16692 if (!this.squeezing
) this.absorbLastFewBits(0x01)
16694 var output
= Buffer
.allocUnsafe(length
)
16695 for (var i
= 0; i
< length
; ++i
) {
16696 output
[i
] = (this.state
[~~(this.count
/ 4)] >>> (8 * (this.count
% 4))) & 0xff
16698 if (this.count
=== this.blockSize
) {
16699 keccakState
.p1600(this.state
)
16707 Keccak
.prototype.copy = function (dest
) {
16708 for (var i
= 0; i
< 50; ++i
) dest
.state
[i
] = this.state
[i
]
16709 dest
.blockSize
= this.blockSize
16710 dest
.count
= this.count
16711 dest
.squeezing
= this.squeezing
16714 module
.exports
= Keccak
16716 }).call(this,require("buffer").Buffer
)
16717 },{"./keccak-state-unroll":69,"buffer":5}],71:[function(require
,module
,exports
){
16718 (function (Buffer
){
16721 code.google.com/p/crypto-js
16722 (c) 2009-2013 by Jeff Mott. All rights reserved.
16723 code.google.com/p/crypto-js/wiki/License
16726 (c) 2012 by Cédric Mesnil. All rights reserved.
16728 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
16730 - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
16731 - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
16733 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
16738 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16739 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
16740 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
16741 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
16742 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
16746 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
16747 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
16748 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
16749 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
16750 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
16754 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
16755 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
16756 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
16757 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
16758 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
16762 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
16763 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
16764 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
16765 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
16766 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
16769 var hl
= [0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]
16770 var hr
= [0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]
16772 function bytesToWords (bytes
) {
16774 for (var i
= 0, b
= 0; i
< bytes
.length
; i
++, b
+= 8) {
16775 words
[b
>>> 5] |= bytes
[i
] << (24 - b
% 32)
16780 function wordsToBytes (words
) {
16782 for (var b
= 0; b
< words
.length
* 32; b
+= 8) {
16783 bytes
.push((words
[b
>>> 5] >>> (24 - b
% 32)) & 0xFF)
16788 function processBlock (H
, M
, offset
) {
16790 for (var i
= 0; i
< 16; i
++) {
16791 var offset_i
= offset
+ i
16792 var M_offset_i
= M
[offset_i
]
16796 (((M_offset_i
<< 8) | (M_offset_i
>>> 24)) & 0x00ff00ff) |
16797 (((M_offset_i
<< 24) | (M_offset_i
>>> 8)) & 0xff00ff00)
16801 // Working variables
16802 var al
, bl
, cl
, dl
, el
16803 var ar
, br
, cr
, dr
, er
16813 for (i
= 0; i
< 80; i
+= 1) {
16814 t
= (al
+ M
[offset
+ zl
[i
]]) | 0
16816 t
+= f1(bl
, cl
, dl
) + hl
[0]
16817 } else if (i
< 32) {
16818 t
+= f2(bl
, cl
, dl
) + hl
[1]
16819 } else if (i
< 48) {
16820 t
+= f3(bl
, cl
, dl
) + hl
[2]
16821 } else if (i
< 64) {
16822 t
+= f4(bl
, cl
, dl
) + hl
[3]
16823 } else {// if (i<80) {
16824 t
+= f5(bl
, cl
, dl
) + hl
[4]
16835 t
= (ar
+ M
[offset
+ zr
[i
]]) | 0
16837 t
+= f5(br
, cr
, dr
) + hr
[0]
16838 } else if (i
< 32) {
16839 t
+= f4(br
, cr
, dr
) + hr
[1]
16840 } else if (i
< 48) {
16841 t
+= f3(br
, cr
, dr
) + hr
[2]
16842 } else if (i
< 64) {
16843 t
+= f2(br
, cr
, dr
) + hr
[3]
16844 } else {// if (i<80) {
16845 t
+= f1(br
, cr
, dr
) + hr
[4]
16858 // intermediate hash value
16859 t
= (H
[1] + cl
+ dr
) | 0
16860 H
[1] = (H
[2] + dl
+ er
) | 0
16861 H
[2] = (H
[3] + el
+ ar
) | 0
16862 H
[3] = (H
[4] + al
+ br
) | 0
16863 H
[4] = (H
[0] + bl
+ cr
) | 0
16867 function f1 (x
, y
, z
) {
16868 return ((x
) ^ (y
) ^ (z
))
16871 function f2 (x
, y
, z
) {
16872 return (((x
) & (y
)) | ((~x
) & (z
)))
16875 function f3 (x
, y
, z
) {
16876 return (((x
) | (~(y
))) ^ (z
))
16879 function f4 (x
, y
, z
) {
16880 return (((x
) & (z
)) | ((y
) & (~(z
))))
16883 function f5 (x
, y
, z
) {
16884 return ((x
) ^ ((y
) | (~(z
))))
16887 function rotl (x
, n
) {
16888 return (x
<< n
) | (x
>>> (32 - n
))
16891 function ripemd160 (message
) {
16892 var H
= [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]
16894 if (typeof message
=== 'string') {
16895 message
= new Buffer(message
, 'utf8')
16898 var m
= bytesToWords(message
)
16900 var nBitsLeft
= message
.length
* 8
16901 var nBitsTotal
= message
.length
* 8
16904 m
[nBitsLeft
>>> 5] |= 0x80 << (24 - nBitsLeft
% 32)
16905 m
[(((nBitsLeft
+ 64) >>> 9) << 4) + 14] = (
16906 (((nBitsTotal
<< 8) | (nBitsTotal
>>> 24)) & 0x00ff00ff) |
16907 (((nBitsTotal
<< 24) | (nBitsTotal
>>> 8)) & 0xff00ff00)
16910 for (var i
= 0; i
< m
.length
; i
+= 16) {
16911 processBlock(H
, m
, i
)
16915 for (i
= 0; i
< 5; i
++) {
16920 H
[i
] = (((H_i
<< 8) | (H_i
>>> 24)) & 0x00ff00ff) |
16921 (((H_i
<< 24) | (H_i
>>> 8)) & 0xff00ff00)
16924 var digestbytes
= wordsToBytes(H
)
16925 return new Buffer(digestbytes
)
16928 module
.exports
= ripemd160
16930 }).call(this,require("buffer").Buffer
)
16931 },{"buffer":5}],72:[function(require
,module
,exports
){
16932 (function (Buffer
){
16933 const assert
= require('assert')
16935 * RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP
16936 * This function takes in a data, convert it to buffer if not, and a length for recursion
16938 * @param {Buffer,String,Integer,Array} data - will be converted to buffer
16939 * @returns {Buffer} - returns buffer of encoded data
16941 exports
.encode = function (input
) {
16942 if (input
instanceof Array
) {
16944 for (var i
= 0; i
< input
.length
; i
++) {
16945 output
.push(exports
.encode(input
[i
]))
16947 var buf
= Buffer
.concat(output
)
16948 return Buffer
.concat([encodeLength(buf
.length
, 192), buf
])
16950 input
= toBuffer(input
)
16951 if (input
.length
=== 1 && input
[0] < 128) {
16954 return Buffer
.concat([encodeLength(input
.length
, 128), input
])
16959 function safeParseInt (v
, base
) {
16960 if (v
.slice(0, 2) === '00') {
16961 throw (new Error('invalid RLP: extra zeros'))
16964 return parseInt(v
, base
)
16967 function encodeLength (len
, offset
) {
16969 return new Buffer([len
+ offset
])
16971 var hexLength
= intToHex(len
)
16972 var lLength
= hexLength
.length
/ 2
16973 var firstByte
= intToHex(offset
+ 55 + lLength
)
16974 return new Buffer(firstByte
+ hexLength
, 'hex')
16979 * RLP Decoding based on: {@link https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP|RLP}
16980 * @param {Buffer,String,Integer,Array} data - will be converted to buffer
16981 * @returns {Array} - returns decode Array of Buffers containg the original message
16983 exports
.decode = function (input
, stream
) {
16984 if (!input
|| input
.length
=== 0) {
16985 return new Buffer([])
16988 input
= toBuffer(input
)
16989 var decoded
= _decode(input
)
16995 assert
.equal(decoded
.remainder
.length
, 0, 'invalid remainder')
16996 return decoded
.data
16999 exports
.getLength = function (input
) {
17000 if (!input
|| input
.length
=== 0) {
17001 return new Buffer([])
17004 input
= toBuffer(input
)
17005 var firstByte
= input
[0]
17006 if (firstByte
<= 0x7f) {
17007 return input
.length
17008 } else if (firstByte
<= 0xb7) {
17009 return firstByte
- 0x7f
17010 } else if (firstByte
<= 0xbf) {
17011 return firstByte
- 0xb6
17012 } else if (firstByte
<= 0xf7) {
17013 // a list between 0-55 bytes long
17014 return firstByte
- 0xbf
17016 // a list over 55 bytes long
17017 var llength
= firstByte
- 0xf6
17018 var length
= safeParseInt(input
.slice(1, llength
).toString('hex'), 16)
17019 return llength
+ length
17023 function _decode (input
) {
17024 var length
, llength
, data
, innerRemainder
, d
17026 var firstByte
= input
[0]
17028 if (firstByte
<= 0x7f) {
17029 // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.
17031 data: input
.slice(0, 1),
17032 remainder: input
.slice(1)
17034 } else if (firstByte
<= 0xb7) {
17035 // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string
17036 // The range of the first byte is [0x80, 0xb7]
17037 length
= firstByte
- 0x7f
17039 // set 0x80 null to 0
17040 if (firstByte
=== 0x80) {
17041 data
= new Buffer([])
17043 data
= input
.slice(1, length
)
17046 if (length
=== 2 && data
[0] < 0x80) {
17047 throw new Error('invalid rlp encoding: byte must be less 0x80')
17052 remainder: input
.slice(length
)
17054 } else if (firstByte
<= 0xbf) {
17055 llength
= firstByte
- 0xb6
17056 length
= safeParseInt(input
.slice(1, llength
).toString('hex'), 16)
17057 data
= input
.slice(llength
, length
+ llength
)
17058 if (data
.length
< length
) {
17059 throw (new Error('invalid RLP'))
17064 remainder: input
.slice(length
+ llength
)
17066 } else if (firstByte
<= 0xf7) {
17067 // a list between 0-55 bytes long
17068 length
= firstByte
- 0xbf
17069 innerRemainder
= input
.slice(1, length
)
17070 while (innerRemainder
.length
) {
17071 d
= _decode(innerRemainder
)
17072 decoded
.push(d
.data
)
17073 innerRemainder
= d
.remainder
17078 remainder: input
.slice(length
)
17081 // a list over 55 bytes long
17082 llength
= firstByte
- 0xf6
17083 length
= safeParseInt(input
.slice(1, llength
).toString('hex'), 16)
17084 var totalLength
= llength
+ length
17085 if (totalLength
> input
.length
) {
17086 throw new Error('invalid rlp: total length is larger than the data')
17089 innerRemainder
= input
.slice(llength
, totalLength
)
17090 if (innerRemainder
.length
=== 0) {
17091 throw new Error('invalid rlp, List has a invalid length')
17094 while (innerRemainder
.length
) {
17095 d
= _decode(innerRemainder
)
17096 decoded
.push(d
.data
)
17097 innerRemainder
= d
.remainder
17101 remainder: input
.slice(totalLength
)
17106 function isHexPrefixed (str
) {
17107 return str
.slice(0, 2) === '0x'
17110 // Removes 0x from a given String
17111 function stripHexPrefix (str
) {
17112 if (typeof str
!== 'string') {
17115 return isHexPrefixed(str
) ? str
.slice(2) : str
17118 function intToHex (i
) {
17119 var hex
= i
.toString(16)
17120 if (hex
.length
% 2) {
17127 function padToEven (a
) {
17128 if (a
.length
% 2) a
= '0' + a
17132 function intToBuffer (i
) {
17133 var hex
= intToHex(i
)
17134 return new Buffer(hex
, 'hex')
17137 function toBuffer (v
) {
17138 if (!Buffer
.isBuffer(v
)) {
17139 if (typeof v
=== 'string') {
17140 if (isHexPrefixed(v
)) {
17141 v
= new Buffer(padToEven(stripHexPrefix(v
)), 'hex')
17145 } else if (typeof v
=== 'number') {
17151 } else if (v
=== null || v
=== undefined) {
17153 } else if (v
.toArray
) {
17154 // converts a BN to a Buffer
17155 v
= new Buffer(v
.toArray())
17157 throw new Error('invalid type')
17163 }).call(this,require("buffer").Buffer
)
17164 },{"assert":1,"buffer":5}],73:[function(require
,module
,exports
){
17166 module
.exports
= require('./lib')(require('./lib/elliptic'))
17168 },{"./lib":77,"./lib/elliptic":76}],74:[function(require
,module
,exports
){
17169 (function (Buffer
){
17171 var toString
= Object
.prototype.toString
17174 exports
.isArray = function (value
, message
) {
17175 if (!Array
.isArray(value
)) throw TypeError(message
)
17178 exports
.isBoolean = function (value
, message
) {
17179 if (toString
.call(value
) !== '[object Boolean]') throw TypeError(message
)
17182 exports
.isBuffer = function (value
, message
) {
17183 if (!Buffer
.isBuffer(value
)) throw TypeError(message
)
17186 exports
.isFunction = function (value
, message
) {
17187 if (toString
.call(value
) !== '[object Function]') throw TypeError(message
)
17190 exports
.isNumber = function (value
, message
) {
17191 if (toString
.call(value
) !== '[object Number]') throw TypeError(message
)
17194 exports
.isObject = function (value
, message
) {
17195 if (toString
.call(value
) !== '[object Object]') throw TypeError(message
)
17199 exports
.isBufferLength = function (buffer
, length
, message
) {
17200 if (buffer
.length
!== length
) throw RangeError(message
)
17203 exports
.isBufferLength2 = function (buffer
, length1
, length2
, message
) {
17204 if (buffer
.length
!== length1
&& buffer
.length
!== length2
) throw RangeError(message
)
17207 exports
.isLengthGTZero = function (value
, message
) {
17208 if (value
.length
=== 0) throw RangeError(message
)
17211 exports
.isNumberInInterval = function (number
, x
, y
, message
) {
17212 if (number
<= x
|| number
>= y
) throw RangeError(message
)
17215 }).call(this,{"isBuffer":require("../../../../../.nvm/versions/node/v7.5.0/lib/node_modules/browserify/node_modules/is-buffer/index.js")})
17216 },{"../../../../../.nvm/versions/node/v7.5.0/lib/node_modules/browserify/node_modules/is-buffer/index.js":10}],75:[function(require
,module
,exports
){
17217 (function (Buffer
){
17219 var bip66
= require('bip66')
17221 var EC_PRIVKEY_EXPORT_DER_COMPRESSED
= new Buffer([
17223 0x30, 0x81, 0xd3, 0x02, 0x01, 0x01, 0x04, 0x20,
17225 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17226 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17228 0xa0, 0x81, 0x85, 0x30, 0x81, 0x82, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48,
17229 0xcE, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
17230 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
17231 0xff, 0xff, 0xfE, 0xff, 0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04,
17232 0x21, 0x02, 0x79, 0xbE, 0x66, 0x7E, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xcE, 0x87,
17233 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xcE, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8,
17234 0x17, 0x98, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
17235 0xff, 0xff, 0xff, 0xff, 0xfE, 0xba, 0xaE, 0xdc, 0xE6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5E,
17236 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01, 0x01, 0xa1, 0x24, 0x03, 0x22, 0x00,
17238 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17243 var EC_PRIVKEY_EXPORT_DER_UNCOMPRESSED
= new Buffer([
17245 0x30, 0x82, 0x01, 0x13, 0x02, 0x01, 0x01, 0x04, 0x20,
17247 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17248 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17250 0xa0, 0x81, 0xa5, 0x30, 0x81, 0xa2, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48,
17251 0xcE, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
17252 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
17253 0xff, 0xff, 0xfE, 0xff, 0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04,
17254 0x41, 0x04, 0x79, 0xbE, 0x66, 0x7E, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xcE, 0x87,
17255 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xcE, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8,
17256 0x17, 0x98, 0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, 0x0E, 0x11,
17257 0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48, 0xa6, 0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10,
17258 0xd4, 0xb8, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
17259 0xff, 0xff, 0xff, 0xff, 0xfE, 0xba, 0xaE, 0xdc, 0xE6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5E,
17260 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01, 0x01, 0xa1, 0x44, 0x03, 0x42, 0x00,
17262 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17263 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17264 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17265 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17269 var ZERO_BUFFER_32
= new Buffer([
17270 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
17271 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
17274 exports
.privateKeyExport = function (privateKey
, publicKey
, compressed
) {
17275 var result
= new Buffer(compressed
? EC_PRIVKEY_EXPORT_DER_COMPRESSED : EC_PRIVKEY_EXPORT_DER_UNCOMPRESSED
)
17276 privateKey
.copy(result
, compressed
? 8 : 9)
17277 publicKey
.copy(result
, compressed
? 181 : 214)
17281 exports
.privateKeyImport = function (privateKey
) {
17282 var length
= privateKey
.length
17286 if (length
< index
+ 1 || privateKey
[index
] !== 0x30) return
17289 // sequence length constructor
17290 if (length
< index
+ 1 || !(privateKey
[index
] & 0x80)) return
17292 var lenb
= privateKey
[index
] & 0x7f
17294 if (lenb
< 1 || lenb
> 2) return
17295 if (length
< index
+ lenb
) return
17298 var len
= privateKey
[index
+ lenb
- 1] | (lenb
> 1 ? privateKey
[index
+ lenb
- 2] << 8 : 0)
17300 if (length
< index
+ len
) return
17302 // sequence element 0: version number (=1)
17303 if (length
< index
+ 3 ||
17304 privateKey
[index
] !== 0x02 ||
17305 privateKey
[index
+ 1] !== 0x01 ||
17306 privateKey
[index
+ 2] !== 0x01) {
17311 // sequence element 1: octet string, up to 32 bytes
17312 if (length
< index
+ 2 ||
17313 privateKey
[index
] !== 0x04 ||
17314 privateKey
[index
+ 1] > 0x20 ||
17315 length
< index
+ 2 + privateKey
[index
+ 1]) {
17319 return privateKey
.slice(index
+ 2, index
+ 2 + privateKey
[index
+ 1])
17322 exports
.signatureExport = function (sigObj
) {
17323 var r
= Buffer
.concat([new Buffer([0]), sigObj
.r
])
17324 for (var lenR
= 33, posR
= 0; lenR
> 1 && r
[posR
] === 0x00 && !(r
[posR
+ 1] & 0x80); --lenR
, ++posR
);
17326 var s
= Buffer
.concat([new Buffer([0]), sigObj
.s
])
17327 for (var lenS
= 33, posS
= 0; lenS
> 1 && s
[posS
] === 0x00 && !(s
[posS
+ 1] & 0x80); --lenS
, ++posS
);
17329 return bip66
.encode(r
.slice(posR
), s
.slice(posS
))
17332 exports
.signatureImport = function (sig
) {
17333 var r
= new Buffer(ZERO_BUFFER_32
)
17334 var s
= new Buffer(ZERO_BUFFER_32
)
17337 var sigObj
= bip66
.decode(sig
)
17338 if (sigObj
.r
.length
=== 33 && sigObj
.r
[0] === 0x00) sigObj
.r
= sigObj
.r
.slice(1)
17339 if (sigObj
.r
.length
> 32) throw new Error('R length is too long')
17340 if (sigObj
.s
.length
=== 33 && sigObj
.s
[0] === 0x00) sigObj
.s
= sigObj
.s
.slice(1)
17341 if (sigObj
.s
.length
> 32) throw new Error('S length is too long')
17346 sigObj
.r
.copy(r
, 32 - sigObj
.r
.length
)
17347 sigObj
.s
.copy(s
, 32 - sigObj
.s
.length
)
17349 return { r: r
, s: s
}
17352 exports
.signatureImportLax = function (sig
) {
17353 var r
= new Buffer(ZERO_BUFFER_32
)
17354 var s
= new Buffer(ZERO_BUFFER_32
)
17356 var length
= sig
.length
17359 // sequence tag byte
17360 if (sig
[index
++] !== 0x30) return
17362 // sequence length byte
17363 var lenbyte
= sig
[index
++]
17364 if (lenbyte
& 0x80) {
17365 index
+= lenbyte
- 0x80
17366 if (index
> length
) return
17369 // sequence tag byte for r
17370 if (sig
[index
++] !== 0x02) return
17373 var rlen
= sig
[index
++]
17375 lenbyte
= rlen
- 0x80
17376 if (index
+ lenbyte
> length
) return
17377 for (; lenbyte
> 0 && sig
[index
] === 0x00; index
+= 1, lenbyte
-= 1);
17378 for (rlen
= 0; lenbyte
> 0; index
+= 1, lenbyte
-= 1) rlen
= (rlen
<< 8) + sig
[index
]
17380 if (rlen
> length
- index
) return
17384 // sequence tag byte for s
17385 if (sig
[index
++] !== 0x02) return
17388 var slen
= sig
[index
++]
17390 lenbyte
= slen
- 0x80
17391 if (index
+ lenbyte
> length
) return
17392 for (; lenbyte
> 0 && sig
[index
] === 0x00; index
+= 1, lenbyte
-= 1);
17393 for (slen
= 0; lenbyte
> 0; index
+= 1, lenbyte
-= 1) slen
= (slen
<< 8) + sig
[index
]
17395 if (slen
> length
- index
) return
17399 // ignore leading zeros in r
17400 for (; rlen
> 0 && sig
[rindex
] === 0x00; rlen
-= 1, rindex
+= 1);
17402 if (rlen
> 32) return
17403 var rvalue
= sig
.slice(rindex
, rindex
+ rlen
)
17404 rvalue
.copy(r
, 32 - rvalue
.length
)
17406 // ignore leading zeros in s
17407 for (; slen
> 0 && sig
[sindex
] === 0x00; slen
-= 1, sindex
+= 1);
17409 if (slen
> 32) return
17410 var svalue
= sig
.slice(sindex
, sindex
+ slen
)
17411 svalue
.copy(s
, 32 - svalue
.length
)
17413 return { r: r
, s: s
}
17416 }).call(this,require("buffer").Buffer
)
17417 },{"bip66":32,"buffer":5}],76:[function(require
,module
,exports
){
17418 (function (Buffer
){
17420 var createHash
= require('create-hash')
17421 var BN
= require('bn.js')
17422 var EC
= require('elliptic').ec
17424 var messages
= require('../messages.json')
17426 var ec
= new EC('secp256k1')
17427 var ecparams
= ec
.curve
17429 function loadCompressedPublicKey (first
, xBuffer
) {
17430 var x
= new BN(xBuffer
)
17433 if (x
.cmp(ecparams
.p
) >= 0) return null
17434 x
= x
.toRed(ecparams
.red
)
17436 // compute corresponding Y
17437 var y
= x
.redSqr().redIMul(x
).redIAdd(ecparams
.b
).redSqrt()
17438 if ((first
=== 0x03) !== y
.isOdd()) y
= y
.redNeg()
17440 return ec
.keyPair({ pub: { x: x
, y: y
} })
17443 function loadUncompressedPublicKey (first
, xBuffer
, yBuffer
) {
17444 var x
= new BN(xBuffer
)
17445 var y
= new BN(yBuffer
)
17448 if (x
.cmp(ecparams
.p
) >= 0 || y
.cmp(ecparams
.p
) >= 0) return null
17450 x
= x
.toRed(ecparams
.red
)
17451 y
= y
.toRed(ecparams
.red
)
17454 if ((first
=== 0x06 || first
=== 0x07) && y
.isOdd() !== (first
=== 0x07)) return null
17457 var x3
= x
.redSqr().redIMul(x
)
17458 if (!y
.redSqr().redISub(x3
.redIAdd(ecparams
.b
)).isZero()) return null
17460 return ec
.keyPair({ pub: { x: x
, y: y
} })
17463 function loadPublicKey (publicKey
) {
17464 var first
= publicKey
[0]
17468 if (publicKey
.length
!== 33) return null
17469 return loadCompressedPublicKey(first
, publicKey
.slice(1, 33))
17473 if (publicKey
.length
!== 65) return null
17474 return loadUncompressedPublicKey(first
, publicKey
.slice(1, 33), publicKey
.slice(33, 65))
17480 exports
.privateKeyVerify = function (privateKey
) {
17481 var bn
= new BN(privateKey
)
17482 return bn
.cmp(ecparams
.n
) < 0 && !bn
.isZero()
17485 exports
.privateKeyExport = function (privateKey
, compressed
) {
17486 var d
= new BN(privateKey
)
17487 if (d
.cmp(ecparams
.n
) >= 0 || d
.isZero()) throw new Error(messages
.EC_PRIVATE_KEY_EXPORT_DER_FAIL
)
17489 return new Buffer(ec
.keyFromPrivate(privateKey
).getPublic(compressed
, true))
17492 exports
.privateKeyTweakAdd = function (privateKey
, tweak
) {
17493 var bn
= new BN(tweak
)
17494 if (bn
.cmp(ecparams
.n
) >= 0) throw new Error(messages
.EC_PRIVATE_KEY_TWEAK_ADD_FAIL
)
17496 bn
.iadd(new BN(privateKey
))
17497 if (bn
.cmp(ecparams
.n
) >= 0) bn
.isub(ecparams
.n
)
17498 if (bn
.isZero()) throw new Error(messages
.EC_PRIVATE_KEY_TWEAK_ADD_FAIL
)
17500 return bn
.toArrayLike(Buffer
, 'be', 32)
17503 exports
.privateKeyTweakMul = function (privateKey
, tweak
) {
17504 var bn
= new BN(tweak
)
17505 if (bn
.cmp(ecparams
.n
) >= 0 || bn
.isZero()) throw new Error(messages
.EC_PRIVATE_KEY_TWEAK_MUL_FAIL
)
17507 bn
.imul(new BN(privateKey
))
17508 if (bn
.cmp(ecparams
.n
)) bn
= bn
.umod(ecparams
.n
)
17510 return bn
.toArrayLike(Buffer
, 'be', 32)
17513 exports
.publicKeyCreate = function (privateKey
, compressed
) {
17514 var d
= new BN(privateKey
)
17515 if (d
.cmp(ecparams
.n
) >= 0 || d
.isZero()) throw new Error(messages
.EC_PUBLIC_KEY_CREATE_FAIL
)
17517 return new Buffer(ec
.keyFromPrivate(privateKey
).getPublic(compressed
, true))
17520 exports
.publicKeyConvert = function (publicKey
, compressed
) {
17521 var pair
= loadPublicKey(publicKey
)
17522 if (pair
=== null) throw new Error(messages
.EC_PUBLIC_KEY_PARSE_FAIL
)
17524 return new Buffer(pair
.getPublic(compressed
, true))
17527 exports
.publicKeyVerify = function (publicKey
) {
17528 return loadPublicKey(publicKey
) !== null
17531 exports
.publicKeyTweakAdd = function (publicKey
, tweak
, compressed
) {
17532 var pair
= loadPublicKey(publicKey
)
17533 if (pair
=== null) throw new Error(messages
.EC_PUBLIC_KEY_PARSE_FAIL
)
17535 tweak
= new BN(tweak
)
17536 if (tweak
.cmp(ecparams
.n
) >= 0) throw new Error(messages
.EC_PUBLIC_KEY_TWEAK_ADD_FAIL
)
17538 return new Buffer(ecparams
.g
.mul(tweak
).add(pair
.pub
).encode(true, compressed
))
17541 exports
.publicKeyTweakMul = function (publicKey
, tweak
, compressed
) {
17542 var pair
= loadPublicKey(publicKey
)
17543 if (pair
=== null) throw new Error(messages
.EC_PUBLIC_KEY_PARSE_FAIL
)
17545 tweak
= new BN(tweak
)
17546 if (tweak
.cmp(ecparams
.n
) >= 0 || tweak
.isZero()) throw new Error(messages
.EC_PUBLIC_KEY_TWEAK_MUL_FAIL
)
17548 return new Buffer(pair
.pub
.mul(tweak
).encode(true, compressed
))
17551 exports
.publicKeyCombine = function (publicKeys
, compressed
) {
17552 var pairs
= new Array(publicKeys
.length
)
17553 for (var i
= 0; i
< publicKeys
.length
; ++i
) {
17554 pairs
[i
] = loadPublicKey(publicKeys
[i
])
17555 if (pairs
[i
] === null) throw new Error(messages
.EC_PUBLIC_KEY_PARSE_FAIL
)
17558 var point
= pairs
[0].pub
17559 for (var j
= 1; j
< pairs
.length
; ++j
) point
= point
.add(pairs
[j
].pub
)
17560 if (point
.isInfinity()) throw new Error(messages
.EC_PUBLIC_KEY_COMBINE_FAIL
)
17562 return new Buffer(point
.encode(true, compressed
))
17565 exports
.signatureNormalize = function (signature
) {
17566 var r
= new BN(signature
.slice(0, 32))
17567 var s
= new BN(signature
.slice(32, 64))
17568 if (r
.cmp(ecparams
.n
) >= 0 || s
.cmp(ecparams
.n
) >= 0) throw new Error(messages
.ECDSA_SIGNATURE_PARSE_FAIL
)
17570 var result
= new Buffer(signature
)
17571 if (s
.cmp(ec
.nh
) === 1) ecparams
.n
.sub(s
).toArrayLike(Buffer
, 'be', 32).copy(result
, 32)
17576 exports
.signatureExport = function (signature
) {
17577 var r
= signature
.slice(0, 32)
17578 var s
= signature
.slice(32, 64)
17579 if (new BN(r
).cmp(ecparams
.n
) >= 0 || new BN(s
).cmp(ecparams
.n
) >= 0) throw new Error(messages
.ECDSA_SIGNATURE_PARSE_FAIL
)
17581 return { r: r
, s: s
}
17584 exports
.signatureImport = function (sigObj
) {
17585 var r
= new BN(sigObj
.r
)
17586 if (r
.cmp(ecparams
.n
) >= 0) r
= new BN(0)
17588 var s
= new BN(sigObj
.s
)
17589 if (s
.cmp(ecparams
.n
) >= 0) s
= new BN(0)
17591 return Buffer
.concat([
17592 r
.toArrayLike(Buffer
, 'be', 32),
17593 s
.toArrayLike(Buffer
, 'be', 32)
17597 exports
.sign = function (message
, privateKey
, noncefn
, data
) {
17598 if (typeof noncefn
=== 'function') {
17599 var getNonce
= noncefn
17600 noncefn = function (counter
) {
17601 var nonce
= getNonce(message
, privateKey
, null, data
, counter
)
17602 if (!Buffer
.isBuffer(nonce
) || nonce
.length
!== 32) throw new Error(messages
.ECDSA_SIGN_FAIL
)
17604 return new BN(nonce
)
17608 var d
= new BN(privateKey
)
17609 if (d
.cmp(ecparams
.n
) >= 0 || d
.isZero()) throw new Error(messages
.ECDSA_SIGN_FAIL
)
17611 var result
= ec
.sign(message
, privateKey
, { canonical: true, k: noncefn
, pers: data
})
17613 signature: Buffer
.concat([
17614 result
.r
.toArrayLike(Buffer
, 'be', 32),
17615 result
.s
.toArrayLike(Buffer
, 'be', 32)
17617 recovery: result
.recoveryParam
17621 exports
.verify = function (message
, signature
, publicKey
) {
17622 var sigObj
= {r: signature
.slice(0, 32), s: signature
.slice(32, 64)}
17624 var sigr
= new BN(sigObj
.r
)
17625 var sigs
= new BN(sigObj
.s
)
17626 if (sigr
.cmp(ecparams
.n
) >= 0 || sigs
.cmp(ecparams
.n
) >= 0) throw new Error(messages
.ECDSA_SIGNATURE_PARSE_FAIL
)
17627 if (sigs
.cmp(ec
.nh
) === 1 || sigr
.isZero() || sigs
.isZero()) return false
17629 var pair
= loadPublicKey(publicKey
)
17630 if (pair
=== null) throw new Error(messages
.EC_PUBLIC_KEY_PARSE_FAIL
)
17632 return ec
.verify(message
, sigObj
, {x: pair
.pub
.x
, y: pair
.pub
.y
})
17635 exports
.recover = function (message
, signature
, recovery
, compressed
) {
17636 var sigObj
= {r: signature
.slice(0, 32), s: signature
.slice(32, 64)}
17638 var sigr
= new BN(sigObj
.r
)
17639 var sigs
= new BN(sigObj
.s
)
17640 if (sigr
.cmp(ecparams
.n
) >= 0 || sigs
.cmp(ecparams
.n
) >= 0) throw new Error(messages
.ECDSA_SIGNATURE_PARSE_FAIL
)
17643 if (sigr
.isZero() || sigs
.isZero()) throw new Error()
17645 var point
= ec
.recoverPubKey(message
, sigObj
, recovery
)
17646 return new Buffer(point
.encode(true, compressed
))
17648 throw new Error(messages
.ECDSA_RECOVER_FAIL
)
17652 exports
.ecdh = function (publicKey
, privateKey
) {
17653 var shared
= exports
.ecdhUnsafe(publicKey
, privateKey
, true)
17654 return createHash('sha256').update(shared
).digest()
17657 exports
.ecdhUnsafe = function (publicKey
, privateKey
, compressed
) {
17658 var pair
= loadPublicKey(publicKey
)
17659 if (pair
=== null) throw new Error(messages
.EC_PUBLIC_KEY_PARSE_FAIL
)
17661 var scalar
= new BN(privateKey
)
17662 if (scalar
.cmp(ecparams
.n
) >= 0 || scalar
.isZero()) throw new Error(messages
.ECDH_FAIL
)
17664 return new Buffer(pair
.pub
.mul(scalar
).encode(true, compressed
))
17667 }).call(this,require("buffer").Buffer
)
17668 },{"../messages.json":78,"bn.js":33,"buffer":5,"create-hash":36,"elliptic":39}],77:[function(require
,module
,exports
){
17670 var assert
= require('./assert')
17671 var der
= require('./der')
17672 var messages
= require('./messages.json')
17674 function initCompressedValue (value
, defaultValue
) {
17675 if (value
=== undefined) return defaultValue
17677 assert
.isBoolean(value
, messages
.COMPRESSED_TYPE_INVALID
)
17681 module
.exports = function (secp256k1
) {
17683 privateKeyVerify: function (privateKey
) {
17684 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17685 return privateKey
.length
=== 32 && secp256k1
.privateKeyVerify(privateKey
)
17688 privateKeyExport: function (privateKey
, compressed
) {
17689 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17690 assert
.isBufferLength(privateKey
, 32, messages
.EC_PRIVATE_KEY_LENGTH_INVALID
)
17692 compressed
= initCompressedValue(compressed
, true)
17693 var publicKey
= secp256k1
.privateKeyExport(privateKey
, compressed
)
17695 return der
.privateKeyExport(privateKey
, publicKey
, compressed
)
17698 privateKeyImport: function (privateKey
) {
17699 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17701 privateKey
= der
.privateKeyImport(privateKey
)
17702 if (privateKey
&& privateKey
.length
=== 32 && secp256k1
.privateKeyVerify(privateKey
)) return privateKey
17704 throw new Error(messages
.EC_PRIVATE_KEY_IMPORT_DER_FAIL
)
17707 privateKeyTweakAdd: function (privateKey
, tweak
) {
17708 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17709 assert
.isBufferLength(privateKey
, 32, messages
.EC_PRIVATE_KEY_LENGTH_INVALID
)
17711 assert
.isBuffer(tweak
, messages
.TWEAK_TYPE_INVALID
)
17712 assert
.isBufferLength(tweak
, 32, messages
.TWEAK_LENGTH_INVALID
)
17714 return secp256k1
.privateKeyTweakAdd(privateKey
, tweak
)
17717 privateKeyTweakMul: function (privateKey
, tweak
) {
17718 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17719 assert
.isBufferLength(privateKey
, 32, messages
.EC_PRIVATE_KEY_LENGTH_INVALID
)
17721 assert
.isBuffer(tweak
, messages
.TWEAK_TYPE_INVALID
)
17722 assert
.isBufferLength(tweak
, 32, messages
.TWEAK_LENGTH_INVALID
)
17724 return secp256k1
.privateKeyTweakMul(privateKey
, tweak
)
17727 publicKeyCreate: function (privateKey
, compressed
) {
17728 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17729 assert
.isBufferLength(privateKey
, 32, messages
.EC_PRIVATE_KEY_LENGTH_INVALID
)
17731 compressed
= initCompressedValue(compressed
, true)
17733 return secp256k1
.publicKeyCreate(privateKey
, compressed
)
17736 publicKeyConvert: function (publicKey
, compressed
) {
17737 assert
.isBuffer(publicKey
, messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17738 assert
.isBufferLength2(publicKey
, 33, 65, messages
.EC_PUBLIC_KEY_LENGTH_INVALID
)
17740 compressed
= initCompressedValue(compressed
, true)
17742 return secp256k1
.publicKeyConvert(publicKey
, compressed
)
17745 publicKeyVerify: function (publicKey
) {
17746 assert
.isBuffer(publicKey
, messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17747 return secp256k1
.publicKeyVerify(publicKey
)
17750 publicKeyTweakAdd: function (publicKey
, tweak
, compressed
) {
17751 assert
.isBuffer(publicKey
, messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17752 assert
.isBufferLength2(publicKey
, 33, 65, messages
.EC_PUBLIC_KEY_LENGTH_INVALID
)
17754 assert
.isBuffer(tweak
, messages
.TWEAK_TYPE_INVALID
)
17755 assert
.isBufferLength(tweak
, 32, messages
.TWEAK_LENGTH_INVALID
)
17757 compressed
= initCompressedValue(compressed
, true)
17759 return secp256k1
.publicKeyTweakAdd(publicKey
, tweak
, compressed
)
17762 publicKeyTweakMul: function (publicKey
, tweak
, compressed
) {
17763 assert
.isBuffer(publicKey
, messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17764 assert
.isBufferLength2(publicKey
, 33, 65, messages
.EC_PUBLIC_KEY_LENGTH_INVALID
)
17766 assert
.isBuffer(tweak
, messages
.TWEAK_TYPE_INVALID
)
17767 assert
.isBufferLength(tweak
, 32, messages
.TWEAK_LENGTH_INVALID
)
17769 compressed
= initCompressedValue(compressed
, true)
17771 return secp256k1
.publicKeyTweakMul(publicKey
, tweak
, compressed
)
17774 publicKeyCombine: function (publicKeys
, compressed
) {
17775 assert
.isArray(publicKeys
, messages
.EC_PUBLIC_KEYS_TYPE_INVALID
)
17776 assert
.isLengthGTZero(publicKeys
, messages
.EC_PUBLIC_KEYS_LENGTH_INVALID
)
17777 for (var i
= 0; i
< publicKeys
.length
; ++i
) {
17778 assert
.isBuffer(publicKeys
[i
], messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17779 assert
.isBufferLength2(publicKeys
[i
], 33, 65, messages
.EC_PUBLIC_KEY_LENGTH_INVALID
)
17782 compressed
= initCompressedValue(compressed
, true)
17784 return secp256k1
.publicKeyCombine(publicKeys
, compressed
)
17787 signatureNormalize: function (signature
) {
17788 assert
.isBuffer(signature
, messages
.ECDSA_SIGNATURE_TYPE_INVALID
)
17789 assert
.isBufferLength(signature
, 64, messages
.ECDSA_SIGNATURE_LENGTH_INVALID
)
17791 return secp256k1
.signatureNormalize(signature
)
17794 signatureExport: function (signature
) {
17795 assert
.isBuffer(signature
, messages
.ECDSA_SIGNATURE_TYPE_INVALID
)
17796 assert
.isBufferLength(signature
, 64, messages
.ECDSA_SIGNATURE_LENGTH_INVALID
)
17798 var sigObj
= secp256k1
.signatureExport(signature
)
17799 return der
.signatureExport(sigObj
)
17802 signatureImport: function (sig
) {
17803 assert
.isBuffer(sig
, messages
.ECDSA_SIGNATURE_TYPE_INVALID
)
17804 assert
.isLengthGTZero(sig
, messages
.ECDSA_SIGNATURE_LENGTH_INVALID
)
17806 var sigObj
= der
.signatureImport(sig
)
17807 if (sigObj
) return secp256k1
.signatureImport(sigObj
)
17809 throw new Error(messages
.ECDSA_SIGNATURE_PARSE_DER_FAIL
)
17812 signatureImportLax: function (sig
) {
17813 assert
.isBuffer(sig
, messages
.ECDSA_SIGNATURE_TYPE_INVALID
)
17814 assert
.isLengthGTZero(sig
, messages
.ECDSA_SIGNATURE_LENGTH_INVALID
)
17816 var sigObj
= der
.signatureImportLax(sig
)
17817 if (sigObj
) return secp256k1
.signatureImport(sigObj
)
17819 throw new Error(messages
.ECDSA_SIGNATURE_PARSE_DER_FAIL
)
17822 sign: function (message
, privateKey
, options
) {
17823 assert
.isBuffer(message
, messages
.MSG32_TYPE_INVALID
)
17824 assert
.isBufferLength(message
, 32, messages
.MSG32_LENGTH_INVALID
)
17826 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17827 assert
.isBufferLength(privateKey
, 32, messages
.EC_PRIVATE_KEY_LENGTH_INVALID
)
17831 if (options
!== undefined) {
17832 assert
.isObject(options
, messages
.OPTIONS_TYPE_INVALID
)
17834 if (options
.data
!== undefined) {
17835 assert
.isBuffer(options
.data
, messages
.OPTIONS_DATA_TYPE_INVALID
)
17836 assert
.isBufferLength(options
.data
, 32, messages
.OPTIONS_DATA_LENGTH_INVALID
)
17837 data
= options
.data
17840 if (options
.noncefn
!== undefined) {
17841 assert
.isFunction(options
.noncefn
, messages
.OPTIONS_NONCEFN_TYPE_INVALID
)
17842 noncefn
= options
.noncefn
17846 return secp256k1
.sign(message
, privateKey
, noncefn
, data
)
17849 verify: function (message
, signature
, publicKey
) {
17850 assert
.isBuffer(message
, messages
.MSG32_TYPE_INVALID
)
17851 assert
.isBufferLength(message
, 32, messages
.MSG32_LENGTH_INVALID
)
17853 assert
.isBuffer(signature
, messages
.ECDSA_SIGNATURE_TYPE_INVALID
)
17854 assert
.isBufferLength(signature
, 64, messages
.ECDSA_SIGNATURE_LENGTH_INVALID
)
17856 assert
.isBuffer(publicKey
, messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17857 assert
.isBufferLength2(publicKey
, 33, 65, messages
.EC_PUBLIC_KEY_LENGTH_INVALID
)
17859 return secp256k1
.verify(message
, signature
, publicKey
)
17862 recover: function (message
, signature
, recovery
, compressed
) {
17863 assert
.isBuffer(message
, messages
.MSG32_TYPE_INVALID
)
17864 assert
.isBufferLength(message
, 32, messages
.MSG32_LENGTH_INVALID
)
17866 assert
.isBuffer(signature
, messages
.ECDSA_SIGNATURE_TYPE_INVALID
)
17867 assert
.isBufferLength(signature
, 64, messages
.ECDSA_SIGNATURE_LENGTH_INVALID
)
17869 assert
.isNumber(recovery
, messages
.RECOVERY_ID_TYPE_INVALID
)
17870 assert
.isNumberInInterval(recovery
, -1, 4, messages
.RECOVERY_ID_VALUE_INVALID
)
17872 compressed
= initCompressedValue(compressed
, true)
17874 return secp256k1
.recover(message
, signature
, recovery
, compressed
)
17877 ecdh: function (publicKey
, privateKey
) {
17878 assert
.isBuffer(publicKey
, messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17879 assert
.isBufferLength2(publicKey
, 33, 65, messages
.EC_PUBLIC_KEY_LENGTH_INVALID
)
17881 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17882 assert
.isBufferLength(privateKey
, 32, messages
.EC_PRIVATE_KEY_LENGTH_INVALID
)
17884 return secp256k1
.ecdh(publicKey
, privateKey
)
17887 ecdhUnsafe: function (publicKey
, privateKey
, compressed
) {
17888 assert
.isBuffer(publicKey
, messages
.EC_PUBLIC_KEY_TYPE_INVALID
)
17889 assert
.isBufferLength2(publicKey
, 33, 65, messages
.EC_PUBLIC_KEY_LENGTH_INVALID
)
17891 assert
.isBuffer(privateKey
, messages
.EC_PRIVATE_KEY_TYPE_INVALID
)
17892 assert
.isBufferLength(privateKey
, 32, messages
.EC_PRIVATE_KEY_LENGTH_INVALID
)
17894 compressed
= initCompressedValue(compressed
, true)
17896 return secp256k1
.ecdhUnsafe(publicKey
, privateKey
, compressed
)
17901 },{"./assert":74,"./der":75,"./messages.json":78}],78:[function(require
,module
,exports
){
17903 "COMPRESSED_TYPE_INVALID": "compressed should be a boolean",
17904 "EC_PRIVATE_KEY_TYPE_INVALID": "private key should be a Buffer",
17905 "EC_PRIVATE_KEY_LENGTH_INVALID": "private key length is invalid",
17906 "EC_PRIVATE_KEY_TWEAK_ADD_FAIL": "tweak out of range or resulting private key is invalid",
17907 "EC_PRIVATE_KEY_TWEAK_MUL_FAIL": "tweak out of range",
17908 "EC_PRIVATE_KEY_EXPORT_DER_FAIL": "couldn't export to DER format",
17909 "EC_PRIVATE_KEY_IMPORT_DER_FAIL": "couldn't import from DER format",
17910 "EC_PUBLIC_KEYS_TYPE_INVALID": "public keys should be an Array",
17911 "EC_PUBLIC_KEYS_LENGTH_INVALID": "public keys Array should have at least 1 element",
17912 "EC_PUBLIC_KEY_TYPE_INVALID": "public key should be a Buffer",
17913 "EC_PUBLIC_KEY_LENGTH_INVALID": "public key length is invalid",
17914 "EC_PUBLIC_KEY_PARSE_FAIL": "the public key could not be parsed or is invalid",
17915 "EC_PUBLIC_KEY_CREATE_FAIL": "private was invalid, try again",
17916 "EC_PUBLIC_KEY_TWEAK_ADD_FAIL": "tweak out of range or resulting public key is invalid",
17917 "EC_PUBLIC_KEY_TWEAK_MUL_FAIL": "tweak out of range",
17918 "EC_PUBLIC_KEY_COMBINE_FAIL": "the sum of the public keys is not valid",
17919 "ECDH_FAIL": "scalar was invalid (zero or overflow)",
17920 "ECDSA_SIGNATURE_TYPE_INVALID": "signature should be a Buffer",
17921 "ECDSA_SIGNATURE_LENGTH_INVALID": "signature length is invalid",
17922 "ECDSA_SIGNATURE_PARSE_FAIL": "couldn't parse signature",
17923 "ECDSA_SIGNATURE_PARSE_DER_FAIL": "couldn't parse DER signature",
17924 "ECDSA_SIGNATURE_SERIALIZE_DER_FAIL": "couldn't serialize signature to DER format",
17925 "ECDSA_SIGN_FAIL": "nonce generation function failed or private key is invalid",
17926 "ECDSA_RECOVER_FAIL": "couldn't recover public key from signature",
17927 "MSG32_TYPE_INVALID": "message should be a Buffer",
17928 "MSG32_LENGTH_INVALID": "message length is invalid",
17929 "OPTIONS_TYPE_INVALID": "options should be an Object",
17930 "OPTIONS_DATA_TYPE_INVALID": "options.data should be a Buffer",
17931 "OPTIONS_DATA_LENGTH_INVALID": "options.data length is invalid",
17932 "OPTIONS_NONCEFN_TYPE_INVALID": "options.noncefn should be a Function",
17933 "RECOVERY_ID_TYPE_INVALID": "recovery should be a Number",
17934 "RECOVERY_ID_VALUE_INVALID": "recovery should have value between -1 and 4",
17935 "TWEAK_TYPE_INVALID": "tweak should be a Buffer",
17936 "TWEAK_LENGTH_INVALID": "tweak length is invalid"
17939 },{}],79:[function(require
,module
,exports
){
17940 (function (Buffer
){
17941 // prototype class for hash functions
17942 function Hash (blockSize
, finalSize
) {
17943 this._block
= new Buffer(blockSize
)
17944 this._finalSize
= finalSize
17945 this._blockSize
= blockSize
17950 Hash
.prototype.update = function (data
, enc
) {
17951 if (typeof data
=== 'string') {
17952 enc
= enc
|| 'utf8'
17953 data
= new Buffer(data
, enc
)
17956 var l
= this._len
+= data
.length
17957 var s
= this._s
|| 0
17959 var buffer
= this._block
17962 var t
= Math
.min(data
.length
, f
+ this._blockSize
- (s
% this._blockSize
))
17965 for (var i
= 0; i
< ch
; i
++) {
17966 buffer
[(s
% this._blockSize
) + i
] = data
[i
+ f
]
17972 if ((s
% this._blockSize
) === 0) {
17973 this._update(buffer
)
17981 Hash
.prototype.digest = function (enc
) {
17982 // Suppose the length of the message M, in bits, is l
17983 var l
= this._len
* 8
17985 // Append the bit 1 to the end of the message
17986 this._block
[this._len
% this._blockSize
] = 0x80
17988 // and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
17989 this._block
.fill(0, this._len
% this._blockSize
+ 1)
17991 if (l
% (this._blockSize
* 8) >= this._finalSize
* 8) {
17992 this._update(this._block
)
17993 this._block
.fill(0)
17996 // to this append the block which is equal to the number l written in binary
17997 // TODO: handle case where l is > Math.pow(2, 29)
17998 this._block
.writeInt32BE(l
, this._blockSize
- 4)
18000 var hash
= this._update(this._block
) || this._hash()
18002 return enc
? hash
.toString(enc
) : hash
18005 Hash
.prototype._update = function () {
18006 throw new Error('_update must be implemented by subclass')
18009 module
.exports
= Hash
18011 }).call(this,require("buffer").Buffer
)
18012 },{"buffer":5}],80:[function(require
,module
,exports
){
18013 var exports
= module
.exports
= function SHA (algorithm
) {
18014 algorithm
= algorithm
.toLowerCase()
18016 var Algorithm
= exports
[algorithm
]
18017 if (!Algorithm
) throw new Error(algorithm
+ ' is not supported (we accept pull requests)')
18019 return new Algorithm()
18022 exports
.sha
= require('./sha')
18023 exports
.sha1
= require('./sha1')
18024 exports
.sha224
= require('./sha224')
18025 exports
.sha256
= require('./sha256')
18026 exports
.sha384
= require('./sha384')
18027 exports
.sha512
= require('./sha512')
18029 },{"./sha":81,"./sha1":82,"./sha224":83,"./sha256":84,"./sha384":85,"./sha512":86}],81:[function(require
,module
,exports
){
18030 (function (Buffer
){
18032 * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
18033 * in FIPS PUB 180-1
18034 * This source code is derived from sha1.js of the same repository.
18035 * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
18036 * operation was added.
18039 var inherits
= require('inherits')
18040 var Hash
= require('./hash')
18043 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
18046 var W
= new Array(80)
18052 Hash
.call(this, 64, 56)
18055 inherits(Sha
, Hash
)
18057 Sha
.prototype.init = function () {
18058 this._a
= 0x67452301
18059 this._b
= 0xefcdab89
18060 this._c
= 0x98badcfe
18061 this._d
= 0x10325476
18062 this._e
= 0xc3d2e1f0
18067 function rotl5 (num
) {
18068 return (num
<< 5) | (num
>>> 27)
18071 function rotl30 (num
) {
18072 return (num
<< 30) | (num
>>> 2)
18075 function ft (s
, b
, c
, d
) {
18076 if (s
=== 0) return (b
& c
) | ((~b
) & d
)
18077 if (s
=== 2) return (b
& c
) | (b
& d
) | (c
& d
)
18081 Sha
.prototype._update = function (M
) {
18084 var a
= this._a
| 0
18085 var b
= this._b
| 0
18086 var c
= this._c
| 0
18087 var d
= this._d
| 0
18088 var e
= this._e
| 0
18090 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
18091 for (; i
< 80; ++i
) W
[i
] = W
[i
- 3] ^ W
[i
- 8] ^ W
[i
- 14] ^ W
[i
- 16]
18093 for (var j
= 0; j
< 80; ++j
) {
18095 var t
= (rotl5(a
) + ft(s
, b
, c
, d
) + e
+ W
[j
] + K
[s
]) | 0
18104 this._a
= (a
+ this._a
) | 0
18105 this._b
= (b
+ this._b
) | 0
18106 this._c
= (c
+ this._c
) | 0
18107 this._d
= (d
+ this._d
) | 0
18108 this._e
= (e
+ this._e
) | 0
18111 Sha
.prototype._hash = function () {
18112 var H
= new Buffer(20)
18114 H
.writeInt32BE(this._a
| 0, 0)
18115 H
.writeInt32BE(this._b
| 0, 4)
18116 H
.writeInt32BE(this._c
| 0, 8)
18117 H
.writeInt32BE(this._d
| 0, 12)
18118 H
.writeInt32BE(this._e
| 0, 16)
18123 module
.exports
= Sha
18125 }).call(this,require("buffer").Buffer
)
18126 },{"./hash":79,"buffer":5,"inherits":63}],82:[function(require
,module
,exports
){
18127 (function (Buffer
){
18129 * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
18130 * in FIPS PUB 180-1
18131 * Version 2.1a Copyright Paul Johnston 2000 - 2002.
18132 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
18133 * Distributed under the BSD License
18134 * See http://pajhome.org.uk/crypt/md5 for details.
18137 var inherits
= require('inherits')
18138 var Hash
= require('./hash')
18141 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
18144 var W
= new Array(80)
18150 Hash
.call(this, 64, 56)
18153 inherits(Sha1
, Hash
)
18155 Sha1
.prototype.init = function () {
18156 this._a
= 0x67452301
18157 this._b
= 0xefcdab89
18158 this._c
= 0x98badcfe
18159 this._d
= 0x10325476
18160 this._e
= 0xc3d2e1f0
18165 function rotl1 (num
) {
18166 return (num
<< 1) | (num
>>> 31)
18169 function rotl5 (num
) {
18170 return (num
<< 5) | (num
>>> 27)
18173 function rotl30 (num
) {
18174 return (num
<< 30) | (num
>>> 2)
18177 function ft (s
, b
, c
, d
) {
18178 if (s
=== 0) return (b
& c
) | ((~b
) & d
)
18179 if (s
=== 2) return (b
& c
) | (b
& d
) | (c
& d
)
18183 Sha1
.prototype._update = function (M
) {
18186 var a
= this._a
| 0
18187 var b
= this._b
| 0
18188 var c
= this._c
| 0
18189 var d
= this._d
| 0
18190 var e
= this._e
| 0
18192 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
18193 for (; i
< 80; ++i
) W
[i
] = rotl1(W
[i
- 3] ^ W
[i
- 8] ^ W
[i
- 14] ^ W
[i
- 16])
18195 for (var j
= 0; j
< 80; ++j
) {
18197 var t
= (rotl5(a
) + ft(s
, b
, c
, d
) + e
+ W
[j
] + K
[s
]) | 0
18206 this._a
= (a
+ this._a
) | 0
18207 this._b
= (b
+ this._b
) | 0
18208 this._c
= (c
+ this._c
) | 0
18209 this._d
= (d
+ this._d
) | 0
18210 this._e
= (e
+ this._e
) | 0
18213 Sha1
.prototype._hash = function () {
18214 var H
= new Buffer(20)
18216 H
.writeInt32BE(this._a
| 0, 0)
18217 H
.writeInt32BE(this._b
| 0, 4)
18218 H
.writeInt32BE(this._c
| 0, 8)
18219 H
.writeInt32BE(this._d
| 0, 12)
18220 H
.writeInt32BE(this._e
| 0, 16)
18225 module
.exports
= Sha1
18227 }).call(this,require("buffer").Buffer
)
18228 },{"./hash":79,"buffer":5,"inherits":63}],83:[function(require
,module
,exports
){
18229 (function (Buffer
){
18231 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
18233 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
18234 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
18238 var inherits
= require('inherits')
18239 var Sha256
= require('./sha256')
18240 var Hash
= require('./hash')
18242 var W
= new Array(64)
18244 function Sha224 () {
18247 this._w
= W
// new Array(64)
18249 Hash
.call(this, 64, 56)
18252 inherits(Sha224
, Sha256
)
18254 Sha224
.prototype.init = function () {
18255 this._a
= 0xc1059ed8
18256 this._b
= 0x367cd507
18257 this._c
= 0x3070dd17
18258 this._d
= 0xf70e5939
18259 this._e
= 0xffc00b31
18260 this._f
= 0x68581511
18261 this._g
= 0x64f98fa7
18262 this._h
= 0xbefa4fa4
18267 Sha224
.prototype._hash = function () {
18268 var H
= new Buffer(28)
18270 H
.writeInt32BE(this._a
, 0)
18271 H
.writeInt32BE(this._b
, 4)
18272 H
.writeInt32BE(this._c
, 8)
18273 H
.writeInt32BE(this._d
, 12)
18274 H
.writeInt32BE(this._e
, 16)
18275 H
.writeInt32BE(this._f
, 20)
18276 H
.writeInt32BE(this._g
, 24)
18281 module
.exports
= Sha224
18283 }).call(this,require("buffer").Buffer
)
18284 },{"./hash":79,"./sha256":84,"buffer":5,"inherits":63}],84:[function(require
,module
,exports
){
18285 (function (Buffer
){
18287 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
18289 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
18290 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
18294 var inherits
= require('inherits')
18295 var Hash
= require('./hash')
18298 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
18299 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
18300 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
18301 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
18302 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
18303 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
18304 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
18305 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
18306 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
18307 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
18308 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
18309 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
18310 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
18311 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
18312 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
18313 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
18316 var W
= new Array(64)
18318 function Sha256 () {
18321 this._w
= W
// new Array(64)
18323 Hash
.call(this, 64, 56)
18326 inherits(Sha256
, Hash
)
18328 Sha256
.prototype.init = function () {
18329 this._a
= 0x6a09e667
18330 this._b
= 0xbb67ae85
18331 this._c
= 0x3c6ef372
18332 this._d
= 0xa54ff53a
18333 this._e
= 0x510e527f
18334 this._f
= 0x9b05688c
18335 this._g
= 0x1f83d9ab
18336 this._h
= 0x5be0cd19
18341 function ch (x
, y
, z
) {
18342 return z
^ (x
& (y
^ z
))
18345 function maj (x
, y
, z
) {
18346 return (x
& y
) | (z
& (x
| y
))
18349 function sigma0 (x
) {
18350 return (x
>>> 2 | x
<< 30) ^ (x
>>> 13 | x
<< 19) ^ (x
>>> 22 | x
<< 10)
18353 function sigma1 (x
) {
18354 return (x
>>> 6 | x
<< 26) ^ (x
>>> 11 | x
<< 21) ^ (x
>>> 25 | x
<< 7)
18357 function gamma0 (x
) {
18358 return (x
>>> 7 | x
<< 25) ^ (x
>>> 18 | x
<< 14) ^ (x
>>> 3)
18361 function gamma1 (x
) {
18362 return (x
>>> 17 | x
<< 15) ^ (x
>>> 19 | x
<< 13) ^ (x
>>> 10)
18365 Sha256
.prototype._update = function (M
) {
18368 var a
= this._a
| 0
18369 var b
= this._b
| 0
18370 var c
= this._c
| 0
18371 var d
= this._d
| 0
18372 var e
= this._e
| 0
18373 var f
= this._f
| 0
18374 var g
= this._g
| 0
18375 var h
= this._h
| 0
18377 for (var i
= 0; i
< 16; ++i
) W
[i
] = M
.readInt32BE(i
* 4)
18378 for (; i
< 64; ++i
) W
[i
] = (gamma1(W
[i
- 2]) + W
[i
- 7] + gamma0(W
[i
- 15]) + W
[i
- 16]) | 0
18380 for (var j
= 0; j
< 64; ++j
) {
18381 var T1
= (h
+ sigma1(e
) + ch(e
, f
, g
) + K
[j
] + W
[j
]) | 0
18382 var T2
= (sigma0(a
) + maj(a
, b
, c
)) | 0
18394 this._a
= (a
+ this._a
) | 0
18395 this._b
= (b
+ this._b
) | 0
18396 this._c
= (c
+ this._c
) | 0
18397 this._d
= (d
+ this._d
) | 0
18398 this._e
= (e
+ this._e
) | 0
18399 this._f
= (f
+ this._f
) | 0
18400 this._g
= (g
+ this._g
) | 0
18401 this._h
= (h
+ this._h
) | 0
18404 Sha256
.prototype._hash = function () {
18405 var H
= new Buffer(32)
18407 H
.writeInt32BE(this._a
, 0)
18408 H
.writeInt32BE(this._b
, 4)
18409 H
.writeInt32BE(this._c
, 8)
18410 H
.writeInt32BE(this._d
, 12)
18411 H
.writeInt32BE(this._e
, 16)
18412 H
.writeInt32BE(this._f
, 20)
18413 H
.writeInt32BE(this._g
, 24)
18414 H
.writeInt32BE(this._h
, 28)
18419 module
.exports
= Sha256
18421 }).call(this,require("buffer").Buffer
)
18422 },{"./hash":79,"buffer":5,"inherits":63}],85:[function(require
,module
,exports
){
18423 (function (Buffer
){
18424 var inherits
= require('inherits')
18425 var SHA512
= require('./sha512')
18426 var Hash
= require('./hash')
18428 var W
= new Array(160)
18430 function Sha384 () {
18434 Hash
.call(this, 128, 112)
18437 inherits(Sha384
, SHA512
)
18439 Sha384
.prototype.init = function () {
18440 this._ah
= 0xcbbb9d5d
18441 this._bh
= 0x629a292a
18442 this._ch
= 0x9159015a
18443 this._dh
= 0x152fecd8
18444 this._eh
= 0x67332667
18445 this._fh
= 0x8eb44a87
18446 this._gh
= 0xdb0c2e0d
18447 this._hh
= 0x47b5481d
18449 this._al
= 0xc1059ed8
18450 this._bl
= 0x367cd507
18451 this._cl
= 0x3070dd17
18452 this._dl
= 0xf70e5939
18453 this._el
= 0xffc00b31
18454 this._fl
= 0x68581511
18455 this._gl
= 0x64f98fa7
18456 this._hl
= 0xbefa4fa4
18461 Sha384
.prototype._hash = function () {
18462 var H
= new Buffer(48)
18464 function writeInt64BE (h
, l
, offset
) {
18465 H
.writeInt32BE(h
, offset
)
18466 H
.writeInt32BE(l
, offset
+ 4)
18469 writeInt64BE(this._ah
, this._al
, 0)
18470 writeInt64BE(this._bh
, this._bl
, 8)
18471 writeInt64BE(this._ch
, this._cl
, 16)
18472 writeInt64BE(this._dh
, this._dl
, 24)
18473 writeInt64BE(this._eh
, this._el
, 32)
18474 writeInt64BE(this._fh
, this._fl
, 40)
18479 module
.exports
= Sha384
18481 }).call(this,require("buffer").Buffer
)
18482 },{"./hash":79,"./sha512":86,"buffer":5,"inherits":63}],86:[function(require
,module
,exports
){
18483 (function (Buffer
){
18484 var inherits
= require('inherits')
18485 var Hash
= require('./hash')
18488 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
18489 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
18490 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
18491 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
18492 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
18493 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
18494 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
18495 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
18496 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
18497 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
18498 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
18499 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
18500 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
18501 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
18502 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
18503 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
18504 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
18505 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
18506 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
18507 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
18508 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
18509 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
18510 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
18511 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
18512 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
18513 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
18514 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
18515 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
18516 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
18517 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
18518 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
18519 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
18520 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
18521 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
18522 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
18523 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
18524 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
18525 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
18526 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
18527 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
18530 var W
= new Array(160)
18532 function Sha512 () {
18536 Hash
.call(this, 128, 112)
18539 inherits(Sha512
, Hash
)
18541 Sha512
.prototype.init = function () {
18542 this._ah
= 0x6a09e667
18543 this._bh
= 0xbb67ae85
18544 this._ch
= 0x3c6ef372
18545 this._dh
= 0xa54ff53a
18546 this._eh
= 0x510e527f
18547 this._fh
= 0x9b05688c
18548 this._gh
= 0x1f83d9ab
18549 this._hh
= 0x5be0cd19
18551 this._al
= 0xf3bcc908
18552 this._bl
= 0x84caa73b
18553 this._cl
= 0xfe94f82b
18554 this._dl
= 0x5f1d36f1
18555 this._el
= 0xade682d1
18556 this._fl
= 0x2b3e6c1f
18557 this._gl
= 0xfb41bd6b
18558 this._hl
= 0x137e2179
18563 function Ch (x
, y
, z
) {
18564 return z
^ (x
& (y
^ z
))
18567 function maj (x
, y
, z
) {
18568 return (x
& y
) | (z
& (x
| y
))
18571 function sigma0 (x
, xl
) {
18572 return (x
>>> 28 | xl
<< 4) ^ (xl
>>> 2 | x
<< 30) ^ (xl
>>> 7 | x
<< 25)
18575 function sigma1 (x
, xl
) {
18576 return (x
>>> 14 | xl
<< 18) ^ (x
>>> 18 | xl
<< 14) ^ (xl
>>> 9 | x
<< 23)
18579 function Gamma0 (x
, xl
) {
18580 return (x
>>> 1 | xl
<< 31) ^ (x
>>> 8 | xl
<< 24) ^ (x
>>> 7)
18583 function Gamma0l (x
, xl
) {
18584 return (x
>>> 1 | xl
<< 31) ^ (x
>>> 8 | xl
<< 24) ^ (x
>>> 7 | xl
<< 25)
18587 function Gamma1 (x
, xl
) {
18588 return (x
>>> 19 | xl
<< 13) ^ (xl
>>> 29 | x
<< 3) ^ (x
>>> 6)
18591 function Gamma1l (x
, xl
) {
18592 return (x
>>> 19 | xl
<< 13) ^ (xl
>>> 29 | x
<< 3) ^ (x
>>> 6 | xl
<< 26)
18595 function getCarry (a
, b
) {
18596 return (a
>>> 0) < (b
>>> 0) ? 1 : 0
18599 Sha512
.prototype._update = function (M
) {
18602 var ah
= this._ah
| 0
18603 var bh
= this._bh
| 0
18604 var ch
= this._ch
| 0
18605 var dh
= this._dh
| 0
18606 var eh
= this._eh
| 0
18607 var fh
= this._fh
| 0
18608 var gh
= this._gh
| 0
18609 var hh
= this._hh
| 0
18611 var al
= this._al
| 0
18612 var bl
= this._bl
| 0
18613 var cl
= this._cl
| 0
18614 var dl
= this._dl
| 0
18615 var el
= this._el
| 0
18616 var fl
= this._fl
| 0
18617 var gl
= this._gl
| 0
18618 var hl
= this._hl
| 0
18620 for (var i
= 0; i
< 32; i
+= 2) {
18621 W
[i
] = M
.readInt32BE(i
* 4)
18622 W
[i
+ 1] = M
.readInt32BE(i
* 4 + 4)
18624 for (; i
< 160; i
+= 2) {
18625 var xh
= W
[i
- 15 * 2]
18626 var xl
= W
[i
- 15 * 2 + 1]
18627 var gamma0
= Gamma0(xh
, xl
)
18628 var gamma0l
= Gamma0l(xl
, xh
)
18631 xl
= W
[i
- 2 * 2 + 1]
18632 var gamma1
= Gamma1(xh
, xl
)
18633 var gamma1l
= Gamma1l(xl
, xh
)
18635 // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
18636 var Wi7h
= W
[i
- 7 * 2]
18637 var Wi7l
= W
[i
- 7 * 2 + 1]
18639 var Wi16h
= W
[i
- 16 * 2]
18640 var Wi16l
= W
[i
- 16 * 2 + 1]
18642 var Wil
= (gamma0l
+ Wi7l
) | 0
18643 var Wih
= (gamma0
+ Wi7h
+ getCarry(Wil
, gamma0l
)) | 0
18644 Wil
= (Wil
+ gamma1l
) | 0
18645 Wih
= (Wih
+ gamma1
+ getCarry(Wil
, gamma1l
)) | 0
18646 Wil
= (Wil
+ Wi16l
) | 0
18647 Wih
= (Wih
+ Wi16h
+ getCarry(Wil
, Wi16l
)) | 0
18653 for (var j
= 0; j
< 160; j
+= 2) {
18657 var majh
= maj(ah
, bh
, ch
)
18658 var majl
= maj(al
, bl
, cl
)
18660 var sigma0h
= sigma0(ah
, al
)
18661 var sigma0l
= sigma0(al
, ah
)
18662 var sigma1h
= sigma1(eh
, el
)
18663 var sigma1l
= sigma1(el
, eh
)
18665 // t1 = h + sigma1 + ch + K[j] + W[j]
18669 var chh
= Ch(eh
, fh
, gh
)
18670 var chl
= Ch(el
, fl
, gl
)
18672 var t1l
= (hl
+ sigma1l
) | 0
18673 var t1h
= (hh
+ sigma1h
+ getCarry(t1l
, hl
)) | 0
18674 t1l
= (t1l
+ chl
) | 0
18675 t1h
= (t1h
+ chh
+ getCarry(t1l
, chl
)) | 0
18676 t1l
= (t1l
+ Kil
) | 0
18677 t1h
= (t1h
+ Kih
+ getCarry(t1l
, Kil
)) | 0
18678 t1l
= (t1l
+ Wil
) | 0
18679 t1h
= (t1h
+ Wih
+ getCarry(t1l
, Wil
)) | 0
18681 // t2 = sigma0 + maj
18682 var t2l
= (sigma0l
+ majl
) | 0
18683 var t2h
= (sigma0h
+ majh
+ getCarry(t2l
, sigma0l
)) | 0
18691 el
= (dl
+ t1l
) | 0
18692 eh
= (dh
+ t1h
+ getCarry(el
, dl
)) | 0
18699 al
= (t1l
+ t2l
) | 0
18700 ah
= (t1h
+ t2h
+ getCarry(al
, t1l
)) | 0
18703 this._al
= (this._al
+ al
) | 0
18704 this._bl
= (this._bl
+ bl
) | 0
18705 this._cl
= (this._cl
+ cl
) | 0
18706 this._dl
= (this._dl
+ dl
) | 0
18707 this._el
= (this._el
+ el
) | 0
18708 this._fl
= (this._fl
+ fl
) | 0
18709 this._gl
= (this._gl
+ gl
) | 0
18710 this._hl
= (this._hl
+ hl
) | 0
18712 this._ah
= (this._ah
+ ah
+ getCarry(this._al
, al
)) | 0
18713 this._bh
= (this._bh
+ bh
+ getCarry(this._bl
, bl
)) | 0
18714 this._ch
= (this._ch
+ ch
+ getCarry(this._cl
, cl
)) | 0
18715 this._dh
= (this._dh
+ dh
+ getCarry(this._dl
, dl
)) | 0
18716 this._eh
= (this._eh
+ eh
+ getCarry(this._el
, el
)) | 0
18717 this._fh
= (this._fh
+ fh
+ getCarry(this._fl
, fl
)) | 0
18718 this._gh
= (this._gh
+ gh
+ getCarry(this._gl
, gl
)) | 0
18719 this._hh
= (this._hh
+ hh
+ getCarry(this._hl
, hl
)) | 0
18722 Sha512
.prototype._hash = function () {
18723 var H
= new Buffer(64)
18725 function writeInt64BE (h
, l
, offset
) {
18726 H
.writeInt32BE(h
, offset
)
18727 H
.writeInt32BE(l
, offset
+ 4)
18730 writeInt64BE(this._ah
, this._al
, 0)
18731 writeInt64BE(this._bh
, this._bl
, 8)
18732 writeInt64BE(this._ch
, this._cl
, 16)
18733 writeInt64BE(this._dh
, this._dl
, 24)
18734 writeInt64BE(this._eh
, this._el
, 32)
18735 writeInt64BE(this._fh
, this._fl
, 40)
18736 writeInt64BE(this._gh
, this._gl
, 48)
18737 writeInt64BE(this._hh
, this._hl
, 56)
18742 module
.exports
= Sha512
18744 }).call(this,require("buffer").Buffer
)
18745 },{"./hash":79,"buffer":5,"inherits":63}],87:[function(require
,module
,exports
){
18746 var isHexPrefixed
= require('is-hex-prefixed');
18749 * Removes '0x' from a given `String` is present
18750 * @param {String} str the string value
18751 * @return {String|Optional} a string by pass if necessary
18753 module
.exports
= function stripHexPrefix(str
) {
18754 if (typeof str
!== 'string') {
18758 return isHexPrefixed(str
) ? str
.slice(2) : str
;
18761 },{"is-hex-prefixed":64}]},{},[31])(31)