diff options
author | Suat Özgür <s.oezguer@gmail.com> | 2018-12-17 00:43:16 +0100 |
---|---|---|
committer | Suat Özgür <s.oezguer@gmail.com> | 2018-12-17 00:43:16 +0100 |
commit | 8ffa333bc94699ce1945cf58b24838e73295b028 (patch) | |
tree | 9173d263f707c0602fd5dece9e19ccf1c082cc00 /src/js/stellar-util.js | |
parent | 2ef27fb80b0aa0419d3ebd8b320b354fd24c67f3 (diff) | |
download | BIP39-8ffa333bc94699ce1945cf58b24838e73295b028.tar.gz BIP39-8ffa333bc94699ce1945cf58b24838e73295b028.tar.zst BIP39-8ffa333bc94699ce1945cf58b24838e73295b028.zip |
adding xlm stellar
Diffstat (limited to 'src/js/stellar-util.js')
-rw-r--r-- | src/js/stellar-util.js | 41520 |
1 files changed, 41520 insertions, 0 deletions
diff --git a/src/js/stellar-util.js b/src/js/stellar-util.js new file mode 100644 index 0000000..5d991db --- /dev/null +++ b/src/js/stellar-util.js | |||
@@ -0,0 +1,41520 @@ | |||
1 | (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ | ||
2 | var asn1 = exports; | ||
3 | |||
4 | asn1.bignum = require('bn.js'); | ||
5 | |||
6 | asn1.define = require('./asn1/api').define; | ||
7 | asn1.base = require('./asn1/base'); | ||
8 | asn1.constants = require('./asn1/constants'); | ||
9 | asn1.decoders = require('./asn1/decoders'); | ||
10 | asn1.encoders = require('./asn1/encoders'); | ||
11 | |||
12 | },{"./asn1/api":2,"./asn1/base":4,"./asn1/constants":8,"./asn1/decoders":10,"./asn1/encoders":13,"bn.js":18}],2:[function(require,module,exports){ | ||
13 | var asn1 = require('../asn1'); | ||
14 | var inherits = require('inherits'); | ||
15 | |||
16 | var api = exports; | ||
17 | |||
18 | api.define = function define(name, body) { | ||
19 | return new Entity(name, body); | ||
20 | }; | ||
21 | |||
22 | function Entity(name, body) { | ||
23 | this.name = name; | ||
24 | this.body = body; | ||
25 | |||
26 | this.decoders = {}; | ||
27 | this.encoders = {}; | ||
28 | }; | ||
29 | |||
30 | Entity.prototype._createNamed = function createNamed(base) { | ||
31 | var named; | ||
32 | try { | ||
33 | named = require('vm').runInThisContext( | ||
34 | '(function ' + this.name + '(entity) {\n' + | ||
35 | ' this._initNamed(entity);\n' + | ||
36 | '})' | ||
37 | ); | ||
38 | } catch (e) { | ||
39 | named = function (entity) { | ||
40 | this._initNamed(entity); | ||
41 | }; | ||
42 | } | ||
43 | inherits(named, base); | ||
44 | named.prototype._initNamed = function initnamed(entity) { | ||
45 | base.call(this, entity); | ||
46 | }; | ||
47 | |||
48 | return new named(this); | ||
49 | }; | ||
50 | |||
51 | Entity.prototype._getDecoder = function _getDecoder(enc) { | ||
52 | enc = enc || 'der'; | ||
53 | // Lazily create decoder | ||
54 | if (!this.decoders.hasOwnProperty(enc)) | ||
55 | this.decoders[enc] = this._createNamed(asn1.decoders[enc]); | ||
56 | return this.decoders[enc]; | ||
57 | }; | ||
58 | |||
59 | Entity.prototype.decode = function decode(data, enc, options) { | ||
60 | return this._getDecoder(enc).decode(data, options); | ||
61 | }; | ||
62 | |||
63 | Entity.prototype._getEncoder = function _getEncoder(enc) { | ||
64 | enc = enc || 'der'; | ||
65 | // Lazily create encoder | ||
66 | if (!this.encoders.hasOwnProperty(enc)) | ||
67 | this.encoders[enc] = this._createNamed(asn1.encoders[enc]); | ||
68 | return this.encoders[enc]; | ||
69 | }; | ||
70 | |||
71 | Entity.prototype.encode = function encode(data, enc, /* internal */ reporter) { | ||
72 | return this._getEncoder(enc).encode(data, reporter); | ||
73 | }; | ||
74 | |||
75 | },{"../asn1":1,"inherits":116,"vm":439}],3:[function(require,module,exports){ | ||
76 | var inherits = require('inherits'); | ||
77 | var Reporter = require('../base').Reporter; | ||
78 | var Buffer = require('buffer').Buffer; | ||
79 | |||
80 | function DecoderBuffer(base, options) { | ||
81 | Reporter.call(this, options); | ||
82 | if (!Buffer.isBuffer(base)) { | ||
83 | this.error('Input not Buffer'); | ||
84 | return; | ||
85 | } | ||
86 | |||
87 | this.base = base; | ||
88 | this.offset = 0; | ||
89 | this.length = base.length; | ||
90 | } | ||
91 | inherits(DecoderBuffer, Reporter); | ||
92 | exports.DecoderBuffer = DecoderBuffer; | ||
93 | |||
94 | DecoderBuffer.prototype.save = function save() { | ||
95 | return { offset: this.offset, reporter: Reporter.prototype.save.call(this) }; | ||
96 | }; | ||
97 | |||
98 | DecoderBuffer.prototype.restore = function restore(save) { | ||
99 | // Return skipped data | ||
100 | var res = new DecoderBuffer(this.base); | ||
101 | res.offset = save.offset; | ||
102 | res.length = this.offset; | ||
103 | |||
104 | this.offset = save.offset; | ||
105 | Reporter.prototype.restore.call(this, save.reporter); | ||
106 | |||
107 | return res; | ||
108 | }; | ||
109 | |||
110 | DecoderBuffer.prototype.isEmpty = function isEmpty() { | ||
111 | return this.offset === this.length; | ||
112 | }; | ||
113 | |||
114 | DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) { | ||
115 | if (this.offset + 1 <= this.length) | ||
116 | return this.base.readUInt8(this.offset++, true); | ||
117 | else | ||
118 | return this.error(fail || 'DecoderBuffer overrun'); | ||
119 | } | ||
120 | |||
121 | DecoderBuffer.prototype.skip = function skip(bytes, fail) { | ||
122 | if (!(this.offset + bytes <= this.length)) | ||
123 | return this.error(fail || 'DecoderBuffer overrun'); | ||
124 | |||
125 | var res = new DecoderBuffer(this.base); | ||
126 | |||
127 | // Share reporter state | ||
128 | res._reporterState = this._reporterState; | ||
129 | |||
130 | res.offset = this.offset; | ||
131 | res.length = this.offset + bytes; | ||
132 | this.offset += bytes; | ||
133 | return res; | ||
134 | } | ||
135 | |||
136 | DecoderBuffer.prototype.raw = function raw(save) { | ||
137 | return this.base.slice(save ? save.offset : this.offset, this.length); | ||
138 | } | ||
139 | |||
140 | function EncoderBuffer(value, reporter) { | ||
141 | if (Array.isArray(value)) { | ||
142 | this.length = 0; | ||
143 | this.value = value.map(function(item) { | ||
144 | if (!(item instanceof EncoderBuffer)) | ||
145 | item = new EncoderBuffer(item, reporter); | ||
146 | this.length += item.length; | ||
147 | return item; | ||
148 | }, this); | ||
149 | } else if (typeof value === 'number') { | ||
150 | if (!(0 <= value && value <= 0xff)) | ||
151 | return reporter.error('non-byte EncoderBuffer value'); | ||
152 | this.value = value; | ||
153 | this.length = 1; | ||
154 | } else if (typeof value === 'string') { | ||
155 | this.value = value; | ||
156 | this.length = Buffer.byteLength(value); | ||
157 | } else if (Buffer.isBuffer(value)) { | ||
158 | this.value = value; | ||
159 | this.length = value.length; | ||
160 | } else { | ||
161 | return reporter.error('Unsupported type: ' + typeof value); | ||
162 | } | ||
163 | } | ||
164 | exports.EncoderBuffer = EncoderBuffer; | ||
165 | |||
166 | EncoderBuffer.prototype.join = function join(out, offset) { | ||
167 | if (!out) | ||
168 | out = new Buffer(this.length); | ||
169 | if (!offset) | ||
170 | offset = 0; | ||
171 | |||
172 | if (this.length === 0) | ||
173 | return out; | ||
174 | |||
175 | if (Array.isArray(this.value)) { | ||
176 | this.value.forEach(function(item) { | ||
177 | item.join(out, offset); | ||
178 | offset += item.length; | ||
179 | }); | ||
180 | } else { | ||
181 | if (typeof this.value === 'number') | ||
182 | out[offset] = this.value; | ||
183 | else if (typeof this.value === 'string') | ||
184 | out.write(this.value, offset); | ||
185 | else if (Buffer.isBuffer(this.value)) | ||
186 | this.value.copy(out, offset); | ||
187 | offset += this.length; | ||
188 | } | ||
189 | |||
190 | return out; | ||
191 | }; | ||
192 | |||
193 | },{"../base":4,"buffer":49,"inherits":116}],4:[function(require,module,exports){ | ||
194 | var base = exports; | ||
195 | |||
196 | base.Reporter = require('./reporter').Reporter; | ||
197 | base.DecoderBuffer = require('./buffer').DecoderBuffer; | ||
198 | base.EncoderBuffer = require('./buffer').EncoderBuffer; | ||
199 | base.Node = require('./node'); | ||
200 | |||
201 | },{"./buffer":3,"./node":5,"./reporter":6}],5:[function(require,module,exports){ | ||
202 | var Reporter = require('../base').Reporter; | ||
203 | var EncoderBuffer = require('../base').EncoderBuffer; | ||
204 | var DecoderBuffer = require('../base').DecoderBuffer; | ||
205 | var assert = require('minimalistic-assert'); | ||
206 | |||
207 | // Supported tags | ||
208 | var tags = [ | ||
209 | 'seq', 'seqof', 'set', 'setof', 'objid', 'bool', | ||
210 | 'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc', | ||
211 | 'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str', | ||
212 | 'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr' | ||
213 | ]; | ||
214 | |||
215 | // Public methods list | ||
216 | var methods = [ | ||
217 | 'key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice', | ||
218 | 'any', 'contains' | ||
219 | ].concat(tags); | ||
220 | |||
221 | // Overrided methods list | ||
222 | var overrided = [ | ||
223 | '_peekTag', '_decodeTag', '_use', | ||
224 | '_decodeStr', '_decodeObjid', '_decodeTime', | ||
225 | '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList', | ||
226 | |||
227 | '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime', | ||
228 | '_encodeNull', '_encodeInt', '_encodeBool' | ||
229 | ]; | ||
230 | |||
231 | function Node(enc, parent) { | ||
232 | var state = {}; | ||
233 | this._baseState = state; | ||
234 | |||
235 | state.enc = enc; | ||
236 | |||
237 | state.parent = parent || null; | ||
238 | state.children = null; | ||
239 | |||
240 | // State | ||
241 | state.tag = null; | ||
242 | state.args = null; | ||
243 | state.reverseArgs = null; | ||
244 | state.choice = null; | ||
245 | state.optional = false; | ||
246 | state.any = false; | ||
247 | state.obj = false; | ||
248 | state.use = null; | ||
249 | state.useDecoder = null; | ||
250 | state.key = null; | ||
251 | state['default'] = null; | ||
252 | state.explicit = null; | ||
253 | state.implicit = null; | ||
254 | state.contains = null; | ||
255 | |||
256 | // Should create new instance on each method | ||
257 | if (!state.parent) { | ||
258 | state.children = []; | ||
259 | this._wrap(); | ||
260 | } | ||
261 | } | ||
262 | module.exports = Node; | ||
263 | |||
264 | var stateProps = [ | ||
265 | 'enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice', | ||
266 | 'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit', | ||
267 | 'implicit', 'contains' | ||
268 | ]; | ||
269 | |||
270 | Node.prototype.clone = function clone() { | ||
271 | var state = this._baseState; | ||
272 | var cstate = {}; | ||
273 | stateProps.forEach(function(prop) { | ||
274 | cstate[prop] = state[prop]; | ||
275 | }); | ||
276 | var res = new this.constructor(cstate.parent); | ||
277 | res._baseState = cstate; | ||
278 | return res; | ||
279 | }; | ||
280 | |||
281 | Node.prototype._wrap = function wrap() { | ||
282 | var state = this._baseState; | ||
283 | methods.forEach(function(method) { | ||
284 | this[method] = function _wrappedMethod() { | ||
285 | var clone = new this.constructor(this); | ||
286 | state.children.push(clone); | ||
287 | return clone[method].apply(clone, arguments); | ||
288 | }; | ||
289 | }, this); | ||
290 | }; | ||
291 | |||
292 | Node.prototype._init = function init(body) { | ||
293 | var state = this._baseState; | ||
294 | |||
295 | assert(state.parent === null); | ||
296 | body.call(this); | ||
297 | |||
298 | // Filter children | ||
299 | state.children = state.children.filter(function(child) { | ||
300 | return child._baseState.parent === this; | ||
301 | }, this); | ||
302 | assert.equal(state.children.length, 1, 'Root node can have only one child'); | ||
303 | }; | ||
304 | |||
305 | Node.prototype._useArgs = function useArgs(args) { | ||
306 | var state = this._baseState; | ||
307 | |||
308 | // Filter children and args | ||
309 | var children = args.filter(function(arg) { | ||
310 | return arg instanceof this.constructor; | ||
311 | }, this); | ||
312 | args = args.filter(function(arg) { | ||
313 | return !(arg instanceof this.constructor); | ||
314 | }, this); | ||
315 | |||
316 | if (children.length !== 0) { | ||
317 | assert(state.children === null); | ||
318 | state.children = children; | ||
319 | |||
320 | // Replace parent to maintain backward link | ||
321 | children.forEach(function(child) { | ||
322 | child._baseState.parent = this; | ||
323 | }, this); | ||
324 | } | ||
325 | if (args.length !== 0) { | ||
326 | assert(state.args === null); | ||
327 | state.args = args; | ||
328 | state.reverseArgs = args.map(function(arg) { | ||
329 | if (typeof arg !== 'object' || arg.constructor !== Object) | ||
330 | return arg; | ||
331 | |||
332 | var res = {}; | ||
333 | Object.keys(arg).forEach(function(key) { | ||
334 | if (key == (key | 0)) | ||
335 | key |= 0; | ||
336 | var value = arg[key]; | ||
337 | res[value] = key; | ||
338 | }); | ||
339 | return res; | ||
340 | }); | ||
341 | } | ||
342 | }; | ||
343 | |||
344 | // | ||
345 | // Overrided methods | ||
346 | // | ||
347 | |||
348 | overrided.forEach(function(method) { | ||
349 | Node.prototype[method] = function _overrided() { | ||
350 | var state = this._baseState; | ||
351 | throw new Error(method + ' not implemented for encoding: ' + state.enc); | ||
352 | }; | ||
353 | }); | ||
354 | |||
355 | // | ||
356 | // Public methods | ||
357 | // | ||
358 | |||
359 | tags.forEach(function(tag) { | ||
360 | Node.prototype[tag] = function _tagMethod() { | ||
361 | var state = this._baseState; | ||
362 | var args = Array.prototype.slice.call(arguments); | ||
363 | |||
364 | assert(state.tag === null); | ||
365 | state.tag = tag; | ||
366 | |||
367 | this._useArgs(args); | ||
368 | |||
369 | return this; | ||
370 | }; | ||
371 | }); | ||
372 | |||
373 | Node.prototype.use = function use(item) { | ||
374 | assert(item); | ||
375 | var state = this._baseState; | ||
376 | |||
377 | assert(state.use === null); | ||
378 | state.use = item; | ||
379 | |||
380 | return this; | ||
381 | }; | ||
382 | |||
383 | Node.prototype.optional = function optional() { | ||
384 | var state = this._baseState; | ||
385 | |||
386 | state.optional = true; | ||
387 | |||
388 | return this; | ||
389 | }; | ||
390 | |||
391 | Node.prototype.def = function def(val) { | ||
392 | var state = this._baseState; | ||
393 | |||
394 | assert(state['default'] === null); | ||
395 | state['default'] = val; | ||
396 | state.optional = true; | ||
397 | |||
398 | return this; | ||
399 | }; | ||
400 | |||
401 | Node.prototype.explicit = function explicit(num) { | ||
402 | var state = this._baseState; | ||
403 | |||
404 | assert(state.explicit === null && state.implicit === null); | ||
405 | state.explicit = num; | ||
406 | |||
407 | return this; | ||
408 | }; | ||
409 | |||
410 | Node.prototype.implicit = function implicit(num) { | ||
411 | var state = this._baseState; | ||
412 | |||
413 | assert(state.explicit === null && state.implicit === null); | ||
414 | state.implicit = num; | ||
415 | |||
416 | return this; | ||
417 | }; | ||
418 | |||
419 | Node.prototype.obj = function obj() { | ||
420 | var state = this._baseState; | ||
421 | var args = Array.prototype.slice.call(arguments); | ||
422 | |||
423 | state.obj = true; | ||
424 | |||
425 | if (args.length !== 0) | ||
426 | this._useArgs(args); | ||
427 | |||
428 | return this; | ||
429 | }; | ||
430 | |||
431 | Node.prototype.key = function key(newKey) { | ||
432 | var state = this._baseState; | ||
433 | |||
434 | assert(state.key === null); | ||
435 | state.key = newKey; | ||
436 | |||
437 | return this; | ||
438 | }; | ||
439 | |||
440 | Node.prototype.any = function any() { | ||
441 | var state = this._baseState; | ||
442 | |||
443 | state.any = true; | ||
444 | |||
445 | return this; | ||
446 | }; | ||
447 | |||
448 | Node.prototype.choice = function choice(obj) { | ||
449 | var state = this._baseState; | ||
450 | |||
451 | assert(state.choice === null); | ||
452 | state.choice = obj; | ||
453 | this._useArgs(Object.keys(obj).map(function(key) { | ||
454 | return obj[key]; | ||
455 | })); | ||
456 | |||
457 | return this; | ||
458 | }; | ||
459 | |||
460 | Node.prototype.contains = function contains(item) { | ||
461 | var state = this._baseState; | ||
462 | |||
463 | assert(state.use === null); | ||
464 | state.contains = item; | ||
465 | |||
466 | return this; | ||
467 | }; | ||
468 | |||
469 | // | ||
470 | // Decoding | ||
471 | // | ||
472 | |||
473 | Node.prototype._decode = function decode(input, options) { | ||
474 | var state = this._baseState; | ||
475 | |||
476 | // Decode root node | ||
477 | if (state.parent === null) | ||
478 | return input.wrapResult(state.children[0]._decode(input, options)); | ||
479 | |||
480 | var result = state['default']; | ||
481 | var present = true; | ||
482 | |||
483 | var prevKey = null; | ||
484 | if (state.key !== null) | ||
485 | prevKey = input.enterKey(state.key); | ||
486 | |||
487 | // Check if tag is there | ||
488 | if (state.optional) { | ||
489 | var tag = null; | ||
490 | if (state.explicit !== null) | ||
491 | tag = state.explicit; | ||
492 | else if (state.implicit !== null) | ||
493 | tag = state.implicit; | ||
494 | else if (state.tag !== null) | ||
495 | tag = state.tag; | ||
496 | |||
497 | if (tag === null && !state.any) { | ||
498 | // Trial and Error | ||
499 | var save = input.save(); | ||
500 | try { | ||
501 | if (state.choice === null) | ||
502 | this._decodeGeneric(state.tag, input, options); | ||
503 | else | ||
504 | this._decodeChoice(input, options); | ||
505 | present = true; | ||
506 | } catch (e) { | ||
507 | present = false; | ||
508 | } | ||
509 | input.restore(save); | ||
510 | } else { | ||
511 | present = this._peekTag(input, tag, state.any); | ||
512 | |||
513 | if (input.isError(present)) | ||
514 | return present; | ||
515 | } | ||
516 | } | ||
517 | |||
518 | // Push object on stack | ||
519 | var prevObj; | ||
520 | if (state.obj && present) | ||
521 | prevObj = input.enterObject(); | ||
522 | |||
523 | if (present) { | ||
524 | // Unwrap explicit values | ||
525 | if (state.explicit !== null) { | ||
526 | var explicit = this._decodeTag(input, state.explicit); | ||
527 | if (input.isError(explicit)) | ||
528 | return explicit; | ||
529 | input = explicit; | ||
530 | } | ||
531 | |||
532 | var start = input.offset; | ||
533 | |||
534 | // Unwrap implicit and normal values | ||
535 | if (state.use === null && state.choice === null) { | ||
536 | if (state.any) | ||
537 | var save = input.save(); | ||
538 | var body = this._decodeTag( | ||
539 | input, | ||
540 | state.implicit !== null ? state.implicit : state.tag, | ||
541 | state.any | ||
542 | ); | ||
543 | if (input.isError(body)) | ||
544 | return body; | ||
545 | |||
546 | if (state.any) | ||
547 | result = input.raw(save); | ||
548 | else | ||
549 | input = body; | ||
550 | } | ||
551 | |||
552 | if (options && options.track && state.tag !== null) | ||
553 | options.track(input.path(), start, input.length, 'tagged'); | ||
554 | |||
555 | if (options && options.track && state.tag !== null) | ||
556 | options.track(input.path(), input.offset, input.length, 'content'); | ||
557 | |||
558 | // Select proper method for tag | ||
559 | if (state.any) | ||
560 | result = result; | ||
561 | else if (state.choice === null) | ||
562 | result = this._decodeGeneric(state.tag, input, options); | ||
563 | else | ||
564 | result = this._decodeChoice(input, options); | ||
565 | |||
566 | if (input.isError(result)) | ||
567 | return result; | ||
568 | |||
569 | // Decode children | ||
570 | if (!state.any && state.choice === null && state.children !== null) { | ||
571 | state.children.forEach(function decodeChildren(child) { | ||
572 | // NOTE: We are ignoring errors here, to let parser continue with other | ||
573 | // parts of encoded data | ||
574 | child._decode(input, options); | ||
575 | }); | ||
576 | } | ||
577 | |||
578 | // Decode contained/encoded by schema, only in bit or octet strings | ||
579 | if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) { | ||
580 | var data = new DecoderBuffer(result); | ||
581 | result = this._getUse(state.contains, input._reporterState.obj) | ||
582 | ._decode(data, options); | ||
583 | } | ||
584 | } | ||
585 | |||
586 | // Pop object | ||
587 | if (state.obj && present) | ||
588 | result = input.leaveObject(prevObj); | ||
589 | |||
590 | // Set key | ||
591 | if (state.key !== null && (result !== null || present === true)) | ||
592 | input.leaveKey(prevKey, state.key, result); | ||
593 | else if (prevKey !== null) | ||
594 | input.exitKey(prevKey); | ||
595 | |||
596 | return result; | ||
597 | }; | ||
598 | |||
599 | Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) { | ||
600 | var state = this._baseState; | ||
601 | |||
602 | if (tag === 'seq' || tag === 'set') | ||
603 | return null; | ||
604 | if (tag === 'seqof' || tag === 'setof') | ||
605 | return this._decodeList(input, tag, state.args[0], options); | ||
606 | else if (/str$/.test(tag)) | ||
607 | return this._decodeStr(input, tag, options); | ||
608 | else if (tag === 'objid' && state.args) | ||
609 | return this._decodeObjid(input, state.args[0], state.args[1], options); | ||
610 | else if (tag === 'objid') | ||
611 | return this._decodeObjid(input, null, null, options); | ||
612 | else if (tag === 'gentime' || tag === 'utctime') | ||
613 | return this._decodeTime(input, tag, options); | ||
614 | else if (tag === 'null_') | ||
615 | return this._decodeNull(input, options); | ||
616 | else if (tag === 'bool') | ||
617 | return this._decodeBool(input, options); | ||
618 | else if (tag === 'objDesc') | ||
619 | return this._decodeStr(input, tag, options); | ||
620 | else if (tag === 'int' || tag === 'enum') | ||
621 | return this._decodeInt(input, state.args && state.args[0], options); | ||
622 | |||
623 | if (state.use !== null) { | ||
624 | return this._getUse(state.use, input._reporterState.obj) | ||
625 | ._decode(input, options); | ||
626 | } else { | ||
627 | return input.error('unknown tag: ' + tag); | ||
628 | } | ||
629 | }; | ||
630 | |||
631 | Node.prototype._getUse = function _getUse(entity, obj) { | ||
632 | |||
633 | var state = this._baseState; | ||
634 | // Create altered use decoder if implicit is set | ||
635 | state.useDecoder = this._use(entity, obj); | ||
636 | assert(state.useDecoder._baseState.parent === null); | ||
637 | state.useDecoder = state.useDecoder._baseState.children[0]; | ||
638 | if (state.implicit !== state.useDecoder._baseState.implicit) { | ||
639 | state.useDecoder = state.useDecoder.clone(); | ||
640 | state.useDecoder._baseState.implicit = state.implicit; | ||
641 | } | ||
642 | return state.useDecoder; | ||
643 | }; | ||
644 | |||
645 | Node.prototype._decodeChoice = function decodeChoice(input, options) { | ||
646 | var state = this._baseState; | ||
647 | var result = null; | ||
648 | var match = false; | ||
649 | |||
650 | Object.keys(state.choice).some(function(key) { | ||
651 | var save = input.save(); | ||
652 | var node = state.choice[key]; | ||
653 | try { | ||
654 | var value = node._decode(input, options); | ||
655 | if (input.isError(value)) | ||
656 | return false; | ||
657 | |||
658 | result = { type: key, value: value }; | ||
659 | match = true; | ||
660 | } catch (e) { | ||
661 | input.restore(save); | ||
662 | return false; | ||
663 | } | ||
664 | return true; | ||
665 | }, this); | ||
666 | |||
667 | if (!match) | ||
668 | return input.error('Choice not matched'); | ||
669 | |||
670 | return result; | ||
671 | }; | ||
672 | |||
673 | // | ||
674 | // Encoding | ||
675 | // | ||
676 | |||
677 | Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) { | ||
678 | return new EncoderBuffer(data, this.reporter); | ||
679 | }; | ||
680 | |||
681 | Node.prototype._encode = function encode(data, reporter, parent) { | ||
682 | var state = this._baseState; | ||
683 | if (state['default'] !== null && state['default'] === data) | ||
684 | return; | ||
685 | |||
686 | var result = this._encodeValue(data, reporter, parent); | ||
687 | if (result === undefined) | ||
688 | return; | ||
689 | |||
690 | if (this._skipDefault(result, reporter, parent)) | ||
691 | return; | ||
692 | |||
693 | return result; | ||
694 | }; | ||
695 | |||
696 | Node.prototype._encodeValue = function encode(data, reporter, parent) { | ||
697 | var state = this._baseState; | ||
698 | |||
699 | // Decode root node | ||
700 | if (state.parent === null) | ||
701 | return state.children[0]._encode(data, reporter || new Reporter()); | ||
702 | |||
703 | var result = null; | ||
704 | |||
705 | // Set reporter to share it with a child class | ||
706 | this.reporter = reporter; | ||
707 | |||
708 | // Check if data is there | ||
709 | if (state.optional && data === undefined) { | ||
710 | if (state['default'] !== null) | ||
711 | data = state['default'] | ||
712 | else | ||
713 | return; | ||
714 | } | ||
715 | |||
716 | // Encode children first | ||
717 | var content = null; | ||
718 | var primitive = false; | ||
719 | if (state.any) { | ||
720 | // Anything that was given is translated to buffer | ||
721 | result = this._createEncoderBuffer(data); | ||
722 | } else if (state.choice) { | ||
723 | result = this._encodeChoice(data, reporter); | ||
724 | } else if (state.contains) { | ||
725 | content = this._getUse(state.contains, parent)._encode(data, reporter); | ||
726 | primitive = true; | ||
727 | } else if (state.children) { | ||
728 | content = state.children.map(function(child) { | ||
729 | if (child._baseState.tag === 'null_') | ||
730 | return child._encode(null, reporter, data); | ||
731 | |||
732 | if (child._baseState.key === null) | ||
733 | return reporter.error('Child should have a key'); | ||
734 | var prevKey = reporter.enterKey(child._baseState.key); | ||
735 | |||
736 | if (typeof data !== 'object') | ||
737 | return reporter.error('Child expected, but input is not object'); | ||
738 | |||
739 | var res = child._encode(data[child._baseState.key], reporter, data); | ||
740 | reporter.leaveKey(prevKey); | ||
741 | |||
742 | return res; | ||
743 | }, this).filter(function(child) { | ||
744 | return child; | ||
745 | }); | ||
746 | content = this._createEncoderBuffer(content); | ||
747 | } else { | ||
748 | if (state.tag === 'seqof' || state.tag === 'setof') { | ||
749 | // TODO(indutny): this should be thrown on DSL level | ||
750 | if (!(state.args && state.args.length === 1)) | ||
751 | return reporter.error('Too many args for : ' + state.tag); | ||
752 | |||
753 | if (!Array.isArray(data)) | ||
754 | return reporter.error('seqof/setof, but data is not Array'); | ||
755 | |||
756 | var child = this.clone(); | ||
757 | child._baseState.implicit = null; | ||
758 | content = this._createEncoderBuffer(data.map(function(item) { | ||
759 | var state = this._baseState; | ||
760 | |||
761 | return this._getUse(state.args[0], data)._encode(item, reporter); | ||
762 | }, child)); | ||
763 | } else if (state.use !== null) { | ||
764 | result = this._getUse(state.use, parent)._encode(data, reporter); | ||
765 | } else { | ||
766 | content = this._encodePrimitive(state.tag, data); | ||
767 | primitive = true; | ||
768 | } | ||
769 | } | ||
770 | |||
771 | // Encode data itself | ||
772 | var result; | ||
773 | if (!state.any && state.choice === null) { | ||
774 | var tag = state.implicit !== null ? state.implicit : state.tag; | ||
775 | var cls = state.implicit === null ? 'universal' : 'context'; | ||
776 | |||
777 | if (tag === null) { | ||
778 | if (state.use === null) | ||
779 | reporter.error('Tag could be omitted only for .use()'); | ||
780 | } else { | ||
781 | if (state.use === null) | ||
782 | result = this._encodeComposite(tag, primitive, cls, content); | ||
783 | } | ||
784 | } | ||
785 | |||
786 | // Wrap in explicit | ||
787 | if (state.explicit !== null) | ||
788 | result = this._encodeComposite(state.explicit, false, 'context', result); | ||
789 | |||
790 | return result; | ||
791 | }; | ||
792 | |||
793 | Node.prototype._encodeChoice = function encodeChoice(data, reporter) { | ||
794 | var state = this._baseState; | ||
795 | |||
796 | var node = state.choice[data.type]; | ||
797 | if (!node) { | ||
798 | assert( | ||
799 | false, | ||
800 | data.type + ' not found in ' + | ||
801 | JSON.stringify(Object.keys(state.choice))); | ||
802 | } | ||
803 | return node._encode(data.value, reporter); | ||
804 | }; | ||
805 | |||
806 | Node.prototype._encodePrimitive = function encodePrimitive(tag, data) { | ||
807 | var state = this._baseState; | ||
808 | |||
809 | if (/str$/.test(tag)) | ||
810 | return this._encodeStr(data, tag); | ||
811 | else if (tag === 'objid' && state.args) | ||
812 | return this._encodeObjid(data, state.reverseArgs[0], state.args[1]); | ||
813 | else if (tag === 'objid') | ||
814 | return this._encodeObjid(data, null, null); | ||
815 | else if (tag === 'gentime' || tag === 'utctime') | ||
816 | return this._encodeTime(data, tag); | ||
817 | else if (tag === 'null_') | ||
818 | return this._encodeNull(); | ||
819 | else if (tag === 'int' || tag === 'enum') | ||
820 | return this._encodeInt(data, state.args && state.reverseArgs[0]); | ||
821 | else if (tag === 'bool') | ||
822 | return this._encodeBool(data); | ||
823 | else if (tag === 'objDesc') | ||
824 | return this._encodeStr(data, tag); | ||
825 | else | ||
826 | throw new Error('Unsupported tag: ' + tag); | ||
827 | }; | ||
828 | |||
829 | Node.prototype._isNumstr = function isNumstr(str) { | ||
830 | return /^[0-9 ]*$/.test(str); | ||
831 | }; | ||
832 | |||
833 | Node.prototype._isPrintstr = function isPrintstr(str) { | ||
834 | return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str); | ||
835 | }; | ||
836 | |||
837 | },{"../base":4,"minimalistic-assert":356}],6:[function(require,module,exports){ | ||
838 | var inherits = require('inherits'); | ||
839 | |||
840 | function Reporter(options) { | ||
841 | this._reporterState = { | ||
842 | obj: null, | ||
843 | path: [], | ||
844 | options: options || {}, | ||
845 | errors: [] | ||
846 | }; | ||
847 | } | ||
848 | exports.Reporter = Reporter; | ||
849 | |||
850 | Reporter.prototype.isError = function isError(obj) { | ||
851 | return obj instanceof ReporterError; | ||
852 | }; | ||
853 | |||
854 | Reporter.prototype.save = function save() { | ||
855 | var state = this._reporterState; | ||
856 | |||
857 | return { obj: state.obj, pathLen: state.path.length }; | ||
858 | }; | ||
859 | |||
860 | Reporter.prototype.restore = function restore(data) { | ||
861 | var state = this._reporterState; | ||
862 | |||
863 | state.obj = data.obj; | ||
864 | state.path = state.path.slice(0, data.pathLen); | ||
865 | }; | ||
866 | |||
867 | Reporter.prototype.enterKey = function enterKey(key) { | ||
868 | return this._reporterState.path.push(key); | ||
869 | }; | ||
870 | |||
871 | Reporter.prototype.exitKey = function exitKey(index) { | ||
872 | var state = this._reporterState; | ||
873 | |||
874 | state.path = state.path.slice(0, index - 1); | ||
875 | }; | ||
876 | |||
877 | Reporter.prototype.leaveKey = function leaveKey(index, key, value) { | ||
878 | var state = this._reporterState; | ||
879 | |||
880 | this.exitKey(index); | ||
881 | if (state.obj !== null) | ||
882 | state.obj[key] = value; | ||
883 | }; | ||
884 | |||
885 | Reporter.prototype.path = function path() { | ||
886 | return this._reporterState.path.join('/'); | ||
887 | }; | ||
888 | |||
889 | Reporter.prototype.enterObject = function enterObject() { | ||
890 | var state = this._reporterState; | ||
891 | |||
892 | var prev = state.obj; | ||
893 | state.obj = {}; | ||
894 | return prev; | ||
895 | }; | ||
896 | |||
897 | Reporter.prototype.leaveObject = function leaveObject(prev) { | ||
898 | var state = this._reporterState; | ||
899 | |||
900 | var now = state.obj; | ||
901 | state.obj = prev; | ||
902 | return now; | ||
903 | }; | ||
904 | |||
905 | Reporter.prototype.error = function error(msg) { | ||
906 | var err; | ||
907 | var state = this._reporterState; | ||
908 | |||
909 | var inherited = msg instanceof ReporterError; | ||
910 | if (inherited) { | ||
911 | err = msg; | ||
912 | } else { | ||
913 | err = new ReporterError(state.path.map(function(elem) { | ||
914 | return '[' + JSON.stringify(elem) + ']'; | ||
915 | }).join(''), msg.message || msg, msg.stack); | ||
916 | } | ||
917 | |||
918 | if (!state.options.partial) | ||
919 | throw err; | ||
920 | |||
921 | if (!inherited) | ||
922 | state.errors.push(err); | ||
923 | |||
924 | return err; | ||
925 | }; | ||
926 | |||
927 | Reporter.prototype.wrapResult = function wrapResult(result) { | ||
928 | var state = this._reporterState; | ||
929 | if (!state.options.partial) | ||
930 | return result; | ||
931 | |||
932 | return { | ||
933 | result: this.isError(result) ? null : result, | ||
934 | errors: state.errors | ||
935 | }; | ||
936 | }; | ||
937 | |||
938 | function ReporterError(path, msg) { | ||
939 | this.path = path; | ||
940 | this.rethrow(msg); | ||
941 | }; | ||
942 | inherits(ReporterError, Error); | ||
943 | |||
944 | ReporterError.prototype.rethrow = function rethrow(msg) { | ||
945 | this.message = msg + ' at: ' + (this.path || '(shallow)'); | ||
946 | if (Error.captureStackTrace) | ||
947 | Error.captureStackTrace(this, ReporterError); | ||
948 | |||
949 | if (!this.stack) { | ||
950 | try { | ||
951 | // IE only adds stack when thrown | ||
952 | throw new Error(this.message); | ||
953 | } catch (e) { | ||
954 | this.stack = e.stack; | ||
955 | } | ||
956 | } | ||
957 | return this; | ||
958 | }; | ||
959 | |||
960 | },{"inherits":116}],7:[function(require,module,exports){ | ||
961 | var constants = require('../constants'); | ||
962 | |||
963 | exports.tagClass = { | ||
964 | 0: 'universal', | ||
965 | 1: 'application', | ||
966 | 2: 'context', | ||
967 | 3: 'private' | ||
968 | }; | ||
969 | exports.tagClassByName = constants._reverse(exports.tagClass); | ||
970 | |||
971 | exports.tag = { | ||
972 | 0x00: 'end', | ||
973 | 0x01: 'bool', | ||
974 | 0x02: 'int', | ||
975 | 0x03: 'bitstr', | ||
976 | 0x04: 'octstr', | ||
977 | 0x05: 'null_', | ||
978 | 0x06: 'objid', | ||
979 | 0x07: 'objDesc', | ||
980 | 0x08: 'external', | ||
981 | 0x09: 'real', | ||
982 | 0x0a: 'enum', | ||
983 | 0x0b: 'embed', | ||
984 | 0x0c: 'utf8str', | ||
985 | 0x0d: 'relativeOid', | ||
986 | 0x10: 'seq', | ||
987 | 0x11: 'set', | ||
988 | 0x12: 'numstr', | ||
989 | 0x13: 'printstr', | ||
990 | 0x14: 't61str', | ||
991 | 0x15: 'videostr', | ||
992 | 0x16: 'ia5str', | ||
993 | 0x17: 'utctime', | ||
994 | 0x18: 'gentime', | ||
995 | 0x19: 'graphstr', | ||
996 | 0x1a: 'iso646str', | ||
997 | 0x1b: 'genstr', | ||
998 | 0x1c: 'unistr', | ||
999 | 0x1d: 'charstr', | ||
1000 | 0x1e: 'bmpstr' | ||
1001 | }; | ||
1002 | exports.tagByName = constants._reverse(exports.tag); | ||
1003 | |||
1004 | },{"../constants":8}],8:[function(require,module,exports){ | ||
1005 | var constants = exports; | ||
1006 | |||
1007 | // Helper | ||
1008 | constants._reverse = function reverse(map) { | ||
1009 | var res = {}; | ||
1010 | |||
1011 | Object.keys(map).forEach(function(key) { | ||
1012 | // Convert key to integer if it is stringified | ||
1013 | if ((key | 0) == key) | ||
1014 | key = key | 0; | ||
1015 | |||
1016 | var value = map[key]; | ||
1017 | res[value] = key; | ||
1018 | }); | ||
1019 | |||
1020 | return res; | ||
1021 | }; | ||
1022 | |||
1023 | constants.der = require('./der'); | ||
1024 | |||
1025 | },{"./der":7}],9:[function(require,module,exports){ | ||
1026 | var inherits = require('inherits'); | ||
1027 | |||
1028 | var asn1 = require('../../asn1'); | ||
1029 | var base = asn1.base; | ||
1030 | var bignum = asn1.bignum; | ||
1031 | |||
1032 | // Import DER constants | ||
1033 | var der = asn1.constants.der; | ||
1034 | |||
1035 | function DERDecoder(entity) { | ||
1036 | this.enc = 'der'; | ||
1037 | this.name = entity.name; | ||
1038 | this.entity = entity; | ||
1039 | |||
1040 | // Construct base tree | ||
1041 | this.tree = new DERNode(); | ||
1042 | this.tree._init(entity.body); | ||
1043 | }; | ||
1044 | module.exports = DERDecoder; | ||
1045 | |||
1046 | DERDecoder.prototype.decode = function decode(data, options) { | ||
1047 | if (!(data instanceof base.DecoderBuffer)) | ||
1048 | data = new base.DecoderBuffer(data, options); | ||
1049 | |||
1050 | return this.tree._decode(data, options); | ||
1051 | }; | ||
1052 | |||
1053 | // Tree methods | ||
1054 | |||
1055 | function DERNode(parent) { | ||
1056 | base.Node.call(this, 'der', parent); | ||
1057 | } | ||
1058 | inherits(DERNode, base.Node); | ||
1059 | |||
1060 | DERNode.prototype._peekTag = function peekTag(buffer, tag, any) { | ||
1061 | if (buffer.isEmpty()) | ||
1062 | return false; | ||
1063 | |||
1064 | var state = buffer.save(); | ||
1065 | var decodedTag = derDecodeTag(buffer, 'Failed to peek tag: "' + tag + '"'); | ||
1066 | if (buffer.isError(decodedTag)) | ||
1067 | return decodedTag; | ||
1068 | |||
1069 | buffer.restore(state); | ||
1070 | |||
1071 | return decodedTag.tag === tag || decodedTag.tagStr === tag || | ||
1072 | (decodedTag.tagStr + 'of') === tag || any; | ||
1073 | }; | ||
1074 | |||
1075 | DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) { | ||
1076 | var decodedTag = derDecodeTag(buffer, | ||
1077 | 'Failed to decode tag of "' + tag + '"'); | ||
1078 | if (buffer.isError(decodedTag)) | ||
1079 | return decodedTag; | ||
1080 | |||
1081 | var len = derDecodeLen(buffer, | ||
1082 | decodedTag.primitive, | ||
1083 | 'Failed to get length of "' + tag + '"'); | ||
1084 | |||
1085 | // Failure | ||
1086 | if (buffer.isError(len)) | ||
1087 | return len; | ||
1088 | |||
1089 | if (!any && | ||
1090 | decodedTag.tag !== tag && | ||
1091 | decodedTag.tagStr !== tag && | ||
1092 | decodedTag.tagStr + 'of' !== tag) { | ||
1093 | return buffer.error('Failed to match tag: "' + tag + '"'); | ||
1094 | } | ||
1095 | |||
1096 | if (decodedTag.primitive || len !== null) | ||
1097 | return buffer.skip(len, 'Failed to match body of: "' + tag + '"'); | ||
1098 | |||
1099 | // Indefinite length... find END tag | ||
1100 | var state = buffer.save(); | ||
1101 | var res = this._skipUntilEnd( | ||
1102 | buffer, | ||
1103 | 'Failed to skip indefinite length body: "' + this.tag + '"'); | ||
1104 | if (buffer.isError(res)) | ||
1105 | return res; | ||
1106 | |||
1107 | len = buffer.offset - state.offset; | ||
1108 | buffer.restore(state); | ||
1109 | return buffer.skip(len, 'Failed to match body of: "' + tag + '"'); | ||
1110 | }; | ||
1111 | |||
1112 | DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) { | ||
1113 | while (true) { | ||
1114 | var tag = derDecodeTag(buffer, fail); | ||
1115 | if (buffer.isError(tag)) | ||
1116 | return tag; | ||
1117 | var len = derDecodeLen(buffer, tag.primitive, fail); | ||
1118 | if (buffer.isError(len)) | ||
1119 | return len; | ||
1120 | |||
1121 | var res; | ||
1122 | if (tag.primitive || len !== null) | ||
1123 | res = buffer.skip(len) | ||
1124 | else | ||
1125 | res = this._skipUntilEnd(buffer, fail); | ||
1126 | |||
1127 | // Failure | ||
1128 | if (buffer.isError(res)) | ||
1129 | return res; | ||
1130 | |||
1131 | if (tag.tagStr === 'end') | ||
1132 | break; | ||
1133 | } | ||
1134 | }; | ||
1135 | |||
1136 | DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder, | ||
1137 | options) { | ||
1138 | var result = []; | ||
1139 | while (!buffer.isEmpty()) { | ||
1140 | var possibleEnd = this._peekTag(buffer, 'end'); | ||
1141 | if (buffer.isError(possibleEnd)) | ||
1142 | return possibleEnd; | ||
1143 | |||
1144 | var res = decoder.decode(buffer, 'der', options); | ||
1145 | if (buffer.isError(res) && possibleEnd) | ||
1146 | break; | ||
1147 | result.push(res); | ||
1148 | } | ||
1149 | return result; | ||
1150 | }; | ||
1151 | |||
1152 | DERNode.prototype._decodeStr = function decodeStr(buffer, tag) { | ||
1153 | if (tag === 'bitstr') { | ||
1154 | var unused = buffer.readUInt8(); | ||
1155 | if (buffer.isError(unused)) | ||
1156 | return unused; | ||
1157 | return { unused: unused, data: buffer.raw() }; | ||
1158 | } else if (tag === 'bmpstr') { | ||
1159 | var raw = buffer.raw(); | ||
1160 | if (raw.length % 2 === 1) | ||
1161 | return buffer.error('Decoding of string type: bmpstr length mismatch'); | ||
1162 | |||
1163 | var str = ''; | ||
1164 | for (var i = 0; i < raw.length / 2; i++) { | ||
1165 | str += String.fromCharCode(raw.readUInt16BE(i * 2)); | ||
1166 | } | ||
1167 | return str; | ||
1168 | } else if (tag === 'numstr') { | ||
1169 | var numstr = buffer.raw().toString('ascii'); | ||
1170 | if (!this._isNumstr(numstr)) { | ||
1171 | return buffer.error('Decoding of string type: ' + | ||
1172 | 'numstr unsupported characters'); | ||
1173 | } | ||
1174 | return numstr; | ||
1175 | } else if (tag === 'octstr') { | ||
1176 | return buffer.raw(); | ||
1177 | } else if (tag === 'objDesc') { | ||
1178 | return buffer.raw(); | ||
1179 | } else if (tag === 'printstr') { | ||
1180 | var printstr = buffer.raw().toString('ascii'); | ||
1181 | if (!this._isPrintstr(printstr)) { | ||
1182 | return buffer.error('Decoding of string type: ' + | ||
1183 | 'printstr unsupported characters'); | ||
1184 | } | ||
1185 | return printstr; | ||
1186 | } else if (/str$/.test(tag)) { | ||
1187 | return buffer.raw().toString(); | ||
1188 | } else { | ||
1189 | return buffer.error('Decoding of string type: ' + tag + ' unsupported'); | ||
1190 | } | ||
1191 | }; | ||
1192 | |||
1193 | DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) { | ||
1194 | var result; | ||
1195 | var identifiers = []; | ||
1196 | var ident = 0; | ||
1197 | while (!buffer.isEmpty()) { | ||
1198 | var subident = buffer.readUInt8(); | ||
1199 | ident <<= 7; | ||
1200 | ident |= subident & 0x7f; | ||
1201 | if ((subident & 0x80) === 0) { | ||
1202 | identifiers.push(ident); | ||
1203 | ident = 0; | ||
1204 | } | ||
1205 | } | ||
1206 | if (subident & 0x80) | ||
1207 | identifiers.push(ident); | ||
1208 | |||
1209 | var first = (identifiers[0] / 40) | 0; | ||
1210 | var second = identifiers[0] % 40; | ||
1211 | |||
1212 | if (relative) | ||
1213 | result = identifiers; | ||
1214 | else | ||
1215 | result = [first, second].concat(identifiers.slice(1)); | ||
1216 | |||
1217 | if (values) { | ||
1218 | var tmp = values[result.join(' ')]; | ||
1219 | if (tmp === undefined) | ||
1220 | tmp = values[result.join('.')]; | ||
1221 | if (tmp !== undefined) | ||
1222 | result = tmp; | ||
1223 | } | ||
1224 | |||
1225 | return result; | ||
1226 | }; | ||
1227 | |||
1228 | DERNode.prototype._decodeTime = function decodeTime(buffer, tag) { | ||
1229 | var str = buffer.raw().toString(); | ||
1230 | if (tag === 'gentime') { | ||
1231 | var year = str.slice(0, 4) | 0; | ||
1232 | var mon = str.slice(4, 6) | 0; | ||
1233 | var day = str.slice(6, 8) | 0; | ||
1234 | var hour = str.slice(8, 10) | 0; | ||
1235 | var min = str.slice(10, 12) | 0; | ||
1236 | var sec = str.slice(12, 14) | 0; | ||
1237 | } else if (tag === 'utctime') { | ||
1238 | var year = str.slice(0, 2) | 0; | ||
1239 | var mon = str.slice(2, 4) | 0; | ||
1240 | var day = str.slice(4, 6) | 0; | ||
1241 | var hour = str.slice(6, 8) | 0; | ||
1242 | var min = str.slice(8, 10) | 0; | ||
1243 | var sec = str.slice(10, 12) | 0; | ||
1244 | if (year < 70) | ||
1245 | year = 2000 + year; | ||
1246 | else | ||
1247 | year = 1900 + year; | ||
1248 | } else { | ||
1249 | return buffer.error('Decoding ' + tag + ' time is not supported yet'); | ||
1250 | } | ||
1251 | |||
1252 | return Date.UTC(year, mon - 1, day, hour, min, sec, 0); | ||
1253 | }; | ||
1254 | |||
1255 | DERNode.prototype._decodeNull = function decodeNull(buffer) { | ||
1256 | return null; | ||
1257 | }; | ||
1258 | |||
1259 | DERNode.prototype._decodeBool = function decodeBool(buffer) { | ||
1260 | var res = buffer.readUInt8(); | ||
1261 | if (buffer.isError(res)) | ||
1262 | return res; | ||
1263 | else | ||
1264 | return res !== 0; | ||
1265 | }; | ||
1266 | |||
1267 | DERNode.prototype._decodeInt = function decodeInt(buffer, values) { | ||
1268 | // Bigint, return as it is (assume big endian) | ||
1269 | var raw = buffer.raw(); | ||
1270 | var res = new bignum(raw); | ||
1271 | |||
1272 | if (values) | ||
1273 | res = values[res.toString(10)] || res; | ||
1274 | |||
1275 | return res; | ||
1276 | }; | ||
1277 | |||
1278 | DERNode.prototype._use = function use(entity, obj) { | ||
1279 | if (typeof entity === 'function') | ||
1280 | entity = entity(obj); | ||
1281 | return entity._getDecoder('der').tree; | ||
1282 | }; | ||
1283 | |||
1284 | // Utility methods | ||
1285 | |||
1286 | function derDecodeTag(buf, fail) { | ||
1287 | var tag = buf.readUInt8(fail); | ||
1288 | if (buf.isError(tag)) | ||
1289 | return tag; | ||
1290 | |||
1291 | var cls = der.tagClass[tag >> 6]; | ||
1292 | var primitive = (tag & 0x20) === 0; | ||
1293 | |||
1294 | // Multi-octet tag - load | ||
1295 | if ((tag & 0x1f) === 0x1f) { | ||
1296 | var oct = tag; | ||
1297 | tag = 0; | ||
1298 | while ((oct & 0x80) === 0x80) { | ||
1299 | oct = buf.readUInt8(fail); | ||
1300 | if (buf.isError(oct)) | ||
1301 | return oct; | ||
1302 | |||
1303 | tag <<= 7; | ||
1304 | tag |= oct & 0x7f; | ||
1305 | } | ||
1306 | } else { | ||
1307 | tag &= 0x1f; | ||
1308 | } | ||
1309 | var tagStr = der.tag[tag]; | ||
1310 | |||
1311 | return { | ||
1312 | cls: cls, | ||
1313 | primitive: primitive, | ||
1314 | tag: tag, | ||
1315 | tagStr: tagStr | ||
1316 | }; | ||
1317 | } | ||
1318 | |||
1319 | function derDecodeLen(buf, primitive, fail) { | ||
1320 | var len = buf.readUInt8(fail); | ||
1321 | if (buf.isError(len)) | ||
1322 | return len; | ||
1323 | |||
1324 | // Indefinite form | ||
1325 | if (!primitive && len === 0x80) | ||
1326 | return null; | ||
1327 | |||
1328 | // Definite form | ||
1329 | if ((len & 0x80) === 0) { | ||
1330 | // Short form | ||
1331 | return len; | ||
1332 | } | ||
1333 | |||
1334 | // Long form | ||
1335 | var num = len & 0x7f; | ||
1336 | if (num > 4) | ||
1337 | return buf.error('length octect is too long'); | ||
1338 | |||
1339 | len = 0; | ||
1340 | for (var i = 0; i < num; i++) { | ||
1341 | len <<= 8; | ||
1342 | var j = buf.readUInt8(fail); | ||
1343 | if (buf.isError(j)) | ||
1344 | return j; | ||
1345 | len |= j; | ||
1346 | } | ||
1347 | |||
1348 | return len; | ||
1349 | } | ||
1350 | |||
1351 | },{"../../asn1":1,"inherits":116}],10:[function(require,module,exports){ | ||
1352 | var decoders = exports; | ||
1353 | |||
1354 | decoders.der = require('./der'); | ||
1355 | decoders.pem = require('./pem'); | ||
1356 | |||
1357 | },{"./der":9,"./pem":11}],11:[function(require,module,exports){ | ||
1358 | var inherits = require('inherits'); | ||
1359 | var Buffer = require('buffer').Buffer; | ||
1360 | |||
1361 | var DERDecoder = require('./der'); | ||
1362 | |||
1363 | function PEMDecoder(entity) { | ||
1364 | DERDecoder.call(this, entity); | ||
1365 | this.enc = 'pem'; | ||
1366 | }; | ||
1367 | inherits(PEMDecoder, DERDecoder); | ||
1368 | module.exports = PEMDecoder; | ||
1369 | |||
1370 | PEMDecoder.prototype.decode = function decode(data, options) { | ||
1371 | var lines = data.toString().split(/[\r\n]+/g); | ||
1372 | |||
1373 | var label = options.label.toUpperCase(); | ||
1374 | |||
1375 | var re = /^-----(BEGIN|END) ([^-]+)-----$/; | ||
1376 | var start = -1; | ||
1377 | var end = -1; | ||
1378 | for (var i = 0; i < lines.length; i++) { | ||
1379 | var match = lines[i].match(re); | ||
1380 | if (match === null) | ||
1381 | continue; | ||
1382 | |||
1383 | if (match[2] !== label) | ||
1384 | continue; | ||
1385 | |||
1386 | if (start === -1) { | ||
1387 | if (match[1] !== 'BEGIN') | ||
1388 | break; | ||
1389 | start = i; | ||
1390 | } else { | ||
1391 | if (match[1] !== 'END') | ||
1392 | break; | ||
1393 | end = i; | ||
1394 | break; | ||
1395 | } | ||
1396 | } | ||
1397 | if (start === -1 || end === -1) | ||
1398 | throw new Error('PEM section not found for: ' + label); | ||
1399 | |||
1400 | var base64 = lines.slice(start + 1, end).join(''); | ||
1401 | // Remove excessive symbols | ||
1402 | base64.replace(/[^a-z0-9\+\/=]+/gi, ''); | ||
1403 | |||
1404 | var input = new Buffer(base64, 'base64'); | ||
1405 | return DERDecoder.prototype.decode.call(this, input, options); | ||
1406 | }; | ||
1407 | |||
1408 | },{"./der":9,"buffer":49,"inherits":116}],12:[function(require,module,exports){ | ||
1409 | var inherits = require('inherits'); | ||
1410 | var Buffer = require('buffer').Buffer; | ||
1411 | |||
1412 | var asn1 = require('../../asn1'); | ||
1413 | var base = asn1.base; | ||
1414 | |||
1415 | // Import DER constants | ||
1416 | var der = asn1.constants.der; | ||
1417 | |||
1418 | function DEREncoder(entity) { | ||
1419 | this.enc = 'der'; | ||
1420 | this.name = entity.name; | ||
1421 | this.entity = entity; | ||
1422 | |||
1423 | // Construct base tree | ||
1424 | this.tree = new DERNode(); | ||
1425 | this.tree._init(entity.body); | ||
1426 | }; | ||
1427 | module.exports = DEREncoder; | ||
1428 | |||
1429 | DEREncoder.prototype.encode = function encode(data, reporter) { | ||
1430 | return this.tree._encode(data, reporter).join(); | ||
1431 | }; | ||
1432 | |||
1433 | // Tree methods | ||
1434 | |||
1435 | function DERNode(parent) { | ||
1436 | base.Node.call(this, 'der', parent); | ||
1437 | } | ||
1438 | inherits(DERNode, base.Node); | ||
1439 | |||
1440 | DERNode.prototype._encodeComposite = function encodeComposite(tag, | ||
1441 | primitive, | ||
1442 | cls, | ||
1443 | content) { | ||
1444 | var encodedTag = encodeTag(tag, primitive, cls, this.reporter); | ||
1445 | |||
1446 | // Short form | ||
1447 | if (content.length < 0x80) { | ||
1448 | var header = new Buffer(2); | ||
1449 | header[0] = encodedTag; | ||
1450 | header[1] = content.length; | ||
1451 | return this._createEncoderBuffer([ header, content ]); | ||
1452 | } | ||
1453 | |||
1454 | // Long form | ||
1455 | // Count octets required to store length | ||
1456 | var lenOctets = 1; | ||
1457 | for (var i = content.length; i >= 0x100; i >>= 8) | ||
1458 | lenOctets++; | ||
1459 | |||
1460 | var header = new Buffer(1 + 1 + lenOctets); | ||
1461 | header[0] = encodedTag; | ||
1462 | header[1] = 0x80 | lenOctets; | ||
1463 | |||
1464 | for (var i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8) | ||
1465 | header[i] = j & 0xff; | ||
1466 | |||
1467 | return this._createEncoderBuffer([ header, content ]); | ||
1468 | }; | ||
1469 | |||
1470 | DERNode.prototype._encodeStr = function encodeStr(str, tag) { | ||
1471 | if (tag === 'bitstr') { | ||
1472 | return this._createEncoderBuffer([ str.unused | 0, str.data ]); | ||
1473 | } else if (tag === 'bmpstr') { | ||
1474 | var buf = new Buffer(str.length * 2); | ||
1475 | for (var i = 0; i < str.length; i++) { | ||
1476 | buf.writeUInt16BE(str.charCodeAt(i), i * 2); | ||
1477 | } | ||
1478 | return this._createEncoderBuffer(buf); | ||
1479 | } else if (tag === 'numstr') { | ||
1480 | if (!this._isNumstr(str)) { | ||
1481 | return this.reporter.error('Encoding of string type: numstr supports ' + | ||
1482 | 'only digits and space'); | ||
1483 | } | ||
1484 | return this._createEncoderBuffer(str); | ||
1485 | } else if (tag === 'printstr') { | ||
1486 | if (!this._isPrintstr(str)) { | ||
1487 | return this.reporter.error('Encoding of string type: printstr supports ' + | ||
1488 | 'only latin upper and lower case letters, ' + | ||
1489 | 'digits, space, apostrophe, left and rigth ' + | ||
1490 | 'parenthesis, plus sign, comma, hyphen, ' + | ||
1491 | 'dot, slash, colon, equal sign, ' + | ||
1492 | 'question mark'); | ||
1493 | } | ||
1494 | return this._createEncoderBuffer(str); | ||
1495 | } else if (/str$/.test(tag)) { | ||
1496 | return this._createEncoderBuffer(str); | ||
1497 | } else if (tag === 'objDesc') { | ||
1498 | return this._createEncoderBuffer(str); | ||
1499 | } else { | ||
1500 | return this.reporter.error('Encoding of string type: ' + tag + | ||
1501 | ' unsupported'); | ||
1502 | } | ||
1503 | }; | ||
1504 | |||
1505 | DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) { | ||
1506 | if (typeof id === 'string') { | ||
1507 | if (!values) | ||
1508 | return this.reporter.error('string objid given, but no values map found'); | ||
1509 | if (!values.hasOwnProperty(id)) | ||
1510 | return this.reporter.error('objid not found in values map'); | ||
1511 | id = values[id].split(/[\s\.]+/g); | ||
1512 | for (var i = 0; i < id.length; i++) | ||
1513 | id[i] |= 0; | ||
1514 | } else if (Array.isArray(id)) { | ||
1515 | id = id.slice(); | ||
1516 | for (var i = 0; i < id.length; i++) | ||
1517 | id[i] |= 0; | ||
1518 | } | ||
1519 | |||
1520 | if (!Array.isArray(id)) { | ||
1521 | return this.reporter.error('objid() should be either array or string, ' + | ||
1522 | 'got: ' + JSON.stringify(id)); | ||
1523 | } | ||
1524 | |||
1525 | if (!relative) { | ||
1526 | if (id[1] >= 40) | ||
1527 | return this.reporter.error('Second objid identifier OOB'); | ||
1528 | id.splice(0, 2, id[0] * 40 + id[1]); | ||
1529 | } | ||
1530 | |||
1531 | // Count number of octets | ||
1532 | var size = 0; | ||
1533 | for (var i = 0; i < id.length; i++) { | ||
1534 | var ident = id[i]; | ||
1535 | for (size++; ident >= 0x80; ident >>= 7) | ||
1536 | size++; | ||
1537 | } | ||
1538 | |||
1539 | var objid = new Buffer(size); | ||
1540 | var offset = objid.length - 1; | ||
1541 | for (var i = id.length - 1; i >= 0; i--) { | ||
1542 | var ident = id[i]; | ||
1543 | objid[offset--] = ident & 0x7f; | ||
1544 | while ((ident >>= 7) > 0) | ||
1545 | objid[offset--] = 0x80 | (ident & 0x7f); | ||
1546 | } | ||
1547 | |||
1548 | return this._createEncoderBuffer(objid); | ||
1549 | }; | ||
1550 | |||
1551 | function two(num) { | ||
1552 | if (num < 10) | ||
1553 | return '0' + num; | ||
1554 | else | ||
1555 | return num; | ||
1556 | } | ||
1557 | |||
1558 | DERNode.prototype._encodeTime = function encodeTime(time, tag) { | ||
1559 | var str; | ||
1560 | var date = new Date(time); | ||
1561 | |||
1562 | if (tag === 'gentime') { | ||
1563 | str = [ | ||
1564 | two(date.getFullYear()), | ||
1565 | two(date.getUTCMonth() + 1), | ||
1566 | two(date.getUTCDate()), | ||
1567 | two(date.getUTCHours()), | ||
1568 | two(date.getUTCMinutes()), | ||
1569 | two(date.getUTCSeconds()), | ||
1570 | 'Z' | ||
1571 | ].join(''); | ||
1572 | } else if (tag === 'utctime') { | ||
1573 | str = [ | ||
1574 | two(date.getFullYear() % 100), | ||
1575 | two(date.getUTCMonth() + 1), | ||
1576 | two(date.getUTCDate()), | ||
1577 | two(date.getUTCHours()), | ||
1578 | two(date.getUTCMinutes()), | ||
1579 | two(date.getUTCSeconds()), | ||
1580 | 'Z' | ||
1581 | ].join(''); | ||
1582 | } else { | ||
1583 | this.reporter.error('Encoding ' + tag + ' time is not supported yet'); | ||
1584 | } | ||
1585 | |||
1586 | return this._encodeStr(str, 'octstr'); | ||
1587 | }; | ||
1588 | |||
1589 | DERNode.prototype._encodeNull = function encodeNull() { | ||
1590 | return this._createEncoderBuffer(''); | ||
1591 | }; | ||
1592 | |||
1593 | DERNode.prototype._encodeInt = function encodeInt(num, values) { | ||
1594 | if (typeof num === 'string') { | ||
1595 | if (!values) | ||
1596 | return this.reporter.error('String int or enum given, but no values map'); | ||
1597 | if (!values.hasOwnProperty(num)) { | ||
1598 | return this.reporter.error('Values map doesn\'t contain: ' + | ||
1599 | JSON.stringify(num)); | ||
1600 | } | ||
1601 | num = values[num]; | ||
1602 | } | ||
1603 | |||
1604 | // Bignum, assume big endian | ||
1605 | if (typeof num !== 'number' && !Buffer.isBuffer(num)) { | ||
1606 | var numArray = num.toArray(); | ||
1607 | if (!num.sign && numArray[0] & 0x80) { | ||
1608 | numArray.unshift(0); | ||
1609 | } | ||
1610 | num = new Buffer(numArray); | ||
1611 | } | ||
1612 | |||
1613 | if (Buffer.isBuffer(num)) { | ||
1614 | var size = num.length; | ||
1615 | if (num.length === 0) | ||
1616 | size++; | ||
1617 | |||
1618 | var out = new Buffer(size); | ||
1619 | num.copy(out); | ||
1620 | if (num.length === 0) | ||
1621 | out[0] = 0 | ||
1622 | return this._createEncoderBuffer(out); | ||
1623 | } | ||
1624 | |||
1625 | if (num < 0x80) | ||
1626 | return this._createEncoderBuffer(num); | ||
1627 | |||
1628 | if (num < 0x100) | ||
1629 | return this._createEncoderBuffer([0, num]); | ||
1630 | |||
1631 | var size = 1; | ||
1632 | for (var i = num; i >= 0x100; i >>= 8) | ||
1633 | size++; | ||
1634 | |||
1635 | var out = new Array(size); | ||
1636 | for (var i = out.length - 1; i >= 0; i--) { | ||
1637 | out[i] = num & 0xff; | ||
1638 | num >>= 8; | ||
1639 | } | ||
1640 | if(out[0] & 0x80) { | ||
1641 | out.unshift(0); | ||
1642 | } | ||
1643 | |||
1644 | return this._createEncoderBuffer(new Buffer(out)); | ||
1645 | }; | ||
1646 | |||
1647 | DERNode.prototype._encodeBool = function encodeBool(value) { | ||
1648 | return this._createEncoderBuffer(value ? 0xff : 0); | ||
1649 | }; | ||
1650 | |||
1651 | DERNode.prototype._use = function use(entity, obj) { | ||
1652 | if (typeof entity === 'function') | ||
1653 | entity = entity(obj); | ||
1654 | return entity._getEncoder('der').tree; | ||
1655 | }; | ||
1656 | |||
1657 | DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) { | ||
1658 | var state = this._baseState; | ||
1659 | var i; | ||
1660 | if (state['default'] === null) | ||
1661 | return false; | ||
1662 | |||
1663 | var data = dataBuffer.join(); | ||
1664 | if (state.defaultBuffer === undefined) | ||
1665 | state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join(); | ||
1666 | |||
1667 | if (data.length !== state.defaultBuffer.length) | ||
1668 | return false; | ||
1669 | |||
1670 | for (i=0; i < data.length; i++) | ||
1671 | if (data[i] !== state.defaultBuffer[i]) | ||
1672 | return false; | ||
1673 | |||
1674 | return true; | ||
1675 | }; | ||
1676 | |||
1677 | // Utility methods | ||
1678 | |||
1679 | function encodeTag(tag, primitive, cls, reporter) { | ||
1680 | var res; | ||
1681 | |||
1682 | if (tag === 'seqof') | ||
1683 | tag = 'seq'; | ||
1684 | else if (tag === 'setof') | ||
1685 | tag = 'set'; | ||
1686 | |||
1687 | if (der.tagByName.hasOwnProperty(tag)) | ||
1688 | res = der.tagByName[tag]; | ||
1689 | else if (typeof tag === 'number' && (tag | 0) === tag) | ||
1690 | res = tag; | ||
1691 | else | ||
1692 | return reporter.error('Unknown tag: ' + tag); | ||
1693 | |||
1694 | if (res >= 0x1f) | ||
1695 | return reporter.error('Multi-octet tag encoding unsupported'); | ||
1696 | |||
1697 | if (!primitive) | ||
1698 | res |= 0x20; | ||
1699 | |||
1700 | res |= (der.tagClassByName[cls || 'universal'] << 6); | ||
1701 | |||
1702 | return res; | ||
1703 | } | ||
1704 | |||
1705 | },{"../../asn1":1,"buffer":49,"inherits":116}],13:[function(require,module,exports){ | ||
1706 | var encoders = exports; | ||
1707 | |||
1708 | encoders.der = require('./der'); | ||
1709 | encoders.pem = require('./pem'); | ||
1710 | |||
1711 | },{"./der":12,"./pem":14}],14:[function(require,module,exports){ | ||
1712 | var inherits = require('inherits'); | ||
1713 | |||
1714 | var DEREncoder = require('./der'); | ||
1715 | |||
1716 | function PEMEncoder(entity) { | ||
1717 | DEREncoder.call(this, entity); | ||
1718 | this.enc = 'pem'; | ||
1719 | }; | ||
1720 | inherits(PEMEncoder, DEREncoder); | ||
1721 | module.exports = PEMEncoder; | ||
1722 | |||
1723 | PEMEncoder.prototype.encode = function encode(data, options) { | ||
1724 | var buf = DEREncoder.prototype.encode.call(this, data); | ||
1725 | |||
1726 | var p = buf.toString('base64'); | ||
1727 | var out = [ '-----BEGIN ' + options.label + '-----' ]; | ||
1728 | for (var i = 0; i < p.length; i += 64) | ||
1729 | out.push(p.slice(i, i + 64)); | ||
1730 | out.push('-----END ' + options.label + '-----'); | ||
1731 | return out.join('\n'); | ||
1732 | }; | ||
1733 | |||
1734 | },{"./der":12,"inherits":116}],15:[function(require,module,exports){ | ||
1735 | "use strict"; | ||
1736 | |||
1737 | /** | ||
1738 | * Generate a character map. | ||
1739 | * @param {string} alphabet e.g. "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567" | ||
1740 | * @param {object} mappings map overrides from key to value | ||
1741 | * @method | ||
1742 | */ | ||
1743 | |||
1744 | var charmap = function (alphabet, mappings) { | ||
1745 | mappings || (mappings = {}); | ||
1746 | alphabet.split("").forEach(function (c, i) { | ||
1747 | if (!(c in mappings)) mappings[c] = i; | ||
1748 | }); | ||
1749 | return mappings; | ||
1750 | } | ||
1751 | |||
1752 | /** | ||
1753 | * The RFC 4648 base 32 alphabet and character map. | ||
1754 | * @see {@link https://tools.ietf.org/html/rfc4648} | ||
1755 | */ | ||
1756 | |||
1757 | var rfc4648 = { | ||
1758 | alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", | ||
1759 | charmap: { | ||
1760 | 0: 14, | ||
1761 | 1: 8 | ||
1762 | } | ||
1763 | }; | ||
1764 | |||
1765 | rfc4648.charmap = charmap(rfc4648.alphabet, rfc4648.charmap); | ||
1766 | |||
1767 | /** | ||
1768 | * The Crockford base 32 alphabet and character map. | ||
1769 | * @see {@link http://www.crockford.com/wrmg/base32.html} | ||
1770 | */ | ||
1771 | |||
1772 | var crockford = { | ||
1773 | alphabet: "0123456789ABCDEFGHJKMNPQRSTVWXYZ", | ||
1774 | charmap: { | ||
1775 | O: 0, | ||
1776 | I: 1, | ||
1777 | L: 1 | ||
1778 | } | ||
1779 | }; | ||
1780 | |||
1781 | crockford.charmap = charmap(crockford.alphabet, crockford.charmap); | ||
1782 | |||
1783 | /** | ||
1784 | * base32hex | ||
1785 | * @see {@link https://en.wikipedia.org/wiki/Base32#base32hex} | ||
1786 | */ | ||
1787 | |||
1788 | var base32hex = { | ||
1789 | alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV", | ||
1790 | charmap: {} | ||
1791 | }; | ||
1792 | |||
1793 | base32hex.charmap = charmap(base32hex.alphabet, base32hex.charmap); | ||
1794 | |||
1795 | /** | ||
1796 | * Create a new `Decoder` with the given options. | ||
1797 | * | ||
1798 | * @param {object} [options] | ||
1799 | * @param {string} [type] Supported Base-32 variants are "rfc4648" and | ||
1800 | * "crockford". | ||
1801 | * @param {object} [charmap] Override the character map used in decoding. | ||
1802 | * @constructor | ||
1803 | */ | ||
1804 | |||
1805 | function Decoder (options) { | ||
1806 | this.buf = []; | ||
1807 | this.shift = 8; | ||
1808 | this.carry = 0; | ||
1809 | |||
1810 | if (options) { | ||
1811 | |||
1812 | switch (options.type) { | ||
1813 | case "rfc4648": | ||
1814 | this.charmap = exports.rfc4648.charmap; | ||
1815 | break; | ||
1816 | case "crockford": | ||
1817 | this.charmap = exports.crockford.charmap; | ||
1818 | break; | ||
1819 | case "base32hex": | ||
1820 | this.charmap = exports.base32hex.charmap; | ||
1821 | break; | ||
1822 | default: | ||
1823 | throw new Error("invalid type"); | ||
1824 | } | ||
1825 | |||
1826 | if (options.charmap) this.charmap = options.charmap; | ||
1827 | } | ||
1828 | } | ||
1829 | |||
1830 | /** | ||
1831 | * The default character map coresponds to RFC4648. | ||
1832 | */ | ||
1833 | |||
1834 | Decoder.prototype.charmap = rfc4648.charmap; | ||
1835 | |||
1836 | /** | ||
1837 | * Decode a string, continuing from the previous state. | ||
1838 | * | ||
1839 | * @param {string} str | ||
1840 | * @return {Decoder} this | ||
1841 | */ | ||
1842 | |||
1843 | Decoder.prototype.write = function (str) { | ||
1844 | var charmap = this.charmap; | ||
1845 | var buf = this.buf; | ||
1846 | var shift = this.shift; | ||
1847 | var carry = this.carry; | ||
1848 | |||
1849 | // decode string | ||
1850 | str.toUpperCase().split("").forEach(function (char) { | ||
1851 | |||
1852 | // ignore padding | ||
1853 | if (char == "=") return; | ||
1854 | |||
1855 | // lookup symbol | ||
1856 | var symbol = charmap[char] & 0xff; | ||
1857 | |||
1858 | // 1: 00000 000 | ||
1859 | // 2: 00 00000 0 | ||
1860 | // 3: 0000 0000 | ||
1861 | // 4: 0 00000 00 | ||
1862 | // 5: 000 00000 | ||
1863 | // 6: 00000 000 | ||
1864 | // 7: 00 00000 0 | ||
1865 | |||
1866 | shift -= 5; | ||
1867 | if (shift > 0) { | ||
1868 | carry |= symbol << shift; | ||
1869 | } else if (shift < 0) { | ||
1870 | buf.push(carry | (symbol >> -shift)); | ||
1871 | shift += 8; | ||
1872 | carry = (symbol << shift) & 0xff; | ||
1873 | } else { | ||
1874 | buf.push(carry | symbol); | ||
1875 | shift = 8; | ||
1876 | carry = 0; | ||
1877 | } | ||
1878 | }); | ||
1879 | |||
1880 | // save state | ||
1881 | this.shift = shift; | ||
1882 | this.carry = carry; | ||
1883 | |||
1884 | // for chaining | ||
1885 | return this; | ||
1886 | }; | ||
1887 | |||
1888 | /** | ||
1889 | * Finish decoding. | ||
1890 | * | ||
1891 | * @param {string} [str] The final string to decode. | ||
1892 | * @return {Array} Decoded byte array. | ||
1893 | */ | ||
1894 | |||
1895 | Decoder.prototype.finalize = function (str) { | ||
1896 | if (str) { | ||
1897 | this.write(str); | ||
1898 | } | ||
1899 | if (this.shift !== 8 && this.carry !== 0) { | ||
1900 | this.buf.push(this.carry); | ||
1901 | this.shift = 8; | ||
1902 | this.carry = 0; | ||
1903 | } | ||
1904 | return this.buf; | ||
1905 | }; | ||
1906 | |||
1907 | /** | ||
1908 | * Create a new `Encoder` with the given options. | ||
1909 | * | ||
1910 | * @param {object} [options] | ||
1911 | * @param {string} [type] Supported Base-32 variants are "rfc4648" and | ||
1912 | * "crockford". | ||
1913 | * @param {object} [alphabet] Override the alphabet used in encoding. | ||
1914 | * @constructor | ||
1915 | */ | ||
1916 | |||
1917 | function Encoder (options) { | ||
1918 | this.buf = ""; | ||
1919 | this.shift = 3; | ||
1920 | this.carry = 0; | ||
1921 | |||
1922 | if (options) { | ||
1923 | |||
1924 | switch (options.type) { | ||
1925 | case "rfc4648": | ||
1926 | this.alphabet = exports.rfc4648.alphabet; | ||
1927 | break; | ||
1928 | case "crockford": | ||
1929 | this.alphabet = exports.crockford.alphabet; | ||
1930 | break; | ||
1931 | case "base32hex": | ||
1932 | this.alphabet = exports.base32hex.alphabet; | ||
1933 | break; | ||
1934 | default: | ||
1935 | throw new Error("invalid type"); | ||
1936 | } | ||
1937 | |||
1938 | if (options.alphabet) this.alphabet = options.alphabet; | ||
1939 | else if (options.lc) this.alphabet = this.alphabet.toLowerCase(); | ||
1940 | } | ||
1941 | } | ||
1942 | |||
1943 | /** | ||
1944 | * The default alphabet coresponds to RFC4648. | ||
1945 | */ | ||
1946 | |||
1947 | Encoder.prototype.alphabet = rfc4648.alphabet; | ||
1948 | |||
1949 | /** | ||
1950 | * Encode a byte array, continuing from the previous state. | ||
1951 | * | ||
1952 | * @param {byte[]} buf The byte array to encode. | ||
1953 | * @return {Encoder} this | ||
1954 | */ | ||
1955 | |||
1956 | Encoder.prototype.write = function (buf) { | ||
1957 | var shift = this.shift; | ||
1958 | var carry = this.carry; | ||
1959 | var symbol; | ||
1960 | var byte; | ||
1961 | var i; | ||
1962 | |||
1963 | // encode each byte in buf | ||
1964 | for (i = 0; i < buf.length; i++) { | ||
1965 | byte = buf[i]; | ||
1966 | |||
1967 | // 1: 00000 000 | ||
1968 | // 2: 00 00000 0 | ||
1969 | // 3: 0000 0000 | ||
1970 | // 4: 0 00000 00 | ||
1971 | // 5: 000 00000 | ||
1972 | // 6: 00000 000 | ||
1973 | // 7: 00 00000 0 | ||
1974 | |||
1975 | symbol = carry | (byte >> shift); | ||
1976 | this.buf += this.alphabet[symbol & 0x1f]; | ||
1977 | |||
1978 | if (shift > 5) { | ||
1979 | shift -= 5; | ||
1980 | symbol = byte >> shift; | ||
1981 | this.buf += this.alphabet[symbol & 0x1f]; | ||
1982 | } | ||
1983 | |||
1984 | shift = 5 - shift; | ||
1985 | carry = byte << shift; | ||
1986 | shift = 8 - shift; | ||
1987 | } | ||
1988 | |||
1989 | // save state | ||
1990 | this.shift = shift; | ||
1991 | this.carry = carry; | ||
1992 | |||
1993 | // for chaining | ||
1994 | return this; | ||
1995 | }; | ||
1996 | |||
1997 | /** | ||
1998 | * Finish encoding. | ||
1999 | * | ||
2000 | * @param {byte[]} [buf] The final byte array to encode. | ||
2001 | * @return {string} The encoded byte array. | ||
2002 | */ | ||
2003 | |||
2004 | Encoder.prototype.finalize = function (buf) { | ||
2005 | if (buf) { | ||
2006 | this.write(buf); | ||
2007 | } | ||
2008 | if (this.shift !== 3) { | ||
2009 | this.buf += this.alphabet[this.carry & 0x1f]; | ||
2010 | this.shift = 3; | ||
2011 | this.carry = 0; | ||
2012 | } | ||
2013 | return this.buf; | ||
2014 | }; | ||
2015 | |||
2016 | /** | ||
2017 | * Convenience encoder. | ||
2018 | * | ||
2019 | * @param {byte[]} buf The byte array to encode. | ||
2020 | * @param {object} [options] Options to pass to the encoder. | ||
2021 | * @return {string} The encoded string. | ||
2022 | */ | ||
2023 | |||
2024 | exports.encode = function (buf, options) { | ||
2025 | return new Encoder(options).finalize(buf); | ||
2026 | }; | ||
2027 | |||
2028 | /** | ||
2029 | * Convenience decoder. | ||
2030 | * | ||
2031 | * @param {string} str The string to decode. | ||
2032 | * @param {object} [options] Options to pass to the decoder. | ||
2033 | * @return {byte[]} The decoded byte array. | ||
2034 | */ | ||
2035 | |||
2036 | exports.decode = function (str, options) { | ||
2037 | return new Decoder(options).finalize(str); | ||
2038 | }; | ||
2039 | |||
2040 | // Exports. | ||
2041 | exports.Decoder = Decoder; | ||
2042 | exports.Encoder = Encoder; | ||
2043 | exports.charmap = charmap; | ||
2044 | exports.crockford = crockford; | ||
2045 | exports.rfc4648 = rfc4648; | ||
2046 | exports.base32hex = base32hex; | ||
2047 | |||
2048 | },{}],16:[function(require,module,exports){ | ||
2049 | 'use strict' | ||
2050 | |||
2051 | exports.byteLength = byteLength | ||
2052 | exports.toByteArray = toByteArray | ||
2053 | exports.fromByteArray = fromByteArray | ||
2054 | |||
2055 | var lookup = [] | ||
2056 | var revLookup = [] | ||
2057 | var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array | ||
2058 | |||
2059 | var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' | ||
2060 | for (var i = 0, len = code.length; i < len; ++i) { | ||
2061 | lookup[i] = code[i] | ||
2062 | revLookup[code.charCodeAt(i)] = i | ||
2063 | } | ||
2064 | |||
2065 | // Support decoding URL-safe base64 strings, as Node.js does. | ||
2066 | // See: https://en.wikipedia.org/wiki/Base64#URL_applications | ||
2067 | revLookup['-'.charCodeAt(0)] = 62 | ||
2068 | revLookup['_'.charCodeAt(0)] = 63 | ||
2069 | |||
2070 | function getLens (b64) { | ||
2071 | var len = b64.length | ||
2072 | |||
2073 | if (len % 4 > 0) { | ||
2074 | throw new Error('Invalid string. Length must be a multiple of 4') | ||
2075 | } | ||
2076 | |||
2077 | // Trim off extra bytes after placeholder bytes are found | ||
2078 | // See: https://github.com/beatgammit/base64-js/issues/42 | ||
2079 | var validLen = b64.indexOf('=') | ||
2080 | if (validLen === -1) validLen = len | ||
2081 | |||
2082 | var placeHoldersLen = validLen === len | ||
2083 | ? 0 | ||
2084 | : 4 - (validLen % 4) | ||
2085 | |||
2086 | return [validLen, placeHoldersLen] | ||
2087 | } | ||
2088 | |||
2089 | // base64 is 4/3 + up to two characters of the original data | ||
2090 | function byteLength (b64) { | ||
2091 | var lens = getLens(b64) | ||
2092 | var validLen = lens[0] | ||
2093 | var placeHoldersLen = lens[1] | ||
2094 | return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen | ||
2095 | } | ||
2096 | |||
2097 | function _byteLength (b64, validLen, placeHoldersLen) { | ||
2098 | return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen | ||
2099 | } | ||
2100 | |||
2101 | function toByteArray (b64) { | ||
2102 | var tmp | ||
2103 | var lens = getLens(b64) | ||
2104 | var validLen = lens[0] | ||
2105 | var placeHoldersLen = lens[1] | ||
2106 | |||
2107 | var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) | ||
2108 | |||
2109 | var curByte = 0 | ||
2110 | |||
2111 | // if there are placeholders, only get up to the last complete 4 chars | ||
2112 | var len = placeHoldersLen > 0 | ||
2113 | ? validLen - 4 | ||
2114 | : validLen | ||
2115 | |||
2116 | for (var i = 0; i < len; i += 4) { | ||
2117 | tmp = | ||
2118 | (revLookup[b64.charCodeAt(i)] << 18) | | ||
2119 | (revLookup[b64.charCodeAt(i + 1)] << 12) | | ||
2120 | (revLookup[b64.charCodeAt(i + 2)] << 6) | | ||
2121 | revLookup[b64.charCodeAt(i + 3)] | ||
2122 | arr[curByte++] = (tmp >> 16) & 0xFF | ||
2123 | arr[curByte++] = (tmp >> 8) & 0xFF | ||
2124 | arr[curByte++] = tmp & 0xFF | ||
2125 | } | ||
2126 | |||
2127 | if (placeHoldersLen === 2) { | ||
2128 | tmp = | ||
2129 | (revLookup[b64.charCodeAt(i)] << 2) | | ||
2130 | (revLookup[b64.charCodeAt(i + 1)] >> 4) | ||
2131 | arr[curByte++] = tmp & 0xFF | ||
2132 | } | ||
2133 | |||
2134 | if (placeHoldersLen === 1) { | ||
2135 | tmp = | ||
2136 | (revLookup[b64.charCodeAt(i)] << 10) | | ||
2137 | (revLookup[b64.charCodeAt(i + 1)] << 4) | | ||
2138 | (revLookup[b64.charCodeAt(i + 2)] >> 2) | ||
2139 | arr[curByte++] = (tmp >> 8) & 0xFF | ||
2140 | arr[curByte++] = tmp & 0xFF | ||
2141 | } | ||
2142 | |||
2143 | return arr | ||
2144 | } | ||
2145 | |||
2146 | function tripletToBase64 (num) { | ||
2147 | return lookup[num >> 18 & 0x3F] + | ||
2148 | lookup[num >> 12 & 0x3F] + | ||
2149 | lookup[num >> 6 & 0x3F] + | ||
2150 | lookup[num & 0x3F] | ||
2151 | } | ||
2152 | |||
2153 | function encodeChunk (uint8, start, end) { | ||
2154 | var tmp | ||
2155 | var output = [] | ||
2156 | for (var i = start; i < end; i += 3) { | ||
2157 | tmp = | ||
2158 | ((uint8[i] << 16) & 0xFF0000) + | ||
2159 | ((uint8[i + 1] << 8) & 0xFF00) + | ||
2160 | (uint8[i + 2] & 0xFF) | ||
2161 | output.push(tripletToBase64(tmp)) | ||
2162 | } | ||
2163 | return output.join('') | ||
2164 | } | ||
2165 | |||
2166 | function fromByteArray (uint8) { | ||
2167 | var tmp | ||
2168 | var len = uint8.length | ||
2169 | var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes | ||
2170 | var parts = [] | ||
2171 | var maxChunkLength = 16383 // must be multiple of 3 | ||
2172 | |||
2173 | // go through the array every three bytes, we'll deal with trailing stuff later | ||
2174 | for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { | ||
2175 | parts.push(encodeChunk( | ||
2176 | uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength) | ||
2177 | )) | ||
2178 | } | ||
2179 | |||
2180 | // pad the end with zeros, but make sure to not forget the extra bytes | ||
2181 | if (extraBytes === 1) { | ||
2182 | tmp = uint8[len - 1] | ||
2183 | parts.push( | ||
2184 | lookup[tmp >> 2] + | ||
2185 | lookup[(tmp << 4) & 0x3F] + | ||
2186 | '==' | ||
2187 | ) | ||
2188 | } else if (extraBytes === 2) { | ||
2189 | tmp = (uint8[len - 2] << 8) + uint8[len - 1] | ||
2190 | parts.push( | ||
2191 | lookup[tmp >> 10] + | ||
2192 | lookup[(tmp >> 4) & 0x3F] + | ||
2193 | lookup[(tmp << 2) & 0x3F] + | ||
2194 | '=' | ||
2195 | ) | ||
2196 | } | ||
2197 | |||
2198 | return parts.join('') | ||
2199 | } | ||
2200 | |||
2201 | },{}],17:[function(require,module,exports){ | ||
2202 | /*! bignumber.js v4.1.0 https://github.com/MikeMcl/bignumber.js/LICENCE */ | ||
2203 | |||
2204 | ;(function (globalObj) { | ||
2205 | 'use strict'; | ||
2206 | |||
2207 | /* | ||
2208 | bignumber.js v4.1.0 | ||
2209 | A JavaScript library for arbitrary-precision arithmetic. | ||
2210 | https://github.com/MikeMcl/bignumber.js | ||
2211 | Copyright (c) 2017 Michael Mclaughlin <M8ch88l@gmail.com> | ||
2212 | MIT Expat Licence | ||
2213 | */ | ||
2214 | |||
2215 | |||
2216 | var BigNumber, | ||
2217 | isNumeric = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i, | ||
2218 | mathceil = Math.ceil, | ||
2219 | mathfloor = Math.floor, | ||
2220 | notBool = ' not a boolean or binary digit', | ||
2221 | roundingMode = 'rounding mode', | ||
2222 | tooManyDigits = 'number type has more than 15 significant digits', | ||
2223 | ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_', | ||
2224 | BASE = 1e14, | ||
2225 | LOG_BASE = 14, | ||
2226 | MAX_SAFE_INTEGER = 0x1fffffffffffff, // 2^53 - 1 | ||
2227 | // MAX_INT32 = 0x7fffffff, // 2^31 - 1 | ||
2228 | POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13], | ||
2229 | SQRT_BASE = 1e7, | ||
2230 | |||
2231 | /* | ||
2232 | * The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and | ||
2233 | * the arguments to toExponential, toFixed, toFormat, and toPrecision, beyond which an | ||
2234 | * exception is thrown (if ERRORS is true). | ||
2235 | */ | ||
2236 | MAX = 1E9; // 0 to MAX_INT32 | ||
2237 | |||
2238 | |||
2239 | /* | ||
2240 | * Create and return a BigNumber constructor. | ||
2241 | */ | ||
2242 | function constructorFactory(config) { | ||
2243 | var div, parseNumeric, | ||
2244 | |||
2245 | // id tracks the caller function, so its name can be included in error messages. | ||
2246 | id = 0, | ||
2247 | P = BigNumber.prototype, | ||
2248 | ONE = new BigNumber(1), | ||
2249 | |||
2250 | |||
2251 | /********************************* EDITABLE DEFAULTS **********************************/ | ||
2252 | |||
2253 | |||
2254 | /* | ||
2255 | * The default values below must be integers within the inclusive ranges stated. | ||
2256 | * The values can also be changed at run-time using BigNumber.config. | ||
2257 | */ | ||
2258 | |||
2259 | // The maximum number of decimal places for operations involving division. | ||
2260 | DECIMAL_PLACES = 20, // 0 to MAX | ||
2261 | |||
2262 | /* | ||
2263 | * The rounding mode used when rounding to the above decimal places, and when using | ||
2264 | * toExponential, toFixed, toFormat and toPrecision, and round (default value). | ||
2265 | * UP 0 Away from zero. | ||
2266 | * DOWN 1 Towards zero. | ||
2267 | * CEIL 2 Towards +Infinity. | ||
2268 | * FLOOR 3 Towards -Infinity. | ||
2269 | * HALF_UP 4 Towards nearest neighbour. If equidistant, up. | ||
2270 | * HALF_DOWN 5 Towards nearest neighbour. If equidistant, down. | ||
2271 | * HALF_EVEN 6 Towards nearest neighbour. If equidistant, towards even neighbour. | ||
2272 | * HALF_CEIL 7 Towards nearest neighbour. If equidistant, towards +Infinity. | ||
2273 | * HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity. | ||
2274 | */ | ||
2275 | ROUNDING_MODE = 4, // 0 to 8 | ||
2276 | |||
2277 | // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS] | ||
2278 | |||
2279 | // The exponent value at and beneath which toString returns exponential notation. | ||
2280 | // Number type: -7 | ||
2281 | TO_EXP_NEG = -7, // 0 to -MAX | ||
2282 | |||
2283 | // The exponent value at and above which toString returns exponential notation. | ||
2284 | // Number type: 21 | ||
2285 | TO_EXP_POS = 21, // 0 to MAX | ||
2286 | |||
2287 | // RANGE : [MIN_EXP, MAX_EXP] | ||
2288 | |||
2289 | // The minimum exponent value, beneath which underflow to zero occurs. | ||
2290 | // Number type: -324 (5e-324) | ||
2291 | MIN_EXP = -1e7, // -1 to -MAX | ||
2292 | |||
2293 | // The maximum exponent value, above which overflow to Infinity occurs. | ||
2294 | // Number type: 308 (1.7976931348623157e+308) | ||
2295 | // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow. | ||
2296 | MAX_EXP = 1e7, // 1 to MAX | ||
2297 | |||
2298 | // Whether BigNumber Errors are ever thrown. | ||
2299 | ERRORS = true, // true or false | ||
2300 | |||
2301 | // Change to intValidatorNoErrors if ERRORS is false. | ||
2302 | isValidInt = intValidatorWithErrors, // intValidatorWithErrors/intValidatorNoErrors | ||
2303 | |||
2304 | // Whether to use cryptographically-secure random number generation, if available. | ||
2305 | CRYPTO = false, // true or false | ||
2306 | |||
2307 | /* | ||
2308 | * The modulo mode used when calculating the modulus: a mod n. | ||
2309 | * The quotient (q = a / n) is calculated according to the corresponding rounding mode. | ||
2310 | * The remainder (r) is calculated as: r = a - n * q. | ||
2311 | * | ||
2312 | * UP 0 The remainder is positive if the dividend is negative, else is negative. | ||
2313 | * DOWN 1 The remainder has the same sign as the dividend. | ||
2314 | * This modulo mode is commonly known as 'truncated division' and is | ||
2315 | * equivalent to (a % n) in JavaScript. | ||
2316 | * FLOOR 3 The remainder has the same sign as the divisor (Python %). | ||
2317 | * HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function. | ||
2318 | * EUCLID 9 Euclidian division. q = sign(n) * floor(a / abs(n)). | ||
2319 | * The remainder is always positive. | ||
2320 | * | ||
2321 | * The truncated division, floored division, Euclidian division and IEEE 754 remainder | ||
2322 | * modes are commonly used for the modulus operation. | ||
2323 | * Although the other rounding modes can also be used, they may not give useful results. | ||
2324 | */ | ||
2325 | MODULO_MODE = 1, // 0 to 9 | ||
2326 | |||
2327 | // The maximum number of significant digits of the result of the toPower operation. | ||
2328 | // If POW_PRECISION is 0, there will be unlimited significant digits. | ||
2329 | POW_PRECISION = 0, // 0 to MAX | ||
2330 | |||
2331 | // The format specification used by the BigNumber.prototype.toFormat method. | ||
2332 | FORMAT = { | ||
2333 | decimalSeparator: '.', | ||
2334 | groupSeparator: ',', | ||
2335 | groupSize: 3, | ||
2336 | secondaryGroupSize: 0, | ||
2337 | fractionGroupSeparator: '\xA0', // non-breaking space | ||
2338 | fractionGroupSize: 0 | ||
2339 | }; | ||
2340 | |||
2341 | |||
2342 | /******************************************************************************************/ | ||
2343 | |||
2344 | |||
2345 | // CONSTRUCTOR | ||
2346 | |||
2347 | |||
2348 | /* | ||
2349 | * The BigNumber constructor and exported function. | ||
2350 | * Create and return a new instance of a BigNumber object. | ||
2351 | * | ||
2352 | * n {number|string|BigNumber} A numeric value. | ||
2353 | * [b] {number} The base of n. Integer, 2 to 64 inclusive. | ||
2354 | */ | ||
2355 | function BigNumber( n, b ) { | ||
2356 | var c, e, i, num, len, str, | ||
2357 | x = this; | ||
2358 | |||
2359 | // Enable constructor usage without new. | ||
2360 | if ( !( x instanceof BigNumber ) ) { | ||
2361 | |||
2362 | // 'BigNumber() constructor call without new: {n}' | ||
2363 | if (ERRORS) raise( 26, 'constructor call without new', n ); | ||
2364 | return new BigNumber( n, b ); | ||
2365 | } | ||
2366 | |||
2367 | // 'new BigNumber() base not an integer: {b}' | ||
2368 | // 'new BigNumber() base out of range: {b}' | ||
2369 | if ( b == null || !isValidInt( b, 2, 64, id, 'base' ) ) { | ||
2370 | |||
2371 | // Duplicate. | ||
2372 | if ( n instanceof BigNumber ) { | ||
2373 | x.s = n.s; | ||
2374 | x.e = n.e; | ||
2375 | x.c = ( n = n.c ) ? n.slice() : n; | ||
2376 | id = 0; | ||
2377 | return; | ||
2378 | } | ||
2379 | |||
2380 | if ( ( num = typeof n == 'number' ) && n * 0 == 0 ) { | ||
2381 | x.s = 1 / n < 0 ? ( n = -n, -1 ) : 1; | ||
2382 | |||
2383 | // Fast path for integers. | ||
2384 | if ( n === ~~n ) { | ||
2385 | for ( e = 0, i = n; i >= 10; i /= 10, e++ ); | ||
2386 | x.e = e; | ||
2387 | x.c = [n]; | ||
2388 | id = 0; | ||
2389 | return; | ||
2390 | } | ||
2391 | |||
2392 | str = n + ''; | ||
2393 | } else { | ||
2394 | if ( !isNumeric.test( str = n + '' ) ) return parseNumeric( x, str, num ); | ||
2395 | x.s = str.charCodeAt(0) === 45 ? ( str = str.slice(1), -1 ) : 1; | ||
2396 | } | ||
2397 | } else { | ||
2398 | b = b | 0; | ||
2399 | str = n + ''; | ||
2400 | |||
2401 | // Ensure return value is rounded to DECIMAL_PLACES as with other bases. | ||
2402 | // Allow exponential notation to be used with base 10 argument. | ||
2403 | if ( b == 10 ) { | ||
2404 | x = new BigNumber( n instanceof BigNumber ? n : str ); | ||
2405 | return round( x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE ); | ||
2406 | } | ||
2407 | |||
2408 | // Avoid potential interpretation of Infinity and NaN as base 44+ values. | ||
2409 | // Any number in exponential form will fail due to the [Ee][+-]. | ||
2410 | if ( ( num = typeof n == 'number' ) && n * 0 != 0 || | ||
2411 | !( new RegExp( '^-?' + ( c = '[' + ALPHABET.slice( 0, b ) + ']+' ) + | ||
2412 | '(?:\\.' + c + ')?$',b < 37 ? 'i' : '' ) ).test(str) ) { | ||
2413 | return parseNumeric( x, str, num, b ); | ||
2414 | } | ||
2415 | |||
2416 | if (num) { | ||
2417 | x.s = 1 / n < 0 ? ( str = str.slice(1), -1 ) : 1; | ||
2418 | |||
2419 | if ( ERRORS && str.replace( /^0\.0*|\./, '' ).length > 15 ) { | ||
2420 | |||
2421 | // 'new BigNumber() number type has more than 15 significant digits: {n}' | ||
2422 | raise( id, tooManyDigits, n ); | ||
2423 | } | ||
2424 | |||
2425 | // Prevent later check for length on converted number. | ||
2426 | num = false; | ||
2427 | } else { | ||
2428 | x.s = str.charCodeAt(0) === 45 ? ( str = str.slice(1), -1 ) : 1; | ||
2429 | } | ||
2430 | |||
2431 | str = convertBase( str, 10, b, x.s ); | ||
2432 | } | ||
2433 | |||
2434 | // Decimal point? | ||
2435 | if ( ( e = str.indexOf('.') ) > -1 ) str = str.replace( '.', '' ); | ||
2436 | |||
2437 | // Exponential form? | ||
2438 | if ( ( i = str.search( /e/i ) ) > 0 ) { | ||
2439 | |||
2440 | // Determine exponent. | ||
2441 | if ( e < 0 ) e = i; | ||
2442 | e += +str.slice( i + 1 ); | ||
2443 | str = str.substring( 0, i ); | ||
2444 | } else if ( e < 0 ) { | ||
2445 | |||
2446 | // Integer. | ||
2447 | e = str.length; | ||
2448 | } | ||
2449 | |||
2450 | // Determine leading zeros. | ||
2451 | for ( i = 0; str.charCodeAt(i) === 48; i++ ); | ||
2452 | |||
2453 | // Determine trailing zeros. | ||
2454 | for ( len = str.length; str.charCodeAt(--len) === 48; ); | ||
2455 | str = str.slice( i, len + 1 ); | ||
2456 | |||
2457 | if (str) { | ||
2458 | len = str.length; | ||
2459 | |||
2460 | // Disallow numbers with over 15 significant digits if number type. | ||
2461 | // 'new BigNumber() number type has more than 15 significant digits: {n}' | ||
2462 | if ( num && ERRORS && len > 15 && ( n > MAX_SAFE_INTEGER || n !== mathfloor(n) ) ) { | ||
2463 | raise( id, tooManyDigits, x.s * n ); | ||
2464 | } | ||
2465 | |||
2466 | e = e - i - 1; | ||
2467 | |||
2468 | // Overflow? | ||
2469 | if ( e > MAX_EXP ) { | ||
2470 | |||
2471 | // Infinity. | ||
2472 | x.c = x.e = null; | ||
2473 | |||
2474 | // Underflow? | ||
2475 | } else if ( e < MIN_EXP ) { | ||
2476 | |||
2477 | // Zero. | ||
2478 | x.c = [ x.e = 0 ]; | ||
2479 | } else { | ||
2480 | x.e = e; | ||
2481 | x.c = []; | ||
2482 | |||
2483 | // Transform base | ||
2484 | |||
2485 | // e is the base 10 exponent. | ||
2486 | // i is where to slice str to get the first element of the coefficient array. | ||
2487 | i = ( e + 1 ) % LOG_BASE; | ||
2488 | if ( e < 0 ) i += LOG_BASE; | ||
2489 | |||
2490 | if ( i < len ) { | ||
2491 | if (i) x.c.push( +str.slice( 0, i ) ); | ||
2492 | |||
2493 | for ( len -= LOG_BASE; i < len; ) { | ||
2494 | x.c.push( +str.slice( i, i += LOG_BASE ) ); | ||
2495 | } | ||
2496 | |||
2497 | str = str.slice(i); | ||
2498 | i = LOG_BASE - str.length; | ||
2499 | } else { | ||
2500 | i -= len; | ||
2501 | } | ||
2502 | |||
2503 | for ( ; i--; str += '0' ); | ||
2504 | x.c.push( +str ); | ||
2505 | } | ||
2506 | } else { | ||
2507 | |||
2508 | // Zero. | ||
2509 | x.c = [ x.e = 0 ]; | ||
2510 | } | ||
2511 | |||
2512 | id = 0; | ||
2513 | } | ||
2514 | |||
2515 | |||
2516 | // CONSTRUCTOR PROPERTIES | ||
2517 | |||
2518 | |||
2519 | BigNumber.another = constructorFactory; | ||
2520 | |||
2521 | BigNumber.ROUND_UP = 0; | ||
2522 | BigNumber.ROUND_DOWN = 1; | ||
2523 | BigNumber.ROUND_CEIL = 2; | ||
2524 | BigNumber.ROUND_FLOOR = 3; | ||
2525 | BigNumber.ROUND_HALF_UP = 4; | ||
2526 | BigNumber.ROUND_HALF_DOWN = 5; | ||
2527 | BigNumber.ROUND_HALF_EVEN = 6; | ||
2528 | BigNumber.ROUND_HALF_CEIL = 7; | ||
2529 | BigNumber.ROUND_HALF_FLOOR = 8; | ||
2530 | BigNumber.EUCLID = 9; | ||
2531 | |||
2532 | |||
2533 | /* | ||
2534 | * Configure infrequently-changing library-wide settings. | ||
2535 | * | ||
2536 | * Accept an object or an argument list, with one or many of the following properties or | ||
2537 | * parameters respectively: | ||
2538 | * | ||
2539 | * DECIMAL_PLACES {number} Integer, 0 to MAX inclusive | ||
2540 | * ROUNDING_MODE {number} Integer, 0 to 8 inclusive | ||
2541 | * EXPONENTIAL_AT {number|number[]} Integer, -MAX to MAX inclusive or | ||
2542 | * [integer -MAX to 0 incl., 0 to MAX incl.] | ||
2543 | * RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or | ||
2544 | * [integer -MAX to -1 incl., integer 1 to MAX incl.] | ||
2545 | * ERRORS {boolean|number} true, false, 1 or 0 | ||
2546 | * CRYPTO {boolean|number} true, false, 1 or 0 | ||
2547 | * MODULO_MODE {number} 0 to 9 inclusive | ||
2548 | * POW_PRECISION {number} 0 to MAX inclusive | ||
2549 | * FORMAT {object} See BigNumber.prototype.toFormat | ||
2550 | * decimalSeparator {string} | ||
2551 | * groupSeparator {string} | ||
2552 | * groupSize {number} | ||
2553 | * secondaryGroupSize {number} | ||
2554 | * fractionGroupSeparator {string} | ||
2555 | * fractionGroupSize {number} | ||
2556 | * | ||
2557 | * (The values assigned to the above FORMAT object properties are not checked for validity.) | ||
2558 | * | ||
2559 | * E.g. | ||
2560 | * BigNumber.config(20, 4) is equivalent to | ||
2561 | * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 }) | ||
2562 | * | ||
2563 | * Ignore properties/parameters set to null or undefined. | ||
2564 | * Return an object with the properties current values. | ||
2565 | */ | ||
2566 | BigNumber.config = BigNumber.set = function () { | ||
2567 | var v, p, | ||
2568 | i = 0, | ||
2569 | r = {}, | ||
2570 | a = arguments, | ||
2571 | o = a[0], | ||
2572 | has = o && typeof o == 'object' | ||
2573 | ? function () { if ( o.hasOwnProperty(p) ) return ( v = o[p] ) != null; } | ||
2574 | : function () { if ( a.length > i ) return ( v = a[i++] ) != null; }; | ||
2575 | |||
2576 | // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive. | ||
2577 | // 'config() DECIMAL_PLACES not an integer: {v}' | ||
2578 | // 'config() DECIMAL_PLACES out of range: {v}' | ||
2579 | if ( has( p = 'DECIMAL_PLACES' ) && isValidInt( v, 0, MAX, 2, p ) ) { | ||
2580 | DECIMAL_PLACES = v | 0; | ||
2581 | } | ||
2582 | r[p] = DECIMAL_PLACES; | ||
2583 | |||
2584 | // ROUNDING_MODE {number} Integer, 0 to 8 inclusive. | ||
2585 | // 'config() ROUNDING_MODE not an integer: {v}' | ||
2586 | // 'config() ROUNDING_MODE out of range: {v}' | ||
2587 | if ( has( p = 'ROUNDING_MODE' ) && isValidInt( v, 0, 8, 2, p ) ) { | ||
2588 | ROUNDING_MODE = v | 0; | ||
2589 | } | ||
2590 | r[p] = ROUNDING_MODE; | ||
2591 | |||
2592 | // EXPONENTIAL_AT {number|number[]} | ||
2593 | // Integer, -MAX to MAX inclusive or [integer -MAX to 0 inclusive, 0 to MAX inclusive]. | ||
2594 | // 'config() EXPONENTIAL_AT not an integer: {v}' | ||
2595 | // 'config() EXPONENTIAL_AT out of range: {v}' | ||
2596 | if ( has( p = 'EXPONENTIAL_AT' ) ) { | ||
2597 | |||
2598 | if ( isArray(v) ) { | ||
2599 | if ( isValidInt( v[0], -MAX, 0, 2, p ) && isValidInt( v[1], 0, MAX, 2, p ) ) { | ||
2600 | TO_EXP_NEG = v[0] | 0; | ||
2601 | TO_EXP_POS = v[1] | 0; | ||
2602 | } | ||
2603 | } else if ( isValidInt( v, -MAX, MAX, 2, p ) ) { | ||
2604 | TO_EXP_NEG = -( TO_EXP_POS = ( v < 0 ? -v : v ) | 0 ); | ||
2605 | } | ||
2606 | } | ||
2607 | r[p] = [ TO_EXP_NEG, TO_EXP_POS ]; | ||
2608 | |||
2609 | // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or | ||
2610 | // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive]. | ||
2611 | // 'config() RANGE not an integer: {v}' | ||
2612 | // 'config() RANGE cannot be zero: {v}' | ||
2613 | // 'config() RANGE out of range: {v}' | ||
2614 | if ( has( p = 'RANGE' ) ) { | ||
2615 | |||
2616 | if ( isArray(v) ) { | ||
2617 | if ( isValidInt( v[0], -MAX, -1, 2, p ) && isValidInt( v[1], 1, MAX, 2, p ) ) { | ||
2618 | MIN_EXP = v[0] | 0; | ||
2619 | MAX_EXP = v[1] | 0; | ||
2620 | } | ||
2621 | } else if ( isValidInt( v, -MAX, MAX, 2, p ) ) { | ||
2622 | if ( v | 0 ) MIN_EXP = -( MAX_EXP = ( v < 0 ? -v : v ) | 0 ); | ||
2623 | else if (ERRORS) raise( 2, p + ' cannot be zero', v ); | ||
2624 | } | ||
2625 | } | ||
2626 | r[p] = [ MIN_EXP, MAX_EXP ]; | ||
2627 | |||
2628 | // ERRORS {boolean|number} true, false, 1 or 0. | ||
2629 | // 'config() ERRORS not a boolean or binary digit: {v}' | ||
2630 | if ( has( p = 'ERRORS' ) ) { | ||
2631 | |||
2632 | if ( v === !!v || v === 1 || v === 0 ) { | ||
2633 | id = 0; | ||
2634 | isValidInt = ( ERRORS = !!v ) ? intValidatorWithErrors : intValidatorNoErrors; | ||
2635 | } else if (ERRORS) { | ||
2636 | raise( 2, p + notBool, v ); | ||
2637 | } | ||
2638 | } | ||
2639 | r[p] = ERRORS; | ||
2640 | |||
2641 | // CRYPTO {boolean|number} true, false, 1 or 0. | ||
2642 | // 'config() CRYPTO not a boolean or binary digit: {v}' | ||
2643 | // 'config() crypto unavailable: {crypto}' | ||
2644 | if ( has( p = 'CRYPTO' ) ) { | ||
2645 | |||
2646 | if ( v === true || v === false || v === 1 || v === 0 ) { | ||
2647 | if (v) { | ||
2648 | v = typeof crypto == 'undefined'; | ||
2649 | if ( !v && crypto && (crypto.getRandomValues || crypto.randomBytes)) { | ||
2650 | CRYPTO = true; | ||
2651 | } else if (ERRORS) { | ||
2652 | raise( 2, 'crypto unavailable', v ? void 0 : crypto ); | ||
2653 | } else { | ||
2654 | CRYPTO = false; | ||
2655 | } | ||
2656 | } else { | ||
2657 | CRYPTO = false; | ||
2658 | } | ||
2659 | } else if (ERRORS) { | ||
2660 | raise( 2, p + notBool, v ); | ||
2661 | } | ||
2662 | } | ||
2663 | r[p] = CRYPTO; | ||
2664 | |||
2665 | // MODULO_MODE {number} Integer, 0 to 9 inclusive. | ||
2666 | // 'config() MODULO_MODE not an integer: {v}' | ||
2667 | // 'config() MODULO_MODE out of range: {v}' | ||
2668 | if ( has( p = 'MODULO_MODE' ) && isValidInt( v, 0, 9, 2, p ) ) { | ||
2669 | MODULO_MODE = v | 0; | ||
2670 | } | ||
2671 | r[p] = MODULO_MODE; | ||
2672 | |||
2673 | // POW_PRECISION {number} Integer, 0 to MAX inclusive. | ||
2674 | // 'config() POW_PRECISION not an integer: {v}' | ||
2675 | // 'config() POW_PRECISION out of range: {v}' | ||
2676 | if ( has( p = 'POW_PRECISION' ) && isValidInt( v, 0, MAX, 2, p ) ) { | ||
2677 | POW_PRECISION = v | 0; | ||
2678 | } | ||
2679 | r[p] = POW_PRECISION; | ||
2680 | |||
2681 | // FORMAT {object} | ||
2682 | // 'config() FORMAT not an object: {v}' | ||
2683 | if ( has( p = 'FORMAT' ) ) { | ||
2684 | |||
2685 | if ( typeof v == 'object' ) { | ||
2686 | FORMAT = v; | ||
2687 | } else if (ERRORS) { | ||
2688 | raise( 2, p + ' not an object', v ); | ||
2689 | } | ||
2690 | } | ||
2691 | r[p] = FORMAT; | ||
2692 | |||
2693 | return r; | ||
2694 | }; | ||
2695 | |||
2696 | |||
2697 | /* | ||
2698 | * Return a new BigNumber whose value is the maximum of the arguments. | ||
2699 | * | ||
2700 | * arguments {number|string|BigNumber} | ||
2701 | */ | ||
2702 | BigNumber.max = function () { return maxOrMin( arguments, P.lt ); }; | ||
2703 | |||
2704 | |||
2705 | /* | ||
2706 | * Return a new BigNumber whose value is the minimum of the arguments. | ||
2707 | * | ||
2708 | * arguments {number|string|BigNumber} | ||
2709 | */ | ||
2710 | BigNumber.min = function () { return maxOrMin( arguments, P.gt ); }; | ||
2711 | |||
2712 | |||
2713 | /* | ||
2714 | * Return a new BigNumber with a random value equal to or greater than 0 and less than 1, | ||
2715 | * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing | ||
2716 | * zeros are produced). | ||
2717 | * | ||
2718 | * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. | ||
2719 | * | ||
2720 | * 'random() decimal places not an integer: {dp}' | ||
2721 | * 'random() decimal places out of range: {dp}' | ||
2722 | * 'random() crypto unavailable: {crypto}' | ||
2723 | */ | ||
2724 | BigNumber.random = (function () { | ||
2725 | var pow2_53 = 0x20000000000000; | ||
2726 | |||
2727 | // Return a 53 bit integer n, where 0 <= n < 9007199254740992. | ||
2728 | // Check if Math.random() produces more than 32 bits of randomness. | ||
2729 | // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits. | ||
2730 | // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1. | ||
2731 | var random53bitInt = (Math.random() * pow2_53) & 0x1fffff | ||
2732 | ? function () { return mathfloor( Math.random() * pow2_53 ); } | ||
2733 | : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) + | ||
2734 | (Math.random() * 0x800000 | 0); }; | ||
2735 | |||
2736 | return function (dp) { | ||
2737 | var a, b, e, k, v, | ||
2738 | i = 0, | ||
2739 | c = [], | ||
2740 | rand = new BigNumber(ONE); | ||
2741 | |||
2742 | dp = dp == null || !isValidInt( dp, 0, MAX, 14 ) ? DECIMAL_PLACES : dp | 0; | ||
2743 | k = mathceil( dp / LOG_BASE ); | ||
2744 | |||
2745 | if (CRYPTO) { | ||
2746 | |||
2747 | // Browsers supporting crypto.getRandomValues. | ||
2748 | if (crypto.getRandomValues) { | ||
2749 | |||
2750 | a = crypto.getRandomValues( new Uint32Array( k *= 2 ) ); | ||
2751 | |||
2752 | for ( ; i < k; ) { | ||
2753 | |||
2754 | // 53 bits: | ||
2755 | // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2) | ||
2756 | // 11111 11111111 11111111 11111111 11100000 00000000 00000000 | ||
2757 | // ((Math.pow(2, 32) - 1) >>> 11).toString(2) | ||
2758 | // 11111 11111111 11111111 | ||
2759 | // 0x20000 is 2^21. | ||
2760 | v = a[i] * 0x20000 + (a[i + 1] >>> 11); | ||
2761 | |||
2762 | // Rejection sampling: | ||
2763 | // 0 <= v < 9007199254740992 | ||
2764 | // Probability that v >= 9e15, is | ||
2765 | // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251 | ||
2766 | if ( v >= 9e15 ) { | ||
2767 | b = crypto.getRandomValues( new Uint32Array(2) ); | ||
2768 | a[i] = b[0]; | ||
2769 | a[i + 1] = b[1]; | ||
2770 | } else { | ||
2771 | |||
2772 | // 0 <= v <= 8999999999999999 | ||
2773 | // 0 <= (v % 1e14) <= 99999999999999 | ||
2774 | c.push( v % 1e14 ); | ||
2775 | i += 2; | ||
2776 | } | ||
2777 | } | ||
2778 | i = k / 2; | ||
2779 | |||
2780 | // Node.js supporting crypto.randomBytes. | ||
2781 | } else if (crypto.randomBytes) { | ||
2782 | |||
2783 | // buffer | ||
2784 | a = crypto.randomBytes( k *= 7 ); | ||
2785 | |||
2786 | for ( ; i < k; ) { | ||
2787 | |||
2788 | // 0x1000000000000 is 2^48, 0x10000000000 is 2^40 | ||
2789 | // 0x100000000 is 2^32, 0x1000000 is 2^24 | ||
2790 | // 11111 11111111 11111111 11111111 11111111 11111111 11111111 | ||
2791 | // 0 <= v < 9007199254740992 | ||
2792 | v = ( ( a[i] & 31 ) * 0x1000000000000 ) + ( a[i + 1] * 0x10000000000 ) + | ||
2793 | ( a[i + 2] * 0x100000000 ) + ( a[i + 3] * 0x1000000 ) + | ||
2794 | ( a[i + 4] << 16 ) + ( a[i + 5] << 8 ) + a[i + 6]; | ||
2795 | |||
2796 | if ( v >= 9e15 ) { | ||
2797 | crypto.randomBytes(7).copy( a, i ); | ||
2798 | } else { | ||
2799 | |||
2800 | // 0 <= (v % 1e14) <= 99999999999999 | ||
2801 | c.push( v % 1e14 ); | ||
2802 | i += 7; | ||
2803 | } | ||
2804 | } | ||
2805 | i = k / 7; | ||
2806 | } else { | ||
2807 | CRYPTO = false; | ||
2808 | if (ERRORS) raise( 14, 'crypto unavailable', crypto ); | ||
2809 | } | ||
2810 | } | ||
2811 | |||
2812 | // Use Math.random. | ||
2813 | if (!CRYPTO) { | ||
2814 | |||
2815 | for ( ; i < k; ) { | ||
2816 | v = random53bitInt(); | ||
2817 | if ( v < 9e15 ) c[i++] = v % 1e14; | ||
2818 | } | ||
2819 | } | ||
2820 | |||
2821 | k = c[--i]; | ||
2822 | dp %= LOG_BASE; | ||
2823 | |||
2824 | // Convert trailing digits to zeros according to dp. | ||
2825 | if ( k && dp ) { | ||
2826 | v = POWS_TEN[LOG_BASE - dp]; | ||
2827 | c[i] = mathfloor( k / v ) * v; | ||
2828 | } | ||
2829 | |||
2830 | // Remove trailing elements which are zero. | ||
2831 | for ( ; c[i] === 0; c.pop(), i-- ); | ||
2832 | |||
2833 | // Zero? | ||
2834 | if ( i < 0 ) { | ||
2835 | c = [ e = 0 ]; | ||
2836 | } else { | ||
2837 | |||
2838 | // Remove leading elements which are zero and adjust exponent accordingly. | ||
2839 | for ( e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE); | ||
2840 | |||
2841 | // Count the digits of the first element of c to determine leading zeros, and... | ||
2842 | for ( i = 1, v = c[0]; v >= 10; v /= 10, i++); | ||
2843 | |||
2844 | // adjust the exponent accordingly. | ||
2845 | if ( i < LOG_BASE ) e -= LOG_BASE - i; | ||
2846 | } | ||
2847 | |||
2848 | rand.e = e; | ||
2849 | rand.c = c; | ||
2850 | return rand; | ||
2851 | }; | ||
2852 | })(); | ||
2853 | |||
2854 | |||
2855 | // PRIVATE FUNCTIONS | ||
2856 | |||
2857 | |||
2858 | // Convert a numeric string of baseIn to a numeric string of baseOut. | ||
2859 | function convertBase( str, baseOut, baseIn, sign ) { | ||
2860 | var d, e, k, r, x, xc, y, | ||
2861 | i = str.indexOf( '.' ), | ||
2862 | dp = DECIMAL_PLACES, | ||
2863 | rm = ROUNDING_MODE; | ||
2864 | |||
2865 | if ( baseIn < 37 ) str = str.toLowerCase(); | ||
2866 | |||
2867 | // Non-integer. | ||
2868 | if ( i >= 0 ) { | ||
2869 | k = POW_PRECISION; | ||
2870 | |||
2871 | // Unlimited precision. | ||
2872 | POW_PRECISION = 0; | ||
2873 | str = str.replace( '.', '' ); | ||
2874 | y = new BigNumber(baseIn); | ||
2875 | x = y.pow( str.length - i ); | ||
2876 | POW_PRECISION = k; | ||
2877 | |||
2878 | // Convert str as if an integer, then restore the fraction part by dividing the | ||
2879 | // result by its base raised to a power. | ||
2880 | y.c = toBaseOut( toFixedPoint( coeffToString( x.c ), x.e ), 10, baseOut ); | ||
2881 | y.e = y.c.length; | ||
2882 | } | ||
2883 | |||
2884 | // Convert the number as integer. | ||
2885 | xc = toBaseOut( str, baseIn, baseOut ); | ||
2886 | e = k = xc.length; | ||
2887 | |||
2888 | // Remove trailing zeros. | ||
2889 | for ( ; xc[--k] == 0; xc.pop() ); | ||
2890 | if ( !xc[0] ) return '0'; | ||
2891 | |||
2892 | if ( i < 0 ) { | ||
2893 | --e; | ||
2894 | } else { | ||
2895 | x.c = xc; | ||
2896 | x.e = e; | ||
2897 | |||
2898 | // sign is needed for correct rounding. | ||
2899 | x.s = sign; | ||
2900 | x = div( x, y, dp, rm, baseOut ); | ||
2901 | xc = x.c; | ||
2902 | r = x.r; | ||
2903 | e = x.e; | ||
2904 | } | ||
2905 | |||
2906 | d = e + dp + 1; | ||
2907 | |||
2908 | // The rounding digit, i.e. the digit to the right of the digit that may be rounded up. | ||
2909 | i = xc[d]; | ||
2910 | k = baseOut / 2; | ||
2911 | r = r || d < 0 || xc[d + 1] != null; | ||
2912 | |||
2913 | r = rm < 4 ? ( i != null || r ) && ( rm == 0 || rm == ( x.s < 0 ? 3 : 2 ) ) | ||
2914 | : i > k || i == k &&( rm == 4 || r || rm == 6 && xc[d - 1] & 1 || | ||
2915 | rm == ( x.s < 0 ? 8 : 7 ) ); | ||
2916 | |||
2917 | if ( d < 1 || !xc[0] ) { | ||
2918 | |||
2919 | // 1^-dp or 0. | ||
2920 | str = r ? toFixedPoint( '1', -dp ) : '0'; | ||
2921 | } else { | ||
2922 | xc.length = d; | ||
2923 | |||
2924 | if (r) { | ||
2925 | |||
2926 | // Rounding up may mean the previous digit has to be rounded up and so on. | ||
2927 | for ( --baseOut; ++xc[--d] > baseOut; ) { | ||
2928 | xc[d] = 0; | ||
2929 | |||
2930 | if ( !d ) { | ||
2931 | ++e; | ||
2932 | xc = [1].concat(xc); | ||
2933 | } | ||
2934 | } | ||
2935 | } | ||
2936 | |||
2937 | // Determine trailing zeros. | ||
2938 | for ( k = xc.length; !xc[--k]; ); | ||
2939 | |||
2940 | // E.g. [4, 11, 15] becomes 4bf. | ||
2941 | for ( i = 0, str = ''; i <= k; str += ALPHABET.charAt( xc[i++] ) ); | ||
2942 | str = toFixedPoint( str, e ); | ||
2943 | } | ||
2944 | |||
2945 | // The caller will add the sign. | ||
2946 | return str; | ||
2947 | } | ||
2948 | |||
2949 | |||
2950 | // Perform division in the specified base. Called by div and convertBase. | ||
2951 | div = (function () { | ||
2952 | |||
2953 | // Assume non-zero x and k. | ||
2954 | function multiply( x, k, base ) { | ||
2955 | var m, temp, xlo, xhi, | ||
2956 | carry = 0, | ||
2957 | i = x.length, | ||
2958 | klo = k % SQRT_BASE, | ||
2959 | khi = k / SQRT_BASE | 0; | ||
2960 | |||
2961 | for ( x = x.slice(); i--; ) { | ||
2962 | xlo = x[i] % SQRT_BASE; | ||
2963 | xhi = x[i] / SQRT_BASE | 0; | ||
2964 | m = khi * xlo + xhi * klo; | ||
2965 | temp = klo * xlo + ( ( m % SQRT_BASE ) * SQRT_BASE ) + carry; | ||
2966 | carry = ( temp / base | 0 ) + ( m / SQRT_BASE | 0 ) + khi * xhi; | ||
2967 | x[i] = temp % base; | ||
2968 | } | ||
2969 | |||
2970 | if (carry) x = [carry].concat(x); | ||
2971 | |||
2972 | return x; | ||
2973 | } | ||
2974 | |||
2975 | function compare( a, b, aL, bL ) { | ||
2976 | var i, cmp; | ||
2977 | |||
2978 | if ( aL != bL ) { | ||
2979 | cmp = aL > bL ? 1 : -1; | ||
2980 | } else { | ||
2981 | |||
2982 | for ( i = cmp = 0; i < aL; i++ ) { | ||
2983 | |||
2984 | if ( a[i] != b[i] ) { | ||
2985 | cmp = a[i] > b[i] ? 1 : -1; | ||
2986 | break; | ||
2987 | } | ||
2988 | } | ||
2989 | } | ||
2990 | return cmp; | ||
2991 | } | ||
2992 | |||
2993 | function subtract( a, b, aL, base ) { | ||
2994 | var i = 0; | ||
2995 | |||
2996 | // Subtract b from a. | ||
2997 | for ( ; aL--; ) { | ||
2998 | a[aL] -= i; | ||
2999 | i = a[aL] < b[aL] ? 1 : 0; | ||
3000 | a[aL] = i * base + a[aL] - b[aL]; | ||
3001 | } | ||
3002 | |||
3003 | // Remove leading zeros. | ||
3004 | for ( ; !a[0] && a.length > 1; a.splice(0, 1) ); | ||
3005 | } | ||
3006 | |||
3007 | // x: dividend, y: divisor. | ||
3008 | return function ( x, y, dp, rm, base ) { | ||
3009 | var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0, | ||
3010 | yL, yz, | ||
3011 | s = x.s == y.s ? 1 : -1, | ||
3012 | xc = x.c, | ||
3013 | yc = y.c; | ||
3014 | |||
3015 | // Either NaN, Infinity or 0? | ||
3016 | if ( !xc || !xc[0] || !yc || !yc[0] ) { | ||
3017 | |||
3018 | return new BigNumber( | ||
3019 | |||
3020 | // Return NaN if either NaN, or both Infinity or 0. | ||
3021 | !x.s || !y.s || ( xc ? yc && xc[0] == yc[0] : !yc ) ? NaN : | ||
3022 | |||
3023 | // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0. | ||
3024 | xc && xc[0] == 0 || !yc ? s * 0 : s / 0 | ||
3025 | ); | ||
3026 | } | ||
3027 | |||
3028 | q = new BigNumber(s); | ||
3029 | qc = q.c = []; | ||
3030 | e = x.e - y.e; | ||
3031 | s = dp + e + 1; | ||
3032 | |||
3033 | if ( !base ) { | ||
3034 | base = BASE; | ||
3035 | e = bitFloor( x.e / LOG_BASE ) - bitFloor( y.e / LOG_BASE ); | ||
3036 | s = s / LOG_BASE | 0; | ||
3037 | } | ||
3038 | |||
3039 | // Result exponent may be one less then the current value of e. | ||
3040 | // The coefficients of the BigNumbers from convertBase may have trailing zeros. | ||
3041 | for ( i = 0; yc[i] == ( xc[i] || 0 ); i++ ); | ||
3042 | if ( yc[i] > ( xc[i] || 0 ) ) e--; | ||
3043 | |||
3044 | if ( s < 0 ) { | ||
3045 | qc.push(1); | ||
3046 | more = true; | ||
3047 | } else { | ||
3048 | xL = xc.length; | ||
3049 | yL = yc.length; | ||
3050 | i = 0; | ||
3051 | s += 2; | ||
3052 | |||
3053 | // Normalise xc and yc so highest order digit of yc is >= base / 2. | ||
3054 | |||
3055 | n = mathfloor( base / ( yc[0] + 1 ) ); | ||
3056 | |||
3057 | // Not necessary, but to handle odd bases where yc[0] == ( base / 2 ) - 1. | ||
3058 | // if ( n > 1 || n++ == 1 && yc[0] < base / 2 ) { | ||
3059 | if ( n > 1 ) { | ||
3060 | yc = multiply( yc, n, base ); | ||
3061 | xc = multiply( xc, n, base ); | ||
3062 | yL = yc.length; | ||
3063 | xL = xc.length; | ||
3064 | } | ||
3065 | |||
3066 | xi = yL; | ||
3067 | rem = xc.slice( 0, yL ); | ||
3068 | remL = rem.length; | ||
3069 | |||
3070 | // Add zeros to make remainder as long as divisor. | ||
3071 | for ( ; remL < yL; rem[remL++] = 0 ); | ||
3072 | yz = yc.slice(); | ||
3073 | yz = [0].concat(yz); | ||
3074 | yc0 = yc[0]; | ||
3075 | if ( yc[1] >= base / 2 ) yc0++; | ||
3076 | // Not necessary, but to prevent trial digit n > base, when using base 3. | ||
3077 | // else if ( base == 3 && yc0 == 1 ) yc0 = 1 + 1e-15; | ||
3078 | |||
3079 | do { | ||
3080 | n = 0; | ||
3081 | |||
3082 | // Compare divisor and remainder. | ||
3083 | cmp = compare( yc, rem, yL, remL ); | ||
3084 | |||
3085 | // If divisor < remainder. | ||
3086 | if ( cmp < 0 ) { | ||
3087 | |||
3088 | // Calculate trial digit, n. | ||
3089 | |||
3090 | rem0 = rem[0]; | ||
3091 | if ( yL != remL ) rem0 = rem0 * base + ( rem[1] || 0 ); | ||
3092 | |||
3093 | // n is how many times the divisor goes into the current remainder. | ||
3094 | n = mathfloor( rem0 / yc0 ); | ||
3095 | |||
3096 | // Algorithm: | ||
3097 | // 1. product = divisor * trial digit (n) | ||
3098 | // 2. if product > remainder: product -= divisor, n-- | ||
3099 | // 3. remainder -= product | ||
3100 | // 4. if product was < remainder at 2: | ||
3101 | // 5. compare new remainder and divisor | ||
3102 | // 6. If remainder > divisor: remainder -= divisor, n++ | ||
3103 | |||
3104 | if ( n > 1 ) { | ||
3105 | |||
3106 | // n may be > base only when base is 3. | ||
3107 | if (n >= base) n = base - 1; | ||
3108 | |||
3109 | // product = divisor * trial digit. | ||
3110 | prod = multiply( yc, n, base ); | ||
3111 | prodL = prod.length; | ||
3112 | remL = rem.length; | ||
3113 | |||
3114 | // Compare product and remainder. | ||
3115 | // If product > remainder. | ||
3116 | // Trial digit n too high. | ||
3117 | // n is 1 too high about 5% of the time, and is not known to have | ||
3118 | // ever been more than 1 too high. | ||
3119 | while ( compare( prod, rem, prodL, remL ) == 1 ) { | ||
3120 | n--; | ||
3121 | |||
3122 | // Subtract divisor from product. | ||
3123 | subtract( prod, yL < prodL ? yz : yc, prodL, base ); | ||
3124 | prodL = prod.length; | ||
3125 | cmp = 1; | ||
3126 | } | ||
3127 | } else { | ||
3128 | |||
3129 | // n is 0 or 1, cmp is -1. | ||
3130 | // If n is 0, there is no need to compare yc and rem again below, | ||
3131 | // so change cmp to 1 to avoid it. | ||
3132 | // If n is 1, leave cmp as -1, so yc and rem are compared again. | ||
3133 | if ( n == 0 ) { | ||
3134 | |||
3135 | // divisor < remainder, so n must be at least 1. | ||
3136 | cmp = n = 1; | ||
3137 | } | ||
3138 | |||
3139 | // product = divisor | ||
3140 | prod = yc.slice(); | ||
3141 | prodL = prod.length; | ||
3142 | } | ||
3143 | |||
3144 | if ( prodL < remL ) prod = [0].concat(prod); | ||
3145 | |||
3146 | // Subtract product from remainder. | ||
3147 | subtract( rem, prod, remL, base ); | ||
3148 | remL = rem.length; | ||
3149 | |||
3150 | // If product was < remainder. | ||
3151 | if ( cmp == -1 ) { | ||
3152 | |||
3153 | // Compare divisor and new remainder. | ||
3154 | // If divisor < new remainder, subtract divisor from remainder. | ||
3155 | // Trial digit n too low. | ||
3156 | // n is 1 too low about 5% of the time, and very rarely 2 too low. | ||
3157 | while ( compare( yc, rem, yL, remL ) < 1 ) { | ||
3158 | n++; | ||
3159 | |||
3160 | // Subtract divisor from remainder. | ||
3161 | subtract( rem, yL < remL ? yz : yc, remL, base ); | ||
3162 | remL = rem.length; | ||
3163 | } | ||
3164 | } | ||
3165 | } else if ( cmp === 0 ) { | ||
3166 | n++; | ||
3167 | rem = [0]; | ||
3168 | } // else cmp === 1 and n will be 0 | ||
3169 | |||
3170 | // Add the next digit, n, to the result array. | ||
3171 | qc[i++] = n; | ||
3172 | |||
3173 | // Update the remainder. | ||
3174 | if ( rem[0] ) { | ||
3175 | rem[remL++] = xc[xi] || 0; | ||
3176 | } else { | ||
3177 | rem = [ xc[xi] ]; | ||
3178 | remL = 1; | ||
3179 | } | ||
3180 | } while ( ( xi++ < xL || rem[0] != null ) && s-- ); | ||
3181 | |||
3182 | more = rem[0] != null; | ||
3183 | |||
3184 | // Leading zero? | ||
3185 | if ( !qc[0] ) qc.splice(0, 1); | ||
3186 | } | ||
3187 | |||
3188 | if ( base == BASE ) { | ||
3189 | |||
3190 | // To calculate q.e, first get the number of digits of qc[0]. | ||
3191 | for ( i = 1, s = qc[0]; s >= 10; s /= 10, i++ ); | ||
3192 | round( q, dp + ( q.e = i + e * LOG_BASE - 1 ) + 1, rm, more ); | ||
3193 | |||
3194 | // Caller is convertBase. | ||
3195 | } else { | ||
3196 | q.e = e; | ||
3197 | q.r = +more; | ||
3198 | } | ||
3199 | |||
3200 | return q; | ||
3201 | }; | ||
3202 | })(); | ||
3203 | |||
3204 | |||
3205 | /* | ||
3206 | * Return a string representing the value of BigNumber n in fixed-point or exponential | ||
3207 | * notation rounded to the specified decimal places or significant digits. | ||
3208 | * | ||
3209 | * n is a BigNumber. | ||
3210 | * i is the index of the last digit required (i.e. the digit that may be rounded up). | ||
3211 | * rm is the rounding mode. | ||
3212 | * caller is caller id: toExponential 19, toFixed 20, toFormat 21, toPrecision 24. | ||
3213 | */ | ||
3214 | function format( n, i, rm, caller ) { | ||
3215 | var c0, e, ne, len, str; | ||
3216 | |||
3217 | rm = rm != null && isValidInt( rm, 0, 8, caller, roundingMode ) | ||
3218 | ? rm | 0 : ROUNDING_MODE; | ||
3219 | |||
3220 | if ( !n.c ) return n.toString(); | ||
3221 | c0 = n.c[0]; | ||
3222 | ne = n.e; | ||
3223 | |||
3224 | if ( i == null ) { | ||
3225 | str = coeffToString( n.c ); | ||
3226 | str = caller == 19 || caller == 24 && ne <= TO_EXP_NEG | ||
3227 | ? toExponential( str, ne ) | ||
3228 | : toFixedPoint( str, ne ); | ||
3229 | } else { | ||
3230 | n = round( new BigNumber(n), i, rm ); | ||
3231 | |||
3232 | // n.e may have changed if the value was rounded up. | ||
3233 | e = n.e; | ||
3234 | |||
3235 | str = coeffToString( n.c ); | ||
3236 | len = str.length; | ||
3237 | |||
3238 | // toPrecision returns exponential notation if the number of significant digits | ||
3239 | // specified is less than the number of digits necessary to represent the integer | ||
3240 | // part of the value in fixed-point notation. | ||
3241 | |||
3242 | // Exponential notation. | ||
3243 | if ( caller == 19 || caller == 24 && ( i <= e || e <= TO_EXP_NEG ) ) { | ||
3244 | |||
3245 | // Append zeros? | ||
3246 | for ( ; len < i; str += '0', len++ ); | ||
3247 | str = toExponential( str, e ); | ||
3248 | |||
3249 | // Fixed-point notation. | ||
3250 | } else { | ||
3251 | i -= ne; | ||
3252 | str = toFixedPoint( str, e ); | ||
3253 | |||
3254 | // Append zeros? | ||
3255 | if ( e + 1 > len ) { | ||
3256 | if ( --i > 0 ) for ( str += '.'; i--; str += '0' ); | ||
3257 | } else { | ||
3258 | i += e - len; | ||
3259 | if ( i > 0 ) { | ||
3260 | if ( e + 1 == len ) str += '.'; | ||
3261 | for ( ; i--; str += '0' ); | ||
3262 | } | ||
3263 | } | ||
3264 | } | ||
3265 | } | ||
3266 | |||
3267 | return n.s < 0 && c0 ? '-' + str : str; | ||
3268 | } | ||
3269 | |||
3270 | |||
3271 | // Handle BigNumber.max and BigNumber.min. | ||
3272 | function maxOrMin( args, method ) { | ||
3273 | var m, n, | ||
3274 | i = 0; | ||
3275 | |||
3276 | if ( isArray( args[0] ) ) args = args[0]; | ||
3277 | m = new BigNumber( args[0] ); | ||
3278 | |||
3279 | for ( ; ++i < args.length; ) { | ||
3280 | n = new BigNumber( args[i] ); | ||
3281 | |||
3282 | // If any number is NaN, return NaN. | ||
3283 | if ( !n.s ) { | ||
3284 | m = n; | ||
3285 | break; | ||
3286 | } else if ( method.call( m, n ) ) { | ||
3287 | m = n; | ||
3288 | } | ||
3289 | } | ||
3290 | |||
3291 | return m; | ||
3292 | } | ||
3293 | |||
3294 | |||
3295 | /* | ||
3296 | * Return true if n is an integer in range, otherwise throw. | ||
3297 | * Use for argument validation when ERRORS is true. | ||
3298 | */ | ||
3299 | function intValidatorWithErrors( n, min, max, caller, name ) { | ||
3300 | if ( n < min || n > max || n != truncate(n) ) { | ||
3301 | raise( caller, ( name || 'decimal places' ) + | ||
3302 | ( n < min || n > max ? ' out of range' : ' not an integer' ), n ); | ||
3303 | } | ||
3304 | |||
3305 | return true; | ||
3306 | } | ||
3307 | |||
3308 | |||
3309 | /* | ||
3310 | * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP. | ||
3311 | * Called by minus, plus and times. | ||
3312 | */ | ||
3313 | function normalise( n, c, e ) { | ||
3314 | var i = 1, | ||
3315 | j = c.length; | ||
3316 | |||
3317 | // Remove trailing zeros. | ||
3318 | for ( ; !c[--j]; c.pop() ); | ||
3319 | |||
3320 | // Calculate the base 10 exponent. First get the number of digits of c[0]. | ||
3321 | for ( j = c[0]; j >= 10; j /= 10, i++ ); | ||
3322 | |||
3323 | // Overflow? | ||
3324 | if ( ( e = i + e * LOG_BASE - 1 ) > MAX_EXP ) { | ||
3325 | |||
3326 | // Infinity. | ||
3327 | n.c = n.e = null; | ||
3328 | |||
3329 | // Underflow? | ||
3330 | } else if ( e < MIN_EXP ) { | ||
3331 | |||
3332 | // Zero. | ||
3333 | n.c = [ n.e = 0 ]; | ||
3334 | } else { | ||
3335 | n.e = e; | ||
3336 | n.c = c; | ||
3337 | } | ||
3338 | |||
3339 | return n; | ||
3340 | } | ||
3341 | |||
3342 | |||
3343 | // Handle values that fail the validity test in BigNumber. | ||
3344 | parseNumeric = (function () { | ||
3345 | var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, | ||
3346 | dotAfter = /^([^.]+)\.$/, | ||
3347 | dotBefore = /^\.([^.]+)$/, | ||
3348 | isInfinityOrNaN = /^-?(Infinity|NaN)$/, | ||
3349 | whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g; | ||
3350 | |||
3351 | return function ( x, str, num, b ) { | ||
3352 | var base, | ||
3353 | s = num ? str : str.replace( whitespaceOrPlus, '' ); | ||
3354 | |||
3355 | // No exception on ±Infinity or NaN. | ||
3356 | if ( isInfinityOrNaN.test(s) ) { | ||
3357 | x.s = isNaN(s) ? null : s < 0 ? -1 : 1; | ||
3358 | } else { | ||
3359 | if ( !num ) { | ||
3360 | |||
3361 | // basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i | ||
3362 | s = s.replace( basePrefix, function ( m, p1, p2 ) { | ||
3363 | base = ( p2 = p2.toLowerCase() ) == 'x' ? 16 : p2 == 'b' ? 2 : 8; | ||
3364 | return !b || b == base ? p1 : m; | ||
3365 | }); | ||
3366 | |||
3367 | if (b) { | ||
3368 | base = b; | ||
3369 | |||
3370 | // E.g. '1.' to '1', '.1' to '0.1' | ||
3371 | s = s.replace( dotAfter, '$1' ).replace( dotBefore, '0.$1' ); | ||
3372 | } | ||
3373 | |||
3374 | if ( str != s ) return new BigNumber( s, base ); | ||
3375 | } | ||
3376 | |||
3377 | // 'new BigNumber() not a number: {n}' | ||
3378 | // 'new BigNumber() not a base {b} number: {n}' | ||
3379 | if (ERRORS) raise( id, 'not a' + ( b ? ' base ' + b : '' ) + ' number', str ); | ||
3380 | x.s = null; | ||
3381 | } | ||
3382 | |||
3383 | x.c = x.e = null; | ||
3384 | id = 0; | ||
3385 | } | ||
3386 | })(); | ||
3387 | |||
3388 | |||
3389 | // Throw a BigNumber Error. | ||
3390 | function raise( caller, msg, val ) { | ||
3391 | var error = new Error( [ | ||
3392 | 'new BigNumber', // 0 | ||
3393 | 'cmp', // 1 | ||
3394 | 'config', // 2 | ||
3395 | 'div', // 3 | ||
3396 | 'divToInt', // 4 | ||
3397 | 'eq', // 5 | ||
3398 | 'gt', // 6 | ||
3399 | 'gte', // 7 | ||
3400 | 'lt', // 8 | ||
3401 | 'lte', // 9 | ||
3402 | 'minus', // 10 | ||
3403 | 'mod', // 11 | ||
3404 | 'plus', // 12 | ||
3405 | 'precision', // 13 | ||
3406 | 'random', // 14 | ||
3407 | 'round', // 15 | ||
3408 | 'shift', // 16 | ||
3409 | 'times', // 17 | ||
3410 | 'toDigits', // 18 | ||
3411 | 'toExponential', // 19 | ||
3412 | 'toFixed', // 20 | ||
3413 | 'toFormat', // 21 | ||
3414 | 'toFraction', // 22 | ||
3415 | 'pow', // 23 | ||
3416 | 'toPrecision', // 24 | ||
3417 | 'toString', // 25 | ||
3418 | 'BigNumber' // 26 | ||
3419 | ][caller] + '() ' + msg + ': ' + val ); | ||
3420 | |||
3421 | error.name = 'BigNumber Error'; | ||
3422 | id = 0; | ||
3423 | throw error; | ||
3424 | } | ||
3425 | |||
3426 | |||
3427 | /* | ||
3428 | * Round x to sd significant digits using rounding mode rm. Check for over/under-flow. | ||
3429 | * If r is truthy, it is known that there are more digits after the rounding digit. | ||
3430 | */ | ||
3431 | function round( x, sd, rm, r ) { | ||
3432 | var d, i, j, k, n, ni, rd, | ||
3433 | xc = x.c, | ||
3434 | pows10 = POWS_TEN; | ||
3435 | |||
3436 | // if x is not Infinity or NaN... | ||
3437 | if (xc) { | ||
3438 | |||
3439 | // rd is the rounding digit, i.e. the digit after the digit that may be rounded up. | ||
3440 | // n is a base 1e14 number, the value of the element of array x.c containing rd. | ||
3441 | // ni is the index of n within x.c. | ||
3442 | // d is the number of digits of n. | ||
3443 | // i is the index of rd within n including leading zeros. | ||
3444 | // j is the actual index of rd within n (if < 0, rd is a leading zero). | ||
3445 | out: { | ||
3446 | |||
3447 | // Get the number of digits of the first element of xc. | ||
3448 | for ( d = 1, k = xc[0]; k >= 10; k /= 10, d++ ); | ||
3449 | i = sd - d; | ||
3450 | |||
3451 | // If the rounding digit is in the first element of xc... | ||
3452 | if ( i < 0 ) { | ||
3453 | i += LOG_BASE; | ||
3454 | j = sd; | ||
3455 | n = xc[ ni = 0 ]; | ||
3456 | |||
3457 | // Get the rounding digit at index j of n. | ||
3458 | rd = n / pows10[ d - j - 1 ] % 10 | 0; | ||
3459 | } else { | ||
3460 | ni = mathceil( ( i + 1 ) / LOG_BASE ); | ||
3461 | |||
3462 | if ( ni >= xc.length ) { | ||
3463 | |||
3464 | if (r) { | ||
3465 | |||
3466 | // Needed by sqrt. | ||
3467 | for ( ; xc.length <= ni; xc.push(0) ); | ||
3468 | n = rd = 0; | ||
3469 | d = 1; | ||
3470 | i %= LOG_BASE; | ||
3471 | j = i - LOG_BASE + 1; | ||
3472 | } else { | ||
3473 | break out; | ||
3474 | } | ||
3475 | } else { | ||
3476 | n = k = xc[ni]; | ||
3477 | |||
3478 | // Get the number of digits of n. | ||
3479 | for ( d = 1; k >= 10; k /= 10, d++ ); | ||
3480 | |||
3481 | // Get the index of rd within n. | ||
3482 | i %= LOG_BASE; | ||
3483 | |||
3484 | // Get the index of rd within n, adjusted for leading zeros. | ||
3485 | // The number of leading zeros of n is given by LOG_BASE - d. | ||
3486 | j = i - LOG_BASE + d; | ||
3487 | |||
3488 | // Get the rounding digit at index j of n. | ||
3489 | rd = j < 0 ? 0 : n / pows10[ d - j - 1 ] % 10 | 0; | ||
3490 | } | ||
3491 | } | ||
3492 | |||
3493 | r = r || sd < 0 || | ||
3494 | |||
3495 | // Are there any non-zero digits after the rounding digit? | ||
3496 | // The expression n % pows10[ d - j - 1 ] returns all digits of n to the right | ||
3497 | // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714. | ||
3498 | xc[ni + 1] != null || ( j < 0 ? n : n % pows10[ d - j - 1 ] ); | ||
3499 | |||
3500 | r = rm < 4 | ||
3501 | ? ( rd || r ) && ( rm == 0 || rm == ( x.s < 0 ? 3 : 2 ) ) | ||
3502 | : rd > 5 || rd == 5 && ( rm == 4 || r || rm == 6 && | ||
3503 | |||
3504 | // Check whether the digit to the left of the rounding digit is odd. | ||
3505 | ( ( i > 0 ? j > 0 ? n / pows10[ d - j ] : 0 : xc[ni - 1] ) % 10 ) & 1 || | ||
3506 | rm == ( x.s < 0 ? 8 : 7 ) ); | ||
3507 | |||
3508 | if ( sd < 1 || !xc[0] ) { | ||
3509 | xc.length = 0; | ||
3510 | |||
3511 | if (r) { | ||
3512 | |||
3513 | // Convert sd to decimal places. | ||
3514 | sd -= x.e + 1; | ||
3515 | |||
3516 | // 1, 0.1, 0.01, 0.001, 0.0001 etc. | ||
3517 | xc[0] = pows10[ ( LOG_BASE - sd % LOG_BASE ) % LOG_BASE ]; | ||
3518 | x.e = -sd || 0; | ||
3519 | } else { | ||
3520 | |||
3521 | // Zero. | ||
3522 | xc[0] = x.e = 0; | ||
3523 | } | ||
3524 | |||
3525 | return x; | ||
3526 | } | ||
3527 | |||
3528 | // Remove excess digits. | ||
3529 | if ( i == 0 ) { | ||
3530 | xc.length = ni; | ||
3531 | k = 1; | ||
3532 | ni--; | ||
3533 | } else { | ||
3534 | xc.length = ni + 1; | ||
3535 | k = pows10[ LOG_BASE - i ]; | ||
3536 | |||
3537 | // E.g. 56700 becomes 56000 if 7 is the rounding digit. | ||
3538 | // j > 0 means i > number of leading zeros of n. | ||
3539 | xc[ni] = j > 0 ? mathfloor( n / pows10[ d - j ] % pows10[j] ) * k : 0; | ||
3540 | } | ||
3541 | |||
3542 | // Round up? | ||
3543 | if (r) { | ||
3544 | |||
3545 | for ( ; ; ) { | ||
3546 | |||
3547 | // If the digit to be rounded up is in the first element of xc... | ||
3548 | if ( ni == 0 ) { | ||
3549 | |||
3550 | // i will be the length of xc[0] before k is added. | ||
3551 | for ( i = 1, j = xc[0]; j >= 10; j /= 10, i++ ); | ||
3552 | j = xc[0] += k; | ||
3553 | for ( k = 1; j >= 10; j /= 10, k++ ); | ||
3554 | |||
3555 | // if i != k the length has increased. | ||
3556 | if ( i != k ) { | ||
3557 | x.e++; | ||
3558 | if ( xc[0] == BASE ) xc[0] = 1; | ||
3559 | } | ||
3560 | |||
3561 | break; | ||
3562 | } else { | ||
3563 | xc[ni] += k; | ||
3564 | if ( xc[ni] != BASE ) break; | ||
3565 | xc[ni--] = 0; | ||
3566 | k = 1; | ||
3567 | } | ||
3568 | } | ||
3569 | } | ||
3570 | |||
3571 | // Remove trailing zeros. | ||
3572 | for ( i = xc.length; xc[--i] === 0; xc.pop() ); | ||
3573 | } | ||
3574 | |||
3575 | // Overflow? Infinity. | ||
3576 | if ( x.e > MAX_EXP ) { | ||
3577 | x.c = x.e = null; | ||
3578 | |||
3579 | // Underflow? Zero. | ||
3580 | } else if ( x.e < MIN_EXP ) { | ||
3581 | x.c = [ x.e = 0 ]; | ||
3582 | } | ||
3583 | } | ||
3584 | |||
3585 | return x; | ||
3586 | } | ||
3587 | |||
3588 | |||
3589 | // PROTOTYPE/INSTANCE METHODS | ||
3590 | |||
3591 | |||
3592 | /* | ||
3593 | * Return a new BigNumber whose value is the absolute value of this BigNumber. | ||
3594 | */ | ||
3595 | P.absoluteValue = P.abs = function () { | ||
3596 | var x = new BigNumber(this); | ||
3597 | if ( x.s < 0 ) x.s = 1; | ||
3598 | return x; | ||
3599 | }; | ||
3600 | |||
3601 | |||
3602 | /* | ||
3603 | * Return a new BigNumber whose value is the value of this BigNumber rounded to a whole | ||
3604 | * number in the direction of Infinity. | ||
3605 | */ | ||
3606 | P.ceil = function () { | ||
3607 | return round( new BigNumber(this), this.e + 1, 2 ); | ||
3608 | }; | ||
3609 | |||
3610 | |||
3611 | /* | ||
3612 | * Return | ||
3613 | * 1 if the value of this BigNumber is greater than the value of BigNumber(y, b), | ||
3614 | * -1 if the value of this BigNumber is less than the value of BigNumber(y, b), | ||
3615 | * 0 if they have the same value, | ||
3616 | * or null if the value of either is NaN. | ||
3617 | */ | ||
3618 | P.comparedTo = P.cmp = function ( y, b ) { | ||
3619 | id = 1; | ||
3620 | return compare( this, new BigNumber( y, b ) ); | ||
3621 | }; | ||
3622 | |||
3623 | |||
3624 | /* | ||
3625 | * Return the number of decimal places of the value of this BigNumber, or null if the value | ||
3626 | * of this BigNumber is ±Infinity or NaN. | ||
3627 | */ | ||
3628 | P.decimalPlaces = P.dp = function () { | ||
3629 | var n, v, | ||
3630 | c = this.c; | ||
3631 | |||
3632 | if ( !c ) return null; | ||
3633 | n = ( ( v = c.length - 1 ) - bitFloor( this.e / LOG_BASE ) ) * LOG_BASE; | ||
3634 | |||
3635 | // Subtract the number of trailing zeros of the last number. | ||
3636 | if ( v = c[v] ) for ( ; v % 10 == 0; v /= 10, n-- ); | ||
3637 | if ( n < 0 ) n = 0; | ||
3638 | |||
3639 | return n; | ||
3640 | }; | ||
3641 | |||
3642 | |||
3643 | /* | ||
3644 | * n / 0 = I | ||
3645 | * n / N = N | ||
3646 | * n / I = 0 | ||
3647 | * 0 / n = 0 | ||
3648 | * 0 / 0 = N | ||
3649 | * 0 / N = N | ||
3650 | * 0 / I = 0 | ||
3651 | * N / n = N | ||
3652 | * N / 0 = N | ||
3653 | * N / N = N | ||
3654 | * N / I = N | ||
3655 | * I / n = I | ||
3656 | * I / 0 = I | ||
3657 | * I / N = N | ||
3658 | * I / I = N | ||
3659 | * | ||
3660 | * Return a new BigNumber whose value is the value of this BigNumber divided by the value of | ||
3661 | * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE. | ||
3662 | */ | ||
3663 | P.dividedBy = P.div = function ( y, b ) { | ||
3664 | id = 3; | ||
3665 | return div( this, new BigNumber( y, b ), DECIMAL_PLACES, ROUNDING_MODE ); | ||
3666 | }; | ||
3667 | |||
3668 | |||
3669 | /* | ||
3670 | * Return a new BigNumber whose value is the integer part of dividing the value of this | ||
3671 | * BigNumber by the value of BigNumber(y, b). | ||
3672 | */ | ||
3673 | P.dividedToIntegerBy = P.divToInt = function ( y, b ) { | ||
3674 | id = 4; | ||
3675 | return div( this, new BigNumber( y, b ), 0, 1 ); | ||
3676 | }; | ||
3677 | |||
3678 | |||
3679 | /* | ||
3680 | * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b), | ||
3681 | * otherwise returns false. | ||
3682 | */ | ||
3683 | P.equals = P.eq = function ( y, b ) { | ||
3684 | id = 5; | ||
3685 | return compare( this, new BigNumber( y, b ) ) === 0; | ||
3686 | }; | ||
3687 | |||
3688 | |||
3689 | /* | ||
3690 | * Return a new BigNumber whose value is the value of this BigNumber rounded to a whole | ||
3691 | * number in the direction of -Infinity. | ||
3692 | */ | ||
3693 | P.floor = function () { | ||
3694 | return round( new BigNumber(this), this.e + 1, 3 ); | ||
3695 | }; | ||
3696 | |||
3697 | |||
3698 | /* | ||
3699 | * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b), | ||
3700 | * otherwise returns false. | ||
3701 | */ | ||
3702 | P.greaterThan = P.gt = function ( y, b ) { | ||
3703 | id = 6; | ||
3704 | return compare( this, new BigNumber( y, b ) ) > 0; | ||
3705 | }; | ||
3706 | |||
3707 | |||
3708 | /* | ||
3709 | * Return true if the value of this BigNumber is greater than or equal to the value of | ||
3710 | * BigNumber(y, b), otherwise returns false. | ||
3711 | */ | ||
3712 | P.greaterThanOrEqualTo = P.gte = function ( y, b ) { | ||
3713 | id = 7; | ||
3714 | return ( b = compare( this, new BigNumber( y, b ) ) ) === 1 || b === 0; | ||
3715 | |||
3716 | }; | ||
3717 | |||
3718 | |||
3719 | /* | ||
3720 | * Return true if the value of this BigNumber is a finite number, otherwise returns false. | ||
3721 | */ | ||
3722 | P.isFinite = function () { | ||
3723 | return !!this.c; | ||
3724 | }; | ||
3725 | |||
3726 | |||
3727 | /* | ||
3728 | * Return true if the value of this BigNumber is an integer, otherwise return false. | ||
3729 | */ | ||
3730 | P.isInteger = P.isInt = function () { | ||
3731 | return !!this.c && bitFloor( this.e / LOG_BASE ) > this.c.length - 2; | ||
3732 | }; | ||
3733 | |||
3734 | |||
3735 | /* | ||
3736 | * Return true if the value of this BigNumber is NaN, otherwise returns false. | ||
3737 | */ | ||
3738 | P.isNaN = function () { | ||
3739 | return !this.s; | ||
3740 | }; | ||
3741 | |||
3742 | |||
3743 | /* | ||
3744 | * Return true if the value of this BigNumber is negative, otherwise returns false. | ||
3745 | */ | ||
3746 | P.isNegative = P.isNeg = function () { | ||
3747 | return this.s < 0; | ||
3748 | }; | ||
3749 | |||
3750 | |||
3751 | /* | ||
3752 | * Return true if the value of this BigNumber is 0 or -0, otherwise returns false. | ||
3753 | */ | ||
3754 | P.isZero = function () { | ||
3755 | return !!this.c && this.c[0] == 0; | ||
3756 | }; | ||
3757 | |||
3758 | |||
3759 | /* | ||
3760 | * Return true if the value of this BigNumber is less than the value of BigNumber(y, b), | ||
3761 | * otherwise returns false. | ||
3762 | */ | ||
3763 | P.lessThan = P.lt = function ( y, b ) { | ||
3764 | id = 8; | ||
3765 | return compare( this, new BigNumber( y, b ) ) < 0; | ||
3766 | }; | ||
3767 | |||
3768 | |||
3769 | /* | ||
3770 | * Return true if the value of this BigNumber is less than or equal to the value of | ||
3771 | * BigNumber(y, b), otherwise returns false. | ||
3772 | */ | ||
3773 | P.lessThanOrEqualTo = P.lte = function ( y, b ) { | ||
3774 | id = 9; | ||
3775 | return ( b = compare( this, new BigNumber( y, b ) ) ) === -1 || b === 0; | ||
3776 | }; | ||
3777 | |||
3778 | |||
3779 | /* | ||
3780 | * n - 0 = n | ||
3781 | * n - N = N | ||
3782 | * n - I = -I | ||
3783 | * 0 - n = -n | ||
3784 | * 0 - 0 = 0 | ||
3785 | * 0 - N = N | ||
3786 | * 0 - I = -I | ||
3787 | * N - n = N | ||
3788 | * N - 0 = N | ||
3789 | * N - N = N | ||
3790 | * N - I = N | ||
3791 | * I - n = I | ||
3792 | * I - 0 = I | ||
3793 | * I - N = N | ||
3794 | * I - I = N | ||
3795 | * | ||
3796 | * Return a new BigNumber whose value is the value of this BigNumber minus the value of | ||
3797 | * BigNumber(y, b). | ||
3798 | */ | ||
3799 | P.minus = P.sub = function ( y, b ) { | ||
3800 | var i, j, t, xLTy, | ||
3801 | x = this, | ||
3802 | a = x.s; | ||
3803 | |||
3804 | id = 10; | ||
3805 | y = new BigNumber( y, b ); | ||
3806 | b = y.s; | ||
3807 | |||
3808 | // Either NaN? | ||
3809 | if ( !a || !b ) return new BigNumber(NaN); | ||
3810 | |||
3811 | // Signs differ? | ||
3812 | if ( a != b ) { | ||
3813 | y.s = -b; | ||
3814 | return x.plus(y); | ||
3815 | } | ||
3816 | |||
3817 | var xe = x.e / LOG_BASE, | ||
3818 | ye = y.e / LOG_BASE, | ||
3819 | xc = x.c, | ||
3820 | yc = y.c; | ||
3821 | |||
3822 | if ( !xe || !ye ) { | ||
3823 | |||
3824 | // Either Infinity? | ||
3825 | if ( !xc || !yc ) return xc ? ( y.s = -b, y ) : new BigNumber( yc ? x : NaN ); | ||
3826 | |||
3827 | // Either zero? | ||
3828 | if ( !xc[0] || !yc[0] ) { | ||
3829 | |||
3830 | // Return y if y is non-zero, x if x is non-zero, or zero if both are zero. | ||
3831 | return yc[0] ? ( y.s = -b, y ) : new BigNumber( xc[0] ? x : | ||
3832 | |||
3833 | // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity | ||
3834 | ROUNDING_MODE == 3 ? -0 : 0 ); | ||
3835 | } | ||
3836 | } | ||
3837 | |||
3838 | xe = bitFloor(xe); | ||
3839 | ye = bitFloor(ye); | ||
3840 | xc = xc.slice(); | ||
3841 | |||
3842 | // Determine which is the bigger number. | ||
3843 | if ( a = xe - ye ) { | ||
3844 | |||
3845 | if ( xLTy = a < 0 ) { | ||
3846 | a = -a; | ||
3847 | t = xc; | ||
3848 | } else { | ||
3849 | ye = xe; | ||
3850 | t = yc; | ||
3851 | } | ||
3852 | |||
3853 | t.reverse(); | ||
3854 | |||
3855 | // Prepend zeros to equalise exponents. | ||
3856 | for ( b = a; b--; t.push(0) ); | ||
3857 | t.reverse(); | ||
3858 | } else { | ||
3859 | |||
3860 | // Exponents equal. Check digit by digit. | ||
3861 | j = ( xLTy = ( a = xc.length ) < ( b = yc.length ) ) ? a : b; | ||
3862 | |||
3863 | for ( a = b = 0; b < j; b++ ) { | ||
3864 | |||
3865 | if ( xc[b] != yc[b] ) { | ||
3866 | xLTy = xc[b] < yc[b]; | ||
3867 | break; | ||
3868 | } | ||
3869 | } | ||
3870 | } | ||
3871 | |||
3872 | // x < y? Point xc to the array of the bigger number. | ||
3873 | if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s; | ||
3874 | |||
3875 | b = ( j = yc.length ) - ( i = xc.length ); | ||
3876 | |||
3877 | // Append zeros to xc if shorter. | ||
3878 | // No need to add zeros to yc if shorter as subtract only needs to start at yc.length. | ||
3879 | if ( b > 0 ) for ( ; b--; xc[i++] = 0 ); | ||
3880 | b = BASE - 1; | ||
3881 | |||
3882 | // Subtract yc from xc. | ||
3883 | for ( ; j > a; ) { | ||
3884 | |||
3885 | if ( xc[--j] < yc[j] ) { | ||
3886 | for ( i = j; i && !xc[--i]; xc[i] = b ); | ||
3887 | --xc[i]; | ||
3888 | xc[j] += BASE; | ||
3889 | } | ||
3890 | |||
3891 | xc[j] -= yc[j]; | ||
3892 | } | ||
3893 | |||
3894 | // Remove leading zeros and adjust exponent accordingly. | ||
3895 | for ( ; xc[0] == 0; xc.splice(0, 1), --ye ); | ||
3896 | |||
3897 | // Zero? | ||
3898 | if ( !xc[0] ) { | ||
3899 | |||
3900 | // Following IEEE 754 (2008) 6.3, | ||
3901 | // n - n = +0 but n - n = -0 when rounding towards -Infinity. | ||
3902 | y.s = ROUNDING_MODE == 3 ? -1 : 1; | ||
3903 | y.c = [ y.e = 0 ]; | ||
3904 | return y; | ||
3905 | } | ||
3906 | |||
3907 | // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity | ||
3908 | // for finite x and y. | ||
3909 | return normalise( y, xc, ye ); | ||
3910 | }; | ||
3911 | |||
3912 | |||
3913 | /* | ||
3914 | * n % 0 = N | ||
3915 | * n % N = N | ||
3916 | * n % I = n | ||
3917 | * 0 % n = 0 | ||
3918 | * -0 % n = -0 | ||
3919 | * 0 % 0 = N | ||
3920 | * 0 % N = N | ||
3921 | * 0 % I = 0 | ||
3922 | * N % n = N | ||
3923 | * N % 0 = N | ||
3924 | * N % N = N | ||
3925 | * N % I = N | ||
3926 | * I % n = N | ||
3927 | * I % 0 = N | ||
3928 | * I % N = N | ||
3929 | * I % I = N | ||
3930 | * | ||
3931 | * Return a new BigNumber whose value is the value of this BigNumber modulo the value of | ||
3932 | * BigNumber(y, b). The result depends on the value of MODULO_MODE. | ||
3933 | */ | ||
3934 | P.modulo = P.mod = function ( y, b ) { | ||
3935 | var q, s, | ||
3936 | x = this; | ||
3937 | |||
3938 | id = 11; | ||
3939 | y = new BigNumber( y, b ); | ||
3940 | |||
3941 | // Return NaN if x is Infinity or NaN, or y is NaN or zero. | ||
3942 | if ( !x.c || !y.s || y.c && !y.c[0] ) { | ||
3943 | return new BigNumber(NaN); | ||
3944 | |||
3945 | // Return x if y is Infinity or x is zero. | ||
3946 | } else if ( !y.c || x.c && !x.c[0] ) { | ||
3947 | return new BigNumber(x); | ||
3948 | } | ||
3949 | |||
3950 | if ( MODULO_MODE == 9 ) { | ||
3951 | |||
3952 | // Euclidian division: q = sign(y) * floor(x / abs(y)) | ||
3953 | // r = x - qy where 0 <= r < abs(y) | ||
3954 | s = y.s; | ||
3955 | y.s = 1; | ||
3956 | q = div( x, y, 0, 3 ); | ||
3957 | y.s = s; | ||
3958 | q.s *= s; | ||
3959 | } else { | ||
3960 | q = div( x, y, 0, MODULO_MODE ); | ||
3961 | } | ||
3962 | |||
3963 | return x.minus( q.times(y) ); | ||
3964 | }; | ||
3965 | |||
3966 | |||
3967 | /* | ||
3968 | * Return a new BigNumber whose value is the value of this BigNumber negated, | ||
3969 | * i.e. multiplied by -1. | ||
3970 | */ | ||
3971 | P.negated = P.neg = function () { | ||
3972 | var x = new BigNumber(this); | ||
3973 | x.s = -x.s || null; | ||
3974 | return x; | ||
3975 | }; | ||
3976 | |||
3977 | |||
3978 | /* | ||
3979 | * n + 0 = n | ||
3980 | * n + N = N | ||
3981 | * n + I = I | ||
3982 | * 0 + n = n | ||
3983 | * 0 + 0 = 0 | ||
3984 | * 0 + N = N | ||
3985 | * 0 + I = I | ||
3986 | * N + n = N | ||
3987 | * N + 0 = N | ||
3988 | * N + N = N | ||
3989 | * N + I = N | ||
3990 | * I + n = I | ||
3991 | * I + 0 = I | ||
3992 | * I + N = N | ||
3993 | * I + I = I | ||
3994 | * | ||
3995 | * Return a new BigNumber whose value is the value of this BigNumber plus the value of | ||
3996 | * BigNumber(y, b). | ||
3997 | */ | ||
3998 | P.plus = P.add = function ( y, b ) { | ||
3999 | var t, | ||
4000 | x = this, | ||
4001 | a = x.s; | ||
4002 | |||
4003 | id = 12; | ||
4004 | y = new BigNumber( y, b ); | ||
4005 | b = y.s; | ||
4006 | |||
4007 | // Either NaN? | ||
4008 | if ( !a || !b ) return new BigNumber(NaN); | ||
4009 | |||
4010 | // Signs differ? | ||
4011 | if ( a != b ) { | ||
4012 | y.s = -b; | ||
4013 | return x.minus(y); | ||
4014 | } | ||
4015 | |||
4016 | var xe = x.e / LOG_BASE, | ||
4017 | ye = y.e / LOG_BASE, | ||
4018 | xc = x.c, | ||
4019 | yc = y.c; | ||
4020 | |||
4021 | if ( !xe || !ye ) { | ||
4022 | |||
4023 | // Return ±Infinity if either ±Infinity. | ||
4024 | if ( !xc || !yc ) return new BigNumber( a / 0 ); | ||
4025 | |||
4026 | // Either zero? | ||
4027 | // Return y if y is non-zero, x if x is non-zero, or zero if both are zero. | ||
4028 | if ( !xc[0] || !yc[0] ) return yc[0] ? y : new BigNumber( xc[0] ? x : a * 0 ); | ||
4029 | } | ||
4030 | |||
4031 | xe = bitFloor(xe); | ||
4032 | ye = bitFloor(ye); | ||
4033 | xc = xc.slice(); | ||
4034 | |||
4035 | // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts. | ||
4036 | if ( a = xe - ye ) { | ||
4037 | if ( a > 0 ) { | ||
4038 | ye = xe; | ||
4039 | t = yc; | ||
4040 | } else { | ||
4041 | a = -a; | ||
4042 | t = xc; | ||
4043 | } | ||
4044 | |||
4045 | t.reverse(); | ||
4046 | for ( ; a--; t.push(0) ); | ||
4047 | t.reverse(); | ||
4048 | } | ||
4049 | |||
4050 | a = xc.length; | ||
4051 | b = yc.length; | ||
4052 | |||
4053 | // Point xc to the longer array, and b to the shorter length. | ||
4054 | if ( a - b < 0 ) t = yc, yc = xc, xc = t, b = a; | ||
4055 | |||
4056 | // Only start adding at yc.length - 1 as the further digits of xc can be ignored. | ||
4057 | for ( a = 0; b; ) { | ||
4058 | a = ( xc[--b] = xc[b] + yc[b] + a ) / BASE | 0; | ||
4059 | xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE; | ||
4060 | } | ||
4061 | |||
4062 | if (a) { | ||
4063 | xc = [a].concat(xc); | ||
4064 | ++ye; | ||
4065 | } | ||
4066 | |||
4067 | // No need to check for zero, as +x + +y != 0 && -x + -y != 0 | ||
4068 | // ye = MAX_EXP + 1 possible | ||
4069 | return normalise( y, xc, ye ); | ||
4070 | }; | ||
4071 | |||
4072 | |||
4073 | /* | ||
4074 | * Return the number of significant digits of the value of this BigNumber. | ||
4075 | * | ||
4076 | * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0. | ||
4077 | */ | ||
4078 | P.precision = P.sd = function (z) { | ||
4079 | var n, v, | ||
4080 | x = this, | ||
4081 | c = x.c; | ||
4082 | |||
4083 | // 'precision() argument not a boolean or binary digit: {z}' | ||
4084 | if ( z != null && z !== !!z && z !== 1 && z !== 0 ) { | ||
4085 | if (ERRORS) raise( 13, 'argument' + notBool, z ); | ||
4086 | if ( z != !!z ) z = null; | ||
4087 | } | ||
4088 | |||
4089 | if ( !c ) return null; | ||
4090 | v = c.length - 1; | ||
4091 | n = v * LOG_BASE + 1; | ||
4092 | |||
4093 | if ( v = c[v] ) { | ||
4094 | |||
4095 | // Subtract the number of trailing zeros of the last element. | ||
4096 | for ( ; v % 10 == 0; v /= 10, n-- ); | ||
4097 | |||
4098 | // Add the number of digits of the first element. | ||
4099 | for ( v = c[0]; v >= 10; v /= 10, n++ ); | ||
4100 | } | ||
4101 | |||
4102 | if ( z && x.e + 1 > n ) n = x.e + 1; | ||
4103 | |||
4104 | return n; | ||
4105 | }; | ||
4106 | |||
4107 | |||
4108 | /* | ||
4109 | * Return a new BigNumber whose value is the value of this BigNumber rounded to a maximum of | ||
4110 | * dp decimal places using rounding mode rm, or to 0 and ROUNDING_MODE respectively if | ||
4111 | * omitted. | ||
4112 | * | ||
4113 | * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. | ||
4114 | * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. | ||
4115 | * | ||
4116 | * 'round() decimal places out of range: {dp}' | ||
4117 | * 'round() decimal places not an integer: {dp}' | ||
4118 | * 'round() rounding mode not an integer: {rm}' | ||
4119 | * 'round() rounding mode out of range: {rm}' | ||
4120 | */ | ||
4121 | P.round = function ( dp, rm ) { | ||
4122 | var n = new BigNumber(this); | ||
4123 | |||
4124 | if ( dp == null || isValidInt( dp, 0, MAX, 15 ) ) { | ||
4125 | round( n, ~~dp + this.e + 1, rm == null || | ||
4126 | !isValidInt( rm, 0, 8, 15, roundingMode ) ? ROUNDING_MODE : rm | 0 ); | ||
4127 | } | ||
4128 | |||
4129 | return n; | ||
4130 | }; | ||
4131 | |||
4132 | |||
4133 | /* | ||
4134 | * Return a new BigNumber whose value is the value of this BigNumber shifted by k places | ||
4135 | * (powers of 10). Shift to the right if n > 0, and to the left if n < 0. | ||
4136 | * | ||
4137 | * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive. | ||
4138 | * | ||
4139 | * If k is out of range and ERRORS is false, the result will be ±0 if k < 0, or ±Infinity | ||
4140 | * otherwise. | ||
4141 | * | ||
4142 | * 'shift() argument not an integer: {k}' | ||
4143 | * 'shift() argument out of range: {k}' | ||
4144 | */ | ||
4145 | P.shift = function (k) { | ||
4146 | var n = this; | ||
4147 | return isValidInt( k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER, 16, 'argument' ) | ||
4148 | |||
4149 | // k < 1e+21, or truncate(k) will produce exponential notation. | ||
4150 | ? n.times( '1e' + truncate(k) ) | ||
4151 | : new BigNumber( n.c && n.c[0] && ( k < -MAX_SAFE_INTEGER || k > MAX_SAFE_INTEGER ) | ||
4152 | ? n.s * ( k < 0 ? 0 : 1 / 0 ) | ||
4153 | : n ); | ||
4154 | }; | ||
4155 | |||
4156 | |||
4157 | /* | ||
4158 | * sqrt(-n) = N | ||
4159 | * sqrt( N) = N | ||
4160 | * sqrt(-I) = N | ||
4161 | * sqrt( I) = I | ||
4162 | * sqrt( 0) = 0 | ||
4163 | * sqrt(-0) = -0 | ||
4164 | * | ||
4165 | * Return a new BigNumber whose value is the square root of the value of this BigNumber, | ||
4166 | * rounded according to DECIMAL_PLACES and ROUNDING_MODE. | ||
4167 | */ | ||
4168 | P.squareRoot = P.sqrt = function () { | ||
4169 | var m, n, r, rep, t, | ||
4170 | x = this, | ||
4171 | c = x.c, | ||
4172 | s = x.s, | ||
4173 | e = x.e, | ||
4174 | dp = DECIMAL_PLACES + 4, | ||
4175 | half = new BigNumber('0.5'); | ||
4176 | |||
4177 | // Negative/NaN/Infinity/zero? | ||
4178 | if ( s !== 1 || !c || !c[0] ) { | ||
4179 | return new BigNumber( !s || s < 0 && ( !c || c[0] ) ? NaN : c ? x : 1 / 0 ); | ||
4180 | } | ||
4181 | |||
4182 | // Initial estimate. | ||
4183 | s = Math.sqrt( +x ); | ||
4184 | |||
4185 | // Math.sqrt underflow/overflow? | ||
4186 | // Pass x to Math.sqrt as integer, then adjust the exponent of the result. | ||
4187 | if ( s == 0 || s == 1 / 0 ) { | ||
4188 | n = coeffToString(c); | ||
4189 | if ( ( n.length + e ) % 2 == 0 ) n += '0'; | ||
4190 | s = Math.sqrt(n); | ||
4191 | e = bitFloor( ( e + 1 ) / 2 ) - ( e < 0 || e % 2 ); | ||
4192 | |||
4193 | if ( s == 1 / 0 ) { | ||
4194 | n = '1e' + e; | ||
4195 | } else { | ||
4196 | n = s.toExponential(); | ||
4197 | n = n.slice( 0, n.indexOf('e') + 1 ) + e; | ||
4198 | } | ||
4199 | |||
4200 | r = new BigNumber(n); | ||
4201 | } else { | ||
4202 | r = new BigNumber( s + '' ); | ||
4203 | } | ||
4204 | |||
4205 | // Check for zero. | ||
4206 | // r could be zero if MIN_EXP is changed after the this value was created. | ||
4207 | // This would cause a division by zero (x/t) and hence Infinity below, which would cause | ||
4208 | // coeffToString to throw. | ||
4209 | if ( r.c[0] ) { | ||
4210 | e = r.e; | ||
4211 | s = e + dp; | ||
4212 | if ( s < 3 ) s = 0; | ||
4213 | |||
4214 | // Newton-Raphson iteration. | ||
4215 | for ( ; ; ) { | ||
4216 | t = r; | ||
4217 | r = half.times( t.plus( div( x, t, dp, 1 ) ) ); | ||
4218 | |||
4219 | if ( coeffToString( t.c ).slice( 0, s ) === ( n = | ||
4220 | coeffToString( r.c ) ).slice( 0, s ) ) { | ||
4221 | |||
4222 | // The exponent of r may here be one less than the final result exponent, | ||
4223 | // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits | ||
4224 | // are indexed correctly. | ||
4225 | if ( r.e < e ) --s; | ||
4226 | n = n.slice( s - 3, s + 1 ); | ||
4227 | |||
4228 | // The 4th rounding digit may be in error by -1 so if the 4 rounding digits | ||
4229 | // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the | ||
4230 | // iteration. | ||
4231 | if ( n == '9999' || !rep && n == '4999' ) { | ||
4232 | |||
4233 | // On the first iteration only, check to see if rounding up gives the | ||
4234 | // exact result as the nines may infinitely repeat. | ||
4235 | if ( !rep ) { | ||
4236 | round( t, t.e + DECIMAL_PLACES + 2, 0 ); | ||
4237 | |||
4238 | if ( t.times(t).eq(x) ) { | ||
4239 | r = t; | ||
4240 | break; | ||
4241 | } | ||
4242 | } | ||
4243 | |||
4244 | dp += 4; | ||
4245 | s += 4; | ||
4246 | rep = 1; | ||
4247 | } else { | ||
4248 | |||
4249 | // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact | ||
4250 | // result. If not, then there are further digits and m will be truthy. | ||
4251 | if ( !+n || !+n.slice(1) && n.charAt(0) == '5' ) { | ||
4252 | |||
4253 | // Truncate to the first rounding digit. | ||
4254 | round( r, r.e + DECIMAL_PLACES + 2, 1 ); | ||
4255 | m = !r.times(r).eq(x); | ||
4256 | } | ||
4257 | |||
4258 | break; | ||
4259 | } | ||
4260 | } | ||
4261 | } | ||
4262 | } | ||
4263 | |||
4264 | return round( r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m ); | ||
4265 | }; | ||
4266 | |||
4267 | |||
4268 | /* | ||
4269 | * n * 0 = 0 | ||
4270 | * n * N = N | ||
4271 | * n * I = I | ||
4272 | * 0 * n = 0 | ||
4273 | * 0 * 0 = 0 | ||
4274 | * 0 * N = N | ||
4275 | * 0 * I = N | ||
4276 | * N * n = N | ||
4277 | * N * 0 = N | ||
4278 | * N * N = N | ||
4279 | * N * I = N | ||
4280 | * I * n = I | ||
4281 | * I * 0 = N | ||
4282 | * I * N = N | ||
4283 | * I * I = I | ||
4284 | * | ||
4285 | * Return a new BigNumber whose value is the value of this BigNumber times the value of | ||
4286 | * BigNumber(y, b). | ||
4287 | */ | ||
4288 | P.times = P.mul = function ( y, b ) { | ||
4289 | var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, | ||
4290 | base, sqrtBase, | ||
4291 | x = this, | ||
4292 | xc = x.c, | ||
4293 | yc = ( id = 17, y = new BigNumber( y, b ) ).c; | ||
4294 | |||
4295 | // Either NaN, ±Infinity or ±0? | ||
4296 | if ( !xc || !yc || !xc[0] || !yc[0] ) { | ||
4297 | |||
4298 | // Return NaN if either is NaN, or one is 0 and the other is Infinity. | ||
4299 | if ( !x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc ) { | ||
4300 | y.c = y.e = y.s = null; | ||
4301 | } else { | ||
4302 | y.s *= x.s; | ||
4303 | |||
4304 | // Return ±Infinity if either is ±Infinity. | ||
4305 | if ( !xc || !yc ) { | ||
4306 | y.c = y.e = null; | ||
4307 | |||
4308 | // Return ±0 if either is ±0. | ||
4309 | } else { | ||
4310 | y.c = [0]; | ||
4311 | y.e = 0; | ||
4312 | } | ||
4313 | } | ||
4314 | |||
4315 | return y; | ||
4316 | } | ||
4317 | |||
4318 | e = bitFloor( x.e / LOG_BASE ) + bitFloor( y.e / LOG_BASE ); | ||
4319 | y.s *= x.s; | ||
4320 | xcL = xc.length; | ||
4321 | ycL = yc.length; | ||
4322 | |||
4323 | // Ensure xc points to longer array and xcL to its length. | ||
4324 | if ( xcL < ycL ) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i; | ||
4325 | |||
4326 | // Initialise the result array with zeros. | ||
4327 | for ( i = xcL + ycL, zc = []; i--; zc.push(0) ); | ||
4328 | |||
4329 | base = BASE; | ||
4330 | sqrtBase = SQRT_BASE; | ||
4331 | |||
4332 | for ( i = ycL; --i >= 0; ) { | ||
4333 | c = 0; | ||
4334 | ylo = yc[i] % sqrtBase; | ||
4335 | yhi = yc[i] / sqrtBase | 0; | ||
4336 | |||
4337 | for ( k = xcL, j = i + k; j > i; ) { | ||
4338 | xlo = xc[--k] % sqrtBase; | ||
4339 | xhi = xc[k] / sqrtBase | 0; | ||
4340 | m = yhi * xlo + xhi * ylo; | ||
4341 | xlo = ylo * xlo + ( ( m % sqrtBase ) * sqrtBase ) + zc[j] + c; | ||
4342 | c = ( xlo / base | 0 ) + ( m / sqrtBase | 0 ) + yhi * xhi; | ||
4343 | zc[j--] = xlo % base; | ||
4344 | } | ||
4345 | |||
4346 | zc[j] = c; | ||
4347 | } | ||
4348 | |||
4349 | if (c) { | ||
4350 | ++e; | ||
4351 | } else { | ||
4352 | zc.splice(0, 1); | ||
4353 | } | ||
4354 | |||
4355 | return normalise( y, zc, e ); | ||
4356 | }; | ||
4357 | |||
4358 | |||
4359 | /* | ||
4360 | * Return a new BigNumber whose value is the value of this BigNumber rounded to a maximum of | ||
4361 | * sd significant digits using rounding mode rm, or ROUNDING_MODE if rm is omitted. | ||
4362 | * | ||
4363 | * [sd] {number} Significant digits. Integer, 1 to MAX inclusive. | ||
4364 | * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. | ||
4365 | * | ||
4366 | * 'toDigits() precision out of range: {sd}' | ||
4367 | * 'toDigits() precision not an integer: {sd}' | ||
4368 | * 'toDigits() rounding mode not an integer: {rm}' | ||
4369 | * 'toDigits() rounding mode out of range: {rm}' | ||
4370 | */ | ||
4371 | P.toDigits = function ( sd, rm ) { | ||
4372 | var n = new BigNumber(this); | ||
4373 | sd = sd == null || !isValidInt( sd, 1, MAX, 18, 'precision' ) ? null : sd | 0; | ||
4374 | rm = rm == null || !isValidInt( rm, 0, 8, 18, roundingMode ) ? ROUNDING_MODE : rm | 0; | ||
4375 | return sd ? round( n, sd, rm ) : n; | ||
4376 | }; | ||
4377 | |||
4378 | |||
4379 | /* | ||
4380 | * Return a string representing the value of this BigNumber in exponential notation and | ||
4381 | * rounded using ROUNDING_MODE to dp fixed decimal places. | ||
4382 | * | ||
4383 | * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. | ||
4384 | * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. | ||
4385 | * | ||
4386 | * 'toExponential() decimal places not an integer: {dp}' | ||
4387 | * 'toExponential() decimal places out of range: {dp}' | ||
4388 | * 'toExponential() rounding mode not an integer: {rm}' | ||
4389 | * 'toExponential() rounding mode out of range: {rm}' | ||
4390 | */ | ||
4391 | P.toExponential = function ( dp, rm ) { | ||
4392 | return format( this, | ||
4393 | dp != null && isValidInt( dp, 0, MAX, 19 ) ? ~~dp + 1 : null, rm, 19 ); | ||
4394 | }; | ||
4395 | |||
4396 | |||
4397 | /* | ||
4398 | * Return a string representing the value of this BigNumber in fixed-point notation rounding | ||
4399 | * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted. | ||
4400 | * | ||
4401 | * Note: as with JavaScript's number type, (-0).toFixed(0) is '0', | ||
4402 | * but e.g. (-0.00001).toFixed(0) is '-0'. | ||
4403 | * | ||
4404 | * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. | ||
4405 | * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. | ||
4406 | * | ||
4407 | * 'toFixed() decimal places not an integer: {dp}' | ||
4408 | * 'toFixed() decimal places out of range: {dp}' | ||
4409 | * 'toFixed() rounding mode not an integer: {rm}' | ||
4410 | * 'toFixed() rounding mode out of range: {rm}' | ||
4411 | */ | ||
4412 | P.toFixed = function ( dp, rm ) { | ||
4413 | return format( this, dp != null && isValidInt( dp, 0, MAX, 20 ) | ||
4414 | ? ~~dp + this.e + 1 : null, rm, 20 ); | ||
4415 | }; | ||
4416 | |||
4417 | |||
4418 | /* | ||
4419 | * Return a string representing the value of this BigNumber in fixed-point notation rounded | ||
4420 | * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties | ||
4421 | * of the FORMAT object (see BigNumber.config). | ||
4422 | * | ||
4423 | * FORMAT = { | ||
4424 | * decimalSeparator : '.', | ||
4425 | * groupSeparator : ',', | ||
4426 | * groupSize : 3, | ||
4427 | * secondaryGroupSize : 0, | ||
4428 | * fractionGroupSeparator : '\xA0', // non-breaking space | ||
4429 | * fractionGroupSize : 0 | ||
4430 | * }; | ||
4431 | * | ||
4432 | * [dp] {number} Decimal places. Integer, 0 to MAX inclusive. | ||
4433 | * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. | ||
4434 | * | ||
4435 | * 'toFormat() decimal places not an integer: {dp}' | ||
4436 | * 'toFormat() decimal places out of range: {dp}' | ||
4437 | * 'toFormat() rounding mode not an integer: {rm}' | ||
4438 | * 'toFormat() rounding mode out of range: {rm}' | ||
4439 | */ | ||
4440 | P.toFormat = function ( dp, rm ) { | ||
4441 | var str = format( this, dp != null && isValidInt( dp, 0, MAX, 21 ) | ||
4442 | ? ~~dp + this.e + 1 : null, rm, 21 ); | ||
4443 | |||
4444 | if ( this.c ) { | ||
4445 | var i, | ||
4446 | arr = str.split('.'), | ||
4447 | g1 = +FORMAT.groupSize, | ||
4448 | g2 = +FORMAT.secondaryGroupSize, | ||
4449 | groupSeparator = FORMAT.groupSeparator, | ||
4450 | intPart = arr[0], | ||
4451 | fractionPart = arr[1], | ||
4452 | isNeg = this.s < 0, | ||
4453 | intDigits = isNeg ? intPart.slice(1) : intPart, | ||
4454 | len = intDigits.length; | ||
4455 | |||
4456 | if (g2) i = g1, g1 = g2, g2 = i, len -= i; | ||
4457 | |||
4458 | if ( g1 > 0 && len > 0 ) { | ||
4459 | i = len % g1 || g1; | ||
4460 | intPart = intDigits.substr( 0, i ); | ||
4461 | |||
4462 | for ( ; i < len; i += g1 ) { | ||
4463 | intPart += groupSeparator + intDigits.substr( i, g1 ); | ||
4464 | } | ||
4465 | |||
4466 | if ( g2 > 0 ) intPart += groupSeparator + intDigits.slice(i); | ||
4467 | if (isNeg) intPart = '-' + intPart; | ||
4468 | } | ||
4469 | |||
4470 | str = fractionPart | ||
4471 | ? intPart + FORMAT.decimalSeparator + ( ( g2 = +FORMAT.fractionGroupSize ) | ||
4472 | ? fractionPart.replace( new RegExp( '\\d{' + g2 + '}\\B', 'g' ), | ||
4473 | '$&' + FORMAT.fractionGroupSeparator ) | ||
4474 | : fractionPart ) | ||
4475 | : intPart; | ||
4476 | } | ||
4477 | |||
4478 | return str; | ||
4479 | }; | ||
4480 | |||
4481 | |||
4482 | /* | ||
4483 | * Return a string array representing the value of this BigNumber as a simple fraction with | ||
4484 | * an integer numerator and an integer denominator. The denominator will be a positive | ||
4485 | * non-zero value less than or equal to the specified maximum denominator. If a maximum | ||
4486 | * denominator is not specified, the denominator will be the lowest value necessary to | ||
4487 | * represent the number exactly. | ||
4488 | * | ||
4489 | * [md] {number|string|BigNumber} Integer >= 1 and < Infinity. The maximum denominator. | ||
4490 | * | ||
4491 | * 'toFraction() max denominator not an integer: {md}' | ||
4492 | * 'toFraction() max denominator out of range: {md}' | ||
4493 | */ | ||
4494 | P.toFraction = function (md) { | ||
4495 | var arr, d0, d2, e, exp, n, n0, q, s, | ||
4496 | k = ERRORS, | ||
4497 | x = this, | ||
4498 | xc = x.c, | ||
4499 | d = new BigNumber(ONE), | ||
4500 | n1 = d0 = new BigNumber(ONE), | ||
4501 | d1 = n0 = new BigNumber(ONE); | ||
4502 | |||
4503 | if ( md != null ) { | ||
4504 | ERRORS = false; | ||
4505 | n = new BigNumber(md); | ||
4506 | ERRORS = k; | ||
4507 | |||
4508 | if ( !( k = n.isInt() ) || n.lt(ONE) ) { | ||
4509 | |||
4510 | if (ERRORS) { | ||
4511 | raise( 22, | ||
4512 | 'max denominator ' + ( k ? 'out of range' : 'not an integer' ), md ); | ||
4513 | } | ||
4514 | |||
4515 | // ERRORS is false: | ||
4516 | // If md is a finite non-integer >= 1, round it to an integer and use it. | ||
4517 | md = !k && n.c && round( n, n.e + 1, 1 ).gte(ONE) ? n : null; | ||
4518 | } | ||
4519 | } | ||
4520 | |||
4521 | if ( !xc ) return x.toString(); | ||
4522 | s = coeffToString(xc); | ||
4523 | |||
4524 | // Determine initial denominator. | ||
4525 | // d is a power of 10 and the minimum max denominator that specifies the value exactly. | ||
4526 | e = d.e = s.length - x.e - 1; | ||
4527 | d.c[0] = POWS_TEN[ ( exp = e % LOG_BASE ) < 0 ? LOG_BASE + exp : exp ]; | ||
4528 | md = !md || n.cmp(d) > 0 ? ( e > 0 ? d : n1 ) : n; | ||
4529 | |||
4530 | exp = MAX_EXP; | ||
4531 | MAX_EXP = 1 / 0; | ||
4532 | n = new BigNumber(s); | ||
4533 | |||
4534 | // n0 = d1 = 0 | ||
4535 | n0.c[0] = 0; | ||
4536 | |||
4537 | for ( ; ; ) { | ||
4538 | q = div( n, d, 0, 1 ); | ||
4539 | d2 = d0.plus( q.times(d1) ); | ||
4540 | if ( d2.cmp(md) == 1 ) break; | ||
4541 | d0 = d1; | ||
4542 | d1 = d2; | ||
4543 | n1 = n0.plus( q.times( d2 = n1 ) ); | ||
4544 | n0 = d2; | ||
4545 | d = n.minus( q.times( d2 = d ) ); | ||
4546 | n = d2; | ||
4547 | } | ||
4548 | |||
4549 | d2 = div( md.minus(d0), d1, 0, 1 ); | ||
4550 | n0 = n0.plus( d2.times(n1) ); | ||
4551 | d0 = d0.plus( d2.times(d1) ); | ||
4552 | n0.s = n1.s = x.s; | ||
4553 | e *= 2; | ||
4554 | |||
4555 | // Determine which fraction is closer to x, n0/d0 or n1/d1 | ||
4556 | arr = div( n1, d1, e, ROUNDING_MODE ).minus(x).abs().cmp( | ||
4557 | div( n0, d0, e, ROUNDING_MODE ).minus(x).abs() ) < 1 | ||
4558 | ? [ n1.toString(), d1.toString() ] | ||
4559 | : [ n0.toString(), d0.toString() ]; | ||
4560 | |||
4561 | MAX_EXP = exp; | ||
4562 | return arr; | ||
4563 | }; | ||
4564 | |||
4565 | |||
4566 | /* | ||
4567 | * Return the value of this BigNumber converted to a number primitive. | ||
4568 | */ | ||
4569 | P.toNumber = function () { | ||
4570 | return +this; | ||
4571 | }; | ||
4572 | |||
4573 | |||
4574 | /* | ||
4575 | * Return a BigNumber whose value is the value of this BigNumber raised to the power n. | ||
4576 | * If m is present, return the result modulo m. | ||
4577 | * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE. | ||
4578 | * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using | ||
4579 | * ROUNDING_MODE. | ||
4580 | * | ||
4581 | * The modular power operation works efficiently when x, n, and m are positive integers, | ||
4582 | * otherwise it is equivalent to calculating x.toPower(n).modulo(m) (with POW_PRECISION 0). | ||
4583 | * | ||
4584 | * n {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive. | ||
4585 | * [m] {number|string|BigNumber} The modulus. | ||
4586 | * | ||
4587 | * 'pow() exponent not an integer: {n}' | ||
4588 | * 'pow() exponent out of range: {n}' | ||
4589 | * | ||
4590 | * Performs 54 loop iterations for n of 9007199254740991. | ||
4591 | */ | ||
4592 | P.toPower = P.pow = function ( n, m ) { | ||
4593 | var k, y, z, | ||
4594 | i = mathfloor( n < 0 ? -n : +n ), | ||
4595 | x = this; | ||
4596 | |||
4597 | if ( m != null ) { | ||
4598 | id = 23; | ||
4599 | m = new BigNumber(m); | ||
4600 | } | ||
4601 | |||
4602 | // Pass ±Infinity to Math.pow if exponent is out of range. | ||
4603 | if ( !isValidInt( n, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER, 23, 'exponent' ) && | ||
4604 | ( !isFinite(n) || i > MAX_SAFE_INTEGER && ( n /= 0 ) || | ||
4605 | parseFloat(n) != n && !( n = NaN ) ) || n == 0 ) { | ||
4606 | k = Math.pow( +x, n ); | ||
4607 | return new BigNumber( m ? k % m : k ); | ||
4608 | } | ||
4609 | |||
4610 | if (m) { | ||
4611 | if ( n > 1 && x.gt(ONE) && x.isInt() && m.gt(ONE) && m.isInt() ) { | ||
4612 | x = x.mod(m); | ||
4613 | } else { | ||
4614 | z = m; | ||
4615 | |||
4616 | // Nullify m so only a single mod operation is performed at the end. | ||
4617 | m = null; | ||
4618 | } | ||
4619 | } else if (POW_PRECISION) { | ||
4620 | |||
4621 | // Truncating each coefficient array to a length of k after each multiplication | ||
4622 | // equates to truncating significant digits to POW_PRECISION + [28, 41], | ||
4623 | // i.e. there will be a minimum of 28 guard digits retained. | ||
4624 | // (Using + 1.5 would give [9, 21] guard digits.) | ||
4625 | k = mathceil( POW_PRECISION / LOG_BASE + 2 ); | ||
4626 | } | ||
4627 | |||
4628 | y = new BigNumber(ONE); | ||
4629 | |||
4630 | for ( ; ; ) { | ||
4631 | if ( i % 2 ) { | ||
4632 | y = y.times(x); | ||
4633 | if ( !y.c ) break; | ||
4634 | if (k) { | ||
4635 | if ( y.c.length > k ) y.c.length = k; | ||
4636 | } else if (m) { | ||
4637 | y = y.mod(m); | ||
4638 | } | ||
4639 | } | ||
4640 | |||
4641 | i = mathfloor( i / 2 ); | ||
4642 | if ( !i ) break; | ||
4643 | x = x.times(x); | ||
4644 | if (k) { | ||
4645 | if ( x.c && x.c.length > k ) x.c.length = k; | ||
4646 | } else if (m) { | ||
4647 | x = x.mod(m); | ||
4648 | } | ||
4649 | } | ||
4650 | |||
4651 | if (m) return y; | ||
4652 | if ( n < 0 ) y = ONE.div(y); | ||
4653 | |||
4654 | return z ? y.mod(z) : k ? round( y, POW_PRECISION, ROUNDING_MODE ) : y; | ||
4655 | }; | ||
4656 | |||
4657 | |||
4658 | /* | ||
4659 | * Return a string representing the value of this BigNumber rounded to sd significant digits | ||
4660 | * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits | ||
4661 | * necessary to represent the integer part of the value in fixed-point notation, then use | ||
4662 | * exponential notation. | ||
4663 | * | ||
4664 | * [sd] {number} Significant digits. Integer, 1 to MAX inclusive. | ||
4665 | * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive. | ||
4666 | * | ||
4667 | * 'toPrecision() precision not an integer: {sd}' | ||
4668 | * 'toPrecision() precision out of range: {sd}' | ||
4669 | * 'toPrecision() rounding mode not an integer: {rm}' | ||
4670 | * 'toPrecision() rounding mode out of range: {rm}' | ||
4671 | */ | ||
4672 | P.toPrecision = function ( sd, rm ) { | ||
4673 | return format( this, sd != null && isValidInt( sd, 1, MAX, 24, 'precision' ) | ||
4674 | ? sd | 0 : null, rm, 24 ); | ||
4675 | }; | ||
4676 | |||
4677 | |||
4678 | /* | ||
4679 | * Return a string representing the value of this BigNumber in base b, or base 10 if b is | ||
4680 | * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and | ||
4681 | * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent | ||
4682 | * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than | ||
4683 | * TO_EXP_NEG, return exponential notation. | ||
4684 | * | ||
4685 | * [b] {number} Integer, 2 to 64 inclusive. | ||
4686 | * | ||
4687 | * 'toString() base not an integer: {b}' | ||
4688 | * 'toString() base out of range: {b}' | ||
4689 | */ | ||
4690 | P.toString = function (b) { | ||
4691 | var str, | ||
4692 | n = this, | ||
4693 | s = n.s, | ||
4694 | e = n.e; | ||
4695 | |||
4696 | // Infinity or NaN? | ||
4697 | if ( e === null ) { | ||
4698 | |||
4699 | if (s) { | ||
4700 | str = 'Infinity'; | ||
4701 | if ( s < 0 ) str = '-' + str; | ||
4702 | } else { | ||
4703 | str = 'NaN'; | ||
4704 | } | ||
4705 | } else { | ||
4706 | str = coeffToString( n.c ); | ||
4707 | |||
4708 | if ( b == null || !isValidInt( b, 2, 64, 25, 'base' ) ) { | ||
4709 | str = e <= TO_EXP_NEG || e >= TO_EXP_POS | ||
4710 | ? toExponential( str, e ) | ||
4711 | : toFixedPoint( str, e ); | ||
4712 | } else { | ||
4713 | str = convertBase( toFixedPoint( str, e ), b | 0, 10, s ); | ||
4714 | } | ||
4715 | |||
4716 | if ( s < 0 && n.c[0] ) str = '-' + str; | ||
4717 | } | ||
4718 | |||
4719 | return str; | ||
4720 | }; | ||
4721 | |||
4722 | |||
4723 | /* | ||
4724 | * Return a new BigNumber whose value is the value of this BigNumber truncated to a whole | ||
4725 | * number. | ||
4726 | */ | ||
4727 | P.truncated = P.trunc = function () { | ||
4728 | return round( new BigNumber(this), this.e + 1, 1 ); | ||
4729 | }; | ||
4730 | |||
4731 | |||
4732 | /* | ||
4733 | * Return as toString, but do not accept a base argument, and include the minus sign for | ||
4734 | * negative zero. | ||
4735 | */ | ||
4736 | P.valueOf = P.toJSON = function () { | ||
4737 | var str, | ||
4738 | n = this, | ||
4739 | e = n.e; | ||
4740 | |||
4741 | if ( e === null ) return n.toString(); | ||
4742 | |||
4743 | str = coeffToString( n.c ); | ||
4744 | |||
4745 | str = e <= TO_EXP_NEG || e >= TO_EXP_POS | ||
4746 | ? toExponential( str, e ) | ||
4747 | : toFixedPoint( str, e ); | ||
4748 | |||
4749 | return n.s < 0 ? '-' + str : str; | ||
4750 | }; | ||
4751 | |||
4752 | |||
4753 | P.isBigNumber = true; | ||
4754 | |||
4755 | if ( config != null ) BigNumber.config(config); | ||
4756 | |||
4757 | return BigNumber; | ||
4758 | } | ||
4759 | |||
4760 | |||
4761 | // PRIVATE HELPER FUNCTIONS | ||
4762 | |||
4763 | |||
4764 | function bitFloor(n) { | ||
4765 | var i = n | 0; | ||
4766 | return n > 0 || n === i ? i : i - 1; | ||
4767 | } | ||
4768 | |||
4769 | |||
4770 | // Return a coefficient array as a string of base 10 digits. | ||
4771 | function coeffToString(a) { | ||
4772 | var s, z, | ||
4773 | i = 1, | ||
4774 | j = a.length, | ||
4775 | r = a[0] + ''; | ||
4776 | |||
4777 | for ( ; i < j; ) { | ||
4778 | s = a[i++] + ''; | ||
4779 | z = LOG_BASE - s.length; | ||
4780 | for ( ; z--; s = '0' + s ); | ||
4781 | r += s; | ||
4782 | } | ||
4783 | |||
4784 | // Determine trailing zeros. | ||
4785 | for ( j = r.length; r.charCodeAt(--j) === 48; ); | ||
4786 | return r.slice( 0, j + 1 || 1 ); | ||
4787 | } | ||
4788 | |||
4789 | |||
4790 | // Compare the value of BigNumbers x and y. | ||
4791 | function compare( x, y ) { | ||
4792 | var a, b, | ||
4793 | xc = x.c, | ||
4794 | yc = y.c, | ||
4795 | i = x.s, | ||
4796 | j = y.s, | ||
4797 | k = x.e, | ||
4798 | l = y.e; | ||
4799 | |||
4800 | // Either NaN? | ||
4801 | if ( !i || !j ) return null; | ||
4802 | |||
4803 | a = xc && !xc[0]; | ||
4804 | b = yc && !yc[0]; | ||
4805 | |||
4806 | // Either zero? | ||
4807 | if ( a || b ) return a ? b ? 0 : -j : i; | ||
4808 | |||
4809 | // Signs differ? | ||
4810 | if ( i != j ) return i; | ||
4811 | |||
4812 | a = i < 0; | ||
4813 | b = k == l; | ||
4814 | |||
4815 | // Either Infinity? | ||
4816 | if ( !xc || !yc ) return b ? 0 : !xc ^ a ? 1 : -1; | ||
4817 | |||
4818 | // Compare exponents. | ||
4819 | if ( !b ) return k > l ^ a ? 1 : -1; | ||
4820 | |||
4821 | j = ( k = xc.length ) < ( l = yc.length ) ? k : l; | ||
4822 | |||
4823 | // Compare digit by digit. | ||
4824 | for ( i = 0; i < j; i++ ) if ( xc[i] != yc[i] ) return xc[i] > yc[i] ^ a ? 1 : -1; | ||
4825 | |||
4826 | // Compare lengths. | ||
4827 | return k == l ? 0 : k > l ^ a ? 1 : -1; | ||
4828 | } | ||
4829 | |||
4830 | |||
4831 | /* | ||
4832 | * Return true if n is a valid number in range, otherwise false. | ||
4833 | * Use for argument validation when ERRORS is false. | ||
4834 | * Note: parseInt('1e+1') == 1 but parseFloat('1e+1') == 10. | ||
4835 | */ | ||
4836 | function intValidatorNoErrors( n, min, max ) { | ||
4837 | return ( n = truncate(n) ) >= min && n <= max; | ||
4838 | } | ||
4839 | |||
4840 | |||
4841 | function isArray(obj) { | ||
4842 | return Object.prototype.toString.call(obj) == '[object Array]'; | ||
4843 | } | ||
4844 | |||
4845 | |||
4846 | /* | ||
4847 | * Convert string of baseIn to an array of numbers of baseOut. | ||
4848 | * Eg. convertBase('255', 10, 16) returns [15, 15]. | ||
4849 | * Eg. convertBase('ff', 16, 10) returns [2, 5, 5]. | ||
4850 | */ | ||
4851 | function toBaseOut( str, baseIn, baseOut ) { | ||
4852 | var j, | ||
4853 | arr = [0], | ||
4854 | arrL, | ||
4855 | i = 0, | ||
4856 | len = str.length; | ||
4857 | |||
4858 | for ( ; i < len; ) { | ||
4859 | for ( arrL = arr.length; arrL--; arr[arrL] *= baseIn ); | ||
4860 | arr[ j = 0 ] += ALPHABET.indexOf( str.charAt( i++ ) ); | ||
4861 | |||
4862 | for ( ; j < arr.length; j++ ) { | ||
4863 | |||
4864 | if ( arr[j] > baseOut - 1 ) { | ||
4865 | if ( arr[j + 1] == null ) arr[j + 1] = 0; | ||
4866 | arr[j + 1] += arr[j] / baseOut | 0; | ||
4867 | arr[j] %= baseOut; | ||
4868 | } | ||
4869 | } | ||
4870 | } | ||
4871 | |||
4872 | return arr.reverse(); | ||
4873 | } | ||
4874 | |||
4875 | |||
4876 | function toExponential( str, e ) { | ||
4877 | return ( str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str ) + | ||
4878 | ( e < 0 ? 'e' : 'e+' ) + e; | ||
4879 | } | ||
4880 | |||
4881 | |||
4882 | function toFixedPoint( str, e ) { | ||
4883 | var len, z; | ||
4884 | |||
4885 | // Negative exponent? | ||
4886 | if ( e < 0 ) { | ||
4887 | |||
4888 | // Prepend zeros. | ||
4889 | for ( z = '0.'; ++e; z += '0' ); | ||
4890 | str = z + str; | ||
4891 | |||
4892 | // Positive exponent | ||
4893 | } else { | ||
4894 | len = str.length; | ||
4895 | |||
4896 | // Append zeros. | ||
4897 | if ( ++e > len ) { | ||
4898 | for ( z = '0', e -= len; --e; z += '0' ); | ||
4899 | str += z; | ||
4900 | } else if ( e < len ) { | ||
4901 | str = str.slice( 0, e ) + '.' + str.slice(e); | ||
4902 | } | ||
4903 | } | ||
4904 | |||
4905 | return str; | ||
4906 | } | ||
4907 | |||
4908 | |||
4909 | function truncate(n) { | ||
4910 | n = parseFloat(n); | ||
4911 | return n < 0 ? mathceil(n) : mathfloor(n); | ||
4912 | } | ||
4913 | |||
4914 | |||
4915 | // EXPORT | ||
4916 | |||
4917 | |||
4918 | BigNumber = constructorFactory(); | ||
4919 | BigNumber['default'] = BigNumber.BigNumber = BigNumber; | ||
4920 | |||
4921 | |||
4922 | // AMD. | ||
4923 | if ( typeof define == 'function' && define.amd ) { | ||
4924 | define( function () { return BigNumber; } ); | ||
4925 | |||
4926 | // Node.js and other environments that support module.exports. | ||
4927 | } else if ( typeof module != 'undefined' && module.exports ) { | ||
4928 | module.exports = BigNumber; | ||
4929 | |||
4930 | // Browser. | ||
4931 | } else { | ||
4932 | if ( !globalObj ) globalObj = typeof self != 'undefined' ? self : Function('return this')(); | ||
4933 | globalObj.BigNumber = BigNumber; | ||
4934 | } | ||
4935 | })(this); | ||
4936 | |||
4937 | },{}],18:[function(require,module,exports){ | ||
4938 | (function (module, exports) { | ||
4939 | 'use strict'; | ||
4940 | |||
4941 | // Utils | ||
4942 | function assert (val, msg) { | ||
4943 | if (!val) throw new Error(msg || 'Assertion failed'); | ||
4944 | } | ||
4945 | |||
4946 | // Could use `inherits` module, but don't want to move from single file | ||
4947 | // architecture yet. | ||
4948 | function inherits (ctor, superCtor) { | ||
4949 | ctor.super_ = superCtor; | ||
4950 | var TempCtor = function () {}; | ||
4951 | TempCtor.prototype = superCtor.prototype; | ||
4952 | ctor.prototype = new TempCtor(); | ||
4953 | ctor.prototype.constructor = ctor; | ||
4954 | } | ||
4955 | |||
4956 | // BN | ||
4957 | |||
4958 | function BN (number, base, endian) { | ||
4959 | if (BN.isBN(number)) { | ||
4960 | return number; | ||
4961 | } | ||
4962 | |||
4963 | this.negative = 0; | ||
4964 | this.words = null; | ||
4965 | this.length = 0; | ||
4966 | |||
4967 | // Reduction context | ||
4968 | this.red = null; | ||
4969 | |||
4970 | if (number !== null) { | ||
4971 | if (base === 'le' || base === 'be') { | ||
4972 | endian = base; | ||
4973 | base = 10; | ||
4974 | } | ||
4975 | |||
4976 | this._init(number || 0, base || 10, endian || 'be'); | ||
4977 | } | ||
4978 | } | ||
4979 | if (typeof module === 'object') { | ||
4980 | module.exports = BN; | ||
4981 | } else { | ||
4982 | exports.BN = BN; | ||
4983 | } | ||
4984 | |||
4985 | BN.BN = BN; | ||
4986 | BN.wordSize = 26; | ||
4987 | |||
4988 | var Buffer; | ||
4989 | try { | ||
4990 | Buffer = require('buffer').Buffer; | ||
4991 | } catch (e) { | ||
4992 | } | ||
4993 | |||
4994 | BN.isBN = function isBN (num) { | ||
4995 | if (num instanceof BN) { | ||
4996 | return true; | ||
4997 | } | ||
4998 | |||
4999 | return num !== null && typeof num === 'object' && | ||
5000 | num.constructor.wordSize === BN.wordSize && Array.isArray(num.words); | ||
5001 | }; | ||
5002 | |||
5003 | BN.max = function max (left, right) { | ||
5004 | if (left.cmp(right) > 0) return left; | ||
5005 | return right; | ||
5006 | }; | ||
5007 | |||
5008 | BN.min = function min (left, right) { | ||
5009 | if (left.cmp(right) < 0) return left; | ||
5010 | return right; | ||
5011 | }; | ||
5012 | |||
5013 | BN.prototype._init = function init (number, base, endian) { | ||
5014 | if (typeof number === 'number') { | ||
5015 | return this._initNumber(number, base, endian); | ||
5016 | } | ||
5017 | |||
5018 | if (typeof number === 'object') { | ||
5019 | return this._initArray(number, base, endian); | ||
5020 | } | ||
5021 | |||
5022 | if (base === 'hex') { | ||
5023 | base = 16; | ||
5024 | } | ||
5025 | assert(base === (base | 0) && base >= 2 && base <= 36); | ||
5026 | |||
5027 | number = number.toString().replace(/\s+/g, ''); | ||
5028 | var start = 0; | ||
5029 | if (number[0] === '-') { | ||
5030 | start++; | ||
5031 | } | ||
5032 | |||
5033 | if (base === 16) { | ||
5034 | this._parseHex(number, start); | ||
5035 | } else { | ||
5036 | this._parseBase(number, base, start); | ||
5037 | } | ||
5038 | |||
5039 | if (number[0] === '-') { | ||
5040 | this.negative = 1; | ||
5041 | } | ||
5042 | |||
5043 | this.strip(); | ||
5044 | |||
5045 | if (endian !== 'le') return; | ||
5046 | |||
5047 | this._initArray(this.toArray(), base, endian); | ||
5048 | }; | ||
5049 | |||
5050 | BN.prototype._initNumber = function _initNumber (number, base, endian) { | ||
5051 | if (number < 0) { | ||
5052 | this.negative = 1; | ||
5053 | number = -number; | ||
5054 | } | ||
5055 | if (number < 0x4000000) { | ||
5056 | this.words = [ number & 0x3ffffff ]; | ||
5057 | this.length = 1; | ||
5058 | } else if (number < 0x10000000000000) { | ||
5059 | this.words = [ | ||
5060 | number & 0x3ffffff, | ||
5061 | (number / 0x4000000) & 0x3ffffff | ||
5062 | ]; | ||
5063 | this.length = 2; | ||
5064 | } else { | ||
5065 | assert(number < 0x20000000000000); // 2 ^ 53 (unsafe) | ||
5066 | this.words = [ | ||
5067 | number & 0x3ffffff, | ||
5068 | (number / 0x4000000) & 0x3ffffff, | ||
5069 | 1 | ||
5070 | ]; | ||
5071 | this.length = 3; | ||
5072 | } | ||
5073 | |||
5074 | if (endian !== 'le') return; | ||
5075 | |||
5076 | // Reverse the bytes | ||
5077 | this._initArray(this.toArray(), base, endian); | ||
5078 | }; | ||
5079 | |||
5080 | BN.prototype._initArray = function _initArray (number, base, endian) { | ||
5081 | // Perhaps a Uint8Array | ||
5082 | assert(typeof number.length === 'number'); | ||
5083 | if (number.length <= 0) { | ||
5084 | this.words = [ 0 ]; | ||
5085 | this.length = 1; | ||
5086 | return this; | ||
5087 | } | ||
5088 | |||
5089 | this.length = Math.ceil(number.length / 3); | ||
5090 | this.words = new Array(this.length); | ||
5091 | for (var i = 0; i < this.length; i++) { | ||
5092 | this.words[i] = 0; | ||
5093 | } | ||
5094 | |||
5095 | var j, w; | ||
5096 | var off = 0; | ||
5097 | if (endian === 'be') { | ||
5098 | for (i = number.length - 1, j = 0; i >= 0; i -= 3) { | ||
5099 | w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16); | ||
5100 | this.words[j] |= (w << off) & 0x3ffffff; | ||
5101 | this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff; | ||
5102 | off += 24; | ||
5103 | if (off >= 26) { | ||
5104 | off -= 26; | ||
5105 | j++; | ||
5106 | } | ||
5107 | } | ||
5108 | } else if (endian === 'le') { | ||
5109 | for (i = 0, j = 0; i < number.length; i += 3) { | ||
5110 | w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16); | ||
5111 | this.words[j] |= (w << off) & 0x3ffffff; | ||
5112 | this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff; | ||
5113 | off += 24; | ||
5114 | if (off >= 26) { | ||
5115 | off -= 26; | ||
5116 | j++; | ||
5117 | } | ||
5118 | } | ||
5119 | } | ||
5120 | return this.strip(); | ||
5121 | }; | ||
5122 | |||
5123 | function parseHex (str, start, end) { | ||
5124 | var r = 0; | ||
5125 | var len = Math.min(str.length, end); | ||
5126 | for (var i = start; i < len; i++) { | ||
5127 | var c = str.charCodeAt(i) - 48; | ||
5128 | |||
5129 | r <<= 4; | ||
5130 | |||
5131 | // 'a' - 'f' | ||
5132 | if (c >= 49 && c <= 54) { | ||
5133 | r |= c - 49 + 0xa; | ||
5134 | |||
5135 | // 'A' - 'F' | ||
5136 | } else if (c >= 17 && c <= 22) { | ||
5137 | r |= c - 17 + 0xa; | ||
5138 | |||
5139 | // '0' - '9' | ||
5140 | } else { | ||
5141 | r |= c & 0xf; | ||
5142 | } | ||
5143 | } | ||
5144 | return r; | ||
5145 | } | ||
5146 | |||
5147 | BN.prototype._parseHex = function _parseHex (number, start) { | ||
5148 | // Create possibly bigger array to ensure that it fits the number | ||
5149 | this.length = Math.ceil((number.length - start) / 6); | ||
5150 | this.words = new Array(this.length); | ||
5151 | for (var i = 0; i < this.length; i++) { | ||
5152 | this.words[i] = 0; | ||
5153 | } | ||
5154 | |||
5155 | var j, w; | ||
5156 | // Scan 24-bit chunks and add them to the number | ||
5157 | var off = 0; | ||
5158 | for (i = number.length - 6, j = 0; i >= start; i -= 6) { | ||
5159 | w = parseHex(number, i, i + 6); | ||
5160 | this.words[j] |= (w << off) & 0x3ffffff; | ||
5161 | // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb | ||
5162 | this.words[j + 1] |= w >>> (26 - off) & 0x3fffff; | ||
5163 | off += 24; | ||
5164 | if (off >= 26) { | ||
5165 | off -= 26; | ||
5166 | j++; | ||
5167 | } | ||
5168 | } | ||
5169 | if (i + 6 !== start) { | ||
5170 | w = parseHex(number, start, i + 6); | ||
5171 | this.words[j] |= (w << off) & 0x3ffffff; | ||
5172 | this.words[j + 1] |= w >>> (26 - off) & 0x3fffff; | ||
5173 | } | ||
5174 | this.strip(); | ||
5175 | }; | ||
5176 | |||
5177 | function parseBase (str, start, end, mul) { | ||
5178 | var r = 0; | ||
5179 | var len = Math.min(str.length, end); | ||
5180 | for (var i = start; i < len; i++) { | ||
5181 | var c = str.charCodeAt(i) - 48; | ||
5182 | |||
5183 | r *= mul; | ||
5184 | |||
5185 | // 'a' | ||
5186 | if (c >= 49) { | ||
5187 | r += c - 49 + 0xa; | ||
5188 | |||
5189 | // 'A' | ||
5190 | } else if (c >= 17) { | ||
5191 | r += c - 17 + 0xa; | ||
5192 | |||
5193 | // '0' - '9' | ||
5194 | } else { | ||
5195 | r += c; | ||
5196 | } | ||
5197 | } | ||
5198 | return r; | ||
5199 | } | ||
5200 | |||
5201 | BN.prototype._parseBase = function _parseBase (number, base, start) { | ||
5202 | // Initialize as zero | ||
5203 | this.words = [ 0 ]; | ||
5204 | this.length = 1; | ||
5205 | |||
5206 | // Find length of limb in base | ||
5207 | for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) { | ||
5208 | limbLen++; | ||
5209 | } | ||
5210 | limbLen--; | ||
5211 | limbPow = (limbPow / base) | 0; | ||
5212 | |||
5213 | var total = number.length - start; | ||
5214 | var mod = total % limbLen; | ||
5215 | var end = Math.min(total, total - mod) + start; | ||
5216 | |||
5217 | var word = 0; | ||
5218 | for (var i = start; i < end; i += limbLen) { | ||
5219 | word = parseBase(number, i, i + limbLen, base); | ||
5220 | |||
5221 | this.imuln(limbPow); | ||
5222 | if (this.words[0] + word < 0x4000000) { | ||
5223 | this.words[0] += word; | ||
5224 | } else { | ||
5225 | this._iaddn(word); | ||
5226 | } | ||
5227 | } | ||
5228 | |||
5229 | if (mod !== 0) { | ||
5230 | var pow = 1; | ||
5231 | word = parseBase(number, i, number.length, base); | ||
5232 | |||
5233 | for (i = 0; i < mod; i++) { | ||
5234 | pow *= base; | ||
5235 | } | ||
5236 | |||
5237 | this.imuln(pow); | ||
5238 | if (this.words[0] + word < 0x4000000) { | ||
5239 | this.words[0] += word; | ||
5240 | } else { | ||
5241 | this._iaddn(word); | ||
5242 | } | ||
5243 | } | ||
5244 | }; | ||
5245 | |||
5246 | BN.prototype.copy = function copy (dest) { | ||
5247 | dest.words = new Array(this.length); | ||
5248 | for (var i = 0; i < this.length; i++) { | ||
5249 | dest.words[i] = this.words[i]; | ||
5250 | } | ||
5251 | dest.length = this.length; | ||
5252 | dest.negative = this.negative; | ||
5253 | dest.red = this.red; | ||
5254 | }; | ||
5255 | |||
5256 | BN.prototype.clone = function clone () { | ||
5257 | var r = new BN(null); | ||
5258 | this.copy(r); | ||
5259 | return r; | ||
5260 | }; | ||
5261 | |||
5262 | BN.prototype._expand = function _expand (size) { | ||
5263 | while (this.length < size) { | ||
5264 | this.words[this.length++] = 0; | ||
5265 | } | ||
5266 | return this; | ||
5267 | }; | ||
5268 | |||
5269 | // Remove leading `0` from `this` | ||
5270 | BN.prototype.strip = function strip () { | ||
5271 | while (this.length > 1 && this.words[this.length - 1] === 0) { | ||
5272 | this.length--; | ||
5273 | } | ||
5274 | return this._normSign(); | ||
5275 | }; | ||
5276 | |||
5277 | BN.prototype._normSign = function _normSign () { | ||
5278 | // -0 = 0 | ||
5279 | if (this.length === 1 && this.words[0] === 0) { | ||
5280 | this.negative = 0; | ||
5281 | } | ||
5282 | return this; | ||
5283 | }; | ||
5284 | |||
5285 | BN.prototype.inspect = function inspect () { | ||
5286 | return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>'; | ||
5287 | }; | ||
5288 | |||
5289 | /* | ||
5290 | |||
5291 | var zeros = []; | ||
5292 | var groupSizes = []; | ||
5293 | var groupBases = []; | ||
5294 | |||
5295 | var s = ''; | ||
5296 | var i = -1; | ||
5297 | while (++i < BN.wordSize) { | ||
5298 | zeros[i] = s; | ||
5299 | s += '0'; | ||
5300 | } | ||
5301 | groupSizes[0] = 0; | ||
5302 | groupSizes[1] = 0; | ||
5303 | groupBases[0] = 0; | ||
5304 | groupBases[1] = 0; | ||
5305 | var base = 2 - 1; | ||
5306 | while (++base < 36 + 1) { | ||
5307 | var groupSize = 0; | ||
5308 | var groupBase = 1; | ||
5309 | while (groupBase < (1 << BN.wordSize) / base) { | ||
5310 | groupBase *= base; | ||
5311 | groupSize += 1; | ||
5312 | } | ||
5313 | groupSizes[base] = groupSize; | ||
5314 | groupBases[base] = groupBase; | ||
5315 | } | ||
5316 | |||
5317 | */ | ||
5318 | |||
5319 | var zeros = [ | ||
5320 | '', | ||
5321 | '0', | ||
5322 | '00', | ||
5323 | '000', | ||
5324 | '0000', | ||
5325 | '00000', | ||
5326 | '000000', | ||
5327 | '0000000', | ||
5328 | '00000000', | ||
5329 | '000000000', | ||
5330 | '0000000000', | ||
5331 | '00000000000', | ||
5332 | '000000000000', | ||
5333 | '0000000000000', | ||
5334 | '00000000000000', | ||
5335 | '000000000000000', | ||
5336 | '0000000000000000', | ||
5337 | '00000000000000000', | ||
5338 | '000000000000000000', | ||
5339 | '0000000000000000000', | ||
5340 | '00000000000000000000', | ||
5341 | '000000000000000000000', | ||
5342 | '0000000000000000000000', | ||
5343 | '00000000000000000000000', | ||
5344 | '000000000000000000000000', | ||
5345 | '0000000000000000000000000' | ||
5346 | ]; | ||
5347 | |||
5348 | var groupSizes = [ | ||
5349 | 0, 0, | ||
5350 | 25, 16, 12, 11, 10, 9, 8, | ||
5351 | 8, 7, 7, 7, 7, 6, 6, | ||
5352 | 6, 6, 6, 6, 6, 5, 5, | ||
5353 | 5, 5, 5, 5, 5, 5, 5, | ||
5354 | 5, 5, 5, 5, 5, 5, 5 | ||
5355 | ]; | ||
5356 | |||
5357 | var groupBases = [ | ||
5358 | 0, 0, | ||
5359 | 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216, | ||
5360 | 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625, | ||
5361 | 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632, | ||
5362 | 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149, | ||
5363 | 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176 | ||
5364 | ]; | ||
5365 | |||
5366 | BN.prototype.toString = function toString (base, padding) { | ||
5367 | base = base || 10; | ||
5368 | padding = padding | 0 || 1; | ||
5369 | |||
5370 | var out; | ||
5371 | if (base === 16 || base === 'hex') { | ||
5372 | out = ''; | ||
5373 | var off = 0; | ||
5374 | var carry = 0; | ||
5375 | for (var i = 0; i < this.length; i++) { | ||
5376 | var w = this.words[i]; | ||
5377 | var word = (((w << off) | carry) & 0xffffff).toString(16); | ||
5378 | carry = (w >>> (24 - off)) & 0xffffff; | ||
5379 | if (carry !== 0 || i !== this.length - 1) { | ||
5380 | out = zeros[6 - word.length] + word + out; | ||
5381 | } else { | ||
5382 | out = word + out; | ||
5383 | } | ||
5384 | off += 2; | ||
5385 | if (off >= 26) { | ||
5386 | off -= 26; | ||
5387 | i--; | ||
5388 | } | ||
5389 | } | ||
5390 | if (carry !== 0) { | ||
5391 | out = carry.toString(16) + out; | ||
5392 | } | ||
5393 | while (out.length % padding !== 0) { | ||
5394 | out = '0' + out; | ||
5395 | } | ||
5396 | if (this.negative !== 0) { | ||
5397 | out = '-' + out; | ||
5398 | } | ||
5399 | return out; | ||
5400 | } | ||
5401 | |||
5402 | if (base === (base | 0) && base >= 2 && base <= 36) { | ||
5403 | // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base)); | ||
5404 | var groupSize = groupSizes[base]; | ||
5405 | // var groupBase = Math.pow(base, groupSize); | ||
5406 | var groupBase = groupBases[base]; | ||
5407 | out = ''; | ||
5408 | var c = this.clone(); | ||
5409 | c.negative = 0; | ||
5410 | while (!c.isZero()) { | ||
5411 | var r = c.modn(groupBase).toString(base); | ||
5412 | c = c.idivn(groupBase); | ||
5413 | |||
5414 | if (!c.isZero()) { | ||
5415 | out = zeros[groupSize - r.length] + r + out; | ||
5416 | } else { | ||
5417 | out = r + out; | ||
5418 | } | ||
5419 | } | ||
5420 | if (this.isZero()) { | ||
5421 | out = '0' + out; | ||
5422 | } | ||
5423 | while (out.length % padding !== 0) { | ||
5424 | out = '0' + out; | ||
5425 | } | ||
5426 | if (this.negative !== 0) { | ||
5427 | out = '-' + out; | ||
5428 | } | ||
5429 | return out; | ||
5430 | } | ||
5431 | |||
5432 | assert(false, 'Base should be between 2 and 36'); | ||
5433 | }; | ||
5434 | |||
5435 | BN.prototype.toNumber = function toNumber () { | ||
5436 | var ret = this.words[0]; | ||
5437 | if (this.length === 2) { | ||
5438 | ret += this.words[1] * 0x4000000; | ||
5439 | } else if (this.length === 3 && this.words[2] === 0x01) { | ||
5440 | // NOTE: at this stage it is known that the top bit is set | ||
5441 | ret += 0x10000000000000 + (this.words[1] * 0x4000000); | ||
5442 | } else if (this.length > 2) { | ||
5443 | assert(false, 'Number can only safely store up to 53 bits'); | ||
5444 | } | ||
5445 | return (this.negative !== 0) ? -ret : ret; | ||
5446 | }; | ||
5447 | |||
5448 | BN.prototype.toJSON = function toJSON () { | ||
5449 | return this.toString(16); | ||
5450 | }; | ||
5451 | |||
5452 | BN.prototype.toBuffer = function toBuffer (endian, length) { | ||
5453 | assert(typeof Buffer !== 'undefined'); | ||
5454 | return this.toArrayLike(Buffer, endian, length); | ||
5455 | }; | ||
5456 | |||
5457 | BN.prototype.toArray = function toArray (endian, length) { | ||
5458 | return this.toArrayLike(Array, endian, length); | ||
5459 | }; | ||
5460 | |||
5461 | BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) { | ||
5462 | var byteLength = this.byteLength(); | ||
5463 | var reqLength = length || Math.max(1, byteLength); | ||
5464 | assert(byteLength <= reqLength, 'byte array longer than desired length'); | ||
5465 | assert(reqLength > 0, 'Requested array length <= 0'); | ||
5466 | |||
5467 | this.strip(); | ||
5468 | var littleEndian = endian === 'le'; | ||
5469 | var res = new ArrayType(reqLength); | ||
5470 | |||
5471 | var b, i; | ||
5472 | var q = this.clone(); | ||
5473 | if (!littleEndian) { | ||
5474 | // Assume big-endian | ||
5475 | for (i = 0; i < reqLength - byteLength; i++) { | ||
5476 | res[i] = 0; | ||
5477 | } | ||
5478 | |||
5479 | for (i = 0; !q.isZero(); i++) { | ||
5480 | b = q.andln(0xff); | ||
5481 | q.iushrn(8); | ||
5482 | |||
5483 | res[reqLength - i - 1] = b; | ||
5484 | } | ||
5485 | } else { | ||
5486 | for (i = 0; !q.isZero(); i++) { | ||
5487 | b = q.andln(0xff); | ||
5488 | q.iushrn(8); | ||
5489 | |||
5490 | res[i] = b; | ||
5491 | } | ||
5492 | |||
5493 | for (; i < reqLength; i++) { | ||
5494 | res[i] = 0; | ||
5495 | } | ||
5496 | } | ||
5497 | |||
5498 | return res; | ||
5499 | }; | ||
5500 | |||
5501 | if (Math.clz32) { | ||
5502 | BN.prototype._countBits = function _countBits (w) { | ||
5503 | return 32 - Math.clz32(w); | ||
5504 | }; | ||
5505 | } else { | ||
5506 | BN.prototype._countBits = function _countBits (w) { | ||
5507 | var t = w; | ||
5508 | var r = 0; | ||
5509 | if (t >= 0x1000) { | ||
5510 | r += 13; | ||
5511 | t >>>= 13; | ||
5512 | } | ||
5513 | if (t >= 0x40) { | ||
5514 | r += 7; | ||
5515 | t >>>= 7; | ||
5516 | } | ||
5517 | if (t >= 0x8) { | ||
5518 | r += 4; | ||
5519 | t >>>= 4; | ||
5520 | } | ||
5521 | if (t >= 0x02) { | ||
5522 | r += 2; | ||
5523 | t >>>= 2; | ||
5524 | } | ||
5525 | return r + t; | ||
5526 | }; | ||
5527 | } | ||
5528 | |||
5529 | BN.prototype._zeroBits = function _zeroBits (w) { | ||
5530 | // Short-cut | ||
5531 | if (w === 0) return 26; | ||
5532 | |||
5533 | var t = w; | ||
5534 | var r = 0; | ||
5535 | if ((t & 0x1fff) === 0) { | ||
5536 | r += 13; | ||
5537 | t >>>= 13; | ||
5538 | } | ||
5539 | if ((t & 0x7f) === 0) { | ||
5540 | r += 7; | ||
5541 | t >>>= 7; | ||
5542 | } | ||
5543 | if ((t & 0xf) === 0) { | ||
5544 | r += 4; | ||
5545 | t >>>= 4; | ||
5546 | } | ||
5547 | if ((t & 0x3) === 0) { | ||
5548 | r += 2; | ||
5549 | t >>>= 2; | ||
5550 | } | ||
5551 | if ((t & 0x1) === 0) { | ||
5552 | r++; | ||
5553 | } | ||
5554 | return r; | ||
5555 | }; | ||
5556 | |||
5557 | // Return number of used bits in a BN | ||
5558 | BN.prototype.bitLength = function bitLength () { | ||
5559 | var w = this.words[this.length - 1]; | ||
5560 | var hi = this._countBits(w); | ||
5561 | return (this.length - 1) * 26 + hi; | ||
5562 | }; | ||
5563 | |||
5564 | function toBitArray (num) { | ||
5565 | var w = new Array(num.bitLength()); | ||
5566 | |||
5567 | for (var bit = 0; bit < w.length; bit++) { | ||
5568 | var off = (bit / 26) | 0; | ||
5569 | var wbit = bit % 26; | ||
5570 | |||
5571 | w[bit] = (num.words[off] & (1 << wbit)) >>> wbit; | ||
5572 | } | ||
5573 | |||
5574 | return w; | ||
5575 | } | ||
5576 | |||
5577 | // Number of trailing zero bits | ||
5578 | BN.prototype.zeroBits = function zeroBits () { | ||
5579 | if (this.isZero()) return 0; | ||
5580 | |||
5581 | var r = 0; | ||
5582 | for (var i = 0; i < this.length; i++) { | ||
5583 | var b = this._zeroBits(this.words[i]); | ||
5584 | r += b; | ||
5585 | if (b !== 26) break; | ||
5586 | } | ||
5587 | return r; | ||
5588 | }; | ||
5589 | |||
5590 | BN.prototype.byteLength = function byteLength () { | ||
5591 | return Math.ceil(this.bitLength() / 8); | ||
5592 | }; | ||
5593 | |||
5594 | BN.prototype.toTwos = function toTwos (width) { | ||
5595 | if (this.negative !== 0) { | ||
5596 | return this.abs().inotn(width).iaddn(1); | ||
5597 | } | ||
5598 | return this.clone(); | ||
5599 | }; | ||
5600 | |||
5601 | BN.prototype.fromTwos = function fromTwos (width) { | ||
5602 | if (this.testn(width - 1)) { | ||
5603 | return this.notn(width).iaddn(1).ineg(); | ||
5604 | } | ||
5605 | return this.clone(); | ||
5606 | }; | ||
5607 | |||
5608 | BN.prototype.isNeg = function isNeg () { | ||
5609 | return this.negative !== 0; | ||
5610 | }; | ||
5611 | |||
5612 | // Return negative clone of `this` | ||
5613 | BN.prototype.neg = function neg () { | ||
5614 | return this.clone().ineg(); | ||
5615 | }; | ||
5616 | |||
5617 | BN.prototype.ineg = function ineg () { | ||
5618 | if (!this.isZero()) { | ||
5619 | this.negative ^= 1; | ||
5620 | } | ||
5621 | |||
5622 | return this; | ||
5623 | }; | ||
5624 | |||
5625 | // Or `num` with `this` in-place | ||
5626 | BN.prototype.iuor = function iuor (num) { | ||
5627 | while (this.length < num.length) { | ||
5628 | this.words[this.length++] = 0; | ||
5629 | } | ||
5630 | |||
5631 | for (var i = 0; i < num.length; i++) { | ||
5632 | this.words[i] = this.words[i] | num.words[i]; | ||
5633 | } | ||
5634 | |||
5635 | return this.strip(); | ||
5636 | }; | ||
5637 | |||
5638 | BN.prototype.ior = function ior (num) { | ||
5639 | assert((this.negative | num.negative) === 0); | ||
5640 | return this.iuor(num); | ||
5641 | }; | ||
5642 | |||
5643 | // Or `num` with `this` | ||
5644 | BN.prototype.or = function or (num) { | ||
5645 | if (this.length > num.length) return this.clone().ior(num); | ||
5646 | return num.clone().ior(this); | ||
5647 | }; | ||
5648 | |||
5649 | BN.prototype.uor = function uor (num) { | ||
5650 | if (this.length > num.length) return this.clone().iuor(num); | ||
5651 | return num.clone().iuor(this); | ||
5652 | }; | ||
5653 | |||
5654 | // And `num` with `this` in-place | ||
5655 | BN.prototype.iuand = function iuand (num) { | ||
5656 | // b = min-length(num, this) | ||
5657 | var b; | ||
5658 | if (this.length > num.length) { | ||
5659 | b = num; | ||
5660 | } else { | ||
5661 | b = this; | ||
5662 | } | ||
5663 | |||
5664 | for (var i = 0; i < b.length; i++) { | ||
5665 | this.words[i] = this.words[i] & num.words[i]; | ||
5666 | } | ||
5667 | |||
5668 | this.length = b.length; | ||
5669 | |||
5670 | return this.strip(); | ||
5671 | }; | ||
5672 | |||
5673 | BN.prototype.iand = function iand (num) { | ||
5674 | assert((this.negative | num.negative) === 0); | ||
5675 | return this.iuand(num); | ||
5676 | }; | ||
5677 | |||
5678 | // And `num` with `this` | ||
5679 | BN.prototype.and = function and (num) { | ||
5680 | if (this.length > num.length) return this.clone().iand(num); | ||
5681 | return num.clone().iand(this); | ||
5682 | }; | ||
5683 | |||
5684 | BN.prototype.uand = function uand (num) { | ||
5685 | if (this.length > num.length) return this.clone().iuand(num); | ||
5686 | return num.clone().iuand(this); | ||
5687 | }; | ||
5688 | |||
5689 | // Xor `num` with `this` in-place | ||
5690 | BN.prototype.iuxor = function iuxor (num) { | ||
5691 | // a.length > b.length | ||
5692 | var a; | ||
5693 | var b; | ||
5694 | if (this.length > num.length) { | ||
5695 | a = this; | ||
5696 | b = num; | ||
5697 | } else { | ||
5698 | a = num; | ||
5699 | b = this; | ||
5700 | } | ||
5701 | |||
5702 | for (var i = 0; i < b.length; i++) { | ||
5703 | this.words[i] = a.words[i] ^ b.words[i]; | ||
5704 | } | ||
5705 | |||
5706 | if (this !== a) { | ||
5707 | for (; i < a.length; i++) { | ||
5708 | this.words[i] = a.words[i]; | ||
5709 | } | ||
5710 | } | ||
5711 | |||
5712 | this.length = a.length; | ||
5713 | |||
5714 | return this.strip(); | ||
5715 | }; | ||
5716 | |||
5717 | BN.prototype.ixor = function ixor (num) { | ||
5718 | assert((this.negative | num.negative) === 0); | ||
5719 | return this.iuxor(num); | ||
5720 | }; | ||
5721 | |||
5722 | // Xor `num` with `this` | ||
5723 | BN.prototype.xor = function xor (num) { | ||
5724 | if (this.length > num.length) return this.clone().ixor(num); | ||
5725 | return num.clone().ixor(this); | ||
5726 | }; | ||
5727 | |||
5728 | BN.prototype.uxor = function uxor (num) { | ||
5729 | if (this.length > num.length) return this.clone().iuxor(num); | ||
5730 | return num.clone().iuxor(this); | ||
5731 | }; | ||
5732 | |||
5733 | // Not ``this`` with ``width`` bitwidth | ||
5734 | BN.prototype.inotn = function inotn (width) { | ||
5735 | assert(typeof width === 'number' && width >= 0); | ||
5736 | |||
5737 | var bytesNeeded = Math.ceil(width / 26) | 0; | ||
5738 | var bitsLeft = width % 26; | ||
5739 | |||
5740 | // Extend the buffer with leading zeroes | ||
5741 | this._expand(bytesNeeded); | ||
5742 | |||
5743 | if (bitsLeft > 0) { | ||
5744 | bytesNeeded--; | ||
5745 | } | ||
5746 | |||
5747 | // Handle complete words | ||
5748 | for (var i = 0; i < bytesNeeded; i++) { | ||
5749 | this.words[i] = ~this.words[i] & 0x3ffffff; | ||
5750 | } | ||
5751 | |||
5752 | // Handle the residue | ||
5753 | if (bitsLeft > 0) { | ||
5754 | this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft)); | ||
5755 | } | ||
5756 | |||
5757 | // And remove leading zeroes | ||
5758 | return this.strip(); | ||
5759 | }; | ||
5760 | |||
5761 | BN.prototype.notn = function notn (width) { | ||
5762 | return this.clone().inotn(width); | ||
5763 | }; | ||
5764 | |||
5765 | // Set `bit` of `this` | ||
5766 | BN.prototype.setn = function setn (bit, val) { | ||
5767 | assert(typeof bit === 'number' && bit >= 0); | ||
5768 | |||
5769 | var off = (bit / 26) | 0; | ||
5770 | var wbit = bit % 26; | ||
5771 | |||
5772 | this._expand(off + 1); | ||
5773 | |||
5774 | if (val) { | ||
5775 | this.words[off] = this.words[off] | (1 << wbit); | ||
5776 | } else { | ||
5777 | this.words[off] = this.words[off] & ~(1 << wbit); | ||
5778 | } | ||
5779 | |||
5780 | return this.strip(); | ||
5781 | }; | ||
5782 | |||
5783 | // Add `num` to `this` in-place | ||
5784 | BN.prototype.iadd = function iadd (num) { | ||
5785 | var r; | ||
5786 | |||
5787 | // negative + positive | ||
5788 | if (this.negative !== 0 && num.negative === 0) { | ||
5789 | this.negative = 0; | ||
5790 | r = this.isub(num); | ||
5791 | this.negative ^= 1; | ||
5792 | return this._normSign(); | ||
5793 | |||
5794 | // positive + negative | ||
5795 | } else if (this.negative === 0 && num.negative !== 0) { | ||
5796 | num.negative = 0; | ||
5797 | r = this.isub(num); | ||
5798 | num.negative = 1; | ||
5799 | return r._normSign(); | ||
5800 | } | ||
5801 | |||
5802 | // a.length > b.length | ||
5803 | var a, b; | ||
5804 | if (this.length > num.length) { | ||
5805 | a = this; | ||
5806 | b = num; | ||
5807 | } else { | ||
5808 | a = num; | ||
5809 | b = this; | ||
5810 | } | ||
5811 | |||
5812 | var carry = 0; | ||
5813 | for (var i = 0; i < b.length; i++) { | ||
5814 | r = (a.words[i] | 0) + (b.words[i] | 0) + carry; | ||
5815 | this.words[i] = r & 0x3ffffff; | ||
5816 | carry = r >>> 26; | ||
5817 | } | ||
5818 | for (; carry !== 0 && i < a.length; i++) { | ||
5819 | r = (a.words[i] | 0) + carry; | ||
5820 | this.words[i] = r & 0x3ffffff; | ||
5821 | carry = r >>> 26; | ||
5822 | } | ||
5823 | |||
5824 | this.length = a.length; | ||
5825 | if (carry !== 0) { | ||
5826 | this.words[this.length] = carry; | ||
5827 | this.length++; | ||
5828 | // Copy the rest of the words | ||
5829 | } else if (a !== this) { | ||
5830 | for (; i < a.length; i++) { | ||
5831 | this.words[i] = a.words[i]; | ||
5832 | } | ||
5833 | } | ||
5834 | |||
5835 | return this; | ||
5836 | }; | ||
5837 | |||
5838 | // Add `num` to `this` | ||
5839 | BN.prototype.add = function add (num) { | ||
5840 | var res; | ||
5841 | if (num.negative !== 0 && this.negative === 0) { | ||
5842 | num.negative = 0; | ||
5843 | res = this.sub(num); | ||
5844 | num.negative ^= 1; | ||
5845 | return res; | ||
5846 | } else if (num.negative === 0 && this.negative !== 0) { | ||
5847 | this.negative = 0; | ||
5848 | res = num.sub(this); | ||
5849 | this.negative = 1; | ||
5850 | return res; | ||
5851 | } | ||
5852 | |||
5853 | if (this.length > num.length) return this.clone().iadd(num); | ||
5854 | |||
5855 | return num.clone().iadd(this); | ||
5856 | }; | ||
5857 | |||
5858 | // Subtract `num` from `this` in-place | ||
5859 | BN.prototype.isub = function isub (num) { | ||
5860 | // this - (-num) = this + num | ||
5861 | if (num.negative !== 0) { | ||
5862 | num.negative = 0; | ||
5863 | var r = this.iadd(num); | ||
5864 | num.negative = 1; | ||
5865 | return r._normSign(); | ||
5866 | |||
5867 | // -this - num = -(this + num) | ||
5868 | } else if (this.negative !== 0) { | ||
5869 | this.negative = 0; | ||
5870 | this.iadd(num); | ||
5871 | this.negative = 1; | ||
5872 | return this._normSign(); | ||
5873 | } | ||
5874 | |||
5875 | // At this point both numbers are positive | ||
5876 | var cmp = this.cmp(num); | ||
5877 | |||
5878 | // Optimization - zeroify | ||
5879 | if (cmp === 0) { | ||
5880 | this.negative = 0; | ||
5881 | this.length = 1; | ||
5882 | this.words[0] = 0; | ||
5883 | return this; | ||
5884 | } | ||
5885 | |||
5886 | // a > b | ||
5887 | var a, b; | ||
5888 | if (cmp > 0) { | ||
5889 | a = this; | ||
5890 | b = num; | ||
5891 | } else { | ||
5892 | a = num; | ||
5893 | b = this; | ||
5894 | } | ||
5895 | |||
5896 | var carry = 0; | ||
5897 | for (var i = 0; i < b.length; i++) { | ||
5898 | r = (a.words[i] | 0) - (b.words[i] | 0) + carry; | ||
5899 | carry = r >> 26; | ||
5900 | this.words[i] = r & 0x3ffffff; | ||
5901 | } | ||
5902 | for (; carry !== 0 && i < a.length; i++) { | ||
5903 | r = (a.words[i] | 0) + carry; | ||
5904 | carry = r >> 26; | ||
5905 | this.words[i] = r & 0x3ffffff; | ||
5906 | } | ||
5907 | |||
5908 | // Copy rest of the words | ||
5909 | if (carry === 0 && i < a.length && a !== this) { | ||
5910 | for (; i < a.length; i++) { | ||
5911 | this.words[i] = a.words[i]; | ||
5912 | } | ||
5913 | } | ||
5914 | |||
5915 | this.length = Math.max(this.length, i); | ||
5916 | |||
5917 | if (a !== this) { | ||
5918 | this.negative = 1; | ||
5919 | } | ||
5920 | |||
5921 | return this.strip(); | ||
5922 | }; | ||
5923 | |||
5924 | // Subtract `num` from `this` | ||
5925 | BN.prototype.sub = function sub (num) { | ||
5926 | return this.clone().isub(num); | ||
5927 | }; | ||
5928 | |||
5929 | function smallMulTo (self, num, out) { | ||
5930 | out.negative = num.negative ^ self.negative; | ||
5931 | var len = (self.length + num.length) | 0; | ||
5932 | out.length = len; | ||
5933 | len = (len - 1) | 0; | ||
5934 | |||
5935 | // Peel one iteration (compiler can't do it, because of code complexity) | ||
5936 | var a = self.words[0] | 0; | ||
5937 | var b = num.words[0] | 0; | ||
5938 | var r = a * b; | ||
5939 | |||
5940 | var lo = r & 0x3ffffff; | ||
5941 | var carry = (r / 0x4000000) | 0; | ||
5942 | out.words[0] = lo; | ||
5943 | |||
5944 | for (var k = 1; k < len; k++) { | ||
5945 | // Sum all words with the same `i + j = k` and accumulate `ncarry`, | ||
5946 | // note that ncarry could be >= 0x3ffffff | ||
5947 | var ncarry = carry >>> 26; | ||
5948 | var rword = carry & 0x3ffffff; | ||
5949 | var maxJ = Math.min(k, num.length - 1); | ||
5950 | for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) { | ||
5951 | var i = (k - j) | 0; | ||
5952 | a = self.words[i] | 0; | ||
5953 | b = num.words[j] | 0; | ||
5954 | r = a * b + rword; | ||
5955 | ncarry += (r / 0x4000000) | 0; | ||
5956 | rword = r & 0x3ffffff; | ||
5957 | } | ||
5958 | out.words[k] = rword | 0; | ||
5959 | carry = ncarry | 0; | ||
5960 | } | ||
5961 | if (carry !== 0) { | ||
5962 | out.words[k] = carry | 0; | ||
5963 | } else { | ||
5964 | out.length--; | ||
5965 | } | ||
5966 | |||
5967 | return out.strip(); | ||
5968 | } | ||
5969 | |||
5970 | // TODO(indutny): it may be reasonable to omit it for users who don't need | ||
5971 | // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit | ||
5972 | // multiplication (like elliptic secp256k1). | ||
5973 | var comb10MulTo = function comb10MulTo (self, num, out) { | ||
5974 | var a = self.words; | ||
5975 | var b = num.words; | ||
5976 | var o = out.words; | ||
5977 | var c = 0; | ||
5978 | var lo; | ||
5979 | var mid; | ||
5980 | var hi; | ||
5981 | var a0 = a[0] | 0; | ||
5982 | var al0 = a0 & 0x1fff; | ||
5983 | var ah0 = a0 >>> 13; | ||
5984 | var a1 = a[1] | 0; | ||
5985 | var al1 = a1 & 0x1fff; | ||
5986 | var ah1 = a1 >>> 13; | ||
5987 | var a2 = a[2] | 0; | ||
5988 | var al2 = a2 & 0x1fff; | ||
5989 | var ah2 = a2 >>> 13; | ||
5990 | var a3 = a[3] | 0; | ||
5991 | var al3 = a3 & 0x1fff; | ||
5992 | var ah3 = a3 >>> 13; | ||
5993 | var a4 = a[4] | 0; | ||
5994 | var al4 = a4 & 0x1fff; | ||
5995 | var ah4 = a4 >>> 13; | ||
5996 | var a5 = a[5] | 0; | ||
5997 | var al5 = a5 & 0x1fff; | ||
5998 | var ah5 = a5 >>> 13; | ||
5999 | var a6 = a[6] | 0; | ||
6000 | var al6 = a6 & 0x1fff; | ||
6001 | var ah6 = a6 >>> 13; | ||
6002 | var a7 = a[7] | 0; | ||
6003 | var al7 = a7 & 0x1fff; | ||
6004 | var ah7 = a7 >>> 13; | ||
6005 | var a8 = a[8] | 0; | ||
6006 | var al8 = a8 & 0x1fff; | ||
6007 | var ah8 = a8 >>> 13; | ||
6008 | var a9 = a[9] | 0; | ||
6009 | var al9 = a9 & 0x1fff; | ||
6010 | var ah9 = a9 >>> 13; | ||
6011 | var b0 = b[0] | 0; | ||
6012 | var bl0 = b0 & 0x1fff; | ||
6013 | var bh0 = b0 >>> 13; | ||
6014 | var b1 = b[1] | 0; | ||
6015 | var bl1 = b1 & 0x1fff; | ||
6016 | var bh1 = b1 >>> 13; | ||
6017 | var b2 = b[2] | 0; | ||
6018 | var bl2 = b2 & 0x1fff; | ||
6019 | var bh2 = b2 >>> 13; | ||
6020 | var b3 = b[3] | 0; | ||
6021 | var bl3 = b3 & 0x1fff; | ||
6022 | var bh3 = b3 >>> 13; | ||
6023 | var b4 = b[4] | 0; | ||
6024 | var bl4 = b4 & 0x1fff; | ||
6025 | var bh4 = b4 >>> 13; | ||
6026 | var b5 = b[5] | 0; | ||
6027 | var bl5 = b5 & 0x1fff; | ||
6028 | var bh5 = b5 >>> 13; | ||
6029 | var b6 = b[6] | 0; | ||
6030 | var bl6 = b6 & 0x1fff; | ||
6031 | var bh6 = b6 >>> 13; | ||
6032 | var b7 = b[7] | 0; | ||
6033 | var bl7 = b7 & 0x1fff; | ||
6034 | var bh7 = b7 >>> 13; | ||
6035 | var b8 = b[8] | 0; | ||
6036 | var bl8 = b8 & 0x1fff; | ||
6037 | var bh8 = b8 >>> 13; | ||
6038 | var b9 = b[9] | 0; | ||
6039 | var bl9 = b9 & 0x1fff; | ||
6040 | var bh9 = b9 >>> 13; | ||
6041 | |||
6042 | out.negative = self.negative ^ num.negative; | ||
6043 | out.length = 19; | ||
6044 | /* k = 0 */ | ||
6045 | lo = Math.imul(al0, bl0); | ||
6046 | mid = Math.imul(al0, bh0); | ||
6047 | mid = (mid + Math.imul(ah0, bl0)) | 0; | ||
6048 | hi = Math.imul(ah0, bh0); | ||
6049 | var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6050 | c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0; | ||
6051 | w0 &= 0x3ffffff; | ||
6052 | /* k = 1 */ | ||
6053 | lo = Math.imul(al1, bl0); | ||
6054 | mid = Math.imul(al1, bh0); | ||
6055 | mid = (mid + Math.imul(ah1, bl0)) | 0; | ||
6056 | hi = Math.imul(ah1, bh0); | ||
6057 | lo = (lo + Math.imul(al0, bl1)) | 0; | ||
6058 | mid = (mid + Math.imul(al0, bh1)) | 0; | ||
6059 | mid = (mid + Math.imul(ah0, bl1)) | 0; | ||
6060 | hi = (hi + Math.imul(ah0, bh1)) | 0; | ||
6061 | var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6062 | c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0; | ||
6063 | w1 &= 0x3ffffff; | ||
6064 | /* k = 2 */ | ||
6065 | lo = Math.imul(al2, bl0); | ||
6066 | mid = Math.imul(al2, bh0); | ||
6067 | mid = (mid + Math.imul(ah2, bl0)) | 0; | ||
6068 | hi = Math.imul(ah2, bh0); | ||
6069 | lo = (lo + Math.imul(al1, bl1)) | 0; | ||
6070 | mid = (mid + Math.imul(al1, bh1)) | 0; | ||
6071 | mid = (mid + Math.imul(ah1, bl1)) | 0; | ||
6072 | hi = (hi + Math.imul(ah1, bh1)) | 0; | ||
6073 | lo = (lo + Math.imul(al0, bl2)) | 0; | ||
6074 | mid = (mid + Math.imul(al0, bh2)) | 0; | ||
6075 | mid = (mid + Math.imul(ah0, bl2)) | 0; | ||
6076 | hi = (hi + Math.imul(ah0, bh2)) | 0; | ||
6077 | var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6078 | c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0; | ||
6079 | w2 &= 0x3ffffff; | ||
6080 | /* k = 3 */ | ||
6081 | lo = Math.imul(al3, bl0); | ||
6082 | mid = Math.imul(al3, bh0); | ||
6083 | mid = (mid + Math.imul(ah3, bl0)) | 0; | ||
6084 | hi = Math.imul(ah3, bh0); | ||
6085 | lo = (lo + Math.imul(al2, bl1)) | 0; | ||
6086 | mid = (mid + Math.imul(al2, bh1)) | 0; | ||
6087 | mid = (mid + Math.imul(ah2, bl1)) | 0; | ||
6088 | hi = (hi + Math.imul(ah2, bh1)) | 0; | ||
6089 | lo = (lo + Math.imul(al1, bl2)) | 0; | ||
6090 | mid = (mid + Math.imul(al1, bh2)) | 0; | ||
6091 | mid = (mid + Math.imul(ah1, bl2)) | 0; | ||
6092 | hi = (hi + Math.imul(ah1, bh2)) | 0; | ||
6093 | lo = (lo + Math.imul(al0, bl3)) | 0; | ||
6094 | mid = (mid + Math.imul(al0, bh3)) | 0; | ||
6095 | mid = (mid + Math.imul(ah0, bl3)) | 0; | ||
6096 | hi = (hi + Math.imul(ah0, bh3)) | 0; | ||
6097 | var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6098 | c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0; | ||
6099 | w3 &= 0x3ffffff; | ||
6100 | /* k = 4 */ | ||
6101 | lo = Math.imul(al4, bl0); | ||
6102 | mid = Math.imul(al4, bh0); | ||
6103 | mid = (mid + Math.imul(ah4, bl0)) | 0; | ||
6104 | hi = Math.imul(ah4, bh0); | ||
6105 | lo = (lo + Math.imul(al3, bl1)) | 0; | ||
6106 | mid = (mid + Math.imul(al3, bh1)) | 0; | ||
6107 | mid = (mid + Math.imul(ah3, bl1)) | 0; | ||
6108 | hi = (hi + Math.imul(ah3, bh1)) | 0; | ||
6109 | lo = (lo + Math.imul(al2, bl2)) | 0; | ||
6110 | mid = (mid + Math.imul(al2, bh2)) | 0; | ||
6111 | mid = (mid + Math.imul(ah2, bl2)) | 0; | ||
6112 | hi = (hi + Math.imul(ah2, bh2)) | 0; | ||
6113 | lo = (lo + Math.imul(al1, bl3)) | 0; | ||
6114 | mid = (mid + Math.imul(al1, bh3)) | 0; | ||
6115 | mid = (mid + Math.imul(ah1, bl3)) | 0; | ||
6116 | hi = (hi + Math.imul(ah1, bh3)) | 0; | ||
6117 | lo = (lo + Math.imul(al0, bl4)) | 0; | ||
6118 | mid = (mid + Math.imul(al0, bh4)) | 0; | ||
6119 | mid = (mid + Math.imul(ah0, bl4)) | 0; | ||
6120 | hi = (hi + Math.imul(ah0, bh4)) | 0; | ||
6121 | var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6122 | c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0; | ||
6123 | w4 &= 0x3ffffff; | ||
6124 | /* k = 5 */ | ||
6125 | lo = Math.imul(al5, bl0); | ||
6126 | mid = Math.imul(al5, bh0); | ||
6127 | mid = (mid + Math.imul(ah5, bl0)) | 0; | ||
6128 | hi = Math.imul(ah5, bh0); | ||
6129 | lo = (lo + Math.imul(al4, bl1)) | 0; | ||
6130 | mid = (mid + Math.imul(al4, bh1)) | 0; | ||
6131 | mid = (mid + Math.imul(ah4, bl1)) | 0; | ||
6132 | hi = (hi + Math.imul(ah4, bh1)) | 0; | ||
6133 | lo = (lo + Math.imul(al3, bl2)) | 0; | ||
6134 | mid = (mid + Math.imul(al3, bh2)) | 0; | ||
6135 | mid = (mid + Math.imul(ah3, bl2)) | 0; | ||
6136 | hi = (hi + Math.imul(ah3, bh2)) | 0; | ||
6137 | lo = (lo + Math.imul(al2, bl3)) | 0; | ||
6138 | mid = (mid + Math.imul(al2, bh3)) | 0; | ||
6139 | mid = (mid + Math.imul(ah2, bl3)) | 0; | ||
6140 | hi = (hi + Math.imul(ah2, bh3)) | 0; | ||
6141 | lo = (lo + Math.imul(al1, bl4)) | 0; | ||
6142 | mid = (mid + Math.imul(al1, bh4)) | 0; | ||
6143 | mid = (mid + Math.imul(ah1, bl4)) | 0; | ||
6144 | hi = (hi + Math.imul(ah1, bh4)) | 0; | ||
6145 | lo = (lo + Math.imul(al0, bl5)) | 0; | ||
6146 | mid = (mid + Math.imul(al0, bh5)) | 0; | ||
6147 | mid = (mid + Math.imul(ah0, bl5)) | 0; | ||
6148 | hi = (hi + Math.imul(ah0, bh5)) | 0; | ||
6149 | var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6150 | c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0; | ||
6151 | w5 &= 0x3ffffff; | ||
6152 | /* k = 6 */ | ||
6153 | lo = Math.imul(al6, bl0); | ||
6154 | mid = Math.imul(al6, bh0); | ||
6155 | mid = (mid + Math.imul(ah6, bl0)) | 0; | ||
6156 | hi = Math.imul(ah6, bh0); | ||
6157 | lo = (lo + Math.imul(al5, bl1)) | 0; | ||
6158 | mid = (mid + Math.imul(al5, bh1)) | 0; | ||
6159 | mid = (mid + Math.imul(ah5, bl1)) | 0; | ||
6160 | hi = (hi + Math.imul(ah5, bh1)) | 0; | ||
6161 | lo = (lo + Math.imul(al4, bl2)) | 0; | ||
6162 | mid = (mid + Math.imul(al4, bh2)) | 0; | ||
6163 | mid = (mid + Math.imul(ah4, bl2)) | 0; | ||
6164 | hi = (hi + Math.imul(ah4, bh2)) | 0; | ||
6165 | lo = (lo + Math.imul(al3, bl3)) | 0; | ||
6166 | mid = (mid + Math.imul(al3, bh3)) | 0; | ||
6167 | mid = (mid + Math.imul(ah3, bl3)) | 0; | ||
6168 | hi = (hi + Math.imul(ah3, bh3)) | 0; | ||
6169 | lo = (lo + Math.imul(al2, bl4)) | 0; | ||
6170 | mid = (mid + Math.imul(al2, bh4)) | 0; | ||
6171 | mid = (mid + Math.imul(ah2, bl4)) | 0; | ||
6172 | hi = (hi + Math.imul(ah2, bh4)) | 0; | ||
6173 | lo = (lo + Math.imul(al1, bl5)) | 0; | ||
6174 | mid = (mid + Math.imul(al1, bh5)) | 0; | ||
6175 | mid = (mid + Math.imul(ah1, bl5)) | 0; | ||
6176 | hi = (hi + Math.imul(ah1, bh5)) | 0; | ||
6177 | lo = (lo + Math.imul(al0, bl6)) | 0; | ||
6178 | mid = (mid + Math.imul(al0, bh6)) | 0; | ||
6179 | mid = (mid + Math.imul(ah0, bl6)) | 0; | ||
6180 | hi = (hi + Math.imul(ah0, bh6)) | 0; | ||
6181 | var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6182 | c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0; | ||
6183 | w6 &= 0x3ffffff; | ||
6184 | /* k = 7 */ | ||
6185 | lo = Math.imul(al7, bl0); | ||
6186 | mid = Math.imul(al7, bh0); | ||
6187 | mid = (mid + Math.imul(ah7, bl0)) | 0; | ||
6188 | hi = Math.imul(ah7, bh0); | ||
6189 | lo = (lo + Math.imul(al6, bl1)) | 0; | ||
6190 | mid = (mid + Math.imul(al6, bh1)) | 0; | ||
6191 | mid = (mid + Math.imul(ah6, bl1)) | 0; | ||
6192 | hi = (hi + Math.imul(ah6, bh1)) | 0; | ||
6193 | lo = (lo + Math.imul(al5, bl2)) | 0; | ||
6194 | mid = (mid + Math.imul(al5, bh2)) | 0; | ||
6195 | mid = (mid + Math.imul(ah5, bl2)) | 0; | ||
6196 | hi = (hi + Math.imul(ah5, bh2)) | 0; | ||
6197 | lo = (lo + Math.imul(al4, bl3)) | 0; | ||
6198 | mid = (mid + Math.imul(al4, bh3)) | 0; | ||
6199 | mid = (mid + Math.imul(ah4, bl3)) | 0; | ||
6200 | hi = (hi + Math.imul(ah4, bh3)) | 0; | ||
6201 | lo = (lo + Math.imul(al3, bl4)) | 0; | ||
6202 | mid = (mid + Math.imul(al3, bh4)) | 0; | ||
6203 | mid = (mid + Math.imul(ah3, bl4)) | 0; | ||
6204 | hi = (hi + Math.imul(ah3, bh4)) | 0; | ||
6205 | lo = (lo + Math.imul(al2, bl5)) | 0; | ||
6206 | mid = (mid + Math.imul(al2, bh5)) | 0; | ||
6207 | mid = (mid + Math.imul(ah2, bl5)) | 0; | ||
6208 | hi = (hi + Math.imul(ah2, bh5)) | 0; | ||
6209 | lo = (lo + Math.imul(al1, bl6)) | 0; | ||
6210 | mid = (mid + Math.imul(al1, bh6)) | 0; | ||
6211 | mid = (mid + Math.imul(ah1, bl6)) | 0; | ||
6212 | hi = (hi + Math.imul(ah1, bh6)) | 0; | ||
6213 | lo = (lo + Math.imul(al0, bl7)) | 0; | ||
6214 | mid = (mid + Math.imul(al0, bh7)) | 0; | ||
6215 | mid = (mid + Math.imul(ah0, bl7)) | 0; | ||
6216 | hi = (hi + Math.imul(ah0, bh7)) | 0; | ||
6217 | var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6218 | c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0; | ||
6219 | w7 &= 0x3ffffff; | ||
6220 | /* k = 8 */ | ||
6221 | lo = Math.imul(al8, bl0); | ||
6222 | mid = Math.imul(al8, bh0); | ||
6223 | mid = (mid + Math.imul(ah8, bl0)) | 0; | ||
6224 | hi = Math.imul(ah8, bh0); | ||
6225 | lo = (lo + Math.imul(al7, bl1)) | 0; | ||
6226 | mid = (mid + Math.imul(al7, bh1)) | 0; | ||
6227 | mid = (mid + Math.imul(ah7, bl1)) | 0; | ||
6228 | hi = (hi + Math.imul(ah7, bh1)) | 0; | ||
6229 | lo = (lo + Math.imul(al6, bl2)) | 0; | ||
6230 | mid = (mid + Math.imul(al6, bh2)) | 0; | ||
6231 | mid = (mid + Math.imul(ah6, bl2)) | 0; | ||
6232 | hi = (hi + Math.imul(ah6, bh2)) | 0; | ||
6233 | lo = (lo + Math.imul(al5, bl3)) | 0; | ||
6234 | mid = (mid + Math.imul(al5, bh3)) | 0; | ||
6235 | mid = (mid + Math.imul(ah5, bl3)) | 0; | ||
6236 | hi = (hi + Math.imul(ah5, bh3)) | 0; | ||
6237 | lo = (lo + Math.imul(al4, bl4)) | 0; | ||
6238 | mid = (mid + Math.imul(al4, bh4)) | 0; | ||
6239 | mid = (mid + Math.imul(ah4, bl4)) | 0; | ||
6240 | hi = (hi + Math.imul(ah4, bh4)) | 0; | ||
6241 | lo = (lo + Math.imul(al3, bl5)) | 0; | ||
6242 | mid = (mid + Math.imul(al3, bh5)) | 0; | ||
6243 | mid = (mid + Math.imul(ah3, bl5)) | 0; | ||
6244 | hi = (hi + Math.imul(ah3, bh5)) | 0; | ||
6245 | lo = (lo + Math.imul(al2, bl6)) | 0; | ||
6246 | mid = (mid + Math.imul(al2, bh6)) | 0; | ||
6247 | mid = (mid + Math.imul(ah2, bl6)) | 0; | ||
6248 | hi = (hi + Math.imul(ah2, bh6)) | 0; | ||
6249 | lo = (lo + Math.imul(al1, bl7)) | 0; | ||
6250 | mid = (mid + Math.imul(al1, bh7)) | 0; | ||
6251 | mid = (mid + Math.imul(ah1, bl7)) | 0; | ||
6252 | hi = (hi + Math.imul(ah1, bh7)) | 0; | ||
6253 | lo = (lo + Math.imul(al0, bl8)) | 0; | ||
6254 | mid = (mid + Math.imul(al0, bh8)) | 0; | ||
6255 | mid = (mid + Math.imul(ah0, bl8)) | 0; | ||
6256 | hi = (hi + Math.imul(ah0, bh8)) | 0; | ||
6257 | var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6258 | c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0; | ||
6259 | w8 &= 0x3ffffff; | ||
6260 | /* k = 9 */ | ||
6261 | lo = Math.imul(al9, bl0); | ||
6262 | mid = Math.imul(al9, bh0); | ||
6263 | mid = (mid + Math.imul(ah9, bl0)) | 0; | ||
6264 | hi = Math.imul(ah9, bh0); | ||
6265 | lo = (lo + Math.imul(al8, bl1)) | 0; | ||
6266 | mid = (mid + Math.imul(al8, bh1)) | 0; | ||
6267 | mid = (mid + Math.imul(ah8, bl1)) | 0; | ||
6268 | hi = (hi + Math.imul(ah8, bh1)) | 0; | ||
6269 | lo = (lo + Math.imul(al7, bl2)) | 0; | ||
6270 | mid = (mid + Math.imul(al7, bh2)) | 0; | ||
6271 | mid = (mid + Math.imul(ah7, bl2)) | 0; | ||
6272 | hi = (hi + Math.imul(ah7, bh2)) | 0; | ||
6273 | lo = (lo + Math.imul(al6, bl3)) | 0; | ||
6274 | mid = (mid + Math.imul(al6, bh3)) | 0; | ||
6275 | mid = (mid + Math.imul(ah6, bl3)) | 0; | ||
6276 | hi = (hi + Math.imul(ah6, bh3)) | 0; | ||
6277 | lo = (lo + Math.imul(al5, bl4)) | 0; | ||
6278 | mid = (mid + Math.imul(al5, bh4)) | 0; | ||
6279 | mid = (mid + Math.imul(ah5, bl4)) | 0; | ||
6280 | hi = (hi + Math.imul(ah5, bh4)) | 0; | ||
6281 | lo = (lo + Math.imul(al4, bl5)) | 0; | ||
6282 | mid = (mid + Math.imul(al4, bh5)) | 0; | ||
6283 | mid = (mid + Math.imul(ah4, bl5)) | 0; | ||
6284 | hi = (hi + Math.imul(ah4, bh5)) | 0; | ||
6285 | lo = (lo + Math.imul(al3, bl6)) | 0; | ||
6286 | mid = (mid + Math.imul(al3, bh6)) | 0; | ||
6287 | mid = (mid + Math.imul(ah3, bl6)) | 0; | ||
6288 | hi = (hi + Math.imul(ah3, bh6)) | 0; | ||
6289 | lo = (lo + Math.imul(al2, bl7)) | 0; | ||
6290 | mid = (mid + Math.imul(al2, bh7)) | 0; | ||
6291 | mid = (mid + Math.imul(ah2, bl7)) | 0; | ||
6292 | hi = (hi + Math.imul(ah2, bh7)) | 0; | ||
6293 | lo = (lo + Math.imul(al1, bl8)) | 0; | ||
6294 | mid = (mid + Math.imul(al1, bh8)) | 0; | ||
6295 | mid = (mid + Math.imul(ah1, bl8)) | 0; | ||
6296 | hi = (hi + Math.imul(ah1, bh8)) | 0; | ||
6297 | lo = (lo + Math.imul(al0, bl9)) | 0; | ||
6298 | mid = (mid + Math.imul(al0, bh9)) | 0; | ||
6299 | mid = (mid + Math.imul(ah0, bl9)) | 0; | ||
6300 | hi = (hi + Math.imul(ah0, bh9)) | 0; | ||
6301 | var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6302 | c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0; | ||
6303 | w9 &= 0x3ffffff; | ||
6304 | /* k = 10 */ | ||
6305 | lo = Math.imul(al9, bl1); | ||
6306 | mid = Math.imul(al9, bh1); | ||
6307 | mid = (mid + Math.imul(ah9, bl1)) | 0; | ||
6308 | hi = Math.imul(ah9, bh1); | ||
6309 | lo = (lo + Math.imul(al8, bl2)) | 0; | ||
6310 | mid = (mid + Math.imul(al8, bh2)) | 0; | ||
6311 | mid = (mid + Math.imul(ah8, bl2)) | 0; | ||
6312 | hi = (hi + Math.imul(ah8, bh2)) | 0; | ||
6313 | lo = (lo + Math.imul(al7, bl3)) | 0; | ||
6314 | mid = (mid + Math.imul(al7, bh3)) | 0; | ||
6315 | mid = (mid + Math.imul(ah7, bl3)) | 0; | ||
6316 | hi = (hi + Math.imul(ah7, bh3)) | 0; | ||
6317 | lo = (lo + Math.imul(al6, bl4)) | 0; | ||
6318 | mid = (mid + Math.imul(al6, bh4)) | 0; | ||
6319 | mid = (mid + Math.imul(ah6, bl4)) | 0; | ||
6320 | hi = (hi + Math.imul(ah6, bh4)) | 0; | ||
6321 | lo = (lo + Math.imul(al5, bl5)) | 0; | ||
6322 | mid = (mid + Math.imul(al5, bh5)) | 0; | ||
6323 | mid = (mid + Math.imul(ah5, bl5)) | 0; | ||
6324 | hi = (hi + Math.imul(ah5, bh5)) | 0; | ||
6325 | lo = (lo + Math.imul(al4, bl6)) | 0; | ||
6326 | mid = (mid + Math.imul(al4, bh6)) | 0; | ||
6327 | mid = (mid + Math.imul(ah4, bl6)) | 0; | ||
6328 | hi = (hi + Math.imul(ah4, bh6)) | 0; | ||
6329 | lo = (lo + Math.imul(al3, bl7)) | 0; | ||
6330 | mid = (mid + Math.imul(al3, bh7)) | 0; | ||
6331 | mid = (mid + Math.imul(ah3, bl7)) | 0; | ||
6332 | hi = (hi + Math.imul(ah3, bh7)) | 0; | ||
6333 | lo = (lo + Math.imul(al2, bl8)) | 0; | ||
6334 | mid = (mid + Math.imul(al2, bh8)) | 0; | ||
6335 | mid = (mid + Math.imul(ah2, bl8)) | 0; | ||
6336 | hi = (hi + Math.imul(ah2, bh8)) | 0; | ||
6337 | lo = (lo + Math.imul(al1, bl9)) | 0; | ||
6338 | mid = (mid + Math.imul(al1, bh9)) | 0; | ||
6339 | mid = (mid + Math.imul(ah1, bl9)) | 0; | ||
6340 | hi = (hi + Math.imul(ah1, bh9)) | 0; | ||
6341 | var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6342 | c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0; | ||
6343 | w10 &= 0x3ffffff; | ||
6344 | /* k = 11 */ | ||
6345 | lo = Math.imul(al9, bl2); | ||
6346 | mid = Math.imul(al9, bh2); | ||
6347 | mid = (mid + Math.imul(ah9, bl2)) | 0; | ||
6348 | hi = Math.imul(ah9, bh2); | ||
6349 | lo = (lo + Math.imul(al8, bl3)) | 0; | ||
6350 | mid = (mid + Math.imul(al8, bh3)) | 0; | ||
6351 | mid = (mid + Math.imul(ah8, bl3)) | 0; | ||
6352 | hi = (hi + Math.imul(ah8, bh3)) | 0; | ||
6353 | lo = (lo + Math.imul(al7, bl4)) | 0; | ||
6354 | mid = (mid + Math.imul(al7, bh4)) | 0; | ||
6355 | mid = (mid + Math.imul(ah7, bl4)) | 0; | ||
6356 | hi = (hi + Math.imul(ah7, bh4)) | 0; | ||
6357 | lo = (lo + Math.imul(al6, bl5)) | 0; | ||
6358 | mid = (mid + Math.imul(al6, bh5)) | 0; | ||
6359 | mid = (mid + Math.imul(ah6, bl5)) | 0; | ||
6360 | hi = (hi + Math.imul(ah6, bh5)) | 0; | ||
6361 | lo = (lo + Math.imul(al5, bl6)) | 0; | ||
6362 | mid = (mid + Math.imul(al5, bh6)) | 0; | ||
6363 | mid = (mid + Math.imul(ah5, bl6)) | 0; | ||
6364 | hi = (hi + Math.imul(ah5, bh6)) | 0; | ||
6365 | lo = (lo + Math.imul(al4, bl7)) | 0; | ||
6366 | mid = (mid + Math.imul(al4, bh7)) | 0; | ||
6367 | mid = (mid + Math.imul(ah4, bl7)) | 0; | ||
6368 | hi = (hi + Math.imul(ah4, bh7)) | 0; | ||
6369 | lo = (lo + Math.imul(al3, bl8)) | 0; | ||
6370 | mid = (mid + Math.imul(al3, bh8)) | 0; | ||
6371 | mid = (mid + Math.imul(ah3, bl8)) | 0; | ||
6372 | hi = (hi + Math.imul(ah3, bh8)) | 0; | ||
6373 | lo = (lo + Math.imul(al2, bl9)) | 0; | ||
6374 | mid = (mid + Math.imul(al2, bh9)) | 0; | ||
6375 | mid = (mid + Math.imul(ah2, bl9)) | 0; | ||
6376 | hi = (hi + Math.imul(ah2, bh9)) | 0; | ||
6377 | var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6378 | c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0; | ||
6379 | w11 &= 0x3ffffff; | ||
6380 | /* k = 12 */ | ||
6381 | lo = Math.imul(al9, bl3); | ||
6382 | mid = Math.imul(al9, bh3); | ||
6383 | mid = (mid + Math.imul(ah9, bl3)) | 0; | ||
6384 | hi = Math.imul(ah9, bh3); | ||
6385 | lo = (lo + Math.imul(al8, bl4)) | 0; | ||
6386 | mid = (mid + Math.imul(al8, bh4)) | 0; | ||
6387 | mid = (mid + Math.imul(ah8, bl4)) | 0; | ||
6388 | hi = (hi + Math.imul(ah8, bh4)) | 0; | ||
6389 | lo = (lo + Math.imul(al7, bl5)) | 0; | ||
6390 | mid = (mid + Math.imul(al7, bh5)) | 0; | ||
6391 | mid = (mid + Math.imul(ah7, bl5)) | 0; | ||
6392 | hi = (hi + Math.imul(ah7, bh5)) | 0; | ||
6393 | lo = (lo + Math.imul(al6, bl6)) | 0; | ||
6394 | mid = (mid + Math.imul(al6, bh6)) | 0; | ||
6395 | mid = (mid + Math.imul(ah6, bl6)) | 0; | ||
6396 | hi = (hi + Math.imul(ah6, bh6)) | 0; | ||
6397 | lo = (lo + Math.imul(al5, bl7)) | 0; | ||
6398 | mid = (mid + Math.imul(al5, bh7)) | 0; | ||
6399 | mid = (mid + Math.imul(ah5, bl7)) | 0; | ||
6400 | hi = (hi + Math.imul(ah5, bh7)) | 0; | ||
6401 | lo = (lo + Math.imul(al4, bl8)) | 0; | ||
6402 | mid = (mid + Math.imul(al4, bh8)) | 0; | ||
6403 | mid = (mid + Math.imul(ah4, bl8)) | 0; | ||
6404 | hi = (hi + Math.imul(ah4, bh8)) | 0; | ||
6405 | lo = (lo + Math.imul(al3, bl9)) | 0; | ||
6406 | mid = (mid + Math.imul(al3, bh9)) | 0; | ||
6407 | mid = (mid + Math.imul(ah3, bl9)) | 0; | ||
6408 | hi = (hi + Math.imul(ah3, bh9)) | 0; | ||
6409 | var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6410 | c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0; | ||
6411 | w12 &= 0x3ffffff; | ||
6412 | /* k = 13 */ | ||
6413 | lo = Math.imul(al9, bl4); | ||
6414 | mid = Math.imul(al9, bh4); | ||
6415 | mid = (mid + Math.imul(ah9, bl4)) | 0; | ||
6416 | hi = Math.imul(ah9, bh4); | ||
6417 | lo = (lo + Math.imul(al8, bl5)) | 0; | ||
6418 | mid = (mid + Math.imul(al8, bh5)) | 0; | ||
6419 | mid = (mid + Math.imul(ah8, bl5)) | 0; | ||
6420 | hi = (hi + Math.imul(ah8, bh5)) | 0; | ||
6421 | lo = (lo + Math.imul(al7, bl6)) | 0; | ||
6422 | mid = (mid + Math.imul(al7, bh6)) | 0; | ||
6423 | mid = (mid + Math.imul(ah7, bl6)) | 0; | ||
6424 | hi = (hi + Math.imul(ah7, bh6)) | 0; | ||
6425 | lo = (lo + Math.imul(al6, bl7)) | 0; | ||
6426 | mid = (mid + Math.imul(al6, bh7)) | 0; | ||
6427 | mid = (mid + Math.imul(ah6, bl7)) | 0; | ||
6428 | hi = (hi + Math.imul(ah6, bh7)) | 0; | ||
6429 | lo = (lo + Math.imul(al5, bl8)) | 0; | ||
6430 | mid = (mid + Math.imul(al5, bh8)) | 0; | ||
6431 | mid = (mid + Math.imul(ah5, bl8)) | 0; | ||
6432 | hi = (hi + Math.imul(ah5, bh8)) | 0; | ||
6433 | lo = (lo + Math.imul(al4, bl9)) | 0; | ||
6434 | mid = (mid + Math.imul(al4, bh9)) | 0; | ||
6435 | mid = (mid + Math.imul(ah4, bl9)) | 0; | ||
6436 | hi = (hi + Math.imul(ah4, bh9)) | 0; | ||
6437 | var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6438 | c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0; | ||
6439 | w13 &= 0x3ffffff; | ||
6440 | /* k = 14 */ | ||
6441 | lo = Math.imul(al9, bl5); | ||
6442 | mid = Math.imul(al9, bh5); | ||
6443 | mid = (mid + Math.imul(ah9, bl5)) | 0; | ||
6444 | hi = Math.imul(ah9, bh5); | ||
6445 | lo = (lo + Math.imul(al8, bl6)) | 0; | ||
6446 | mid = (mid + Math.imul(al8, bh6)) | 0; | ||
6447 | mid = (mid + Math.imul(ah8, bl6)) | 0; | ||
6448 | hi = (hi + Math.imul(ah8, bh6)) | 0; | ||
6449 | lo = (lo + Math.imul(al7, bl7)) | 0; | ||
6450 | mid = (mid + Math.imul(al7, bh7)) | 0; | ||
6451 | mid = (mid + Math.imul(ah7, bl7)) | 0; | ||
6452 | hi = (hi + Math.imul(ah7, bh7)) | 0; | ||
6453 | lo = (lo + Math.imul(al6, bl8)) | 0; | ||
6454 | mid = (mid + Math.imul(al6, bh8)) | 0; | ||
6455 | mid = (mid + Math.imul(ah6, bl8)) | 0; | ||
6456 | hi = (hi + Math.imul(ah6, bh8)) | 0; | ||
6457 | lo = (lo + Math.imul(al5, bl9)) | 0; | ||
6458 | mid = (mid + Math.imul(al5, bh9)) | 0; | ||
6459 | mid = (mid + Math.imul(ah5, bl9)) | 0; | ||
6460 | hi = (hi + Math.imul(ah5, bh9)) | 0; | ||
6461 | var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6462 | c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0; | ||
6463 | w14 &= 0x3ffffff; | ||
6464 | /* k = 15 */ | ||
6465 | lo = Math.imul(al9, bl6); | ||
6466 | mid = Math.imul(al9, bh6); | ||
6467 | mid = (mid + Math.imul(ah9, bl6)) | 0; | ||
6468 | hi = Math.imul(ah9, bh6); | ||
6469 | lo = (lo + Math.imul(al8, bl7)) | 0; | ||
6470 | mid = (mid + Math.imul(al8, bh7)) | 0; | ||
6471 | mid = (mid + Math.imul(ah8, bl7)) | 0; | ||
6472 | hi = (hi + Math.imul(ah8, bh7)) | 0; | ||
6473 | lo = (lo + Math.imul(al7, bl8)) | 0; | ||
6474 | mid = (mid + Math.imul(al7, bh8)) | 0; | ||
6475 | mid = (mid + Math.imul(ah7, bl8)) | 0; | ||
6476 | hi = (hi + Math.imul(ah7, bh8)) | 0; | ||
6477 | lo = (lo + Math.imul(al6, bl9)) | 0; | ||
6478 | mid = (mid + Math.imul(al6, bh9)) | 0; | ||
6479 | mid = (mid + Math.imul(ah6, bl9)) | 0; | ||
6480 | hi = (hi + Math.imul(ah6, bh9)) | 0; | ||
6481 | var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6482 | c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0; | ||
6483 | w15 &= 0x3ffffff; | ||
6484 | /* k = 16 */ | ||
6485 | lo = Math.imul(al9, bl7); | ||
6486 | mid = Math.imul(al9, bh7); | ||
6487 | mid = (mid + Math.imul(ah9, bl7)) | 0; | ||
6488 | hi = Math.imul(ah9, bh7); | ||
6489 | lo = (lo + Math.imul(al8, bl8)) | 0; | ||
6490 | mid = (mid + Math.imul(al8, bh8)) | 0; | ||
6491 | mid = (mid + Math.imul(ah8, bl8)) | 0; | ||
6492 | hi = (hi + Math.imul(ah8, bh8)) | 0; | ||
6493 | lo = (lo + Math.imul(al7, bl9)) | 0; | ||
6494 | mid = (mid + Math.imul(al7, bh9)) | 0; | ||
6495 | mid = (mid + Math.imul(ah7, bl9)) | 0; | ||
6496 | hi = (hi + Math.imul(ah7, bh9)) | 0; | ||
6497 | var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6498 | c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0; | ||
6499 | w16 &= 0x3ffffff; | ||
6500 | /* k = 17 */ | ||
6501 | lo = Math.imul(al9, bl8); | ||
6502 | mid = Math.imul(al9, bh8); | ||
6503 | mid = (mid + Math.imul(ah9, bl8)) | 0; | ||
6504 | hi = Math.imul(ah9, bh8); | ||
6505 | lo = (lo + Math.imul(al8, bl9)) | 0; | ||
6506 | mid = (mid + Math.imul(al8, bh9)) | 0; | ||
6507 | mid = (mid + Math.imul(ah8, bl9)) | 0; | ||
6508 | hi = (hi + Math.imul(ah8, bh9)) | 0; | ||
6509 | var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6510 | c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0; | ||
6511 | w17 &= 0x3ffffff; | ||
6512 | /* k = 18 */ | ||
6513 | lo = Math.imul(al9, bl9); | ||
6514 | mid = Math.imul(al9, bh9); | ||
6515 | mid = (mid + Math.imul(ah9, bl9)) | 0; | ||
6516 | hi = Math.imul(ah9, bh9); | ||
6517 | var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; | ||
6518 | c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0; | ||
6519 | w18 &= 0x3ffffff; | ||
6520 | o[0] = w0; | ||
6521 | o[1] = w1; | ||
6522 | o[2] = w2; | ||
6523 | o[3] = w3; | ||
6524 | o[4] = w4; | ||
6525 | o[5] = w5; | ||
6526 | o[6] = w6; | ||
6527 | o[7] = w7; | ||
6528 | o[8] = w8; | ||
6529 | o[9] = w9; | ||
6530 | o[10] = w10; | ||
6531 | o[11] = w11; | ||
6532 | o[12] = w12; | ||
6533 | o[13] = w13; | ||
6534 | o[14] = w14; | ||
6535 | o[15] = w15; | ||
6536 | o[16] = w16; | ||
6537 | o[17] = w17; | ||
6538 | o[18] = w18; | ||
6539 | if (c !== 0) { | ||
6540 | o[19] = c; | ||
6541 | out.length++; | ||
6542 | } | ||
6543 | return out; | ||
6544 | }; | ||
6545 | |||
6546 | // Polyfill comb | ||
6547 | if (!Math.imul) { | ||
6548 | comb10MulTo = smallMulTo; | ||
6549 | } | ||
6550 | |||
6551 | function bigMulTo (self, num, out) { | ||
6552 | out.negative = num.negative ^ self.negative; | ||
6553 | out.length = self.length + num.length; | ||
6554 | |||
6555 | var carry = 0; | ||
6556 | var hncarry = 0; | ||
6557 | for (var k = 0; k < out.length - 1; k++) { | ||
6558 | // Sum all words with the same `i + j = k` and accumulate `ncarry`, | ||
6559 | // note that ncarry could be >= 0x3ffffff | ||
6560 | var ncarry = hncarry; | ||
6561 | hncarry = 0; | ||
6562 | var rword = carry & 0x3ffffff; | ||
6563 | var maxJ = Math.min(k, num.length - 1); | ||
6564 | for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) { | ||
6565 | var i = k - j; | ||
6566 | var a = self.words[i] | 0; | ||
6567 | var b = num.words[j] | 0; | ||
6568 | var r = a * b; | ||
6569 | |||
6570 | var lo = r & 0x3ffffff; | ||
6571 | ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0; | ||
6572 | lo = (lo + rword) | 0; | ||
6573 | rword = lo & 0x3ffffff; | ||
6574 | ncarry = (ncarry + (lo >>> 26)) | 0; | ||
6575 | |||
6576 | hncarry += ncarry >>> 26; | ||
6577 | ncarry &= 0x3ffffff; | ||
6578 | } | ||
6579 | out.words[k] = rword; | ||
6580 | carry = ncarry; | ||
6581 | ncarry = hncarry; | ||
6582 | } | ||
6583 | if (carry !== 0) { | ||
6584 | out.words[k] = carry; | ||
6585 | } else { | ||
6586 | out.length--; | ||
6587 | } | ||
6588 | |||
6589 | return out.strip(); | ||
6590 | } | ||
6591 | |||
6592 | function jumboMulTo (self, num, out) { | ||
6593 | var fftm = new FFTM(); | ||
6594 | return fftm.mulp(self, num, out); | ||
6595 | } | ||
6596 | |||
6597 | BN.prototype.mulTo = function mulTo (num, out) { | ||
6598 | var res; | ||
6599 | var len = this.length + num.length; | ||
6600 | if (this.length === 10 && num.length === 10) { | ||
6601 | res = comb10MulTo(this, num, out); | ||
6602 | } else if (len < 63) { | ||
6603 | res = smallMulTo(this, num, out); | ||
6604 | } else if (len < 1024) { | ||
6605 | res = bigMulTo(this, num, out); | ||
6606 | } else { | ||
6607 | res = jumboMulTo(this, num, out); | ||
6608 | } | ||
6609 | |||
6610 | return res; | ||
6611 | }; | ||
6612 | |||
6613 | // Cooley-Tukey algorithm for FFT | ||
6614 | // slightly revisited to rely on looping instead of recursion | ||
6615 | |||
6616 | function FFTM (x, y) { | ||
6617 | this.x = x; | ||
6618 | this.y = y; | ||
6619 | } | ||
6620 | |||
6621 | FFTM.prototype.makeRBT = function makeRBT (N) { | ||
6622 | var t = new Array(N); | ||
6623 | var l = BN.prototype._countBits(N) - 1; | ||
6624 | for (var i = 0; i < N; i++) { | ||
6625 | t[i] = this.revBin(i, l, N); | ||
6626 | } | ||
6627 | |||
6628 | return t; | ||
6629 | }; | ||
6630 | |||
6631 | // Returns binary-reversed representation of `x` | ||
6632 | FFTM.prototype.revBin = function revBin (x, l, N) { | ||
6633 | if (x === 0 || x === N - 1) return x; | ||
6634 | |||
6635 | var rb = 0; | ||
6636 | for (var i = 0; i < l; i++) { | ||
6637 | rb |= (x & 1) << (l - i - 1); | ||
6638 | x >>= 1; | ||
6639 | } | ||
6640 | |||
6641 | return rb; | ||
6642 | }; | ||
6643 | |||
6644 | // Performs "tweedling" phase, therefore 'emulating' | ||
6645 | // behaviour of the recursive algorithm | ||
6646 | FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) { | ||
6647 | for (var i = 0; i < N; i++) { | ||
6648 | rtws[i] = rws[rbt[i]]; | ||
6649 | itws[i] = iws[rbt[i]]; | ||
6650 | } | ||
6651 | }; | ||
6652 | |||
6653 | FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) { | ||
6654 | this.permute(rbt, rws, iws, rtws, itws, N); | ||
6655 | |||
6656 | for (var s = 1; s < N; s <<= 1) { | ||
6657 | var l = s << 1; | ||
6658 | |||
6659 | var rtwdf = Math.cos(2 * Math.PI / l); | ||
6660 | var itwdf = Math.sin(2 * Math.PI / l); | ||
6661 | |||
6662 | for (var p = 0; p < N; p += l) { | ||
6663 | var rtwdf_ = rtwdf; | ||
6664 | var itwdf_ = itwdf; | ||
6665 | |||
6666 | for (var j = 0; j < s; j++) { | ||
6667 | var re = rtws[p + j]; | ||
6668 | var ie = itws[p + j]; | ||
6669 | |||
6670 | var ro = rtws[p + j + s]; | ||
6671 | var io = itws[p + j + s]; | ||
6672 | |||
6673 | var rx = rtwdf_ * ro - itwdf_ * io; | ||
6674 | |||
6675 | io = rtwdf_ * io + itwdf_ * ro; | ||
6676 | ro = rx; | ||
6677 | |||
6678 | rtws[p + j] = re + ro; | ||
6679 | itws[p + j] = ie + io; | ||
6680 | |||
6681 | rtws[p + j + s] = re - ro; | ||
6682 | itws[p + j + s] = ie - io; | ||
6683 | |||
6684 | /* jshint maxdepth : false */ | ||
6685 | if (j !== l) { | ||
6686 | rx = rtwdf * rtwdf_ - itwdf * itwdf_; | ||
6687 | |||
6688 | itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_; | ||
6689 | rtwdf_ = rx; | ||
6690 | } | ||
6691 | } | ||
6692 | } | ||
6693 | } | ||
6694 | }; | ||
6695 | |||
6696 | FFTM.prototype.guessLen13b = function guessLen13b (n, m) { | ||
6697 | var N = Math.max(m, n) | 1; | ||
6698 | var odd = N & 1; | ||
6699 | var i = 0; | ||
6700 | for (N = N / 2 | 0; N; N = N >>> 1) { | ||
6701 | i++; | ||
6702 | } | ||
6703 | |||
6704 | return 1 << i + 1 + odd; | ||
6705 | }; | ||
6706 | |||
6707 | FFTM.prototype.conjugate = function conjugate (rws, iws, N) { | ||
6708 | if (N <= 1) return; | ||
6709 | |||
6710 | for (var i = 0; i < N / 2; i++) { | ||
6711 | var t = rws[i]; | ||
6712 | |||
6713 | rws[i] = rws[N - i - 1]; | ||
6714 | rws[N - i - 1] = t; | ||
6715 | |||
6716 | t = iws[i]; | ||
6717 | |||
6718 | iws[i] = -iws[N - i - 1]; | ||
6719 | iws[N - i - 1] = -t; | ||
6720 | } | ||
6721 | }; | ||
6722 | |||
6723 | FFTM.prototype.normalize13b = function normalize13b (ws, N) { | ||
6724 | var carry = 0; | ||
6725 | for (var i = 0; i < N / 2; i++) { | ||
6726 | var w = Math.round(ws[2 * i + 1] / N) * 0x2000 + | ||
6727 | Math.round(ws[2 * i] / N) + | ||
6728 | carry; | ||
6729 | |||
6730 | ws[i] = w & 0x3ffffff; | ||
6731 | |||
6732 | if (w < 0x4000000) { | ||
6733 | carry = 0; | ||
6734 | } else { | ||
6735 | carry = w / 0x4000000 | 0; | ||
6736 | } | ||
6737 | } | ||
6738 | |||
6739 | return ws; | ||
6740 | }; | ||
6741 | |||
6742 | FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) { | ||
6743 | var carry = 0; | ||
6744 | for (var i = 0; i < len; i++) { | ||
6745 | carry = carry + (ws[i] | 0); | ||
6746 | |||
6747 | rws[2 * i] = carry & 0x1fff; carry = carry >>> 13; | ||
6748 | rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13; | ||
6749 | } | ||
6750 | |||
6751 | // Pad with zeroes | ||
6752 | for (i = 2 * len; i < N; ++i) { | ||
6753 | rws[i] = 0; | ||
6754 | } | ||
6755 | |||
6756 | assert(carry === 0); | ||
6757 | assert((carry & ~0x1fff) === 0); | ||
6758 | }; | ||
6759 | |||
6760 | FFTM.prototype.stub = function stub (N) { | ||
6761 | var ph = new Array(N); | ||
6762 | for (var i = 0; i < N; i++) { | ||
6763 | ph[i] = 0; | ||
6764 | } | ||
6765 | |||
6766 | return ph; | ||
6767 | }; | ||
6768 | |||
6769 | FFTM.prototype.mulp = function mulp (x, y, out) { | ||
6770 | var N = 2 * this.guessLen13b(x.length, y.length); | ||
6771 | |||
6772 | var rbt = this.makeRBT(N); | ||
6773 | |||
6774 | var _ = this.stub(N); | ||
6775 | |||
6776 | var rws = new Array(N); | ||
6777 | var rwst = new Array(N); | ||
6778 | var iwst = new Array(N); | ||
6779 | |||
6780 | var nrws = new Array(N); | ||
6781 | var nrwst = new Array(N); | ||
6782 | var niwst = new Array(N); | ||
6783 | |||
6784 | var rmws = out.words; | ||
6785 | rmws.length = N; | ||
6786 | |||
6787 | this.convert13b(x.words, x.length, rws, N); | ||
6788 | this.convert13b(y.words, y.length, nrws, N); | ||
6789 | |||
6790 | this.transform(rws, _, rwst, iwst, N, rbt); | ||
6791 | this.transform(nrws, _, nrwst, niwst, N, rbt); | ||
6792 | |||
6793 | for (var i = 0; i < N; i++) { | ||
6794 | var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i]; | ||
6795 | iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i]; | ||
6796 | rwst[i] = rx; | ||
6797 | } | ||
6798 | |||
6799 | this.conjugate(rwst, iwst, N); | ||
6800 | this.transform(rwst, iwst, rmws, _, N, rbt); | ||
6801 | this.conjugate(rmws, _, N); | ||
6802 | this.normalize13b(rmws, N); | ||
6803 | |||
6804 | out.negative = x.negative ^ y.negative; | ||
6805 | out.length = x.length + y.length; | ||
6806 | return out.strip(); | ||
6807 | }; | ||
6808 | |||
6809 | // Multiply `this` by `num` | ||
6810 | BN.prototype.mul = function mul (num) { | ||
6811 | var out = new BN(null); | ||
6812 | out.words = new Array(this.length + num.length); | ||
6813 | return this.mulTo(num, out); | ||
6814 | }; | ||
6815 | |||
6816 | // Multiply employing FFT | ||
6817 | BN.prototype.mulf = function mulf (num) { | ||
6818 | var out = new BN(null); | ||
6819 | out.words = new Array(this.length + num.length); | ||
6820 | return jumboMulTo(this, num, out); | ||
6821 | }; | ||
6822 | |||
6823 | // In-place Multiplication | ||
6824 | BN.prototype.imul = function imul (num) { | ||
6825 | return this.clone().mulTo(num, this); | ||
6826 | }; | ||
6827 | |||
6828 | BN.prototype.imuln = function imuln (num) { | ||
6829 | assert(typeof num === 'number'); | ||
6830 | assert(num < 0x4000000); | ||
6831 | |||
6832 | // Carry | ||
6833 | var carry = 0; | ||
6834 | for (var i = 0; i < this.length; i++) { | ||
6835 | var w = (this.words[i] | 0) * num; | ||
6836 | var lo = (w & 0x3ffffff) + (carry & 0x3ffffff); | ||
6837 | carry >>= 26; | ||
6838 | carry += (w / 0x4000000) | 0; | ||
6839 | // NOTE: lo is 27bit maximum | ||
6840 | carry += lo >>> 26; | ||
6841 | this.words[i] = lo & 0x3ffffff; | ||
6842 | } | ||
6843 | |||
6844 | if (carry !== 0) { | ||
6845 | this.words[i] = carry; | ||
6846 | this.length++; | ||
6847 | } | ||
6848 | |||
6849 | return this; | ||
6850 | }; | ||
6851 | |||
6852 | BN.prototype.muln = function muln (num) { | ||
6853 | return this.clone().imuln(num); | ||
6854 | }; | ||
6855 | |||
6856 | // `this` * `this` | ||
6857 | BN.prototype.sqr = function sqr () { | ||
6858 | return this.mul(this); | ||
6859 | }; | ||
6860 | |||
6861 | // `this` * `this` in-place | ||
6862 | BN.prototype.isqr = function isqr () { | ||
6863 | return this.imul(this.clone()); | ||
6864 | }; | ||
6865 | |||
6866 | // Math.pow(`this`, `num`) | ||
6867 | BN.prototype.pow = function pow (num) { | ||
6868 | var w = toBitArray(num); | ||
6869 | if (w.length === 0) return new BN(1); | ||
6870 | |||
6871 | // Skip leading zeroes | ||
6872 | var res = this; | ||
6873 | for (var i = 0; i < w.length; i++, res = res.sqr()) { | ||
6874 | if (w[i] !== 0) break; | ||
6875 | } | ||
6876 | |||
6877 | if (++i < w.length) { | ||
6878 | for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) { | ||
6879 | if (w[i] === 0) continue; | ||
6880 | |||
6881 | res = res.mul(q); | ||
6882 | } | ||
6883 | } | ||
6884 | |||
6885 | return res; | ||
6886 | }; | ||
6887 | |||
6888 | // Shift-left in-place | ||
6889 | BN.prototype.iushln = function iushln (bits) { | ||
6890 | assert(typeof bits === 'number' && bits >= 0); | ||
6891 | var r = bits % 26; | ||
6892 | var s = (bits - r) / 26; | ||
6893 | var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r); | ||
6894 | var i; | ||
6895 | |||
6896 | if (r !== 0) { | ||
6897 | var carry = 0; | ||
6898 | |||
6899 | for (i = 0; i < this.length; i++) { | ||
6900 | var newCarry = this.words[i] & carryMask; | ||
6901 | var c = ((this.words[i] | 0) - newCarry) << r; | ||
6902 | this.words[i] = c | carry; | ||
6903 | carry = newCarry >>> (26 - r); | ||
6904 | } | ||
6905 | |||
6906 | if (carry) { | ||
6907 | this.words[i] = carry; | ||
6908 | this.length++; | ||
6909 | } | ||
6910 | } | ||
6911 | |||
6912 | if (s !== 0) { | ||
6913 | for (i = this.length - 1; i >= 0; i--) { | ||
6914 | this.words[i + s] = this.words[i]; | ||
6915 | } | ||
6916 | |||
6917 | for (i = 0; i < s; i++) { | ||
6918 | this.words[i] = 0; | ||
6919 | } | ||
6920 | |||
6921 | this.length += s; | ||
6922 | } | ||
6923 | |||
6924 | return this.strip(); | ||
6925 | }; | ||
6926 | |||
6927 | BN.prototype.ishln = function ishln (bits) { | ||
6928 | // TODO(indutny): implement me | ||
6929 | assert(this.negative === 0); | ||
6930 | return this.iushln(bits); | ||
6931 | }; | ||
6932 | |||
6933 | // Shift-right in-place | ||
6934 | // NOTE: `hint` is a lowest bit before trailing zeroes | ||
6935 | // NOTE: if `extended` is present - it will be filled with destroyed bits | ||
6936 | BN.prototype.iushrn = function iushrn (bits, hint, extended) { | ||
6937 | assert(typeof bits === 'number' && bits >= 0); | ||
6938 | var h; | ||
6939 | if (hint) { | ||
6940 | h = (hint - (hint % 26)) / 26; | ||
6941 | } else { | ||
6942 | h = 0; | ||
6943 | } | ||
6944 | |||
6945 | var r = bits % 26; | ||
6946 | var s = Math.min((bits - r) / 26, this.length); | ||
6947 | var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r); | ||
6948 | var maskedWords = extended; | ||
6949 | |||
6950 | h -= s; | ||
6951 | h = Math.max(0, h); | ||
6952 | |||
6953 | // Extended mode, copy masked part | ||
6954 | if (maskedWords) { | ||
6955 | for (var i = 0; i < s; i++) { | ||
6956 | maskedWords.words[i] = this.words[i]; | ||
6957 | } | ||
6958 | maskedWords.length = s; | ||
6959 | } | ||
6960 | |||
6961 | if (s === 0) { | ||
6962 | // No-op, we should not move anything at all | ||
6963 | } else if (this.length > s) { | ||
6964 | this.length -= s; | ||
6965 | for (i = 0; i < this.length; i++) { | ||
6966 | this.words[i] = this.words[i + s]; | ||
6967 | } | ||
6968 | } else { | ||
6969 | this.words[0] = 0; | ||
6970 | this.length = 1; | ||
6971 | } | ||
6972 | |||
6973 | var carry = 0; | ||
6974 | for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) { | ||
6975 | var word = this.words[i] | 0; | ||
6976 | this.words[i] = (carry << (26 - r)) | (word >>> r); | ||
6977 | carry = word & mask; | ||
6978 | } | ||
6979 | |||
6980 | // Push carried bits as a mask | ||
6981 | if (maskedWords && carry !== 0) { | ||
6982 | maskedWords.words[maskedWords.length++] = carry; | ||
6983 | } | ||
6984 | |||
6985 | if (this.length === 0) { | ||
6986 | this.words[0] = 0; | ||
6987 | this.length = 1; | ||
6988 | } | ||
6989 | |||
6990 | return this.strip(); | ||
6991 | }; | ||
6992 | |||
6993 | BN.prototype.ishrn = function ishrn (bits, hint, extended) { | ||
6994 | // TODO(indutny): implement me | ||
6995 | assert(this.negative === 0); | ||
6996 | return this.iushrn(bits, hint, extended); | ||
6997 | }; | ||
6998 | |||
6999 | // Shift-left | ||
7000 | BN.prototype.shln = function shln (bits) { | ||
7001 | return this.clone().ishln(bits); | ||
7002 | }; | ||
7003 | |||
7004 | BN.prototype.ushln = function ushln (bits) { | ||
7005 | return this.clone().iushln(bits); | ||
7006 | }; | ||
7007 | |||
7008 | // Shift-right | ||
7009 | BN.prototype.shrn = function shrn (bits) { | ||
7010 | return this.clone().ishrn(bits); | ||
7011 | }; | ||
7012 | |||
7013 | BN.prototype.ushrn = function ushrn (bits) { | ||
7014 | return this.clone().iushrn(bits); | ||
7015 | }; | ||
7016 | |||
7017 | // Test if n bit is set | ||
7018 | BN.prototype.testn = function testn (bit) { | ||
7019 | assert(typeof bit === 'number' && bit >= 0); | ||
7020 | var r = bit % 26; | ||
7021 | var s = (bit - r) / 26; | ||
7022 | var q = 1 << r; | ||
7023 | |||
7024 | // Fast case: bit is much higher than all existing words | ||
7025 | if (this.length <= s) return false; | ||
7026 | |||
7027 | // Check bit and return | ||
7028 | var w = this.words[s]; | ||
7029 | |||
7030 | return !!(w & q); | ||
7031 | }; | ||
7032 | |||
7033 | // Return only lowers bits of number (in-place) | ||
7034 | BN.prototype.imaskn = function imaskn (bits) { | ||
7035 | assert(typeof bits === 'number' && bits >= 0); | ||
7036 | var r = bits % 26; | ||
7037 | var s = (bits - r) / 26; | ||
7038 | |||
7039 | assert(this.negative === 0, 'imaskn works only with positive numbers'); | ||
7040 | |||
7041 | if (this.length <= s) { | ||
7042 | return this; | ||
7043 | } | ||
7044 | |||
7045 | if (r !== 0) { | ||
7046 | s++; | ||
7047 | } | ||
7048 | this.length = Math.min(s, this.length); | ||
7049 | |||
7050 | if (r !== 0) { | ||
7051 | var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r); | ||
7052 | this.words[this.length - 1] &= mask; | ||
7053 | } | ||
7054 | |||
7055 | return this.strip(); | ||
7056 | }; | ||
7057 | |||
7058 | // Return only lowers bits of number | ||
7059 | BN.prototype.maskn = function maskn (bits) { | ||
7060 | return this.clone().imaskn(bits); | ||
7061 | }; | ||
7062 | |||
7063 | // Add plain number `num` to `this` | ||
7064 | BN.prototype.iaddn = function iaddn (num) { | ||
7065 | assert(typeof num === 'number'); | ||
7066 | assert(num < 0x4000000); | ||
7067 | if (num < 0) return this.isubn(-num); | ||
7068 | |||
7069 | // Possible sign change | ||
7070 | if (this.negative !== 0) { | ||
7071 | if (this.length === 1 && (this.words[0] | 0) < num) { | ||
7072 | this.words[0] = num - (this.words[0] | 0); | ||
7073 | this.negative = 0; | ||
7074 | return this; | ||
7075 | } | ||
7076 | |||
7077 | this.negative = 0; | ||
7078 | this.isubn(num); | ||
7079 | this.negative = 1; | ||
7080 | return this; | ||
7081 | } | ||
7082 | |||
7083 | // Add without checks | ||
7084 | return this._iaddn(num); | ||
7085 | }; | ||
7086 | |||
7087 | BN.prototype._iaddn = function _iaddn (num) { | ||
7088 | this.words[0] += num; | ||
7089 | |||
7090 | // Carry | ||
7091 | for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) { | ||
7092 | this.words[i] -= 0x4000000; | ||
7093 | if (i === this.length - 1) { | ||
7094 | this.words[i + 1] = 1; | ||
7095 | } else { | ||
7096 | this.words[i + 1]++; | ||
7097 | } | ||
7098 | } | ||
7099 | this.length = Math.max(this.length, i + 1); | ||
7100 | |||
7101 | return this; | ||
7102 | }; | ||
7103 | |||
7104 | // Subtract plain number `num` from `this` | ||
7105 | BN.prototype.isubn = function isubn (num) { | ||
7106 | assert(typeof num === 'number'); | ||
7107 | assert(num < 0x4000000); | ||
7108 | if (num < 0) return this.iaddn(-num); | ||
7109 | |||
7110 | if (this.negative !== 0) { | ||
7111 | this.negative = 0; | ||
7112 | this.iaddn(num); | ||
7113 | this.negative = 1; | ||
7114 | return this; | ||
7115 | } | ||
7116 | |||
7117 | this.words[0] -= num; | ||
7118 | |||
7119 | if (this.length === 1 && this.words[0] < 0) { | ||
7120 | this.words[0] = -this.words[0]; | ||
7121 | this.negative = 1; | ||
7122 | } else { | ||
7123 | // Carry | ||
7124 | for (var i = 0; i < this.length && this.words[i] < 0; i++) { | ||
7125 | this.words[i] += 0x4000000; | ||
7126 | this.words[i + 1] -= 1; | ||
7127 | } | ||
7128 | } | ||
7129 | |||
7130 | return this.strip(); | ||
7131 | }; | ||
7132 | |||
7133 | BN.prototype.addn = function addn (num) { | ||
7134 | return this.clone().iaddn(num); | ||
7135 | }; | ||
7136 | |||
7137 | BN.prototype.subn = function subn (num) { | ||
7138 | return this.clone().isubn(num); | ||
7139 | }; | ||
7140 | |||
7141 | BN.prototype.iabs = function iabs () { | ||
7142 | this.negative = 0; | ||
7143 | |||
7144 | return this; | ||
7145 | }; | ||
7146 | |||
7147 | BN.prototype.abs = function abs () { | ||
7148 | return this.clone().iabs(); | ||
7149 | }; | ||
7150 | |||
7151 | BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) { | ||
7152 | var len = num.length + shift; | ||
7153 | var i; | ||
7154 | |||
7155 | this._expand(len); | ||
7156 | |||
7157 | var w; | ||
7158 | var carry = 0; | ||
7159 | for (i = 0; i < num.length; i++) { | ||
7160 | w = (this.words[i + shift] | 0) + carry; | ||
7161 | var right = (num.words[i] | 0) * mul; | ||
7162 | w -= right & 0x3ffffff; | ||
7163 | carry = (w >> 26) - ((right / 0x4000000) | 0); | ||
7164 | this.words[i + shift] = w & 0x3ffffff; | ||
7165 | } | ||
7166 | for (; i < this.length - shift; i++) { | ||
7167 | w = (this.words[i + shift] | 0) + carry; | ||
7168 | carry = w >> 26; | ||
7169 | this.words[i + shift] = w & 0x3ffffff; | ||
7170 | } | ||
7171 | |||
7172 | if (carry === 0) return this.strip(); | ||
7173 | |||
7174 | // Subtraction overflow | ||
7175 | assert(carry === -1); | ||
7176 | carry = 0; | ||
7177 | for (i = 0; i < this.length; i++) { | ||
7178 | w = -(this.words[i] | 0) + carry; | ||
7179 | carry = w >> 26; | ||
7180 | this.words[i] = w & 0x3ffffff; | ||
7181 | } | ||
7182 | this.negative = 1; | ||
7183 | |||
7184 | return this.strip(); | ||
7185 | }; | ||
7186 | |||
7187 | BN.prototype._wordDiv = function _wordDiv (num, mode) { | ||
7188 | var shift = this.length - num.length; | ||
7189 | |||
7190 | var a = this.clone(); | ||
7191 | var b = num; | ||
7192 | |||
7193 | // Normalize | ||
7194 | var bhi = b.words[b.length - 1] | 0; | ||
7195 | var bhiBits = this._countBits(bhi); | ||
7196 | shift = 26 - bhiBits; | ||
7197 | if (shift !== 0) { | ||
7198 | b = b.ushln(shift); | ||
7199 | a.iushln(shift); | ||
7200 | bhi = b.words[b.length - 1] | 0; | ||
7201 | } | ||
7202 | |||
7203 | // Initialize quotient | ||
7204 | var m = a.length - b.length; | ||
7205 | var q; | ||
7206 | |||
7207 | if (mode !== 'mod') { | ||
7208 | q = new BN(null); | ||
7209 | q.length = m + 1; | ||
7210 | q.words = new Array(q.length); | ||
7211 | for (var i = 0; i < q.length; i++) { | ||
7212 | q.words[i] = 0; | ||
7213 | } | ||
7214 | } | ||
7215 | |||
7216 | var diff = a.clone()._ishlnsubmul(b, 1, m); | ||
7217 | if (diff.negative === 0) { | ||
7218 | a = diff; | ||
7219 | if (q) { | ||
7220 | q.words[m] = 1; | ||
7221 | } | ||
7222 | } | ||
7223 | |||
7224 | for (var j = m - 1; j >= 0; j--) { | ||
7225 | var qj = (a.words[b.length + j] | 0) * 0x4000000 + | ||
7226 | (a.words[b.length + j - 1] | 0); | ||
7227 | |||
7228 | // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max | ||
7229 | // (0x7ffffff) | ||
7230 | qj = Math.min((qj / bhi) | 0, 0x3ffffff); | ||
7231 | |||
7232 | a._ishlnsubmul(b, qj, j); | ||
7233 | while (a.negative !== 0) { | ||
7234 | qj--; | ||
7235 | a.negative = 0; | ||
7236 | a._ishlnsubmul(b, 1, j); | ||
7237 | if (!a.isZero()) { | ||
7238 | a.negative ^= 1; | ||
7239 | } | ||
7240 | } | ||
7241 | if (q) { | ||
7242 | q.words[j] = qj; | ||
7243 | } | ||
7244 | } | ||
7245 | if (q) { | ||
7246 | q.strip(); | ||
7247 | } | ||
7248 | a.strip(); | ||
7249 | |||
7250 | // Denormalize | ||
7251 | if (mode !== 'div' && shift !== 0) { | ||
7252 | a.iushrn(shift); | ||
7253 | } | ||
7254 | |||
7255 | return { | ||
7256 | div: q || null, | ||
7257 | mod: a | ||
7258 | }; | ||
7259 | }; | ||
7260 | |||
7261 | // NOTE: 1) `mode` can be set to `mod` to request mod only, | ||
7262 | // to `div` to request div only, or be absent to | ||
7263 | // request both div & mod | ||
7264 | // 2) `positive` is true if unsigned mod is requested | ||
7265 | BN.prototype.divmod = function divmod (num, mode, positive) { | ||
7266 | assert(!num.isZero()); | ||
7267 | |||
7268 | if (this.isZero()) { | ||
7269 | return { | ||
7270 | div: new BN(0), | ||
7271 | mod: new BN(0) | ||
7272 | }; | ||
7273 | } | ||
7274 | |||
7275 | var div, mod, res; | ||
7276 | if (this.negative !== 0 && num.negative === 0) { | ||
7277 | res = this.neg().divmod(num, mode); | ||
7278 | |||
7279 | if (mode !== 'mod') { | ||
7280 | div = res.div.neg(); | ||
7281 | } | ||
7282 | |||
7283 | if (mode !== 'div') { | ||
7284 | mod = res.mod.neg(); | ||
7285 | if (positive && mod.negative !== 0) { | ||
7286 | mod.iadd(num); | ||
7287 | } | ||
7288 | } | ||
7289 | |||
7290 | return { | ||
7291 | div: div, | ||
7292 | mod: mod | ||
7293 | }; | ||
7294 | } | ||
7295 | |||
7296 | if (this.negative === 0 && num.negative !== 0) { | ||
7297 | res = this.divmod(num.neg(), mode); | ||
7298 | |||
7299 | if (mode !== 'mod') { | ||
7300 | div = res.div.neg(); | ||
7301 | } | ||
7302 | |||
7303 | return { | ||
7304 | div: div, | ||
7305 | mod: res.mod | ||
7306 | }; | ||
7307 | } | ||
7308 | |||
7309 | if ((this.negative & num.negative) !== 0) { | ||
7310 | res = this.neg().divmod(num.neg(), mode); | ||
7311 | |||
7312 | if (mode !== 'div') { | ||
7313 | mod = res.mod.neg(); | ||
7314 | if (positive && mod.negative !== 0) { | ||
7315 | mod.isub(num); | ||
7316 | } | ||
7317 | } | ||
7318 | |||
7319 | return { | ||
7320 | div: res.div, | ||
7321 | mod: mod | ||
7322 | }; | ||
7323 | } | ||
7324 | |||
7325 | // Both numbers are positive at this point | ||
7326 | |||
7327 | // Strip both numbers to approximate shift value | ||
7328 | if (num.length > this.length || this.cmp(num) < 0) { | ||
7329 | return { | ||
7330 | div: new BN(0), | ||
7331 | mod: this | ||
7332 | }; | ||
7333 | } | ||
7334 | |||
7335 | // Very short reduction | ||
7336 | if (num.length === 1) { | ||
7337 | if (mode === 'div') { | ||
7338 | return { | ||
7339 | div: this.divn(num.words[0]), | ||
7340 | mod: null | ||
7341 | }; | ||
7342 | } | ||
7343 | |||
7344 | if (mode === 'mod') { | ||
7345 | return { | ||
7346 | div: null, | ||
7347 | mod: new BN(this.modn(num.words[0])) | ||
7348 | }; | ||
7349 | } | ||
7350 | |||
7351 | return { | ||
7352 | div: this.divn(num.words[0]), | ||
7353 | mod: new BN(this.modn(num.words[0])) | ||
7354 | }; | ||
7355 | } | ||
7356 | |||
7357 | return this._wordDiv(num, mode); | ||
7358 | }; | ||
7359 | |||
7360 | // Find `this` / `num` | ||
7361 | BN.prototype.div = function div (num) { | ||
7362 | return this.divmod(num, 'div', false).div; | ||
7363 | }; | ||
7364 | |||
7365 | // Find `this` % `num` | ||
7366 | BN.prototype.mod = function mod (num) { | ||
7367 | return this.divmod(num, 'mod', false).mod; | ||
7368 | }; | ||
7369 | |||
7370 | BN.prototype.umod = function umod (num) { | ||
7371 | return this.divmod(num, 'mod', true).mod; | ||
7372 | }; | ||
7373 | |||
7374 | // Find Round(`this` / `num`) | ||
7375 | BN.prototype.divRound = function divRound (num) { | ||
7376 | var dm = this.divmod(num); | ||
7377 | |||
7378 | // Fast case - exact division | ||
7379 | if (dm.mod.isZero()) return dm.div; | ||
7380 | |||
7381 | var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod; | ||
7382 | |||
7383 | var half = num.ushrn(1); | ||
7384 | var r2 = num.andln(1); | ||
7385 | var cmp = mod.cmp(half); | ||
7386 | |||
7387 | // Round down | ||
7388 | if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div; | ||
7389 | |||
7390 | // Round up | ||
7391 | return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1); | ||
7392 | }; | ||
7393 | |||
7394 | BN.prototype.modn = function modn (num) { | ||
7395 | assert(num <= 0x3ffffff); | ||
7396 | var p = (1 << 26) % num; | ||
7397 | |||
7398 | var acc = 0; | ||
7399 | for (var i = this.length - 1; i >= 0; i--) { | ||
7400 | acc = (p * acc + (this.words[i] | 0)) % num; | ||
7401 | } | ||
7402 | |||
7403 | return acc; | ||
7404 | }; | ||
7405 | |||
7406 | // In-place division by number | ||
7407 | BN.prototype.idivn = function idivn (num) { | ||
7408 | assert(num <= 0x3ffffff); | ||
7409 | |||
7410 | var carry = 0; | ||
7411 | for (var i = this.length - 1; i >= 0; i--) { | ||
7412 | var w = (this.words[i] | 0) + carry * 0x4000000; | ||
7413 | this.words[i] = (w / num) | 0; | ||
7414 | carry = w % num; | ||
7415 | } | ||
7416 | |||
7417 | return this.strip(); | ||
7418 | }; | ||
7419 | |||
7420 | BN.prototype.divn = function divn (num) { | ||
7421 | return this.clone().idivn(num); | ||
7422 | }; | ||
7423 | |||
7424 | BN.prototype.egcd = function egcd (p) { | ||
7425 | assert(p.negative === 0); | ||
7426 | assert(!p.isZero()); | ||
7427 | |||
7428 | var x = this; | ||
7429 | var y = p.clone(); | ||
7430 | |||
7431 | if (x.negative !== 0) { | ||
7432 | x = x.umod(p); | ||
7433 | } else { | ||
7434 | x = x.clone(); | ||
7435 | } | ||
7436 | |||
7437 | // A * x + B * y = x | ||
7438 | var A = new BN(1); | ||
7439 | var B = new BN(0); | ||
7440 | |||
7441 | // C * x + D * y = y | ||
7442 | var C = new BN(0); | ||
7443 | var D = new BN(1); | ||
7444 | |||
7445 | var g = 0; | ||
7446 | |||
7447 | while (x.isEven() && y.isEven()) { | ||
7448 | x.iushrn(1); | ||
7449 | y.iushrn(1); | ||
7450 | ++g; | ||
7451 | } | ||
7452 | |||
7453 | var yp = y.clone(); | ||
7454 | var xp = x.clone(); | ||
7455 | |||
7456 | while (!x.isZero()) { | ||
7457 | for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1); | ||
7458 | if (i > 0) { | ||
7459 | x.iushrn(i); | ||
7460 | while (i-- > 0) { | ||
7461 | if (A.isOdd() || B.isOdd()) { | ||
7462 | A.iadd(yp); | ||
7463 | B.isub(xp); | ||
7464 | } | ||
7465 | |||
7466 | A.iushrn(1); | ||
7467 | B.iushrn(1); | ||
7468 | } | ||
7469 | } | ||
7470 | |||
7471 | for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1); | ||
7472 | if (j > 0) { | ||
7473 | y.iushrn(j); | ||
7474 | while (j-- > 0) { | ||
7475 | if (C.isOdd() || D.isOdd()) { | ||
7476 | C.iadd(yp); | ||
7477 | D.isub(xp); | ||
7478 | } | ||
7479 | |||
7480 | C.iushrn(1); | ||
7481 | D.iushrn(1); | ||
7482 | } | ||
7483 | } | ||
7484 | |||
7485 | if (x.cmp(y) >= 0) { | ||
7486 | x.isub(y); | ||
7487 | A.isub(C); | ||
7488 | B.isub(D); | ||
7489 | } else { | ||
7490 | y.isub(x); | ||
7491 | C.isub(A); | ||
7492 | D.isub(B); | ||
7493 | } | ||
7494 | } | ||
7495 | |||
7496 | return { | ||
7497 | a: C, | ||
7498 | b: D, | ||
7499 | gcd: y.iushln(g) | ||
7500 | }; | ||
7501 | }; | ||
7502 | |||
7503 | // This is reduced incarnation of the binary EEA | ||
7504 | // above, designated to invert members of the | ||
7505 | // _prime_ fields F(p) at a maximal speed | ||
7506 | BN.prototype._invmp = function _invmp (p) { | ||
7507 | assert(p.negative === 0); | ||
7508 | assert(!p.isZero()); | ||
7509 | |||
7510 | var a = this; | ||
7511 | var b = p.clone(); | ||
7512 | |||
7513 | if (a.negative !== 0) { | ||
7514 | a = a.umod(p); | ||
7515 | } else { | ||
7516 | a = a.clone(); | ||
7517 | } | ||
7518 | |||
7519 | var x1 = new BN(1); | ||
7520 | var x2 = new BN(0); | ||
7521 | |||
7522 | var delta = b.clone(); | ||
7523 | |||
7524 | while (a.cmpn(1) > 0 && b.cmpn(1) > 0) { | ||
7525 | for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1); | ||
7526 | if (i > 0) { | ||
7527 | a.iushrn(i); | ||
7528 | while (i-- > 0) { | ||
7529 | if (x1.isOdd()) { | ||
7530 | x1.iadd(delta); | ||
7531 | } | ||
7532 | |||
7533 | x1.iushrn(1); | ||
7534 | } | ||
7535 | } | ||
7536 | |||
7537 | for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1); | ||
7538 | if (j > 0) { | ||
7539 | b.iushrn(j); | ||
7540 | while (j-- > 0) { | ||
7541 | if (x2.isOdd()) { | ||
7542 | x2.iadd(delta); | ||
7543 | } | ||
7544 | |||
7545 | x2.iushrn(1); | ||
7546 | } | ||
7547 | } | ||
7548 | |||
7549 | if (a.cmp(b) >= 0) { | ||
7550 | a.isub(b); | ||
7551 | x1.isub(x2); | ||
7552 | } else { | ||
7553 | b.isub(a); | ||
7554 | x2.isub(x1); | ||
7555 | } | ||
7556 | } | ||
7557 | |||
7558 | var res; | ||
7559 | if (a.cmpn(1) === 0) { | ||
7560 | res = x1; | ||
7561 | } else { | ||
7562 | res = x2; | ||
7563 | } | ||
7564 | |||
7565 | if (res.cmpn(0) < 0) { | ||
7566 | res.iadd(p); | ||
7567 | } | ||
7568 | |||
7569 | return res; | ||
7570 | }; | ||
7571 | |||
7572 | BN.prototype.gcd = function gcd (num) { | ||
7573 | if (this.isZero()) return num.abs(); | ||
7574 | if (num.isZero()) return this.abs(); | ||
7575 | |||
7576 | var a = this.clone(); | ||
7577 | var b = num.clone(); | ||
7578 | a.negative = 0; | ||
7579 | b.negative = 0; | ||
7580 | |||
7581 | // Remove common factor of two | ||
7582 | for (var shift = 0; a.isEven() && b.isEven(); shift++) { | ||
7583 | a.iushrn(1); | ||
7584 | b.iushrn(1); | ||
7585 | } | ||
7586 | |||
7587 | do { | ||
7588 | while (a.isEven()) { | ||
7589 | a.iushrn(1); | ||
7590 | } | ||
7591 | while (b.isEven()) { | ||
7592 | b.iushrn(1); | ||
7593 | } | ||
7594 | |||
7595 | var r = a.cmp(b); | ||
7596 | if (r < 0) { | ||
7597 | // Swap `a` and `b` to make `a` always bigger than `b` | ||
7598 | var t = a; | ||
7599 | a = b; | ||
7600 | b = t; | ||
7601 | } else if (r === 0 || b.cmpn(1) === 0) { | ||
7602 | break; | ||
7603 | } | ||
7604 | |||
7605 | a.isub(b); | ||
7606 | } while (true); | ||
7607 | |||
7608 | return b.iushln(shift); | ||
7609 | }; | ||
7610 | |||
7611 | // Invert number in the field F(num) | ||
7612 | BN.prototype.invm = function invm (num) { | ||
7613 | return this.egcd(num).a.umod(num); | ||
7614 | }; | ||
7615 | |||
7616 | BN.prototype.isEven = function isEven () { | ||
7617 | return (this.words[0] & 1) === 0; | ||
7618 | }; | ||
7619 | |||
7620 | BN.prototype.isOdd = function isOdd () { | ||
7621 | return (this.words[0] & 1) === 1; | ||
7622 | }; | ||
7623 | |||
7624 | // And first word and num | ||
7625 | BN.prototype.andln = function andln (num) { | ||
7626 | return this.words[0] & num; | ||
7627 | }; | ||
7628 | |||
7629 | // Increment at the bit position in-line | ||
7630 | BN.prototype.bincn = function bincn (bit) { | ||
7631 | assert(typeof bit === 'number'); | ||
7632 | var r = bit % 26; | ||
7633 | var s = (bit - r) / 26; | ||
7634 | var q = 1 << r; | ||
7635 | |||
7636 | // Fast case: bit is much higher than all existing words | ||
7637 | if (this.length <= s) { | ||
7638 | this._expand(s + 1); | ||
7639 | this.words[s] |= q; | ||
7640 | return this; | ||
7641 | } | ||
7642 | |||
7643 | // Add bit and propagate, if needed | ||
7644 | var carry = q; | ||
7645 | for (var i = s; carry !== 0 && i < this.length; i++) { | ||
7646 | var w = this.words[i] | 0; | ||
7647 | w += carry; | ||
7648 | carry = w >>> 26; | ||
7649 | w &= 0x3ffffff; | ||
7650 | this.words[i] = w; | ||
7651 | } | ||
7652 | if (carry !== 0) { | ||
7653 | this.words[i] = carry; | ||
7654 | this.length++; | ||
7655 | } | ||
7656 | return this; | ||
7657 | }; | ||
7658 | |||
7659 | BN.prototype.isZero = function isZero () { | ||
7660 | return this.length === 1 && this.words[0] === 0; | ||
7661 | }; | ||
7662 | |||
7663 | BN.prototype.cmpn = function cmpn (num) { | ||
7664 | var negative = num < 0; | ||
7665 | |||
7666 | if (this.negative !== 0 && !negative) return -1; | ||
7667 | if (this.negative === 0 && negative) return 1; | ||
7668 | |||
7669 | this.strip(); | ||
7670 | |||
7671 | var res; | ||
7672 | if (this.length > 1) { | ||
7673 | res = 1; | ||
7674 | } else { | ||
7675 | if (negative) { | ||
7676 | num = -num; | ||
7677 | } | ||
7678 | |||
7679 | assert(num <= 0x3ffffff, 'Number is too big'); | ||
7680 | |||
7681 | var w = this.words[0] | 0; | ||
7682 | res = w === num ? 0 : w < num ? -1 : 1; | ||
7683 | } | ||
7684 | if (this.negative !== 0) return -res | 0; | ||
7685 | return res; | ||
7686 | }; | ||
7687 | |||
7688 | // Compare two numbers and return: | ||
7689 | // 1 - if `this` > `num` | ||
7690 | // 0 - if `this` == `num` | ||
7691 | // -1 - if `this` < `num` | ||
7692 | BN.prototype.cmp = function cmp (num) { | ||
7693 | if (this.negative !== 0 && num.negative === 0) return -1; | ||
7694 | if (this.negative === 0 && num.negative !== 0) return 1; | ||
7695 | |||
7696 | var res = this.ucmp(num); | ||
7697 | if (this.negative !== 0) return -res | 0; | ||
7698 | return res; | ||
7699 | }; | ||
7700 | |||
7701 | // Unsigned comparison | ||
7702 | BN.prototype.ucmp = function ucmp (num) { | ||
7703 | // At this point both numbers have the same sign | ||
7704 | if (this.length > num.length) return 1; | ||
7705 | if (this.length < num.length) return -1; | ||
7706 | |||
7707 | var res = 0; | ||
7708 | for (var i = this.length - 1; i >= 0; i--) { | ||
7709 | var a = this.words[i] | 0; | ||
7710 | var b = num.words[i] | 0; | ||
7711 | |||
7712 | if (a === b) continue; | ||
7713 | if (a < b) { | ||
7714 | res = -1; | ||
7715 | } else if (a > b) { | ||
7716 | res = 1; | ||
7717 | } | ||
7718 | break; | ||
7719 | } | ||
7720 | return res; | ||
7721 | }; | ||
7722 | |||
7723 | BN.prototype.gtn = function gtn (num) { | ||
7724 | return this.cmpn(num) === 1; | ||
7725 | }; | ||
7726 | |||
7727 | BN.prototype.gt = function gt (num) { | ||
7728 | return this.cmp(num) === 1; | ||
7729 | }; | ||
7730 | |||
7731 | BN.prototype.gten = function gten (num) { | ||
7732 | return this.cmpn(num) >= 0; | ||
7733 | }; | ||
7734 | |||
7735 | BN.prototype.gte = function gte (num) { | ||
7736 | return this.cmp(num) >= 0; | ||
7737 | }; | ||
7738 | |||
7739 | BN.prototype.ltn = function ltn (num) { | ||
7740 | return this.cmpn(num) === -1; | ||
7741 | }; | ||
7742 | |||
7743 | BN.prototype.lt = function lt (num) { | ||
7744 | return this.cmp(num) === -1; | ||
7745 | }; | ||
7746 | |||
7747 | BN.prototype.lten = function lten (num) { | ||
7748 | return this.cmpn(num) <= 0; | ||
7749 | }; | ||
7750 | |||
7751 | BN.prototype.lte = function lte (num) { | ||
7752 | return this.cmp(num) <= 0; | ||
7753 | }; | ||
7754 | |||
7755 | BN.prototype.eqn = function eqn (num) { | ||
7756 | return this.cmpn(num) === 0; | ||
7757 | }; | ||
7758 | |||
7759 | BN.prototype.eq = function eq (num) { | ||
7760 | return this.cmp(num) === 0; | ||
7761 | }; | ||
7762 | |||
7763 | // | ||
7764 | // A reduce context, could be using montgomery or something better, depending | ||
7765 | // on the `m` itself. | ||
7766 | // | ||
7767 | BN.red = function red (num) { | ||
7768 | return new Red(num); | ||
7769 | }; | ||
7770 | |||
7771 | BN.prototype.toRed = function toRed (ctx) { | ||
7772 | assert(!this.red, 'Already a number in reduction context'); | ||
7773 | assert(this.negative === 0, 'red works only with positives'); | ||
7774 | return ctx.convertTo(this)._forceRed(ctx); | ||
7775 | }; | ||
7776 | |||
7777 | BN.prototype.fromRed = function fromRed () { | ||
7778 | assert(this.red, 'fromRed works only with numbers in reduction context'); | ||
7779 | return this.red.convertFrom(this); | ||
7780 | }; | ||
7781 | |||
7782 | BN.prototype._forceRed = function _forceRed (ctx) { | ||
7783 | this.red = ctx; | ||
7784 | return this; | ||
7785 | }; | ||
7786 | |||
7787 | BN.prototype.forceRed = function forceRed (ctx) { | ||
7788 | assert(!this.red, 'Already a number in reduction context'); | ||
7789 | return this._forceRed(ctx); | ||
7790 | }; | ||
7791 | |||
7792 | BN.prototype.redAdd = function redAdd (num) { | ||
7793 | assert(this.red, 'redAdd works only with red numbers'); | ||
7794 | return this.red.add(this, num); | ||
7795 | }; | ||
7796 | |||
7797 | BN.prototype.redIAdd = function redIAdd (num) { | ||
7798 | assert(this.red, 'redIAdd works only with red numbers'); | ||
7799 | return this.red.iadd(this, num); | ||
7800 | }; | ||
7801 | |||
7802 | BN.prototype.redSub = function redSub (num) { | ||
7803 | assert(this.red, 'redSub works only with red numbers'); | ||
7804 | return this.red.sub(this, num); | ||
7805 | }; | ||
7806 | |||
7807 | BN.prototype.redISub = function redISub (num) { | ||
7808 | assert(this.red, 'redISub works only with red numbers'); | ||
7809 | return this.red.isub(this, num); | ||
7810 | }; | ||
7811 | |||
7812 | BN.prototype.redShl = function redShl (num) { | ||
7813 | assert(this.red, 'redShl works only with red numbers'); | ||
7814 | return this.red.shl(this, num); | ||
7815 | }; | ||
7816 | |||
7817 | BN.prototype.redMul = function redMul (num) { | ||
7818 | assert(this.red, 'redMul works only with red numbers'); | ||
7819 | this.red._verify2(this, num); | ||
7820 | return this.red.mul(this, num); | ||
7821 | }; | ||
7822 | |||
7823 | BN.prototype.redIMul = function redIMul (num) { | ||
7824 | assert(this.red, 'redMul works only with red numbers'); | ||
7825 | this.red._verify2(this, num); | ||
7826 | return this.red.imul(this, num); | ||
7827 | }; | ||
7828 | |||
7829 | BN.prototype.redSqr = function redSqr () { | ||
7830 | assert(this.red, 'redSqr works only with red numbers'); | ||
7831 | this.red._verify1(this); | ||
7832 | return this.red.sqr(this); | ||
7833 | }; | ||
7834 | |||
7835 | BN.prototype.redISqr = function redISqr () { | ||
7836 | assert(this.red, 'redISqr works only with red numbers'); | ||
7837 | this.red._verify1(this); | ||
7838 | return this.red.isqr(this); | ||
7839 | }; | ||
7840 | |||
7841 | // Square root over p | ||
7842 | BN.prototype.redSqrt = function redSqrt () { | ||
7843 | assert(this.red, 'redSqrt works only with red numbers'); | ||
7844 | this.red._verify1(this); | ||
7845 | return this.red.sqrt(this); | ||
7846 | }; | ||
7847 | |||
7848 | BN.prototype.redInvm = function redInvm () { | ||
7849 | assert(this.red, 'redInvm works only with red numbers'); | ||
7850 | this.red._verify1(this); | ||
7851 | return this.red.invm(this); | ||
7852 | }; | ||
7853 | |||
7854 | // Return negative clone of `this` % `red modulo` | ||
7855 | BN.prototype.redNeg = function redNeg () { | ||
7856 | assert(this.red, 'redNeg works only with red numbers'); | ||
7857 | this.red._verify1(this); | ||
7858 | return this.red.neg(this); | ||
7859 | }; | ||
7860 | |||
7861 | BN.prototype.redPow = function redPow (num) { | ||
7862 | assert(this.red && !num.red, 'redPow(normalNum)'); | ||
7863 | this.red._verify1(this); | ||
7864 | return this.red.pow(this, num); | ||
7865 | }; | ||
7866 | |||
7867 | // Prime numbers with efficient reduction | ||
7868 | var primes = { | ||
7869 | k256: null, | ||
7870 | p224: null, | ||
7871 | p192: null, | ||
7872 | p25519: null | ||
7873 | }; | ||
7874 | |||
7875 | // Pseudo-Mersenne prime | ||
7876 | function MPrime (name, p) { | ||
7877 | // P = 2 ^ N - K | ||
7878 | this.name = name; | ||
7879 | this.p = new BN(p, 16); | ||
7880 | this.n = this.p.bitLength(); | ||
7881 | this.k = new BN(1).iushln(this.n).isub(this.p); | ||
7882 | |||
7883 | this.tmp = this._tmp(); | ||
7884 | } | ||
7885 | |||
7886 | MPrime.prototype._tmp = function _tmp () { | ||
7887 | var tmp = new BN(null); | ||
7888 | tmp.words = new Array(Math.ceil(this.n / 13)); | ||
7889 | return tmp; | ||
7890 | }; | ||
7891 | |||
7892 | MPrime.prototype.ireduce = function ireduce (num) { | ||
7893 | // Assumes that `num` is less than `P^2` | ||
7894 | // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P) | ||
7895 | var r = num; | ||
7896 | var rlen; | ||
7897 | |||
7898 | do { | ||
7899 | this.split(r, this.tmp); | ||
7900 | r = this.imulK(r); | ||
7901 | r = r.iadd(this.tmp); | ||
7902 | rlen = r.bitLength(); | ||
7903 | } while (rlen > this.n); | ||
7904 | |||
7905 | var cmp = rlen < this.n ? -1 : r.ucmp(this.p); | ||
7906 | if (cmp === 0) { | ||
7907 | r.words[0] = 0; | ||
7908 | r.length = 1; | ||
7909 | } else if (cmp > 0) { | ||
7910 | r.isub(this.p); | ||
7911 | } else { | ||
7912 | r.strip(); | ||
7913 | } | ||
7914 | |||
7915 | return r; | ||
7916 | }; | ||
7917 | |||
7918 | MPrime.prototype.split = function split (input, out) { | ||
7919 | input.iushrn(this.n, 0, out); | ||
7920 | }; | ||
7921 | |||
7922 | MPrime.prototype.imulK = function imulK (num) { | ||
7923 | return num.imul(this.k); | ||
7924 | }; | ||
7925 | |||
7926 | function K256 () { | ||
7927 | MPrime.call( | ||
7928 | this, | ||
7929 | 'k256', | ||
7930 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f'); | ||
7931 | } | ||
7932 | inherits(K256, MPrime); | ||
7933 | |||
7934 | K256.prototype.split = function split (input, output) { | ||
7935 | // 256 = 9 * 26 + 22 | ||
7936 | var mask = 0x3fffff; | ||
7937 | |||
7938 | var outLen = Math.min(input.length, 9); | ||
7939 | for (var i = 0; i < outLen; i++) { | ||
7940 | output.words[i] = input.words[i]; | ||
7941 | } | ||
7942 | output.length = outLen; | ||
7943 | |||
7944 | if (input.length <= 9) { | ||
7945 | input.words[0] = 0; | ||
7946 | input.length = 1; | ||
7947 | return; | ||
7948 | } | ||
7949 | |||
7950 | // Shift by 9 limbs | ||
7951 | var prev = input.words[9]; | ||
7952 | output.words[output.length++] = prev & mask; | ||
7953 | |||
7954 | for (i = 10; i < input.length; i++) { | ||
7955 | var next = input.words[i] | 0; | ||
7956 | input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22); | ||
7957 | prev = next; | ||
7958 | } | ||
7959 | prev >>>= 22; | ||
7960 | input.words[i - 10] = prev; | ||
7961 | if (prev === 0 && input.length > 10) { | ||
7962 | input.length -= 10; | ||
7963 | } else { | ||
7964 | input.length -= 9; | ||
7965 | } | ||
7966 | }; | ||
7967 | |||
7968 | K256.prototype.imulK = function imulK (num) { | ||
7969 | // K = 0x1000003d1 = [ 0x40, 0x3d1 ] | ||
7970 | num.words[num.length] = 0; | ||
7971 | num.words[num.length + 1] = 0; | ||
7972 | num.length += 2; | ||
7973 | |||
7974 | // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390 | ||
7975 | var lo = 0; | ||
7976 | for (var i = 0; i < num.length; i++) { | ||
7977 | var w = num.words[i] | 0; | ||
7978 | lo += w * 0x3d1; | ||
7979 | num.words[i] = lo & 0x3ffffff; | ||
7980 | lo = w * 0x40 + ((lo / 0x4000000) | 0); | ||
7981 | } | ||
7982 | |||
7983 | // Fast length reduction | ||
7984 | if (num.words[num.length - 1] === 0) { | ||
7985 | num.length--; | ||
7986 | if (num.words[num.length - 1] === 0) { | ||
7987 | num.length--; | ||
7988 | } | ||
7989 | } | ||
7990 | return num; | ||
7991 | }; | ||
7992 | |||
7993 | function P224 () { | ||
7994 | MPrime.call( | ||
7995 | this, | ||
7996 | 'p224', | ||
7997 | 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001'); | ||
7998 | } | ||
7999 | inherits(P224, MPrime); | ||
8000 | |||
8001 | function P192 () { | ||
8002 | MPrime.call( | ||
8003 | this, | ||
8004 | 'p192', | ||
8005 | 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff'); | ||
8006 | } | ||
8007 | inherits(P192, MPrime); | ||
8008 | |||
8009 | function P25519 () { | ||
8010 | // 2 ^ 255 - 19 | ||
8011 | MPrime.call( | ||
8012 | this, | ||
8013 | '25519', | ||
8014 | '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed'); | ||
8015 | } | ||
8016 | inherits(P25519, MPrime); | ||
8017 | |||
8018 | P25519.prototype.imulK = function imulK (num) { | ||
8019 | // K = 0x13 | ||
8020 | var carry = 0; | ||
8021 | for (var i = 0; i < num.length; i++) { | ||
8022 | var hi = (num.words[i] | 0) * 0x13 + carry; | ||
8023 | var lo = hi & 0x3ffffff; | ||
8024 | hi >>>= 26; | ||
8025 | |||
8026 | num.words[i] = lo; | ||
8027 | carry = hi; | ||
8028 | } | ||
8029 | if (carry !== 0) { | ||
8030 | num.words[num.length++] = carry; | ||
8031 | } | ||
8032 | return num; | ||
8033 | }; | ||
8034 | |||
8035 | // Exported mostly for testing purposes, use plain name instead | ||
8036 | BN._prime = function prime (name) { | ||
8037 | // Cached version of prime | ||
8038 | if (primes[name]) return primes[name]; | ||
8039 | |||
8040 | var prime; | ||
8041 | if (name === 'k256') { | ||
8042 | prime = new K256(); | ||
8043 | } else if (name === 'p224') { | ||
8044 | prime = new P224(); | ||
8045 | } else if (name === 'p192') { | ||
8046 | prime = new P192(); | ||
8047 | } else if (name === 'p25519') { | ||
8048 | prime = new P25519(); | ||
8049 | } else { | ||
8050 | throw new Error('Unknown prime ' + name); | ||
8051 | } | ||
8052 | primes[name] = prime; | ||
8053 | |||
8054 | return prime; | ||
8055 | }; | ||
8056 | |||
8057 | // | ||
8058 | // Base reduction engine | ||
8059 | // | ||
8060 | function Red (m) { | ||
8061 | if (typeof m === 'string') { | ||
8062 | var prime = BN._prime(m); | ||
8063 | this.m = prime.p; | ||
8064 | this.prime = prime; | ||
8065 | } else { | ||
8066 | assert(m.gtn(1), 'modulus must be greater than 1'); | ||
8067 | this.m = m; | ||
8068 | this.prime = null; | ||
8069 | } | ||
8070 | } | ||
8071 | |||
8072 | Red.prototype._verify1 = function _verify1 (a) { | ||
8073 | assert(a.negative === 0, 'red works only with positives'); | ||
8074 | assert(a.red, 'red works only with red numbers'); | ||
8075 | }; | ||
8076 | |||
8077 | Red.prototype._verify2 = function _verify2 (a, b) { | ||
8078 | assert((a.negative | b.negative) === 0, 'red works only with positives'); | ||
8079 | assert(a.red && a.red === b.red, | ||
8080 | 'red works only with red numbers'); | ||
8081 | }; | ||
8082 | |||
8083 | Red.prototype.imod = function imod (a) { | ||
8084 | if (this.prime) return this.prime.ireduce(a)._forceRed(this); | ||
8085 | return a.umod(this.m)._forceRed(this); | ||
8086 | }; | ||
8087 | |||
8088 | Red.prototype.neg = function neg (a) { | ||
8089 | if (a.isZero()) { | ||
8090 | return a.clone(); | ||
8091 | } | ||
8092 | |||
8093 | return this.m.sub(a)._forceRed(this); | ||
8094 | }; | ||
8095 | |||
8096 | Red.prototype.add = function add (a, b) { | ||
8097 | this._verify2(a, b); | ||
8098 | |||
8099 | var res = a.add(b); | ||
8100 | if (res.cmp(this.m) >= 0) { | ||
8101 | res.isub(this.m); | ||
8102 | } | ||
8103 | return res._forceRed(this); | ||
8104 | }; | ||
8105 | |||
8106 | Red.prototype.iadd = function iadd (a, b) { | ||
8107 | this._verify2(a, b); | ||
8108 | |||
8109 | var res = a.iadd(b); | ||
8110 | if (res.cmp(this.m) >= 0) { | ||
8111 | res.isub(this.m); | ||
8112 | } | ||
8113 | return res; | ||
8114 | }; | ||
8115 | |||
8116 | Red.prototype.sub = function sub (a, b) { | ||
8117 | this._verify2(a, b); | ||
8118 | |||
8119 | var res = a.sub(b); | ||
8120 | if (res.cmpn(0) < 0) { | ||
8121 | res.iadd(this.m); | ||
8122 | } | ||
8123 | return res._forceRed(this); | ||
8124 | }; | ||
8125 | |||
8126 | Red.prototype.isub = function isub (a, b) { | ||
8127 | this._verify2(a, b); | ||
8128 | |||
8129 | var res = a.isub(b); | ||
8130 | if (res.cmpn(0) < 0) { | ||
8131 | res.iadd(this.m); | ||
8132 | } | ||
8133 | return res; | ||
8134 | }; | ||
8135 | |||
8136 | Red.prototype.shl = function shl (a, num) { | ||
8137 | this._verify1(a); | ||
8138 | return this.imod(a.ushln(num)); | ||
8139 | }; | ||
8140 | |||
8141 | Red.prototype.imul = function imul (a, b) { | ||
8142 | this._verify2(a, b); | ||
8143 | return this.imod(a.imul(b)); | ||
8144 | }; | ||
8145 | |||
8146 | Red.prototype.mul = function mul (a, b) { | ||
8147 | this._verify2(a, b); | ||
8148 | return this.imod(a.mul(b)); | ||
8149 | }; | ||
8150 | |||
8151 | Red.prototype.isqr = function isqr (a) { | ||
8152 | return this.imul(a, a.clone()); | ||
8153 | }; | ||
8154 | |||
8155 | Red.prototype.sqr = function sqr (a) { | ||
8156 | return this.mul(a, a); | ||
8157 | }; | ||
8158 | |||
8159 | Red.prototype.sqrt = function sqrt (a) { | ||
8160 | if (a.isZero()) return a.clone(); | ||
8161 | |||
8162 | var mod3 = this.m.andln(3); | ||
8163 | assert(mod3 % 2 === 1); | ||
8164 | |||
8165 | // Fast case | ||
8166 | if (mod3 === 3) { | ||
8167 | var pow = this.m.add(new BN(1)).iushrn(2); | ||
8168 | return this.pow(a, pow); | ||
8169 | } | ||
8170 | |||
8171 | // Tonelli-Shanks algorithm (Totally unoptimized and slow) | ||
8172 | // | ||
8173 | // Find Q and S, that Q * 2 ^ S = (P - 1) | ||
8174 | var q = this.m.subn(1); | ||
8175 | var s = 0; | ||
8176 | while (!q.isZero() && q.andln(1) === 0) { | ||
8177 | s++; | ||
8178 | q.iushrn(1); | ||
8179 | } | ||
8180 | assert(!q.isZero()); | ||
8181 | |||
8182 | var one = new BN(1).toRed(this); | ||
8183 | var nOne = one.redNeg(); | ||
8184 | |||
8185 | // Find quadratic non-residue | ||
8186 | // NOTE: Max is such because of generalized Riemann hypothesis. | ||
8187 | var lpow = this.m.subn(1).iushrn(1); | ||
8188 | var z = this.m.bitLength(); | ||
8189 | z = new BN(2 * z * z).toRed(this); | ||
8190 | |||
8191 | while (this.pow(z, lpow).cmp(nOne) !== 0) { | ||
8192 | z.redIAdd(nOne); | ||
8193 | } | ||
8194 | |||
8195 | var c = this.pow(z, q); | ||
8196 | var r = this.pow(a, q.addn(1).iushrn(1)); | ||
8197 | var t = this.pow(a, q); | ||
8198 | var m = s; | ||
8199 | while (t.cmp(one) !== 0) { | ||
8200 | var tmp = t; | ||
8201 | for (var i = 0; tmp.cmp(one) !== 0; i++) { | ||
8202 | tmp = tmp.redSqr(); | ||
8203 | } | ||
8204 | assert(i < m); | ||
8205 | var b = this.pow(c, new BN(1).iushln(m - i - 1)); | ||
8206 | |||
8207 | r = r.redMul(b); | ||
8208 | c = b.redSqr(); | ||
8209 | t = t.redMul(c); | ||
8210 | m = i; | ||
8211 | } | ||
8212 | |||
8213 | return r; | ||
8214 | }; | ||
8215 | |||
8216 | Red.prototype.invm = function invm (a) { | ||
8217 | var inv = a._invmp(this.m); | ||
8218 | if (inv.negative !== 0) { | ||
8219 | inv.negative = 0; | ||
8220 | return this.imod(inv).redNeg(); | ||
8221 | } else { | ||
8222 | return this.imod(inv); | ||
8223 | } | ||
8224 | }; | ||
8225 | |||
8226 | Red.prototype.pow = function pow (a, num) { | ||
8227 | if (num.isZero()) return new BN(1).toRed(this); | ||
8228 | if (num.cmpn(1) === 0) return a.clone(); | ||
8229 | |||
8230 | var windowSize = 4; | ||
8231 | var wnd = new Array(1 << windowSize); | ||
8232 | wnd[0] = new BN(1).toRed(this); | ||
8233 | wnd[1] = a; | ||
8234 | for (var i = 2; i < wnd.length; i++) { | ||
8235 | wnd[i] = this.mul(wnd[i - 1], a); | ||
8236 | } | ||
8237 | |||
8238 | var res = wnd[0]; | ||
8239 | var current = 0; | ||
8240 | var currentLen = 0; | ||
8241 | var start = num.bitLength() % 26; | ||
8242 | if (start === 0) { | ||
8243 | start = 26; | ||
8244 | } | ||
8245 | |||
8246 | for (i = num.length - 1; i >= 0; i--) { | ||
8247 | var word = num.words[i]; | ||
8248 | for (var j = start - 1; j >= 0; j--) { | ||
8249 | var bit = (word >> j) & 1; | ||
8250 | if (res !== wnd[0]) { | ||
8251 | res = this.sqr(res); | ||
8252 | } | ||
8253 | |||
8254 | if (bit === 0 && current === 0) { | ||
8255 | currentLen = 0; | ||
8256 | continue; | ||
8257 | } | ||
8258 | |||
8259 | current <<= 1; | ||
8260 | current |= bit; | ||
8261 | currentLen++; | ||
8262 | if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue; | ||
8263 | |||
8264 | res = this.mul(res, wnd[current]); | ||
8265 | currentLen = 0; | ||
8266 | current = 0; | ||
8267 | } | ||
8268 | start = 26; | ||
8269 | } | ||
8270 | |||
8271 | return res; | ||
8272 | }; | ||
8273 | |||
8274 | Red.prototype.convertTo = function convertTo (num) { | ||
8275 | var r = num.umod(this.m); | ||
8276 | |||
8277 | return r === num ? r.clone() : r; | ||
8278 | }; | ||
8279 | |||
8280 | Red.prototype.convertFrom = function convertFrom (num) { | ||
8281 | var res = num.clone(); | ||
8282 | res.red = null; | ||
8283 | return res; | ||
8284 | }; | ||
8285 | |||
8286 | // | ||
8287 | // Montgomery method engine | ||
8288 | // | ||
8289 | |||
8290 | BN.mont = function mont (num) { | ||
8291 | return new Mont(num); | ||
8292 | }; | ||
8293 | |||
8294 | function Mont (m) { | ||
8295 | Red.call(this, m); | ||
8296 | |||
8297 | this.shift = this.m.bitLength(); | ||
8298 | if (this.shift % 26 !== 0) { | ||
8299 | this.shift += 26 - (this.shift % 26); | ||
8300 | } | ||
8301 | |||
8302 | this.r = new BN(1).iushln(this.shift); | ||
8303 | this.r2 = this.imod(this.r.sqr()); | ||
8304 | this.rinv = this.r._invmp(this.m); | ||
8305 | |||
8306 | this.minv = this.rinv.mul(this.r).isubn(1).div(this.m); | ||
8307 | this.minv = this.minv.umod(this.r); | ||
8308 | this.minv = this.r.sub(this.minv); | ||
8309 | } | ||
8310 | inherits(Mont, Red); | ||
8311 | |||
8312 | Mont.prototype.convertTo = function convertTo (num) { | ||
8313 | return this.imod(num.ushln(this.shift)); | ||
8314 | }; | ||
8315 | |||
8316 | Mont.prototype.convertFrom = function convertFrom (num) { | ||
8317 | var r = this.imod(num.mul(this.rinv)); | ||
8318 | r.red = null; | ||
8319 | return r; | ||
8320 | }; | ||
8321 | |||
8322 | Mont.prototype.imul = function imul (a, b) { | ||
8323 | if (a.isZero() || b.isZero()) { | ||
8324 | a.words[0] = 0; | ||
8325 | a.length = 1; | ||
8326 | return a; | ||
8327 | } | ||
8328 | |||
8329 | var t = a.imul(b); | ||
8330 | var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m); | ||
8331 | var u = t.isub(c).iushrn(this.shift); | ||
8332 | var res = u; | ||
8333 | |||
8334 | if (u.cmp(this.m) >= 0) { | ||
8335 | res = u.isub(this.m); | ||
8336 | } else if (u.cmpn(0) < 0) { | ||
8337 | res = u.iadd(this.m); | ||
8338 | } | ||
8339 | |||
8340 | return res._forceRed(this); | ||
8341 | }; | ||
8342 | |||
8343 | Mont.prototype.mul = function mul (a, b) { | ||
8344 | if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this); | ||
8345 | |||
8346 | var t = a.mul(b); | ||
8347 | var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m); | ||
8348 | var u = t.isub(c).iushrn(this.shift); | ||
8349 | var res = u; | ||
8350 | if (u.cmp(this.m) >= 0) { | ||
8351 | res = u.isub(this.m); | ||
8352 | } else if (u.cmpn(0) < 0) { | ||
8353 | res = u.iadd(this.m); | ||
8354 | } | ||
8355 | |||
8356 | return res._forceRed(this); | ||
8357 | }; | ||
8358 | |||
8359 | Mont.prototype.invm = function invm (a) { | ||
8360 | // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R | ||
8361 | var res = this.imod(a._invmp(this.m).mul(this.r2)); | ||
8362 | return res._forceRed(this); | ||
8363 | }; | ||
8364 | })(typeof module === 'undefined' || module, this); | ||
8365 | |||
8366 | },{"buffer":20}],19:[function(require,module,exports){ | ||
8367 | var r; | ||
8368 | |||
8369 | module.exports = function rand(len) { | ||
8370 | if (!r) | ||
8371 | r = new Rand(null); | ||
8372 | |||
8373 | return r.generate(len); | ||
8374 | }; | ||
8375 | |||
8376 | function Rand(rand) { | ||
8377 | this.rand = rand; | ||
8378 | } | ||
8379 | module.exports.Rand = Rand; | ||
8380 | |||
8381 | Rand.prototype.generate = function generate(len) { | ||
8382 | return this._rand(len); | ||
8383 | }; | ||
8384 | |||
8385 | // Emulate crypto API using randy | ||
8386 | Rand.prototype._rand = function _rand(n) { | ||
8387 | if (this.rand.getBytes) | ||
8388 | return this.rand.getBytes(n); | ||
8389 | |||
8390 | var res = new Uint8Array(n); | ||
8391 | for (var i = 0; i < res.length; i++) | ||
8392 | res[i] = this.rand.getByte(); | ||
8393 | return res; | ||
8394 | }; | ||
8395 | |||
8396 | if (typeof self === 'object') { | ||
8397 | if (self.crypto && self.crypto.getRandomValues) { | ||
8398 | // Modern browsers | ||
8399 | Rand.prototype._rand = function _rand(n) { | ||
8400 | var arr = new Uint8Array(n); | ||
8401 | self.crypto.getRandomValues(arr); | ||
8402 | return arr; | ||
8403 | }; | ||
8404 | } else if (self.msCrypto && self.msCrypto.getRandomValues) { | ||
8405 | // IE | ||
8406 | Rand.prototype._rand = function _rand(n) { | ||
8407 | var arr = new Uint8Array(n); | ||
8408 | self.msCrypto.getRandomValues(arr); | ||
8409 | return arr; | ||
8410 | }; | ||
8411 | |||
8412 | // Safari's WebWorkers do not have `crypto` | ||
8413 | } else if (typeof window === 'object') { | ||
8414 | // Old junk | ||
8415 | Rand.prototype._rand = function() { | ||
8416 | throw new Error('Not implemented yet'); | ||
8417 | }; | ||
8418 | } | ||
8419 | } else { | ||
8420 | // Node.js or Web worker with no crypto support | ||
8421 | try { | ||
8422 | var crypto = require('crypto'); | ||
8423 | if (typeof crypto.randomBytes !== 'function') | ||
8424 | throw new Error('Not supported'); | ||
8425 | |||
8426 | Rand.prototype._rand = function _rand(n) { | ||
8427 | return crypto.randomBytes(n); | ||
8428 | }; | ||
8429 | } catch (e) { | ||
8430 | } | ||
8431 | } | ||
8432 | |||
8433 | },{"crypto":20}],20:[function(require,module,exports){ | ||
8434 | |||
8435 | },{}],21:[function(require,module,exports){ | ||
8436 | // based on the aes implimentation in triple sec | ||
8437 | // https://github.com/keybase/triplesec | ||
8438 | // which is in turn based on the one from crypto-js | ||
8439 | // https://code.google.com/p/crypto-js/ | ||
8440 | |||
8441 | var Buffer = require('safe-buffer').Buffer | ||
8442 | |||
8443 | function asUInt32Array (buf) { | ||
8444 | if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf) | ||
8445 | |||
8446 | var len = (buf.length / 4) | 0 | ||
8447 | var out = new Array(len) | ||
8448 | |||
8449 | for (var i = 0; i < len; i++) { | ||
8450 | out[i] = buf.readUInt32BE(i * 4) | ||
8451 | } | ||
8452 | |||
8453 | return out | ||
8454 | } | ||
8455 | |||
8456 | function scrubVec (v) { | ||
8457 | for (var i = 0; i < v.length; v++) { | ||
8458 | v[i] = 0 | ||
8459 | } | ||
8460 | } | ||
8461 | |||
8462 | function cryptBlock (M, keySchedule, SUB_MIX, SBOX, nRounds) { | ||
8463 | var SUB_MIX0 = SUB_MIX[0] | ||
8464 | var SUB_MIX1 = SUB_MIX[1] | ||
8465 | var SUB_MIX2 = SUB_MIX[2] | ||
8466 | var SUB_MIX3 = SUB_MIX[3] | ||
8467 | |||
8468 | var s0 = M[0] ^ keySchedule[0] | ||
8469 | var s1 = M[1] ^ keySchedule[1] | ||
8470 | var s2 = M[2] ^ keySchedule[2] | ||
8471 | var s3 = M[3] ^ keySchedule[3] | ||
8472 | var t0, t1, t2, t3 | ||
8473 | var ksRow = 4 | ||
8474 | |||
8475 | for (var round = 1; round < nRounds; round++) { | ||
8476 | t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[(s1 >>> 16) & 0xff] ^ SUB_MIX2[(s2 >>> 8) & 0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++] | ||
8477 | t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[(s2 >>> 16) & 0xff] ^ SUB_MIX2[(s3 >>> 8) & 0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++] | ||
8478 | t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[(s3 >>> 16) & 0xff] ^ SUB_MIX2[(s0 >>> 8) & 0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++] | ||
8479 | t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[(s0 >>> 16) & 0xff] ^ SUB_MIX2[(s1 >>> 8) & 0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++] | ||
8480 | s0 = t0 | ||
8481 | s1 = t1 | ||
8482 | s2 = t2 | ||
8483 | s3 = t3 | ||
8484 | } | ||
8485 | |||
8486 | t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++] | ||
8487 | t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++] | ||
8488 | t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++] | ||
8489 | t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++] | ||
8490 | t0 = t0 >>> 0 | ||
8491 | t1 = t1 >>> 0 | ||
8492 | t2 = t2 >>> 0 | ||
8493 | t3 = t3 >>> 0 | ||
8494 | |||
8495 | return [t0, t1, t2, t3] | ||
8496 | } | ||
8497 | |||
8498 | // AES constants | ||
8499 | var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36] | ||
8500 | var G = (function () { | ||
8501 | // Compute double table | ||
8502 | var d = new Array(256) | ||
8503 | for (var j = 0; j < 256; j++) { | ||
8504 | if (j < 128) { | ||
8505 | d[j] = j << 1 | ||
8506 | } else { | ||
8507 | d[j] = (j << 1) ^ 0x11b | ||
8508 | } | ||
8509 | } | ||
8510 | |||
8511 | var SBOX = [] | ||
8512 | var INV_SBOX = [] | ||
8513 | var SUB_MIX = [[], [], [], []] | ||
8514 | var INV_SUB_MIX = [[], [], [], []] | ||
8515 | |||
8516 | // Walk GF(2^8) | ||
8517 | var x = 0 | ||
8518 | var xi = 0 | ||
8519 | for (var i = 0; i < 256; ++i) { | ||
8520 | // Compute sbox | ||
8521 | var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4) | ||
8522 | sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63 | ||
8523 | SBOX[x] = sx | ||
8524 | INV_SBOX[sx] = x | ||
8525 | |||
8526 | // Compute multiplication | ||
8527 | var x2 = d[x] | ||
8528 | var x4 = d[x2] | ||
8529 | var x8 = d[x4] | ||
8530 | |||
8531 | // Compute sub bytes, mix columns tables | ||
8532 | var t = (d[sx] * 0x101) ^ (sx * 0x1010100) | ||
8533 | SUB_MIX[0][x] = (t << 24) | (t >>> 8) | ||
8534 | SUB_MIX[1][x] = (t << 16) | (t >>> 16) | ||
8535 | SUB_MIX[2][x] = (t << 8) | (t >>> 24) | ||
8536 | SUB_MIX[3][x] = t | ||
8537 | |||
8538 | // Compute inv sub bytes, inv mix columns tables | ||
8539 | t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100) | ||
8540 | INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8) | ||
8541 | INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16) | ||
8542 | INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24) | ||
8543 | INV_SUB_MIX[3][sx] = t | ||
8544 | |||
8545 | if (x === 0) { | ||
8546 | x = xi = 1 | ||
8547 | } else { | ||
8548 | x = x2 ^ d[d[d[x8 ^ x2]]] | ||
8549 | xi ^= d[d[xi]] | ||
8550 | } | ||
8551 | } | ||
8552 | |||
8553 | return { | ||
8554 | SBOX: SBOX, | ||
8555 | INV_SBOX: INV_SBOX, | ||
8556 | SUB_MIX: SUB_MIX, | ||
8557 | INV_SUB_MIX: INV_SUB_MIX | ||
8558 | } | ||
8559 | })() | ||
8560 | |||
8561 | function AES (key) { | ||
8562 | this._key = asUInt32Array(key) | ||
8563 | this._reset() | ||
8564 | } | ||
8565 | |||
8566 | AES.blockSize = 4 * 4 | ||
8567 | AES.keySize = 256 / 8 | ||
8568 | AES.prototype.blockSize = AES.blockSize | ||
8569 | AES.prototype.keySize = AES.keySize | ||
8570 | AES.prototype._reset = function () { | ||
8571 | var keyWords = this._key | ||
8572 | var keySize = keyWords.length | ||
8573 | var nRounds = keySize + 6 | ||
8574 | var ksRows = (nRounds + 1) * 4 | ||
8575 | |||
8576 | var keySchedule = [] | ||
8577 | for (var k = 0; k < keySize; k++) { | ||
8578 | keySchedule[k] = keyWords[k] | ||
8579 | } | ||
8580 | |||
8581 | for (k = keySize; k < ksRows; k++) { | ||
8582 | var t = keySchedule[k - 1] | ||
8583 | |||
8584 | if (k % keySize === 0) { | ||
8585 | t = (t << 8) | (t >>> 24) | ||
8586 | t = | ||
8587 | (G.SBOX[t >>> 24] << 24) | | ||
8588 | (G.SBOX[(t >>> 16) & 0xff] << 16) | | ||
8589 | (G.SBOX[(t >>> 8) & 0xff] << 8) | | ||
8590 | (G.SBOX[t & 0xff]) | ||
8591 | |||
8592 | t ^= RCON[(k / keySize) | 0] << 24 | ||
8593 | } else if (keySize > 6 && k % keySize === 4) { | ||
8594 | t = | ||
8595 | (G.SBOX[t >>> 24] << 24) | | ||
8596 | (G.SBOX[(t >>> 16) & 0xff] << 16) | | ||
8597 | (G.SBOX[(t >>> 8) & 0xff] << 8) | | ||
8598 | (G.SBOX[t & 0xff]) | ||
8599 | } | ||
8600 | |||
8601 | keySchedule[k] = keySchedule[k - keySize] ^ t | ||
8602 | } | ||
8603 | |||
8604 | var invKeySchedule = [] | ||
8605 | for (var ik = 0; ik < ksRows; ik++) { | ||
8606 | var ksR = ksRows - ik | ||
8607 | var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)] | ||
8608 | |||
8609 | if (ik < 4 || ksR <= 4) { | ||
8610 | invKeySchedule[ik] = tt | ||
8611 | } else { | ||
8612 | invKeySchedule[ik] = | ||
8613 | G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^ | ||
8614 | G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^ | ||
8615 | G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^ | ||
8616 | G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]] | ||
8617 | } | ||
8618 | } | ||
8619 | |||
8620 | this._nRounds = nRounds | ||
8621 | this._keySchedule = keySchedule | ||
8622 | this._invKeySchedule = invKeySchedule | ||
8623 | } | ||
8624 | |||
8625 | AES.prototype.encryptBlockRaw = function (M) { | ||
8626 | M = asUInt32Array(M) | ||
8627 | return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds) | ||
8628 | } | ||
8629 | |||
8630 | AES.prototype.encryptBlock = function (M) { | ||
8631 | var out = this.encryptBlockRaw(M) | ||
8632 | var buf = Buffer.allocUnsafe(16) | ||
8633 | buf.writeUInt32BE(out[0], 0) | ||
8634 | buf.writeUInt32BE(out[1], 4) | ||
8635 | buf.writeUInt32BE(out[2], 8) | ||
8636 | buf.writeUInt32BE(out[3], 12) | ||
8637 | return buf | ||
8638 | } | ||
8639 | |||
8640 | AES.prototype.decryptBlock = function (M) { | ||
8641 | M = asUInt32Array(M) | ||
8642 | |||
8643 | // swap | ||
8644 | var m1 = M[1] | ||
8645 | M[1] = M[3] | ||
8646 | M[3] = m1 | ||
8647 | |||
8648 | var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds) | ||
8649 | var buf = Buffer.allocUnsafe(16) | ||
8650 | buf.writeUInt32BE(out[0], 0) | ||
8651 | buf.writeUInt32BE(out[3], 4) | ||
8652 | buf.writeUInt32BE(out[2], 8) | ||
8653 | buf.writeUInt32BE(out[1], 12) | ||
8654 | return buf | ||
8655 | } | ||
8656 | |||
8657 | AES.prototype.scrub = function () { | ||
8658 | scrubVec(this._keySchedule) | ||
8659 | scrubVec(this._invKeySchedule) | ||
8660 | scrubVec(this._key) | ||
8661 | } | ||
8662 | |||
8663 | module.exports.AES = AES | ||
8664 | |||
8665 | },{"safe-buffer":393}],22:[function(require,module,exports){ | ||
8666 | var aes = require('./aes') | ||
8667 | var Buffer = require('safe-buffer').Buffer | ||
8668 | var Transform = require('cipher-base') | ||
8669 | var inherits = require('inherits') | ||
8670 | var GHASH = require('./ghash') | ||
8671 | var xor = require('buffer-xor') | ||
8672 | var incr32 = require('./incr32') | ||
8673 | |||
8674 | function xorTest (a, b) { | ||
8675 | var out = 0 | ||
8676 | if (a.length !== b.length) out++ | ||
8677 | |||
8678 | var len = Math.min(a.length, b.length) | ||
8679 | for (var i = 0; i < len; ++i) { | ||
8680 | out += (a[i] ^ b[i]) | ||
8681 | } | ||
8682 | |||
8683 | return out | ||
8684 | } | ||
8685 | |||
8686 | function calcIv (self, iv, ck) { | ||
8687 | if (iv.length === 12) { | ||
8688 | self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])]) | ||
8689 | return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])]) | ||
8690 | } | ||
8691 | var ghash = new GHASH(ck) | ||
8692 | var len = iv.length | ||
8693 | var toPad = len % 16 | ||
8694 | ghash.update(iv) | ||
8695 | if (toPad) { | ||
8696 | toPad = 16 - toPad | ||
8697 | ghash.update(Buffer.alloc(toPad, 0)) | ||
8698 | } | ||
8699 | ghash.update(Buffer.alloc(8, 0)) | ||
8700 | var ivBits = len * 8 | ||
8701 | var tail = Buffer.alloc(8) | ||
8702 | tail.writeUIntBE(ivBits, 0, 8) | ||
8703 | ghash.update(tail) | ||
8704 | self._finID = ghash.state | ||
8705 | var out = Buffer.from(self._finID) | ||
8706 | incr32(out) | ||
8707 | return out | ||
8708 | } | ||
8709 | function StreamCipher (mode, key, iv, decrypt) { | ||
8710 | Transform.call(this) | ||
8711 | |||
8712 | var h = Buffer.alloc(4, 0) | ||
8713 | |||
8714 | this._cipher = new aes.AES(key) | ||
8715 | var ck = this._cipher.encryptBlock(h) | ||
8716 | this._ghash = new GHASH(ck) | ||
8717 | iv = calcIv(this, iv, ck) | ||
8718 | |||
8719 | this._prev = Buffer.from(iv) | ||
8720 | this._cache = Buffer.allocUnsafe(0) | ||
8721 | this._secCache = Buffer.allocUnsafe(0) | ||
8722 | this._decrypt = decrypt | ||
8723 | this._alen = 0 | ||
8724 | this._len = 0 | ||
8725 | this._mode = mode | ||
8726 | |||
8727 | this._authTag = null | ||
8728 | this._called = false | ||
8729 | } | ||
8730 | |||
8731 | inherits(StreamCipher, Transform) | ||
8732 | |||
8733 | StreamCipher.prototype._update = function (chunk) { | ||
8734 | if (!this._called && this._alen) { | ||
8735 | var rump = 16 - (this._alen % 16) | ||
8736 | if (rump < 16) { | ||
8737 | rump = Buffer.alloc(rump, 0) | ||
8738 | this._ghash.update(rump) | ||
8739 | } | ||
8740 | } | ||
8741 | |||
8742 | this._called = true | ||
8743 | var out = this._mode.encrypt(this, chunk) | ||
8744 | if (this._decrypt) { | ||
8745 | this._ghash.update(chunk) | ||
8746 | } else { | ||
8747 | this._ghash.update(out) | ||
8748 | } | ||
8749 | this._len += chunk.length | ||
8750 | return out | ||
8751 | } | ||
8752 | |||
8753 | StreamCipher.prototype._final = function () { | ||
8754 | if (this._decrypt && !this._authTag) throw new Error('Unsupported state or unable to authenticate data') | ||
8755 | |||
8756 | var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID)) | ||
8757 | if (this._decrypt && xorTest(tag, this._authTag)) throw new Error('Unsupported state or unable to authenticate data') | ||
8758 | |||
8759 | this._authTag = tag | ||
8760 | this._cipher.scrub() | ||
8761 | } | ||
8762 | |||
8763 | StreamCipher.prototype.getAuthTag = function getAuthTag () { | ||
8764 | if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag in unsupported state') | ||
8765 | |||
8766 | return this._authTag | ||
8767 | } | ||
8768 | |||
8769 | StreamCipher.prototype.setAuthTag = function setAuthTag (tag) { | ||
8770 | if (!this._decrypt) throw new Error('Attempting to set auth tag in unsupported state') | ||
8771 | |||
8772 | this._authTag = tag | ||
8773 | } | ||
8774 | |||
8775 | StreamCipher.prototype.setAAD = function setAAD (buf) { | ||
8776 | if (this._called) throw new Error('Attempting to set AAD in unsupported state') | ||
8777 | |||
8778 | this._ghash.update(buf) | ||
8779 | this._alen += buf.length | ||
8780 | } | ||
8781 | |||
8782 | module.exports = StreamCipher | ||
8783 | |||
8784 | },{"./aes":21,"./ghash":26,"./incr32":27,"buffer-xor":48,"cipher-base":50,"inherits":116,"safe-buffer":393}],23:[function(require,module,exports){ | ||
8785 | var ciphers = require('./encrypter') | ||
8786 | var deciphers = require('./decrypter') | ||
8787 | var modes = require('./modes/list.json') | ||
8788 | |||
8789 | function getCiphers () { | ||
8790 | return Object.keys(modes) | ||
8791 | } | ||
8792 | |||
8793 | exports.createCipher = exports.Cipher = ciphers.createCipher | ||
8794 | exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv | ||
8795 | exports.createDecipher = exports.Decipher = deciphers.createDecipher | ||
8796 | exports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv | ||
8797 | exports.listCiphers = exports.getCiphers = getCiphers | ||
8798 | |||
8799 | },{"./decrypter":24,"./encrypter":25,"./modes/list.json":35}],24:[function(require,module,exports){ | ||
8800 | var AuthCipher = require('./authCipher') | ||
8801 | var Buffer = require('safe-buffer').Buffer | ||
8802 | var MODES = require('./modes') | ||
8803 | var StreamCipher = require('./streamCipher') | ||
8804 | var Transform = require('cipher-base') | ||
8805 | var aes = require('./aes') | ||
8806 | var ebtk = require('evp_bytestokey') | ||
8807 | var inherits = require('inherits') | ||
8808 | |||
8809 | function Decipher (mode, key, iv) { | ||
8810 | Transform.call(this) | ||
8811 | |||
8812 | this._cache = new Splitter() | ||
8813 | this._last = void 0 | ||
8814 | this._cipher = new aes.AES(key) | ||
8815 | this._prev = Buffer.from(iv) | ||
8816 | this._mode = mode | ||
8817 | this._autopadding = true | ||
8818 | } | ||
8819 | |||
8820 | inherits(Decipher, Transform) | ||
8821 | |||
8822 | Decipher.prototype._update = function (data) { | ||
8823 | this._cache.add(data) | ||
8824 | var chunk | ||
8825 | var thing | ||
8826 | var out = [] | ||
8827 | while ((chunk = this._cache.get(this._autopadding))) { | ||
8828 | thing = this._mode.decrypt(this, chunk) | ||
8829 | out.push(thing) | ||
8830 | } | ||
8831 | return Buffer.concat(out) | ||
8832 | } | ||
8833 | |||
8834 | Decipher.prototype._final = function () { | ||
8835 | var chunk = this._cache.flush() | ||
8836 | if (this._autopadding) { | ||
8837 | return unpad(this._mode.decrypt(this, chunk)) | ||
8838 | } else if (chunk) { | ||
8839 | throw new Error('data not multiple of block length') | ||
8840 | } | ||
8841 | } | ||
8842 | |||
8843 | Decipher.prototype.setAutoPadding = function (setTo) { | ||
8844 | this._autopadding = !!setTo | ||
8845 | return this | ||
8846 | } | ||
8847 | |||
8848 | function Splitter () { | ||
8849 | this.cache = Buffer.allocUnsafe(0) | ||
8850 | } | ||
8851 | |||
8852 | Splitter.prototype.add = function (data) { | ||
8853 | this.cache = Buffer.concat([this.cache, data]) | ||
8854 | } | ||
8855 | |||
8856 | Splitter.prototype.get = function (autoPadding) { | ||
8857 | var out | ||
8858 | if (autoPadding) { | ||
8859 | if (this.cache.length > 16) { | ||
8860 | out = this.cache.slice(0, 16) | ||
8861 | this.cache = this.cache.slice(16) | ||
8862 | return out | ||
8863 | } | ||
8864 | } else { | ||
8865 | if (this.cache.length >= 16) { | ||
8866 | out = this.cache.slice(0, 16) | ||
8867 | this.cache = this.cache.slice(16) | ||
8868 | return out | ||
8869 | } | ||
8870 | } | ||
8871 | |||
8872 | return null | ||
8873 | } | ||
8874 | |||
8875 | Splitter.prototype.flush = function () { | ||
8876 | if (this.cache.length) return this.cache | ||
8877 | } | ||
8878 | |||
8879 | function unpad (last) { | ||
8880 | var padded = last[15] | ||
8881 | if (padded < 1 || padded > 16) { | ||
8882 | throw new Error('unable to decrypt data') | ||
8883 | } | ||
8884 | var i = -1 | ||
8885 | while (++i < padded) { | ||
8886 | if (last[(i + (16 - padded))] !== padded) { | ||
8887 | throw new Error('unable to decrypt data') | ||
8888 | } | ||
8889 | } | ||
8890 | if (padded === 16) return | ||
8891 | |||
8892 | return last.slice(0, 16 - padded) | ||
8893 | } | ||
8894 | |||
8895 | function createDecipheriv (suite, password, iv) { | ||
8896 | var config = MODES[suite.toLowerCase()] | ||
8897 | if (!config) throw new TypeError('invalid suite type') | ||
8898 | |||
8899 | if (typeof iv === 'string') iv = Buffer.from(iv) | ||
8900 | if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length) | ||
8901 | |||
8902 | if (typeof password === 'string') password = Buffer.from(password) | ||
8903 | if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length) | ||
8904 | |||
8905 | if (config.type === 'stream') { | ||
8906 | return new StreamCipher(config.module, password, iv, true) | ||
8907 | } else if (config.type === 'auth') { | ||
8908 | return new AuthCipher(config.module, password, iv, true) | ||
8909 | } | ||
8910 | |||
8911 | return new Decipher(config.module, password, iv) | ||
8912 | } | ||
8913 | |||
8914 | function createDecipher (suite, password) { | ||
8915 | var config = MODES[suite.toLowerCase()] | ||
8916 | if (!config) throw new TypeError('invalid suite type') | ||
8917 | |||
8918 | var keys = ebtk(password, false, config.key, config.iv) | ||
8919 | return createDecipheriv(suite, keys.key, keys.iv) | ||
8920 | } | ||
8921 | |||
8922 | exports.createDecipher = createDecipher | ||
8923 | exports.createDecipheriv = createDecipheriv | ||
8924 | |||
8925 | },{"./aes":21,"./authCipher":22,"./modes":34,"./streamCipher":37,"cipher-base":50,"evp_bytestokey":100,"inherits":116,"safe-buffer":393}],25:[function(require,module,exports){ | ||
8926 | var MODES = require('./modes') | ||
8927 | var AuthCipher = require('./authCipher') | ||
8928 | var Buffer = require('safe-buffer').Buffer | ||
8929 | var StreamCipher = require('./streamCipher') | ||
8930 | var Transform = require('cipher-base') | ||
8931 | var aes = require('./aes') | ||
8932 | var ebtk = require('evp_bytestokey') | ||
8933 | var inherits = require('inherits') | ||
8934 | |||
8935 | function Cipher (mode, key, iv) { | ||
8936 | Transform.call(this) | ||
8937 | |||
8938 | this._cache = new Splitter() | ||
8939 | this._cipher = new aes.AES(key) | ||
8940 | this._prev = Buffer.from(iv) | ||
8941 | this._mode = mode | ||
8942 | this._autopadding = true | ||
8943 | } | ||
8944 | |||
8945 | inherits(Cipher, Transform) | ||
8946 | |||
8947 | Cipher.prototype._update = function (data) { | ||
8948 | this._cache.add(data) | ||
8949 | var chunk | ||
8950 | var thing | ||
8951 | var out = [] | ||
8952 | |||
8953 | while ((chunk = this._cache.get())) { | ||
8954 | thing = this._mode.encrypt(this, chunk) | ||
8955 | out.push(thing) | ||
8956 | } | ||
8957 | |||
8958 | return Buffer.concat(out) | ||
8959 | } | ||
8960 | |||
8961 | var PADDING = Buffer.alloc(16, 0x10) | ||
8962 | |||
8963 | Cipher.prototype._final = function () { | ||
8964 | var chunk = this._cache.flush() | ||
8965 | if (this._autopadding) { | ||
8966 | chunk = this._mode.encrypt(this, chunk) | ||
8967 | this._cipher.scrub() | ||
8968 | return chunk | ||
8969 | } | ||
8970 | |||
8971 | if (!chunk.equals(PADDING)) { | ||
8972 | this._cipher.scrub() | ||
8973 | throw new Error('data not multiple of block length') | ||
8974 | } | ||
8975 | } | ||
8976 | |||
8977 | Cipher.prototype.setAutoPadding = function (setTo) { | ||
8978 | this._autopadding = !!setTo | ||
8979 | return this | ||
8980 | } | ||
8981 | |||
8982 | function Splitter () { | ||
8983 | this.cache = Buffer.allocUnsafe(0) | ||
8984 | } | ||
8985 | |||
8986 | Splitter.prototype.add = function (data) { | ||
8987 | this.cache = Buffer.concat([this.cache, data]) | ||
8988 | } | ||
8989 | |||
8990 | Splitter.prototype.get = function () { | ||
8991 | if (this.cache.length > 15) { | ||
8992 | var out = this.cache.slice(0, 16) | ||
8993 | this.cache = this.cache.slice(16) | ||
8994 | return out | ||
8995 | } | ||
8996 | return null | ||
8997 | } | ||
8998 | |||
8999 | Splitter.prototype.flush = function () { | ||
9000 | var len = 16 - this.cache.length | ||
9001 | var padBuff = Buffer.allocUnsafe(len) | ||
9002 | |||
9003 | var i = -1 | ||
9004 | while (++i < len) { | ||
9005 | padBuff.writeUInt8(len, i) | ||
9006 | } | ||
9007 | |||
9008 | return Buffer.concat([this.cache, padBuff]) | ||
9009 | } | ||
9010 | |||
9011 | function createCipheriv (suite, password, iv) { | ||
9012 | var config = MODES[suite.toLowerCase()] | ||
9013 | if (!config) throw new TypeError('invalid suite type') | ||
9014 | |||
9015 | if (typeof password === 'string') password = Buffer.from(password) | ||
9016 | if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length) | ||
9017 | |||
9018 | if (typeof iv === 'string') iv = Buffer.from(iv) | ||
9019 | if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length) | ||
9020 | |||
9021 | if (config.type === 'stream') { | ||
9022 | return new StreamCipher(config.module, password, iv) | ||
9023 | } else if (config.type === 'auth') { | ||
9024 | return new AuthCipher(config.module, password, iv) | ||
9025 | } | ||
9026 | |||
9027 | return new Cipher(config.module, password, iv) | ||
9028 | } | ||
9029 | |||
9030 | function createCipher (suite, password) { | ||
9031 | var config = MODES[suite.toLowerCase()] | ||
9032 | if (!config) throw new TypeError('invalid suite type') | ||
9033 | |||
9034 | var keys = ebtk(password, false, config.key, config.iv) | ||
9035 | return createCipheriv(suite, keys.key, keys.iv) | ||
9036 | } | ||
9037 | |||
9038 | exports.createCipheriv = createCipheriv | ||
9039 | exports.createCipher = createCipher | ||
9040 | |||
9041 | },{"./aes":21,"./authCipher":22,"./modes":34,"./streamCipher":37,"cipher-base":50,"evp_bytestokey":100,"inherits":116,"safe-buffer":393}],26:[function(require,module,exports){ | ||
9042 | var Buffer = require('safe-buffer').Buffer | ||
9043 | var ZEROES = Buffer.alloc(16, 0) | ||
9044 | |||
9045 | function toArray (buf) { | ||
9046 | return [ | ||
9047 | buf.readUInt32BE(0), | ||
9048 | buf.readUInt32BE(4), | ||
9049 | buf.readUInt32BE(8), | ||
9050 | buf.readUInt32BE(12) | ||
9051 | ] | ||
9052 | } | ||
9053 | |||
9054 | function fromArray (out) { | ||
9055 | var buf = Buffer.allocUnsafe(16) | ||
9056 | buf.writeUInt32BE(out[0] >>> 0, 0) | ||
9057 | buf.writeUInt32BE(out[1] >>> 0, 4) | ||
9058 | buf.writeUInt32BE(out[2] >>> 0, 8) | ||
9059 | buf.writeUInt32BE(out[3] >>> 0, 12) | ||
9060 | return buf | ||
9061 | } | ||
9062 | |||
9063 | function GHASH (key) { | ||
9064 | this.h = key | ||
9065 | this.state = Buffer.alloc(16, 0) | ||
9066 | this.cache = Buffer.allocUnsafe(0) | ||
9067 | } | ||
9068 | |||
9069 | // from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html | ||
9070 | // by Juho Vähä-Herttua | ||
9071 | GHASH.prototype.ghash = function (block) { | ||
9072 | var i = -1 | ||
9073 | while (++i < block.length) { | ||
9074 | this.state[i] ^= block[i] | ||
9075 | } | ||
9076 | this._multiply() | ||
9077 | } | ||
9078 | |||
9079 | GHASH.prototype._multiply = function () { | ||
9080 | var Vi = toArray(this.h) | ||
9081 | var Zi = [0, 0, 0, 0] | ||
9082 | var j, xi, lsbVi | ||
9083 | var i = -1 | ||
9084 | while (++i < 128) { | ||
9085 | xi = (this.state[~~(i / 8)] & (1 << (7 - (i % 8)))) !== 0 | ||
9086 | if (xi) { | ||
9087 | // Z_i+1 = Z_i ^ V_i | ||
9088 | Zi[0] ^= Vi[0] | ||
9089 | Zi[1] ^= Vi[1] | ||
9090 | Zi[2] ^= Vi[2] | ||
9091 | Zi[3] ^= Vi[3] | ||
9092 | } | ||
9093 | |||
9094 | // Store the value of LSB(V_i) | ||
9095 | lsbVi = (Vi[3] & 1) !== 0 | ||
9096 | |||
9097 | // V_i+1 = V_i >> 1 | ||
9098 | for (j = 3; j > 0; j--) { | ||
9099 | Vi[j] = (Vi[j] >>> 1) | ((Vi[j - 1] & 1) << 31) | ||
9100 | } | ||
9101 | Vi[0] = Vi[0] >>> 1 | ||
9102 | |||
9103 | // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R | ||
9104 | if (lsbVi) { | ||
9105 | Vi[0] = Vi[0] ^ (0xe1 << 24) | ||
9106 | } | ||
9107 | } | ||
9108 | this.state = fromArray(Zi) | ||
9109 | } | ||
9110 | |||
9111 | GHASH.prototype.update = function (buf) { | ||
9112 | this.cache = Buffer.concat([this.cache, buf]) | ||
9113 | var chunk | ||
9114 | while (this.cache.length >= 16) { | ||
9115 | chunk = this.cache.slice(0, 16) | ||
9116 | this.cache = this.cache.slice(16) | ||
9117 | this.ghash(chunk) | ||
9118 | } | ||
9119 | } | ||
9120 | |||
9121 | GHASH.prototype.final = function (abl, bl) { | ||
9122 | if (this.cache.length) { | ||
9123 | this.ghash(Buffer.concat([this.cache, ZEROES], 16)) | ||
9124 | } | ||
9125 | |||
9126 | this.ghash(fromArray([0, abl, 0, bl])) | ||
9127 | return this.state | ||
9128 | } | ||
9129 | |||
9130 | module.exports = GHASH | ||
9131 | |||
9132 | },{"safe-buffer":393}],27:[function(require,module,exports){ | ||
9133 | function incr32 (iv) { | ||
9134 | var len = iv.length | ||
9135 | var item | ||
9136 | while (len--) { | ||
9137 | item = iv.readUInt8(len) | ||
9138 | if (item === 255) { | ||
9139 | iv.writeUInt8(0, len) | ||
9140 | } else { | ||
9141 | item++ | ||
9142 | iv.writeUInt8(item, len) | ||
9143 | break | ||
9144 | } | ||
9145 | } | ||
9146 | } | ||
9147 | module.exports = incr32 | ||
9148 | |||
9149 | },{}],28:[function(require,module,exports){ | ||
9150 | var xor = require('buffer-xor') | ||
9151 | |||
9152 | exports.encrypt = function (self, block) { | ||
9153 | var data = xor(block, self._prev) | ||
9154 | |||
9155 | self._prev = self._cipher.encryptBlock(data) | ||
9156 | return self._prev | ||
9157 | } | ||
9158 | |||
9159 | exports.decrypt = function (self, block) { | ||
9160 | var pad = self._prev | ||
9161 | |||
9162 | self._prev = block | ||
9163 | var out = self._cipher.decryptBlock(block) | ||
9164 | |||
9165 | return xor(out, pad) | ||
9166 | } | ||
9167 | |||
9168 | },{"buffer-xor":48}],29:[function(require,module,exports){ | ||
9169 | var Buffer = require('safe-buffer').Buffer | ||
9170 | var xor = require('buffer-xor') | ||
9171 | |||
9172 | function encryptStart (self, data, decrypt) { | ||
9173 | var len = data.length | ||
9174 | var out = xor(data, self._cache) | ||
9175 | self._cache = self._cache.slice(len) | ||
9176 | self._prev = Buffer.concat([self._prev, decrypt ? data : out]) | ||
9177 | return out | ||
9178 | } | ||
9179 | |||
9180 | exports.encrypt = function (self, data, decrypt) { | ||
9181 | var out = Buffer.allocUnsafe(0) | ||
9182 | var len | ||
9183 | |||
9184 | while (data.length) { | ||
9185 | if (self._cache.length === 0) { | ||
9186 | self._cache = self._cipher.encryptBlock(self._prev) | ||
9187 | self._prev = Buffer.allocUnsafe(0) | ||
9188 | } | ||
9189 | |||
9190 | if (self._cache.length <= data.length) { | ||
9191 | len = self._cache.length | ||
9192 | out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)]) | ||
9193 | data = data.slice(len) | ||
9194 | } else { | ||
9195 | out = Buffer.concat([out, encryptStart(self, data, decrypt)]) | ||
9196 | break | ||
9197 | } | ||
9198 | } | ||
9199 | |||
9200 | return out | ||
9201 | } | ||
9202 | |||
9203 | },{"buffer-xor":48,"safe-buffer":393}],30:[function(require,module,exports){ | ||
9204 | var Buffer = require('safe-buffer').Buffer | ||
9205 | |||
9206 | function encryptByte (self, byteParam, decrypt) { | ||
9207 | var pad | ||
9208 | var i = -1 | ||
9209 | var len = 8 | ||
9210 | var out = 0 | ||
9211 | var bit, value | ||
9212 | while (++i < len) { | ||
9213 | pad = self._cipher.encryptBlock(self._prev) | ||
9214 | bit = (byteParam & (1 << (7 - i))) ? 0x80 : 0 | ||
9215 | value = pad[0] ^ bit | ||
9216 | out += ((value & 0x80) >> (i % 8)) | ||
9217 | self._prev = shiftIn(self._prev, decrypt ? bit : value) | ||
9218 | } | ||
9219 | return out | ||
9220 | } | ||
9221 | |||
9222 | function shiftIn (buffer, value) { | ||
9223 | var len = buffer.length | ||
9224 | var i = -1 | ||
9225 | var out = Buffer.allocUnsafe(buffer.length) | ||
9226 | buffer = Buffer.concat([buffer, Buffer.from([value])]) | ||
9227 | |||
9228 | while (++i < len) { | ||
9229 | out[i] = buffer[i] << 1 | buffer[i + 1] >> (7) | ||
9230 | } | ||
9231 | |||
9232 | return out | ||
9233 | } | ||
9234 | |||
9235 | exports.encrypt = function (self, chunk, decrypt) { | ||
9236 | var len = chunk.length | ||
9237 | var out = Buffer.allocUnsafe(len) | ||
9238 | var i = -1 | ||
9239 | |||
9240 | while (++i < len) { | ||
9241 | out[i] = encryptByte(self, chunk[i], decrypt) | ||
9242 | } | ||
9243 | |||
9244 | return out | ||
9245 | } | ||
9246 | |||
9247 | },{"safe-buffer":393}],31:[function(require,module,exports){ | ||
9248 | var Buffer = require('safe-buffer').Buffer | ||
9249 | |||
9250 | function encryptByte (self, byteParam, decrypt) { | ||
9251 | var pad = self._cipher.encryptBlock(self._prev) | ||
9252 | var out = pad[0] ^ byteParam | ||
9253 | |||
9254 | self._prev = Buffer.concat([ | ||
9255 | self._prev.slice(1), | ||
9256 | Buffer.from([decrypt ? byteParam : out]) | ||
9257 | ]) | ||
9258 | |||
9259 | return out | ||
9260 | } | ||
9261 | |||
9262 | exports.encrypt = function (self, chunk, decrypt) { | ||
9263 | var len = chunk.length | ||
9264 | var out = Buffer.allocUnsafe(len) | ||
9265 | var i = -1 | ||
9266 | |||
9267 | while (++i < len) { | ||
9268 | out[i] = encryptByte(self, chunk[i], decrypt) | ||
9269 | } | ||
9270 | |||
9271 | return out | ||
9272 | } | ||
9273 | |||
9274 | },{"safe-buffer":393}],32:[function(require,module,exports){ | ||
9275 | var xor = require('buffer-xor') | ||
9276 | var Buffer = require('safe-buffer').Buffer | ||
9277 | var incr32 = require('../incr32') | ||
9278 | |||
9279 | function getBlock (self) { | ||
9280 | var out = self._cipher.encryptBlockRaw(self._prev) | ||
9281 | incr32(self._prev) | ||
9282 | return out | ||
9283 | } | ||
9284 | |||
9285 | var blockSize = 16 | ||
9286 | exports.encrypt = function (self, chunk) { | ||
9287 | var chunkNum = Math.ceil(chunk.length / blockSize) | ||
9288 | var start = self._cache.length | ||
9289 | self._cache = Buffer.concat([ | ||
9290 | self._cache, | ||
9291 | Buffer.allocUnsafe(chunkNum * blockSize) | ||
9292 | ]) | ||
9293 | for (var i = 0; i < chunkNum; i++) { | ||
9294 | var out = getBlock(self) | ||
9295 | var offset = start + i * blockSize | ||
9296 | self._cache.writeUInt32BE(out[0], offset + 0) | ||
9297 | self._cache.writeUInt32BE(out[1], offset + 4) | ||
9298 | self._cache.writeUInt32BE(out[2], offset + 8) | ||
9299 | self._cache.writeUInt32BE(out[3], offset + 12) | ||
9300 | } | ||
9301 | var pad = self._cache.slice(0, chunk.length) | ||
9302 | self._cache = self._cache.slice(chunk.length) | ||
9303 | return xor(chunk, pad) | ||
9304 | } | ||
9305 | |||
9306 | },{"../incr32":27,"buffer-xor":48,"safe-buffer":393}],33:[function(require,module,exports){ | ||
9307 | exports.encrypt = function (self, block) { | ||
9308 | return self._cipher.encryptBlock(block) | ||
9309 | } | ||
9310 | |||
9311 | exports.decrypt = function (self, block) { | ||
9312 | return self._cipher.decryptBlock(block) | ||
9313 | } | ||
9314 | |||
9315 | },{}],34:[function(require,module,exports){ | ||
9316 | var modeModules = { | ||
9317 | ECB: require('./ecb'), | ||
9318 | CBC: require('./cbc'), | ||
9319 | CFB: require('./cfb'), | ||
9320 | CFB8: require('./cfb8'), | ||
9321 | CFB1: require('./cfb1'), | ||
9322 | OFB: require('./ofb'), | ||
9323 | CTR: require('./ctr'), | ||
9324 | GCM: require('./ctr') | ||
9325 | } | ||
9326 | |||
9327 | var modes = require('./list.json') | ||
9328 | |||
9329 | for (var key in modes) { | ||
9330 | modes[key].module = modeModules[modes[key].mode] | ||
9331 | } | ||
9332 | |||
9333 | module.exports = modes | ||
9334 | |||
9335 | },{"./cbc":28,"./cfb":29,"./cfb1":30,"./cfb8":31,"./ctr":32,"./ecb":33,"./list.json":35,"./ofb":36}],35:[function(require,module,exports){ | ||
9336 | module.exports={ | ||
9337 | "aes-128-ecb": { | ||
9338 | "cipher": "AES", | ||
9339 | "key": 128, | ||
9340 | "iv": 0, | ||
9341 | "mode": "ECB", | ||
9342 | "type": "block" | ||
9343 | }, | ||
9344 | "aes-192-ecb": { | ||
9345 | "cipher": "AES", | ||
9346 | "key": 192, | ||
9347 | "iv": 0, | ||
9348 | "mode": "ECB", | ||
9349 | "type": "block" | ||
9350 | }, | ||
9351 | "aes-256-ecb": { | ||
9352 | "cipher": "AES", | ||
9353 | "key": 256, | ||
9354 | "iv": 0, | ||
9355 | "mode": "ECB", | ||
9356 | "type": "block" | ||
9357 | }, | ||
9358 | "aes-128-cbc": { | ||
9359 | "cipher": "AES", | ||
9360 | "key": 128, | ||
9361 | "iv": 16, | ||
9362 | "mode": "CBC", | ||
9363 | "type": "block" | ||
9364 | }, | ||
9365 | "aes-192-cbc": { | ||
9366 | "cipher": "AES", | ||
9367 | "key": 192, | ||
9368 | "iv": 16, | ||
9369 | "mode": "CBC", | ||
9370 | "type": "block" | ||
9371 | }, | ||
9372 | "aes-256-cbc": { | ||
9373 | "cipher": "AES", | ||
9374 | "key": 256, | ||
9375 | "iv": 16, | ||
9376 | "mode": "CBC", | ||
9377 | "type": "block" | ||
9378 | }, | ||
9379 | "aes128": { | ||
9380 | "cipher": "AES", | ||
9381 | "key": 128, | ||
9382 | "iv": 16, | ||
9383 | "mode": "CBC", | ||
9384 | "type": "block" | ||
9385 | }, | ||
9386 | "aes192": { | ||
9387 | "cipher": "AES", | ||
9388 | "key": 192, | ||
9389 | "iv": 16, | ||
9390 | "mode": "CBC", | ||
9391 | "type": "block" | ||
9392 | }, | ||
9393 | "aes256": { | ||
9394 | "cipher": "AES", | ||
9395 | "key": 256, | ||
9396 | "iv": 16, | ||
9397 | "mode": "CBC", | ||
9398 | "type": "block" | ||
9399 | }, | ||
9400 | "aes-128-cfb": { | ||
9401 | "cipher": "AES", | ||
9402 | "key": 128, | ||
9403 | "iv": 16, | ||
9404 | "mode": "CFB", | ||
9405 | "type": "stream" | ||
9406 | }, | ||
9407 | "aes-192-cfb": { | ||
9408 | "cipher": "AES", | ||
9409 | "key": 192, | ||
9410 | "iv": 16, | ||
9411 | "mode": "CFB", | ||
9412 | "type": "stream" | ||
9413 | }, | ||
9414 | "aes-256-cfb": { | ||
9415 | "cipher": "AES", | ||
9416 | "key": 256, | ||
9417 | "iv": 16, | ||
9418 | "mode": "CFB", | ||
9419 | "type": "stream" | ||
9420 | }, | ||
9421 | "aes-128-cfb8": { | ||
9422 | "cipher": "AES", | ||
9423 | "key": 128, | ||
9424 | "iv": 16, | ||
9425 | "mode": "CFB8", | ||
9426 | "type": "stream" | ||
9427 | }, | ||
9428 | "aes-192-cfb8": { | ||
9429 | "cipher": "AES", | ||
9430 | "key": 192, | ||
9431 | "iv": 16, | ||
9432 | "mode": "CFB8", | ||
9433 | "type": "stream" | ||
9434 | }, | ||
9435 | "aes-256-cfb8": { | ||
9436 | "cipher": "AES", | ||
9437 | "key": 256, | ||
9438 | "iv": 16, | ||
9439 | "mode": "CFB8", | ||
9440 | "type": "stream" | ||
9441 | }, | ||
9442 | "aes-128-cfb1": { | ||
9443 | "cipher": "AES", | ||
9444 | "key": 128, | ||
9445 | "iv": 16, | ||
9446 | "mode": "CFB1", | ||
9447 | "type": "stream" | ||
9448 | }, | ||
9449 | "aes-192-cfb1": { | ||
9450 | "cipher": "AES", | ||
9451 | "key": 192, | ||
9452 | "iv": 16, | ||
9453 | "mode": "CFB1", | ||
9454 | "type": "stream" | ||
9455 | }, | ||
9456 | "aes-256-cfb1": { | ||
9457 | "cipher": "AES", | ||
9458 | "key": 256, | ||
9459 | "iv": 16, | ||
9460 | "mode": "CFB1", | ||
9461 | "type": "stream" | ||
9462 | }, | ||
9463 | "aes-128-ofb": { | ||
9464 | "cipher": "AES", | ||
9465 | "key": 128, | ||
9466 | "iv": 16, | ||
9467 | "mode": "OFB", | ||
9468 | "type": "stream" | ||
9469 | }, | ||
9470 | "aes-192-ofb": { | ||
9471 | "cipher": "AES", | ||
9472 | "key": 192, | ||
9473 | "iv": 16, | ||
9474 | "mode": "OFB", | ||
9475 | "type": "stream" | ||
9476 | }, | ||
9477 | "aes-256-ofb": { | ||
9478 | "cipher": "AES", | ||
9479 | "key": 256, | ||
9480 | "iv": 16, | ||
9481 | "mode": "OFB", | ||
9482 | "type": "stream" | ||
9483 | }, | ||
9484 | "aes-128-ctr": { | ||
9485 | "cipher": "AES", | ||
9486 | "key": 128, | ||
9487 | "iv": 16, | ||
9488 | "mode": "CTR", | ||
9489 | "type": "stream" | ||
9490 | }, | ||
9491 | "aes-192-ctr": { | ||
9492 | "cipher": "AES", | ||
9493 | "key": 192, | ||
9494 | "iv": 16, | ||
9495 | "mode": "CTR", | ||
9496 | "type": "stream" | ||
9497 | }, | ||
9498 | "aes-256-ctr": { | ||
9499 | "cipher": "AES", | ||
9500 | "key": 256, | ||
9501 | "iv": 16, | ||
9502 | "mode": "CTR", | ||
9503 | "type": "stream" | ||
9504 | }, | ||
9505 | "aes-128-gcm": { | ||
9506 | "cipher": "AES", | ||
9507 | "key": 128, | ||
9508 | "iv": 12, | ||
9509 | "mode": "GCM", | ||
9510 | "type": "auth" | ||
9511 | }, | ||
9512 | "aes-192-gcm": { | ||
9513 | "cipher": "AES", | ||
9514 | "key": 192, | ||
9515 | "iv": 12, | ||
9516 | "mode": "GCM", | ||
9517 | "type": "auth" | ||
9518 | }, | ||
9519 | "aes-256-gcm": { | ||
9520 | "cipher": "AES", | ||
9521 | "key": 256, | ||
9522 | "iv": 12, | ||
9523 | "mode": "GCM", | ||
9524 | "type": "auth" | ||
9525 | } | ||
9526 | } | ||
9527 | |||
9528 | },{}],36:[function(require,module,exports){ | ||
9529 | (function (Buffer){ | ||
9530 | var xor = require('buffer-xor') | ||
9531 | |||
9532 | function getBlock (self) { | ||
9533 | self._prev = self._cipher.encryptBlock(self._prev) | ||
9534 | return self._prev | ||
9535 | } | ||
9536 | |||
9537 | exports.encrypt = function (self, chunk) { | ||
9538 | while (self._cache.length < chunk.length) { | ||
9539 | self._cache = Buffer.concat([self._cache, getBlock(self)]) | ||
9540 | } | ||
9541 | |||
9542 | var pad = self._cache.slice(0, chunk.length) | ||
9543 | self._cache = self._cache.slice(chunk.length) | ||
9544 | return xor(chunk, pad) | ||
9545 | } | ||
9546 | |||
9547 | }).call(this,require("buffer").Buffer) | ||
9548 | },{"buffer":49,"buffer-xor":48}],37:[function(require,module,exports){ | ||
9549 | var aes = require('./aes') | ||
9550 | var Buffer = require('safe-buffer').Buffer | ||
9551 | var Transform = require('cipher-base') | ||
9552 | var inherits = require('inherits') | ||
9553 | |||
9554 | function StreamCipher (mode, key, iv, decrypt) { | ||
9555 | Transform.call(this) | ||
9556 | |||
9557 | this._cipher = new aes.AES(key) | ||
9558 | this._prev = Buffer.from(iv) | ||
9559 | this._cache = Buffer.allocUnsafe(0) | ||
9560 | this._secCache = Buffer.allocUnsafe(0) | ||
9561 | this._decrypt = decrypt | ||
9562 | this._mode = mode | ||
9563 | } | ||
9564 | |||
9565 | inherits(StreamCipher, Transform) | ||
9566 | |||
9567 | StreamCipher.prototype._update = function (chunk) { | ||
9568 | return this._mode.encrypt(this, chunk, this._decrypt) | ||
9569 | } | ||
9570 | |||
9571 | StreamCipher.prototype._final = function () { | ||
9572 | this._cipher.scrub() | ||
9573 | } | ||
9574 | |||
9575 | module.exports = StreamCipher | ||
9576 | |||
9577 | },{"./aes":21,"cipher-base":50,"inherits":116,"safe-buffer":393}],38:[function(require,module,exports){ | ||
9578 | var DES = require('browserify-des') | ||
9579 | var aes = require('browserify-aes/browser') | ||
9580 | var aesModes = require('browserify-aes/modes') | ||
9581 | var desModes = require('browserify-des/modes') | ||
9582 | var ebtk = require('evp_bytestokey') | ||
9583 | |||
9584 | function createCipher (suite, password) { | ||
9585 | suite = suite.toLowerCase() | ||
9586 | |||
9587 | var keyLen, ivLen | ||
9588 | if (aesModes[suite]) { | ||
9589 | keyLen = aesModes[suite].key | ||
9590 | ivLen = aesModes[suite].iv | ||
9591 | } else if (desModes[suite]) { | ||
9592 | keyLen = desModes[suite].key * 8 | ||
9593 | ivLen = desModes[suite].iv | ||
9594 | } else { | ||
9595 | throw new TypeError('invalid suite type') | ||
9596 | } | ||
9597 | |||
9598 | var keys = ebtk(password, false, keyLen, ivLen) | ||
9599 | return createCipheriv(suite, keys.key, keys.iv) | ||
9600 | } | ||
9601 | |||
9602 | function createDecipher (suite, password) { | ||
9603 | suite = suite.toLowerCase() | ||
9604 | |||
9605 | var keyLen, ivLen | ||
9606 | if (aesModes[suite]) { | ||
9607 | keyLen = aesModes[suite].key | ||
9608 | ivLen = aesModes[suite].iv | ||
9609 | } else if (desModes[suite]) { | ||
9610 | keyLen = desModes[suite].key * 8 | ||
9611 | ivLen = desModes[suite].iv | ||
9612 | } else { | ||
9613 | throw new TypeError('invalid suite type') | ||
9614 | } | ||
9615 | |||
9616 | var keys = ebtk(password, false, keyLen, ivLen) | ||
9617 | return createDecipheriv(suite, keys.key, keys.iv) | ||
9618 | } | ||
9619 | |||
9620 | function createCipheriv (suite, key, iv) { | ||
9621 | suite = suite.toLowerCase() | ||
9622 | if (aesModes[suite]) return aes.createCipheriv(suite, key, iv) | ||
9623 | if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite }) | ||
9624 | |||
9625 | throw new TypeError('invalid suite type') | ||
9626 | } | ||
9627 | |||
9628 | function createDecipheriv (suite, key, iv) { | ||
9629 | suite = suite.toLowerCase() | ||
9630 | if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv) | ||
9631 | if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite, decrypt: true }) | ||
9632 | |||
9633 | throw new TypeError('invalid suite type') | ||
9634 | } | ||
9635 | |||
9636 | function getCiphers () { | ||
9637 | return Object.keys(desModes).concat(aes.getCiphers()) | ||
9638 | } | ||
9639 | |||
9640 | exports.createCipher = exports.Cipher = createCipher | ||
9641 | exports.createCipheriv = exports.Cipheriv = createCipheriv | ||
9642 | exports.createDecipher = exports.Decipher = createDecipher | ||
9643 | exports.createDecipheriv = exports.Decipheriv = createDecipheriv | ||
9644 | exports.listCiphers = exports.getCiphers = getCiphers | ||
9645 | |||
9646 | },{"browserify-aes/browser":23,"browserify-aes/modes":34,"browserify-des":39,"browserify-des/modes":40,"evp_bytestokey":100}],39:[function(require,module,exports){ | ||
9647 | var CipherBase = require('cipher-base') | ||
9648 | var des = require('des.js') | ||
9649 | var inherits = require('inherits') | ||
9650 | var Buffer = require('safe-buffer').Buffer | ||
9651 | |||
9652 | var modes = { | ||
9653 | 'des-ede3-cbc': des.CBC.instantiate(des.EDE), | ||
9654 | 'des-ede3': des.EDE, | ||
9655 | 'des-ede-cbc': des.CBC.instantiate(des.EDE), | ||
9656 | 'des-ede': des.EDE, | ||
9657 | 'des-cbc': des.CBC.instantiate(des.DES), | ||
9658 | 'des-ecb': des.DES | ||
9659 | } | ||
9660 | modes.des = modes['des-cbc'] | ||
9661 | modes.des3 = modes['des-ede3-cbc'] | ||
9662 | module.exports = DES | ||
9663 | inherits(DES, CipherBase) | ||
9664 | function DES (opts) { | ||
9665 | CipherBase.call(this) | ||
9666 | var modeName = opts.mode.toLowerCase() | ||
9667 | var mode = modes[modeName] | ||
9668 | var type | ||
9669 | if (opts.decrypt) { | ||
9670 | type = 'decrypt' | ||
9671 | } else { | ||
9672 | type = 'encrypt' | ||
9673 | } | ||
9674 | var key = opts.key | ||
9675 | if (!Buffer.isBuffer(key)) { | ||
9676 | key = Buffer.from(key) | ||
9677 | } | ||
9678 | if (modeName === 'des-ede' || modeName === 'des-ede-cbc') { | ||
9679 | key = Buffer.concat([key, key.slice(0, 8)]) | ||
9680 | } | ||
9681 | var iv = opts.iv | ||
9682 | if (!Buffer.isBuffer(iv)) { | ||
9683 | iv = Buffer.from(iv) | ||
9684 | } | ||
9685 | this._des = mode.create({ | ||
9686 | key: key, | ||
9687 | iv: iv, | ||
9688 | type: type | ||
9689 | }) | ||
9690 | } | ||
9691 | DES.prototype._update = function (data) { | ||
9692 | return Buffer.from(this._des.update(data)) | ||
9693 | } | ||
9694 | DES.prototype._final = function () { | ||
9695 | return Buffer.from(this._des.final()) | ||
9696 | } | ||
9697 | |||
9698 | },{"cipher-base":50,"des.js":73,"inherits":116,"safe-buffer":393}],40:[function(require,module,exports){ | ||
9699 | exports['des-ecb'] = { | ||
9700 | key: 8, | ||
9701 | iv: 0 | ||
9702 | } | ||
9703 | exports['des-cbc'] = exports.des = { | ||
9704 | key: 8, | ||
9705 | iv: 8 | ||
9706 | } | ||
9707 | exports['des-ede3-cbc'] = exports.des3 = { | ||
9708 | key: 24, | ||
9709 | iv: 8 | ||
9710 | } | ||
9711 | exports['des-ede3'] = { | ||
9712 | key: 24, | ||
9713 | iv: 0 | ||
9714 | } | ||
9715 | exports['des-ede-cbc'] = { | ||
9716 | key: 16, | ||
9717 | iv: 8 | ||
9718 | } | ||
9719 | exports['des-ede'] = { | ||
9720 | key: 16, | ||
9721 | iv: 0 | ||
9722 | } | ||
9723 | |||
9724 | },{}],41:[function(require,module,exports){ | ||
9725 | (function (Buffer){ | ||
9726 | var bn = require('bn.js'); | ||
9727 | var randomBytes = require('randombytes'); | ||
9728 | module.exports = crt; | ||
9729 | function blind(priv) { | ||
9730 | var r = getr(priv); | ||
9731 | var blinder = r.toRed(bn.mont(priv.modulus)) | ||
9732 | .redPow(new bn(priv.publicExponent)).fromRed(); | ||
9733 | return { | ||
9734 | blinder: blinder, | ||
9735 | unblinder:r.invm(priv.modulus) | ||
9736 | }; | ||
9737 | } | ||
9738 | function crt(msg, priv) { | ||
9739 | var blinds = blind(priv); | ||
9740 | var len = priv.modulus.byteLength(); | ||
9741 | var mod = bn.mont(priv.modulus); | ||
9742 | var blinded = new bn(msg).mul(blinds.blinder).umod(priv.modulus); | ||
9743 | var c1 = blinded.toRed(bn.mont(priv.prime1)); | ||
9744 | var c2 = blinded.toRed(bn.mont(priv.prime2)); | ||
9745 | var qinv = priv.coefficient; | ||
9746 | var p = priv.prime1; | ||
9747 | var q = priv.prime2; | ||
9748 | var m1 = c1.redPow(priv.exponent1); | ||
9749 | var m2 = c2.redPow(priv.exponent2); | ||
9750 | m1 = m1.fromRed(); | ||
9751 | m2 = m2.fromRed(); | ||
9752 | var h = m1.isub(m2).imul(qinv).umod(p); | ||
9753 | h.imul(q); | ||
9754 | m2.iadd(h); | ||
9755 | return new Buffer(m2.imul(blinds.unblinder).umod(priv.modulus).toArray(false, len)); | ||
9756 | } | ||
9757 | crt.getr = getr; | ||
9758 | function getr(priv) { | ||
9759 | var len = priv.modulus.byteLength(); | ||
9760 | var r = new bn(randomBytes(len)); | ||
9761 | while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2)) { | ||
9762 | r = new bn(randomBytes(len)); | ||
9763 | } | ||
9764 | return r; | ||
9765 | } | ||
9766 | |||
9767 | }).call(this,require("buffer").Buffer) | ||
9768 | },{"bn.js":18,"buffer":49,"randombytes":376}],42:[function(require,module,exports){ | ||
9769 | module.exports = require('./browser/algorithms.json') | ||
9770 | |||
9771 | },{"./browser/algorithms.json":43}],43:[function(require,module,exports){ | ||
9772 | module.exports={ | ||
9773 | "sha224WithRSAEncryption": { | ||
9774 | "sign": "rsa", | ||
9775 | "hash": "sha224", | ||
9776 | "id": "302d300d06096086480165030402040500041c" | ||
9777 | }, | ||
9778 | "RSA-SHA224": { | ||
9779 | "sign": "ecdsa/rsa", | ||
9780 | "hash": "sha224", | ||
9781 | "id": "302d300d06096086480165030402040500041c" | ||
9782 | }, | ||
9783 | "sha256WithRSAEncryption": { | ||
9784 | "sign": "rsa", | ||
9785 | "hash": "sha256", | ||
9786 | "id": "3031300d060960864801650304020105000420" | ||
9787 | }, | ||
9788 | "RSA-SHA256": { | ||
9789 | "sign": "ecdsa/rsa", | ||
9790 | "hash": "sha256", | ||
9791 | "id": "3031300d060960864801650304020105000420" | ||
9792 | }, | ||
9793 | "sha384WithRSAEncryption": { | ||
9794 | "sign": "rsa", | ||
9795 | "hash": "sha384", | ||
9796 | "id": "3041300d060960864801650304020205000430" | ||
9797 | }, | ||
9798 | "RSA-SHA384": { | ||
9799 | "sign": "ecdsa/rsa", | ||
9800 | "hash": "sha384", | ||
9801 | "id": "3041300d060960864801650304020205000430" | ||
9802 | }, | ||
9803 | "sha512WithRSAEncryption": { | ||
9804 | "sign": "rsa", | ||
9805 | "hash": "sha512", | ||
9806 | "id": "3051300d060960864801650304020305000440" | ||
9807 | }, | ||
9808 | "RSA-SHA512": { | ||
9809 | "sign": "ecdsa/rsa", | ||
9810 | "hash": "sha512", | ||
9811 | "id": "3051300d060960864801650304020305000440" | ||
9812 | }, | ||
9813 | "RSA-SHA1": { | ||
9814 | "sign": "rsa", | ||
9815 | "hash": "sha1", | ||
9816 | "id": "3021300906052b0e03021a05000414" | ||
9817 | }, | ||
9818 | "ecdsa-with-SHA1": { | ||
9819 | "sign": "ecdsa", | ||
9820 | "hash": "sha1", | ||
9821 | "id": "" | ||
9822 | }, | ||
9823 | "sha256": { | ||
9824 | "sign": "ecdsa", | ||
9825 | "hash": "sha256", | ||
9826 | "id": "" | ||
9827 | }, | ||
9828 | "sha224": { | ||
9829 | "sign": "ecdsa", | ||
9830 | "hash": "sha224", | ||
9831 | "id": "" | ||
9832 | }, | ||
9833 | "sha384": { | ||
9834 | "sign": "ecdsa", | ||
9835 | "hash": "sha384", | ||
9836 | "id": "" | ||
9837 | }, | ||
9838 | "sha512": { | ||
9839 | "sign": "ecdsa", | ||
9840 | "hash": "sha512", | ||
9841 | "id": "" | ||
9842 | }, | ||
9843 | "DSA-SHA": { | ||
9844 | "sign": "dsa", | ||
9845 | "hash": "sha1", | ||
9846 | "id": "" | ||
9847 | }, | ||
9848 | "DSA-SHA1": { | ||
9849 | "sign": "dsa", | ||
9850 | "hash": "sha1", | ||
9851 | "id": "" | ||
9852 | }, | ||
9853 | "DSA": { | ||
9854 | "sign": "dsa", | ||
9855 | "hash": "sha1", | ||
9856 | "id": "" | ||
9857 | }, | ||
9858 | "DSA-WITH-SHA224": { | ||
9859 | "sign": "dsa", | ||
9860 | "hash": "sha224", | ||
9861 | "id": "" | ||
9862 | }, | ||
9863 | "DSA-SHA224": { | ||
9864 | "sign": "dsa", | ||
9865 | "hash": "sha224", | ||
9866 | "id": "" | ||
9867 | }, | ||
9868 | "DSA-WITH-SHA256": { | ||
9869 | "sign": "dsa", | ||
9870 | "hash": "sha256", | ||
9871 | "id": "" | ||
9872 | }, | ||
9873 | "DSA-SHA256": { | ||
9874 | "sign": "dsa", | ||
9875 | "hash": "sha256", | ||
9876 | "id": "" | ||
9877 | }, | ||
9878 | "DSA-WITH-SHA384": { | ||
9879 | "sign": "dsa", | ||
9880 | "hash": "sha384", | ||
9881 | "id": "" | ||
9882 | }, | ||
9883 | "DSA-SHA384": { | ||
9884 | "sign": "dsa", | ||
9885 | "hash": "sha384", | ||
9886 | "id": "" | ||
9887 | }, | ||
9888 | "DSA-WITH-SHA512": { | ||
9889 | "sign": "dsa", | ||
9890 | "hash": "sha512", | ||
9891 | "id": "" | ||
9892 | }, | ||
9893 | "DSA-SHA512": { | ||
9894 | "sign": "dsa", | ||
9895 | "hash": "sha512", | ||
9896 | "id": "" | ||
9897 | }, | ||
9898 | "DSA-RIPEMD160": { | ||
9899 | "sign": "dsa", | ||
9900 | "hash": "rmd160", | ||
9901 | "id": "" | ||
9902 | }, | ||
9903 | "ripemd160WithRSA": { | ||
9904 | "sign": "rsa", | ||
9905 | "hash": "rmd160", | ||
9906 | "id": "3021300906052b2403020105000414" | ||
9907 | }, | ||
9908 | "RSA-RIPEMD160": { | ||
9909 | "sign": "rsa", | ||
9910 | "hash": "rmd160", | ||
9911 | "id": "3021300906052b2403020105000414" | ||
9912 | }, | ||
9913 | "md5WithRSAEncryption": { | ||
9914 | "sign": "rsa", | ||
9915 | "hash": "md5", | ||
9916 | "id": "3020300c06082a864886f70d020505000410" | ||
9917 | }, | ||
9918 | "RSA-MD5": { | ||
9919 | "sign": "rsa", | ||
9920 | "hash": "md5", | ||
9921 | "id": "3020300c06082a864886f70d020505000410" | ||
9922 | } | ||
9923 | } | ||
9924 | |||
9925 | },{}],44:[function(require,module,exports){ | ||
9926 | module.exports={ | ||
9927 | "1.3.132.0.10": "secp256k1", | ||
9928 | "1.3.132.0.33": "p224", | ||
9929 | "1.2.840.10045.3.1.1": "p192", | ||
9930 | "1.2.840.10045.3.1.7": "p256", | ||
9931 | "1.3.132.0.34": "p384", | ||
9932 | "1.3.132.0.35": "p521" | ||
9933 | } | ||
9934 | |||
9935 | },{}],45:[function(require,module,exports){ | ||
9936 | (function (Buffer){ | ||
9937 | var createHash = require('create-hash') | ||
9938 | var stream = require('stream') | ||
9939 | var inherits = require('inherits') | ||
9940 | var sign = require('./sign') | ||
9941 | var verify = require('./verify') | ||
9942 | |||
9943 | var algorithms = require('./algorithms.json') | ||
9944 | Object.keys(algorithms).forEach(function (key) { | ||
9945 | algorithms[key].id = new Buffer(algorithms[key].id, 'hex') | ||
9946 | algorithms[key.toLowerCase()] = algorithms[key] | ||
9947 | }) | ||
9948 | |||
9949 | function Sign (algorithm) { | ||
9950 | stream.Writable.call(this) | ||
9951 | |||
9952 | var data = algorithms[algorithm] | ||
9953 | if (!data) throw new Error('Unknown message digest') | ||
9954 | |||
9955 | this._hashType = data.hash | ||
9956 | this._hash = createHash(data.hash) | ||
9957 | this._tag = data.id | ||
9958 | this._signType = data.sign | ||
9959 | } | ||
9960 | inherits(Sign, stream.Writable) | ||
9961 | |||
9962 | Sign.prototype._write = function _write (data, _, done) { | ||
9963 | this._hash.update(data) | ||
9964 | done() | ||
9965 | } | ||
9966 | |||
9967 | Sign.prototype.update = function update (data, enc) { | ||
9968 | if (typeof data === 'string') data = new Buffer(data, enc) | ||
9969 | |||
9970 | this._hash.update(data) | ||
9971 | return this | ||
9972 | } | ||
9973 | |||
9974 | Sign.prototype.sign = function signMethod (key, enc) { | ||
9975 | this.end() | ||
9976 | var hash = this._hash.digest() | ||
9977 | var sig = sign(hash, key, this._hashType, this._signType, this._tag) | ||
9978 | |||
9979 | return enc ? sig.toString(enc) : sig | ||
9980 | } | ||
9981 | |||
9982 | function Verify (algorithm) { | ||
9983 | stream.Writable.call(this) | ||
9984 | |||
9985 | var data = algorithms[algorithm] | ||
9986 | if (!data) throw new Error('Unknown message digest') | ||
9987 | |||
9988 | this._hash = createHash(data.hash) | ||
9989 | this._tag = data.id | ||
9990 | this._signType = data.sign | ||
9991 | } | ||
9992 | inherits(Verify, stream.Writable) | ||
9993 | |||
9994 | Verify.prototype._write = function _write (data, _, done) { | ||
9995 | this._hash.update(data) | ||
9996 | done() | ||
9997 | } | ||
9998 | |||
9999 | Verify.prototype.update = function update (data, enc) { | ||
10000 | if (typeof data === 'string') data = new Buffer(data, enc) | ||
10001 | |||
10002 | this._hash.update(data) | ||
10003 | return this | ||
10004 | } | ||
10005 | |||
10006 | Verify.prototype.verify = function verifyMethod (key, sig, enc) { | ||
10007 | if (typeof sig === 'string') sig = new Buffer(sig, enc) | ||
10008 | |||
10009 | this.end() | ||
10010 | var hash = this._hash.digest() | ||
10011 | return verify(sig, hash, key, this._signType, this._tag) | ||
10012 | } | ||
10013 | |||
10014 | function createSign (algorithm) { | ||
10015 | return new Sign(algorithm) | ||
10016 | } | ||
10017 | |||
10018 | function createVerify (algorithm) { | ||
10019 | return new Verify(algorithm) | ||
10020 | } | ||
10021 | |||
10022 | module.exports = { | ||
10023 | Sign: createSign, | ||
10024 | Verify: createVerify, | ||
10025 | createSign: createSign, | ||
10026 | createVerify: createVerify | ||
10027 | } | ||
10028 | |||
10029 | }).call(this,require("buffer").Buffer) | ||
10030 | },{"./algorithms.json":43,"./sign":46,"./verify":47,"buffer":49,"create-hash":67,"inherits":116,"stream":432}],46:[function(require,module,exports){ | ||
10031 | (function (Buffer){ | ||
10032 | // much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js | ||
10033 | var createHmac = require('create-hmac') | ||
10034 | var crt = require('browserify-rsa') | ||
10035 | var EC = require('elliptic').ec | ||
10036 | var BN = require('bn.js') | ||
10037 | var parseKeys = require('parse-asn1') | ||
10038 | var curves = require('./curves.json') | ||
10039 | |||
10040 | function sign (hash, key, hashType, signType, tag) { | ||
10041 | var priv = parseKeys(key) | ||
10042 | if (priv.curve) { | ||
10043 | // rsa keys can be interpreted as ecdsa ones in openssl | ||
10044 | if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type') | ||
10045 | return ecSign(hash, priv) | ||
10046 | } else if (priv.type === 'dsa') { | ||
10047 | if (signType !== 'dsa') throw new Error('wrong private key type') | ||
10048 | return dsaSign(hash, priv, hashType) | ||
10049 | } else { | ||
10050 | if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type') | ||
10051 | } | ||
10052 | hash = Buffer.concat([tag, hash]) | ||
10053 | var len = priv.modulus.byteLength() | ||
10054 | var pad = [ 0, 1 ] | ||
10055 | while (hash.length + pad.length + 1 < len) pad.push(0xff) | ||
10056 | pad.push(0x00) | ||
10057 | var i = -1 | ||
10058 | while (++i < hash.length) pad.push(hash[i]) | ||
10059 | |||
10060 | var out = crt(pad, priv) | ||
10061 | return out | ||
10062 | } | ||
10063 | |||
10064 | function ecSign (hash, priv) { | ||
10065 | var curveId = curves[priv.curve.join('.')] | ||
10066 | if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.')) | ||
10067 | |||
10068 | var curve = new EC(curveId) | ||
10069 | var key = curve.keyFromPrivate(priv.privateKey) | ||
10070 | var out = key.sign(hash) | ||
10071 | |||
10072 | return new Buffer(out.toDER()) | ||
10073 | } | ||
10074 | |||
10075 | function dsaSign (hash, priv, algo) { | ||
10076 | var x = priv.params.priv_key | ||
10077 | var p = priv.params.p | ||
10078 | var q = priv.params.q | ||
10079 | var g = priv.params.g | ||
10080 | var r = new BN(0) | ||
10081 | var k | ||
10082 | var H = bits2int(hash, q).mod(q) | ||
10083 | var s = false | ||
10084 | var kv = getKey(x, q, hash, algo) | ||
10085 | while (s === false) { | ||
10086 | k = makeKey(q, kv, algo) | ||
10087 | r = makeR(g, k, p, q) | ||
10088 | s = k.invm(q).imul(H.add(x.mul(r))).mod(q) | ||
10089 | if (s.cmpn(0) === 0) { | ||
10090 | s = false | ||
10091 | r = new BN(0) | ||
10092 | } | ||
10093 | } | ||
10094 | return toDER(r, s) | ||
10095 | } | ||
10096 | |||
10097 | function toDER (r, s) { | ||
10098 | r = r.toArray() | ||
10099 | s = s.toArray() | ||
10100 | |||
10101 | // Pad values | ||
10102 | if (r[0] & 0x80) r = [ 0 ].concat(r) | ||
10103 | if (s[0] & 0x80) s = [ 0 ].concat(s) | ||
10104 | |||
10105 | var total = r.length + s.length + 4 | ||
10106 | var res = [ 0x30, total, 0x02, r.length ] | ||
10107 | res = res.concat(r, [ 0x02, s.length ], s) | ||
10108 | return new Buffer(res) | ||
10109 | } | ||
10110 | |||
10111 | function getKey (x, q, hash, algo) { | ||
10112 | x = new Buffer(x.toArray()) | ||
10113 | if (x.length < q.byteLength()) { | ||
10114 | var zeros = new Buffer(q.byteLength() - x.length) | ||
10115 | zeros.fill(0) | ||
10116 | x = Buffer.concat([ zeros, x ]) | ||
10117 | } | ||
10118 | var hlen = hash.length | ||
10119 | var hbits = bits2octets(hash, q) | ||
10120 | var v = new Buffer(hlen) | ||
10121 | v.fill(1) | ||
10122 | var k = new Buffer(hlen) | ||
10123 | k.fill(0) | ||
10124 | k = createHmac(algo, k).update(v).update(new Buffer([ 0 ])).update(x).update(hbits).digest() | ||
10125 | v = createHmac(algo, k).update(v).digest() | ||
10126 | k = createHmac(algo, k).update(v).update(new Buffer([ 1 ])).update(x).update(hbits).digest() | ||
10127 | v = createHmac(algo, k).update(v).digest() | ||
10128 | return { k: k, v: v } | ||
10129 | } | ||
10130 | |||
10131 | function bits2int (obits, q) { | ||
10132 | var bits = new BN(obits) | ||
10133 | var shift = (obits.length << 3) - q.bitLength() | ||
10134 | if (shift > 0) bits.ishrn(shift) | ||
10135 | return bits | ||
10136 | } | ||
10137 | |||
10138 | function bits2octets (bits, q) { | ||
10139 | bits = bits2int(bits, q) | ||
10140 | bits = bits.mod(q) | ||
10141 | var out = new Buffer(bits.toArray()) | ||
10142 | if (out.length < q.byteLength()) { | ||
10143 | var zeros = new Buffer(q.byteLength() - out.length) | ||
10144 | zeros.fill(0) | ||
10145 | out = Buffer.concat([ zeros, out ]) | ||
10146 | } | ||
10147 | return out | ||
10148 | } | ||
10149 | |||
10150 | function makeKey (q, kv, algo) { | ||
10151 | var t | ||
10152 | var k | ||
10153 | |||
10154 | do { | ||
10155 | t = new Buffer(0) | ||
10156 | |||
10157 | while (t.length * 8 < q.bitLength()) { | ||
10158 | kv.v = createHmac(algo, kv.k).update(kv.v).digest() | ||
10159 | t = Buffer.concat([ t, kv.v ]) | ||
10160 | } | ||
10161 | |||
10162 | k = bits2int(t, q) | ||
10163 | kv.k = createHmac(algo, kv.k).update(kv.v).update(new Buffer([ 0 ])).digest() | ||
10164 | kv.v = createHmac(algo, kv.k).update(kv.v).digest() | ||
10165 | } while (k.cmp(q) !== -1) | ||
10166 | |||
10167 | return k | ||
10168 | } | ||
10169 | |||
10170 | function makeR (g, k, p, q) { | ||
10171 | return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q) | ||
10172 | } | ||
10173 | |||
10174 | module.exports = sign | ||
10175 | module.exports.getKey = getKey | ||
10176 | module.exports.makeKey = makeKey | ||
10177 | |||
10178 | }).call(this,require("buffer").Buffer) | ||
10179 | },{"./curves.json":44,"bn.js":18,"browserify-rsa":41,"buffer":49,"create-hmac":69,"elliptic":83,"parse-asn1":362}],47:[function(require,module,exports){ | ||
10180 | (function (Buffer){ | ||
10181 | // much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js | ||
10182 | var BN = require('bn.js') | ||
10183 | var EC = require('elliptic').ec | ||
10184 | var parseKeys = require('parse-asn1') | ||
10185 | var curves = require('./curves.json') | ||
10186 | |||
10187 | function verify (sig, hash, key, signType, tag) { | ||
10188 | var pub = parseKeys(key) | ||
10189 | if (pub.type === 'ec') { | ||
10190 | // rsa keys can be interpreted as ecdsa ones in openssl | ||
10191 | if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type') | ||
10192 | return ecVerify(sig, hash, pub) | ||
10193 | } else if (pub.type === 'dsa') { | ||
10194 | if (signType !== 'dsa') throw new Error('wrong public key type') | ||
10195 | return dsaVerify(sig, hash, pub) | ||
10196 | } else { | ||
10197 | if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type') | ||
10198 | } | ||
10199 | hash = Buffer.concat([tag, hash]) | ||
10200 | var len = pub.modulus.byteLength() | ||
10201 | var pad = [ 1 ] | ||
10202 | var padNum = 0 | ||
10203 | while (hash.length + pad.length + 2 < len) { | ||
10204 | pad.push(0xff) | ||
10205 | padNum++ | ||
10206 | } | ||
10207 | pad.push(0x00) | ||
10208 | var i = -1 | ||
10209 | while (++i < hash.length) { | ||
10210 | pad.push(hash[i]) | ||
10211 | } | ||
10212 | pad = new Buffer(pad) | ||
10213 | var red = BN.mont(pub.modulus) | ||
10214 | sig = new BN(sig).toRed(red) | ||
10215 | |||
10216 | sig = sig.redPow(new BN(pub.publicExponent)) | ||
10217 | sig = new Buffer(sig.fromRed().toArray()) | ||
10218 | var out = padNum < 8 ? 1 : 0 | ||
10219 | len = Math.min(sig.length, pad.length) | ||
10220 | if (sig.length !== pad.length) out = 1 | ||
10221 | |||
10222 | i = -1 | ||
10223 | while (++i < len) out |= sig[i] ^ pad[i] | ||
10224 | return out === 0 | ||
10225 | } | ||
10226 | |||
10227 | function ecVerify (sig, hash, pub) { | ||
10228 | var curveId = curves[pub.data.algorithm.curve.join('.')] | ||
10229 | if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.')) | ||
10230 | |||
10231 | var curve = new EC(curveId) | ||
10232 | var pubkey = pub.data.subjectPrivateKey.data | ||
10233 | |||
10234 | return curve.verify(hash, sig, pubkey) | ||
10235 | } | ||
10236 | |||
10237 | function dsaVerify (sig, hash, pub) { | ||
10238 | var p = pub.data.p | ||
10239 | var q = pub.data.q | ||
10240 | var g = pub.data.g | ||
10241 | var y = pub.data.pub_key | ||
10242 | var unpacked = parseKeys.signature.decode(sig, 'der') | ||
10243 | var s = unpacked.s | ||
10244 | var r = unpacked.r | ||
10245 | checkValue(s, q) | ||
10246 | checkValue(r, q) | ||
10247 | var montp = BN.mont(p) | ||
10248 | var w = s.invm(q) | ||
10249 | var v = g.toRed(montp) | ||
10250 | .redPow(new BN(hash).mul(w).mod(q)) | ||
10251 | .fromRed() | ||
10252 | .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed()) | ||
10253 | .mod(p) | ||
10254 | .mod(q) | ||
10255 | return v.cmp(r) === 0 | ||
10256 | } | ||
10257 | |||
10258 | function checkValue (b, q) { | ||
10259 | if (b.cmpn(0) <= 0) throw new Error('invalid sig') | ||
10260 | if (b.cmp(q) >= q) throw new Error('invalid sig') | ||
10261 | } | ||
10262 | |||
10263 | module.exports = verify | ||
10264 | |||
10265 | }).call(this,require("buffer").Buffer) | ||
10266 | },{"./curves.json":44,"bn.js":18,"buffer":49,"elliptic":83,"parse-asn1":362}],48:[function(require,module,exports){ | ||
10267 | (function (Buffer){ | ||
10268 | module.exports = function xor (a, b) { | ||
10269 | var length = Math.min(a.length, b.length) | ||
10270 | var buffer = new Buffer(length) | ||
10271 | |||
10272 | for (var i = 0; i < length; ++i) { | ||
10273 | buffer[i] = a[i] ^ b[i] | ||
10274 | } | ||
10275 | |||
10276 | return buffer | ||
10277 | } | ||
10278 | |||
10279 | }).call(this,require("buffer").Buffer) | ||
10280 | },{"buffer":49}],49:[function(require,module,exports){ | ||
10281 | /*! | ||
10282 | * The buffer module from node.js, for the browser. | ||
10283 | * | ||
10284 | * @author Feross Aboukhadijeh <https://feross.org> | ||
10285 | * @license MIT | ||
10286 | */ | ||
10287 | /* eslint-disable no-proto */ | ||
10288 | |||
10289 | 'use strict' | ||
10290 | |||
10291 | var base64 = require('base64-js') | ||
10292 | var ieee754 = require('ieee754') | ||
10293 | |||
10294 | exports.Buffer = Buffer | ||
10295 | exports.SlowBuffer = SlowBuffer | ||
10296 | exports.INSPECT_MAX_BYTES = 50 | ||
10297 | |||
10298 | var K_MAX_LENGTH = 0x7fffffff | ||
10299 | exports.kMaxLength = K_MAX_LENGTH | ||
10300 | |||
10301 | /** | ||
10302 | * If `Buffer.TYPED_ARRAY_SUPPORT`: | ||
10303 | * === true Use Uint8Array implementation (fastest) | ||
10304 | * === false Print warning and recommend using `buffer` v4.x which has an Object | ||
10305 | * implementation (most compatible, even IE6) | ||
10306 | * | ||
10307 | * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, | ||
10308 | * Opera 11.6+, iOS 4.2+. | ||
10309 | * | ||
10310 | * We report that the browser does not support typed arrays if the are not subclassable | ||
10311 | * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` | ||
10312 | * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support | ||
10313 | * for __proto__ and has a buggy typed array implementation. | ||
10314 | */ | ||
10315 | Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() | ||
10316 | |||
10317 | if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && | ||
10318 | typeof console.error === 'function') { | ||
10319 | console.error( | ||
10320 | 'This browser lacks typed array (Uint8Array) support which is required by ' + | ||
10321 | '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' | ||
10322 | ) | ||
10323 | } | ||
10324 | |||
10325 | function typedArraySupport () { | ||
10326 | // Can typed array instances can be augmented? | ||
10327 | try { | ||
10328 | var arr = new Uint8Array(1) | ||
10329 | arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } } | ||
10330 | return arr.foo() === 42 | ||
10331 | } catch (e) { | ||
10332 | return false | ||
10333 | } | ||
10334 | } | ||
10335 | |||
10336 | Object.defineProperty(Buffer.prototype, 'parent', { | ||
10337 | enumerable: true, | ||
10338 | get: function () { | ||
10339 | if (!Buffer.isBuffer(this)) return undefined | ||
10340 | return this.buffer | ||
10341 | } | ||
10342 | }) | ||
10343 | |||
10344 | Object.defineProperty(Buffer.prototype, 'offset', { | ||
10345 | enumerable: true, | ||
10346 | get: function () { | ||
10347 | if (!Buffer.isBuffer(this)) return undefined | ||
10348 | return this.byteOffset | ||
10349 | } | ||
10350 | }) | ||
10351 | |||
10352 | function createBuffer (length) { | ||
10353 | if (length > K_MAX_LENGTH) { | ||
10354 | throw new RangeError('The value "' + length + '" is invalid for option "size"') | ||
10355 | } | ||
10356 | // Return an augmented `Uint8Array` instance | ||
10357 | var buf = new Uint8Array(length) | ||
10358 | buf.__proto__ = Buffer.prototype | ||
10359 | return buf | ||
10360 | } | ||
10361 | |||
10362 | /** | ||
10363 | * The Buffer constructor returns instances of `Uint8Array` that have their | ||
10364 | * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of | ||
10365 | * `Uint8Array`, so the returned instances will have all the node `Buffer` methods | ||
10366 | * and the `Uint8Array` methods. Square bracket notation works as expected -- it | ||
10367 | * returns a single octet. | ||
10368 | * | ||
10369 | * The `Uint8Array` prototype remains unmodified. | ||
10370 | */ | ||
10371 | |||
10372 | function Buffer (arg, encodingOrOffset, length) { | ||
10373 | // Common case. | ||
10374 | if (typeof arg === 'number') { | ||
10375 | if (typeof encodingOrOffset === 'string') { | ||
10376 | throw new TypeError( | ||
10377 | 'The "string" argument must be of type string. Received type number' | ||
10378 | ) | ||
10379 | } | ||
10380 | return allocUnsafe(arg) | ||
10381 | } | ||
10382 | return from(arg, encodingOrOffset, length) | ||
10383 | } | ||
10384 | |||
10385 | // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 | ||
10386 | if (typeof Symbol !== 'undefined' && Symbol.species != null && | ||
10387 | Buffer[Symbol.species] === Buffer) { | ||
10388 | Object.defineProperty(Buffer, Symbol.species, { | ||
10389 | value: null, | ||
10390 | configurable: true, | ||
10391 | enumerable: false, | ||
10392 | writable: false | ||
10393 | }) | ||
10394 | } | ||
10395 | |||
10396 | Buffer.poolSize = 8192 // not used by this implementation | ||
10397 | |||
10398 | function from (value, encodingOrOffset, length) { | ||
10399 | if (typeof value === 'string') { | ||
10400 | return fromString(value, encodingOrOffset) | ||
10401 | } | ||
10402 | |||
10403 | if (ArrayBuffer.isView(value)) { | ||
10404 | return fromArrayLike(value) | ||
10405 | } | ||
10406 | |||
10407 | if (value == null) { | ||
10408 | throw TypeError( | ||
10409 | 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + | ||
10410 | 'or Array-like Object. Received type ' + (typeof value) | ||
10411 | ) | ||
10412 | } | ||
10413 | |||
10414 | if (isInstance(value, ArrayBuffer) || | ||
10415 | (value && isInstance(value.buffer, ArrayBuffer))) { | ||
10416 | return fromArrayBuffer(value, encodingOrOffset, length) | ||
10417 | } | ||
10418 | |||
10419 | if (typeof value === 'number') { | ||
10420 | throw new TypeError( | ||
10421 | 'The "value" argument must not be of type number. Received type number' | ||
10422 | ) | ||
10423 | } | ||
10424 | |||
10425 | var valueOf = value.valueOf && value.valueOf() | ||
10426 | if (valueOf != null && valueOf !== value) { | ||
10427 | return Buffer.from(valueOf, encodingOrOffset, length) | ||
10428 | } | ||
10429 | |||
10430 | var b = fromObject(value) | ||
10431 | if (b) return b | ||
10432 | |||
10433 | if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null && | ||
10434 | typeof value[Symbol.toPrimitive] === 'function') { | ||
10435 | return Buffer.from( | ||
10436 | value[Symbol.toPrimitive]('string'), encodingOrOffset, length | ||
10437 | ) | ||
10438 | } | ||
10439 | |||
10440 | throw new TypeError( | ||
10441 | 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + | ||
10442 | 'or Array-like Object. Received type ' + (typeof value) | ||
10443 | ) | ||
10444 | } | ||
10445 | |||
10446 | /** | ||
10447 | * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError | ||
10448 | * if value is a number. | ||
10449 | * Buffer.from(str[, encoding]) | ||
10450 | * Buffer.from(array) | ||
10451 | * Buffer.from(buffer) | ||
10452 | * Buffer.from(arrayBuffer[, byteOffset[, length]]) | ||
10453 | **/ | ||
10454 | Buffer.from = function (value, encodingOrOffset, length) { | ||
10455 | return from(value, encodingOrOffset, length) | ||
10456 | } | ||
10457 | |||
10458 | // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: | ||
10459 | // https://github.com/feross/buffer/pull/148 | ||
10460 | Buffer.prototype.__proto__ = Uint8Array.prototype | ||
10461 | Buffer.__proto__ = Uint8Array | ||
10462 | |||
10463 | function assertSize (size) { | ||
10464 | if (typeof size !== 'number') { | ||
10465 | throw new TypeError('"size" argument must be of type number') | ||
10466 | } else if (size < 0) { | ||
10467 | throw new RangeError('The value "' + size + '" is invalid for option "size"') | ||
10468 | } | ||
10469 | } | ||
10470 | |||
10471 | function alloc (size, fill, encoding) { | ||
10472 | assertSize(size) | ||
10473 | if (size <= 0) { | ||
10474 | return createBuffer(size) | ||
10475 | } | ||
10476 | if (fill !== undefined) { | ||
10477 | // Only pay attention to encoding if it's a string. This | ||
10478 | // prevents accidentally sending in a number that would | ||
10479 | // be interpretted as a start offset. | ||
10480 | return typeof encoding === 'string' | ||
10481 | ? createBuffer(size).fill(fill, encoding) | ||
10482 | : createBuffer(size).fill(fill) | ||
10483 | } | ||
10484 | return createBuffer(size) | ||
10485 | } | ||
10486 | |||
10487 | /** | ||
10488 | * Creates a new filled Buffer instance. | ||
10489 | * alloc(size[, fill[, encoding]]) | ||
10490 | **/ | ||
10491 | Buffer.alloc = function (size, fill, encoding) { | ||
10492 | return alloc(size, fill, encoding) | ||
10493 | } | ||
10494 | |||
10495 | function allocUnsafe (size) { | ||
10496 | assertSize(size) | ||
10497 | return createBuffer(size < 0 ? 0 : checked(size) | 0) | ||
10498 | } | ||
10499 | |||
10500 | /** | ||
10501 | * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. | ||
10502 | * */ | ||
10503 | Buffer.allocUnsafe = function (size) { | ||
10504 | return allocUnsafe(size) | ||
10505 | } | ||
10506 | /** | ||
10507 | * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. | ||
10508 | */ | ||
10509 | Buffer.allocUnsafeSlow = function (size) { | ||
10510 | return allocUnsafe(size) | ||
10511 | } | ||
10512 | |||
10513 | function fromString (string, encoding) { | ||
10514 | if (typeof encoding !== 'string' || encoding === '') { | ||
10515 | encoding = 'utf8' | ||
10516 | } | ||
10517 | |||
10518 | if (!Buffer.isEncoding(encoding)) { | ||
10519 | throw new TypeError('Unknown encoding: ' + encoding) | ||
10520 | } | ||
10521 | |||
10522 | var length = byteLength(string, encoding) | 0 | ||
10523 | var buf = createBuffer(length) | ||
10524 | |||
10525 | var actual = buf.write(string, encoding) | ||
10526 | |||
10527 | if (actual !== length) { | ||
10528 | // Writing a hex string, for example, that contains invalid characters will | ||
10529 | // cause everything after the first invalid character to be ignored. (e.g. | ||
10530 | // 'abxxcd' will be treated as 'ab') | ||
10531 | buf = buf.slice(0, actual) | ||
10532 | } | ||
10533 | |||
10534 | return buf | ||
10535 | } | ||
10536 | |||
10537 | function fromArrayLike (array) { | ||
10538 | var length = array.length < 0 ? 0 : checked(array.length) | 0 | ||
10539 | var buf = createBuffer(length) | ||
10540 | for (var i = 0; i < length; i += 1) { | ||
10541 | buf[i] = array[i] & 255 | ||
10542 | } | ||
10543 | return buf | ||
10544 | } | ||
10545 | |||
10546 | function fromArrayBuffer (array, byteOffset, length) { | ||
10547 | if (byteOffset < 0 || array.byteLength < byteOffset) { | ||
10548 | throw new RangeError('"offset" is outside of buffer bounds') | ||
10549 | } | ||
10550 | |||
10551 | if (array.byteLength < byteOffset + (length || 0)) { | ||
10552 | throw new RangeError('"length" is outside of buffer bounds') | ||
10553 | } | ||
10554 | |||
10555 | var buf | ||
10556 | if (byteOffset === undefined && length === undefined) { | ||
10557 | buf = new Uint8Array(array) | ||
10558 | } else if (length === undefined) { | ||
10559 | buf = new Uint8Array(array, byteOffset) | ||
10560 | } else { | ||
10561 | buf = new Uint8Array(array, byteOffset, length) | ||
10562 | } | ||
10563 | |||
10564 | // Return an augmented `Uint8Array` instance | ||
10565 | buf.__proto__ = Buffer.prototype | ||
10566 | return buf | ||
10567 | } | ||
10568 | |||
10569 | function fromObject (obj) { | ||
10570 | if (Buffer.isBuffer(obj)) { | ||
10571 | var len = checked(obj.length) | 0 | ||
10572 | var buf = createBuffer(len) | ||
10573 | |||
10574 | if (buf.length === 0) { | ||
10575 | return buf | ||
10576 | } | ||
10577 | |||
10578 | obj.copy(buf, 0, 0, len) | ||
10579 | return buf | ||
10580 | } | ||
10581 | |||
10582 | if (obj.length !== undefined) { | ||
10583 | if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { | ||
10584 | return createBuffer(0) | ||
10585 | } | ||
10586 | return fromArrayLike(obj) | ||
10587 | } | ||
10588 | |||
10589 | if (obj.type === 'Buffer' && Array.isArray(obj.data)) { | ||
10590 | return fromArrayLike(obj.data) | ||
10591 | } | ||
10592 | } | ||
10593 | |||
10594 | function checked (length) { | ||
10595 | // Note: cannot use `length < K_MAX_LENGTH` here because that fails when | ||
10596 | // length is NaN (which is otherwise coerced to zero.) | ||
10597 | if (length >= K_MAX_LENGTH) { | ||
10598 | throw new RangeError('Attempt to allocate Buffer larger than maximum ' + | ||
10599 | 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') | ||
10600 | } | ||
10601 | return length | 0 | ||
10602 | } | ||
10603 | |||
10604 | function SlowBuffer (length) { | ||
10605 | if (+length != length) { // eslint-disable-line eqeqeq | ||
10606 | length = 0 | ||
10607 | } | ||
10608 | return Buffer.alloc(+length) | ||
10609 | } | ||
10610 | |||
10611 | Buffer.isBuffer = function isBuffer (b) { | ||
10612 | return b != null && b._isBuffer === true && | ||
10613 | b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false | ||
10614 | } | ||
10615 | |||
10616 | Buffer.compare = function compare (a, b) { | ||
10617 | if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength) | ||
10618 | if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength) | ||
10619 | if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { | ||
10620 | throw new TypeError( | ||
10621 | 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' | ||
10622 | ) | ||
10623 | } | ||
10624 | |||
10625 | if (a === b) return 0 | ||
10626 | |||
10627 | var x = a.length | ||
10628 | var y = b.length | ||
10629 | |||
10630 | for (var i = 0, len = Math.min(x, y); i < len; ++i) { | ||
10631 | if (a[i] !== b[i]) { | ||
10632 | x = a[i] | ||
10633 | y = b[i] | ||
10634 | break | ||
10635 | } | ||
10636 | } | ||
10637 | |||
10638 | if (x < y) return -1 | ||
10639 | if (y < x) return 1 | ||
10640 | return 0 | ||
10641 | } | ||
10642 | |||
10643 | Buffer.isEncoding = function isEncoding (encoding) { | ||
10644 | switch (String(encoding).toLowerCase()) { | ||
10645 | case 'hex': | ||
10646 | case 'utf8': | ||
10647 | case 'utf-8': | ||
10648 | case 'ascii': | ||
10649 | case 'latin1': | ||
10650 | case 'binary': | ||
10651 | case 'base64': | ||
10652 | case 'ucs2': | ||
10653 | case 'ucs-2': | ||
10654 | case 'utf16le': | ||
10655 | case 'utf-16le': | ||
10656 | return true | ||
10657 | default: | ||
10658 | return false | ||
10659 | } | ||
10660 | } | ||
10661 | |||
10662 | Buffer.concat = function concat (list, length) { | ||
10663 | if (!Array.isArray(list)) { | ||
10664 | throw new TypeError('"list" argument must be an Array of Buffers') | ||
10665 | } | ||
10666 | |||
10667 | if (list.length === 0) { | ||
10668 | return Buffer.alloc(0) | ||
10669 | } | ||
10670 | |||
10671 | var i | ||
10672 | if (length === undefined) { | ||
10673 | length = 0 | ||
10674 | for (i = 0; i < list.length; ++i) { | ||
10675 | length += list[i].length | ||
10676 | } | ||
10677 | } | ||
10678 | |||
10679 | var buffer = Buffer.allocUnsafe(length) | ||
10680 | var pos = 0 | ||
10681 | for (i = 0; i < list.length; ++i) { | ||
10682 | var buf = list[i] | ||
10683 | if (isInstance(buf, Uint8Array)) { | ||
10684 | buf = Buffer.from(buf) | ||
10685 | } | ||
10686 | if (!Buffer.isBuffer(buf)) { | ||
10687 | throw new TypeError('"list" argument must be an Array of Buffers') | ||
10688 | } | ||
10689 | buf.copy(buffer, pos) | ||
10690 | pos += buf.length | ||
10691 | } | ||
10692 | return buffer | ||
10693 | } | ||
10694 | |||
10695 | function byteLength (string, encoding) { | ||
10696 | if (Buffer.isBuffer(string)) { | ||
10697 | return string.length | ||
10698 | } | ||
10699 | if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { | ||
10700 | return string.byteLength | ||
10701 | } | ||
10702 | if (typeof string !== 'string') { | ||
10703 | throw new TypeError( | ||
10704 | 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + | ||
10705 | 'Received type ' + typeof string | ||
10706 | ) | ||
10707 | } | ||
10708 | |||
10709 | var len = string.length | ||
10710 | var mustMatch = (arguments.length > 2 && arguments[2] === true) | ||
10711 | if (!mustMatch && len === 0) return 0 | ||
10712 | |||
10713 | // Use a for loop to avoid recursion | ||
10714 | var loweredCase = false | ||
10715 | for (;;) { | ||
10716 | switch (encoding) { | ||
10717 | case 'ascii': | ||
10718 | case 'latin1': | ||
10719 | case 'binary': | ||
10720 | return len | ||
10721 | case 'utf8': | ||
10722 | case 'utf-8': | ||
10723 | return utf8ToBytes(string).length | ||
10724 | case 'ucs2': | ||
10725 | case 'ucs-2': | ||
10726 | case 'utf16le': | ||
10727 | case 'utf-16le': | ||
10728 | return len * 2 | ||
10729 | case 'hex': | ||
10730 | return len >>> 1 | ||
10731 | case 'base64': | ||
10732 | return base64ToBytes(string).length | ||
10733 | default: | ||
10734 | if (loweredCase) { | ||
10735 | return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8 | ||
10736 | } | ||
10737 | encoding = ('' + encoding).toLowerCase() | ||
10738 | loweredCase = true | ||
10739 | } | ||
10740 | } | ||
10741 | } | ||
10742 | Buffer.byteLength = byteLength | ||
10743 | |||
10744 | function slowToString (encoding, start, end) { | ||
10745 | var loweredCase = false | ||
10746 | |||
10747 | // No need to verify that "this.length <= MAX_UINT32" since it's a read-only | ||
10748 | // property of a typed array. | ||
10749 | |||
10750 | // This behaves neither like String nor Uint8Array in that we set start/end | ||
10751 | // to their upper/lower bounds if the value passed is out of range. | ||
10752 | // undefined is handled specially as per ECMA-262 6th Edition, | ||
10753 | // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. | ||
10754 | if (start === undefined || start < 0) { | ||
10755 | start = 0 | ||
10756 | } | ||
10757 | // Return early if start > this.length. Done here to prevent potential uint32 | ||
10758 | // coercion fail below. | ||
10759 | if (start > this.length) { | ||
10760 | return '' | ||
10761 | } | ||
10762 | |||
10763 | if (end === undefined || end > this.length) { | ||
10764 | end = this.length | ||
10765 | } | ||
10766 | |||
10767 | if (end <= 0) { | ||
10768 | return '' | ||
10769 | } | ||
10770 | |||
10771 | // Force coersion to uint32. This will also coerce falsey/NaN values to 0. | ||
10772 | end >>>= 0 | ||
10773 | start >>>= 0 | ||
10774 | |||
10775 | if (end <= start) { | ||
10776 | return '' | ||
10777 | } | ||
10778 | |||
10779 | if (!encoding) encoding = 'utf8' | ||
10780 | |||
10781 | while (true) { | ||
10782 | switch (encoding) { | ||
10783 | case 'hex': | ||
10784 | return hexSlice(this, start, end) | ||
10785 | |||
10786 | case 'utf8': | ||
10787 | case 'utf-8': | ||
10788 | return utf8Slice(this, start, end) | ||
10789 | |||
10790 | case 'ascii': | ||
10791 | return asciiSlice(this, start, end) | ||
10792 | |||
10793 | case 'latin1': | ||
10794 | case 'binary': | ||
10795 | return latin1Slice(this, start, end) | ||
10796 | |||
10797 | case 'base64': | ||
10798 | return base64Slice(this, start, end) | ||
10799 | |||
10800 | case 'ucs2': | ||
10801 | case 'ucs-2': | ||
10802 | case 'utf16le': | ||
10803 | case 'utf-16le': | ||
10804 | return utf16leSlice(this, start, end) | ||
10805 | |||
10806 | default: | ||
10807 | if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) | ||
10808 | encoding = (encoding + '').toLowerCase() | ||
10809 | loweredCase = true | ||
10810 | } | ||
10811 | } | ||
10812 | } | ||
10813 | |||
10814 | // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) | ||
10815 | // to detect a Buffer instance. It's not possible to use `instanceof Buffer` | ||
10816 | // reliably in a browserify context because there could be multiple different | ||
10817 | // copies of the 'buffer' package in use. This method works even for Buffer | ||
10818 | // instances that were created from another copy of the `buffer` package. | ||
10819 | // See: https://github.com/feross/buffer/issues/154 | ||
10820 | Buffer.prototype._isBuffer = true | ||
10821 | |||
10822 | function swap (b, n, m) { | ||
10823 | var i = b[n] | ||
10824 | b[n] = b[m] | ||
10825 | b[m] = i | ||
10826 | } | ||
10827 | |||
10828 | Buffer.prototype.swap16 = function swap16 () { | ||
10829 | var len = this.length | ||
10830 | if (len % 2 !== 0) { | ||
10831 | throw new RangeError('Buffer size must be a multiple of 16-bits') | ||
10832 | } | ||
10833 | for (var i = 0; i < len; i += 2) { | ||
10834 | swap(this, i, i + 1) | ||
10835 | } | ||
10836 | return this | ||
10837 | } | ||
10838 | |||
10839 | Buffer.prototype.swap32 = function swap32 () { | ||
10840 | var len = this.length | ||
10841 | if (len % 4 !== 0) { | ||
10842 | throw new RangeError('Buffer size must be a multiple of 32-bits') | ||
10843 | } | ||
10844 | for (var i = 0; i < len; i += 4) { | ||
10845 | swap(this, i, i + 3) | ||
10846 | swap(this, i + 1, i + 2) | ||
10847 | } | ||
10848 | return this | ||
10849 | } | ||
10850 | |||
10851 | Buffer.prototype.swap64 = function swap64 () { | ||
10852 | var len = this.length | ||
10853 | if (len % 8 !== 0) { | ||
10854 | throw new RangeError('Buffer size must be a multiple of 64-bits') | ||
10855 | } | ||
10856 | for (var i = 0; i < len; i += 8) { | ||
10857 | swap(this, i, i + 7) | ||
10858 | swap(this, i + 1, i + 6) | ||
10859 | swap(this, i + 2, i + 5) | ||
10860 | swap(this, i + 3, i + 4) | ||
10861 | } | ||
10862 | return this | ||
10863 | } | ||
10864 | |||
10865 | Buffer.prototype.toString = function toString () { | ||
10866 | var length = this.length | ||
10867 | if (length === 0) return '' | ||
10868 | if (arguments.length === 0) return utf8Slice(this, 0, length) | ||
10869 | return slowToString.apply(this, arguments) | ||
10870 | } | ||
10871 | |||
10872 | Buffer.prototype.toLocaleString = Buffer.prototype.toString | ||
10873 | |||
10874 | Buffer.prototype.equals = function equals (b) { | ||
10875 | if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') | ||
10876 | if (this === b) return true | ||
10877 | return Buffer.compare(this, b) === 0 | ||
10878 | } | ||
10879 | |||
10880 | Buffer.prototype.inspect = function inspect () { | ||
10881 | var str = '' | ||
10882 | var max = exports.INSPECT_MAX_BYTES | ||
10883 | str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim() | ||
10884 | if (this.length > max) str += ' ... ' | ||
10885 | return '<Buffer ' + str + '>' | ||
10886 | } | ||
10887 | |||
10888 | Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { | ||
10889 | if (isInstance(target, Uint8Array)) { | ||
10890 | target = Buffer.from(target, target.offset, target.byteLength) | ||
10891 | } | ||
10892 | if (!Buffer.isBuffer(target)) { | ||
10893 | throw new TypeError( | ||
10894 | 'The "target" argument must be one of type Buffer or Uint8Array. ' + | ||
10895 | 'Received type ' + (typeof target) | ||
10896 | ) | ||
10897 | } | ||
10898 | |||
10899 | if (start === undefined) { | ||
10900 | start = 0 | ||
10901 | } | ||
10902 | if (end === undefined) { | ||
10903 | end = target ? target.length : 0 | ||
10904 | } | ||
10905 | if (thisStart === undefined) { | ||
10906 | thisStart = 0 | ||
10907 | } | ||
10908 | if (thisEnd === undefined) { | ||
10909 | thisEnd = this.length | ||
10910 | } | ||
10911 | |||
10912 | if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { | ||
10913 | throw new RangeError('out of range index') | ||
10914 | } | ||
10915 | |||
10916 | if (thisStart >= thisEnd && start >= end) { | ||
10917 | return 0 | ||
10918 | } | ||
10919 | if (thisStart >= thisEnd) { | ||
10920 | return -1 | ||
10921 | } | ||
10922 | if (start >= end) { | ||
10923 | return 1 | ||
10924 | } | ||
10925 | |||
10926 | start >>>= 0 | ||
10927 | end >>>= 0 | ||
10928 | thisStart >>>= 0 | ||
10929 | thisEnd >>>= 0 | ||
10930 | |||
10931 | if (this === target) return 0 | ||
10932 | |||
10933 | var x = thisEnd - thisStart | ||
10934 | var y = end - start | ||
10935 | var len = Math.min(x, y) | ||
10936 | |||
10937 | var thisCopy = this.slice(thisStart, thisEnd) | ||
10938 | var targetCopy = target.slice(start, end) | ||
10939 | |||
10940 | for (var i = 0; i < len; ++i) { | ||
10941 | if (thisCopy[i] !== targetCopy[i]) { | ||
10942 | x = thisCopy[i] | ||
10943 | y = targetCopy[i] | ||
10944 | break | ||
10945 | } | ||
10946 | } | ||
10947 | |||
10948 | if (x < y) return -1 | ||
10949 | if (y < x) return 1 | ||
10950 | return 0 | ||
10951 | } | ||
10952 | |||
10953 | // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, | ||
10954 | // OR the last index of `val` in `buffer` at offset <= `byteOffset`. | ||
10955 | // | ||
10956 | // Arguments: | ||
10957 | // - buffer - a Buffer to search | ||
10958 | // - val - a string, Buffer, or number | ||
10959 | // - byteOffset - an index into `buffer`; will be clamped to an int32 | ||
10960 | // - encoding - an optional encoding, relevant is val is a string | ||
10961 | // - dir - true for indexOf, false for lastIndexOf | ||
10962 | function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { | ||
10963 | // Empty buffer means no match | ||
10964 | if (buffer.length === 0) return -1 | ||
10965 | |||
10966 | // Normalize byteOffset | ||
10967 | if (typeof byteOffset === 'string') { | ||
10968 | encoding = byteOffset | ||
10969 | byteOffset = 0 | ||
10970 | } else if (byteOffset > 0x7fffffff) { | ||
10971 | byteOffset = 0x7fffffff | ||
10972 | } else if (byteOffset < -0x80000000) { | ||
10973 | byteOffset = -0x80000000 | ||
10974 | } | ||
10975 | byteOffset = +byteOffset // Coerce to Number. | ||
10976 | if (numberIsNaN(byteOffset)) { | ||
10977 | // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer | ||
10978 | byteOffset = dir ? 0 : (buffer.length - 1) | ||
10979 | } | ||
10980 | |||
10981 | // Normalize byteOffset: negative offsets start from the end of the buffer | ||
10982 | if (byteOffset < 0) byteOffset = buffer.length + byteOffset | ||
10983 | if (byteOffset >= buffer.length) { | ||
10984 | if (dir) return -1 | ||
10985 | else byteOffset = buffer.length - 1 | ||
10986 | } else if (byteOffset < 0) { | ||
10987 | if (dir) byteOffset = 0 | ||
10988 | else return -1 | ||
10989 | } | ||
10990 | |||
10991 | // Normalize val | ||
10992 | if (typeof val === 'string') { | ||
10993 | val = Buffer.from(val, encoding) | ||
10994 | } | ||
10995 | |||
10996 | // Finally, search either indexOf (if dir is true) or lastIndexOf | ||
10997 | if (Buffer.isBuffer(val)) { | ||
10998 | // Special case: looking for empty string/buffer always fails | ||
10999 | if (val.length === 0) { | ||
11000 | return -1 | ||
11001 | } | ||
11002 | return arrayIndexOf(buffer, val, byteOffset, encoding, dir) | ||
11003 | } else if (typeof val === 'number') { | ||
11004 | val = val & 0xFF // Search for a byte value [0-255] | ||
11005 | if (typeof Uint8Array.prototype.indexOf === 'function') { | ||
11006 | if (dir) { | ||
11007 | return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) | ||
11008 | } else { | ||
11009 | return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) | ||
11010 | } | ||
11011 | } | ||
11012 | return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) | ||
11013 | } | ||
11014 | |||
11015 | throw new TypeError('val must be string, number or Buffer') | ||
11016 | } | ||
11017 | |||
11018 | function arrayIndexOf (arr, val, byteOffset, encoding, dir) { | ||
11019 | var indexSize = 1 | ||
11020 | var arrLength = arr.length | ||
11021 | var valLength = val.length | ||
11022 | |||
11023 | if (encoding !== undefined) { | ||
11024 | encoding = String(encoding).toLowerCase() | ||
11025 | if (encoding === 'ucs2' || encoding === 'ucs-2' || | ||
11026 | encoding === 'utf16le' || encoding === 'utf-16le') { | ||
11027 | if (arr.length < 2 || val.length < 2) { | ||
11028 | return -1 | ||
11029 | } | ||
11030 | indexSize = 2 | ||
11031 | arrLength /= 2 | ||
11032 | valLength /= 2 | ||
11033 | byteOffset /= 2 | ||
11034 | } | ||
11035 | } | ||
11036 | |||
11037 | function read (buf, i) { | ||
11038 | if (indexSize === 1) { | ||
11039 | return buf[i] | ||
11040 | } else { | ||
11041 | return buf.readUInt16BE(i * indexSize) | ||
11042 | } | ||
11043 | } | ||
11044 | |||
11045 | var i | ||
11046 | if (dir) { | ||
11047 | var foundIndex = -1 | ||
11048 | for (i = byteOffset; i < arrLength; i++) { | ||
11049 | if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { | ||
11050 | if (foundIndex === -1) foundIndex = i | ||
11051 | if (i - foundIndex + 1 === valLength) return foundIndex * indexSize | ||
11052 | } else { | ||
11053 | if (foundIndex !== -1) i -= i - foundIndex | ||
11054 | foundIndex = -1 | ||
11055 | } | ||
11056 | } | ||
11057 | } else { | ||
11058 | if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength | ||
11059 | for (i = byteOffset; i >= 0; i--) { | ||
11060 | var found = true | ||
11061 | for (var j = 0; j < valLength; j++) { | ||
11062 | if (read(arr, i + j) !== read(val, j)) { | ||
11063 | found = false | ||
11064 | break | ||
11065 | } | ||
11066 | } | ||
11067 | if (found) return i | ||
11068 | } | ||
11069 | } | ||
11070 | |||
11071 | return -1 | ||
11072 | } | ||
11073 | |||
11074 | Buffer.prototype.includes = function includes (val, byteOffset, encoding) { | ||
11075 | return this.indexOf(val, byteOffset, encoding) !== -1 | ||
11076 | } | ||
11077 | |||
11078 | Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { | ||
11079 | return bidirectionalIndexOf(this, val, byteOffset, encoding, true) | ||
11080 | } | ||
11081 | |||
11082 | Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { | ||
11083 | return bidirectionalIndexOf(this, val, byteOffset, encoding, false) | ||
11084 | } | ||
11085 | |||
11086 | function hexWrite (buf, string, offset, length) { | ||
11087 | offset = Number(offset) || 0 | ||
11088 | var remaining = buf.length - offset | ||
11089 | if (!length) { | ||
11090 | length = remaining | ||
11091 | } else { | ||
11092 | length = Number(length) | ||
11093 | if (length > remaining) { | ||
11094 | length = remaining | ||
11095 | } | ||
11096 | } | ||
11097 | |||
11098 | var strLen = string.length | ||
11099 | |||
11100 | if (length > strLen / 2) { | ||
11101 | length = strLen / 2 | ||
11102 | } | ||
11103 | for (var i = 0; i < length; ++i) { | ||
11104 | var parsed = parseInt(string.substr(i * 2, 2), 16) | ||
11105 | if (numberIsNaN(parsed)) return i | ||
11106 | buf[offset + i] = parsed | ||
11107 | } | ||
11108 | return i | ||
11109 | } | ||
11110 | |||
11111 | function utf8Write (buf, string, offset, length) { | ||
11112 | return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) | ||
11113 | } | ||
11114 | |||
11115 | function asciiWrite (buf, string, offset, length) { | ||
11116 | return blitBuffer(asciiToBytes(string), buf, offset, length) | ||
11117 | } | ||
11118 | |||
11119 | function latin1Write (buf, string, offset, length) { | ||
11120 | return asciiWrite(buf, string, offset, length) | ||
11121 | } | ||
11122 | |||
11123 | function base64Write (buf, string, offset, length) { | ||
11124 | return blitBuffer(base64ToBytes(string), buf, offset, length) | ||
11125 | } | ||
11126 | |||
11127 | function ucs2Write (buf, string, offset, length) { | ||
11128 | return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) | ||
11129 | } | ||
11130 | |||
11131 | Buffer.prototype.write = function write (string, offset, length, encoding) { | ||
11132 | // Buffer#write(string) | ||
11133 | if (offset === undefined) { | ||
11134 | encoding = 'utf8' | ||
11135 | length = this.length | ||
11136 | offset = 0 | ||
11137 | // Buffer#write(string, encoding) | ||
11138 | } else if (length === undefined && typeof offset === 'string') { | ||
11139 | encoding = offset | ||
11140 | length = this.length | ||
11141 | offset = 0 | ||
11142 | // Buffer#write(string, offset[, length][, encoding]) | ||
11143 | } else if (isFinite(offset)) { | ||
11144 | offset = offset >>> 0 | ||
11145 | if (isFinite(length)) { | ||
11146 | length = length >>> 0 | ||
11147 | if (encoding === undefined) encoding = 'utf8' | ||
11148 | } else { | ||
11149 | encoding = length | ||
11150 | length = undefined | ||
11151 | } | ||
11152 | } else { | ||
11153 | throw new Error( | ||
11154 | 'Buffer.write(string, encoding, offset[, length]) is no longer supported' | ||
11155 | ) | ||
11156 | } | ||
11157 | |||
11158 | var remaining = this.length - offset | ||
11159 | if (length === undefined || length > remaining) length = remaining | ||
11160 | |||
11161 | if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { | ||
11162 | throw new RangeError('Attempt to write outside buffer bounds') | ||
11163 | } | ||
11164 | |||
11165 | if (!encoding) encoding = 'utf8' | ||
11166 | |||
11167 | var loweredCase = false | ||
11168 | for (;;) { | ||
11169 | switch (encoding) { | ||
11170 | case 'hex': | ||
11171 | return hexWrite(this, string, offset, length) | ||
11172 | |||
11173 | case 'utf8': | ||
11174 | case 'utf-8': | ||
11175 | return utf8Write(this, string, offset, length) | ||
11176 | |||
11177 | case 'ascii': | ||
11178 | return asciiWrite(this, string, offset, length) | ||
11179 | |||
11180 | case 'latin1': | ||
11181 | case 'binary': | ||
11182 | return latin1Write(this, string, offset, length) | ||
11183 | |||
11184 | case 'base64': | ||
11185 | // Warning: maxLength not taken into account in base64Write | ||
11186 | return base64Write(this, string, offset, length) | ||
11187 | |||
11188 | case 'ucs2': | ||
11189 | case 'ucs-2': | ||
11190 | case 'utf16le': | ||
11191 | case 'utf-16le': | ||
11192 | return ucs2Write(this, string, offset, length) | ||
11193 | |||
11194 | default: | ||
11195 | if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) | ||
11196 | encoding = ('' + encoding).toLowerCase() | ||
11197 | loweredCase = true | ||
11198 | } | ||
11199 | } | ||
11200 | } | ||
11201 | |||
11202 | Buffer.prototype.toJSON = function toJSON () { | ||
11203 | return { | ||
11204 | type: 'Buffer', | ||
11205 | data: Array.prototype.slice.call(this._arr || this, 0) | ||
11206 | } | ||
11207 | } | ||
11208 | |||
11209 | function base64Slice (buf, start, end) { | ||
11210 | if (start === 0 && end === buf.length) { | ||
11211 | return base64.fromByteArray(buf) | ||
11212 | } else { | ||
11213 | return base64.fromByteArray(buf.slice(start, end)) | ||
11214 | } | ||
11215 | } | ||
11216 | |||
11217 | function utf8Slice (buf, start, end) { | ||
11218 | end = Math.min(buf.length, end) | ||
11219 | var res = [] | ||
11220 | |||
11221 | var i = start | ||
11222 | while (i < end) { | ||
11223 | var firstByte = buf[i] | ||
11224 | var codePoint = null | ||
11225 | var bytesPerSequence = (firstByte > 0xEF) ? 4 | ||
11226 | : (firstByte > 0xDF) ? 3 | ||
11227 | : (firstByte > 0xBF) ? 2 | ||
11228 | : 1 | ||
11229 | |||
11230 | if (i + bytesPerSequence <= end) { | ||
11231 | var secondByte, thirdByte, fourthByte, tempCodePoint | ||
11232 | |||
11233 | switch (bytesPerSequence) { | ||
11234 | case 1: | ||
11235 | if (firstByte < 0x80) { | ||
11236 | codePoint = firstByte | ||
11237 | } | ||
11238 | break | ||
11239 | case 2: | ||
11240 | secondByte = buf[i + 1] | ||
11241 | if ((secondByte & 0xC0) === 0x80) { | ||
11242 | tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) | ||
11243 | if (tempCodePoint > 0x7F) { | ||
11244 | codePoint = tempCodePoint | ||
11245 | } | ||
11246 | } | ||
11247 | break | ||
11248 | case 3: | ||
11249 | secondByte = buf[i + 1] | ||
11250 | thirdByte = buf[i + 2] | ||
11251 | if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { | ||
11252 | tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) | ||
11253 | if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { | ||
11254 | codePoint = tempCodePoint | ||
11255 | } | ||
11256 | } | ||
11257 | break | ||
11258 | case 4: | ||
11259 | secondByte = buf[i + 1] | ||
11260 | thirdByte = buf[i + 2] | ||
11261 | fourthByte = buf[i + 3] | ||
11262 | if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { | ||
11263 | tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) | ||
11264 | if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { | ||
11265 | codePoint = tempCodePoint | ||
11266 | } | ||
11267 | } | ||
11268 | } | ||
11269 | } | ||
11270 | |||
11271 | if (codePoint === null) { | ||
11272 | // we did not generate a valid codePoint so insert a | ||
11273 | // replacement char (U+FFFD) and advance only 1 byte | ||
11274 | codePoint = 0xFFFD | ||
11275 | bytesPerSequence = 1 | ||
11276 | } else if (codePoint > 0xFFFF) { | ||
11277 | // encode to utf16 (surrogate pair dance) | ||
11278 | codePoint -= 0x10000 | ||
11279 | res.push(codePoint >>> 10 & 0x3FF | 0xD800) | ||
11280 | codePoint = 0xDC00 | codePoint & 0x3FF | ||
11281 | } | ||
11282 | |||
11283 | res.push(codePoint) | ||
11284 | i += bytesPerSequence | ||
11285 | } | ||
11286 | |||
11287 | return decodeCodePointsArray(res) | ||
11288 | } | ||
11289 | |||
11290 | // Based on http://stackoverflow.com/a/22747272/680742, the browser with | ||
11291 | // the lowest limit is Chrome, with 0x10000 args. | ||
11292 | // We go 1 magnitude less, for safety | ||
11293 | var MAX_ARGUMENTS_LENGTH = 0x1000 | ||
11294 | |||
11295 | function decodeCodePointsArray (codePoints) { | ||
11296 | var len = codePoints.length | ||
11297 | if (len <= MAX_ARGUMENTS_LENGTH) { | ||
11298 | return String.fromCharCode.apply(String, codePoints) // avoid extra slice() | ||
11299 | } | ||
11300 | |||
11301 | // Decode in chunks to avoid "call stack size exceeded". | ||
11302 | var res = '' | ||
11303 | var i = 0 | ||
11304 | while (i < len) { | ||
11305 | res += String.fromCharCode.apply( | ||
11306 | String, | ||
11307 | codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) | ||
11308 | ) | ||
11309 | } | ||
11310 | return res | ||
11311 | } | ||
11312 | |||
11313 | function asciiSlice (buf, start, end) { | ||
11314 | var ret = '' | ||
11315 | end = Math.min(buf.length, end) | ||
11316 | |||
11317 | for (var i = start; i < end; ++i) { | ||
11318 | ret += String.fromCharCode(buf[i] & 0x7F) | ||
11319 | } | ||
11320 | return ret | ||
11321 | } | ||
11322 | |||
11323 | function latin1Slice (buf, start, end) { | ||
11324 | var ret = '' | ||
11325 | end = Math.min(buf.length, end) | ||
11326 | |||
11327 | for (var i = start; i < end; ++i) { | ||
11328 | ret += String.fromCharCode(buf[i]) | ||
11329 | } | ||
11330 | return ret | ||
11331 | } | ||
11332 | |||
11333 | function hexSlice (buf, start, end) { | ||
11334 | var len = buf.length | ||
11335 | |||
11336 | if (!start || start < 0) start = 0 | ||
11337 | if (!end || end < 0 || end > len) end = len | ||
11338 | |||
11339 | var out = '' | ||
11340 | for (var i = start; i < end; ++i) { | ||
11341 | out += toHex(buf[i]) | ||
11342 | } | ||
11343 | return out | ||
11344 | } | ||
11345 | |||
11346 | function utf16leSlice (buf, start, end) { | ||
11347 | var bytes = buf.slice(start, end) | ||
11348 | var res = '' | ||
11349 | for (var i = 0; i < bytes.length; i += 2) { | ||
11350 | res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) | ||
11351 | } | ||
11352 | return res | ||
11353 | } | ||
11354 | |||
11355 | Buffer.prototype.slice = function slice (start, end) { | ||
11356 | var len = this.length | ||
11357 | start = ~~start | ||
11358 | end = end === undefined ? len : ~~end | ||
11359 | |||
11360 | if (start < 0) { | ||
11361 | start += len | ||
11362 | if (start < 0) start = 0 | ||
11363 | } else if (start > len) { | ||
11364 | start = len | ||
11365 | } | ||
11366 | |||
11367 | if (end < 0) { | ||
11368 | end += len | ||
11369 | if (end < 0) end = 0 | ||
11370 | } else if (end > len) { | ||
11371 | end = len | ||
11372 | } | ||
11373 | |||
11374 | if (end < start) end = start | ||
11375 | |||
11376 | var newBuf = this.subarray(start, end) | ||
11377 | // Return an augmented `Uint8Array` instance | ||
11378 | newBuf.__proto__ = Buffer.prototype | ||
11379 | return newBuf | ||
11380 | } | ||
11381 | |||
11382 | /* | ||
11383 | * Need to make sure that buffer isn't trying to write out of bounds. | ||
11384 | */ | ||
11385 | function checkOffset (offset, ext, length) { | ||
11386 | if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') | ||
11387 | if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') | ||
11388 | } | ||
11389 | |||
11390 | Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { | ||
11391 | offset = offset >>> 0 | ||
11392 | byteLength = byteLength >>> 0 | ||
11393 | if (!noAssert) checkOffset(offset, byteLength, this.length) | ||
11394 | |||
11395 | var val = this[offset] | ||
11396 | var mul = 1 | ||
11397 | var i = 0 | ||
11398 | while (++i < byteLength && (mul *= 0x100)) { | ||
11399 | val += this[offset + i] * mul | ||
11400 | } | ||
11401 | |||
11402 | return val | ||
11403 | } | ||
11404 | |||
11405 | Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { | ||
11406 | offset = offset >>> 0 | ||
11407 | byteLength = byteLength >>> 0 | ||
11408 | if (!noAssert) { | ||
11409 | checkOffset(offset, byteLength, this.length) | ||
11410 | } | ||
11411 | |||
11412 | var val = this[offset + --byteLength] | ||
11413 | var mul = 1 | ||
11414 | while (byteLength > 0 && (mul *= 0x100)) { | ||
11415 | val += this[offset + --byteLength] * mul | ||
11416 | } | ||
11417 | |||
11418 | return val | ||
11419 | } | ||
11420 | |||
11421 | Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { | ||
11422 | offset = offset >>> 0 | ||
11423 | if (!noAssert) checkOffset(offset, 1, this.length) | ||
11424 | return this[offset] | ||
11425 | } | ||
11426 | |||
11427 | Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { | ||
11428 | offset = offset >>> 0 | ||
11429 | if (!noAssert) checkOffset(offset, 2, this.length) | ||
11430 | return this[offset] | (this[offset + 1] << 8) | ||
11431 | } | ||
11432 | |||
11433 | Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { | ||
11434 | offset = offset >>> 0 | ||
11435 | if (!noAssert) checkOffset(offset, 2, this.length) | ||
11436 | return (this[offset] << 8) | this[offset + 1] | ||
11437 | } | ||
11438 | |||
11439 | Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { | ||
11440 | offset = offset >>> 0 | ||
11441 | if (!noAssert) checkOffset(offset, 4, this.length) | ||
11442 | |||
11443 | return ((this[offset]) | | ||
11444 | (this[offset + 1] << 8) | | ||
11445 | (this[offset + 2] << 16)) + | ||
11446 | (this[offset + 3] * 0x1000000) | ||
11447 | } | ||
11448 | |||
11449 | Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { | ||
11450 | offset = offset >>> 0 | ||
11451 | if (!noAssert) checkOffset(offset, 4, this.length) | ||
11452 | |||
11453 | return (this[offset] * 0x1000000) + | ||
11454 | ((this[offset + 1] << 16) | | ||
11455 | (this[offset + 2] << 8) | | ||
11456 | this[offset + 3]) | ||
11457 | } | ||
11458 | |||
11459 | Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { | ||
11460 | offset = offset >>> 0 | ||
11461 | byteLength = byteLength >>> 0 | ||
11462 | if (!noAssert) checkOffset(offset, byteLength, this.length) | ||
11463 | |||
11464 | var val = this[offset] | ||
11465 | var mul = 1 | ||
11466 | var i = 0 | ||
11467 | while (++i < byteLength && (mul *= 0x100)) { | ||
11468 | val += this[offset + i] * mul | ||
11469 | } | ||
11470 | mul *= 0x80 | ||
11471 | |||
11472 | if (val >= mul) val -= Math.pow(2, 8 * byteLength) | ||
11473 | |||
11474 | return val | ||
11475 | } | ||
11476 | |||
11477 | Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { | ||
11478 | offset = offset >>> 0 | ||
11479 | byteLength = byteLength >>> 0 | ||
11480 | if (!noAssert) checkOffset(offset, byteLength, this.length) | ||
11481 | |||
11482 | var i = byteLength | ||
11483 | var mul = 1 | ||
11484 | var val = this[offset + --i] | ||
11485 | while (i > 0 && (mul *= 0x100)) { | ||
11486 | val += this[offset + --i] * mul | ||
11487 | } | ||
11488 | mul *= 0x80 | ||
11489 | |||
11490 | if (val >= mul) val -= Math.pow(2, 8 * byteLength) | ||
11491 | |||
11492 | return val | ||
11493 | } | ||
11494 | |||
11495 | Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { | ||
11496 | offset = offset >>> 0 | ||
11497 | if (!noAssert) checkOffset(offset, 1, this.length) | ||
11498 | if (!(this[offset] & 0x80)) return (this[offset]) | ||
11499 | return ((0xff - this[offset] + 1) * -1) | ||
11500 | } | ||
11501 | |||
11502 | Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { | ||
11503 | offset = offset >>> 0 | ||
11504 | if (!noAssert) checkOffset(offset, 2, this.length) | ||
11505 | var val = this[offset] | (this[offset + 1] << 8) | ||
11506 | return (val & 0x8000) ? val | 0xFFFF0000 : val | ||
11507 | } | ||
11508 | |||
11509 | Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { | ||
11510 | offset = offset >>> 0 | ||
11511 | if (!noAssert) checkOffset(offset, 2, this.length) | ||
11512 | var val = this[offset + 1] | (this[offset] << 8) | ||
11513 | return (val & 0x8000) ? val | 0xFFFF0000 : val | ||
11514 | } | ||
11515 | |||
11516 | Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { | ||
11517 | offset = offset >>> 0 | ||
11518 | if (!noAssert) checkOffset(offset, 4, this.length) | ||
11519 | |||
11520 | return (this[offset]) | | ||
11521 | (this[offset + 1] << 8) | | ||
11522 | (this[offset + 2] << 16) | | ||
11523 | (this[offset + 3] << 24) | ||
11524 | } | ||
11525 | |||
11526 | Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { | ||
11527 | offset = offset >>> 0 | ||
11528 | if (!noAssert) checkOffset(offset, 4, this.length) | ||
11529 | |||
11530 | return (this[offset] << 24) | | ||
11531 | (this[offset + 1] << 16) | | ||
11532 | (this[offset + 2] << 8) | | ||
11533 | (this[offset + 3]) | ||
11534 | } | ||
11535 | |||
11536 | Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { | ||
11537 | offset = offset >>> 0 | ||
11538 | if (!noAssert) checkOffset(offset, 4, this.length) | ||
11539 | return ieee754.read(this, offset, true, 23, 4) | ||
11540 | } | ||
11541 | |||
11542 | Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { | ||
11543 | offset = offset >>> 0 | ||
11544 | if (!noAssert) checkOffset(offset, 4, this.length) | ||
11545 | return ieee754.read(this, offset, false, 23, 4) | ||
11546 | } | ||
11547 | |||
11548 | Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { | ||
11549 | offset = offset >>> 0 | ||
11550 | if (!noAssert) checkOffset(offset, 8, this.length) | ||
11551 | return ieee754.read(this, offset, true, 52, 8) | ||
11552 | } | ||
11553 | |||
11554 | Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { | ||
11555 | offset = offset >>> 0 | ||
11556 | if (!noAssert) checkOffset(offset, 8, this.length) | ||
11557 | return ieee754.read(this, offset, false, 52, 8) | ||
11558 | } | ||
11559 | |||
11560 | function checkInt (buf, value, offset, ext, max, min) { | ||
11561 | if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') | ||
11562 | if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') | ||
11563 | if (offset + ext > buf.length) throw new RangeError('Index out of range') | ||
11564 | } | ||
11565 | |||
11566 | Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { | ||
11567 | value = +value | ||
11568 | offset = offset >>> 0 | ||
11569 | byteLength = byteLength >>> 0 | ||
11570 | if (!noAssert) { | ||
11571 | var maxBytes = Math.pow(2, 8 * byteLength) - 1 | ||
11572 | checkInt(this, value, offset, byteLength, maxBytes, 0) | ||
11573 | } | ||
11574 | |||
11575 | var mul = 1 | ||
11576 | var i = 0 | ||
11577 | this[offset] = value & 0xFF | ||
11578 | while (++i < byteLength && (mul *= 0x100)) { | ||
11579 | this[offset + i] = (value / mul) & 0xFF | ||
11580 | } | ||
11581 | |||
11582 | return offset + byteLength | ||
11583 | } | ||
11584 | |||
11585 | Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { | ||
11586 | value = +value | ||
11587 | offset = offset >>> 0 | ||
11588 | byteLength = byteLength >>> 0 | ||
11589 | if (!noAssert) { | ||
11590 | var maxBytes = Math.pow(2, 8 * byteLength) - 1 | ||
11591 | checkInt(this, value, offset, byteLength, maxBytes, 0) | ||
11592 | } | ||
11593 | |||
11594 | var i = byteLength - 1 | ||
11595 | var mul = 1 | ||
11596 | this[offset + i] = value & 0xFF | ||
11597 | while (--i >= 0 && (mul *= 0x100)) { | ||
11598 | this[offset + i] = (value / mul) & 0xFF | ||
11599 | } | ||
11600 | |||
11601 | return offset + byteLength | ||
11602 | } | ||
11603 | |||
11604 | Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { | ||
11605 | value = +value | ||
11606 | offset = offset >>> 0 | ||
11607 | if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) | ||
11608 | this[offset] = (value & 0xff) | ||
11609 | return offset + 1 | ||
11610 | } | ||
11611 | |||
11612 | Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { | ||
11613 | value = +value | ||
11614 | offset = offset >>> 0 | ||
11615 | if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) | ||
11616 | this[offset] = (value & 0xff) | ||
11617 | this[offset + 1] = (value >>> 8) | ||
11618 | return offset + 2 | ||
11619 | } | ||
11620 | |||
11621 | Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { | ||
11622 | value = +value | ||
11623 | offset = offset >>> 0 | ||
11624 | if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) | ||
11625 | this[offset] = (value >>> 8) | ||
11626 | this[offset + 1] = (value & 0xff) | ||
11627 | return offset + 2 | ||
11628 | } | ||
11629 | |||
11630 | Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { | ||
11631 | value = +value | ||
11632 | offset = offset >>> 0 | ||
11633 | if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) | ||
11634 | this[offset + 3] = (value >>> 24) | ||
11635 | this[offset + 2] = (value >>> 16) | ||
11636 | this[offset + 1] = (value >>> 8) | ||
11637 | this[offset] = (value & 0xff) | ||
11638 | return offset + 4 | ||
11639 | } | ||
11640 | |||
11641 | Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { | ||
11642 | value = +value | ||
11643 | offset = offset >>> 0 | ||
11644 | if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) | ||
11645 | this[offset] = (value >>> 24) | ||
11646 | this[offset + 1] = (value >>> 16) | ||
11647 | this[offset + 2] = (value >>> 8) | ||
11648 | this[offset + 3] = (value & 0xff) | ||
11649 | return offset + 4 | ||
11650 | } | ||
11651 | |||
11652 | Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { | ||
11653 | value = +value | ||
11654 | offset = offset >>> 0 | ||
11655 | if (!noAssert) { | ||
11656 | var limit = Math.pow(2, (8 * byteLength) - 1) | ||
11657 | |||
11658 | checkInt(this, value, offset, byteLength, limit - 1, -limit) | ||
11659 | } | ||
11660 | |||
11661 | var i = 0 | ||
11662 | var mul = 1 | ||
11663 | var sub = 0 | ||
11664 | this[offset] = value & 0xFF | ||
11665 | while (++i < byteLength && (mul *= 0x100)) { | ||
11666 | if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { | ||
11667 | sub = 1 | ||
11668 | } | ||
11669 | this[offset + i] = ((value / mul) >> 0) - sub & 0xFF | ||
11670 | } | ||
11671 | |||
11672 | return offset + byteLength | ||
11673 | } | ||
11674 | |||
11675 | Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { | ||
11676 | value = +value | ||
11677 | offset = offset >>> 0 | ||
11678 | if (!noAssert) { | ||
11679 | var limit = Math.pow(2, (8 * byteLength) - 1) | ||
11680 | |||
11681 | checkInt(this, value, offset, byteLength, limit - 1, -limit) | ||
11682 | } | ||
11683 | |||
11684 | var i = byteLength - 1 | ||
11685 | var mul = 1 | ||
11686 | var sub = 0 | ||
11687 | this[offset + i] = value & 0xFF | ||
11688 | while (--i >= 0 && (mul *= 0x100)) { | ||
11689 | if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { | ||
11690 | sub = 1 | ||
11691 | } | ||
11692 | this[offset + i] = ((value / mul) >> 0) - sub & 0xFF | ||
11693 | } | ||
11694 | |||
11695 | return offset + byteLength | ||
11696 | } | ||
11697 | |||
11698 | Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { | ||
11699 | value = +value | ||
11700 | offset = offset >>> 0 | ||
11701 | if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) | ||
11702 | if (value < 0) value = 0xff + value + 1 | ||
11703 | this[offset] = (value & 0xff) | ||
11704 | return offset + 1 | ||
11705 | } | ||
11706 | |||
11707 | Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { | ||
11708 | value = +value | ||
11709 | offset = offset >>> 0 | ||
11710 | if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) | ||
11711 | this[offset] = (value & 0xff) | ||
11712 | this[offset + 1] = (value >>> 8) | ||
11713 | return offset + 2 | ||
11714 | } | ||
11715 | |||
11716 | Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { | ||
11717 | value = +value | ||
11718 | offset = offset >>> 0 | ||
11719 | if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) | ||
11720 | this[offset] = (value >>> 8) | ||
11721 | this[offset + 1] = (value & 0xff) | ||
11722 | return offset + 2 | ||
11723 | } | ||
11724 | |||
11725 | Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { | ||
11726 | value = +value | ||
11727 | offset = offset >>> 0 | ||
11728 | if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) | ||
11729 | this[offset] = (value & 0xff) | ||
11730 | this[offset + 1] = (value >>> 8) | ||
11731 | this[offset + 2] = (value >>> 16) | ||
11732 | this[offset + 3] = (value >>> 24) | ||
11733 | return offset + 4 | ||
11734 | } | ||
11735 | |||
11736 | Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { | ||
11737 | value = +value | ||
11738 | offset = offset >>> 0 | ||
11739 | if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) | ||
11740 | if (value < 0) value = 0xffffffff + value + 1 | ||
11741 | this[offset] = (value >>> 24) | ||
11742 | this[offset + 1] = (value >>> 16) | ||
11743 | this[offset + 2] = (value >>> 8) | ||
11744 | this[offset + 3] = (value & 0xff) | ||
11745 | return offset + 4 | ||
11746 | } | ||
11747 | |||
11748 | function checkIEEE754 (buf, value, offset, ext, max, min) { | ||
11749 | if (offset + ext > buf.length) throw new RangeError('Index out of range') | ||
11750 | if (offset < 0) throw new RangeError('Index out of range') | ||
11751 | } | ||
11752 | |||
11753 | function writeFloat (buf, value, offset, littleEndian, noAssert) { | ||
11754 | value = +value | ||
11755 | offset = offset >>> 0 | ||
11756 | if (!noAssert) { | ||
11757 | checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) | ||
11758 | } | ||
11759 | ieee754.write(buf, value, offset, littleEndian, 23, 4) | ||
11760 | return offset + 4 | ||
11761 | } | ||
11762 | |||
11763 | Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { | ||
11764 | return writeFloat(this, value, offset, true, noAssert) | ||
11765 | } | ||
11766 | |||
11767 | Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { | ||
11768 | return writeFloat(this, value, offset, false, noAssert) | ||
11769 | } | ||
11770 | |||
11771 | function writeDouble (buf, value, offset, littleEndian, noAssert) { | ||
11772 | value = +value | ||
11773 | offset = offset >>> 0 | ||
11774 | if (!noAssert) { | ||
11775 | checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) | ||
11776 | } | ||
11777 | ieee754.write(buf, value, offset, littleEndian, 52, 8) | ||
11778 | return offset + 8 | ||
11779 | } | ||
11780 | |||
11781 | Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { | ||
11782 | return writeDouble(this, value, offset, true, noAssert) | ||
11783 | } | ||
11784 | |||
11785 | Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { | ||
11786 | return writeDouble(this, value, offset, false, noAssert) | ||
11787 | } | ||
11788 | |||
11789 | // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) | ||
11790 | Buffer.prototype.copy = function copy (target, targetStart, start, end) { | ||
11791 | if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer') | ||
11792 | if (!start) start = 0 | ||
11793 | if (!end && end !== 0) end = this.length | ||
11794 | if (targetStart >= target.length) targetStart = target.length | ||
11795 | if (!targetStart) targetStart = 0 | ||
11796 | if (end > 0 && end < start) end = start | ||
11797 | |||
11798 | // Copy 0 bytes; we're done | ||
11799 | if (end === start) return 0 | ||
11800 | if (target.length === 0 || this.length === 0) return 0 | ||
11801 | |||
11802 | // Fatal error conditions | ||
11803 | if (targetStart < 0) { | ||
11804 | throw new RangeError('targetStart out of bounds') | ||
11805 | } | ||
11806 | if (start < 0 || start >= this.length) throw new RangeError('Index out of range') | ||
11807 | if (end < 0) throw new RangeError('sourceEnd out of bounds') | ||
11808 | |||
11809 | // Are we oob? | ||
11810 | if (end > this.length) end = this.length | ||
11811 | if (target.length - targetStart < end - start) { | ||
11812 | end = target.length - targetStart + start | ||
11813 | } | ||
11814 | |||
11815 | var len = end - start | ||
11816 | |||
11817 | if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') { | ||
11818 | // Use built-in when available, missing from IE11 | ||
11819 | this.copyWithin(targetStart, start, end) | ||
11820 | } else if (this === target && start < targetStart && targetStart < end) { | ||
11821 | // descending copy from end | ||
11822 | for (var i = len - 1; i >= 0; --i) { | ||
11823 | target[i + targetStart] = this[i + start] | ||
11824 | } | ||
11825 | } else { | ||
11826 | Uint8Array.prototype.set.call( | ||
11827 | target, | ||
11828 | this.subarray(start, end), | ||
11829 | targetStart | ||
11830 | ) | ||
11831 | } | ||
11832 | |||
11833 | return len | ||
11834 | } | ||
11835 | |||
11836 | // Usage: | ||
11837 | // buffer.fill(number[, offset[, end]]) | ||
11838 | // buffer.fill(buffer[, offset[, end]]) | ||
11839 | // buffer.fill(string[, offset[, end]][, encoding]) | ||
11840 | Buffer.prototype.fill = function fill (val, start, end, encoding) { | ||
11841 | // Handle string cases: | ||
11842 | if (typeof val === 'string') { | ||
11843 | if (typeof start === 'string') { | ||
11844 | encoding = start | ||
11845 | start = 0 | ||
11846 | end = this.length | ||
11847 | } else if (typeof end === 'string') { | ||
11848 | encoding = end | ||
11849 | end = this.length | ||
11850 | } | ||
11851 | if (encoding !== undefined && typeof encoding !== 'string') { | ||
11852 | throw new TypeError('encoding must be a string') | ||
11853 | } | ||
11854 | if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { | ||
11855 | throw new TypeError('Unknown encoding: ' + encoding) | ||
11856 | } | ||
11857 | if (val.length === 1) { | ||
11858 | var code = val.charCodeAt(0) | ||
11859 | if ((encoding === 'utf8' && code < 128) || | ||
11860 | encoding === 'latin1') { | ||
11861 | // Fast path: If `val` fits into a single byte, use that numeric value. | ||
11862 | val = code | ||
11863 | } | ||
11864 | } | ||
11865 | } else if (typeof val === 'number') { | ||
11866 | val = val & 255 | ||
11867 | } | ||
11868 | |||
11869 | // Invalid ranges are not set to a default, so can range check early. | ||
11870 | if (start < 0 || this.length < start || this.length < end) { | ||
11871 | throw new RangeError('Out of range index') | ||
11872 | } | ||
11873 | |||
11874 | if (end <= start) { | ||
11875 | return this | ||
11876 | } | ||
11877 | |||
11878 | start = start >>> 0 | ||
11879 | end = end === undefined ? this.length : end >>> 0 | ||
11880 | |||
11881 | if (!val) val = 0 | ||
11882 | |||
11883 | var i | ||
11884 | if (typeof val === 'number') { | ||
11885 | for (i = start; i < end; ++i) { | ||
11886 | this[i] = val | ||
11887 | } | ||
11888 | } else { | ||
11889 | var bytes = Buffer.isBuffer(val) | ||
11890 | ? val | ||
11891 | : Buffer.from(val, encoding) | ||
11892 | var len = bytes.length | ||
11893 | if (len === 0) { | ||
11894 | throw new TypeError('The value "' + val + | ||
11895 | '" is invalid for argument "value"') | ||
11896 | } | ||
11897 | for (i = 0; i < end - start; ++i) { | ||
11898 | this[i + start] = bytes[i % len] | ||
11899 | } | ||
11900 | } | ||
11901 | |||
11902 | return this | ||
11903 | } | ||
11904 | |||
11905 | // HELPER FUNCTIONS | ||
11906 | // ================ | ||
11907 | |||
11908 | var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g | ||
11909 | |||
11910 | function base64clean (str) { | ||
11911 | // Node takes equal signs as end of the Base64 encoding | ||
11912 | str = str.split('=')[0] | ||
11913 | // Node strips out invalid characters like \n and \t from the string, base64-js does not | ||
11914 | str = str.trim().replace(INVALID_BASE64_RE, '') | ||
11915 | // Node converts strings with length < 2 to '' | ||
11916 | if (str.length < 2) return '' | ||
11917 | // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not | ||
11918 | while (str.length % 4 !== 0) { | ||
11919 | str = str + '=' | ||
11920 | } | ||
11921 | return str | ||
11922 | } | ||
11923 | |||
11924 | function toHex (n) { | ||
11925 | if (n < 16) return '0' + n.toString(16) | ||
11926 | return n.toString(16) | ||
11927 | } | ||
11928 | |||
11929 | function utf8ToBytes (string, units) { | ||
11930 | units = units || Infinity | ||
11931 | var codePoint | ||
11932 | var length = string.length | ||
11933 | var leadSurrogate = null | ||
11934 | var bytes = [] | ||
11935 | |||
11936 | for (var i = 0; i < length; ++i) { | ||
11937 | codePoint = string.charCodeAt(i) | ||
11938 | |||
11939 | // is surrogate component | ||
11940 | if (codePoint > 0xD7FF && codePoint < 0xE000) { | ||
11941 | // last char was a lead | ||
11942 | if (!leadSurrogate) { | ||
11943 | // no lead yet | ||
11944 | if (codePoint > 0xDBFF) { | ||
11945 | // unexpected trail | ||
11946 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | ||
11947 | continue | ||
11948 | } else if (i + 1 === length) { | ||
11949 | // unpaired lead | ||
11950 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | ||
11951 | continue | ||
11952 | } | ||
11953 | |||
11954 | // valid lead | ||
11955 | leadSurrogate = codePoint | ||
11956 | |||
11957 | continue | ||
11958 | } | ||
11959 | |||
11960 | // 2 leads in a row | ||
11961 | if (codePoint < 0xDC00) { | ||
11962 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | ||
11963 | leadSurrogate = codePoint | ||
11964 | continue | ||
11965 | } | ||
11966 | |||
11967 | // valid surrogate pair | ||
11968 | codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 | ||
11969 | } else if (leadSurrogate) { | ||
11970 | // valid bmp char, but last char was a lead | ||
11971 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | ||
11972 | } | ||
11973 | |||
11974 | leadSurrogate = null | ||
11975 | |||
11976 | // encode utf8 | ||
11977 | if (codePoint < 0x80) { | ||
11978 | if ((units -= 1) < 0) break | ||
11979 | bytes.push(codePoint) | ||
11980 | } else if (codePoint < 0x800) { | ||
11981 | if ((units -= 2) < 0) break | ||
11982 | bytes.push( | ||
11983 | codePoint >> 0x6 | 0xC0, | ||
11984 | codePoint & 0x3F | 0x80 | ||
11985 | ) | ||
11986 | } else if (codePoint < 0x10000) { | ||
11987 | if ((units -= 3) < 0) break | ||
11988 | bytes.push( | ||
11989 | codePoint >> 0xC | 0xE0, | ||
11990 | codePoint >> 0x6 & 0x3F | 0x80, | ||
11991 | codePoint & 0x3F | 0x80 | ||
11992 | ) | ||
11993 | } else if (codePoint < 0x110000) { | ||
11994 | if ((units -= 4) < 0) break | ||
11995 | bytes.push( | ||
11996 | codePoint >> 0x12 | 0xF0, | ||
11997 | codePoint >> 0xC & 0x3F | 0x80, | ||
11998 | codePoint >> 0x6 & 0x3F | 0x80, | ||
11999 | codePoint & 0x3F | 0x80 | ||
12000 | ) | ||
12001 | } else { | ||
12002 | throw new Error('Invalid code point') | ||
12003 | } | ||
12004 | } | ||
12005 | |||
12006 | return bytes | ||
12007 | } | ||
12008 | |||
12009 | function asciiToBytes (str) { | ||
12010 | var byteArray = [] | ||
12011 | for (var i = 0; i < str.length; ++i) { | ||
12012 | // Node's code seems to be doing this and not & 0x7F.. | ||
12013 | byteArray.push(str.charCodeAt(i) & 0xFF) | ||
12014 | } | ||
12015 | return byteArray | ||
12016 | } | ||
12017 | |||
12018 | function utf16leToBytes (str, units) { | ||
12019 | var c, hi, lo | ||
12020 | var byteArray = [] | ||
12021 | for (var i = 0; i < str.length; ++i) { | ||
12022 | if ((units -= 2) < 0) break | ||
12023 | |||
12024 | c = str.charCodeAt(i) | ||
12025 | hi = c >> 8 | ||
12026 | lo = c % 256 | ||
12027 | byteArray.push(lo) | ||
12028 | byteArray.push(hi) | ||
12029 | } | ||
12030 | |||
12031 | return byteArray | ||
12032 | } | ||
12033 | |||
12034 | function base64ToBytes (str) { | ||
12035 | return base64.toByteArray(base64clean(str)) | ||
12036 | } | ||
12037 | |||
12038 | function blitBuffer (src, dst, offset, length) { | ||
12039 | for (var i = 0; i < length; ++i) { | ||
12040 | if ((i + offset >= dst.length) || (i >= src.length)) break | ||
12041 | dst[i + offset] = src[i] | ||
12042 | } | ||
12043 | return i | ||
12044 | } | ||
12045 | |||
12046 | // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass | ||
12047 | // the `instanceof` check but they should be treated as of that type. | ||
12048 | // See: https://github.com/feross/buffer/issues/166 | ||
12049 | function isInstance (obj, type) { | ||
12050 | return obj instanceof type || | ||
12051 | (obj != null && obj.constructor != null && obj.constructor.name != null && | ||
12052 | obj.constructor.name === type.name) | ||
12053 | } | ||
12054 | function numberIsNaN (obj) { | ||
12055 | // For IE11 support | ||
12056 | return obj !== obj // eslint-disable-line no-self-compare | ||
12057 | } | ||
12058 | |||
12059 | },{"base64-js":16,"ieee754":115}],50:[function(require,module,exports){ | ||
12060 | var Buffer = require('safe-buffer').Buffer | ||
12061 | var Transform = require('stream').Transform | ||
12062 | var StringDecoder = require('string_decoder').StringDecoder | ||
12063 | var inherits = require('inherits') | ||
12064 | |||
12065 | function CipherBase (hashMode) { | ||
12066 | Transform.call(this) | ||
12067 | this.hashMode = typeof hashMode === 'string' | ||
12068 | if (this.hashMode) { | ||
12069 | this[hashMode] = this._finalOrDigest | ||
12070 | } else { | ||
12071 | this.final = this._finalOrDigest | ||
12072 | } | ||
12073 | if (this._final) { | ||
12074 | this.__final = this._final | ||
12075 | this._final = null | ||
12076 | } | ||
12077 | this._decoder = null | ||
12078 | this._encoding = null | ||
12079 | } | ||
12080 | inherits(CipherBase, Transform) | ||
12081 | |||
12082 | CipherBase.prototype.update = function (data, inputEnc, outputEnc) { | ||
12083 | if (typeof data === 'string') { | ||
12084 | data = Buffer.from(data, inputEnc) | ||
12085 | } | ||
12086 | |||
12087 | var outData = this._update(data) | ||
12088 | if (this.hashMode) return this | ||
12089 | |||
12090 | if (outputEnc) { | ||
12091 | outData = this._toString(outData, outputEnc) | ||
12092 | } | ||
12093 | |||
12094 | return outData | ||
12095 | } | ||
12096 | |||
12097 | CipherBase.prototype.setAutoPadding = function () {} | ||
12098 | CipherBase.prototype.getAuthTag = function () { | ||
12099 | throw new Error('trying to get auth tag in unsupported state') | ||
12100 | } | ||
12101 | |||
12102 | CipherBase.prototype.setAuthTag = function () { | ||
12103 | throw new Error('trying to set auth tag in unsupported state') | ||
12104 | } | ||
12105 | |||
12106 | CipherBase.prototype.setAAD = function () { | ||
12107 | throw new Error('trying to set aad in unsupported state') | ||
12108 | } | ||
12109 | |||
12110 | CipherBase.prototype._transform = function (data, _, next) { | ||
12111 | var err | ||
12112 | try { | ||
12113 | if (this.hashMode) { | ||
12114 | this._update(data) | ||
12115 | } else { | ||
12116 | this.push(this._update(data)) | ||
12117 | } | ||
12118 | } catch (e) { | ||
12119 | err = e | ||
12120 | } finally { | ||
12121 | next(err) | ||
12122 | } | ||
12123 | } | ||
12124 | CipherBase.prototype._flush = function (done) { | ||
12125 | var err | ||
12126 | try { | ||
12127 | this.push(this.__final()) | ||
12128 | } catch (e) { | ||
12129 | err = e | ||
12130 | } | ||
12131 | |||
12132 | done(err) | ||
12133 | } | ||
12134 | CipherBase.prototype._finalOrDigest = function (outputEnc) { | ||
12135 | var outData = this.__final() || Buffer.alloc(0) | ||
12136 | if (outputEnc) { | ||
12137 | outData = this._toString(outData, outputEnc, true) | ||
12138 | } | ||
12139 | return outData | ||
12140 | } | ||
12141 | |||
12142 | CipherBase.prototype._toString = function (value, enc, fin) { | ||
12143 | if (!this._decoder) { | ||
12144 | this._decoder = new StringDecoder(enc) | ||
12145 | this._encoding = enc | ||
12146 | } | ||
12147 | |||
12148 | if (this._encoding !== enc) throw new Error('can\'t switch encodings') | ||
12149 | |||
12150 | var out = this._decoder.write(value) | ||
12151 | if (fin) { | ||
12152 | out += this._decoder.end() | ||
12153 | } | ||
12154 | |||
12155 | return out | ||
12156 | } | ||
12157 | |||
12158 | module.exports = CipherBase | ||
12159 | |||
12160 | },{"inherits":116,"safe-buffer":393,"stream":432,"string_decoder":433}],51:[function(require,module,exports){ | ||
12161 | (function (Buffer){ | ||
12162 | // Copyright Joyent, Inc. and other Node contributors. | ||
12163 | // | ||
12164 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
12165 | // copy of this software and associated documentation files (the | ||
12166 | // "Software"), to deal in the Software without restriction, including | ||
12167 | // without limitation the rights to use, copy, modify, merge, publish, | ||
12168 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
12169 | // persons to whom the Software is furnished to do so, subject to the | ||
12170 | // following conditions: | ||
12171 | // | ||
12172 | // The above copyright notice and this permission notice shall be included | ||
12173 | // in all copies or substantial portions of the Software. | ||
12174 | // | ||
12175 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
12176 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
12177 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
12178 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
12179 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
12180 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
12181 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
12182 | |||
12183 | // NOTE: These type checking functions intentionally don't use `instanceof` | ||
12184 | // because it is fragile and can be easily faked with `Object.create()`. | ||
12185 | |||
12186 | function isArray(arg) { | ||
12187 | if (Array.isArray) { | ||
12188 | return Array.isArray(arg); | ||
12189 | } | ||
12190 | return objectToString(arg) === '[object Array]'; | ||
12191 | } | ||
12192 | exports.isArray = isArray; | ||
12193 | |||
12194 | function isBoolean(arg) { | ||
12195 | return typeof arg === 'boolean'; | ||
12196 | } | ||
12197 | exports.isBoolean = isBoolean; | ||
12198 | |||
12199 | function isNull(arg) { | ||
12200 | return arg === null; | ||
12201 | } | ||
12202 | exports.isNull = isNull; | ||
12203 | |||
12204 | function isNullOrUndefined(arg) { | ||
12205 | return arg == null; | ||
12206 | } | ||
12207 | exports.isNullOrUndefined = isNullOrUndefined; | ||
12208 | |||
12209 | function isNumber(arg) { | ||
12210 | return typeof arg === 'number'; | ||
12211 | } | ||
12212 | exports.isNumber = isNumber; | ||
12213 | |||
12214 | function isString(arg) { | ||
12215 | return typeof arg === 'string'; | ||
12216 | } | ||
12217 | exports.isString = isString; | ||
12218 | |||
12219 | function isSymbol(arg) { | ||
12220 | return typeof arg === 'symbol'; | ||
12221 | } | ||
12222 | exports.isSymbol = isSymbol; | ||
12223 | |||
12224 | function isUndefined(arg) { | ||
12225 | return arg === void 0; | ||
12226 | } | ||
12227 | exports.isUndefined = isUndefined; | ||
12228 | |||
12229 | function isRegExp(re) { | ||
12230 | return objectToString(re) === '[object RegExp]'; | ||
12231 | } | ||
12232 | exports.isRegExp = isRegExp; | ||
12233 | |||
12234 | function isObject(arg) { | ||
12235 | return typeof arg === 'object' && arg !== null; | ||
12236 | } | ||
12237 | exports.isObject = isObject; | ||
12238 | |||
12239 | function isDate(d) { | ||
12240 | return objectToString(d) === '[object Date]'; | ||
12241 | } | ||
12242 | exports.isDate = isDate; | ||
12243 | |||
12244 | function isError(e) { | ||
12245 | return (objectToString(e) === '[object Error]' || e instanceof Error); | ||
12246 | } | ||
12247 | exports.isError = isError; | ||
12248 | |||
12249 | function isFunction(arg) { | ||
12250 | return typeof arg === 'function'; | ||
12251 | } | ||
12252 | exports.isFunction = isFunction; | ||
12253 | |||
12254 | function isPrimitive(arg) { | ||
12255 | return arg === null || | ||
12256 | typeof arg === 'boolean' || | ||
12257 | typeof arg === 'number' || | ||
12258 | typeof arg === 'string' || | ||
12259 | typeof arg === 'symbol' || // ES6 symbol | ||
12260 | typeof arg === 'undefined'; | ||
12261 | } | ||
12262 | exports.isPrimitive = isPrimitive; | ||
12263 | |||
12264 | exports.isBuffer = Buffer.isBuffer; | ||
12265 | |||
12266 | function objectToString(o) { | ||
12267 | return Object.prototype.toString.call(o); | ||
12268 | } | ||
12269 | |||
12270 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | ||
12271 | },{"../../is-buffer/index.js":117}],52:[function(require,module,exports){ | ||
12272 | 'use strict'; | ||
12273 | |||
12274 | var _buffer = require('buffer'); | ||
12275 | |||
12276 | var _create_buffer = require('./create_buffer'); | ||
12277 | |||
12278 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12279 | |||
12280 | var _define_crc = require('./define_crc'); | ||
12281 | |||
12282 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12283 | |||
12284 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12285 | |||
12286 | module.exports = (0, _define_crc2.default)('crc1', function (buf, previous) { | ||
12287 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12288 | |||
12289 | var crc = ~~previous; | ||
12290 | var accum = 0; | ||
12291 | |||
12292 | for (var index = 0; index < buf.length; index++) { | ||
12293 | var byte = buf[index]; | ||
12294 | accum += byte; | ||
12295 | } | ||
12296 | |||
12297 | crc += accum % 256; | ||
12298 | return crc % 256; | ||
12299 | }); | ||
12300 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],53:[function(require,module,exports){ | ||
12301 | 'use strict'; | ||
12302 | |||
12303 | var _buffer = require('buffer'); | ||
12304 | |||
12305 | var _create_buffer = require('./create_buffer'); | ||
12306 | |||
12307 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12308 | |||
12309 | var _define_crc = require('./define_crc'); | ||
12310 | |||
12311 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12312 | |||
12313 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12314 | |||
12315 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-16 --generate=c` | ||
12316 | var TABLE = [0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040]; | ||
12317 | |||
12318 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12319 | |||
12320 | module.exports = (0, _define_crc2.default)('crc-16', function (buf, previous) { | ||
12321 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12322 | |||
12323 | var crc = ~~previous; | ||
12324 | |||
12325 | for (var index = 0; index < buf.length; index++) { | ||
12326 | var byte = buf[index]; | ||
12327 | crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff; | ||
12328 | } | ||
12329 | |||
12330 | return crc; | ||
12331 | }); | ||
12332 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],54:[function(require,module,exports){ | ||
12333 | 'use strict'; | ||
12334 | |||
12335 | var _buffer = require('buffer'); | ||
12336 | |||
12337 | var _create_buffer = require('./create_buffer'); | ||
12338 | |||
12339 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12340 | |||
12341 | var _define_crc = require('./define_crc'); | ||
12342 | |||
12343 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12344 | |||
12345 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12346 | |||
12347 | // Generated by `./pycrc.py --algorithm=table-driven --model=ccitt --generate=c` | ||
12348 | var TABLE = [0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0]; | ||
12349 | |||
12350 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12351 | |||
12352 | module.exports = (0, _define_crc2.default)('ccitt', function (buf, previous) { | ||
12353 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12354 | |||
12355 | var crc = typeof previous !== 'undefined' ? ~~previous : 0xffff; | ||
12356 | |||
12357 | for (var index = 0; index < buf.length; index++) { | ||
12358 | var byte = buf[index]; | ||
12359 | crc = (TABLE[(crc >> 8 ^ byte) & 0xff] ^ crc << 8) & 0xffff; | ||
12360 | } | ||
12361 | |||
12362 | return crc; | ||
12363 | }); | ||
12364 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],55:[function(require,module,exports){ | ||
12365 | 'use strict'; | ||
12366 | |||
12367 | var _buffer = require('buffer'); | ||
12368 | |||
12369 | var _create_buffer = require('./create_buffer'); | ||
12370 | |||
12371 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12372 | |||
12373 | var _define_crc = require('./define_crc'); | ||
12374 | |||
12375 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12376 | |||
12377 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12378 | |||
12379 | // Generated by `./pycrc.py --algorithm=table-driven --model=kermit --generate=c` | ||
12380 | var TABLE = [0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78]; | ||
12381 | |||
12382 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12383 | |||
12384 | module.exports = (0, _define_crc2.default)('kermit', function (buf, previous) { | ||
12385 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12386 | |||
12387 | var crc = typeof previous !== 'undefined' ? ~~previous : 0x0000; | ||
12388 | |||
12389 | for (var index = 0; index < buf.length; index++) { | ||
12390 | var byte = buf[index]; | ||
12391 | crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff; | ||
12392 | } | ||
12393 | |||
12394 | return crc; | ||
12395 | }); | ||
12396 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],56:[function(require,module,exports){ | ||
12397 | 'use strict'; | ||
12398 | |||
12399 | var _buffer = require('buffer'); | ||
12400 | |||
12401 | var _create_buffer = require('./create_buffer'); | ||
12402 | |||
12403 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12404 | |||
12405 | var _define_crc = require('./define_crc'); | ||
12406 | |||
12407 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12408 | |||
12409 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12410 | |||
12411 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-16-modbus --generate=c` | ||
12412 | var TABLE = [0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040]; | ||
12413 | |||
12414 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12415 | |||
12416 | module.exports = (0, _define_crc2.default)('crc-16-modbus', function (buf, previous) { | ||
12417 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12418 | |||
12419 | var crc = typeof previous !== 'undefined' ? ~~previous : 0xffff; | ||
12420 | |||
12421 | for (var index = 0; index < buf.length; index++) { | ||
12422 | var byte = buf[index]; | ||
12423 | crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff; | ||
12424 | } | ||
12425 | |||
12426 | return crc; | ||
12427 | }); | ||
12428 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],57:[function(require,module,exports){ | ||
12429 | 'use strict'; | ||
12430 | |||
12431 | var _buffer = require('buffer'); | ||
12432 | |||
12433 | var _create_buffer = require('./create_buffer'); | ||
12434 | |||
12435 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12436 | |||
12437 | var _define_crc = require('./define_crc'); | ||
12438 | |||
12439 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12440 | |||
12441 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12442 | |||
12443 | module.exports = (0, _define_crc2.default)('xmodem', function (buf, previous) { | ||
12444 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12445 | |||
12446 | var crc = typeof previous !== 'undefined' ? ~~previous : 0x0; | ||
12447 | |||
12448 | for (var index = 0; index < buf.length; index++) { | ||
12449 | var byte = buf[index]; | ||
12450 | var code = crc >>> 8 & 0xFF; | ||
12451 | |||
12452 | code ^= byte & 0xFF; | ||
12453 | code ^= code >>> 4; | ||
12454 | crc = crc << 8 & 0xFFFF; | ||
12455 | crc ^= code; | ||
12456 | code = code << 5 & 0xFFFF; | ||
12457 | crc ^= code; | ||
12458 | code = code << 7 & 0xFFFF; | ||
12459 | crc ^= code; | ||
12460 | } | ||
12461 | |||
12462 | return crc; | ||
12463 | }); | ||
12464 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],58:[function(require,module,exports){ | ||
12465 | 'use strict'; | ||
12466 | |||
12467 | var _buffer = require('buffer'); | ||
12468 | |||
12469 | var _create_buffer = require('./create_buffer'); | ||
12470 | |||
12471 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12472 | |||
12473 | var _define_crc = require('./define_crc'); | ||
12474 | |||
12475 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12476 | |||
12477 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12478 | |||
12479 | // Generated by `./pycrc.py --algorithm=table-drive --model=crc-24 --generate=c` | ||
12480 | var TABLE = [0x000000, 0x864cfb, 0x8ad50d, 0x0c99f6, 0x93e6e1, 0x15aa1a, 0x1933ec, 0x9f7f17, 0xa18139, 0x27cdc2, 0x2b5434, 0xad18cf, 0x3267d8, 0xb42b23, 0xb8b2d5, 0x3efe2e, 0xc54e89, 0x430272, 0x4f9b84, 0xc9d77f, 0x56a868, 0xd0e493, 0xdc7d65, 0x5a319e, 0x64cfb0, 0xe2834b, 0xee1abd, 0x685646, 0xf72951, 0x7165aa, 0x7dfc5c, 0xfbb0a7, 0x0cd1e9, 0x8a9d12, 0x8604e4, 0x00481f, 0x9f3708, 0x197bf3, 0x15e205, 0x93aefe, 0xad50d0, 0x2b1c2b, 0x2785dd, 0xa1c926, 0x3eb631, 0xb8faca, 0xb4633c, 0x322fc7, 0xc99f60, 0x4fd39b, 0x434a6d, 0xc50696, 0x5a7981, 0xdc357a, 0xd0ac8c, 0x56e077, 0x681e59, 0xee52a2, 0xe2cb54, 0x6487af, 0xfbf8b8, 0x7db443, 0x712db5, 0xf7614e, 0x19a3d2, 0x9fef29, 0x9376df, 0x153a24, 0x8a4533, 0x0c09c8, 0x00903e, 0x86dcc5, 0xb822eb, 0x3e6e10, 0x32f7e6, 0xb4bb1d, 0x2bc40a, 0xad88f1, 0xa11107, 0x275dfc, 0xdced5b, 0x5aa1a0, 0x563856, 0xd074ad, 0x4f0bba, 0xc94741, 0xc5deb7, 0x43924c, 0x7d6c62, 0xfb2099, 0xf7b96f, 0x71f594, 0xee8a83, 0x68c678, 0x645f8e, 0xe21375, 0x15723b, 0x933ec0, 0x9fa736, 0x19ebcd, 0x8694da, 0x00d821, 0x0c41d7, 0x8a0d2c, 0xb4f302, 0x32bff9, 0x3e260f, 0xb86af4, 0x2715e3, 0xa15918, 0xadc0ee, 0x2b8c15, 0xd03cb2, 0x567049, 0x5ae9bf, 0xdca544, 0x43da53, 0xc596a8, 0xc90f5e, 0x4f43a5, 0x71bd8b, 0xf7f170, 0xfb6886, 0x7d247d, 0xe25b6a, 0x641791, 0x688e67, 0xeec29c, 0x3347a4, 0xb50b5f, 0xb992a9, 0x3fde52, 0xa0a145, 0x26edbe, 0x2a7448, 0xac38b3, 0x92c69d, 0x148a66, 0x181390, 0x9e5f6b, 0x01207c, 0x876c87, 0x8bf571, 0x0db98a, 0xf6092d, 0x7045d6, 0x7cdc20, 0xfa90db, 0x65efcc, 0xe3a337, 0xef3ac1, 0x69763a, 0x578814, 0xd1c4ef, 0xdd5d19, 0x5b11e2, 0xc46ef5, 0x42220e, 0x4ebbf8, 0xc8f703, 0x3f964d, 0xb9dab6, 0xb54340, 0x330fbb, 0xac70ac, 0x2a3c57, 0x26a5a1, 0xa0e95a, 0x9e1774, 0x185b8f, 0x14c279, 0x928e82, 0x0df195, 0x8bbd6e, 0x872498, 0x016863, 0xfad8c4, 0x7c943f, 0x700dc9, 0xf64132, 0x693e25, 0xef72de, 0xe3eb28, 0x65a7d3, 0x5b59fd, 0xdd1506, 0xd18cf0, 0x57c00b, 0xc8bf1c, 0x4ef3e7, 0x426a11, 0xc426ea, 0x2ae476, 0xaca88d, 0xa0317b, 0x267d80, 0xb90297, 0x3f4e6c, 0x33d79a, 0xb59b61, 0x8b654f, 0x0d29b4, 0x01b042, 0x87fcb9, 0x1883ae, 0x9ecf55, 0x9256a3, 0x141a58, 0xefaaff, 0x69e604, 0x657ff2, 0xe33309, 0x7c4c1e, 0xfa00e5, 0xf69913, 0x70d5e8, 0x4e2bc6, 0xc8673d, 0xc4fecb, 0x42b230, 0xddcd27, 0x5b81dc, 0x57182a, 0xd154d1, 0x26359f, 0xa07964, 0xace092, 0x2aac69, 0xb5d37e, 0x339f85, 0x3f0673, 0xb94a88, 0x87b4a6, 0x01f85d, 0x0d61ab, 0x8b2d50, 0x145247, 0x921ebc, 0x9e874a, 0x18cbb1, 0xe37b16, 0x6537ed, 0x69ae1b, 0xefe2e0, 0x709df7, 0xf6d10c, 0xfa48fa, 0x7c0401, 0x42fa2f, 0xc4b6d4, 0xc82f22, 0x4e63d9, 0xd11cce, 0x575035, 0x5bc9c3, 0xdd8538]; | ||
12481 | |||
12482 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12483 | |||
12484 | module.exports = (0, _define_crc2.default)('crc-24', function (buf, previous) { | ||
12485 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12486 | |||
12487 | var crc = typeof previous !== 'undefined' ? ~~previous : 0xb704ce; | ||
12488 | |||
12489 | for (var index = 0; index < buf.length; index++) { | ||
12490 | var byte = buf[index]; | ||
12491 | crc = (TABLE[(crc >> 16 ^ byte) & 0xff] ^ crc << 8) & 0xffffff; | ||
12492 | } | ||
12493 | |||
12494 | return crc; | ||
12495 | }); | ||
12496 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],59:[function(require,module,exports){ | ||
12497 | 'use strict'; | ||
12498 | |||
12499 | var _buffer = require('buffer'); | ||
12500 | |||
12501 | var _create_buffer = require('./create_buffer'); | ||
12502 | |||
12503 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12504 | |||
12505 | var _define_crc = require('./define_crc'); | ||
12506 | |||
12507 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12508 | |||
12509 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12510 | |||
12511 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-32 --generate=c` | ||
12512 | var TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d]; | ||
12513 | |||
12514 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12515 | |||
12516 | module.exports = (0, _define_crc2.default)('crc-32', function (buf, previous) { | ||
12517 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12518 | |||
12519 | var crc = previous === 0 ? 0 : ~~previous ^ -1; | ||
12520 | |||
12521 | for (var index = 0; index < buf.length; index++) { | ||
12522 | var byte = buf[index]; | ||
12523 | crc = TABLE[(crc ^ byte) & 0xff] ^ crc >>> 8; | ||
12524 | } | ||
12525 | |||
12526 | return crc ^ -1; | ||
12527 | }); | ||
12528 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],60:[function(require,module,exports){ | ||
12529 | 'use strict'; | ||
12530 | |||
12531 | var _buffer = require('buffer'); | ||
12532 | |||
12533 | var _create_buffer = require('./create_buffer'); | ||
12534 | |||
12535 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12536 | |||
12537 | var _define_crc = require('./define_crc'); | ||
12538 | |||
12539 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12540 | |||
12541 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12542 | |||
12543 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-8 --generate=c` | ||
12544 | var TABLE = [0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d, 0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65, 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d, 0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5, 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd, 0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd, 0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2, 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea, 0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2, 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a, 0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a, 0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42, 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a, 0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c, 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4, 0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4, 0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c, 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44, 0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c, 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34, 0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63, 0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b, 0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13, 0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb, 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83, 0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3]; | ||
12545 | |||
12546 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12547 | |||
12548 | module.exports = (0, _define_crc2.default)('crc-8', function (buf, previous) { | ||
12549 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12550 | |||
12551 | var crc = ~~previous; | ||
12552 | |||
12553 | for (var index = 0; index < buf.length; index++) { | ||
12554 | var byte = buf[index]; | ||
12555 | crc = TABLE[(crc ^ byte) & 0xff] & 0xff; | ||
12556 | } | ||
12557 | |||
12558 | return crc; | ||
12559 | }); | ||
12560 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],61:[function(require,module,exports){ | ||
12561 | 'use strict'; | ||
12562 | |||
12563 | var _buffer = require('buffer'); | ||
12564 | |||
12565 | var _create_buffer = require('./create_buffer'); | ||
12566 | |||
12567 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12568 | |||
12569 | var _define_crc = require('./define_crc'); | ||
12570 | |||
12571 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12572 | |||
12573 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12574 | |||
12575 | // Generated by `./pycrc.py --algorithm=table-driven --model=dallas-1-wire --generate=c` | ||
12576 | var TABLE = [0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41, 0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc, 0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62, 0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff, 0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07, 0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a, 0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24, 0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9, 0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd, 0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50, 0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee, 0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73, 0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b, 0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16, 0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8, 0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35]; | ||
12577 | |||
12578 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12579 | |||
12580 | module.exports = (0, _define_crc2.default)('dallas-1-wire', function (buf, previous) { | ||
12581 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12582 | |||
12583 | var crc = ~~previous; | ||
12584 | |||
12585 | for (var index = 0; index < buf.length; index++) { | ||
12586 | var byte = buf[index]; | ||
12587 | crc = TABLE[(crc ^ byte) & 0xff] & 0xff; | ||
12588 | } | ||
12589 | |||
12590 | return crc; | ||
12591 | }); | ||
12592 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],62:[function(require,module,exports){ | ||
12593 | 'use strict'; | ||
12594 | |||
12595 | var _buffer = require('buffer'); | ||
12596 | |||
12597 | var _create_buffer = require('./create_buffer'); | ||
12598 | |||
12599 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | ||
12600 | |||
12601 | var _define_crc = require('./define_crc'); | ||
12602 | |||
12603 | var _define_crc2 = _interopRequireDefault(_define_crc); | ||
12604 | |||
12605 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
12606 | |||
12607 | // Generated by `./pycrc.py --algorithm=table-driven --model=jam --generate=c` | ||
12608 | var TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d]; | ||
12609 | |||
12610 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | ||
12611 | |||
12612 | module.exports = (0, _define_crc2.default)('jam', function (buf) { | ||
12613 | var previous = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1; | ||
12614 | |||
12615 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | ||
12616 | |||
12617 | var crc = previous === 0 ? 0 : ~~previous; | ||
12618 | |||
12619 | for (var index = 0; index < buf.length; index++) { | ||
12620 | var byte = buf[index]; | ||
12621 | crc = TABLE[(crc ^ byte) & 0xff] ^ crc >>> 8; | ||
12622 | } | ||
12623 | |||
12624 | return crc; | ||
12625 | }); | ||
12626 | },{"./create_buffer":63,"./define_crc":64,"buffer":49}],63:[function(require,module,exports){ | ||
12627 | 'use strict'; | ||
12628 | |||
12629 | Object.defineProperty(exports, "__esModule", { | ||
12630 | value: true | ||
12631 | }); | ||
12632 | |||
12633 | var _buffer = require('buffer'); | ||
12634 | |||
12635 | var createBuffer = _buffer.Buffer.from && _buffer.Buffer.alloc && _buffer.Buffer.allocUnsafe && _buffer.Buffer.allocUnsafeSlow ? _buffer.Buffer.from | ||
12636 | |||
12637 | // support for Node < 5.10 | ||
12638 | : function (val) { | ||
12639 | return new _buffer.Buffer(val); | ||
12640 | }; | ||
12641 | |||
12642 | exports.default = createBuffer; | ||
12643 | },{"buffer":49}],64:[function(require,module,exports){ | ||
12644 | "use strict"; | ||
12645 | |||
12646 | Object.defineProperty(exports, "__esModule", { | ||
12647 | value: true | ||
12648 | }); | ||
12649 | |||
12650 | exports.default = function (model, calc) { | ||
12651 | var fn = function fn(buf, previous) { | ||
12652 | return calc(buf, previous) >>> 0; | ||
12653 | }; | ||
12654 | fn.signed = calc; | ||
12655 | fn.unsigned = fn; | ||
12656 | fn.model = model; | ||
12657 | |||
12658 | return fn; | ||
12659 | }; | ||
12660 | },{}],65:[function(require,module,exports){ | ||
12661 | 'use strict'; | ||
12662 | |||
12663 | module.exports = { | ||
12664 | crc1: require('./crc1'), | ||
12665 | crc8: require('./crc8'), | ||
12666 | crc81wire: require('./crc8_1wire'), | ||
12667 | crc16: require('./crc16'), | ||
12668 | crc16ccitt: require('./crc16_ccitt'), | ||
12669 | crc16modbus: require('./crc16_modbus'), | ||
12670 | crc16xmodem: require('./crc16_xmodem'), | ||
12671 | crc16kermit: require('./crc16_kermit'), | ||
12672 | crc24: require('./crc24'), | ||
12673 | crc32: require('./crc32'), | ||
12674 | crcjam: require('./crcjam') | ||
12675 | }; | ||
12676 | },{"./crc1":52,"./crc16":53,"./crc16_ccitt":54,"./crc16_kermit":55,"./crc16_modbus":56,"./crc16_xmodem":57,"./crc24":58,"./crc32":59,"./crc8":60,"./crc8_1wire":61,"./crcjam":62}],66:[function(require,module,exports){ | ||
12677 | (function (Buffer){ | ||
12678 | var elliptic = require('elliptic') | ||
12679 | var BN = require('bn.js') | ||
12680 | |||
12681 | module.exports = function createECDH (curve) { | ||
12682 | return new ECDH(curve) | ||
12683 | } | ||
12684 | |||
12685 | var aliases = { | ||
12686 | secp256k1: { | ||
12687 | name: 'secp256k1', | ||
12688 | byteLength: 32 | ||
12689 | }, | ||
12690 | secp224r1: { | ||
12691 | name: 'p224', | ||
12692 | byteLength: 28 | ||
12693 | }, | ||
12694 | prime256v1: { | ||
12695 | name: 'p256', | ||
12696 | byteLength: 32 | ||
12697 | }, | ||
12698 | prime192v1: { | ||
12699 | name: 'p192', | ||
12700 | byteLength: 24 | ||
12701 | }, | ||
12702 | ed25519: { | ||
12703 | name: 'ed25519', | ||
12704 | byteLength: 32 | ||
12705 | }, | ||
12706 | secp384r1: { | ||
12707 | name: 'p384', | ||
12708 | byteLength: 48 | ||
12709 | }, | ||
12710 | secp521r1: { | ||
12711 | name: 'p521', | ||
12712 | byteLength: 66 | ||
12713 | } | ||
12714 | } | ||
12715 | |||
12716 | aliases.p224 = aliases.secp224r1 | ||
12717 | aliases.p256 = aliases.secp256r1 = aliases.prime256v1 | ||
12718 | aliases.p192 = aliases.secp192r1 = aliases.prime192v1 | ||
12719 | aliases.p384 = aliases.secp384r1 | ||
12720 | aliases.p521 = aliases.secp521r1 | ||
12721 | |||
12722 | function ECDH (curve) { | ||
12723 | this.curveType = aliases[curve] | ||
12724 | if (!this.curveType) { | ||
12725 | this.curveType = { | ||
12726 | name: curve | ||
12727 | } | ||
12728 | } | ||
12729 | this.curve = new elliptic.ec(this.curveType.name) // eslint-disable-line new-cap | ||
12730 | this.keys = void 0 | ||
12731 | } | ||
12732 | |||
12733 | ECDH.prototype.generateKeys = function (enc, format) { | ||
12734 | this.keys = this.curve.genKeyPair() | ||
12735 | return this.getPublicKey(enc, format) | ||
12736 | } | ||
12737 | |||
12738 | ECDH.prototype.computeSecret = function (other, inenc, enc) { | ||
12739 | inenc = inenc || 'utf8' | ||
12740 | if (!Buffer.isBuffer(other)) { | ||
12741 | other = new Buffer(other, inenc) | ||
12742 | } | ||
12743 | var otherPub = this.curve.keyFromPublic(other).getPublic() | ||
12744 | var out = otherPub.mul(this.keys.getPrivate()).getX() | ||
12745 | return formatReturnValue(out, enc, this.curveType.byteLength) | ||
12746 | } | ||
12747 | |||
12748 | ECDH.prototype.getPublicKey = function (enc, format) { | ||
12749 | var key = this.keys.getPublic(format === 'compressed', true) | ||
12750 | if (format === 'hybrid') { | ||
12751 | if (key[key.length - 1] % 2) { | ||
12752 | key[0] = 7 | ||
12753 | } else { | ||
12754 | key[0] = 6 | ||
12755 | } | ||
12756 | } | ||
12757 | return formatReturnValue(key, enc) | ||
12758 | } | ||
12759 | |||
12760 | ECDH.prototype.getPrivateKey = function (enc) { | ||
12761 | return formatReturnValue(this.keys.getPrivate(), enc) | ||
12762 | } | ||
12763 | |||
12764 | ECDH.prototype.setPublicKey = function (pub, enc) { | ||
12765 | enc = enc || 'utf8' | ||
12766 | if (!Buffer.isBuffer(pub)) { | ||
12767 | pub = new Buffer(pub, enc) | ||
12768 | } | ||
12769 | this.keys._importPublic(pub) | ||
12770 | return this | ||
12771 | } | ||
12772 | |||
12773 | ECDH.prototype.setPrivateKey = function (priv, enc) { | ||
12774 | enc = enc || 'utf8' | ||
12775 | if (!Buffer.isBuffer(priv)) { | ||
12776 | priv = new Buffer(priv, enc) | ||
12777 | } | ||
12778 | |||
12779 | var _priv = new BN(priv) | ||
12780 | _priv = _priv.toString(16) | ||
12781 | this.keys = this.curve.genKeyPair() | ||
12782 | this.keys._importPrivate(_priv) | ||
12783 | return this | ||
12784 | } | ||
12785 | |||
12786 | function formatReturnValue (bn, enc, len) { | ||
12787 | if (!Array.isArray(bn)) { | ||
12788 | bn = bn.toArray() | ||
12789 | } | ||
12790 | var buf = new Buffer(bn) | ||
12791 | if (len && buf.length < len) { | ||
12792 | var zeros = new Buffer(len - buf.length) | ||
12793 | zeros.fill(0) | ||
12794 | buf = Buffer.concat([zeros, buf]) | ||
12795 | } | ||
12796 | if (!enc) { | ||
12797 | return buf | ||
12798 | } else { | ||
12799 | return buf.toString(enc) | ||
12800 | } | ||
12801 | } | ||
12802 | |||
12803 | }).call(this,require("buffer").Buffer) | ||
12804 | },{"bn.js":18,"buffer":49,"elliptic":83}],67:[function(require,module,exports){ | ||
12805 | 'use strict' | ||
12806 | var inherits = require('inherits') | ||
12807 | var MD5 = require('md5.js') | ||
12808 | var RIPEMD160 = require('ripemd160') | ||
12809 | var sha = require('sha.js') | ||
12810 | var Base = require('cipher-base') | ||
12811 | |||
12812 | function Hash (hash) { | ||
12813 | Base.call(this, 'digest') | ||
12814 | |||
12815 | this._hash = hash | ||
12816 | } | ||
12817 | |||
12818 | inherits(Hash, Base) | ||
12819 | |||
12820 | Hash.prototype._update = function (data) { | ||
12821 | this._hash.update(data) | ||
12822 | } | ||
12823 | |||
12824 | Hash.prototype._final = function () { | ||
12825 | return this._hash.digest() | ||
12826 | } | ||
12827 | |||
12828 | module.exports = function createHash (alg) { | ||
12829 | alg = alg.toLowerCase() | ||
12830 | if (alg === 'md5') return new MD5() | ||
12831 | if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160() | ||
12832 | |||
12833 | return new Hash(sha(alg)) | ||
12834 | } | ||
12835 | |||
12836 | },{"cipher-base":50,"inherits":116,"md5.js":354,"ripemd160":392,"sha.js":395}],68:[function(require,module,exports){ | ||
12837 | var MD5 = require('md5.js') | ||
12838 | |||
12839 | module.exports = function (buffer) { | ||
12840 | return new MD5().update(buffer).digest() | ||
12841 | } | ||
12842 | |||
12843 | },{"md5.js":354}],69:[function(require,module,exports){ | ||
12844 | 'use strict' | ||
12845 | var inherits = require('inherits') | ||
12846 | var Legacy = require('./legacy') | ||
12847 | var Base = require('cipher-base') | ||
12848 | var Buffer = require('safe-buffer').Buffer | ||
12849 | var md5 = require('create-hash/md5') | ||
12850 | var RIPEMD160 = require('ripemd160') | ||
12851 | |||
12852 | var sha = require('sha.js') | ||
12853 | |||
12854 | var ZEROS = Buffer.alloc(128) | ||
12855 | |||
12856 | function Hmac (alg, key) { | ||
12857 | Base.call(this, 'digest') | ||
12858 | if (typeof key === 'string') { | ||
12859 | key = Buffer.from(key) | ||
12860 | } | ||
12861 | |||
12862 | var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64 | ||
12863 | |||
12864 | this._alg = alg | ||
12865 | this._key = key | ||
12866 | if (key.length > blocksize) { | ||
12867 | var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg) | ||
12868 | key = hash.update(key).digest() | ||
12869 | } else if (key.length < blocksize) { | ||
12870 | key = Buffer.concat([key, ZEROS], blocksize) | ||
12871 | } | ||
12872 | |||
12873 | var ipad = this._ipad = Buffer.allocUnsafe(blocksize) | ||
12874 | var opad = this._opad = Buffer.allocUnsafe(blocksize) | ||
12875 | |||
12876 | for (var i = 0; i < blocksize; i++) { | ||
12877 | ipad[i] = key[i] ^ 0x36 | ||
12878 | opad[i] = key[i] ^ 0x5C | ||
12879 | } | ||
12880 | this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg) | ||
12881 | this._hash.update(ipad) | ||
12882 | } | ||
12883 | |||
12884 | inherits(Hmac, Base) | ||
12885 | |||
12886 | Hmac.prototype._update = function (data) { | ||
12887 | this._hash.update(data) | ||
12888 | } | ||
12889 | |||
12890 | Hmac.prototype._final = function () { | ||
12891 | var h = this._hash.digest() | ||
12892 | var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg) | ||
12893 | return hash.update(this._opad).update(h).digest() | ||
12894 | } | ||
12895 | |||
12896 | module.exports = function createHmac (alg, key) { | ||
12897 | alg = alg.toLowerCase() | ||
12898 | if (alg === 'rmd160' || alg === 'ripemd160') { | ||
12899 | return new Hmac('rmd160', key) | ||
12900 | } | ||
12901 | if (alg === 'md5') { | ||
12902 | return new Legacy(md5, key) | ||
12903 | } | ||
12904 | return new Hmac(alg, key) | ||
12905 | } | ||
12906 | |||
12907 | },{"./legacy":70,"cipher-base":50,"create-hash/md5":68,"inherits":116,"ripemd160":392,"safe-buffer":393,"sha.js":395}],70:[function(require,module,exports){ | ||
12908 | 'use strict' | ||
12909 | var inherits = require('inherits') | ||
12910 | var Buffer = require('safe-buffer').Buffer | ||
12911 | |||
12912 | var Base = require('cipher-base') | ||
12913 | |||
12914 | var ZEROS = Buffer.alloc(128) | ||
12915 | var blocksize = 64 | ||
12916 | |||
12917 | function Hmac (alg, key) { | ||
12918 | Base.call(this, 'digest') | ||
12919 | if (typeof key === 'string') { | ||
12920 | key = Buffer.from(key) | ||
12921 | } | ||
12922 | |||
12923 | this._alg = alg | ||
12924 | this._key = key | ||
12925 | |||
12926 | if (key.length > blocksize) { | ||
12927 | key = alg(key) | ||
12928 | } else if (key.length < blocksize) { | ||
12929 | key = Buffer.concat([key, ZEROS], blocksize) | ||
12930 | } | ||
12931 | |||
12932 | var ipad = this._ipad = Buffer.allocUnsafe(blocksize) | ||
12933 | var opad = this._opad = Buffer.allocUnsafe(blocksize) | ||
12934 | |||
12935 | for (var i = 0; i < blocksize; i++) { | ||
12936 | ipad[i] = key[i] ^ 0x36 | ||
12937 | opad[i] = key[i] ^ 0x5C | ||
12938 | } | ||
12939 | |||
12940 | this._hash = [ipad] | ||
12941 | } | ||
12942 | |||
12943 | inherits(Hmac, Base) | ||
12944 | |||
12945 | Hmac.prototype._update = function (data) { | ||
12946 | this._hash.push(data) | ||
12947 | } | ||
12948 | |||
12949 | Hmac.prototype._final = function () { | ||
12950 | var h = this._alg(Buffer.concat(this._hash)) | ||
12951 | return this._alg(Buffer.concat([this._opad, h])) | ||
12952 | } | ||
12953 | module.exports = Hmac | ||
12954 | |||
12955 | },{"cipher-base":50,"inherits":116,"safe-buffer":393}],71:[function(require,module,exports){ | ||
12956 | 'use strict' | ||
12957 | |||
12958 | exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes') | ||
12959 | exports.createHash = exports.Hash = require('create-hash') | ||
12960 | exports.createHmac = exports.Hmac = require('create-hmac') | ||
12961 | |||
12962 | var algos = require('browserify-sign/algos') | ||
12963 | var algoKeys = Object.keys(algos) | ||
12964 | var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys) | ||
12965 | exports.getHashes = function () { | ||
12966 | return hashes | ||
12967 | } | ||
12968 | |||
12969 | var p = require('pbkdf2') | ||
12970 | exports.pbkdf2 = p.pbkdf2 | ||
12971 | exports.pbkdf2Sync = p.pbkdf2Sync | ||
12972 | |||
12973 | var aes = require('browserify-cipher') | ||
12974 | |||
12975 | exports.Cipher = aes.Cipher | ||
12976 | exports.createCipher = aes.createCipher | ||
12977 | exports.Cipheriv = aes.Cipheriv | ||
12978 | exports.createCipheriv = aes.createCipheriv | ||
12979 | exports.Decipher = aes.Decipher | ||
12980 | exports.createDecipher = aes.createDecipher | ||
12981 | exports.Decipheriv = aes.Decipheriv | ||
12982 | exports.createDecipheriv = aes.createDecipheriv | ||
12983 | exports.getCiphers = aes.getCiphers | ||
12984 | exports.listCiphers = aes.listCiphers | ||
12985 | |||
12986 | var dh = require('diffie-hellman') | ||
12987 | |||
12988 | exports.DiffieHellmanGroup = dh.DiffieHellmanGroup | ||
12989 | exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup | ||
12990 | exports.getDiffieHellman = dh.getDiffieHellman | ||
12991 | exports.createDiffieHellman = dh.createDiffieHellman | ||
12992 | exports.DiffieHellman = dh.DiffieHellman | ||
12993 | |||
12994 | var sign = require('browserify-sign') | ||
12995 | |||
12996 | exports.createSign = sign.createSign | ||
12997 | exports.Sign = sign.Sign | ||
12998 | exports.createVerify = sign.createVerify | ||
12999 | exports.Verify = sign.Verify | ||
13000 | |||
13001 | exports.createECDH = require('create-ecdh') | ||
13002 | |||
13003 | var publicEncrypt = require('public-encrypt') | ||
13004 | |||
13005 | exports.publicEncrypt = publicEncrypt.publicEncrypt | ||
13006 | exports.privateEncrypt = publicEncrypt.privateEncrypt | ||
13007 | exports.publicDecrypt = publicEncrypt.publicDecrypt | ||
13008 | exports.privateDecrypt = publicEncrypt.privateDecrypt | ||
13009 | |||
13010 | // the least I can do is make error messages for the rest of the node.js/crypto api. | ||
13011 | // ;[ | ||
13012 | // 'createCredentials' | ||
13013 | // ].forEach(function (name) { | ||
13014 | // exports[name] = function () { | ||
13015 | // throw new Error([ | ||
13016 | // 'sorry, ' + name + ' is not implemented yet', | ||
13017 | // 'we accept pull requests', | ||
13018 | // 'https://github.com/crypto-browserify/crypto-browserify' | ||
13019 | // ].join('\n')) | ||
13020 | // } | ||
13021 | // }) | ||
13022 | |||
13023 | var rf = require('randomfill') | ||
13024 | |||
13025 | exports.randomFill = rf.randomFill | ||
13026 | exports.randomFillSync = rf.randomFillSync | ||
13027 | |||
13028 | exports.createCredentials = function () { | ||
13029 | throw new Error([ | ||
13030 | 'sorry, createCredentials is not implemented yet', | ||
13031 | 'we accept pull requests', | ||
13032 | 'https://github.com/crypto-browserify/crypto-browserify' | ||
13033 | ].join('\n')) | ||
13034 | } | ||
13035 | |||
13036 | exports.constants = { | ||
13037 | 'DH_CHECK_P_NOT_SAFE_PRIME': 2, | ||
13038 | 'DH_CHECK_P_NOT_PRIME': 1, | ||
13039 | 'DH_UNABLE_TO_CHECK_GENERATOR': 4, | ||
13040 | 'DH_NOT_SUITABLE_GENERATOR': 8, | ||
13041 | 'NPN_ENABLED': 1, | ||
13042 | 'ALPN_ENABLED': 1, | ||
13043 | 'RSA_PKCS1_PADDING': 1, | ||
13044 | 'RSA_SSLV23_PADDING': 2, | ||
13045 | 'RSA_NO_PADDING': 3, | ||
13046 | 'RSA_PKCS1_OAEP_PADDING': 4, | ||
13047 | 'RSA_X931_PADDING': 5, | ||
13048 | 'RSA_PKCS1_PSS_PADDING': 6, | ||
13049 | 'POINT_CONVERSION_COMPRESSED': 2, | ||
13050 | 'POINT_CONVERSION_UNCOMPRESSED': 4, | ||
13051 | 'POINT_CONVERSION_HYBRID': 6 | ||
13052 | } | ||
13053 | |||
13054 | },{"browserify-cipher":38,"browserify-sign":45,"browserify-sign/algos":42,"create-ecdh":66,"create-hash":67,"create-hmac":69,"diffie-hellman":79,"pbkdf2":363,"public-encrypt":370,"randombytes":376,"randomfill":377}],72:[function(require,module,exports){ | ||
13055 | (function (Buffer){ | ||
13056 | var Cursor = function(buffer) | ||
13057 | { | ||
13058 | if (!(this instanceof Cursor)) | ||
13059 | { | ||
13060 | return new Cursor(buffer); | ||
13061 | } | ||
13062 | |||
13063 | if (!(buffer instanceof Buffer)) | ||
13064 | { | ||
13065 | buffer = new Buffer(buffer); | ||
13066 | } | ||
13067 | |||
13068 | this._setBuffer(buffer); | ||
13069 | this.rewind(); | ||
13070 | }; | ||
13071 | |||
13072 | Cursor.prototype._setBuffer = function(buffer) | ||
13073 | { | ||
13074 | this._buffer = buffer; | ||
13075 | this.length = buffer.length; | ||
13076 | }; | ||
13077 | |||
13078 | Cursor.prototype.buffer = function() | ||
13079 | { | ||
13080 | return this._buffer; | ||
13081 | }; | ||
13082 | |||
13083 | Cursor.prototype.tap = function(cb) | ||
13084 | { | ||
13085 | cb(this); | ||
13086 | return this; | ||
13087 | }; | ||
13088 | |||
13089 | Cursor.prototype.clone = function(newIndex) | ||
13090 | { | ||
13091 | var c = new this.constructor(this.buffer()); | ||
13092 | c.seek(arguments.length === 0 ? this.tell() : newIndex); | ||
13093 | |||
13094 | return c; | ||
13095 | }; | ||
13096 | |||
13097 | Cursor.prototype.tell = function() | ||
13098 | { | ||
13099 | return this._index; | ||
13100 | }; | ||
13101 | |||
13102 | Cursor.prototype.seek = function(op, index) | ||
13103 | { | ||
13104 | if (arguments.length == 1) | ||
13105 | { | ||
13106 | index = op; | ||
13107 | op = '='; | ||
13108 | } | ||
13109 | |||
13110 | if (op == '+') | ||
13111 | { | ||
13112 | this._index += index; | ||
13113 | } | ||
13114 | else if (op == '-') | ||
13115 | { | ||
13116 | this._index -= index; | ||
13117 | } | ||
13118 | else | ||
13119 | { | ||
13120 | this._index = index; | ||
13121 | } | ||
13122 | |||
13123 | return this; | ||
13124 | }; | ||
13125 | |||
13126 | Cursor.prototype.rewind = function() | ||
13127 | { | ||
13128 | return this.seek(0); | ||
13129 | }; | ||
13130 | |||
13131 | Cursor.prototype.eof = function() | ||
13132 | { | ||
13133 | return this.tell() == this.buffer().length; | ||
13134 | }; | ||
13135 | |||
13136 | Cursor.prototype.write = function(string, length, encoding) | ||
13137 | { | ||
13138 | return this.seek('+', this.buffer().write(string, this.tell(), length, encoding)); | ||
13139 | }; | ||
13140 | |||
13141 | Cursor.prototype.fill = function(value, length) | ||
13142 | { | ||
13143 | if (arguments.length == 1) | ||
13144 | { | ||
13145 | length = this.buffer().length - this.tell(); | ||
13146 | } | ||
13147 | |||
13148 | this.buffer().fill(value, this.tell(), this.tell() + length); | ||
13149 | this.seek('+', length); | ||
13150 | |||
13151 | return this; | ||
13152 | }; | ||
13153 | |||
13154 | Cursor.prototype.slice = function(length) | ||
13155 | { | ||
13156 | if (arguments.length === 0) | ||
13157 | { | ||
13158 | length = this.length - this.tell(); | ||
13159 | } | ||
13160 | |||
13161 | var c = new this.constructor(this.buffer().slice(this.tell(), this.tell() + length)); | ||
13162 | this.seek('+', length); | ||
13163 | |||
13164 | return c; | ||
13165 | }; | ||
13166 | |||
13167 | Cursor.prototype.copyFrom = function(source) | ||
13168 | { | ||
13169 | var buf = source instanceof Buffer ? source: source.buffer(); | ||
13170 | buf.copy(this.buffer(), this.tell(), 0, buf.length); | ||
13171 | this.seek('+', buf.length); | ||
13172 | |||
13173 | return this; | ||
13174 | }; | ||
13175 | |||
13176 | Cursor.prototype.concat = function(list) | ||
13177 | { | ||
13178 | for (var i in list) | ||
13179 | { | ||
13180 | if (list[i] instanceof Cursor) | ||
13181 | { | ||
13182 | list[i] = list[i].buffer(); | ||
13183 | } | ||
13184 | } | ||
13185 | |||
13186 | list.unshift(this.buffer()); | ||
13187 | |||
13188 | var b = Buffer.concat(list); | ||
13189 | this._setBuffer(b); | ||
13190 | |||
13191 | return this; | ||
13192 | }; | ||
13193 | |||
13194 | Cursor.prototype.toString = function(encoding, length) | ||
13195 | { | ||
13196 | if (arguments.length === 0) | ||
13197 | { | ||
13198 | encoding = 'utf8'; | ||
13199 | length = this.buffer().length - this.tell(); | ||
13200 | } | ||
13201 | else if (arguments.length === 1) | ||
13202 | { | ||
13203 | length = this.buffer().length - this.tell(); | ||
13204 | } | ||
13205 | |||
13206 | var val = this.buffer().toString(encoding, this.tell(), this.tell() + length); | ||
13207 | this.seek('+', length); | ||
13208 | |||
13209 | return val; | ||
13210 | }; | ||
13211 | |||
13212 | [ | ||
13213 | [1, ['readInt8', 'readUInt8']], | ||
13214 | [2, ['readInt16BE', 'readInt16LE', 'readUInt16BE', 'readUInt16LE']], | ||
13215 | [4, ['readInt32BE', 'readInt32LE', 'readUInt32BE', 'readUInt32LE', 'readFloatBE', 'readFloatLE']], | ||
13216 | [8, ['readDoubleBE', 'readDoubleLE']] | ||
13217 | ].forEach(function(arr) | ||
13218 | { | ||
13219 | arr[1].forEach(function(method) | ||
13220 | { | ||
13221 | Cursor.prototype[method] = function() | ||
13222 | { | ||
13223 | var val = this.buffer()[method](this.tell()); | ||
13224 | this.seek('+', arr[0]); | ||
13225 | |||
13226 | return val; | ||
13227 | }; | ||
13228 | }); | ||
13229 | }); | ||
13230 | |||
13231 | [ | ||
13232 | [1, ['writeInt8', 'writeUInt8']], | ||
13233 | [2, ['writeInt16BE', 'writeInt16LE', 'writeUInt16BE', 'writeUInt16LE']], | ||
13234 | [4, ['writeInt32BE', 'writeInt32LE', 'writeUInt32BE', 'writeUInt32LE', 'writeFloatBE', 'writeFloatLE']], | ||
13235 | [8, ['writeDoubleBE', 'writeDoubleLE']] | ||
13236 | ].forEach(function(arr) | ||
13237 | { | ||
13238 | arr[1].forEach(function(method) | ||
13239 | { | ||
13240 | Cursor.prototype[method] = function(val) | ||
13241 | { | ||
13242 | val = this.buffer()[method](val, this.tell()); | ||
13243 | this.seek('+', arr[0]); | ||
13244 | |||
13245 | return this; | ||
13246 | }; | ||
13247 | }); | ||
13248 | }); | ||
13249 | |||
13250 | //basic extend functionality to facilitate | ||
13251 | //writing your own cursor while still providing | ||
13252 | //access to low level r/w functionality | ||
13253 | Cursor.extend = function(C, proto) | ||
13254 | { | ||
13255 | var parent = this; | ||
13256 | |||
13257 | if (arguments.length === 1) | ||
13258 | { | ||
13259 | proto = C; | ||
13260 | C = null; | ||
13261 | } | ||
13262 | |||
13263 | proto = proto || {}; | ||
13264 | |||
13265 | C = C || function ctor(buffer) | ||
13266 | { | ||
13267 | if (!(this instanceof C)) | ||
13268 | { | ||
13269 | return new C(buffer); | ||
13270 | } | ||
13271 | |||
13272 | parent.call(this, buffer); | ||
13273 | }; | ||
13274 | |||
13275 | require('util').inherits(C, parent); | ||
13276 | |||
13277 | C.extend = parent.extend; | ||
13278 | C.define = parent.define; | ||
13279 | |||
13280 | for (var i in proto) | ||
13281 | { | ||
13282 | C.define(i, proto[i]); | ||
13283 | } | ||
13284 | |||
13285 | return C; | ||
13286 | }; | ||
13287 | |||
13288 | Cursor.define = function(name, fn) | ||
13289 | { | ||
13290 | var proto = this.prototype[name]; | ||
13291 | |||
13292 | this.prototype[name] = proto && function() | ||
13293 | { | ||
13294 | this.__super = proto; | ||
13295 | return fn.apply(this, arguments); | ||
13296 | } || fn; | ||
13297 | }; | ||
13298 | |||
13299 | module.exports = Cursor; | ||
13300 | |||
13301 | }).call(this,require("buffer").Buffer) | ||
13302 | },{"buffer":49,"util":438}],73:[function(require,module,exports){ | ||
13303 | 'use strict'; | ||
13304 | |||
13305 | exports.utils = require('./des/utils'); | ||
13306 | exports.Cipher = require('./des/cipher'); | ||
13307 | exports.DES = require('./des/des'); | ||
13308 | exports.CBC = require('./des/cbc'); | ||
13309 | exports.EDE = require('./des/ede'); | ||
13310 | |||
13311 | },{"./des/cbc":74,"./des/cipher":75,"./des/des":76,"./des/ede":77,"./des/utils":78}],74:[function(require,module,exports){ | ||
13312 | 'use strict'; | ||
13313 | |||
13314 | var assert = require('minimalistic-assert'); | ||
13315 | var inherits = require('inherits'); | ||
13316 | |||
13317 | var proto = {}; | ||
13318 | |||
13319 | function CBCState(iv) { | ||
13320 | assert.equal(iv.length, 8, 'Invalid IV length'); | ||
13321 | |||
13322 | this.iv = new Array(8); | ||
13323 | for (var i = 0; i < this.iv.length; i++) | ||
13324 | this.iv[i] = iv[i]; | ||
13325 | } | ||
13326 | |||
13327 | function instantiate(Base) { | ||
13328 | function CBC(options) { | ||
13329 | Base.call(this, options); | ||
13330 | this._cbcInit(); | ||
13331 | } | ||
13332 | inherits(CBC, Base); | ||
13333 | |||
13334 | var keys = Object.keys(proto); | ||
13335 | for (var i = 0; i < keys.length; i++) { | ||
13336 | var key = keys[i]; | ||
13337 | CBC.prototype[key] = proto[key]; | ||
13338 | } | ||
13339 | |||
13340 | CBC.create = function create(options) { | ||
13341 | return new CBC(options); | ||
13342 | }; | ||
13343 | |||
13344 | return CBC; | ||
13345 | } | ||
13346 | |||
13347 | exports.instantiate = instantiate; | ||
13348 | |||
13349 | proto._cbcInit = function _cbcInit() { | ||
13350 | var state = new CBCState(this.options.iv); | ||
13351 | this._cbcState = state; | ||
13352 | }; | ||
13353 | |||
13354 | proto._update = function _update(inp, inOff, out, outOff) { | ||
13355 | var state = this._cbcState; | ||
13356 | var superProto = this.constructor.super_.prototype; | ||
13357 | |||
13358 | var iv = state.iv; | ||
13359 | if (this.type === 'encrypt') { | ||
13360 | for (var i = 0; i < this.blockSize; i++) | ||
13361 | iv[i] ^= inp[inOff + i]; | ||
13362 | |||
13363 | superProto._update.call(this, iv, 0, out, outOff); | ||
13364 | |||
13365 | for (var i = 0; i < this.blockSize; i++) | ||
13366 | iv[i] = out[outOff + i]; | ||
13367 | } else { | ||
13368 | superProto._update.call(this, inp, inOff, out, outOff); | ||
13369 | |||
13370 | for (var i = 0; i < this.blockSize; i++) | ||
13371 | out[outOff + i] ^= iv[i]; | ||
13372 | |||
13373 | for (var i = 0; i < this.blockSize; i++) | ||
13374 | iv[i] = inp[inOff + i]; | ||
13375 | } | ||
13376 | }; | ||
13377 | |||
13378 | },{"inherits":116,"minimalistic-assert":356}],75:[function(require,module,exports){ | ||
13379 | 'use strict'; | ||
13380 | |||
13381 | var assert = require('minimalistic-assert'); | ||
13382 | |||
13383 | function Cipher(options) { | ||
13384 | this.options = options; | ||
13385 | |||
13386 | this.type = this.options.type; | ||
13387 | this.blockSize = 8; | ||
13388 | this._init(); | ||
13389 | |||
13390 | this.buffer = new Array(this.blockSize); | ||
13391 | this.bufferOff = 0; | ||
13392 | } | ||
13393 | module.exports = Cipher; | ||
13394 | |||
13395 | Cipher.prototype._init = function _init() { | ||
13396 | // Might be overrided | ||
13397 | }; | ||
13398 | |||
13399 | Cipher.prototype.update = function update(data) { | ||
13400 | if (data.length === 0) | ||
13401 | return []; | ||
13402 | |||
13403 | if (this.type === 'decrypt') | ||
13404 | return this._updateDecrypt(data); | ||
13405 | else | ||
13406 | return this._updateEncrypt(data); | ||
13407 | }; | ||
13408 | |||
13409 | Cipher.prototype._buffer = function _buffer(data, off) { | ||
13410 | // Append data to buffer | ||
13411 | var min = Math.min(this.buffer.length - this.bufferOff, data.length - off); | ||
13412 | for (var i = 0; i < min; i++) | ||
13413 | this.buffer[this.bufferOff + i] = data[off + i]; | ||
13414 | this.bufferOff += min; | ||
13415 | |||
13416 | // Shift next | ||
13417 | return min; | ||
13418 | }; | ||
13419 | |||
13420 | Cipher.prototype._flushBuffer = function _flushBuffer(out, off) { | ||
13421 | this._update(this.buffer, 0, out, off); | ||
13422 | this.bufferOff = 0; | ||
13423 | return this.blockSize; | ||
13424 | }; | ||
13425 | |||
13426 | Cipher.prototype._updateEncrypt = function _updateEncrypt(data) { | ||
13427 | var inputOff = 0; | ||
13428 | var outputOff = 0; | ||
13429 | |||
13430 | var count = ((this.bufferOff + data.length) / this.blockSize) | 0; | ||
13431 | var out = new Array(count * this.blockSize); | ||
13432 | |||
13433 | if (this.bufferOff !== 0) { | ||
13434 | inputOff += this._buffer(data, inputOff); | ||
13435 | |||
13436 | if (this.bufferOff === this.buffer.length) | ||
13437 | outputOff += this._flushBuffer(out, outputOff); | ||
13438 | } | ||
13439 | |||
13440 | // Write blocks | ||
13441 | var max = data.length - ((data.length - inputOff) % this.blockSize); | ||
13442 | for (; inputOff < max; inputOff += this.blockSize) { | ||
13443 | this._update(data, inputOff, out, outputOff); | ||
13444 | outputOff += this.blockSize; | ||
13445 | } | ||
13446 | |||
13447 | // Queue rest | ||
13448 | for (; inputOff < data.length; inputOff++, this.bufferOff++) | ||
13449 | this.buffer[this.bufferOff] = data[inputOff]; | ||
13450 | |||
13451 | return out; | ||
13452 | }; | ||
13453 | |||
13454 | Cipher.prototype._updateDecrypt = function _updateDecrypt(data) { | ||
13455 | var inputOff = 0; | ||
13456 | var outputOff = 0; | ||
13457 | |||
13458 | var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1; | ||
13459 | var out = new Array(count * this.blockSize); | ||
13460 | |||
13461 | // TODO(indutny): optimize it, this is far from optimal | ||
13462 | for (; count > 0; count--) { | ||
13463 | inputOff += this._buffer(data, inputOff); | ||
13464 | outputOff += this._flushBuffer(out, outputOff); | ||
13465 | } | ||
13466 | |||
13467 | // Buffer rest of the input | ||
13468 | inputOff += this._buffer(data, inputOff); | ||
13469 | |||
13470 | return out; | ||
13471 | }; | ||
13472 | |||
13473 | Cipher.prototype.final = function final(buffer) { | ||
13474 | var first; | ||
13475 | if (buffer) | ||
13476 | first = this.update(buffer); | ||
13477 | |||
13478 | var last; | ||
13479 | if (this.type === 'encrypt') | ||
13480 | last = this._finalEncrypt(); | ||
13481 | else | ||
13482 | last = this._finalDecrypt(); | ||
13483 | |||
13484 | if (first) | ||
13485 | return first.concat(last); | ||
13486 | else | ||
13487 | return last; | ||
13488 | }; | ||
13489 | |||
13490 | Cipher.prototype._pad = function _pad(buffer, off) { | ||
13491 | if (off === 0) | ||
13492 | return false; | ||
13493 | |||
13494 | while (off < buffer.length) | ||
13495 | buffer[off++] = 0; | ||
13496 | |||
13497 | return true; | ||
13498 | }; | ||
13499 | |||
13500 | Cipher.prototype._finalEncrypt = function _finalEncrypt() { | ||
13501 | if (!this._pad(this.buffer, this.bufferOff)) | ||
13502 | return []; | ||
13503 | |||
13504 | var out = new Array(this.blockSize); | ||
13505 | this._update(this.buffer, 0, out, 0); | ||
13506 | return out; | ||
13507 | }; | ||
13508 | |||
13509 | Cipher.prototype._unpad = function _unpad(buffer) { | ||
13510 | return buffer; | ||
13511 | }; | ||
13512 | |||
13513 | Cipher.prototype._finalDecrypt = function _finalDecrypt() { | ||
13514 | assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt'); | ||
13515 | var out = new Array(this.blockSize); | ||
13516 | this._flushBuffer(out, 0); | ||
13517 | |||
13518 | return this._unpad(out); | ||
13519 | }; | ||
13520 | |||
13521 | },{"minimalistic-assert":356}],76:[function(require,module,exports){ | ||
13522 | 'use strict'; | ||
13523 | |||
13524 | var assert = require('minimalistic-assert'); | ||
13525 | var inherits = require('inherits'); | ||
13526 | |||
13527 | var des = require('../des'); | ||
13528 | var utils = des.utils; | ||
13529 | var Cipher = des.Cipher; | ||
13530 | |||
13531 | function DESState() { | ||
13532 | this.tmp = new Array(2); | ||
13533 | this.keys = null; | ||
13534 | } | ||
13535 | |||
13536 | function DES(options) { | ||
13537 | Cipher.call(this, options); | ||
13538 | |||
13539 | var state = new DESState(); | ||
13540 | this._desState = state; | ||
13541 | |||
13542 | this.deriveKeys(state, options.key); | ||
13543 | } | ||
13544 | inherits(DES, Cipher); | ||
13545 | module.exports = DES; | ||
13546 | |||
13547 | DES.create = function create(options) { | ||
13548 | return new DES(options); | ||
13549 | }; | ||
13550 | |||
13551 | var shiftTable = [ | ||
13552 | 1, 1, 2, 2, 2, 2, 2, 2, | ||
13553 | 1, 2, 2, 2, 2, 2, 2, 1 | ||
13554 | ]; | ||
13555 | |||
13556 | DES.prototype.deriveKeys = function deriveKeys(state, key) { | ||
13557 | state.keys = new Array(16 * 2); | ||
13558 | |||
13559 | assert.equal(key.length, this.blockSize, 'Invalid key length'); | ||
13560 | |||
13561 | var kL = utils.readUInt32BE(key, 0); | ||
13562 | var kR = utils.readUInt32BE(key, 4); | ||
13563 | |||
13564 | utils.pc1(kL, kR, state.tmp, 0); | ||
13565 | kL = state.tmp[0]; | ||
13566 | kR = state.tmp[1]; | ||
13567 | for (var i = 0; i < state.keys.length; i += 2) { | ||
13568 | var shift = shiftTable[i >>> 1]; | ||
13569 | kL = utils.r28shl(kL, shift); | ||
13570 | kR = utils.r28shl(kR, shift); | ||
13571 | utils.pc2(kL, kR, state.keys, i); | ||
13572 | } | ||
13573 | }; | ||
13574 | |||
13575 | DES.prototype._update = function _update(inp, inOff, out, outOff) { | ||
13576 | var state = this._desState; | ||
13577 | |||
13578 | var l = utils.readUInt32BE(inp, inOff); | ||
13579 | var r = utils.readUInt32BE(inp, inOff + 4); | ||
13580 | |||
13581 | // Initial Permutation | ||
13582 | utils.ip(l, r, state.tmp, 0); | ||
13583 | l = state.tmp[0]; | ||
13584 | r = state.tmp[1]; | ||
13585 | |||
13586 | if (this.type === 'encrypt') | ||
13587 | this._encrypt(state, l, r, state.tmp, 0); | ||
13588 | else | ||
13589 | this._decrypt(state, l, r, state.tmp, 0); | ||
13590 | |||
13591 | l = state.tmp[0]; | ||
13592 | r = state.tmp[1]; | ||
13593 | |||
13594 | utils.writeUInt32BE(out, l, outOff); | ||
13595 | utils.writeUInt32BE(out, r, outOff + 4); | ||
13596 | }; | ||
13597 | |||
13598 | DES.prototype._pad = function _pad(buffer, off) { | ||
13599 | var value = buffer.length - off; | ||
13600 | for (var i = off; i < buffer.length; i++) | ||
13601 | buffer[i] = value; | ||
13602 | |||
13603 | return true; | ||
13604 | }; | ||
13605 | |||
13606 | DES.prototype._unpad = function _unpad(buffer) { | ||
13607 | var pad = buffer[buffer.length - 1]; | ||
13608 | for (var i = buffer.length - pad; i < buffer.length; i++) | ||
13609 | assert.equal(buffer[i], pad); | ||
13610 | |||
13611 | return buffer.slice(0, buffer.length - pad); | ||
13612 | }; | ||
13613 | |||
13614 | DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) { | ||
13615 | var l = lStart; | ||
13616 | var r = rStart; | ||
13617 | |||
13618 | // Apply f() x16 times | ||
13619 | for (var i = 0; i < state.keys.length; i += 2) { | ||
13620 | var keyL = state.keys[i]; | ||
13621 | var keyR = state.keys[i + 1]; | ||
13622 | |||
13623 | // f(r, k) | ||
13624 | utils.expand(r, state.tmp, 0); | ||
13625 | |||
13626 | keyL ^= state.tmp[0]; | ||
13627 | keyR ^= state.tmp[1]; | ||
13628 | var s = utils.substitute(keyL, keyR); | ||
13629 | var f = utils.permute(s); | ||
13630 | |||
13631 | var t = r; | ||
13632 | r = (l ^ f) >>> 0; | ||
13633 | l = t; | ||
13634 | } | ||
13635 | |||
13636 | // Reverse Initial Permutation | ||
13637 | utils.rip(r, l, out, off); | ||
13638 | }; | ||
13639 | |||
13640 | DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) { | ||
13641 | var l = rStart; | ||
13642 | var r = lStart; | ||
13643 | |||
13644 | // Apply f() x16 times | ||
13645 | for (var i = state.keys.length - 2; i >= 0; i -= 2) { | ||
13646 | var keyL = state.keys[i]; | ||
13647 | var keyR = state.keys[i + 1]; | ||
13648 | |||
13649 | // f(r, k) | ||
13650 | utils.expand(l, state.tmp, 0); | ||
13651 | |||
13652 | keyL ^= state.tmp[0]; | ||
13653 | keyR ^= state.tmp[1]; | ||
13654 | var s = utils.substitute(keyL, keyR); | ||
13655 | var f = utils.permute(s); | ||
13656 | |||
13657 | var t = l; | ||
13658 | l = (r ^ f) >>> 0; | ||
13659 | r = t; | ||
13660 | } | ||
13661 | |||
13662 | // Reverse Initial Permutation | ||
13663 | utils.rip(l, r, out, off); | ||
13664 | }; | ||
13665 | |||
13666 | },{"../des":73,"inherits":116,"minimalistic-assert":356}],77:[function(require,module,exports){ | ||
13667 | 'use strict'; | ||
13668 | |||
13669 | var assert = require('minimalistic-assert'); | ||
13670 | var inherits = require('inherits'); | ||
13671 | |||
13672 | var des = require('../des'); | ||
13673 | var Cipher = des.Cipher; | ||
13674 | var DES = des.DES; | ||
13675 | |||
13676 | function EDEState(type, key) { | ||
13677 | assert.equal(key.length, 24, 'Invalid key length'); | ||
13678 | |||
13679 | var k1 = key.slice(0, 8); | ||
13680 | var k2 = key.slice(8, 16); | ||
13681 | var k3 = key.slice(16, 24); | ||
13682 | |||
13683 | if (type === 'encrypt') { | ||
13684 | this.ciphers = [ | ||
13685 | DES.create({ type: 'encrypt', key: k1 }), | ||
13686 | DES.create({ type: 'decrypt', key: k2 }), | ||
13687 | DES.create({ type: 'encrypt', key: k3 }) | ||
13688 | ]; | ||
13689 | } else { | ||
13690 | this.ciphers = [ | ||
13691 | DES.create({ type: 'decrypt', key: k3 }), | ||
13692 | DES.create({ type: 'encrypt', key: k2 }), | ||
13693 | DES.create({ type: 'decrypt', key: k1 }) | ||
13694 | ]; | ||
13695 | } | ||
13696 | } | ||
13697 | |||
13698 | function EDE(options) { | ||
13699 | Cipher.call(this, options); | ||
13700 | |||
13701 | var state = new EDEState(this.type, this.options.key); | ||
13702 | this._edeState = state; | ||
13703 | } | ||
13704 | inherits(EDE, Cipher); | ||
13705 | |||
13706 | module.exports = EDE; | ||
13707 | |||
13708 | EDE.create = function create(options) { | ||
13709 | return new EDE(options); | ||
13710 | }; | ||
13711 | |||
13712 | EDE.prototype._update = function _update(inp, inOff, out, outOff) { | ||
13713 | var state = this._edeState; | ||
13714 | |||
13715 | state.ciphers[0]._update(inp, inOff, out, outOff); | ||
13716 | state.ciphers[1]._update(out, outOff, out, outOff); | ||
13717 | state.ciphers[2]._update(out, outOff, out, outOff); | ||
13718 | }; | ||
13719 | |||
13720 | EDE.prototype._pad = DES.prototype._pad; | ||
13721 | EDE.prototype._unpad = DES.prototype._unpad; | ||
13722 | |||
13723 | },{"../des":73,"inherits":116,"minimalistic-assert":356}],78:[function(require,module,exports){ | ||
13724 | 'use strict'; | ||
13725 | |||
13726 | exports.readUInt32BE = function readUInt32BE(bytes, off) { | ||
13727 | var res = (bytes[0 + off] << 24) | | ||
13728 | (bytes[1 + off] << 16) | | ||
13729 | (bytes[2 + off] << 8) | | ||
13730 | bytes[3 + off]; | ||
13731 | return res >>> 0; | ||
13732 | }; | ||
13733 | |||
13734 | exports.writeUInt32BE = function writeUInt32BE(bytes, value, off) { | ||
13735 | bytes[0 + off] = value >>> 24; | ||
13736 | bytes[1 + off] = (value >>> 16) & 0xff; | ||
13737 | bytes[2 + off] = (value >>> 8) & 0xff; | ||
13738 | bytes[3 + off] = value & 0xff; | ||
13739 | }; | ||
13740 | |||
13741 | exports.ip = function ip(inL, inR, out, off) { | ||
13742 | var outL = 0; | ||
13743 | var outR = 0; | ||
13744 | |||
13745 | for (var i = 6; i >= 0; i -= 2) { | ||
13746 | for (var j = 0; j <= 24; j += 8) { | ||
13747 | outL <<= 1; | ||
13748 | outL |= (inR >>> (j + i)) & 1; | ||
13749 | } | ||
13750 | for (var j = 0; j <= 24; j += 8) { | ||
13751 | outL <<= 1; | ||
13752 | outL |= (inL >>> (j + i)) & 1; | ||
13753 | } | ||
13754 | } | ||
13755 | |||
13756 | for (var i = 6; i >= 0; i -= 2) { | ||
13757 | for (var j = 1; j <= 25; j += 8) { | ||
13758 | outR <<= 1; | ||
13759 | outR |= (inR >>> (j + i)) & 1; | ||
13760 | } | ||
13761 | for (var j = 1; j <= 25; j += 8) { | ||
13762 | outR <<= 1; | ||
13763 | outR |= (inL >>> (j + i)) & 1; | ||
13764 | } | ||
13765 | } | ||
13766 | |||
13767 | out[off + 0] = outL >>> 0; | ||
13768 | out[off + 1] = outR >>> 0; | ||
13769 | }; | ||
13770 | |||
13771 | exports.rip = function rip(inL, inR, out, off) { | ||
13772 | var outL = 0; | ||
13773 | var outR = 0; | ||
13774 | |||
13775 | for (var i = 0; i < 4; i++) { | ||
13776 | for (var j = 24; j >= 0; j -= 8) { | ||
13777 | outL <<= 1; | ||
13778 | outL |= (inR >>> (j + i)) & 1; | ||
13779 | outL <<= 1; | ||
13780 | outL |= (inL >>> (j + i)) & 1; | ||
13781 | } | ||
13782 | } | ||
13783 | for (var i = 4; i < 8; i++) { | ||
13784 | for (var j = 24; j >= 0; j -= 8) { | ||
13785 | outR <<= 1; | ||
13786 | outR |= (inR >>> (j + i)) & 1; | ||
13787 | outR <<= 1; | ||
13788 | outR |= (inL >>> (j + i)) & 1; | ||
13789 | } | ||
13790 | } | ||
13791 | |||
13792 | out[off + 0] = outL >>> 0; | ||
13793 | out[off + 1] = outR >>> 0; | ||
13794 | }; | ||
13795 | |||
13796 | exports.pc1 = function pc1(inL, inR, out, off) { | ||
13797 | var outL = 0; | ||
13798 | var outR = 0; | ||
13799 | |||
13800 | // 7, 15, 23, 31, 39, 47, 55, 63 | ||
13801 | // 6, 14, 22, 30, 39, 47, 55, 63 | ||
13802 | // 5, 13, 21, 29, 39, 47, 55, 63 | ||
13803 | // 4, 12, 20, 28 | ||
13804 | for (var i = 7; i >= 5; i--) { | ||
13805 | for (var j = 0; j <= 24; j += 8) { | ||
13806 | outL <<= 1; | ||
13807 | outL |= (inR >> (j + i)) & 1; | ||
13808 | } | ||
13809 | for (var j = 0; j <= 24; j += 8) { | ||
13810 | outL <<= 1; | ||
13811 | outL |= (inL >> (j + i)) & 1; | ||
13812 | } | ||
13813 | } | ||
13814 | for (var j = 0; j <= 24; j += 8) { | ||
13815 | outL <<= 1; | ||
13816 | outL |= (inR >> (j + i)) & 1; | ||
13817 | } | ||
13818 | |||
13819 | // 1, 9, 17, 25, 33, 41, 49, 57 | ||
13820 | // 2, 10, 18, 26, 34, 42, 50, 58 | ||
13821 | // 3, 11, 19, 27, 35, 43, 51, 59 | ||
13822 | // 36, 44, 52, 60 | ||
13823 | for (var i = 1; i <= 3; i++) { | ||
13824 | for (var j = 0; j <= 24; j += 8) { | ||
13825 | outR <<= 1; | ||
13826 | outR |= (inR >> (j + i)) & 1; | ||
13827 | } | ||
13828 | for (var j = 0; j <= 24; j += 8) { | ||
13829 | outR <<= 1; | ||
13830 | outR |= (inL >> (j + i)) & 1; | ||
13831 | } | ||
13832 | } | ||
13833 | for (var j = 0; j <= 24; j += 8) { | ||
13834 | outR <<= 1; | ||
13835 | outR |= (inL >> (j + i)) & 1; | ||
13836 | } | ||
13837 | |||
13838 | out[off + 0] = outL >>> 0; | ||
13839 | out[off + 1] = outR >>> 0; | ||
13840 | }; | ||
13841 | |||
13842 | exports.r28shl = function r28shl(num, shift) { | ||
13843 | return ((num << shift) & 0xfffffff) | (num >>> (28 - shift)); | ||
13844 | }; | ||
13845 | |||
13846 | var pc2table = [ | ||
13847 | // inL => outL | ||
13848 | 14, 11, 17, 4, 27, 23, 25, 0, | ||
13849 | 13, 22, 7, 18, 5, 9, 16, 24, | ||
13850 | 2, 20, 12, 21, 1, 8, 15, 26, | ||
13851 | |||
13852 | // inR => outR | ||
13853 | 15, 4, 25, 19, 9, 1, 26, 16, | ||
13854 | 5, 11, 23, 8, 12, 7, 17, 0, | ||
13855 | 22, 3, 10, 14, 6, 20, 27, 24 | ||
13856 | ]; | ||
13857 | |||
13858 | exports.pc2 = function pc2(inL, inR, out, off) { | ||
13859 | var outL = 0; | ||
13860 | var outR = 0; | ||
13861 | |||
13862 | var len = pc2table.length >>> 1; | ||
13863 | for (var i = 0; i < len; i++) { | ||
13864 | outL <<= 1; | ||
13865 | outL |= (inL >>> pc2table[i]) & 0x1; | ||
13866 | } | ||
13867 | for (var i = len; i < pc2table.length; i++) { | ||
13868 | outR <<= 1; | ||
13869 | outR |= (inR >>> pc2table[i]) & 0x1; | ||
13870 | } | ||
13871 | |||
13872 | out[off + 0] = outL >>> 0; | ||
13873 | out[off + 1] = outR >>> 0; | ||
13874 | }; | ||
13875 | |||
13876 | exports.expand = function expand(r, out, off) { | ||
13877 | var outL = 0; | ||
13878 | var outR = 0; | ||
13879 | |||
13880 | outL = ((r & 1) << 5) | (r >>> 27); | ||
13881 | for (var i = 23; i >= 15; i -= 4) { | ||
13882 | outL <<= 6; | ||
13883 | outL |= (r >>> i) & 0x3f; | ||
13884 | } | ||
13885 | for (var i = 11; i >= 3; i -= 4) { | ||
13886 | outR |= (r >>> i) & 0x3f; | ||
13887 | outR <<= 6; | ||
13888 | } | ||
13889 | outR |= ((r & 0x1f) << 1) | (r >>> 31); | ||
13890 | |||
13891 | out[off + 0] = outL >>> 0; | ||
13892 | out[off + 1] = outR >>> 0; | ||
13893 | }; | ||
13894 | |||
13895 | var sTable = [ | ||
13896 | 14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1, | ||
13897 | 3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8, | ||
13898 | 4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7, | ||
13899 | 15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13, | ||
13900 | |||
13901 | 15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14, | ||
13902 | 9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5, | ||
13903 | 0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2, | ||
13904 | 5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9, | ||
13905 | |||
13906 | 10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10, | ||
13907 | 1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1, | ||
13908 | 13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7, | ||
13909 | 11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12, | ||
13910 | |||
13911 | 7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3, | ||
13912 | 1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9, | ||
13913 | 10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8, | ||
13914 | 15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14, | ||
13915 | |||
13916 | 2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1, | ||
13917 | 8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6, | ||
13918 | 4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13, | ||
13919 | 15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3, | ||
13920 | |||
13921 | 12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5, | ||
13922 | 0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8, | ||
13923 | 9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10, | ||
13924 | 7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13, | ||
13925 | |||
13926 | 4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10, | ||
13927 | 3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6, | ||
13928 | 1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7, | ||
13929 | 10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12, | ||
13930 | |||
13931 | 13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4, | ||
13932 | 10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2, | ||
13933 | 7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13, | ||
13934 | 0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11 | ||
13935 | ]; | ||
13936 | |||
13937 | exports.substitute = function substitute(inL, inR) { | ||
13938 | var out = 0; | ||
13939 | for (var i = 0; i < 4; i++) { | ||
13940 | var b = (inL >>> (18 - i * 6)) & 0x3f; | ||
13941 | var sb = sTable[i * 0x40 + b]; | ||
13942 | |||
13943 | out <<= 4; | ||
13944 | out |= sb; | ||
13945 | } | ||
13946 | for (var i = 0; i < 4; i++) { | ||
13947 | var b = (inR >>> (18 - i * 6)) & 0x3f; | ||
13948 | var sb = sTable[4 * 0x40 + i * 0x40 + b]; | ||
13949 | |||
13950 | out <<= 4; | ||
13951 | out |= sb; | ||
13952 | } | ||
13953 | return out >>> 0; | ||
13954 | }; | ||
13955 | |||
13956 | var permuteTable = [ | ||
13957 | 16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22, | ||
13958 | 30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7 | ||
13959 | ]; | ||
13960 | |||
13961 | exports.permute = function permute(num) { | ||
13962 | var out = 0; | ||
13963 | for (var i = 0; i < permuteTable.length; i++) { | ||
13964 | out <<= 1; | ||
13965 | out |= (num >>> permuteTable[i]) & 0x1; | ||
13966 | } | ||
13967 | return out >>> 0; | ||
13968 | }; | ||
13969 | |||
13970 | exports.padSplit = function padSplit(num, size, group) { | ||
13971 | var str = num.toString(2); | ||
13972 | while (str.length < size) | ||
13973 | str = '0' + str; | ||
13974 | |||
13975 | var out = []; | ||
13976 | for (var i = 0; i < size; i += group) | ||
13977 | out.push(str.slice(i, i + group)); | ||
13978 | return out.join(' '); | ||
13979 | }; | ||
13980 | |||
13981 | },{}],79:[function(require,module,exports){ | ||
13982 | (function (Buffer){ | ||
13983 | var generatePrime = require('./lib/generatePrime') | ||
13984 | var primes = require('./lib/primes.json') | ||
13985 | |||
13986 | var DH = require('./lib/dh') | ||
13987 | |||
13988 | function getDiffieHellman (mod) { | ||
13989 | var prime = new Buffer(primes[mod].prime, 'hex') | ||
13990 | var gen = new Buffer(primes[mod].gen, 'hex') | ||
13991 | |||
13992 | return new DH(prime, gen) | ||
13993 | } | ||
13994 | |||
13995 | var ENCODINGS = { | ||
13996 | 'binary': true, 'hex': true, 'base64': true | ||
13997 | } | ||
13998 | |||
13999 | function createDiffieHellman (prime, enc, generator, genc) { | ||
14000 | if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) { | ||
14001 | return createDiffieHellman(prime, 'binary', enc, generator) | ||
14002 | } | ||
14003 | |||
14004 | enc = enc || 'binary' | ||
14005 | genc = genc || 'binary' | ||
14006 | generator = generator || new Buffer([2]) | ||
14007 | |||
14008 | if (!Buffer.isBuffer(generator)) { | ||
14009 | generator = new Buffer(generator, genc) | ||
14010 | } | ||
14011 | |||
14012 | if (typeof prime === 'number') { | ||
14013 | return new DH(generatePrime(prime, generator), generator, true) | ||
14014 | } | ||
14015 | |||
14016 | if (!Buffer.isBuffer(prime)) { | ||
14017 | prime = new Buffer(prime, enc) | ||
14018 | } | ||
14019 | |||
14020 | return new DH(prime, generator, true) | ||
14021 | } | ||
14022 | |||
14023 | exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman | ||
14024 | exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman | ||
14025 | |||
14026 | }).call(this,require("buffer").Buffer) | ||
14027 | },{"./lib/dh":80,"./lib/generatePrime":81,"./lib/primes.json":82,"buffer":49}],80:[function(require,module,exports){ | ||
14028 | (function (Buffer){ | ||
14029 | var BN = require('bn.js'); | ||
14030 | var MillerRabin = require('miller-rabin'); | ||
14031 | var millerRabin = new MillerRabin(); | ||
14032 | var TWENTYFOUR = new BN(24); | ||
14033 | var ELEVEN = new BN(11); | ||
14034 | var TEN = new BN(10); | ||
14035 | var THREE = new BN(3); | ||
14036 | var SEVEN = new BN(7); | ||
14037 | var primes = require('./generatePrime'); | ||
14038 | var randomBytes = require('randombytes'); | ||
14039 | module.exports = DH; | ||
14040 | |||
14041 | function setPublicKey(pub, enc) { | ||
14042 | enc = enc || 'utf8'; | ||
14043 | if (!Buffer.isBuffer(pub)) { | ||
14044 | pub = new Buffer(pub, enc); | ||
14045 | } | ||
14046 | this._pub = new BN(pub); | ||
14047 | return this; | ||
14048 | } | ||
14049 | |||
14050 | function setPrivateKey(priv, enc) { | ||
14051 | enc = enc || 'utf8'; | ||
14052 | if (!Buffer.isBuffer(priv)) { | ||
14053 | priv = new Buffer(priv, enc); | ||
14054 | } | ||
14055 | this._priv = new BN(priv); | ||
14056 | return this; | ||
14057 | } | ||
14058 | |||
14059 | var primeCache = {}; | ||
14060 | function checkPrime(prime, generator) { | ||
14061 | var gen = generator.toString('hex'); | ||
14062 | var hex = [gen, prime.toString(16)].join('_'); | ||
14063 | if (hex in primeCache) { | ||
14064 | return primeCache[hex]; | ||
14065 | } | ||
14066 | var error = 0; | ||
14067 | |||
14068 | if (prime.isEven() || | ||
14069 | !primes.simpleSieve || | ||
14070 | !primes.fermatTest(prime) || | ||
14071 | !millerRabin.test(prime)) { | ||
14072 | //not a prime so +1 | ||
14073 | error += 1; | ||
14074 | |||
14075 | if (gen === '02' || gen === '05') { | ||
14076 | // we'd be able to check the generator | ||
14077 | // it would fail so +8 | ||
14078 | error += 8; | ||
14079 | } else { | ||
14080 | //we wouldn't be able to test the generator | ||
14081 | // so +4 | ||
14082 | error += 4; | ||
14083 | } | ||
14084 | primeCache[hex] = error; | ||
14085 | return error; | ||
14086 | } | ||
14087 | if (!millerRabin.test(prime.shrn(1))) { | ||
14088 | //not a safe prime | ||
14089 | error += 2; | ||
14090 | } | ||
14091 | var rem; | ||
14092 | switch (gen) { | ||
14093 | case '02': | ||
14094 | if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) { | ||
14095 | // unsuidable generator | ||
14096 | error += 8; | ||
14097 | } | ||
14098 | break; | ||
14099 | case '05': | ||
14100 | rem = prime.mod(TEN); | ||
14101 | if (rem.cmp(THREE) && rem.cmp(SEVEN)) { | ||
14102 | // prime mod 10 needs to equal 3 or 7 | ||
14103 | error += 8; | ||
14104 | } | ||
14105 | break; | ||
14106 | default: | ||
14107 | error += 4; | ||
14108 | } | ||
14109 | primeCache[hex] = error; | ||
14110 | return error; | ||
14111 | } | ||
14112 | |||
14113 | function DH(prime, generator, malleable) { | ||
14114 | this.setGenerator(generator); | ||
14115 | this.__prime = new BN(prime); | ||
14116 | this._prime = BN.mont(this.__prime); | ||
14117 | this._primeLen = prime.length; | ||
14118 | this._pub = undefined; | ||
14119 | this._priv = undefined; | ||
14120 | this._primeCode = undefined; | ||
14121 | if (malleable) { | ||
14122 | this.setPublicKey = setPublicKey; | ||
14123 | this.setPrivateKey = setPrivateKey; | ||
14124 | } else { | ||
14125 | this._primeCode = 8; | ||
14126 | } | ||
14127 | } | ||
14128 | Object.defineProperty(DH.prototype, 'verifyError', { | ||
14129 | enumerable: true, | ||
14130 | get: function () { | ||
14131 | if (typeof this._primeCode !== 'number') { | ||
14132 | this._primeCode = checkPrime(this.__prime, this.__gen); | ||
14133 | } | ||
14134 | return this._primeCode; | ||
14135 | } | ||
14136 | }); | ||
14137 | DH.prototype.generateKeys = function () { | ||
14138 | if (!this._priv) { | ||
14139 | this._priv = new BN(randomBytes(this._primeLen)); | ||
14140 | } | ||
14141 | this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed(); | ||
14142 | return this.getPublicKey(); | ||
14143 | }; | ||
14144 | |||
14145 | DH.prototype.computeSecret = function (other) { | ||
14146 | other = new BN(other); | ||
14147 | other = other.toRed(this._prime); | ||
14148 | var secret = other.redPow(this._priv).fromRed(); | ||
14149 | var out = new Buffer(secret.toArray()); | ||
14150 | var prime = this.getPrime(); | ||
14151 | if (out.length < prime.length) { | ||
14152 | var front = new Buffer(prime.length - out.length); | ||
14153 | front.fill(0); | ||
14154 | out = Buffer.concat([front, out]); | ||
14155 | } | ||
14156 | return out; | ||
14157 | }; | ||
14158 | |||
14159 | DH.prototype.getPublicKey = function getPublicKey(enc) { | ||
14160 | return formatReturnValue(this._pub, enc); | ||
14161 | }; | ||
14162 | |||
14163 | DH.prototype.getPrivateKey = function getPrivateKey(enc) { | ||
14164 | return formatReturnValue(this._priv, enc); | ||
14165 | }; | ||
14166 | |||
14167 | DH.prototype.getPrime = function (enc) { | ||
14168 | return formatReturnValue(this.__prime, enc); | ||
14169 | }; | ||
14170 | |||
14171 | DH.prototype.getGenerator = function (enc) { | ||
14172 | return formatReturnValue(this._gen, enc); | ||
14173 | }; | ||
14174 | |||
14175 | DH.prototype.setGenerator = function (gen, enc) { | ||
14176 | enc = enc || 'utf8'; | ||
14177 | if (!Buffer.isBuffer(gen)) { | ||
14178 | gen = new Buffer(gen, enc); | ||
14179 | } | ||
14180 | this.__gen = gen; | ||
14181 | this._gen = new BN(gen); | ||
14182 | return this; | ||
14183 | }; | ||
14184 | |||
14185 | function formatReturnValue(bn, enc) { | ||
14186 | var buf = new Buffer(bn.toArray()); | ||
14187 | if (!enc) { | ||
14188 | return buf; | ||
14189 | } else { | ||
14190 | return buf.toString(enc); | ||
14191 | } | ||
14192 | } | ||
14193 | |||
14194 | }).call(this,require("buffer").Buffer) | ||
14195 | },{"./generatePrime":81,"bn.js":18,"buffer":49,"miller-rabin":355,"randombytes":376}],81:[function(require,module,exports){ | ||
14196 | var randomBytes = require('randombytes'); | ||
14197 | module.exports = findPrime; | ||
14198 | findPrime.simpleSieve = simpleSieve; | ||
14199 | findPrime.fermatTest = fermatTest; | ||
14200 | var BN = require('bn.js'); | ||
14201 | var TWENTYFOUR = new BN(24); | ||
14202 | var MillerRabin = require('miller-rabin'); | ||
14203 | var millerRabin = new MillerRabin(); | ||
14204 | var ONE = new BN(1); | ||
14205 | var TWO = new BN(2); | ||
14206 | var FIVE = new BN(5); | ||
14207 | var SIXTEEN = new BN(16); | ||
14208 | var EIGHT = new BN(8); | ||
14209 | var TEN = new BN(10); | ||
14210 | var THREE = new BN(3); | ||
14211 | var SEVEN = new BN(7); | ||
14212 | var ELEVEN = new BN(11); | ||
14213 | var FOUR = new BN(4); | ||
14214 | var TWELVE = new BN(12); | ||
14215 | var primes = null; | ||
14216 | |||
14217 | function _getPrimes() { | ||
14218 | if (primes !== null) | ||
14219 | return primes; | ||
14220 | |||
14221 | var limit = 0x100000; | ||
14222 | var res = []; | ||
14223 | res[0] = 2; | ||
14224 | for (var i = 1, k = 3; k < limit; k += 2) { | ||
14225 | var sqrt = Math.ceil(Math.sqrt(k)); | ||
14226 | for (var j = 0; j < i && res[j] <= sqrt; j++) | ||
14227 | if (k % res[j] === 0) | ||
14228 | break; | ||
14229 | |||
14230 | if (i !== j && res[j] <= sqrt) | ||
14231 | continue; | ||
14232 | |||
14233 | res[i++] = k; | ||
14234 | } | ||
14235 | primes = res; | ||
14236 | return res; | ||
14237 | } | ||
14238 | |||
14239 | function simpleSieve(p) { | ||
14240 | var primes = _getPrimes(); | ||
14241 | |||
14242 | for (var i = 0; i < primes.length; i++) | ||
14243 | if (p.modn(primes[i]) === 0) { | ||
14244 | if (p.cmpn(primes[i]) === 0) { | ||
14245 | return true; | ||
14246 | } else { | ||
14247 | return false; | ||
14248 | } | ||
14249 | } | ||
14250 | |||
14251 | return true; | ||
14252 | } | ||
14253 | |||
14254 | function fermatTest(p) { | ||
14255 | var red = BN.mont(p); | ||
14256 | return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0; | ||
14257 | } | ||
14258 | |||
14259 | function findPrime(bits, gen) { | ||
14260 | if (bits < 16) { | ||
14261 | // this is what openssl does | ||
14262 | if (gen === 2 || gen === 5) { | ||
14263 | return new BN([0x8c, 0x7b]); | ||
14264 | } else { | ||
14265 | return new BN([0x8c, 0x27]); | ||
14266 | } | ||
14267 | } | ||
14268 | gen = new BN(gen); | ||
14269 | |||
14270 | var num, n2; | ||
14271 | |||
14272 | while (true) { | ||
14273 | num = new BN(randomBytes(Math.ceil(bits / 8))); | ||
14274 | while (num.bitLength() > bits) { | ||
14275 | num.ishrn(1); | ||
14276 | } | ||
14277 | if (num.isEven()) { | ||
14278 | num.iadd(ONE); | ||
14279 | } | ||
14280 | if (!num.testn(1)) { | ||
14281 | num.iadd(TWO); | ||
14282 | } | ||
14283 | if (!gen.cmp(TWO)) { | ||
14284 | while (num.mod(TWENTYFOUR).cmp(ELEVEN)) { | ||
14285 | num.iadd(FOUR); | ||
14286 | } | ||
14287 | } else if (!gen.cmp(FIVE)) { | ||
14288 | while (num.mod(TEN).cmp(THREE)) { | ||
14289 | num.iadd(FOUR); | ||
14290 | } | ||
14291 | } | ||
14292 | n2 = num.shrn(1); | ||
14293 | if (simpleSieve(n2) && simpleSieve(num) && | ||
14294 | fermatTest(n2) && fermatTest(num) && | ||
14295 | millerRabin.test(n2) && millerRabin.test(num)) { | ||
14296 | return num; | ||
14297 | } | ||
14298 | } | ||
14299 | |||
14300 | } | ||
14301 | |||
14302 | },{"bn.js":18,"miller-rabin":355,"randombytes":376}],82:[function(require,module,exports){ | ||
14303 | module.exports={ | ||
14304 | "modp1": { | ||
14305 | "gen": "02", | ||
14306 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff" | ||
14307 | }, | ||
14308 | "modp2": { | ||
14309 | "gen": "02", | ||
14310 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff" | ||
14311 | }, | ||
14312 | "modp5": { | ||
14313 | "gen": "02", | ||
14314 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff" | ||
14315 | }, | ||
14316 | "modp14": { | ||
14317 | "gen": "02", | ||
14318 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff" | ||
14319 | }, | ||
14320 | "modp15": { | ||
14321 | "gen": "02", | ||
14322 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff" | ||
14323 | }, | ||
14324 | "modp16": { | ||
14325 | "gen": "02", | ||
14326 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff" | ||
14327 | }, | ||
14328 | "modp17": { | ||
14329 | "gen": "02", | ||
14330 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff" | ||
14331 | }, | ||
14332 | "modp18": { | ||
14333 | "gen": "02", | ||
14334 | "prime": "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" | ||
14335 | } | ||
14336 | } | ||
14337 | },{}],83:[function(require,module,exports){ | ||
14338 | 'use strict'; | ||
14339 | |||
14340 | var elliptic = exports; | ||
14341 | |||
14342 | elliptic.version = require('../package.json').version; | ||
14343 | elliptic.utils = require('./elliptic/utils'); | ||
14344 | elliptic.rand = require('brorand'); | ||
14345 | elliptic.curve = require('./elliptic/curve'); | ||
14346 | elliptic.curves = require('./elliptic/curves'); | ||
14347 | |||
14348 | // Protocols | ||
14349 | elliptic.ec = require('./elliptic/ec'); | ||
14350 | elliptic.eddsa = require('./elliptic/eddsa'); | ||
14351 | |||
14352 | },{"../package.json":98,"./elliptic/curve":86,"./elliptic/curves":89,"./elliptic/ec":90,"./elliptic/eddsa":93,"./elliptic/utils":97,"brorand":19}],84:[function(require,module,exports){ | ||
14353 | 'use strict'; | ||
14354 | |||
14355 | var BN = require('bn.js'); | ||
14356 | var elliptic = require('../../elliptic'); | ||
14357 | var utils = elliptic.utils; | ||
14358 | var getNAF = utils.getNAF; | ||
14359 | var getJSF = utils.getJSF; | ||
14360 | var assert = utils.assert; | ||
14361 | |||
14362 | function BaseCurve(type, conf) { | ||
14363 | this.type = type; | ||
14364 | this.p = new BN(conf.p, 16); | ||
14365 | |||
14366 | // Use Montgomery, when there is no fast reduction for the prime | ||
14367 | this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p); | ||
14368 | |||
14369 | // Useful for many curves | ||
14370 | this.zero = new BN(0).toRed(this.red); | ||
14371 | this.one = new BN(1).toRed(this.red); | ||
14372 | this.two = new BN(2).toRed(this.red); | ||
14373 | |||
14374 | // Curve configuration, optional | ||
14375 | this.n = conf.n && new BN(conf.n, 16); | ||
14376 | this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed); | ||
14377 | |||
14378 | // Temporary arrays | ||
14379 | this._wnafT1 = new Array(4); | ||
14380 | this._wnafT2 = new Array(4); | ||
14381 | this._wnafT3 = new Array(4); | ||
14382 | this._wnafT4 = new Array(4); | ||
14383 | |||
14384 | // Generalized Greg Maxwell's trick | ||
14385 | var adjustCount = this.n && this.p.div(this.n); | ||
14386 | if (!adjustCount || adjustCount.cmpn(100) > 0) { | ||
14387 | this.redN = null; | ||
14388 | } else { | ||
14389 | this._maxwellTrick = true; | ||
14390 | this.redN = this.n.toRed(this.red); | ||
14391 | } | ||
14392 | } | ||
14393 | module.exports = BaseCurve; | ||
14394 | |||
14395 | BaseCurve.prototype.point = function point() { | ||
14396 | throw new Error('Not implemented'); | ||
14397 | }; | ||
14398 | |||
14399 | BaseCurve.prototype.validate = function validate() { | ||
14400 | throw new Error('Not implemented'); | ||
14401 | }; | ||
14402 | |||
14403 | BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) { | ||
14404 | assert(p.precomputed); | ||
14405 | var doubles = p._getDoubles(); | ||
14406 | |||
14407 | var naf = getNAF(k, 1); | ||
14408 | var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1); | ||
14409 | I /= 3; | ||
14410 | |||
14411 | // Translate into more windowed form | ||
14412 | var repr = []; | ||
14413 | for (var j = 0; j < naf.length; j += doubles.step) { | ||
14414 | var nafW = 0; | ||
14415 | for (var k = j + doubles.step - 1; k >= j; k--) | ||
14416 | nafW = (nafW << 1) + naf[k]; | ||
14417 | repr.push(nafW); | ||
14418 | } | ||
14419 | |||
14420 | var a = this.jpoint(null, null, null); | ||
14421 | var b = this.jpoint(null, null, null); | ||
14422 | for (var i = I; i > 0; i--) { | ||
14423 | for (var j = 0; j < repr.length; j++) { | ||
14424 | var nafW = repr[j]; | ||
14425 | if (nafW === i) | ||
14426 | b = b.mixedAdd(doubles.points[j]); | ||
14427 | else if (nafW === -i) | ||
14428 | b = b.mixedAdd(doubles.points[j].neg()); | ||
14429 | } | ||
14430 | a = a.add(b); | ||
14431 | } | ||
14432 | return a.toP(); | ||
14433 | }; | ||
14434 | |||
14435 | BaseCurve.prototype._wnafMul = function _wnafMul(p, k) { | ||
14436 | var w = 4; | ||
14437 | |||
14438 | // Precompute window | ||
14439 | var nafPoints = p._getNAFPoints(w); | ||
14440 | w = nafPoints.wnd; | ||
14441 | var wnd = nafPoints.points; | ||
14442 | |||
14443 | // Get NAF form | ||
14444 | var naf = getNAF(k, w); | ||
14445 | |||
14446 | // Add `this`*(N+1) for every w-NAF index | ||
14447 | var acc = this.jpoint(null, null, null); | ||
14448 | for (var i = naf.length - 1; i >= 0; i--) { | ||
14449 | // Count zeroes | ||
14450 | for (var k = 0; i >= 0 && naf[i] === 0; i--) | ||
14451 | k++; | ||
14452 | if (i >= 0) | ||
14453 | k++; | ||
14454 | acc = acc.dblp(k); | ||
14455 | |||
14456 | if (i < 0) | ||
14457 | break; | ||
14458 | var z = naf[i]; | ||
14459 | assert(z !== 0); | ||
14460 | if (p.type === 'affine') { | ||
14461 | // J +- P | ||
14462 | if (z > 0) | ||
14463 | acc = acc.mixedAdd(wnd[(z - 1) >> 1]); | ||
14464 | else | ||
14465 | acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg()); | ||
14466 | } else { | ||
14467 | // J +- J | ||
14468 | if (z > 0) | ||
14469 | acc = acc.add(wnd[(z - 1) >> 1]); | ||
14470 | else | ||
14471 | acc = acc.add(wnd[(-z - 1) >> 1].neg()); | ||
14472 | } | ||
14473 | } | ||
14474 | return p.type === 'affine' ? acc.toP() : acc; | ||
14475 | }; | ||
14476 | |||
14477 | BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, | ||
14478 | points, | ||
14479 | coeffs, | ||
14480 | len, | ||
14481 | jacobianResult) { | ||
14482 | var wndWidth = this._wnafT1; | ||
14483 | var wnd = this._wnafT2; | ||
14484 | var naf = this._wnafT3; | ||
14485 | |||
14486 | // Fill all arrays | ||
14487 | var max = 0; | ||
14488 | for (var i = 0; i < len; i++) { | ||
14489 | var p = points[i]; | ||
14490 | var nafPoints = p._getNAFPoints(defW); | ||
14491 | wndWidth[i] = nafPoints.wnd; | ||
14492 | wnd[i] = nafPoints.points; | ||
14493 | } | ||
14494 | |||
14495 | // Comb small window NAFs | ||
14496 | for (var i = len - 1; i >= 1; i -= 2) { | ||
14497 | var a = i - 1; | ||
14498 | var b = i; | ||
14499 | if (wndWidth[a] !== 1 || wndWidth[b] !== 1) { | ||
14500 | naf[a] = getNAF(coeffs[a], wndWidth[a]); | ||
14501 | naf[b] = getNAF(coeffs[b], wndWidth[b]); | ||
14502 | max = Math.max(naf[a].length, max); | ||
14503 | max = Math.max(naf[b].length, max); | ||
14504 | continue; | ||
14505 | } | ||
14506 | |||
14507 | var comb = [ | ||
14508 | points[a], /* 1 */ | ||
14509 | null, /* 3 */ | ||
14510 | null, /* 5 */ | ||
14511 | points[b] /* 7 */ | ||
14512 | ]; | ||
14513 | |||
14514 | // Try to avoid Projective points, if possible | ||
14515 | if (points[a].y.cmp(points[b].y) === 0) { | ||
14516 | comb[1] = points[a].add(points[b]); | ||
14517 | comb[2] = points[a].toJ().mixedAdd(points[b].neg()); | ||
14518 | } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) { | ||
14519 | comb[1] = points[a].toJ().mixedAdd(points[b]); | ||
14520 | comb[2] = points[a].add(points[b].neg()); | ||
14521 | } else { | ||
14522 | comb[1] = points[a].toJ().mixedAdd(points[b]); | ||
14523 | comb[2] = points[a].toJ().mixedAdd(points[b].neg()); | ||
14524 | } | ||
14525 | |||
14526 | var index = [ | ||
14527 | -3, /* -1 -1 */ | ||
14528 | -1, /* -1 0 */ | ||
14529 | -5, /* -1 1 */ | ||
14530 | -7, /* 0 -1 */ | ||
14531 | 0, /* 0 0 */ | ||
14532 | 7, /* 0 1 */ | ||
14533 | 5, /* 1 -1 */ | ||
14534 | 1, /* 1 0 */ | ||
14535 | 3 /* 1 1 */ | ||
14536 | ]; | ||
14537 | |||
14538 | var jsf = getJSF(coeffs[a], coeffs[b]); | ||
14539 | max = Math.max(jsf[0].length, max); | ||
14540 | naf[a] = new Array(max); | ||
14541 | naf[b] = new Array(max); | ||
14542 | for (var j = 0; j < max; j++) { | ||
14543 | var ja = jsf[0][j] | 0; | ||
14544 | var jb = jsf[1][j] | 0; | ||
14545 | |||
14546 | naf[a][j] = index[(ja + 1) * 3 + (jb + 1)]; | ||
14547 | naf[b][j] = 0; | ||
14548 | wnd[a] = comb; | ||
14549 | } | ||
14550 | } | ||
14551 | |||
14552 | var acc = this.jpoint(null, null, null); | ||
14553 | var tmp = this._wnafT4; | ||
14554 | for (var i = max; i >= 0; i--) { | ||
14555 | var k = 0; | ||
14556 | |||
14557 | while (i >= 0) { | ||
14558 | var zero = true; | ||
14559 | for (var j = 0; j < len; j++) { | ||
14560 | tmp[j] = naf[j][i] | 0; | ||
14561 | if (tmp[j] !== 0) | ||
14562 | zero = false; | ||
14563 | } | ||
14564 | if (!zero) | ||
14565 | break; | ||
14566 | k++; | ||
14567 | i--; | ||
14568 | } | ||
14569 | if (i >= 0) | ||
14570 | k++; | ||
14571 | acc = acc.dblp(k); | ||
14572 | if (i < 0) | ||
14573 | break; | ||
14574 | |||
14575 | for (var j = 0; j < len; j++) { | ||
14576 | var z = tmp[j]; | ||
14577 | var p; | ||
14578 | if (z === 0) | ||
14579 | continue; | ||
14580 | else if (z > 0) | ||
14581 | p = wnd[j][(z - 1) >> 1]; | ||
14582 | else if (z < 0) | ||
14583 | p = wnd[j][(-z - 1) >> 1].neg(); | ||
14584 | |||
14585 | if (p.type === 'affine') | ||
14586 | acc = acc.mixedAdd(p); | ||
14587 | else | ||
14588 | acc = acc.add(p); | ||
14589 | } | ||
14590 | } | ||
14591 | // Zeroify references | ||
14592 | for (var i = 0; i < len; i++) | ||
14593 | wnd[i] = null; | ||
14594 | |||
14595 | if (jacobianResult) | ||
14596 | return acc; | ||
14597 | else | ||
14598 | return acc.toP(); | ||
14599 | }; | ||
14600 | |||
14601 | function BasePoint(curve, type) { | ||
14602 | this.curve = curve; | ||
14603 | this.type = type; | ||
14604 | this.precomputed = null; | ||
14605 | } | ||
14606 | BaseCurve.BasePoint = BasePoint; | ||
14607 | |||
14608 | BasePoint.prototype.eq = function eq(/*other*/) { | ||
14609 | throw new Error('Not implemented'); | ||
14610 | }; | ||
14611 | |||
14612 | BasePoint.prototype.validate = function validate() { | ||
14613 | return this.curve.validate(this); | ||
14614 | }; | ||
14615 | |||
14616 | BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) { | ||
14617 | bytes = utils.toArray(bytes, enc); | ||
14618 | |||
14619 | var len = this.p.byteLength(); | ||
14620 | |||
14621 | // uncompressed, hybrid-odd, hybrid-even | ||
14622 | if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) && | ||
14623 | bytes.length - 1 === 2 * len) { | ||
14624 | if (bytes[0] === 0x06) | ||
14625 | assert(bytes[bytes.length - 1] % 2 === 0); | ||
14626 | else if (bytes[0] === 0x07) | ||
14627 | assert(bytes[bytes.length - 1] % 2 === 1); | ||
14628 | |||
14629 | var res = this.point(bytes.slice(1, 1 + len), | ||
14630 | bytes.slice(1 + len, 1 + 2 * len)); | ||
14631 | |||
14632 | return res; | ||
14633 | } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) && | ||
14634 | bytes.length - 1 === len) { | ||
14635 | return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03); | ||
14636 | } | ||
14637 | throw new Error('Unknown point format'); | ||
14638 | }; | ||
14639 | |||
14640 | BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) { | ||
14641 | return this.encode(enc, true); | ||
14642 | }; | ||
14643 | |||
14644 | BasePoint.prototype._encode = function _encode(compact) { | ||
14645 | var len = this.curve.p.byteLength(); | ||
14646 | var x = this.getX().toArray('be', len); | ||
14647 | |||
14648 | if (compact) | ||
14649 | return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x); | ||
14650 | |||
14651 | return [ 0x04 ].concat(x, this.getY().toArray('be', len)) ; | ||
14652 | }; | ||
14653 | |||
14654 | BasePoint.prototype.encode = function encode(enc, compact) { | ||
14655 | return utils.encode(this._encode(compact), enc); | ||
14656 | }; | ||
14657 | |||
14658 | BasePoint.prototype.precompute = function precompute(power) { | ||
14659 | if (this.precomputed) | ||
14660 | return this; | ||
14661 | |||
14662 | var precomputed = { | ||
14663 | doubles: null, | ||
14664 | naf: null, | ||
14665 | beta: null | ||
14666 | }; | ||
14667 | precomputed.naf = this._getNAFPoints(8); | ||
14668 | precomputed.doubles = this._getDoubles(4, power); | ||
14669 | precomputed.beta = this._getBeta(); | ||
14670 | this.precomputed = precomputed; | ||
14671 | |||
14672 | return this; | ||
14673 | }; | ||
14674 | |||
14675 | BasePoint.prototype._hasDoubles = function _hasDoubles(k) { | ||
14676 | if (!this.precomputed) | ||
14677 | return false; | ||
14678 | |||
14679 | var doubles = this.precomputed.doubles; | ||
14680 | if (!doubles) | ||
14681 | return false; | ||
14682 | |||
14683 | return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step); | ||
14684 | }; | ||
14685 | |||
14686 | BasePoint.prototype._getDoubles = function _getDoubles(step, power) { | ||
14687 | if (this.precomputed && this.precomputed.doubles) | ||
14688 | return this.precomputed.doubles; | ||
14689 | |||
14690 | var doubles = [ this ]; | ||
14691 | var acc = this; | ||
14692 | for (var i = 0; i < power; i += step) { | ||
14693 | for (var j = 0; j < step; j++) | ||
14694 | acc = acc.dbl(); | ||
14695 | doubles.push(acc); | ||
14696 | } | ||
14697 | return { | ||
14698 | step: step, | ||
14699 | points: doubles | ||
14700 | }; | ||
14701 | }; | ||
14702 | |||
14703 | BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) { | ||
14704 | if (this.precomputed && this.precomputed.naf) | ||
14705 | return this.precomputed.naf; | ||
14706 | |||
14707 | var res = [ this ]; | ||
14708 | var max = (1 << wnd) - 1; | ||
14709 | var dbl = max === 1 ? null : this.dbl(); | ||
14710 | for (var i = 1; i < max; i++) | ||
14711 | res[i] = res[i - 1].add(dbl); | ||
14712 | return { | ||
14713 | wnd: wnd, | ||
14714 | points: res | ||
14715 | }; | ||
14716 | }; | ||
14717 | |||
14718 | BasePoint.prototype._getBeta = function _getBeta() { | ||
14719 | return null; | ||
14720 | }; | ||
14721 | |||
14722 | BasePoint.prototype.dblp = function dblp(k) { | ||
14723 | var r = this; | ||
14724 | for (var i = 0; i < k; i++) | ||
14725 | r = r.dbl(); | ||
14726 | return r; | ||
14727 | }; | ||
14728 | |||
14729 | },{"../../elliptic":83,"bn.js":18}],85:[function(require,module,exports){ | ||
14730 | 'use strict'; | ||
14731 | |||
14732 | var curve = require('../curve'); | ||
14733 | var elliptic = require('../../elliptic'); | ||
14734 | var BN = require('bn.js'); | ||
14735 | var inherits = require('inherits'); | ||
14736 | var Base = curve.base; | ||
14737 | |||
14738 | var assert = elliptic.utils.assert; | ||
14739 | |||
14740 | function EdwardsCurve(conf) { | ||
14741 | // NOTE: Important as we are creating point in Base.call() | ||
14742 | this.twisted = (conf.a | 0) !== 1; | ||
14743 | this.mOneA = this.twisted && (conf.a | 0) === -1; | ||
14744 | this.extended = this.mOneA; | ||
14745 | |||
14746 | Base.call(this, 'edwards', conf); | ||
14747 | |||
14748 | this.a = new BN(conf.a, 16).umod(this.red.m); | ||
14749 | this.a = this.a.toRed(this.red); | ||
14750 | this.c = new BN(conf.c, 16).toRed(this.red); | ||
14751 | this.c2 = this.c.redSqr(); | ||
14752 | this.d = new BN(conf.d, 16).toRed(this.red); | ||
14753 | this.dd = this.d.redAdd(this.d); | ||
14754 | |||
14755 | assert(!this.twisted || this.c.fromRed().cmpn(1) === 0); | ||
14756 | this.oneC = (conf.c | 0) === 1; | ||
14757 | } | ||
14758 | inherits(EdwardsCurve, Base); | ||
14759 | module.exports = EdwardsCurve; | ||
14760 | |||
14761 | EdwardsCurve.prototype._mulA = function _mulA(num) { | ||
14762 | if (this.mOneA) | ||
14763 | return num.redNeg(); | ||
14764 | else | ||
14765 | return this.a.redMul(num); | ||
14766 | }; | ||
14767 | |||
14768 | EdwardsCurve.prototype._mulC = function _mulC(num) { | ||
14769 | if (this.oneC) | ||
14770 | return num; | ||
14771 | else | ||
14772 | return this.c.redMul(num); | ||
14773 | }; | ||
14774 | |||
14775 | // Just for compatibility with Short curve | ||
14776 | EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) { | ||
14777 | return this.point(x, y, z, t); | ||
14778 | }; | ||
14779 | |||
14780 | EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) { | ||
14781 | x = new BN(x, 16); | ||
14782 | if (!x.red) | ||
14783 | x = x.toRed(this.red); | ||
14784 | |||
14785 | var x2 = x.redSqr(); | ||
14786 | var rhs = this.c2.redSub(this.a.redMul(x2)); | ||
14787 | var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2)); | ||
14788 | |||
14789 | var y2 = rhs.redMul(lhs.redInvm()); | ||
14790 | var y = y2.redSqrt(); | ||
14791 | if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) | ||
14792 | throw new Error('invalid point'); | ||
14793 | |||
14794 | var isOdd = y.fromRed().isOdd(); | ||
14795 | if (odd && !isOdd || !odd && isOdd) | ||
14796 | y = y.redNeg(); | ||
14797 | |||
14798 | return this.point(x, y); | ||
14799 | }; | ||
14800 | |||
14801 | EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) { | ||
14802 | y = new BN(y, 16); | ||
14803 | if (!y.red) | ||
14804 | y = y.toRed(this.red); | ||
14805 | |||
14806 | // x^2 = (y^2 - c^2) / (c^2 d y^2 - a) | ||
14807 | var y2 = y.redSqr(); | ||
14808 | var lhs = y2.redSub(this.c2); | ||
14809 | var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a); | ||
14810 | var x2 = lhs.redMul(rhs.redInvm()); | ||
14811 | |||
14812 | if (x2.cmp(this.zero) === 0) { | ||
14813 | if (odd) | ||
14814 | throw new Error('invalid point'); | ||
14815 | else | ||
14816 | return this.point(this.zero, y); | ||
14817 | } | ||
14818 | |||
14819 | var x = x2.redSqrt(); | ||
14820 | if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) | ||
14821 | throw new Error('invalid point'); | ||
14822 | |||
14823 | if (x.fromRed().isOdd() !== odd) | ||
14824 | x = x.redNeg(); | ||
14825 | |||
14826 | return this.point(x, y); | ||
14827 | }; | ||
14828 | |||
14829 | EdwardsCurve.prototype.validate = function validate(point) { | ||
14830 | if (point.isInfinity()) | ||
14831 | return true; | ||
14832 | |||
14833 | // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2) | ||
14834 | point.normalize(); | ||
14835 | |||
14836 | var x2 = point.x.redSqr(); | ||
14837 | var y2 = point.y.redSqr(); | ||
14838 | var lhs = x2.redMul(this.a).redAdd(y2); | ||
14839 | var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2))); | ||
14840 | |||
14841 | return lhs.cmp(rhs) === 0; | ||
14842 | }; | ||
14843 | |||
14844 | function Point(curve, x, y, z, t) { | ||
14845 | Base.BasePoint.call(this, curve, 'projective'); | ||
14846 | if (x === null && y === null && z === null) { | ||
14847 | this.x = this.curve.zero; | ||
14848 | this.y = this.curve.one; | ||
14849 | this.z = this.curve.one; | ||
14850 | this.t = this.curve.zero; | ||
14851 | this.zOne = true; | ||
14852 | } else { | ||
14853 | this.x = new BN(x, 16); | ||
14854 | this.y = new BN(y, 16); | ||
14855 | this.z = z ? new BN(z, 16) : this.curve.one; | ||
14856 | this.t = t && new BN(t, 16); | ||
14857 | if (!this.x.red) | ||
14858 | this.x = this.x.toRed(this.curve.red); | ||
14859 | if (!this.y.red) | ||
14860 | this.y = this.y.toRed(this.curve.red); | ||
14861 | if (!this.z.red) | ||
14862 | this.z = this.z.toRed(this.curve.red); | ||
14863 | if (this.t && !this.t.red) | ||
14864 | this.t = this.t.toRed(this.curve.red); | ||
14865 | this.zOne = this.z === this.curve.one; | ||
14866 | |||
14867 | // Use extended coordinates | ||
14868 | if (this.curve.extended && !this.t) { | ||
14869 | this.t = this.x.redMul(this.y); | ||
14870 | if (!this.zOne) | ||
14871 | this.t = this.t.redMul(this.z.redInvm()); | ||
14872 | } | ||
14873 | } | ||
14874 | } | ||
14875 | inherits(Point, Base.BasePoint); | ||
14876 | |||
14877 | EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) { | ||
14878 | return Point.fromJSON(this, obj); | ||
14879 | }; | ||
14880 | |||
14881 | EdwardsCurve.prototype.point = function point(x, y, z, t) { | ||
14882 | return new Point(this, x, y, z, t); | ||
14883 | }; | ||
14884 | |||
14885 | Point.fromJSON = function fromJSON(curve, obj) { | ||
14886 | return new Point(curve, obj[0], obj[1], obj[2]); | ||
14887 | }; | ||
14888 | |||
14889 | Point.prototype.inspect = function inspect() { | ||
14890 | if (this.isInfinity()) | ||
14891 | return '<EC Point Infinity>'; | ||
14892 | return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + | ||
14893 | ' y: ' + this.y.fromRed().toString(16, 2) + | ||
14894 | ' z: ' + this.z.fromRed().toString(16, 2) + '>'; | ||
14895 | }; | ||
14896 | |||
14897 | Point.prototype.isInfinity = function isInfinity() { | ||
14898 | // XXX This code assumes that zero is always zero in red | ||
14899 | return this.x.cmpn(0) === 0 && | ||
14900 | (this.y.cmp(this.z) === 0 || | ||
14901 | (this.zOne && this.y.cmp(this.curve.c) === 0)); | ||
14902 | }; | ||
14903 | |||
14904 | Point.prototype._extDbl = function _extDbl() { | ||
14905 | // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html | ||
14906 | // #doubling-dbl-2008-hwcd | ||
14907 | // 4M + 4S | ||
14908 | |||
14909 | // A = X1^2 | ||
14910 | var a = this.x.redSqr(); | ||
14911 | // B = Y1^2 | ||
14912 | var b = this.y.redSqr(); | ||
14913 | // C = 2 * Z1^2 | ||
14914 | var c = this.z.redSqr(); | ||
14915 | c = c.redIAdd(c); | ||
14916 | // D = a * A | ||
14917 | var d = this.curve._mulA(a); | ||
14918 | // E = (X1 + Y1)^2 - A - B | ||
14919 | var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b); | ||
14920 | // G = D + B | ||
14921 | var g = d.redAdd(b); | ||
14922 | // F = G - C | ||
14923 | var f = g.redSub(c); | ||
14924 | // H = D - B | ||
14925 | var h = d.redSub(b); | ||
14926 | // X3 = E * F | ||
14927 | var nx = e.redMul(f); | ||
14928 | // Y3 = G * H | ||
14929 | var ny = g.redMul(h); | ||
14930 | // T3 = E * H | ||
14931 | var nt = e.redMul(h); | ||
14932 | // Z3 = F * G | ||
14933 | var nz = f.redMul(g); | ||
14934 | return this.curve.point(nx, ny, nz, nt); | ||
14935 | }; | ||
14936 | |||
14937 | Point.prototype._projDbl = function _projDbl() { | ||
14938 | // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html | ||
14939 | // #doubling-dbl-2008-bbjlp | ||
14940 | // #doubling-dbl-2007-bl | ||
14941 | // and others | ||
14942 | // Generally 3M + 4S or 2M + 4S | ||
14943 | |||
14944 | // B = (X1 + Y1)^2 | ||
14945 | var b = this.x.redAdd(this.y).redSqr(); | ||
14946 | // C = X1^2 | ||
14947 | var c = this.x.redSqr(); | ||
14948 | // D = Y1^2 | ||
14949 | var d = this.y.redSqr(); | ||
14950 | |||
14951 | var nx; | ||
14952 | var ny; | ||
14953 | var nz; | ||
14954 | if (this.curve.twisted) { | ||
14955 | // E = a * C | ||
14956 | var e = this.curve._mulA(c); | ||
14957 | // F = E + D | ||
14958 | var f = e.redAdd(d); | ||
14959 | if (this.zOne) { | ||
14960 | // X3 = (B - C - D) * (F - 2) | ||
14961 | nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two)); | ||
14962 | // Y3 = F * (E - D) | ||
14963 | ny = f.redMul(e.redSub(d)); | ||
14964 | // Z3 = F^2 - 2 * F | ||
14965 | nz = f.redSqr().redSub(f).redSub(f); | ||
14966 | } else { | ||
14967 | // H = Z1^2 | ||
14968 | var h = this.z.redSqr(); | ||
14969 | // J = F - 2 * H | ||
14970 | var j = f.redSub(h).redISub(h); | ||
14971 | // X3 = (B-C-D)*J | ||
14972 | nx = b.redSub(c).redISub(d).redMul(j); | ||
14973 | // Y3 = F * (E - D) | ||
14974 | ny = f.redMul(e.redSub(d)); | ||
14975 | // Z3 = F * J | ||
14976 | nz = f.redMul(j); | ||
14977 | } | ||
14978 | } else { | ||
14979 | // E = C + D | ||
14980 | var e = c.redAdd(d); | ||
14981 | // H = (c * Z1)^2 | ||
14982 | var h = this.curve._mulC(this.z).redSqr(); | ||
14983 | // J = E - 2 * H | ||
14984 | var j = e.redSub(h).redSub(h); | ||
14985 | // X3 = c * (B - E) * J | ||
14986 | nx = this.curve._mulC(b.redISub(e)).redMul(j); | ||
14987 | // Y3 = c * E * (C - D) | ||
14988 | ny = this.curve._mulC(e).redMul(c.redISub(d)); | ||
14989 | // Z3 = E * J | ||
14990 | nz = e.redMul(j); | ||
14991 | } | ||
14992 | return this.curve.point(nx, ny, nz); | ||
14993 | }; | ||
14994 | |||
14995 | Point.prototype.dbl = function dbl() { | ||
14996 | if (this.isInfinity()) | ||
14997 | return this; | ||
14998 | |||
14999 | // Double in extended coordinates | ||
15000 | if (this.curve.extended) | ||
15001 | return this._extDbl(); | ||
15002 | else | ||
15003 | return this._projDbl(); | ||
15004 | }; | ||
15005 | |||
15006 | Point.prototype._extAdd = function _extAdd(p) { | ||
15007 | // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html | ||
15008 | // #addition-add-2008-hwcd-3 | ||
15009 | // 8M | ||
15010 | |||
15011 | // A = (Y1 - X1) * (Y2 - X2) | ||
15012 | var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x)); | ||
15013 | // B = (Y1 + X1) * (Y2 + X2) | ||
15014 | var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x)); | ||
15015 | // C = T1 * k * T2 | ||
15016 | var c = this.t.redMul(this.curve.dd).redMul(p.t); | ||
15017 | // D = Z1 * 2 * Z2 | ||
15018 | var d = this.z.redMul(p.z.redAdd(p.z)); | ||
15019 | // E = B - A | ||
15020 | var e = b.redSub(a); | ||
15021 | // F = D - C | ||
15022 | var f = d.redSub(c); | ||
15023 | // G = D + C | ||
15024 | var g = d.redAdd(c); | ||
15025 | // H = B + A | ||
15026 | var h = b.redAdd(a); | ||
15027 | // X3 = E * F | ||
15028 | var nx = e.redMul(f); | ||
15029 | // Y3 = G * H | ||
15030 | var ny = g.redMul(h); | ||
15031 | // T3 = E * H | ||
15032 | var nt = e.redMul(h); | ||
15033 | // Z3 = F * G | ||
15034 | var nz = f.redMul(g); | ||
15035 | return this.curve.point(nx, ny, nz, nt); | ||
15036 | }; | ||
15037 | |||
15038 | Point.prototype._projAdd = function _projAdd(p) { | ||
15039 | // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html | ||
15040 | // #addition-add-2008-bbjlp | ||
15041 | // #addition-add-2007-bl | ||
15042 | // 10M + 1S | ||
15043 | |||
15044 | // A = Z1 * Z2 | ||
15045 | var a = this.z.redMul(p.z); | ||
15046 | // B = A^2 | ||
15047 | var b = a.redSqr(); | ||
15048 | // C = X1 * X2 | ||
15049 | var c = this.x.redMul(p.x); | ||
15050 | // D = Y1 * Y2 | ||
15051 | var d = this.y.redMul(p.y); | ||
15052 | // E = d * C * D | ||
15053 | var e = this.curve.d.redMul(c).redMul(d); | ||
15054 | // F = B - E | ||
15055 | var f = b.redSub(e); | ||
15056 | // G = B + E | ||
15057 | var g = b.redAdd(e); | ||
15058 | // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D) | ||
15059 | var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d); | ||
15060 | var nx = a.redMul(f).redMul(tmp); | ||
15061 | var ny; | ||
15062 | var nz; | ||
15063 | if (this.curve.twisted) { | ||
15064 | // Y3 = A * G * (D - a * C) | ||
15065 | ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c))); | ||
15066 | // Z3 = F * G | ||
15067 | nz = f.redMul(g); | ||
15068 | } else { | ||
15069 | // Y3 = A * G * (D - C) | ||
15070 | ny = a.redMul(g).redMul(d.redSub(c)); | ||
15071 | // Z3 = c * F * G | ||
15072 | nz = this.curve._mulC(f).redMul(g); | ||
15073 | } | ||
15074 | return this.curve.point(nx, ny, nz); | ||
15075 | }; | ||
15076 | |||
15077 | Point.prototype.add = function add(p) { | ||
15078 | if (this.isInfinity()) | ||
15079 | return p; | ||
15080 | if (p.isInfinity()) | ||
15081 | return this; | ||
15082 | |||
15083 | if (this.curve.extended) | ||
15084 | return this._extAdd(p); | ||
15085 | else | ||
15086 | return this._projAdd(p); | ||
15087 | }; | ||
15088 | |||
15089 | Point.prototype.mul = function mul(k) { | ||
15090 | if (this._hasDoubles(k)) | ||
15091 | return this.curve._fixedNafMul(this, k); | ||
15092 | else | ||
15093 | return this.curve._wnafMul(this, k); | ||
15094 | }; | ||
15095 | |||
15096 | Point.prototype.mulAdd = function mulAdd(k1, p, k2) { | ||
15097 | return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, false); | ||
15098 | }; | ||
15099 | |||
15100 | Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) { | ||
15101 | return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, true); | ||
15102 | }; | ||
15103 | |||
15104 | Point.prototype.normalize = function normalize() { | ||
15105 | if (this.zOne) | ||
15106 | return this; | ||
15107 | |||
15108 | // Normalize coordinates | ||
15109 | var zi = this.z.redInvm(); | ||
15110 | this.x = this.x.redMul(zi); | ||
15111 | this.y = this.y.redMul(zi); | ||
15112 | if (this.t) | ||
15113 | this.t = this.t.redMul(zi); | ||
15114 | this.z = this.curve.one; | ||
15115 | this.zOne = true; | ||
15116 | return this; | ||
15117 | }; | ||
15118 | |||
15119 | Point.prototype.neg = function neg() { | ||
15120 | return this.curve.point(this.x.redNeg(), | ||
15121 | this.y, | ||
15122 | this.z, | ||
15123 | this.t && this.t.redNeg()); | ||
15124 | }; | ||
15125 | |||
15126 | Point.prototype.getX = function getX() { | ||
15127 | this.normalize(); | ||
15128 | return this.x.fromRed(); | ||
15129 | }; | ||
15130 | |||
15131 | Point.prototype.getY = function getY() { | ||
15132 | this.normalize(); | ||
15133 | return this.y.fromRed(); | ||
15134 | }; | ||
15135 | |||
15136 | Point.prototype.eq = function eq(other) { | ||
15137 | return this === other || | ||
15138 | this.getX().cmp(other.getX()) === 0 && | ||
15139 | this.getY().cmp(other.getY()) === 0; | ||
15140 | }; | ||
15141 | |||
15142 | Point.prototype.eqXToP = function eqXToP(x) { | ||
15143 | var rx = x.toRed(this.curve.red).redMul(this.z); | ||
15144 | if (this.x.cmp(rx) === 0) | ||
15145 | return true; | ||
15146 | |||
15147 | var xc = x.clone(); | ||
15148 | var t = this.curve.redN.redMul(this.z); | ||
15149 | for (;;) { | ||
15150 | xc.iadd(this.curve.n); | ||
15151 | if (xc.cmp(this.curve.p) >= 0) | ||
15152 | return false; | ||
15153 | |||
15154 | rx.redIAdd(t); | ||
15155 | if (this.x.cmp(rx) === 0) | ||
15156 | return true; | ||
15157 | } | ||
15158 | }; | ||
15159 | |||
15160 | // Compatibility with BaseCurve | ||
15161 | Point.prototype.toP = Point.prototype.normalize; | ||
15162 | Point.prototype.mixedAdd = Point.prototype.add; | ||
15163 | |||
15164 | },{"../../elliptic":83,"../curve":86,"bn.js":18,"inherits":116}],86:[function(require,module,exports){ | ||
15165 | 'use strict'; | ||
15166 | |||
15167 | var curve = exports; | ||
15168 | |||
15169 | curve.base = require('./base'); | ||
15170 | curve.short = require('./short'); | ||
15171 | curve.mont = require('./mont'); | ||
15172 | curve.edwards = require('./edwards'); | ||
15173 | |||
15174 | },{"./base":84,"./edwards":85,"./mont":87,"./short":88}],87:[function(require,module,exports){ | ||
15175 | 'use strict'; | ||
15176 | |||
15177 | var curve = require('../curve'); | ||
15178 | var BN = require('bn.js'); | ||
15179 | var inherits = require('inherits'); | ||
15180 | var Base = curve.base; | ||
15181 | |||
15182 | var elliptic = require('../../elliptic'); | ||
15183 | var utils = elliptic.utils; | ||
15184 | |||
15185 | function MontCurve(conf) { | ||
15186 | Base.call(this, 'mont', conf); | ||
15187 | |||
15188 | this.a = new BN(conf.a, 16).toRed(this.red); | ||
15189 | this.b = new BN(conf.b, 16).toRed(this.red); | ||
15190 | this.i4 = new BN(4).toRed(this.red).redInvm(); | ||
15191 | this.two = new BN(2).toRed(this.red); | ||
15192 | this.a24 = this.i4.redMul(this.a.redAdd(this.two)); | ||
15193 | } | ||
15194 | inherits(MontCurve, Base); | ||
15195 | module.exports = MontCurve; | ||
15196 | |||
15197 | MontCurve.prototype.validate = function validate(point) { | ||
15198 | var x = point.normalize().x; | ||
15199 | var x2 = x.redSqr(); | ||
15200 | var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x); | ||
15201 | var y = rhs.redSqrt(); | ||
15202 | |||
15203 | return y.redSqr().cmp(rhs) === 0; | ||
15204 | }; | ||
15205 | |||
15206 | function Point(curve, x, z) { | ||
15207 | Base.BasePoint.call(this, curve, 'projective'); | ||
15208 | if (x === null && z === null) { | ||
15209 | this.x = this.curve.one; | ||
15210 | this.z = this.curve.zero; | ||
15211 | } else { | ||
15212 | this.x = new BN(x, 16); | ||
15213 | this.z = new BN(z, 16); | ||
15214 | if (!this.x.red) | ||
15215 | this.x = this.x.toRed(this.curve.red); | ||
15216 | if (!this.z.red) | ||
15217 | this.z = this.z.toRed(this.curve.red); | ||
15218 | } | ||
15219 | } | ||
15220 | inherits(Point, Base.BasePoint); | ||
15221 | |||
15222 | MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) { | ||
15223 | return this.point(utils.toArray(bytes, enc), 1); | ||
15224 | }; | ||
15225 | |||
15226 | MontCurve.prototype.point = function point(x, z) { | ||
15227 | return new Point(this, x, z); | ||
15228 | }; | ||
15229 | |||
15230 | MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) { | ||
15231 | return Point.fromJSON(this, obj); | ||
15232 | }; | ||
15233 | |||
15234 | Point.prototype.precompute = function precompute() { | ||
15235 | // No-op | ||
15236 | }; | ||
15237 | |||
15238 | Point.prototype._encode = function _encode() { | ||
15239 | return this.getX().toArray('be', this.curve.p.byteLength()); | ||
15240 | }; | ||
15241 | |||
15242 | Point.fromJSON = function fromJSON(curve, obj) { | ||
15243 | return new Point(curve, obj[0], obj[1] || curve.one); | ||
15244 | }; | ||
15245 | |||
15246 | Point.prototype.inspect = function inspect() { | ||
15247 | if (this.isInfinity()) | ||
15248 | return '<EC Point Infinity>'; | ||
15249 | return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + | ||
15250 | ' z: ' + this.z.fromRed().toString(16, 2) + '>'; | ||
15251 | }; | ||
15252 | |||
15253 | Point.prototype.isInfinity = function isInfinity() { | ||
15254 | // XXX This code assumes that zero is always zero in red | ||
15255 | return this.z.cmpn(0) === 0; | ||
15256 | }; | ||
15257 | |||
15258 | Point.prototype.dbl = function dbl() { | ||
15259 | // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3 | ||
15260 | // 2M + 2S + 4A | ||
15261 | |||
15262 | // A = X1 + Z1 | ||
15263 | var a = this.x.redAdd(this.z); | ||
15264 | // AA = A^2 | ||
15265 | var aa = a.redSqr(); | ||
15266 | // B = X1 - Z1 | ||
15267 | var b = this.x.redSub(this.z); | ||
15268 | // BB = B^2 | ||
15269 | var bb = b.redSqr(); | ||
15270 | // C = AA - BB | ||
15271 | var c = aa.redSub(bb); | ||
15272 | // X3 = AA * BB | ||
15273 | var nx = aa.redMul(bb); | ||
15274 | // Z3 = C * (BB + A24 * C) | ||
15275 | var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c))); | ||
15276 | return this.curve.point(nx, nz); | ||
15277 | }; | ||
15278 | |||
15279 | Point.prototype.add = function add() { | ||
15280 | throw new Error('Not supported on Montgomery curve'); | ||
15281 | }; | ||
15282 | |||
15283 | Point.prototype.diffAdd = function diffAdd(p, diff) { | ||
15284 | // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3 | ||
15285 | // 4M + 2S + 6A | ||
15286 | |||
15287 | // A = X2 + Z2 | ||
15288 | var a = this.x.redAdd(this.z); | ||
15289 | // B = X2 - Z2 | ||
15290 | var b = this.x.redSub(this.z); | ||
15291 | // C = X3 + Z3 | ||
15292 | var c = p.x.redAdd(p.z); | ||
15293 | // D = X3 - Z3 | ||
15294 | var d = p.x.redSub(p.z); | ||
15295 | // DA = D * A | ||
15296 | var da = d.redMul(a); | ||
15297 | // CB = C * B | ||
15298 | var cb = c.redMul(b); | ||
15299 | // X5 = Z1 * (DA + CB)^2 | ||
15300 | var nx = diff.z.redMul(da.redAdd(cb).redSqr()); | ||
15301 | // Z5 = X1 * (DA - CB)^2 | ||
15302 | var nz = diff.x.redMul(da.redISub(cb).redSqr()); | ||
15303 | return this.curve.point(nx, nz); | ||
15304 | }; | ||
15305 | |||
15306 | Point.prototype.mul = function mul(k) { | ||
15307 | var t = k.clone(); | ||
15308 | var a = this; // (N / 2) * Q + Q | ||
15309 | var b = this.curve.point(null, null); // (N / 2) * Q | ||
15310 | var c = this; // Q | ||
15311 | |||
15312 | for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) | ||
15313 | bits.push(t.andln(1)); | ||
15314 | |||
15315 | for (var i = bits.length - 1; i >= 0; i--) { | ||
15316 | if (bits[i] === 0) { | ||
15317 | // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q | ||
15318 | a = a.diffAdd(b, c); | ||
15319 | // N * Q = 2 * ((N / 2) * Q + Q)) | ||
15320 | b = b.dbl(); | ||
15321 | } else { | ||
15322 | // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q) | ||
15323 | b = a.diffAdd(b, c); | ||
15324 | // N * Q + Q = 2 * ((N / 2) * Q + Q) | ||
15325 | a = a.dbl(); | ||
15326 | } | ||
15327 | } | ||
15328 | return b; | ||
15329 | }; | ||
15330 | |||
15331 | Point.prototype.mulAdd = function mulAdd() { | ||
15332 | throw new Error('Not supported on Montgomery curve'); | ||
15333 | }; | ||
15334 | |||
15335 | Point.prototype.jumlAdd = function jumlAdd() { | ||
15336 | throw new Error('Not supported on Montgomery curve'); | ||
15337 | }; | ||
15338 | |||
15339 | Point.prototype.eq = function eq(other) { | ||
15340 | return this.getX().cmp(other.getX()) === 0; | ||
15341 | }; | ||
15342 | |||
15343 | Point.prototype.normalize = function normalize() { | ||
15344 | this.x = this.x.redMul(this.z.redInvm()); | ||
15345 | this.z = this.curve.one; | ||
15346 | return this; | ||
15347 | }; | ||
15348 | |||
15349 | Point.prototype.getX = function getX() { | ||
15350 | // Normalize coordinates | ||
15351 | this.normalize(); | ||
15352 | |||
15353 | return this.x.fromRed(); | ||
15354 | }; | ||
15355 | |||
15356 | },{"../../elliptic":83,"../curve":86,"bn.js":18,"inherits":116}],88:[function(require,module,exports){ | ||
15357 | 'use strict'; | ||
15358 | |||
15359 | var curve = require('../curve'); | ||
15360 | var elliptic = require('../../elliptic'); | ||
15361 | var BN = require('bn.js'); | ||
15362 | var inherits = require('inherits'); | ||
15363 | var Base = curve.base; | ||
15364 | |||
15365 | var assert = elliptic.utils.assert; | ||
15366 | |||
15367 | function ShortCurve(conf) { | ||
15368 | Base.call(this, 'short', conf); | ||
15369 | |||
15370 | this.a = new BN(conf.a, 16).toRed(this.red); | ||
15371 | this.b = new BN(conf.b, 16).toRed(this.red); | ||
15372 | this.tinv = this.two.redInvm(); | ||
15373 | |||
15374 | this.zeroA = this.a.fromRed().cmpn(0) === 0; | ||
15375 | this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0; | ||
15376 | |||
15377 | // If the curve is endomorphic, precalculate beta and lambda | ||
15378 | this.endo = this._getEndomorphism(conf); | ||
15379 | this._endoWnafT1 = new Array(4); | ||
15380 | this._endoWnafT2 = new Array(4); | ||
15381 | } | ||
15382 | inherits(ShortCurve, Base); | ||
15383 | module.exports = ShortCurve; | ||
15384 | |||
15385 | ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) { | ||
15386 | // No efficient endomorphism | ||
15387 | if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) | ||
15388 | return; | ||
15389 | |||
15390 | // Compute beta and lambda, that lambda * P = (beta * Px; Py) | ||
15391 | var beta; | ||
15392 | var lambda; | ||
15393 | if (conf.beta) { | ||
15394 | beta = new BN(conf.beta, 16).toRed(this.red); | ||
15395 | } else { | ||
15396 | var betas = this._getEndoRoots(this.p); | ||
15397 | // Choose the smallest beta | ||
15398 | beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1]; | ||
15399 | beta = beta.toRed(this.red); | ||
15400 | } | ||
15401 | if (conf.lambda) { | ||
15402 | lambda = new BN(conf.lambda, 16); | ||
15403 | } else { | ||
15404 | // Choose the lambda that is matching selected beta | ||
15405 | var lambdas = this._getEndoRoots(this.n); | ||
15406 | if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) { | ||
15407 | lambda = lambdas[0]; | ||
15408 | } else { | ||
15409 | lambda = lambdas[1]; | ||
15410 | assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0); | ||
15411 | } | ||
15412 | } | ||
15413 | |||
15414 | // Get basis vectors, used for balanced length-two representation | ||
15415 | var basis; | ||
15416 | if (conf.basis) { | ||
15417 | basis = conf.basis.map(function(vec) { | ||
15418 | return { | ||
15419 | a: new BN(vec.a, 16), | ||
15420 | b: new BN(vec.b, 16) | ||
15421 | }; | ||
15422 | }); | ||
15423 | } else { | ||
15424 | basis = this._getEndoBasis(lambda); | ||
15425 | } | ||
15426 | |||
15427 | return { | ||
15428 | beta: beta, | ||
15429 | lambda: lambda, | ||
15430 | basis: basis | ||
15431 | }; | ||
15432 | }; | ||
15433 | |||
15434 | ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) { | ||
15435 | // Find roots of for x^2 + x + 1 in F | ||
15436 | // Root = (-1 +- Sqrt(-3)) / 2 | ||
15437 | // | ||
15438 | var red = num === this.p ? this.red : BN.mont(num); | ||
15439 | var tinv = new BN(2).toRed(red).redInvm(); | ||
15440 | var ntinv = tinv.redNeg(); | ||
15441 | |||
15442 | var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv); | ||
15443 | |||
15444 | var l1 = ntinv.redAdd(s).fromRed(); | ||
15445 | var l2 = ntinv.redSub(s).fromRed(); | ||
15446 | return [ l1, l2 ]; | ||
15447 | }; | ||
15448 | |||
15449 | ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) { | ||
15450 | // aprxSqrt >= sqrt(this.n) | ||
15451 | var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2)); | ||
15452 | |||
15453 | // 3.74 | ||
15454 | // Run EGCD, until r(L + 1) < aprxSqrt | ||
15455 | var u = lambda; | ||
15456 | var v = this.n.clone(); | ||
15457 | var x1 = new BN(1); | ||
15458 | var y1 = new BN(0); | ||
15459 | var x2 = new BN(0); | ||
15460 | var y2 = new BN(1); | ||
15461 | |||
15462 | // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n) | ||
15463 | var a0; | ||
15464 | var b0; | ||
15465 | // First vector | ||
15466 | var a1; | ||
15467 | var b1; | ||
15468 | // Second vector | ||
15469 | var a2; | ||
15470 | var b2; | ||
15471 | |||
15472 | var prevR; | ||
15473 | var i = 0; | ||
15474 | var r; | ||
15475 | var x; | ||
15476 | while (u.cmpn(0) !== 0) { | ||
15477 | var q = v.div(u); | ||
15478 | r = v.sub(q.mul(u)); | ||
15479 | x = x2.sub(q.mul(x1)); | ||
15480 | var y = y2.sub(q.mul(y1)); | ||
15481 | |||
15482 | if (!a1 && r.cmp(aprxSqrt) < 0) { | ||
15483 | a0 = prevR.neg(); | ||
15484 | b0 = x1; | ||
15485 | a1 = r.neg(); | ||
15486 | b1 = x; | ||
15487 | } else if (a1 && ++i === 2) { | ||
15488 | break; | ||
15489 | } | ||
15490 | prevR = r; | ||
15491 | |||
15492 | v = u; | ||
15493 | u = r; | ||
15494 | x2 = x1; | ||
15495 | x1 = x; | ||
15496 | y2 = y1; | ||
15497 | y1 = y; | ||
15498 | } | ||
15499 | a2 = r.neg(); | ||
15500 | b2 = x; | ||
15501 | |||
15502 | var len1 = a1.sqr().add(b1.sqr()); | ||
15503 | var len2 = a2.sqr().add(b2.sqr()); | ||
15504 | if (len2.cmp(len1) >= 0) { | ||
15505 | a2 = a0; | ||
15506 | b2 = b0; | ||
15507 | } | ||
15508 | |||
15509 | // Normalize signs | ||
15510 | if (a1.negative) { | ||
15511 | a1 = a1.neg(); | ||
15512 | b1 = b1.neg(); | ||
15513 | } | ||
15514 | if (a2.negative) { | ||
15515 | a2 = a2.neg(); | ||
15516 | b2 = b2.neg(); | ||
15517 | } | ||
15518 | |||
15519 | return [ | ||
15520 | { a: a1, b: b1 }, | ||
15521 | { a: a2, b: b2 } | ||
15522 | ]; | ||
15523 | }; | ||
15524 | |||
15525 | ShortCurve.prototype._endoSplit = function _endoSplit(k) { | ||
15526 | var basis = this.endo.basis; | ||
15527 | var v1 = basis[0]; | ||
15528 | var v2 = basis[1]; | ||
15529 | |||
15530 | var c1 = v2.b.mul(k).divRound(this.n); | ||
15531 | var c2 = v1.b.neg().mul(k).divRound(this.n); | ||
15532 | |||
15533 | var p1 = c1.mul(v1.a); | ||
15534 | var p2 = c2.mul(v2.a); | ||
15535 | var q1 = c1.mul(v1.b); | ||
15536 | var q2 = c2.mul(v2.b); | ||
15537 | |||
15538 | // Calculate answer | ||
15539 | var k1 = k.sub(p1).sub(p2); | ||
15540 | var k2 = q1.add(q2).neg(); | ||
15541 | return { k1: k1, k2: k2 }; | ||
15542 | }; | ||
15543 | |||
15544 | ShortCurve.prototype.pointFromX = function pointFromX(x, odd) { | ||
15545 | x = new BN(x, 16); | ||
15546 | if (!x.red) | ||
15547 | x = x.toRed(this.red); | ||
15548 | |||
15549 | var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b); | ||
15550 | var y = y2.redSqrt(); | ||
15551 | if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) | ||
15552 | throw new Error('invalid point'); | ||
15553 | |||
15554 | // XXX Is there any way to tell if the number is odd without converting it | ||
15555 | // to non-red form? | ||
15556 | var isOdd = y.fromRed().isOdd(); | ||
15557 | if (odd && !isOdd || !odd && isOdd) | ||
15558 | y = y.redNeg(); | ||
15559 | |||
15560 | return this.point(x, y); | ||
15561 | }; | ||
15562 | |||
15563 | ShortCurve.prototype.validate = function validate(point) { | ||
15564 | if (point.inf) | ||
15565 | return true; | ||
15566 | |||
15567 | var x = point.x; | ||
15568 | var y = point.y; | ||
15569 | |||
15570 | var ax = this.a.redMul(x); | ||
15571 | var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b); | ||
15572 | return y.redSqr().redISub(rhs).cmpn(0) === 0; | ||
15573 | }; | ||
15574 | |||
15575 | ShortCurve.prototype._endoWnafMulAdd = | ||
15576 | function _endoWnafMulAdd(points, coeffs, jacobianResult) { | ||
15577 | var npoints = this._endoWnafT1; | ||
15578 | var ncoeffs = this._endoWnafT2; | ||
15579 | for (var i = 0; i < points.length; i++) { | ||
15580 | var split = this._endoSplit(coeffs[i]); | ||
15581 | var p = points[i]; | ||
15582 | var beta = p._getBeta(); | ||
15583 | |||
15584 | if (split.k1.negative) { | ||
15585 | split.k1.ineg(); | ||
15586 | p = p.neg(true); | ||
15587 | } | ||
15588 | if (split.k2.negative) { | ||
15589 | split.k2.ineg(); | ||
15590 | beta = beta.neg(true); | ||
15591 | } | ||
15592 | |||
15593 | npoints[i * 2] = p; | ||
15594 | npoints[i * 2 + 1] = beta; | ||
15595 | ncoeffs[i * 2] = split.k1; | ||
15596 | ncoeffs[i * 2 + 1] = split.k2; | ||
15597 | } | ||
15598 | var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult); | ||
15599 | |||
15600 | // Clean-up references to points and coefficients | ||
15601 | for (var j = 0; j < i * 2; j++) { | ||
15602 | npoints[j] = null; | ||
15603 | ncoeffs[j] = null; | ||
15604 | } | ||
15605 | return res; | ||
15606 | }; | ||
15607 | |||
15608 | function Point(curve, x, y, isRed) { | ||
15609 | Base.BasePoint.call(this, curve, 'affine'); | ||
15610 | if (x === null && y === null) { | ||
15611 | this.x = null; | ||
15612 | this.y = null; | ||
15613 | this.inf = true; | ||
15614 | } else { | ||
15615 | this.x = new BN(x, 16); | ||
15616 | this.y = new BN(y, 16); | ||
15617 | // Force redgomery representation when loading from JSON | ||
15618 | if (isRed) { | ||
15619 | this.x.forceRed(this.curve.red); | ||
15620 | this.y.forceRed(this.curve.red); | ||
15621 | } | ||
15622 | if (!this.x.red) | ||
15623 | this.x = this.x.toRed(this.curve.red); | ||
15624 | if (!this.y.red) | ||
15625 | this.y = this.y.toRed(this.curve.red); | ||
15626 | this.inf = false; | ||
15627 | } | ||
15628 | } | ||
15629 | inherits(Point, Base.BasePoint); | ||
15630 | |||
15631 | ShortCurve.prototype.point = function point(x, y, isRed) { | ||
15632 | return new Point(this, x, y, isRed); | ||
15633 | }; | ||
15634 | |||
15635 | ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) { | ||
15636 | return Point.fromJSON(this, obj, red); | ||
15637 | }; | ||
15638 | |||
15639 | Point.prototype._getBeta = function _getBeta() { | ||
15640 | if (!this.curve.endo) | ||
15641 | return; | ||
15642 | |||
15643 | var pre = this.precomputed; | ||
15644 | if (pre && pre.beta) | ||
15645 | return pre.beta; | ||
15646 | |||
15647 | var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y); | ||
15648 | if (pre) { | ||
15649 | var curve = this.curve; | ||
15650 | var endoMul = function(p) { | ||
15651 | return curve.point(p.x.redMul(curve.endo.beta), p.y); | ||
15652 | }; | ||
15653 | pre.beta = beta; | ||
15654 | beta.precomputed = { | ||
15655 | beta: null, | ||
15656 | naf: pre.naf && { | ||
15657 | wnd: pre.naf.wnd, | ||
15658 | points: pre.naf.points.map(endoMul) | ||
15659 | }, | ||
15660 | doubles: pre.doubles && { | ||
15661 | step: pre.doubles.step, | ||
15662 | points: pre.doubles.points.map(endoMul) | ||
15663 | } | ||
15664 | }; | ||
15665 | } | ||
15666 | return beta; | ||
15667 | }; | ||
15668 | |||
15669 | Point.prototype.toJSON = function toJSON() { | ||
15670 | if (!this.precomputed) | ||
15671 | return [ this.x, this.y ]; | ||
15672 | |||
15673 | return [ this.x, this.y, this.precomputed && { | ||
15674 | doubles: this.precomputed.doubles && { | ||
15675 | step: this.precomputed.doubles.step, | ||
15676 | points: this.precomputed.doubles.points.slice(1) | ||
15677 | }, | ||
15678 | naf: this.precomputed.naf && { | ||
15679 | wnd: this.precomputed.naf.wnd, | ||
15680 | points: this.precomputed.naf.points.slice(1) | ||
15681 | } | ||
15682 | } ]; | ||
15683 | }; | ||
15684 | |||
15685 | Point.fromJSON = function fromJSON(curve, obj, red) { | ||
15686 | if (typeof obj === 'string') | ||
15687 | obj = JSON.parse(obj); | ||
15688 | var res = curve.point(obj[0], obj[1], red); | ||
15689 | if (!obj[2]) | ||
15690 | return res; | ||
15691 | |||
15692 | function obj2point(obj) { | ||
15693 | return curve.point(obj[0], obj[1], red); | ||
15694 | } | ||
15695 | |||
15696 | var pre = obj[2]; | ||
15697 | res.precomputed = { | ||
15698 | beta: null, | ||
15699 | doubles: pre.doubles && { | ||
15700 | step: pre.doubles.step, | ||
15701 | points: [ res ].concat(pre.doubles.points.map(obj2point)) | ||
15702 | }, | ||
15703 | naf: pre.naf && { | ||
15704 | wnd: pre.naf.wnd, | ||
15705 | points: [ res ].concat(pre.naf.points.map(obj2point)) | ||
15706 | } | ||
15707 | }; | ||
15708 | return res; | ||
15709 | }; | ||
15710 | |||
15711 | Point.prototype.inspect = function inspect() { | ||
15712 | if (this.isInfinity()) | ||
15713 | return '<EC Point Infinity>'; | ||
15714 | return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + | ||
15715 | ' y: ' + this.y.fromRed().toString(16, 2) + '>'; | ||
15716 | }; | ||
15717 | |||
15718 | Point.prototype.isInfinity = function isInfinity() { | ||
15719 | return this.inf; | ||
15720 | }; | ||
15721 | |||
15722 | Point.prototype.add = function add(p) { | ||
15723 | // O + P = P | ||
15724 | if (this.inf) | ||
15725 | return p; | ||
15726 | |||
15727 | // P + O = P | ||
15728 | if (p.inf) | ||
15729 | return this; | ||
15730 | |||
15731 | // P + P = 2P | ||
15732 | if (this.eq(p)) | ||
15733 | return this.dbl(); | ||
15734 | |||
15735 | // P + (-P) = O | ||
15736 | if (this.neg().eq(p)) | ||
15737 | return this.curve.point(null, null); | ||
15738 | |||
15739 | // P + Q = O | ||
15740 | if (this.x.cmp(p.x) === 0) | ||
15741 | return this.curve.point(null, null); | ||
15742 | |||
15743 | var c = this.y.redSub(p.y); | ||
15744 | if (c.cmpn(0) !== 0) | ||
15745 | c = c.redMul(this.x.redSub(p.x).redInvm()); | ||
15746 | var nx = c.redSqr().redISub(this.x).redISub(p.x); | ||
15747 | var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); | ||
15748 | return this.curve.point(nx, ny); | ||
15749 | }; | ||
15750 | |||
15751 | Point.prototype.dbl = function dbl() { | ||
15752 | if (this.inf) | ||
15753 | return this; | ||
15754 | |||
15755 | // 2P = O | ||
15756 | var ys1 = this.y.redAdd(this.y); | ||
15757 | if (ys1.cmpn(0) === 0) | ||
15758 | return this.curve.point(null, null); | ||
15759 | |||
15760 | var a = this.curve.a; | ||
15761 | |||
15762 | var x2 = this.x.redSqr(); | ||
15763 | var dyinv = ys1.redInvm(); | ||
15764 | var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv); | ||
15765 | |||
15766 | var nx = c.redSqr().redISub(this.x.redAdd(this.x)); | ||
15767 | var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); | ||
15768 | return this.curve.point(nx, ny); | ||
15769 | }; | ||
15770 | |||
15771 | Point.prototype.getX = function getX() { | ||
15772 | return this.x.fromRed(); | ||
15773 | }; | ||
15774 | |||
15775 | Point.prototype.getY = function getY() { | ||
15776 | return this.y.fromRed(); | ||
15777 | }; | ||
15778 | |||
15779 | Point.prototype.mul = function mul(k) { | ||
15780 | k = new BN(k, 16); | ||
15781 | |||
15782 | if (this._hasDoubles(k)) | ||
15783 | return this.curve._fixedNafMul(this, k); | ||
15784 | else if (this.curve.endo) | ||
15785 | return this.curve._endoWnafMulAdd([ this ], [ k ]); | ||
15786 | else | ||
15787 | return this.curve._wnafMul(this, k); | ||
15788 | }; | ||
15789 | |||
15790 | Point.prototype.mulAdd = function mulAdd(k1, p2, k2) { | ||
15791 | var points = [ this, p2 ]; | ||
15792 | var coeffs = [ k1, k2 ]; | ||
15793 | if (this.curve.endo) | ||
15794 | return this.curve._endoWnafMulAdd(points, coeffs); | ||
15795 | else | ||
15796 | return this.curve._wnafMulAdd(1, points, coeffs, 2); | ||
15797 | }; | ||
15798 | |||
15799 | Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) { | ||
15800 | var points = [ this, p2 ]; | ||
15801 | var coeffs = [ k1, k2 ]; | ||
15802 | if (this.curve.endo) | ||
15803 | return this.curve._endoWnafMulAdd(points, coeffs, true); | ||
15804 | else | ||
15805 | return this.curve._wnafMulAdd(1, points, coeffs, 2, true); | ||
15806 | }; | ||
15807 | |||
15808 | Point.prototype.eq = function eq(p) { | ||
15809 | return this === p || | ||
15810 | this.inf === p.inf && | ||
15811 | (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0); | ||
15812 | }; | ||
15813 | |||
15814 | Point.prototype.neg = function neg(_precompute) { | ||
15815 | if (this.inf) | ||
15816 | return this; | ||
15817 | |||
15818 | var res = this.curve.point(this.x, this.y.redNeg()); | ||
15819 | if (_precompute && this.precomputed) { | ||
15820 | var pre = this.precomputed; | ||
15821 | var negate = function(p) { | ||
15822 | return p.neg(); | ||
15823 | }; | ||
15824 | res.precomputed = { | ||
15825 | naf: pre.naf && { | ||
15826 | wnd: pre.naf.wnd, | ||
15827 | points: pre.naf.points.map(negate) | ||
15828 | }, | ||
15829 | doubles: pre.doubles && { | ||
15830 | step: pre.doubles.step, | ||
15831 | points: pre.doubles.points.map(negate) | ||
15832 | } | ||
15833 | }; | ||
15834 | } | ||
15835 | return res; | ||
15836 | }; | ||
15837 | |||
15838 | Point.prototype.toJ = function toJ() { | ||
15839 | if (this.inf) | ||
15840 | return this.curve.jpoint(null, null, null); | ||
15841 | |||
15842 | var res = this.curve.jpoint(this.x, this.y, this.curve.one); | ||
15843 | return res; | ||
15844 | }; | ||
15845 | |||
15846 | function JPoint(curve, x, y, z) { | ||
15847 | Base.BasePoint.call(this, curve, 'jacobian'); | ||
15848 | if (x === null && y === null && z === null) { | ||
15849 | this.x = this.curve.one; | ||
15850 | this.y = this.curve.one; | ||
15851 | this.z = new BN(0); | ||
15852 | } else { | ||
15853 | this.x = new BN(x, 16); | ||
15854 | this.y = new BN(y, 16); | ||
15855 | this.z = new BN(z, 16); | ||
15856 | } | ||
15857 | if (!this.x.red) | ||
15858 | this.x = this.x.toRed(this.curve.red); | ||
15859 | if (!this.y.red) | ||
15860 | this.y = this.y.toRed(this.curve.red); | ||
15861 | if (!this.z.red) | ||
15862 | this.z = this.z.toRed(this.curve.red); | ||
15863 | |||
15864 | this.zOne = this.z === this.curve.one; | ||
15865 | } | ||
15866 | inherits(JPoint, Base.BasePoint); | ||
15867 | |||
15868 | ShortCurve.prototype.jpoint = function jpoint(x, y, z) { | ||
15869 | return new JPoint(this, x, y, z); | ||
15870 | }; | ||
15871 | |||
15872 | JPoint.prototype.toP = function toP() { | ||
15873 | if (this.isInfinity()) | ||
15874 | return this.curve.point(null, null); | ||
15875 | |||
15876 | var zinv = this.z.redInvm(); | ||
15877 | var zinv2 = zinv.redSqr(); | ||
15878 | var ax = this.x.redMul(zinv2); | ||
15879 | var ay = this.y.redMul(zinv2).redMul(zinv); | ||
15880 | |||
15881 | return this.curve.point(ax, ay); | ||
15882 | }; | ||
15883 | |||
15884 | JPoint.prototype.neg = function neg() { | ||
15885 | return this.curve.jpoint(this.x, this.y.redNeg(), this.z); | ||
15886 | }; | ||
15887 | |||
15888 | JPoint.prototype.add = function add(p) { | ||
15889 | // O + P = P | ||
15890 | if (this.isInfinity()) | ||
15891 | return p; | ||
15892 | |||
15893 | // P + O = P | ||
15894 | if (p.isInfinity()) | ||
15895 | return this; | ||
15896 | |||
15897 | // 12M + 4S + 7A | ||
15898 | var pz2 = p.z.redSqr(); | ||
15899 | var z2 = this.z.redSqr(); | ||
15900 | var u1 = this.x.redMul(pz2); | ||
15901 | var u2 = p.x.redMul(z2); | ||
15902 | var s1 = this.y.redMul(pz2.redMul(p.z)); | ||
15903 | var s2 = p.y.redMul(z2.redMul(this.z)); | ||
15904 | |||
15905 | var h = u1.redSub(u2); | ||
15906 | var r = s1.redSub(s2); | ||
15907 | if (h.cmpn(0) === 0) { | ||
15908 | if (r.cmpn(0) !== 0) | ||
15909 | return this.curve.jpoint(null, null, null); | ||
15910 | else | ||
15911 | return this.dbl(); | ||
15912 | } | ||
15913 | |||
15914 | var h2 = h.redSqr(); | ||
15915 | var h3 = h2.redMul(h); | ||
15916 | var v = u1.redMul(h2); | ||
15917 | |||
15918 | var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); | ||
15919 | var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); | ||
15920 | var nz = this.z.redMul(p.z).redMul(h); | ||
15921 | |||
15922 | return this.curve.jpoint(nx, ny, nz); | ||
15923 | }; | ||
15924 | |||
15925 | JPoint.prototype.mixedAdd = function mixedAdd(p) { | ||
15926 | // O + P = P | ||
15927 | if (this.isInfinity()) | ||
15928 | return p.toJ(); | ||
15929 | |||
15930 | // P + O = P | ||
15931 | if (p.isInfinity()) | ||
15932 | return this; | ||
15933 | |||
15934 | // 8M + 3S + 7A | ||
15935 | var z2 = this.z.redSqr(); | ||
15936 | var u1 = this.x; | ||
15937 | var u2 = p.x.redMul(z2); | ||
15938 | var s1 = this.y; | ||
15939 | var s2 = p.y.redMul(z2).redMul(this.z); | ||
15940 | |||
15941 | var h = u1.redSub(u2); | ||
15942 | var r = s1.redSub(s2); | ||
15943 | if (h.cmpn(0) === 0) { | ||
15944 | if (r.cmpn(0) !== 0) | ||
15945 | return this.curve.jpoint(null, null, null); | ||
15946 | else | ||
15947 | return this.dbl(); | ||
15948 | } | ||
15949 | |||
15950 | var h2 = h.redSqr(); | ||
15951 | var h3 = h2.redMul(h); | ||
15952 | var v = u1.redMul(h2); | ||
15953 | |||
15954 | var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); | ||
15955 | var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); | ||
15956 | var nz = this.z.redMul(h); | ||
15957 | |||
15958 | return this.curve.jpoint(nx, ny, nz); | ||
15959 | }; | ||
15960 | |||
15961 | JPoint.prototype.dblp = function dblp(pow) { | ||
15962 | if (pow === 0) | ||
15963 | return this; | ||
15964 | if (this.isInfinity()) | ||
15965 | return this; | ||
15966 | if (!pow) | ||
15967 | return this.dbl(); | ||
15968 | |||
15969 | if (this.curve.zeroA || this.curve.threeA) { | ||
15970 | var r = this; | ||
15971 | for (var i = 0; i < pow; i++) | ||
15972 | r = r.dbl(); | ||
15973 | return r; | ||
15974 | } | ||
15975 | |||
15976 | // 1M + 2S + 1A + N * (4S + 5M + 8A) | ||
15977 | // N = 1 => 6M + 6S + 9A | ||
15978 | var a = this.curve.a; | ||
15979 | var tinv = this.curve.tinv; | ||
15980 | |||
15981 | var jx = this.x; | ||
15982 | var jy = this.y; | ||
15983 | var jz = this.z; | ||
15984 | var jz4 = jz.redSqr().redSqr(); | ||
15985 | |||
15986 | // Reuse results | ||
15987 | var jyd = jy.redAdd(jy); | ||
15988 | for (var i = 0; i < pow; i++) { | ||
15989 | var jx2 = jx.redSqr(); | ||
15990 | var jyd2 = jyd.redSqr(); | ||
15991 | var jyd4 = jyd2.redSqr(); | ||
15992 | var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); | ||
15993 | |||
15994 | var t1 = jx.redMul(jyd2); | ||
15995 | var nx = c.redSqr().redISub(t1.redAdd(t1)); | ||
15996 | var t2 = t1.redISub(nx); | ||
15997 | var dny = c.redMul(t2); | ||
15998 | dny = dny.redIAdd(dny).redISub(jyd4); | ||
15999 | var nz = jyd.redMul(jz); | ||
16000 | if (i + 1 < pow) | ||
16001 | jz4 = jz4.redMul(jyd4); | ||
16002 | |||
16003 | jx = nx; | ||
16004 | jz = nz; | ||
16005 | jyd = dny; | ||
16006 | } | ||
16007 | |||
16008 | return this.curve.jpoint(jx, jyd.redMul(tinv), jz); | ||
16009 | }; | ||
16010 | |||
16011 | JPoint.prototype.dbl = function dbl() { | ||
16012 | if (this.isInfinity()) | ||
16013 | return this; | ||
16014 | |||
16015 | if (this.curve.zeroA) | ||
16016 | return this._zeroDbl(); | ||
16017 | else if (this.curve.threeA) | ||
16018 | return this._threeDbl(); | ||
16019 | else | ||
16020 | return this._dbl(); | ||
16021 | }; | ||
16022 | |||
16023 | JPoint.prototype._zeroDbl = function _zeroDbl() { | ||
16024 | var nx; | ||
16025 | var ny; | ||
16026 | var nz; | ||
16027 | // Z = 1 | ||
16028 | if (this.zOne) { | ||
16029 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html | ||
16030 | // #doubling-mdbl-2007-bl | ||
16031 | // 1M + 5S + 14A | ||
16032 | |||
16033 | // XX = X1^2 | ||
16034 | var xx = this.x.redSqr(); | ||
16035 | // YY = Y1^2 | ||
16036 | var yy = this.y.redSqr(); | ||
16037 | // YYYY = YY^2 | ||
16038 | var yyyy = yy.redSqr(); | ||
16039 | // S = 2 * ((X1 + YY)^2 - XX - YYYY) | ||
16040 | var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); | ||
16041 | s = s.redIAdd(s); | ||
16042 | // M = 3 * XX + a; a = 0 | ||
16043 | var m = xx.redAdd(xx).redIAdd(xx); | ||
16044 | // T = M ^ 2 - 2*S | ||
16045 | var t = m.redSqr().redISub(s).redISub(s); | ||
16046 | |||
16047 | // 8 * YYYY | ||
16048 | var yyyy8 = yyyy.redIAdd(yyyy); | ||
16049 | yyyy8 = yyyy8.redIAdd(yyyy8); | ||
16050 | yyyy8 = yyyy8.redIAdd(yyyy8); | ||
16051 | |||
16052 | // X3 = T | ||
16053 | nx = t; | ||
16054 | // Y3 = M * (S - T) - 8 * YYYY | ||
16055 | ny = m.redMul(s.redISub(t)).redISub(yyyy8); | ||
16056 | // Z3 = 2*Y1 | ||
16057 | nz = this.y.redAdd(this.y); | ||
16058 | } else { | ||
16059 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html | ||
16060 | // #doubling-dbl-2009-l | ||
16061 | // 2M + 5S + 13A | ||
16062 | |||
16063 | // A = X1^2 | ||
16064 | var a = this.x.redSqr(); | ||
16065 | // B = Y1^2 | ||
16066 | var b = this.y.redSqr(); | ||
16067 | // C = B^2 | ||
16068 | var c = b.redSqr(); | ||
16069 | // D = 2 * ((X1 + B)^2 - A - C) | ||
16070 | var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c); | ||
16071 | d = d.redIAdd(d); | ||
16072 | // E = 3 * A | ||
16073 | var e = a.redAdd(a).redIAdd(a); | ||
16074 | // F = E^2 | ||
16075 | var f = e.redSqr(); | ||
16076 | |||
16077 | // 8 * C | ||
16078 | var c8 = c.redIAdd(c); | ||
16079 | c8 = c8.redIAdd(c8); | ||
16080 | c8 = c8.redIAdd(c8); | ||
16081 | |||
16082 | // X3 = F - 2 * D | ||
16083 | nx = f.redISub(d).redISub(d); | ||
16084 | // Y3 = E * (D - X3) - 8 * C | ||
16085 | ny = e.redMul(d.redISub(nx)).redISub(c8); | ||
16086 | // Z3 = 2 * Y1 * Z1 | ||
16087 | nz = this.y.redMul(this.z); | ||
16088 | nz = nz.redIAdd(nz); | ||
16089 | } | ||
16090 | |||
16091 | return this.curve.jpoint(nx, ny, nz); | ||
16092 | }; | ||
16093 | |||
16094 | JPoint.prototype._threeDbl = function _threeDbl() { | ||
16095 | var nx; | ||
16096 | var ny; | ||
16097 | var nz; | ||
16098 | // Z = 1 | ||
16099 | if (this.zOne) { | ||
16100 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html | ||
16101 | // #doubling-mdbl-2007-bl | ||
16102 | // 1M + 5S + 15A | ||
16103 | |||
16104 | // XX = X1^2 | ||
16105 | var xx = this.x.redSqr(); | ||
16106 | // YY = Y1^2 | ||
16107 | var yy = this.y.redSqr(); | ||
16108 | // YYYY = YY^2 | ||
16109 | var yyyy = yy.redSqr(); | ||
16110 | // S = 2 * ((X1 + YY)^2 - XX - YYYY) | ||
16111 | var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); | ||
16112 | s = s.redIAdd(s); | ||
16113 | // M = 3 * XX + a | ||
16114 | var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a); | ||
16115 | // T = M^2 - 2 * S | ||
16116 | var t = m.redSqr().redISub(s).redISub(s); | ||
16117 | // X3 = T | ||
16118 | nx = t; | ||
16119 | // Y3 = M * (S - T) - 8 * YYYY | ||
16120 | var yyyy8 = yyyy.redIAdd(yyyy); | ||
16121 | yyyy8 = yyyy8.redIAdd(yyyy8); | ||
16122 | yyyy8 = yyyy8.redIAdd(yyyy8); | ||
16123 | ny = m.redMul(s.redISub(t)).redISub(yyyy8); | ||
16124 | // Z3 = 2 * Y1 | ||
16125 | nz = this.y.redAdd(this.y); | ||
16126 | } else { | ||
16127 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b | ||
16128 | // 3M + 5S | ||
16129 | |||
16130 | // delta = Z1^2 | ||
16131 | var delta = this.z.redSqr(); | ||
16132 | // gamma = Y1^2 | ||
16133 | var gamma = this.y.redSqr(); | ||
16134 | // beta = X1 * gamma | ||
16135 | var beta = this.x.redMul(gamma); | ||
16136 | // alpha = 3 * (X1 - delta) * (X1 + delta) | ||
16137 | var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta)); | ||
16138 | alpha = alpha.redAdd(alpha).redIAdd(alpha); | ||
16139 | // X3 = alpha^2 - 8 * beta | ||
16140 | var beta4 = beta.redIAdd(beta); | ||
16141 | beta4 = beta4.redIAdd(beta4); | ||
16142 | var beta8 = beta4.redAdd(beta4); | ||
16143 | nx = alpha.redSqr().redISub(beta8); | ||
16144 | // Z3 = (Y1 + Z1)^2 - gamma - delta | ||
16145 | nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta); | ||
16146 | // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2 | ||
16147 | var ggamma8 = gamma.redSqr(); | ||
16148 | ggamma8 = ggamma8.redIAdd(ggamma8); | ||
16149 | ggamma8 = ggamma8.redIAdd(ggamma8); | ||
16150 | ggamma8 = ggamma8.redIAdd(ggamma8); | ||
16151 | ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8); | ||
16152 | } | ||
16153 | |||
16154 | return this.curve.jpoint(nx, ny, nz); | ||
16155 | }; | ||
16156 | |||
16157 | JPoint.prototype._dbl = function _dbl() { | ||
16158 | var a = this.curve.a; | ||
16159 | |||
16160 | // 4M + 6S + 10A | ||
16161 | var jx = this.x; | ||
16162 | var jy = this.y; | ||
16163 | var jz = this.z; | ||
16164 | var jz4 = jz.redSqr().redSqr(); | ||
16165 | |||
16166 | var jx2 = jx.redSqr(); | ||
16167 | var jy2 = jy.redSqr(); | ||
16168 | |||
16169 | var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); | ||
16170 | |||
16171 | var jxd4 = jx.redAdd(jx); | ||
16172 | jxd4 = jxd4.redIAdd(jxd4); | ||
16173 | var t1 = jxd4.redMul(jy2); | ||
16174 | var nx = c.redSqr().redISub(t1.redAdd(t1)); | ||
16175 | var t2 = t1.redISub(nx); | ||
16176 | |||
16177 | var jyd8 = jy2.redSqr(); | ||
16178 | jyd8 = jyd8.redIAdd(jyd8); | ||
16179 | jyd8 = jyd8.redIAdd(jyd8); | ||
16180 | jyd8 = jyd8.redIAdd(jyd8); | ||
16181 | var ny = c.redMul(t2).redISub(jyd8); | ||
16182 | var nz = jy.redAdd(jy).redMul(jz); | ||
16183 | |||
16184 | return this.curve.jpoint(nx, ny, nz); | ||
16185 | }; | ||
16186 | |||
16187 | JPoint.prototype.trpl = function trpl() { | ||
16188 | if (!this.curve.zeroA) | ||
16189 | return this.dbl().add(this); | ||
16190 | |||
16191 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl | ||
16192 | // 5M + 10S + ... | ||
16193 | |||
16194 | // XX = X1^2 | ||
16195 | var xx = this.x.redSqr(); | ||
16196 | // YY = Y1^2 | ||
16197 | var yy = this.y.redSqr(); | ||
16198 | // ZZ = Z1^2 | ||
16199 | var zz = this.z.redSqr(); | ||
16200 | // YYYY = YY^2 | ||
16201 | var yyyy = yy.redSqr(); | ||
16202 | // M = 3 * XX + a * ZZ2; a = 0 | ||
16203 | var m = xx.redAdd(xx).redIAdd(xx); | ||
16204 | // MM = M^2 | ||
16205 | var mm = m.redSqr(); | ||
16206 | // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM | ||
16207 | var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); | ||
16208 | e = e.redIAdd(e); | ||
16209 | e = e.redAdd(e).redIAdd(e); | ||
16210 | e = e.redISub(mm); | ||
16211 | // EE = E^2 | ||
16212 | var ee = e.redSqr(); | ||
16213 | // T = 16*YYYY | ||
16214 | var t = yyyy.redIAdd(yyyy); | ||
16215 | t = t.redIAdd(t); | ||
16216 | t = t.redIAdd(t); | ||
16217 | t = t.redIAdd(t); | ||
16218 | // U = (M + E)^2 - MM - EE - T | ||
16219 | var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t); | ||
16220 | // X3 = 4 * (X1 * EE - 4 * YY * U) | ||
16221 | var yyu4 = yy.redMul(u); | ||
16222 | yyu4 = yyu4.redIAdd(yyu4); | ||
16223 | yyu4 = yyu4.redIAdd(yyu4); | ||
16224 | var nx = this.x.redMul(ee).redISub(yyu4); | ||
16225 | nx = nx.redIAdd(nx); | ||
16226 | nx = nx.redIAdd(nx); | ||
16227 | // Y3 = 8 * Y1 * (U * (T - U) - E * EE) | ||
16228 | var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee))); | ||
16229 | ny = ny.redIAdd(ny); | ||
16230 | ny = ny.redIAdd(ny); | ||
16231 | ny = ny.redIAdd(ny); | ||
16232 | // Z3 = (Z1 + E)^2 - ZZ - EE | ||
16233 | var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee); | ||
16234 | |||
16235 | return this.curve.jpoint(nx, ny, nz); | ||
16236 | }; | ||
16237 | |||
16238 | JPoint.prototype.mul = function mul(k, kbase) { | ||
16239 | k = new BN(k, kbase); | ||
16240 | |||
16241 | return this.curve._wnafMul(this, k); | ||
16242 | }; | ||
16243 | |||
16244 | JPoint.prototype.eq = function eq(p) { | ||
16245 | if (p.type === 'affine') | ||
16246 | return this.eq(p.toJ()); | ||
16247 | |||
16248 | if (this === p) | ||
16249 | return true; | ||
16250 | |||
16251 | // x1 * z2^2 == x2 * z1^2 | ||
16252 | var z2 = this.z.redSqr(); | ||
16253 | var pz2 = p.z.redSqr(); | ||
16254 | if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) | ||
16255 | return false; | ||
16256 | |||
16257 | // y1 * z2^3 == y2 * z1^3 | ||
16258 | var z3 = z2.redMul(this.z); | ||
16259 | var pz3 = pz2.redMul(p.z); | ||
16260 | return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0; | ||
16261 | }; | ||
16262 | |||
16263 | JPoint.prototype.eqXToP = function eqXToP(x) { | ||
16264 | var zs = this.z.redSqr(); | ||
16265 | var rx = x.toRed(this.curve.red).redMul(zs); | ||
16266 | if (this.x.cmp(rx) === 0) | ||
16267 | return true; | ||
16268 | |||
16269 | var xc = x.clone(); | ||
16270 | var t = this.curve.redN.redMul(zs); | ||
16271 | for (;;) { | ||
16272 | xc.iadd(this.curve.n); | ||
16273 | if (xc.cmp(this.curve.p) >= 0) | ||
16274 | return false; | ||
16275 | |||
16276 | rx.redIAdd(t); | ||
16277 | if (this.x.cmp(rx) === 0) | ||
16278 | return true; | ||
16279 | } | ||
16280 | }; | ||
16281 | |||
16282 | JPoint.prototype.inspect = function inspect() { | ||
16283 | if (this.isInfinity()) | ||
16284 | return '<EC JPoint Infinity>'; | ||
16285 | return '<EC JPoint x: ' + this.x.toString(16, 2) + | ||
16286 | ' y: ' + this.y.toString(16, 2) + | ||
16287 | ' z: ' + this.z.toString(16, 2) + '>'; | ||
16288 | }; | ||
16289 | |||
16290 | JPoint.prototype.isInfinity = function isInfinity() { | ||
16291 | // XXX This code assumes that zero is always zero in red | ||
16292 | return this.z.cmpn(0) === 0; | ||
16293 | }; | ||
16294 | |||
16295 | },{"../../elliptic":83,"../curve":86,"bn.js":18,"inherits":116}],89:[function(require,module,exports){ | ||
16296 | 'use strict'; | ||
16297 | |||
16298 | var curves = exports; | ||
16299 | |||
16300 | var hash = require('hash.js'); | ||
16301 | var elliptic = require('../elliptic'); | ||
16302 | |||
16303 | var assert = elliptic.utils.assert; | ||
16304 | |||
16305 | function PresetCurve(options) { | ||
16306 | if (options.type === 'short') | ||
16307 | this.curve = new elliptic.curve.short(options); | ||
16308 | else if (options.type === 'edwards') | ||
16309 | this.curve = new elliptic.curve.edwards(options); | ||
16310 | else | ||
16311 | this.curve = new elliptic.curve.mont(options); | ||
16312 | this.g = this.curve.g; | ||
16313 | this.n = this.curve.n; | ||
16314 | this.hash = options.hash; | ||
16315 | |||
16316 | assert(this.g.validate(), 'Invalid curve'); | ||
16317 | assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O'); | ||
16318 | } | ||
16319 | curves.PresetCurve = PresetCurve; | ||
16320 | |||
16321 | function defineCurve(name, options) { | ||
16322 | Object.defineProperty(curves, name, { | ||
16323 | configurable: true, | ||
16324 | enumerable: true, | ||
16325 | get: function() { | ||
16326 | var curve = new PresetCurve(options); | ||
16327 | Object.defineProperty(curves, name, { | ||
16328 | configurable: true, | ||
16329 | enumerable: true, | ||
16330 | value: curve | ||
16331 | }); | ||
16332 | return curve; | ||
16333 | } | ||
16334 | }); | ||
16335 | } | ||
16336 | |||
16337 | defineCurve('p192', { | ||
16338 | type: 'short', | ||
16339 | prime: 'p192', | ||
16340 | p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff', | ||
16341 | a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc', | ||
16342 | b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1', | ||
16343 | n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831', | ||
16344 | hash: hash.sha256, | ||
16345 | gRed: false, | ||
16346 | g: [ | ||
16347 | '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012', | ||
16348 | '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811' | ||
16349 | ] | ||
16350 | }); | ||
16351 | |||
16352 | defineCurve('p224', { | ||
16353 | type: 'short', | ||
16354 | prime: 'p224', | ||
16355 | p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001', | ||
16356 | a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe', | ||
16357 | b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4', | ||
16358 | n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d', | ||
16359 | hash: hash.sha256, | ||
16360 | gRed: false, | ||
16361 | g: [ | ||
16362 | 'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21', | ||
16363 | 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34' | ||
16364 | ] | ||
16365 | }); | ||
16366 | |||
16367 | defineCurve('p256', { | ||
16368 | type: 'short', | ||
16369 | prime: null, | ||
16370 | p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff', | ||
16371 | a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc', | ||
16372 | b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b', | ||
16373 | n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551', | ||
16374 | hash: hash.sha256, | ||
16375 | gRed: false, | ||
16376 | g: [ | ||
16377 | '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296', | ||
16378 | '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5' | ||
16379 | ] | ||
16380 | }); | ||
16381 | |||
16382 | defineCurve('p384', { | ||
16383 | type: 'short', | ||
16384 | prime: null, | ||
16385 | p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | ||
16386 | 'fffffffe ffffffff 00000000 00000000 ffffffff', | ||
16387 | a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | ||
16388 | 'fffffffe ffffffff 00000000 00000000 fffffffc', | ||
16389 | b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' + | ||
16390 | '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef', | ||
16391 | n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' + | ||
16392 | 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973', | ||
16393 | hash: hash.sha384, | ||
16394 | gRed: false, | ||
16395 | g: [ | ||
16396 | 'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' + | ||
16397 | '5502f25d bf55296c 3a545e38 72760ab7', | ||
16398 | '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' + | ||
16399 | '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f' | ||
16400 | ] | ||
16401 | }); | ||
16402 | |||
16403 | defineCurve('p521', { | ||
16404 | type: 'short', | ||
16405 | prime: null, | ||
16406 | p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | ||
16407 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | ||
16408 | 'ffffffff ffffffff ffffffff ffffffff ffffffff', | ||
16409 | a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | ||
16410 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | ||
16411 | 'ffffffff ffffffff ffffffff ffffffff fffffffc', | ||
16412 | b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' + | ||
16413 | '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' + | ||
16414 | '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00', | ||
16415 | n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | ||
16416 | 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' + | ||
16417 | 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409', | ||
16418 | hash: hash.sha512, | ||
16419 | gRed: false, | ||
16420 | g: [ | ||
16421 | '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' + | ||
16422 | '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' + | ||
16423 | 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66', | ||
16424 | '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' + | ||
16425 | '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' + | ||
16426 | '3fad0761 353c7086 a272c240 88be9476 9fd16650' | ||
16427 | ] | ||
16428 | }); | ||
16429 | |||
16430 | defineCurve('curve25519', { | ||
16431 | type: 'mont', | ||
16432 | prime: 'p25519', | ||
16433 | p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed', | ||
16434 | a: '76d06', | ||
16435 | b: '1', | ||
16436 | n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed', | ||
16437 | hash: hash.sha256, | ||
16438 | gRed: false, | ||
16439 | g: [ | ||
16440 | '9' | ||
16441 | ] | ||
16442 | }); | ||
16443 | |||
16444 | defineCurve('ed25519', { | ||
16445 | type: 'edwards', | ||
16446 | prime: 'p25519', | ||
16447 | p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed', | ||
16448 | a: '-1', | ||
16449 | c: '1', | ||
16450 | // -121665 * (121666^(-1)) (mod P) | ||
16451 | d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3', | ||
16452 | n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed', | ||
16453 | hash: hash.sha256, | ||
16454 | gRed: false, | ||
16455 | g: [ | ||
16456 | '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a', | ||
16457 | |||
16458 | // 4/5 | ||
16459 | '6666666666666666666666666666666666666666666666666666666666666658' | ||
16460 | ] | ||
16461 | }); | ||
16462 | |||
16463 | var pre; | ||
16464 | try { | ||
16465 | pre = require('./precomputed/secp256k1'); | ||
16466 | } catch (e) { | ||
16467 | pre = undefined; | ||
16468 | } | ||
16469 | |||
16470 | defineCurve('secp256k1', { | ||
16471 | type: 'short', | ||
16472 | prime: 'k256', | ||
16473 | p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f', | ||
16474 | a: '0', | ||
16475 | b: '7', | ||
16476 | n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141', | ||
16477 | h: '1', | ||
16478 | hash: hash.sha256, | ||
16479 | |||
16480 | // Precomputed endomorphism | ||
16481 | beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee', | ||
16482 | lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72', | ||
16483 | basis: [ | ||
16484 | { | ||
16485 | a: '3086d221a7d46bcde86c90e49284eb15', | ||
16486 | b: '-e4437ed6010e88286f547fa90abfe4c3' | ||
16487 | }, | ||
16488 | { | ||
16489 | a: '114ca50f7a8e2f3f657c1108d9d44cfd8', | ||
16490 | b: '3086d221a7d46bcde86c90e49284eb15' | ||
16491 | } | ||
16492 | ], | ||
16493 | |||
16494 | gRed: false, | ||
16495 | g: [ | ||
16496 | '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', | ||
16497 | '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8', | ||
16498 | pre | ||
16499 | ] | ||
16500 | }); | ||
16501 | |||
16502 | },{"../elliptic":83,"./precomputed/secp256k1":96,"hash.js":102}],90:[function(require,module,exports){ | ||
16503 | 'use strict'; | ||
16504 | |||
16505 | var BN = require('bn.js'); | ||
16506 | var HmacDRBG = require('hmac-drbg'); | ||
16507 | var elliptic = require('../../elliptic'); | ||
16508 | var utils = elliptic.utils; | ||
16509 | var assert = utils.assert; | ||
16510 | |||
16511 | var KeyPair = require('./key'); | ||
16512 | var Signature = require('./signature'); | ||
16513 | |||
16514 | function EC(options) { | ||
16515 | if (!(this instanceof EC)) | ||
16516 | return new EC(options); | ||
16517 | |||
16518 | // Shortcut `elliptic.ec(curve-name)` | ||
16519 | if (typeof options === 'string') { | ||
16520 | assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options); | ||
16521 | |||
16522 | options = elliptic.curves[options]; | ||
16523 | } | ||
16524 | |||
16525 | // Shortcut for `elliptic.ec(elliptic.curves.curveName)` | ||
16526 | if (options instanceof elliptic.curves.PresetCurve) | ||
16527 | options = { curve: options }; | ||
16528 | |||
16529 | this.curve = options.curve.curve; | ||
16530 | this.n = this.curve.n; | ||
16531 | this.nh = this.n.ushrn(1); | ||
16532 | this.g = this.curve.g; | ||
16533 | |||
16534 | // Point on curve | ||
16535 | this.g = options.curve.g; | ||
16536 | this.g.precompute(options.curve.n.bitLength() + 1); | ||
16537 | |||
16538 | // Hash for function for DRBG | ||
16539 | this.hash = options.hash || options.curve.hash; | ||
16540 | } | ||
16541 | module.exports = EC; | ||
16542 | |||
16543 | EC.prototype.keyPair = function keyPair(options) { | ||
16544 | return new KeyPair(this, options); | ||
16545 | }; | ||
16546 | |||
16547 | EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) { | ||
16548 | return KeyPair.fromPrivate(this, priv, enc); | ||
16549 | }; | ||
16550 | |||
16551 | EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) { | ||
16552 | return KeyPair.fromPublic(this, pub, enc); | ||
16553 | }; | ||
16554 | |||
16555 | EC.prototype.genKeyPair = function genKeyPair(options) { | ||
16556 | if (!options) | ||
16557 | options = {}; | ||
16558 | |||
16559 | // Instantiate Hmac_DRBG | ||
16560 | var drbg = new HmacDRBG({ | ||
16561 | hash: this.hash, | ||
16562 | pers: options.pers, | ||
16563 | persEnc: options.persEnc || 'utf8', | ||
16564 | entropy: options.entropy || elliptic.rand(this.hash.hmacStrength), | ||
16565 | entropyEnc: options.entropy && options.entropyEnc || 'utf8', | ||
16566 | nonce: this.n.toArray() | ||
16567 | }); | ||
16568 | |||
16569 | var bytes = this.n.byteLength(); | ||
16570 | var ns2 = this.n.sub(new BN(2)); | ||
16571 | do { | ||
16572 | var priv = new BN(drbg.generate(bytes)); | ||
16573 | if (priv.cmp(ns2) > 0) | ||
16574 | continue; | ||
16575 | |||
16576 | priv.iaddn(1); | ||
16577 | return this.keyFromPrivate(priv); | ||
16578 | } while (true); | ||
16579 | }; | ||
16580 | |||
16581 | EC.prototype._truncateToN = function truncateToN(msg, truncOnly) { | ||
16582 | var delta = msg.byteLength() * 8 - this.n.bitLength(); | ||
16583 | if (delta > 0) | ||
16584 | msg = msg.ushrn(delta); | ||
16585 | if (!truncOnly && msg.cmp(this.n) >= 0) | ||
16586 | return msg.sub(this.n); | ||
16587 | else | ||
16588 | return msg; | ||
16589 | }; | ||
16590 | |||
16591 | EC.prototype.sign = function sign(msg, key, enc, options) { | ||
16592 | if (typeof enc === 'object') { | ||
16593 | options = enc; | ||
16594 | enc = null; | ||
16595 | } | ||
16596 | if (!options) | ||
16597 | options = {}; | ||
16598 | |||
16599 | key = this.keyFromPrivate(key, enc); | ||
16600 | msg = this._truncateToN(new BN(msg, 16)); | ||
16601 | |||
16602 | // Zero-extend key to provide enough entropy | ||
16603 | var bytes = this.n.byteLength(); | ||
16604 | var bkey = key.getPrivate().toArray('be', bytes); | ||
16605 | |||
16606 | // Zero-extend nonce to have the same byte size as N | ||
16607 | var nonce = msg.toArray('be', bytes); | ||
16608 | |||
16609 | // Instantiate Hmac_DRBG | ||
16610 | var drbg = new HmacDRBG({ | ||
16611 | hash: this.hash, | ||
16612 | entropy: bkey, | ||
16613 | nonce: nonce, | ||
16614 | pers: options.pers, | ||
16615 | persEnc: options.persEnc || 'utf8' | ||
16616 | }); | ||
16617 | |||
16618 | // Number of bytes to generate | ||
16619 | var ns1 = this.n.sub(new BN(1)); | ||
16620 | |||
16621 | for (var iter = 0; true; iter++) { | ||
16622 | var k = options.k ? | ||
16623 | options.k(iter) : | ||
16624 | new BN(drbg.generate(this.n.byteLength())); | ||
16625 | k = this._truncateToN(k, true); | ||
16626 | if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) | ||
16627 | continue; | ||
16628 | |||
16629 | var kp = this.g.mul(k); | ||
16630 | if (kp.isInfinity()) | ||
16631 | continue; | ||
16632 | |||
16633 | var kpX = kp.getX(); | ||
16634 | var r = kpX.umod(this.n); | ||
16635 | if (r.cmpn(0) === 0) | ||
16636 | continue; | ||
16637 | |||
16638 | var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg)); | ||
16639 | s = s.umod(this.n); | ||
16640 | if (s.cmpn(0) === 0) | ||
16641 | continue; | ||
16642 | |||
16643 | var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | | ||
16644 | (kpX.cmp(r) !== 0 ? 2 : 0); | ||
16645 | |||
16646 | // Use complement of `s`, if it is > `n / 2` | ||
16647 | if (options.canonical && s.cmp(this.nh) > 0) { | ||
16648 | s = this.n.sub(s); | ||
16649 | recoveryParam ^= 1; | ||
16650 | } | ||
16651 | |||
16652 | return new Signature({ r: r, s: s, recoveryParam: recoveryParam }); | ||
16653 | } | ||
16654 | }; | ||
16655 | |||
16656 | EC.prototype.verify = function verify(msg, signature, key, enc) { | ||
16657 | msg = this._truncateToN(new BN(msg, 16)); | ||
16658 | key = this.keyFromPublic(key, enc); | ||
16659 | signature = new Signature(signature, 'hex'); | ||
16660 | |||
16661 | // Perform primitive values validation | ||
16662 | var r = signature.r; | ||
16663 | var s = signature.s; | ||
16664 | if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) | ||
16665 | return false; | ||
16666 | if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) | ||
16667 | return false; | ||
16668 | |||
16669 | // Validate signature | ||
16670 | var sinv = s.invm(this.n); | ||
16671 | var u1 = sinv.mul(msg).umod(this.n); | ||
16672 | var u2 = sinv.mul(r).umod(this.n); | ||
16673 | |||
16674 | if (!this.curve._maxwellTrick) { | ||
16675 | var p = this.g.mulAdd(u1, key.getPublic(), u2); | ||
16676 | if (p.isInfinity()) | ||
16677 | return false; | ||
16678 | |||
16679 | return p.getX().umod(this.n).cmp(r) === 0; | ||
16680 | } | ||
16681 | |||
16682 | // NOTE: Greg Maxwell's trick, inspired by: | ||
16683 | // https://git.io/vad3K | ||
16684 | |||
16685 | var p = this.g.jmulAdd(u1, key.getPublic(), u2); | ||
16686 | if (p.isInfinity()) | ||
16687 | return false; | ||
16688 | |||
16689 | // Compare `p.x` of Jacobian point with `r`, | ||
16690 | // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the | ||
16691 | // inverse of `p.z^2` | ||
16692 | return p.eqXToP(r); | ||
16693 | }; | ||
16694 | |||
16695 | EC.prototype.recoverPubKey = function(msg, signature, j, enc) { | ||
16696 | assert((3 & j) === j, 'The recovery param is more than two bits'); | ||
16697 | signature = new Signature(signature, enc); | ||
16698 | |||
16699 | var n = this.n; | ||
16700 | var e = new BN(msg); | ||
16701 | var r = signature.r; | ||
16702 | var s = signature.s; | ||
16703 | |||
16704 | // A set LSB signifies that the y-coordinate is odd | ||
16705 | var isYOdd = j & 1; | ||
16706 | var isSecondKey = j >> 1; | ||
16707 | if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) | ||
16708 | throw new Error('Unable to find sencond key candinate'); | ||
16709 | |||
16710 | // 1.1. Let x = r + jn. | ||
16711 | if (isSecondKey) | ||
16712 | r = this.curve.pointFromX(r.add(this.curve.n), isYOdd); | ||
16713 | else | ||
16714 | r = this.curve.pointFromX(r, isYOdd); | ||
16715 | |||
16716 | var rInv = signature.r.invm(n); | ||
16717 | var s1 = n.sub(e).mul(rInv).umod(n); | ||
16718 | var s2 = s.mul(rInv).umod(n); | ||
16719 | |||
16720 | // 1.6.1 Compute Q = r^-1 (sR - eG) | ||
16721 | // Q = r^-1 (sR + -eG) | ||
16722 | return this.g.mulAdd(s1, r, s2); | ||
16723 | }; | ||
16724 | |||
16725 | EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) { | ||
16726 | signature = new Signature(signature, enc); | ||
16727 | if (signature.recoveryParam !== null) | ||
16728 | return signature.recoveryParam; | ||
16729 | |||
16730 | for (var i = 0; i < 4; i++) { | ||
16731 | var Qprime; | ||
16732 | try { | ||
16733 | Qprime = this.recoverPubKey(e, signature, i); | ||
16734 | } catch (e) { | ||
16735 | continue; | ||
16736 | } | ||
16737 | |||
16738 | if (Qprime.eq(Q)) | ||
16739 | return i; | ||
16740 | } | ||
16741 | throw new Error('Unable to find valid recovery factor'); | ||
16742 | }; | ||
16743 | |||
16744 | },{"../../elliptic":83,"./key":91,"./signature":92,"bn.js":18,"hmac-drbg":114}],91:[function(require,module,exports){ | ||
16745 | 'use strict'; | ||
16746 | |||
16747 | var BN = require('bn.js'); | ||
16748 | var elliptic = require('../../elliptic'); | ||
16749 | var utils = elliptic.utils; | ||
16750 | var assert = utils.assert; | ||
16751 | |||
16752 | function KeyPair(ec, options) { | ||
16753 | this.ec = ec; | ||
16754 | this.priv = null; | ||
16755 | this.pub = null; | ||
16756 | |||
16757 | // KeyPair(ec, { priv: ..., pub: ... }) | ||
16758 | if (options.priv) | ||
16759 | this._importPrivate(options.priv, options.privEnc); | ||
16760 | if (options.pub) | ||
16761 | this._importPublic(options.pub, options.pubEnc); | ||
16762 | } | ||
16763 | module.exports = KeyPair; | ||
16764 | |||
16765 | KeyPair.fromPublic = function fromPublic(ec, pub, enc) { | ||
16766 | if (pub instanceof KeyPair) | ||
16767 | return pub; | ||
16768 | |||
16769 | return new KeyPair(ec, { | ||
16770 | pub: pub, | ||
16771 | pubEnc: enc | ||
16772 | }); | ||
16773 | }; | ||
16774 | |||
16775 | KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) { | ||
16776 | if (priv instanceof KeyPair) | ||
16777 | return priv; | ||
16778 | |||
16779 | return new KeyPair(ec, { | ||
16780 | priv: priv, | ||
16781 | privEnc: enc | ||
16782 | }); | ||
16783 | }; | ||
16784 | |||
16785 | KeyPair.prototype.validate = function validate() { | ||
16786 | var pub = this.getPublic(); | ||
16787 | |||
16788 | if (pub.isInfinity()) | ||
16789 | return { result: false, reason: 'Invalid public key' }; | ||
16790 | if (!pub.validate()) | ||
16791 | return { result: false, reason: 'Public key is not a point' }; | ||
16792 | if (!pub.mul(this.ec.curve.n).isInfinity()) | ||
16793 | return { result: false, reason: 'Public key * N != O' }; | ||
16794 | |||
16795 | return { result: true, reason: null }; | ||
16796 | }; | ||
16797 | |||
16798 | KeyPair.prototype.getPublic = function getPublic(compact, enc) { | ||
16799 | // compact is optional argument | ||
16800 | if (typeof compact === 'string') { | ||
16801 | enc = compact; | ||
16802 | compact = null; | ||
16803 | } | ||
16804 | |||
16805 | if (!this.pub) | ||
16806 | this.pub = this.ec.g.mul(this.priv); | ||
16807 | |||
16808 | if (!enc) | ||
16809 | return this.pub; | ||
16810 | |||
16811 | return this.pub.encode(enc, compact); | ||
16812 | }; | ||
16813 | |||
16814 | KeyPair.prototype.getPrivate = function getPrivate(enc) { | ||
16815 | if (enc === 'hex') | ||
16816 | return this.priv.toString(16, 2); | ||
16817 | else | ||
16818 | return this.priv; | ||
16819 | }; | ||
16820 | |||
16821 | KeyPair.prototype._importPrivate = function _importPrivate(key, enc) { | ||
16822 | this.priv = new BN(key, enc || 16); | ||
16823 | |||
16824 | // Ensure that the priv won't be bigger than n, otherwise we may fail | ||
16825 | // in fixed multiplication method | ||
16826 | this.priv = this.priv.umod(this.ec.curve.n); | ||
16827 | }; | ||
16828 | |||
16829 | KeyPair.prototype._importPublic = function _importPublic(key, enc) { | ||
16830 | if (key.x || key.y) { | ||
16831 | // Montgomery points only have an `x` coordinate. | ||
16832 | // Weierstrass/Edwards points on the other hand have both `x` and | ||
16833 | // `y` coordinates. | ||
16834 | if (this.ec.curve.type === 'mont') { | ||
16835 | assert(key.x, 'Need x coordinate'); | ||
16836 | } else if (this.ec.curve.type === 'short' || | ||
16837 | this.ec.curve.type === 'edwards') { | ||
16838 | assert(key.x && key.y, 'Need both x and y coordinate'); | ||
16839 | } | ||
16840 | this.pub = this.ec.curve.point(key.x, key.y); | ||
16841 | return; | ||
16842 | } | ||
16843 | this.pub = this.ec.curve.decodePoint(key, enc); | ||
16844 | }; | ||
16845 | |||
16846 | // ECDH | ||
16847 | KeyPair.prototype.derive = function derive(pub) { | ||
16848 | return pub.mul(this.priv).getX(); | ||
16849 | }; | ||
16850 | |||
16851 | // ECDSA | ||
16852 | KeyPair.prototype.sign = function sign(msg, enc, options) { | ||
16853 | return this.ec.sign(msg, this, enc, options); | ||
16854 | }; | ||
16855 | |||
16856 | KeyPair.prototype.verify = function verify(msg, signature) { | ||
16857 | return this.ec.verify(msg, signature, this); | ||
16858 | }; | ||
16859 | |||
16860 | KeyPair.prototype.inspect = function inspect() { | ||
16861 | return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) + | ||
16862 | ' pub: ' + (this.pub && this.pub.inspect()) + ' >'; | ||
16863 | }; | ||
16864 | |||
16865 | },{"../../elliptic":83,"bn.js":18}],92:[function(require,module,exports){ | ||
16866 | 'use strict'; | ||
16867 | |||
16868 | var BN = require('bn.js'); | ||
16869 | |||
16870 | var elliptic = require('../../elliptic'); | ||
16871 | var utils = elliptic.utils; | ||
16872 | var assert = utils.assert; | ||
16873 | |||
16874 | function Signature(options, enc) { | ||
16875 | if (options instanceof Signature) | ||
16876 | return options; | ||
16877 | |||
16878 | if (this._importDER(options, enc)) | ||
16879 | return; | ||
16880 | |||
16881 | assert(options.r && options.s, 'Signature without r or s'); | ||
16882 | this.r = new BN(options.r, 16); | ||
16883 | this.s = new BN(options.s, 16); | ||
16884 | if (options.recoveryParam === undefined) | ||
16885 | this.recoveryParam = null; | ||
16886 | else | ||
16887 | this.recoveryParam = options.recoveryParam; | ||
16888 | } | ||
16889 | module.exports = Signature; | ||
16890 | |||
16891 | function Position() { | ||
16892 | this.place = 0; | ||
16893 | } | ||
16894 | |||
16895 | function getLength(buf, p) { | ||
16896 | var initial = buf[p.place++]; | ||
16897 | if (!(initial & 0x80)) { | ||
16898 | return initial; | ||
16899 | } | ||
16900 | var octetLen = initial & 0xf; | ||
16901 | var val = 0; | ||
16902 | for (var i = 0, off = p.place; i < octetLen; i++, off++) { | ||
16903 | val <<= 8; | ||
16904 | val |= buf[off]; | ||
16905 | } | ||
16906 | p.place = off; | ||
16907 | return val; | ||
16908 | } | ||
16909 | |||
16910 | function rmPadding(buf) { | ||
16911 | var i = 0; | ||
16912 | var len = buf.length - 1; | ||
16913 | while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) { | ||
16914 | i++; | ||
16915 | } | ||
16916 | if (i === 0) { | ||
16917 | return buf; | ||
16918 | } | ||
16919 | return buf.slice(i); | ||
16920 | } | ||
16921 | |||
16922 | Signature.prototype._importDER = function _importDER(data, enc) { | ||
16923 | data = utils.toArray(data, enc); | ||
16924 | var p = new Position(); | ||
16925 | if (data[p.place++] !== 0x30) { | ||
16926 | return false; | ||
16927 | } | ||
16928 | var len = getLength(data, p); | ||
16929 | if ((len + p.place) !== data.length) { | ||
16930 | return false; | ||
16931 | } | ||
16932 | if (data[p.place++] !== 0x02) { | ||
16933 | return false; | ||
16934 | } | ||
16935 | var rlen = getLength(data, p); | ||
16936 | var r = data.slice(p.place, rlen + p.place); | ||
16937 | p.place += rlen; | ||
16938 | if (data[p.place++] !== 0x02) { | ||
16939 | return false; | ||
16940 | } | ||
16941 | var slen = getLength(data, p); | ||
16942 | if (data.length !== slen + p.place) { | ||
16943 | return false; | ||
16944 | } | ||
16945 | var s = data.slice(p.place, slen + p.place); | ||
16946 | if (r[0] === 0 && (r[1] & 0x80)) { | ||
16947 | r = r.slice(1); | ||
16948 | } | ||
16949 | if (s[0] === 0 && (s[1] & 0x80)) { | ||
16950 | s = s.slice(1); | ||
16951 | } | ||
16952 | |||
16953 | this.r = new BN(r); | ||
16954 | this.s = new BN(s); | ||
16955 | this.recoveryParam = null; | ||
16956 | |||
16957 | return true; | ||
16958 | }; | ||
16959 | |||
16960 | function constructLength(arr, len) { | ||
16961 | if (len < 0x80) { | ||
16962 | arr.push(len); | ||
16963 | return; | ||
16964 | } | ||
16965 | var octets = 1 + (Math.log(len) / Math.LN2 >>> 3); | ||
16966 | arr.push(octets | 0x80); | ||
16967 | while (--octets) { | ||
16968 | arr.push((len >>> (octets << 3)) & 0xff); | ||
16969 | } | ||
16970 | arr.push(len); | ||
16971 | } | ||
16972 | |||
16973 | Signature.prototype.toDER = function toDER(enc) { | ||
16974 | var r = this.r.toArray(); | ||
16975 | var s = this.s.toArray(); | ||
16976 | |||
16977 | // Pad values | ||
16978 | if (r[0] & 0x80) | ||
16979 | r = [ 0 ].concat(r); | ||
16980 | // Pad values | ||
16981 | if (s[0] & 0x80) | ||
16982 | s = [ 0 ].concat(s); | ||
16983 | |||
16984 | r = rmPadding(r); | ||
16985 | s = rmPadding(s); | ||
16986 | |||
16987 | while (!s[0] && !(s[1] & 0x80)) { | ||
16988 | s = s.slice(1); | ||
16989 | } | ||
16990 | var arr = [ 0x02 ]; | ||
16991 | constructLength(arr, r.length); | ||
16992 | arr = arr.concat(r); | ||
16993 | arr.push(0x02); | ||
16994 | constructLength(arr, s.length); | ||
16995 | var backHalf = arr.concat(s); | ||
16996 | var res = [ 0x30 ]; | ||
16997 | constructLength(res, backHalf.length); | ||
16998 | res = res.concat(backHalf); | ||
16999 | return utils.encode(res, enc); | ||
17000 | }; | ||
17001 | |||
17002 | },{"../../elliptic":83,"bn.js":18}],93:[function(require,module,exports){ | ||
17003 | 'use strict'; | ||
17004 | |||
17005 | var hash = require('hash.js'); | ||
17006 | var elliptic = require('../../elliptic'); | ||
17007 | var utils = elliptic.utils; | ||
17008 | var assert = utils.assert; | ||
17009 | var parseBytes = utils.parseBytes; | ||
17010 | var KeyPair = require('./key'); | ||
17011 | var Signature = require('./signature'); | ||
17012 | |||
17013 | function EDDSA(curve) { | ||
17014 | assert(curve === 'ed25519', 'only tested with ed25519 so far'); | ||
17015 | |||
17016 | if (!(this instanceof EDDSA)) | ||
17017 | return new EDDSA(curve); | ||
17018 | |||
17019 | var curve = elliptic.curves[curve].curve; | ||
17020 | this.curve = curve; | ||
17021 | this.g = curve.g; | ||
17022 | this.g.precompute(curve.n.bitLength() + 1); | ||
17023 | |||
17024 | this.pointClass = curve.point().constructor; | ||
17025 | this.encodingLength = Math.ceil(curve.n.bitLength() / 8); | ||
17026 | this.hash = hash.sha512; | ||
17027 | } | ||
17028 | |||
17029 | module.exports = EDDSA; | ||
17030 | |||
17031 | /** | ||
17032 | * @param {Array|String} message - message bytes | ||
17033 | * @param {Array|String|KeyPair} secret - secret bytes or a keypair | ||
17034 | * @returns {Signature} - signature | ||
17035 | */ | ||
17036 | EDDSA.prototype.sign = function sign(message, secret) { | ||
17037 | message = parseBytes(message); | ||
17038 | var key = this.keyFromSecret(secret); | ||
17039 | var r = this.hashInt(key.messagePrefix(), message); | ||
17040 | var R = this.g.mul(r); | ||
17041 | var Rencoded = this.encodePoint(R); | ||
17042 | var s_ = this.hashInt(Rencoded, key.pubBytes(), message) | ||
17043 | .mul(key.priv()); | ||
17044 | var S = r.add(s_).umod(this.curve.n); | ||
17045 | return this.makeSignature({ R: R, S: S, Rencoded: Rencoded }); | ||
17046 | }; | ||
17047 | |||
17048 | /** | ||
17049 | * @param {Array} message - message bytes | ||
17050 | * @param {Array|String|Signature} sig - sig bytes | ||
17051 | * @param {Array|String|Point|KeyPair} pub - public key | ||
17052 | * @returns {Boolean} - true if public key matches sig of message | ||
17053 | */ | ||
17054 | EDDSA.prototype.verify = function verify(message, sig, pub) { | ||
17055 | message = parseBytes(message); | ||
17056 | sig = this.makeSignature(sig); | ||
17057 | var key = this.keyFromPublic(pub); | ||
17058 | var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message); | ||
17059 | var SG = this.g.mul(sig.S()); | ||
17060 | var RplusAh = sig.R().add(key.pub().mul(h)); | ||
17061 | return RplusAh.eq(SG); | ||
17062 | }; | ||
17063 | |||
17064 | EDDSA.prototype.hashInt = function hashInt() { | ||
17065 | var hash = this.hash(); | ||
17066 | for (var i = 0; i < arguments.length; i++) | ||
17067 | hash.update(arguments[i]); | ||
17068 | return utils.intFromLE(hash.digest()).umod(this.curve.n); | ||
17069 | }; | ||
17070 | |||
17071 | EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) { | ||
17072 | return KeyPair.fromPublic(this, pub); | ||
17073 | }; | ||
17074 | |||
17075 | EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) { | ||
17076 | return KeyPair.fromSecret(this, secret); | ||
17077 | }; | ||
17078 | |||
17079 | EDDSA.prototype.makeSignature = function makeSignature(sig) { | ||
17080 | if (sig instanceof Signature) | ||
17081 | return sig; | ||
17082 | return new Signature(this, sig); | ||
17083 | }; | ||
17084 | |||
17085 | /** | ||
17086 | * * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2 | ||
17087 | * | ||
17088 | * EDDSA defines methods for encoding and decoding points and integers. These are | ||
17089 | * helper convenience methods, that pass along to utility functions implied | ||
17090 | * parameters. | ||
17091 | * | ||
17092 | */ | ||
17093 | EDDSA.prototype.encodePoint = function encodePoint(point) { | ||
17094 | var enc = point.getY().toArray('le', this.encodingLength); | ||
17095 | enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0; | ||
17096 | return enc; | ||
17097 | }; | ||
17098 | |||
17099 | EDDSA.prototype.decodePoint = function decodePoint(bytes) { | ||
17100 | bytes = utils.parseBytes(bytes); | ||
17101 | |||
17102 | var lastIx = bytes.length - 1; | ||
17103 | var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80); | ||
17104 | var xIsOdd = (bytes[lastIx] & 0x80) !== 0; | ||
17105 | |||
17106 | var y = utils.intFromLE(normed); | ||
17107 | return this.curve.pointFromY(y, xIsOdd); | ||
17108 | }; | ||
17109 | |||
17110 | EDDSA.prototype.encodeInt = function encodeInt(num) { | ||
17111 | return num.toArray('le', this.encodingLength); | ||
17112 | }; | ||
17113 | |||
17114 | EDDSA.prototype.decodeInt = function decodeInt(bytes) { | ||
17115 | return utils.intFromLE(bytes); | ||
17116 | }; | ||
17117 | |||
17118 | EDDSA.prototype.isPoint = function isPoint(val) { | ||
17119 | return val instanceof this.pointClass; | ||
17120 | }; | ||
17121 | |||
17122 | },{"../../elliptic":83,"./key":94,"./signature":95,"hash.js":102}],94:[function(require,module,exports){ | ||
17123 | 'use strict'; | ||
17124 | |||
17125 | var elliptic = require('../../elliptic'); | ||
17126 | var utils = elliptic.utils; | ||
17127 | var assert = utils.assert; | ||
17128 | var parseBytes = utils.parseBytes; | ||
17129 | var cachedProperty = utils.cachedProperty; | ||
17130 | |||
17131 | /** | ||
17132 | * @param {EDDSA} eddsa - instance | ||
17133 | * @param {Object} params - public/private key parameters | ||
17134 | * | ||
17135 | * @param {Array<Byte>} [params.secret] - secret seed bytes | ||
17136 | * @param {Point} [params.pub] - public key point (aka `A` in eddsa terms) | ||
17137 | * @param {Array<Byte>} [params.pub] - public key point encoded as bytes | ||
17138 | * | ||
17139 | */ | ||
17140 | function KeyPair(eddsa, params) { | ||
17141 | this.eddsa = eddsa; | ||
17142 | this._secret = parseBytes(params.secret); | ||
17143 | if (eddsa.isPoint(params.pub)) | ||
17144 | this._pub = params.pub; | ||
17145 | else | ||
17146 | this._pubBytes = parseBytes(params.pub); | ||
17147 | } | ||
17148 | |||
17149 | KeyPair.fromPublic = function fromPublic(eddsa, pub) { | ||
17150 | if (pub instanceof KeyPair) | ||
17151 | return pub; | ||
17152 | return new KeyPair(eddsa, { pub: pub }); | ||
17153 | }; | ||
17154 | |||
17155 | KeyPair.fromSecret = function fromSecret(eddsa, secret) { | ||
17156 | if (secret instanceof KeyPair) | ||
17157 | return secret; | ||
17158 | return new KeyPair(eddsa, { secret: secret }); | ||
17159 | }; | ||
17160 | |||
17161 | KeyPair.prototype.secret = function secret() { | ||
17162 | return this._secret; | ||
17163 | }; | ||
17164 | |||
17165 | cachedProperty(KeyPair, 'pubBytes', function pubBytes() { | ||
17166 | return this.eddsa.encodePoint(this.pub()); | ||
17167 | }); | ||
17168 | |||
17169 | cachedProperty(KeyPair, 'pub', function pub() { | ||
17170 | if (this._pubBytes) | ||
17171 | return this.eddsa.decodePoint(this._pubBytes); | ||
17172 | return this.eddsa.g.mul(this.priv()); | ||
17173 | }); | ||
17174 | |||
17175 | cachedProperty(KeyPair, 'privBytes', function privBytes() { | ||
17176 | var eddsa = this.eddsa; | ||
17177 | var hash = this.hash(); | ||
17178 | var lastIx = eddsa.encodingLength - 1; | ||
17179 | |||
17180 | var a = hash.slice(0, eddsa.encodingLength); | ||
17181 | a[0] &= 248; | ||
17182 | a[lastIx] &= 127; | ||
17183 | a[lastIx] |= 64; | ||
17184 | |||
17185 | return a; | ||
17186 | }); | ||
17187 | |||
17188 | cachedProperty(KeyPair, 'priv', function priv() { | ||
17189 | return this.eddsa.decodeInt(this.privBytes()); | ||
17190 | }); | ||
17191 | |||
17192 | cachedProperty(KeyPair, 'hash', function hash() { | ||
17193 | return this.eddsa.hash().update(this.secret()).digest(); | ||
17194 | }); | ||
17195 | |||
17196 | cachedProperty(KeyPair, 'messagePrefix', function messagePrefix() { | ||
17197 | return this.hash().slice(this.eddsa.encodingLength); | ||
17198 | }); | ||
17199 | |||
17200 | KeyPair.prototype.sign = function sign(message) { | ||
17201 | assert(this._secret, 'KeyPair can only verify'); | ||
17202 | return this.eddsa.sign(message, this); | ||
17203 | }; | ||
17204 | |||
17205 | KeyPair.prototype.verify = function verify(message, sig) { | ||
17206 | return this.eddsa.verify(message, sig, this); | ||
17207 | }; | ||
17208 | |||
17209 | KeyPair.prototype.getSecret = function getSecret(enc) { | ||
17210 | assert(this._secret, 'KeyPair is public only'); | ||
17211 | return utils.encode(this.secret(), enc); | ||
17212 | }; | ||
17213 | |||
17214 | KeyPair.prototype.getPublic = function getPublic(enc) { | ||
17215 | return utils.encode(this.pubBytes(), enc); | ||
17216 | }; | ||
17217 | |||
17218 | module.exports = KeyPair; | ||
17219 | |||
17220 | },{"../../elliptic":83}],95:[function(require,module,exports){ | ||
17221 | 'use strict'; | ||
17222 | |||
17223 | var BN = require('bn.js'); | ||
17224 | var elliptic = require('../../elliptic'); | ||
17225 | var utils = elliptic.utils; | ||
17226 | var assert = utils.assert; | ||
17227 | var cachedProperty = utils.cachedProperty; | ||
17228 | var parseBytes = utils.parseBytes; | ||
17229 | |||
17230 | /** | ||
17231 | * @param {EDDSA} eddsa - eddsa instance | ||
17232 | * @param {Array<Bytes>|Object} sig - | ||
17233 | * @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes | ||
17234 | * @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes | ||
17235 | * @param {Array<Bytes>} [sig.Rencoded] - R point encoded | ||
17236 | * @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded | ||
17237 | */ | ||
17238 | function Signature(eddsa, sig) { | ||
17239 | this.eddsa = eddsa; | ||
17240 | |||
17241 | if (typeof sig !== 'object') | ||
17242 | sig = parseBytes(sig); | ||
17243 | |||
17244 | if (Array.isArray(sig)) { | ||
17245 | sig = { | ||
17246 | R: sig.slice(0, eddsa.encodingLength), | ||
17247 | S: sig.slice(eddsa.encodingLength) | ||
17248 | }; | ||
17249 | } | ||
17250 | |||
17251 | assert(sig.R && sig.S, 'Signature without R or S'); | ||
17252 | |||
17253 | if (eddsa.isPoint(sig.R)) | ||
17254 | this._R = sig.R; | ||
17255 | if (sig.S instanceof BN) | ||
17256 | this._S = sig.S; | ||
17257 | |||
17258 | this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded; | ||
17259 | this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded; | ||
17260 | } | ||
17261 | |||
17262 | cachedProperty(Signature, 'S', function S() { | ||
17263 | return this.eddsa.decodeInt(this.Sencoded()); | ||
17264 | }); | ||
17265 | |||
17266 | cachedProperty(Signature, 'R', function R() { | ||
17267 | return this.eddsa.decodePoint(this.Rencoded()); | ||
17268 | }); | ||
17269 | |||
17270 | cachedProperty(Signature, 'Rencoded', function Rencoded() { | ||
17271 | return this.eddsa.encodePoint(this.R()); | ||
17272 | }); | ||
17273 | |||
17274 | cachedProperty(Signature, 'Sencoded', function Sencoded() { | ||
17275 | return this.eddsa.encodeInt(this.S()); | ||
17276 | }); | ||
17277 | |||
17278 | Signature.prototype.toBytes = function toBytes() { | ||
17279 | return this.Rencoded().concat(this.Sencoded()); | ||
17280 | }; | ||
17281 | |||
17282 | Signature.prototype.toHex = function toHex() { | ||
17283 | return utils.encode(this.toBytes(), 'hex').toUpperCase(); | ||
17284 | }; | ||
17285 | |||
17286 | module.exports = Signature; | ||
17287 | |||
17288 | },{"../../elliptic":83,"bn.js":18}],96:[function(require,module,exports){ | ||
17289 | module.exports = { | ||
17290 | doubles: { | ||
17291 | step: 4, | ||
17292 | points: [ | ||
17293 | [ | ||
17294 | 'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a', | ||
17295 | 'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821' | ||
17296 | ], | ||
17297 | [ | ||
17298 | '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508', | ||
17299 | '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf' | ||
17300 | ], | ||
17301 | [ | ||
17302 | '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739', | ||
17303 | 'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695' | ||
17304 | ], | ||
17305 | [ | ||
17306 | '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640', | ||
17307 | '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9' | ||
17308 | ], | ||
17309 | [ | ||
17310 | '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c', | ||
17311 | '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36' | ||
17312 | ], | ||
17313 | [ | ||
17314 | '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda', | ||
17315 | '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f' | ||
17316 | ], | ||
17317 | [ | ||
17318 | 'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa', | ||
17319 | '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999' | ||
17320 | ], | ||
17321 | [ | ||
17322 | '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0', | ||
17323 | 'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09' | ||
17324 | ], | ||
17325 | [ | ||
17326 | 'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d', | ||
17327 | '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d' | ||
17328 | ], | ||
17329 | [ | ||
17330 | 'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d', | ||
17331 | 'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088' | ||
17332 | ], | ||
17333 | [ | ||
17334 | 'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1', | ||
17335 | '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d' | ||
17336 | ], | ||
17337 | [ | ||
17338 | '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0', | ||
17339 | '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8' | ||
17340 | ], | ||
17341 | [ | ||
17342 | '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047', | ||
17343 | '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a' | ||
17344 | ], | ||
17345 | [ | ||
17346 | '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862', | ||
17347 | '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453' | ||
17348 | ], | ||
17349 | [ | ||
17350 | '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7', | ||
17351 | '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160' | ||
17352 | ], | ||
17353 | [ | ||
17354 | '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd', | ||
17355 | '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0' | ||
17356 | ], | ||
17357 | [ | ||
17358 | '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83', | ||
17359 | '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6' | ||
17360 | ], | ||
17361 | [ | ||
17362 | '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a', | ||
17363 | '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589' | ||
17364 | ], | ||
17365 | [ | ||
17366 | '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8', | ||
17367 | 'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17' | ||
17368 | ], | ||
17369 | [ | ||
17370 | 'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d', | ||
17371 | '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda' | ||
17372 | ], | ||
17373 | [ | ||
17374 | 'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725', | ||
17375 | '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd' | ||
17376 | ], | ||
17377 | [ | ||
17378 | '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754', | ||
17379 | '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2' | ||
17380 | ], | ||
17381 | [ | ||
17382 | '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c', | ||
17383 | '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6' | ||
17384 | ], | ||
17385 | [ | ||
17386 | 'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6', | ||
17387 | '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f' | ||
17388 | ], | ||
17389 | [ | ||
17390 | '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39', | ||
17391 | 'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01' | ||
17392 | ], | ||
17393 | [ | ||
17394 | 'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891', | ||
17395 | '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3' | ||
17396 | ], | ||
17397 | [ | ||
17398 | 'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b', | ||
17399 | 'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f' | ||
17400 | ], | ||
17401 | [ | ||
17402 | 'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03', | ||
17403 | '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7' | ||
17404 | ], | ||
17405 | [ | ||
17406 | 'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d', | ||
17407 | 'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78' | ||
17408 | ], | ||
17409 | [ | ||
17410 | 'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070', | ||
17411 | '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1' | ||
17412 | ], | ||
17413 | [ | ||
17414 | '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4', | ||
17415 | 'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150' | ||
17416 | ], | ||
17417 | [ | ||
17418 | '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da', | ||
17419 | '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82' | ||
17420 | ], | ||
17421 | [ | ||
17422 | 'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11', | ||
17423 | '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc' | ||
17424 | ], | ||
17425 | [ | ||
17426 | '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e', | ||
17427 | 'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b' | ||
17428 | ], | ||
17429 | [ | ||
17430 | 'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41', | ||
17431 | '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51' | ||
17432 | ], | ||
17433 | [ | ||
17434 | 'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef', | ||
17435 | '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45' | ||
17436 | ], | ||
17437 | [ | ||
17438 | 'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8', | ||
17439 | 'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120' | ||
17440 | ], | ||
17441 | [ | ||
17442 | '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d', | ||
17443 | '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84' | ||
17444 | ], | ||
17445 | [ | ||
17446 | '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96', | ||
17447 | '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d' | ||
17448 | ], | ||
17449 | [ | ||
17450 | '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd', | ||
17451 | 'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d' | ||
17452 | ], | ||
17453 | [ | ||
17454 | '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5', | ||
17455 | '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8' | ||
17456 | ], | ||
17457 | [ | ||
17458 | 'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266', | ||
17459 | '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8' | ||
17460 | ], | ||
17461 | [ | ||
17462 | '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71', | ||
17463 | '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac' | ||
17464 | ], | ||
17465 | [ | ||
17466 | '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac', | ||
17467 | 'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f' | ||
17468 | ], | ||
17469 | [ | ||
17470 | '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751', | ||
17471 | '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962' | ||
17472 | ], | ||
17473 | [ | ||
17474 | 'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e', | ||
17475 | '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907' | ||
17476 | ], | ||
17477 | [ | ||
17478 | '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241', | ||
17479 | 'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec' | ||
17480 | ], | ||
17481 | [ | ||
17482 | 'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3', | ||
17483 | 'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d' | ||
17484 | ], | ||
17485 | [ | ||
17486 | 'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f', | ||
17487 | '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414' | ||
17488 | ], | ||
17489 | [ | ||
17490 | '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19', | ||
17491 | 'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd' | ||
17492 | ], | ||
17493 | [ | ||
17494 | '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be', | ||
17495 | 'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0' | ||
17496 | ], | ||
17497 | [ | ||
17498 | 'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9', | ||
17499 | '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811' | ||
17500 | ], | ||
17501 | [ | ||
17502 | 'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2', | ||
17503 | '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1' | ||
17504 | ], | ||
17505 | [ | ||
17506 | 'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13', | ||
17507 | '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c' | ||
17508 | ], | ||
17509 | [ | ||
17510 | '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c', | ||
17511 | 'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73' | ||
17512 | ], | ||
17513 | [ | ||
17514 | '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba', | ||
17515 | '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd' | ||
17516 | ], | ||
17517 | [ | ||
17518 | 'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151', | ||
17519 | 'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405' | ||
17520 | ], | ||
17521 | [ | ||
17522 | '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073', | ||
17523 | 'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589' | ||
17524 | ], | ||
17525 | [ | ||
17526 | '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458', | ||
17527 | '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e' | ||
17528 | ], | ||
17529 | [ | ||
17530 | '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b', | ||
17531 | '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27' | ||
17532 | ], | ||
17533 | [ | ||
17534 | 'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366', | ||
17535 | 'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1' | ||
17536 | ], | ||
17537 | [ | ||
17538 | '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa', | ||
17539 | '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482' | ||
17540 | ], | ||
17541 | [ | ||
17542 | '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0', | ||
17543 | '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945' | ||
17544 | ], | ||
17545 | [ | ||
17546 | 'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787', | ||
17547 | '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573' | ||
17548 | ], | ||
17549 | [ | ||
17550 | 'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e', | ||
17551 | 'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82' | ||
17552 | ] | ||
17553 | ] | ||
17554 | }, | ||
17555 | naf: { | ||
17556 | wnd: 7, | ||
17557 | points: [ | ||
17558 | [ | ||
17559 | 'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9', | ||
17560 | '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672' | ||
17561 | ], | ||
17562 | [ | ||
17563 | '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4', | ||
17564 | 'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6' | ||
17565 | ], | ||
17566 | [ | ||
17567 | '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc', | ||
17568 | '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da' | ||
17569 | ], | ||
17570 | [ | ||
17571 | 'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe', | ||
17572 | 'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37' | ||
17573 | ], | ||
17574 | [ | ||
17575 | '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb', | ||
17576 | 'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b' | ||
17577 | ], | ||
17578 | [ | ||
17579 | 'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8', | ||
17580 | 'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81' | ||
17581 | ], | ||
17582 | [ | ||
17583 | 'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e', | ||
17584 | '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58' | ||
17585 | ], | ||
17586 | [ | ||
17587 | 'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34', | ||
17588 | '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77' | ||
17589 | ], | ||
17590 | [ | ||
17591 | '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c', | ||
17592 | '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a' | ||
17593 | ], | ||
17594 | [ | ||
17595 | '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5', | ||
17596 | '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c' | ||
17597 | ], | ||
17598 | [ | ||
17599 | '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f', | ||
17600 | '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67' | ||
17601 | ], | ||
17602 | [ | ||
17603 | '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714', | ||
17604 | '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402' | ||
17605 | ], | ||
17606 | [ | ||
17607 | 'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729', | ||
17608 | 'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55' | ||
17609 | ], | ||
17610 | [ | ||
17611 | 'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db', | ||
17612 | '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482' | ||
17613 | ], | ||
17614 | [ | ||
17615 | '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4', | ||
17616 | 'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82' | ||
17617 | ], | ||
17618 | [ | ||
17619 | '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5', | ||
17620 | 'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396' | ||
17621 | ], | ||
17622 | [ | ||
17623 | '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479', | ||
17624 | '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49' | ||
17625 | ], | ||
17626 | [ | ||
17627 | '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d', | ||
17628 | '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf' | ||
17629 | ], | ||
17630 | [ | ||
17631 | '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f', | ||
17632 | '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a' | ||
17633 | ], | ||
17634 | [ | ||
17635 | '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb', | ||
17636 | 'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7' | ||
17637 | ], | ||
17638 | [ | ||
17639 | 'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9', | ||
17640 | 'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933' | ||
17641 | ], | ||
17642 | [ | ||
17643 | '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963', | ||
17644 | '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a' | ||
17645 | ], | ||
17646 | [ | ||
17647 | '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74', | ||
17648 | '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6' | ||
17649 | ], | ||
17650 | [ | ||
17651 | 'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530', | ||
17652 | 'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37' | ||
17653 | ], | ||
17654 | [ | ||
17655 | '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b', | ||
17656 | '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e' | ||
17657 | ], | ||
17658 | [ | ||
17659 | 'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247', | ||
17660 | 'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6' | ||
17661 | ], | ||
17662 | [ | ||
17663 | 'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1', | ||
17664 | 'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476' | ||
17665 | ], | ||
17666 | [ | ||
17667 | '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120', | ||
17668 | '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40' | ||
17669 | ], | ||
17670 | [ | ||
17671 | '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435', | ||
17672 | '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61' | ||
17673 | ], | ||
17674 | [ | ||
17675 | '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18', | ||
17676 | '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683' | ||
17677 | ], | ||
17678 | [ | ||
17679 | 'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8', | ||
17680 | '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5' | ||
17681 | ], | ||
17682 | [ | ||
17683 | '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb', | ||
17684 | '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b' | ||
17685 | ], | ||
17686 | [ | ||
17687 | 'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f', | ||
17688 | '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417' | ||
17689 | ], | ||
17690 | [ | ||
17691 | '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143', | ||
17692 | 'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868' | ||
17693 | ], | ||
17694 | [ | ||
17695 | '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba', | ||
17696 | 'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a' | ||
17697 | ], | ||
17698 | [ | ||
17699 | 'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45', | ||
17700 | 'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6' | ||
17701 | ], | ||
17702 | [ | ||
17703 | '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a', | ||
17704 | '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996' | ||
17705 | ], | ||
17706 | [ | ||
17707 | '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e', | ||
17708 | 'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e' | ||
17709 | ], | ||
17710 | [ | ||
17711 | 'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8', | ||
17712 | 'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d' | ||
17713 | ], | ||
17714 | [ | ||
17715 | '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c', | ||
17716 | '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2' | ||
17717 | ], | ||
17718 | [ | ||
17719 | '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519', | ||
17720 | 'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e' | ||
17721 | ], | ||
17722 | [ | ||
17723 | '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab', | ||
17724 | '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437' | ||
17725 | ], | ||
17726 | [ | ||
17727 | '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca', | ||
17728 | 'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311' | ||
17729 | ], | ||
17730 | [ | ||
17731 | 'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf', | ||
17732 | '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4' | ||
17733 | ], | ||
17734 | [ | ||
17735 | '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610', | ||
17736 | '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575' | ||
17737 | ], | ||
17738 | [ | ||
17739 | '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4', | ||
17740 | 'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d' | ||
17741 | ], | ||
17742 | [ | ||
17743 | '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c', | ||
17744 | 'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d' | ||
17745 | ], | ||
17746 | [ | ||
17747 | 'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940', | ||
17748 | 'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629' | ||
17749 | ], | ||
17750 | [ | ||
17751 | 'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980', | ||
17752 | 'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06' | ||
17753 | ], | ||
17754 | [ | ||
17755 | '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3', | ||
17756 | '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374' | ||
17757 | ], | ||
17758 | [ | ||
17759 | '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf', | ||
17760 | '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee' | ||
17761 | ], | ||
17762 | [ | ||
17763 | 'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63', | ||
17764 | '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1' | ||
17765 | ], | ||
17766 | [ | ||
17767 | 'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448', | ||
17768 | 'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b' | ||
17769 | ], | ||
17770 | [ | ||
17771 | '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf', | ||
17772 | '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661' | ||
17773 | ], | ||
17774 | [ | ||
17775 | '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5', | ||
17776 | '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6' | ||
17777 | ], | ||
17778 | [ | ||
17779 | 'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6', | ||
17780 | '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e' | ||
17781 | ], | ||
17782 | [ | ||
17783 | '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5', | ||
17784 | '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d' | ||
17785 | ], | ||
17786 | [ | ||
17787 | 'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99', | ||
17788 | 'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc' | ||
17789 | ], | ||
17790 | [ | ||
17791 | '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51', | ||
17792 | 'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4' | ||
17793 | ], | ||
17794 | [ | ||
17795 | '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5', | ||
17796 | '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c' | ||
17797 | ], | ||
17798 | [ | ||
17799 | 'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5', | ||
17800 | '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b' | ||
17801 | ], | ||
17802 | [ | ||
17803 | 'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997', | ||
17804 | '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913' | ||
17805 | ], | ||
17806 | [ | ||
17807 | '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881', | ||
17808 | '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154' | ||
17809 | ], | ||
17810 | [ | ||
17811 | '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5', | ||
17812 | '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865' | ||
17813 | ], | ||
17814 | [ | ||
17815 | '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66', | ||
17816 | 'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc' | ||
17817 | ], | ||
17818 | [ | ||
17819 | '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726', | ||
17820 | 'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224' | ||
17821 | ], | ||
17822 | [ | ||
17823 | '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede', | ||
17824 | '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e' | ||
17825 | ], | ||
17826 | [ | ||
17827 | '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94', | ||
17828 | '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6' | ||
17829 | ], | ||
17830 | [ | ||
17831 | '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31', | ||
17832 | '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511' | ||
17833 | ], | ||
17834 | [ | ||
17835 | '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51', | ||
17836 | 'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b' | ||
17837 | ], | ||
17838 | [ | ||
17839 | 'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252', | ||
17840 | 'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2' | ||
17841 | ], | ||
17842 | [ | ||
17843 | '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5', | ||
17844 | 'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c' | ||
17845 | ], | ||
17846 | [ | ||
17847 | 'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b', | ||
17848 | '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3' | ||
17849 | ], | ||
17850 | [ | ||
17851 | 'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4', | ||
17852 | '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d' | ||
17853 | ], | ||
17854 | [ | ||
17855 | 'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f', | ||
17856 | '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700' | ||
17857 | ], | ||
17858 | [ | ||
17859 | 'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889', | ||
17860 | '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4' | ||
17861 | ], | ||
17862 | [ | ||
17863 | '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246', | ||
17864 | 'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196' | ||
17865 | ], | ||
17866 | [ | ||
17867 | '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984', | ||
17868 | '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4' | ||
17869 | ], | ||
17870 | [ | ||
17871 | '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a', | ||
17872 | 'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257' | ||
17873 | ], | ||
17874 | [ | ||
17875 | 'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030', | ||
17876 | 'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13' | ||
17877 | ], | ||
17878 | [ | ||
17879 | 'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197', | ||
17880 | '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096' | ||
17881 | ], | ||
17882 | [ | ||
17883 | 'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593', | ||
17884 | 'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38' | ||
17885 | ], | ||
17886 | [ | ||
17887 | 'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef', | ||
17888 | '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f' | ||
17889 | ], | ||
17890 | [ | ||
17891 | '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38', | ||
17892 | '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448' | ||
17893 | ], | ||
17894 | [ | ||
17895 | 'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a', | ||
17896 | '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a' | ||
17897 | ], | ||
17898 | [ | ||
17899 | 'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111', | ||
17900 | '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4' | ||
17901 | ], | ||
17902 | [ | ||
17903 | '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502', | ||
17904 | '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437' | ||
17905 | ], | ||
17906 | [ | ||
17907 | '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea', | ||
17908 | 'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7' | ||
17909 | ], | ||
17910 | [ | ||
17911 | 'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26', | ||
17912 | '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d' | ||
17913 | ], | ||
17914 | [ | ||
17915 | 'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986', | ||
17916 | '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a' | ||
17917 | ], | ||
17918 | [ | ||
17919 | 'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e', | ||
17920 | '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54' | ||
17921 | ], | ||
17922 | [ | ||
17923 | '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4', | ||
17924 | '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77' | ||
17925 | ], | ||
17926 | [ | ||
17927 | 'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda', | ||
17928 | 'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517' | ||
17929 | ], | ||
17930 | [ | ||
17931 | '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859', | ||
17932 | 'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10' | ||
17933 | ], | ||
17934 | [ | ||
17935 | 'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f', | ||
17936 | 'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125' | ||
17937 | ], | ||
17938 | [ | ||
17939 | 'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c', | ||
17940 | '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e' | ||
17941 | ], | ||
17942 | [ | ||
17943 | '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942', | ||
17944 | 'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1' | ||
17945 | ], | ||
17946 | [ | ||
17947 | 'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a', | ||
17948 | '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2' | ||
17949 | ], | ||
17950 | [ | ||
17951 | 'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80', | ||
17952 | '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423' | ||
17953 | ], | ||
17954 | [ | ||
17955 | 'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d', | ||
17956 | '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8' | ||
17957 | ], | ||
17958 | [ | ||
17959 | '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1', | ||
17960 | 'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758' | ||
17961 | ], | ||
17962 | [ | ||
17963 | '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63', | ||
17964 | 'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375' | ||
17965 | ], | ||
17966 | [ | ||
17967 | 'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352', | ||
17968 | '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d' | ||
17969 | ], | ||
17970 | [ | ||
17971 | '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193', | ||
17972 | 'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec' | ||
17973 | ], | ||
17974 | [ | ||
17975 | '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00', | ||
17976 | '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0' | ||
17977 | ], | ||
17978 | [ | ||
17979 | '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58', | ||
17980 | 'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c' | ||
17981 | ], | ||
17982 | [ | ||
17983 | 'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7', | ||
17984 | 'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4' | ||
17985 | ], | ||
17986 | [ | ||
17987 | '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8', | ||
17988 | 'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f' | ||
17989 | ], | ||
17990 | [ | ||
17991 | '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e', | ||
17992 | '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649' | ||
17993 | ], | ||
17994 | [ | ||
17995 | '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d', | ||
17996 | 'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826' | ||
17997 | ], | ||
17998 | [ | ||
17999 | '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b', | ||
18000 | '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5' | ||
18001 | ], | ||
18002 | [ | ||
18003 | 'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f', | ||
18004 | 'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87' | ||
18005 | ], | ||
18006 | [ | ||
18007 | '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6', | ||
18008 | '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b' | ||
18009 | ], | ||
18010 | [ | ||
18011 | 'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297', | ||
18012 | '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc' | ||
18013 | ], | ||
18014 | [ | ||
18015 | '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a', | ||
18016 | '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c' | ||
18017 | ], | ||
18018 | [ | ||
18019 | 'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c', | ||
18020 | 'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f' | ||
18021 | ], | ||
18022 | [ | ||
18023 | 'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52', | ||
18024 | '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a' | ||
18025 | ], | ||
18026 | [ | ||
18027 | 'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb', | ||
18028 | 'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46' | ||
18029 | ], | ||
18030 | [ | ||
18031 | '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065', | ||
18032 | 'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f' | ||
18033 | ], | ||
18034 | [ | ||
18035 | '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917', | ||
18036 | '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03' | ||
18037 | ], | ||
18038 | [ | ||
18039 | '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9', | ||
18040 | 'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08' | ||
18041 | ], | ||
18042 | [ | ||
18043 | '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3', | ||
18044 | '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8' | ||
18045 | ], | ||
18046 | [ | ||
18047 | '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57', | ||
18048 | '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373' | ||
18049 | ], | ||
18050 | [ | ||
18051 | '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66', | ||
18052 | 'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3' | ||
18053 | ], | ||
18054 | [ | ||
18055 | '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8', | ||
18056 | '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8' | ||
18057 | ], | ||
18058 | [ | ||
18059 | '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721', | ||
18060 | '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1' | ||
18061 | ], | ||
18062 | [ | ||
18063 | '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180', | ||
18064 | '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9' | ||
18065 | ] | ||
18066 | ] | ||
18067 | } | ||
18068 | }; | ||
18069 | |||
18070 | },{}],97:[function(require,module,exports){ | ||
18071 | 'use strict'; | ||
18072 | |||
18073 | var utils = exports; | ||
18074 | var BN = require('bn.js'); | ||
18075 | var minAssert = require('minimalistic-assert'); | ||
18076 | var minUtils = require('minimalistic-crypto-utils'); | ||
18077 | |||
18078 | utils.assert = minAssert; | ||
18079 | utils.toArray = minUtils.toArray; | ||
18080 | utils.zero2 = minUtils.zero2; | ||
18081 | utils.toHex = minUtils.toHex; | ||
18082 | utils.encode = minUtils.encode; | ||
18083 | |||
18084 | // Represent num in a w-NAF form | ||
18085 | function getNAF(num, w) { | ||
18086 | var naf = []; | ||
18087 | var ws = 1 << (w + 1); | ||
18088 | var k = num.clone(); | ||
18089 | while (k.cmpn(1) >= 0) { | ||
18090 | var z; | ||
18091 | if (k.isOdd()) { | ||
18092 | var mod = k.andln(ws - 1); | ||
18093 | if (mod > (ws >> 1) - 1) | ||
18094 | z = (ws >> 1) - mod; | ||
18095 | else | ||
18096 | z = mod; | ||
18097 | k.isubn(z); | ||
18098 | } else { | ||
18099 | z = 0; | ||
18100 | } | ||
18101 | naf.push(z); | ||
18102 | |||
18103 | // Optimization, shift by word if possible | ||
18104 | var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1; | ||
18105 | for (var i = 1; i < shift; i++) | ||
18106 | naf.push(0); | ||
18107 | k.iushrn(shift); | ||
18108 | } | ||
18109 | |||
18110 | return naf; | ||
18111 | } | ||
18112 | utils.getNAF = getNAF; | ||
18113 | |||
18114 | // Represent k1, k2 in a Joint Sparse Form | ||
18115 | function getJSF(k1, k2) { | ||
18116 | var jsf = [ | ||
18117 | [], | ||
18118 | [] | ||
18119 | ]; | ||
18120 | |||
18121 | k1 = k1.clone(); | ||
18122 | k2 = k2.clone(); | ||
18123 | var d1 = 0; | ||
18124 | var d2 = 0; | ||
18125 | while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) { | ||
18126 | |||
18127 | // First phase | ||
18128 | var m14 = (k1.andln(3) + d1) & 3; | ||
18129 | var m24 = (k2.andln(3) + d2) & 3; | ||
18130 | if (m14 === 3) | ||
18131 | m14 = -1; | ||
18132 | if (m24 === 3) | ||
18133 | m24 = -1; | ||
18134 | var u1; | ||
18135 | if ((m14 & 1) === 0) { | ||
18136 | u1 = 0; | ||
18137 | } else { | ||
18138 | var m8 = (k1.andln(7) + d1) & 7; | ||
18139 | if ((m8 === 3 || m8 === 5) && m24 === 2) | ||
18140 | u1 = -m14; | ||
18141 | else | ||
18142 | u1 = m14; | ||
18143 | } | ||
18144 | jsf[0].push(u1); | ||
18145 | |||
18146 | var u2; | ||
18147 | if ((m24 & 1) === 0) { | ||
18148 | u2 = 0; | ||
18149 | } else { | ||
18150 | var m8 = (k2.andln(7) + d2) & 7; | ||
18151 | if ((m8 === 3 || m8 === 5) && m14 === 2) | ||
18152 | u2 = -m24; | ||
18153 | else | ||
18154 | u2 = m24; | ||
18155 | } | ||
18156 | jsf[1].push(u2); | ||
18157 | |||
18158 | // Second phase | ||
18159 | if (2 * d1 === u1 + 1) | ||
18160 | d1 = 1 - d1; | ||
18161 | if (2 * d2 === u2 + 1) | ||
18162 | d2 = 1 - d2; | ||
18163 | k1.iushrn(1); | ||
18164 | k2.iushrn(1); | ||
18165 | } | ||
18166 | |||
18167 | return jsf; | ||
18168 | } | ||
18169 | utils.getJSF = getJSF; | ||
18170 | |||
18171 | function cachedProperty(obj, name, computer) { | ||
18172 | var key = '_' + name; | ||
18173 | obj.prototype[name] = function cachedProperty() { | ||
18174 | return this[key] !== undefined ? this[key] : | ||
18175 | this[key] = computer.call(this); | ||
18176 | }; | ||
18177 | } | ||
18178 | utils.cachedProperty = cachedProperty; | ||
18179 | |||
18180 | function parseBytes(bytes) { | ||
18181 | return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') : | ||
18182 | bytes; | ||
18183 | } | ||
18184 | utils.parseBytes = parseBytes; | ||
18185 | |||
18186 | function intFromLE(bytes) { | ||
18187 | return new BN(bytes, 'hex', 'le'); | ||
18188 | } | ||
18189 | utils.intFromLE = intFromLE; | ||
18190 | |||
18191 | |||
18192 | },{"bn.js":18,"minimalistic-assert":356,"minimalistic-crypto-utils":357}],98:[function(require,module,exports){ | ||
18193 | module.exports={ | ||
18194 | "_from": "elliptic@^6.0.0", | ||
18195 | "_id": "elliptic@6.4.1", | ||
18196 | "_inBundle": false, | ||
18197 | "_integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==", | ||
18198 | "_location": "/elliptic", | ||
18199 | "_phantomChildren": {}, | ||
18200 | "_requested": { | ||
18201 | "type": "range", | ||
18202 | "registry": true, | ||
18203 | "raw": "elliptic@^6.0.0", | ||
18204 | "name": "elliptic", | ||
18205 | "escapedName": "elliptic", | ||
18206 | "rawSpec": "^6.0.0", | ||
18207 | "saveSpec": null, | ||
18208 | "fetchSpec": "^6.0.0" | ||
18209 | }, | ||
18210 | "_requiredBy": [ | ||
18211 | "/browserify-sign", | ||
18212 | "/create-ecdh" | ||
18213 | ], | ||
18214 | "_resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz", | ||
18215 | "_shasum": "c2d0b7776911b86722c632c3c06c60f2f819939a", | ||
18216 | "_spec": "elliptic@^6.0.0", | ||
18217 | "_where": "C:\\Projects\\bip39-2\\libs\\stellar-util\\node_modules\\browserify-sign", | ||
18218 | "author": { | ||
18219 | "name": "Fedor Indutny", | ||
18220 | "email": "fedor@indutny.com" | ||
18221 | }, | ||
18222 | "bugs": { | ||
18223 | "url": "https://github.com/indutny/elliptic/issues" | ||
18224 | }, | ||
18225 | "bundleDependencies": false, | ||
18226 | "dependencies": { | ||
18227 | "bn.js": "^4.4.0", | ||
18228 | "brorand": "^1.0.1", | ||
18229 | "hash.js": "^1.0.0", | ||
18230 | "hmac-drbg": "^1.0.0", | ||
18231 | "inherits": "^2.0.1", | ||
18232 | "minimalistic-assert": "^1.0.0", | ||
18233 | "minimalistic-crypto-utils": "^1.0.0" | ||
18234 | }, | ||
18235 | "deprecated": false, | ||
18236 | "description": "EC cryptography", | ||
18237 | "devDependencies": { | ||
18238 | "brfs": "^1.4.3", | ||
18239 | "coveralls": "^2.11.3", | ||
18240 | "grunt": "^0.4.5", | ||
18241 | "grunt-browserify": "^5.0.0", | ||
18242 | "grunt-cli": "^1.2.0", | ||
18243 | "grunt-contrib-connect": "^1.0.0", | ||
18244 | "grunt-contrib-copy": "^1.0.0", | ||
18245 | "grunt-contrib-uglify": "^1.0.1", | ||
18246 | "grunt-mocha-istanbul": "^3.0.1", | ||
18247 | "grunt-saucelabs": "^8.6.2", | ||
18248 | "istanbul": "^0.4.2", | ||
18249 | "jscs": "^2.9.0", | ||
18250 | "jshint": "^2.6.0", | ||
18251 | "mocha": "^2.1.0" | ||
18252 | }, | ||
18253 | "files": [ | ||
18254 | "lib" | ||
18255 | ], | ||
18256 | "homepage": "https://github.com/indutny/elliptic", | ||
18257 | "keywords": [ | ||
18258 | "EC", | ||
18259 | "Elliptic", | ||
18260 | "curve", | ||
18261 | "Cryptography" | ||
18262 | ], | ||
18263 | "license": "MIT", | ||
18264 | "main": "lib/elliptic.js", | ||
18265 | "name": "elliptic", | ||
18266 | "repository": { | ||
18267 | "type": "git", | ||
18268 | "url": "git+ssh://git@github.com/indutny/elliptic.git" | ||
18269 | }, | ||
18270 | "scripts": { | ||
18271 | "jscs": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js", | ||
18272 | "jshint": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js", | ||
18273 | "lint": "npm run jscs && npm run jshint", | ||
18274 | "test": "npm run lint && npm run unit", | ||
18275 | "unit": "istanbul test _mocha --reporter=spec test/index.js", | ||
18276 | "version": "grunt dist && git add dist/" | ||
18277 | }, | ||
18278 | "version": "6.4.1" | ||
18279 | } | ||
18280 | |||
18281 | },{}],99:[function(require,module,exports){ | ||
18282 | // Copyright Joyent, Inc. and other Node contributors. | ||
18283 | // | ||
18284 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
18285 | // copy of this software and associated documentation files (the | ||
18286 | // "Software"), to deal in the Software without restriction, including | ||
18287 | // without limitation the rights to use, copy, modify, merge, publish, | ||
18288 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
18289 | // persons to whom the Software is furnished to do so, subject to the | ||
18290 | // following conditions: | ||
18291 | // | ||
18292 | // The above copyright notice and this permission notice shall be included | ||
18293 | // in all copies or substantial portions of the Software. | ||
18294 | // | ||
18295 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
18296 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
18297 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
18298 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
18299 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
18300 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
18301 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
18302 | |||
18303 | var objectCreate = Object.create || objectCreatePolyfill | ||
18304 | var objectKeys = Object.keys || objectKeysPolyfill | ||
18305 | var bind = Function.prototype.bind || functionBindPolyfill | ||
18306 | |||
18307 | function EventEmitter() { | ||
18308 | if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) { | ||
18309 | this._events = objectCreate(null); | ||
18310 | this._eventsCount = 0; | ||
18311 | } | ||
18312 | |||
18313 | this._maxListeners = this._maxListeners || undefined; | ||
18314 | } | ||
18315 | module.exports = EventEmitter; | ||
18316 | |||
18317 | // Backwards-compat with node 0.10.x | ||
18318 | EventEmitter.EventEmitter = EventEmitter; | ||
18319 | |||
18320 | EventEmitter.prototype._events = undefined; | ||
18321 | EventEmitter.prototype._maxListeners = undefined; | ||
18322 | |||
18323 | // By default EventEmitters will print a warning if more than 10 listeners are | ||
18324 | // added to it. This is a useful default which helps finding memory leaks. | ||
18325 | var defaultMaxListeners = 10; | ||
18326 | |||
18327 | var hasDefineProperty; | ||
18328 | try { | ||
18329 | var o = {}; | ||
18330 | if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 }); | ||
18331 | hasDefineProperty = o.x === 0; | ||
18332 | } catch (err) { hasDefineProperty = false } | ||
18333 | if (hasDefineProperty) { | ||
18334 | Object.defineProperty(EventEmitter, 'defaultMaxListeners', { | ||
18335 | enumerable: true, | ||
18336 | get: function() { | ||
18337 | return defaultMaxListeners; | ||
18338 | }, | ||
18339 | set: function(arg) { | ||
18340 | // check whether the input is a positive number (whose value is zero or | ||
18341 | // greater and not a NaN). | ||
18342 | if (typeof arg !== 'number' || arg < 0 || arg !== arg) | ||
18343 | throw new TypeError('"defaultMaxListeners" must be a positive number'); | ||
18344 | defaultMaxListeners = arg; | ||
18345 | } | ||
18346 | }); | ||
18347 | } else { | ||
18348 | EventEmitter.defaultMaxListeners = defaultMaxListeners; | ||
18349 | } | ||
18350 | |||
18351 | // Obviously not all Emitters should be limited to 10. This function allows | ||
18352 | // that to be increased. Set to zero for unlimited. | ||
18353 | EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { | ||
18354 | if (typeof n !== 'number' || n < 0 || isNaN(n)) | ||
18355 | throw new TypeError('"n" argument must be a positive number'); | ||
18356 | this._maxListeners = n; | ||
18357 | return this; | ||
18358 | }; | ||
18359 | |||
18360 | function $getMaxListeners(that) { | ||
18361 | if (that._maxListeners === undefined) | ||
18362 | return EventEmitter.defaultMaxListeners; | ||
18363 | return that._maxListeners; | ||
18364 | } | ||
18365 | |||
18366 | EventEmitter.prototype.getMaxListeners = function getMaxListeners() { | ||
18367 | return $getMaxListeners(this); | ||
18368 | }; | ||
18369 | |||
18370 | // These standalone emit* functions are used to optimize calling of event | ||
18371 | // handlers for fast cases because emit() itself often has a variable number of | ||
18372 | // arguments and can be deoptimized because of that. These functions always have | ||
18373 | // the same number of arguments and thus do not get deoptimized, so the code | ||
18374 | // inside them can execute faster. | ||
18375 | function emitNone(handler, isFn, self) { | ||
18376 | if (isFn) | ||
18377 | handler.call(self); | ||
18378 | else { | ||
18379 | var len = handler.length; | ||
18380 | var listeners = arrayClone(handler, len); | ||
18381 | for (var i = 0; i < len; ++i) | ||
18382 | listeners[i].call(self); | ||
18383 | } | ||
18384 | } | ||
18385 | function emitOne(handler, isFn, self, arg1) { | ||
18386 | if (isFn) | ||
18387 | handler.call(self, arg1); | ||
18388 | else { | ||
18389 | var len = handler.length; | ||
18390 | var listeners = arrayClone(handler, len); | ||
18391 | for (var i = 0; i < len; ++i) | ||
18392 | listeners[i].call(self, arg1); | ||
18393 | } | ||
18394 | } | ||
18395 | function emitTwo(handler, isFn, self, arg1, arg2) { | ||
18396 | if (isFn) | ||
18397 | handler.call(self, arg1, arg2); | ||
18398 | else { | ||
18399 | var len = handler.length; | ||
18400 | var listeners = arrayClone(handler, len); | ||
18401 | for (var i = 0; i < len; ++i) | ||
18402 | listeners[i].call(self, arg1, arg2); | ||
18403 | } | ||
18404 | } | ||
18405 | function emitThree(handler, isFn, self, arg1, arg2, arg3) { | ||
18406 | if (isFn) | ||
18407 | handler.call(self, arg1, arg2, arg3); | ||
18408 | else { | ||
18409 | var len = handler.length; | ||
18410 | var listeners = arrayClone(handler, len); | ||
18411 | for (var i = 0; i < len; ++i) | ||
18412 | listeners[i].call(self, arg1, arg2, arg3); | ||
18413 | } | ||
18414 | } | ||
18415 | |||
18416 | function emitMany(handler, isFn, self, args) { | ||
18417 | if (isFn) | ||
18418 | handler.apply(self, args); | ||
18419 | else { | ||
18420 | var len = handler.length; | ||
18421 | var listeners = arrayClone(handler, len); | ||
18422 | for (var i = 0; i < len; ++i) | ||
18423 | listeners[i].apply(self, args); | ||
18424 | } | ||
18425 | } | ||
18426 | |||
18427 | EventEmitter.prototype.emit = function emit(type) { | ||
18428 | var er, handler, len, args, i, events; | ||
18429 | var doError = (type === 'error'); | ||
18430 | |||
18431 | events = this._events; | ||
18432 | if (events) | ||
18433 | doError = (doError && events.error == null); | ||
18434 | else if (!doError) | ||
18435 | return false; | ||
18436 | |||
18437 | // If there is no 'error' event listener then throw. | ||
18438 | if (doError) { | ||
18439 | if (arguments.length > 1) | ||
18440 | er = arguments[1]; | ||
18441 | if (er instanceof Error) { | ||
18442 | throw er; // Unhandled 'error' event | ||
18443 | } else { | ||
18444 | // At least give some kind of context to the user | ||
18445 | var err = new Error('Unhandled "error" event. (' + er + ')'); | ||
18446 | err.context = er; | ||
18447 | throw err; | ||
18448 | } | ||
18449 | return false; | ||
18450 | } | ||
18451 | |||
18452 | handler = events[type]; | ||
18453 | |||
18454 | if (!handler) | ||
18455 | return false; | ||
18456 | |||
18457 | var isFn = typeof handler === 'function'; | ||
18458 | len = arguments.length; | ||
18459 | switch (len) { | ||
18460 | // fast cases | ||
18461 | case 1: | ||
18462 | emitNone(handler, isFn, this); | ||
18463 | break; | ||
18464 | case 2: | ||
18465 | emitOne(handler, isFn, this, arguments[1]); | ||
18466 | break; | ||
18467 | case 3: | ||
18468 | emitTwo(handler, isFn, this, arguments[1], arguments[2]); | ||
18469 | break; | ||
18470 | case 4: | ||
18471 | emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); | ||
18472 | break; | ||
18473 | // slower | ||
18474 | default: | ||
18475 | args = new Array(len - 1); | ||
18476 | for (i = 1; i < len; i++) | ||
18477 | args[i - 1] = arguments[i]; | ||
18478 | emitMany(handler, isFn, this, args); | ||
18479 | } | ||
18480 | |||
18481 | return true; | ||
18482 | }; | ||
18483 | |||
18484 | function _addListener(target, type, listener, prepend) { | ||
18485 | var m; | ||
18486 | var events; | ||
18487 | var existing; | ||
18488 | |||
18489 | if (typeof listener !== 'function') | ||
18490 | throw new TypeError('"listener" argument must be a function'); | ||
18491 | |||
18492 | events = target._events; | ||
18493 | if (!events) { | ||
18494 | events = target._events = objectCreate(null); | ||
18495 | target._eventsCount = 0; | ||
18496 | } else { | ||
18497 | // To avoid recursion in the case that type === "newListener"! Before | ||
18498 | // adding it to the listeners, first emit "newListener". | ||
18499 | if (events.newListener) { | ||
18500 | target.emit('newListener', type, | ||
18501 | listener.listener ? listener.listener : listener); | ||
18502 | |||
18503 | // Re-assign `events` because a newListener handler could have caused the | ||
18504 | // this._events to be assigned to a new object | ||
18505 | events = target._events; | ||
18506 | } | ||
18507 | existing = events[type]; | ||
18508 | } | ||
18509 | |||
18510 | if (!existing) { | ||
18511 | // Optimize the case of one listener. Don't need the extra array object. | ||
18512 | existing = events[type] = listener; | ||
18513 | ++target._eventsCount; | ||
18514 | } else { | ||
18515 | if (typeof existing === 'function') { | ||
18516 | // Adding the second element, need to change to array. | ||
18517 | existing = events[type] = | ||
18518 | prepend ? [listener, existing] : [existing, listener]; | ||
18519 | } else { | ||
18520 | // If we've already got an array, just append. | ||
18521 | if (prepend) { | ||
18522 | existing.unshift(listener); | ||
18523 | } else { | ||
18524 | existing.push(listener); | ||
18525 | } | ||
18526 | } | ||
18527 | |||
18528 | // Check for listener leak | ||
18529 | if (!existing.warned) { | ||
18530 | m = $getMaxListeners(target); | ||
18531 | if (m && m > 0 && existing.length > m) { | ||
18532 | existing.warned = true; | ||
18533 | var w = new Error('Possible EventEmitter memory leak detected. ' + | ||
18534 | existing.length + ' "' + String(type) + '" listeners ' + | ||
18535 | 'added. Use emitter.setMaxListeners() to ' + | ||
18536 | 'increase limit.'); | ||
18537 | w.name = 'MaxListenersExceededWarning'; | ||
18538 | w.emitter = target; | ||
18539 | w.type = type; | ||
18540 | w.count = existing.length; | ||
18541 | if (typeof console === 'object' && console.warn) { | ||
18542 | console.warn('%s: %s', w.name, w.message); | ||
18543 | } | ||
18544 | } | ||
18545 | } | ||
18546 | } | ||
18547 | |||
18548 | return target; | ||
18549 | } | ||
18550 | |||
18551 | EventEmitter.prototype.addListener = function addListener(type, listener) { | ||
18552 | return _addListener(this, type, listener, false); | ||
18553 | }; | ||
18554 | |||
18555 | EventEmitter.prototype.on = EventEmitter.prototype.addListener; | ||
18556 | |||
18557 | EventEmitter.prototype.prependListener = | ||
18558 | function prependListener(type, listener) { | ||
18559 | return _addListener(this, type, listener, true); | ||
18560 | }; | ||
18561 | |||
18562 | function onceWrapper() { | ||
18563 | if (!this.fired) { | ||
18564 | this.target.removeListener(this.type, this.wrapFn); | ||
18565 | this.fired = true; | ||
18566 | switch (arguments.length) { | ||
18567 | case 0: | ||
18568 | return this.listener.call(this.target); | ||
18569 | case 1: | ||
18570 | return this.listener.call(this.target, arguments[0]); | ||
18571 | case 2: | ||
18572 | return this.listener.call(this.target, arguments[0], arguments[1]); | ||
18573 | case 3: | ||
18574 | return this.listener.call(this.target, arguments[0], arguments[1], | ||
18575 | arguments[2]); | ||
18576 | default: | ||
18577 | var args = new Array(arguments.length); | ||
18578 | for (var i = 0; i < args.length; ++i) | ||
18579 | args[i] = arguments[i]; | ||
18580 | this.listener.apply(this.target, args); | ||
18581 | } | ||
18582 | } | ||
18583 | } | ||
18584 | |||
18585 | function _onceWrap(target, type, listener) { | ||
18586 | var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; | ||
18587 | var wrapped = bind.call(onceWrapper, state); | ||
18588 | wrapped.listener = listener; | ||
18589 | state.wrapFn = wrapped; | ||
18590 | return wrapped; | ||
18591 | } | ||
18592 | |||
18593 | EventEmitter.prototype.once = function once(type, listener) { | ||
18594 | if (typeof listener !== 'function') | ||
18595 | throw new TypeError('"listener" argument must be a function'); | ||
18596 | this.on(type, _onceWrap(this, type, listener)); | ||
18597 | return this; | ||
18598 | }; | ||
18599 | |||
18600 | EventEmitter.prototype.prependOnceListener = | ||
18601 | function prependOnceListener(type, listener) { | ||
18602 | if (typeof listener !== 'function') | ||
18603 | throw new TypeError('"listener" argument must be a function'); | ||
18604 | this.prependListener(type, _onceWrap(this, type, listener)); | ||
18605 | return this; | ||
18606 | }; | ||
18607 | |||
18608 | // Emits a 'removeListener' event if and only if the listener was removed. | ||
18609 | EventEmitter.prototype.removeListener = | ||
18610 | function removeListener(type, listener) { | ||
18611 | var list, events, position, i, originalListener; | ||
18612 | |||
18613 | if (typeof listener !== 'function') | ||
18614 | throw new TypeError('"listener" argument must be a function'); | ||
18615 | |||
18616 | events = this._events; | ||
18617 | if (!events) | ||
18618 | return this; | ||
18619 | |||
18620 | list = events[type]; | ||
18621 | if (!list) | ||
18622 | return this; | ||
18623 | |||
18624 | if (list === listener || list.listener === listener) { | ||
18625 | if (--this._eventsCount === 0) | ||
18626 | this._events = objectCreate(null); | ||
18627 | else { | ||
18628 | delete events[type]; | ||
18629 | if (events.removeListener) | ||
18630 | this.emit('removeListener', type, list.listener || listener); | ||
18631 | } | ||
18632 | } else if (typeof list !== 'function') { | ||
18633 | position = -1; | ||
18634 | |||
18635 | for (i = list.length - 1; i >= 0; i--) { | ||
18636 | if (list[i] === listener || list[i].listener === listener) { | ||
18637 | originalListener = list[i].listener; | ||
18638 | position = i; | ||
18639 | break; | ||
18640 | } | ||
18641 | } | ||
18642 | |||
18643 | if (position < 0) | ||
18644 | return this; | ||
18645 | |||
18646 | if (position === 0) | ||
18647 | list.shift(); | ||
18648 | else | ||
18649 | spliceOne(list, position); | ||
18650 | |||
18651 | if (list.length === 1) | ||
18652 | events[type] = list[0]; | ||
18653 | |||
18654 | if (events.removeListener) | ||
18655 | this.emit('removeListener', type, originalListener || listener); | ||
18656 | } | ||
18657 | |||
18658 | return this; | ||
18659 | }; | ||
18660 | |||
18661 | EventEmitter.prototype.removeAllListeners = | ||
18662 | function removeAllListeners(type) { | ||
18663 | var listeners, events, i; | ||
18664 | |||
18665 | events = this._events; | ||
18666 | if (!events) | ||
18667 | return this; | ||
18668 | |||
18669 | // not listening for removeListener, no need to emit | ||
18670 | if (!events.removeListener) { | ||
18671 | if (arguments.length === 0) { | ||
18672 | this._events = objectCreate(null); | ||
18673 | this._eventsCount = 0; | ||
18674 | } else if (events[type]) { | ||
18675 | if (--this._eventsCount === 0) | ||
18676 | this._events = objectCreate(null); | ||
18677 | else | ||
18678 | delete events[type]; | ||
18679 | } | ||
18680 | return this; | ||
18681 | } | ||
18682 | |||
18683 | // emit removeListener for all listeners on all events | ||
18684 | if (arguments.length === 0) { | ||
18685 | var keys = objectKeys(events); | ||
18686 | var key; | ||
18687 | for (i = 0; i < keys.length; ++i) { | ||
18688 | key = keys[i]; | ||
18689 | if (key === 'removeListener') continue; | ||
18690 | this.removeAllListeners(key); | ||
18691 | } | ||
18692 | this.removeAllListeners('removeListener'); | ||
18693 | this._events = objectCreate(null); | ||
18694 | this._eventsCount = 0; | ||
18695 | return this; | ||
18696 | } | ||
18697 | |||
18698 | listeners = events[type]; | ||
18699 | |||
18700 | if (typeof listeners === 'function') { | ||
18701 | this.removeListener(type, listeners); | ||
18702 | } else if (listeners) { | ||
18703 | // LIFO order | ||
18704 | for (i = listeners.length - 1; i >= 0; i--) { | ||
18705 | this.removeListener(type, listeners[i]); | ||
18706 | } | ||
18707 | } | ||
18708 | |||
18709 | return this; | ||
18710 | }; | ||
18711 | |||
18712 | function _listeners(target, type, unwrap) { | ||
18713 | var events = target._events; | ||
18714 | |||
18715 | if (!events) | ||
18716 | return []; | ||
18717 | |||
18718 | var evlistener = events[type]; | ||
18719 | if (!evlistener) | ||
18720 | return []; | ||
18721 | |||
18722 | if (typeof evlistener === 'function') | ||
18723 | return unwrap ? [evlistener.listener || evlistener] : [evlistener]; | ||
18724 | |||
18725 | return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); | ||
18726 | } | ||
18727 | |||
18728 | EventEmitter.prototype.listeners = function listeners(type) { | ||
18729 | return _listeners(this, type, true); | ||
18730 | }; | ||
18731 | |||
18732 | EventEmitter.prototype.rawListeners = function rawListeners(type) { | ||
18733 | return _listeners(this, type, false); | ||
18734 | }; | ||
18735 | |||
18736 | EventEmitter.listenerCount = function(emitter, type) { | ||
18737 | if (typeof emitter.listenerCount === 'function') { | ||
18738 | return emitter.listenerCount(type); | ||
18739 | } else { | ||
18740 | return listenerCount.call(emitter, type); | ||
18741 | } | ||
18742 | }; | ||
18743 | |||
18744 | EventEmitter.prototype.listenerCount = listenerCount; | ||
18745 | function listenerCount(type) { | ||
18746 | var events = this._events; | ||
18747 | |||
18748 | if (events) { | ||
18749 | var evlistener = events[type]; | ||
18750 | |||
18751 | if (typeof evlistener === 'function') { | ||
18752 | return 1; | ||
18753 | } else if (evlistener) { | ||
18754 | return evlistener.length; | ||
18755 | } | ||
18756 | } | ||
18757 | |||
18758 | return 0; | ||
18759 | } | ||
18760 | |||
18761 | EventEmitter.prototype.eventNames = function eventNames() { | ||
18762 | return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; | ||
18763 | }; | ||
18764 | |||
18765 | // About 1.5x faster than the two-arg version of Array#splice(). | ||
18766 | function spliceOne(list, index) { | ||
18767 | for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) | ||
18768 | list[i] = list[k]; | ||
18769 | list.pop(); | ||
18770 | } | ||
18771 | |||
18772 | function arrayClone(arr, n) { | ||
18773 | var copy = new Array(n); | ||
18774 | for (var i = 0; i < n; ++i) | ||
18775 | copy[i] = arr[i]; | ||
18776 | return copy; | ||
18777 | } | ||
18778 | |||
18779 | function unwrapListeners(arr) { | ||
18780 | var ret = new Array(arr.length); | ||
18781 | for (var i = 0; i < ret.length; ++i) { | ||
18782 | ret[i] = arr[i].listener || arr[i]; | ||
18783 | } | ||
18784 | return ret; | ||
18785 | } | ||
18786 | |||
18787 | function objectCreatePolyfill(proto) { | ||
18788 | var F = function() {}; | ||
18789 | F.prototype = proto; | ||
18790 | return new F; | ||
18791 | } | ||
18792 | function objectKeysPolyfill(obj) { | ||
18793 | var keys = []; | ||
18794 | for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) { | ||
18795 | keys.push(k); | ||
18796 | } | ||
18797 | return k; | ||
18798 | } | ||
18799 | function functionBindPolyfill(context) { | ||
18800 | var fn = this; | ||
18801 | return function () { | ||
18802 | return fn.apply(context, arguments); | ||
18803 | }; | ||
18804 | } | ||
18805 | |||
18806 | },{}],100:[function(require,module,exports){ | ||
18807 | var Buffer = require('safe-buffer').Buffer | ||
18808 | var MD5 = require('md5.js') | ||
18809 | |||
18810 | /* eslint-disable camelcase */ | ||
18811 | function EVP_BytesToKey (password, salt, keyBits, ivLen) { | ||
18812 | if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary') | ||
18813 | if (salt) { | ||
18814 | if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary') | ||
18815 | if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length') | ||
18816 | } | ||
18817 | |||
18818 | var keyLen = keyBits / 8 | ||
18819 | var key = Buffer.alloc(keyLen) | ||
18820 | var iv = Buffer.alloc(ivLen || 0) | ||
18821 | var tmp = Buffer.alloc(0) | ||
18822 | |||
18823 | while (keyLen > 0 || ivLen > 0) { | ||
18824 | var hash = new MD5() | ||
18825 | hash.update(tmp) | ||
18826 | hash.update(password) | ||
18827 | if (salt) hash.update(salt) | ||
18828 | tmp = hash.digest() | ||
18829 | |||
18830 | var used = 0 | ||
18831 | |||
18832 | if (keyLen > 0) { | ||
18833 | var keyStart = key.length - keyLen | ||
18834 | used = Math.min(keyLen, tmp.length) | ||
18835 | tmp.copy(key, keyStart, 0, used) | ||
18836 | keyLen -= used | ||
18837 | } | ||
18838 | |||
18839 | if (used < tmp.length && ivLen > 0) { | ||
18840 | var ivStart = iv.length - ivLen | ||
18841 | var length = Math.min(ivLen, tmp.length - used) | ||
18842 | tmp.copy(iv, ivStart, used, used + length) | ||
18843 | ivLen -= length | ||
18844 | } | ||
18845 | } | ||
18846 | |||
18847 | tmp.fill(0) | ||
18848 | return { key: key, iv: iv } | ||
18849 | } | ||
18850 | |||
18851 | module.exports = EVP_BytesToKey | ||
18852 | |||
18853 | },{"md5.js":354,"safe-buffer":393}],101:[function(require,module,exports){ | ||
18854 | 'use strict' | ||
18855 | var Buffer = require('safe-buffer').Buffer | ||
18856 | var Transform = require('stream').Transform | ||
18857 | var inherits = require('inherits') | ||
18858 | |||
18859 | function throwIfNotStringOrBuffer (val, prefix) { | ||
18860 | if (!Buffer.isBuffer(val) && typeof val !== 'string') { | ||
18861 | throw new TypeError(prefix + ' must be a string or a buffer') | ||
18862 | } | ||
18863 | } | ||
18864 | |||
18865 | function HashBase (blockSize) { | ||
18866 | Transform.call(this) | ||
18867 | |||
18868 | this._block = Buffer.allocUnsafe(blockSize) | ||
18869 | this._blockSize = blockSize | ||
18870 | this._blockOffset = 0 | ||
18871 | this._length = [0, 0, 0, 0] | ||
18872 | |||
18873 | this._finalized = false | ||
18874 | } | ||
18875 | |||
18876 | inherits(HashBase, Transform) | ||
18877 | |||
18878 | HashBase.prototype._transform = function (chunk, encoding, callback) { | ||
18879 | var error = null | ||
18880 | try { | ||
18881 | this.update(chunk, encoding) | ||
18882 | } catch (err) { | ||
18883 | error = err | ||
18884 | } | ||
18885 | |||
18886 | callback(error) | ||
18887 | } | ||
18888 | |||
18889 | HashBase.prototype._flush = function (callback) { | ||
18890 | var error = null | ||
18891 | try { | ||
18892 | this.push(this.digest()) | ||
18893 | } catch (err) { | ||
18894 | error = err | ||
18895 | } | ||
18896 | |||
18897 | callback(error) | ||
18898 | } | ||
18899 | |||
18900 | HashBase.prototype.update = function (data, encoding) { | ||
18901 | throwIfNotStringOrBuffer(data, 'Data') | ||
18902 | if (this._finalized) throw new Error('Digest already called') | ||
18903 | if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding) | ||
18904 | |||
18905 | // consume data | ||
18906 | var block = this._block | ||
18907 | var offset = 0 | ||
18908 | while (this._blockOffset + data.length - offset >= this._blockSize) { | ||
18909 | for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++] | ||
18910 | this._update() | ||
18911 | this._blockOffset = 0 | ||
18912 | } | ||
18913 | while (offset < data.length) block[this._blockOffset++] = data[offset++] | ||
18914 | |||
18915 | // update length | ||
18916 | for (var j = 0, carry = data.length * 8; carry > 0; ++j) { | ||
18917 | this._length[j] += carry | ||
18918 | carry = (this._length[j] / 0x0100000000) | 0 | ||
18919 | if (carry > 0) this._length[j] -= 0x0100000000 * carry | ||
18920 | } | ||
18921 | |||
18922 | return this | ||
18923 | } | ||
18924 | |||
18925 | HashBase.prototype._update = function () { | ||
18926 | throw new Error('_update is not implemented') | ||
18927 | } | ||
18928 | |||
18929 | HashBase.prototype.digest = function (encoding) { | ||
18930 | if (this._finalized) throw new Error('Digest already called') | ||
18931 | this._finalized = true | ||
18932 | |||
18933 | var digest = this._digest() | ||
18934 | if (encoding !== undefined) digest = digest.toString(encoding) | ||
18935 | |||
18936 | // reset state | ||
18937 | this._block.fill(0) | ||
18938 | this._blockOffset = 0 | ||
18939 | for (var i = 0; i < 4; ++i) this._length[i] = 0 | ||
18940 | |||
18941 | return digest | ||
18942 | } | ||
18943 | |||
18944 | HashBase.prototype._digest = function () { | ||
18945 | throw new Error('_digest is not implemented') | ||
18946 | } | ||
18947 | |||
18948 | module.exports = HashBase | ||
18949 | |||
18950 | },{"inherits":116,"safe-buffer":393,"stream":432}],102:[function(require,module,exports){ | ||
18951 | var hash = exports; | ||
18952 | |||
18953 | hash.utils = require('./hash/utils'); | ||
18954 | hash.common = require('./hash/common'); | ||
18955 | hash.sha = require('./hash/sha'); | ||
18956 | hash.ripemd = require('./hash/ripemd'); | ||
18957 | hash.hmac = require('./hash/hmac'); | ||
18958 | |||
18959 | // Proxy hash functions to the main object | ||
18960 | hash.sha1 = hash.sha.sha1; | ||
18961 | hash.sha256 = hash.sha.sha256; | ||
18962 | hash.sha224 = hash.sha.sha224; | ||
18963 | hash.sha384 = hash.sha.sha384; | ||
18964 | hash.sha512 = hash.sha.sha512; | ||
18965 | hash.ripemd160 = hash.ripemd.ripemd160; | ||
18966 | |||
18967 | },{"./hash/common":103,"./hash/hmac":104,"./hash/ripemd":105,"./hash/sha":106,"./hash/utils":113}],103:[function(require,module,exports){ | ||
18968 | 'use strict'; | ||
18969 | |||
18970 | var utils = require('./utils'); | ||
18971 | var assert = require('minimalistic-assert'); | ||
18972 | |||
18973 | function BlockHash() { | ||
18974 | this.pending = null; | ||
18975 | this.pendingTotal = 0; | ||
18976 | this.blockSize = this.constructor.blockSize; | ||
18977 | this.outSize = this.constructor.outSize; | ||
18978 | this.hmacStrength = this.constructor.hmacStrength; | ||
18979 | this.padLength = this.constructor.padLength / 8; | ||
18980 | this.endian = 'big'; | ||
18981 | |||
18982 | this._delta8 = this.blockSize / 8; | ||
18983 | this._delta32 = this.blockSize / 32; | ||
18984 | } | ||
18985 | exports.BlockHash = BlockHash; | ||
18986 | |||
18987 | BlockHash.prototype.update = function update(msg, enc) { | ||
18988 | // Convert message to array, pad it, and join into 32bit blocks | ||
18989 | msg = utils.toArray(msg, enc); | ||
18990 | if (!this.pending) | ||
18991 | this.pending = msg; | ||
18992 | else | ||
18993 | this.pending = this.pending.concat(msg); | ||
18994 | this.pendingTotal += msg.length; | ||
18995 | |||
18996 | // Enough data, try updating | ||
18997 | if (this.pending.length >= this._delta8) { | ||
18998 | msg = this.pending; | ||
18999 | |||
19000 | // Process pending data in blocks | ||
19001 | var r = msg.length % this._delta8; | ||
19002 | this.pending = msg.slice(msg.length - r, msg.length); | ||
19003 | if (this.pending.length === 0) | ||
19004 | this.pending = null; | ||
19005 | |||
19006 | msg = utils.join32(msg, 0, msg.length - r, this.endian); | ||
19007 | for (var i = 0; i < msg.length; i += this._delta32) | ||
19008 | this._update(msg, i, i + this._delta32); | ||
19009 | } | ||
19010 | |||
19011 | return this; | ||
19012 | }; | ||
19013 | |||
19014 | BlockHash.prototype.digest = function digest(enc) { | ||
19015 | this.update(this._pad()); | ||
19016 | assert(this.pending === null); | ||
19017 | |||
19018 | return this._digest(enc); | ||
19019 | }; | ||
19020 | |||
19021 | BlockHash.prototype._pad = function pad() { | ||
19022 | var len = this.pendingTotal; | ||
19023 | var bytes = this._delta8; | ||
19024 | var k = bytes - ((len + this.padLength) % bytes); | ||
19025 | var res = new Array(k + this.padLength); | ||
19026 | res[0] = 0x80; | ||
19027 | for (var i = 1; i < k; i++) | ||
19028 | res[i] = 0; | ||
19029 | |||
19030 | // Append length | ||
19031 | len <<= 3; | ||
19032 | if (this.endian === 'big') { | ||
19033 | for (var t = 8; t < this.padLength; t++) | ||
19034 | res[i++] = 0; | ||
19035 | |||
19036 | res[i++] = 0; | ||
19037 | res[i++] = 0; | ||
19038 | res[i++] = 0; | ||
19039 | res[i++] = 0; | ||
19040 | res[i++] = (len >>> 24) & 0xff; | ||
19041 | res[i++] = (len >>> 16) & 0xff; | ||
19042 | res[i++] = (len >>> 8) & 0xff; | ||
19043 | res[i++] = len & 0xff; | ||
19044 | } else { | ||
19045 | res[i++] = len & 0xff; | ||
19046 | res[i++] = (len >>> 8) & 0xff; | ||
19047 | res[i++] = (len >>> 16) & 0xff; | ||
19048 | res[i++] = (len >>> 24) & 0xff; | ||
19049 | res[i++] = 0; | ||
19050 | res[i++] = 0; | ||
19051 | res[i++] = 0; | ||
19052 | res[i++] = 0; | ||
19053 | |||
19054 | for (t = 8; t < this.padLength; t++) | ||
19055 | res[i++] = 0; | ||
19056 | } | ||
19057 | |||
19058 | return res; | ||
19059 | }; | ||
19060 | |||
19061 | },{"./utils":113,"minimalistic-assert":356}],104:[function(require,module,exports){ | ||
19062 | 'use strict'; | ||
19063 | |||
19064 | var utils = require('./utils'); | ||
19065 | var assert = require('minimalistic-assert'); | ||
19066 | |||
19067 | function Hmac(hash, key, enc) { | ||
19068 | if (!(this instanceof Hmac)) | ||
19069 | return new Hmac(hash, key, enc); | ||
19070 | this.Hash = hash; | ||
19071 | this.blockSize = hash.blockSize / 8; | ||
19072 | this.outSize = hash.outSize / 8; | ||
19073 | this.inner = null; | ||
19074 | this.outer = null; | ||
19075 | |||
19076 | this._init(utils.toArray(key, enc)); | ||
19077 | } | ||
19078 | module.exports = Hmac; | ||
19079 | |||
19080 | Hmac.prototype._init = function init(key) { | ||
19081 | // Shorten key, if needed | ||
19082 | if (key.length > this.blockSize) | ||
19083 | key = new this.Hash().update(key).digest(); | ||
19084 | assert(key.length <= this.blockSize); | ||
19085 | |||
19086 | // Add padding to key | ||
19087 | for (var i = key.length; i < this.blockSize; i++) | ||
19088 | key.push(0); | ||
19089 | |||
19090 | for (i = 0; i < key.length; i++) | ||
19091 | key[i] ^= 0x36; | ||
19092 | this.inner = new this.Hash().update(key); | ||
19093 | |||
19094 | // 0x36 ^ 0x5c = 0x6a | ||
19095 | for (i = 0; i < key.length; i++) | ||
19096 | key[i] ^= 0x6a; | ||
19097 | this.outer = new this.Hash().update(key); | ||
19098 | }; | ||
19099 | |||
19100 | Hmac.prototype.update = function update(msg, enc) { | ||
19101 | this.inner.update(msg, enc); | ||
19102 | return this; | ||
19103 | }; | ||
19104 | |||
19105 | Hmac.prototype.digest = function digest(enc) { | ||
19106 | this.outer.update(this.inner.digest()); | ||
19107 | return this.outer.digest(enc); | ||
19108 | }; | ||
19109 | |||
19110 | },{"./utils":113,"minimalistic-assert":356}],105:[function(require,module,exports){ | ||
19111 | 'use strict'; | ||
19112 | |||
19113 | var utils = require('./utils'); | ||
19114 | var common = require('./common'); | ||
19115 | |||
19116 | var rotl32 = utils.rotl32; | ||
19117 | var sum32 = utils.sum32; | ||
19118 | var sum32_3 = utils.sum32_3; | ||
19119 | var sum32_4 = utils.sum32_4; | ||
19120 | var BlockHash = common.BlockHash; | ||
19121 | |||
19122 | function RIPEMD160() { | ||
19123 | if (!(this instanceof RIPEMD160)) | ||
19124 | return new RIPEMD160(); | ||
19125 | |||
19126 | BlockHash.call(this); | ||
19127 | |||
19128 | this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ]; | ||
19129 | this.endian = 'little'; | ||
19130 | } | ||
19131 | utils.inherits(RIPEMD160, BlockHash); | ||
19132 | exports.ripemd160 = RIPEMD160; | ||
19133 | |||
19134 | RIPEMD160.blockSize = 512; | ||
19135 | RIPEMD160.outSize = 160; | ||
19136 | RIPEMD160.hmacStrength = 192; | ||
19137 | RIPEMD160.padLength = 64; | ||
19138 | |||
19139 | RIPEMD160.prototype._update = function update(msg, start) { | ||
19140 | var A = this.h[0]; | ||
19141 | var B = this.h[1]; | ||
19142 | var C = this.h[2]; | ||
19143 | var D = this.h[3]; | ||
19144 | var E = this.h[4]; | ||
19145 | var Ah = A; | ||
19146 | var Bh = B; | ||
19147 | var Ch = C; | ||
19148 | var Dh = D; | ||
19149 | var Eh = E; | ||
19150 | for (var j = 0; j < 80; j++) { | ||
19151 | var T = sum32( | ||
19152 | rotl32( | ||
19153 | sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), | ||
19154 | s[j]), | ||
19155 | E); | ||
19156 | A = E; | ||
19157 | E = D; | ||
19158 | D = rotl32(C, 10); | ||
19159 | C = B; | ||
19160 | B = T; | ||
19161 | T = sum32( | ||
19162 | rotl32( | ||
19163 | sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), | ||
19164 | sh[j]), | ||
19165 | Eh); | ||
19166 | Ah = Eh; | ||
19167 | Eh = Dh; | ||
19168 | Dh = rotl32(Ch, 10); | ||
19169 | Ch = Bh; | ||
19170 | Bh = T; | ||
19171 | } | ||
19172 | T = sum32_3(this.h[1], C, Dh); | ||
19173 | this.h[1] = sum32_3(this.h[2], D, Eh); | ||
19174 | this.h[2] = sum32_3(this.h[3], E, Ah); | ||
19175 | this.h[3] = sum32_3(this.h[4], A, Bh); | ||
19176 | this.h[4] = sum32_3(this.h[0], B, Ch); | ||
19177 | this.h[0] = T; | ||
19178 | }; | ||
19179 | |||
19180 | RIPEMD160.prototype._digest = function digest(enc) { | ||
19181 | if (enc === 'hex') | ||
19182 | return utils.toHex32(this.h, 'little'); | ||
19183 | else | ||
19184 | return utils.split32(this.h, 'little'); | ||
19185 | }; | ||
19186 | |||
19187 | function f(j, x, y, z) { | ||
19188 | if (j <= 15) | ||
19189 | return x ^ y ^ z; | ||
19190 | else if (j <= 31) | ||
19191 | return (x & y) | ((~x) & z); | ||
19192 | else if (j <= 47) | ||
19193 | return (x | (~y)) ^ z; | ||
19194 | else if (j <= 63) | ||
19195 | return (x & z) | (y & (~z)); | ||
19196 | else | ||
19197 | return x ^ (y | (~z)); | ||
19198 | } | ||
19199 | |||
19200 | function K(j) { | ||
19201 | if (j <= 15) | ||
19202 | return 0x00000000; | ||
19203 | else if (j <= 31) | ||
19204 | return 0x5a827999; | ||
19205 | else if (j <= 47) | ||
19206 | return 0x6ed9eba1; | ||
19207 | else if (j <= 63) | ||
19208 | return 0x8f1bbcdc; | ||
19209 | else | ||
19210 | return 0xa953fd4e; | ||
19211 | } | ||
19212 | |||
19213 | function Kh(j) { | ||
19214 | if (j <= 15) | ||
19215 | return 0x50a28be6; | ||
19216 | else if (j <= 31) | ||
19217 | return 0x5c4dd124; | ||
19218 | else if (j <= 47) | ||
19219 | return 0x6d703ef3; | ||
19220 | else if (j <= 63) | ||
19221 | return 0x7a6d76e9; | ||
19222 | else | ||
19223 | return 0x00000000; | ||
19224 | } | ||
19225 | |||
19226 | var r = [ | ||
19227 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, | ||
19228 | 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, | ||
19229 | 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, | ||
19230 | 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, | ||
19231 | 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 | ||
19232 | ]; | ||
19233 | |||
19234 | var rh = [ | ||
19235 | 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, | ||
19236 | 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, | ||
19237 | 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, | ||
19238 | 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, | ||
19239 | 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 | ||
19240 | ]; | ||
19241 | |||
19242 | var s = [ | ||
19243 | 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, | ||
19244 | 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, | ||
19245 | 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, | ||
19246 | 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, | ||
19247 | 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 | ||
19248 | ]; | ||
19249 | |||
19250 | var sh = [ | ||
19251 | 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, | ||
19252 | 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, | ||
19253 | 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, | ||
19254 | 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, | ||
19255 | 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 | ||
19256 | ]; | ||
19257 | |||
19258 | },{"./common":103,"./utils":113}],106:[function(require,module,exports){ | ||
19259 | 'use strict'; | ||
19260 | |||
19261 | exports.sha1 = require('./sha/1'); | ||
19262 | exports.sha224 = require('./sha/224'); | ||
19263 | exports.sha256 = require('./sha/256'); | ||
19264 | exports.sha384 = require('./sha/384'); | ||
19265 | exports.sha512 = require('./sha/512'); | ||
19266 | |||
19267 | },{"./sha/1":107,"./sha/224":108,"./sha/256":109,"./sha/384":110,"./sha/512":111}],107:[function(require,module,exports){ | ||
19268 | 'use strict'; | ||
19269 | |||
19270 | var utils = require('../utils'); | ||
19271 | var common = require('../common'); | ||
19272 | var shaCommon = require('./common'); | ||
19273 | |||
19274 | var rotl32 = utils.rotl32; | ||
19275 | var sum32 = utils.sum32; | ||
19276 | var sum32_5 = utils.sum32_5; | ||
19277 | var ft_1 = shaCommon.ft_1; | ||
19278 | var BlockHash = common.BlockHash; | ||
19279 | |||
19280 | var sha1_K = [ | ||
19281 | 0x5A827999, 0x6ED9EBA1, | ||
19282 | 0x8F1BBCDC, 0xCA62C1D6 | ||
19283 | ]; | ||
19284 | |||
19285 | function SHA1() { | ||
19286 | if (!(this instanceof SHA1)) | ||
19287 | return new SHA1(); | ||
19288 | |||
19289 | BlockHash.call(this); | ||
19290 | this.h = [ | ||
19291 | 0x67452301, 0xefcdab89, 0x98badcfe, | ||
19292 | 0x10325476, 0xc3d2e1f0 ]; | ||
19293 | this.W = new Array(80); | ||
19294 | } | ||
19295 | |||
19296 | utils.inherits(SHA1, BlockHash); | ||
19297 | module.exports = SHA1; | ||
19298 | |||
19299 | SHA1.blockSize = 512; | ||
19300 | SHA1.outSize = 160; | ||
19301 | SHA1.hmacStrength = 80; | ||
19302 | SHA1.padLength = 64; | ||
19303 | |||
19304 | SHA1.prototype._update = function _update(msg, start) { | ||
19305 | var W = this.W; | ||
19306 | |||
19307 | for (var i = 0; i < 16; i++) | ||
19308 | W[i] = msg[start + i]; | ||
19309 | |||
19310 | for(; i < W.length; i++) | ||
19311 | W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1); | ||
19312 | |||
19313 | var a = this.h[0]; | ||
19314 | var b = this.h[1]; | ||
19315 | var c = this.h[2]; | ||
19316 | var d = this.h[3]; | ||
19317 | var e = this.h[4]; | ||
19318 | |||
19319 | for (i = 0; i < W.length; i++) { | ||
19320 | var s = ~~(i / 20); | ||
19321 | var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]); | ||
19322 | e = d; | ||
19323 | d = c; | ||
19324 | c = rotl32(b, 30); | ||
19325 | b = a; | ||
19326 | a = t; | ||
19327 | } | ||
19328 | |||
19329 | this.h[0] = sum32(this.h[0], a); | ||
19330 | this.h[1] = sum32(this.h[1], b); | ||
19331 | this.h[2] = sum32(this.h[2], c); | ||
19332 | this.h[3] = sum32(this.h[3], d); | ||
19333 | this.h[4] = sum32(this.h[4], e); | ||
19334 | }; | ||
19335 | |||
19336 | SHA1.prototype._digest = function digest(enc) { | ||
19337 | if (enc === 'hex') | ||
19338 | return utils.toHex32(this.h, 'big'); | ||
19339 | else | ||
19340 | return utils.split32(this.h, 'big'); | ||
19341 | }; | ||
19342 | |||
19343 | },{"../common":103,"../utils":113,"./common":112}],108:[function(require,module,exports){ | ||
19344 | 'use strict'; | ||
19345 | |||
19346 | var utils = require('../utils'); | ||
19347 | var SHA256 = require('./256'); | ||
19348 | |||
19349 | function SHA224() { | ||
19350 | if (!(this instanceof SHA224)) | ||
19351 | return new SHA224(); | ||
19352 | |||
19353 | SHA256.call(this); | ||
19354 | this.h = [ | ||
19355 | 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, | ||
19356 | 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ]; | ||
19357 | } | ||
19358 | utils.inherits(SHA224, SHA256); | ||
19359 | module.exports = SHA224; | ||
19360 | |||
19361 | SHA224.blockSize = 512; | ||
19362 | SHA224.outSize = 224; | ||
19363 | SHA224.hmacStrength = 192; | ||
19364 | SHA224.padLength = 64; | ||
19365 | |||
19366 | SHA224.prototype._digest = function digest(enc) { | ||
19367 | // Just truncate output | ||
19368 | if (enc === 'hex') | ||
19369 | return utils.toHex32(this.h.slice(0, 7), 'big'); | ||
19370 | else | ||
19371 | return utils.split32(this.h.slice(0, 7), 'big'); | ||
19372 | }; | ||
19373 | |||
19374 | |||
19375 | },{"../utils":113,"./256":109}],109:[function(require,module,exports){ | ||
19376 | 'use strict'; | ||
19377 | |||
19378 | var utils = require('../utils'); | ||
19379 | var common = require('../common'); | ||
19380 | var shaCommon = require('./common'); | ||
19381 | var assert = require('minimalistic-assert'); | ||
19382 | |||
19383 | var sum32 = utils.sum32; | ||
19384 | var sum32_4 = utils.sum32_4; | ||
19385 | var sum32_5 = utils.sum32_5; | ||
19386 | var ch32 = shaCommon.ch32; | ||
19387 | var maj32 = shaCommon.maj32; | ||
19388 | var s0_256 = shaCommon.s0_256; | ||
19389 | var s1_256 = shaCommon.s1_256; | ||
19390 | var g0_256 = shaCommon.g0_256; | ||
19391 | var g1_256 = shaCommon.g1_256; | ||
19392 | |||
19393 | var BlockHash = common.BlockHash; | ||
19394 | |||
19395 | var sha256_K = [ | ||
19396 | 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, | ||
19397 | 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, | ||
19398 | 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, | ||
19399 | 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, | ||
19400 | 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, | ||
19401 | 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, | ||
19402 | 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, | ||
19403 | 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, | ||
19404 | 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, | ||
19405 | 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, | ||
19406 | 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, | ||
19407 | 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, | ||
19408 | 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, | ||
19409 | 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, | ||
19410 | 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, | ||
19411 | 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 | ||
19412 | ]; | ||
19413 | |||
19414 | function SHA256() { | ||
19415 | if (!(this instanceof SHA256)) | ||
19416 | return new SHA256(); | ||
19417 | |||
19418 | BlockHash.call(this); | ||
19419 | this.h = [ | ||
19420 | 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, | ||
19421 | 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 | ||
19422 | ]; | ||
19423 | this.k = sha256_K; | ||
19424 | this.W = new Array(64); | ||
19425 | } | ||
19426 | utils.inherits(SHA256, BlockHash); | ||
19427 | module.exports = SHA256; | ||
19428 | |||
19429 | SHA256.blockSize = 512; | ||
19430 | SHA256.outSize = 256; | ||
19431 | SHA256.hmacStrength = 192; | ||
19432 | SHA256.padLength = 64; | ||
19433 | |||
19434 | SHA256.prototype._update = function _update(msg, start) { | ||
19435 | var W = this.W; | ||
19436 | |||
19437 | for (var i = 0; i < 16; i++) | ||
19438 | W[i] = msg[start + i]; | ||
19439 | for (; i < W.length; i++) | ||
19440 | W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]); | ||
19441 | |||
19442 | var a = this.h[0]; | ||
19443 | var b = this.h[1]; | ||
19444 | var c = this.h[2]; | ||
19445 | var d = this.h[3]; | ||
19446 | var e = this.h[4]; | ||
19447 | var f = this.h[5]; | ||
19448 | var g = this.h[6]; | ||
19449 | var h = this.h[7]; | ||
19450 | |||
19451 | assert(this.k.length === W.length); | ||
19452 | for (i = 0; i < W.length; i++) { | ||
19453 | var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]); | ||
19454 | var T2 = sum32(s0_256(a), maj32(a, b, c)); | ||
19455 | h = g; | ||
19456 | g = f; | ||
19457 | f = e; | ||
19458 | e = sum32(d, T1); | ||
19459 | d = c; | ||
19460 | c = b; | ||
19461 | b = a; | ||
19462 | a = sum32(T1, T2); | ||
19463 | } | ||
19464 | |||
19465 | this.h[0] = sum32(this.h[0], a); | ||
19466 | this.h[1] = sum32(this.h[1], b); | ||
19467 | this.h[2] = sum32(this.h[2], c); | ||
19468 | this.h[3] = sum32(this.h[3], d); | ||
19469 | this.h[4] = sum32(this.h[4], e); | ||
19470 | this.h[5] = sum32(this.h[5], f); | ||
19471 | this.h[6] = sum32(this.h[6], g); | ||
19472 | this.h[7] = sum32(this.h[7], h); | ||
19473 | }; | ||
19474 | |||
19475 | SHA256.prototype._digest = function digest(enc) { | ||
19476 | if (enc === 'hex') | ||
19477 | return utils.toHex32(this.h, 'big'); | ||
19478 | else | ||
19479 | return utils.split32(this.h, 'big'); | ||
19480 | }; | ||
19481 | |||
19482 | },{"../common":103,"../utils":113,"./common":112,"minimalistic-assert":356}],110:[function(require,module,exports){ | ||
19483 | 'use strict'; | ||
19484 | |||
19485 | var utils = require('../utils'); | ||
19486 | |||
19487 | var SHA512 = require('./512'); | ||
19488 | |||
19489 | function SHA384() { | ||
19490 | if (!(this instanceof SHA384)) | ||
19491 | return new SHA384(); | ||
19492 | |||
19493 | SHA512.call(this); | ||
19494 | this.h = [ | ||
19495 | 0xcbbb9d5d, 0xc1059ed8, | ||
19496 | 0x629a292a, 0x367cd507, | ||
19497 | 0x9159015a, 0x3070dd17, | ||
19498 | 0x152fecd8, 0xf70e5939, | ||
19499 | 0x67332667, 0xffc00b31, | ||
19500 | 0x8eb44a87, 0x68581511, | ||
19501 | 0xdb0c2e0d, 0x64f98fa7, | ||
19502 | 0x47b5481d, 0xbefa4fa4 ]; | ||
19503 | } | ||
19504 | utils.inherits(SHA384, SHA512); | ||
19505 | module.exports = SHA384; | ||
19506 | |||
19507 | SHA384.blockSize = 1024; | ||
19508 | SHA384.outSize = 384; | ||
19509 | SHA384.hmacStrength = 192; | ||
19510 | SHA384.padLength = 128; | ||
19511 | |||
19512 | SHA384.prototype._digest = function digest(enc) { | ||
19513 | if (enc === 'hex') | ||
19514 | return utils.toHex32(this.h.slice(0, 12), 'big'); | ||
19515 | else | ||
19516 | return utils.split32(this.h.slice(0, 12), 'big'); | ||
19517 | }; | ||
19518 | |||
19519 | },{"../utils":113,"./512":111}],111:[function(require,module,exports){ | ||
19520 | 'use strict'; | ||
19521 | |||
19522 | var utils = require('../utils'); | ||
19523 | var common = require('../common'); | ||
19524 | var assert = require('minimalistic-assert'); | ||
19525 | |||
19526 | var rotr64_hi = utils.rotr64_hi; | ||
19527 | var rotr64_lo = utils.rotr64_lo; | ||
19528 | var shr64_hi = utils.shr64_hi; | ||
19529 | var shr64_lo = utils.shr64_lo; | ||
19530 | var sum64 = utils.sum64; | ||
19531 | var sum64_hi = utils.sum64_hi; | ||
19532 | var sum64_lo = utils.sum64_lo; | ||
19533 | var sum64_4_hi = utils.sum64_4_hi; | ||
19534 | var sum64_4_lo = utils.sum64_4_lo; | ||
19535 | var sum64_5_hi = utils.sum64_5_hi; | ||
19536 | var sum64_5_lo = utils.sum64_5_lo; | ||
19537 | |||
19538 | var BlockHash = common.BlockHash; | ||
19539 | |||
19540 | var sha512_K = [ | ||
19541 | 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, | ||
19542 | 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, | ||
19543 | 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, | ||
19544 | 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, | ||
19545 | 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, | ||
19546 | 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, | ||
19547 | 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, | ||
19548 | 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, | ||
19549 | 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, | ||
19550 | 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, | ||
19551 | 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, | ||
19552 | 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, | ||
19553 | 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, | ||
19554 | 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, | ||
19555 | 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, | ||
19556 | 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, | ||
19557 | 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, | ||
19558 | 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, | ||
19559 | 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, | ||
19560 | 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, | ||
19561 | 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, | ||
19562 | 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, | ||
19563 | 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, | ||
19564 | 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, | ||
19565 | 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, | ||
19566 | 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, | ||
19567 | 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, | ||
19568 | 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, | ||
19569 | 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, | ||
19570 | 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, | ||
19571 | 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, | ||
19572 | 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, | ||
19573 | 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, | ||
19574 | 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, | ||
19575 | 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, | ||
19576 | 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, | ||
19577 | 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, | ||
19578 | 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, | ||
19579 | 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, | ||
19580 | 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 | ||
19581 | ]; | ||
19582 | |||
19583 | function SHA512() { | ||
19584 | if (!(this instanceof SHA512)) | ||
19585 | return new SHA512(); | ||
19586 | |||
19587 | BlockHash.call(this); | ||
19588 | this.h = [ | ||
19589 | 0x6a09e667, 0xf3bcc908, | ||
19590 | 0xbb67ae85, 0x84caa73b, | ||
19591 | 0x3c6ef372, 0xfe94f82b, | ||
19592 | 0xa54ff53a, 0x5f1d36f1, | ||
19593 | 0x510e527f, 0xade682d1, | ||
19594 | 0x9b05688c, 0x2b3e6c1f, | ||
19595 | 0x1f83d9ab, 0xfb41bd6b, | ||
19596 | 0x5be0cd19, 0x137e2179 ]; | ||
19597 | this.k = sha512_K; | ||
19598 | this.W = new Array(160); | ||
19599 | } | ||
19600 | utils.inherits(SHA512, BlockHash); | ||
19601 | module.exports = SHA512; | ||
19602 | |||
19603 | SHA512.blockSize = 1024; | ||
19604 | SHA512.outSize = 512; | ||
19605 | SHA512.hmacStrength = 192; | ||
19606 | SHA512.padLength = 128; | ||
19607 | |||
19608 | SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) { | ||
19609 | var W = this.W; | ||
19610 | |||
19611 | // 32 x 32bit words | ||
19612 | for (var i = 0; i < 32; i++) | ||
19613 | W[i] = msg[start + i]; | ||
19614 | for (; i < W.length; i += 2) { | ||
19615 | var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // i - 2 | ||
19616 | var c0_lo = g1_512_lo(W[i - 4], W[i - 3]); | ||
19617 | var c1_hi = W[i - 14]; // i - 7 | ||
19618 | var c1_lo = W[i - 13]; | ||
19619 | var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // i - 15 | ||
19620 | var c2_lo = g0_512_lo(W[i - 30], W[i - 29]); | ||
19621 | var c3_hi = W[i - 32]; // i - 16 | ||
19622 | var c3_lo = W[i - 31]; | ||
19623 | |||
19624 | W[i] = sum64_4_hi( | ||
19625 | c0_hi, c0_lo, | ||
19626 | c1_hi, c1_lo, | ||
19627 | c2_hi, c2_lo, | ||
19628 | c3_hi, c3_lo); | ||
19629 | W[i + 1] = sum64_4_lo( | ||
19630 | c0_hi, c0_lo, | ||
19631 | c1_hi, c1_lo, | ||
19632 | c2_hi, c2_lo, | ||
19633 | c3_hi, c3_lo); | ||
19634 | } | ||
19635 | }; | ||
19636 | |||
19637 | SHA512.prototype._update = function _update(msg, start) { | ||
19638 | this._prepareBlock(msg, start); | ||
19639 | |||
19640 | var W = this.W; | ||
19641 | |||
19642 | var ah = this.h[0]; | ||
19643 | var al = this.h[1]; | ||
19644 | var bh = this.h[2]; | ||
19645 | var bl = this.h[3]; | ||
19646 | var ch = this.h[4]; | ||
19647 | var cl = this.h[5]; | ||
19648 | var dh = this.h[6]; | ||
19649 | var dl = this.h[7]; | ||
19650 | var eh = this.h[8]; | ||
19651 | var el = this.h[9]; | ||
19652 | var fh = this.h[10]; | ||
19653 | var fl = this.h[11]; | ||
19654 | var gh = this.h[12]; | ||
19655 | var gl = this.h[13]; | ||
19656 | var hh = this.h[14]; | ||
19657 | var hl = this.h[15]; | ||
19658 | |||
19659 | assert(this.k.length === W.length); | ||
19660 | for (var i = 0; i < W.length; i += 2) { | ||
19661 | var c0_hi = hh; | ||
19662 | var c0_lo = hl; | ||
19663 | var c1_hi = s1_512_hi(eh, el); | ||
19664 | var c1_lo = s1_512_lo(eh, el); | ||
19665 | var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl); | ||
19666 | var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl); | ||
19667 | var c3_hi = this.k[i]; | ||
19668 | var c3_lo = this.k[i + 1]; | ||
19669 | var c4_hi = W[i]; | ||
19670 | var c4_lo = W[i + 1]; | ||
19671 | |||
19672 | var T1_hi = sum64_5_hi( | ||
19673 | c0_hi, c0_lo, | ||
19674 | c1_hi, c1_lo, | ||
19675 | c2_hi, c2_lo, | ||
19676 | c3_hi, c3_lo, | ||
19677 | c4_hi, c4_lo); | ||
19678 | var T1_lo = sum64_5_lo( | ||
19679 | c0_hi, c0_lo, | ||
19680 | c1_hi, c1_lo, | ||
19681 | c2_hi, c2_lo, | ||
19682 | c3_hi, c3_lo, | ||
19683 | c4_hi, c4_lo); | ||
19684 | |||
19685 | c0_hi = s0_512_hi(ah, al); | ||
19686 | c0_lo = s0_512_lo(ah, al); | ||
19687 | c1_hi = maj64_hi(ah, al, bh, bl, ch, cl); | ||
19688 | c1_lo = maj64_lo(ah, al, bh, bl, ch, cl); | ||
19689 | |||
19690 | var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo); | ||
19691 | var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo); | ||
19692 | |||
19693 | hh = gh; | ||
19694 | hl = gl; | ||
19695 | |||
19696 | gh = fh; | ||
19697 | gl = fl; | ||
19698 | |||
19699 | fh = eh; | ||
19700 | fl = el; | ||
19701 | |||
19702 | eh = sum64_hi(dh, dl, T1_hi, T1_lo); | ||
19703 | el = sum64_lo(dl, dl, T1_hi, T1_lo); | ||
19704 | |||
19705 | dh = ch; | ||
19706 | dl = cl; | ||
19707 | |||
19708 | ch = bh; | ||
19709 | cl = bl; | ||
19710 | |||
19711 | bh = ah; | ||
19712 | bl = al; | ||
19713 | |||
19714 | ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo); | ||
19715 | al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo); | ||
19716 | } | ||
19717 | |||
19718 | sum64(this.h, 0, ah, al); | ||
19719 | sum64(this.h, 2, bh, bl); | ||
19720 | sum64(this.h, 4, ch, cl); | ||
19721 | sum64(this.h, 6, dh, dl); | ||
19722 | sum64(this.h, 8, eh, el); | ||
19723 | sum64(this.h, 10, fh, fl); | ||
19724 | sum64(this.h, 12, gh, gl); | ||
19725 | sum64(this.h, 14, hh, hl); | ||
19726 | }; | ||
19727 | |||
19728 | SHA512.prototype._digest = function digest(enc) { | ||
19729 | if (enc === 'hex') | ||
19730 | return utils.toHex32(this.h, 'big'); | ||
19731 | else | ||
19732 | return utils.split32(this.h, 'big'); | ||
19733 | }; | ||
19734 | |||
19735 | function ch64_hi(xh, xl, yh, yl, zh) { | ||
19736 | var r = (xh & yh) ^ ((~xh) & zh); | ||
19737 | if (r < 0) | ||
19738 | r += 0x100000000; | ||
19739 | return r; | ||
19740 | } | ||
19741 | |||
19742 | function ch64_lo(xh, xl, yh, yl, zh, zl) { | ||
19743 | var r = (xl & yl) ^ ((~xl) & zl); | ||
19744 | if (r < 0) | ||
19745 | r += 0x100000000; | ||
19746 | return r; | ||
19747 | } | ||
19748 | |||
19749 | function maj64_hi(xh, xl, yh, yl, zh) { | ||
19750 | var r = (xh & yh) ^ (xh & zh) ^ (yh & zh); | ||
19751 | if (r < 0) | ||
19752 | r += 0x100000000; | ||
19753 | return r; | ||
19754 | } | ||
19755 | |||
19756 | function maj64_lo(xh, xl, yh, yl, zh, zl) { | ||
19757 | var r = (xl & yl) ^ (xl & zl) ^ (yl & zl); | ||
19758 | if (r < 0) | ||
19759 | r += 0x100000000; | ||
19760 | return r; | ||
19761 | } | ||
19762 | |||
19763 | function s0_512_hi(xh, xl) { | ||
19764 | var c0_hi = rotr64_hi(xh, xl, 28); | ||
19765 | var c1_hi = rotr64_hi(xl, xh, 2); // 34 | ||
19766 | var c2_hi = rotr64_hi(xl, xh, 7); // 39 | ||
19767 | |||
19768 | var r = c0_hi ^ c1_hi ^ c2_hi; | ||
19769 | if (r < 0) | ||
19770 | r += 0x100000000; | ||
19771 | return r; | ||
19772 | } | ||
19773 | |||
19774 | function s0_512_lo(xh, xl) { | ||
19775 | var c0_lo = rotr64_lo(xh, xl, 28); | ||
19776 | var c1_lo = rotr64_lo(xl, xh, 2); // 34 | ||
19777 | var c2_lo = rotr64_lo(xl, xh, 7); // 39 | ||
19778 | |||
19779 | var r = c0_lo ^ c1_lo ^ c2_lo; | ||
19780 | if (r < 0) | ||
19781 | r += 0x100000000; | ||
19782 | return r; | ||
19783 | } | ||
19784 | |||
19785 | function s1_512_hi(xh, xl) { | ||
19786 | var c0_hi = rotr64_hi(xh, xl, 14); | ||
19787 | var c1_hi = rotr64_hi(xh, xl, 18); | ||
19788 | var c2_hi = rotr64_hi(xl, xh, 9); // 41 | ||
19789 | |||
19790 | var r = c0_hi ^ c1_hi ^ c2_hi; | ||
19791 | if (r < 0) | ||
19792 | r += 0x100000000; | ||
19793 | return r; | ||
19794 | } | ||
19795 | |||
19796 | function s1_512_lo(xh, xl) { | ||
19797 | var c0_lo = rotr64_lo(xh, xl, 14); | ||
19798 | var c1_lo = rotr64_lo(xh, xl, 18); | ||
19799 | var c2_lo = rotr64_lo(xl, xh, 9); // 41 | ||
19800 | |||
19801 | var r = c0_lo ^ c1_lo ^ c2_lo; | ||
19802 | if (r < 0) | ||
19803 | r += 0x100000000; | ||
19804 | return r; | ||
19805 | } | ||
19806 | |||
19807 | function g0_512_hi(xh, xl) { | ||
19808 | var c0_hi = rotr64_hi(xh, xl, 1); | ||
19809 | var c1_hi = rotr64_hi(xh, xl, 8); | ||
19810 | var c2_hi = shr64_hi(xh, xl, 7); | ||
19811 | |||
19812 | var r = c0_hi ^ c1_hi ^ c2_hi; | ||
19813 | if (r < 0) | ||
19814 | r += 0x100000000; | ||
19815 | return r; | ||
19816 | } | ||
19817 | |||
19818 | function g0_512_lo(xh, xl) { | ||
19819 | var c0_lo = rotr64_lo(xh, xl, 1); | ||
19820 | var c1_lo = rotr64_lo(xh, xl, 8); | ||
19821 | var c2_lo = shr64_lo(xh, xl, 7); | ||
19822 | |||
19823 | var r = c0_lo ^ c1_lo ^ c2_lo; | ||
19824 | if (r < 0) | ||
19825 | r += 0x100000000; | ||
19826 | return r; | ||
19827 | } | ||
19828 | |||
19829 | function g1_512_hi(xh, xl) { | ||
19830 | var c0_hi = rotr64_hi(xh, xl, 19); | ||
19831 | var c1_hi = rotr64_hi(xl, xh, 29); // 61 | ||
19832 | var c2_hi = shr64_hi(xh, xl, 6); | ||
19833 | |||
19834 | var r = c0_hi ^ c1_hi ^ c2_hi; | ||
19835 | if (r < 0) | ||
19836 | r += 0x100000000; | ||
19837 | return r; | ||
19838 | } | ||
19839 | |||
19840 | function g1_512_lo(xh, xl) { | ||
19841 | var c0_lo = rotr64_lo(xh, xl, 19); | ||
19842 | var c1_lo = rotr64_lo(xl, xh, 29); // 61 | ||
19843 | var c2_lo = shr64_lo(xh, xl, 6); | ||
19844 | |||
19845 | var r = c0_lo ^ c1_lo ^ c2_lo; | ||
19846 | if (r < 0) | ||
19847 | r += 0x100000000; | ||
19848 | return r; | ||
19849 | } | ||
19850 | |||
19851 | },{"../common":103,"../utils":113,"minimalistic-assert":356}],112:[function(require,module,exports){ | ||
19852 | 'use strict'; | ||
19853 | |||
19854 | var utils = require('../utils'); | ||
19855 | var rotr32 = utils.rotr32; | ||
19856 | |||
19857 | function ft_1(s, x, y, z) { | ||
19858 | if (s === 0) | ||
19859 | return ch32(x, y, z); | ||
19860 | if (s === 1 || s === 3) | ||
19861 | return p32(x, y, z); | ||
19862 | if (s === 2) | ||
19863 | return maj32(x, y, z); | ||
19864 | } | ||
19865 | exports.ft_1 = ft_1; | ||
19866 | |||
19867 | function ch32(x, y, z) { | ||
19868 | return (x & y) ^ ((~x) & z); | ||
19869 | } | ||
19870 | exports.ch32 = ch32; | ||
19871 | |||
19872 | function maj32(x, y, z) { | ||
19873 | return (x & y) ^ (x & z) ^ (y & z); | ||
19874 | } | ||
19875 | exports.maj32 = maj32; | ||
19876 | |||
19877 | function p32(x, y, z) { | ||
19878 | return x ^ y ^ z; | ||
19879 | } | ||
19880 | exports.p32 = p32; | ||
19881 | |||
19882 | function s0_256(x) { | ||
19883 | return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22); | ||
19884 | } | ||
19885 | exports.s0_256 = s0_256; | ||
19886 | |||
19887 | function s1_256(x) { | ||
19888 | return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25); | ||
19889 | } | ||
19890 | exports.s1_256 = s1_256; | ||
19891 | |||
19892 | function g0_256(x) { | ||
19893 | return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3); | ||
19894 | } | ||
19895 | exports.g0_256 = g0_256; | ||
19896 | |||
19897 | function g1_256(x) { | ||
19898 | return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10); | ||
19899 | } | ||
19900 | exports.g1_256 = g1_256; | ||
19901 | |||
19902 | },{"../utils":113}],113:[function(require,module,exports){ | ||
19903 | 'use strict'; | ||
19904 | |||
19905 | var assert = require('minimalistic-assert'); | ||
19906 | var inherits = require('inherits'); | ||
19907 | |||
19908 | exports.inherits = inherits; | ||
19909 | |||
19910 | function isSurrogatePair(msg, i) { | ||
19911 | if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) { | ||
19912 | return false; | ||
19913 | } | ||
19914 | if (i < 0 || i + 1 >= msg.length) { | ||
19915 | return false; | ||
19916 | } | ||
19917 | return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00; | ||
19918 | } | ||
19919 | |||
19920 | function toArray(msg, enc) { | ||
19921 | if (Array.isArray(msg)) | ||
19922 | return msg.slice(); | ||
19923 | if (!msg) | ||
19924 | return []; | ||
19925 | var res = []; | ||
19926 | if (typeof msg === 'string') { | ||
19927 | if (!enc) { | ||
19928 | // Inspired by stringToUtf8ByteArray() in closure-library by Google | ||
19929 | // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143 | ||
19930 | // Apache License 2.0 | ||
19931 | // https://github.com/google/closure-library/blob/master/LICENSE | ||
19932 | var p = 0; | ||
19933 | for (var i = 0; i < msg.length; i++) { | ||
19934 | var c = msg.charCodeAt(i); | ||
19935 | if (c < 128) { | ||
19936 | res[p++] = c; | ||
19937 | } else if (c < 2048) { | ||
19938 | res[p++] = (c >> 6) | 192; | ||
19939 | res[p++] = (c & 63) | 128; | ||
19940 | } else if (isSurrogatePair(msg, i)) { | ||
19941 | c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF); | ||
19942 | res[p++] = (c >> 18) | 240; | ||
19943 | res[p++] = ((c >> 12) & 63) | 128; | ||
19944 | res[p++] = ((c >> 6) & 63) | 128; | ||
19945 | res[p++] = (c & 63) | 128; | ||
19946 | } else { | ||
19947 | res[p++] = (c >> 12) | 224; | ||
19948 | res[p++] = ((c >> 6) & 63) | 128; | ||
19949 | res[p++] = (c & 63) | 128; | ||
19950 | } | ||
19951 | } | ||
19952 | } else if (enc === 'hex') { | ||
19953 | msg = msg.replace(/[^a-z0-9]+/ig, ''); | ||
19954 | if (msg.length % 2 !== 0) | ||
19955 | msg = '0' + msg; | ||
19956 | for (i = 0; i < msg.length; i += 2) | ||
19957 | res.push(parseInt(msg[i] + msg[i + 1], 16)); | ||
19958 | } | ||
19959 | } else { | ||
19960 | for (i = 0; i < msg.length; i++) | ||
19961 | res[i] = msg[i] | 0; | ||
19962 | } | ||
19963 | return res; | ||
19964 | } | ||
19965 | exports.toArray = toArray; | ||
19966 | |||
19967 | function toHex(msg) { | ||
19968 | var res = ''; | ||
19969 | for (var i = 0; i < msg.length; i++) | ||
19970 | res += zero2(msg[i].toString(16)); | ||
19971 | return res; | ||
19972 | } | ||
19973 | exports.toHex = toHex; | ||
19974 | |||
19975 | function htonl(w) { | ||
19976 | var res = (w >>> 24) | | ||
19977 | ((w >>> 8) & 0xff00) | | ||
19978 | ((w << 8) & 0xff0000) | | ||
19979 | ((w & 0xff) << 24); | ||
19980 | return res >>> 0; | ||
19981 | } | ||
19982 | exports.htonl = htonl; | ||
19983 | |||
19984 | function toHex32(msg, endian) { | ||
19985 | var res = ''; | ||
19986 | for (var i = 0; i < msg.length; i++) { | ||
19987 | var w = msg[i]; | ||
19988 | if (endian === 'little') | ||
19989 | w = htonl(w); | ||
19990 | res += zero8(w.toString(16)); | ||
19991 | } | ||
19992 | return res; | ||
19993 | } | ||
19994 | exports.toHex32 = toHex32; | ||
19995 | |||
19996 | function zero2(word) { | ||
19997 | if (word.length === 1) | ||
19998 | return '0' + word; | ||
19999 | else | ||
20000 | return word; | ||
20001 | } | ||
20002 | exports.zero2 = zero2; | ||
20003 | |||
20004 | function zero8(word) { | ||
20005 | if (word.length === 7) | ||
20006 | return '0' + word; | ||
20007 | else if (word.length === 6) | ||
20008 | return '00' + word; | ||
20009 | else if (word.length === 5) | ||
20010 | return '000' + word; | ||
20011 | else if (word.length === 4) | ||
20012 | return '0000' + word; | ||
20013 | else if (word.length === 3) | ||
20014 | return '00000' + word; | ||
20015 | else if (word.length === 2) | ||
20016 | return '000000' + word; | ||
20017 | else if (word.length === 1) | ||
20018 | return '0000000' + word; | ||
20019 | else | ||
20020 | return word; | ||
20021 | } | ||
20022 | exports.zero8 = zero8; | ||
20023 | |||
20024 | function join32(msg, start, end, endian) { | ||
20025 | var len = end - start; | ||
20026 | assert(len % 4 === 0); | ||
20027 | var res = new Array(len / 4); | ||
20028 | for (var i = 0, k = start; i < res.length; i++, k += 4) { | ||
20029 | var w; | ||
20030 | if (endian === 'big') | ||
20031 | w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3]; | ||
20032 | else | ||
20033 | w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k]; | ||
20034 | res[i] = w >>> 0; | ||
20035 | } | ||
20036 | return res; | ||
20037 | } | ||
20038 | exports.join32 = join32; | ||
20039 | |||
20040 | function split32(msg, endian) { | ||
20041 | var res = new Array(msg.length * 4); | ||
20042 | for (var i = 0, k = 0; i < msg.length; i++, k += 4) { | ||
20043 | var m = msg[i]; | ||
20044 | if (endian === 'big') { | ||
20045 | res[k] = m >>> 24; | ||
20046 | res[k + 1] = (m >>> 16) & 0xff; | ||
20047 | res[k + 2] = (m >>> 8) & 0xff; | ||
20048 | res[k + 3] = m & 0xff; | ||
20049 | } else { | ||
20050 | res[k + 3] = m >>> 24; | ||
20051 | res[k + 2] = (m >>> 16) & 0xff; | ||
20052 | res[k + 1] = (m >>> 8) & 0xff; | ||
20053 | res[k] = m & 0xff; | ||
20054 | } | ||
20055 | } | ||
20056 | return res; | ||
20057 | } | ||
20058 | exports.split32 = split32; | ||
20059 | |||
20060 | function rotr32(w, b) { | ||
20061 | return (w >>> b) | (w << (32 - b)); | ||
20062 | } | ||
20063 | exports.rotr32 = rotr32; | ||
20064 | |||
20065 | function rotl32(w, b) { | ||
20066 | return (w << b) | (w >>> (32 - b)); | ||
20067 | } | ||
20068 | exports.rotl32 = rotl32; | ||
20069 | |||
20070 | function sum32(a, b) { | ||
20071 | return (a + b) >>> 0; | ||
20072 | } | ||
20073 | exports.sum32 = sum32; | ||
20074 | |||
20075 | function sum32_3(a, b, c) { | ||
20076 | return (a + b + c) >>> 0; | ||
20077 | } | ||
20078 | exports.sum32_3 = sum32_3; | ||
20079 | |||
20080 | function sum32_4(a, b, c, d) { | ||
20081 | return (a + b + c + d) >>> 0; | ||
20082 | } | ||
20083 | exports.sum32_4 = sum32_4; | ||
20084 | |||
20085 | function sum32_5(a, b, c, d, e) { | ||
20086 | return (a + b + c + d + e) >>> 0; | ||
20087 | } | ||
20088 | exports.sum32_5 = sum32_5; | ||
20089 | |||
20090 | function sum64(buf, pos, ah, al) { | ||
20091 | var bh = buf[pos]; | ||
20092 | var bl = buf[pos + 1]; | ||
20093 | |||
20094 | var lo = (al + bl) >>> 0; | ||
20095 | var hi = (lo < al ? 1 : 0) + ah + bh; | ||
20096 | buf[pos] = hi >>> 0; | ||
20097 | buf[pos + 1] = lo; | ||
20098 | } | ||
20099 | exports.sum64 = sum64; | ||
20100 | |||
20101 | function sum64_hi(ah, al, bh, bl) { | ||
20102 | var lo = (al + bl) >>> 0; | ||
20103 | var hi = (lo < al ? 1 : 0) + ah + bh; | ||
20104 | return hi >>> 0; | ||
20105 | } | ||
20106 | exports.sum64_hi = sum64_hi; | ||
20107 | |||
20108 | function sum64_lo(ah, al, bh, bl) { | ||
20109 | var lo = al + bl; | ||
20110 | return lo >>> 0; | ||
20111 | } | ||
20112 | exports.sum64_lo = sum64_lo; | ||
20113 | |||
20114 | function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) { | ||
20115 | var carry = 0; | ||
20116 | var lo = al; | ||
20117 | lo = (lo + bl) >>> 0; | ||
20118 | carry += lo < al ? 1 : 0; | ||
20119 | lo = (lo + cl) >>> 0; | ||
20120 | carry += lo < cl ? 1 : 0; | ||
20121 | lo = (lo + dl) >>> 0; | ||
20122 | carry += lo < dl ? 1 : 0; | ||
20123 | |||
20124 | var hi = ah + bh + ch + dh + carry; | ||
20125 | return hi >>> 0; | ||
20126 | } | ||
20127 | exports.sum64_4_hi = sum64_4_hi; | ||
20128 | |||
20129 | function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) { | ||
20130 | var lo = al + bl + cl + dl; | ||
20131 | return lo >>> 0; | ||
20132 | } | ||
20133 | exports.sum64_4_lo = sum64_4_lo; | ||
20134 | |||
20135 | function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) { | ||
20136 | var carry = 0; | ||
20137 | var lo = al; | ||
20138 | lo = (lo + bl) >>> 0; | ||
20139 | carry += lo < al ? 1 : 0; | ||
20140 | lo = (lo + cl) >>> 0; | ||
20141 | carry += lo < cl ? 1 : 0; | ||
20142 | lo = (lo + dl) >>> 0; | ||
20143 | carry += lo < dl ? 1 : 0; | ||
20144 | lo = (lo + el) >>> 0; | ||
20145 | carry += lo < el ? 1 : 0; | ||
20146 | |||
20147 | var hi = ah + bh + ch + dh + eh + carry; | ||
20148 | return hi >>> 0; | ||
20149 | } | ||
20150 | exports.sum64_5_hi = sum64_5_hi; | ||
20151 | |||
20152 | function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) { | ||
20153 | var lo = al + bl + cl + dl + el; | ||
20154 | |||
20155 | return lo >>> 0; | ||
20156 | } | ||
20157 | exports.sum64_5_lo = sum64_5_lo; | ||
20158 | |||
20159 | function rotr64_hi(ah, al, num) { | ||
20160 | var r = (al << (32 - num)) | (ah >>> num); | ||
20161 | return r >>> 0; | ||
20162 | } | ||
20163 | exports.rotr64_hi = rotr64_hi; | ||
20164 | |||
20165 | function rotr64_lo(ah, al, num) { | ||
20166 | var r = (ah << (32 - num)) | (al >>> num); | ||
20167 | return r >>> 0; | ||
20168 | } | ||
20169 | exports.rotr64_lo = rotr64_lo; | ||
20170 | |||
20171 | function shr64_hi(ah, al, num) { | ||
20172 | return ah >>> num; | ||
20173 | } | ||
20174 | exports.shr64_hi = shr64_hi; | ||
20175 | |||
20176 | function shr64_lo(ah, al, num) { | ||
20177 | var r = (ah << (32 - num)) | (al >>> num); | ||
20178 | return r >>> 0; | ||
20179 | } | ||
20180 | exports.shr64_lo = shr64_lo; | ||
20181 | |||
20182 | },{"inherits":116,"minimalistic-assert":356}],114:[function(require,module,exports){ | ||
20183 | 'use strict'; | ||
20184 | |||
20185 | var hash = require('hash.js'); | ||
20186 | var utils = require('minimalistic-crypto-utils'); | ||
20187 | var assert = require('minimalistic-assert'); | ||
20188 | |||
20189 | function HmacDRBG(options) { | ||
20190 | if (!(this instanceof HmacDRBG)) | ||
20191 | return new HmacDRBG(options); | ||
20192 | this.hash = options.hash; | ||
20193 | this.predResist = !!options.predResist; | ||
20194 | |||
20195 | this.outLen = this.hash.outSize; | ||
20196 | this.minEntropy = options.minEntropy || this.hash.hmacStrength; | ||
20197 | |||
20198 | this._reseed = null; | ||
20199 | this.reseedInterval = null; | ||
20200 | this.K = null; | ||
20201 | this.V = null; | ||
20202 | |||
20203 | var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex'); | ||
20204 | var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex'); | ||
20205 | var pers = utils.toArray(options.pers, options.persEnc || 'hex'); | ||
20206 | assert(entropy.length >= (this.minEntropy / 8), | ||
20207 | 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits'); | ||
20208 | this._init(entropy, nonce, pers); | ||
20209 | } | ||
20210 | module.exports = HmacDRBG; | ||
20211 | |||
20212 | HmacDRBG.prototype._init = function init(entropy, nonce, pers) { | ||
20213 | var seed = entropy.concat(nonce).concat(pers); | ||
20214 | |||
20215 | this.K = new Array(this.outLen / 8); | ||
20216 | this.V = new Array(this.outLen / 8); | ||
20217 | for (var i = 0; i < this.V.length; i++) { | ||
20218 | this.K[i] = 0x00; | ||
20219 | this.V[i] = 0x01; | ||
20220 | } | ||
20221 | |||
20222 | this._update(seed); | ||
20223 | this._reseed = 1; | ||
20224 | this.reseedInterval = 0x1000000000000; // 2^48 | ||
20225 | }; | ||
20226 | |||
20227 | HmacDRBG.prototype._hmac = function hmac() { | ||
20228 | return new hash.hmac(this.hash, this.K); | ||
20229 | }; | ||
20230 | |||
20231 | HmacDRBG.prototype._update = function update(seed) { | ||
20232 | var kmac = this._hmac() | ||
20233 | .update(this.V) | ||
20234 | .update([ 0x00 ]); | ||
20235 | if (seed) | ||
20236 | kmac = kmac.update(seed); | ||
20237 | this.K = kmac.digest(); | ||
20238 | this.V = this._hmac().update(this.V).digest(); | ||
20239 | if (!seed) | ||
20240 | return; | ||
20241 | |||
20242 | this.K = this._hmac() | ||
20243 | .update(this.V) | ||
20244 | .update([ 0x01 ]) | ||
20245 | .update(seed) | ||
20246 | .digest(); | ||
20247 | this.V = this._hmac().update(this.V).digest(); | ||
20248 | }; | ||
20249 | |||
20250 | HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) { | ||
20251 | // Optional entropy enc | ||
20252 | if (typeof entropyEnc !== 'string') { | ||
20253 | addEnc = add; | ||
20254 | add = entropyEnc; | ||
20255 | entropyEnc = null; | ||
20256 | } | ||
20257 | |||
20258 | entropy = utils.toArray(entropy, entropyEnc); | ||
20259 | add = utils.toArray(add, addEnc); | ||
20260 | |||
20261 | assert(entropy.length >= (this.minEntropy / 8), | ||
20262 | 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits'); | ||
20263 | |||
20264 | this._update(entropy.concat(add || [])); | ||
20265 | this._reseed = 1; | ||
20266 | }; | ||
20267 | |||
20268 | HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) { | ||
20269 | if (this._reseed > this.reseedInterval) | ||
20270 | throw new Error('Reseed is required'); | ||
20271 | |||
20272 | // Optional encoding | ||
20273 | if (typeof enc !== 'string') { | ||
20274 | addEnc = add; | ||
20275 | add = enc; | ||
20276 | enc = null; | ||
20277 | } | ||
20278 | |||
20279 | // Optional additional data | ||
20280 | if (add) { | ||
20281 | add = utils.toArray(add, addEnc || 'hex'); | ||
20282 | this._update(add); | ||
20283 | } | ||
20284 | |||
20285 | var temp = []; | ||
20286 | while (temp.length < len) { | ||
20287 | this.V = this._hmac().update(this.V).digest(); | ||
20288 | temp = temp.concat(this.V); | ||
20289 | } | ||
20290 | |||
20291 | var res = temp.slice(0, len); | ||
20292 | this._update(add); | ||
20293 | this._reseed++; | ||
20294 | return utils.encode(res, enc); | ||
20295 | }; | ||
20296 | |||
20297 | },{"hash.js":102,"minimalistic-assert":356,"minimalistic-crypto-utils":357}],115:[function(require,module,exports){ | ||
20298 | exports.read = function (buffer, offset, isLE, mLen, nBytes) { | ||
20299 | var e, m | ||
20300 | var eLen = (nBytes * 8) - mLen - 1 | ||
20301 | var eMax = (1 << eLen) - 1 | ||
20302 | var eBias = eMax >> 1 | ||
20303 | var nBits = -7 | ||
20304 | var i = isLE ? (nBytes - 1) : 0 | ||
20305 | var d = isLE ? -1 : 1 | ||
20306 | var s = buffer[offset + i] | ||
20307 | |||
20308 | i += d | ||
20309 | |||
20310 | e = s & ((1 << (-nBits)) - 1) | ||
20311 | s >>= (-nBits) | ||
20312 | nBits += eLen | ||
20313 | for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} | ||
20314 | |||
20315 | m = e & ((1 << (-nBits)) - 1) | ||
20316 | e >>= (-nBits) | ||
20317 | nBits += mLen | ||
20318 | for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} | ||
20319 | |||
20320 | if (e === 0) { | ||
20321 | e = 1 - eBias | ||
20322 | } else if (e === eMax) { | ||
20323 | return m ? NaN : ((s ? -1 : 1) * Infinity) | ||
20324 | } else { | ||
20325 | m = m + Math.pow(2, mLen) | ||
20326 | e = e - eBias | ||
20327 | } | ||
20328 | return (s ? -1 : 1) * m * Math.pow(2, e - mLen) | ||
20329 | } | ||
20330 | |||
20331 | exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { | ||
20332 | var e, m, c | ||
20333 | var eLen = (nBytes * 8) - mLen - 1 | ||
20334 | var eMax = (1 << eLen) - 1 | ||
20335 | var eBias = eMax >> 1 | ||
20336 | var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) | ||
20337 | var i = isLE ? 0 : (nBytes - 1) | ||
20338 | var d = isLE ? 1 : -1 | ||
20339 | var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 | ||
20340 | |||
20341 | value = Math.abs(value) | ||
20342 | |||
20343 | if (isNaN(value) || value === Infinity) { | ||
20344 | m = isNaN(value) ? 1 : 0 | ||
20345 | e = eMax | ||
20346 | } else { | ||
20347 | e = Math.floor(Math.log(value) / Math.LN2) | ||
20348 | if (value * (c = Math.pow(2, -e)) < 1) { | ||
20349 | e-- | ||
20350 | c *= 2 | ||
20351 | } | ||
20352 | if (e + eBias >= 1) { | ||
20353 | value += rt / c | ||
20354 | } else { | ||
20355 | value += rt * Math.pow(2, 1 - eBias) | ||
20356 | } | ||
20357 | if (value * c >= 2) { | ||
20358 | e++ | ||
20359 | c /= 2 | ||
20360 | } | ||
20361 | |||
20362 | if (e + eBias >= eMax) { | ||
20363 | m = 0 | ||
20364 | e = eMax | ||
20365 | } else if (e + eBias >= 1) { | ||
20366 | m = ((value * c) - 1) * Math.pow(2, mLen) | ||
20367 | e = e + eBias | ||
20368 | } else { | ||
20369 | m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) | ||
20370 | e = 0 | ||
20371 | } | ||
20372 | } | ||
20373 | |||
20374 | for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} | ||
20375 | |||
20376 | e = (e << mLen) | m | ||
20377 | eLen += mLen | ||
20378 | for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} | ||
20379 | |||
20380 | buffer[offset + i - d] |= s * 128 | ||
20381 | } | ||
20382 | |||
20383 | },{}],116:[function(require,module,exports){ | ||
20384 | if (typeof Object.create === 'function') { | ||
20385 | // implementation from standard node.js 'util' module | ||
20386 | module.exports = function inherits(ctor, superCtor) { | ||
20387 | ctor.super_ = superCtor | ||
20388 | ctor.prototype = Object.create(superCtor.prototype, { | ||
20389 | constructor: { | ||
20390 | value: ctor, | ||
20391 | enumerable: false, | ||
20392 | writable: true, | ||
20393 | configurable: true | ||
20394 | } | ||
20395 | }); | ||
20396 | }; | ||
20397 | } else { | ||
20398 | // old school shim for old browsers | ||
20399 | module.exports = function inherits(ctor, superCtor) { | ||
20400 | ctor.super_ = superCtor | ||
20401 | var TempCtor = function () {} | ||
20402 | TempCtor.prototype = superCtor.prototype | ||
20403 | ctor.prototype = new TempCtor() | ||
20404 | ctor.prototype.constructor = ctor | ||
20405 | } | ||
20406 | } | ||
20407 | |||
20408 | },{}],117:[function(require,module,exports){ | ||
20409 | /*! | ||
20410 | * Determine if an object is a Buffer | ||
20411 | * | ||
20412 | * @author Feross Aboukhadijeh <https://feross.org> | ||
20413 | * @license MIT | ||
20414 | */ | ||
20415 | |||
20416 | // The _isBuffer check is for Safari 5-7 support, because it's missing | ||
20417 | // Object.prototype.constructor. Remove this eventually | ||
20418 | module.exports = function (obj) { | ||
20419 | return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) | ||
20420 | } | ||
20421 | |||
20422 | function isBuffer (obj) { | ||
20423 | return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) | ||
20424 | } | ||
20425 | |||
20426 | // For Node v0.10 support. Remove this eventually. | ||
20427 | function isSlowBuffer (obj) { | ||
20428 | return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) | ||
20429 | } | ||
20430 | |||
20431 | },{}],118:[function(require,module,exports){ | ||
20432 | var toString = {}.toString; | ||
20433 | |||
20434 | module.exports = Array.isArray || function (arr) { | ||
20435 | return toString.call(arr) == '[object Array]'; | ||
20436 | }; | ||
20437 | |||
20438 | },{}],119:[function(require,module,exports){ | ||
20439 | "use strict"; | ||
20440 | |||
20441 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
20442 | |||
20443 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
20444 | |||
20445 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
20446 | |||
20447 | Object.defineProperty(exports, "__esModule", { | ||
20448 | value: true | ||
20449 | }); | ||
20450 | |||
20451 | var every = _interopRequire(require("lodash/every")); | ||
20452 | |||
20453 | var each = _interopRequire(require("lodash/each")); | ||
20454 | |||
20455 | var times = _interopRequire(require("lodash/times")); | ||
20456 | |||
20457 | var isArray = _interopRequire(require("lodash/isArray")); | ||
20458 | |||
20459 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
20460 | |||
20461 | var Array = exports.Array = (function () { | ||
20462 | function Array(childType, length) { | ||
20463 | _classCallCheck(this, Array); | ||
20464 | |||
20465 | this._childType = childType; | ||
20466 | this._length = length; | ||
20467 | } | ||
20468 | |||
20469 | _createClass(Array, { | ||
20470 | read: { | ||
20471 | value: function read(io) { | ||
20472 | var _this = this; | ||
20473 | |||
20474 | return times(this._length, function () { | ||
20475 | return _this._childType.read(io); | ||
20476 | }); | ||
20477 | } | ||
20478 | }, | ||
20479 | write: { | ||
20480 | value: function write(value, io) { | ||
20481 | var _this = this; | ||
20482 | |||
20483 | if (!isArray(value)) { | ||
20484 | throw new Error("XDR Write Error: value is not array"); | ||
20485 | } | ||
20486 | |||
20487 | if (value.length !== this._length) { | ||
20488 | throw new Error("XDR Write Error: Got array of size " + value.length + "," + ("expected " + this._length)); | ||
20489 | } | ||
20490 | |||
20491 | each(value, function (child) { | ||
20492 | return _this._childType.write(child, io); | ||
20493 | }); | ||
20494 | } | ||
20495 | }, | ||
20496 | isValid: { | ||
20497 | value: function isValid(value) { | ||
20498 | var _this = this; | ||
20499 | |||
20500 | if (!isArray(value)) { | ||
20501 | return false; | ||
20502 | } | ||
20503 | if (value.length !== this._length) { | ||
20504 | return false; | ||
20505 | } | ||
20506 | |||
20507 | return every(value, function (child) { | ||
20508 | return _this._childType.isValid(child); | ||
20509 | }); | ||
20510 | } | ||
20511 | } | ||
20512 | }); | ||
20513 | |||
20514 | return Array; | ||
20515 | })(); | ||
20516 | |||
20517 | includeIoMixin(Array.prototype); | ||
20518 | },{"./io-mixin":129,"lodash/each":308,"lodash/every":310,"lodash/isArray":319,"lodash/times":346}],120:[function(require,module,exports){ | ||
20519 | "use strict"; | ||
20520 | |||
20521 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
20522 | |||
20523 | Object.defineProperty(exports, "__esModule", { | ||
20524 | value: true | ||
20525 | }); | ||
20526 | |||
20527 | var Int = require("./int").Int; | ||
20528 | |||
20529 | var isBoolean = _interopRequire(require("lodash/isBoolean")); | ||
20530 | |||
20531 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
20532 | |||
20533 | var Bool = { | ||
20534 | read: function read(io) { | ||
20535 | var value = Int.read(io); | ||
20536 | |||
20537 | switch (value) { | ||
20538 | case 0: | ||
20539 | return false; | ||
20540 | case 1: | ||
20541 | return true; | ||
20542 | default: | ||
20543 | throw new Error("XDR Read Error: Got " + value + " when trying to read a bool"); | ||
20544 | } | ||
20545 | }, | ||
20546 | |||
20547 | write: function write(value, io) { | ||
20548 | var intVal = value ? 1 : 0; | ||
20549 | return Int.write(intVal, io); | ||
20550 | }, | ||
20551 | |||
20552 | isValid: function isValid(value) { | ||
20553 | return isBoolean(value); | ||
20554 | } | ||
20555 | }; | ||
20556 | |||
20557 | exports.Bool = Bool; | ||
20558 | includeIoMixin(Bool); | ||
20559 | },{"./int":128,"./io-mixin":129,"lodash/isBoolean":321}],121:[function(require,module,exports){ | ||
20560 | "use strict"; | ||
20561 | |||
20562 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
20563 | |||
20564 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | ||
20565 | |||
20566 | var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }; | ||
20567 | |||
20568 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
20569 | |||
20570 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
20571 | |||
20572 | exports.config = config; | ||
20573 | Object.defineProperty(exports, "__esModule", { | ||
20574 | value: true | ||
20575 | }); | ||
20576 | |||
20577 | var XDR = _interopRequireWildcard(require("./types")); | ||
20578 | |||
20579 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
20580 | |||
20581 | var isPlainObject = _interopRequire(require("lodash/isPlainObject")); | ||
20582 | |||
20583 | var isArray = _interopRequire(require("lodash/isArray")); | ||
20584 | |||
20585 | var each = _interopRequire(require("lodash/each")); | ||
20586 | |||
20587 | var map = _interopRequire(require("lodash/map")); | ||
20588 | |||
20589 | var pick = _interopRequire(require("lodash/pick")); | ||
20590 | |||
20591 | function config(fn) { | ||
20592 | var types = arguments[1] === undefined ? {} : arguments[1]; | ||
20593 | |||
20594 | if (fn) { | ||
20595 | var builder = new TypeBuilder(types); | ||
20596 | fn(builder); | ||
20597 | builder.resolve(); | ||
20598 | } | ||
20599 | |||
20600 | return types; | ||
20601 | } | ||
20602 | |||
20603 | var Reference = exports.Reference = (function () { | ||
20604 | function Reference() { | ||
20605 | _classCallCheck(this, Reference); | ||
20606 | } | ||
20607 | |||
20608 | _createClass(Reference, { | ||
20609 | resolve: { | ||
20610 | /* jshint unused: false */ | ||
20611 | |||
20612 | value: function resolve(context) { | ||
20613 | throw new Error("implement resolve in child class"); | ||
20614 | } | ||
20615 | } | ||
20616 | }); | ||
20617 | |||
20618 | return Reference; | ||
20619 | })(); | ||
20620 | |||
20621 | var SimpleReference = (function (_Reference) { | ||
20622 | function SimpleReference(name) { | ||
20623 | _classCallCheck(this, SimpleReference); | ||
20624 | |||
20625 | this.name = name; | ||
20626 | } | ||
20627 | |||
20628 | _inherits(SimpleReference, _Reference); | ||
20629 | |||
20630 | _createClass(SimpleReference, { | ||
20631 | resolve: { | ||
20632 | value: function resolve(context) { | ||
20633 | var defn = context.definitions[this.name]; | ||
20634 | return defn.resolve(context); | ||
20635 | } | ||
20636 | } | ||
20637 | }); | ||
20638 | |||
20639 | return SimpleReference; | ||
20640 | })(Reference); | ||
20641 | |||
20642 | var ArrayReference = (function (_Reference2) { | ||
20643 | function ArrayReference(childReference, length) { | ||
20644 | var variable = arguments[2] === undefined ? false : arguments[2]; | ||
20645 | |||
20646 | _classCallCheck(this, ArrayReference); | ||
20647 | |||
20648 | this.childReference = childReference; | ||
20649 | this.length = length; | ||
20650 | this.variable = variable; | ||
20651 | } | ||
20652 | |||
20653 | _inherits(ArrayReference, _Reference2); | ||
20654 | |||
20655 | _createClass(ArrayReference, { | ||
20656 | resolve: { | ||
20657 | value: function resolve(context) { | ||
20658 | var resolvedChild = this.childReference; | ||
20659 | var length = this.length; | ||
20660 | |||
20661 | if (resolvedChild instanceof Reference) { | ||
20662 | resolvedChild = resolvedChild.resolve(context); | ||
20663 | } | ||
20664 | |||
20665 | if (length instanceof Reference) { | ||
20666 | length = length.resolve(context); | ||
20667 | } | ||
20668 | |||
20669 | if (this.variable) { | ||
20670 | return new XDR.VarArray(resolvedChild, length); | ||
20671 | } else { | ||
20672 | return new XDR.Array(resolvedChild, length); | ||
20673 | } | ||
20674 | } | ||
20675 | } | ||
20676 | }); | ||
20677 | |||
20678 | return ArrayReference; | ||
20679 | })(Reference); | ||
20680 | |||
20681 | var OptionReference = (function (_Reference3) { | ||
20682 | function OptionReference(childReference) { | ||
20683 | _classCallCheck(this, OptionReference); | ||
20684 | |||
20685 | this.childReference = childReference; | ||
20686 | this.name = childReference.name; | ||
20687 | } | ||
20688 | |||
20689 | _inherits(OptionReference, _Reference3); | ||
20690 | |||
20691 | _createClass(OptionReference, { | ||
20692 | resolve: { | ||
20693 | value: function resolve(context) { | ||
20694 | var resolvedChild = this.childReference; | ||
20695 | |||
20696 | if (resolvedChild instanceof Reference) { | ||
20697 | resolvedChild = resolvedChild.resolve(context); | ||
20698 | } | ||
20699 | |||
20700 | return new XDR.Option(resolvedChild); | ||
20701 | } | ||
20702 | } | ||
20703 | }); | ||
20704 | |||
20705 | return OptionReference; | ||
20706 | })(Reference); | ||
20707 | |||
20708 | var SizedReference = (function (_Reference4) { | ||
20709 | function SizedReference(sizedType, length) { | ||
20710 | _classCallCheck(this, SizedReference); | ||
20711 | |||
20712 | this.sizedType = sizedType; | ||
20713 | this.length = length; | ||
20714 | } | ||
20715 | |||
20716 | _inherits(SizedReference, _Reference4); | ||
20717 | |||
20718 | _createClass(SizedReference, { | ||
20719 | resolve: { | ||
20720 | value: function resolve(context) { | ||
20721 | var length = this.length; | ||
20722 | |||
20723 | if (length instanceof Reference) { | ||
20724 | length = length.resolve(context); | ||
20725 | } | ||
20726 | |||
20727 | return new this.sizedType(length); | ||
20728 | } | ||
20729 | } | ||
20730 | }); | ||
20731 | |||
20732 | return SizedReference; | ||
20733 | })(Reference); | ||
20734 | |||
20735 | var Definition = (function () { | ||
20736 | function Definition(constructor, name, config) { | ||
20737 | _classCallCheck(this, Definition); | ||
20738 | |||
20739 | this.constructor = constructor; | ||
20740 | this.name = name; | ||
20741 | this.config = config; | ||
20742 | } | ||
20743 | |||
20744 | _createClass(Definition, { | ||
20745 | resolve: { | ||
20746 | |||
20747 | // resolve calls the constructor of this definition with the provided context | ||
20748 | // and this definitions config values. The definitions constructor should | ||
20749 | // populate the final type on `context.results`, and may refer to other | ||
20750 | // definitions through `context.definitions` | ||
20751 | |||
20752 | value: function resolve(context) { | ||
20753 | if (this.name in context.results) { | ||
20754 | return context.results[this.name]; | ||
20755 | } | ||
20756 | |||
20757 | return this.constructor(context, this.name, this.config); | ||
20758 | } | ||
20759 | } | ||
20760 | }); | ||
20761 | |||
20762 | return Definition; | ||
20763 | })(); | ||
20764 | |||
20765 | var TypeBuilder = (function () { | ||
20766 | function TypeBuilder(destination) { | ||
20767 | _classCallCheck(this, TypeBuilder); | ||
20768 | |||
20769 | this._destination = destination; | ||
20770 | this._definitions = {}; | ||
20771 | } | ||
20772 | |||
20773 | _createClass(TypeBuilder, { | ||
20774 | "enum": { | ||
20775 | value: function _enum(name, members) { | ||
20776 | var result = new Definition(XDR.Enum.create, name, members); | ||
20777 | this.define(name, result); | ||
20778 | } | ||
20779 | }, | ||
20780 | struct: { | ||
20781 | value: function struct(name, members) { | ||
20782 | var result = new Definition(XDR.Struct.create, name, members); | ||
20783 | this.define(name, result); | ||
20784 | } | ||
20785 | }, | ||
20786 | union: { | ||
20787 | value: function union(name, config) { | ||
20788 | var result = new Definition(XDR.Union.create, name, config); | ||
20789 | this.define(name, result); | ||
20790 | } | ||
20791 | }, | ||
20792 | typedef: { | ||
20793 | value: function typedef(name, config) { | ||
20794 | // let the reference resoltion system do it's thing | ||
20795 | // the "constructor" for a typedef just returns the resolved value | ||
20796 | var createTypedef = function (context, name, value) { | ||
20797 | if (value instanceof Reference) { | ||
20798 | value = value.resolve(context); | ||
20799 | } | ||
20800 | context.results[name] = value; | ||
20801 | return value; | ||
20802 | }; | ||
20803 | |||
20804 | var result = new Definition(createTypedef, name, config); | ||
20805 | this.define(name, result); | ||
20806 | } | ||
20807 | }, | ||
20808 | "const": { | ||
20809 | value: function _const(name, config) { | ||
20810 | var createConst = function (context, name, value) { | ||
20811 | context.results[name] = value; | ||
20812 | return value; | ||
20813 | }; | ||
20814 | |||
20815 | var result = new Definition(createConst, name, config); | ||
20816 | this.define(name, result); | ||
20817 | } | ||
20818 | }, | ||
20819 | "void": { | ||
20820 | value: function _void() { | ||
20821 | return XDR.Void; | ||
20822 | } | ||
20823 | }, | ||
20824 | bool: { | ||
20825 | value: function bool() { | ||
20826 | return XDR.Bool; | ||
20827 | } | ||
20828 | }, | ||
20829 | int: { | ||
20830 | value: function int() { | ||
20831 | return XDR.Int; | ||
20832 | } | ||
20833 | }, | ||
20834 | hyper: { | ||
20835 | value: function hyper() { | ||
20836 | return XDR.Hyper; | ||
20837 | } | ||
20838 | }, | ||
20839 | uint: { | ||
20840 | value: function uint() { | ||
20841 | return XDR.UnsignedInt; | ||
20842 | } | ||
20843 | }, | ||
20844 | uhyper: { | ||
20845 | value: function uhyper() { | ||
20846 | return XDR.UnsignedHyper; | ||
20847 | } | ||
20848 | }, | ||
20849 | float: { | ||
20850 | value: function float() { | ||
20851 | return XDR.Float; | ||
20852 | } | ||
20853 | }, | ||
20854 | double: { | ||
20855 | value: function double() { | ||
20856 | return XDR.Double; | ||
20857 | } | ||
20858 | }, | ||
20859 | quadruple: { | ||
20860 | value: function quadruple() { | ||
20861 | return XDR.Quadruple; | ||
20862 | } | ||
20863 | }, | ||
20864 | string: { | ||
20865 | value: function string(length) { | ||
20866 | return new SizedReference(XDR.String, length); | ||
20867 | } | ||
20868 | }, | ||
20869 | opaque: { | ||
20870 | value: function opaque(length) { | ||
20871 | return new SizedReference(XDR.Opaque, length); | ||
20872 | } | ||
20873 | }, | ||
20874 | varOpaque: { | ||
20875 | value: function varOpaque(length) { | ||
20876 | return new SizedReference(XDR.VarOpaque, length); | ||
20877 | } | ||
20878 | }, | ||
20879 | array: { | ||
20880 | value: function array(childType, length) { | ||
20881 | return new ArrayReference(childType, length); | ||
20882 | } | ||
20883 | }, | ||
20884 | varArray: { | ||
20885 | value: function varArray(childType, maxLength) { | ||
20886 | return new ArrayReference(childType, maxLength, true); | ||
20887 | } | ||
20888 | }, | ||
20889 | option: { | ||
20890 | value: function option(childType) { | ||
20891 | return new OptionReference(childType); | ||
20892 | } | ||
20893 | }, | ||
20894 | define: { | ||
20895 | value: function define(name, definition) { | ||
20896 | if (isUndefined(this._destination[name])) { | ||
20897 | this._definitions[name] = definition; | ||
20898 | } else { | ||
20899 | throw new Error("XDR Error:" + name + " is already defined"); | ||
20900 | } | ||
20901 | } | ||
20902 | }, | ||
20903 | lookup: { | ||
20904 | value: function lookup(name) { | ||
20905 | return new SimpleReference(name); | ||
20906 | } | ||
20907 | }, | ||
20908 | resolve: { | ||
20909 | value: function resolve() { | ||
20910 | var _this = this; | ||
20911 | |||
20912 | each(this._definitions, function (defn, name) { | ||
20913 | defn.resolve({ | ||
20914 | definitions: _this._definitions, | ||
20915 | results: _this._destination | ||
20916 | }); | ||
20917 | }); | ||
20918 | } | ||
20919 | } | ||
20920 | }); | ||
20921 | |||
20922 | return TypeBuilder; | ||
20923 | })(); | ||
20924 | },{"./types":135,"lodash/each":308,"lodash/isArray":319,"lodash/isPlainObject":331,"lodash/isUndefined":336,"lodash/map":339,"lodash/pick":342}],122:[function(require,module,exports){ | ||
20925 | (function (Buffer){ | ||
20926 | "use strict"; | ||
20927 | |||
20928 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
20929 | |||
20930 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
20931 | |||
20932 | var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }; | ||
20933 | |||
20934 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
20935 | |||
20936 | Object.defineProperty(exports, "__esModule", { | ||
20937 | value: true | ||
20938 | }); | ||
20939 | |||
20940 | var BaseCursor = _interopRequire(require("cursor")); | ||
20941 | |||
20942 | var calculatePadding = require("./util").calculatePadding; | ||
20943 | |||
20944 | var Cursor = exports.Cursor = (function (_BaseCursor) { | ||
20945 | function Cursor() { | ||
20946 | _classCallCheck(this, Cursor); | ||
20947 | |||
20948 | if (_BaseCursor != null) { | ||
20949 | _BaseCursor.apply(this, arguments); | ||
20950 | } | ||
20951 | } | ||
20952 | |||
20953 | _inherits(Cursor, _BaseCursor); | ||
20954 | |||
20955 | _createClass(Cursor, { | ||
20956 | writeBufferPadded: { | ||
20957 | value: function writeBufferPadded(buffer) { | ||
20958 | var padding = calculatePadding(buffer.length); | ||
20959 | var paddingBuffer = Buffer.alloc(padding); | ||
20960 | |||
20961 | return this.copyFrom(new Cursor(buffer)).copyFrom(new Cursor(paddingBuffer)); | ||
20962 | } | ||
20963 | } | ||
20964 | }); | ||
20965 | |||
20966 | return Cursor; | ||
20967 | })(BaseCursor); | ||
20968 | }).call(this,require("buffer").Buffer) | ||
20969 | },{"./util":139,"buffer":49,"cursor":72}],123:[function(require,module,exports){ | ||
20970 | "use strict"; | ||
20971 | |||
20972 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
20973 | |||
20974 | Object.defineProperty(exports, "__esModule", { | ||
20975 | value: true | ||
20976 | }); | ||
20977 | |||
20978 | var isNumber = _interopRequire(require("lodash/isNumber")); | ||
20979 | |||
20980 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
20981 | |||
20982 | var Double = { | ||
20983 | |||
20984 | read: function read(io) { | ||
20985 | return io.readDoubleBE(); | ||
20986 | }, | ||
20987 | |||
20988 | write: function write(value, io) { | ||
20989 | if (!isNumber(value)) { | ||
20990 | throw new Error("XDR Write Error: not a number"); | ||
20991 | } | ||
20992 | |||
20993 | io.writeDoubleBE(value); | ||
20994 | }, | ||
20995 | |||
20996 | isValid: function isValid(value) { | ||
20997 | return isNumber(value); | ||
20998 | } }; | ||
20999 | |||
21000 | exports.Double = Double; | ||
21001 | includeIoMixin(Double); | ||
21002 | },{"./io-mixin":129,"lodash/isNumber":328}],124:[function(require,module,exports){ | ||
21003 | "use strict"; | ||
21004 | |||
21005 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21006 | |||
21007 | var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc && desc.writable) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; | ||
21008 | |||
21009 | var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }; | ||
21010 | |||
21011 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
21012 | |||
21013 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
21014 | |||
21015 | Object.defineProperty(exports, "__esModule", { | ||
21016 | value: true | ||
21017 | }); | ||
21018 | |||
21019 | var Int = require("./int").Int; | ||
21020 | |||
21021 | var each = _interopRequire(require("lodash/each")); | ||
21022 | |||
21023 | var vals = _interopRequire(require("lodash/values")); | ||
21024 | |||
21025 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21026 | |||
21027 | var Enum = exports.Enum = (function () { | ||
21028 | function Enum(name, value) { | ||
21029 | _classCallCheck(this, Enum); | ||
21030 | |||
21031 | this.name = name; | ||
21032 | this.value = value; | ||
21033 | } | ||
21034 | |||
21035 | _createClass(Enum, null, { | ||
21036 | read: { | ||
21037 | value: function read(io) { | ||
21038 | var intVal = Int.read(io); | ||
21039 | |||
21040 | if (!this._byValue.has(intVal)) { | ||
21041 | throw new Error("XDR Read Error: Unknown " + this.enumName + " member for value " + intVal); | ||
21042 | } | ||
21043 | |||
21044 | return this._byValue.get(intVal); | ||
21045 | } | ||
21046 | }, | ||
21047 | write: { | ||
21048 | value: function write(value, io) { | ||
21049 | if (!(value instanceof this)) { | ||
21050 | throw new Error("XDR Write Error: Unknown " + value + " is not a " + this.enumName); | ||
21051 | } | ||
21052 | |||
21053 | Int.write(value.value, io); | ||
21054 | } | ||
21055 | }, | ||
21056 | isValid: { | ||
21057 | value: function isValid(value) { | ||
21058 | return value instanceof this; | ||
21059 | } | ||
21060 | }, | ||
21061 | members: { | ||
21062 | value: function members() { | ||
21063 | return this._members; | ||
21064 | } | ||
21065 | }, | ||
21066 | values: { | ||
21067 | value: function values() { | ||
21068 | return vals(this._members); | ||
21069 | } | ||
21070 | }, | ||
21071 | fromName: { | ||
21072 | value: function fromName(name) { | ||
21073 | var result = this._members[name]; | ||
21074 | |||
21075 | if (!result) { | ||
21076 | throw new Error("" + name + " is not a member of " + this.enumName); | ||
21077 | } | ||
21078 | |||
21079 | return result; | ||
21080 | } | ||
21081 | }, | ||
21082 | fromValue: { | ||
21083 | value: function fromValue(value) { | ||
21084 | var result = this._byValue.get(value); | ||
21085 | |||
21086 | if (!result) { | ||
21087 | throw new Error("" + value + " is not a value of any member of " + this.enumName); | ||
21088 | } | ||
21089 | |||
21090 | return result; | ||
21091 | } | ||
21092 | }, | ||
21093 | create: { | ||
21094 | value: function create(context, name, members) { | ||
21095 | var ChildEnum = (function (_Enum) { | ||
21096 | var _class = function ChildEnum() { | ||
21097 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | ||
21098 | args[_key] = arguments[_key]; | ||
21099 | } | ||
21100 | |||
21101 | _classCallCheck(this, _class); | ||
21102 | |||
21103 | _get(Object.getPrototypeOf(_class.prototype), "constructor", this).apply(this, args); | ||
21104 | }; | ||
21105 | |||
21106 | _inherits(_class, _Enum); | ||
21107 | |||
21108 | return _class; | ||
21109 | })(Enum); | ||
21110 | |||
21111 | ChildEnum.enumName = name; | ||
21112 | context.results[name] = ChildEnum; | ||
21113 | |||
21114 | ChildEnum._members = {}; | ||
21115 | ChildEnum._byValue = new Map(); | ||
21116 | |||
21117 | each(members, function (value, key) { | ||
21118 | var inst = new ChildEnum(key, value); | ||
21119 | ChildEnum._members[key] = inst; | ||
21120 | ChildEnum._byValue.set(value, inst); | ||
21121 | ChildEnum[key] = function () { | ||
21122 | return inst; | ||
21123 | }; | ||
21124 | }); | ||
21125 | |||
21126 | return ChildEnum; | ||
21127 | } | ||
21128 | } | ||
21129 | }); | ||
21130 | |||
21131 | return Enum; | ||
21132 | })(); | ||
21133 | |||
21134 | includeIoMixin(Enum); | ||
21135 | },{"./int":128,"./io-mixin":129,"lodash/each":308,"lodash/values":352}],125:[function(require,module,exports){ | ||
21136 | "use strict"; | ||
21137 | |||
21138 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21139 | |||
21140 | Object.defineProperty(exports, "__esModule", { | ||
21141 | value: true | ||
21142 | }); | ||
21143 | |||
21144 | var isNumber = _interopRequire(require("lodash/isNumber")); | ||
21145 | |||
21146 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21147 | |||
21148 | var Float = { | ||
21149 | |||
21150 | read: function read(io) { | ||
21151 | return io.readFloatBE(); | ||
21152 | }, | ||
21153 | |||
21154 | write: function write(value, io) { | ||
21155 | if (!isNumber(value)) { | ||
21156 | throw new Error("XDR Write Error: not a number"); | ||
21157 | } | ||
21158 | |||
21159 | io.writeFloatBE(value); | ||
21160 | }, | ||
21161 | |||
21162 | isValid: function isValid(value) { | ||
21163 | return isNumber(value); | ||
21164 | } }; | ||
21165 | |||
21166 | exports.Float = Float; | ||
21167 | includeIoMixin(Float); | ||
21168 | },{"./io-mixin":129,"lodash/isNumber":328}],126:[function(require,module,exports){ | ||
21169 | "use strict"; | ||
21170 | |||
21171 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21172 | |||
21173 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
21174 | |||
21175 | var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc && desc.writable) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; | ||
21176 | |||
21177 | var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }; | ||
21178 | |||
21179 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
21180 | |||
21181 | Object.defineProperty(exports, "__esModule", { | ||
21182 | value: true | ||
21183 | }); | ||
21184 | |||
21185 | var Long = _interopRequire(require("long")); | ||
21186 | |||
21187 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21188 | |||
21189 | var Hyper = exports.Hyper = (function (_Long) { | ||
21190 | function Hyper(low, high) { | ||
21191 | _classCallCheck(this, Hyper); | ||
21192 | |||
21193 | _get(Object.getPrototypeOf(Hyper.prototype), "constructor", this).call(this, low, high, false); | ||
21194 | } | ||
21195 | |||
21196 | _inherits(Hyper, _Long); | ||
21197 | |||
21198 | _createClass(Hyper, null, { | ||
21199 | read: { | ||
21200 | value: function read(io) { | ||
21201 | var high = io.readInt32BE(); | ||
21202 | var low = io.readInt32BE(); | ||
21203 | return this.fromBits(low, high); | ||
21204 | } | ||
21205 | }, | ||
21206 | write: { | ||
21207 | value: function write(value, io) { | ||
21208 | if (!(value instanceof this)) { | ||
21209 | throw new Error("XDR Write Error: " + value + " is not a Hyper"); | ||
21210 | } | ||
21211 | |||
21212 | io.writeInt32BE(value.high); | ||
21213 | io.writeInt32BE(value.low); | ||
21214 | } | ||
21215 | }, | ||
21216 | fromString: { | ||
21217 | value: function fromString(string) { | ||
21218 | if (!/^-?\d+$/.test(string)) { | ||
21219 | throw new Error("Invalid hyper string: " + string); | ||
21220 | } | ||
21221 | var result = _get(Object.getPrototypeOf(Hyper), "fromString", this).call(this, string, false); | ||
21222 | return new this(result.low, result.high); | ||
21223 | } | ||
21224 | }, | ||
21225 | fromBits: { | ||
21226 | value: function fromBits(low, high) { | ||
21227 | var result = _get(Object.getPrototypeOf(Hyper), "fromBits", this).call(this, low, high, false); | ||
21228 | return new this(result.low, result.high); | ||
21229 | } | ||
21230 | }, | ||
21231 | isValid: { | ||
21232 | value: function isValid(value) { | ||
21233 | return value instanceof this; | ||
21234 | } | ||
21235 | } | ||
21236 | }); | ||
21237 | |||
21238 | return Hyper; | ||
21239 | })(Long); | ||
21240 | |||
21241 | includeIoMixin(Hyper); | ||
21242 | |||
21243 | Hyper.MAX_VALUE = new Hyper(Long.MAX_VALUE.low, Long.MAX_VALUE.high); | ||
21244 | Hyper.MIN_VALUE = new Hyper(Long.MIN_VALUE.low, Long.MIN_VALUE.high); | ||
21245 | },{"./io-mixin":129,"long":353}],127:[function(require,module,exports){ | ||
21246 | "use strict"; | ||
21247 | |||
21248 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | ||
21249 | |||
21250 | var _defaults = function (obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }; | ||
21251 | |||
21252 | Object.defineProperty(exports, "__esModule", { | ||
21253 | value: true | ||
21254 | }); | ||
21255 | |||
21256 | _defaults(exports, _interopRequireWildcard(require("./types"))); | ||
21257 | |||
21258 | var _config = require("./config"); | ||
21259 | |||
21260 | _defaults(exports, _interopRequireWildcard(_config)); | ||
21261 | |||
21262 | var config = _config.config; | ||
21263 | },{"./config":121,"./types":135}],128:[function(require,module,exports){ | ||
21264 | "use strict"; | ||
21265 | |||
21266 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21267 | |||
21268 | Object.defineProperty(exports, "__esModule", { | ||
21269 | value: true | ||
21270 | }); | ||
21271 | |||
21272 | var isNumber = _interopRequire(require("lodash/isNumber")); | ||
21273 | |||
21274 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21275 | |||
21276 | var Int = { | ||
21277 | |||
21278 | read: function read(io) { | ||
21279 | return io.readInt32BE(); | ||
21280 | }, | ||
21281 | |||
21282 | write: function write(value, io) { | ||
21283 | if (!isNumber(value)) { | ||
21284 | throw new Error("XDR Write Error: not a number"); | ||
21285 | } | ||
21286 | |||
21287 | if (Math.floor(value) !== value) { | ||
21288 | throw new Error("XDR Write Error: not an integer"); | ||
21289 | } | ||
21290 | |||
21291 | io.writeInt32BE(value); | ||
21292 | }, | ||
21293 | |||
21294 | isValid: function isValid(value) { | ||
21295 | if (!isNumber(value)) { | ||
21296 | return false; | ||
21297 | } | ||
21298 | if (Math.floor(value) !== value) { | ||
21299 | return false; | ||
21300 | } | ||
21301 | |||
21302 | return value >= Int.MIN_VALUE && value <= Int.MAX_VALUE; | ||
21303 | } }; | ||
21304 | |||
21305 | exports.Int = Int; | ||
21306 | Int.MAX_VALUE = Math.pow(2, 31) - 1; | ||
21307 | Int.MIN_VALUE = -Math.pow(2, 31); | ||
21308 | |||
21309 | includeIoMixin(Int); | ||
21310 | },{"./io-mixin":129,"lodash/isNumber":328}],129:[function(require,module,exports){ | ||
21311 | (function (Buffer){ | ||
21312 | "use strict"; | ||
21313 | |||
21314 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21315 | |||
21316 | module.exports = includeIoMixin; | ||
21317 | |||
21318 | var Cursor = require("./cursor").Cursor; | ||
21319 | |||
21320 | var extend = _interopRequire(require("lodash/extend")); | ||
21321 | |||
21322 | var isFunction = _interopRequire(require("lodash/isFunction")); | ||
21323 | |||
21324 | //TODO: build a system to grow a buffer as we write to it | ||
21325 | var BUFFER_SIZE = Math.pow(2, 16); | ||
21326 | |||
21327 | var staticMethods = { | ||
21328 | toXDR: function toXDR(val) { | ||
21329 | var cursor = new Cursor(BUFFER_SIZE); | ||
21330 | this.write(val, cursor); | ||
21331 | var bytesWritten = cursor.tell(); | ||
21332 | cursor.rewind(); | ||
21333 | |||
21334 | return cursor.slice(bytesWritten).buffer(); | ||
21335 | }, | ||
21336 | |||
21337 | fromXDR: function fromXDR(input) { | ||
21338 | var format = arguments[1] === undefined ? "raw" : arguments[1]; | ||
21339 | |||
21340 | var buffer = undefined; | ||
21341 | switch (format) { | ||
21342 | case "raw": | ||
21343 | buffer = input;break; | ||
21344 | case "hex": | ||
21345 | buffer = Buffer.from(input, "hex");break; | ||
21346 | case "base64": | ||
21347 | buffer = Buffer.from(input, "base64");break; | ||
21348 | default: | ||
21349 | throw new Error("Invalid format " + format + ", must be \"raw\", \"hex\", \"base64\""); | ||
21350 | } | ||
21351 | |||
21352 | var cursor = new Cursor(buffer); | ||
21353 | var result = this.read(cursor); | ||
21354 | |||
21355 | //TODO: error out if the entire buffer isn't consumed | ||
21356 | |||
21357 | return result; | ||
21358 | } }; | ||
21359 | |||
21360 | var instanceMethods = { | ||
21361 | toXDR: function toXDR() { | ||
21362 | var format = arguments[0] === undefined ? "raw" : arguments[0]; | ||
21363 | |||
21364 | var buffer = this.constructor.toXDR(this); | ||
21365 | switch (format) { | ||
21366 | case "raw": | ||
21367 | return buffer; | ||
21368 | case "hex": | ||
21369 | return buffer.toString("hex"); | ||
21370 | case "base64": | ||
21371 | return buffer.toString("base64"); | ||
21372 | default: | ||
21373 | throw new Error("Invalid format " + format + ", must be \"raw\", \"hex\", \"base64\""); | ||
21374 | } | ||
21375 | } | ||
21376 | }; | ||
21377 | |||
21378 | function includeIoMixin(obj) { | ||
21379 | extend(obj, staticMethods); | ||
21380 | |||
21381 | if (isFunction(obj)) { | ||
21382 | extend(obj.prototype, instanceMethods); | ||
21383 | } | ||
21384 | } | ||
21385 | }).call(this,require("buffer").Buffer) | ||
21386 | },{"./cursor":122,"buffer":49,"lodash/extend":311,"lodash/isFunction":324}],130:[function(require,module,exports){ | ||
21387 | (function (Buffer){ | ||
21388 | "use strict"; | ||
21389 | |||
21390 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21391 | |||
21392 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
21393 | |||
21394 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
21395 | |||
21396 | Object.defineProperty(exports, "__esModule", { | ||
21397 | value: true | ||
21398 | }); | ||
21399 | |||
21400 | var _util = require("./util"); | ||
21401 | |||
21402 | var calculatePadding = _util.calculatePadding; | ||
21403 | var slicePadding = _util.slicePadding; | ||
21404 | |||
21405 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21406 | |||
21407 | var Opaque = exports.Opaque = (function () { | ||
21408 | function Opaque(length) { | ||
21409 | _classCallCheck(this, Opaque); | ||
21410 | |||
21411 | this._length = length; | ||
21412 | this._padding = calculatePadding(length); | ||
21413 | } | ||
21414 | |||
21415 | _createClass(Opaque, { | ||
21416 | read: { | ||
21417 | value: function read(io) { | ||
21418 | var result = io.slice(this._length); | ||
21419 | slicePadding(io, this._padding); | ||
21420 | return result.buffer(); | ||
21421 | } | ||
21422 | }, | ||
21423 | write: { | ||
21424 | value: function write(value, io) { | ||
21425 | if (value.length !== this._length) { | ||
21426 | throw new Error("XDR Write Error: Got " + value.length + " bytes, expected " + this._length); | ||
21427 | } | ||
21428 | |||
21429 | io.writeBufferPadded(value); | ||
21430 | } | ||
21431 | }, | ||
21432 | isValid: { | ||
21433 | value: function isValid(value) { | ||
21434 | return Buffer.isBuffer(value) && value.length === this._length; | ||
21435 | } | ||
21436 | } | ||
21437 | }); | ||
21438 | |||
21439 | return Opaque; | ||
21440 | })(); | ||
21441 | |||
21442 | includeIoMixin(Opaque.prototype); | ||
21443 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | ||
21444 | },{"../../is-buffer/index.js":117,"./io-mixin":129,"./util":139}],131:[function(require,module,exports){ | ||
21445 | "use strict"; | ||
21446 | |||
21447 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21448 | |||
21449 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
21450 | |||
21451 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
21452 | |||
21453 | Object.defineProperty(exports, "__esModule", { | ||
21454 | value: true | ||
21455 | }); | ||
21456 | |||
21457 | var Bool = require("./bool").Bool; | ||
21458 | |||
21459 | var isNull = _interopRequire(require("lodash/isNull")); | ||
21460 | |||
21461 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
21462 | |||
21463 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21464 | |||
21465 | var Option = exports.Option = (function () { | ||
21466 | function Option(childType) { | ||
21467 | _classCallCheck(this, Option); | ||
21468 | |||
21469 | this._childType = childType; | ||
21470 | } | ||
21471 | |||
21472 | _createClass(Option, { | ||
21473 | read: { | ||
21474 | value: function read(io) { | ||
21475 | if (Bool.read(io)) { | ||
21476 | return this._childType.read(io); | ||
21477 | } | ||
21478 | } | ||
21479 | }, | ||
21480 | write: { | ||
21481 | value: function write(value, io) { | ||
21482 | var isPresent = !(isNull(value) || isUndefined(value)); | ||
21483 | |||
21484 | Bool.write(isPresent, io); | ||
21485 | |||
21486 | if (isPresent) { | ||
21487 | this._childType.write(value, io); | ||
21488 | } | ||
21489 | } | ||
21490 | }, | ||
21491 | isValid: { | ||
21492 | value: function isValid(value) { | ||
21493 | if (isNull(value)) { | ||
21494 | return true; | ||
21495 | } | ||
21496 | if (isUndefined(value)) { | ||
21497 | return true; | ||
21498 | } | ||
21499 | |||
21500 | return this._childType.isValid(value); | ||
21501 | } | ||
21502 | } | ||
21503 | }); | ||
21504 | |||
21505 | return Option; | ||
21506 | })(); | ||
21507 | |||
21508 | includeIoMixin(Option.prototype); | ||
21509 | },{"./bool":120,"./io-mixin":129,"lodash/isNull":327,"lodash/isUndefined":336}],132:[function(require,module,exports){ | ||
21510 | "use strict"; | ||
21511 | |||
21512 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21513 | |||
21514 | Object.defineProperty(exports, "__esModule", { | ||
21515 | value: true | ||
21516 | }); | ||
21517 | |||
21518 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21519 | |||
21520 | var Quadruple = { | ||
21521 | /* jshint unused: false */ | ||
21522 | |||
21523 | read: function read(io) { | ||
21524 | throw new Error("XDR Read Error: quadruple not supported"); | ||
21525 | }, | ||
21526 | |||
21527 | write: function write(value, io) { | ||
21528 | throw new Error("XDR Write Error: quadruple not supported"); | ||
21529 | }, | ||
21530 | |||
21531 | isValid: function isValid(value) { | ||
21532 | return false; | ||
21533 | } }; | ||
21534 | |||
21535 | exports.Quadruple = Quadruple; | ||
21536 | includeIoMixin(Quadruple); | ||
21537 | },{"./io-mixin":129}],133:[function(require,module,exports){ | ||
21538 | (function (Buffer){ | ||
21539 | "use strict"; | ||
21540 | |||
21541 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21542 | |||
21543 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
21544 | |||
21545 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
21546 | |||
21547 | Object.defineProperty(exports, "__esModule", { | ||
21548 | value: true | ||
21549 | }); | ||
21550 | |||
21551 | var Int = require("./int").Int; | ||
21552 | |||
21553 | var UnsignedInt = require("./unsigned-int").UnsignedInt; | ||
21554 | |||
21555 | var _util = require("./util"); | ||
21556 | |||
21557 | var calculatePadding = _util.calculatePadding; | ||
21558 | var slicePadding = _util.slicePadding; | ||
21559 | |||
21560 | var isString = _interopRequire(require("lodash/isString")); | ||
21561 | |||
21562 | var isArray = _interopRequire(require("lodash/isArray")); | ||
21563 | |||
21564 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21565 | |||
21566 | var String = exports.String = (function () { | ||
21567 | function String() { | ||
21568 | var maxLength = arguments[0] === undefined ? UnsignedInt.MAX_VALUE : arguments[0]; | ||
21569 | |||
21570 | _classCallCheck(this, String); | ||
21571 | |||
21572 | this._maxLength = maxLength; | ||
21573 | } | ||
21574 | |||
21575 | _createClass(String, { | ||
21576 | read: { | ||
21577 | value: function read(io) { | ||
21578 | var length = Int.read(io); | ||
21579 | |||
21580 | if (length > this._maxLength) { | ||
21581 | throw new Error("XDR Read Error: Saw " + length + " length String," + ("max allowed is " + this._maxLength)); | ||
21582 | } | ||
21583 | var padding = calculatePadding(length); | ||
21584 | var result = io.slice(length); | ||
21585 | slicePadding(io, padding); | ||
21586 | return result.buffer(); | ||
21587 | } | ||
21588 | }, | ||
21589 | readString: { | ||
21590 | value: function readString(io) { | ||
21591 | return this.read(io).toString("utf8"); | ||
21592 | } | ||
21593 | }, | ||
21594 | write: { | ||
21595 | value: function write(value, io) { | ||
21596 | if (value.length > this._maxLength) { | ||
21597 | throw new Error("XDR Write Error: Got " + value.length + " bytes," + ("max allows is " + this._maxLength)); | ||
21598 | } | ||
21599 | |||
21600 | var buffer = undefined; | ||
21601 | if (isString(value)) { | ||
21602 | buffer = Buffer.from(value, "utf8"); | ||
21603 | } else { | ||
21604 | buffer = Buffer.from(value); | ||
21605 | } | ||
21606 | |||
21607 | Int.write(buffer.length, io); | ||
21608 | io.writeBufferPadded(buffer); | ||
21609 | } | ||
21610 | }, | ||
21611 | isValid: { | ||
21612 | value: function isValid(value) { | ||
21613 | var buffer = undefined; | ||
21614 | if (isString(value)) { | ||
21615 | buffer = Buffer.from(value, "utf8"); | ||
21616 | } else if (isArray(value) || Buffer.isBuffer(value)) { | ||
21617 | buffer = Buffer.from(value); | ||
21618 | } else { | ||
21619 | return false; | ||
21620 | } | ||
21621 | return buffer.length <= this._maxLength; | ||
21622 | } | ||
21623 | } | ||
21624 | }); | ||
21625 | |||
21626 | return String; | ||
21627 | })(); | ||
21628 | |||
21629 | includeIoMixin(String.prototype); | ||
21630 | }).call(this,require("buffer").Buffer) | ||
21631 | },{"./int":128,"./io-mixin":129,"./unsigned-int":138,"./util":139,"buffer":49,"lodash/isArray":319,"lodash/isString":333}],134:[function(require,module,exports){ | ||
21632 | "use strict"; | ||
21633 | |||
21634 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21635 | |||
21636 | var _slicedToArray = function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; | ||
21637 | |||
21638 | var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc && desc.writable) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; | ||
21639 | |||
21640 | var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }; | ||
21641 | |||
21642 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
21643 | |||
21644 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
21645 | |||
21646 | Object.defineProperty(exports, "__esModule", { | ||
21647 | value: true | ||
21648 | }); | ||
21649 | |||
21650 | var each = _interopRequire(require("lodash/each")); | ||
21651 | |||
21652 | var map = _interopRequire(require("lodash/map")); | ||
21653 | |||
21654 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
21655 | |||
21656 | var fromPairs = _interopRequire(require("lodash/fromPairs")); | ||
21657 | |||
21658 | var Reference = require("./config").Reference; | ||
21659 | |||
21660 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21661 | |||
21662 | var Struct = exports.Struct = (function () { | ||
21663 | function Struct(attributes) { | ||
21664 | _classCallCheck(this, Struct); | ||
21665 | |||
21666 | this._attributes = attributes || {}; | ||
21667 | } | ||
21668 | |||
21669 | _createClass(Struct, null, { | ||
21670 | read: { | ||
21671 | value: function read(io) { | ||
21672 | var fields = map(this._fields, function (field) { | ||
21673 | var _field = _slicedToArray(field, 2); | ||
21674 | |||
21675 | var name = _field[0]; | ||
21676 | var type = _field[1]; | ||
21677 | |||
21678 | var value = type.read(io); | ||
21679 | return [name, value]; | ||
21680 | }); | ||
21681 | |||
21682 | return new this(fromPairs(fields)); | ||
21683 | } | ||
21684 | }, | ||
21685 | write: { | ||
21686 | value: function write(value, io) { | ||
21687 | if (!(value instanceof this)) { | ||
21688 | throw new Error("XDR Write Error: " + value + " is not a " + this.structName); | ||
21689 | } | ||
21690 | each(this._fields, function (field) { | ||
21691 | var _field = _slicedToArray(field, 2); | ||
21692 | |||
21693 | var name = _field[0]; | ||
21694 | var type = _field[1]; | ||
21695 | |||
21696 | var attribute = value._attributes[name]; | ||
21697 | type.write(attribute, io); | ||
21698 | }); | ||
21699 | } | ||
21700 | }, | ||
21701 | isValid: { | ||
21702 | value: function isValid(value) { | ||
21703 | return value instanceof this; | ||
21704 | } | ||
21705 | }, | ||
21706 | create: { | ||
21707 | value: function create(context, name, fields) { | ||
21708 | var ChildStruct = (function (_Struct) { | ||
21709 | var _class = function ChildStruct() { | ||
21710 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | ||
21711 | args[_key] = arguments[_key]; | ||
21712 | } | ||
21713 | |||
21714 | _classCallCheck(this, _class); | ||
21715 | |||
21716 | _get(Object.getPrototypeOf(_class.prototype), "constructor", this).apply(this, args); | ||
21717 | }; | ||
21718 | |||
21719 | _inherits(_class, _Struct); | ||
21720 | |||
21721 | return _class; | ||
21722 | })(Struct); | ||
21723 | |||
21724 | ChildStruct.structName = name; | ||
21725 | |||
21726 | context.results[name] = ChildStruct; | ||
21727 | |||
21728 | ChildStruct._fields = fields.map(function (_ref) { | ||
21729 | var _ref2 = _slicedToArray(_ref, 2); | ||
21730 | |||
21731 | var name = _ref2[0]; | ||
21732 | var field = _ref2[1]; | ||
21733 | |||
21734 | if (field instanceof Reference) { | ||
21735 | field = field.resolve(context); | ||
21736 | } | ||
21737 | |||
21738 | return [name, field]; | ||
21739 | }); | ||
21740 | |||
21741 | each(ChildStruct._fields, function (field) { | ||
21742 | var _field = _slicedToArray(field, 1); | ||
21743 | |||
21744 | var fieldName = _field[0]; | ||
21745 | |||
21746 | ChildStruct.prototype[fieldName] = readOrWriteAttribute(fieldName); | ||
21747 | }); | ||
21748 | |||
21749 | return ChildStruct; | ||
21750 | } | ||
21751 | } | ||
21752 | }); | ||
21753 | |||
21754 | return Struct; | ||
21755 | })(); | ||
21756 | |||
21757 | includeIoMixin(Struct); | ||
21758 | |||
21759 | function readOrWriteAttribute(name) { | ||
21760 | return function (value) { | ||
21761 | if (!isUndefined(value)) { | ||
21762 | this._attributes[name] = value; | ||
21763 | } | ||
21764 | |||
21765 | return this._attributes[name]; | ||
21766 | }; | ||
21767 | } | ||
21768 | },{"./config":121,"./io-mixin":129,"lodash/each":308,"lodash/fromPairs":314,"lodash/isUndefined":336,"lodash/map":339}],135:[function(require,module,exports){ | ||
21769 | "use strict"; | ||
21770 | |||
21771 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | ||
21772 | |||
21773 | var _defaults = function (obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }; | ||
21774 | |||
21775 | Object.defineProperty(exports, "__esModule", { | ||
21776 | value: true | ||
21777 | }); | ||
21778 | |||
21779 | _defaults(exports, _interopRequireWildcard(require("./int"))); | ||
21780 | |||
21781 | _defaults(exports, _interopRequireWildcard(require("./hyper"))); | ||
21782 | |||
21783 | _defaults(exports, _interopRequireWildcard(require("./unsigned-int"))); | ||
21784 | |||
21785 | _defaults(exports, _interopRequireWildcard(require("./unsigned-hyper"))); | ||
21786 | |||
21787 | _defaults(exports, _interopRequireWildcard(require("./float"))); | ||
21788 | |||
21789 | _defaults(exports, _interopRequireWildcard(require("./double"))); | ||
21790 | |||
21791 | _defaults(exports, _interopRequireWildcard(require("./quadruple"))); | ||
21792 | |||
21793 | _defaults(exports, _interopRequireWildcard(require("./bool"))); | ||
21794 | |||
21795 | _defaults(exports, _interopRequireWildcard(require("./string"))); | ||
21796 | |||
21797 | _defaults(exports, _interopRequireWildcard(require("./opaque"))); | ||
21798 | |||
21799 | _defaults(exports, _interopRequireWildcard(require("./var-opaque"))); | ||
21800 | |||
21801 | _defaults(exports, _interopRequireWildcard(require("./array"))); | ||
21802 | |||
21803 | _defaults(exports, _interopRequireWildcard(require("./var-array"))); | ||
21804 | |||
21805 | _defaults(exports, _interopRequireWildcard(require("./option"))); | ||
21806 | |||
21807 | _defaults(exports, _interopRequireWildcard(require("./void"))); | ||
21808 | |||
21809 | _defaults(exports, _interopRequireWildcard(require("./enum"))); | ||
21810 | |||
21811 | _defaults(exports, _interopRequireWildcard(require("./struct"))); | ||
21812 | |||
21813 | _defaults(exports, _interopRequireWildcard(require("./union"))); | ||
21814 | },{"./array":119,"./bool":120,"./double":123,"./enum":124,"./float":125,"./hyper":126,"./int":128,"./opaque":130,"./option":131,"./quadruple":132,"./string":133,"./struct":134,"./union":136,"./unsigned-hyper":137,"./unsigned-int":138,"./var-array":140,"./var-opaque":141,"./void":142}],136:[function(require,module,exports){ | ||
21815 | "use strict"; | ||
21816 | |||
21817 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
21818 | |||
21819 | var _slicedToArray = function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; | ||
21820 | |||
21821 | var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc && desc.writable) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; | ||
21822 | |||
21823 | var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }; | ||
21824 | |||
21825 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
21826 | |||
21827 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
21828 | |||
21829 | Object.defineProperty(exports, "__esModule", { | ||
21830 | value: true | ||
21831 | }); | ||
21832 | |||
21833 | var each = _interopRequire(require("lodash/each")); | ||
21834 | |||
21835 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
21836 | |||
21837 | var isString = _interopRequire(require("lodash/isString")); | ||
21838 | |||
21839 | var Void = require("./void").Void; | ||
21840 | |||
21841 | var Reference = require("./config").Reference; | ||
21842 | |||
21843 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
21844 | |||
21845 | var Union = exports.Union = (function () { | ||
21846 | function Union(aSwitch, value) { | ||
21847 | _classCallCheck(this, Union); | ||
21848 | |||
21849 | this.set(aSwitch, value); | ||
21850 | } | ||
21851 | |||
21852 | _createClass(Union, { | ||
21853 | set: { | ||
21854 | value: function set(aSwitch, value) { | ||
21855 | if (isString(aSwitch)) { | ||
21856 | aSwitch = this.constructor._switchOn.fromName(aSwitch); | ||
21857 | } | ||
21858 | |||
21859 | this._switch = aSwitch; | ||
21860 | this._arm = this.constructor.armForSwitch(this._switch); | ||
21861 | this._armType = this.constructor.armTypeForArm(this._arm); | ||
21862 | this._value = value; | ||
21863 | } | ||
21864 | }, | ||
21865 | get: { | ||
21866 | value: function get() { | ||
21867 | var armName = arguments[0] === undefined ? this._arm : arguments[0]; | ||
21868 | |||
21869 | if (this._arm !== Void && this._arm !== armName) { | ||
21870 | throw new Error("" + armName + " not set"); | ||
21871 | } | ||
21872 | return this._value; | ||
21873 | } | ||
21874 | }, | ||
21875 | "switch": { | ||
21876 | value: function _switch() { | ||
21877 | return this._switch; | ||
21878 | } | ||
21879 | }, | ||
21880 | arm: { | ||
21881 | value: function arm() { | ||
21882 | return this._arm; | ||
21883 | } | ||
21884 | }, | ||
21885 | armType: { | ||
21886 | value: function armType() { | ||
21887 | return this._armType; | ||
21888 | } | ||
21889 | }, | ||
21890 | value: { | ||
21891 | value: function value() { | ||
21892 | return this._value; | ||
21893 | } | ||
21894 | } | ||
21895 | }, { | ||
21896 | armForSwitch: { | ||
21897 | value: function armForSwitch(aSwitch) { | ||
21898 | if (this._switches.has(aSwitch)) { | ||
21899 | return this._switches.get(aSwitch); | ||
21900 | } else if (this._defaultArm) { | ||
21901 | return this._defaultArm; | ||
21902 | } else { | ||
21903 | throw new Error("Bad union switch: " + aSwitch); | ||
21904 | } | ||
21905 | } | ||
21906 | }, | ||
21907 | armTypeForArm: { | ||
21908 | value: function armTypeForArm(arm) { | ||
21909 | if (arm === Void) { | ||
21910 | return Void; | ||
21911 | } else { | ||
21912 | return this._arms[arm]; | ||
21913 | } | ||
21914 | } | ||
21915 | }, | ||
21916 | read: { | ||
21917 | value: function read(io) { | ||
21918 | var aSwitch = this._switchOn.read(io); | ||
21919 | var arm = this.armForSwitch(aSwitch); | ||
21920 | var armType = this.armTypeForArm(arm); | ||
21921 | var value = armType.read(io); | ||
21922 | return new this(aSwitch, value); | ||
21923 | } | ||
21924 | }, | ||
21925 | write: { | ||
21926 | value: function write(value, io) { | ||
21927 | if (!(value instanceof this)) { | ||
21928 | throw new Error("XDR Write Error: " + value + " is not a " + this.unionName); | ||
21929 | } | ||
21930 | |||
21931 | this._switchOn.write(value["switch"](), io); | ||
21932 | value.armType().write(value.value(), io); | ||
21933 | } | ||
21934 | }, | ||
21935 | isValid: { | ||
21936 | value: function isValid(value) { | ||
21937 | return value instanceof this; | ||
21938 | } | ||
21939 | }, | ||
21940 | create: { | ||
21941 | value: function create(context, name, config) { | ||
21942 | var ChildUnion = (function (_Union) { | ||
21943 | var _class = function ChildUnion() { | ||
21944 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | ||
21945 | args[_key] = arguments[_key]; | ||
21946 | } | ||
21947 | |||
21948 | _classCallCheck(this, _class); | ||
21949 | |||
21950 | _get(Object.getPrototypeOf(_class.prototype), "constructor", this).apply(this, args); | ||
21951 | }; | ||
21952 | |||
21953 | _inherits(_class, _Union); | ||
21954 | |||
21955 | return _class; | ||
21956 | })(Union); | ||
21957 | |||
21958 | ChildUnion.unionName = name; | ||
21959 | context.results[name] = ChildUnion; | ||
21960 | |||
21961 | if (config.switchOn instanceof Reference) { | ||
21962 | ChildUnion._switchOn = config.switchOn.resolve(context); | ||
21963 | } else { | ||
21964 | ChildUnion._switchOn = config.switchOn; | ||
21965 | } | ||
21966 | |||
21967 | ChildUnion._switches = new Map(); | ||
21968 | ChildUnion._arms = {}; | ||
21969 | |||
21970 | each(config.arms, function (value, name) { | ||
21971 | if (value instanceof Reference) { | ||
21972 | value = value.resolve(context); | ||
21973 | } | ||
21974 | |||
21975 | ChildUnion._arms[name] = value; | ||
21976 | }); | ||
21977 | |||
21978 | // resolve default arm | ||
21979 | var defaultArm = config.defaultArm; | ||
21980 | if (defaultArm instanceof Reference) { | ||
21981 | defaultArm = defaultArm.resolve(context); | ||
21982 | } | ||
21983 | |||
21984 | ChildUnion._defaultArm = defaultArm; | ||
21985 | |||
21986 | each(config.switches, function (_ref) { | ||
21987 | var _ref2 = _slicedToArray(_ref, 2); | ||
21988 | |||
21989 | var aSwitch = _ref2[0]; | ||
21990 | var armName = _ref2[1]; | ||
21991 | |||
21992 | if (isString(aSwitch)) { | ||
21993 | aSwitch = ChildUnion._switchOn.fromName(aSwitch); | ||
21994 | } | ||
21995 | |||
21996 | ChildUnion._switches.set(aSwitch, armName); | ||
21997 | }); | ||
21998 | |||
21999 | // add enum-based helpers | ||
22000 | // NOTE: we don't have good notation for "is a subclass of XDR.Enum", | ||
22001 | // and so we use the following check (does _switchOn have a `values` | ||
22002 | // attribute) to approximate the intent. | ||
22003 | if (!isUndefined(ChildUnion._switchOn.values)) { | ||
22004 | each(ChildUnion._switchOn.values(), function (aSwitch) { | ||
22005 | // Add enum-based constrocutors | ||
22006 | ChildUnion[aSwitch.name] = function (value) { | ||
22007 | return new ChildUnion(aSwitch, value); | ||
22008 | }; | ||
22009 | |||
22010 | // Add enum-based "set" helpers | ||
22011 | ChildUnion.prototype[aSwitch.name] = function (value) { | ||
22012 | return this.set(aSwitch, value); | ||
22013 | }; | ||
22014 | }); | ||
22015 | } | ||
22016 | |||
22017 | // Add arm accessor helpers | ||
22018 | each(ChildUnion._arms, function (type, name) { | ||
22019 | if (type === Void) { | ||
22020 | return; | ||
22021 | } | ||
22022 | |||
22023 | ChildUnion.prototype[name] = function () { | ||
22024 | return this.get(name); | ||
22025 | }; | ||
22026 | }); | ||
22027 | |||
22028 | return ChildUnion; | ||
22029 | } | ||
22030 | } | ||
22031 | }); | ||
22032 | |||
22033 | return Union; | ||
22034 | })(); | ||
22035 | |||
22036 | includeIoMixin(Union); | ||
22037 | },{"./config":121,"./io-mixin":129,"./void":142,"lodash/each":308,"lodash/isString":333,"lodash/isUndefined":336}],137:[function(require,module,exports){ | ||
22038 | "use strict"; | ||
22039 | |||
22040 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
22041 | |||
22042 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
22043 | |||
22044 | var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc && desc.writable) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; | ||
22045 | |||
22046 | var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }; | ||
22047 | |||
22048 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
22049 | |||
22050 | Object.defineProperty(exports, "__esModule", { | ||
22051 | value: true | ||
22052 | }); | ||
22053 | |||
22054 | var Long = _interopRequire(require("long")); | ||
22055 | |||
22056 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
22057 | |||
22058 | var UnsignedHyper = exports.UnsignedHyper = (function (_Long) { | ||
22059 | function UnsignedHyper(low, high) { | ||
22060 | _classCallCheck(this, UnsignedHyper); | ||
22061 | |||
22062 | _get(Object.getPrototypeOf(UnsignedHyper.prototype), "constructor", this).call(this, low, high, true); | ||
22063 | } | ||
22064 | |||
22065 | _inherits(UnsignedHyper, _Long); | ||
22066 | |||
22067 | _createClass(UnsignedHyper, null, { | ||
22068 | read: { | ||
22069 | value: function read(io) { | ||
22070 | var high = io.readInt32BE(); | ||
22071 | var low = io.readInt32BE(); | ||
22072 | return this.fromBits(low, high); | ||
22073 | } | ||
22074 | }, | ||
22075 | write: { | ||
22076 | value: function write(value, io) { | ||
22077 | if (!(value instanceof this)) { | ||
22078 | throw new Error("XDR Write Error: " + value + " is not an UnsignedHyper"); | ||
22079 | } | ||
22080 | |||
22081 | io.writeInt32BE(value.high); | ||
22082 | io.writeInt32BE(value.low); | ||
22083 | } | ||
22084 | }, | ||
22085 | fromString: { | ||
22086 | value: function fromString(string) { | ||
22087 | if (!/^\d+$/.test(string)) { | ||
22088 | throw new Error("Invalid hyper string: " + string); | ||
22089 | } | ||
22090 | var result = _get(Object.getPrototypeOf(UnsignedHyper), "fromString", this).call(this, string, true); | ||
22091 | return new this(result.low, result.high); | ||
22092 | } | ||
22093 | }, | ||
22094 | fromBits: { | ||
22095 | value: function fromBits(low, high) { | ||
22096 | var result = _get(Object.getPrototypeOf(UnsignedHyper), "fromBits", this).call(this, low, high, true); | ||
22097 | return new this(result.low, result.high); | ||
22098 | } | ||
22099 | }, | ||
22100 | isValid: { | ||
22101 | value: function isValid(value) { | ||
22102 | return value instanceof this; | ||
22103 | } | ||
22104 | } | ||
22105 | }); | ||
22106 | |||
22107 | return UnsignedHyper; | ||
22108 | })(Long); | ||
22109 | |||
22110 | includeIoMixin(UnsignedHyper); | ||
22111 | |||
22112 | UnsignedHyper.MAX_VALUE = new UnsignedHyper(Long.MAX_UNSIGNED_VALUE.low, Long.MAX_UNSIGNED_VALUE.high); | ||
22113 | |||
22114 | UnsignedHyper.MIN_VALUE = new UnsignedHyper(Long.MIN_VALUE.low, Long.MIN_VALUE.high); | ||
22115 | },{"./io-mixin":129,"long":353}],138:[function(require,module,exports){ | ||
22116 | "use strict"; | ||
22117 | |||
22118 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
22119 | |||
22120 | Object.defineProperty(exports, "__esModule", { | ||
22121 | value: true | ||
22122 | }); | ||
22123 | |||
22124 | var isNumber = _interopRequire(require("lodash/isNumber")); | ||
22125 | |||
22126 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
22127 | |||
22128 | var UnsignedInt = { | ||
22129 | |||
22130 | read: function read(io) { | ||
22131 | return io.readUInt32BE(); | ||
22132 | }, | ||
22133 | |||
22134 | write: function write(value, io) { | ||
22135 | if (!isNumber(value)) { | ||
22136 | throw new Error("XDR Write Error: not a number"); | ||
22137 | } | ||
22138 | |||
22139 | if (Math.floor(value) !== value) { | ||
22140 | throw new Error("XDR Write Error: not an integer"); | ||
22141 | } | ||
22142 | |||
22143 | if (value < 0) { | ||
22144 | throw new Error("XDR Write Error: negative number " + value); | ||
22145 | } | ||
22146 | |||
22147 | io.writeUInt32BE(value); | ||
22148 | }, | ||
22149 | |||
22150 | isValid: function isValid(value) { | ||
22151 | if (!isNumber(value)) { | ||
22152 | return false; | ||
22153 | } | ||
22154 | if (Math.floor(value) !== value) { | ||
22155 | return false; | ||
22156 | } | ||
22157 | |||
22158 | return value >= UnsignedInt.MIN_VALUE && value <= UnsignedInt.MAX_VALUE; | ||
22159 | } }; | ||
22160 | |||
22161 | exports.UnsignedInt = UnsignedInt; | ||
22162 | UnsignedInt.MAX_VALUE = Math.pow(2, 32) - 1; | ||
22163 | UnsignedInt.MIN_VALUE = 0; | ||
22164 | |||
22165 | includeIoMixin(UnsignedInt); | ||
22166 | },{"./io-mixin":129,"lodash/isNumber":328}],139:[function(require,module,exports){ | ||
22167 | "use strict"; | ||
22168 | |||
22169 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
22170 | |||
22171 | exports.calculatePadding = calculatePadding; | ||
22172 | exports.slicePadding = slicePadding; | ||
22173 | Object.defineProperty(exports, "__esModule", { | ||
22174 | value: true | ||
22175 | }); | ||
22176 | |||
22177 | var every = _interopRequire(require("lodash/every")); | ||
22178 | |||
22179 | function calculatePadding(length) { | ||
22180 | switch (length % 4) { | ||
22181 | case 0: | ||
22182 | return 0; | ||
22183 | case 1: | ||
22184 | return 3; | ||
22185 | case 2: | ||
22186 | return 2; | ||
22187 | case 3: | ||
22188 | return 1; | ||
22189 | } | ||
22190 | } | ||
22191 | |||
22192 | function slicePadding(io, length) { | ||
22193 | var padding = io.slice(length); | ||
22194 | var allZero = every(padding.buffer(), function (byte) { | ||
22195 | return byte === 0; | ||
22196 | }); | ||
22197 | |||
22198 | if (allZero !== true) { | ||
22199 | throw new Error("XDR Read Error: invalid padding"); | ||
22200 | } | ||
22201 | } | ||
22202 | },{"lodash/every":310}],140:[function(require,module,exports){ | ||
22203 | "use strict"; | ||
22204 | |||
22205 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
22206 | |||
22207 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
22208 | |||
22209 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
22210 | |||
22211 | Object.defineProperty(exports, "__esModule", { | ||
22212 | value: true | ||
22213 | }); | ||
22214 | |||
22215 | var Int = require("./int").Int; | ||
22216 | |||
22217 | var UnsignedInt = require("./unsigned-int").UnsignedInt; | ||
22218 | |||
22219 | var every = _interopRequire(require("lodash/every")); | ||
22220 | |||
22221 | var each = _interopRequire(require("lodash/each")); | ||
22222 | |||
22223 | var times = _interopRequire(require("lodash/times")); | ||
22224 | |||
22225 | var isArray = _interopRequire(require("lodash/isArray")); | ||
22226 | |||
22227 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
22228 | |||
22229 | var VarArray = exports.VarArray = (function () { | ||
22230 | function VarArray(childType) { | ||
22231 | var maxLength = arguments[1] === undefined ? UnsignedInt.MAX_VALUE : arguments[1]; | ||
22232 | |||
22233 | _classCallCheck(this, VarArray); | ||
22234 | |||
22235 | this._childType = childType; | ||
22236 | this._maxLength = maxLength; | ||
22237 | } | ||
22238 | |||
22239 | _createClass(VarArray, { | ||
22240 | read: { | ||
22241 | value: function read(io) { | ||
22242 | var _this = this; | ||
22243 | |||
22244 | var length = Int.read(io); | ||
22245 | |||
22246 | if (length > this._maxLength) { | ||
22247 | throw new Error("XDR Read Error: Saw " + length + " length VarArray," + ("max allowed is " + this._maxLength)); | ||
22248 | } | ||
22249 | |||
22250 | return times(length, function () { | ||
22251 | return _this._childType.read(io); | ||
22252 | }); | ||
22253 | } | ||
22254 | }, | ||
22255 | write: { | ||
22256 | value: function write(value, io) { | ||
22257 | var _this = this; | ||
22258 | |||
22259 | if (!isArray(value)) { | ||
22260 | throw new Error("XDR Write Error: value is not array"); | ||
22261 | } | ||
22262 | |||
22263 | if (value.length > this._maxLength) { | ||
22264 | throw new Error("XDR Write Error: Got array of size " + value.length + "," + ("max allowed is " + this._maxLength)); | ||
22265 | } | ||
22266 | |||
22267 | Int.write(value.length, io); | ||
22268 | each(value, function (child) { | ||
22269 | return _this._childType.write(child, io); | ||
22270 | }); | ||
22271 | } | ||
22272 | }, | ||
22273 | isValid: { | ||
22274 | value: function isValid(value) { | ||
22275 | var _this = this; | ||
22276 | |||
22277 | if (!isArray(value)) { | ||
22278 | return false; | ||
22279 | } | ||
22280 | if (value.length > this._maxLength) { | ||
22281 | return false; | ||
22282 | } | ||
22283 | |||
22284 | return every(value, function (child) { | ||
22285 | return _this._childType.isValid(child); | ||
22286 | }); | ||
22287 | } | ||
22288 | } | ||
22289 | }); | ||
22290 | |||
22291 | return VarArray; | ||
22292 | })(); | ||
22293 | |||
22294 | includeIoMixin(VarArray.prototype); | ||
22295 | },{"./int":128,"./io-mixin":129,"./unsigned-int":138,"lodash/each":308,"lodash/every":310,"lodash/isArray":319,"lodash/times":346}],141:[function(require,module,exports){ | ||
22296 | (function (Buffer){ | ||
22297 | "use strict"; | ||
22298 | |||
22299 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
22300 | |||
22301 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
22302 | |||
22303 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
22304 | |||
22305 | Object.defineProperty(exports, "__esModule", { | ||
22306 | value: true | ||
22307 | }); | ||
22308 | |||
22309 | var Int = require("./int").Int; | ||
22310 | |||
22311 | var UnsignedInt = require("./unsigned-int").UnsignedInt; | ||
22312 | |||
22313 | var _util = require("./util"); | ||
22314 | |||
22315 | var calculatePadding = _util.calculatePadding; | ||
22316 | var slicePadding = _util.slicePadding; | ||
22317 | |||
22318 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
22319 | |||
22320 | var VarOpaque = exports.VarOpaque = (function () { | ||
22321 | function VarOpaque() { | ||
22322 | var maxLength = arguments[0] === undefined ? UnsignedInt.MAX_VALUE : arguments[0]; | ||
22323 | |||
22324 | _classCallCheck(this, VarOpaque); | ||
22325 | |||
22326 | this._maxLength = maxLength; | ||
22327 | } | ||
22328 | |||
22329 | _createClass(VarOpaque, { | ||
22330 | read: { | ||
22331 | value: function read(io) { | ||
22332 | var length = Int.read(io); | ||
22333 | |||
22334 | if (length > this._maxLength) { | ||
22335 | throw new Error("XDR Read Error: Saw " + length + " length VarOpaque," + ("max allowed is " + this._maxLength)); | ||
22336 | } | ||
22337 | var padding = calculatePadding(length); | ||
22338 | var result = io.slice(length); | ||
22339 | slicePadding(io, padding); | ||
22340 | return result.buffer(); | ||
22341 | } | ||
22342 | }, | ||
22343 | write: { | ||
22344 | value: function write(value, io) { | ||
22345 | if (value.length > this._maxLength) { | ||
22346 | throw new Error("XDR Write Error: Got " + value.length + " bytes," + ("max allows is " + this._maxLength)); | ||
22347 | } | ||
22348 | Int.write(value.length, io); | ||
22349 | io.writeBufferPadded(value); | ||
22350 | } | ||
22351 | }, | ||
22352 | isValid: { | ||
22353 | value: function isValid(value) { | ||
22354 | return Buffer.isBuffer(value) && value.length <= this._maxLength; | ||
22355 | } | ||
22356 | } | ||
22357 | }); | ||
22358 | |||
22359 | return VarOpaque; | ||
22360 | })(); | ||
22361 | |||
22362 | includeIoMixin(VarOpaque.prototype); | ||
22363 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | ||
22364 | },{"../../is-buffer/index.js":117,"./int":128,"./io-mixin":129,"./unsigned-int":138,"./util":139}],142:[function(require,module,exports){ | ||
22365 | "use strict"; | ||
22366 | |||
22367 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
22368 | |||
22369 | Object.defineProperty(exports, "__esModule", { | ||
22370 | value: true | ||
22371 | }); | ||
22372 | |||
22373 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
22374 | |||
22375 | var includeIoMixin = _interopRequire(require("./io-mixin")); | ||
22376 | |||
22377 | var Void = { | ||
22378 | /* jshint unused: false */ | ||
22379 | |||
22380 | read: function read(io) { | ||
22381 | return undefined; | ||
22382 | }, | ||
22383 | |||
22384 | write: function write(value, io) { | ||
22385 | if (!isUndefined(value)) { | ||
22386 | throw new Error("XDR Write Error: trying to write value to a void slot"); | ||
22387 | } | ||
22388 | }, | ||
22389 | |||
22390 | isValid: function isValid(value) { | ||
22391 | return isUndefined(value); | ||
22392 | } }; | ||
22393 | |||
22394 | exports.Void = Void; | ||
22395 | includeIoMixin(Void); | ||
22396 | },{"./io-mixin":129,"lodash/isUndefined":336}],143:[function(require,module,exports){ | ||
22397 | var getNative = require('./_getNative'), | ||
22398 | root = require('./_root'); | ||
22399 | |||
22400 | /* Built-in method references that are verified to be native. */ | ||
22401 | var DataView = getNative(root, 'DataView'); | ||
22402 | |||
22403 | module.exports = DataView; | ||
22404 | |||
22405 | },{"./_getNative":241,"./_root":286}],144:[function(require,module,exports){ | ||
22406 | var hashClear = require('./_hashClear'), | ||
22407 | hashDelete = require('./_hashDelete'), | ||
22408 | hashGet = require('./_hashGet'), | ||
22409 | hashHas = require('./_hashHas'), | ||
22410 | hashSet = require('./_hashSet'); | ||
22411 | |||
22412 | /** | ||
22413 | * Creates a hash object. | ||
22414 | * | ||
22415 | * @private | ||
22416 | * @constructor | ||
22417 | * @param {Array} [entries] The key-value pairs to cache. | ||
22418 | */ | ||
22419 | function Hash(entries) { | ||
22420 | var index = -1, | ||
22421 | length = entries == null ? 0 : entries.length; | ||
22422 | |||
22423 | this.clear(); | ||
22424 | while (++index < length) { | ||
22425 | var entry = entries[index]; | ||
22426 | this.set(entry[0], entry[1]); | ||
22427 | } | ||
22428 | } | ||
22429 | |||
22430 | // Add methods to `Hash`. | ||
22431 | Hash.prototype.clear = hashClear; | ||
22432 | Hash.prototype['delete'] = hashDelete; | ||
22433 | Hash.prototype.get = hashGet; | ||
22434 | Hash.prototype.has = hashHas; | ||
22435 | Hash.prototype.set = hashSet; | ||
22436 | |||
22437 | module.exports = Hash; | ||
22438 | |||
22439 | },{"./_hashClear":250,"./_hashDelete":251,"./_hashGet":252,"./_hashHas":253,"./_hashSet":254}],145:[function(require,module,exports){ | ||
22440 | var listCacheClear = require('./_listCacheClear'), | ||
22441 | listCacheDelete = require('./_listCacheDelete'), | ||
22442 | listCacheGet = require('./_listCacheGet'), | ||
22443 | listCacheHas = require('./_listCacheHas'), | ||
22444 | listCacheSet = require('./_listCacheSet'); | ||
22445 | |||
22446 | /** | ||
22447 | * Creates an list cache object. | ||
22448 | * | ||
22449 | * @private | ||
22450 | * @constructor | ||
22451 | * @param {Array} [entries] The key-value pairs to cache. | ||
22452 | */ | ||
22453 | function ListCache(entries) { | ||
22454 | var index = -1, | ||
22455 | length = entries == null ? 0 : entries.length; | ||
22456 | |||
22457 | this.clear(); | ||
22458 | while (++index < length) { | ||
22459 | var entry = entries[index]; | ||
22460 | this.set(entry[0], entry[1]); | ||
22461 | } | ||
22462 | } | ||
22463 | |||
22464 | // Add methods to `ListCache`. | ||
22465 | ListCache.prototype.clear = listCacheClear; | ||
22466 | ListCache.prototype['delete'] = listCacheDelete; | ||
22467 | ListCache.prototype.get = listCacheGet; | ||
22468 | ListCache.prototype.has = listCacheHas; | ||
22469 | ListCache.prototype.set = listCacheSet; | ||
22470 | |||
22471 | module.exports = ListCache; | ||
22472 | |||
22473 | },{"./_listCacheClear":266,"./_listCacheDelete":267,"./_listCacheGet":268,"./_listCacheHas":269,"./_listCacheSet":270}],146:[function(require,module,exports){ | ||
22474 | var getNative = require('./_getNative'), | ||
22475 | root = require('./_root'); | ||
22476 | |||
22477 | /* Built-in method references that are verified to be native. */ | ||
22478 | var Map = getNative(root, 'Map'); | ||
22479 | |||
22480 | module.exports = Map; | ||
22481 | |||
22482 | },{"./_getNative":241,"./_root":286}],147:[function(require,module,exports){ | ||
22483 | var mapCacheClear = require('./_mapCacheClear'), | ||
22484 | mapCacheDelete = require('./_mapCacheDelete'), | ||
22485 | mapCacheGet = require('./_mapCacheGet'), | ||
22486 | mapCacheHas = require('./_mapCacheHas'), | ||
22487 | mapCacheSet = require('./_mapCacheSet'); | ||
22488 | |||
22489 | /** | ||
22490 | * Creates a map cache object to store key-value pairs. | ||
22491 | * | ||
22492 | * @private | ||
22493 | * @constructor | ||
22494 | * @param {Array} [entries] The key-value pairs to cache. | ||
22495 | */ | ||
22496 | function MapCache(entries) { | ||
22497 | var index = -1, | ||
22498 | length = entries == null ? 0 : entries.length; | ||
22499 | |||
22500 | this.clear(); | ||
22501 | while (++index < length) { | ||
22502 | var entry = entries[index]; | ||
22503 | this.set(entry[0], entry[1]); | ||
22504 | } | ||
22505 | } | ||
22506 | |||
22507 | // Add methods to `MapCache`. | ||
22508 | MapCache.prototype.clear = mapCacheClear; | ||
22509 | MapCache.prototype['delete'] = mapCacheDelete; | ||
22510 | MapCache.prototype.get = mapCacheGet; | ||
22511 | MapCache.prototype.has = mapCacheHas; | ||
22512 | MapCache.prototype.set = mapCacheSet; | ||
22513 | |||
22514 | module.exports = MapCache; | ||
22515 | |||
22516 | },{"./_mapCacheClear":271,"./_mapCacheDelete":272,"./_mapCacheGet":273,"./_mapCacheHas":274,"./_mapCacheSet":275}],148:[function(require,module,exports){ | ||
22517 | var getNative = require('./_getNative'), | ||
22518 | root = require('./_root'); | ||
22519 | |||
22520 | /* Built-in method references that are verified to be native. */ | ||
22521 | var Promise = getNative(root, 'Promise'); | ||
22522 | |||
22523 | module.exports = Promise; | ||
22524 | |||
22525 | },{"./_getNative":241,"./_root":286}],149:[function(require,module,exports){ | ||
22526 | var getNative = require('./_getNative'), | ||
22527 | root = require('./_root'); | ||
22528 | |||
22529 | /* Built-in method references that are verified to be native. */ | ||
22530 | var Set = getNative(root, 'Set'); | ||
22531 | |||
22532 | module.exports = Set; | ||
22533 | |||
22534 | },{"./_getNative":241,"./_root":286}],150:[function(require,module,exports){ | ||
22535 | var MapCache = require('./_MapCache'), | ||
22536 | setCacheAdd = require('./_setCacheAdd'), | ||
22537 | setCacheHas = require('./_setCacheHas'); | ||
22538 | |||
22539 | /** | ||
22540 | * | ||
22541 | * Creates an array cache object to store unique values. | ||
22542 | * | ||
22543 | * @private | ||
22544 | * @constructor | ||
22545 | * @param {Array} [values] The values to cache. | ||
22546 | */ | ||
22547 | function SetCache(values) { | ||
22548 | var index = -1, | ||
22549 | length = values == null ? 0 : values.length; | ||
22550 | |||
22551 | this.__data__ = new MapCache; | ||
22552 | while (++index < length) { | ||
22553 | this.add(values[index]); | ||
22554 | } | ||
22555 | } | ||
22556 | |||
22557 | // Add methods to `SetCache`. | ||
22558 | SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; | ||
22559 | SetCache.prototype.has = setCacheHas; | ||
22560 | |||
22561 | module.exports = SetCache; | ||
22562 | |||
22563 | },{"./_MapCache":147,"./_setCacheAdd":287,"./_setCacheHas":288}],151:[function(require,module,exports){ | ||
22564 | var ListCache = require('./_ListCache'), | ||
22565 | stackClear = require('./_stackClear'), | ||
22566 | stackDelete = require('./_stackDelete'), | ||
22567 | stackGet = require('./_stackGet'), | ||
22568 | stackHas = require('./_stackHas'), | ||
22569 | stackSet = require('./_stackSet'); | ||
22570 | |||
22571 | /** | ||
22572 | * Creates a stack cache object to store key-value pairs. | ||
22573 | * | ||
22574 | * @private | ||
22575 | * @constructor | ||
22576 | * @param {Array} [entries] The key-value pairs to cache. | ||
22577 | */ | ||
22578 | function Stack(entries) { | ||
22579 | var data = this.__data__ = new ListCache(entries); | ||
22580 | this.size = data.size; | ||
22581 | } | ||
22582 | |||
22583 | // Add methods to `Stack`. | ||
22584 | Stack.prototype.clear = stackClear; | ||
22585 | Stack.prototype['delete'] = stackDelete; | ||
22586 | Stack.prototype.get = stackGet; | ||
22587 | Stack.prototype.has = stackHas; | ||
22588 | Stack.prototype.set = stackSet; | ||
22589 | |||
22590 | module.exports = Stack; | ||
22591 | |||
22592 | },{"./_ListCache":145,"./_stackClear":292,"./_stackDelete":293,"./_stackGet":294,"./_stackHas":295,"./_stackSet":296}],152:[function(require,module,exports){ | ||
22593 | var root = require('./_root'); | ||
22594 | |||
22595 | /** Built-in value references. */ | ||
22596 | var Symbol = root.Symbol; | ||
22597 | |||
22598 | module.exports = Symbol; | ||
22599 | |||
22600 | },{"./_root":286}],153:[function(require,module,exports){ | ||
22601 | var root = require('./_root'); | ||
22602 | |||
22603 | /** Built-in value references. */ | ||
22604 | var Uint8Array = root.Uint8Array; | ||
22605 | |||
22606 | module.exports = Uint8Array; | ||
22607 | |||
22608 | },{"./_root":286}],154:[function(require,module,exports){ | ||
22609 | var getNative = require('./_getNative'), | ||
22610 | root = require('./_root'); | ||
22611 | |||
22612 | /* Built-in method references that are verified to be native. */ | ||
22613 | var WeakMap = getNative(root, 'WeakMap'); | ||
22614 | |||
22615 | module.exports = WeakMap; | ||
22616 | |||
22617 | },{"./_getNative":241,"./_root":286}],155:[function(require,module,exports){ | ||
22618 | /** | ||
22619 | * A faster alternative to `Function#apply`, this function invokes `func` | ||
22620 | * with the `this` binding of `thisArg` and the arguments of `args`. | ||
22621 | * | ||
22622 | * @private | ||
22623 | * @param {Function} func The function to invoke. | ||
22624 | * @param {*} thisArg The `this` binding of `func`. | ||
22625 | * @param {Array} args The arguments to invoke `func` with. | ||
22626 | * @returns {*} Returns the result of `func`. | ||
22627 | */ | ||
22628 | function apply(func, thisArg, args) { | ||
22629 | switch (args.length) { | ||
22630 | case 0: return func.call(thisArg); | ||
22631 | case 1: return func.call(thisArg, args[0]); | ||
22632 | case 2: return func.call(thisArg, args[0], args[1]); | ||
22633 | case 3: return func.call(thisArg, args[0], args[1], args[2]); | ||
22634 | } | ||
22635 | return func.apply(thisArg, args); | ||
22636 | } | ||
22637 | |||
22638 | module.exports = apply; | ||
22639 | |||
22640 | },{}],156:[function(require,module,exports){ | ||
22641 | /** | ||
22642 | * A specialized version of `_.forEach` for arrays without support for | ||
22643 | * iteratee shorthands. | ||
22644 | * | ||
22645 | * @private | ||
22646 | * @param {Array} [array] The array to iterate over. | ||
22647 | * @param {Function} iteratee The function invoked per iteration. | ||
22648 | * @returns {Array} Returns `array`. | ||
22649 | */ | ||
22650 | function arrayEach(array, iteratee) { | ||
22651 | var index = -1, | ||
22652 | length = array == null ? 0 : array.length; | ||
22653 | |||
22654 | while (++index < length) { | ||
22655 | if (iteratee(array[index], index, array) === false) { | ||
22656 | break; | ||
22657 | } | ||
22658 | } | ||
22659 | return array; | ||
22660 | } | ||
22661 | |||
22662 | module.exports = arrayEach; | ||
22663 | |||
22664 | },{}],157:[function(require,module,exports){ | ||
22665 | /** | ||
22666 | * A specialized version of `_.every` for arrays without support for | ||
22667 | * iteratee shorthands. | ||
22668 | * | ||
22669 | * @private | ||
22670 | * @param {Array} [array] The array to iterate over. | ||
22671 | * @param {Function} predicate The function invoked per iteration. | ||
22672 | * @returns {boolean} Returns `true` if all elements pass the predicate check, | ||
22673 | * else `false`. | ||
22674 | */ | ||
22675 | function arrayEvery(array, predicate) { | ||
22676 | var index = -1, | ||
22677 | length = array == null ? 0 : array.length; | ||
22678 | |||
22679 | while (++index < length) { | ||
22680 | if (!predicate(array[index], index, array)) { | ||
22681 | return false; | ||
22682 | } | ||
22683 | } | ||
22684 | return true; | ||
22685 | } | ||
22686 | |||
22687 | module.exports = arrayEvery; | ||
22688 | |||
22689 | },{}],158:[function(require,module,exports){ | ||
22690 | /** | ||
22691 | * A specialized version of `_.filter` for arrays without support for | ||
22692 | * iteratee shorthands. | ||
22693 | * | ||
22694 | * @private | ||
22695 | * @param {Array} [array] The array to iterate over. | ||
22696 | * @param {Function} predicate The function invoked per iteration. | ||
22697 | * @returns {Array} Returns the new filtered array. | ||
22698 | */ | ||
22699 | function arrayFilter(array, predicate) { | ||
22700 | var index = -1, | ||
22701 | length = array == null ? 0 : array.length, | ||
22702 | resIndex = 0, | ||
22703 | result = []; | ||
22704 | |||
22705 | while (++index < length) { | ||
22706 | var value = array[index]; | ||
22707 | if (predicate(value, index, array)) { | ||
22708 | result[resIndex++] = value; | ||
22709 | } | ||
22710 | } | ||
22711 | return result; | ||
22712 | } | ||
22713 | |||
22714 | module.exports = arrayFilter; | ||
22715 | |||
22716 | },{}],159:[function(require,module,exports){ | ||
22717 | var baseTimes = require('./_baseTimes'), | ||
22718 | isArguments = require('./isArguments'), | ||
22719 | isArray = require('./isArray'), | ||
22720 | isBuffer = require('./isBuffer'), | ||
22721 | isIndex = require('./_isIndex'), | ||
22722 | isTypedArray = require('./isTypedArray'); | ||
22723 | |||
22724 | /** Used for built-in method references. */ | ||
22725 | var objectProto = Object.prototype; | ||
22726 | |||
22727 | /** Used to check objects for own properties. */ | ||
22728 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
22729 | |||
22730 | /** | ||
22731 | * Creates an array of the enumerable property names of the array-like `value`. | ||
22732 | * | ||
22733 | * @private | ||
22734 | * @param {*} value The value to query. | ||
22735 | * @param {boolean} inherited Specify returning inherited property names. | ||
22736 | * @returns {Array} Returns the array of property names. | ||
22737 | */ | ||
22738 | function arrayLikeKeys(value, inherited) { | ||
22739 | var isArr = isArray(value), | ||
22740 | isArg = !isArr && isArguments(value), | ||
22741 | isBuff = !isArr && !isArg && isBuffer(value), | ||
22742 | isType = !isArr && !isArg && !isBuff && isTypedArray(value), | ||
22743 | skipIndexes = isArr || isArg || isBuff || isType, | ||
22744 | result = skipIndexes ? baseTimes(value.length, String) : [], | ||
22745 | length = result.length; | ||
22746 | |||
22747 | for (var key in value) { | ||
22748 | if ((inherited || hasOwnProperty.call(value, key)) && | ||
22749 | !(skipIndexes && ( | ||
22750 | // Safari 9 has enumerable `arguments.length` in strict mode. | ||
22751 | key == 'length' || | ||
22752 | // Node.js 0.10 has enumerable non-index properties on buffers. | ||
22753 | (isBuff && (key == 'offset' || key == 'parent')) || | ||
22754 | // PhantomJS 2 has enumerable non-index properties on typed arrays. | ||
22755 | (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || | ||
22756 | // Skip index properties. | ||
22757 | isIndex(key, length) | ||
22758 | ))) { | ||
22759 | result.push(key); | ||
22760 | } | ||
22761 | } | ||
22762 | return result; | ||
22763 | } | ||
22764 | |||
22765 | module.exports = arrayLikeKeys; | ||
22766 | |||
22767 | },{"./_baseTimes":207,"./_isIndex":259,"./isArguments":318,"./isArray":319,"./isBuffer":322,"./isTypedArray":335}],160:[function(require,module,exports){ | ||
22768 | /** | ||
22769 | * A specialized version of `_.map` for arrays without support for iteratee | ||
22770 | * shorthands. | ||
22771 | * | ||
22772 | * @private | ||
22773 | * @param {Array} [array] The array to iterate over. | ||
22774 | * @param {Function} iteratee The function invoked per iteration. | ||
22775 | * @returns {Array} Returns the new mapped array. | ||
22776 | */ | ||
22777 | function arrayMap(array, iteratee) { | ||
22778 | var index = -1, | ||
22779 | length = array == null ? 0 : array.length, | ||
22780 | result = Array(length); | ||
22781 | |||
22782 | while (++index < length) { | ||
22783 | result[index] = iteratee(array[index], index, array); | ||
22784 | } | ||
22785 | return result; | ||
22786 | } | ||
22787 | |||
22788 | module.exports = arrayMap; | ||
22789 | |||
22790 | },{}],161:[function(require,module,exports){ | ||
22791 | /** | ||
22792 | * Appends the elements of `values` to `array`. | ||
22793 | * | ||
22794 | * @private | ||
22795 | * @param {Array} array The array to modify. | ||
22796 | * @param {Array} values The values to append. | ||
22797 | * @returns {Array} Returns `array`. | ||
22798 | */ | ||
22799 | function arrayPush(array, values) { | ||
22800 | var index = -1, | ||
22801 | length = values.length, | ||
22802 | offset = array.length; | ||
22803 | |||
22804 | while (++index < length) { | ||
22805 | array[offset + index] = values[index]; | ||
22806 | } | ||
22807 | return array; | ||
22808 | } | ||
22809 | |||
22810 | module.exports = arrayPush; | ||
22811 | |||
22812 | },{}],162:[function(require,module,exports){ | ||
22813 | /** | ||
22814 | * A specialized version of `_.some` for arrays without support for iteratee | ||
22815 | * shorthands. | ||
22816 | * | ||
22817 | * @private | ||
22818 | * @param {Array} [array] The array to iterate over. | ||
22819 | * @param {Function} predicate The function invoked per iteration. | ||
22820 | * @returns {boolean} Returns `true` if any element passes the predicate check, | ||
22821 | * else `false`. | ||
22822 | */ | ||
22823 | function arraySome(array, predicate) { | ||
22824 | var index = -1, | ||
22825 | length = array == null ? 0 : array.length; | ||
22826 | |||
22827 | while (++index < length) { | ||
22828 | if (predicate(array[index], index, array)) { | ||
22829 | return true; | ||
22830 | } | ||
22831 | } | ||
22832 | return false; | ||
22833 | } | ||
22834 | |||
22835 | module.exports = arraySome; | ||
22836 | |||
22837 | },{}],163:[function(require,module,exports){ | ||
22838 | var baseProperty = require('./_baseProperty'); | ||
22839 | |||
22840 | /** | ||
22841 | * Gets the size of an ASCII `string`. | ||
22842 | * | ||
22843 | * @private | ||
22844 | * @param {string} string The string inspect. | ||
22845 | * @returns {number} Returns the string size. | ||
22846 | */ | ||
22847 | var asciiSize = baseProperty('length'); | ||
22848 | |||
22849 | module.exports = asciiSize; | ||
22850 | |||
22851 | },{"./_baseProperty":200}],164:[function(require,module,exports){ | ||
22852 | /** | ||
22853 | * Converts an ASCII `string` to an array. | ||
22854 | * | ||
22855 | * @private | ||
22856 | * @param {string} string The string to convert. | ||
22857 | * @returns {Array} Returns the converted array. | ||
22858 | */ | ||
22859 | function asciiToArray(string) { | ||
22860 | return string.split(''); | ||
22861 | } | ||
22862 | |||
22863 | module.exports = asciiToArray; | ||
22864 | |||
22865 | },{}],165:[function(require,module,exports){ | ||
22866 | var baseAssignValue = require('./_baseAssignValue'), | ||
22867 | eq = require('./eq'); | ||
22868 | |||
22869 | /** Used for built-in method references. */ | ||
22870 | var objectProto = Object.prototype; | ||
22871 | |||
22872 | /** Used to check objects for own properties. */ | ||
22873 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
22874 | |||
22875 | /** | ||
22876 | * Assigns `value` to `key` of `object` if the existing value is not equivalent | ||
22877 | * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) | ||
22878 | * for equality comparisons. | ||
22879 | * | ||
22880 | * @private | ||
22881 | * @param {Object} object The object to modify. | ||
22882 | * @param {string} key The key of the property to assign. | ||
22883 | * @param {*} value The value to assign. | ||
22884 | */ | ||
22885 | function assignValue(object, key, value) { | ||
22886 | var objValue = object[key]; | ||
22887 | if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || | ||
22888 | (value === undefined && !(key in object))) { | ||
22889 | baseAssignValue(object, key, value); | ||
22890 | } | ||
22891 | } | ||
22892 | |||
22893 | module.exports = assignValue; | ||
22894 | |||
22895 | },{"./_baseAssignValue":169,"./eq":309}],166:[function(require,module,exports){ | ||
22896 | var eq = require('./eq'); | ||
22897 | |||
22898 | /** | ||
22899 | * Gets the index at which the `key` is found in `array` of key-value pairs. | ||
22900 | * | ||
22901 | * @private | ||
22902 | * @param {Array} array The array to inspect. | ||
22903 | * @param {*} key The key to search for. | ||
22904 | * @returns {number} Returns the index of the matched value, else `-1`. | ||
22905 | */ | ||
22906 | function assocIndexOf(array, key) { | ||
22907 | var length = array.length; | ||
22908 | while (length--) { | ||
22909 | if (eq(array[length][0], key)) { | ||
22910 | return length; | ||
22911 | } | ||
22912 | } | ||
22913 | return -1; | ||
22914 | } | ||
22915 | |||
22916 | module.exports = assocIndexOf; | ||
22917 | |||
22918 | },{"./eq":309}],167:[function(require,module,exports){ | ||
22919 | var copyObject = require('./_copyObject'), | ||
22920 | keys = require('./keys'); | ||
22921 | |||
22922 | /** | ||
22923 | * The base implementation of `_.assign` without support for multiple sources | ||
22924 | * or `customizer` functions. | ||
22925 | * | ||
22926 | * @private | ||
22927 | * @param {Object} object The destination object. | ||
22928 | * @param {Object} source The source object. | ||
22929 | * @returns {Object} Returns `object`. | ||
22930 | */ | ||
22931 | function baseAssign(object, source) { | ||
22932 | return object && copyObject(source, keys(source), object); | ||
22933 | } | ||
22934 | |||
22935 | module.exports = baseAssign; | ||
22936 | |||
22937 | },{"./_copyObject":223,"./keys":337}],168:[function(require,module,exports){ | ||
22938 | var copyObject = require('./_copyObject'), | ||
22939 | keysIn = require('./keysIn'); | ||
22940 | |||
22941 | /** | ||
22942 | * The base implementation of `_.assignIn` without support for multiple sources | ||
22943 | * or `customizer` functions. | ||
22944 | * | ||
22945 | * @private | ||
22946 | * @param {Object} object The destination object. | ||
22947 | * @param {Object} source The source object. | ||
22948 | * @returns {Object} Returns `object`. | ||
22949 | */ | ||
22950 | function baseAssignIn(object, source) { | ||
22951 | return object && copyObject(source, keysIn(source), object); | ||
22952 | } | ||
22953 | |||
22954 | module.exports = baseAssignIn; | ||
22955 | |||
22956 | },{"./_copyObject":223,"./keysIn":338}],169:[function(require,module,exports){ | ||
22957 | var defineProperty = require('./_defineProperty'); | ||
22958 | |||
22959 | /** | ||
22960 | * The base implementation of `assignValue` and `assignMergeValue` without | ||
22961 | * value checks. | ||
22962 | * | ||
22963 | * @private | ||
22964 | * @param {Object} object The object to modify. | ||
22965 | * @param {string} key The key of the property to assign. | ||
22966 | * @param {*} value The value to assign. | ||
22967 | */ | ||
22968 | function baseAssignValue(object, key, value) { | ||
22969 | if (key == '__proto__' && defineProperty) { | ||
22970 | defineProperty(object, key, { | ||
22971 | 'configurable': true, | ||
22972 | 'enumerable': true, | ||
22973 | 'value': value, | ||
22974 | 'writable': true | ||
22975 | }); | ||
22976 | } else { | ||
22977 | object[key] = value; | ||
22978 | } | ||
22979 | } | ||
22980 | |||
22981 | module.exports = baseAssignValue; | ||
22982 | |||
22983 | },{"./_defineProperty":231}],170:[function(require,module,exports){ | ||
22984 | var Stack = require('./_Stack'), | ||
22985 | arrayEach = require('./_arrayEach'), | ||
22986 | assignValue = require('./_assignValue'), | ||
22987 | baseAssign = require('./_baseAssign'), | ||
22988 | baseAssignIn = require('./_baseAssignIn'), | ||
22989 | cloneBuffer = require('./_cloneBuffer'), | ||
22990 | copyArray = require('./_copyArray'), | ||
22991 | copySymbols = require('./_copySymbols'), | ||
22992 | copySymbolsIn = require('./_copySymbolsIn'), | ||
22993 | getAllKeys = require('./_getAllKeys'), | ||
22994 | getAllKeysIn = require('./_getAllKeysIn'), | ||
22995 | getTag = require('./_getTag'), | ||
22996 | initCloneArray = require('./_initCloneArray'), | ||
22997 | initCloneByTag = require('./_initCloneByTag'), | ||
22998 | initCloneObject = require('./_initCloneObject'), | ||
22999 | isArray = require('./isArray'), | ||
23000 | isBuffer = require('./isBuffer'), | ||
23001 | isMap = require('./isMap'), | ||
23002 | isObject = require('./isObject'), | ||
23003 | isSet = require('./isSet'), | ||
23004 | keys = require('./keys'); | ||
23005 | |||
23006 | /** Used to compose bitmasks for cloning. */ | ||
23007 | var CLONE_DEEP_FLAG = 1, | ||
23008 | CLONE_FLAT_FLAG = 2, | ||
23009 | CLONE_SYMBOLS_FLAG = 4; | ||
23010 | |||
23011 | /** `Object#toString` result references. */ | ||
23012 | var argsTag = '[object Arguments]', | ||
23013 | arrayTag = '[object Array]', | ||
23014 | boolTag = '[object Boolean]', | ||
23015 | dateTag = '[object Date]', | ||
23016 | errorTag = '[object Error]', | ||
23017 | funcTag = '[object Function]', | ||
23018 | genTag = '[object GeneratorFunction]', | ||
23019 | mapTag = '[object Map]', | ||
23020 | numberTag = '[object Number]', | ||
23021 | objectTag = '[object Object]', | ||
23022 | regexpTag = '[object RegExp]', | ||
23023 | setTag = '[object Set]', | ||
23024 | stringTag = '[object String]', | ||
23025 | symbolTag = '[object Symbol]', | ||
23026 | weakMapTag = '[object WeakMap]'; | ||
23027 | |||
23028 | var arrayBufferTag = '[object ArrayBuffer]', | ||
23029 | dataViewTag = '[object DataView]', | ||
23030 | float32Tag = '[object Float32Array]', | ||
23031 | float64Tag = '[object Float64Array]', | ||
23032 | int8Tag = '[object Int8Array]', | ||
23033 | int16Tag = '[object Int16Array]', | ||
23034 | int32Tag = '[object Int32Array]', | ||
23035 | uint8Tag = '[object Uint8Array]', | ||
23036 | uint8ClampedTag = '[object Uint8ClampedArray]', | ||
23037 | uint16Tag = '[object Uint16Array]', | ||
23038 | uint32Tag = '[object Uint32Array]'; | ||
23039 | |||
23040 | /** Used to identify `toStringTag` values supported by `_.clone`. */ | ||
23041 | var cloneableTags = {}; | ||
23042 | cloneableTags[argsTag] = cloneableTags[arrayTag] = | ||
23043 | cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = | ||
23044 | cloneableTags[boolTag] = cloneableTags[dateTag] = | ||
23045 | cloneableTags[float32Tag] = cloneableTags[float64Tag] = | ||
23046 | cloneableTags[int8Tag] = cloneableTags[int16Tag] = | ||
23047 | cloneableTags[int32Tag] = cloneableTags[mapTag] = | ||
23048 | cloneableTags[numberTag] = cloneableTags[objectTag] = | ||
23049 | cloneableTags[regexpTag] = cloneableTags[setTag] = | ||
23050 | cloneableTags[stringTag] = cloneableTags[symbolTag] = | ||
23051 | cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = | ||
23052 | cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; | ||
23053 | cloneableTags[errorTag] = cloneableTags[funcTag] = | ||
23054 | cloneableTags[weakMapTag] = false; | ||
23055 | |||
23056 | /** | ||
23057 | * The base implementation of `_.clone` and `_.cloneDeep` which tracks | ||
23058 | * traversed objects. | ||
23059 | * | ||
23060 | * @private | ||
23061 | * @param {*} value The value to clone. | ||
23062 | * @param {boolean} bitmask The bitmask flags. | ||
23063 | * 1 - Deep clone | ||
23064 | * 2 - Flatten inherited properties | ||
23065 | * 4 - Clone symbols | ||
23066 | * @param {Function} [customizer] The function to customize cloning. | ||
23067 | * @param {string} [key] The key of `value`. | ||
23068 | * @param {Object} [object] The parent object of `value`. | ||
23069 | * @param {Object} [stack] Tracks traversed objects and their clone counterparts. | ||
23070 | * @returns {*} Returns the cloned value. | ||
23071 | */ | ||
23072 | function baseClone(value, bitmask, customizer, key, object, stack) { | ||
23073 | var result, | ||
23074 | isDeep = bitmask & CLONE_DEEP_FLAG, | ||
23075 | isFlat = bitmask & CLONE_FLAT_FLAG, | ||
23076 | isFull = bitmask & CLONE_SYMBOLS_FLAG; | ||
23077 | |||
23078 | if (customizer) { | ||
23079 | result = object ? customizer(value, key, object, stack) : customizer(value); | ||
23080 | } | ||
23081 | if (result !== undefined) { | ||
23082 | return result; | ||
23083 | } | ||
23084 | if (!isObject(value)) { | ||
23085 | return value; | ||
23086 | } | ||
23087 | var isArr = isArray(value); | ||
23088 | if (isArr) { | ||
23089 | result = initCloneArray(value); | ||
23090 | if (!isDeep) { | ||
23091 | return copyArray(value, result); | ||
23092 | } | ||
23093 | } else { | ||
23094 | var tag = getTag(value), | ||
23095 | isFunc = tag == funcTag || tag == genTag; | ||
23096 | |||
23097 | if (isBuffer(value)) { | ||
23098 | return cloneBuffer(value, isDeep); | ||
23099 | } | ||
23100 | if (tag == objectTag || tag == argsTag || (isFunc && !object)) { | ||
23101 | result = (isFlat || isFunc) ? {} : initCloneObject(value); | ||
23102 | if (!isDeep) { | ||
23103 | return isFlat | ||
23104 | ? copySymbolsIn(value, baseAssignIn(result, value)) | ||
23105 | : copySymbols(value, baseAssign(result, value)); | ||
23106 | } | ||
23107 | } else { | ||
23108 | if (!cloneableTags[tag]) { | ||
23109 | return object ? value : {}; | ||
23110 | } | ||
23111 | result = initCloneByTag(value, tag, isDeep); | ||
23112 | } | ||
23113 | } | ||
23114 | // Check for circular references and return its corresponding clone. | ||
23115 | stack || (stack = new Stack); | ||
23116 | var stacked = stack.get(value); | ||
23117 | if (stacked) { | ||
23118 | return stacked; | ||
23119 | } | ||
23120 | stack.set(value, result); | ||
23121 | |||
23122 | if (isSet(value)) { | ||
23123 | value.forEach(function(subValue) { | ||
23124 | result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); | ||
23125 | }); | ||
23126 | |||
23127 | return result; | ||
23128 | } | ||
23129 | |||
23130 | if (isMap(value)) { | ||
23131 | value.forEach(function(subValue, key) { | ||
23132 | result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); | ||
23133 | }); | ||
23134 | |||
23135 | return result; | ||
23136 | } | ||
23137 | |||
23138 | var keysFunc = isFull | ||
23139 | ? (isFlat ? getAllKeysIn : getAllKeys) | ||
23140 | : (isFlat ? keysIn : keys); | ||
23141 | |||
23142 | var props = isArr ? undefined : keysFunc(value); | ||
23143 | arrayEach(props || value, function(subValue, key) { | ||
23144 | if (props) { | ||
23145 | key = subValue; | ||
23146 | subValue = value[key]; | ||
23147 | } | ||
23148 | // Recursively populate clone (susceptible to call stack limits). | ||
23149 | assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); | ||
23150 | }); | ||
23151 | return result; | ||
23152 | } | ||
23153 | |||
23154 | module.exports = baseClone; | ||
23155 | |||
23156 | },{"./_Stack":151,"./_arrayEach":156,"./_assignValue":165,"./_baseAssign":167,"./_baseAssignIn":168,"./_cloneBuffer":217,"./_copyArray":222,"./_copySymbols":224,"./_copySymbolsIn":225,"./_getAllKeys":237,"./_getAllKeysIn":238,"./_getTag":246,"./_initCloneArray":255,"./_initCloneByTag":256,"./_initCloneObject":257,"./isArray":319,"./isBuffer":322,"./isMap":326,"./isObject":329,"./isSet":332,"./keys":337}],171:[function(require,module,exports){ | ||
23157 | var isObject = require('./isObject'); | ||
23158 | |||
23159 | /** Built-in value references. */ | ||
23160 | var objectCreate = Object.create; | ||
23161 | |||
23162 | /** | ||
23163 | * The base implementation of `_.create` without support for assigning | ||
23164 | * properties to the created object. | ||
23165 | * | ||
23166 | * @private | ||
23167 | * @param {Object} proto The object to inherit from. | ||
23168 | * @returns {Object} Returns the new object. | ||
23169 | */ | ||
23170 | var baseCreate = (function() { | ||
23171 | function object() {} | ||
23172 | return function(proto) { | ||
23173 | if (!isObject(proto)) { | ||
23174 | return {}; | ||
23175 | } | ||
23176 | if (objectCreate) { | ||
23177 | return objectCreate(proto); | ||
23178 | } | ||
23179 | object.prototype = proto; | ||
23180 | var result = new object; | ||
23181 | object.prototype = undefined; | ||
23182 | return result; | ||
23183 | }; | ||
23184 | }()); | ||
23185 | |||
23186 | module.exports = baseCreate; | ||
23187 | |||
23188 | },{"./isObject":329}],172:[function(require,module,exports){ | ||
23189 | var baseForOwn = require('./_baseForOwn'), | ||
23190 | createBaseEach = require('./_createBaseEach'); | ||
23191 | |||
23192 | /** | ||
23193 | * The base implementation of `_.forEach` without support for iteratee shorthands. | ||
23194 | * | ||
23195 | * @private | ||
23196 | * @param {Array|Object} collection The collection to iterate over. | ||
23197 | * @param {Function} iteratee The function invoked per iteration. | ||
23198 | * @returns {Array|Object} Returns `collection`. | ||
23199 | */ | ||
23200 | var baseEach = createBaseEach(baseForOwn); | ||
23201 | |||
23202 | module.exports = baseEach; | ||
23203 | |||
23204 | },{"./_baseForOwn":177,"./_createBaseEach":228}],173:[function(require,module,exports){ | ||
23205 | var baseEach = require('./_baseEach'); | ||
23206 | |||
23207 | /** | ||
23208 | * The base implementation of `_.every` without support for iteratee shorthands. | ||
23209 | * | ||
23210 | * @private | ||
23211 | * @param {Array|Object} collection The collection to iterate over. | ||
23212 | * @param {Function} predicate The function invoked per iteration. | ||
23213 | * @returns {boolean} Returns `true` if all elements pass the predicate check, | ||
23214 | * else `false` | ||
23215 | */ | ||
23216 | function baseEvery(collection, predicate) { | ||
23217 | var result = true; | ||
23218 | baseEach(collection, function(value, index, collection) { | ||
23219 | result = !!predicate(value, index, collection); | ||
23220 | return result; | ||
23221 | }); | ||
23222 | return result; | ||
23223 | } | ||
23224 | |||
23225 | module.exports = baseEvery; | ||
23226 | |||
23227 | },{"./_baseEach":172}],174:[function(require,module,exports){ | ||
23228 | /** | ||
23229 | * The base implementation of `_.findIndex` and `_.findLastIndex` without | ||
23230 | * support for iteratee shorthands. | ||
23231 | * | ||
23232 | * @private | ||
23233 | * @param {Array} array The array to inspect. | ||
23234 | * @param {Function} predicate The function invoked per iteration. | ||
23235 | * @param {number} fromIndex The index to search from. | ||
23236 | * @param {boolean} [fromRight] Specify iterating from right to left. | ||
23237 | * @returns {number} Returns the index of the matched value, else `-1`. | ||
23238 | */ | ||
23239 | function baseFindIndex(array, predicate, fromIndex, fromRight) { | ||
23240 | var length = array.length, | ||
23241 | index = fromIndex + (fromRight ? 1 : -1); | ||
23242 | |||
23243 | while ((fromRight ? index-- : ++index < length)) { | ||
23244 | if (predicate(array[index], index, array)) { | ||
23245 | return index; | ||
23246 | } | ||
23247 | } | ||
23248 | return -1; | ||
23249 | } | ||
23250 | |||
23251 | module.exports = baseFindIndex; | ||
23252 | |||
23253 | },{}],175:[function(require,module,exports){ | ||
23254 | var arrayPush = require('./_arrayPush'), | ||
23255 | isFlattenable = require('./_isFlattenable'); | ||
23256 | |||
23257 | /** | ||
23258 | * The base implementation of `_.flatten` with support for restricting flattening. | ||
23259 | * | ||
23260 | * @private | ||
23261 | * @param {Array} array The array to flatten. | ||
23262 | * @param {number} depth The maximum recursion depth. | ||
23263 | * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. | ||
23264 | * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. | ||
23265 | * @param {Array} [result=[]] The initial result value. | ||
23266 | * @returns {Array} Returns the new flattened array. | ||
23267 | */ | ||
23268 | function baseFlatten(array, depth, predicate, isStrict, result) { | ||
23269 | var index = -1, | ||
23270 | length = array.length; | ||
23271 | |||
23272 | predicate || (predicate = isFlattenable); | ||
23273 | result || (result = []); | ||
23274 | |||
23275 | while (++index < length) { | ||
23276 | var value = array[index]; | ||
23277 | if (depth > 0 && predicate(value)) { | ||
23278 | if (depth > 1) { | ||
23279 | // Recursively flatten arrays (susceptible to call stack limits). | ||
23280 | baseFlatten(value, depth - 1, predicate, isStrict, result); | ||
23281 | } else { | ||
23282 | arrayPush(result, value); | ||
23283 | } | ||
23284 | } else if (!isStrict) { | ||
23285 | result[result.length] = value; | ||
23286 | } | ||
23287 | } | ||
23288 | return result; | ||
23289 | } | ||
23290 | |||
23291 | module.exports = baseFlatten; | ||
23292 | |||
23293 | },{"./_arrayPush":161,"./_isFlattenable":258}],176:[function(require,module,exports){ | ||
23294 | var createBaseFor = require('./_createBaseFor'); | ||
23295 | |||
23296 | /** | ||
23297 | * The base implementation of `baseForOwn` which iterates over `object` | ||
23298 | * properties returned by `keysFunc` and invokes `iteratee` for each property. | ||
23299 | * Iteratee functions may exit iteration early by explicitly returning `false`. | ||
23300 | * | ||
23301 | * @private | ||
23302 | * @param {Object} object The object to iterate over. | ||
23303 | * @param {Function} iteratee The function invoked per iteration. | ||
23304 | * @param {Function} keysFunc The function to get the keys of `object`. | ||
23305 | * @returns {Object} Returns `object`. | ||
23306 | */ | ||
23307 | var baseFor = createBaseFor(); | ||
23308 | |||
23309 | module.exports = baseFor; | ||
23310 | |||
23311 | },{"./_createBaseFor":229}],177:[function(require,module,exports){ | ||
23312 | var baseFor = require('./_baseFor'), | ||
23313 | keys = require('./keys'); | ||
23314 | |||
23315 | /** | ||
23316 | * The base implementation of `_.forOwn` without support for iteratee shorthands. | ||
23317 | * | ||
23318 | * @private | ||
23319 | * @param {Object} object The object to iterate over. | ||
23320 | * @param {Function} iteratee The function invoked per iteration. | ||
23321 | * @returns {Object} Returns `object`. | ||
23322 | */ | ||
23323 | function baseForOwn(object, iteratee) { | ||
23324 | return object && baseFor(object, iteratee, keys); | ||
23325 | } | ||
23326 | |||
23327 | module.exports = baseForOwn; | ||
23328 | |||
23329 | },{"./_baseFor":176,"./keys":337}],178:[function(require,module,exports){ | ||
23330 | var castPath = require('./_castPath'), | ||
23331 | toKey = require('./_toKey'); | ||
23332 | |||
23333 | /** | ||
23334 | * The base implementation of `_.get` without support for default values. | ||
23335 | * | ||
23336 | * @private | ||
23337 | * @param {Object} object The object to query. | ||
23338 | * @param {Array|string} path The path of the property to get. | ||
23339 | * @returns {*} Returns the resolved value. | ||
23340 | */ | ||
23341 | function baseGet(object, path) { | ||
23342 | path = castPath(path, object); | ||
23343 | |||
23344 | var index = 0, | ||
23345 | length = path.length; | ||
23346 | |||
23347 | while (object != null && index < length) { | ||
23348 | object = object[toKey(path[index++])]; | ||
23349 | } | ||
23350 | return (index && index == length) ? object : undefined; | ||
23351 | } | ||
23352 | |||
23353 | module.exports = baseGet; | ||
23354 | |||
23355 | },{"./_castPath":213,"./_toKey":301}],179:[function(require,module,exports){ | ||
23356 | var arrayPush = require('./_arrayPush'), | ||
23357 | isArray = require('./isArray'); | ||
23358 | |||
23359 | /** | ||
23360 | * The base implementation of `getAllKeys` and `getAllKeysIn` which uses | ||
23361 | * `keysFunc` and `symbolsFunc` to get the enumerable property names and | ||
23362 | * symbols of `object`. | ||
23363 | * | ||
23364 | * @private | ||
23365 | * @param {Object} object The object to query. | ||
23366 | * @param {Function} keysFunc The function to get the keys of `object`. | ||
23367 | * @param {Function} symbolsFunc The function to get the symbols of `object`. | ||
23368 | * @returns {Array} Returns the array of property names and symbols. | ||
23369 | */ | ||
23370 | function baseGetAllKeys(object, keysFunc, symbolsFunc) { | ||
23371 | var result = keysFunc(object); | ||
23372 | return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); | ||
23373 | } | ||
23374 | |||
23375 | module.exports = baseGetAllKeys; | ||
23376 | |||
23377 | },{"./_arrayPush":161,"./isArray":319}],180:[function(require,module,exports){ | ||
23378 | var Symbol = require('./_Symbol'), | ||
23379 | getRawTag = require('./_getRawTag'), | ||
23380 | objectToString = require('./_objectToString'); | ||
23381 | |||
23382 | /** `Object#toString` result references. */ | ||
23383 | var nullTag = '[object Null]', | ||
23384 | undefinedTag = '[object Undefined]'; | ||
23385 | |||
23386 | /** Built-in value references. */ | ||
23387 | var symToStringTag = Symbol ? Symbol.toStringTag : undefined; | ||
23388 | |||
23389 | /** | ||
23390 | * The base implementation of `getTag` without fallbacks for buggy environments. | ||
23391 | * | ||
23392 | * @private | ||
23393 | * @param {*} value The value to query. | ||
23394 | * @returns {string} Returns the `toStringTag`. | ||
23395 | */ | ||
23396 | function baseGetTag(value) { | ||
23397 | if (value == null) { | ||
23398 | return value === undefined ? undefinedTag : nullTag; | ||
23399 | } | ||
23400 | return (symToStringTag && symToStringTag in Object(value)) | ||
23401 | ? getRawTag(value) | ||
23402 | : objectToString(value); | ||
23403 | } | ||
23404 | |||
23405 | module.exports = baseGetTag; | ||
23406 | |||
23407 | },{"./_Symbol":152,"./_getRawTag":243,"./_objectToString":283}],181:[function(require,module,exports){ | ||
23408 | /** | ||
23409 | * The base implementation of `_.hasIn` without support for deep paths. | ||
23410 | * | ||
23411 | * @private | ||
23412 | * @param {Object} [object] The object to query. | ||
23413 | * @param {Array|string} key The key to check. | ||
23414 | * @returns {boolean} Returns `true` if `key` exists, else `false`. | ||
23415 | */ | ||
23416 | function baseHasIn(object, key) { | ||
23417 | return object != null && key in Object(object); | ||
23418 | } | ||
23419 | |||
23420 | module.exports = baseHasIn; | ||
23421 | |||
23422 | },{}],182:[function(require,module,exports){ | ||
23423 | var baseFindIndex = require('./_baseFindIndex'), | ||
23424 | baseIsNaN = require('./_baseIsNaN'), | ||
23425 | strictIndexOf = require('./_strictIndexOf'); | ||
23426 | |||
23427 | /** | ||
23428 | * The base implementation of `_.indexOf` without `fromIndex` bounds checks. | ||
23429 | * | ||
23430 | * @private | ||
23431 | * @param {Array} array The array to inspect. | ||
23432 | * @param {*} value The value to search for. | ||
23433 | * @param {number} fromIndex The index to search from. | ||
23434 | * @returns {number} Returns the index of the matched value, else `-1`. | ||
23435 | */ | ||
23436 | function baseIndexOf(array, value, fromIndex) { | ||
23437 | return value === value | ||
23438 | ? strictIndexOf(array, value, fromIndex) | ||
23439 | : baseFindIndex(array, baseIsNaN, fromIndex); | ||
23440 | } | ||
23441 | |||
23442 | module.exports = baseIndexOf; | ||
23443 | |||
23444 | },{"./_baseFindIndex":174,"./_baseIsNaN":188,"./_strictIndexOf":297}],183:[function(require,module,exports){ | ||
23445 | var baseGetTag = require('./_baseGetTag'), | ||
23446 | isObjectLike = require('./isObjectLike'); | ||
23447 | |||
23448 | /** `Object#toString` result references. */ | ||
23449 | var argsTag = '[object Arguments]'; | ||
23450 | |||
23451 | /** | ||
23452 | * The base implementation of `_.isArguments`. | ||
23453 | * | ||
23454 | * @private | ||
23455 | * @param {*} value The value to check. | ||
23456 | * @returns {boolean} Returns `true` if `value` is an `arguments` object, | ||
23457 | */ | ||
23458 | function baseIsArguments(value) { | ||
23459 | return isObjectLike(value) && baseGetTag(value) == argsTag; | ||
23460 | } | ||
23461 | |||
23462 | module.exports = baseIsArguments; | ||
23463 | |||
23464 | },{"./_baseGetTag":180,"./isObjectLike":330}],184:[function(require,module,exports){ | ||
23465 | var baseIsEqualDeep = require('./_baseIsEqualDeep'), | ||
23466 | isObjectLike = require('./isObjectLike'); | ||
23467 | |||
23468 | /** | ||
23469 | * The base implementation of `_.isEqual` which supports partial comparisons | ||
23470 | * and tracks traversed objects. | ||
23471 | * | ||
23472 | * @private | ||
23473 | * @param {*} value The value to compare. | ||
23474 | * @param {*} other The other value to compare. | ||
23475 | * @param {boolean} bitmask The bitmask flags. | ||
23476 | * 1 - Unordered comparison | ||
23477 | * 2 - Partial comparison | ||
23478 | * @param {Function} [customizer] The function to customize comparisons. | ||
23479 | * @param {Object} [stack] Tracks traversed `value` and `other` objects. | ||
23480 | * @returns {boolean} Returns `true` if the values are equivalent, else `false`. | ||
23481 | */ | ||
23482 | function baseIsEqual(value, other, bitmask, customizer, stack) { | ||
23483 | if (value === other) { | ||
23484 | return true; | ||
23485 | } | ||
23486 | if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { | ||
23487 | return value !== value && other !== other; | ||
23488 | } | ||
23489 | return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); | ||
23490 | } | ||
23491 | |||
23492 | module.exports = baseIsEqual; | ||
23493 | |||
23494 | },{"./_baseIsEqualDeep":185,"./isObjectLike":330}],185:[function(require,module,exports){ | ||
23495 | var Stack = require('./_Stack'), | ||
23496 | equalArrays = require('./_equalArrays'), | ||
23497 | equalByTag = require('./_equalByTag'), | ||
23498 | equalObjects = require('./_equalObjects'), | ||
23499 | getTag = require('./_getTag'), | ||
23500 | isArray = require('./isArray'), | ||
23501 | isBuffer = require('./isBuffer'), | ||
23502 | isTypedArray = require('./isTypedArray'); | ||
23503 | |||
23504 | /** Used to compose bitmasks for value comparisons. */ | ||
23505 | var COMPARE_PARTIAL_FLAG = 1; | ||
23506 | |||
23507 | /** `Object#toString` result references. */ | ||
23508 | var argsTag = '[object Arguments]', | ||
23509 | arrayTag = '[object Array]', | ||
23510 | objectTag = '[object Object]'; | ||
23511 | |||
23512 | /** Used for built-in method references. */ | ||
23513 | var objectProto = Object.prototype; | ||
23514 | |||
23515 | /** Used to check objects for own properties. */ | ||
23516 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
23517 | |||
23518 | /** | ||
23519 | * A specialized version of `baseIsEqual` for arrays and objects which performs | ||
23520 | * deep comparisons and tracks traversed objects enabling objects with circular | ||
23521 | * references to be compared. | ||
23522 | * | ||
23523 | * @private | ||
23524 | * @param {Object} object The object to compare. | ||
23525 | * @param {Object} other The other object to compare. | ||
23526 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | ||
23527 | * @param {Function} customizer The function to customize comparisons. | ||
23528 | * @param {Function} equalFunc The function to determine equivalents of values. | ||
23529 | * @param {Object} [stack] Tracks traversed `object` and `other` objects. | ||
23530 | * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. | ||
23531 | */ | ||
23532 | function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { | ||
23533 | var objIsArr = isArray(object), | ||
23534 | othIsArr = isArray(other), | ||
23535 | objTag = objIsArr ? arrayTag : getTag(object), | ||
23536 | othTag = othIsArr ? arrayTag : getTag(other); | ||
23537 | |||
23538 | objTag = objTag == argsTag ? objectTag : objTag; | ||
23539 | othTag = othTag == argsTag ? objectTag : othTag; | ||
23540 | |||
23541 | var objIsObj = objTag == objectTag, | ||
23542 | othIsObj = othTag == objectTag, | ||
23543 | isSameTag = objTag == othTag; | ||
23544 | |||
23545 | if (isSameTag && isBuffer(object)) { | ||
23546 | if (!isBuffer(other)) { | ||
23547 | return false; | ||
23548 | } | ||
23549 | objIsArr = true; | ||
23550 | objIsObj = false; | ||
23551 | } | ||
23552 | if (isSameTag && !objIsObj) { | ||
23553 | stack || (stack = new Stack); | ||
23554 | return (objIsArr || isTypedArray(object)) | ||
23555 | ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) | ||
23556 | : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); | ||
23557 | } | ||
23558 | if (!(bitmask & COMPARE_PARTIAL_FLAG)) { | ||
23559 | var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), | ||
23560 | othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); | ||
23561 | |||
23562 | if (objIsWrapped || othIsWrapped) { | ||
23563 | var objUnwrapped = objIsWrapped ? object.value() : object, | ||
23564 | othUnwrapped = othIsWrapped ? other.value() : other; | ||
23565 | |||
23566 | stack || (stack = new Stack); | ||
23567 | return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); | ||
23568 | } | ||
23569 | } | ||
23570 | if (!isSameTag) { | ||
23571 | return false; | ||
23572 | } | ||
23573 | stack || (stack = new Stack); | ||
23574 | return equalObjects(object, other, bitmask, customizer, equalFunc, stack); | ||
23575 | } | ||
23576 | |||
23577 | module.exports = baseIsEqualDeep; | ||
23578 | |||
23579 | },{"./_Stack":151,"./_equalArrays":232,"./_equalByTag":233,"./_equalObjects":234,"./_getTag":246,"./isArray":319,"./isBuffer":322,"./isTypedArray":335}],186:[function(require,module,exports){ | ||
23580 | var getTag = require('./_getTag'), | ||
23581 | isObjectLike = require('./isObjectLike'); | ||
23582 | |||
23583 | /** `Object#toString` result references. */ | ||
23584 | var mapTag = '[object Map]'; | ||
23585 | |||
23586 | /** | ||
23587 | * The base implementation of `_.isMap` without Node.js optimizations. | ||
23588 | * | ||
23589 | * @private | ||
23590 | * @param {*} value The value to check. | ||
23591 | * @returns {boolean} Returns `true` if `value` is a map, else `false`. | ||
23592 | */ | ||
23593 | function baseIsMap(value) { | ||
23594 | return isObjectLike(value) && getTag(value) == mapTag; | ||
23595 | } | ||
23596 | |||
23597 | module.exports = baseIsMap; | ||
23598 | |||
23599 | },{"./_getTag":246,"./isObjectLike":330}],187:[function(require,module,exports){ | ||
23600 | var Stack = require('./_Stack'), | ||
23601 | baseIsEqual = require('./_baseIsEqual'); | ||
23602 | |||
23603 | /** Used to compose bitmasks for value comparisons. */ | ||
23604 | var COMPARE_PARTIAL_FLAG = 1, | ||
23605 | COMPARE_UNORDERED_FLAG = 2; | ||
23606 | |||
23607 | /** | ||
23608 | * The base implementation of `_.isMatch` without support for iteratee shorthands. | ||
23609 | * | ||
23610 | * @private | ||
23611 | * @param {Object} object The object to inspect. | ||
23612 | * @param {Object} source The object of property values to match. | ||
23613 | * @param {Array} matchData The property names, values, and compare flags to match. | ||
23614 | * @param {Function} [customizer] The function to customize comparisons. | ||
23615 | * @returns {boolean} Returns `true` if `object` is a match, else `false`. | ||
23616 | */ | ||
23617 | function baseIsMatch(object, source, matchData, customizer) { | ||
23618 | var index = matchData.length, | ||
23619 | length = index, | ||
23620 | noCustomizer = !customizer; | ||
23621 | |||
23622 | if (object == null) { | ||
23623 | return !length; | ||
23624 | } | ||
23625 | object = Object(object); | ||
23626 | while (index--) { | ||
23627 | var data = matchData[index]; | ||
23628 | if ((noCustomizer && data[2]) | ||
23629 | ? data[1] !== object[data[0]] | ||
23630 | : !(data[0] in object) | ||
23631 | ) { | ||
23632 | return false; | ||
23633 | } | ||
23634 | } | ||
23635 | while (++index < length) { | ||
23636 | data = matchData[index]; | ||
23637 | var key = data[0], | ||
23638 | objValue = object[key], | ||
23639 | srcValue = data[1]; | ||
23640 | |||
23641 | if (noCustomizer && data[2]) { | ||
23642 | if (objValue === undefined && !(key in object)) { | ||
23643 | return false; | ||
23644 | } | ||
23645 | } else { | ||
23646 | var stack = new Stack; | ||
23647 | if (customizer) { | ||
23648 | var result = customizer(objValue, srcValue, key, object, source, stack); | ||
23649 | } | ||
23650 | if (!(result === undefined | ||
23651 | ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) | ||
23652 | : result | ||
23653 | )) { | ||
23654 | return false; | ||
23655 | } | ||
23656 | } | ||
23657 | } | ||
23658 | return true; | ||
23659 | } | ||
23660 | |||
23661 | module.exports = baseIsMatch; | ||
23662 | |||
23663 | },{"./_Stack":151,"./_baseIsEqual":184}],188:[function(require,module,exports){ | ||
23664 | /** | ||
23665 | * The base implementation of `_.isNaN` without support for number objects. | ||
23666 | * | ||
23667 | * @private | ||
23668 | * @param {*} value The value to check. | ||
23669 | * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. | ||
23670 | */ | ||
23671 | function baseIsNaN(value) { | ||
23672 | return value !== value; | ||
23673 | } | ||
23674 | |||
23675 | module.exports = baseIsNaN; | ||
23676 | |||
23677 | },{}],189:[function(require,module,exports){ | ||
23678 | var isFunction = require('./isFunction'), | ||
23679 | isMasked = require('./_isMasked'), | ||
23680 | isObject = require('./isObject'), | ||
23681 | toSource = require('./_toSource'); | ||
23682 | |||
23683 | /** | ||
23684 | * Used to match `RegExp` | ||
23685 | * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). | ||
23686 | */ | ||
23687 | var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; | ||
23688 | |||
23689 | /** Used to detect host constructors (Safari). */ | ||
23690 | var reIsHostCtor = /^\[object .+?Constructor\]$/; | ||
23691 | |||
23692 | /** Used for built-in method references. */ | ||
23693 | var funcProto = Function.prototype, | ||
23694 | objectProto = Object.prototype; | ||
23695 | |||
23696 | /** Used to resolve the decompiled source of functions. */ | ||
23697 | var funcToString = funcProto.toString; | ||
23698 | |||
23699 | /** Used to check objects for own properties. */ | ||
23700 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
23701 | |||
23702 | /** Used to detect if a method is native. */ | ||
23703 | var reIsNative = RegExp('^' + | ||
23704 | funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') | ||
23705 | .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' | ||
23706 | ); | ||
23707 | |||
23708 | /** | ||
23709 | * The base implementation of `_.isNative` without bad shim checks. | ||
23710 | * | ||
23711 | * @private | ||
23712 | * @param {*} value The value to check. | ||
23713 | * @returns {boolean} Returns `true` if `value` is a native function, | ||
23714 | * else `false`. | ||
23715 | */ | ||
23716 | function baseIsNative(value) { | ||
23717 | if (!isObject(value) || isMasked(value)) { | ||
23718 | return false; | ||
23719 | } | ||
23720 | var pattern = isFunction(value) ? reIsNative : reIsHostCtor; | ||
23721 | return pattern.test(toSource(value)); | ||
23722 | } | ||
23723 | |||
23724 | module.exports = baseIsNative; | ||
23725 | |||
23726 | },{"./_isMasked":263,"./_toSource":302,"./isFunction":324,"./isObject":329}],190:[function(require,module,exports){ | ||
23727 | var getTag = require('./_getTag'), | ||
23728 | isObjectLike = require('./isObjectLike'); | ||
23729 | |||
23730 | /** `Object#toString` result references. */ | ||
23731 | var setTag = '[object Set]'; | ||
23732 | |||
23733 | /** | ||
23734 | * The base implementation of `_.isSet` without Node.js optimizations. | ||
23735 | * | ||
23736 | * @private | ||
23737 | * @param {*} value The value to check. | ||
23738 | * @returns {boolean} Returns `true` if `value` is a set, else `false`. | ||
23739 | */ | ||
23740 | function baseIsSet(value) { | ||
23741 | return isObjectLike(value) && getTag(value) == setTag; | ||
23742 | } | ||
23743 | |||
23744 | module.exports = baseIsSet; | ||
23745 | |||
23746 | },{"./_getTag":246,"./isObjectLike":330}],191:[function(require,module,exports){ | ||
23747 | var baseGetTag = require('./_baseGetTag'), | ||
23748 | isLength = require('./isLength'), | ||
23749 | isObjectLike = require('./isObjectLike'); | ||
23750 | |||
23751 | /** `Object#toString` result references. */ | ||
23752 | var argsTag = '[object Arguments]', | ||
23753 | arrayTag = '[object Array]', | ||
23754 | boolTag = '[object Boolean]', | ||
23755 | dateTag = '[object Date]', | ||
23756 | errorTag = '[object Error]', | ||
23757 | funcTag = '[object Function]', | ||
23758 | mapTag = '[object Map]', | ||
23759 | numberTag = '[object Number]', | ||
23760 | objectTag = '[object Object]', | ||
23761 | regexpTag = '[object RegExp]', | ||
23762 | setTag = '[object Set]', | ||
23763 | stringTag = '[object String]', | ||
23764 | weakMapTag = '[object WeakMap]'; | ||
23765 | |||
23766 | var arrayBufferTag = '[object ArrayBuffer]', | ||
23767 | dataViewTag = '[object DataView]', | ||
23768 | float32Tag = '[object Float32Array]', | ||
23769 | float64Tag = '[object Float64Array]', | ||
23770 | int8Tag = '[object Int8Array]', | ||
23771 | int16Tag = '[object Int16Array]', | ||
23772 | int32Tag = '[object Int32Array]', | ||
23773 | uint8Tag = '[object Uint8Array]', | ||
23774 | uint8ClampedTag = '[object Uint8ClampedArray]', | ||
23775 | uint16Tag = '[object Uint16Array]', | ||
23776 | uint32Tag = '[object Uint32Array]'; | ||
23777 | |||
23778 | /** Used to identify `toStringTag` values of typed arrays. */ | ||
23779 | var typedArrayTags = {}; | ||
23780 | typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = | ||
23781 | typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = | ||
23782 | typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = | ||
23783 | typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = | ||
23784 | typedArrayTags[uint32Tag] = true; | ||
23785 | typedArrayTags[argsTag] = typedArrayTags[arrayTag] = | ||
23786 | typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = | ||
23787 | typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = | ||
23788 | typedArrayTags[errorTag] = typedArrayTags[funcTag] = | ||
23789 | typedArrayTags[mapTag] = typedArrayTags[numberTag] = | ||
23790 | typedArrayTags[objectTag] = typedArrayTags[regexpTag] = | ||
23791 | typedArrayTags[setTag] = typedArrayTags[stringTag] = | ||
23792 | typedArrayTags[weakMapTag] = false; | ||
23793 | |||
23794 | /** | ||
23795 | * The base implementation of `_.isTypedArray` without Node.js optimizations. | ||
23796 | * | ||
23797 | * @private | ||
23798 | * @param {*} value The value to check. | ||
23799 | * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. | ||
23800 | */ | ||
23801 | function baseIsTypedArray(value) { | ||
23802 | return isObjectLike(value) && | ||
23803 | isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; | ||
23804 | } | ||
23805 | |||
23806 | module.exports = baseIsTypedArray; | ||
23807 | |||
23808 | },{"./_baseGetTag":180,"./isLength":325,"./isObjectLike":330}],192:[function(require,module,exports){ | ||
23809 | var baseMatches = require('./_baseMatches'), | ||
23810 | baseMatchesProperty = require('./_baseMatchesProperty'), | ||
23811 | identity = require('./identity'), | ||
23812 | isArray = require('./isArray'), | ||
23813 | property = require('./property'); | ||
23814 | |||
23815 | /** | ||
23816 | * The base implementation of `_.iteratee`. | ||
23817 | * | ||
23818 | * @private | ||
23819 | * @param {*} [value=_.identity] The value to convert to an iteratee. | ||
23820 | * @returns {Function} Returns the iteratee. | ||
23821 | */ | ||
23822 | function baseIteratee(value) { | ||
23823 | // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. | ||
23824 | // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. | ||
23825 | if (typeof value == 'function') { | ||
23826 | return value; | ||
23827 | } | ||
23828 | if (value == null) { | ||
23829 | return identity; | ||
23830 | } | ||
23831 | if (typeof value == 'object') { | ||
23832 | return isArray(value) | ||
23833 | ? baseMatchesProperty(value[0], value[1]) | ||
23834 | : baseMatches(value); | ||
23835 | } | ||
23836 | return property(value); | ||
23837 | } | ||
23838 | |||
23839 | module.exports = baseIteratee; | ||
23840 | |||
23841 | },{"./_baseMatches":196,"./_baseMatchesProperty":197,"./identity":317,"./isArray":319,"./property":343}],193:[function(require,module,exports){ | ||
23842 | var isPrototype = require('./_isPrototype'), | ||
23843 | nativeKeys = require('./_nativeKeys'); | ||
23844 | |||
23845 | /** Used for built-in method references. */ | ||
23846 | var objectProto = Object.prototype; | ||
23847 | |||
23848 | /** Used to check objects for own properties. */ | ||
23849 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
23850 | |||
23851 | /** | ||
23852 | * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. | ||
23853 | * | ||
23854 | * @private | ||
23855 | * @param {Object} object The object to query. | ||
23856 | * @returns {Array} Returns the array of property names. | ||
23857 | */ | ||
23858 | function baseKeys(object) { | ||
23859 | if (!isPrototype(object)) { | ||
23860 | return nativeKeys(object); | ||
23861 | } | ||
23862 | var result = []; | ||
23863 | for (var key in Object(object)) { | ||
23864 | if (hasOwnProperty.call(object, key) && key != 'constructor') { | ||
23865 | result.push(key); | ||
23866 | } | ||
23867 | } | ||
23868 | return result; | ||
23869 | } | ||
23870 | |||
23871 | module.exports = baseKeys; | ||
23872 | |||
23873 | },{"./_isPrototype":264,"./_nativeKeys":280}],194:[function(require,module,exports){ | ||
23874 | var isObject = require('./isObject'), | ||
23875 | isPrototype = require('./_isPrototype'), | ||
23876 | nativeKeysIn = require('./_nativeKeysIn'); | ||
23877 | |||
23878 | /** Used for built-in method references. */ | ||
23879 | var objectProto = Object.prototype; | ||
23880 | |||
23881 | /** Used to check objects for own properties. */ | ||
23882 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
23883 | |||
23884 | /** | ||
23885 | * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. | ||
23886 | * | ||
23887 | * @private | ||
23888 | * @param {Object} object The object to query. | ||
23889 | * @returns {Array} Returns the array of property names. | ||
23890 | */ | ||
23891 | function baseKeysIn(object) { | ||
23892 | if (!isObject(object)) { | ||
23893 | return nativeKeysIn(object); | ||
23894 | } | ||
23895 | var isProto = isPrototype(object), | ||
23896 | result = []; | ||
23897 | |||
23898 | for (var key in object) { | ||
23899 | if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { | ||
23900 | result.push(key); | ||
23901 | } | ||
23902 | } | ||
23903 | return result; | ||
23904 | } | ||
23905 | |||
23906 | module.exports = baseKeysIn; | ||
23907 | |||
23908 | },{"./_isPrototype":264,"./_nativeKeysIn":281,"./isObject":329}],195:[function(require,module,exports){ | ||
23909 | var baseEach = require('./_baseEach'), | ||
23910 | isArrayLike = require('./isArrayLike'); | ||
23911 | |||
23912 | /** | ||
23913 | * The base implementation of `_.map` without support for iteratee shorthands. | ||
23914 | * | ||
23915 | * @private | ||
23916 | * @param {Array|Object} collection The collection to iterate over. | ||
23917 | * @param {Function} iteratee The function invoked per iteration. | ||
23918 | * @returns {Array} Returns the new mapped array. | ||
23919 | */ | ||
23920 | function baseMap(collection, iteratee) { | ||
23921 | var index = -1, | ||
23922 | result = isArrayLike(collection) ? Array(collection.length) : []; | ||
23923 | |||
23924 | baseEach(collection, function(value, key, collection) { | ||
23925 | result[++index] = iteratee(value, key, collection); | ||
23926 | }); | ||
23927 | return result; | ||
23928 | } | ||
23929 | |||
23930 | module.exports = baseMap; | ||
23931 | |||
23932 | },{"./_baseEach":172,"./isArrayLike":320}],196:[function(require,module,exports){ | ||
23933 | var baseIsMatch = require('./_baseIsMatch'), | ||
23934 | getMatchData = require('./_getMatchData'), | ||
23935 | matchesStrictComparable = require('./_matchesStrictComparable'); | ||
23936 | |||
23937 | /** | ||
23938 | * The base implementation of `_.matches` which doesn't clone `source`. | ||
23939 | * | ||
23940 | * @private | ||
23941 | * @param {Object} source The object of property values to match. | ||
23942 | * @returns {Function} Returns the new spec function. | ||
23943 | */ | ||
23944 | function baseMatches(source) { | ||
23945 | var matchData = getMatchData(source); | ||
23946 | if (matchData.length == 1 && matchData[0][2]) { | ||
23947 | return matchesStrictComparable(matchData[0][0], matchData[0][1]); | ||
23948 | } | ||
23949 | return function(object) { | ||
23950 | return object === source || baseIsMatch(object, source, matchData); | ||
23951 | }; | ||
23952 | } | ||
23953 | |||
23954 | module.exports = baseMatches; | ||
23955 | |||
23956 | },{"./_baseIsMatch":187,"./_getMatchData":240,"./_matchesStrictComparable":277}],197:[function(require,module,exports){ | ||
23957 | var baseIsEqual = require('./_baseIsEqual'), | ||
23958 | get = require('./get'), | ||
23959 | hasIn = require('./hasIn'), | ||
23960 | isKey = require('./_isKey'), | ||
23961 | isStrictComparable = require('./_isStrictComparable'), | ||
23962 | matchesStrictComparable = require('./_matchesStrictComparable'), | ||
23963 | toKey = require('./_toKey'); | ||
23964 | |||
23965 | /** Used to compose bitmasks for value comparisons. */ | ||
23966 | var COMPARE_PARTIAL_FLAG = 1, | ||
23967 | COMPARE_UNORDERED_FLAG = 2; | ||
23968 | |||
23969 | /** | ||
23970 | * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. | ||
23971 | * | ||
23972 | * @private | ||
23973 | * @param {string} path The path of the property to get. | ||
23974 | * @param {*} srcValue The value to match. | ||
23975 | * @returns {Function} Returns the new spec function. | ||
23976 | */ | ||
23977 | function baseMatchesProperty(path, srcValue) { | ||
23978 | if (isKey(path) && isStrictComparable(srcValue)) { | ||
23979 | return matchesStrictComparable(toKey(path), srcValue); | ||
23980 | } | ||
23981 | return function(object) { | ||
23982 | var objValue = get(object, path); | ||
23983 | return (objValue === undefined && objValue === srcValue) | ||
23984 | ? hasIn(object, path) | ||
23985 | : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); | ||
23986 | }; | ||
23987 | } | ||
23988 | |||
23989 | module.exports = baseMatchesProperty; | ||
23990 | |||
23991 | },{"./_baseIsEqual":184,"./_isKey":261,"./_isStrictComparable":265,"./_matchesStrictComparable":277,"./_toKey":301,"./get":315,"./hasIn":316}],198:[function(require,module,exports){ | ||
23992 | var basePickBy = require('./_basePickBy'), | ||
23993 | hasIn = require('./hasIn'); | ||
23994 | |||
23995 | /** | ||
23996 | * The base implementation of `_.pick` without support for individual | ||
23997 | * property identifiers. | ||
23998 | * | ||
23999 | * @private | ||
24000 | * @param {Object} object The source object. | ||
24001 | * @param {string[]} paths The property paths to pick. | ||
24002 | * @returns {Object} Returns the new object. | ||
24003 | */ | ||
24004 | function basePick(object, paths) { | ||
24005 | return basePickBy(object, paths, function(value, path) { | ||
24006 | return hasIn(object, path); | ||
24007 | }); | ||
24008 | } | ||
24009 | |||
24010 | module.exports = basePick; | ||
24011 | |||
24012 | },{"./_basePickBy":199,"./hasIn":316}],199:[function(require,module,exports){ | ||
24013 | var baseGet = require('./_baseGet'), | ||
24014 | baseSet = require('./_baseSet'), | ||
24015 | castPath = require('./_castPath'); | ||
24016 | |||
24017 | /** | ||
24018 | * The base implementation of `_.pickBy` without support for iteratee shorthands. | ||
24019 | * | ||
24020 | * @private | ||
24021 | * @param {Object} object The source object. | ||
24022 | * @param {string[]} paths The property paths to pick. | ||
24023 | * @param {Function} predicate The function invoked per property. | ||
24024 | * @returns {Object} Returns the new object. | ||
24025 | */ | ||
24026 | function basePickBy(object, paths, predicate) { | ||
24027 | var index = -1, | ||
24028 | length = paths.length, | ||
24029 | result = {}; | ||
24030 | |||
24031 | while (++index < length) { | ||
24032 | var path = paths[index], | ||
24033 | value = baseGet(object, path); | ||
24034 | |||
24035 | if (predicate(value, path)) { | ||
24036 | baseSet(result, castPath(path, object), value); | ||
24037 | } | ||
24038 | } | ||
24039 | return result; | ||
24040 | } | ||
24041 | |||
24042 | module.exports = basePickBy; | ||
24043 | |||
24044 | },{"./_baseGet":178,"./_baseSet":204,"./_castPath":213}],200:[function(require,module,exports){ | ||
24045 | /** | ||
24046 | * The base implementation of `_.property` without support for deep paths. | ||
24047 | * | ||
24048 | * @private | ||
24049 | * @param {string} key The key of the property to get. | ||
24050 | * @returns {Function} Returns the new accessor function. | ||
24051 | */ | ||
24052 | function baseProperty(key) { | ||
24053 | return function(object) { | ||
24054 | return object == null ? undefined : object[key]; | ||
24055 | }; | ||
24056 | } | ||
24057 | |||
24058 | module.exports = baseProperty; | ||
24059 | |||
24060 | },{}],201:[function(require,module,exports){ | ||
24061 | var baseGet = require('./_baseGet'); | ||
24062 | |||
24063 | /** | ||
24064 | * A specialized version of `baseProperty` which supports deep paths. | ||
24065 | * | ||
24066 | * @private | ||
24067 | * @param {Array|string} path The path of the property to get. | ||
24068 | * @returns {Function} Returns the new accessor function. | ||
24069 | */ | ||
24070 | function basePropertyDeep(path) { | ||
24071 | return function(object) { | ||
24072 | return baseGet(object, path); | ||
24073 | }; | ||
24074 | } | ||
24075 | |||
24076 | module.exports = basePropertyDeep; | ||
24077 | |||
24078 | },{"./_baseGet":178}],202:[function(require,module,exports){ | ||
24079 | /** Used as references for various `Number` constants. */ | ||
24080 | var MAX_SAFE_INTEGER = 9007199254740991; | ||
24081 | |||
24082 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
24083 | var nativeFloor = Math.floor; | ||
24084 | |||
24085 | /** | ||
24086 | * The base implementation of `_.repeat` which doesn't coerce arguments. | ||
24087 | * | ||
24088 | * @private | ||
24089 | * @param {string} string The string to repeat. | ||
24090 | * @param {number} n The number of times to repeat the string. | ||
24091 | * @returns {string} Returns the repeated string. | ||
24092 | */ | ||
24093 | function baseRepeat(string, n) { | ||
24094 | var result = ''; | ||
24095 | if (!string || n < 1 || n > MAX_SAFE_INTEGER) { | ||
24096 | return result; | ||
24097 | } | ||
24098 | // Leverage the exponentiation by squaring algorithm for a faster repeat. | ||
24099 | // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. | ||
24100 | do { | ||
24101 | if (n % 2) { | ||
24102 | result += string; | ||
24103 | } | ||
24104 | n = nativeFloor(n / 2); | ||
24105 | if (n) { | ||
24106 | string += string; | ||
24107 | } | ||
24108 | } while (n); | ||
24109 | |||
24110 | return result; | ||
24111 | } | ||
24112 | |||
24113 | module.exports = baseRepeat; | ||
24114 | |||
24115 | },{}],203:[function(require,module,exports){ | ||
24116 | var identity = require('./identity'), | ||
24117 | overRest = require('./_overRest'), | ||
24118 | setToString = require('./_setToString'); | ||
24119 | |||
24120 | /** | ||
24121 | * The base implementation of `_.rest` which doesn't validate or coerce arguments. | ||
24122 | * | ||
24123 | * @private | ||
24124 | * @param {Function} func The function to apply a rest parameter to. | ||
24125 | * @param {number} [start=func.length-1] The start position of the rest parameter. | ||
24126 | * @returns {Function} Returns the new function. | ||
24127 | */ | ||
24128 | function baseRest(func, start) { | ||
24129 | return setToString(overRest(func, start, identity), func + ''); | ||
24130 | } | ||
24131 | |||
24132 | module.exports = baseRest; | ||
24133 | |||
24134 | },{"./_overRest":285,"./_setToString":290,"./identity":317}],204:[function(require,module,exports){ | ||
24135 | var assignValue = require('./_assignValue'), | ||
24136 | castPath = require('./_castPath'), | ||
24137 | isIndex = require('./_isIndex'), | ||
24138 | isObject = require('./isObject'), | ||
24139 | toKey = require('./_toKey'); | ||
24140 | |||
24141 | /** | ||
24142 | * The base implementation of `_.set`. | ||
24143 | * | ||
24144 | * @private | ||
24145 | * @param {Object} object The object to modify. | ||
24146 | * @param {Array|string} path The path of the property to set. | ||
24147 | * @param {*} value The value to set. | ||
24148 | * @param {Function} [customizer] The function to customize path creation. | ||
24149 | * @returns {Object} Returns `object`. | ||
24150 | */ | ||
24151 | function baseSet(object, path, value, customizer) { | ||
24152 | if (!isObject(object)) { | ||
24153 | return object; | ||
24154 | } | ||
24155 | path = castPath(path, object); | ||
24156 | |||
24157 | var index = -1, | ||
24158 | length = path.length, | ||
24159 | lastIndex = length - 1, | ||
24160 | nested = object; | ||
24161 | |||
24162 | while (nested != null && ++index < length) { | ||
24163 | var key = toKey(path[index]), | ||
24164 | newValue = value; | ||
24165 | |||
24166 | if (index != lastIndex) { | ||
24167 | var objValue = nested[key]; | ||
24168 | newValue = customizer ? customizer(objValue, key, nested) : undefined; | ||
24169 | if (newValue === undefined) { | ||
24170 | newValue = isObject(objValue) | ||
24171 | ? objValue | ||
24172 | : (isIndex(path[index + 1]) ? [] : {}); | ||
24173 | } | ||
24174 | } | ||
24175 | assignValue(nested, key, newValue); | ||
24176 | nested = nested[key]; | ||
24177 | } | ||
24178 | return object; | ||
24179 | } | ||
24180 | |||
24181 | module.exports = baseSet; | ||
24182 | |||
24183 | },{"./_assignValue":165,"./_castPath":213,"./_isIndex":259,"./_toKey":301,"./isObject":329}],205:[function(require,module,exports){ | ||
24184 | var constant = require('./constant'), | ||
24185 | defineProperty = require('./_defineProperty'), | ||
24186 | identity = require('./identity'); | ||
24187 | |||
24188 | /** | ||
24189 | * The base implementation of `setToString` without support for hot loop shorting. | ||
24190 | * | ||
24191 | * @private | ||
24192 | * @param {Function} func The function to modify. | ||
24193 | * @param {Function} string The `toString` result. | ||
24194 | * @returns {Function} Returns `func`. | ||
24195 | */ | ||
24196 | var baseSetToString = !defineProperty ? identity : function(func, string) { | ||
24197 | return defineProperty(func, 'toString', { | ||
24198 | 'configurable': true, | ||
24199 | 'enumerable': false, | ||
24200 | 'value': constant(string), | ||
24201 | 'writable': true | ||
24202 | }); | ||
24203 | }; | ||
24204 | |||
24205 | module.exports = baseSetToString; | ||
24206 | |||
24207 | },{"./_defineProperty":231,"./constant":307,"./identity":317}],206:[function(require,module,exports){ | ||
24208 | /** | ||
24209 | * The base implementation of `_.slice` without an iteratee call guard. | ||
24210 | * | ||
24211 | * @private | ||
24212 | * @param {Array} array The array to slice. | ||
24213 | * @param {number} [start=0] The start position. | ||
24214 | * @param {number} [end=array.length] The end position. | ||
24215 | * @returns {Array} Returns the slice of `array`. | ||
24216 | */ | ||
24217 | function baseSlice(array, start, end) { | ||
24218 | var index = -1, | ||
24219 | length = array.length; | ||
24220 | |||
24221 | if (start < 0) { | ||
24222 | start = -start > length ? 0 : (length + start); | ||
24223 | } | ||
24224 | end = end > length ? length : end; | ||
24225 | if (end < 0) { | ||
24226 | end += length; | ||
24227 | } | ||
24228 | length = start > end ? 0 : ((end - start) >>> 0); | ||
24229 | start >>>= 0; | ||
24230 | |||
24231 | var result = Array(length); | ||
24232 | while (++index < length) { | ||
24233 | result[index] = array[index + start]; | ||
24234 | } | ||
24235 | return result; | ||
24236 | } | ||
24237 | |||
24238 | module.exports = baseSlice; | ||
24239 | |||
24240 | },{}],207:[function(require,module,exports){ | ||
24241 | /** | ||
24242 | * The base implementation of `_.times` without support for iteratee shorthands | ||
24243 | * or max array length checks. | ||
24244 | * | ||
24245 | * @private | ||
24246 | * @param {number} n The number of times to invoke `iteratee`. | ||
24247 | * @param {Function} iteratee The function invoked per iteration. | ||
24248 | * @returns {Array} Returns the array of results. | ||
24249 | */ | ||
24250 | function baseTimes(n, iteratee) { | ||
24251 | var index = -1, | ||
24252 | result = Array(n); | ||
24253 | |||
24254 | while (++index < n) { | ||
24255 | result[index] = iteratee(index); | ||
24256 | } | ||
24257 | return result; | ||
24258 | } | ||
24259 | |||
24260 | module.exports = baseTimes; | ||
24261 | |||
24262 | },{}],208:[function(require,module,exports){ | ||
24263 | var Symbol = require('./_Symbol'), | ||
24264 | arrayMap = require('./_arrayMap'), | ||
24265 | isArray = require('./isArray'), | ||
24266 | isSymbol = require('./isSymbol'); | ||
24267 | |||
24268 | /** Used as references for various `Number` constants. */ | ||
24269 | var INFINITY = 1 / 0; | ||
24270 | |||
24271 | /** Used to convert symbols to primitives and strings. */ | ||
24272 | var symbolProto = Symbol ? Symbol.prototype : undefined, | ||
24273 | symbolToString = symbolProto ? symbolProto.toString : undefined; | ||
24274 | |||
24275 | /** | ||
24276 | * The base implementation of `_.toString` which doesn't convert nullish | ||
24277 | * values to empty strings. | ||
24278 | * | ||
24279 | * @private | ||
24280 | * @param {*} value The value to process. | ||
24281 | * @returns {string} Returns the string. | ||
24282 | */ | ||
24283 | function baseToString(value) { | ||
24284 | // Exit early for strings to avoid a performance hit in some environments. | ||
24285 | if (typeof value == 'string') { | ||
24286 | return value; | ||
24287 | } | ||
24288 | if (isArray(value)) { | ||
24289 | // Recursively convert values (susceptible to call stack limits). | ||
24290 | return arrayMap(value, baseToString) + ''; | ||
24291 | } | ||
24292 | if (isSymbol(value)) { | ||
24293 | return symbolToString ? symbolToString.call(value) : ''; | ||
24294 | } | ||
24295 | var result = (value + ''); | ||
24296 | return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; | ||
24297 | } | ||
24298 | |||
24299 | module.exports = baseToString; | ||
24300 | |||
24301 | },{"./_Symbol":152,"./_arrayMap":160,"./isArray":319,"./isSymbol":334}],209:[function(require,module,exports){ | ||
24302 | /** | ||
24303 | * The base implementation of `_.unary` without support for storing metadata. | ||
24304 | * | ||
24305 | * @private | ||
24306 | * @param {Function} func The function to cap arguments for. | ||
24307 | * @returns {Function} Returns the new capped function. | ||
24308 | */ | ||
24309 | function baseUnary(func) { | ||
24310 | return function(value) { | ||
24311 | return func(value); | ||
24312 | }; | ||
24313 | } | ||
24314 | |||
24315 | module.exports = baseUnary; | ||
24316 | |||
24317 | },{}],210:[function(require,module,exports){ | ||
24318 | var arrayMap = require('./_arrayMap'); | ||
24319 | |||
24320 | /** | ||
24321 | * The base implementation of `_.values` and `_.valuesIn` which creates an | ||
24322 | * array of `object` property values corresponding to the property names | ||
24323 | * of `props`. | ||
24324 | * | ||
24325 | * @private | ||
24326 | * @param {Object} object The object to query. | ||
24327 | * @param {Array} props The property names to get values for. | ||
24328 | * @returns {Object} Returns the array of property values. | ||
24329 | */ | ||
24330 | function baseValues(object, props) { | ||
24331 | return arrayMap(props, function(key) { | ||
24332 | return object[key]; | ||
24333 | }); | ||
24334 | } | ||
24335 | |||
24336 | module.exports = baseValues; | ||
24337 | |||
24338 | },{"./_arrayMap":160}],211:[function(require,module,exports){ | ||
24339 | /** | ||
24340 | * Checks if a `cache` value for `key` exists. | ||
24341 | * | ||
24342 | * @private | ||
24343 | * @param {Object} cache The cache to query. | ||
24344 | * @param {string} key The key of the entry to check. | ||
24345 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
24346 | */ | ||
24347 | function cacheHas(cache, key) { | ||
24348 | return cache.has(key); | ||
24349 | } | ||
24350 | |||
24351 | module.exports = cacheHas; | ||
24352 | |||
24353 | },{}],212:[function(require,module,exports){ | ||
24354 | var identity = require('./identity'); | ||
24355 | |||
24356 | /** | ||
24357 | * Casts `value` to `identity` if it's not a function. | ||
24358 | * | ||
24359 | * @private | ||
24360 | * @param {*} value The value to inspect. | ||
24361 | * @returns {Function} Returns cast function. | ||
24362 | */ | ||
24363 | function castFunction(value) { | ||
24364 | return typeof value == 'function' ? value : identity; | ||
24365 | } | ||
24366 | |||
24367 | module.exports = castFunction; | ||
24368 | |||
24369 | },{"./identity":317}],213:[function(require,module,exports){ | ||
24370 | var isArray = require('./isArray'), | ||
24371 | isKey = require('./_isKey'), | ||
24372 | stringToPath = require('./_stringToPath'), | ||
24373 | toString = require('./toString'); | ||
24374 | |||
24375 | /** | ||
24376 | * Casts `value` to a path array if it's not one. | ||
24377 | * | ||
24378 | * @private | ||
24379 | * @param {*} value The value to inspect. | ||
24380 | * @param {Object} [object] The object to query keys on. | ||
24381 | * @returns {Array} Returns the cast property path array. | ||
24382 | */ | ||
24383 | function castPath(value, object) { | ||
24384 | if (isArray(value)) { | ||
24385 | return value; | ||
24386 | } | ||
24387 | return isKey(value, object) ? [value] : stringToPath(toString(value)); | ||
24388 | } | ||
24389 | |||
24390 | module.exports = castPath; | ||
24391 | |||
24392 | },{"./_isKey":261,"./_stringToPath":300,"./isArray":319,"./toString":350}],214:[function(require,module,exports){ | ||
24393 | var baseSlice = require('./_baseSlice'); | ||
24394 | |||
24395 | /** | ||
24396 | * Casts `array` to a slice if it's needed. | ||
24397 | * | ||
24398 | * @private | ||
24399 | * @param {Array} array The array to inspect. | ||
24400 | * @param {number} start The start position. | ||
24401 | * @param {number} [end=array.length] The end position. | ||
24402 | * @returns {Array} Returns the cast slice. | ||
24403 | */ | ||
24404 | function castSlice(array, start, end) { | ||
24405 | var length = array.length; | ||
24406 | end = end === undefined ? length : end; | ||
24407 | return (!start && end >= length) ? array : baseSlice(array, start, end); | ||
24408 | } | ||
24409 | |||
24410 | module.exports = castSlice; | ||
24411 | |||
24412 | },{"./_baseSlice":206}],215:[function(require,module,exports){ | ||
24413 | var baseIndexOf = require('./_baseIndexOf'); | ||
24414 | |||
24415 | /** | ||
24416 | * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol | ||
24417 | * that is not found in the character symbols. | ||
24418 | * | ||
24419 | * @private | ||
24420 | * @param {Array} strSymbols The string symbols to inspect. | ||
24421 | * @param {Array} chrSymbols The character symbols to find. | ||
24422 | * @returns {number} Returns the index of the last unmatched string symbol. | ||
24423 | */ | ||
24424 | function charsEndIndex(strSymbols, chrSymbols) { | ||
24425 | var index = strSymbols.length; | ||
24426 | |||
24427 | while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} | ||
24428 | return index; | ||
24429 | } | ||
24430 | |||
24431 | module.exports = charsEndIndex; | ||
24432 | |||
24433 | },{"./_baseIndexOf":182}],216:[function(require,module,exports){ | ||
24434 | var Uint8Array = require('./_Uint8Array'); | ||
24435 | |||
24436 | /** | ||
24437 | * Creates a clone of `arrayBuffer`. | ||
24438 | * | ||
24439 | * @private | ||
24440 | * @param {ArrayBuffer} arrayBuffer The array buffer to clone. | ||
24441 | * @returns {ArrayBuffer} Returns the cloned array buffer. | ||
24442 | */ | ||
24443 | function cloneArrayBuffer(arrayBuffer) { | ||
24444 | var result = new arrayBuffer.constructor(arrayBuffer.byteLength); | ||
24445 | new Uint8Array(result).set(new Uint8Array(arrayBuffer)); | ||
24446 | return result; | ||
24447 | } | ||
24448 | |||
24449 | module.exports = cloneArrayBuffer; | ||
24450 | |||
24451 | },{"./_Uint8Array":153}],217:[function(require,module,exports){ | ||
24452 | var root = require('./_root'); | ||
24453 | |||
24454 | /** Detect free variable `exports`. */ | ||
24455 | var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; | ||
24456 | |||
24457 | /** Detect free variable `module`. */ | ||
24458 | var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; | ||
24459 | |||
24460 | /** Detect the popular CommonJS extension `module.exports`. */ | ||
24461 | var moduleExports = freeModule && freeModule.exports === freeExports; | ||
24462 | |||
24463 | /** Built-in value references. */ | ||
24464 | var Buffer = moduleExports ? root.Buffer : undefined, | ||
24465 | allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined; | ||
24466 | |||
24467 | /** | ||
24468 | * Creates a clone of `buffer`. | ||
24469 | * | ||
24470 | * @private | ||
24471 | * @param {Buffer} buffer The buffer to clone. | ||
24472 | * @param {boolean} [isDeep] Specify a deep clone. | ||
24473 | * @returns {Buffer} Returns the cloned buffer. | ||
24474 | */ | ||
24475 | function cloneBuffer(buffer, isDeep) { | ||
24476 | if (isDeep) { | ||
24477 | return buffer.slice(); | ||
24478 | } | ||
24479 | var length = buffer.length, | ||
24480 | result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); | ||
24481 | |||
24482 | buffer.copy(result); | ||
24483 | return result; | ||
24484 | } | ||
24485 | |||
24486 | module.exports = cloneBuffer; | ||
24487 | |||
24488 | },{"./_root":286}],218:[function(require,module,exports){ | ||
24489 | var cloneArrayBuffer = require('./_cloneArrayBuffer'); | ||
24490 | |||
24491 | /** | ||
24492 | * Creates a clone of `dataView`. | ||
24493 | * | ||
24494 | * @private | ||
24495 | * @param {Object} dataView The data view to clone. | ||
24496 | * @param {boolean} [isDeep] Specify a deep clone. | ||
24497 | * @returns {Object} Returns the cloned data view. | ||
24498 | */ | ||
24499 | function cloneDataView(dataView, isDeep) { | ||
24500 | var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; | ||
24501 | return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); | ||
24502 | } | ||
24503 | |||
24504 | module.exports = cloneDataView; | ||
24505 | |||
24506 | },{"./_cloneArrayBuffer":216}],219:[function(require,module,exports){ | ||
24507 | /** Used to match `RegExp` flags from their coerced string values. */ | ||
24508 | var reFlags = /\w*$/; | ||
24509 | |||
24510 | /** | ||
24511 | * Creates a clone of `regexp`. | ||
24512 | * | ||
24513 | * @private | ||
24514 | * @param {Object} regexp The regexp to clone. | ||
24515 | * @returns {Object} Returns the cloned regexp. | ||
24516 | */ | ||
24517 | function cloneRegExp(regexp) { | ||
24518 | var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); | ||
24519 | result.lastIndex = regexp.lastIndex; | ||
24520 | return result; | ||
24521 | } | ||
24522 | |||
24523 | module.exports = cloneRegExp; | ||
24524 | |||
24525 | },{}],220:[function(require,module,exports){ | ||
24526 | var Symbol = require('./_Symbol'); | ||
24527 | |||
24528 | /** Used to convert symbols to primitives and strings. */ | ||
24529 | var symbolProto = Symbol ? Symbol.prototype : undefined, | ||
24530 | symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; | ||
24531 | |||
24532 | /** | ||
24533 | * Creates a clone of the `symbol` object. | ||
24534 | * | ||
24535 | * @private | ||
24536 | * @param {Object} symbol The symbol object to clone. | ||
24537 | * @returns {Object} Returns the cloned symbol object. | ||
24538 | */ | ||
24539 | function cloneSymbol(symbol) { | ||
24540 | return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; | ||
24541 | } | ||
24542 | |||
24543 | module.exports = cloneSymbol; | ||
24544 | |||
24545 | },{"./_Symbol":152}],221:[function(require,module,exports){ | ||
24546 | var cloneArrayBuffer = require('./_cloneArrayBuffer'); | ||
24547 | |||
24548 | /** | ||
24549 | * Creates a clone of `typedArray`. | ||
24550 | * | ||
24551 | * @private | ||
24552 | * @param {Object} typedArray The typed array to clone. | ||
24553 | * @param {boolean} [isDeep] Specify a deep clone. | ||
24554 | * @returns {Object} Returns the cloned typed array. | ||
24555 | */ | ||
24556 | function cloneTypedArray(typedArray, isDeep) { | ||
24557 | var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; | ||
24558 | return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); | ||
24559 | } | ||
24560 | |||
24561 | module.exports = cloneTypedArray; | ||
24562 | |||
24563 | },{"./_cloneArrayBuffer":216}],222:[function(require,module,exports){ | ||
24564 | /** | ||
24565 | * Copies the values of `source` to `array`. | ||
24566 | * | ||
24567 | * @private | ||
24568 | * @param {Array} source The array to copy values from. | ||
24569 | * @param {Array} [array=[]] The array to copy values to. | ||
24570 | * @returns {Array} Returns `array`. | ||
24571 | */ | ||
24572 | function copyArray(source, array) { | ||
24573 | var index = -1, | ||
24574 | length = source.length; | ||
24575 | |||
24576 | array || (array = Array(length)); | ||
24577 | while (++index < length) { | ||
24578 | array[index] = source[index]; | ||
24579 | } | ||
24580 | return array; | ||
24581 | } | ||
24582 | |||
24583 | module.exports = copyArray; | ||
24584 | |||
24585 | },{}],223:[function(require,module,exports){ | ||
24586 | var assignValue = require('./_assignValue'), | ||
24587 | baseAssignValue = require('./_baseAssignValue'); | ||
24588 | |||
24589 | /** | ||
24590 | * Copies properties of `source` to `object`. | ||
24591 | * | ||
24592 | * @private | ||
24593 | * @param {Object} source The object to copy properties from. | ||
24594 | * @param {Array} props The property identifiers to copy. | ||
24595 | * @param {Object} [object={}] The object to copy properties to. | ||
24596 | * @param {Function} [customizer] The function to customize copied values. | ||
24597 | * @returns {Object} Returns `object`. | ||
24598 | */ | ||
24599 | function copyObject(source, props, object, customizer) { | ||
24600 | var isNew = !object; | ||
24601 | object || (object = {}); | ||
24602 | |||
24603 | var index = -1, | ||
24604 | length = props.length; | ||
24605 | |||
24606 | while (++index < length) { | ||
24607 | var key = props[index]; | ||
24608 | |||
24609 | var newValue = customizer | ||
24610 | ? customizer(object[key], source[key], key, object, source) | ||
24611 | : undefined; | ||
24612 | |||
24613 | if (newValue === undefined) { | ||
24614 | newValue = source[key]; | ||
24615 | } | ||
24616 | if (isNew) { | ||
24617 | baseAssignValue(object, key, newValue); | ||
24618 | } else { | ||
24619 | assignValue(object, key, newValue); | ||
24620 | } | ||
24621 | } | ||
24622 | return object; | ||
24623 | } | ||
24624 | |||
24625 | module.exports = copyObject; | ||
24626 | |||
24627 | },{"./_assignValue":165,"./_baseAssignValue":169}],224:[function(require,module,exports){ | ||
24628 | var copyObject = require('./_copyObject'), | ||
24629 | getSymbols = require('./_getSymbols'); | ||
24630 | |||
24631 | /** | ||
24632 | * Copies own symbols of `source` to `object`. | ||
24633 | * | ||
24634 | * @private | ||
24635 | * @param {Object} source The object to copy symbols from. | ||
24636 | * @param {Object} [object={}] The object to copy symbols to. | ||
24637 | * @returns {Object} Returns `object`. | ||
24638 | */ | ||
24639 | function copySymbols(source, object) { | ||
24640 | return copyObject(source, getSymbols(source), object); | ||
24641 | } | ||
24642 | |||
24643 | module.exports = copySymbols; | ||
24644 | |||
24645 | },{"./_copyObject":223,"./_getSymbols":244}],225:[function(require,module,exports){ | ||
24646 | var copyObject = require('./_copyObject'), | ||
24647 | getSymbolsIn = require('./_getSymbolsIn'); | ||
24648 | |||
24649 | /** | ||
24650 | * Copies own and inherited symbols of `source` to `object`. | ||
24651 | * | ||
24652 | * @private | ||
24653 | * @param {Object} source The object to copy symbols from. | ||
24654 | * @param {Object} [object={}] The object to copy symbols to. | ||
24655 | * @returns {Object} Returns `object`. | ||
24656 | */ | ||
24657 | function copySymbolsIn(source, object) { | ||
24658 | return copyObject(source, getSymbolsIn(source), object); | ||
24659 | } | ||
24660 | |||
24661 | module.exports = copySymbolsIn; | ||
24662 | |||
24663 | },{"./_copyObject":223,"./_getSymbolsIn":245}],226:[function(require,module,exports){ | ||
24664 | var root = require('./_root'); | ||
24665 | |||
24666 | /** Used to detect overreaching core-js shims. */ | ||
24667 | var coreJsData = root['__core-js_shared__']; | ||
24668 | |||
24669 | module.exports = coreJsData; | ||
24670 | |||
24671 | },{"./_root":286}],227:[function(require,module,exports){ | ||
24672 | var baseRest = require('./_baseRest'), | ||
24673 | isIterateeCall = require('./_isIterateeCall'); | ||
24674 | |||
24675 | /** | ||
24676 | * Creates a function like `_.assign`. | ||
24677 | * | ||
24678 | * @private | ||
24679 | * @param {Function} assigner The function to assign values. | ||
24680 | * @returns {Function} Returns the new assigner function. | ||
24681 | */ | ||
24682 | function createAssigner(assigner) { | ||
24683 | return baseRest(function(object, sources) { | ||
24684 | var index = -1, | ||
24685 | length = sources.length, | ||
24686 | customizer = length > 1 ? sources[length - 1] : undefined, | ||
24687 | guard = length > 2 ? sources[2] : undefined; | ||
24688 | |||
24689 | customizer = (assigner.length > 3 && typeof customizer == 'function') | ||
24690 | ? (length--, customizer) | ||
24691 | : undefined; | ||
24692 | |||
24693 | if (guard && isIterateeCall(sources[0], sources[1], guard)) { | ||
24694 | customizer = length < 3 ? undefined : customizer; | ||
24695 | length = 1; | ||
24696 | } | ||
24697 | object = Object(object); | ||
24698 | while (++index < length) { | ||
24699 | var source = sources[index]; | ||
24700 | if (source) { | ||
24701 | assigner(object, source, index, customizer); | ||
24702 | } | ||
24703 | } | ||
24704 | return object; | ||
24705 | }); | ||
24706 | } | ||
24707 | |||
24708 | module.exports = createAssigner; | ||
24709 | |||
24710 | },{"./_baseRest":203,"./_isIterateeCall":260}],228:[function(require,module,exports){ | ||
24711 | var isArrayLike = require('./isArrayLike'); | ||
24712 | |||
24713 | /** | ||
24714 | * Creates a `baseEach` or `baseEachRight` function. | ||
24715 | * | ||
24716 | * @private | ||
24717 | * @param {Function} eachFunc The function to iterate over a collection. | ||
24718 | * @param {boolean} [fromRight] Specify iterating from right to left. | ||
24719 | * @returns {Function} Returns the new base function. | ||
24720 | */ | ||
24721 | function createBaseEach(eachFunc, fromRight) { | ||
24722 | return function(collection, iteratee) { | ||
24723 | if (collection == null) { | ||
24724 | return collection; | ||
24725 | } | ||
24726 | if (!isArrayLike(collection)) { | ||
24727 | return eachFunc(collection, iteratee); | ||
24728 | } | ||
24729 | var length = collection.length, | ||
24730 | index = fromRight ? length : -1, | ||
24731 | iterable = Object(collection); | ||
24732 | |||
24733 | while ((fromRight ? index-- : ++index < length)) { | ||
24734 | if (iteratee(iterable[index], index, iterable) === false) { | ||
24735 | break; | ||
24736 | } | ||
24737 | } | ||
24738 | return collection; | ||
24739 | }; | ||
24740 | } | ||
24741 | |||
24742 | module.exports = createBaseEach; | ||
24743 | |||
24744 | },{"./isArrayLike":320}],229:[function(require,module,exports){ | ||
24745 | /** | ||
24746 | * Creates a base function for methods like `_.forIn` and `_.forOwn`. | ||
24747 | * | ||
24748 | * @private | ||
24749 | * @param {boolean} [fromRight] Specify iterating from right to left. | ||
24750 | * @returns {Function} Returns the new base function. | ||
24751 | */ | ||
24752 | function createBaseFor(fromRight) { | ||
24753 | return function(object, iteratee, keysFunc) { | ||
24754 | var index = -1, | ||
24755 | iterable = Object(object), | ||
24756 | props = keysFunc(object), | ||
24757 | length = props.length; | ||
24758 | |||
24759 | while (length--) { | ||
24760 | var key = props[fromRight ? length : ++index]; | ||
24761 | if (iteratee(iterable[key], key, iterable) === false) { | ||
24762 | break; | ||
24763 | } | ||
24764 | } | ||
24765 | return object; | ||
24766 | }; | ||
24767 | } | ||
24768 | |||
24769 | module.exports = createBaseFor; | ||
24770 | |||
24771 | },{}],230:[function(require,module,exports){ | ||
24772 | var baseRepeat = require('./_baseRepeat'), | ||
24773 | baseToString = require('./_baseToString'), | ||
24774 | castSlice = require('./_castSlice'), | ||
24775 | hasUnicode = require('./_hasUnicode'), | ||
24776 | stringSize = require('./_stringSize'), | ||
24777 | stringToArray = require('./_stringToArray'); | ||
24778 | |||
24779 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
24780 | var nativeCeil = Math.ceil; | ||
24781 | |||
24782 | /** | ||
24783 | * Creates the padding for `string` based on `length`. The `chars` string | ||
24784 | * is truncated if the number of characters exceeds `length`. | ||
24785 | * | ||
24786 | * @private | ||
24787 | * @param {number} length The padding length. | ||
24788 | * @param {string} [chars=' '] The string used as padding. | ||
24789 | * @returns {string} Returns the padding for `string`. | ||
24790 | */ | ||
24791 | function createPadding(length, chars) { | ||
24792 | chars = chars === undefined ? ' ' : baseToString(chars); | ||
24793 | |||
24794 | var charsLength = chars.length; | ||
24795 | if (charsLength < 2) { | ||
24796 | return charsLength ? baseRepeat(chars, length) : chars; | ||
24797 | } | ||
24798 | var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); | ||
24799 | return hasUnicode(chars) | ||
24800 | ? castSlice(stringToArray(result), 0, length).join('') | ||
24801 | : result.slice(0, length); | ||
24802 | } | ||
24803 | |||
24804 | module.exports = createPadding; | ||
24805 | |||
24806 | },{"./_baseRepeat":202,"./_baseToString":208,"./_castSlice":214,"./_hasUnicode":249,"./_stringSize":298,"./_stringToArray":299}],231:[function(require,module,exports){ | ||
24807 | var getNative = require('./_getNative'); | ||
24808 | |||
24809 | var defineProperty = (function() { | ||
24810 | try { | ||
24811 | var func = getNative(Object, 'defineProperty'); | ||
24812 | func({}, '', {}); | ||
24813 | return func; | ||
24814 | } catch (e) {} | ||
24815 | }()); | ||
24816 | |||
24817 | module.exports = defineProperty; | ||
24818 | |||
24819 | },{"./_getNative":241}],232:[function(require,module,exports){ | ||
24820 | var SetCache = require('./_SetCache'), | ||
24821 | arraySome = require('./_arraySome'), | ||
24822 | cacheHas = require('./_cacheHas'); | ||
24823 | |||
24824 | /** Used to compose bitmasks for value comparisons. */ | ||
24825 | var COMPARE_PARTIAL_FLAG = 1, | ||
24826 | COMPARE_UNORDERED_FLAG = 2; | ||
24827 | |||
24828 | /** | ||
24829 | * A specialized version of `baseIsEqualDeep` for arrays with support for | ||
24830 | * partial deep comparisons. | ||
24831 | * | ||
24832 | * @private | ||
24833 | * @param {Array} array The array to compare. | ||
24834 | * @param {Array} other The other array to compare. | ||
24835 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | ||
24836 | * @param {Function} customizer The function to customize comparisons. | ||
24837 | * @param {Function} equalFunc The function to determine equivalents of values. | ||
24838 | * @param {Object} stack Tracks traversed `array` and `other` objects. | ||
24839 | * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. | ||
24840 | */ | ||
24841 | function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { | ||
24842 | var isPartial = bitmask & COMPARE_PARTIAL_FLAG, | ||
24843 | arrLength = array.length, | ||
24844 | othLength = other.length; | ||
24845 | |||
24846 | if (arrLength != othLength && !(isPartial && othLength > arrLength)) { | ||
24847 | return false; | ||
24848 | } | ||
24849 | // Assume cyclic values are equal. | ||
24850 | var stacked = stack.get(array); | ||
24851 | if (stacked && stack.get(other)) { | ||
24852 | return stacked == other; | ||
24853 | } | ||
24854 | var index = -1, | ||
24855 | result = true, | ||
24856 | seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; | ||
24857 | |||
24858 | stack.set(array, other); | ||
24859 | stack.set(other, array); | ||
24860 | |||
24861 | // Ignore non-index properties. | ||
24862 | while (++index < arrLength) { | ||
24863 | var arrValue = array[index], | ||
24864 | othValue = other[index]; | ||
24865 | |||
24866 | if (customizer) { | ||
24867 | var compared = isPartial | ||
24868 | ? customizer(othValue, arrValue, index, other, array, stack) | ||
24869 | : customizer(arrValue, othValue, index, array, other, stack); | ||
24870 | } | ||
24871 | if (compared !== undefined) { | ||
24872 | if (compared) { | ||
24873 | continue; | ||
24874 | } | ||
24875 | result = false; | ||
24876 | break; | ||
24877 | } | ||
24878 | // Recursively compare arrays (susceptible to call stack limits). | ||
24879 | if (seen) { | ||
24880 | if (!arraySome(other, function(othValue, othIndex) { | ||
24881 | if (!cacheHas(seen, othIndex) && | ||
24882 | (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { | ||
24883 | return seen.push(othIndex); | ||
24884 | } | ||
24885 | })) { | ||
24886 | result = false; | ||
24887 | break; | ||
24888 | } | ||
24889 | } else if (!( | ||
24890 | arrValue === othValue || | ||
24891 | equalFunc(arrValue, othValue, bitmask, customizer, stack) | ||
24892 | )) { | ||
24893 | result = false; | ||
24894 | break; | ||
24895 | } | ||
24896 | } | ||
24897 | stack['delete'](array); | ||
24898 | stack['delete'](other); | ||
24899 | return result; | ||
24900 | } | ||
24901 | |||
24902 | module.exports = equalArrays; | ||
24903 | |||
24904 | },{"./_SetCache":150,"./_arraySome":162,"./_cacheHas":211}],233:[function(require,module,exports){ | ||
24905 | var Symbol = require('./_Symbol'), | ||
24906 | Uint8Array = require('./_Uint8Array'), | ||
24907 | eq = require('./eq'), | ||
24908 | equalArrays = require('./_equalArrays'), | ||
24909 | mapToArray = require('./_mapToArray'), | ||
24910 | setToArray = require('./_setToArray'); | ||
24911 | |||
24912 | /** Used to compose bitmasks for value comparisons. */ | ||
24913 | var COMPARE_PARTIAL_FLAG = 1, | ||
24914 | COMPARE_UNORDERED_FLAG = 2; | ||
24915 | |||
24916 | /** `Object#toString` result references. */ | ||
24917 | var boolTag = '[object Boolean]', | ||
24918 | dateTag = '[object Date]', | ||
24919 | errorTag = '[object Error]', | ||
24920 | mapTag = '[object Map]', | ||
24921 | numberTag = '[object Number]', | ||
24922 | regexpTag = '[object RegExp]', | ||
24923 | setTag = '[object Set]', | ||
24924 | stringTag = '[object String]', | ||
24925 | symbolTag = '[object Symbol]'; | ||
24926 | |||
24927 | var arrayBufferTag = '[object ArrayBuffer]', | ||
24928 | dataViewTag = '[object DataView]'; | ||
24929 | |||
24930 | /** Used to convert symbols to primitives and strings. */ | ||
24931 | var symbolProto = Symbol ? Symbol.prototype : undefined, | ||
24932 | symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; | ||
24933 | |||
24934 | /** | ||
24935 | * A specialized version of `baseIsEqualDeep` for comparing objects of | ||
24936 | * the same `toStringTag`. | ||
24937 | * | ||
24938 | * **Note:** This function only supports comparing values with tags of | ||
24939 | * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. | ||
24940 | * | ||
24941 | * @private | ||
24942 | * @param {Object} object The object to compare. | ||
24943 | * @param {Object} other The other object to compare. | ||
24944 | * @param {string} tag The `toStringTag` of the objects to compare. | ||
24945 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | ||
24946 | * @param {Function} customizer The function to customize comparisons. | ||
24947 | * @param {Function} equalFunc The function to determine equivalents of values. | ||
24948 | * @param {Object} stack Tracks traversed `object` and `other` objects. | ||
24949 | * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. | ||
24950 | */ | ||
24951 | function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { | ||
24952 | switch (tag) { | ||
24953 | case dataViewTag: | ||
24954 | if ((object.byteLength != other.byteLength) || | ||
24955 | (object.byteOffset != other.byteOffset)) { | ||
24956 | return false; | ||
24957 | } | ||
24958 | object = object.buffer; | ||
24959 | other = other.buffer; | ||
24960 | |||
24961 | case arrayBufferTag: | ||
24962 | if ((object.byteLength != other.byteLength) || | ||
24963 | !equalFunc(new Uint8Array(object), new Uint8Array(other))) { | ||
24964 | return false; | ||
24965 | } | ||
24966 | return true; | ||
24967 | |||
24968 | case boolTag: | ||
24969 | case dateTag: | ||
24970 | case numberTag: | ||
24971 | // Coerce booleans to `1` or `0` and dates to milliseconds. | ||
24972 | // Invalid dates are coerced to `NaN`. | ||
24973 | return eq(+object, +other); | ||
24974 | |||
24975 | case errorTag: | ||
24976 | return object.name == other.name && object.message == other.message; | ||
24977 | |||
24978 | case regexpTag: | ||
24979 | case stringTag: | ||
24980 | // Coerce regexes to strings and treat strings, primitives and objects, | ||
24981 | // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring | ||
24982 | // for more details. | ||
24983 | return object == (other + ''); | ||
24984 | |||
24985 | case mapTag: | ||
24986 | var convert = mapToArray; | ||
24987 | |||
24988 | case setTag: | ||
24989 | var isPartial = bitmask & COMPARE_PARTIAL_FLAG; | ||
24990 | convert || (convert = setToArray); | ||
24991 | |||
24992 | if (object.size != other.size && !isPartial) { | ||
24993 | return false; | ||
24994 | } | ||
24995 | // Assume cyclic values are equal. | ||
24996 | var stacked = stack.get(object); | ||
24997 | if (stacked) { | ||
24998 | return stacked == other; | ||
24999 | } | ||
25000 | bitmask |= COMPARE_UNORDERED_FLAG; | ||
25001 | |||
25002 | // Recursively compare objects (susceptible to call stack limits). | ||
25003 | stack.set(object, other); | ||
25004 | var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); | ||
25005 | stack['delete'](object); | ||
25006 | return result; | ||
25007 | |||
25008 | case symbolTag: | ||
25009 | if (symbolValueOf) { | ||
25010 | return symbolValueOf.call(object) == symbolValueOf.call(other); | ||
25011 | } | ||
25012 | } | ||
25013 | return false; | ||
25014 | } | ||
25015 | |||
25016 | module.exports = equalByTag; | ||
25017 | |||
25018 | },{"./_Symbol":152,"./_Uint8Array":153,"./_equalArrays":232,"./_mapToArray":276,"./_setToArray":289,"./eq":309}],234:[function(require,module,exports){ | ||
25019 | var getAllKeys = require('./_getAllKeys'); | ||
25020 | |||
25021 | /** Used to compose bitmasks for value comparisons. */ | ||
25022 | var COMPARE_PARTIAL_FLAG = 1; | ||
25023 | |||
25024 | /** Used for built-in method references. */ | ||
25025 | var objectProto = Object.prototype; | ||
25026 | |||
25027 | /** Used to check objects for own properties. */ | ||
25028 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
25029 | |||
25030 | /** | ||
25031 | * A specialized version of `baseIsEqualDeep` for objects with support for | ||
25032 | * partial deep comparisons. | ||
25033 | * | ||
25034 | * @private | ||
25035 | * @param {Object} object The object to compare. | ||
25036 | * @param {Object} other The other object to compare. | ||
25037 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | ||
25038 | * @param {Function} customizer The function to customize comparisons. | ||
25039 | * @param {Function} equalFunc The function to determine equivalents of values. | ||
25040 | * @param {Object} stack Tracks traversed `object` and `other` objects. | ||
25041 | * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. | ||
25042 | */ | ||
25043 | function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { | ||
25044 | var isPartial = bitmask & COMPARE_PARTIAL_FLAG, | ||
25045 | objProps = getAllKeys(object), | ||
25046 | objLength = objProps.length, | ||
25047 | othProps = getAllKeys(other), | ||
25048 | othLength = othProps.length; | ||
25049 | |||
25050 | if (objLength != othLength && !isPartial) { | ||
25051 | return false; | ||
25052 | } | ||
25053 | var index = objLength; | ||
25054 | while (index--) { | ||
25055 | var key = objProps[index]; | ||
25056 | if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { | ||
25057 | return false; | ||
25058 | } | ||
25059 | } | ||
25060 | // Assume cyclic values are equal. | ||
25061 | var stacked = stack.get(object); | ||
25062 | if (stacked && stack.get(other)) { | ||
25063 | return stacked == other; | ||
25064 | } | ||
25065 | var result = true; | ||
25066 | stack.set(object, other); | ||
25067 | stack.set(other, object); | ||
25068 | |||
25069 | var skipCtor = isPartial; | ||
25070 | while (++index < objLength) { | ||
25071 | key = objProps[index]; | ||
25072 | var objValue = object[key], | ||
25073 | othValue = other[key]; | ||
25074 | |||
25075 | if (customizer) { | ||
25076 | var compared = isPartial | ||
25077 | ? customizer(othValue, objValue, key, other, object, stack) | ||
25078 | : customizer(objValue, othValue, key, object, other, stack); | ||
25079 | } | ||
25080 | // Recursively compare objects (susceptible to call stack limits). | ||
25081 | if (!(compared === undefined | ||
25082 | ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) | ||
25083 | : compared | ||
25084 | )) { | ||
25085 | result = false; | ||
25086 | break; | ||
25087 | } | ||
25088 | skipCtor || (skipCtor = key == 'constructor'); | ||
25089 | } | ||
25090 | if (result && !skipCtor) { | ||
25091 | var objCtor = object.constructor, | ||
25092 | othCtor = other.constructor; | ||
25093 | |||
25094 | // Non `Object` object instances with different constructors are not equal. | ||
25095 | if (objCtor != othCtor && | ||
25096 | ('constructor' in object && 'constructor' in other) && | ||
25097 | !(typeof objCtor == 'function' && objCtor instanceof objCtor && | ||
25098 | typeof othCtor == 'function' && othCtor instanceof othCtor)) { | ||
25099 | result = false; | ||
25100 | } | ||
25101 | } | ||
25102 | stack['delete'](object); | ||
25103 | stack['delete'](other); | ||
25104 | return result; | ||
25105 | } | ||
25106 | |||
25107 | module.exports = equalObjects; | ||
25108 | |||
25109 | },{"./_getAllKeys":237}],235:[function(require,module,exports){ | ||
25110 | var flatten = require('./flatten'), | ||
25111 | overRest = require('./_overRest'), | ||
25112 | setToString = require('./_setToString'); | ||
25113 | |||
25114 | /** | ||
25115 | * A specialized version of `baseRest` which flattens the rest array. | ||
25116 | * | ||
25117 | * @private | ||
25118 | * @param {Function} func The function to apply a rest parameter to. | ||
25119 | * @returns {Function} Returns the new function. | ||
25120 | */ | ||
25121 | function flatRest(func) { | ||
25122 | return setToString(overRest(func, undefined, flatten), func + ''); | ||
25123 | } | ||
25124 | |||
25125 | module.exports = flatRest; | ||
25126 | |||
25127 | },{"./_overRest":285,"./_setToString":290,"./flatten":312}],236:[function(require,module,exports){ | ||
25128 | (function (global){ | ||
25129 | /** Detect free variable `global` from Node.js. */ | ||
25130 | var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; | ||
25131 | |||
25132 | module.exports = freeGlobal; | ||
25133 | |||
25134 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | ||
25135 | },{}],237:[function(require,module,exports){ | ||
25136 | var baseGetAllKeys = require('./_baseGetAllKeys'), | ||
25137 | getSymbols = require('./_getSymbols'), | ||
25138 | keys = require('./keys'); | ||
25139 | |||
25140 | /** | ||
25141 | * Creates an array of own enumerable property names and symbols of `object`. | ||
25142 | * | ||
25143 | * @private | ||
25144 | * @param {Object} object The object to query. | ||
25145 | * @returns {Array} Returns the array of property names and symbols. | ||
25146 | */ | ||
25147 | function getAllKeys(object) { | ||
25148 | return baseGetAllKeys(object, keys, getSymbols); | ||
25149 | } | ||
25150 | |||
25151 | module.exports = getAllKeys; | ||
25152 | |||
25153 | },{"./_baseGetAllKeys":179,"./_getSymbols":244,"./keys":337}],238:[function(require,module,exports){ | ||
25154 | var baseGetAllKeys = require('./_baseGetAllKeys'), | ||
25155 | getSymbolsIn = require('./_getSymbolsIn'), | ||
25156 | keysIn = require('./keysIn'); | ||
25157 | |||
25158 | /** | ||
25159 | * Creates an array of own and inherited enumerable property names and | ||
25160 | * symbols of `object`. | ||
25161 | * | ||
25162 | * @private | ||
25163 | * @param {Object} object The object to query. | ||
25164 | * @returns {Array} Returns the array of property names and symbols. | ||
25165 | */ | ||
25166 | function getAllKeysIn(object) { | ||
25167 | return baseGetAllKeys(object, keysIn, getSymbolsIn); | ||
25168 | } | ||
25169 | |||
25170 | module.exports = getAllKeysIn; | ||
25171 | |||
25172 | },{"./_baseGetAllKeys":179,"./_getSymbolsIn":245,"./keysIn":338}],239:[function(require,module,exports){ | ||
25173 | var isKeyable = require('./_isKeyable'); | ||
25174 | |||
25175 | /** | ||
25176 | * Gets the data for `map`. | ||
25177 | * | ||
25178 | * @private | ||
25179 | * @param {Object} map The map to query. | ||
25180 | * @param {string} key The reference key. | ||
25181 | * @returns {*} Returns the map data. | ||
25182 | */ | ||
25183 | function getMapData(map, key) { | ||
25184 | var data = map.__data__; | ||
25185 | return isKeyable(key) | ||
25186 | ? data[typeof key == 'string' ? 'string' : 'hash'] | ||
25187 | : data.map; | ||
25188 | } | ||
25189 | |||
25190 | module.exports = getMapData; | ||
25191 | |||
25192 | },{"./_isKeyable":262}],240:[function(require,module,exports){ | ||
25193 | var isStrictComparable = require('./_isStrictComparable'), | ||
25194 | keys = require('./keys'); | ||
25195 | |||
25196 | /** | ||
25197 | * Gets the property names, values, and compare flags of `object`. | ||
25198 | * | ||
25199 | * @private | ||
25200 | * @param {Object} object The object to query. | ||
25201 | * @returns {Array} Returns the match data of `object`. | ||
25202 | */ | ||
25203 | function getMatchData(object) { | ||
25204 | var result = keys(object), | ||
25205 | length = result.length; | ||
25206 | |||
25207 | while (length--) { | ||
25208 | var key = result[length], | ||
25209 | value = object[key]; | ||
25210 | |||
25211 | result[length] = [key, value, isStrictComparable(value)]; | ||
25212 | } | ||
25213 | return result; | ||
25214 | } | ||
25215 | |||
25216 | module.exports = getMatchData; | ||
25217 | |||
25218 | },{"./_isStrictComparable":265,"./keys":337}],241:[function(require,module,exports){ | ||
25219 | var baseIsNative = require('./_baseIsNative'), | ||
25220 | getValue = require('./_getValue'); | ||
25221 | |||
25222 | /** | ||
25223 | * Gets the native function at `key` of `object`. | ||
25224 | * | ||
25225 | * @private | ||
25226 | * @param {Object} object The object to query. | ||
25227 | * @param {string} key The key of the method to get. | ||
25228 | * @returns {*} Returns the function if it's native, else `undefined`. | ||
25229 | */ | ||
25230 | function getNative(object, key) { | ||
25231 | var value = getValue(object, key); | ||
25232 | return baseIsNative(value) ? value : undefined; | ||
25233 | } | ||
25234 | |||
25235 | module.exports = getNative; | ||
25236 | |||
25237 | },{"./_baseIsNative":189,"./_getValue":247}],242:[function(require,module,exports){ | ||
25238 | var overArg = require('./_overArg'); | ||
25239 | |||
25240 | /** Built-in value references. */ | ||
25241 | var getPrototype = overArg(Object.getPrototypeOf, Object); | ||
25242 | |||
25243 | module.exports = getPrototype; | ||
25244 | |||
25245 | },{"./_overArg":284}],243:[function(require,module,exports){ | ||
25246 | var Symbol = require('./_Symbol'); | ||
25247 | |||
25248 | /** Used for built-in method references. */ | ||
25249 | var objectProto = Object.prototype; | ||
25250 | |||
25251 | /** Used to check objects for own properties. */ | ||
25252 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
25253 | |||
25254 | /** | ||
25255 | * Used to resolve the | ||
25256 | * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) | ||
25257 | * of values. | ||
25258 | */ | ||
25259 | var nativeObjectToString = objectProto.toString; | ||
25260 | |||
25261 | /** Built-in value references. */ | ||
25262 | var symToStringTag = Symbol ? Symbol.toStringTag : undefined; | ||
25263 | |||
25264 | /** | ||
25265 | * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. | ||
25266 | * | ||
25267 | * @private | ||
25268 | * @param {*} value The value to query. | ||
25269 | * @returns {string} Returns the raw `toStringTag`. | ||
25270 | */ | ||
25271 | function getRawTag(value) { | ||
25272 | var isOwn = hasOwnProperty.call(value, symToStringTag), | ||
25273 | tag = value[symToStringTag]; | ||
25274 | |||
25275 | try { | ||
25276 | value[symToStringTag] = undefined; | ||
25277 | var unmasked = true; | ||
25278 | } catch (e) {} | ||
25279 | |||
25280 | var result = nativeObjectToString.call(value); | ||
25281 | if (unmasked) { | ||
25282 | if (isOwn) { | ||
25283 | value[symToStringTag] = tag; | ||
25284 | } else { | ||
25285 | delete value[symToStringTag]; | ||
25286 | } | ||
25287 | } | ||
25288 | return result; | ||
25289 | } | ||
25290 | |||
25291 | module.exports = getRawTag; | ||
25292 | |||
25293 | },{"./_Symbol":152}],244:[function(require,module,exports){ | ||
25294 | var arrayFilter = require('./_arrayFilter'), | ||
25295 | stubArray = require('./stubArray'); | ||
25296 | |||
25297 | /** Used for built-in method references. */ | ||
25298 | var objectProto = Object.prototype; | ||
25299 | |||
25300 | /** Built-in value references. */ | ||
25301 | var propertyIsEnumerable = objectProto.propertyIsEnumerable; | ||
25302 | |||
25303 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
25304 | var nativeGetSymbols = Object.getOwnPropertySymbols; | ||
25305 | |||
25306 | /** | ||
25307 | * Creates an array of the own enumerable symbols of `object`. | ||
25308 | * | ||
25309 | * @private | ||
25310 | * @param {Object} object The object to query. | ||
25311 | * @returns {Array} Returns the array of symbols. | ||
25312 | */ | ||
25313 | var getSymbols = !nativeGetSymbols ? stubArray : function(object) { | ||
25314 | if (object == null) { | ||
25315 | return []; | ||
25316 | } | ||
25317 | object = Object(object); | ||
25318 | return arrayFilter(nativeGetSymbols(object), function(symbol) { | ||
25319 | return propertyIsEnumerable.call(object, symbol); | ||
25320 | }); | ||
25321 | }; | ||
25322 | |||
25323 | module.exports = getSymbols; | ||
25324 | |||
25325 | },{"./_arrayFilter":158,"./stubArray":344}],245:[function(require,module,exports){ | ||
25326 | var arrayPush = require('./_arrayPush'), | ||
25327 | getPrototype = require('./_getPrototype'), | ||
25328 | getSymbols = require('./_getSymbols'), | ||
25329 | stubArray = require('./stubArray'); | ||
25330 | |||
25331 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
25332 | var nativeGetSymbols = Object.getOwnPropertySymbols; | ||
25333 | |||
25334 | /** | ||
25335 | * Creates an array of the own and inherited enumerable symbols of `object`. | ||
25336 | * | ||
25337 | * @private | ||
25338 | * @param {Object} object The object to query. | ||
25339 | * @returns {Array} Returns the array of symbols. | ||
25340 | */ | ||
25341 | var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { | ||
25342 | var result = []; | ||
25343 | while (object) { | ||
25344 | arrayPush(result, getSymbols(object)); | ||
25345 | object = getPrototype(object); | ||
25346 | } | ||
25347 | return result; | ||
25348 | }; | ||
25349 | |||
25350 | module.exports = getSymbolsIn; | ||
25351 | |||
25352 | },{"./_arrayPush":161,"./_getPrototype":242,"./_getSymbols":244,"./stubArray":344}],246:[function(require,module,exports){ | ||
25353 | var DataView = require('./_DataView'), | ||
25354 | Map = require('./_Map'), | ||
25355 | Promise = require('./_Promise'), | ||
25356 | Set = require('./_Set'), | ||
25357 | WeakMap = require('./_WeakMap'), | ||
25358 | baseGetTag = require('./_baseGetTag'), | ||
25359 | toSource = require('./_toSource'); | ||
25360 | |||
25361 | /** `Object#toString` result references. */ | ||
25362 | var mapTag = '[object Map]', | ||
25363 | objectTag = '[object Object]', | ||
25364 | promiseTag = '[object Promise]', | ||
25365 | setTag = '[object Set]', | ||
25366 | weakMapTag = '[object WeakMap]'; | ||
25367 | |||
25368 | var dataViewTag = '[object DataView]'; | ||
25369 | |||
25370 | /** Used to detect maps, sets, and weakmaps. */ | ||
25371 | var dataViewCtorString = toSource(DataView), | ||
25372 | mapCtorString = toSource(Map), | ||
25373 | promiseCtorString = toSource(Promise), | ||
25374 | setCtorString = toSource(Set), | ||
25375 | weakMapCtorString = toSource(WeakMap); | ||
25376 | |||
25377 | /** | ||
25378 | * Gets the `toStringTag` of `value`. | ||
25379 | * | ||
25380 | * @private | ||
25381 | * @param {*} value The value to query. | ||
25382 | * @returns {string} Returns the `toStringTag`. | ||
25383 | */ | ||
25384 | var getTag = baseGetTag; | ||
25385 | |||
25386 | // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. | ||
25387 | if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || | ||
25388 | (Map && getTag(new Map) != mapTag) || | ||
25389 | (Promise && getTag(Promise.resolve()) != promiseTag) || | ||
25390 | (Set && getTag(new Set) != setTag) || | ||
25391 | (WeakMap && getTag(new WeakMap) != weakMapTag)) { | ||
25392 | getTag = function(value) { | ||
25393 | var result = baseGetTag(value), | ||
25394 | Ctor = result == objectTag ? value.constructor : undefined, | ||
25395 | ctorString = Ctor ? toSource(Ctor) : ''; | ||
25396 | |||
25397 | if (ctorString) { | ||
25398 | switch (ctorString) { | ||
25399 | case dataViewCtorString: return dataViewTag; | ||
25400 | case mapCtorString: return mapTag; | ||
25401 | case promiseCtorString: return promiseTag; | ||
25402 | case setCtorString: return setTag; | ||
25403 | case weakMapCtorString: return weakMapTag; | ||
25404 | } | ||
25405 | } | ||
25406 | return result; | ||
25407 | }; | ||
25408 | } | ||
25409 | |||
25410 | module.exports = getTag; | ||
25411 | |||
25412 | },{"./_DataView":143,"./_Map":146,"./_Promise":148,"./_Set":149,"./_WeakMap":154,"./_baseGetTag":180,"./_toSource":302}],247:[function(require,module,exports){ | ||
25413 | /** | ||
25414 | * Gets the value at `key` of `object`. | ||
25415 | * | ||
25416 | * @private | ||
25417 | * @param {Object} [object] The object to query. | ||
25418 | * @param {string} key The key of the property to get. | ||
25419 | * @returns {*} Returns the property value. | ||
25420 | */ | ||
25421 | function getValue(object, key) { | ||
25422 | return object == null ? undefined : object[key]; | ||
25423 | } | ||
25424 | |||
25425 | module.exports = getValue; | ||
25426 | |||
25427 | },{}],248:[function(require,module,exports){ | ||
25428 | var castPath = require('./_castPath'), | ||
25429 | isArguments = require('./isArguments'), | ||
25430 | isArray = require('./isArray'), | ||
25431 | isIndex = require('./_isIndex'), | ||
25432 | isLength = require('./isLength'), | ||
25433 | toKey = require('./_toKey'); | ||
25434 | |||
25435 | /** | ||
25436 | * Checks if `path` exists on `object`. | ||
25437 | * | ||
25438 | * @private | ||
25439 | * @param {Object} object The object to query. | ||
25440 | * @param {Array|string} path The path to check. | ||
25441 | * @param {Function} hasFunc The function to check properties. | ||
25442 | * @returns {boolean} Returns `true` if `path` exists, else `false`. | ||
25443 | */ | ||
25444 | function hasPath(object, path, hasFunc) { | ||
25445 | path = castPath(path, object); | ||
25446 | |||
25447 | var index = -1, | ||
25448 | length = path.length, | ||
25449 | result = false; | ||
25450 | |||
25451 | while (++index < length) { | ||
25452 | var key = toKey(path[index]); | ||
25453 | if (!(result = object != null && hasFunc(object, key))) { | ||
25454 | break; | ||
25455 | } | ||
25456 | object = object[key]; | ||
25457 | } | ||
25458 | if (result || ++index != length) { | ||
25459 | return result; | ||
25460 | } | ||
25461 | length = object == null ? 0 : object.length; | ||
25462 | return !!length && isLength(length) && isIndex(key, length) && | ||
25463 | (isArray(object) || isArguments(object)); | ||
25464 | } | ||
25465 | |||
25466 | module.exports = hasPath; | ||
25467 | |||
25468 | },{"./_castPath":213,"./_isIndex":259,"./_toKey":301,"./isArguments":318,"./isArray":319,"./isLength":325}],249:[function(require,module,exports){ | ||
25469 | /** Used to compose unicode character classes. */ | ||
25470 | var rsAstralRange = '\\ud800-\\udfff', | ||
25471 | rsComboMarksRange = '\\u0300-\\u036f', | ||
25472 | reComboHalfMarksRange = '\\ufe20-\\ufe2f', | ||
25473 | rsComboSymbolsRange = '\\u20d0-\\u20ff', | ||
25474 | rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, | ||
25475 | rsVarRange = '\\ufe0e\\ufe0f'; | ||
25476 | |||
25477 | /** Used to compose unicode capture groups. */ | ||
25478 | var rsZWJ = '\\u200d'; | ||
25479 | |||
25480 | /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ | ||
25481 | var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']'); | ||
25482 | |||
25483 | /** | ||
25484 | * Checks if `string` contains Unicode symbols. | ||
25485 | * | ||
25486 | * @private | ||
25487 | * @param {string} string The string to inspect. | ||
25488 | * @returns {boolean} Returns `true` if a symbol is found, else `false`. | ||
25489 | */ | ||
25490 | function hasUnicode(string) { | ||
25491 | return reHasUnicode.test(string); | ||
25492 | } | ||
25493 | |||
25494 | module.exports = hasUnicode; | ||
25495 | |||
25496 | },{}],250:[function(require,module,exports){ | ||
25497 | var nativeCreate = require('./_nativeCreate'); | ||
25498 | |||
25499 | /** | ||
25500 | * Removes all key-value entries from the hash. | ||
25501 | * | ||
25502 | * @private | ||
25503 | * @name clear | ||
25504 | * @memberOf Hash | ||
25505 | */ | ||
25506 | function hashClear() { | ||
25507 | this.__data__ = nativeCreate ? nativeCreate(null) : {}; | ||
25508 | this.size = 0; | ||
25509 | } | ||
25510 | |||
25511 | module.exports = hashClear; | ||
25512 | |||
25513 | },{"./_nativeCreate":279}],251:[function(require,module,exports){ | ||
25514 | /** | ||
25515 | * Removes `key` and its value from the hash. | ||
25516 | * | ||
25517 | * @private | ||
25518 | * @name delete | ||
25519 | * @memberOf Hash | ||
25520 | * @param {Object} hash The hash to modify. | ||
25521 | * @param {string} key The key of the value to remove. | ||
25522 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | ||
25523 | */ | ||
25524 | function hashDelete(key) { | ||
25525 | var result = this.has(key) && delete this.__data__[key]; | ||
25526 | this.size -= result ? 1 : 0; | ||
25527 | return result; | ||
25528 | } | ||
25529 | |||
25530 | module.exports = hashDelete; | ||
25531 | |||
25532 | },{}],252:[function(require,module,exports){ | ||
25533 | var nativeCreate = require('./_nativeCreate'); | ||
25534 | |||
25535 | /** Used to stand-in for `undefined` hash values. */ | ||
25536 | var HASH_UNDEFINED = '__lodash_hash_undefined__'; | ||
25537 | |||
25538 | /** Used for built-in method references. */ | ||
25539 | var objectProto = Object.prototype; | ||
25540 | |||
25541 | /** Used to check objects for own properties. */ | ||
25542 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
25543 | |||
25544 | /** | ||
25545 | * Gets the hash value for `key`. | ||
25546 | * | ||
25547 | * @private | ||
25548 | * @name get | ||
25549 | * @memberOf Hash | ||
25550 | * @param {string} key The key of the value to get. | ||
25551 | * @returns {*} Returns the entry value. | ||
25552 | */ | ||
25553 | function hashGet(key) { | ||
25554 | var data = this.__data__; | ||
25555 | if (nativeCreate) { | ||
25556 | var result = data[key]; | ||
25557 | return result === HASH_UNDEFINED ? undefined : result; | ||
25558 | } | ||
25559 | return hasOwnProperty.call(data, key) ? data[key] : undefined; | ||
25560 | } | ||
25561 | |||
25562 | module.exports = hashGet; | ||
25563 | |||
25564 | },{"./_nativeCreate":279}],253:[function(require,module,exports){ | ||
25565 | var nativeCreate = require('./_nativeCreate'); | ||
25566 | |||
25567 | /** Used for built-in method references. */ | ||
25568 | var objectProto = Object.prototype; | ||
25569 | |||
25570 | /** Used to check objects for own properties. */ | ||
25571 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
25572 | |||
25573 | /** | ||
25574 | * Checks if a hash value for `key` exists. | ||
25575 | * | ||
25576 | * @private | ||
25577 | * @name has | ||
25578 | * @memberOf Hash | ||
25579 | * @param {string} key The key of the entry to check. | ||
25580 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
25581 | */ | ||
25582 | function hashHas(key) { | ||
25583 | var data = this.__data__; | ||
25584 | return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); | ||
25585 | } | ||
25586 | |||
25587 | module.exports = hashHas; | ||
25588 | |||
25589 | },{"./_nativeCreate":279}],254:[function(require,module,exports){ | ||
25590 | var nativeCreate = require('./_nativeCreate'); | ||
25591 | |||
25592 | /** Used to stand-in for `undefined` hash values. */ | ||
25593 | var HASH_UNDEFINED = '__lodash_hash_undefined__'; | ||
25594 | |||
25595 | /** | ||
25596 | * Sets the hash `key` to `value`. | ||
25597 | * | ||
25598 | * @private | ||
25599 | * @name set | ||
25600 | * @memberOf Hash | ||
25601 | * @param {string} key The key of the value to set. | ||
25602 | * @param {*} value The value to set. | ||
25603 | * @returns {Object} Returns the hash instance. | ||
25604 | */ | ||
25605 | function hashSet(key, value) { | ||
25606 | var data = this.__data__; | ||
25607 | this.size += this.has(key) ? 0 : 1; | ||
25608 | data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; | ||
25609 | return this; | ||
25610 | } | ||
25611 | |||
25612 | module.exports = hashSet; | ||
25613 | |||
25614 | },{"./_nativeCreate":279}],255:[function(require,module,exports){ | ||
25615 | /** Used for built-in method references. */ | ||
25616 | var objectProto = Object.prototype; | ||
25617 | |||
25618 | /** Used to check objects for own properties. */ | ||
25619 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
25620 | |||
25621 | /** | ||
25622 | * Initializes an array clone. | ||
25623 | * | ||
25624 | * @private | ||
25625 | * @param {Array} array The array to clone. | ||
25626 | * @returns {Array} Returns the initialized clone. | ||
25627 | */ | ||
25628 | function initCloneArray(array) { | ||
25629 | var length = array.length, | ||
25630 | result = new array.constructor(length); | ||
25631 | |||
25632 | // Add properties assigned by `RegExp#exec`. | ||
25633 | if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { | ||
25634 | result.index = array.index; | ||
25635 | result.input = array.input; | ||
25636 | } | ||
25637 | return result; | ||
25638 | } | ||
25639 | |||
25640 | module.exports = initCloneArray; | ||
25641 | |||
25642 | },{}],256:[function(require,module,exports){ | ||
25643 | var cloneArrayBuffer = require('./_cloneArrayBuffer'), | ||
25644 | cloneDataView = require('./_cloneDataView'), | ||
25645 | cloneRegExp = require('./_cloneRegExp'), | ||
25646 | cloneSymbol = require('./_cloneSymbol'), | ||
25647 | cloneTypedArray = require('./_cloneTypedArray'); | ||
25648 | |||
25649 | /** `Object#toString` result references. */ | ||
25650 | var boolTag = '[object Boolean]', | ||
25651 | dateTag = '[object Date]', | ||
25652 | mapTag = '[object Map]', | ||
25653 | numberTag = '[object Number]', | ||
25654 | regexpTag = '[object RegExp]', | ||
25655 | setTag = '[object Set]', | ||
25656 | stringTag = '[object String]', | ||
25657 | symbolTag = '[object Symbol]'; | ||
25658 | |||
25659 | var arrayBufferTag = '[object ArrayBuffer]', | ||
25660 | dataViewTag = '[object DataView]', | ||
25661 | float32Tag = '[object Float32Array]', | ||
25662 | float64Tag = '[object Float64Array]', | ||
25663 | int8Tag = '[object Int8Array]', | ||
25664 | int16Tag = '[object Int16Array]', | ||
25665 | int32Tag = '[object Int32Array]', | ||
25666 | uint8Tag = '[object Uint8Array]', | ||
25667 | uint8ClampedTag = '[object Uint8ClampedArray]', | ||
25668 | uint16Tag = '[object Uint16Array]', | ||
25669 | uint32Tag = '[object Uint32Array]'; | ||
25670 | |||
25671 | /** | ||
25672 | * Initializes an object clone based on its `toStringTag`. | ||
25673 | * | ||
25674 | * **Note:** This function only supports cloning values with tags of | ||
25675 | * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. | ||
25676 | * | ||
25677 | * @private | ||
25678 | * @param {Object} object The object to clone. | ||
25679 | * @param {string} tag The `toStringTag` of the object to clone. | ||
25680 | * @param {boolean} [isDeep] Specify a deep clone. | ||
25681 | * @returns {Object} Returns the initialized clone. | ||
25682 | */ | ||
25683 | function initCloneByTag(object, tag, isDeep) { | ||
25684 | var Ctor = object.constructor; | ||
25685 | switch (tag) { | ||
25686 | case arrayBufferTag: | ||
25687 | return cloneArrayBuffer(object); | ||
25688 | |||
25689 | case boolTag: | ||
25690 | case dateTag: | ||
25691 | return new Ctor(+object); | ||
25692 | |||
25693 | case dataViewTag: | ||
25694 | return cloneDataView(object, isDeep); | ||
25695 | |||
25696 | case float32Tag: case float64Tag: | ||
25697 | case int8Tag: case int16Tag: case int32Tag: | ||
25698 | case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: | ||
25699 | return cloneTypedArray(object, isDeep); | ||
25700 | |||
25701 | case mapTag: | ||
25702 | return new Ctor; | ||
25703 | |||
25704 | case numberTag: | ||
25705 | case stringTag: | ||
25706 | return new Ctor(object); | ||
25707 | |||
25708 | case regexpTag: | ||
25709 | return cloneRegExp(object); | ||
25710 | |||
25711 | case setTag: | ||
25712 | return new Ctor; | ||
25713 | |||
25714 | case symbolTag: | ||
25715 | return cloneSymbol(object); | ||
25716 | } | ||
25717 | } | ||
25718 | |||
25719 | module.exports = initCloneByTag; | ||
25720 | |||
25721 | },{"./_cloneArrayBuffer":216,"./_cloneDataView":218,"./_cloneRegExp":219,"./_cloneSymbol":220,"./_cloneTypedArray":221}],257:[function(require,module,exports){ | ||
25722 | var baseCreate = require('./_baseCreate'), | ||
25723 | getPrototype = require('./_getPrototype'), | ||
25724 | isPrototype = require('./_isPrototype'); | ||
25725 | |||
25726 | /** | ||
25727 | * Initializes an object clone. | ||
25728 | * | ||
25729 | * @private | ||
25730 | * @param {Object} object The object to clone. | ||
25731 | * @returns {Object} Returns the initialized clone. | ||
25732 | */ | ||
25733 | function initCloneObject(object) { | ||
25734 | return (typeof object.constructor == 'function' && !isPrototype(object)) | ||
25735 | ? baseCreate(getPrototype(object)) | ||
25736 | : {}; | ||
25737 | } | ||
25738 | |||
25739 | module.exports = initCloneObject; | ||
25740 | |||
25741 | },{"./_baseCreate":171,"./_getPrototype":242,"./_isPrototype":264}],258:[function(require,module,exports){ | ||
25742 | var Symbol = require('./_Symbol'), | ||
25743 | isArguments = require('./isArguments'), | ||
25744 | isArray = require('./isArray'); | ||
25745 | |||
25746 | /** Built-in value references. */ | ||
25747 | var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined; | ||
25748 | |||
25749 | /** | ||
25750 | * Checks if `value` is a flattenable `arguments` object or array. | ||
25751 | * | ||
25752 | * @private | ||
25753 | * @param {*} value The value to check. | ||
25754 | * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. | ||
25755 | */ | ||
25756 | function isFlattenable(value) { | ||
25757 | return isArray(value) || isArguments(value) || | ||
25758 | !!(spreadableSymbol && value && value[spreadableSymbol]); | ||
25759 | } | ||
25760 | |||
25761 | module.exports = isFlattenable; | ||
25762 | |||
25763 | },{"./_Symbol":152,"./isArguments":318,"./isArray":319}],259:[function(require,module,exports){ | ||
25764 | /** Used as references for various `Number` constants. */ | ||
25765 | var MAX_SAFE_INTEGER = 9007199254740991; | ||
25766 | |||
25767 | /** Used to detect unsigned integer values. */ | ||
25768 | var reIsUint = /^(?:0|[1-9]\d*)$/; | ||
25769 | |||
25770 | /** | ||
25771 | * Checks if `value` is a valid array-like index. | ||
25772 | * | ||
25773 | * @private | ||
25774 | * @param {*} value The value to check. | ||
25775 | * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. | ||
25776 | * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. | ||
25777 | */ | ||
25778 | function isIndex(value, length) { | ||
25779 | var type = typeof value; | ||
25780 | length = length == null ? MAX_SAFE_INTEGER : length; | ||
25781 | |||
25782 | return !!length && | ||
25783 | (type == 'number' || | ||
25784 | (type != 'symbol' && reIsUint.test(value))) && | ||
25785 | (value > -1 && value % 1 == 0 && value < length); | ||
25786 | } | ||
25787 | |||
25788 | module.exports = isIndex; | ||
25789 | |||
25790 | },{}],260:[function(require,module,exports){ | ||
25791 | var eq = require('./eq'), | ||
25792 | isArrayLike = require('./isArrayLike'), | ||
25793 | isIndex = require('./_isIndex'), | ||
25794 | isObject = require('./isObject'); | ||
25795 | |||
25796 | /** | ||
25797 | * Checks if the given arguments are from an iteratee call. | ||
25798 | * | ||
25799 | * @private | ||
25800 | * @param {*} value The potential iteratee value argument. | ||
25801 | * @param {*} index The potential iteratee index or key argument. | ||
25802 | * @param {*} object The potential iteratee object argument. | ||
25803 | * @returns {boolean} Returns `true` if the arguments are from an iteratee call, | ||
25804 | * else `false`. | ||
25805 | */ | ||
25806 | function isIterateeCall(value, index, object) { | ||
25807 | if (!isObject(object)) { | ||
25808 | return false; | ||
25809 | } | ||
25810 | var type = typeof index; | ||
25811 | if (type == 'number' | ||
25812 | ? (isArrayLike(object) && isIndex(index, object.length)) | ||
25813 | : (type == 'string' && index in object) | ||
25814 | ) { | ||
25815 | return eq(object[index], value); | ||
25816 | } | ||
25817 | return false; | ||
25818 | } | ||
25819 | |||
25820 | module.exports = isIterateeCall; | ||
25821 | |||
25822 | },{"./_isIndex":259,"./eq":309,"./isArrayLike":320,"./isObject":329}],261:[function(require,module,exports){ | ||
25823 | var isArray = require('./isArray'), | ||
25824 | isSymbol = require('./isSymbol'); | ||
25825 | |||
25826 | /** Used to match property names within property paths. */ | ||
25827 | var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, | ||
25828 | reIsPlainProp = /^\w*$/; | ||
25829 | |||
25830 | /** | ||
25831 | * Checks if `value` is a property name and not a property path. | ||
25832 | * | ||
25833 | * @private | ||
25834 | * @param {*} value The value to check. | ||
25835 | * @param {Object} [object] The object to query keys on. | ||
25836 | * @returns {boolean} Returns `true` if `value` is a property name, else `false`. | ||
25837 | */ | ||
25838 | function isKey(value, object) { | ||
25839 | if (isArray(value)) { | ||
25840 | return false; | ||
25841 | } | ||
25842 | var type = typeof value; | ||
25843 | if (type == 'number' || type == 'symbol' || type == 'boolean' || | ||
25844 | value == null || isSymbol(value)) { | ||
25845 | return true; | ||
25846 | } | ||
25847 | return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || | ||
25848 | (object != null && value in Object(object)); | ||
25849 | } | ||
25850 | |||
25851 | module.exports = isKey; | ||
25852 | |||
25853 | },{"./isArray":319,"./isSymbol":334}],262:[function(require,module,exports){ | ||
25854 | /** | ||
25855 | * Checks if `value` is suitable for use as unique object key. | ||
25856 | * | ||
25857 | * @private | ||
25858 | * @param {*} value The value to check. | ||
25859 | * @returns {boolean} Returns `true` if `value` is suitable, else `false`. | ||
25860 | */ | ||
25861 | function isKeyable(value) { | ||
25862 | var type = typeof value; | ||
25863 | return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') | ||
25864 | ? (value !== '__proto__') | ||
25865 | : (value === null); | ||
25866 | } | ||
25867 | |||
25868 | module.exports = isKeyable; | ||
25869 | |||
25870 | },{}],263:[function(require,module,exports){ | ||
25871 | var coreJsData = require('./_coreJsData'); | ||
25872 | |||
25873 | /** Used to detect methods masquerading as native. */ | ||
25874 | var maskSrcKey = (function() { | ||
25875 | var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); | ||
25876 | return uid ? ('Symbol(src)_1.' + uid) : ''; | ||
25877 | }()); | ||
25878 | |||
25879 | /** | ||
25880 | * Checks if `func` has its source masked. | ||
25881 | * | ||
25882 | * @private | ||
25883 | * @param {Function} func The function to check. | ||
25884 | * @returns {boolean} Returns `true` if `func` is masked, else `false`. | ||
25885 | */ | ||
25886 | function isMasked(func) { | ||
25887 | return !!maskSrcKey && (maskSrcKey in func); | ||
25888 | } | ||
25889 | |||
25890 | module.exports = isMasked; | ||
25891 | |||
25892 | },{"./_coreJsData":226}],264:[function(require,module,exports){ | ||
25893 | /** Used for built-in method references. */ | ||
25894 | var objectProto = Object.prototype; | ||
25895 | |||
25896 | /** | ||
25897 | * Checks if `value` is likely a prototype object. | ||
25898 | * | ||
25899 | * @private | ||
25900 | * @param {*} value The value to check. | ||
25901 | * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. | ||
25902 | */ | ||
25903 | function isPrototype(value) { | ||
25904 | var Ctor = value && value.constructor, | ||
25905 | proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; | ||
25906 | |||
25907 | return value === proto; | ||
25908 | } | ||
25909 | |||
25910 | module.exports = isPrototype; | ||
25911 | |||
25912 | },{}],265:[function(require,module,exports){ | ||
25913 | var isObject = require('./isObject'); | ||
25914 | |||
25915 | /** | ||
25916 | * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. | ||
25917 | * | ||
25918 | * @private | ||
25919 | * @param {*} value The value to check. | ||
25920 | * @returns {boolean} Returns `true` if `value` if suitable for strict | ||
25921 | * equality comparisons, else `false`. | ||
25922 | */ | ||
25923 | function isStrictComparable(value) { | ||
25924 | return value === value && !isObject(value); | ||
25925 | } | ||
25926 | |||
25927 | module.exports = isStrictComparable; | ||
25928 | |||
25929 | },{"./isObject":329}],266:[function(require,module,exports){ | ||
25930 | /** | ||
25931 | * Removes all key-value entries from the list cache. | ||
25932 | * | ||
25933 | * @private | ||
25934 | * @name clear | ||
25935 | * @memberOf ListCache | ||
25936 | */ | ||
25937 | function listCacheClear() { | ||
25938 | this.__data__ = []; | ||
25939 | this.size = 0; | ||
25940 | } | ||
25941 | |||
25942 | module.exports = listCacheClear; | ||
25943 | |||
25944 | },{}],267:[function(require,module,exports){ | ||
25945 | var assocIndexOf = require('./_assocIndexOf'); | ||
25946 | |||
25947 | /** Used for built-in method references. */ | ||
25948 | var arrayProto = Array.prototype; | ||
25949 | |||
25950 | /** Built-in value references. */ | ||
25951 | var splice = arrayProto.splice; | ||
25952 | |||
25953 | /** | ||
25954 | * Removes `key` and its value from the list cache. | ||
25955 | * | ||
25956 | * @private | ||
25957 | * @name delete | ||
25958 | * @memberOf ListCache | ||
25959 | * @param {string} key The key of the value to remove. | ||
25960 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | ||
25961 | */ | ||
25962 | function listCacheDelete(key) { | ||
25963 | var data = this.__data__, | ||
25964 | index = assocIndexOf(data, key); | ||
25965 | |||
25966 | if (index < 0) { | ||
25967 | return false; | ||
25968 | } | ||
25969 | var lastIndex = data.length - 1; | ||
25970 | if (index == lastIndex) { | ||
25971 | data.pop(); | ||
25972 | } else { | ||
25973 | splice.call(data, index, 1); | ||
25974 | } | ||
25975 | --this.size; | ||
25976 | return true; | ||
25977 | } | ||
25978 | |||
25979 | module.exports = listCacheDelete; | ||
25980 | |||
25981 | },{"./_assocIndexOf":166}],268:[function(require,module,exports){ | ||
25982 | var assocIndexOf = require('./_assocIndexOf'); | ||
25983 | |||
25984 | /** | ||
25985 | * Gets the list cache value for `key`. | ||
25986 | * | ||
25987 | * @private | ||
25988 | * @name get | ||
25989 | * @memberOf ListCache | ||
25990 | * @param {string} key The key of the value to get. | ||
25991 | * @returns {*} Returns the entry value. | ||
25992 | */ | ||
25993 | function listCacheGet(key) { | ||
25994 | var data = this.__data__, | ||
25995 | index = assocIndexOf(data, key); | ||
25996 | |||
25997 | return index < 0 ? undefined : data[index][1]; | ||
25998 | } | ||
25999 | |||
26000 | module.exports = listCacheGet; | ||
26001 | |||
26002 | },{"./_assocIndexOf":166}],269:[function(require,module,exports){ | ||
26003 | var assocIndexOf = require('./_assocIndexOf'); | ||
26004 | |||
26005 | /** | ||
26006 | * Checks if a list cache value for `key` exists. | ||
26007 | * | ||
26008 | * @private | ||
26009 | * @name has | ||
26010 | * @memberOf ListCache | ||
26011 | * @param {string} key The key of the entry to check. | ||
26012 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
26013 | */ | ||
26014 | function listCacheHas(key) { | ||
26015 | return assocIndexOf(this.__data__, key) > -1; | ||
26016 | } | ||
26017 | |||
26018 | module.exports = listCacheHas; | ||
26019 | |||
26020 | },{"./_assocIndexOf":166}],270:[function(require,module,exports){ | ||
26021 | var assocIndexOf = require('./_assocIndexOf'); | ||
26022 | |||
26023 | /** | ||
26024 | * Sets the list cache `key` to `value`. | ||
26025 | * | ||
26026 | * @private | ||
26027 | * @name set | ||
26028 | * @memberOf ListCache | ||
26029 | * @param {string} key The key of the value to set. | ||
26030 | * @param {*} value The value to set. | ||
26031 | * @returns {Object} Returns the list cache instance. | ||
26032 | */ | ||
26033 | function listCacheSet(key, value) { | ||
26034 | var data = this.__data__, | ||
26035 | index = assocIndexOf(data, key); | ||
26036 | |||
26037 | if (index < 0) { | ||
26038 | ++this.size; | ||
26039 | data.push([key, value]); | ||
26040 | } else { | ||
26041 | data[index][1] = value; | ||
26042 | } | ||
26043 | return this; | ||
26044 | } | ||
26045 | |||
26046 | module.exports = listCacheSet; | ||
26047 | |||
26048 | },{"./_assocIndexOf":166}],271:[function(require,module,exports){ | ||
26049 | var Hash = require('./_Hash'), | ||
26050 | ListCache = require('./_ListCache'), | ||
26051 | Map = require('./_Map'); | ||
26052 | |||
26053 | /** | ||
26054 | * Removes all key-value entries from the map. | ||
26055 | * | ||
26056 | * @private | ||
26057 | * @name clear | ||
26058 | * @memberOf MapCache | ||
26059 | */ | ||
26060 | function mapCacheClear() { | ||
26061 | this.size = 0; | ||
26062 | this.__data__ = { | ||
26063 | 'hash': new Hash, | ||
26064 | 'map': new (Map || ListCache), | ||
26065 | 'string': new Hash | ||
26066 | }; | ||
26067 | } | ||
26068 | |||
26069 | module.exports = mapCacheClear; | ||
26070 | |||
26071 | },{"./_Hash":144,"./_ListCache":145,"./_Map":146}],272:[function(require,module,exports){ | ||
26072 | var getMapData = require('./_getMapData'); | ||
26073 | |||
26074 | /** | ||
26075 | * Removes `key` and its value from the map. | ||
26076 | * | ||
26077 | * @private | ||
26078 | * @name delete | ||
26079 | * @memberOf MapCache | ||
26080 | * @param {string} key The key of the value to remove. | ||
26081 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | ||
26082 | */ | ||
26083 | function mapCacheDelete(key) { | ||
26084 | var result = getMapData(this, key)['delete'](key); | ||
26085 | this.size -= result ? 1 : 0; | ||
26086 | return result; | ||
26087 | } | ||
26088 | |||
26089 | module.exports = mapCacheDelete; | ||
26090 | |||
26091 | },{"./_getMapData":239}],273:[function(require,module,exports){ | ||
26092 | var getMapData = require('./_getMapData'); | ||
26093 | |||
26094 | /** | ||
26095 | * Gets the map value for `key`. | ||
26096 | * | ||
26097 | * @private | ||
26098 | * @name get | ||
26099 | * @memberOf MapCache | ||
26100 | * @param {string} key The key of the value to get. | ||
26101 | * @returns {*} Returns the entry value. | ||
26102 | */ | ||
26103 | function mapCacheGet(key) { | ||
26104 | return getMapData(this, key).get(key); | ||
26105 | } | ||
26106 | |||
26107 | module.exports = mapCacheGet; | ||
26108 | |||
26109 | },{"./_getMapData":239}],274:[function(require,module,exports){ | ||
26110 | var getMapData = require('./_getMapData'); | ||
26111 | |||
26112 | /** | ||
26113 | * Checks if a map value for `key` exists. | ||
26114 | * | ||
26115 | * @private | ||
26116 | * @name has | ||
26117 | * @memberOf MapCache | ||
26118 | * @param {string} key The key of the entry to check. | ||
26119 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
26120 | */ | ||
26121 | function mapCacheHas(key) { | ||
26122 | return getMapData(this, key).has(key); | ||
26123 | } | ||
26124 | |||
26125 | module.exports = mapCacheHas; | ||
26126 | |||
26127 | },{"./_getMapData":239}],275:[function(require,module,exports){ | ||
26128 | var getMapData = require('./_getMapData'); | ||
26129 | |||
26130 | /** | ||
26131 | * Sets the map `key` to `value`. | ||
26132 | * | ||
26133 | * @private | ||
26134 | * @name set | ||
26135 | * @memberOf MapCache | ||
26136 | * @param {string} key The key of the value to set. | ||
26137 | * @param {*} value The value to set. | ||
26138 | * @returns {Object} Returns the map cache instance. | ||
26139 | */ | ||
26140 | function mapCacheSet(key, value) { | ||
26141 | var data = getMapData(this, key), | ||
26142 | size = data.size; | ||
26143 | |||
26144 | data.set(key, value); | ||
26145 | this.size += data.size == size ? 0 : 1; | ||
26146 | return this; | ||
26147 | } | ||
26148 | |||
26149 | module.exports = mapCacheSet; | ||
26150 | |||
26151 | },{"./_getMapData":239}],276:[function(require,module,exports){ | ||
26152 | /** | ||
26153 | * Converts `map` to its key-value pairs. | ||
26154 | * | ||
26155 | * @private | ||
26156 | * @param {Object} map The map to convert. | ||
26157 | * @returns {Array} Returns the key-value pairs. | ||
26158 | */ | ||
26159 | function mapToArray(map) { | ||
26160 | var index = -1, | ||
26161 | result = Array(map.size); | ||
26162 | |||
26163 | map.forEach(function(value, key) { | ||
26164 | result[++index] = [key, value]; | ||
26165 | }); | ||
26166 | return result; | ||
26167 | } | ||
26168 | |||
26169 | module.exports = mapToArray; | ||
26170 | |||
26171 | },{}],277:[function(require,module,exports){ | ||
26172 | /** | ||
26173 | * A specialized version of `matchesProperty` for source values suitable | ||
26174 | * for strict equality comparisons, i.e. `===`. | ||
26175 | * | ||
26176 | * @private | ||
26177 | * @param {string} key The key of the property to get. | ||
26178 | * @param {*} srcValue The value to match. | ||
26179 | * @returns {Function} Returns the new spec function. | ||
26180 | */ | ||
26181 | function matchesStrictComparable(key, srcValue) { | ||
26182 | return function(object) { | ||
26183 | if (object == null) { | ||
26184 | return false; | ||
26185 | } | ||
26186 | return object[key] === srcValue && | ||
26187 | (srcValue !== undefined || (key in Object(object))); | ||
26188 | }; | ||
26189 | } | ||
26190 | |||
26191 | module.exports = matchesStrictComparable; | ||
26192 | |||
26193 | },{}],278:[function(require,module,exports){ | ||
26194 | var memoize = require('./memoize'); | ||
26195 | |||
26196 | /** Used as the maximum memoize cache size. */ | ||
26197 | var MAX_MEMOIZE_SIZE = 500; | ||
26198 | |||
26199 | /** | ||
26200 | * A specialized version of `_.memoize` which clears the memoized function's | ||
26201 | * cache when it exceeds `MAX_MEMOIZE_SIZE`. | ||
26202 | * | ||
26203 | * @private | ||
26204 | * @param {Function} func The function to have its output memoized. | ||
26205 | * @returns {Function} Returns the new memoized function. | ||
26206 | */ | ||
26207 | function memoizeCapped(func) { | ||
26208 | var result = memoize(func, function(key) { | ||
26209 | if (cache.size === MAX_MEMOIZE_SIZE) { | ||
26210 | cache.clear(); | ||
26211 | } | ||
26212 | return key; | ||
26213 | }); | ||
26214 | |||
26215 | var cache = result.cache; | ||
26216 | return result; | ||
26217 | } | ||
26218 | |||
26219 | module.exports = memoizeCapped; | ||
26220 | |||
26221 | },{"./memoize":340}],279:[function(require,module,exports){ | ||
26222 | var getNative = require('./_getNative'); | ||
26223 | |||
26224 | /* Built-in method references that are verified to be native. */ | ||
26225 | var nativeCreate = getNative(Object, 'create'); | ||
26226 | |||
26227 | module.exports = nativeCreate; | ||
26228 | |||
26229 | },{"./_getNative":241}],280:[function(require,module,exports){ | ||
26230 | var overArg = require('./_overArg'); | ||
26231 | |||
26232 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
26233 | var nativeKeys = overArg(Object.keys, Object); | ||
26234 | |||
26235 | module.exports = nativeKeys; | ||
26236 | |||
26237 | },{"./_overArg":284}],281:[function(require,module,exports){ | ||
26238 | /** | ||
26239 | * This function is like | ||
26240 | * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) | ||
26241 | * except that it includes inherited enumerable properties. | ||
26242 | * | ||
26243 | * @private | ||
26244 | * @param {Object} object The object to query. | ||
26245 | * @returns {Array} Returns the array of property names. | ||
26246 | */ | ||
26247 | function nativeKeysIn(object) { | ||
26248 | var result = []; | ||
26249 | if (object != null) { | ||
26250 | for (var key in Object(object)) { | ||
26251 | result.push(key); | ||
26252 | } | ||
26253 | } | ||
26254 | return result; | ||
26255 | } | ||
26256 | |||
26257 | module.exports = nativeKeysIn; | ||
26258 | |||
26259 | },{}],282:[function(require,module,exports){ | ||
26260 | var freeGlobal = require('./_freeGlobal'); | ||
26261 | |||
26262 | /** Detect free variable `exports`. */ | ||
26263 | var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; | ||
26264 | |||
26265 | /** Detect free variable `module`. */ | ||
26266 | var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; | ||
26267 | |||
26268 | /** Detect the popular CommonJS extension `module.exports`. */ | ||
26269 | var moduleExports = freeModule && freeModule.exports === freeExports; | ||
26270 | |||
26271 | /** Detect free variable `process` from Node.js. */ | ||
26272 | var freeProcess = moduleExports && freeGlobal.process; | ||
26273 | |||
26274 | /** Used to access faster Node.js helpers. */ | ||
26275 | var nodeUtil = (function() { | ||
26276 | try { | ||
26277 | // Use `util.types` for Node.js 10+. | ||
26278 | var types = freeModule && freeModule.require && freeModule.require('util').types; | ||
26279 | |||
26280 | if (types) { | ||
26281 | return types; | ||
26282 | } | ||
26283 | |||
26284 | // Legacy `process.binding('util')` for Node.js < 10. | ||
26285 | return freeProcess && freeProcess.binding && freeProcess.binding('util'); | ||
26286 | } catch (e) {} | ||
26287 | }()); | ||
26288 | |||
26289 | module.exports = nodeUtil; | ||
26290 | |||
26291 | },{"./_freeGlobal":236}],283:[function(require,module,exports){ | ||
26292 | /** Used for built-in method references. */ | ||
26293 | var objectProto = Object.prototype; | ||
26294 | |||
26295 | /** | ||
26296 | * Used to resolve the | ||
26297 | * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) | ||
26298 | * of values. | ||
26299 | */ | ||
26300 | var nativeObjectToString = objectProto.toString; | ||
26301 | |||
26302 | /** | ||
26303 | * Converts `value` to a string using `Object.prototype.toString`. | ||
26304 | * | ||
26305 | * @private | ||
26306 | * @param {*} value The value to convert. | ||
26307 | * @returns {string} Returns the converted string. | ||
26308 | */ | ||
26309 | function objectToString(value) { | ||
26310 | return nativeObjectToString.call(value); | ||
26311 | } | ||
26312 | |||
26313 | module.exports = objectToString; | ||
26314 | |||
26315 | },{}],284:[function(require,module,exports){ | ||
26316 | /** | ||
26317 | * Creates a unary function that invokes `func` with its argument transformed. | ||
26318 | * | ||
26319 | * @private | ||
26320 | * @param {Function} func The function to wrap. | ||
26321 | * @param {Function} transform The argument transform. | ||
26322 | * @returns {Function} Returns the new function. | ||
26323 | */ | ||
26324 | function overArg(func, transform) { | ||
26325 | return function(arg) { | ||
26326 | return func(transform(arg)); | ||
26327 | }; | ||
26328 | } | ||
26329 | |||
26330 | module.exports = overArg; | ||
26331 | |||
26332 | },{}],285:[function(require,module,exports){ | ||
26333 | var apply = require('./_apply'); | ||
26334 | |||
26335 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
26336 | var nativeMax = Math.max; | ||
26337 | |||
26338 | /** | ||
26339 | * A specialized version of `baseRest` which transforms the rest array. | ||
26340 | * | ||
26341 | * @private | ||
26342 | * @param {Function} func The function to apply a rest parameter to. | ||
26343 | * @param {number} [start=func.length-1] The start position of the rest parameter. | ||
26344 | * @param {Function} transform The rest array transform. | ||
26345 | * @returns {Function} Returns the new function. | ||
26346 | */ | ||
26347 | function overRest(func, start, transform) { | ||
26348 | start = nativeMax(start === undefined ? (func.length - 1) : start, 0); | ||
26349 | return function() { | ||
26350 | var args = arguments, | ||
26351 | index = -1, | ||
26352 | length = nativeMax(args.length - start, 0), | ||
26353 | array = Array(length); | ||
26354 | |||
26355 | while (++index < length) { | ||
26356 | array[index] = args[start + index]; | ||
26357 | } | ||
26358 | index = -1; | ||
26359 | var otherArgs = Array(start + 1); | ||
26360 | while (++index < start) { | ||
26361 | otherArgs[index] = args[index]; | ||
26362 | } | ||
26363 | otherArgs[start] = transform(array); | ||
26364 | return apply(func, this, otherArgs); | ||
26365 | }; | ||
26366 | } | ||
26367 | |||
26368 | module.exports = overRest; | ||
26369 | |||
26370 | },{"./_apply":155}],286:[function(require,module,exports){ | ||
26371 | var freeGlobal = require('./_freeGlobal'); | ||
26372 | |||
26373 | /** Detect free variable `self`. */ | ||
26374 | var freeSelf = typeof self == 'object' && self && self.Object === Object && self; | ||
26375 | |||
26376 | /** Used as a reference to the global object. */ | ||
26377 | var root = freeGlobal || freeSelf || Function('return this')(); | ||
26378 | |||
26379 | module.exports = root; | ||
26380 | |||
26381 | },{"./_freeGlobal":236}],287:[function(require,module,exports){ | ||
26382 | /** Used to stand-in for `undefined` hash values. */ | ||
26383 | var HASH_UNDEFINED = '__lodash_hash_undefined__'; | ||
26384 | |||
26385 | /** | ||
26386 | * Adds `value` to the array cache. | ||
26387 | * | ||
26388 | * @private | ||
26389 | * @name add | ||
26390 | * @memberOf SetCache | ||
26391 | * @alias push | ||
26392 | * @param {*} value The value to cache. | ||
26393 | * @returns {Object} Returns the cache instance. | ||
26394 | */ | ||
26395 | function setCacheAdd(value) { | ||
26396 | this.__data__.set(value, HASH_UNDEFINED); | ||
26397 | return this; | ||
26398 | } | ||
26399 | |||
26400 | module.exports = setCacheAdd; | ||
26401 | |||
26402 | },{}],288:[function(require,module,exports){ | ||
26403 | /** | ||
26404 | * Checks if `value` is in the array cache. | ||
26405 | * | ||
26406 | * @private | ||
26407 | * @name has | ||
26408 | * @memberOf SetCache | ||
26409 | * @param {*} value The value to search for. | ||
26410 | * @returns {number} Returns `true` if `value` is found, else `false`. | ||
26411 | */ | ||
26412 | function setCacheHas(value) { | ||
26413 | return this.__data__.has(value); | ||
26414 | } | ||
26415 | |||
26416 | module.exports = setCacheHas; | ||
26417 | |||
26418 | },{}],289:[function(require,module,exports){ | ||
26419 | /** | ||
26420 | * Converts `set` to an array of its values. | ||
26421 | * | ||
26422 | * @private | ||
26423 | * @param {Object} set The set to convert. | ||
26424 | * @returns {Array} Returns the values. | ||
26425 | */ | ||
26426 | function setToArray(set) { | ||
26427 | var index = -1, | ||
26428 | result = Array(set.size); | ||
26429 | |||
26430 | set.forEach(function(value) { | ||
26431 | result[++index] = value; | ||
26432 | }); | ||
26433 | return result; | ||
26434 | } | ||
26435 | |||
26436 | module.exports = setToArray; | ||
26437 | |||
26438 | },{}],290:[function(require,module,exports){ | ||
26439 | var baseSetToString = require('./_baseSetToString'), | ||
26440 | shortOut = require('./_shortOut'); | ||
26441 | |||
26442 | /** | ||
26443 | * Sets the `toString` method of `func` to return `string`. | ||
26444 | * | ||
26445 | * @private | ||
26446 | * @param {Function} func The function to modify. | ||
26447 | * @param {Function} string The `toString` result. | ||
26448 | * @returns {Function} Returns `func`. | ||
26449 | */ | ||
26450 | var setToString = shortOut(baseSetToString); | ||
26451 | |||
26452 | module.exports = setToString; | ||
26453 | |||
26454 | },{"./_baseSetToString":205,"./_shortOut":291}],291:[function(require,module,exports){ | ||
26455 | /** Used to detect hot functions by number of calls within a span of milliseconds. */ | ||
26456 | var HOT_COUNT = 800, | ||
26457 | HOT_SPAN = 16; | ||
26458 | |||
26459 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
26460 | var nativeNow = Date.now; | ||
26461 | |||
26462 | /** | ||
26463 | * Creates a function that'll short out and invoke `identity` instead | ||
26464 | * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` | ||
26465 | * milliseconds. | ||
26466 | * | ||
26467 | * @private | ||
26468 | * @param {Function} func The function to restrict. | ||
26469 | * @returns {Function} Returns the new shortable function. | ||
26470 | */ | ||
26471 | function shortOut(func) { | ||
26472 | var count = 0, | ||
26473 | lastCalled = 0; | ||
26474 | |||
26475 | return function() { | ||
26476 | var stamp = nativeNow(), | ||
26477 | remaining = HOT_SPAN - (stamp - lastCalled); | ||
26478 | |||
26479 | lastCalled = stamp; | ||
26480 | if (remaining > 0) { | ||
26481 | if (++count >= HOT_COUNT) { | ||
26482 | return arguments[0]; | ||
26483 | } | ||
26484 | } else { | ||
26485 | count = 0; | ||
26486 | } | ||
26487 | return func.apply(undefined, arguments); | ||
26488 | }; | ||
26489 | } | ||
26490 | |||
26491 | module.exports = shortOut; | ||
26492 | |||
26493 | },{}],292:[function(require,module,exports){ | ||
26494 | var ListCache = require('./_ListCache'); | ||
26495 | |||
26496 | /** | ||
26497 | * Removes all key-value entries from the stack. | ||
26498 | * | ||
26499 | * @private | ||
26500 | * @name clear | ||
26501 | * @memberOf Stack | ||
26502 | */ | ||
26503 | function stackClear() { | ||
26504 | this.__data__ = new ListCache; | ||
26505 | this.size = 0; | ||
26506 | } | ||
26507 | |||
26508 | module.exports = stackClear; | ||
26509 | |||
26510 | },{"./_ListCache":145}],293:[function(require,module,exports){ | ||
26511 | /** | ||
26512 | * Removes `key` and its value from the stack. | ||
26513 | * | ||
26514 | * @private | ||
26515 | * @name delete | ||
26516 | * @memberOf Stack | ||
26517 | * @param {string} key The key of the value to remove. | ||
26518 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | ||
26519 | */ | ||
26520 | function stackDelete(key) { | ||
26521 | var data = this.__data__, | ||
26522 | result = data['delete'](key); | ||
26523 | |||
26524 | this.size = data.size; | ||
26525 | return result; | ||
26526 | } | ||
26527 | |||
26528 | module.exports = stackDelete; | ||
26529 | |||
26530 | },{}],294:[function(require,module,exports){ | ||
26531 | /** | ||
26532 | * Gets the stack value for `key`. | ||
26533 | * | ||
26534 | * @private | ||
26535 | * @name get | ||
26536 | * @memberOf Stack | ||
26537 | * @param {string} key The key of the value to get. | ||
26538 | * @returns {*} Returns the entry value. | ||
26539 | */ | ||
26540 | function stackGet(key) { | ||
26541 | return this.__data__.get(key); | ||
26542 | } | ||
26543 | |||
26544 | module.exports = stackGet; | ||
26545 | |||
26546 | },{}],295:[function(require,module,exports){ | ||
26547 | /** | ||
26548 | * Checks if a stack value for `key` exists. | ||
26549 | * | ||
26550 | * @private | ||
26551 | * @name has | ||
26552 | * @memberOf Stack | ||
26553 | * @param {string} key The key of the entry to check. | ||
26554 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
26555 | */ | ||
26556 | function stackHas(key) { | ||
26557 | return this.__data__.has(key); | ||
26558 | } | ||
26559 | |||
26560 | module.exports = stackHas; | ||
26561 | |||
26562 | },{}],296:[function(require,module,exports){ | ||
26563 | var ListCache = require('./_ListCache'), | ||
26564 | Map = require('./_Map'), | ||
26565 | MapCache = require('./_MapCache'); | ||
26566 | |||
26567 | /** Used as the size to enable large array optimizations. */ | ||
26568 | var LARGE_ARRAY_SIZE = 200; | ||
26569 | |||
26570 | /** | ||
26571 | * Sets the stack `key` to `value`. | ||
26572 | * | ||
26573 | * @private | ||
26574 | * @name set | ||
26575 | * @memberOf Stack | ||
26576 | * @param {string} key The key of the value to set. | ||
26577 | * @param {*} value The value to set. | ||
26578 | * @returns {Object} Returns the stack cache instance. | ||
26579 | */ | ||
26580 | function stackSet(key, value) { | ||
26581 | var data = this.__data__; | ||
26582 | if (data instanceof ListCache) { | ||
26583 | var pairs = data.__data__; | ||
26584 | if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { | ||
26585 | pairs.push([key, value]); | ||
26586 | this.size = ++data.size; | ||
26587 | return this; | ||
26588 | } | ||
26589 | data = this.__data__ = new MapCache(pairs); | ||
26590 | } | ||
26591 | data.set(key, value); | ||
26592 | this.size = data.size; | ||
26593 | return this; | ||
26594 | } | ||
26595 | |||
26596 | module.exports = stackSet; | ||
26597 | |||
26598 | },{"./_ListCache":145,"./_Map":146,"./_MapCache":147}],297:[function(require,module,exports){ | ||
26599 | /** | ||
26600 | * A specialized version of `_.indexOf` which performs strict equality | ||
26601 | * comparisons of values, i.e. `===`. | ||
26602 | * | ||
26603 | * @private | ||
26604 | * @param {Array} array The array to inspect. | ||
26605 | * @param {*} value The value to search for. | ||
26606 | * @param {number} fromIndex The index to search from. | ||
26607 | * @returns {number} Returns the index of the matched value, else `-1`. | ||
26608 | */ | ||
26609 | function strictIndexOf(array, value, fromIndex) { | ||
26610 | var index = fromIndex - 1, | ||
26611 | length = array.length; | ||
26612 | |||
26613 | while (++index < length) { | ||
26614 | if (array[index] === value) { | ||
26615 | return index; | ||
26616 | } | ||
26617 | } | ||
26618 | return -1; | ||
26619 | } | ||
26620 | |||
26621 | module.exports = strictIndexOf; | ||
26622 | |||
26623 | },{}],298:[function(require,module,exports){ | ||
26624 | var asciiSize = require('./_asciiSize'), | ||
26625 | hasUnicode = require('./_hasUnicode'), | ||
26626 | unicodeSize = require('./_unicodeSize'); | ||
26627 | |||
26628 | /** | ||
26629 | * Gets the number of symbols in `string`. | ||
26630 | * | ||
26631 | * @private | ||
26632 | * @param {string} string The string to inspect. | ||
26633 | * @returns {number} Returns the string size. | ||
26634 | */ | ||
26635 | function stringSize(string) { | ||
26636 | return hasUnicode(string) | ||
26637 | ? unicodeSize(string) | ||
26638 | : asciiSize(string); | ||
26639 | } | ||
26640 | |||
26641 | module.exports = stringSize; | ||
26642 | |||
26643 | },{"./_asciiSize":163,"./_hasUnicode":249,"./_unicodeSize":303}],299:[function(require,module,exports){ | ||
26644 | var asciiToArray = require('./_asciiToArray'), | ||
26645 | hasUnicode = require('./_hasUnicode'), | ||
26646 | unicodeToArray = require('./_unicodeToArray'); | ||
26647 | |||
26648 | /** | ||
26649 | * Converts `string` to an array. | ||
26650 | * | ||
26651 | * @private | ||
26652 | * @param {string} string The string to convert. | ||
26653 | * @returns {Array} Returns the converted array. | ||
26654 | */ | ||
26655 | function stringToArray(string) { | ||
26656 | return hasUnicode(string) | ||
26657 | ? unicodeToArray(string) | ||
26658 | : asciiToArray(string); | ||
26659 | } | ||
26660 | |||
26661 | module.exports = stringToArray; | ||
26662 | |||
26663 | },{"./_asciiToArray":164,"./_hasUnicode":249,"./_unicodeToArray":304}],300:[function(require,module,exports){ | ||
26664 | var memoizeCapped = require('./_memoizeCapped'); | ||
26665 | |||
26666 | /** Used to match property names within property paths. */ | ||
26667 | var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; | ||
26668 | |||
26669 | /** Used to match backslashes in property paths. */ | ||
26670 | var reEscapeChar = /\\(\\)?/g; | ||
26671 | |||
26672 | /** | ||
26673 | * Converts `string` to a property path array. | ||
26674 | * | ||
26675 | * @private | ||
26676 | * @param {string} string The string to convert. | ||
26677 | * @returns {Array} Returns the property path array. | ||
26678 | */ | ||
26679 | var stringToPath = memoizeCapped(function(string) { | ||
26680 | var result = []; | ||
26681 | if (string.charCodeAt(0) === 46 /* . */) { | ||
26682 | result.push(''); | ||
26683 | } | ||
26684 | string.replace(rePropName, function(match, number, quote, subString) { | ||
26685 | result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); | ||
26686 | }); | ||
26687 | return result; | ||
26688 | }); | ||
26689 | |||
26690 | module.exports = stringToPath; | ||
26691 | |||
26692 | },{"./_memoizeCapped":278}],301:[function(require,module,exports){ | ||
26693 | var isSymbol = require('./isSymbol'); | ||
26694 | |||
26695 | /** Used as references for various `Number` constants. */ | ||
26696 | var INFINITY = 1 / 0; | ||
26697 | |||
26698 | /** | ||
26699 | * Converts `value` to a string key if it's not a string or symbol. | ||
26700 | * | ||
26701 | * @private | ||
26702 | * @param {*} value The value to inspect. | ||
26703 | * @returns {string|symbol} Returns the key. | ||
26704 | */ | ||
26705 | function toKey(value) { | ||
26706 | if (typeof value == 'string' || isSymbol(value)) { | ||
26707 | return value; | ||
26708 | } | ||
26709 | var result = (value + ''); | ||
26710 | return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; | ||
26711 | } | ||
26712 | |||
26713 | module.exports = toKey; | ||
26714 | |||
26715 | },{"./isSymbol":334}],302:[function(require,module,exports){ | ||
26716 | /** Used for built-in method references. */ | ||
26717 | var funcProto = Function.prototype; | ||
26718 | |||
26719 | /** Used to resolve the decompiled source of functions. */ | ||
26720 | var funcToString = funcProto.toString; | ||
26721 | |||
26722 | /** | ||
26723 | * Converts `func` to its source code. | ||
26724 | * | ||
26725 | * @private | ||
26726 | * @param {Function} func The function to convert. | ||
26727 | * @returns {string} Returns the source code. | ||
26728 | */ | ||
26729 | function toSource(func) { | ||
26730 | if (func != null) { | ||
26731 | try { | ||
26732 | return funcToString.call(func); | ||
26733 | } catch (e) {} | ||
26734 | try { | ||
26735 | return (func + ''); | ||
26736 | } catch (e) {} | ||
26737 | } | ||
26738 | return ''; | ||
26739 | } | ||
26740 | |||
26741 | module.exports = toSource; | ||
26742 | |||
26743 | },{}],303:[function(require,module,exports){ | ||
26744 | /** Used to compose unicode character classes. */ | ||
26745 | var rsAstralRange = '\\ud800-\\udfff', | ||
26746 | rsComboMarksRange = '\\u0300-\\u036f', | ||
26747 | reComboHalfMarksRange = '\\ufe20-\\ufe2f', | ||
26748 | rsComboSymbolsRange = '\\u20d0-\\u20ff', | ||
26749 | rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, | ||
26750 | rsVarRange = '\\ufe0e\\ufe0f'; | ||
26751 | |||
26752 | /** Used to compose unicode capture groups. */ | ||
26753 | var rsAstral = '[' + rsAstralRange + ']', | ||
26754 | rsCombo = '[' + rsComboRange + ']', | ||
26755 | rsFitz = '\\ud83c[\\udffb-\\udfff]', | ||
26756 | rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', | ||
26757 | rsNonAstral = '[^' + rsAstralRange + ']', | ||
26758 | rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', | ||
26759 | rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', | ||
26760 | rsZWJ = '\\u200d'; | ||
26761 | |||
26762 | /** Used to compose unicode regexes. */ | ||
26763 | var reOptMod = rsModifier + '?', | ||
26764 | rsOptVar = '[' + rsVarRange + ']?', | ||
26765 | rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', | ||
26766 | rsSeq = rsOptVar + reOptMod + rsOptJoin, | ||
26767 | rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; | ||
26768 | |||
26769 | /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ | ||
26770 | var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); | ||
26771 | |||
26772 | /** | ||
26773 | * Gets the size of a Unicode `string`. | ||
26774 | * | ||
26775 | * @private | ||
26776 | * @param {string} string The string inspect. | ||
26777 | * @returns {number} Returns the string size. | ||
26778 | */ | ||
26779 | function unicodeSize(string) { | ||
26780 | var result = reUnicode.lastIndex = 0; | ||
26781 | while (reUnicode.test(string)) { | ||
26782 | ++result; | ||
26783 | } | ||
26784 | return result; | ||
26785 | } | ||
26786 | |||
26787 | module.exports = unicodeSize; | ||
26788 | |||
26789 | },{}],304:[function(require,module,exports){ | ||
26790 | /** Used to compose unicode character classes. */ | ||
26791 | var rsAstralRange = '\\ud800-\\udfff', | ||
26792 | rsComboMarksRange = '\\u0300-\\u036f', | ||
26793 | reComboHalfMarksRange = '\\ufe20-\\ufe2f', | ||
26794 | rsComboSymbolsRange = '\\u20d0-\\u20ff', | ||
26795 | rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, | ||
26796 | rsVarRange = '\\ufe0e\\ufe0f'; | ||
26797 | |||
26798 | /** Used to compose unicode capture groups. */ | ||
26799 | var rsAstral = '[' + rsAstralRange + ']', | ||
26800 | rsCombo = '[' + rsComboRange + ']', | ||
26801 | rsFitz = '\\ud83c[\\udffb-\\udfff]', | ||
26802 | rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', | ||
26803 | rsNonAstral = '[^' + rsAstralRange + ']', | ||
26804 | rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', | ||
26805 | rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', | ||
26806 | rsZWJ = '\\u200d'; | ||
26807 | |||
26808 | /** Used to compose unicode regexes. */ | ||
26809 | var reOptMod = rsModifier + '?', | ||
26810 | rsOptVar = '[' + rsVarRange + ']?', | ||
26811 | rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', | ||
26812 | rsSeq = rsOptVar + reOptMod + rsOptJoin, | ||
26813 | rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; | ||
26814 | |||
26815 | /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ | ||
26816 | var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); | ||
26817 | |||
26818 | /** | ||
26819 | * Converts a Unicode `string` to an array. | ||
26820 | * | ||
26821 | * @private | ||
26822 | * @param {string} string The string to convert. | ||
26823 | * @returns {Array} Returns the converted array. | ||
26824 | */ | ||
26825 | function unicodeToArray(string) { | ||
26826 | return string.match(reUnicode) || []; | ||
26827 | } | ||
26828 | |||
26829 | module.exports = unicodeToArray; | ||
26830 | |||
26831 | },{}],305:[function(require,module,exports){ | ||
26832 | var copyObject = require('./_copyObject'), | ||
26833 | createAssigner = require('./_createAssigner'), | ||
26834 | keysIn = require('./keysIn'); | ||
26835 | |||
26836 | /** | ||
26837 | * This method is like `_.assign` except that it iterates over own and | ||
26838 | * inherited source properties. | ||
26839 | * | ||
26840 | * **Note:** This method mutates `object`. | ||
26841 | * | ||
26842 | * @static | ||
26843 | * @memberOf _ | ||
26844 | * @since 4.0.0 | ||
26845 | * @alias extend | ||
26846 | * @category Object | ||
26847 | * @param {Object} object The destination object. | ||
26848 | * @param {...Object} [sources] The source objects. | ||
26849 | * @returns {Object} Returns `object`. | ||
26850 | * @see _.assign | ||
26851 | * @example | ||
26852 | * | ||
26853 | * function Foo() { | ||
26854 | * this.a = 1; | ||
26855 | * } | ||
26856 | * | ||
26857 | * function Bar() { | ||
26858 | * this.c = 3; | ||
26859 | * } | ||
26860 | * | ||
26861 | * Foo.prototype.b = 2; | ||
26862 | * Bar.prototype.d = 4; | ||
26863 | * | ||
26864 | * _.assignIn({ 'a': 0 }, new Foo, new Bar); | ||
26865 | * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } | ||
26866 | */ | ||
26867 | var assignIn = createAssigner(function(object, source) { | ||
26868 | copyObject(source, keysIn(source), object); | ||
26869 | }); | ||
26870 | |||
26871 | module.exports = assignIn; | ||
26872 | |||
26873 | },{"./_copyObject":223,"./_createAssigner":227,"./keysIn":338}],306:[function(require,module,exports){ | ||
26874 | var baseClone = require('./_baseClone'); | ||
26875 | |||
26876 | /** Used to compose bitmasks for cloning. */ | ||
26877 | var CLONE_SYMBOLS_FLAG = 4; | ||
26878 | |||
26879 | /** | ||
26880 | * Creates a shallow clone of `value`. | ||
26881 | * | ||
26882 | * **Note:** This method is loosely based on the | ||
26883 | * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) | ||
26884 | * and supports cloning arrays, array buffers, booleans, date objects, maps, | ||
26885 | * numbers, `Object` objects, regexes, sets, strings, symbols, and typed | ||
26886 | * arrays. The own enumerable properties of `arguments` objects are cloned | ||
26887 | * as plain objects. An empty object is returned for uncloneable values such | ||
26888 | * as error objects, functions, DOM nodes, and WeakMaps. | ||
26889 | * | ||
26890 | * @static | ||
26891 | * @memberOf _ | ||
26892 | * @since 0.1.0 | ||
26893 | * @category Lang | ||
26894 | * @param {*} value The value to clone. | ||
26895 | * @returns {*} Returns the cloned value. | ||
26896 | * @see _.cloneDeep | ||
26897 | * @example | ||
26898 | * | ||
26899 | * var objects = [{ 'a': 1 }, { 'b': 2 }]; | ||
26900 | * | ||
26901 | * var shallow = _.clone(objects); | ||
26902 | * console.log(shallow[0] === objects[0]); | ||
26903 | * // => true | ||
26904 | */ | ||
26905 | function clone(value) { | ||
26906 | return baseClone(value, CLONE_SYMBOLS_FLAG); | ||
26907 | } | ||
26908 | |||
26909 | module.exports = clone; | ||
26910 | |||
26911 | },{"./_baseClone":170}],307:[function(require,module,exports){ | ||
26912 | /** | ||
26913 | * Creates a function that returns `value`. | ||
26914 | * | ||
26915 | * @static | ||
26916 | * @memberOf _ | ||
26917 | * @since 2.4.0 | ||
26918 | * @category Util | ||
26919 | * @param {*} value The value to return from the new function. | ||
26920 | * @returns {Function} Returns the new constant function. | ||
26921 | * @example | ||
26922 | * | ||
26923 | * var objects = _.times(2, _.constant({ 'a': 1 })); | ||
26924 | * | ||
26925 | * console.log(objects); | ||
26926 | * // => [{ 'a': 1 }, { 'a': 1 }] | ||
26927 | * | ||
26928 | * console.log(objects[0] === objects[1]); | ||
26929 | * // => true | ||
26930 | */ | ||
26931 | function constant(value) { | ||
26932 | return function() { | ||
26933 | return value; | ||
26934 | }; | ||
26935 | } | ||
26936 | |||
26937 | module.exports = constant; | ||
26938 | |||
26939 | },{}],308:[function(require,module,exports){ | ||
26940 | module.exports = require('./forEach'); | ||
26941 | |||
26942 | },{"./forEach":313}],309:[function(require,module,exports){ | ||
26943 | /** | ||
26944 | * Performs a | ||
26945 | * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) | ||
26946 | * comparison between two values to determine if they are equivalent. | ||
26947 | * | ||
26948 | * @static | ||
26949 | * @memberOf _ | ||
26950 | * @since 4.0.0 | ||
26951 | * @category Lang | ||
26952 | * @param {*} value The value to compare. | ||
26953 | * @param {*} other The other value to compare. | ||
26954 | * @returns {boolean} Returns `true` if the values are equivalent, else `false`. | ||
26955 | * @example | ||
26956 | * | ||
26957 | * var object = { 'a': 1 }; | ||
26958 | * var other = { 'a': 1 }; | ||
26959 | * | ||
26960 | * _.eq(object, object); | ||
26961 | * // => true | ||
26962 | * | ||
26963 | * _.eq(object, other); | ||
26964 | * // => false | ||
26965 | * | ||
26966 | * _.eq('a', 'a'); | ||
26967 | * // => true | ||
26968 | * | ||
26969 | * _.eq('a', Object('a')); | ||
26970 | * // => false | ||
26971 | * | ||
26972 | * _.eq(NaN, NaN); | ||
26973 | * // => true | ||
26974 | */ | ||
26975 | function eq(value, other) { | ||
26976 | return value === other || (value !== value && other !== other); | ||
26977 | } | ||
26978 | |||
26979 | module.exports = eq; | ||
26980 | |||
26981 | },{}],310:[function(require,module,exports){ | ||
26982 | var arrayEvery = require('./_arrayEvery'), | ||
26983 | baseEvery = require('./_baseEvery'), | ||
26984 | baseIteratee = require('./_baseIteratee'), | ||
26985 | isArray = require('./isArray'), | ||
26986 | isIterateeCall = require('./_isIterateeCall'); | ||
26987 | |||
26988 | /** | ||
26989 | * Checks if `predicate` returns truthy for **all** elements of `collection`. | ||
26990 | * Iteration is stopped once `predicate` returns falsey. The predicate is | ||
26991 | * invoked with three arguments: (value, index|key, collection). | ||
26992 | * | ||
26993 | * **Note:** This method returns `true` for | ||
26994 | * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because | ||
26995 | * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of | ||
26996 | * elements of empty collections. | ||
26997 | * | ||
26998 | * @static | ||
26999 | * @memberOf _ | ||
27000 | * @since 0.1.0 | ||
27001 | * @category Collection | ||
27002 | * @param {Array|Object} collection The collection to iterate over. | ||
27003 | * @param {Function} [predicate=_.identity] The function invoked per iteration. | ||
27004 | * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. | ||
27005 | * @returns {boolean} Returns `true` if all elements pass the predicate check, | ||
27006 | * else `false`. | ||
27007 | * @example | ||
27008 | * | ||
27009 | * _.every([true, 1, null, 'yes'], Boolean); | ||
27010 | * // => false | ||
27011 | * | ||
27012 | * var users = [ | ||
27013 | * { 'user': 'barney', 'age': 36, 'active': false }, | ||
27014 | * { 'user': 'fred', 'age': 40, 'active': false } | ||
27015 | * ]; | ||
27016 | * | ||
27017 | * // The `_.matches` iteratee shorthand. | ||
27018 | * _.every(users, { 'user': 'barney', 'active': false }); | ||
27019 | * // => false | ||
27020 | * | ||
27021 | * // The `_.matchesProperty` iteratee shorthand. | ||
27022 | * _.every(users, ['active', false]); | ||
27023 | * // => true | ||
27024 | * | ||
27025 | * // The `_.property` iteratee shorthand. | ||
27026 | * _.every(users, 'active'); | ||
27027 | * // => false | ||
27028 | */ | ||
27029 | function every(collection, predicate, guard) { | ||
27030 | var func = isArray(collection) ? arrayEvery : baseEvery; | ||
27031 | if (guard && isIterateeCall(collection, predicate, guard)) { | ||
27032 | predicate = undefined; | ||
27033 | } | ||
27034 | return func(collection, baseIteratee(predicate, 3)); | ||
27035 | } | ||
27036 | |||
27037 | module.exports = every; | ||
27038 | |||
27039 | },{"./_arrayEvery":157,"./_baseEvery":173,"./_baseIteratee":192,"./_isIterateeCall":260,"./isArray":319}],311:[function(require,module,exports){ | ||
27040 | module.exports = require('./assignIn'); | ||
27041 | |||
27042 | },{"./assignIn":305}],312:[function(require,module,exports){ | ||
27043 | var baseFlatten = require('./_baseFlatten'); | ||
27044 | |||
27045 | /** | ||
27046 | * Flattens `array` a single level deep. | ||
27047 | * | ||
27048 | * @static | ||
27049 | * @memberOf _ | ||
27050 | * @since 0.1.0 | ||
27051 | * @category Array | ||
27052 | * @param {Array} array The array to flatten. | ||
27053 | * @returns {Array} Returns the new flattened array. | ||
27054 | * @example | ||
27055 | * | ||
27056 | * _.flatten([1, [2, [3, [4]], 5]]); | ||
27057 | * // => [1, 2, [3, [4]], 5] | ||
27058 | */ | ||
27059 | function flatten(array) { | ||
27060 | var length = array == null ? 0 : array.length; | ||
27061 | return length ? baseFlatten(array, 1) : []; | ||
27062 | } | ||
27063 | |||
27064 | module.exports = flatten; | ||
27065 | |||
27066 | },{"./_baseFlatten":175}],313:[function(require,module,exports){ | ||
27067 | var arrayEach = require('./_arrayEach'), | ||
27068 | baseEach = require('./_baseEach'), | ||
27069 | castFunction = require('./_castFunction'), | ||
27070 | isArray = require('./isArray'); | ||
27071 | |||
27072 | /** | ||
27073 | * Iterates over elements of `collection` and invokes `iteratee` for each element. | ||
27074 | * The iteratee is invoked with three arguments: (value, index|key, collection). | ||
27075 | * Iteratee functions may exit iteration early by explicitly returning `false`. | ||
27076 | * | ||
27077 | * **Note:** As with other "Collections" methods, objects with a "length" | ||
27078 | * property are iterated like arrays. To avoid this behavior use `_.forIn` | ||
27079 | * or `_.forOwn` for object iteration. | ||
27080 | * | ||
27081 | * @static | ||
27082 | * @memberOf _ | ||
27083 | * @since 0.1.0 | ||
27084 | * @alias each | ||
27085 | * @category Collection | ||
27086 | * @param {Array|Object} collection The collection to iterate over. | ||
27087 | * @param {Function} [iteratee=_.identity] The function invoked per iteration. | ||
27088 | * @returns {Array|Object} Returns `collection`. | ||
27089 | * @see _.forEachRight | ||
27090 | * @example | ||
27091 | * | ||
27092 | * _.forEach([1, 2], function(value) { | ||
27093 | * console.log(value); | ||
27094 | * }); | ||
27095 | * // => Logs `1` then `2`. | ||
27096 | * | ||
27097 | * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { | ||
27098 | * console.log(key); | ||
27099 | * }); | ||
27100 | * // => Logs 'a' then 'b' (iteration order is not guaranteed). | ||
27101 | */ | ||
27102 | function forEach(collection, iteratee) { | ||
27103 | var func = isArray(collection) ? arrayEach : baseEach; | ||
27104 | return func(collection, castFunction(iteratee)); | ||
27105 | } | ||
27106 | |||
27107 | module.exports = forEach; | ||
27108 | |||
27109 | },{"./_arrayEach":156,"./_baseEach":172,"./_castFunction":212,"./isArray":319}],314:[function(require,module,exports){ | ||
27110 | /** | ||
27111 | * The inverse of `_.toPairs`; this method returns an object composed | ||
27112 | * from key-value `pairs`. | ||
27113 | * | ||
27114 | * @static | ||
27115 | * @memberOf _ | ||
27116 | * @since 4.0.0 | ||
27117 | * @category Array | ||
27118 | * @param {Array} pairs The key-value pairs. | ||
27119 | * @returns {Object} Returns the new object. | ||
27120 | * @example | ||
27121 | * | ||
27122 | * _.fromPairs([['a', 1], ['b', 2]]); | ||
27123 | * // => { 'a': 1, 'b': 2 } | ||
27124 | */ | ||
27125 | function fromPairs(pairs) { | ||
27126 | var index = -1, | ||
27127 | length = pairs == null ? 0 : pairs.length, | ||
27128 | result = {}; | ||
27129 | |||
27130 | while (++index < length) { | ||
27131 | var pair = pairs[index]; | ||
27132 | result[pair[0]] = pair[1]; | ||
27133 | } | ||
27134 | return result; | ||
27135 | } | ||
27136 | |||
27137 | module.exports = fromPairs; | ||
27138 | |||
27139 | },{}],315:[function(require,module,exports){ | ||
27140 | var baseGet = require('./_baseGet'); | ||
27141 | |||
27142 | /** | ||
27143 | * Gets the value at `path` of `object`. If the resolved value is | ||
27144 | * `undefined`, the `defaultValue` is returned in its place. | ||
27145 | * | ||
27146 | * @static | ||
27147 | * @memberOf _ | ||
27148 | * @since 3.7.0 | ||
27149 | * @category Object | ||
27150 | * @param {Object} object The object to query. | ||
27151 | * @param {Array|string} path The path of the property to get. | ||
27152 | * @param {*} [defaultValue] The value returned for `undefined` resolved values. | ||
27153 | * @returns {*} Returns the resolved value. | ||
27154 | * @example | ||
27155 | * | ||
27156 | * var object = { 'a': [{ 'b': { 'c': 3 } }] }; | ||
27157 | * | ||
27158 | * _.get(object, 'a[0].b.c'); | ||
27159 | * // => 3 | ||
27160 | * | ||
27161 | * _.get(object, ['a', '0', 'b', 'c']); | ||
27162 | * // => 3 | ||
27163 | * | ||
27164 | * _.get(object, 'a.b.c', 'default'); | ||
27165 | * // => 'default' | ||
27166 | */ | ||
27167 | function get(object, path, defaultValue) { | ||
27168 | var result = object == null ? undefined : baseGet(object, path); | ||
27169 | return result === undefined ? defaultValue : result; | ||
27170 | } | ||
27171 | |||
27172 | module.exports = get; | ||
27173 | |||
27174 | },{"./_baseGet":178}],316:[function(require,module,exports){ | ||
27175 | var baseHasIn = require('./_baseHasIn'), | ||
27176 | hasPath = require('./_hasPath'); | ||
27177 | |||
27178 | /** | ||
27179 | * Checks if `path` is a direct or inherited property of `object`. | ||
27180 | * | ||
27181 | * @static | ||
27182 | * @memberOf _ | ||
27183 | * @since 4.0.0 | ||
27184 | * @category Object | ||
27185 | * @param {Object} object The object to query. | ||
27186 | * @param {Array|string} path The path to check. | ||
27187 | * @returns {boolean} Returns `true` if `path` exists, else `false`. | ||
27188 | * @example | ||
27189 | * | ||
27190 | * var object = _.create({ 'a': _.create({ 'b': 2 }) }); | ||
27191 | * | ||
27192 | * _.hasIn(object, 'a'); | ||
27193 | * // => true | ||
27194 | * | ||
27195 | * _.hasIn(object, 'a.b'); | ||
27196 | * // => true | ||
27197 | * | ||
27198 | * _.hasIn(object, ['a', 'b']); | ||
27199 | * // => true | ||
27200 | * | ||
27201 | * _.hasIn(object, 'b'); | ||
27202 | * // => false | ||
27203 | */ | ||
27204 | function hasIn(object, path) { | ||
27205 | return object != null && hasPath(object, path, baseHasIn); | ||
27206 | } | ||
27207 | |||
27208 | module.exports = hasIn; | ||
27209 | |||
27210 | },{"./_baseHasIn":181,"./_hasPath":248}],317:[function(require,module,exports){ | ||
27211 | /** | ||
27212 | * This method returns the first argument it receives. | ||
27213 | * | ||
27214 | * @static | ||
27215 | * @since 0.1.0 | ||
27216 | * @memberOf _ | ||
27217 | * @category Util | ||
27218 | * @param {*} value Any value. | ||
27219 | * @returns {*} Returns `value`. | ||
27220 | * @example | ||
27221 | * | ||
27222 | * var object = { 'a': 1 }; | ||
27223 | * | ||
27224 | * console.log(_.identity(object) === object); | ||
27225 | * // => true | ||
27226 | */ | ||
27227 | function identity(value) { | ||
27228 | return value; | ||
27229 | } | ||
27230 | |||
27231 | module.exports = identity; | ||
27232 | |||
27233 | },{}],318:[function(require,module,exports){ | ||
27234 | var baseIsArguments = require('./_baseIsArguments'), | ||
27235 | isObjectLike = require('./isObjectLike'); | ||
27236 | |||
27237 | /** Used for built-in method references. */ | ||
27238 | var objectProto = Object.prototype; | ||
27239 | |||
27240 | /** Used to check objects for own properties. */ | ||
27241 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
27242 | |||
27243 | /** Built-in value references. */ | ||
27244 | var propertyIsEnumerable = objectProto.propertyIsEnumerable; | ||
27245 | |||
27246 | /** | ||
27247 | * Checks if `value` is likely an `arguments` object. | ||
27248 | * | ||
27249 | * @static | ||
27250 | * @memberOf _ | ||
27251 | * @since 0.1.0 | ||
27252 | * @category Lang | ||
27253 | * @param {*} value The value to check. | ||
27254 | * @returns {boolean} Returns `true` if `value` is an `arguments` object, | ||
27255 | * else `false`. | ||
27256 | * @example | ||
27257 | * | ||
27258 | * _.isArguments(function() { return arguments; }()); | ||
27259 | * // => true | ||
27260 | * | ||
27261 | * _.isArguments([1, 2, 3]); | ||
27262 | * // => false | ||
27263 | */ | ||
27264 | var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { | ||
27265 | return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && | ||
27266 | !propertyIsEnumerable.call(value, 'callee'); | ||
27267 | }; | ||
27268 | |||
27269 | module.exports = isArguments; | ||
27270 | |||
27271 | },{"./_baseIsArguments":183,"./isObjectLike":330}],319:[function(require,module,exports){ | ||
27272 | /** | ||
27273 | * Checks if `value` is classified as an `Array` object. | ||
27274 | * | ||
27275 | * @static | ||
27276 | * @memberOf _ | ||
27277 | * @since 0.1.0 | ||
27278 | * @category Lang | ||
27279 | * @param {*} value The value to check. | ||
27280 | * @returns {boolean} Returns `true` if `value` is an array, else `false`. | ||
27281 | * @example | ||
27282 | * | ||
27283 | * _.isArray([1, 2, 3]); | ||
27284 | * // => true | ||
27285 | * | ||
27286 | * _.isArray(document.body.children); | ||
27287 | * // => false | ||
27288 | * | ||
27289 | * _.isArray('abc'); | ||
27290 | * // => false | ||
27291 | * | ||
27292 | * _.isArray(_.noop); | ||
27293 | * // => false | ||
27294 | */ | ||
27295 | var isArray = Array.isArray; | ||
27296 | |||
27297 | module.exports = isArray; | ||
27298 | |||
27299 | },{}],320:[function(require,module,exports){ | ||
27300 | var isFunction = require('./isFunction'), | ||
27301 | isLength = require('./isLength'); | ||
27302 | |||
27303 | /** | ||
27304 | * Checks if `value` is array-like. A value is considered array-like if it's | ||
27305 | * not a function and has a `value.length` that's an integer greater than or | ||
27306 | * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. | ||
27307 | * | ||
27308 | * @static | ||
27309 | * @memberOf _ | ||
27310 | * @since 4.0.0 | ||
27311 | * @category Lang | ||
27312 | * @param {*} value The value to check. | ||
27313 | * @returns {boolean} Returns `true` if `value` is array-like, else `false`. | ||
27314 | * @example | ||
27315 | * | ||
27316 | * _.isArrayLike([1, 2, 3]); | ||
27317 | * // => true | ||
27318 | * | ||
27319 | * _.isArrayLike(document.body.children); | ||
27320 | * // => true | ||
27321 | * | ||
27322 | * _.isArrayLike('abc'); | ||
27323 | * // => true | ||
27324 | * | ||
27325 | * _.isArrayLike(_.noop); | ||
27326 | * // => false | ||
27327 | */ | ||
27328 | function isArrayLike(value) { | ||
27329 | return value != null && isLength(value.length) && !isFunction(value); | ||
27330 | } | ||
27331 | |||
27332 | module.exports = isArrayLike; | ||
27333 | |||
27334 | },{"./isFunction":324,"./isLength":325}],321:[function(require,module,exports){ | ||
27335 | var baseGetTag = require('./_baseGetTag'), | ||
27336 | isObjectLike = require('./isObjectLike'); | ||
27337 | |||
27338 | /** `Object#toString` result references. */ | ||
27339 | var boolTag = '[object Boolean]'; | ||
27340 | |||
27341 | /** | ||
27342 | * Checks if `value` is classified as a boolean primitive or object. | ||
27343 | * | ||
27344 | * @static | ||
27345 | * @memberOf _ | ||
27346 | * @since 0.1.0 | ||
27347 | * @category Lang | ||
27348 | * @param {*} value The value to check. | ||
27349 | * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. | ||
27350 | * @example | ||
27351 | * | ||
27352 | * _.isBoolean(false); | ||
27353 | * // => true | ||
27354 | * | ||
27355 | * _.isBoolean(null); | ||
27356 | * // => false | ||
27357 | */ | ||
27358 | function isBoolean(value) { | ||
27359 | return value === true || value === false || | ||
27360 | (isObjectLike(value) && baseGetTag(value) == boolTag); | ||
27361 | } | ||
27362 | |||
27363 | module.exports = isBoolean; | ||
27364 | |||
27365 | },{"./_baseGetTag":180,"./isObjectLike":330}],322:[function(require,module,exports){ | ||
27366 | var root = require('./_root'), | ||
27367 | stubFalse = require('./stubFalse'); | ||
27368 | |||
27369 | /** Detect free variable `exports`. */ | ||
27370 | var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; | ||
27371 | |||
27372 | /** Detect free variable `module`. */ | ||
27373 | var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; | ||
27374 | |||
27375 | /** Detect the popular CommonJS extension `module.exports`. */ | ||
27376 | var moduleExports = freeModule && freeModule.exports === freeExports; | ||
27377 | |||
27378 | /** Built-in value references. */ | ||
27379 | var Buffer = moduleExports ? root.Buffer : undefined; | ||
27380 | |||
27381 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
27382 | var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; | ||
27383 | |||
27384 | /** | ||
27385 | * Checks if `value` is a buffer. | ||
27386 | * | ||
27387 | * @static | ||
27388 | * @memberOf _ | ||
27389 | * @since 4.3.0 | ||
27390 | * @category Lang | ||
27391 | * @param {*} value The value to check. | ||
27392 | * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. | ||
27393 | * @example | ||
27394 | * | ||
27395 | * _.isBuffer(new Buffer(2)); | ||
27396 | * // => true | ||
27397 | * | ||
27398 | * _.isBuffer(new Uint8Array(2)); | ||
27399 | * // => false | ||
27400 | */ | ||
27401 | var isBuffer = nativeIsBuffer || stubFalse; | ||
27402 | |||
27403 | module.exports = isBuffer; | ||
27404 | |||
27405 | },{"./_root":286,"./stubFalse":345}],323:[function(require,module,exports){ | ||
27406 | var root = require('./_root'); | ||
27407 | |||
27408 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
27409 | var nativeIsFinite = root.isFinite; | ||
27410 | |||
27411 | /** | ||
27412 | * Checks if `value` is a finite primitive number. | ||
27413 | * | ||
27414 | * **Note:** This method is based on | ||
27415 | * [`Number.isFinite`](https://mdn.io/Number/isFinite). | ||
27416 | * | ||
27417 | * @static | ||
27418 | * @memberOf _ | ||
27419 | * @since 0.1.0 | ||
27420 | * @category Lang | ||
27421 | * @param {*} value The value to check. | ||
27422 | * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. | ||
27423 | * @example | ||
27424 | * | ||
27425 | * _.isFinite(3); | ||
27426 | * // => true | ||
27427 | * | ||
27428 | * _.isFinite(Number.MIN_VALUE); | ||
27429 | * // => true | ||
27430 | * | ||
27431 | * _.isFinite(Infinity); | ||
27432 | * // => false | ||
27433 | * | ||
27434 | * _.isFinite('3'); | ||
27435 | * // => false | ||
27436 | */ | ||
27437 | function isFinite(value) { | ||
27438 | return typeof value == 'number' && nativeIsFinite(value); | ||
27439 | } | ||
27440 | |||
27441 | module.exports = isFinite; | ||
27442 | |||
27443 | },{"./_root":286}],324:[function(require,module,exports){ | ||
27444 | var baseGetTag = require('./_baseGetTag'), | ||
27445 | isObject = require('./isObject'); | ||
27446 | |||
27447 | /** `Object#toString` result references. */ | ||
27448 | var asyncTag = '[object AsyncFunction]', | ||
27449 | funcTag = '[object Function]', | ||
27450 | genTag = '[object GeneratorFunction]', | ||
27451 | proxyTag = '[object Proxy]'; | ||
27452 | |||
27453 | /** | ||
27454 | * Checks if `value` is classified as a `Function` object. | ||
27455 | * | ||
27456 | * @static | ||
27457 | * @memberOf _ | ||
27458 | * @since 0.1.0 | ||
27459 | * @category Lang | ||
27460 | * @param {*} value The value to check. | ||
27461 | * @returns {boolean} Returns `true` if `value` is a function, else `false`. | ||
27462 | * @example | ||
27463 | * | ||
27464 | * _.isFunction(_); | ||
27465 | * // => true | ||
27466 | * | ||
27467 | * _.isFunction(/abc/); | ||
27468 | * // => false | ||
27469 | */ | ||
27470 | function isFunction(value) { | ||
27471 | if (!isObject(value)) { | ||
27472 | return false; | ||
27473 | } | ||
27474 | // The use of `Object#toString` avoids issues with the `typeof` operator | ||
27475 | // in Safari 9 which returns 'object' for typed arrays and other constructors. | ||
27476 | var tag = baseGetTag(value); | ||
27477 | return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; | ||
27478 | } | ||
27479 | |||
27480 | module.exports = isFunction; | ||
27481 | |||
27482 | },{"./_baseGetTag":180,"./isObject":329}],325:[function(require,module,exports){ | ||
27483 | /** Used as references for various `Number` constants. */ | ||
27484 | var MAX_SAFE_INTEGER = 9007199254740991; | ||
27485 | |||
27486 | /** | ||
27487 | * Checks if `value` is a valid array-like length. | ||
27488 | * | ||
27489 | * **Note:** This method is loosely based on | ||
27490 | * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). | ||
27491 | * | ||
27492 | * @static | ||
27493 | * @memberOf _ | ||
27494 | * @since 4.0.0 | ||
27495 | * @category Lang | ||
27496 | * @param {*} value The value to check. | ||
27497 | * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. | ||
27498 | * @example | ||
27499 | * | ||
27500 | * _.isLength(3); | ||
27501 | * // => true | ||
27502 | * | ||
27503 | * _.isLength(Number.MIN_VALUE); | ||
27504 | * // => false | ||
27505 | * | ||
27506 | * _.isLength(Infinity); | ||
27507 | * // => false | ||
27508 | * | ||
27509 | * _.isLength('3'); | ||
27510 | * // => false | ||
27511 | */ | ||
27512 | function isLength(value) { | ||
27513 | return typeof value == 'number' && | ||
27514 | value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; | ||
27515 | } | ||
27516 | |||
27517 | module.exports = isLength; | ||
27518 | |||
27519 | },{}],326:[function(require,module,exports){ | ||
27520 | var baseIsMap = require('./_baseIsMap'), | ||
27521 | baseUnary = require('./_baseUnary'), | ||
27522 | nodeUtil = require('./_nodeUtil'); | ||
27523 | |||
27524 | /* Node.js helper references. */ | ||
27525 | var nodeIsMap = nodeUtil && nodeUtil.isMap; | ||
27526 | |||
27527 | /** | ||
27528 | * Checks if `value` is classified as a `Map` object. | ||
27529 | * | ||
27530 | * @static | ||
27531 | * @memberOf _ | ||
27532 | * @since 4.3.0 | ||
27533 | * @category Lang | ||
27534 | * @param {*} value The value to check. | ||
27535 | * @returns {boolean} Returns `true` if `value` is a map, else `false`. | ||
27536 | * @example | ||
27537 | * | ||
27538 | * _.isMap(new Map); | ||
27539 | * // => true | ||
27540 | * | ||
27541 | * _.isMap(new WeakMap); | ||
27542 | * // => false | ||
27543 | */ | ||
27544 | var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; | ||
27545 | |||
27546 | module.exports = isMap; | ||
27547 | |||
27548 | },{"./_baseIsMap":186,"./_baseUnary":209,"./_nodeUtil":282}],327:[function(require,module,exports){ | ||
27549 | /** | ||
27550 | * Checks if `value` is `null`. | ||
27551 | * | ||
27552 | * @static | ||
27553 | * @memberOf _ | ||
27554 | * @since 0.1.0 | ||
27555 | * @category Lang | ||
27556 | * @param {*} value The value to check. | ||
27557 | * @returns {boolean} Returns `true` if `value` is `null`, else `false`. | ||
27558 | * @example | ||
27559 | * | ||
27560 | * _.isNull(null); | ||
27561 | * // => true | ||
27562 | * | ||
27563 | * _.isNull(void 0); | ||
27564 | * // => false | ||
27565 | */ | ||
27566 | function isNull(value) { | ||
27567 | return value === null; | ||
27568 | } | ||
27569 | |||
27570 | module.exports = isNull; | ||
27571 | |||
27572 | },{}],328:[function(require,module,exports){ | ||
27573 | var baseGetTag = require('./_baseGetTag'), | ||
27574 | isObjectLike = require('./isObjectLike'); | ||
27575 | |||
27576 | /** `Object#toString` result references. */ | ||
27577 | var numberTag = '[object Number]'; | ||
27578 | |||
27579 | /** | ||
27580 | * Checks if `value` is classified as a `Number` primitive or object. | ||
27581 | * | ||
27582 | * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are | ||
27583 | * classified as numbers, use the `_.isFinite` method. | ||
27584 | * | ||
27585 | * @static | ||
27586 | * @memberOf _ | ||
27587 | * @since 0.1.0 | ||
27588 | * @category Lang | ||
27589 | * @param {*} value The value to check. | ||
27590 | * @returns {boolean} Returns `true` if `value` is a number, else `false`. | ||
27591 | * @example | ||
27592 | * | ||
27593 | * _.isNumber(3); | ||
27594 | * // => true | ||
27595 | * | ||
27596 | * _.isNumber(Number.MIN_VALUE); | ||
27597 | * // => true | ||
27598 | * | ||
27599 | * _.isNumber(Infinity); | ||
27600 | * // => true | ||
27601 | * | ||
27602 | * _.isNumber('3'); | ||
27603 | * // => false | ||
27604 | */ | ||
27605 | function isNumber(value) { | ||
27606 | return typeof value == 'number' || | ||
27607 | (isObjectLike(value) && baseGetTag(value) == numberTag); | ||
27608 | } | ||
27609 | |||
27610 | module.exports = isNumber; | ||
27611 | |||
27612 | },{"./_baseGetTag":180,"./isObjectLike":330}],329:[function(require,module,exports){ | ||
27613 | /** | ||
27614 | * Checks if `value` is the | ||
27615 | * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) | ||
27616 | * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) | ||
27617 | * | ||
27618 | * @static | ||
27619 | * @memberOf _ | ||
27620 | * @since 0.1.0 | ||
27621 | * @category Lang | ||
27622 | * @param {*} value The value to check. | ||
27623 | * @returns {boolean} Returns `true` if `value` is an object, else `false`. | ||
27624 | * @example | ||
27625 | * | ||
27626 | * _.isObject({}); | ||
27627 | * // => true | ||
27628 | * | ||
27629 | * _.isObject([1, 2, 3]); | ||
27630 | * // => true | ||
27631 | * | ||
27632 | * _.isObject(_.noop); | ||
27633 | * // => true | ||
27634 | * | ||
27635 | * _.isObject(null); | ||
27636 | * // => false | ||
27637 | */ | ||
27638 | function isObject(value) { | ||
27639 | var type = typeof value; | ||
27640 | return value != null && (type == 'object' || type == 'function'); | ||
27641 | } | ||
27642 | |||
27643 | module.exports = isObject; | ||
27644 | |||
27645 | },{}],330:[function(require,module,exports){ | ||
27646 | /** | ||
27647 | * Checks if `value` is object-like. A value is object-like if it's not `null` | ||
27648 | * and has a `typeof` result of "object". | ||
27649 | * | ||
27650 | * @static | ||
27651 | * @memberOf _ | ||
27652 | * @since 4.0.0 | ||
27653 | * @category Lang | ||
27654 | * @param {*} value The value to check. | ||
27655 | * @returns {boolean} Returns `true` if `value` is object-like, else `false`. | ||
27656 | * @example | ||
27657 | * | ||
27658 | * _.isObjectLike({}); | ||
27659 | * // => true | ||
27660 | * | ||
27661 | * _.isObjectLike([1, 2, 3]); | ||
27662 | * // => true | ||
27663 | * | ||
27664 | * _.isObjectLike(_.noop); | ||
27665 | * // => false | ||
27666 | * | ||
27667 | * _.isObjectLike(null); | ||
27668 | * // => false | ||
27669 | */ | ||
27670 | function isObjectLike(value) { | ||
27671 | return value != null && typeof value == 'object'; | ||
27672 | } | ||
27673 | |||
27674 | module.exports = isObjectLike; | ||
27675 | |||
27676 | },{}],331:[function(require,module,exports){ | ||
27677 | var baseGetTag = require('./_baseGetTag'), | ||
27678 | getPrototype = require('./_getPrototype'), | ||
27679 | isObjectLike = require('./isObjectLike'); | ||
27680 | |||
27681 | /** `Object#toString` result references. */ | ||
27682 | var objectTag = '[object Object]'; | ||
27683 | |||
27684 | /** Used for built-in method references. */ | ||
27685 | var funcProto = Function.prototype, | ||
27686 | objectProto = Object.prototype; | ||
27687 | |||
27688 | /** Used to resolve the decompiled source of functions. */ | ||
27689 | var funcToString = funcProto.toString; | ||
27690 | |||
27691 | /** Used to check objects for own properties. */ | ||
27692 | var hasOwnProperty = objectProto.hasOwnProperty; | ||
27693 | |||
27694 | /** Used to infer the `Object` constructor. */ | ||
27695 | var objectCtorString = funcToString.call(Object); | ||
27696 | |||
27697 | /** | ||
27698 | * Checks if `value` is a plain object, that is, an object created by the | ||
27699 | * `Object` constructor or one with a `[[Prototype]]` of `null`. | ||
27700 | * | ||
27701 | * @static | ||
27702 | * @memberOf _ | ||
27703 | * @since 0.8.0 | ||
27704 | * @category Lang | ||
27705 | * @param {*} value The value to check. | ||
27706 | * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. | ||
27707 | * @example | ||
27708 | * | ||
27709 | * function Foo() { | ||
27710 | * this.a = 1; | ||
27711 | * } | ||
27712 | * | ||
27713 | * _.isPlainObject(new Foo); | ||
27714 | * // => false | ||
27715 | * | ||
27716 | * _.isPlainObject([1, 2, 3]); | ||
27717 | * // => false | ||
27718 | * | ||
27719 | * _.isPlainObject({ 'x': 0, 'y': 0 }); | ||
27720 | * // => true | ||
27721 | * | ||
27722 | * _.isPlainObject(Object.create(null)); | ||
27723 | * // => true | ||
27724 | */ | ||
27725 | function isPlainObject(value) { | ||
27726 | if (!isObjectLike(value) || baseGetTag(value) != objectTag) { | ||
27727 | return false; | ||
27728 | } | ||
27729 | var proto = getPrototype(value); | ||
27730 | if (proto === null) { | ||
27731 | return true; | ||
27732 | } | ||
27733 | var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; | ||
27734 | return typeof Ctor == 'function' && Ctor instanceof Ctor && | ||
27735 | funcToString.call(Ctor) == objectCtorString; | ||
27736 | } | ||
27737 | |||
27738 | module.exports = isPlainObject; | ||
27739 | |||
27740 | },{"./_baseGetTag":180,"./_getPrototype":242,"./isObjectLike":330}],332:[function(require,module,exports){ | ||
27741 | var baseIsSet = require('./_baseIsSet'), | ||
27742 | baseUnary = require('./_baseUnary'), | ||
27743 | nodeUtil = require('./_nodeUtil'); | ||
27744 | |||
27745 | /* Node.js helper references. */ | ||
27746 | var nodeIsSet = nodeUtil && nodeUtil.isSet; | ||
27747 | |||
27748 | /** | ||
27749 | * Checks if `value` is classified as a `Set` object. | ||
27750 | * | ||
27751 | * @static | ||
27752 | * @memberOf _ | ||
27753 | * @since 4.3.0 | ||
27754 | * @category Lang | ||
27755 | * @param {*} value The value to check. | ||
27756 | * @returns {boolean} Returns `true` if `value` is a set, else `false`. | ||
27757 | * @example | ||
27758 | * | ||
27759 | * _.isSet(new Set); | ||
27760 | * // => true | ||
27761 | * | ||
27762 | * _.isSet(new WeakSet); | ||
27763 | * // => false | ||
27764 | */ | ||
27765 | var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; | ||
27766 | |||
27767 | module.exports = isSet; | ||
27768 | |||
27769 | },{"./_baseIsSet":190,"./_baseUnary":209,"./_nodeUtil":282}],333:[function(require,module,exports){ | ||
27770 | var baseGetTag = require('./_baseGetTag'), | ||
27771 | isArray = require('./isArray'), | ||
27772 | isObjectLike = require('./isObjectLike'); | ||
27773 | |||
27774 | /** `Object#toString` result references. */ | ||
27775 | var stringTag = '[object String]'; | ||
27776 | |||
27777 | /** | ||
27778 | * Checks if `value` is classified as a `String` primitive or object. | ||
27779 | * | ||
27780 | * @static | ||
27781 | * @since 0.1.0 | ||
27782 | * @memberOf _ | ||
27783 | * @category Lang | ||
27784 | * @param {*} value The value to check. | ||
27785 | * @returns {boolean} Returns `true` if `value` is a string, else `false`. | ||
27786 | * @example | ||
27787 | * | ||
27788 | * _.isString('abc'); | ||
27789 | * // => true | ||
27790 | * | ||
27791 | * _.isString(1); | ||
27792 | * // => false | ||
27793 | */ | ||
27794 | function isString(value) { | ||
27795 | return typeof value == 'string' || | ||
27796 | (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); | ||
27797 | } | ||
27798 | |||
27799 | module.exports = isString; | ||
27800 | |||
27801 | },{"./_baseGetTag":180,"./isArray":319,"./isObjectLike":330}],334:[function(require,module,exports){ | ||
27802 | var baseGetTag = require('./_baseGetTag'), | ||
27803 | isObjectLike = require('./isObjectLike'); | ||
27804 | |||
27805 | /** `Object#toString` result references. */ | ||
27806 | var symbolTag = '[object Symbol]'; | ||
27807 | |||
27808 | /** | ||
27809 | * Checks if `value` is classified as a `Symbol` primitive or object. | ||
27810 | * | ||
27811 | * @static | ||
27812 | * @memberOf _ | ||
27813 | * @since 4.0.0 | ||
27814 | * @category Lang | ||
27815 | * @param {*} value The value to check. | ||
27816 | * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. | ||
27817 | * @example | ||
27818 | * | ||
27819 | * _.isSymbol(Symbol.iterator); | ||
27820 | * // => true | ||
27821 | * | ||
27822 | * _.isSymbol('abc'); | ||
27823 | * // => false | ||
27824 | */ | ||
27825 | function isSymbol(value) { | ||
27826 | return typeof value == 'symbol' || | ||
27827 | (isObjectLike(value) && baseGetTag(value) == symbolTag); | ||
27828 | } | ||
27829 | |||
27830 | module.exports = isSymbol; | ||
27831 | |||
27832 | },{"./_baseGetTag":180,"./isObjectLike":330}],335:[function(require,module,exports){ | ||
27833 | var baseIsTypedArray = require('./_baseIsTypedArray'), | ||
27834 | baseUnary = require('./_baseUnary'), | ||
27835 | nodeUtil = require('./_nodeUtil'); | ||
27836 | |||
27837 | /* Node.js helper references. */ | ||
27838 | var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; | ||
27839 | |||
27840 | /** | ||
27841 | * Checks if `value` is classified as a typed array. | ||
27842 | * | ||
27843 | * @static | ||
27844 | * @memberOf _ | ||
27845 | * @since 3.0.0 | ||
27846 | * @category Lang | ||
27847 | * @param {*} value The value to check. | ||
27848 | * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. | ||
27849 | * @example | ||
27850 | * | ||
27851 | * _.isTypedArray(new Uint8Array); | ||
27852 | * // => true | ||
27853 | * | ||
27854 | * _.isTypedArray([]); | ||
27855 | * // => false | ||
27856 | */ | ||
27857 | var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; | ||
27858 | |||
27859 | module.exports = isTypedArray; | ||
27860 | |||
27861 | },{"./_baseIsTypedArray":191,"./_baseUnary":209,"./_nodeUtil":282}],336:[function(require,module,exports){ | ||
27862 | /** | ||
27863 | * Checks if `value` is `undefined`. | ||
27864 | * | ||
27865 | * @static | ||
27866 | * @since 0.1.0 | ||
27867 | * @memberOf _ | ||
27868 | * @category Lang | ||
27869 | * @param {*} value The value to check. | ||
27870 | * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. | ||
27871 | * @example | ||
27872 | * | ||
27873 | * _.isUndefined(void 0); | ||
27874 | * // => true | ||
27875 | * | ||
27876 | * _.isUndefined(null); | ||
27877 | * // => false | ||
27878 | */ | ||
27879 | function isUndefined(value) { | ||
27880 | return value === undefined; | ||
27881 | } | ||
27882 | |||
27883 | module.exports = isUndefined; | ||
27884 | |||
27885 | },{}],337:[function(require,module,exports){ | ||
27886 | var arrayLikeKeys = require('./_arrayLikeKeys'), | ||
27887 | baseKeys = require('./_baseKeys'), | ||
27888 | isArrayLike = require('./isArrayLike'); | ||
27889 | |||
27890 | /** | ||
27891 | * Creates an array of the own enumerable property names of `object`. | ||
27892 | * | ||
27893 | * **Note:** Non-object values are coerced to objects. See the | ||
27894 | * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) | ||
27895 | * for more details. | ||
27896 | * | ||
27897 | * @static | ||
27898 | * @since 0.1.0 | ||
27899 | * @memberOf _ | ||
27900 | * @category Object | ||
27901 | * @param {Object} object The object to query. | ||
27902 | * @returns {Array} Returns the array of property names. | ||
27903 | * @example | ||
27904 | * | ||
27905 | * function Foo() { | ||
27906 | * this.a = 1; | ||
27907 | * this.b = 2; | ||
27908 | * } | ||
27909 | * | ||
27910 | * Foo.prototype.c = 3; | ||
27911 | * | ||
27912 | * _.keys(new Foo); | ||
27913 | * // => ['a', 'b'] (iteration order is not guaranteed) | ||
27914 | * | ||
27915 | * _.keys('hi'); | ||
27916 | * // => ['0', '1'] | ||
27917 | */ | ||
27918 | function keys(object) { | ||
27919 | return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); | ||
27920 | } | ||
27921 | |||
27922 | module.exports = keys; | ||
27923 | |||
27924 | },{"./_arrayLikeKeys":159,"./_baseKeys":193,"./isArrayLike":320}],338:[function(require,module,exports){ | ||
27925 | var arrayLikeKeys = require('./_arrayLikeKeys'), | ||
27926 | baseKeysIn = require('./_baseKeysIn'), | ||
27927 | isArrayLike = require('./isArrayLike'); | ||
27928 | |||
27929 | /** | ||
27930 | * Creates an array of the own and inherited enumerable property names of `object`. | ||
27931 | * | ||
27932 | * **Note:** Non-object values are coerced to objects. | ||
27933 | * | ||
27934 | * @static | ||
27935 | * @memberOf _ | ||
27936 | * @since 3.0.0 | ||
27937 | * @category Object | ||
27938 | * @param {Object} object The object to query. | ||
27939 | * @returns {Array} Returns the array of property names. | ||
27940 | * @example | ||
27941 | * | ||
27942 | * function Foo() { | ||
27943 | * this.a = 1; | ||
27944 | * this.b = 2; | ||
27945 | * } | ||
27946 | * | ||
27947 | * Foo.prototype.c = 3; | ||
27948 | * | ||
27949 | * _.keysIn(new Foo); | ||
27950 | * // => ['a', 'b', 'c'] (iteration order is not guaranteed) | ||
27951 | */ | ||
27952 | function keysIn(object) { | ||
27953 | return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); | ||
27954 | } | ||
27955 | |||
27956 | module.exports = keysIn; | ||
27957 | |||
27958 | },{"./_arrayLikeKeys":159,"./_baseKeysIn":194,"./isArrayLike":320}],339:[function(require,module,exports){ | ||
27959 | var arrayMap = require('./_arrayMap'), | ||
27960 | baseIteratee = require('./_baseIteratee'), | ||
27961 | baseMap = require('./_baseMap'), | ||
27962 | isArray = require('./isArray'); | ||
27963 | |||
27964 | /** | ||
27965 | * Creates an array of values by running each element in `collection` thru | ||
27966 | * `iteratee`. The iteratee is invoked with three arguments: | ||
27967 | * (value, index|key, collection). | ||
27968 | * | ||
27969 | * Many lodash methods are guarded to work as iteratees for methods like | ||
27970 | * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. | ||
27971 | * | ||
27972 | * The guarded methods are: | ||
27973 | * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, | ||
27974 | * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, | ||
27975 | * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, | ||
27976 | * `template`, `trim`, `trimEnd`, `trimStart`, and `words` | ||
27977 | * | ||
27978 | * @static | ||
27979 | * @memberOf _ | ||
27980 | * @since 0.1.0 | ||
27981 | * @category Collection | ||
27982 | * @param {Array|Object} collection The collection to iterate over. | ||
27983 | * @param {Function} [iteratee=_.identity] The function invoked per iteration. | ||
27984 | * @returns {Array} Returns the new mapped array. | ||
27985 | * @example | ||
27986 | * | ||
27987 | * function square(n) { | ||
27988 | * return n * n; | ||
27989 | * } | ||
27990 | * | ||
27991 | * _.map([4, 8], square); | ||
27992 | * // => [16, 64] | ||
27993 | * | ||
27994 | * _.map({ 'a': 4, 'b': 8 }, square); | ||
27995 | * // => [16, 64] (iteration order is not guaranteed) | ||
27996 | * | ||
27997 | * var users = [ | ||
27998 | * { 'user': 'barney' }, | ||
27999 | * { 'user': 'fred' } | ||
28000 | * ]; | ||
28001 | * | ||
28002 | * // The `_.property` iteratee shorthand. | ||
28003 | * _.map(users, 'user'); | ||
28004 | * // => ['barney', 'fred'] | ||
28005 | */ | ||
28006 | function map(collection, iteratee) { | ||
28007 | var func = isArray(collection) ? arrayMap : baseMap; | ||
28008 | return func(collection, baseIteratee(iteratee, 3)); | ||
28009 | } | ||
28010 | |||
28011 | module.exports = map; | ||
28012 | |||
28013 | },{"./_arrayMap":160,"./_baseIteratee":192,"./_baseMap":195,"./isArray":319}],340:[function(require,module,exports){ | ||
28014 | var MapCache = require('./_MapCache'); | ||
28015 | |||
28016 | /** Error message constants. */ | ||
28017 | var FUNC_ERROR_TEXT = 'Expected a function'; | ||
28018 | |||
28019 | /** | ||
28020 | * Creates a function that memoizes the result of `func`. If `resolver` is | ||
28021 | * provided, it determines the cache key for storing the result based on the | ||
28022 | * arguments provided to the memoized function. By default, the first argument | ||
28023 | * provided to the memoized function is used as the map cache key. The `func` | ||
28024 | * is invoked with the `this` binding of the memoized function. | ||
28025 | * | ||
28026 | * **Note:** The cache is exposed as the `cache` property on the memoized | ||
28027 | * function. Its creation may be customized by replacing the `_.memoize.Cache` | ||
28028 | * constructor with one whose instances implement the | ||
28029 | * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) | ||
28030 | * method interface of `clear`, `delete`, `get`, `has`, and `set`. | ||
28031 | * | ||
28032 | * @static | ||
28033 | * @memberOf _ | ||
28034 | * @since 0.1.0 | ||
28035 | * @category Function | ||
28036 | * @param {Function} func The function to have its output memoized. | ||
28037 | * @param {Function} [resolver] The function to resolve the cache key. | ||
28038 | * @returns {Function} Returns the new memoized function. | ||
28039 | * @example | ||
28040 | * | ||
28041 | * var object = { 'a': 1, 'b': 2 }; | ||
28042 | * var other = { 'c': 3, 'd': 4 }; | ||
28043 | * | ||
28044 | * var values = _.memoize(_.values); | ||
28045 | * values(object); | ||
28046 | * // => [1, 2] | ||
28047 | * | ||
28048 | * values(other); | ||
28049 | * // => [3, 4] | ||
28050 | * | ||
28051 | * object.a = 2; | ||
28052 | * values(object); | ||
28053 | * // => [1, 2] | ||
28054 | * | ||
28055 | * // Modify the result cache. | ||
28056 | * values.cache.set(object, ['a', 'b']); | ||
28057 | * values(object); | ||
28058 | * // => ['a', 'b'] | ||
28059 | * | ||
28060 | * // Replace `_.memoize.Cache`. | ||
28061 | * _.memoize.Cache = WeakMap; | ||
28062 | */ | ||
28063 | function memoize(func, resolver) { | ||
28064 | if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { | ||
28065 | throw new TypeError(FUNC_ERROR_TEXT); | ||
28066 | } | ||
28067 | var memoized = function() { | ||
28068 | var args = arguments, | ||
28069 | key = resolver ? resolver.apply(this, args) : args[0], | ||
28070 | cache = memoized.cache; | ||
28071 | |||
28072 | if (cache.has(key)) { | ||
28073 | return cache.get(key); | ||
28074 | } | ||
28075 | var result = func.apply(this, args); | ||
28076 | memoized.cache = cache.set(key, result) || cache; | ||
28077 | return result; | ||
28078 | }; | ||
28079 | memoized.cache = new (memoize.Cache || MapCache); | ||
28080 | return memoized; | ||
28081 | } | ||
28082 | |||
28083 | // Expose `MapCache`. | ||
28084 | memoize.Cache = MapCache; | ||
28085 | |||
28086 | module.exports = memoize; | ||
28087 | |||
28088 | },{"./_MapCache":147}],341:[function(require,module,exports){ | ||
28089 | var createPadding = require('./_createPadding'), | ||
28090 | stringSize = require('./_stringSize'), | ||
28091 | toInteger = require('./toInteger'), | ||
28092 | toString = require('./toString'); | ||
28093 | |||
28094 | /** | ||
28095 | * Pads `string` on the right side if it's shorter than `length`. Padding | ||
28096 | * characters are truncated if they exceed `length`. | ||
28097 | * | ||
28098 | * @static | ||
28099 | * @memberOf _ | ||
28100 | * @since 4.0.0 | ||
28101 | * @category String | ||
28102 | * @param {string} [string=''] The string to pad. | ||
28103 | * @param {number} [length=0] The padding length. | ||
28104 | * @param {string} [chars=' '] The string used as padding. | ||
28105 | * @returns {string} Returns the padded string. | ||
28106 | * @example | ||
28107 | * | ||
28108 | * _.padEnd('abc', 6); | ||
28109 | * // => 'abc ' | ||
28110 | * | ||
28111 | * _.padEnd('abc', 6, '_-'); | ||
28112 | * // => 'abc_-_' | ||
28113 | * | ||
28114 | * _.padEnd('abc', 3); | ||
28115 | * // => 'abc' | ||
28116 | */ | ||
28117 | function padEnd(string, length, chars) { | ||
28118 | string = toString(string); | ||
28119 | length = toInteger(length); | ||
28120 | |||
28121 | var strLength = length ? stringSize(string) : 0; | ||
28122 | return (length && strLength < length) | ||
28123 | ? (string + createPadding(length - strLength, chars)) | ||
28124 | : string; | ||
28125 | } | ||
28126 | |||
28127 | module.exports = padEnd; | ||
28128 | |||
28129 | },{"./_createPadding":230,"./_stringSize":298,"./toInteger":348,"./toString":350}],342:[function(require,module,exports){ | ||
28130 | var basePick = require('./_basePick'), | ||
28131 | flatRest = require('./_flatRest'); | ||
28132 | |||
28133 | /** | ||
28134 | * Creates an object composed of the picked `object` properties. | ||
28135 | * | ||
28136 | * @static | ||
28137 | * @since 0.1.0 | ||
28138 | * @memberOf _ | ||
28139 | * @category Object | ||
28140 | * @param {Object} object The source object. | ||
28141 | * @param {...(string|string[])} [paths] The property paths to pick. | ||
28142 | * @returns {Object} Returns the new object. | ||
28143 | * @example | ||
28144 | * | ||
28145 | * var object = { 'a': 1, 'b': '2', 'c': 3 }; | ||
28146 | * | ||
28147 | * _.pick(object, ['a', 'c']); | ||
28148 | * // => { 'a': 1, 'c': 3 } | ||
28149 | */ | ||
28150 | var pick = flatRest(function(object, paths) { | ||
28151 | return object == null ? {} : basePick(object, paths); | ||
28152 | }); | ||
28153 | |||
28154 | module.exports = pick; | ||
28155 | |||
28156 | },{"./_basePick":198,"./_flatRest":235}],343:[function(require,module,exports){ | ||
28157 | var baseProperty = require('./_baseProperty'), | ||
28158 | basePropertyDeep = require('./_basePropertyDeep'), | ||
28159 | isKey = require('./_isKey'), | ||
28160 | toKey = require('./_toKey'); | ||
28161 | |||
28162 | /** | ||
28163 | * Creates a function that returns the value at `path` of a given object. | ||
28164 | * | ||
28165 | * @static | ||
28166 | * @memberOf _ | ||
28167 | * @since 2.4.0 | ||
28168 | * @category Util | ||
28169 | * @param {Array|string} path The path of the property to get. | ||
28170 | * @returns {Function} Returns the new accessor function. | ||
28171 | * @example | ||
28172 | * | ||
28173 | * var objects = [ | ||
28174 | * { 'a': { 'b': 2 } }, | ||
28175 | * { 'a': { 'b': 1 } } | ||
28176 | * ]; | ||
28177 | * | ||
28178 | * _.map(objects, _.property('a.b')); | ||
28179 | * // => [2, 1] | ||
28180 | * | ||
28181 | * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b'); | ||
28182 | * // => [1, 2] | ||
28183 | */ | ||
28184 | function property(path) { | ||
28185 | return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path); | ||
28186 | } | ||
28187 | |||
28188 | module.exports = property; | ||
28189 | |||
28190 | },{"./_baseProperty":200,"./_basePropertyDeep":201,"./_isKey":261,"./_toKey":301}],344:[function(require,module,exports){ | ||
28191 | /** | ||
28192 | * This method returns a new empty array. | ||
28193 | * | ||
28194 | * @static | ||
28195 | * @memberOf _ | ||
28196 | * @since 4.13.0 | ||
28197 | * @category Util | ||
28198 | * @returns {Array} Returns the new empty array. | ||
28199 | * @example | ||
28200 | * | ||
28201 | * var arrays = _.times(2, _.stubArray); | ||
28202 | * | ||
28203 | * console.log(arrays); | ||
28204 | * // => [[], []] | ||
28205 | * | ||
28206 | * console.log(arrays[0] === arrays[1]); | ||
28207 | * // => false | ||
28208 | */ | ||
28209 | function stubArray() { | ||
28210 | return []; | ||
28211 | } | ||
28212 | |||
28213 | module.exports = stubArray; | ||
28214 | |||
28215 | },{}],345:[function(require,module,exports){ | ||
28216 | /** | ||
28217 | * This method returns `false`. | ||
28218 | * | ||
28219 | * @static | ||
28220 | * @memberOf _ | ||
28221 | * @since 4.13.0 | ||
28222 | * @category Util | ||
28223 | * @returns {boolean} Returns `false`. | ||
28224 | * @example | ||
28225 | * | ||
28226 | * _.times(2, _.stubFalse); | ||
28227 | * // => [false, false] | ||
28228 | */ | ||
28229 | function stubFalse() { | ||
28230 | return false; | ||
28231 | } | ||
28232 | |||
28233 | module.exports = stubFalse; | ||
28234 | |||
28235 | },{}],346:[function(require,module,exports){ | ||
28236 | var baseTimes = require('./_baseTimes'), | ||
28237 | castFunction = require('./_castFunction'), | ||
28238 | toInteger = require('./toInteger'); | ||
28239 | |||
28240 | /** Used as references for various `Number` constants. */ | ||
28241 | var MAX_SAFE_INTEGER = 9007199254740991; | ||
28242 | |||
28243 | /** Used as references for the maximum length and index of an array. */ | ||
28244 | var MAX_ARRAY_LENGTH = 4294967295; | ||
28245 | |||
28246 | /* Built-in method references for those with the same name as other `lodash` methods. */ | ||
28247 | var nativeMin = Math.min; | ||
28248 | |||
28249 | /** | ||
28250 | * Invokes the iteratee `n` times, returning an array of the results of | ||
28251 | * each invocation. The iteratee is invoked with one argument; (index). | ||
28252 | * | ||
28253 | * @static | ||
28254 | * @since 0.1.0 | ||
28255 | * @memberOf _ | ||
28256 | * @category Util | ||
28257 | * @param {number} n The number of times to invoke `iteratee`. | ||
28258 | * @param {Function} [iteratee=_.identity] The function invoked per iteration. | ||
28259 | * @returns {Array} Returns the array of results. | ||
28260 | * @example | ||
28261 | * | ||
28262 | * _.times(3, String); | ||
28263 | * // => ['0', '1', '2'] | ||
28264 | * | ||
28265 | * _.times(4, _.constant(0)); | ||
28266 | * // => [0, 0, 0, 0] | ||
28267 | */ | ||
28268 | function times(n, iteratee) { | ||
28269 | n = toInteger(n); | ||
28270 | if (n < 1 || n > MAX_SAFE_INTEGER) { | ||
28271 | return []; | ||
28272 | } | ||
28273 | var index = MAX_ARRAY_LENGTH, | ||
28274 | length = nativeMin(n, MAX_ARRAY_LENGTH); | ||
28275 | |||
28276 | iteratee = castFunction(iteratee); | ||
28277 | n -= MAX_ARRAY_LENGTH; | ||
28278 | |||
28279 | var result = baseTimes(length, iteratee); | ||
28280 | while (++index < n) { | ||
28281 | iteratee(index); | ||
28282 | } | ||
28283 | return result; | ||
28284 | } | ||
28285 | |||
28286 | module.exports = times; | ||
28287 | |||
28288 | },{"./_baseTimes":207,"./_castFunction":212,"./toInteger":348}],347:[function(require,module,exports){ | ||
28289 | var toNumber = require('./toNumber'); | ||
28290 | |||
28291 | /** Used as references for various `Number` constants. */ | ||
28292 | var INFINITY = 1 / 0, | ||
28293 | MAX_INTEGER = 1.7976931348623157e+308; | ||
28294 | |||
28295 | /** | ||
28296 | * Converts `value` to a finite number. | ||
28297 | * | ||
28298 | * @static | ||
28299 | * @memberOf _ | ||
28300 | * @since 4.12.0 | ||
28301 | * @category Lang | ||
28302 | * @param {*} value The value to convert. | ||
28303 | * @returns {number} Returns the converted number. | ||
28304 | * @example | ||
28305 | * | ||
28306 | * _.toFinite(3.2); | ||
28307 | * // => 3.2 | ||
28308 | * | ||
28309 | * _.toFinite(Number.MIN_VALUE); | ||
28310 | * // => 5e-324 | ||
28311 | * | ||
28312 | * _.toFinite(Infinity); | ||
28313 | * // => 1.7976931348623157e+308 | ||
28314 | * | ||
28315 | * _.toFinite('3.2'); | ||
28316 | * // => 3.2 | ||
28317 | */ | ||
28318 | function toFinite(value) { | ||
28319 | if (!value) { | ||
28320 | return value === 0 ? value : 0; | ||
28321 | } | ||
28322 | value = toNumber(value); | ||
28323 | if (value === INFINITY || value === -INFINITY) { | ||
28324 | var sign = (value < 0 ? -1 : 1); | ||
28325 | return sign * MAX_INTEGER; | ||
28326 | } | ||
28327 | return value === value ? value : 0; | ||
28328 | } | ||
28329 | |||
28330 | module.exports = toFinite; | ||
28331 | |||
28332 | },{"./toNumber":349}],348:[function(require,module,exports){ | ||
28333 | var toFinite = require('./toFinite'); | ||
28334 | |||
28335 | /** | ||
28336 | * Converts `value` to an integer. | ||
28337 | * | ||
28338 | * **Note:** This method is loosely based on | ||
28339 | * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). | ||
28340 | * | ||
28341 | * @static | ||
28342 | * @memberOf _ | ||
28343 | * @since 4.0.0 | ||
28344 | * @category Lang | ||
28345 | * @param {*} value The value to convert. | ||
28346 | * @returns {number} Returns the converted integer. | ||
28347 | * @example | ||
28348 | * | ||
28349 | * _.toInteger(3.2); | ||
28350 | * // => 3 | ||
28351 | * | ||
28352 | * _.toInteger(Number.MIN_VALUE); | ||
28353 | * // => 0 | ||
28354 | * | ||
28355 | * _.toInteger(Infinity); | ||
28356 | * // => 1.7976931348623157e+308 | ||
28357 | * | ||
28358 | * _.toInteger('3.2'); | ||
28359 | * // => 3 | ||
28360 | */ | ||
28361 | function toInteger(value) { | ||
28362 | var result = toFinite(value), | ||
28363 | remainder = result % 1; | ||
28364 | |||
28365 | return result === result ? (remainder ? result - remainder : result) : 0; | ||
28366 | } | ||
28367 | |||
28368 | module.exports = toInteger; | ||
28369 | |||
28370 | },{"./toFinite":347}],349:[function(require,module,exports){ | ||
28371 | var isObject = require('./isObject'), | ||
28372 | isSymbol = require('./isSymbol'); | ||
28373 | |||
28374 | /** Used as references for various `Number` constants. */ | ||
28375 | var NAN = 0 / 0; | ||
28376 | |||
28377 | /** Used to match leading and trailing whitespace. */ | ||
28378 | var reTrim = /^\s+|\s+$/g; | ||
28379 | |||
28380 | /** Used to detect bad signed hexadecimal string values. */ | ||
28381 | var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; | ||
28382 | |||
28383 | /** Used to detect binary string values. */ | ||
28384 | var reIsBinary = /^0b[01]+$/i; | ||
28385 | |||
28386 | /** Used to detect octal string values. */ | ||
28387 | var reIsOctal = /^0o[0-7]+$/i; | ||
28388 | |||
28389 | /** Built-in method references without a dependency on `root`. */ | ||
28390 | var freeParseInt = parseInt; | ||
28391 | |||
28392 | /** | ||
28393 | * Converts `value` to a number. | ||
28394 | * | ||
28395 | * @static | ||
28396 | * @memberOf _ | ||
28397 | * @since 4.0.0 | ||
28398 | * @category Lang | ||
28399 | * @param {*} value The value to process. | ||
28400 | * @returns {number} Returns the number. | ||
28401 | * @example | ||
28402 | * | ||
28403 | * _.toNumber(3.2); | ||
28404 | * // => 3.2 | ||
28405 | * | ||
28406 | * _.toNumber(Number.MIN_VALUE); | ||
28407 | * // => 5e-324 | ||
28408 | * | ||
28409 | * _.toNumber(Infinity); | ||
28410 | * // => Infinity | ||
28411 | * | ||
28412 | * _.toNumber('3.2'); | ||
28413 | * // => 3.2 | ||
28414 | */ | ||
28415 | function toNumber(value) { | ||
28416 | if (typeof value == 'number') { | ||
28417 | return value; | ||
28418 | } | ||
28419 | if (isSymbol(value)) { | ||
28420 | return NAN; | ||
28421 | } | ||
28422 | if (isObject(value)) { | ||
28423 | var other = typeof value.valueOf == 'function' ? value.valueOf() : value; | ||
28424 | value = isObject(other) ? (other + '') : other; | ||
28425 | } | ||
28426 | if (typeof value != 'string') { | ||
28427 | return value === 0 ? value : +value; | ||
28428 | } | ||
28429 | value = value.replace(reTrim, ''); | ||
28430 | var isBinary = reIsBinary.test(value); | ||
28431 | return (isBinary || reIsOctal.test(value)) | ||
28432 | ? freeParseInt(value.slice(2), isBinary ? 2 : 8) | ||
28433 | : (reIsBadHex.test(value) ? NAN : +value); | ||
28434 | } | ||
28435 | |||
28436 | module.exports = toNumber; | ||
28437 | |||
28438 | },{"./isObject":329,"./isSymbol":334}],350:[function(require,module,exports){ | ||
28439 | var baseToString = require('./_baseToString'); | ||
28440 | |||
28441 | /** | ||
28442 | * Converts `value` to a string. An empty string is returned for `null` | ||
28443 | * and `undefined` values. The sign of `-0` is preserved. | ||
28444 | * | ||
28445 | * @static | ||
28446 | * @memberOf _ | ||
28447 | * @since 4.0.0 | ||
28448 | * @category Lang | ||
28449 | * @param {*} value The value to convert. | ||
28450 | * @returns {string} Returns the converted string. | ||
28451 | * @example | ||
28452 | * | ||
28453 | * _.toString(null); | ||
28454 | * // => '' | ||
28455 | * | ||
28456 | * _.toString(-0); | ||
28457 | * // => '-0' | ||
28458 | * | ||
28459 | * _.toString([1, 2, 3]); | ||
28460 | * // => '1,2,3' | ||
28461 | */ | ||
28462 | function toString(value) { | ||
28463 | return value == null ? '' : baseToString(value); | ||
28464 | } | ||
28465 | |||
28466 | module.exports = toString; | ||
28467 | |||
28468 | },{"./_baseToString":208}],351:[function(require,module,exports){ | ||
28469 | var baseToString = require('./_baseToString'), | ||
28470 | castSlice = require('./_castSlice'), | ||
28471 | charsEndIndex = require('./_charsEndIndex'), | ||
28472 | stringToArray = require('./_stringToArray'), | ||
28473 | toString = require('./toString'); | ||
28474 | |||
28475 | /** Used to match leading and trailing whitespace. */ | ||
28476 | var reTrimEnd = /\s+$/; | ||
28477 | |||
28478 | /** | ||
28479 | * Removes trailing whitespace or specified characters from `string`. | ||
28480 | * | ||
28481 | * @static | ||
28482 | * @memberOf _ | ||
28483 | * @since 4.0.0 | ||
28484 | * @category String | ||
28485 | * @param {string} [string=''] The string to trim. | ||
28486 | * @param {string} [chars=whitespace] The characters to trim. | ||
28487 | * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. | ||
28488 | * @returns {string} Returns the trimmed string. | ||
28489 | * @example | ||
28490 | * | ||
28491 | * _.trimEnd(' abc '); | ||
28492 | * // => ' abc' | ||
28493 | * | ||
28494 | * _.trimEnd('-_-abc-_-', '_-'); | ||
28495 | * // => '-_-abc' | ||
28496 | */ | ||
28497 | function trimEnd(string, chars, guard) { | ||
28498 | string = toString(string); | ||
28499 | if (string && (guard || chars === undefined)) { | ||
28500 | return string.replace(reTrimEnd, ''); | ||
28501 | } | ||
28502 | if (!string || !(chars = baseToString(chars))) { | ||
28503 | return string; | ||
28504 | } | ||
28505 | var strSymbols = stringToArray(string), | ||
28506 | end = charsEndIndex(strSymbols, stringToArray(chars)) + 1; | ||
28507 | |||
28508 | return castSlice(strSymbols, 0, end).join(''); | ||
28509 | } | ||
28510 | |||
28511 | module.exports = trimEnd; | ||
28512 | |||
28513 | },{"./_baseToString":208,"./_castSlice":214,"./_charsEndIndex":215,"./_stringToArray":299,"./toString":350}],352:[function(require,module,exports){ | ||
28514 | var baseValues = require('./_baseValues'), | ||
28515 | keys = require('./keys'); | ||
28516 | |||
28517 | /** | ||
28518 | * Creates an array of the own enumerable string keyed property values of `object`. | ||
28519 | * | ||
28520 | * **Note:** Non-object values are coerced to objects. | ||
28521 | * | ||
28522 | * @static | ||
28523 | * @since 0.1.0 | ||
28524 | * @memberOf _ | ||
28525 | * @category Object | ||
28526 | * @param {Object} object The object to query. | ||
28527 | * @returns {Array} Returns the array of property values. | ||
28528 | * @example | ||
28529 | * | ||
28530 | * function Foo() { | ||
28531 | * this.a = 1; | ||
28532 | * this.b = 2; | ||
28533 | * } | ||
28534 | * | ||
28535 | * Foo.prototype.c = 3; | ||
28536 | * | ||
28537 | * _.values(new Foo); | ||
28538 | * // => [1, 2] (iteration order is not guaranteed) | ||
28539 | * | ||
28540 | * _.values('hi'); | ||
28541 | * // => ['h', 'i'] | ||
28542 | */ | ||
28543 | function values(object) { | ||
28544 | return object == null ? [] : baseValues(object, keys(object)); | ||
28545 | } | ||
28546 | |||
28547 | module.exports = values; | ||
28548 | |||
28549 | },{"./_baseValues":210,"./keys":337}],353:[function(require,module,exports){ | ||
28550 | /* | ||
28551 | Copyright 2013 Daniel Wirtz <dcode@dcode.io> | ||
28552 | Copyright 2009 The Closure Library Authors. All Rights Reserved. | ||
28553 | |||
28554 | Licensed under the Apache License, Version 2.0 (the "License"); | ||
28555 | you may not use this file except in compliance with the License. | ||
28556 | You may obtain a copy of the License at | ||
28557 | |||
28558 | http://www.apache.org/licenses/LICENSE-2.0 | ||
28559 | |||
28560 | Unless required by applicable law or agreed to in writing, software | ||
28561 | distributed under the License is distributed on an "AS-IS" BASIS, | ||
28562 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
28563 | See the License for the specific language governing permissions and | ||
28564 | limitations under the License. | ||
28565 | */ | ||
28566 | |||
28567 | /** | ||
28568 | * @license Long.js (c) 2013 Daniel Wirtz <dcode@dcode.io> | ||
28569 | * Released under the Apache License, Version 2.0 | ||
28570 | * see: https://github.com/dcodeIO/Long.js for details | ||
28571 | */ | ||
28572 | (function(global, factory) { | ||
28573 | |||
28574 | /* AMD */ if (typeof define === 'function' && define["amd"]) | ||
28575 | define([], factory); | ||
28576 | /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"]) | ||
28577 | module["exports"] = factory(); | ||
28578 | /* Global */ else | ||
28579 | (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory(); | ||
28580 | |||
28581 | })(this, function() { | ||
28582 | "use strict"; | ||
28583 | |||
28584 | /** | ||
28585 | * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers. | ||
28586 | * See the from* functions below for more convenient ways of constructing Longs. | ||
28587 | * @exports Long | ||
28588 | * @class A Long class for representing a 64 bit two's-complement integer value. | ||
28589 | * @param {number} low The low (signed) 32 bits of the long | ||
28590 | * @param {number} high The high (signed) 32 bits of the long | ||
28591 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | ||
28592 | * @constructor | ||
28593 | */ | ||
28594 | function Long(low, high, unsigned) { | ||
28595 | |||
28596 | /** | ||
28597 | * The low 32 bits as a signed value. | ||
28598 | * @type {number} | ||
28599 | * @expose | ||
28600 | */ | ||
28601 | this.low = low|0; | ||
28602 | |||
28603 | /** | ||
28604 | * The high 32 bits as a signed value. | ||
28605 | * @type {number} | ||
28606 | * @expose | ||
28607 | */ | ||
28608 | this.high = high|0; | ||
28609 | |||
28610 | /** | ||
28611 | * Whether unsigned or not. | ||
28612 | * @type {boolean} | ||
28613 | * @expose | ||
28614 | */ | ||
28615 | this.unsigned = !!unsigned; | ||
28616 | } | ||
28617 | |||
28618 | // The internal representation of a long is the two given signed, 32-bit values. | ||
28619 | // We use 32-bit pieces because these are the size of integers on which | ||
28620 | // Javascript performs bit-operations. For operations like addition and | ||
28621 | // multiplication, we split each number into 16 bit pieces, which can easily be | ||
28622 | // multiplied within Javascript's floating-point representation without overflow | ||
28623 | // or change in sign. | ||
28624 | // | ||
28625 | // In the algorithms below, we frequently reduce the negative case to the | ||
28626 | // positive case by negating the input(s) and then post-processing the result. | ||
28627 | // Note that we must ALWAYS check specially whether those values are MIN_VALUE | ||
28628 | // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as | ||
28629 | // a positive number, it overflows back into a negative). Not handling this | ||
28630 | // case would often result in infinite recursion. | ||
28631 | // | ||
28632 | // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from* | ||
28633 | // methods on which they depend. | ||
28634 | |||
28635 | /** | ||
28636 | * An indicator used to reliably determine if an object is a Long or not. | ||
28637 | * @type {boolean} | ||
28638 | * @const | ||
28639 | * @expose | ||
28640 | * @private | ||
28641 | */ | ||
28642 | Long.__isLong__; | ||
28643 | |||
28644 | Object.defineProperty(Long.prototype, "__isLong__", { | ||
28645 | value: true, | ||
28646 | enumerable: false, | ||
28647 | configurable: false | ||
28648 | }); | ||
28649 | |||
28650 | /** | ||
28651 | * Tests if the specified object is a Long. | ||
28652 | * @param {*} obj Object | ||
28653 | * @returns {boolean} | ||
28654 | * @expose | ||
28655 | */ | ||
28656 | Long.isLong = function isLong(obj) { | ||
28657 | return (obj && obj["__isLong__"]) === true; | ||
28658 | }; | ||
28659 | |||
28660 | /** | ||
28661 | * A cache of the Long representations of small integer values. | ||
28662 | * @type {!Object} | ||
28663 | * @inner | ||
28664 | */ | ||
28665 | var INT_CACHE = {}; | ||
28666 | |||
28667 | /** | ||
28668 | * A cache of the Long representations of small unsigned integer values. | ||
28669 | * @type {!Object} | ||
28670 | * @inner | ||
28671 | */ | ||
28672 | var UINT_CACHE = {}; | ||
28673 | |||
28674 | /** | ||
28675 | * Returns a Long representing the given 32 bit integer value. | ||
28676 | * @param {number} value The 32 bit integer in question | ||
28677 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | ||
28678 | * @returns {!Long} The corresponding Long value | ||
28679 | * @expose | ||
28680 | */ | ||
28681 | Long.fromInt = function fromInt(value, unsigned) { | ||
28682 | var obj, cachedObj; | ||
28683 | if (!unsigned) { | ||
28684 | value = value | 0; | ||
28685 | if (-128 <= value && value < 128) { | ||
28686 | cachedObj = INT_CACHE[value]; | ||
28687 | if (cachedObj) | ||
28688 | return cachedObj; | ||
28689 | } | ||
28690 | obj = new Long(value, value < 0 ? -1 : 0, false); | ||
28691 | if (-128 <= value && value < 128) | ||
28692 | INT_CACHE[value] = obj; | ||
28693 | return obj; | ||
28694 | } else { | ||
28695 | value = value >>> 0; | ||
28696 | if (0 <= value && value < 256) { | ||
28697 | cachedObj = UINT_CACHE[value]; | ||
28698 | if (cachedObj) | ||
28699 | return cachedObj; | ||
28700 | } | ||
28701 | obj = new Long(value, (value | 0) < 0 ? -1 : 0, true); | ||
28702 | if (0 <= value && value < 256) | ||
28703 | UINT_CACHE[value] = obj; | ||
28704 | return obj; | ||
28705 | } | ||
28706 | }; | ||
28707 | |||
28708 | /** | ||
28709 | * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned. | ||
28710 | * @param {number} value The number in question | ||
28711 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | ||
28712 | * @returns {!Long} The corresponding Long value | ||
28713 | * @expose | ||
28714 | */ | ||
28715 | Long.fromNumber = function fromNumber(value, unsigned) { | ||
28716 | unsigned = !!unsigned; | ||
28717 | if (isNaN(value) || !isFinite(value)) | ||
28718 | return Long.ZERO; | ||
28719 | if (!unsigned && value <= -TWO_PWR_63_DBL) | ||
28720 | return Long.MIN_VALUE; | ||
28721 | if (!unsigned && value + 1 >= TWO_PWR_63_DBL) | ||
28722 | return Long.MAX_VALUE; | ||
28723 | if (unsigned && value >= TWO_PWR_64_DBL) | ||
28724 | return Long.MAX_UNSIGNED_VALUE; | ||
28725 | if (value < 0) | ||
28726 | return Long.fromNumber(-value, unsigned).negate(); | ||
28727 | return new Long((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned); | ||
28728 | }; | ||
28729 | |||
28730 | /** | ||
28731 | * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is | ||
28732 | * assumed to use 32 bits. | ||
28733 | * @param {number} lowBits The low 32 bits | ||
28734 | * @param {number} highBits The high 32 bits | ||
28735 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | ||
28736 | * @returns {!Long} The corresponding Long value | ||
28737 | * @expose | ||
28738 | */ | ||
28739 | Long.fromBits = function fromBits(lowBits, highBits, unsigned) { | ||
28740 | return new Long(lowBits, highBits, unsigned); | ||
28741 | }; | ||
28742 | |||
28743 | /** | ||
28744 | * Returns a Long representation of the given string, written using the specified radix. | ||
28745 | * @param {string} str The textual representation of the Long | ||
28746 | * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed | ||
28747 | * @param {number=} radix The radix in which the text is written (2-36), defaults to 10 | ||
28748 | * @returns {!Long} The corresponding Long value | ||
28749 | * @expose | ||
28750 | */ | ||
28751 | Long.fromString = function fromString(str, unsigned, radix) { | ||
28752 | if (str.length === 0) | ||
28753 | throw Error('number format error: empty string'); | ||
28754 | if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity") | ||
28755 | return Long.ZERO; | ||
28756 | if (typeof unsigned === 'number') // For goog.math.long compatibility | ||
28757 | radix = unsigned, | ||
28758 | unsigned = false; | ||
28759 | radix = radix || 10; | ||
28760 | if (radix < 2 || 36 < radix) | ||
28761 | throw Error('radix out of range: ' + radix); | ||
28762 | |||
28763 | var p; | ||
28764 | if ((p = str.indexOf('-')) > 0) | ||
28765 | throw Error('number format error: interior "-" character: ' + str); | ||
28766 | else if (p === 0) | ||
28767 | return Long.fromString(str.substring(1), unsigned, radix).negate(); | ||
28768 | |||
28769 | // Do several (8) digits each time through the loop, so as to | ||
28770 | // minimize the calls to the very expensive emulated div. | ||
28771 | var radixToPower = Long.fromNumber(Math.pow(radix, 8)); | ||
28772 | |||
28773 | var result = Long.ZERO; | ||
28774 | for (var i = 0; i < str.length; i += 8) { | ||
28775 | var size = Math.min(8, str.length - i); | ||
28776 | var value = parseInt(str.substring(i, i + size), radix); | ||
28777 | if (size < 8) { | ||
28778 | var power = Long.fromNumber(Math.pow(radix, size)); | ||
28779 | result = result.multiply(power).add(Long.fromNumber(value)); | ||
28780 | } else { | ||
28781 | result = result.multiply(radixToPower); | ||
28782 | result = result.add(Long.fromNumber(value)); | ||
28783 | } | ||
28784 | } | ||
28785 | result.unsigned = unsigned; | ||
28786 | return result; | ||
28787 | }; | ||
28788 | |||
28789 | /** | ||
28790 | * Converts the specified value to a Long. | ||
28791 | * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value | ||
28792 | * @returns {!Long} | ||
28793 | * @expose | ||
28794 | */ | ||
28795 | Long.fromValue = function fromValue(val) { | ||
28796 | if (val /* is compatible */ instanceof Long) | ||
28797 | return val; | ||
28798 | if (typeof val === 'number') | ||
28799 | return Long.fromNumber(val); | ||
28800 | if (typeof val === 'string') | ||
28801 | return Long.fromString(val); | ||
28802 | // Throws for non-objects, converts non-instanceof Long: | ||
28803 | return new Long(val.low, val.high, val.unsigned); | ||
28804 | }; | ||
28805 | |||
28806 | // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be | ||
28807 | // no runtime penalty for these. | ||
28808 | |||
28809 | /** | ||
28810 | * @type {number} | ||
28811 | * @const | ||
28812 | * @inner | ||
28813 | */ | ||
28814 | var TWO_PWR_16_DBL = 1 << 16; | ||
28815 | |||
28816 | /** | ||
28817 | * @type {number} | ||
28818 | * @const | ||
28819 | * @inner | ||
28820 | */ | ||
28821 | var TWO_PWR_24_DBL = 1 << 24; | ||
28822 | |||
28823 | /** | ||
28824 | * @type {number} | ||
28825 | * @const | ||
28826 | * @inner | ||
28827 | */ | ||
28828 | var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; | ||
28829 | |||
28830 | /** | ||
28831 | * @type {number} | ||
28832 | * @const | ||
28833 | * @inner | ||
28834 | */ | ||
28835 | var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; | ||
28836 | |||
28837 | /** | ||
28838 | * @type {number} | ||
28839 | * @const | ||
28840 | * @inner | ||
28841 | */ | ||
28842 | var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; | ||
28843 | |||
28844 | /** | ||
28845 | * @type {!Long} | ||
28846 | * @const | ||
28847 | * @inner | ||
28848 | */ | ||
28849 | var TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL); | ||
28850 | |||
28851 | /** | ||
28852 | * Signed zero. | ||
28853 | * @type {!Long} | ||
28854 | * @expose | ||
28855 | */ | ||
28856 | Long.ZERO = Long.fromInt(0); | ||
28857 | |||
28858 | /** | ||
28859 | * Unsigned zero. | ||
28860 | * @type {!Long} | ||
28861 | * @expose | ||
28862 | */ | ||
28863 | Long.UZERO = Long.fromInt(0, true); | ||
28864 | |||
28865 | /** | ||
28866 | * Signed one. | ||
28867 | * @type {!Long} | ||
28868 | * @expose | ||
28869 | */ | ||
28870 | Long.ONE = Long.fromInt(1); | ||
28871 | |||
28872 | /** | ||
28873 | * Unsigned one. | ||
28874 | * @type {!Long} | ||
28875 | * @expose | ||
28876 | */ | ||
28877 | Long.UONE = Long.fromInt(1, true); | ||
28878 | |||
28879 | /** | ||
28880 | * Signed negative one. | ||
28881 | * @type {!Long} | ||
28882 | * @expose | ||
28883 | */ | ||
28884 | Long.NEG_ONE = Long.fromInt(-1); | ||
28885 | |||
28886 | /** | ||
28887 | * Maximum signed value. | ||
28888 | * @type {!Long} | ||
28889 | * @expose | ||
28890 | */ | ||
28891 | Long.MAX_VALUE = Long.fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false); | ||
28892 | |||
28893 | /** | ||
28894 | * Maximum unsigned value. | ||
28895 | * @type {!Long} | ||
28896 | * @expose | ||
28897 | */ | ||
28898 | Long.MAX_UNSIGNED_VALUE = Long.fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true); | ||
28899 | |||
28900 | /** | ||
28901 | * Minimum signed value. | ||
28902 | * @type {!Long} | ||
28903 | * @expose | ||
28904 | */ | ||
28905 | Long.MIN_VALUE = Long.fromBits(0, 0x80000000|0, false); | ||
28906 | |||
28907 | /** | ||
28908 | * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer. | ||
28909 | * @returns {number} | ||
28910 | * @expose | ||
28911 | */ | ||
28912 | Long.prototype.toInt = function toInt() { | ||
28913 | return this.unsigned ? this.low >>> 0 : this.low; | ||
28914 | }; | ||
28915 | |||
28916 | /** | ||
28917 | * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa). | ||
28918 | * @returns {number} | ||
28919 | * @expose | ||
28920 | */ | ||
28921 | Long.prototype.toNumber = function toNumber() { | ||
28922 | if (this.unsigned) { | ||
28923 | return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0); | ||
28924 | } | ||
28925 | return this.high * TWO_PWR_32_DBL + (this.low >>> 0); | ||
28926 | }; | ||
28927 | |||
28928 | /** | ||
28929 | * Converts the Long to a string written in the specified radix. | ||
28930 | * @param {number=} radix Radix (2-36), defaults to 10 | ||
28931 | * @returns {string} | ||
28932 | * @override | ||
28933 | * @throws {RangeError} If `radix` is out of range | ||
28934 | * @expose | ||
28935 | */ | ||
28936 | Long.prototype.toString = function toString(radix) { | ||
28937 | radix = radix || 10; | ||
28938 | if (radix < 2 || 36 < radix) | ||
28939 | throw RangeError('radix out of range: ' + radix); | ||
28940 | if (this.isZero()) | ||
28941 | return '0'; | ||
28942 | var rem; | ||
28943 | if (this.isNegative()) { // Unsigned Longs are never negative | ||
28944 | if (this.equals(Long.MIN_VALUE)) { | ||
28945 | // We need to change the Long value before it can be negated, so we remove | ||
28946 | // the bottom-most digit in this base and then recurse to do the rest. | ||
28947 | var radixLong = Long.fromNumber(radix); | ||
28948 | var div = this.divide(radixLong); | ||
28949 | rem = div.multiply(radixLong).subtract(this); | ||
28950 | return div.toString(radix) + rem.toInt().toString(radix); | ||
28951 | } else | ||
28952 | return '-' + this.negate().toString(radix); | ||
28953 | } | ||
28954 | |||
28955 | // Do several (6) digits each time through the loop, so as to | ||
28956 | // minimize the calls to the very expensive emulated div. | ||
28957 | var radixToPower = Long.fromNumber(Math.pow(radix, 6), this.unsigned); | ||
28958 | rem = this; | ||
28959 | var result = ''; | ||
28960 | while (true) { | ||
28961 | var remDiv = rem.divide(radixToPower), | ||
28962 | intval = rem.subtract(remDiv.multiply(radixToPower)).toInt() >>> 0, | ||
28963 | digits = intval.toString(radix); | ||
28964 | rem = remDiv; | ||
28965 | if (rem.isZero()) | ||
28966 | return digits + result; | ||
28967 | else { | ||
28968 | while (digits.length < 6) | ||
28969 | digits = '0' + digits; | ||
28970 | result = '' + digits + result; | ||
28971 | } | ||
28972 | } | ||
28973 | }; | ||
28974 | |||
28975 | /** | ||
28976 | * Gets the high 32 bits as a signed integer. | ||
28977 | * @returns {number} Signed high bits | ||
28978 | * @expose | ||
28979 | */ | ||
28980 | Long.prototype.getHighBits = function getHighBits() { | ||
28981 | return this.high; | ||
28982 | }; | ||
28983 | |||
28984 | /** | ||
28985 | * Gets the high 32 bits as an unsigned integer. | ||
28986 | * @returns {number} Unsigned high bits | ||
28987 | * @expose | ||
28988 | */ | ||
28989 | Long.prototype.getHighBitsUnsigned = function getHighBitsUnsigned() { | ||
28990 | return this.high >>> 0; | ||
28991 | }; | ||
28992 | |||
28993 | /** | ||
28994 | * Gets the low 32 bits as a signed integer. | ||
28995 | * @returns {number} Signed low bits | ||
28996 | * @expose | ||
28997 | */ | ||
28998 | Long.prototype.getLowBits = function getLowBits() { | ||
28999 | return this.low; | ||
29000 | }; | ||
29001 | |||
29002 | /** | ||
29003 | * Gets the low 32 bits as an unsigned integer. | ||
29004 | * @returns {number} Unsigned low bits | ||
29005 | * @expose | ||
29006 | */ | ||
29007 | Long.prototype.getLowBitsUnsigned = function getLowBitsUnsigned() { | ||
29008 | return this.low >>> 0; | ||
29009 | }; | ||
29010 | |||
29011 | /** | ||
29012 | * Gets the number of bits needed to represent the absolute value of this Long. | ||
29013 | * @returns {number} | ||
29014 | * @expose | ||
29015 | */ | ||
29016 | Long.prototype.getNumBitsAbs = function getNumBitsAbs() { | ||
29017 | if (this.isNegative()) // Unsigned Longs are never negative | ||
29018 | return this.equals(Long.MIN_VALUE) ? 64 : this.negate().getNumBitsAbs(); | ||
29019 | var val = this.high != 0 ? this.high : this.low; | ||
29020 | for (var bit = 31; bit > 0; bit--) | ||
29021 | if ((val & (1 << bit)) != 0) | ||
29022 | break; | ||
29023 | return this.high != 0 ? bit + 33 : bit + 1; | ||
29024 | }; | ||
29025 | |||
29026 | /** | ||
29027 | * Tests if this Long's value equals zero. | ||
29028 | * @returns {boolean} | ||
29029 | * @expose | ||
29030 | */ | ||
29031 | Long.prototype.isZero = function isZero() { | ||
29032 | return this.high === 0 && this.low === 0; | ||
29033 | }; | ||
29034 | |||
29035 | /** | ||
29036 | * Tests if this Long's value is negative. | ||
29037 | * @returns {boolean} | ||
29038 | * @expose | ||
29039 | */ | ||
29040 | Long.prototype.isNegative = function isNegative() { | ||
29041 | return !this.unsigned && this.high < 0; | ||
29042 | }; | ||
29043 | |||
29044 | /** | ||
29045 | * Tests if this Long's value is positive. | ||
29046 | * @returns {boolean} | ||
29047 | * @expose | ||
29048 | */ | ||
29049 | Long.prototype.isPositive = function isPositive() { | ||
29050 | return this.unsigned || this.high >= 0; | ||
29051 | }; | ||
29052 | |||
29053 | /** | ||
29054 | * Tests if this Long's value is odd. | ||
29055 | * @returns {boolean} | ||
29056 | * @expose | ||
29057 | */ | ||
29058 | Long.prototype.isOdd = function isOdd() { | ||
29059 | return (this.low & 1) === 1; | ||
29060 | }; | ||
29061 | |||
29062 | /** | ||
29063 | * Tests if this Long's value is even. | ||
29064 | * @returns {boolean} | ||
29065 | * @expose | ||
29066 | */ | ||
29067 | Long.prototype.isEven = function isEven() { | ||
29068 | return (this.low & 1) === 0; | ||
29069 | }; | ||
29070 | |||
29071 | /** | ||
29072 | * Tests if this Long's value equals the specified's. | ||
29073 | * @param {!Long|number|string} other Other value | ||
29074 | * @returns {boolean} | ||
29075 | * @expose | ||
29076 | */ | ||
29077 | Long.prototype.equals = function equals(other) { | ||
29078 | if (!Long.isLong(other)) | ||
29079 | other = Long.fromValue(other); | ||
29080 | if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1) | ||
29081 | return false; | ||
29082 | return this.high === other.high && this.low === other.low; | ||
29083 | }; | ||
29084 | |||
29085 | /** | ||
29086 | * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}. | ||
29087 | * @function | ||
29088 | * @param {!Long|number|string} other Other value | ||
29089 | * @returns {boolean} | ||
29090 | * @expose | ||
29091 | */ | ||
29092 | Long.eq = Long.prototype.equals; | ||
29093 | |||
29094 | /** | ||
29095 | * Tests if this Long's value differs from the specified's. | ||
29096 | * @param {!Long|number|string} other Other value | ||
29097 | * @returns {boolean} | ||
29098 | * @expose | ||
29099 | */ | ||
29100 | Long.prototype.notEquals = function notEquals(other) { | ||
29101 | return !this.equals(/* validates */ other); | ||
29102 | }; | ||
29103 | |||
29104 | /** | ||
29105 | * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}. | ||
29106 | * @function | ||
29107 | * @param {!Long|number|string} other Other value | ||
29108 | * @returns {boolean} | ||
29109 | * @expose | ||
29110 | */ | ||
29111 | Long.neq = Long.prototype.notEquals; | ||
29112 | |||
29113 | /** | ||
29114 | * Tests if this Long's value is less than the specified's. | ||
29115 | * @param {!Long|number|string} other Other value | ||
29116 | * @returns {boolean} | ||
29117 | * @expose | ||
29118 | */ | ||
29119 | Long.prototype.lessThan = function lessThan(other) { | ||
29120 | return this.compare(/* validates */ other) < 0; | ||
29121 | }; | ||
29122 | |||
29123 | /** | ||
29124 | * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}. | ||
29125 | * @function | ||
29126 | * @param {!Long|number|string} other Other value | ||
29127 | * @returns {boolean} | ||
29128 | * @expose | ||
29129 | */ | ||
29130 | Long.prototype.lt = Long.prototype.lessThan; | ||
29131 | |||
29132 | /** | ||
29133 | * Tests if this Long's value is less than or equal the specified's. | ||
29134 | * @param {!Long|number|string} other Other value | ||
29135 | * @returns {boolean} | ||
29136 | * @expose | ||
29137 | */ | ||
29138 | Long.prototype.lessThanOrEqual = function lessThanOrEqual(other) { | ||
29139 | return this.compare(/* validates */ other) <= 0; | ||
29140 | }; | ||
29141 | |||
29142 | /** | ||
29143 | * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}. | ||
29144 | * @function | ||
29145 | * @param {!Long|number|string} other Other value | ||
29146 | * @returns {boolean} | ||
29147 | * @expose | ||
29148 | */ | ||
29149 | Long.prototype.lte = Long.prototype.lessThanOrEqual; | ||
29150 | |||
29151 | /** | ||
29152 | * Tests if this Long's value is greater than the specified's. | ||
29153 | * @param {!Long|number|string} other Other value | ||
29154 | * @returns {boolean} | ||
29155 | * @expose | ||
29156 | */ | ||
29157 | Long.prototype.greaterThan = function greaterThan(other) { | ||
29158 | return this.compare(/* validates */ other) > 0; | ||
29159 | }; | ||
29160 | |||
29161 | /** | ||
29162 | * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}. | ||
29163 | * @function | ||
29164 | * @param {!Long|number|string} other Other value | ||
29165 | * @returns {boolean} | ||
29166 | * @expose | ||
29167 | */ | ||
29168 | Long.prototype.gt = Long.prototype.greaterThan; | ||
29169 | |||
29170 | /** | ||
29171 | * Tests if this Long's value is greater than or equal the specified's. | ||
29172 | * @param {!Long|number|string} other Other value | ||
29173 | * @returns {boolean} | ||
29174 | * @expose | ||
29175 | */ | ||
29176 | Long.prototype.greaterThanOrEqual = function greaterThanOrEqual(other) { | ||
29177 | return this.compare(/* validates */ other) >= 0; | ||
29178 | }; | ||
29179 | |||
29180 | /** | ||
29181 | * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}. | ||
29182 | * @function | ||
29183 | * @param {!Long|number|string} other Other value | ||
29184 | * @returns {boolean} | ||
29185 | * @expose | ||
29186 | */ | ||
29187 | Long.prototype.gte = Long.prototype.greaterThanOrEqual; | ||
29188 | |||
29189 | /** | ||
29190 | * Compares this Long's value with the specified's. | ||
29191 | * @param {!Long|number|string} other Other value | ||
29192 | * @returns {number} 0 if they are the same, 1 if the this is greater and -1 | ||
29193 | * if the given one is greater | ||
29194 | * @expose | ||
29195 | */ | ||
29196 | Long.prototype.compare = function compare(other) { | ||
29197 | if (!Long.isLong(other)) | ||
29198 | other = Long.fromValue(other); | ||
29199 | if (this.equals(other)) | ||
29200 | return 0; | ||
29201 | var thisNeg = this.isNegative(), | ||
29202 | otherNeg = other.isNegative(); | ||
29203 | if (thisNeg && !otherNeg) | ||
29204 | return -1; | ||
29205 | if (!thisNeg && otherNeg) | ||
29206 | return 1; | ||
29207 | // At this point the sign bits are the same | ||
29208 | if (!this.unsigned) | ||
29209 | return this.subtract(other).isNegative() ? -1 : 1; | ||
29210 | // Both are positive if at least one is unsigned | ||
29211 | return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1; | ||
29212 | }; | ||
29213 | |||
29214 | /** | ||
29215 | * Negates this Long's value. | ||
29216 | * @returns {!Long} Negated Long | ||
29217 | * @expose | ||
29218 | */ | ||
29219 | Long.prototype.negate = function negate() { | ||
29220 | if (!this.unsigned && this.equals(Long.MIN_VALUE)) | ||
29221 | return Long.MIN_VALUE; | ||
29222 | return this.not().add(Long.ONE); | ||
29223 | }; | ||
29224 | |||
29225 | /** | ||
29226 | * Negates this Long's value. This is an alias of {@link Long#negate}. | ||
29227 | * @function | ||
29228 | * @returns {!Long} Negated Long | ||
29229 | * @expose | ||
29230 | */ | ||
29231 | Long.prototype.neg = Long.prototype.negate; | ||
29232 | |||
29233 | /** | ||
29234 | * Returns the sum of this and the specified Long. | ||
29235 | * @param {!Long|number|string} addend Addend | ||
29236 | * @returns {!Long} Sum | ||
29237 | * @expose | ||
29238 | */ | ||
29239 | Long.prototype.add = function add(addend) { | ||
29240 | if (!Long.isLong(addend)) | ||
29241 | addend = Long.fromValue(addend); | ||
29242 | |||
29243 | // Divide each number into 4 chunks of 16 bits, and then sum the chunks. | ||
29244 | |||
29245 | var a48 = this.high >>> 16; | ||
29246 | var a32 = this.high & 0xFFFF; | ||
29247 | var a16 = this.low >>> 16; | ||
29248 | var a00 = this.low & 0xFFFF; | ||
29249 | |||
29250 | var b48 = addend.high >>> 16; | ||
29251 | var b32 = addend.high & 0xFFFF; | ||
29252 | var b16 = addend.low >>> 16; | ||
29253 | var b00 = addend.low & 0xFFFF; | ||
29254 | |||
29255 | var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | ||
29256 | c00 += a00 + b00; | ||
29257 | c16 += c00 >>> 16; | ||
29258 | c00 &= 0xFFFF; | ||
29259 | c16 += a16 + b16; | ||
29260 | c32 += c16 >>> 16; | ||
29261 | c16 &= 0xFFFF; | ||
29262 | c32 += a32 + b32; | ||
29263 | c48 += c32 >>> 16; | ||
29264 | c32 &= 0xFFFF; | ||
29265 | c48 += a48 + b48; | ||
29266 | c48 &= 0xFFFF; | ||
29267 | return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); | ||
29268 | }; | ||
29269 | |||
29270 | /** | ||
29271 | * Returns the difference of this and the specified Long. | ||
29272 | * @param {!Long|number|string} subtrahend Subtrahend | ||
29273 | * @returns {!Long} Difference | ||
29274 | * @expose | ||
29275 | */ | ||
29276 | Long.prototype.subtract = function subtract(subtrahend) { | ||
29277 | if (!Long.isLong(subtrahend)) | ||
29278 | subtrahend = Long.fromValue(subtrahend); | ||
29279 | return this.add(subtrahend.negate()); | ||
29280 | }; | ||
29281 | |||
29282 | /** | ||
29283 | * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}. | ||
29284 | * @function | ||
29285 | * @param {!Long|number|string} subtrahend Subtrahend | ||
29286 | * @returns {!Long} Difference | ||
29287 | * @expose | ||
29288 | */ | ||
29289 | Long.prototype.sub = Long.prototype.subtract; | ||
29290 | |||
29291 | /** | ||
29292 | * Returns the product of this and the specified Long. | ||
29293 | * @param {!Long|number|string} multiplier Multiplier | ||
29294 | * @returns {!Long} Product | ||
29295 | * @expose | ||
29296 | */ | ||
29297 | Long.prototype.multiply = function multiply(multiplier) { | ||
29298 | if (this.isZero()) | ||
29299 | return Long.ZERO; | ||
29300 | if (!Long.isLong(multiplier)) | ||
29301 | multiplier = Long.fromValue(multiplier); | ||
29302 | if (multiplier.isZero()) | ||
29303 | return Long.ZERO; | ||
29304 | if (this.equals(Long.MIN_VALUE)) | ||
29305 | return multiplier.isOdd() ? Long.MIN_VALUE : Long.ZERO; | ||
29306 | if (multiplier.equals(Long.MIN_VALUE)) | ||
29307 | return this.isOdd() ? Long.MIN_VALUE : Long.ZERO; | ||
29308 | |||
29309 | if (this.isNegative()) { | ||
29310 | if (multiplier.isNegative()) | ||
29311 | return this.negate().multiply(multiplier.negate()); | ||
29312 | else | ||
29313 | return this.negate().multiply(multiplier).negate(); | ||
29314 | } else if (multiplier.isNegative()) | ||
29315 | return this.multiply(multiplier.negate()).negate(); | ||
29316 | |||
29317 | // If both longs are small, use float multiplication | ||
29318 | if (this.lessThan(TWO_PWR_24) && multiplier.lessThan(TWO_PWR_24)) | ||
29319 | return Long.fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned); | ||
29320 | |||
29321 | // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. | ||
29322 | // We can skip products that would overflow. | ||
29323 | |||
29324 | var a48 = this.high >>> 16; | ||
29325 | var a32 = this.high & 0xFFFF; | ||
29326 | var a16 = this.low >>> 16; | ||
29327 | var a00 = this.low & 0xFFFF; | ||
29328 | |||
29329 | var b48 = multiplier.high >>> 16; | ||
29330 | var b32 = multiplier.high & 0xFFFF; | ||
29331 | var b16 = multiplier.low >>> 16; | ||
29332 | var b00 = multiplier.low & 0xFFFF; | ||
29333 | |||
29334 | var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | ||
29335 | c00 += a00 * b00; | ||
29336 | c16 += c00 >>> 16; | ||
29337 | c00 &= 0xFFFF; | ||
29338 | c16 += a16 * b00; | ||
29339 | c32 += c16 >>> 16; | ||
29340 | c16 &= 0xFFFF; | ||
29341 | c16 += a00 * b16; | ||
29342 | c32 += c16 >>> 16; | ||
29343 | c16 &= 0xFFFF; | ||
29344 | c32 += a32 * b00; | ||
29345 | c48 += c32 >>> 16; | ||
29346 | c32 &= 0xFFFF; | ||
29347 | c32 += a16 * b16; | ||
29348 | c48 += c32 >>> 16; | ||
29349 | c32 &= 0xFFFF; | ||
29350 | c32 += a00 * b32; | ||
29351 | c48 += c32 >>> 16; | ||
29352 | c32 &= 0xFFFF; | ||
29353 | c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; | ||
29354 | c48 &= 0xFFFF; | ||
29355 | return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); | ||
29356 | }; | ||
29357 | |||
29358 | /** | ||
29359 | * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}. | ||
29360 | * @function | ||
29361 | * @param {!Long|number|string} multiplier Multiplier | ||
29362 | * @returns {!Long} Product | ||
29363 | * @expose | ||
29364 | */ | ||
29365 | Long.prototype.mul = Long.prototype.multiply; | ||
29366 | |||
29367 | /** | ||
29368 | * Returns this Long divided by the specified. | ||
29369 | * @param {!Long|number|string} divisor Divisor | ||
29370 | * @returns {!Long} Quotient | ||
29371 | * @expose | ||
29372 | */ | ||
29373 | Long.prototype.divide = function divide(divisor) { | ||
29374 | if (!Long.isLong(divisor)) | ||
29375 | divisor = Long.fromValue(divisor); | ||
29376 | if (divisor.isZero()) | ||
29377 | throw(new Error('division by zero')); | ||
29378 | if (this.isZero()) | ||
29379 | return this.unsigned ? Long.UZERO : Long.ZERO; | ||
29380 | var approx, rem, res; | ||
29381 | if (this.equals(Long.MIN_VALUE)) { | ||
29382 | if (divisor.equals(Long.ONE) || divisor.equals(Long.NEG_ONE)) | ||
29383 | return Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE | ||
29384 | else if (divisor.equals(Long.MIN_VALUE)) | ||
29385 | return Long.ONE; | ||
29386 | else { | ||
29387 | // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. | ||
29388 | var halfThis = this.shiftRight(1); | ||
29389 | approx = halfThis.divide(divisor).shiftLeft(1); | ||
29390 | if (approx.equals(Long.ZERO)) { | ||
29391 | return divisor.isNegative() ? Long.ONE : Long.NEG_ONE; | ||
29392 | } else { | ||
29393 | rem = this.subtract(divisor.multiply(approx)); | ||
29394 | res = approx.add(rem.divide(divisor)); | ||
29395 | return res; | ||
29396 | } | ||
29397 | } | ||
29398 | } else if (divisor.equals(Long.MIN_VALUE)) | ||
29399 | return this.unsigned ? Long.UZERO : Long.ZERO; | ||
29400 | if (this.isNegative()) { | ||
29401 | if (divisor.isNegative()) | ||
29402 | return this.negate().divide(divisor.negate()); | ||
29403 | return this.negate().divide(divisor).negate(); | ||
29404 | } else if (divisor.isNegative()) | ||
29405 | return this.divide(divisor.negate()).negate(); | ||
29406 | |||
29407 | // Repeat the following until the remainder is less than other: find a | ||
29408 | // floating-point that approximates remainder / other *from below*, add this | ||
29409 | // into the result, and subtract it from the remainder. It is critical that | ||
29410 | // the approximate value is less than or equal to the real value so that the | ||
29411 | // remainder never becomes negative. | ||
29412 | res = Long.ZERO; | ||
29413 | rem = this; | ||
29414 | while (rem.greaterThanOrEqual(divisor)) { | ||
29415 | // Approximate the result of division. This may be a little greater or | ||
29416 | // smaller than the actual value. | ||
29417 | approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); | ||
29418 | |||
29419 | // We will tweak the approximate result by changing it in the 48-th digit or | ||
29420 | // the smallest non-fractional digit, whichever is larger. | ||
29421 | var log2 = Math.ceil(Math.log(approx) / Math.LN2), | ||
29422 | delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48), | ||
29423 | |||
29424 | // Decrease the approximation until it is smaller than the remainder. Note | ||
29425 | // that if it is too large, the product overflows and is negative. | ||
29426 | approxRes = Long.fromNumber(approx), | ||
29427 | approxRem = approxRes.multiply(divisor); | ||
29428 | while (approxRem.isNegative() || approxRem.greaterThan(rem)) { | ||
29429 | approx -= delta; | ||
29430 | approxRes = Long.fromNumber(approx, this.unsigned); | ||
29431 | approxRem = approxRes.multiply(divisor); | ||
29432 | } | ||
29433 | |||
29434 | // We know the answer can't be zero... and actually, zero would cause | ||
29435 | // infinite recursion since we would make no progress. | ||
29436 | if (approxRes.isZero()) | ||
29437 | approxRes = Long.ONE; | ||
29438 | |||
29439 | res = res.add(approxRes); | ||
29440 | rem = rem.subtract(approxRem); | ||
29441 | } | ||
29442 | return res; | ||
29443 | }; | ||
29444 | |||
29445 | /** | ||
29446 | * Returns this Long divided by the specified. This is an alias of {@link Long#divide}. | ||
29447 | * @function | ||
29448 | * @param {!Long|number|string} divisor Divisor | ||
29449 | * @returns {!Long} Quotient | ||
29450 | * @expose | ||
29451 | */ | ||
29452 | Long.prototype.div = Long.prototype.divide; | ||
29453 | |||
29454 | /** | ||
29455 | * Returns this Long modulo the specified. | ||
29456 | * @param {!Long|number|string} divisor Divisor | ||
29457 | * @returns {!Long} Remainder | ||
29458 | * @expose | ||
29459 | */ | ||
29460 | Long.prototype.modulo = function modulo(divisor) { | ||
29461 | if (!Long.isLong(divisor)) | ||
29462 | divisor = Long.fromValue(divisor); | ||
29463 | return this.subtract(this.divide(divisor).multiply(divisor)); | ||
29464 | }; | ||
29465 | |||
29466 | /** | ||
29467 | * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}. | ||
29468 | * @function | ||
29469 | * @param {!Long|number|string} divisor Divisor | ||
29470 | * @returns {!Long} Remainder | ||
29471 | * @expose | ||
29472 | */ | ||
29473 | Long.prototype.mod = Long.prototype.modulo; | ||
29474 | |||
29475 | /** | ||
29476 | * Returns the bitwise NOT of this Long. | ||
29477 | * @returns {!Long} | ||
29478 | * @expose | ||
29479 | */ | ||
29480 | Long.prototype.not = function not() { | ||
29481 | return Long.fromBits(~this.low, ~this.high, this.unsigned); | ||
29482 | }; | ||
29483 | |||
29484 | /** | ||
29485 | * Returns the bitwise AND of this Long and the specified. | ||
29486 | * @param {!Long|number|string} other Other Long | ||
29487 | * @returns {!Long} | ||
29488 | * @expose | ||
29489 | */ | ||
29490 | Long.prototype.and = function and(other) { | ||
29491 | if (!Long.isLong(other)) | ||
29492 | other = Long.fromValue(other); | ||
29493 | return Long.fromBits(this.low & other.low, this.high & other.high, this.unsigned); | ||
29494 | }; | ||
29495 | |||
29496 | /** | ||
29497 | * Returns the bitwise OR of this Long and the specified. | ||
29498 | * @param {!Long|number|string} other Other Long | ||
29499 | * @returns {!Long} | ||
29500 | * @expose | ||
29501 | */ | ||
29502 | Long.prototype.or = function or(other) { | ||
29503 | if (!Long.isLong(other)) | ||
29504 | other = Long.fromValue(other); | ||
29505 | return Long.fromBits(this.low | other.low, this.high | other.high, this.unsigned); | ||
29506 | }; | ||
29507 | |||
29508 | /** | ||
29509 | * Returns the bitwise XOR of this Long and the given one. | ||
29510 | * @param {!Long|number|string} other Other Long | ||
29511 | * @returns {!Long} | ||
29512 | * @expose | ||
29513 | */ | ||
29514 | Long.prototype.xor = function xor(other) { | ||
29515 | if (!Long.isLong(other)) | ||
29516 | other = Long.fromValue(other); | ||
29517 | return Long.fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned); | ||
29518 | }; | ||
29519 | |||
29520 | /** | ||
29521 | * Returns this Long with bits shifted to the left by the given amount. | ||
29522 | * @param {number|!Long} numBits Number of bits | ||
29523 | * @returns {!Long} Shifted Long | ||
29524 | * @expose | ||
29525 | */ | ||
29526 | Long.prototype.shiftLeft = function shiftLeft(numBits) { | ||
29527 | if (Long.isLong(numBits)) | ||
29528 | numBits = numBits.toInt(); | ||
29529 | if ((numBits &= 63) === 0) | ||
29530 | return this; | ||
29531 | else if (numBits < 32) | ||
29532 | return Long.fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned); | ||
29533 | else | ||
29534 | return Long.fromBits(0, this.low << (numBits - 32), this.unsigned); | ||
29535 | }; | ||
29536 | |||
29537 | /** | ||
29538 | * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}. | ||
29539 | * @function | ||
29540 | * @param {number|!Long} numBits Number of bits | ||
29541 | * @returns {!Long} Shifted Long | ||
29542 | * @expose | ||
29543 | */ | ||
29544 | Long.prototype.shl = Long.prototype.shiftLeft; | ||
29545 | |||
29546 | /** | ||
29547 | * Returns this Long with bits arithmetically shifted to the right by the given amount. | ||
29548 | * @param {number|!Long} numBits Number of bits | ||
29549 | * @returns {!Long} Shifted Long | ||
29550 | * @expose | ||
29551 | */ | ||
29552 | Long.prototype.shiftRight = function shiftRight(numBits) { | ||
29553 | if (Long.isLong(numBits)) | ||
29554 | numBits = numBits.toInt(); | ||
29555 | if ((numBits &= 63) === 0) | ||
29556 | return this; | ||
29557 | else if (numBits < 32) | ||
29558 | return Long.fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned); | ||
29559 | else | ||
29560 | return Long.fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned); | ||
29561 | }; | ||
29562 | |||
29563 | /** | ||
29564 | * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}. | ||
29565 | * @function | ||
29566 | * @param {number|!Long} numBits Number of bits | ||
29567 | * @returns {!Long} Shifted Long | ||
29568 | * @expose | ||
29569 | */ | ||
29570 | Long.prototype.shr = Long.prototype.shiftRight; | ||
29571 | |||
29572 | /** | ||
29573 | * Returns this Long with bits logically shifted to the right by the given amount. | ||
29574 | * @param {number|!Long} numBits Number of bits | ||
29575 | * @returns {!Long} Shifted Long | ||
29576 | * @expose | ||
29577 | */ | ||
29578 | Long.prototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) { | ||
29579 | if (Long.isLong(numBits)) | ||
29580 | numBits = numBits.toInt(); | ||
29581 | numBits &= 63; | ||
29582 | if (numBits === 0) | ||
29583 | return this; | ||
29584 | else { | ||
29585 | var high = this.high; | ||
29586 | if (numBits < 32) { | ||
29587 | var low = this.low; | ||
29588 | return Long.fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned); | ||
29589 | } else if (numBits === 32) | ||
29590 | return Long.fromBits(high, 0, this.unsigned); | ||
29591 | else | ||
29592 | return Long.fromBits(high >>> (numBits - 32), 0, this.unsigned); | ||
29593 | } | ||
29594 | }; | ||
29595 | |||
29596 | /** | ||
29597 | * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}. | ||
29598 | * @function | ||
29599 | * @param {number|!Long} numBits Number of bits | ||
29600 | * @returns {!Long} Shifted Long | ||
29601 | * @expose | ||
29602 | */ | ||
29603 | Long.prototype.shru = Long.prototype.shiftRightUnsigned; | ||
29604 | |||
29605 | /** | ||
29606 | * Converts this Long to signed. | ||
29607 | * @returns {!Long} Signed long | ||
29608 | * @expose | ||
29609 | */ | ||
29610 | Long.prototype.toSigned = function toSigned() { | ||
29611 | if (!this.unsigned) | ||
29612 | return this; | ||
29613 | return new Long(this.low, this.high, false); | ||
29614 | }; | ||
29615 | |||
29616 | /** | ||
29617 | * Converts this Long to unsigned. | ||
29618 | * @returns {!Long} Unsigned long | ||
29619 | * @expose | ||
29620 | */ | ||
29621 | Long.prototype.toUnsigned = function toUnsigned() { | ||
29622 | if (this.unsigned) | ||
29623 | return this; | ||
29624 | return new Long(this.low, this.high, true); | ||
29625 | }; | ||
29626 | |||
29627 | return Long; | ||
29628 | }); | ||
29629 | |||
29630 | },{}],354:[function(require,module,exports){ | ||
29631 | 'use strict' | ||
29632 | var inherits = require('inherits') | ||
29633 | var HashBase = require('hash-base') | ||
29634 | var Buffer = require('safe-buffer').Buffer | ||
29635 | |||
29636 | var ARRAY16 = new Array(16) | ||
29637 | |||
29638 | function MD5 () { | ||
29639 | HashBase.call(this, 64) | ||
29640 | |||
29641 | // state | ||
29642 | this._a = 0x67452301 | ||
29643 | this._b = 0xefcdab89 | ||
29644 | this._c = 0x98badcfe | ||
29645 | this._d = 0x10325476 | ||
29646 | } | ||
29647 | |||
29648 | inherits(MD5, HashBase) | ||
29649 | |||
29650 | MD5.prototype._update = function () { | ||
29651 | var M = ARRAY16 | ||
29652 | for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4) | ||
29653 | |||
29654 | var a = this._a | ||
29655 | var b = this._b | ||
29656 | var c = this._c | ||
29657 | var d = this._d | ||
29658 | |||
29659 | a = fnF(a, b, c, d, M[0], 0xd76aa478, 7) | ||
29660 | d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12) | ||
29661 | c = fnF(c, d, a, b, M[2], 0x242070db, 17) | ||
29662 | b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22) | ||
29663 | a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7) | ||
29664 | d = fnF(d, a, b, c, M[5], 0x4787c62a, 12) | ||
29665 | c = fnF(c, d, a, b, M[6], 0xa8304613, 17) | ||
29666 | b = fnF(b, c, d, a, M[7], 0xfd469501, 22) | ||
29667 | a = fnF(a, b, c, d, M[8], 0x698098d8, 7) | ||
29668 | d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12) | ||
29669 | c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17) | ||
29670 | b = fnF(b, c, d, a, M[11], 0x895cd7be, 22) | ||
29671 | a = fnF(a, b, c, d, M[12], 0x6b901122, 7) | ||
29672 | d = fnF(d, a, b, c, M[13], 0xfd987193, 12) | ||
29673 | c = fnF(c, d, a, b, M[14], 0xa679438e, 17) | ||
29674 | b = fnF(b, c, d, a, M[15], 0x49b40821, 22) | ||
29675 | |||
29676 | a = fnG(a, b, c, d, M[1], 0xf61e2562, 5) | ||
29677 | d = fnG(d, a, b, c, M[6], 0xc040b340, 9) | ||
29678 | c = fnG(c, d, a, b, M[11], 0x265e5a51, 14) | ||
29679 | b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20) | ||
29680 | a = fnG(a, b, c, d, M[5], 0xd62f105d, 5) | ||
29681 | d = fnG(d, a, b, c, M[10], 0x02441453, 9) | ||
29682 | c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14) | ||
29683 | b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20) | ||
29684 | a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5) | ||
29685 | d = fnG(d, a, b, c, M[14], 0xc33707d6, 9) | ||
29686 | c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14) | ||
29687 | b = fnG(b, c, d, a, M[8], 0x455a14ed, 20) | ||
29688 | a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5) | ||
29689 | d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9) | ||
29690 | c = fnG(c, d, a, b, M[7], 0x676f02d9, 14) | ||
29691 | b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20) | ||
29692 | |||
29693 | a = fnH(a, b, c, d, M[5], 0xfffa3942, 4) | ||
29694 | d = fnH(d, a, b, c, M[8], 0x8771f681, 11) | ||
29695 | c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16) | ||
29696 | b = fnH(b, c, d, a, M[14], 0xfde5380c, 23) | ||
29697 | a = fnH(a, b, c, d, M[1], 0xa4beea44, 4) | ||
29698 | d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11) | ||
29699 | c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16) | ||
29700 | b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23) | ||
29701 | a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4) | ||
29702 | d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11) | ||
29703 | c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16) | ||
29704 | b = fnH(b, c, d, a, M[6], 0x04881d05, 23) | ||
29705 | a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4) | ||
29706 | d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11) | ||
29707 | c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16) | ||
29708 | b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23) | ||
29709 | |||
29710 | a = fnI(a, b, c, d, M[0], 0xf4292244, 6) | ||
29711 | d = fnI(d, a, b, c, M[7], 0x432aff97, 10) | ||
29712 | c = fnI(c, d, a, b, M[14], 0xab9423a7, 15) | ||
29713 | b = fnI(b, c, d, a, M[5], 0xfc93a039, 21) | ||
29714 | a = fnI(a, b, c, d, M[12], 0x655b59c3, 6) | ||
29715 | d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10) | ||
29716 | c = fnI(c, d, a, b, M[10], 0xffeff47d, 15) | ||
29717 | b = fnI(b, c, d, a, M[1], 0x85845dd1, 21) | ||
29718 | a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6) | ||
29719 | d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10) | ||
29720 | c = fnI(c, d, a, b, M[6], 0xa3014314, 15) | ||
29721 | b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21) | ||
29722 | a = fnI(a, b, c, d, M[4], 0xf7537e82, 6) | ||
29723 | d = fnI(d, a, b, c, M[11], 0xbd3af235, 10) | ||
29724 | c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15) | ||
29725 | b = fnI(b, c, d, a, M[9], 0xeb86d391, 21) | ||
29726 | |||
29727 | this._a = (this._a + a) | 0 | ||
29728 | this._b = (this._b + b) | 0 | ||
29729 | this._c = (this._c + c) | 0 | ||
29730 | this._d = (this._d + d) | 0 | ||
29731 | } | ||
29732 | |||
29733 | MD5.prototype._digest = function () { | ||
29734 | // create padding and handle blocks | ||
29735 | this._block[this._blockOffset++] = 0x80 | ||
29736 | if (this._blockOffset > 56) { | ||
29737 | this._block.fill(0, this._blockOffset, 64) | ||
29738 | this._update() | ||
29739 | this._blockOffset = 0 | ||
29740 | } | ||
29741 | |||
29742 | this._block.fill(0, this._blockOffset, 56) | ||
29743 | this._block.writeUInt32LE(this._length[0], 56) | ||
29744 | this._block.writeUInt32LE(this._length[1], 60) | ||
29745 | this._update() | ||
29746 | |||
29747 | // produce result | ||
29748 | var buffer = Buffer.allocUnsafe(16) | ||
29749 | buffer.writeInt32LE(this._a, 0) | ||
29750 | buffer.writeInt32LE(this._b, 4) | ||
29751 | buffer.writeInt32LE(this._c, 8) | ||
29752 | buffer.writeInt32LE(this._d, 12) | ||
29753 | return buffer | ||
29754 | } | ||
29755 | |||
29756 | function rotl (x, n) { | ||
29757 | return (x << n) | (x >>> (32 - n)) | ||
29758 | } | ||
29759 | |||
29760 | function fnF (a, b, c, d, m, k, s) { | ||
29761 | return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0 | ||
29762 | } | ||
29763 | |||
29764 | function fnG (a, b, c, d, m, k, s) { | ||
29765 | return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0 | ||
29766 | } | ||
29767 | |||
29768 | function fnH (a, b, c, d, m, k, s) { | ||
29769 | return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0 | ||
29770 | } | ||
29771 | |||
29772 | function fnI (a, b, c, d, m, k, s) { | ||
29773 | return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0 | ||
29774 | } | ||
29775 | |||
29776 | module.exports = MD5 | ||
29777 | |||
29778 | },{"hash-base":101,"inherits":116,"safe-buffer":393}],355:[function(require,module,exports){ | ||
29779 | var bn = require('bn.js'); | ||
29780 | var brorand = require('brorand'); | ||
29781 | |||
29782 | function MillerRabin(rand) { | ||
29783 | this.rand = rand || new brorand.Rand(); | ||
29784 | } | ||
29785 | module.exports = MillerRabin; | ||
29786 | |||
29787 | MillerRabin.create = function create(rand) { | ||
29788 | return new MillerRabin(rand); | ||
29789 | }; | ||
29790 | |||
29791 | MillerRabin.prototype._randbelow = function _randbelow(n) { | ||
29792 | var len = n.bitLength(); | ||
29793 | var min_bytes = Math.ceil(len / 8); | ||
29794 | |||
29795 | // Generage random bytes until a number less than n is found. | ||
29796 | // This ensures that 0..n-1 have an equal probability of being selected. | ||
29797 | do | ||
29798 | var a = new bn(this.rand.generate(min_bytes)); | ||
29799 | while (a.cmp(n) >= 0); | ||
29800 | |||
29801 | return a; | ||
29802 | }; | ||
29803 | |||
29804 | MillerRabin.prototype._randrange = function _randrange(start, stop) { | ||
29805 | // Generate a random number greater than or equal to start and less than stop. | ||
29806 | var size = stop.sub(start); | ||
29807 | return start.add(this._randbelow(size)); | ||
29808 | }; | ||
29809 | |||
29810 | MillerRabin.prototype.test = function test(n, k, cb) { | ||
29811 | var len = n.bitLength(); | ||
29812 | var red = bn.mont(n); | ||
29813 | var rone = new bn(1).toRed(red); | ||
29814 | |||
29815 | if (!k) | ||
29816 | k = Math.max(1, (len / 48) | 0); | ||
29817 | |||
29818 | // Find d and s, (n - 1) = (2 ^ s) * d; | ||
29819 | var n1 = n.subn(1); | ||
29820 | for (var s = 0; !n1.testn(s); s++) {} | ||
29821 | var d = n.shrn(s); | ||
29822 | |||
29823 | var rn1 = n1.toRed(red); | ||
29824 | |||
29825 | var prime = true; | ||
29826 | for (; k > 0; k--) { | ||
29827 | var a = this._randrange(new bn(2), n1); | ||
29828 | if (cb) | ||
29829 | cb(a); | ||
29830 | |||
29831 | var x = a.toRed(red).redPow(d); | ||
29832 | if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) | ||
29833 | continue; | ||
29834 | |||
29835 | for (var i = 1; i < s; i++) { | ||
29836 | x = x.redSqr(); | ||
29837 | |||
29838 | if (x.cmp(rone) === 0) | ||
29839 | return false; | ||
29840 | if (x.cmp(rn1) === 0) | ||
29841 | break; | ||
29842 | } | ||
29843 | |||
29844 | if (i === s) | ||
29845 | return false; | ||
29846 | } | ||
29847 | |||
29848 | return prime; | ||
29849 | }; | ||
29850 | |||
29851 | MillerRabin.prototype.getDivisor = function getDivisor(n, k) { | ||
29852 | var len = n.bitLength(); | ||
29853 | var red = bn.mont(n); | ||
29854 | var rone = new bn(1).toRed(red); | ||
29855 | |||
29856 | if (!k) | ||
29857 | k = Math.max(1, (len / 48) | 0); | ||
29858 | |||
29859 | // Find d and s, (n - 1) = (2 ^ s) * d; | ||
29860 | var n1 = n.subn(1); | ||
29861 | for (var s = 0; !n1.testn(s); s++) {} | ||
29862 | var d = n.shrn(s); | ||
29863 | |||
29864 | var rn1 = n1.toRed(red); | ||
29865 | |||
29866 | for (; k > 0; k--) { | ||
29867 | var a = this._randrange(new bn(2), n1); | ||
29868 | |||
29869 | var g = n.gcd(a); | ||
29870 | if (g.cmpn(1) !== 0) | ||
29871 | return g; | ||
29872 | |||
29873 | var x = a.toRed(red).redPow(d); | ||
29874 | if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) | ||
29875 | continue; | ||
29876 | |||
29877 | for (var i = 1; i < s; i++) { | ||
29878 | x = x.redSqr(); | ||
29879 | |||
29880 | if (x.cmp(rone) === 0) | ||
29881 | return x.fromRed().subn(1).gcd(n); | ||
29882 | if (x.cmp(rn1) === 0) | ||
29883 | break; | ||
29884 | } | ||
29885 | |||
29886 | if (i === s) { | ||
29887 | x = x.redSqr(); | ||
29888 | return x.fromRed().subn(1).gcd(n); | ||
29889 | } | ||
29890 | } | ||
29891 | |||
29892 | return false; | ||
29893 | }; | ||
29894 | |||
29895 | },{"bn.js":18,"brorand":19}],356:[function(require,module,exports){ | ||
29896 | module.exports = assert; | ||
29897 | |||
29898 | function assert(val, msg) { | ||
29899 | if (!val) | ||
29900 | throw new Error(msg || 'Assertion failed'); | ||
29901 | } | ||
29902 | |||
29903 | assert.equal = function assertEqual(l, r, msg) { | ||
29904 | if (l != r) | ||
29905 | throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r)); | ||
29906 | }; | ||
29907 | |||
29908 | },{}],357:[function(require,module,exports){ | ||
29909 | 'use strict'; | ||
29910 | |||
29911 | var utils = exports; | ||
29912 | |||
29913 | function toArray(msg, enc) { | ||
29914 | if (Array.isArray(msg)) | ||
29915 | return msg.slice(); | ||
29916 | if (!msg) | ||
29917 | return []; | ||
29918 | var res = []; | ||
29919 | if (typeof msg !== 'string') { | ||
29920 | for (var i = 0; i < msg.length; i++) | ||
29921 | res[i] = msg[i] | 0; | ||
29922 | return res; | ||
29923 | } | ||
29924 | if (enc === 'hex') { | ||
29925 | msg = msg.replace(/[^a-z0-9]+/ig, ''); | ||
29926 | if (msg.length % 2 !== 0) | ||
29927 | msg = '0' + msg; | ||
29928 | for (var i = 0; i < msg.length; i += 2) | ||
29929 | res.push(parseInt(msg[i] + msg[i + 1], 16)); | ||
29930 | } else { | ||
29931 | for (var i = 0; i < msg.length; i++) { | ||
29932 | var c = msg.charCodeAt(i); | ||
29933 | var hi = c >> 8; | ||
29934 | var lo = c & 0xff; | ||
29935 | if (hi) | ||
29936 | res.push(hi, lo); | ||
29937 | else | ||
29938 | res.push(lo); | ||
29939 | } | ||
29940 | } | ||
29941 | return res; | ||
29942 | } | ||
29943 | utils.toArray = toArray; | ||
29944 | |||
29945 | function zero2(word) { | ||
29946 | if (word.length === 1) | ||
29947 | return '0' + word; | ||
29948 | else | ||
29949 | return word; | ||
29950 | } | ||
29951 | utils.zero2 = zero2; | ||
29952 | |||
29953 | function toHex(msg) { | ||
29954 | var res = ''; | ||
29955 | for (var i = 0; i < msg.length; i++) | ||
29956 | res += zero2(msg[i].toString(16)); | ||
29957 | return res; | ||
29958 | } | ||
29959 | utils.toHex = toHex; | ||
29960 | |||
29961 | utils.encode = function encode(arr, enc) { | ||
29962 | if (enc === 'hex') | ||
29963 | return toHex(arr); | ||
29964 | else | ||
29965 | return arr; | ||
29966 | }; | ||
29967 | |||
29968 | },{}],358:[function(require,module,exports){ | ||
29969 | module.exports={"2.16.840.1.101.3.4.1.1": "aes-128-ecb", | ||
29970 | "2.16.840.1.101.3.4.1.2": "aes-128-cbc", | ||
29971 | "2.16.840.1.101.3.4.1.3": "aes-128-ofb", | ||
29972 | "2.16.840.1.101.3.4.1.4": "aes-128-cfb", | ||
29973 | "2.16.840.1.101.3.4.1.21": "aes-192-ecb", | ||
29974 | "2.16.840.1.101.3.4.1.22": "aes-192-cbc", | ||
29975 | "2.16.840.1.101.3.4.1.23": "aes-192-ofb", | ||
29976 | "2.16.840.1.101.3.4.1.24": "aes-192-cfb", | ||
29977 | "2.16.840.1.101.3.4.1.41": "aes-256-ecb", | ||
29978 | "2.16.840.1.101.3.4.1.42": "aes-256-cbc", | ||
29979 | "2.16.840.1.101.3.4.1.43": "aes-256-ofb", | ||
29980 | "2.16.840.1.101.3.4.1.44": "aes-256-cfb" | ||
29981 | } | ||
29982 | },{}],359:[function(require,module,exports){ | ||
29983 | // from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js | ||
29984 | // Fedor, you are amazing. | ||
29985 | 'use strict' | ||
29986 | |||
29987 | var asn1 = require('asn1.js') | ||
29988 | |||
29989 | exports.certificate = require('./certificate') | ||
29990 | |||
29991 | var RSAPrivateKey = asn1.define('RSAPrivateKey', function () { | ||
29992 | this.seq().obj( | ||
29993 | this.key('version').int(), | ||
29994 | this.key('modulus').int(), | ||
29995 | this.key('publicExponent').int(), | ||
29996 | this.key('privateExponent').int(), | ||
29997 | this.key('prime1').int(), | ||
29998 | this.key('prime2').int(), | ||
29999 | this.key('exponent1').int(), | ||
30000 | this.key('exponent2').int(), | ||
30001 | this.key('coefficient').int() | ||
30002 | ) | ||
30003 | }) | ||
30004 | exports.RSAPrivateKey = RSAPrivateKey | ||
30005 | |||
30006 | var RSAPublicKey = asn1.define('RSAPublicKey', function () { | ||
30007 | this.seq().obj( | ||
30008 | this.key('modulus').int(), | ||
30009 | this.key('publicExponent').int() | ||
30010 | ) | ||
30011 | }) | ||
30012 | exports.RSAPublicKey = RSAPublicKey | ||
30013 | |||
30014 | var PublicKey = asn1.define('SubjectPublicKeyInfo', function () { | ||
30015 | this.seq().obj( | ||
30016 | this.key('algorithm').use(AlgorithmIdentifier), | ||
30017 | this.key('subjectPublicKey').bitstr() | ||
30018 | ) | ||
30019 | }) | ||
30020 | exports.PublicKey = PublicKey | ||
30021 | |||
30022 | var AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () { | ||
30023 | this.seq().obj( | ||
30024 | this.key('algorithm').objid(), | ||
30025 | this.key('none').null_().optional(), | ||
30026 | this.key('curve').objid().optional(), | ||
30027 | this.key('params').seq().obj( | ||
30028 | this.key('p').int(), | ||
30029 | this.key('q').int(), | ||
30030 | this.key('g').int() | ||
30031 | ).optional() | ||
30032 | ) | ||
30033 | }) | ||
30034 | |||
30035 | var PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () { | ||
30036 | this.seq().obj( | ||
30037 | this.key('version').int(), | ||
30038 | this.key('algorithm').use(AlgorithmIdentifier), | ||
30039 | this.key('subjectPrivateKey').octstr() | ||
30040 | ) | ||
30041 | }) | ||
30042 | exports.PrivateKey = PrivateKeyInfo | ||
30043 | var EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () { | ||
30044 | this.seq().obj( | ||
30045 | this.key('algorithm').seq().obj( | ||
30046 | this.key('id').objid(), | ||
30047 | this.key('decrypt').seq().obj( | ||
30048 | this.key('kde').seq().obj( | ||
30049 | this.key('id').objid(), | ||
30050 | this.key('kdeparams').seq().obj( | ||
30051 | this.key('salt').octstr(), | ||
30052 | this.key('iters').int() | ||
30053 | ) | ||
30054 | ), | ||
30055 | this.key('cipher').seq().obj( | ||
30056 | this.key('algo').objid(), | ||
30057 | this.key('iv').octstr() | ||
30058 | ) | ||
30059 | ) | ||
30060 | ), | ||
30061 | this.key('subjectPrivateKey').octstr() | ||
30062 | ) | ||
30063 | }) | ||
30064 | |||
30065 | exports.EncryptedPrivateKey = EncryptedPrivateKeyInfo | ||
30066 | |||
30067 | var DSAPrivateKey = asn1.define('DSAPrivateKey', function () { | ||
30068 | this.seq().obj( | ||
30069 | this.key('version').int(), | ||
30070 | this.key('p').int(), | ||
30071 | this.key('q').int(), | ||
30072 | this.key('g').int(), | ||
30073 | this.key('pub_key').int(), | ||
30074 | this.key('priv_key').int() | ||
30075 | ) | ||
30076 | }) | ||
30077 | exports.DSAPrivateKey = DSAPrivateKey | ||
30078 | |||
30079 | exports.DSAparam = asn1.define('DSAparam', function () { | ||
30080 | this.int() | ||
30081 | }) | ||
30082 | |||
30083 | var ECPrivateKey = asn1.define('ECPrivateKey', function () { | ||
30084 | this.seq().obj( | ||
30085 | this.key('version').int(), | ||
30086 | this.key('privateKey').octstr(), | ||
30087 | this.key('parameters').optional().explicit(0).use(ECParameters), | ||
30088 | this.key('publicKey').optional().explicit(1).bitstr() | ||
30089 | ) | ||
30090 | }) | ||
30091 | exports.ECPrivateKey = ECPrivateKey | ||
30092 | |||
30093 | var ECParameters = asn1.define('ECParameters', function () { | ||
30094 | this.choice({ | ||
30095 | namedCurve: this.objid() | ||
30096 | }) | ||
30097 | }) | ||
30098 | |||
30099 | exports.signature = asn1.define('signature', function () { | ||
30100 | this.seq().obj( | ||
30101 | this.key('r').int(), | ||
30102 | this.key('s').int() | ||
30103 | ) | ||
30104 | }) | ||
30105 | |||
30106 | },{"./certificate":360,"asn1.js":1}],360:[function(require,module,exports){ | ||
30107 | // from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js | ||
30108 | // thanks to @Rantanen | ||
30109 | |||
30110 | 'use strict' | ||
30111 | |||
30112 | var asn = require('asn1.js') | ||
30113 | |||
30114 | var Time = asn.define('Time', function () { | ||
30115 | this.choice({ | ||
30116 | utcTime: this.utctime(), | ||
30117 | generalTime: this.gentime() | ||
30118 | }) | ||
30119 | }) | ||
30120 | |||
30121 | var AttributeTypeValue = asn.define('AttributeTypeValue', function () { | ||
30122 | this.seq().obj( | ||
30123 | this.key('type').objid(), | ||
30124 | this.key('value').any() | ||
30125 | ) | ||
30126 | }) | ||
30127 | |||
30128 | var AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () { | ||
30129 | this.seq().obj( | ||
30130 | this.key('algorithm').objid(), | ||
30131 | this.key('parameters').optional() | ||
30132 | ) | ||
30133 | }) | ||
30134 | |||
30135 | var SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () { | ||
30136 | this.seq().obj( | ||
30137 | this.key('algorithm').use(AlgorithmIdentifier), | ||
30138 | this.key('subjectPublicKey').bitstr() | ||
30139 | ) | ||
30140 | }) | ||
30141 | |||
30142 | var RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () { | ||
30143 | this.setof(AttributeTypeValue) | ||
30144 | }) | ||
30145 | |||
30146 | var RDNSequence = asn.define('RDNSequence', function () { | ||
30147 | this.seqof(RelativeDistinguishedName) | ||
30148 | }) | ||
30149 | |||
30150 | var Name = asn.define('Name', function () { | ||
30151 | this.choice({ | ||
30152 | rdnSequence: this.use(RDNSequence) | ||
30153 | }) | ||
30154 | }) | ||
30155 | |||
30156 | var Validity = asn.define('Validity', function () { | ||
30157 | this.seq().obj( | ||
30158 | this.key('notBefore').use(Time), | ||
30159 | this.key('notAfter').use(Time) | ||
30160 | ) | ||
30161 | }) | ||
30162 | |||
30163 | var Extension = asn.define('Extension', function () { | ||
30164 | this.seq().obj( | ||
30165 | this.key('extnID').objid(), | ||
30166 | this.key('critical').bool().def(false), | ||
30167 | this.key('extnValue').octstr() | ||
30168 | ) | ||
30169 | }) | ||
30170 | |||
30171 | var TBSCertificate = asn.define('TBSCertificate', function () { | ||
30172 | this.seq().obj( | ||
30173 | this.key('version').explicit(0).int(), | ||
30174 | this.key('serialNumber').int(), | ||
30175 | this.key('signature').use(AlgorithmIdentifier), | ||
30176 | this.key('issuer').use(Name), | ||
30177 | this.key('validity').use(Validity), | ||
30178 | this.key('subject').use(Name), | ||
30179 | this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo), | ||
30180 | this.key('issuerUniqueID').implicit(1).bitstr().optional(), | ||
30181 | this.key('subjectUniqueID').implicit(2).bitstr().optional(), | ||
30182 | this.key('extensions').explicit(3).seqof(Extension).optional() | ||
30183 | ) | ||
30184 | }) | ||
30185 | |||
30186 | var X509Certificate = asn.define('X509Certificate', function () { | ||
30187 | this.seq().obj( | ||
30188 | this.key('tbsCertificate').use(TBSCertificate), | ||
30189 | this.key('signatureAlgorithm').use(AlgorithmIdentifier), | ||
30190 | this.key('signatureValue').bitstr() | ||
30191 | ) | ||
30192 | }) | ||
30193 | |||
30194 | module.exports = X509Certificate | ||
30195 | |||
30196 | },{"asn1.js":1}],361:[function(require,module,exports){ | ||
30197 | (function (Buffer){ | ||
30198 | // adapted from https://github.com/apatil/pemstrip | ||
30199 | var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r\+\/\=]+)[\n\r]+/m | ||
30200 | var startRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----/m | ||
30201 | var fullRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----([0-9A-z\n\r\+\/\=]+)-----END \1-----$/m | ||
30202 | var evp = require('evp_bytestokey') | ||
30203 | var ciphers = require('browserify-aes') | ||
30204 | module.exports = function (okey, password) { | ||
30205 | var key = okey.toString() | ||
30206 | var match = key.match(findProc) | ||
30207 | var decrypted | ||
30208 | if (!match) { | ||
30209 | var match2 = key.match(fullRegex) | ||
30210 | decrypted = new Buffer(match2[2].replace(/[\r\n]/g, ''), 'base64') | ||
30211 | } else { | ||
30212 | var suite = 'aes' + match[1] | ||
30213 | var iv = new Buffer(match[2], 'hex') | ||
30214 | var cipherText = new Buffer(match[3].replace(/[\r\n]/g, ''), 'base64') | ||
30215 | var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key | ||
30216 | var out = [] | ||
30217 | var cipher = ciphers.createDecipheriv(suite, cipherKey, iv) | ||
30218 | out.push(cipher.update(cipherText)) | ||
30219 | out.push(cipher.final()) | ||
30220 | decrypted = Buffer.concat(out) | ||
30221 | } | ||
30222 | var tag = key.match(startRegex)[1] | ||
30223 | return { | ||
30224 | tag: tag, | ||
30225 | data: decrypted | ||
30226 | } | ||
30227 | } | ||
30228 | |||
30229 | }).call(this,require("buffer").Buffer) | ||
30230 | },{"browserify-aes":23,"buffer":49,"evp_bytestokey":100}],362:[function(require,module,exports){ | ||
30231 | (function (Buffer){ | ||
30232 | var asn1 = require('./asn1') | ||
30233 | var aesid = require('./aesid.json') | ||
30234 | var fixProc = require('./fixProc') | ||
30235 | var ciphers = require('browserify-aes') | ||
30236 | var compat = require('pbkdf2') | ||
30237 | module.exports = parseKeys | ||
30238 | |||
30239 | function parseKeys (buffer) { | ||
30240 | var password | ||
30241 | if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) { | ||
30242 | password = buffer.passphrase | ||
30243 | buffer = buffer.key | ||
30244 | } | ||
30245 | if (typeof buffer === 'string') { | ||
30246 | buffer = new Buffer(buffer) | ||
30247 | } | ||
30248 | |||
30249 | var stripped = fixProc(buffer, password) | ||
30250 | |||
30251 | var type = stripped.tag | ||
30252 | var data = stripped.data | ||
30253 | var subtype, ndata | ||
30254 | switch (type) { | ||
30255 | case 'CERTIFICATE': | ||
30256 | ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo | ||
30257 | // falls through | ||
30258 | case 'PUBLIC KEY': | ||
30259 | if (!ndata) { | ||
30260 | ndata = asn1.PublicKey.decode(data, 'der') | ||
30261 | } | ||
30262 | subtype = ndata.algorithm.algorithm.join('.') | ||
30263 | switch (subtype) { | ||
30264 | case '1.2.840.113549.1.1.1': | ||
30265 | return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der') | ||
30266 | case '1.2.840.10045.2.1': | ||
30267 | ndata.subjectPrivateKey = ndata.subjectPublicKey | ||
30268 | return { | ||
30269 | type: 'ec', | ||
30270 | data: ndata | ||
30271 | } | ||
30272 | case '1.2.840.10040.4.1': | ||
30273 | ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der') | ||
30274 | return { | ||
30275 | type: 'dsa', | ||
30276 | data: ndata.algorithm.params | ||
30277 | } | ||
30278 | default: throw new Error('unknown key id ' + subtype) | ||
30279 | } | ||
30280 | throw new Error('unknown key type ' + type) | ||
30281 | case 'ENCRYPTED PRIVATE KEY': | ||
30282 | data = asn1.EncryptedPrivateKey.decode(data, 'der') | ||
30283 | data = decrypt(data, password) | ||
30284 | // falls through | ||
30285 | case 'PRIVATE KEY': | ||
30286 | ndata = asn1.PrivateKey.decode(data, 'der') | ||
30287 | subtype = ndata.algorithm.algorithm.join('.') | ||
30288 | switch (subtype) { | ||
30289 | case '1.2.840.113549.1.1.1': | ||
30290 | return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der') | ||
30291 | case '1.2.840.10045.2.1': | ||
30292 | return { | ||
30293 | curve: ndata.algorithm.curve, | ||
30294 | privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey | ||
30295 | } | ||
30296 | case '1.2.840.10040.4.1': | ||
30297 | ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der') | ||
30298 | return { | ||
30299 | type: 'dsa', | ||
30300 | params: ndata.algorithm.params | ||
30301 | } | ||
30302 | default: throw new Error('unknown key id ' + subtype) | ||
30303 | } | ||
30304 | throw new Error('unknown key type ' + type) | ||
30305 | case 'RSA PUBLIC KEY': | ||
30306 | return asn1.RSAPublicKey.decode(data, 'der') | ||
30307 | case 'RSA PRIVATE KEY': | ||
30308 | return asn1.RSAPrivateKey.decode(data, 'der') | ||
30309 | case 'DSA PRIVATE KEY': | ||
30310 | return { | ||
30311 | type: 'dsa', | ||
30312 | params: asn1.DSAPrivateKey.decode(data, 'der') | ||
30313 | } | ||
30314 | case 'EC PRIVATE KEY': | ||
30315 | data = asn1.ECPrivateKey.decode(data, 'der') | ||
30316 | return { | ||
30317 | curve: data.parameters.value, | ||
30318 | privateKey: data.privateKey | ||
30319 | } | ||
30320 | default: throw new Error('unknown key type ' + type) | ||
30321 | } | ||
30322 | } | ||
30323 | parseKeys.signature = asn1.signature | ||
30324 | function decrypt (data, password) { | ||
30325 | var salt = data.algorithm.decrypt.kde.kdeparams.salt | ||
30326 | var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10) | ||
30327 | var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')] | ||
30328 | var iv = data.algorithm.decrypt.cipher.iv | ||
30329 | var cipherText = data.subjectPrivateKey | ||
30330 | var keylen = parseInt(algo.split('-')[1], 10) / 8 | ||
30331 | var key = compat.pbkdf2Sync(password, salt, iters, keylen) | ||
30332 | var cipher = ciphers.createDecipheriv(algo, key, iv) | ||
30333 | var out = [] | ||
30334 | out.push(cipher.update(cipherText)) | ||
30335 | out.push(cipher.final()) | ||
30336 | return Buffer.concat(out) | ||
30337 | } | ||
30338 | |||
30339 | }).call(this,require("buffer").Buffer) | ||
30340 | },{"./aesid.json":358,"./asn1":359,"./fixProc":361,"browserify-aes":23,"buffer":49,"pbkdf2":363}],363:[function(require,module,exports){ | ||
30341 | exports.pbkdf2 = require('./lib/async') | ||
30342 | exports.pbkdf2Sync = require('./lib/sync') | ||
30343 | |||
30344 | },{"./lib/async":364,"./lib/sync":367}],364:[function(require,module,exports){ | ||
30345 | (function (process,global){ | ||
30346 | var checkParameters = require('./precondition') | ||
30347 | var defaultEncoding = require('./default-encoding') | ||
30348 | var sync = require('./sync') | ||
30349 | var Buffer = require('safe-buffer').Buffer | ||
30350 | |||
30351 | var ZERO_BUF | ||
30352 | var subtle = global.crypto && global.crypto.subtle | ||
30353 | var toBrowser = { | ||
30354 | 'sha': 'SHA-1', | ||
30355 | 'sha-1': 'SHA-1', | ||
30356 | 'sha1': 'SHA-1', | ||
30357 | 'sha256': 'SHA-256', | ||
30358 | 'sha-256': 'SHA-256', | ||
30359 | 'sha384': 'SHA-384', | ||
30360 | 'sha-384': 'SHA-384', | ||
30361 | 'sha-512': 'SHA-512', | ||
30362 | 'sha512': 'SHA-512' | ||
30363 | } | ||
30364 | var checks = [] | ||
30365 | function checkNative (algo) { | ||
30366 | if (global.process && !global.process.browser) { | ||
30367 | return Promise.resolve(false) | ||
30368 | } | ||
30369 | if (!subtle || !subtle.importKey || !subtle.deriveBits) { | ||
30370 | return Promise.resolve(false) | ||
30371 | } | ||
30372 | if (checks[algo] !== undefined) { | ||
30373 | return checks[algo] | ||
30374 | } | ||
30375 | ZERO_BUF = ZERO_BUF || Buffer.alloc(8) | ||
30376 | var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo) | ||
30377 | .then(function () { | ||
30378 | return true | ||
30379 | }).catch(function () { | ||
30380 | return false | ||
30381 | }) | ||
30382 | checks[algo] = prom | ||
30383 | return prom | ||
30384 | } | ||
30385 | |||
30386 | function browserPbkdf2 (password, salt, iterations, length, algo) { | ||
30387 | return subtle.importKey( | ||
30388 | 'raw', password, {name: 'PBKDF2'}, false, ['deriveBits'] | ||
30389 | ).then(function (key) { | ||
30390 | return subtle.deriveBits({ | ||
30391 | name: 'PBKDF2', | ||
30392 | salt: salt, | ||
30393 | iterations: iterations, | ||
30394 | hash: { | ||
30395 | name: algo | ||
30396 | } | ||
30397 | }, key, length << 3) | ||
30398 | }).then(function (res) { | ||
30399 | return Buffer.from(res) | ||
30400 | }) | ||
30401 | } | ||
30402 | |||
30403 | function resolvePromise (promise, callback) { | ||
30404 | promise.then(function (out) { | ||
30405 | process.nextTick(function () { | ||
30406 | callback(null, out) | ||
30407 | }) | ||
30408 | }, function (e) { | ||
30409 | process.nextTick(function () { | ||
30410 | callback(e) | ||
30411 | }) | ||
30412 | }) | ||
30413 | } | ||
30414 | module.exports = function (password, salt, iterations, keylen, digest, callback) { | ||
30415 | if (typeof digest === 'function') { | ||
30416 | callback = digest | ||
30417 | digest = undefined | ||
30418 | } | ||
30419 | |||
30420 | digest = digest || 'sha1' | ||
30421 | var algo = toBrowser[digest.toLowerCase()] | ||
30422 | |||
30423 | if (!algo || typeof global.Promise !== 'function') { | ||
30424 | return process.nextTick(function () { | ||
30425 | var out | ||
30426 | try { | ||
30427 | out = sync(password, salt, iterations, keylen, digest) | ||
30428 | } catch (e) { | ||
30429 | return callback(e) | ||
30430 | } | ||
30431 | callback(null, out) | ||
30432 | }) | ||
30433 | } | ||
30434 | |||
30435 | checkParameters(password, salt, iterations, keylen) | ||
30436 | if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2') | ||
30437 | if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding) | ||
30438 | if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding) | ||
30439 | |||
30440 | resolvePromise(checkNative(algo).then(function (resp) { | ||
30441 | if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo) | ||
30442 | |||
30443 | return sync(password, salt, iterations, keylen, digest) | ||
30444 | }), callback) | ||
30445 | } | ||
30446 | |||
30447 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | ||
30448 | },{"./default-encoding":365,"./precondition":366,"./sync":367,"_process":369,"safe-buffer":393}],365:[function(require,module,exports){ | ||
30449 | (function (process){ | ||
30450 | var defaultEncoding | ||
30451 | /* istanbul ignore next */ | ||
30452 | if (process.browser) { | ||
30453 | defaultEncoding = 'utf-8' | ||
30454 | } else { | ||
30455 | var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10) | ||
30456 | |||
30457 | defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary' | ||
30458 | } | ||
30459 | module.exports = defaultEncoding | ||
30460 | |||
30461 | }).call(this,require('_process')) | ||
30462 | },{"_process":369}],366:[function(require,module,exports){ | ||
30463 | (function (Buffer){ | ||
30464 | var MAX_ALLOC = Math.pow(2, 30) - 1 // default in iojs | ||
30465 | |||
30466 | function checkBuffer (buf, name) { | ||
30467 | if (typeof buf !== 'string' && !Buffer.isBuffer(buf)) { | ||
30468 | throw new TypeError(name + ' must be a buffer or string') | ||
30469 | } | ||
30470 | } | ||
30471 | |||
30472 | module.exports = function (password, salt, iterations, keylen) { | ||
30473 | checkBuffer(password, 'Password') | ||
30474 | checkBuffer(salt, 'Salt') | ||
30475 | |||
30476 | if (typeof iterations !== 'number') { | ||
30477 | throw new TypeError('Iterations not a number') | ||
30478 | } | ||
30479 | |||
30480 | if (iterations < 0) { | ||
30481 | throw new TypeError('Bad iterations') | ||
30482 | } | ||
30483 | |||
30484 | if (typeof keylen !== 'number') { | ||
30485 | throw new TypeError('Key length not a number') | ||
30486 | } | ||
30487 | |||
30488 | if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */ | ||
30489 | throw new TypeError('Bad key length') | ||
30490 | } | ||
30491 | } | ||
30492 | |||
30493 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | ||
30494 | },{"../../is-buffer/index.js":117}],367:[function(require,module,exports){ | ||
30495 | var md5 = require('create-hash/md5') | ||
30496 | var RIPEMD160 = require('ripemd160') | ||
30497 | var sha = require('sha.js') | ||
30498 | |||
30499 | var checkParameters = require('./precondition') | ||
30500 | var defaultEncoding = require('./default-encoding') | ||
30501 | var Buffer = require('safe-buffer').Buffer | ||
30502 | var ZEROS = Buffer.alloc(128) | ||
30503 | var sizes = { | ||
30504 | md5: 16, | ||
30505 | sha1: 20, | ||
30506 | sha224: 28, | ||
30507 | sha256: 32, | ||
30508 | sha384: 48, | ||
30509 | sha512: 64, | ||
30510 | rmd160: 20, | ||
30511 | ripemd160: 20 | ||
30512 | } | ||
30513 | |||
30514 | function Hmac (alg, key, saltLen) { | ||
30515 | var hash = getDigest(alg) | ||
30516 | var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64 | ||
30517 | |||
30518 | if (key.length > blocksize) { | ||
30519 | key = hash(key) | ||
30520 | } else if (key.length < blocksize) { | ||
30521 | key = Buffer.concat([key, ZEROS], blocksize) | ||
30522 | } | ||
30523 | |||
30524 | var ipad = Buffer.allocUnsafe(blocksize + sizes[alg]) | ||
30525 | var opad = Buffer.allocUnsafe(blocksize + sizes[alg]) | ||
30526 | for (var i = 0; i < blocksize; i++) { | ||
30527 | ipad[i] = key[i] ^ 0x36 | ||
30528 | opad[i] = key[i] ^ 0x5C | ||
30529 | } | ||
30530 | |||
30531 | var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4) | ||
30532 | ipad.copy(ipad1, 0, 0, blocksize) | ||
30533 | this.ipad1 = ipad1 | ||
30534 | this.ipad2 = ipad | ||
30535 | this.opad = opad | ||
30536 | this.alg = alg | ||
30537 | this.blocksize = blocksize | ||
30538 | this.hash = hash | ||
30539 | this.size = sizes[alg] | ||
30540 | } | ||
30541 | |||
30542 | Hmac.prototype.run = function (data, ipad) { | ||
30543 | data.copy(ipad, this.blocksize) | ||
30544 | var h = this.hash(ipad) | ||
30545 | h.copy(this.opad, this.blocksize) | ||
30546 | return this.hash(this.opad) | ||
30547 | } | ||
30548 | |||
30549 | function getDigest (alg) { | ||
30550 | function shaFunc (data) { | ||
30551 | return sha(alg).update(data).digest() | ||
30552 | } | ||
30553 | function rmd160Func (data) { | ||
30554 | return new RIPEMD160().update(data).digest() | ||
30555 | } | ||
30556 | |||
30557 | if (alg === 'rmd160' || alg === 'ripemd160') return rmd160Func | ||
30558 | if (alg === 'md5') return md5 | ||
30559 | return shaFunc | ||
30560 | } | ||
30561 | |||
30562 | function pbkdf2 (password, salt, iterations, keylen, digest) { | ||
30563 | checkParameters(password, salt, iterations, keylen) | ||
30564 | |||
30565 | if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding) | ||
30566 | if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding) | ||
30567 | |||
30568 | digest = digest || 'sha1' | ||
30569 | |||
30570 | var hmac = new Hmac(digest, password, salt.length) | ||
30571 | |||
30572 | var DK = Buffer.allocUnsafe(keylen) | ||
30573 | var block1 = Buffer.allocUnsafe(salt.length + 4) | ||
30574 | salt.copy(block1, 0, 0, salt.length) | ||
30575 | |||
30576 | var destPos = 0 | ||
30577 | var hLen = sizes[digest] | ||
30578 | var l = Math.ceil(keylen / hLen) | ||
30579 | |||
30580 | for (var i = 1; i <= l; i++) { | ||
30581 | block1.writeUInt32BE(i, salt.length) | ||
30582 | |||
30583 | var T = hmac.run(block1, hmac.ipad1) | ||
30584 | var U = T | ||
30585 | |||
30586 | for (var j = 1; j < iterations; j++) { | ||
30587 | U = hmac.run(U, hmac.ipad2) | ||
30588 | for (var k = 0; k < hLen; k++) T[k] ^= U[k] | ||
30589 | } | ||
30590 | |||
30591 | T.copy(DK, destPos) | ||
30592 | destPos += hLen | ||
30593 | } | ||
30594 | |||
30595 | return DK | ||
30596 | } | ||
30597 | |||
30598 | module.exports = pbkdf2 | ||
30599 | |||
30600 | },{"./default-encoding":365,"./precondition":366,"create-hash/md5":68,"ripemd160":392,"safe-buffer":393,"sha.js":395}],368:[function(require,module,exports){ | ||
30601 | (function (process){ | ||
30602 | 'use strict'; | ||
30603 | |||
30604 | if (!process.version || | ||
30605 | process.version.indexOf('v0.') === 0 || | ||
30606 | process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { | ||
30607 | module.exports = { nextTick: nextTick }; | ||
30608 | } else { | ||
30609 | module.exports = process | ||
30610 | } | ||
30611 | |||
30612 | function nextTick(fn, arg1, arg2, arg3) { | ||
30613 | if (typeof fn !== 'function') { | ||
30614 | throw new TypeError('"callback" argument must be a function'); | ||
30615 | } | ||
30616 | var len = arguments.length; | ||
30617 | var args, i; | ||
30618 | switch (len) { | ||
30619 | case 0: | ||
30620 | case 1: | ||
30621 | return process.nextTick(fn); | ||
30622 | case 2: | ||
30623 | return process.nextTick(function afterTickOne() { | ||
30624 | fn.call(null, arg1); | ||
30625 | }); | ||
30626 | case 3: | ||
30627 | return process.nextTick(function afterTickTwo() { | ||
30628 | fn.call(null, arg1, arg2); | ||
30629 | }); | ||
30630 | case 4: | ||
30631 | return process.nextTick(function afterTickThree() { | ||
30632 | fn.call(null, arg1, arg2, arg3); | ||
30633 | }); | ||
30634 | default: | ||
30635 | args = new Array(len - 1); | ||
30636 | i = 0; | ||
30637 | while (i < args.length) { | ||
30638 | args[i++] = arguments[i]; | ||
30639 | } | ||
30640 | return process.nextTick(function afterTick() { | ||
30641 | fn.apply(null, args); | ||
30642 | }); | ||
30643 | } | ||
30644 | } | ||
30645 | |||
30646 | |||
30647 | }).call(this,require('_process')) | ||
30648 | },{"_process":369}],369:[function(require,module,exports){ | ||
30649 | // shim for using process in browser | ||
30650 | var process = module.exports = {}; | ||
30651 | |||
30652 | // cached from whatever global is present so that test runners that stub it | ||
30653 | // don't break things. But we need to wrap it in a try catch in case it is | ||
30654 | // wrapped in strict mode code which doesn't define any globals. It's inside a | ||
30655 | // function because try/catches deoptimize in certain engines. | ||
30656 | |||
30657 | var cachedSetTimeout; | ||
30658 | var cachedClearTimeout; | ||
30659 | |||
30660 | function defaultSetTimout() { | ||
30661 | throw new Error('setTimeout has not been defined'); | ||
30662 | } | ||
30663 | function defaultClearTimeout () { | ||
30664 | throw new Error('clearTimeout has not been defined'); | ||
30665 | } | ||
30666 | (function () { | ||
30667 | try { | ||
30668 | if (typeof setTimeout === 'function') { | ||
30669 | cachedSetTimeout = setTimeout; | ||
30670 | } else { | ||
30671 | cachedSetTimeout = defaultSetTimout; | ||
30672 | } | ||
30673 | } catch (e) { | ||
30674 | cachedSetTimeout = defaultSetTimout; | ||
30675 | } | ||
30676 | try { | ||
30677 | if (typeof clearTimeout === 'function') { | ||
30678 | cachedClearTimeout = clearTimeout; | ||
30679 | } else { | ||
30680 | cachedClearTimeout = defaultClearTimeout; | ||
30681 | } | ||
30682 | } catch (e) { | ||
30683 | cachedClearTimeout = defaultClearTimeout; | ||
30684 | } | ||
30685 | } ()) | ||
30686 | function runTimeout(fun) { | ||
30687 | if (cachedSetTimeout === setTimeout) { | ||
30688 | //normal enviroments in sane situations | ||
30689 | return setTimeout(fun, 0); | ||
30690 | } | ||
30691 | // if setTimeout wasn't available but was latter defined | ||
30692 | if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { | ||
30693 | cachedSetTimeout = setTimeout; | ||
30694 | return setTimeout(fun, 0); | ||
30695 | } | ||
30696 | try { | ||
30697 | // when when somebody has screwed with setTimeout but no I.E. maddness | ||
30698 | return cachedSetTimeout(fun, 0); | ||
30699 | } catch(e){ | ||
30700 | try { | ||
30701 | // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | ||
30702 | return cachedSetTimeout.call(null, fun, 0); | ||
30703 | } catch(e){ | ||
30704 | // 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 | ||
30705 | return cachedSetTimeout.call(this, fun, 0); | ||
30706 | } | ||
30707 | } | ||
30708 | |||
30709 | |||
30710 | } | ||
30711 | function runClearTimeout(marker) { | ||
30712 | if (cachedClearTimeout === clearTimeout) { | ||
30713 | //normal enviroments in sane situations | ||
30714 | return clearTimeout(marker); | ||
30715 | } | ||
30716 | // if clearTimeout wasn't available but was latter defined | ||
30717 | if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { | ||
30718 | cachedClearTimeout = clearTimeout; | ||
30719 | return clearTimeout(marker); | ||
30720 | } | ||
30721 | try { | ||
30722 | // when when somebody has screwed with setTimeout but no I.E. maddness | ||
30723 | return cachedClearTimeout(marker); | ||
30724 | } catch (e){ | ||
30725 | try { | ||
30726 | // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | ||
30727 | return cachedClearTimeout.call(null, marker); | ||
30728 | } catch (e){ | ||
30729 | // 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. | ||
30730 | // Some versions of I.E. have different rules for clearTimeout vs setTimeout | ||
30731 | return cachedClearTimeout.call(this, marker); | ||
30732 | } | ||
30733 | } | ||
30734 | |||
30735 | |||
30736 | |||
30737 | } | ||
30738 | var queue = []; | ||
30739 | var draining = false; | ||
30740 | var currentQueue; | ||
30741 | var queueIndex = -1; | ||
30742 | |||
30743 | function cleanUpNextTick() { | ||
30744 | if (!draining || !currentQueue) { | ||
30745 | return; | ||
30746 | } | ||
30747 | draining = false; | ||
30748 | if (currentQueue.length) { | ||
30749 | queue = currentQueue.concat(queue); | ||
30750 | } else { | ||
30751 | queueIndex = -1; | ||
30752 | } | ||
30753 | if (queue.length) { | ||
30754 | drainQueue(); | ||
30755 | } | ||
30756 | } | ||
30757 | |||
30758 | function drainQueue() { | ||
30759 | if (draining) { | ||
30760 | return; | ||
30761 | } | ||
30762 | var timeout = runTimeout(cleanUpNextTick); | ||
30763 | draining = true; | ||
30764 | |||
30765 | var len = queue.length; | ||
30766 | while(len) { | ||
30767 | currentQueue = queue; | ||
30768 | queue = []; | ||
30769 | while (++queueIndex < len) { | ||
30770 | if (currentQueue) { | ||
30771 | currentQueue[queueIndex].run(); | ||
30772 | } | ||
30773 | } | ||
30774 | queueIndex = -1; | ||
30775 | len = queue.length; | ||
30776 | } | ||
30777 | currentQueue = null; | ||
30778 | draining = false; | ||
30779 | runClearTimeout(timeout); | ||
30780 | } | ||
30781 | |||
30782 | process.nextTick = function (fun) { | ||
30783 | var args = new Array(arguments.length - 1); | ||
30784 | if (arguments.length > 1) { | ||
30785 | for (var i = 1; i < arguments.length; i++) { | ||
30786 | args[i - 1] = arguments[i]; | ||
30787 | } | ||
30788 | } | ||
30789 | queue.push(new Item(fun, args)); | ||
30790 | if (queue.length === 1 && !draining) { | ||
30791 | runTimeout(drainQueue); | ||
30792 | } | ||
30793 | }; | ||
30794 | |||
30795 | // v8 likes predictible objects | ||
30796 | function Item(fun, array) { | ||
30797 | this.fun = fun; | ||
30798 | this.array = array; | ||
30799 | } | ||
30800 | Item.prototype.run = function () { | ||
30801 | this.fun.apply(null, this.array); | ||
30802 | }; | ||
30803 | process.title = 'browser'; | ||
30804 | process.browser = true; | ||
30805 | process.env = {}; | ||
30806 | process.argv = []; | ||
30807 | process.version = ''; // empty string to avoid regexp issues | ||
30808 | process.versions = {}; | ||
30809 | |||
30810 | function noop() {} | ||
30811 | |||
30812 | process.on = noop; | ||
30813 | process.addListener = noop; | ||
30814 | process.once = noop; | ||
30815 | process.off = noop; | ||
30816 | process.removeListener = noop; | ||
30817 | process.removeAllListeners = noop; | ||
30818 | process.emit = noop; | ||
30819 | process.prependListener = noop; | ||
30820 | process.prependOnceListener = noop; | ||
30821 | |||
30822 | process.listeners = function (name) { return [] } | ||
30823 | |||
30824 | process.binding = function (name) { | ||
30825 | throw new Error('process.binding is not supported'); | ||
30826 | }; | ||
30827 | |||
30828 | process.cwd = function () { return '/' }; | ||
30829 | process.chdir = function (dir) { | ||
30830 | throw new Error('process.chdir is not supported'); | ||
30831 | }; | ||
30832 | process.umask = function() { return 0; }; | ||
30833 | |||
30834 | },{}],370:[function(require,module,exports){ | ||
30835 | exports.publicEncrypt = require('./publicEncrypt') | ||
30836 | exports.privateDecrypt = require('./privateDecrypt') | ||
30837 | |||
30838 | exports.privateEncrypt = function privateEncrypt (key, buf) { | ||
30839 | return exports.publicEncrypt(key, buf, true) | ||
30840 | } | ||
30841 | |||
30842 | exports.publicDecrypt = function publicDecrypt (key, buf) { | ||
30843 | return exports.privateDecrypt(key, buf, true) | ||
30844 | } | ||
30845 | |||
30846 | },{"./privateDecrypt":372,"./publicEncrypt":373}],371:[function(require,module,exports){ | ||
30847 | var createHash = require('create-hash') | ||
30848 | var Buffer = require('safe-buffer').Buffer | ||
30849 | |||
30850 | module.exports = function (seed, len) { | ||
30851 | var t = Buffer.alloc(0) | ||
30852 | var i = 0 | ||
30853 | var c | ||
30854 | while (t.length < len) { | ||
30855 | c = i2ops(i++) | ||
30856 | t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()]) | ||
30857 | } | ||
30858 | return t.slice(0, len) | ||
30859 | } | ||
30860 | |||
30861 | function i2ops (c) { | ||
30862 | var out = Buffer.allocUnsafe(4) | ||
30863 | out.writeUInt32BE(c, 0) | ||
30864 | return out | ||
30865 | } | ||
30866 | |||
30867 | },{"create-hash":67,"safe-buffer":393}],372:[function(require,module,exports){ | ||
30868 | var parseKeys = require('parse-asn1') | ||
30869 | var mgf = require('./mgf') | ||
30870 | var xor = require('./xor') | ||
30871 | var BN = require('bn.js') | ||
30872 | var crt = require('browserify-rsa') | ||
30873 | var createHash = require('create-hash') | ||
30874 | var withPublic = require('./withPublic') | ||
30875 | var Buffer = require('safe-buffer').Buffer | ||
30876 | |||
30877 | module.exports = function privateDecrypt (privateKey, enc, reverse) { | ||
30878 | var padding | ||
30879 | if (privateKey.padding) { | ||
30880 | padding = privateKey.padding | ||
30881 | } else if (reverse) { | ||
30882 | padding = 1 | ||
30883 | } else { | ||
30884 | padding = 4 | ||
30885 | } | ||
30886 | |||
30887 | var key = parseKeys(privateKey) | ||
30888 | var k = key.modulus.byteLength() | ||
30889 | if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) { | ||
30890 | throw new Error('decryption error') | ||
30891 | } | ||
30892 | var msg | ||
30893 | if (reverse) { | ||
30894 | msg = withPublic(new BN(enc), key) | ||
30895 | } else { | ||
30896 | msg = crt(enc, key) | ||
30897 | } | ||
30898 | var zBuffer = Buffer.alloc(k - msg.length) | ||
30899 | msg = Buffer.concat([zBuffer, msg], k) | ||
30900 | if (padding === 4) { | ||
30901 | return oaep(key, msg) | ||
30902 | } else if (padding === 1) { | ||
30903 | return pkcs1(key, msg, reverse) | ||
30904 | } else if (padding === 3) { | ||
30905 | return msg | ||
30906 | } else { | ||
30907 | throw new Error('unknown padding') | ||
30908 | } | ||
30909 | } | ||
30910 | |||
30911 | function oaep (key, msg) { | ||
30912 | var k = key.modulus.byteLength() | ||
30913 | var iHash = createHash('sha1').update(Buffer.alloc(0)).digest() | ||
30914 | var hLen = iHash.length | ||
30915 | if (msg[0] !== 0) { | ||
30916 | throw new Error('decryption error') | ||
30917 | } | ||
30918 | var maskedSeed = msg.slice(1, hLen + 1) | ||
30919 | var maskedDb = msg.slice(hLen + 1) | ||
30920 | var seed = xor(maskedSeed, mgf(maskedDb, hLen)) | ||
30921 | var db = xor(maskedDb, mgf(seed, k - hLen - 1)) | ||
30922 | if (compare(iHash, db.slice(0, hLen))) { | ||
30923 | throw new Error('decryption error') | ||
30924 | } | ||
30925 | var i = hLen | ||
30926 | while (db[i] === 0) { | ||
30927 | i++ | ||
30928 | } | ||
30929 | if (db[i++] !== 1) { | ||
30930 | throw new Error('decryption error') | ||
30931 | } | ||
30932 | return db.slice(i) | ||
30933 | } | ||
30934 | |||
30935 | function pkcs1 (key, msg, reverse) { | ||
30936 | var p1 = msg.slice(0, 2) | ||
30937 | var i = 2 | ||
30938 | var status = 0 | ||
30939 | while (msg[i++] !== 0) { | ||
30940 | if (i >= msg.length) { | ||
30941 | status++ | ||
30942 | break | ||
30943 | } | ||
30944 | } | ||
30945 | var ps = msg.slice(2, i - 1) | ||
30946 | |||
30947 | if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)) { | ||
30948 | status++ | ||
30949 | } | ||
30950 | if (ps.length < 8) { | ||
30951 | status++ | ||
30952 | } | ||
30953 | if (status) { | ||
30954 | throw new Error('decryption error') | ||
30955 | } | ||
30956 | return msg.slice(i) | ||
30957 | } | ||
30958 | function compare (a, b) { | ||
30959 | a = Buffer.from(a) | ||
30960 | b = Buffer.from(b) | ||
30961 | var dif = 0 | ||
30962 | var len = a.length | ||
30963 | if (a.length !== b.length) { | ||
30964 | dif++ | ||
30965 | len = Math.min(a.length, b.length) | ||
30966 | } | ||
30967 | var i = -1 | ||
30968 | while (++i < len) { | ||
30969 | dif += (a[i] ^ b[i]) | ||
30970 | } | ||
30971 | return dif | ||
30972 | } | ||
30973 | |||
30974 | },{"./mgf":371,"./withPublic":374,"./xor":375,"bn.js":18,"browserify-rsa":41,"create-hash":67,"parse-asn1":362,"safe-buffer":393}],373:[function(require,module,exports){ | ||
30975 | var parseKeys = require('parse-asn1') | ||
30976 | var randomBytes = require('randombytes') | ||
30977 | var createHash = require('create-hash') | ||
30978 | var mgf = require('./mgf') | ||
30979 | var xor = require('./xor') | ||
30980 | var BN = require('bn.js') | ||
30981 | var withPublic = require('./withPublic') | ||
30982 | var crt = require('browserify-rsa') | ||
30983 | var Buffer = require('safe-buffer').Buffer | ||
30984 | |||
30985 | module.exports = function publicEncrypt (publicKey, msg, reverse) { | ||
30986 | var padding | ||
30987 | if (publicKey.padding) { | ||
30988 | padding = publicKey.padding | ||
30989 | } else if (reverse) { | ||
30990 | padding = 1 | ||
30991 | } else { | ||
30992 | padding = 4 | ||
30993 | } | ||
30994 | var key = parseKeys(publicKey) | ||
30995 | var paddedMsg | ||
30996 | if (padding === 4) { | ||
30997 | paddedMsg = oaep(key, msg) | ||
30998 | } else if (padding === 1) { | ||
30999 | paddedMsg = pkcs1(key, msg, reverse) | ||
31000 | } else if (padding === 3) { | ||
31001 | paddedMsg = new BN(msg) | ||
31002 | if (paddedMsg.cmp(key.modulus) >= 0) { | ||
31003 | throw new Error('data too long for modulus') | ||
31004 | } | ||
31005 | } else { | ||
31006 | throw new Error('unknown padding') | ||
31007 | } | ||
31008 | if (reverse) { | ||
31009 | return crt(paddedMsg, key) | ||
31010 | } else { | ||
31011 | return withPublic(paddedMsg, key) | ||
31012 | } | ||
31013 | } | ||
31014 | |||
31015 | function oaep (key, msg) { | ||
31016 | var k = key.modulus.byteLength() | ||
31017 | var mLen = msg.length | ||
31018 | var iHash = createHash('sha1').update(Buffer.alloc(0)).digest() | ||
31019 | var hLen = iHash.length | ||
31020 | var hLen2 = 2 * hLen | ||
31021 | if (mLen > k - hLen2 - 2) { | ||
31022 | throw new Error('message too long') | ||
31023 | } | ||
31024 | var ps = Buffer.alloc(k - mLen - hLen2 - 2) | ||
31025 | var dblen = k - hLen - 1 | ||
31026 | var seed = randomBytes(hLen) | ||
31027 | var maskedDb = xor(Buffer.concat([iHash, ps, Buffer.alloc(1, 1), msg], dblen), mgf(seed, dblen)) | ||
31028 | var maskedSeed = xor(seed, mgf(maskedDb, hLen)) | ||
31029 | return new BN(Buffer.concat([Buffer.alloc(1), maskedSeed, maskedDb], k)) | ||
31030 | } | ||
31031 | function pkcs1 (key, msg, reverse) { | ||
31032 | var mLen = msg.length | ||
31033 | var k = key.modulus.byteLength() | ||
31034 | if (mLen > k - 11) { | ||
31035 | throw new Error('message too long') | ||
31036 | } | ||
31037 | var ps | ||
31038 | if (reverse) { | ||
31039 | ps = Buffer.alloc(k - mLen - 3, 0xff) | ||
31040 | } else { | ||
31041 | ps = nonZero(k - mLen - 3) | ||
31042 | } | ||
31043 | return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k)) | ||
31044 | } | ||
31045 | function nonZero (len) { | ||
31046 | var out = Buffer.allocUnsafe(len) | ||
31047 | var i = 0 | ||
31048 | var cache = randomBytes(len * 2) | ||
31049 | var cur = 0 | ||
31050 | var num | ||
31051 | while (i < len) { | ||
31052 | if (cur === cache.length) { | ||
31053 | cache = randomBytes(len * 2) | ||
31054 | cur = 0 | ||
31055 | } | ||
31056 | num = cache[cur++] | ||
31057 | if (num) { | ||
31058 | out[i++] = num | ||
31059 | } | ||
31060 | } | ||
31061 | return out | ||
31062 | } | ||
31063 | |||
31064 | },{"./mgf":371,"./withPublic":374,"./xor":375,"bn.js":18,"browserify-rsa":41,"create-hash":67,"parse-asn1":362,"randombytes":376,"safe-buffer":393}],374:[function(require,module,exports){ | ||
31065 | var BN = require('bn.js') | ||
31066 | var Buffer = require('safe-buffer').Buffer | ||
31067 | |||
31068 | function withPublic (paddedMsg, key) { | ||
31069 | return Buffer.from(paddedMsg | ||
31070 | .toRed(BN.mont(key.modulus)) | ||
31071 | .redPow(new BN(key.publicExponent)) | ||
31072 | .fromRed() | ||
31073 | .toArray()) | ||
31074 | } | ||
31075 | |||
31076 | module.exports = withPublic | ||
31077 | |||
31078 | },{"bn.js":18,"safe-buffer":393}],375:[function(require,module,exports){ | ||
31079 | module.exports = function xor (a, b) { | ||
31080 | var len = a.length | ||
31081 | var i = -1 | ||
31082 | while (++i < len) { | ||
31083 | a[i] ^= b[i] | ||
31084 | } | ||
31085 | return a | ||
31086 | } | ||
31087 | |||
31088 | },{}],376:[function(require,module,exports){ | ||
31089 | (function (process,global){ | ||
31090 | 'use strict' | ||
31091 | |||
31092 | function oldBrowser () { | ||
31093 | throw new Error('Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11') | ||
31094 | } | ||
31095 | |||
31096 | var Buffer = require('safe-buffer').Buffer | ||
31097 | var crypto = global.crypto || global.msCrypto | ||
31098 | |||
31099 | if (crypto && crypto.getRandomValues) { | ||
31100 | module.exports = randomBytes | ||
31101 | } else { | ||
31102 | module.exports = oldBrowser | ||
31103 | } | ||
31104 | |||
31105 | function randomBytes (size, cb) { | ||
31106 | // phantomjs needs to throw | ||
31107 | if (size > 65536) throw new Error('requested too many random bytes') | ||
31108 | // in case browserify isn't using the Uint8Array version | ||
31109 | var rawBytes = new global.Uint8Array(size) | ||
31110 | |||
31111 | // This will not work in older browsers. | ||
31112 | // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues | ||
31113 | if (size > 0) { // getRandomValues fails on IE if size == 0 | ||
31114 | crypto.getRandomValues(rawBytes) | ||
31115 | } | ||
31116 | |||
31117 | // XXX: phantomjs doesn't like a buffer being passed here | ||
31118 | var bytes = Buffer.from(rawBytes.buffer) | ||
31119 | |||
31120 | if (typeof cb === 'function') { | ||
31121 | return process.nextTick(function () { | ||
31122 | cb(null, bytes) | ||
31123 | }) | ||
31124 | } | ||
31125 | |||
31126 | return bytes | ||
31127 | } | ||
31128 | |||
31129 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | ||
31130 | },{"_process":369,"safe-buffer":393}],377:[function(require,module,exports){ | ||
31131 | (function (process,global){ | ||
31132 | 'use strict' | ||
31133 | |||
31134 | function oldBrowser () { | ||
31135 | throw new Error('secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11') | ||
31136 | } | ||
31137 | var safeBuffer = require('safe-buffer') | ||
31138 | var randombytes = require('randombytes') | ||
31139 | var Buffer = safeBuffer.Buffer | ||
31140 | var kBufferMaxLength = safeBuffer.kMaxLength | ||
31141 | var crypto = global.crypto || global.msCrypto | ||
31142 | var kMaxUint32 = Math.pow(2, 32) - 1 | ||
31143 | function assertOffset (offset, length) { | ||
31144 | if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare | ||
31145 | throw new TypeError('offset must be a number') | ||
31146 | } | ||
31147 | |||
31148 | if (offset > kMaxUint32 || offset < 0) { | ||
31149 | throw new TypeError('offset must be a uint32') | ||
31150 | } | ||
31151 | |||
31152 | if (offset > kBufferMaxLength || offset > length) { | ||
31153 | throw new RangeError('offset out of range') | ||
31154 | } | ||
31155 | } | ||
31156 | |||
31157 | function assertSize (size, offset, length) { | ||
31158 | if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare | ||
31159 | throw new TypeError('size must be a number') | ||
31160 | } | ||
31161 | |||
31162 | if (size > kMaxUint32 || size < 0) { | ||
31163 | throw new TypeError('size must be a uint32') | ||
31164 | } | ||
31165 | |||
31166 | if (size + offset > length || size > kBufferMaxLength) { | ||
31167 | throw new RangeError('buffer too small') | ||
31168 | } | ||
31169 | } | ||
31170 | if ((crypto && crypto.getRandomValues) || !process.browser) { | ||
31171 | exports.randomFill = randomFill | ||
31172 | exports.randomFillSync = randomFillSync | ||
31173 | } else { | ||
31174 | exports.randomFill = oldBrowser | ||
31175 | exports.randomFillSync = oldBrowser | ||
31176 | } | ||
31177 | function randomFill (buf, offset, size, cb) { | ||
31178 | if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) { | ||
31179 | throw new TypeError('"buf" argument must be a Buffer or Uint8Array') | ||
31180 | } | ||
31181 | |||
31182 | if (typeof offset === 'function') { | ||
31183 | cb = offset | ||
31184 | offset = 0 | ||
31185 | size = buf.length | ||
31186 | } else if (typeof size === 'function') { | ||
31187 | cb = size | ||
31188 | size = buf.length - offset | ||
31189 | } else if (typeof cb !== 'function') { | ||
31190 | throw new TypeError('"cb" argument must be a function') | ||
31191 | } | ||
31192 | assertOffset(offset, buf.length) | ||
31193 | assertSize(size, offset, buf.length) | ||
31194 | return actualFill(buf, offset, size, cb) | ||
31195 | } | ||
31196 | |||
31197 | function actualFill (buf, offset, size, cb) { | ||
31198 | if (process.browser) { | ||
31199 | var ourBuf = buf.buffer | ||
31200 | var uint = new Uint8Array(ourBuf, offset, size) | ||
31201 | crypto.getRandomValues(uint) | ||
31202 | if (cb) { | ||
31203 | process.nextTick(function () { | ||
31204 | cb(null, buf) | ||
31205 | }) | ||
31206 | return | ||
31207 | } | ||
31208 | return buf | ||
31209 | } | ||
31210 | if (cb) { | ||
31211 | randombytes(size, function (err, bytes) { | ||
31212 | if (err) { | ||
31213 | return cb(err) | ||
31214 | } | ||
31215 | bytes.copy(buf, offset) | ||
31216 | cb(null, buf) | ||
31217 | }) | ||
31218 | return | ||
31219 | } | ||
31220 | var bytes = randombytes(size) | ||
31221 | bytes.copy(buf, offset) | ||
31222 | return buf | ||
31223 | } | ||
31224 | function randomFillSync (buf, offset, size) { | ||
31225 | if (typeof offset === 'undefined') { | ||
31226 | offset = 0 | ||
31227 | } | ||
31228 | if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) { | ||
31229 | throw new TypeError('"buf" argument must be a Buffer or Uint8Array') | ||
31230 | } | ||
31231 | |||
31232 | assertOffset(offset, buf.length) | ||
31233 | |||
31234 | if (size === undefined) size = buf.length - offset | ||
31235 | |||
31236 | assertSize(size, offset, buf.length) | ||
31237 | |||
31238 | return actualFill(buf, offset, size) | ||
31239 | } | ||
31240 | |||
31241 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | ||
31242 | },{"_process":369,"randombytes":376,"safe-buffer":393}],378:[function(require,module,exports){ | ||
31243 | module.exports = require('./lib/_stream_duplex.js'); | ||
31244 | |||
31245 | },{"./lib/_stream_duplex.js":379}],379:[function(require,module,exports){ | ||
31246 | // Copyright Joyent, Inc. and other Node contributors. | ||
31247 | // | ||
31248 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
31249 | // copy of this software and associated documentation files (the | ||
31250 | // "Software"), to deal in the Software without restriction, including | ||
31251 | // without limitation the rights to use, copy, modify, merge, publish, | ||
31252 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
31253 | // persons to whom the Software is furnished to do so, subject to the | ||
31254 | // following conditions: | ||
31255 | // | ||
31256 | // The above copyright notice and this permission notice shall be included | ||
31257 | // in all copies or substantial portions of the Software. | ||
31258 | // | ||
31259 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
31260 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
31261 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
31262 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
31263 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
31264 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
31265 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
31266 | |||
31267 | // a duplex stream is just a stream that is both readable and writable. | ||
31268 | // Since JS doesn't have multiple prototypal inheritance, this class | ||
31269 | // prototypally inherits from Readable, and then parasitically from | ||
31270 | // Writable. | ||
31271 | |||
31272 | 'use strict'; | ||
31273 | |||
31274 | /*<replacement>*/ | ||
31275 | |||
31276 | var pna = require('process-nextick-args'); | ||
31277 | /*</replacement>*/ | ||
31278 | |||
31279 | /*<replacement>*/ | ||
31280 | var objectKeys = Object.keys || function (obj) { | ||
31281 | var keys = []; | ||
31282 | for (var key in obj) { | ||
31283 | keys.push(key); | ||
31284 | }return keys; | ||
31285 | }; | ||
31286 | /*</replacement>*/ | ||
31287 | |||
31288 | module.exports = Duplex; | ||
31289 | |||
31290 | /*<replacement>*/ | ||
31291 | var util = require('core-util-is'); | ||
31292 | util.inherits = require('inherits'); | ||
31293 | /*</replacement>*/ | ||
31294 | |||
31295 | var Readable = require('./_stream_readable'); | ||
31296 | var Writable = require('./_stream_writable'); | ||
31297 | |||
31298 | util.inherits(Duplex, Readable); | ||
31299 | |||
31300 | { | ||
31301 | // avoid scope creep, the keys array can then be collected | ||
31302 | var keys = objectKeys(Writable.prototype); | ||
31303 | for (var v = 0; v < keys.length; v++) { | ||
31304 | var method = keys[v]; | ||
31305 | if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; | ||
31306 | } | ||
31307 | } | ||
31308 | |||
31309 | function Duplex(options) { | ||
31310 | if (!(this instanceof Duplex)) return new Duplex(options); | ||
31311 | |||
31312 | Readable.call(this, options); | ||
31313 | Writable.call(this, options); | ||
31314 | |||
31315 | if (options && options.readable === false) this.readable = false; | ||
31316 | |||
31317 | if (options && options.writable === false) this.writable = false; | ||
31318 | |||
31319 | this.allowHalfOpen = true; | ||
31320 | if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; | ||
31321 | |||
31322 | this.once('end', onend); | ||
31323 | } | ||
31324 | |||
31325 | Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { | ||
31326 | // making it explicit this property is not enumerable | ||
31327 | // because otherwise some prototype manipulation in | ||
31328 | // userland will fail | ||
31329 | enumerable: false, | ||
31330 | get: function () { | ||
31331 | return this._writableState.highWaterMark; | ||
31332 | } | ||
31333 | }); | ||
31334 | |||
31335 | // the no-half-open enforcer | ||
31336 | function onend() { | ||
31337 | // if we allow half-open state, or if the writable side ended, | ||
31338 | // then we're ok. | ||
31339 | if (this.allowHalfOpen || this._writableState.ended) return; | ||
31340 | |||
31341 | // no more data can be written. | ||
31342 | // But allow more writes to happen in this tick. | ||
31343 | pna.nextTick(onEndNT, this); | ||
31344 | } | ||
31345 | |||
31346 | function onEndNT(self) { | ||
31347 | self.end(); | ||
31348 | } | ||
31349 | |||
31350 | Object.defineProperty(Duplex.prototype, 'destroyed', { | ||
31351 | get: function () { | ||
31352 | if (this._readableState === undefined || this._writableState === undefined) { | ||
31353 | return false; | ||
31354 | } | ||
31355 | return this._readableState.destroyed && this._writableState.destroyed; | ||
31356 | }, | ||
31357 | set: function (value) { | ||
31358 | // we ignore the value if the stream | ||
31359 | // has not been initialized yet | ||
31360 | if (this._readableState === undefined || this._writableState === undefined) { | ||
31361 | return; | ||
31362 | } | ||
31363 | |||
31364 | // backward compatibility, the user is explicitly | ||
31365 | // managing destroyed | ||
31366 | this._readableState.destroyed = value; | ||
31367 | this._writableState.destroyed = value; | ||
31368 | } | ||
31369 | }); | ||
31370 | |||
31371 | Duplex.prototype._destroy = function (err, cb) { | ||
31372 | this.push(null); | ||
31373 | this.end(); | ||
31374 | |||
31375 | pna.nextTick(cb, err); | ||
31376 | }; | ||
31377 | },{"./_stream_readable":381,"./_stream_writable":383,"core-util-is":51,"inherits":116,"process-nextick-args":368}],380:[function(require,module,exports){ | ||
31378 | // Copyright Joyent, Inc. and other Node contributors. | ||
31379 | // | ||
31380 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
31381 | // copy of this software and associated documentation files (the | ||
31382 | // "Software"), to deal in the Software without restriction, including | ||
31383 | // without limitation the rights to use, copy, modify, merge, publish, | ||
31384 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
31385 | // persons to whom the Software is furnished to do so, subject to the | ||
31386 | // following conditions: | ||
31387 | // | ||
31388 | // The above copyright notice and this permission notice shall be included | ||
31389 | // in all copies or substantial portions of the Software. | ||
31390 | // | ||
31391 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
31392 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
31393 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
31394 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
31395 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
31396 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
31397 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
31398 | |||
31399 | // a passthrough stream. | ||
31400 | // basically just the most minimal sort of Transform stream. | ||
31401 | // Every written chunk gets output as-is. | ||
31402 | |||
31403 | 'use strict'; | ||
31404 | |||
31405 | module.exports = PassThrough; | ||
31406 | |||
31407 | var Transform = require('./_stream_transform'); | ||
31408 | |||
31409 | /*<replacement>*/ | ||
31410 | var util = require('core-util-is'); | ||
31411 | util.inherits = require('inherits'); | ||
31412 | /*</replacement>*/ | ||
31413 | |||
31414 | util.inherits(PassThrough, Transform); | ||
31415 | |||
31416 | function PassThrough(options) { | ||
31417 | if (!(this instanceof PassThrough)) return new PassThrough(options); | ||
31418 | |||
31419 | Transform.call(this, options); | ||
31420 | } | ||
31421 | |||
31422 | PassThrough.prototype._transform = function (chunk, encoding, cb) { | ||
31423 | cb(null, chunk); | ||
31424 | }; | ||
31425 | },{"./_stream_transform":382,"core-util-is":51,"inherits":116}],381:[function(require,module,exports){ | ||
31426 | (function (process,global){ | ||
31427 | // Copyright Joyent, Inc. and other Node contributors. | ||
31428 | // | ||
31429 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
31430 | // copy of this software and associated documentation files (the | ||
31431 | // "Software"), to deal in the Software without restriction, including | ||
31432 | // without limitation the rights to use, copy, modify, merge, publish, | ||
31433 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
31434 | // persons to whom the Software is furnished to do so, subject to the | ||
31435 | // following conditions: | ||
31436 | // | ||
31437 | // The above copyright notice and this permission notice shall be included | ||
31438 | // in all copies or substantial portions of the Software. | ||
31439 | // | ||
31440 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
31441 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
31442 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
31443 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
31444 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
31445 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
31446 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
31447 | |||
31448 | 'use strict'; | ||
31449 | |||
31450 | /*<replacement>*/ | ||
31451 | |||
31452 | var pna = require('process-nextick-args'); | ||
31453 | /*</replacement>*/ | ||
31454 | |||
31455 | module.exports = Readable; | ||
31456 | |||
31457 | /*<replacement>*/ | ||
31458 | var isArray = require('isarray'); | ||
31459 | /*</replacement>*/ | ||
31460 | |||
31461 | /*<replacement>*/ | ||
31462 | var Duplex; | ||
31463 | /*</replacement>*/ | ||
31464 | |||
31465 | Readable.ReadableState = ReadableState; | ||
31466 | |||
31467 | /*<replacement>*/ | ||
31468 | var EE = require('events').EventEmitter; | ||
31469 | |||
31470 | var EElistenerCount = function (emitter, type) { | ||
31471 | return emitter.listeners(type).length; | ||
31472 | }; | ||
31473 | /*</replacement>*/ | ||
31474 | |||
31475 | /*<replacement>*/ | ||
31476 | var Stream = require('./internal/streams/stream'); | ||
31477 | /*</replacement>*/ | ||
31478 | |||
31479 | /*<replacement>*/ | ||
31480 | |||
31481 | var Buffer = require('safe-buffer').Buffer; | ||
31482 | var OurUint8Array = global.Uint8Array || function () {}; | ||
31483 | function _uint8ArrayToBuffer(chunk) { | ||
31484 | return Buffer.from(chunk); | ||
31485 | } | ||
31486 | function _isUint8Array(obj) { | ||
31487 | return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; | ||
31488 | } | ||
31489 | |||
31490 | /*</replacement>*/ | ||
31491 | |||
31492 | /*<replacement>*/ | ||
31493 | var util = require('core-util-is'); | ||
31494 | util.inherits = require('inherits'); | ||
31495 | /*</replacement>*/ | ||
31496 | |||
31497 | /*<replacement>*/ | ||
31498 | var debugUtil = require('util'); | ||
31499 | var debug = void 0; | ||
31500 | if (debugUtil && debugUtil.debuglog) { | ||
31501 | debug = debugUtil.debuglog('stream'); | ||
31502 | } else { | ||
31503 | debug = function () {}; | ||
31504 | } | ||
31505 | /*</replacement>*/ | ||
31506 | |||
31507 | var BufferList = require('./internal/streams/BufferList'); | ||
31508 | var destroyImpl = require('./internal/streams/destroy'); | ||
31509 | var StringDecoder; | ||
31510 | |||
31511 | util.inherits(Readable, Stream); | ||
31512 | |||
31513 | var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; | ||
31514 | |||
31515 | function prependListener(emitter, event, fn) { | ||
31516 | // Sadly this is not cacheable as some libraries bundle their own | ||
31517 | // event emitter implementation with them. | ||
31518 | if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); | ||
31519 | |||
31520 | // This is a hack to make sure that our error handler is attached before any | ||
31521 | // userland ones. NEVER DO THIS. This is here only because this code needs | ||
31522 | // to continue to work with older versions of Node.js that do not include | ||
31523 | // the prependListener() method. The goal is to eventually remove this hack. | ||
31524 | 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]]; | ||
31525 | } | ||
31526 | |||
31527 | function ReadableState(options, stream) { | ||
31528 | Duplex = Duplex || require('./_stream_duplex'); | ||
31529 | |||
31530 | options = options || {}; | ||
31531 | |||
31532 | // Duplex streams are both readable and writable, but share | ||
31533 | // the same options object. | ||
31534 | // However, some cases require setting options to different | ||
31535 | // values for the readable and the writable sides of the duplex stream. | ||
31536 | // These options can be provided separately as readableXXX and writableXXX. | ||
31537 | var isDuplex = stream instanceof Duplex; | ||
31538 | |||
31539 | // object stream flag. Used to make read(n) ignore n and to | ||
31540 | // make all the buffer merging and length checks go away | ||
31541 | this.objectMode = !!options.objectMode; | ||
31542 | |||
31543 | if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; | ||
31544 | |||
31545 | // the point at which it stops calling _read() to fill the buffer | ||
31546 | // Note: 0 is a valid value, means "don't call _read preemptively ever" | ||
31547 | var hwm = options.highWaterMark; | ||
31548 | var readableHwm = options.readableHighWaterMark; | ||
31549 | var defaultHwm = this.objectMode ? 16 : 16 * 1024; | ||
31550 | |||
31551 | if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm; | ||
31552 | |||
31553 | // cast to ints. | ||
31554 | this.highWaterMark = Math.floor(this.highWaterMark); | ||
31555 | |||
31556 | // A linked list is used to store data chunks instead of an array because the | ||
31557 | // linked list can remove elements from the beginning faster than | ||
31558 | // array.shift() | ||
31559 | this.buffer = new BufferList(); | ||
31560 | this.length = 0; | ||
31561 | this.pipes = null; | ||
31562 | this.pipesCount = 0; | ||
31563 | this.flowing = null; | ||
31564 | this.ended = false; | ||
31565 | this.endEmitted = false; | ||
31566 | this.reading = false; | ||
31567 | |||
31568 | // a flag to be able to tell if the event 'readable'/'data' is emitted | ||
31569 | // immediately, or on a later tick. We set this to true at first, because | ||
31570 | // any actions that shouldn't happen until "later" should generally also | ||
31571 | // not happen before the first read call. | ||
31572 | this.sync = true; | ||
31573 | |||
31574 | // whenever we return null, then we set a flag to say | ||
31575 | // that we're awaiting a 'readable' event emission. | ||
31576 | this.needReadable = false; | ||
31577 | this.emittedReadable = false; | ||
31578 | this.readableListening = false; | ||
31579 | this.resumeScheduled = false; | ||
31580 | |||
31581 | // has it been destroyed | ||
31582 | this.destroyed = false; | ||
31583 | |||
31584 | // Crypto is kind of old and crusty. Historically, its default string | ||
31585 | // encoding is 'binary' so we have to make this configurable. | ||
31586 | // Everything else in the universe uses 'utf8', though. | ||
31587 | this.defaultEncoding = options.defaultEncoding || 'utf8'; | ||
31588 | |||
31589 | // the number of writers that are awaiting a drain event in .pipe()s | ||
31590 | this.awaitDrain = 0; | ||
31591 | |||
31592 | // if true, a maybeReadMore has been scheduled | ||
31593 | this.readingMore = false; | ||
31594 | |||
31595 | this.decoder = null; | ||
31596 | this.encoding = null; | ||
31597 | if (options.encoding) { | ||
31598 | if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; | ||
31599 | this.decoder = new StringDecoder(options.encoding); | ||
31600 | this.encoding = options.encoding; | ||
31601 | } | ||
31602 | } | ||
31603 | |||
31604 | function Readable(options) { | ||
31605 | Duplex = Duplex || require('./_stream_duplex'); | ||
31606 | |||
31607 | if (!(this instanceof Readable)) return new Readable(options); | ||
31608 | |||
31609 | this._readableState = new ReadableState(options, this); | ||
31610 | |||
31611 | // legacy | ||
31612 | this.readable = true; | ||
31613 | |||
31614 | if (options) { | ||
31615 | if (typeof options.read === 'function') this._read = options.read; | ||
31616 | |||
31617 | if (typeof options.destroy === 'function') this._destroy = options.destroy; | ||
31618 | } | ||
31619 | |||
31620 | Stream.call(this); | ||
31621 | } | ||
31622 | |||
31623 | Object.defineProperty(Readable.prototype, 'destroyed', { | ||
31624 | get: function () { | ||
31625 | if (this._readableState === undefined) { | ||
31626 | return false; | ||
31627 | } | ||
31628 | return this._readableState.destroyed; | ||
31629 | }, | ||
31630 | set: function (value) { | ||
31631 | // we ignore the value if the stream | ||
31632 | // has not been initialized yet | ||
31633 | if (!this._readableState) { | ||
31634 | return; | ||
31635 | } | ||
31636 | |||
31637 | // backward compatibility, the user is explicitly | ||
31638 | // managing destroyed | ||
31639 | this._readableState.destroyed = value; | ||
31640 | } | ||
31641 | }); | ||
31642 | |||
31643 | Readable.prototype.destroy = destroyImpl.destroy; | ||
31644 | Readable.prototype._undestroy = destroyImpl.undestroy; | ||
31645 | Readable.prototype._destroy = function (err, cb) { | ||
31646 | this.push(null); | ||
31647 | cb(err); | ||
31648 | }; | ||
31649 | |||
31650 | // Manually shove something into the read() buffer. | ||
31651 | // This returns true if the highWaterMark has not been hit yet, | ||
31652 | // similar to how Writable.write() returns true if you should | ||
31653 | // write() some more. | ||
31654 | Readable.prototype.push = function (chunk, encoding) { | ||
31655 | var state = this._readableState; | ||
31656 | var skipChunkCheck; | ||
31657 | |||
31658 | if (!state.objectMode) { | ||
31659 | if (typeof chunk === 'string') { | ||
31660 | encoding = encoding || state.defaultEncoding; | ||
31661 | if (encoding !== state.encoding) { | ||
31662 | chunk = Buffer.from(chunk, encoding); | ||
31663 | encoding = ''; | ||
31664 | } | ||
31665 | skipChunkCheck = true; | ||
31666 | } | ||
31667 | } else { | ||
31668 | skipChunkCheck = true; | ||
31669 | } | ||
31670 | |||
31671 | return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); | ||
31672 | }; | ||
31673 | |||
31674 | // Unshift should *always* be something directly out of read() | ||
31675 | Readable.prototype.unshift = function (chunk) { | ||
31676 | return readableAddChunk(this, chunk, null, true, false); | ||
31677 | }; | ||
31678 | |||
31679 | function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { | ||
31680 | var state = stream._readableState; | ||
31681 | if (chunk === null) { | ||
31682 | state.reading = false; | ||
31683 | onEofChunk(stream, state); | ||
31684 | } else { | ||
31685 | var er; | ||
31686 | if (!skipChunkCheck) er = chunkInvalid(state, chunk); | ||
31687 | if (er) { | ||
31688 | stream.emit('error', er); | ||
31689 | } else if (state.objectMode || chunk && chunk.length > 0) { | ||
31690 | if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { | ||
31691 | chunk = _uint8ArrayToBuffer(chunk); | ||
31692 | } | ||
31693 | |||
31694 | if (addToFront) { | ||
31695 | if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true); | ||
31696 | } else if (state.ended) { | ||
31697 | stream.emit('error', new Error('stream.push() after EOF')); | ||
31698 | } else { | ||
31699 | state.reading = false; | ||
31700 | if (state.decoder && !encoding) { | ||
31701 | chunk = state.decoder.write(chunk); | ||
31702 | if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); | ||
31703 | } else { | ||
31704 | addChunk(stream, state, chunk, false); | ||
31705 | } | ||
31706 | } | ||
31707 | } else if (!addToFront) { | ||
31708 | state.reading = false; | ||
31709 | } | ||
31710 | } | ||
31711 | |||
31712 | return needMoreData(state); | ||
31713 | } | ||
31714 | |||
31715 | function addChunk(stream, state, chunk, addToFront) { | ||
31716 | if (state.flowing && state.length === 0 && !state.sync) { | ||
31717 | stream.emit('data', chunk); | ||
31718 | stream.read(0); | ||
31719 | } else { | ||
31720 | // update the buffer info. | ||
31721 | state.length += state.objectMode ? 1 : chunk.length; | ||
31722 | if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); | ||
31723 | |||
31724 | if (state.needReadable) emitReadable(stream); | ||
31725 | } | ||
31726 | maybeReadMore(stream, state); | ||
31727 | } | ||
31728 | |||
31729 | function chunkInvalid(state, chunk) { | ||
31730 | var er; | ||
31731 | if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { | ||
31732 | er = new TypeError('Invalid non-string/buffer chunk'); | ||
31733 | } | ||
31734 | return er; | ||
31735 | } | ||
31736 | |||
31737 | // if it's past the high water mark, we can push in some more. | ||
31738 | // Also, if we have no data yet, we can stand some | ||
31739 | // more bytes. This is to work around cases where hwm=0, | ||
31740 | // such as the repl. Also, if the push() triggered a | ||
31741 | // readable event, and the user called read(largeNumber) such that | ||
31742 | // needReadable was set, then we ought to push more, so that another | ||
31743 | // 'readable' event will be triggered. | ||
31744 | function needMoreData(state) { | ||
31745 | return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); | ||
31746 | } | ||
31747 | |||
31748 | Readable.prototype.isPaused = function () { | ||
31749 | return this._readableState.flowing === false; | ||
31750 | }; | ||
31751 | |||
31752 | // backwards compatibility. | ||
31753 | Readable.prototype.setEncoding = function (enc) { | ||
31754 | if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; | ||
31755 | this._readableState.decoder = new StringDecoder(enc); | ||
31756 | this._readableState.encoding = enc; | ||
31757 | return this; | ||
31758 | }; | ||
31759 | |||
31760 | // Don't raise the hwm > 8MB | ||
31761 | var MAX_HWM = 0x800000; | ||
31762 | function computeNewHighWaterMark(n) { | ||
31763 | if (n >= MAX_HWM) { | ||
31764 | n = MAX_HWM; | ||
31765 | } else { | ||
31766 | // Get the next highest power of 2 to prevent increasing hwm excessively in | ||
31767 | // tiny amounts | ||
31768 | n--; | ||
31769 | n |= n >>> 1; | ||
31770 | n |= n >>> 2; | ||
31771 | n |= n >>> 4; | ||
31772 | n |= n >>> 8; | ||
31773 | n |= n >>> 16; | ||
31774 | n++; | ||
31775 | } | ||
31776 | return n; | ||
31777 | } | ||
31778 | |||
31779 | // This function is designed to be inlinable, so please take care when making | ||
31780 | // changes to the function body. | ||
31781 | function howMuchToRead(n, state) { | ||
31782 | if (n <= 0 || state.length === 0 && state.ended) return 0; | ||
31783 | if (state.objectMode) return 1; | ||
31784 | if (n !== n) { | ||
31785 | // Only flow one buffer at a time | ||
31786 | if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; | ||
31787 | } | ||
31788 | // If we're asking for more than the current hwm, then raise the hwm. | ||
31789 | if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); | ||
31790 | if (n <= state.length) return n; | ||
31791 | // Don't have enough | ||
31792 | if (!state.ended) { | ||
31793 | state.needReadable = true; | ||
31794 | return 0; | ||
31795 | } | ||
31796 | return state.length; | ||
31797 | } | ||
31798 | |||
31799 | // you can override either this method, or the async _read(n) below. | ||
31800 | Readable.prototype.read = function (n) { | ||
31801 | debug('read', n); | ||
31802 | n = parseInt(n, 10); | ||
31803 | var state = this._readableState; | ||
31804 | var nOrig = n; | ||
31805 | |||
31806 | if (n !== 0) state.emittedReadable = false; | ||
31807 | |||
31808 | // if we're doing read(0) to trigger a readable event, but we | ||
31809 | // already have a bunch of data in the buffer, then just trigger | ||
31810 | // the 'readable' event and move on. | ||
31811 | if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { | ||
31812 | debug('read: emitReadable', state.length, state.ended); | ||
31813 | if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); | ||
31814 | return null; | ||
31815 | } | ||
31816 | |||
31817 | n = howMuchToRead(n, state); | ||
31818 | |||
31819 | // if we've ended, and we're now clear, then finish it up. | ||
31820 | if (n === 0 && state.ended) { | ||
31821 | if (state.length === 0) endReadable(this); | ||
31822 | return null; | ||
31823 | } | ||
31824 | |||
31825 | // All the actual chunk generation logic needs to be | ||
31826 | // *below* the call to _read. The reason is that in certain | ||
31827 | // synthetic stream cases, such as passthrough streams, _read | ||
31828 | // may be a completely synchronous operation which may change | ||
31829 | // the state of the read buffer, providing enough data when | ||
31830 | // before there was *not* enough. | ||
31831 | // | ||
31832 | // So, the steps are: | ||
31833 | // 1. Figure out what the state of things will be after we do | ||
31834 | // a read from the buffer. | ||
31835 | // | ||
31836 | // 2. If that resulting state will trigger a _read, then call _read. | ||
31837 | // Note that this may be asynchronous, or synchronous. Yes, it is | ||
31838 | // deeply ugly to write APIs this way, but that still doesn't mean | ||
31839 | // that the Readable class should behave improperly, as streams are | ||
31840 | // designed to be sync/async agnostic. | ||
31841 | // Take note if the _read call is sync or async (ie, if the read call | ||
31842 | // has returned yet), so that we know whether or not it's safe to emit | ||
31843 | // 'readable' etc. | ||
31844 | // | ||
31845 | // 3. Actually pull the requested chunks out of the buffer and return. | ||
31846 | |||
31847 | // if we need a readable event, then we need to do some reading. | ||
31848 | var doRead = state.needReadable; | ||
31849 | debug('need readable', doRead); | ||
31850 | |||
31851 | // if we currently have less than the highWaterMark, then also read some | ||
31852 | if (state.length === 0 || state.length - n < state.highWaterMark) { | ||
31853 | doRead = true; | ||
31854 | debug('length less than watermark', doRead); | ||
31855 | } | ||
31856 | |||
31857 | // however, if we've ended, then there's no point, and if we're already | ||
31858 | // reading, then it's unnecessary. | ||
31859 | if (state.ended || state.reading) { | ||
31860 | doRead = false; | ||
31861 | debug('reading or ended', doRead); | ||
31862 | } else if (doRead) { | ||
31863 | debug('do read'); | ||
31864 | state.reading = true; | ||
31865 | state.sync = true; | ||
31866 | // if the length is currently zero, then we *need* a readable event. | ||
31867 | if (state.length === 0) state.needReadable = true; | ||
31868 | // call internal read method | ||
31869 | this._read(state.highWaterMark); | ||
31870 | state.sync = false; | ||
31871 | // If _read pushed data synchronously, then `reading` will be false, | ||
31872 | // and we need to re-evaluate how much data we can return to the user. | ||
31873 | if (!state.reading) n = howMuchToRead(nOrig, state); | ||
31874 | } | ||
31875 | |||
31876 | var ret; | ||
31877 | if (n > 0) ret = fromList(n, state);else ret = null; | ||
31878 | |||
31879 | if (ret === null) { | ||
31880 | state.needReadable = true; | ||
31881 | n = 0; | ||
31882 | } else { | ||
31883 | state.length -= n; | ||
31884 | } | ||
31885 | |||
31886 | if (state.length === 0) { | ||
31887 | // If we have nothing in the buffer, then we want to know | ||
31888 | // as soon as we *do* get something into the buffer. | ||
31889 | if (!state.ended) state.needReadable = true; | ||
31890 | |||
31891 | // If we tried to read() past the EOF, then emit end on the next tick. | ||
31892 | if (nOrig !== n && state.ended) endReadable(this); | ||
31893 | } | ||
31894 | |||
31895 | if (ret !== null) this.emit('data', ret); | ||
31896 | |||
31897 | return ret; | ||
31898 | }; | ||
31899 | |||
31900 | function onEofChunk(stream, state) { | ||
31901 | if (state.ended) return; | ||
31902 | if (state.decoder) { | ||
31903 | var chunk = state.decoder.end(); | ||
31904 | if (chunk && chunk.length) { | ||
31905 | state.buffer.push(chunk); | ||
31906 | state.length += state.objectMode ? 1 : chunk.length; | ||
31907 | } | ||
31908 | } | ||
31909 | state.ended = true; | ||
31910 | |||
31911 | // emit 'readable' now to make sure it gets picked up. | ||
31912 | emitReadable(stream); | ||
31913 | } | ||
31914 | |||
31915 | // Don't emit readable right away in sync mode, because this can trigger | ||
31916 | // another read() call => stack overflow. This way, it might trigger | ||
31917 | // a nextTick recursion warning, but that's not so bad. | ||
31918 | function emitReadable(stream) { | ||
31919 | var state = stream._readableState; | ||
31920 | state.needReadable = false; | ||
31921 | if (!state.emittedReadable) { | ||
31922 | debug('emitReadable', state.flowing); | ||
31923 | state.emittedReadable = true; | ||
31924 | if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream); | ||
31925 | } | ||
31926 | } | ||
31927 | |||
31928 | function emitReadable_(stream) { | ||
31929 | debug('emit readable'); | ||
31930 | stream.emit('readable'); | ||
31931 | flow(stream); | ||
31932 | } | ||
31933 | |||
31934 | // at this point, the user has presumably seen the 'readable' event, | ||
31935 | // and called read() to consume some data. that may have triggered | ||
31936 | // in turn another _read(n) call, in which case reading = true if | ||
31937 | // it's in progress. | ||
31938 | // However, if we're not ended, or reading, and the length < hwm, | ||
31939 | // then go ahead and try to read some more preemptively. | ||
31940 | function maybeReadMore(stream, state) { | ||
31941 | if (!state.readingMore) { | ||
31942 | state.readingMore = true; | ||
31943 | pna.nextTick(maybeReadMore_, stream, state); | ||
31944 | } | ||
31945 | } | ||
31946 | |||
31947 | function maybeReadMore_(stream, state) { | ||
31948 | var len = state.length; | ||
31949 | while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { | ||
31950 | debug('maybeReadMore read 0'); | ||
31951 | stream.read(0); | ||
31952 | if (len === state.length) | ||
31953 | // didn't get any data, stop spinning. | ||
31954 | break;else len = state.length; | ||
31955 | } | ||
31956 | state.readingMore = false; | ||
31957 | } | ||
31958 | |||
31959 | // abstract method. to be overridden in specific implementation classes. | ||
31960 | // call cb(er, data) where data is <= n in length. | ||
31961 | // for virtual (non-string, non-buffer) streams, "length" is somewhat | ||
31962 | // arbitrary, and perhaps not very meaningful. | ||
31963 | Readable.prototype._read = function (n) { | ||
31964 | this.emit('error', new Error('_read() is not implemented')); | ||
31965 | }; | ||
31966 | |||
31967 | Readable.prototype.pipe = function (dest, pipeOpts) { | ||
31968 | var src = this; | ||
31969 | var state = this._readableState; | ||
31970 | |||
31971 | switch (state.pipesCount) { | ||
31972 | case 0: | ||
31973 | state.pipes = dest; | ||
31974 | break; | ||
31975 | case 1: | ||
31976 | state.pipes = [state.pipes, dest]; | ||
31977 | break; | ||
31978 | default: | ||
31979 | state.pipes.push(dest); | ||
31980 | break; | ||
31981 | } | ||
31982 | state.pipesCount += 1; | ||
31983 | debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); | ||
31984 | |||
31985 | var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; | ||
31986 | |||
31987 | var endFn = doEnd ? onend : unpipe; | ||
31988 | if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn); | ||
31989 | |||
31990 | dest.on('unpipe', onunpipe); | ||
31991 | function onunpipe(readable, unpipeInfo) { | ||
31992 | debug('onunpipe'); | ||
31993 | if (readable === src) { | ||
31994 | if (unpipeInfo && unpipeInfo.hasUnpiped === false) { | ||
31995 | unpipeInfo.hasUnpiped = true; | ||
31996 | cleanup(); | ||
31997 | } | ||
31998 | } | ||
31999 | } | ||
32000 | |||
32001 | function onend() { | ||
32002 | debug('onend'); | ||
32003 | dest.end(); | ||
32004 | } | ||
32005 | |||
32006 | // when the dest drains, it reduces the awaitDrain counter | ||
32007 | // on the source. This would be more elegant with a .once() | ||
32008 | // handler in flow(), but adding and removing repeatedly is | ||
32009 | // too slow. | ||
32010 | var ondrain = pipeOnDrain(src); | ||
32011 | dest.on('drain', ondrain); | ||
32012 | |||
32013 | var cleanedUp = false; | ||
32014 | function cleanup() { | ||
32015 | debug('cleanup'); | ||
32016 | // cleanup event handlers once the pipe is broken | ||
32017 | dest.removeListener('close', onclose); | ||
32018 | dest.removeListener('finish', onfinish); | ||
32019 | dest.removeListener('drain', ondrain); | ||
32020 | dest.removeListener('error', onerror); | ||
32021 | dest.removeListener('unpipe', onunpipe); | ||
32022 | src.removeListener('end', onend); | ||
32023 | src.removeListener('end', unpipe); | ||
32024 | src.removeListener('data', ondata); | ||
32025 | |||
32026 | cleanedUp = true; | ||
32027 | |||
32028 | // if the reader is waiting for a drain event from this | ||
32029 | // specific writer, then it would cause it to never start | ||
32030 | // flowing again. | ||
32031 | // So, if this is awaiting a drain, then we just call it now. | ||
32032 | // If we don't know, then assume that we are waiting for one. | ||
32033 | if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); | ||
32034 | } | ||
32035 | |||
32036 | // If the user pushes more data while we're writing to dest then we'll end up | ||
32037 | // in ondata again. However, we only want to increase awaitDrain once because | ||
32038 | // dest will only emit one 'drain' event for the multiple writes. | ||
32039 | // => Introduce a guard on increasing awaitDrain. | ||
32040 | var increasedAwaitDrain = false; | ||
32041 | src.on('data', ondata); | ||
32042 | function ondata(chunk) { | ||
32043 | debug('ondata'); | ||
32044 | increasedAwaitDrain = false; | ||
32045 | var ret = dest.write(chunk); | ||
32046 | if (false === ret && !increasedAwaitDrain) { | ||
32047 | // If the user unpiped during `dest.write()`, it is possible | ||
32048 | // to get stuck in a permanently paused state if that write | ||
32049 | // also returned false. | ||
32050 | // => Check whether `dest` is still a piping destination. | ||
32051 | if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { | ||
32052 | debug('false write response, pause', src._readableState.awaitDrain); | ||
32053 | src._readableState.awaitDrain++; | ||
32054 | increasedAwaitDrain = true; | ||
32055 | } | ||
32056 | src.pause(); | ||
32057 | } | ||
32058 | } | ||
32059 | |||
32060 | // if the dest has an error, then stop piping into it. | ||
32061 | // however, don't suppress the throwing behavior for this. | ||
32062 | function onerror(er) { | ||
32063 | debug('onerror', er); | ||
32064 | unpipe(); | ||
32065 | dest.removeListener('error', onerror); | ||
32066 | if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); | ||
32067 | } | ||
32068 | |||
32069 | // Make sure our error handler is attached before userland ones. | ||
32070 | prependListener(dest, 'error', onerror); | ||
32071 | |||
32072 | // Both close and finish should trigger unpipe, but only once. | ||
32073 | function onclose() { | ||
32074 | dest.removeListener('finish', onfinish); | ||
32075 | unpipe(); | ||
32076 | } | ||
32077 | dest.once('close', onclose); | ||
32078 | function onfinish() { | ||
32079 | debug('onfinish'); | ||
32080 | dest.removeListener('close', onclose); | ||
32081 | unpipe(); | ||
32082 | } | ||
32083 | dest.once('finish', onfinish); | ||
32084 | |||
32085 | function unpipe() { | ||
32086 | debug('unpipe'); | ||
32087 | src.unpipe(dest); | ||
32088 | } | ||
32089 | |||
32090 | // tell the dest that it's being piped to | ||
32091 | dest.emit('pipe', src); | ||
32092 | |||
32093 | // start the flow if it hasn't been started already. | ||
32094 | if (!state.flowing) { | ||
32095 | debug('pipe resume'); | ||
32096 | src.resume(); | ||
32097 | } | ||
32098 | |||
32099 | return dest; | ||
32100 | }; | ||
32101 | |||
32102 | function pipeOnDrain(src) { | ||
32103 | return function () { | ||
32104 | var state = src._readableState; | ||
32105 | debug('pipeOnDrain', state.awaitDrain); | ||
32106 | if (state.awaitDrain) state.awaitDrain--; | ||
32107 | if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { | ||
32108 | state.flowing = true; | ||
32109 | flow(src); | ||
32110 | } | ||
32111 | }; | ||
32112 | } | ||
32113 | |||
32114 | Readable.prototype.unpipe = function (dest) { | ||
32115 | var state = this._readableState; | ||
32116 | var unpipeInfo = { hasUnpiped: false }; | ||
32117 | |||
32118 | // if we're not piping anywhere, then do nothing. | ||
32119 | if (state.pipesCount === 0) return this; | ||
32120 | |||
32121 | // just one destination. most common case. | ||
32122 | if (state.pipesCount === 1) { | ||
32123 | // passed in one, but it's not the right one. | ||
32124 | if (dest && dest !== state.pipes) return this; | ||
32125 | |||
32126 | if (!dest) dest = state.pipes; | ||
32127 | |||
32128 | // got a match. | ||
32129 | state.pipes = null; | ||
32130 | state.pipesCount = 0; | ||
32131 | state.flowing = false; | ||
32132 | if (dest) dest.emit('unpipe', this, unpipeInfo); | ||
32133 | return this; | ||
32134 | } | ||
32135 | |||
32136 | // slow case. multiple pipe destinations. | ||
32137 | |||
32138 | if (!dest) { | ||
32139 | // remove all. | ||
32140 | var dests = state.pipes; | ||
32141 | var len = state.pipesCount; | ||
32142 | state.pipes = null; | ||
32143 | state.pipesCount = 0; | ||
32144 | state.flowing = false; | ||
32145 | |||
32146 | for (var i = 0; i < len; i++) { | ||
32147 | dests[i].emit('unpipe', this, unpipeInfo); | ||
32148 | }return this; | ||
32149 | } | ||
32150 | |||
32151 | // try to find the right one. | ||
32152 | var index = indexOf(state.pipes, dest); | ||
32153 | if (index === -1) return this; | ||
32154 | |||
32155 | state.pipes.splice(index, 1); | ||
32156 | state.pipesCount -= 1; | ||
32157 | if (state.pipesCount === 1) state.pipes = state.pipes[0]; | ||
32158 | |||
32159 | dest.emit('unpipe', this, unpipeInfo); | ||
32160 | |||
32161 | return this; | ||
32162 | }; | ||
32163 | |||
32164 | // set up data events if they are asked for | ||
32165 | // Ensure readable listeners eventually get something | ||
32166 | Readable.prototype.on = function (ev, fn) { | ||
32167 | var res = Stream.prototype.on.call(this, ev, fn); | ||
32168 | |||
32169 | if (ev === 'data') { | ||
32170 | // Start flowing on next tick if stream isn't explicitly paused | ||
32171 | if (this._readableState.flowing !== false) this.resume(); | ||
32172 | } else if (ev === 'readable') { | ||
32173 | var state = this._readableState; | ||
32174 | if (!state.endEmitted && !state.readableListening) { | ||
32175 | state.readableListening = state.needReadable = true; | ||
32176 | state.emittedReadable = false; | ||
32177 | if (!state.reading) { | ||
32178 | pna.nextTick(nReadingNextTick, this); | ||
32179 | } else if (state.length) { | ||
32180 | emitReadable(this); | ||
32181 | } | ||
32182 | } | ||
32183 | } | ||
32184 | |||
32185 | return res; | ||
32186 | }; | ||
32187 | Readable.prototype.addListener = Readable.prototype.on; | ||
32188 | |||
32189 | function nReadingNextTick(self) { | ||
32190 | debug('readable nexttick read 0'); | ||
32191 | self.read(0); | ||
32192 | } | ||
32193 | |||
32194 | // pause() and resume() are remnants of the legacy readable stream API | ||
32195 | // If the user uses them, then switch into old mode. | ||
32196 | Readable.prototype.resume = function () { | ||
32197 | var state = this._readableState; | ||
32198 | if (!state.flowing) { | ||
32199 | debug('resume'); | ||
32200 | state.flowing = true; | ||
32201 | resume(this, state); | ||
32202 | } | ||
32203 | return this; | ||
32204 | }; | ||
32205 | |||
32206 | function resume(stream, state) { | ||
32207 | if (!state.resumeScheduled) { | ||
32208 | state.resumeScheduled = true; | ||
32209 | pna.nextTick(resume_, stream, state); | ||
32210 | } | ||
32211 | } | ||
32212 | |||
32213 | function resume_(stream, state) { | ||
32214 | if (!state.reading) { | ||
32215 | debug('resume read 0'); | ||
32216 | stream.read(0); | ||
32217 | } | ||
32218 | |||
32219 | state.resumeScheduled = false; | ||
32220 | state.awaitDrain = 0; | ||
32221 | stream.emit('resume'); | ||
32222 | flow(stream); | ||
32223 | if (state.flowing && !state.reading) stream.read(0); | ||
32224 | } | ||
32225 | |||
32226 | Readable.prototype.pause = function () { | ||
32227 | debug('call pause flowing=%j', this._readableState.flowing); | ||
32228 | if (false !== this._readableState.flowing) { | ||
32229 | debug('pause'); | ||
32230 | this._readableState.flowing = false; | ||
32231 | this.emit('pause'); | ||
32232 | } | ||
32233 | return this; | ||
32234 | }; | ||
32235 | |||
32236 | function flow(stream) { | ||
32237 | var state = stream._readableState; | ||
32238 | debug('flow', state.flowing); | ||
32239 | while (state.flowing && stream.read() !== null) {} | ||
32240 | } | ||
32241 | |||
32242 | // wrap an old-style stream as the async data source. | ||
32243 | // This is *not* part of the readable stream interface. | ||
32244 | // It is an ugly unfortunate mess of history. | ||
32245 | Readable.prototype.wrap = function (stream) { | ||
32246 | var _this = this; | ||
32247 | |||
32248 | var state = this._readableState; | ||
32249 | var paused = false; | ||
32250 | |||
32251 | stream.on('end', function () { | ||
32252 | debug('wrapped end'); | ||
32253 | if (state.decoder && !state.ended) { | ||
32254 | var chunk = state.decoder.end(); | ||
32255 | if (chunk && chunk.length) _this.push(chunk); | ||
32256 | } | ||
32257 | |||
32258 | _this.push(null); | ||
32259 | }); | ||
32260 | |||
32261 | stream.on('data', function (chunk) { | ||
32262 | debug('wrapped data'); | ||
32263 | if (state.decoder) chunk = state.decoder.write(chunk); | ||
32264 | |||
32265 | // don't skip over falsy values in objectMode | ||
32266 | if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; | ||
32267 | |||
32268 | var ret = _this.push(chunk); | ||
32269 | if (!ret) { | ||
32270 | paused = true; | ||
32271 | stream.pause(); | ||
32272 | } | ||
32273 | }); | ||
32274 | |||
32275 | // proxy all the other methods. | ||
32276 | // important when wrapping filters and duplexes. | ||
32277 | for (var i in stream) { | ||
32278 | if (this[i] === undefined && typeof stream[i] === 'function') { | ||
32279 | this[i] = function (method) { | ||
32280 | return function () { | ||
32281 | return stream[method].apply(stream, arguments); | ||
32282 | }; | ||
32283 | }(i); | ||
32284 | } | ||
32285 | } | ||
32286 | |||
32287 | // proxy certain important events. | ||
32288 | for (var n = 0; n < kProxyEvents.length; n++) { | ||
32289 | stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); | ||
32290 | } | ||
32291 | |||
32292 | // when we try to consume some more bytes, simply unpause the | ||
32293 | // underlying stream. | ||
32294 | this._read = function (n) { | ||
32295 | debug('wrapped _read', n); | ||
32296 | if (paused) { | ||
32297 | paused = false; | ||
32298 | stream.resume(); | ||
32299 | } | ||
32300 | }; | ||
32301 | |||
32302 | return this; | ||
32303 | }; | ||
32304 | |||
32305 | Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { | ||
32306 | // making it explicit this property is not enumerable | ||
32307 | // because otherwise some prototype manipulation in | ||
32308 | // userland will fail | ||
32309 | enumerable: false, | ||
32310 | get: function () { | ||
32311 | return this._readableState.highWaterMark; | ||
32312 | } | ||
32313 | }); | ||
32314 | |||
32315 | // exposed for testing purposes only. | ||
32316 | Readable._fromList = fromList; | ||
32317 | |||
32318 | // Pluck off n bytes from an array of buffers. | ||
32319 | // Length is the combined lengths of all the buffers in the list. | ||
32320 | // This function is designed to be inlinable, so please take care when making | ||
32321 | // changes to the function body. | ||
32322 | function fromList(n, state) { | ||
32323 | // nothing buffered | ||
32324 | if (state.length === 0) return null; | ||
32325 | |||
32326 | var ret; | ||
32327 | if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { | ||
32328 | // read it all, truncate the list | ||
32329 | 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); | ||
32330 | state.buffer.clear(); | ||
32331 | } else { | ||
32332 | // read part of list | ||
32333 | ret = fromListPartial(n, state.buffer, state.decoder); | ||
32334 | } | ||
32335 | |||
32336 | return ret; | ||
32337 | } | ||
32338 | |||
32339 | // Extracts only enough buffered data to satisfy the amount requested. | ||
32340 | // This function is designed to be inlinable, so please take care when making | ||
32341 | // changes to the function body. | ||
32342 | function fromListPartial(n, list, hasStrings) { | ||
32343 | var ret; | ||
32344 | if (n < list.head.data.length) { | ||
32345 | // slice is the same for buffers and strings | ||
32346 | ret = list.head.data.slice(0, n); | ||
32347 | list.head.data = list.head.data.slice(n); | ||
32348 | } else if (n === list.head.data.length) { | ||
32349 | // first chunk is a perfect match | ||
32350 | ret = list.shift(); | ||
32351 | } else { | ||
32352 | // result spans more than one buffer | ||
32353 | ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); | ||
32354 | } | ||
32355 | return ret; | ||
32356 | } | ||
32357 | |||
32358 | // Copies a specified amount of characters from the list of buffered data | ||
32359 | // chunks. | ||
32360 | // This function is designed to be inlinable, so please take care when making | ||
32361 | // changes to the function body. | ||
32362 | function copyFromBufferString(n, list) { | ||
32363 | var p = list.head; | ||
32364 | var c = 1; | ||
32365 | var ret = p.data; | ||
32366 | n -= ret.length; | ||
32367 | while (p = p.next) { | ||
32368 | var str = p.data; | ||
32369 | var nb = n > str.length ? str.length : n; | ||
32370 | if (nb === str.length) ret += str;else ret += str.slice(0, n); | ||
32371 | n -= nb; | ||
32372 | if (n === 0) { | ||
32373 | if (nb === str.length) { | ||
32374 | ++c; | ||
32375 | if (p.next) list.head = p.next;else list.head = list.tail = null; | ||
32376 | } else { | ||
32377 | list.head = p; | ||
32378 | p.data = str.slice(nb); | ||
32379 | } | ||
32380 | break; | ||
32381 | } | ||
32382 | ++c; | ||
32383 | } | ||
32384 | list.length -= c; | ||
32385 | return ret; | ||
32386 | } | ||
32387 | |||
32388 | // Copies a specified amount of bytes from the list of buffered data chunks. | ||
32389 | // This function is designed to be inlinable, so please take care when making | ||
32390 | // changes to the function body. | ||
32391 | function copyFromBuffer(n, list) { | ||
32392 | var ret = Buffer.allocUnsafe(n); | ||
32393 | var p = list.head; | ||
32394 | var c = 1; | ||
32395 | p.data.copy(ret); | ||
32396 | n -= p.data.length; | ||
32397 | while (p = p.next) { | ||
32398 | var buf = p.data; | ||
32399 | var nb = n > buf.length ? buf.length : n; | ||
32400 | buf.copy(ret, ret.length - n, 0, nb); | ||
32401 | n -= nb; | ||
32402 | if (n === 0) { | ||
32403 | if (nb === buf.length) { | ||
32404 | ++c; | ||
32405 | if (p.next) list.head = p.next;else list.head = list.tail = null; | ||
32406 | } else { | ||
32407 | list.head = p; | ||
32408 | p.data = buf.slice(nb); | ||
32409 | } | ||
32410 | break; | ||
32411 | } | ||
32412 | ++c; | ||
32413 | } | ||
32414 | list.length -= c; | ||
32415 | return ret; | ||
32416 | } | ||
32417 | |||
32418 | function endReadable(stream) { | ||
32419 | var state = stream._readableState; | ||
32420 | |||
32421 | // If we get here before consuming all the bytes, then that is a | ||
32422 | // bug in node. Should never happen. | ||
32423 | if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); | ||
32424 | |||
32425 | if (!state.endEmitted) { | ||
32426 | state.ended = true; | ||
32427 | pna.nextTick(endReadableNT, state, stream); | ||
32428 | } | ||
32429 | } | ||
32430 | |||
32431 | function endReadableNT(state, stream) { | ||
32432 | // Check that we didn't get one last unshift. | ||
32433 | if (!state.endEmitted && state.length === 0) { | ||
32434 | state.endEmitted = true; | ||
32435 | stream.readable = false; | ||
32436 | stream.emit('end'); | ||
32437 | } | ||
32438 | } | ||
32439 | |||
32440 | function indexOf(xs, x) { | ||
32441 | for (var i = 0, l = xs.length; i < l; i++) { | ||
32442 | if (xs[i] === x) return i; | ||
32443 | } | ||
32444 | return -1; | ||
32445 | } | ||
32446 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | ||
32447 | },{"./_stream_duplex":379,"./internal/streams/BufferList":384,"./internal/streams/destroy":385,"./internal/streams/stream":386,"_process":369,"core-util-is":51,"events":99,"inherits":116,"isarray":118,"process-nextick-args":368,"safe-buffer":393,"string_decoder/":387,"util":20}],382:[function(require,module,exports){ | ||
32448 | // Copyright Joyent, Inc. and other Node contributors. | ||
32449 | // | ||
32450 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
32451 | // copy of this software and associated documentation files (the | ||
32452 | // "Software"), to deal in the Software without restriction, including | ||
32453 | // without limitation the rights to use, copy, modify, merge, publish, | ||
32454 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
32455 | // persons to whom the Software is furnished to do so, subject to the | ||
32456 | // following conditions: | ||
32457 | // | ||
32458 | // The above copyright notice and this permission notice shall be included | ||
32459 | // in all copies or substantial portions of the Software. | ||
32460 | // | ||
32461 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
32462 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
32463 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
32464 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
32465 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
32466 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
32467 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
32468 | |||
32469 | // a transform stream is a readable/writable stream where you do | ||
32470 | // something with the data. Sometimes it's called a "filter", | ||
32471 | // but that's not a great name for it, since that implies a thing where | ||
32472 | // some bits pass through, and others are simply ignored. (That would | ||
32473 | // be a valid example of a transform, of course.) | ||
32474 | // | ||
32475 | // While the output is causally related to the input, it's not a | ||
32476 | // necessarily symmetric or synchronous transformation. For example, | ||
32477 | // a zlib stream might take multiple plain-text writes(), and then | ||
32478 | // emit a single compressed chunk some time in the future. | ||
32479 | // | ||
32480 | // Here's how this works: | ||
32481 | // | ||
32482 | // The Transform stream has all the aspects of the readable and writable | ||
32483 | // stream classes. When you write(chunk), that calls _write(chunk,cb) | ||
32484 | // internally, and returns false if there's a lot of pending writes | ||
32485 | // buffered up. When you call read(), that calls _read(n) until | ||
32486 | // there's enough pending readable data buffered up. | ||
32487 | // | ||
32488 | // In a transform stream, the written data is placed in a buffer. When | ||
32489 | // _read(n) is called, it transforms the queued up data, calling the | ||
32490 | // buffered _write cb's as it consumes chunks. If consuming a single | ||
32491 | // written chunk would result in multiple output chunks, then the first | ||
32492 | // outputted bit calls the readcb, and subsequent chunks just go into | ||
32493 | // the read buffer, and will cause it to emit 'readable' if necessary. | ||
32494 | // | ||
32495 | // This way, back-pressure is actually determined by the reading side, | ||
32496 | // since _read has to be called to start processing a new chunk. However, | ||
32497 | // a pathological inflate type of transform can cause excessive buffering | ||
32498 | // here. For example, imagine a stream where every byte of input is | ||
32499 | // interpreted as an integer from 0-255, and then results in that many | ||
32500 | // bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in | ||
32501 | // 1kb of data being output. In this case, you could write a very small | ||
32502 | // amount of input, and end up with a very large amount of output. In | ||
32503 | // such a pathological inflating mechanism, there'd be no way to tell | ||
32504 | // the system to stop doing the transform. A single 4MB write could | ||
32505 | // cause the system to run out of memory. | ||
32506 | // | ||
32507 | // However, even in such a pathological case, only a single written chunk | ||
32508 | // would be consumed, and then the rest would wait (un-transformed) until | ||
32509 | // the results of the previous transformed chunk were consumed. | ||
32510 | |||
32511 | 'use strict'; | ||
32512 | |||
32513 | module.exports = Transform; | ||
32514 | |||
32515 | var Duplex = require('./_stream_duplex'); | ||
32516 | |||
32517 | /*<replacement>*/ | ||
32518 | var util = require('core-util-is'); | ||
32519 | util.inherits = require('inherits'); | ||
32520 | /*</replacement>*/ | ||
32521 | |||
32522 | util.inherits(Transform, Duplex); | ||
32523 | |||
32524 | function afterTransform(er, data) { | ||
32525 | var ts = this._transformState; | ||
32526 | ts.transforming = false; | ||
32527 | |||
32528 | var cb = ts.writecb; | ||
32529 | |||
32530 | if (!cb) { | ||
32531 | return this.emit('error', new Error('write callback called multiple times')); | ||
32532 | } | ||
32533 | |||
32534 | ts.writechunk = null; | ||
32535 | ts.writecb = null; | ||
32536 | |||
32537 | if (data != null) // single equals check for both `null` and `undefined` | ||
32538 | this.push(data); | ||
32539 | |||
32540 | cb(er); | ||
32541 | |||
32542 | var rs = this._readableState; | ||
32543 | rs.reading = false; | ||
32544 | if (rs.needReadable || rs.length < rs.highWaterMark) { | ||
32545 | this._read(rs.highWaterMark); | ||
32546 | } | ||
32547 | } | ||
32548 | |||
32549 | function Transform(options) { | ||
32550 | if (!(this instanceof Transform)) return new Transform(options); | ||
32551 | |||
32552 | Duplex.call(this, options); | ||
32553 | |||
32554 | this._transformState = { | ||
32555 | afterTransform: afterTransform.bind(this), | ||
32556 | needTransform: false, | ||
32557 | transforming: false, | ||
32558 | writecb: null, | ||
32559 | writechunk: null, | ||
32560 | writeencoding: null | ||
32561 | }; | ||
32562 | |||
32563 | // start out asking for a readable event once data is transformed. | ||
32564 | this._readableState.needReadable = true; | ||
32565 | |||
32566 | // we have implemented the _read method, and done the other things | ||
32567 | // that Readable wants before the first _read call, so unset the | ||
32568 | // sync guard flag. | ||
32569 | this._readableState.sync = false; | ||
32570 | |||
32571 | if (options) { | ||
32572 | if (typeof options.transform === 'function') this._transform = options.transform; | ||
32573 | |||
32574 | if (typeof options.flush === 'function') this._flush = options.flush; | ||
32575 | } | ||
32576 | |||
32577 | // When the writable side finishes, then flush out anything remaining. | ||
32578 | this.on('prefinish', prefinish); | ||
32579 | } | ||
32580 | |||
32581 | function prefinish() { | ||
32582 | var _this = this; | ||
32583 | |||
32584 | if (typeof this._flush === 'function') { | ||
32585 | this._flush(function (er, data) { | ||
32586 | done(_this, er, data); | ||
32587 | }); | ||
32588 | } else { | ||
32589 | done(this, null, null); | ||
32590 | } | ||
32591 | } | ||
32592 | |||
32593 | Transform.prototype.push = function (chunk, encoding) { | ||
32594 | this._transformState.needTransform = false; | ||
32595 | return Duplex.prototype.push.call(this, chunk, encoding); | ||
32596 | }; | ||
32597 | |||
32598 | // This is the part where you do stuff! | ||
32599 | // override this function in implementation classes. | ||
32600 | // 'chunk' is an input chunk. | ||
32601 | // | ||
32602 | // Call `push(newChunk)` to pass along transformed output | ||
32603 | // to the readable side. You may call 'push' zero or more times. | ||
32604 | // | ||
32605 | // Call `cb(err)` when you are done with this chunk. If you pass | ||
32606 | // an error, then that'll put the hurt on the whole operation. If you | ||
32607 | // never call cb(), then you'll never get another chunk. | ||
32608 | Transform.prototype._transform = function (chunk, encoding, cb) { | ||
32609 | throw new Error('_transform() is not implemented'); | ||
32610 | }; | ||
32611 | |||
32612 | Transform.prototype._write = function (chunk, encoding, cb) { | ||
32613 | var ts = this._transformState; | ||
32614 | ts.writecb = cb; | ||
32615 | ts.writechunk = chunk; | ||
32616 | ts.writeencoding = encoding; | ||
32617 | if (!ts.transforming) { | ||
32618 | var rs = this._readableState; | ||
32619 | if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); | ||
32620 | } | ||
32621 | }; | ||
32622 | |||
32623 | // Doesn't matter what the args are here. | ||
32624 | // _transform does all the work. | ||
32625 | // That we got here means that the readable side wants more data. | ||
32626 | Transform.prototype._read = function (n) { | ||
32627 | var ts = this._transformState; | ||
32628 | |||
32629 | if (ts.writechunk !== null && ts.writecb && !ts.transforming) { | ||
32630 | ts.transforming = true; | ||
32631 | this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); | ||
32632 | } else { | ||
32633 | // mark that we need a transform, so that any data that comes in | ||
32634 | // will get processed, now that we've asked for it. | ||
32635 | ts.needTransform = true; | ||
32636 | } | ||
32637 | }; | ||
32638 | |||
32639 | Transform.prototype._destroy = function (err, cb) { | ||
32640 | var _this2 = this; | ||
32641 | |||
32642 | Duplex.prototype._destroy.call(this, err, function (err2) { | ||
32643 | cb(err2); | ||
32644 | _this2.emit('close'); | ||
32645 | }); | ||
32646 | }; | ||
32647 | |||
32648 | function done(stream, er, data) { | ||
32649 | if (er) return stream.emit('error', er); | ||
32650 | |||
32651 | if (data != null) // single equals check for both `null` and `undefined` | ||
32652 | stream.push(data); | ||
32653 | |||
32654 | // if there's nothing in the write buffer, then that means | ||
32655 | // that nothing more will ever be provided | ||
32656 | if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0'); | ||
32657 | |||
32658 | if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming'); | ||
32659 | |||
32660 | return stream.push(null); | ||
32661 | } | ||
32662 | },{"./_stream_duplex":379,"core-util-is":51,"inherits":116}],383:[function(require,module,exports){ | ||
32663 | (function (process,global,setImmediate){ | ||
32664 | // Copyright Joyent, Inc. and other Node contributors. | ||
32665 | // | ||
32666 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
32667 | // copy of this software and associated documentation files (the | ||
32668 | // "Software"), to deal in the Software without restriction, including | ||
32669 | // without limitation the rights to use, copy, modify, merge, publish, | ||
32670 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
32671 | // persons to whom the Software is furnished to do so, subject to the | ||
32672 | // following conditions: | ||
32673 | // | ||
32674 | // The above copyright notice and this permission notice shall be included | ||
32675 | // in all copies or substantial portions of the Software. | ||
32676 | // | ||
32677 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
32678 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
32679 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
32680 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
32681 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
32682 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
32683 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
32684 | |||
32685 | // A bit simpler than readable streams. | ||
32686 | // Implement an async ._write(chunk, encoding, cb), and it'll handle all | ||
32687 | // the drain event emission and buffering. | ||
32688 | |||
32689 | 'use strict'; | ||
32690 | |||
32691 | /*<replacement>*/ | ||
32692 | |||
32693 | var pna = require('process-nextick-args'); | ||
32694 | /*</replacement>*/ | ||
32695 | |||
32696 | module.exports = Writable; | ||
32697 | |||
32698 | /* <replacement> */ | ||
32699 | function WriteReq(chunk, encoding, cb) { | ||
32700 | this.chunk = chunk; | ||
32701 | this.encoding = encoding; | ||
32702 | this.callback = cb; | ||
32703 | this.next = null; | ||
32704 | } | ||
32705 | |||
32706 | // It seems a linked list but it is not | ||
32707 | // there will be only 2 of these for each stream | ||
32708 | function CorkedRequest(state) { | ||
32709 | var _this = this; | ||
32710 | |||
32711 | this.next = null; | ||
32712 | this.entry = null; | ||
32713 | this.finish = function () { | ||
32714 | onCorkedFinish(_this, state); | ||
32715 | }; | ||
32716 | } | ||
32717 | /* </replacement> */ | ||
32718 | |||
32719 | /*<replacement>*/ | ||
32720 | var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick; | ||
32721 | /*</replacement>*/ | ||
32722 | |||
32723 | /*<replacement>*/ | ||
32724 | var Duplex; | ||
32725 | /*</replacement>*/ | ||
32726 | |||
32727 | Writable.WritableState = WritableState; | ||
32728 | |||
32729 | /*<replacement>*/ | ||
32730 | var util = require('core-util-is'); | ||
32731 | util.inherits = require('inherits'); | ||
32732 | /*</replacement>*/ | ||
32733 | |||
32734 | /*<replacement>*/ | ||
32735 | var internalUtil = { | ||
32736 | deprecate: require('util-deprecate') | ||
32737 | }; | ||
32738 | /*</replacement>*/ | ||
32739 | |||
32740 | /*<replacement>*/ | ||
32741 | var Stream = require('./internal/streams/stream'); | ||
32742 | /*</replacement>*/ | ||
32743 | |||
32744 | /*<replacement>*/ | ||
32745 | |||
32746 | var Buffer = require('safe-buffer').Buffer; | ||
32747 | var OurUint8Array = global.Uint8Array || function () {}; | ||
32748 | function _uint8ArrayToBuffer(chunk) { | ||
32749 | return Buffer.from(chunk); | ||
32750 | } | ||
32751 | function _isUint8Array(obj) { | ||
32752 | return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; | ||
32753 | } | ||
32754 | |||
32755 | /*</replacement>*/ | ||
32756 | |||
32757 | var destroyImpl = require('./internal/streams/destroy'); | ||
32758 | |||
32759 | util.inherits(Writable, Stream); | ||
32760 | |||
32761 | function nop() {} | ||
32762 | |||
32763 | function WritableState(options, stream) { | ||
32764 | Duplex = Duplex || require('./_stream_duplex'); | ||
32765 | |||
32766 | options = options || {}; | ||
32767 | |||
32768 | // Duplex streams are both readable and writable, but share | ||
32769 | // the same options object. | ||
32770 | // However, some cases require setting options to different | ||
32771 | // values for the readable and the writable sides of the duplex stream. | ||
32772 | // These options can be provided separately as readableXXX and writableXXX. | ||
32773 | var isDuplex = stream instanceof Duplex; | ||
32774 | |||
32775 | // object stream flag to indicate whether or not this stream | ||
32776 | // contains buffers or objects. | ||
32777 | this.objectMode = !!options.objectMode; | ||
32778 | |||
32779 | if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; | ||
32780 | |||
32781 | // the point at which write() starts returning false | ||
32782 | // Note: 0 is a valid value, means that we always return false if | ||
32783 | // the entire buffer is not flushed immediately on write() | ||
32784 | var hwm = options.highWaterMark; | ||
32785 | var writableHwm = options.writableHighWaterMark; | ||
32786 | var defaultHwm = this.objectMode ? 16 : 16 * 1024; | ||
32787 | |||
32788 | if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm; | ||
32789 | |||
32790 | // cast to ints. | ||
32791 | this.highWaterMark = Math.floor(this.highWaterMark); | ||
32792 | |||
32793 | // if _final has been called | ||
32794 | this.finalCalled = false; | ||
32795 | |||
32796 | // drain event flag. | ||
32797 | this.needDrain = false; | ||
32798 | // at the start of calling end() | ||
32799 | this.ending = false; | ||
32800 | // when end() has been called, and returned | ||
32801 | this.ended = false; | ||
32802 | // when 'finish' is emitted | ||
32803 | this.finished = false; | ||
32804 | |||
32805 | // has it been destroyed | ||
32806 | this.destroyed = false; | ||
32807 | |||
32808 | // should we decode strings into buffers before passing to _write? | ||
32809 | // this is here so that some node-core streams can optimize string | ||
32810 | // handling at a lower level. | ||
32811 | var noDecode = options.decodeStrings === false; | ||
32812 | this.decodeStrings = !noDecode; | ||
32813 | |||
32814 | // Crypto is kind of old and crusty. Historically, its default string | ||
32815 | // encoding is 'binary' so we have to make this configurable. | ||
32816 | // Everything else in the universe uses 'utf8', though. | ||
32817 | this.defaultEncoding = options.defaultEncoding || 'utf8'; | ||
32818 | |||
32819 | // not an actual buffer we keep track of, but a measurement | ||
32820 | // of how much we're waiting to get pushed to some underlying | ||
32821 | // socket or file. | ||
32822 | this.length = 0; | ||
32823 | |||
32824 | // a flag to see when we're in the middle of a write. | ||
32825 | this.writing = false; | ||
32826 | |||
32827 | // when true all writes will be buffered until .uncork() call | ||
32828 | this.corked = 0; | ||
32829 | |||
32830 | // a flag to be able to tell if the onwrite cb is called immediately, | ||
32831 | // or on a later tick. We set this to true at first, because any | ||
32832 | // actions that shouldn't happen until "later" should generally also | ||
32833 | // not happen before the first write call. | ||
32834 | this.sync = true; | ||
32835 | |||
32836 | // a flag to know if we're processing previously buffered items, which | ||
32837 | // may call the _write() callback in the same tick, so that we don't | ||
32838 | // end up in an overlapped onwrite situation. | ||
32839 | this.bufferProcessing = false; | ||
32840 | |||
32841 | // the callback that's passed to _write(chunk,cb) | ||
32842 | this.onwrite = function (er) { | ||
32843 | onwrite(stream, er); | ||
32844 | }; | ||
32845 | |||
32846 | // the callback that the user supplies to write(chunk,encoding,cb) | ||
32847 | this.writecb = null; | ||
32848 | |||
32849 | // the amount that is being written when _write is called. | ||
32850 | this.writelen = 0; | ||
32851 | |||
32852 | this.bufferedRequest = null; | ||
32853 | this.lastBufferedRequest = null; | ||
32854 | |||
32855 | // number of pending user-supplied write callbacks | ||
32856 | // this must be 0 before 'finish' can be emitted | ||
32857 | this.pendingcb = 0; | ||
32858 | |||
32859 | // emit prefinish if the only thing we're waiting for is _write cbs | ||
32860 | // This is relevant for synchronous Transform streams | ||
32861 | this.prefinished = false; | ||
32862 | |||
32863 | // True if the error was already emitted and should not be thrown again | ||
32864 | this.errorEmitted = false; | ||
32865 | |||
32866 | // count buffered requests | ||
32867 | this.bufferedRequestCount = 0; | ||
32868 | |||
32869 | // allocate the first CorkedRequest, there is always | ||
32870 | // one allocated and free to use, and we maintain at most two | ||
32871 | this.corkedRequestsFree = new CorkedRequest(this); | ||
32872 | } | ||
32873 | |||
32874 | WritableState.prototype.getBuffer = function getBuffer() { | ||
32875 | var current = this.bufferedRequest; | ||
32876 | var out = []; | ||
32877 | while (current) { | ||
32878 | out.push(current); | ||
32879 | current = current.next; | ||
32880 | } | ||
32881 | return out; | ||
32882 | }; | ||
32883 | |||
32884 | (function () { | ||
32885 | try { | ||
32886 | Object.defineProperty(WritableState.prototype, 'buffer', { | ||
32887 | get: internalUtil.deprecate(function () { | ||
32888 | return this.getBuffer(); | ||
32889 | }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') | ||
32890 | }); | ||
32891 | } catch (_) {} | ||
32892 | })(); | ||
32893 | |||
32894 | // Test _writableState for inheritance to account for Duplex streams, | ||
32895 | // whose prototype chain only points to Readable. | ||
32896 | var realHasInstance; | ||
32897 | if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { | ||
32898 | realHasInstance = Function.prototype[Symbol.hasInstance]; | ||
32899 | Object.defineProperty(Writable, Symbol.hasInstance, { | ||
32900 | value: function (object) { | ||
32901 | if (realHasInstance.call(this, object)) return true; | ||
32902 | if (this !== Writable) return false; | ||
32903 | |||
32904 | return object && object._writableState instanceof WritableState; | ||
32905 | } | ||
32906 | }); | ||
32907 | } else { | ||
32908 | realHasInstance = function (object) { | ||
32909 | return object instanceof this; | ||
32910 | }; | ||
32911 | } | ||
32912 | |||
32913 | function Writable(options) { | ||
32914 | Duplex = Duplex || require('./_stream_duplex'); | ||
32915 | |||
32916 | // Writable ctor is applied to Duplexes, too. | ||
32917 | // `realHasInstance` is necessary because using plain `instanceof` | ||
32918 | // would return false, as no `_writableState` property is attached. | ||
32919 | |||
32920 | // Trying to use the custom `instanceof` for Writable here will also break the | ||
32921 | // Node.js LazyTransform implementation, which has a non-trivial getter for | ||
32922 | // `_writableState` that would lead to infinite recursion. | ||
32923 | if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { | ||
32924 | return new Writable(options); | ||
32925 | } | ||
32926 | |||
32927 | this._writableState = new WritableState(options, this); | ||
32928 | |||
32929 | // legacy. | ||
32930 | this.writable = true; | ||
32931 | |||
32932 | if (options) { | ||
32933 | if (typeof options.write === 'function') this._write = options.write; | ||
32934 | |||
32935 | if (typeof options.writev === 'function') this._writev = options.writev; | ||
32936 | |||
32937 | if (typeof options.destroy === 'function') this._destroy = options.destroy; | ||
32938 | |||
32939 | if (typeof options.final === 'function') this._final = options.final; | ||
32940 | } | ||
32941 | |||
32942 | Stream.call(this); | ||
32943 | } | ||
32944 | |||
32945 | // Otherwise people can pipe Writable streams, which is just wrong. | ||
32946 | Writable.prototype.pipe = function () { | ||
32947 | this.emit('error', new Error('Cannot pipe, not readable')); | ||
32948 | }; | ||
32949 | |||
32950 | function writeAfterEnd(stream, cb) { | ||
32951 | var er = new Error('write after end'); | ||
32952 | // TODO: defer error events consistently everywhere, not just the cb | ||
32953 | stream.emit('error', er); | ||
32954 | pna.nextTick(cb, er); | ||
32955 | } | ||
32956 | |||
32957 | // Checks that a user-supplied chunk is valid, especially for the particular | ||
32958 | // mode the stream is in. Currently this means that `null` is never accepted | ||
32959 | // and undefined/non-string values are only allowed in object mode. | ||
32960 | function validChunk(stream, state, chunk, cb) { | ||
32961 | var valid = true; | ||
32962 | var er = false; | ||
32963 | |||
32964 | if (chunk === null) { | ||
32965 | er = new TypeError('May not write null values to stream'); | ||
32966 | } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { | ||
32967 | er = new TypeError('Invalid non-string/buffer chunk'); | ||
32968 | } | ||
32969 | if (er) { | ||
32970 | stream.emit('error', er); | ||
32971 | pna.nextTick(cb, er); | ||
32972 | valid = false; | ||
32973 | } | ||
32974 | return valid; | ||
32975 | } | ||
32976 | |||
32977 | Writable.prototype.write = function (chunk, encoding, cb) { | ||
32978 | var state = this._writableState; | ||
32979 | var ret = false; | ||
32980 | var isBuf = !state.objectMode && _isUint8Array(chunk); | ||
32981 | |||
32982 | if (isBuf && !Buffer.isBuffer(chunk)) { | ||
32983 | chunk = _uint8ArrayToBuffer(chunk); | ||
32984 | } | ||
32985 | |||
32986 | if (typeof encoding === 'function') { | ||
32987 | cb = encoding; | ||
32988 | encoding = null; | ||
32989 | } | ||
32990 | |||
32991 | if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; | ||
32992 | |||
32993 | if (typeof cb !== 'function') cb = nop; | ||
32994 | |||
32995 | if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { | ||
32996 | state.pendingcb++; | ||
32997 | ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); | ||
32998 | } | ||
32999 | |||
33000 | return ret; | ||
33001 | }; | ||
33002 | |||
33003 | Writable.prototype.cork = function () { | ||
33004 | var state = this._writableState; | ||
33005 | |||
33006 | state.corked++; | ||
33007 | }; | ||
33008 | |||
33009 | Writable.prototype.uncork = function () { | ||
33010 | var state = this._writableState; | ||
33011 | |||
33012 | if (state.corked) { | ||
33013 | state.corked--; | ||
33014 | |||
33015 | if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); | ||
33016 | } | ||
33017 | }; | ||
33018 | |||
33019 | Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { | ||
33020 | // node::ParseEncoding() requires lower case. | ||
33021 | if (typeof encoding === 'string') encoding = encoding.toLowerCase(); | ||
33022 | 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); | ||
33023 | this._writableState.defaultEncoding = encoding; | ||
33024 | return this; | ||
33025 | }; | ||
33026 | |||
33027 | function decodeChunk(state, chunk, encoding) { | ||
33028 | if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { | ||
33029 | chunk = Buffer.from(chunk, encoding); | ||
33030 | } | ||
33031 | return chunk; | ||
33032 | } | ||
33033 | |||
33034 | Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { | ||
33035 | // making it explicit this property is not enumerable | ||
33036 | // because otherwise some prototype manipulation in | ||
33037 | // userland will fail | ||
33038 | enumerable: false, | ||
33039 | get: function () { | ||
33040 | return this._writableState.highWaterMark; | ||
33041 | } | ||
33042 | }); | ||
33043 | |||
33044 | // if we're already writing something, then just put this | ||
33045 | // in the queue, and wait our turn. Otherwise, call _write | ||
33046 | // If we return false, then we need a drain event, so set that flag. | ||
33047 | function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { | ||
33048 | if (!isBuf) { | ||
33049 | var newChunk = decodeChunk(state, chunk, encoding); | ||
33050 | if (chunk !== newChunk) { | ||
33051 | isBuf = true; | ||
33052 | encoding = 'buffer'; | ||
33053 | chunk = newChunk; | ||
33054 | } | ||
33055 | } | ||
33056 | var len = state.objectMode ? 1 : chunk.length; | ||
33057 | |||
33058 | state.length += len; | ||
33059 | |||
33060 | var ret = state.length < state.highWaterMark; | ||
33061 | // we must ensure that previous needDrain will not be reset to false. | ||
33062 | if (!ret) state.needDrain = true; | ||
33063 | |||
33064 | if (state.writing || state.corked) { | ||
33065 | var last = state.lastBufferedRequest; | ||
33066 | state.lastBufferedRequest = { | ||
33067 | chunk: chunk, | ||
33068 | encoding: encoding, | ||
33069 | isBuf: isBuf, | ||
33070 | callback: cb, | ||
33071 | next: null | ||
33072 | }; | ||
33073 | if (last) { | ||
33074 | last.next = state.lastBufferedRequest; | ||
33075 | } else { | ||
33076 | state.bufferedRequest = state.lastBufferedRequest; | ||
33077 | } | ||
33078 | state.bufferedRequestCount += 1; | ||
33079 | } else { | ||
33080 | doWrite(stream, state, false, len, chunk, encoding, cb); | ||
33081 | } | ||
33082 | |||
33083 | return ret; | ||
33084 | } | ||
33085 | |||
33086 | function doWrite(stream, state, writev, len, chunk, encoding, cb) { | ||
33087 | state.writelen = len; | ||
33088 | state.writecb = cb; | ||
33089 | state.writing = true; | ||
33090 | state.sync = true; | ||
33091 | if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); | ||
33092 | state.sync = false; | ||
33093 | } | ||
33094 | |||
33095 | function onwriteError(stream, state, sync, er, cb) { | ||
33096 | --state.pendingcb; | ||
33097 | |||
33098 | if (sync) { | ||
33099 | // defer the callback if we are being called synchronously | ||
33100 | // to avoid piling up things on the stack | ||
33101 | pna.nextTick(cb, er); | ||
33102 | // this can emit finish, and it will always happen | ||
33103 | // after error | ||
33104 | pna.nextTick(finishMaybe, stream, state); | ||
33105 | stream._writableState.errorEmitted = true; | ||
33106 | stream.emit('error', er); | ||
33107 | } else { | ||
33108 | // the caller expect this to happen before if | ||
33109 | // it is async | ||
33110 | cb(er); | ||
33111 | stream._writableState.errorEmitted = true; | ||
33112 | stream.emit('error', er); | ||
33113 | // this can emit finish, but finish must | ||
33114 | // always follow error | ||
33115 | finishMaybe(stream, state); | ||
33116 | } | ||
33117 | } | ||
33118 | |||
33119 | function onwriteStateUpdate(state) { | ||
33120 | state.writing = false; | ||
33121 | state.writecb = null; | ||
33122 | state.length -= state.writelen; | ||
33123 | state.writelen = 0; | ||
33124 | } | ||
33125 | |||
33126 | function onwrite(stream, er) { | ||
33127 | var state = stream._writableState; | ||
33128 | var sync = state.sync; | ||
33129 | var cb = state.writecb; | ||
33130 | |||
33131 | onwriteStateUpdate(state); | ||
33132 | |||
33133 | if (er) onwriteError(stream, state, sync, er, cb);else { | ||
33134 | // Check if we're actually ready to finish, but don't emit yet | ||
33135 | var finished = needFinish(state); | ||
33136 | |||
33137 | if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { | ||
33138 | clearBuffer(stream, state); | ||
33139 | } | ||
33140 | |||
33141 | if (sync) { | ||
33142 | /*<replacement>*/ | ||
33143 | asyncWrite(afterWrite, stream, state, finished, cb); | ||
33144 | /*</replacement>*/ | ||
33145 | } else { | ||
33146 | afterWrite(stream, state, finished, cb); | ||
33147 | } | ||
33148 | } | ||
33149 | } | ||
33150 | |||
33151 | function afterWrite(stream, state, finished, cb) { | ||
33152 | if (!finished) onwriteDrain(stream, state); | ||
33153 | state.pendingcb--; | ||
33154 | cb(); | ||
33155 | finishMaybe(stream, state); | ||
33156 | } | ||
33157 | |||
33158 | // Must force callback to be called on nextTick, so that we don't | ||
33159 | // emit 'drain' before the write() consumer gets the 'false' return | ||
33160 | // value, and has a chance to attach a 'drain' listener. | ||
33161 | function onwriteDrain(stream, state) { | ||
33162 | if (state.length === 0 && state.needDrain) { | ||
33163 | state.needDrain = false; | ||
33164 | stream.emit('drain'); | ||
33165 | } | ||
33166 | } | ||
33167 | |||
33168 | // if there's something in the buffer waiting, then process it | ||
33169 | function clearBuffer(stream, state) { | ||
33170 | state.bufferProcessing = true; | ||
33171 | var entry = state.bufferedRequest; | ||
33172 | |||
33173 | if (stream._writev && entry && entry.next) { | ||
33174 | // Fast case, write everything using _writev() | ||
33175 | var l = state.bufferedRequestCount; | ||
33176 | var buffer = new Array(l); | ||
33177 | var holder = state.corkedRequestsFree; | ||
33178 | holder.entry = entry; | ||
33179 | |||
33180 | var count = 0; | ||
33181 | var allBuffers = true; | ||
33182 | while (entry) { | ||
33183 | buffer[count] = entry; | ||
33184 | if (!entry.isBuf) allBuffers = false; | ||
33185 | entry = entry.next; | ||
33186 | count += 1; | ||
33187 | } | ||
33188 | buffer.allBuffers = allBuffers; | ||
33189 | |||
33190 | doWrite(stream, state, true, state.length, buffer, '', holder.finish); | ||
33191 | |||
33192 | // doWrite is almost always async, defer these to save a bit of time | ||
33193 | // as the hot path ends with doWrite | ||
33194 | state.pendingcb++; | ||
33195 | state.lastBufferedRequest = null; | ||
33196 | if (holder.next) { | ||
33197 | state.corkedRequestsFree = holder.next; | ||
33198 | holder.next = null; | ||
33199 | } else { | ||
33200 | state.corkedRequestsFree = new CorkedRequest(state); | ||
33201 | } | ||
33202 | state.bufferedRequestCount = 0; | ||
33203 | } else { | ||
33204 | // Slow case, write chunks one-by-one | ||
33205 | while (entry) { | ||
33206 | var chunk = entry.chunk; | ||
33207 | var encoding = entry.encoding; | ||
33208 | var cb = entry.callback; | ||
33209 | var len = state.objectMode ? 1 : chunk.length; | ||
33210 | |||
33211 | doWrite(stream, state, false, len, chunk, encoding, cb); | ||
33212 | entry = entry.next; | ||
33213 | state.bufferedRequestCount--; | ||
33214 | // if we didn't call the onwrite immediately, then | ||
33215 | // it means that we need to wait until it does. | ||
33216 | // also, that means that the chunk and cb are currently | ||
33217 | // being processed, so move the buffer counter past them. | ||
33218 | if (state.writing) { | ||
33219 | break; | ||
33220 | } | ||
33221 | } | ||
33222 | |||
33223 | if (entry === null) state.lastBufferedRequest = null; | ||
33224 | } | ||
33225 | |||
33226 | state.bufferedRequest = entry; | ||
33227 | state.bufferProcessing = false; | ||
33228 | } | ||
33229 | |||
33230 | Writable.prototype._write = function (chunk, encoding, cb) { | ||
33231 | cb(new Error('_write() is not implemented')); | ||
33232 | }; | ||
33233 | |||
33234 | Writable.prototype._writev = null; | ||
33235 | |||
33236 | Writable.prototype.end = function (chunk, encoding, cb) { | ||
33237 | var state = this._writableState; | ||
33238 | |||
33239 | if (typeof chunk === 'function') { | ||
33240 | cb = chunk; | ||
33241 | chunk = null; | ||
33242 | encoding = null; | ||
33243 | } else if (typeof encoding === 'function') { | ||
33244 | cb = encoding; | ||
33245 | encoding = null; | ||
33246 | } | ||
33247 | |||
33248 | if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); | ||
33249 | |||
33250 | // .end() fully uncorks | ||
33251 | if (state.corked) { | ||
33252 | state.corked = 1; | ||
33253 | this.uncork(); | ||
33254 | } | ||
33255 | |||
33256 | // ignore unnecessary end() calls. | ||
33257 | if (!state.ending && !state.finished) endWritable(this, state, cb); | ||
33258 | }; | ||
33259 | |||
33260 | function needFinish(state) { | ||
33261 | return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; | ||
33262 | } | ||
33263 | function callFinal(stream, state) { | ||
33264 | stream._final(function (err) { | ||
33265 | state.pendingcb--; | ||
33266 | if (err) { | ||
33267 | stream.emit('error', err); | ||
33268 | } | ||
33269 | state.prefinished = true; | ||
33270 | stream.emit('prefinish'); | ||
33271 | finishMaybe(stream, state); | ||
33272 | }); | ||
33273 | } | ||
33274 | function prefinish(stream, state) { | ||
33275 | if (!state.prefinished && !state.finalCalled) { | ||
33276 | if (typeof stream._final === 'function') { | ||
33277 | state.pendingcb++; | ||
33278 | state.finalCalled = true; | ||
33279 | pna.nextTick(callFinal, stream, state); | ||
33280 | } else { | ||
33281 | state.prefinished = true; | ||
33282 | stream.emit('prefinish'); | ||
33283 | } | ||
33284 | } | ||
33285 | } | ||
33286 | |||
33287 | function finishMaybe(stream, state) { | ||
33288 | var need = needFinish(state); | ||
33289 | if (need) { | ||
33290 | prefinish(stream, state); | ||
33291 | if (state.pendingcb === 0) { | ||
33292 | state.finished = true; | ||
33293 | stream.emit('finish'); | ||
33294 | } | ||
33295 | } | ||
33296 | return need; | ||
33297 | } | ||
33298 | |||
33299 | function endWritable(stream, state, cb) { | ||
33300 | state.ending = true; | ||
33301 | finishMaybe(stream, state); | ||
33302 | if (cb) { | ||
33303 | if (state.finished) pna.nextTick(cb);else stream.once('finish', cb); | ||
33304 | } | ||
33305 | state.ended = true; | ||
33306 | stream.writable = false; | ||
33307 | } | ||
33308 | |||
33309 | function onCorkedFinish(corkReq, state, err) { | ||
33310 | var entry = corkReq.entry; | ||
33311 | corkReq.entry = null; | ||
33312 | while (entry) { | ||
33313 | var cb = entry.callback; | ||
33314 | state.pendingcb--; | ||
33315 | cb(err); | ||
33316 | entry = entry.next; | ||
33317 | } | ||
33318 | if (state.corkedRequestsFree) { | ||
33319 | state.corkedRequestsFree.next = corkReq; | ||
33320 | } else { | ||
33321 | state.corkedRequestsFree = corkReq; | ||
33322 | } | ||
33323 | } | ||
33324 | |||
33325 | Object.defineProperty(Writable.prototype, 'destroyed', { | ||
33326 | get: function () { | ||
33327 | if (this._writableState === undefined) { | ||
33328 | return false; | ||
33329 | } | ||
33330 | return this._writableState.destroyed; | ||
33331 | }, | ||
33332 | set: function (value) { | ||
33333 | // we ignore the value if the stream | ||
33334 | // has not been initialized yet | ||
33335 | if (!this._writableState) { | ||
33336 | return; | ||
33337 | } | ||
33338 | |||
33339 | // backward compatibility, the user is explicitly | ||
33340 | // managing destroyed | ||
33341 | this._writableState.destroyed = value; | ||
33342 | } | ||
33343 | }); | ||
33344 | |||
33345 | Writable.prototype.destroy = destroyImpl.destroy; | ||
33346 | Writable.prototype._undestroy = destroyImpl.undestroy; | ||
33347 | Writable.prototype._destroy = function (err, cb) { | ||
33348 | this.end(); | ||
33349 | cb(err); | ||
33350 | }; | ||
33351 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate) | ||
33352 | },{"./_stream_duplex":379,"./internal/streams/destroy":385,"./internal/streams/stream":386,"_process":369,"core-util-is":51,"inherits":116,"process-nextick-args":368,"safe-buffer":393,"timers":434,"util-deprecate":436}],384:[function(require,module,exports){ | ||
33353 | 'use strict'; | ||
33354 | |||
33355 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | ||
33356 | |||
33357 | var Buffer = require('safe-buffer').Buffer; | ||
33358 | var util = require('util'); | ||
33359 | |||
33360 | function copyBuffer(src, target, offset) { | ||
33361 | src.copy(target, offset); | ||
33362 | } | ||
33363 | |||
33364 | module.exports = function () { | ||
33365 | function BufferList() { | ||
33366 | _classCallCheck(this, BufferList); | ||
33367 | |||
33368 | this.head = null; | ||
33369 | this.tail = null; | ||
33370 | this.length = 0; | ||
33371 | } | ||
33372 | |||
33373 | BufferList.prototype.push = function push(v) { | ||
33374 | var entry = { data: v, next: null }; | ||
33375 | if (this.length > 0) this.tail.next = entry;else this.head = entry; | ||
33376 | this.tail = entry; | ||
33377 | ++this.length; | ||
33378 | }; | ||
33379 | |||
33380 | BufferList.prototype.unshift = function unshift(v) { | ||
33381 | var entry = { data: v, next: this.head }; | ||
33382 | if (this.length === 0) this.tail = entry; | ||
33383 | this.head = entry; | ||
33384 | ++this.length; | ||
33385 | }; | ||
33386 | |||
33387 | BufferList.prototype.shift = function shift() { | ||
33388 | if (this.length === 0) return; | ||
33389 | var ret = this.head.data; | ||
33390 | if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; | ||
33391 | --this.length; | ||
33392 | return ret; | ||
33393 | }; | ||
33394 | |||
33395 | BufferList.prototype.clear = function clear() { | ||
33396 | this.head = this.tail = null; | ||
33397 | this.length = 0; | ||
33398 | }; | ||
33399 | |||
33400 | BufferList.prototype.join = function join(s) { | ||
33401 | if (this.length === 0) return ''; | ||
33402 | var p = this.head; | ||
33403 | var ret = '' + p.data; | ||
33404 | while (p = p.next) { | ||
33405 | ret += s + p.data; | ||
33406 | }return ret; | ||
33407 | }; | ||
33408 | |||
33409 | BufferList.prototype.concat = function concat(n) { | ||
33410 | if (this.length === 0) return Buffer.alloc(0); | ||
33411 | if (this.length === 1) return this.head.data; | ||
33412 | var ret = Buffer.allocUnsafe(n >>> 0); | ||
33413 | var p = this.head; | ||
33414 | var i = 0; | ||
33415 | while (p) { | ||
33416 | copyBuffer(p.data, ret, i); | ||
33417 | i += p.data.length; | ||
33418 | p = p.next; | ||
33419 | } | ||
33420 | return ret; | ||
33421 | }; | ||
33422 | |||
33423 | return BufferList; | ||
33424 | }(); | ||
33425 | |||
33426 | if (util && util.inspect && util.inspect.custom) { | ||
33427 | module.exports.prototype[util.inspect.custom] = function () { | ||
33428 | var obj = util.inspect({ length: this.length }); | ||
33429 | return this.constructor.name + ' ' + obj; | ||
33430 | }; | ||
33431 | } | ||
33432 | },{"safe-buffer":393,"util":20}],385:[function(require,module,exports){ | ||
33433 | 'use strict'; | ||
33434 | |||
33435 | /*<replacement>*/ | ||
33436 | |||
33437 | var pna = require('process-nextick-args'); | ||
33438 | /*</replacement>*/ | ||
33439 | |||
33440 | // undocumented cb() API, needed for core, not for public API | ||
33441 | function destroy(err, cb) { | ||
33442 | var _this = this; | ||
33443 | |||
33444 | var readableDestroyed = this._readableState && this._readableState.destroyed; | ||
33445 | var writableDestroyed = this._writableState && this._writableState.destroyed; | ||
33446 | |||
33447 | if (readableDestroyed || writableDestroyed) { | ||
33448 | if (cb) { | ||
33449 | cb(err); | ||
33450 | } else if (err && (!this._writableState || !this._writableState.errorEmitted)) { | ||
33451 | pna.nextTick(emitErrorNT, this, err); | ||
33452 | } | ||
33453 | return this; | ||
33454 | } | ||
33455 | |||
33456 | // we set destroyed to true before firing error callbacks in order | ||
33457 | // to make it re-entrance safe in case destroy() is called within callbacks | ||
33458 | |||
33459 | if (this._readableState) { | ||
33460 | this._readableState.destroyed = true; | ||
33461 | } | ||
33462 | |||
33463 | // if this is a duplex stream mark the writable part as destroyed as well | ||
33464 | if (this._writableState) { | ||
33465 | this._writableState.destroyed = true; | ||
33466 | } | ||
33467 | |||
33468 | this._destroy(err || null, function (err) { | ||
33469 | if (!cb && err) { | ||
33470 | pna.nextTick(emitErrorNT, _this, err); | ||
33471 | if (_this._writableState) { | ||
33472 | _this._writableState.errorEmitted = true; | ||
33473 | } | ||
33474 | } else if (cb) { | ||
33475 | cb(err); | ||
33476 | } | ||
33477 | }); | ||
33478 | |||
33479 | return this; | ||
33480 | } | ||
33481 | |||
33482 | function undestroy() { | ||
33483 | if (this._readableState) { | ||
33484 | this._readableState.destroyed = false; | ||
33485 | this._readableState.reading = false; | ||
33486 | this._readableState.ended = false; | ||
33487 | this._readableState.endEmitted = false; | ||
33488 | } | ||
33489 | |||
33490 | if (this._writableState) { | ||
33491 | this._writableState.destroyed = false; | ||
33492 | this._writableState.ended = false; | ||
33493 | this._writableState.ending = false; | ||
33494 | this._writableState.finished = false; | ||
33495 | this._writableState.errorEmitted = false; | ||
33496 | } | ||
33497 | } | ||
33498 | |||
33499 | function emitErrorNT(self, err) { | ||
33500 | self.emit('error', err); | ||
33501 | } | ||
33502 | |||
33503 | module.exports = { | ||
33504 | destroy: destroy, | ||
33505 | undestroy: undestroy | ||
33506 | }; | ||
33507 | },{"process-nextick-args":368}],386:[function(require,module,exports){ | ||
33508 | module.exports = require('events').EventEmitter; | ||
33509 | |||
33510 | },{"events":99}],387:[function(require,module,exports){ | ||
33511 | // Copyright Joyent, Inc. and other Node contributors. | ||
33512 | // | ||
33513 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
33514 | // copy of this software and associated documentation files (the | ||
33515 | // "Software"), to deal in the Software without restriction, including | ||
33516 | // without limitation the rights to use, copy, modify, merge, publish, | ||
33517 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
33518 | // persons to whom the Software is furnished to do so, subject to the | ||
33519 | // following conditions: | ||
33520 | // | ||
33521 | // The above copyright notice and this permission notice shall be included | ||
33522 | // in all copies or substantial portions of the Software. | ||
33523 | // | ||
33524 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
33525 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
33526 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
33527 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
33528 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
33529 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
33530 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
33531 | |||
33532 | 'use strict'; | ||
33533 | |||
33534 | /*<replacement>*/ | ||
33535 | |||
33536 | var Buffer = require('safe-buffer').Buffer; | ||
33537 | /*</replacement>*/ | ||
33538 | |||
33539 | var isEncoding = Buffer.isEncoding || function (encoding) { | ||
33540 | encoding = '' + encoding; | ||
33541 | switch (encoding && encoding.toLowerCase()) { | ||
33542 | 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': | ||
33543 | return true; | ||
33544 | default: | ||
33545 | return false; | ||
33546 | } | ||
33547 | }; | ||
33548 | |||
33549 | function _normalizeEncoding(enc) { | ||
33550 | if (!enc) return 'utf8'; | ||
33551 | var retried; | ||
33552 | while (true) { | ||
33553 | switch (enc) { | ||
33554 | case 'utf8': | ||
33555 | case 'utf-8': | ||
33556 | return 'utf8'; | ||
33557 | case 'ucs2': | ||
33558 | case 'ucs-2': | ||
33559 | case 'utf16le': | ||
33560 | case 'utf-16le': | ||
33561 | return 'utf16le'; | ||
33562 | case 'latin1': | ||
33563 | case 'binary': | ||
33564 | return 'latin1'; | ||
33565 | case 'base64': | ||
33566 | case 'ascii': | ||
33567 | case 'hex': | ||
33568 | return enc; | ||
33569 | default: | ||
33570 | if (retried) return; // undefined | ||
33571 | enc = ('' + enc).toLowerCase(); | ||
33572 | retried = true; | ||
33573 | } | ||
33574 | } | ||
33575 | }; | ||
33576 | |||
33577 | // Do not cache `Buffer.isEncoding` when checking encoding names as some | ||
33578 | // modules monkey-patch it to support additional encodings | ||
33579 | function normalizeEncoding(enc) { | ||
33580 | var nenc = _normalizeEncoding(enc); | ||
33581 | if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); | ||
33582 | return nenc || enc; | ||
33583 | } | ||
33584 | |||
33585 | // StringDecoder provides an interface for efficiently splitting a series of | ||
33586 | // buffers into a series of JS strings without breaking apart multi-byte | ||
33587 | // characters. | ||
33588 | exports.StringDecoder = StringDecoder; | ||
33589 | function StringDecoder(encoding) { | ||
33590 | this.encoding = normalizeEncoding(encoding); | ||
33591 | var nb; | ||
33592 | switch (this.encoding) { | ||
33593 | case 'utf16le': | ||
33594 | this.text = utf16Text; | ||
33595 | this.end = utf16End; | ||
33596 | nb = 4; | ||
33597 | break; | ||
33598 | case 'utf8': | ||
33599 | this.fillLast = utf8FillLast; | ||
33600 | nb = 4; | ||
33601 | break; | ||
33602 | case 'base64': | ||
33603 | this.text = base64Text; | ||
33604 | this.end = base64End; | ||
33605 | nb = 3; | ||
33606 | break; | ||
33607 | default: | ||
33608 | this.write = simpleWrite; | ||
33609 | this.end = simpleEnd; | ||
33610 | return; | ||
33611 | } | ||
33612 | this.lastNeed = 0; | ||
33613 | this.lastTotal = 0; | ||
33614 | this.lastChar = Buffer.allocUnsafe(nb); | ||
33615 | } | ||
33616 | |||
33617 | StringDecoder.prototype.write = function (buf) { | ||
33618 | if (buf.length === 0) return ''; | ||
33619 | var r; | ||
33620 | var i; | ||
33621 | if (this.lastNeed) { | ||
33622 | r = this.fillLast(buf); | ||
33623 | if (r === undefined) return ''; | ||
33624 | i = this.lastNeed; | ||
33625 | this.lastNeed = 0; | ||
33626 | } else { | ||
33627 | i = 0; | ||
33628 | } | ||
33629 | if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); | ||
33630 | return r || ''; | ||
33631 | }; | ||
33632 | |||
33633 | StringDecoder.prototype.end = utf8End; | ||
33634 | |||
33635 | // Returns only complete characters in a Buffer | ||
33636 | StringDecoder.prototype.text = utf8Text; | ||
33637 | |||
33638 | // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer | ||
33639 | StringDecoder.prototype.fillLast = function (buf) { | ||
33640 | if (this.lastNeed <= buf.length) { | ||
33641 | buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); | ||
33642 | return this.lastChar.toString(this.encoding, 0, this.lastTotal); | ||
33643 | } | ||
33644 | buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); | ||
33645 | this.lastNeed -= buf.length; | ||
33646 | }; | ||
33647 | |||
33648 | // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a | ||
33649 | // continuation byte. If an invalid byte is detected, -2 is returned. | ||
33650 | function utf8CheckByte(byte) { | ||
33651 | if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; | ||
33652 | return byte >> 6 === 0x02 ? -1 : -2; | ||
33653 | } | ||
33654 | |||
33655 | // Checks at most 3 bytes at the end of a Buffer in order to detect an | ||
33656 | // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) | ||
33657 | // needed to complete the UTF-8 character (if applicable) are returned. | ||
33658 | function utf8CheckIncomplete(self, buf, i) { | ||
33659 | var j = buf.length - 1; | ||
33660 | if (j < i) return 0; | ||
33661 | var nb = utf8CheckByte(buf[j]); | ||
33662 | if (nb >= 0) { | ||
33663 | if (nb > 0) self.lastNeed = nb - 1; | ||
33664 | return nb; | ||
33665 | } | ||
33666 | if (--j < i || nb === -2) return 0; | ||
33667 | nb = utf8CheckByte(buf[j]); | ||
33668 | if (nb >= 0) { | ||
33669 | if (nb > 0) self.lastNeed = nb - 2; | ||
33670 | return nb; | ||
33671 | } | ||
33672 | if (--j < i || nb === -2) return 0; | ||
33673 | nb = utf8CheckByte(buf[j]); | ||
33674 | if (nb >= 0) { | ||
33675 | if (nb > 0) { | ||
33676 | if (nb === 2) nb = 0;else self.lastNeed = nb - 3; | ||
33677 | } | ||
33678 | return nb; | ||
33679 | } | ||
33680 | return 0; | ||
33681 | } | ||
33682 | |||
33683 | // Validates as many continuation bytes for a multi-byte UTF-8 character as | ||
33684 | // needed or are available. If we see a non-continuation byte where we expect | ||
33685 | // one, we "replace" the validated continuation bytes we've seen so far with | ||
33686 | // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding | ||
33687 | // behavior. The continuation byte check is included three times in the case | ||
33688 | // where all of the continuation bytes for a character exist in the same buffer. | ||
33689 | // It is also done this way as a slight performance increase instead of using a | ||
33690 | // loop. | ||
33691 | function utf8CheckExtraBytes(self, buf, p) { | ||
33692 | if ((buf[0] & 0xC0) !== 0x80) { | ||
33693 | self.lastNeed = 0; | ||
33694 | return '\ufffd'; | ||
33695 | } | ||
33696 | if (self.lastNeed > 1 && buf.length > 1) { | ||
33697 | if ((buf[1] & 0xC0) !== 0x80) { | ||
33698 | self.lastNeed = 1; | ||
33699 | return '\ufffd'; | ||
33700 | } | ||
33701 | if (self.lastNeed > 2 && buf.length > 2) { | ||
33702 | if ((buf[2] & 0xC0) !== 0x80) { | ||
33703 | self.lastNeed = 2; | ||
33704 | return '\ufffd'; | ||
33705 | } | ||
33706 | } | ||
33707 | } | ||
33708 | } | ||
33709 | |||
33710 | // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. | ||
33711 | function utf8FillLast(buf) { | ||
33712 | var p = this.lastTotal - this.lastNeed; | ||
33713 | var r = utf8CheckExtraBytes(this, buf, p); | ||
33714 | if (r !== undefined) return r; | ||
33715 | if (this.lastNeed <= buf.length) { | ||
33716 | buf.copy(this.lastChar, p, 0, this.lastNeed); | ||
33717 | return this.lastChar.toString(this.encoding, 0, this.lastTotal); | ||
33718 | } | ||
33719 | buf.copy(this.lastChar, p, 0, buf.length); | ||
33720 | this.lastNeed -= buf.length; | ||
33721 | } | ||
33722 | |||
33723 | // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a | ||
33724 | // partial character, the character's bytes are buffered until the required | ||
33725 | // number of bytes are available. | ||
33726 | function utf8Text(buf, i) { | ||
33727 | var total = utf8CheckIncomplete(this, buf, i); | ||
33728 | if (!this.lastNeed) return buf.toString('utf8', i); | ||
33729 | this.lastTotal = total; | ||
33730 | var end = buf.length - (total - this.lastNeed); | ||
33731 | buf.copy(this.lastChar, 0, end); | ||
33732 | return buf.toString('utf8', i, end); | ||
33733 | } | ||
33734 | |||
33735 | // For UTF-8, a replacement character is added when ending on a partial | ||
33736 | // character. | ||
33737 | function utf8End(buf) { | ||
33738 | var r = buf && buf.length ? this.write(buf) : ''; | ||
33739 | if (this.lastNeed) return r + '\ufffd'; | ||
33740 | return r; | ||
33741 | } | ||
33742 | |||
33743 | // UTF-16LE typically needs two bytes per character, but even if we have an even | ||
33744 | // number of bytes available, we need to check if we end on a leading/high | ||
33745 | // surrogate. In that case, we need to wait for the next two bytes in order to | ||
33746 | // decode the last character properly. | ||
33747 | function utf16Text(buf, i) { | ||
33748 | if ((buf.length - i) % 2 === 0) { | ||
33749 | var r = buf.toString('utf16le', i); | ||
33750 | if (r) { | ||
33751 | var c = r.charCodeAt(r.length - 1); | ||
33752 | if (c >= 0xD800 && c <= 0xDBFF) { | ||
33753 | this.lastNeed = 2; | ||
33754 | this.lastTotal = 4; | ||
33755 | this.lastChar[0] = buf[buf.length - 2]; | ||
33756 | this.lastChar[1] = buf[buf.length - 1]; | ||
33757 | return r.slice(0, -1); | ||
33758 | } | ||
33759 | } | ||
33760 | return r; | ||
33761 | } | ||
33762 | this.lastNeed = 1; | ||
33763 | this.lastTotal = 2; | ||
33764 | this.lastChar[0] = buf[buf.length - 1]; | ||
33765 | return buf.toString('utf16le', i, buf.length - 1); | ||
33766 | } | ||
33767 | |||
33768 | // For UTF-16LE we do not explicitly append special replacement characters if we | ||
33769 | // end on a partial character, we simply let v8 handle that. | ||
33770 | function utf16End(buf) { | ||
33771 | var r = buf && buf.length ? this.write(buf) : ''; | ||
33772 | if (this.lastNeed) { | ||
33773 | var end = this.lastTotal - this.lastNeed; | ||
33774 | return r + this.lastChar.toString('utf16le', 0, end); | ||
33775 | } | ||
33776 | return r; | ||
33777 | } | ||
33778 | |||
33779 | function base64Text(buf, i) { | ||
33780 | var n = (buf.length - i) % 3; | ||
33781 | if (n === 0) return buf.toString('base64', i); | ||
33782 | this.lastNeed = 3 - n; | ||
33783 | this.lastTotal = 3; | ||
33784 | if (n === 1) { | ||
33785 | this.lastChar[0] = buf[buf.length - 1]; | ||
33786 | } else { | ||
33787 | this.lastChar[0] = buf[buf.length - 2]; | ||
33788 | this.lastChar[1] = buf[buf.length - 1]; | ||
33789 | } | ||
33790 | return buf.toString('base64', i, buf.length - n); | ||
33791 | } | ||
33792 | |||
33793 | function base64End(buf) { | ||
33794 | var r = buf && buf.length ? this.write(buf) : ''; | ||
33795 | if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); | ||
33796 | return r; | ||
33797 | } | ||
33798 | |||
33799 | // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) | ||
33800 | function simpleWrite(buf) { | ||
33801 | return buf.toString(this.encoding); | ||
33802 | } | ||
33803 | |||
33804 | function simpleEnd(buf) { | ||
33805 | return buf && buf.length ? this.write(buf) : ''; | ||
33806 | } | ||
33807 | },{"safe-buffer":393}],388:[function(require,module,exports){ | ||
33808 | module.exports = require('./readable').PassThrough | ||
33809 | |||
33810 | },{"./readable":389}],389:[function(require,module,exports){ | ||
33811 | exports = module.exports = require('./lib/_stream_readable.js'); | ||
33812 | exports.Stream = exports; | ||
33813 | exports.Readable = exports; | ||
33814 | exports.Writable = require('./lib/_stream_writable.js'); | ||
33815 | exports.Duplex = require('./lib/_stream_duplex.js'); | ||
33816 | exports.Transform = require('./lib/_stream_transform.js'); | ||
33817 | exports.PassThrough = require('./lib/_stream_passthrough.js'); | ||
33818 | |||
33819 | },{"./lib/_stream_duplex.js":379,"./lib/_stream_passthrough.js":380,"./lib/_stream_readable.js":381,"./lib/_stream_transform.js":382,"./lib/_stream_writable.js":383}],390:[function(require,module,exports){ | ||
33820 | module.exports = require('./readable').Transform | ||
33821 | |||
33822 | },{"./readable":389}],391:[function(require,module,exports){ | ||
33823 | module.exports = require('./lib/_stream_writable.js'); | ||
33824 | |||
33825 | },{"./lib/_stream_writable.js":383}],392:[function(require,module,exports){ | ||
33826 | 'use strict' | ||
33827 | var Buffer = require('buffer').Buffer | ||
33828 | var inherits = require('inherits') | ||
33829 | var HashBase = require('hash-base') | ||
33830 | |||
33831 | var ARRAY16 = new Array(16) | ||
33832 | |||
33833 | var zl = [ | ||
33834 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, | ||
33835 | 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, | ||
33836 | 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, | ||
33837 | 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, | ||
33838 | 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 | ||
33839 | ] | ||
33840 | |||
33841 | var zr = [ | ||
33842 | 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, | ||
33843 | 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, | ||
33844 | 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, | ||
33845 | 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, | ||
33846 | 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 | ||
33847 | ] | ||
33848 | |||
33849 | var sl = [ | ||
33850 | 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, | ||
33851 | 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, | ||
33852 | 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, | ||
33853 | 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, | ||
33854 | 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 | ||
33855 | ] | ||
33856 | |||
33857 | var sr = [ | ||
33858 | 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, | ||
33859 | 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, | ||
33860 | 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, | ||
33861 | 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, | ||
33862 | 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 | ||
33863 | ] | ||
33864 | |||
33865 | var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e] | ||
33866 | var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000] | ||
33867 | |||
33868 | function RIPEMD160 () { | ||
33869 | HashBase.call(this, 64) | ||
33870 | |||
33871 | // state | ||
33872 | this._a = 0x67452301 | ||
33873 | this._b = 0xefcdab89 | ||
33874 | this._c = 0x98badcfe | ||
33875 | this._d = 0x10325476 | ||
33876 | this._e = 0xc3d2e1f0 | ||
33877 | } | ||
33878 | |||
33879 | inherits(RIPEMD160, HashBase) | ||
33880 | |||
33881 | RIPEMD160.prototype._update = function () { | ||
33882 | var words = ARRAY16 | ||
33883 | for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4) | ||
33884 | |||
33885 | var al = this._a | 0 | ||
33886 | var bl = this._b | 0 | ||
33887 | var cl = this._c | 0 | ||
33888 | var dl = this._d | 0 | ||
33889 | var el = this._e | 0 | ||
33890 | |||
33891 | var ar = this._a | 0 | ||
33892 | var br = this._b | 0 | ||
33893 | var cr = this._c | 0 | ||
33894 | var dr = this._d | 0 | ||
33895 | var er = this._e | 0 | ||
33896 | |||
33897 | // computation | ||
33898 | for (var i = 0; i < 80; i += 1) { | ||
33899 | var tl | ||
33900 | var tr | ||
33901 | if (i < 16) { | ||
33902 | tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]) | ||
33903 | tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]) | ||
33904 | } else if (i < 32) { | ||
33905 | tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]) | ||
33906 | tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]) | ||
33907 | } else if (i < 48) { | ||
33908 | tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]) | ||
33909 | tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]) | ||
33910 | } else if (i < 64) { | ||
33911 | tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]) | ||
33912 | tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]) | ||
33913 | } else { // if (i<80) { | ||
33914 | tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]) | ||
33915 | tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]) | ||
33916 | } | ||
33917 | |||
33918 | al = el | ||
33919 | el = dl | ||
33920 | dl = rotl(cl, 10) | ||
33921 | cl = bl | ||
33922 | bl = tl | ||
33923 | |||
33924 | ar = er | ||
33925 | er = dr | ||
33926 | dr = rotl(cr, 10) | ||
33927 | cr = br | ||
33928 | br = tr | ||
33929 | } | ||
33930 | |||
33931 | // update state | ||
33932 | var t = (this._b + cl + dr) | 0 | ||
33933 | this._b = (this._c + dl + er) | 0 | ||
33934 | this._c = (this._d + el + ar) | 0 | ||
33935 | this._d = (this._e + al + br) | 0 | ||
33936 | this._e = (this._a + bl + cr) | 0 | ||
33937 | this._a = t | ||
33938 | } | ||
33939 | |||
33940 | RIPEMD160.prototype._digest = function () { | ||
33941 | // create padding and handle blocks | ||
33942 | this._block[this._blockOffset++] = 0x80 | ||
33943 | if (this._blockOffset > 56) { | ||
33944 | this._block.fill(0, this._blockOffset, 64) | ||
33945 | this._update() | ||
33946 | this._blockOffset = 0 | ||
33947 | } | ||
33948 | |||
33949 | this._block.fill(0, this._blockOffset, 56) | ||
33950 | this._block.writeUInt32LE(this._length[0], 56) | ||
33951 | this._block.writeUInt32LE(this._length[1], 60) | ||
33952 | this._update() | ||
33953 | |||
33954 | // produce result | ||
33955 | var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20) | ||
33956 | buffer.writeInt32LE(this._a, 0) | ||
33957 | buffer.writeInt32LE(this._b, 4) | ||
33958 | buffer.writeInt32LE(this._c, 8) | ||
33959 | buffer.writeInt32LE(this._d, 12) | ||
33960 | buffer.writeInt32LE(this._e, 16) | ||
33961 | return buffer | ||
33962 | } | ||
33963 | |||
33964 | function rotl (x, n) { | ||
33965 | return (x << n) | (x >>> (32 - n)) | ||
33966 | } | ||
33967 | |||
33968 | function fn1 (a, b, c, d, e, m, k, s) { | ||
33969 | return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0 | ||
33970 | } | ||
33971 | |||
33972 | function fn2 (a, b, c, d, e, m, k, s) { | ||
33973 | return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0 | ||
33974 | } | ||
33975 | |||
33976 | function fn3 (a, b, c, d, e, m, k, s) { | ||
33977 | return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0 | ||
33978 | } | ||
33979 | |||
33980 | function fn4 (a, b, c, d, e, m, k, s) { | ||
33981 | return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0 | ||
33982 | } | ||
33983 | |||
33984 | function fn5 (a, b, c, d, e, m, k, s) { | ||
33985 | return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0 | ||
33986 | } | ||
33987 | |||
33988 | module.exports = RIPEMD160 | ||
33989 | |||
33990 | },{"buffer":49,"hash-base":101,"inherits":116}],393:[function(require,module,exports){ | ||
33991 | /* eslint-disable node/no-deprecated-api */ | ||
33992 | var buffer = require('buffer') | ||
33993 | var Buffer = buffer.Buffer | ||
33994 | |||
33995 | // alternative to using Object.keys for old browsers | ||
33996 | function copyProps (src, dst) { | ||
33997 | for (var key in src) { | ||
33998 | dst[key] = src[key] | ||
33999 | } | ||
34000 | } | ||
34001 | if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { | ||
34002 | module.exports = buffer | ||
34003 | } else { | ||
34004 | // Copy properties from require('buffer') | ||
34005 | copyProps(buffer, exports) | ||
34006 | exports.Buffer = SafeBuffer | ||
34007 | } | ||
34008 | |||
34009 | function SafeBuffer (arg, encodingOrOffset, length) { | ||
34010 | return Buffer(arg, encodingOrOffset, length) | ||
34011 | } | ||
34012 | |||
34013 | // Copy static methods from Buffer | ||
34014 | copyProps(Buffer, SafeBuffer) | ||
34015 | |||
34016 | SafeBuffer.from = function (arg, encodingOrOffset, length) { | ||
34017 | if (typeof arg === 'number') { | ||
34018 | throw new TypeError('Argument must not be a number') | ||
34019 | } | ||
34020 | return Buffer(arg, encodingOrOffset, length) | ||
34021 | } | ||
34022 | |||
34023 | SafeBuffer.alloc = function (size, fill, encoding) { | ||
34024 | if (typeof size !== 'number') { | ||
34025 | throw new TypeError('Argument must be a number') | ||
34026 | } | ||
34027 | var buf = Buffer(size) | ||
34028 | if (fill !== undefined) { | ||
34029 | if (typeof encoding === 'string') { | ||
34030 | buf.fill(fill, encoding) | ||
34031 | } else { | ||
34032 | buf.fill(fill) | ||
34033 | } | ||
34034 | } else { | ||
34035 | buf.fill(0) | ||
34036 | } | ||
34037 | return buf | ||
34038 | } | ||
34039 | |||
34040 | SafeBuffer.allocUnsafe = function (size) { | ||
34041 | if (typeof size !== 'number') { | ||
34042 | throw new TypeError('Argument must be a number') | ||
34043 | } | ||
34044 | return Buffer(size) | ||
34045 | } | ||
34046 | |||
34047 | SafeBuffer.allocUnsafeSlow = function (size) { | ||
34048 | if (typeof size !== 'number') { | ||
34049 | throw new TypeError('Argument must be a number') | ||
34050 | } | ||
34051 | return buffer.SlowBuffer(size) | ||
34052 | } | ||
34053 | |||
34054 | },{"buffer":49}],394:[function(require,module,exports){ | ||
34055 | var Buffer = require('safe-buffer').Buffer | ||
34056 | |||
34057 | // prototype class for hash functions | ||
34058 | function Hash (blockSize, finalSize) { | ||
34059 | this._block = Buffer.alloc(blockSize) | ||
34060 | this._finalSize = finalSize | ||
34061 | this._blockSize = blockSize | ||
34062 | this._len = 0 | ||
34063 | } | ||
34064 | |||
34065 | Hash.prototype.update = function (data, enc) { | ||
34066 | if (typeof data === 'string') { | ||
34067 | enc = enc || 'utf8' | ||
34068 | data = Buffer.from(data, enc) | ||
34069 | } | ||
34070 | |||
34071 | var block = this._block | ||
34072 | var blockSize = this._blockSize | ||
34073 | var length = data.length | ||
34074 | var accum = this._len | ||
34075 | |||
34076 | for (var offset = 0; offset < length;) { | ||
34077 | var assigned = accum % blockSize | ||
34078 | var remainder = Math.min(length - offset, blockSize - assigned) | ||
34079 | |||
34080 | for (var i = 0; i < remainder; i++) { | ||
34081 | block[assigned + i] = data[offset + i] | ||
34082 | } | ||
34083 | |||
34084 | accum += remainder | ||
34085 | offset += remainder | ||
34086 | |||
34087 | if ((accum % blockSize) === 0) { | ||
34088 | this._update(block) | ||
34089 | } | ||
34090 | } | ||
34091 | |||
34092 | this._len += length | ||
34093 | return this | ||
34094 | } | ||
34095 | |||
34096 | Hash.prototype.digest = function (enc) { | ||
34097 | var rem = this._len % this._blockSize | ||
34098 | |||
34099 | this._block[rem] = 0x80 | ||
34100 | |||
34101 | // zero (rem + 1) trailing bits, where (rem + 1) is the smallest | ||
34102 | // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize | ||
34103 | this._block.fill(0, rem + 1) | ||
34104 | |||
34105 | if (rem >= this._finalSize) { | ||
34106 | this._update(this._block) | ||
34107 | this._block.fill(0) | ||
34108 | } | ||
34109 | |||
34110 | var bits = this._len * 8 | ||
34111 | |||
34112 | // uint32 | ||
34113 | if (bits <= 0xffffffff) { | ||
34114 | this._block.writeUInt32BE(bits, this._blockSize - 4) | ||
34115 | |||
34116 | // uint64 | ||
34117 | } else { | ||
34118 | var lowBits = (bits & 0xffffffff) >>> 0 | ||
34119 | var highBits = (bits - lowBits) / 0x100000000 | ||
34120 | |||
34121 | this._block.writeUInt32BE(highBits, this._blockSize - 8) | ||
34122 | this._block.writeUInt32BE(lowBits, this._blockSize - 4) | ||
34123 | } | ||
34124 | |||
34125 | this._update(this._block) | ||
34126 | var hash = this._hash() | ||
34127 | |||
34128 | return enc ? hash.toString(enc) : hash | ||
34129 | } | ||
34130 | |||
34131 | Hash.prototype._update = function () { | ||
34132 | throw new Error('_update must be implemented by subclass') | ||
34133 | } | ||
34134 | |||
34135 | module.exports = Hash | ||
34136 | |||
34137 | },{"safe-buffer":393}],395:[function(require,module,exports){ | ||
34138 | var exports = module.exports = function SHA (algorithm) { | ||
34139 | algorithm = algorithm.toLowerCase() | ||
34140 | |||
34141 | var Algorithm = exports[algorithm] | ||
34142 | if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)') | ||
34143 | |||
34144 | return new Algorithm() | ||
34145 | } | ||
34146 | |||
34147 | exports.sha = require('./sha') | ||
34148 | exports.sha1 = require('./sha1') | ||
34149 | exports.sha224 = require('./sha224') | ||
34150 | exports.sha256 = require('./sha256') | ||
34151 | exports.sha384 = require('./sha384') | ||
34152 | exports.sha512 = require('./sha512') | ||
34153 | |||
34154 | },{"./sha":396,"./sha1":397,"./sha224":398,"./sha256":399,"./sha384":400,"./sha512":401}],396:[function(require,module,exports){ | ||
34155 | /* | ||
34156 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined | ||
34157 | * in FIPS PUB 180-1 | ||
34158 | * This source code is derived from sha1.js of the same repository. | ||
34159 | * The difference between SHA-0 and SHA-1 is just a bitwise rotate left | ||
34160 | * operation was added. | ||
34161 | */ | ||
34162 | |||
34163 | var inherits = require('inherits') | ||
34164 | var Hash = require('./hash') | ||
34165 | var Buffer = require('safe-buffer').Buffer | ||
34166 | |||
34167 | var K = [ | ||
34168 | 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 | ||
34169 | ] | ||
34170 | |||
34171 | var W = new Array(80) | ||
34172 | |||
34173 | function Sha () { | ||
34174 | this.init() | ||
34175 | this._w = W | ||
34176 | |||
34177 | Hash.call(this, 64, 56) | ||
34178 | } | ||
34179 | |||
34180 | inherits(Sha, Hash) | ||
34181 | |||
34182 | Sha.prototype.init = function () { | ||
34183 | this._a = 0x67452301 | ||
34184 | this._b = 0xefcdab89 | ||
34185 | this._c = 0x98badcfe | ||
34186 | this._d = 0x10325476 | ||
34187 | this._e = 0xc3d2e1f0 | ||
34188 | |||
34189 | return this | ||
34190 | } | ||
34191 | |||
34192 | function rotl5 (num) { | ||
34193 | return (num << 5) | (num >>> 27) | ||
34194 | } | ||
34195 | |||
34196 | function rotl30 (num) { | ||
34197 | return (num << 30) | (num >>> 2) | ||
34198 | } | ||
34199 | |||
34200 | function ft (s, b, c, d) { | ||
34201 | if (s === 0) return (b & c) | ((~b) & d) | ||
34202 | if (s === 2) return (b & c) | (b & d) | (c & d) | ||
34203 | return b ^ c ^ d | ||
34204 | } | ||
34205 | |||
34206 | Sha.prototype._update = function (M) { | ||
34207 | var W = this._w | ||
34208 | |||
34209 | var a = this._a | 0 | ||
34210 | var b = this._b | 0 | ||
34211 | var c = this._c | 0 | ||
34212 | var d = this._d | 0 | ||
34213 | var e = this._e | 0 | ||
34214 | |||
34215 | for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) | ||
34216 | for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16] | ||
34217 | |||
34218 | for (var j = 0; j < 80; ++j) { | ||
34219 | var s = ~~(j / 20) | ||
34220 | var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0 | ||
34221 | |||
34222 | e = d | ||
34223 | d = c | ||
34224 | c = rotl30(b) | ||
34225 | b = a | ||
34226 | a = t | ||
34227 | } | ||
34228 | |||
34229 | this._a = (a + this._a) | 0 | ||
34230 | this._b = (b + this._b) | 0 | ||
34231 | this._c = (c + this._c) | 0 | ||
34232 | this._d = (d + this._d) | 0 | ||
34233 | this._e = (e + this._e) | 0 | ||
34234 | } | ||
34235 | |||
34236 | Sha.prototype._hash = function () { | ||
34237 | var H = Buffer.allocUnsafe(20) | ||
34238 | |||
34239 | H.writeInt32BE(this._a | 0, 0) | ||
34240 | H.writeInt32BE(this._b | 0, 4) | ||
34241 | H.writeInt32BE(this._c | 0, 8) | ||
34242 | H.writeInt32BE(this._d | 0, 12) | ||
34243 | H.writeInt32BE(this._e | 0, 16) | ||
34244 | |||
34245 | return H | ||
34246 | } | ||
34247 | |||
34248 | module.exports = Sha | ||
34249 | |||
34250 | },{"./hash":394,"inherits":116,"safe-buffer":393}],397:[function(require,module,exports){ | ||
34251 | /* | ||
34252 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined | ||
34253 | * in FIPS PUB 180-1 | ||
34254 | * Version 2.1a Copyright Paul Johnston 2000 - 2002. | ||
34255 | * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet | ||
34256 | * Distributed under the BSD License | ||
34257 | * See http://pajhome.org.uk/crypt/md5 for details. | ||
34258 | */ | ||
34259 | |||
34260 | var inherits = require('inherits') | ||
34261 | var Hash = require('./hash') | ||
34262 | var Buffer = require('safe-buffer').Buffer | ||
34263 | |||
34264 | var K = [ | ||
34265 | 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 | ||
34266 | ] | ||
34267 | |||
34268 | var W = new Array(80) | ||
34269 | |||
34270 | function Sha1 () { | ||
34271 | this.init() | ||
34272 | this._w = W | ||
34273 | |||
34274 | Hash.call(this, 64, 56) | ||
34275 | } | ||
34276 | |||
34277 | inherits(Sha1, Hash) | ||
34278 | |||
34279 | Sha1.prototype.init = function () { | ||
34280 | this._a = 0x67452301 | ||
34281 | this._b = 0xefcdab89 | ||
34282 | this._c = 0x98badcfe | ||
34283 | this._d = 0x10325476 | ||
34284 | this._e = 0xc3d2e1f0 | ||
34285 | |||
34286 | return this | ||
34287 | } | ||
34288 | |||
34289 | function rotl1 (num) { | ||
34290 | return (num << 1) | (num >>> 31) | ||
34291 | } | ||
34292 | |||
34293 | function rotl5 (num) { | ||
34294 | return (num << 5) | (num >>> 27) | ||
34295 | } | ||
34296 | |||
34297 | function rotl30 (num) { | ||
34298 | return (num << 30) | (num >>> 2) | ||
34299 | } | ||
34300 | |||
34301 | function ft (s, b, c, d) { | ||
34302 | if (s === 0) return (b & c) | ((~b) & d) | ||
34303 | if (s === 2) return (b & c) | (b & d) | (c & d) | ||
34304 | return b ^ c ^ d | ||
34305 | } | ||
34306 | |||
34307 | Sha1.prototype._update = function (M) { | ||
34308 | var W = this._w | ||
34309 | |||
34310 | var a = this._a | 0 | ||
34311 | var b = this._b | 0 | ||
34312 | var c = this._c | 0 | ||
34313 | var d = this._d | 0 | ||
34314 | var e = this._e | 0 | ||
34315 | |||
34316 | for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) | ||
34317 | for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]) | ||
34318 | |||
34319 | for (var j = 0; j < 80; ++j) { | ||
34320 | var s = ~~(j / 20) | ||
34321 | var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0 | ||
34322 | |||
34323 | e = d | ||
34324 | d = c | ||
34325 | c = rotl30(b) | ||
34326 | b = a | ||
34327 | a = t | ||
34328 | } | ||
34329 | |||
34330 | this._a = (a + this._a) | 0 | ||
34331 | this._b = (b + this._b) | 0 | ||
34332 | this._c = (c + this._c) | 0 | ||
34333 | this._d = (d + this._d) | 0 | ||
34334 | this._e = (e + this._e) | 0 | ||
34335 | } | ||
34336 | |||
34337 | Sha1.prototype._hash = function () { | ||
34338 | var H = Buffer.allocUnsafe(20) | ||
34339 | |||
34340 | H.writeInt32BE(this._a | 0, 0) | ||
34341 | H.writeInt32BE(this._b | 0, 4) | ||
34342 | H.writeInt32BE(this._c | 0, 8) | ||
34343 | H.writeInt32BE(this._d | 0, 12) | ||
34344 | H.writeInt32BE(this._e | 0, 16) | ||
34345 | |||
34346 | return H | ||
34347 | } | ||
34348 | |||
34349 | module.exports = Sha1 | ||
34350 | |||
34351 | },{"./hash":394,"inherits":116,"safe-buffer":393}],398:[function(require,module,exports){ | ||
34352 | /** | ||
34353 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined | ||
34354 | * in FIPS 180-2 | ||
34355 | * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. | ||
34356 | * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet | ||
34357 | * | ||
34358 | */ | ||
34359 | |||
34360 | var inherits = require('inherits') | ||
34361 | var Sha256 = require('./sha256') | ||
34362 | var Hash = require('./hash') | ||
34363 | var Buffer = require('safe-buffer').Buffer | ||
34364 | |||
34365 | var W = new Array(64) | ||
34366 | |||
34367 | function Sha224 () { | ||
34368 | this.init() | ||
34369 | |||
34370 | this._w = W // new Array(64) | ||
34371 | |||
34372 | Hash.call(this, 64, 56) | ||
34373 | } | ||
34374 | |||
34375 | inherits(Sha224, Sha256) | ||
34376 | |||
34377 | Sha224.prototype.init = function () { | ||
34378 | this._a = 0xc1059ed8 | ||
34379 | this._b = 0x367cd507 | ||
34380 | this._c = 0x3070dd17 | ||
34381 | this._d = 0xf70e5939 | ||
34382 | this._e = 0xffc00b31 | ||
34383 | this._f = 0x68581511 | ||
34384 | this._g = 0x64f98fa7 | ||
34385 | this._h = 0xbefa4fa4 | ||
34386 | |||
34387 | return this | ||
34388 | } | ||
34389 | |||
34390 | Sha224.prototype._hash = function () { | ||
34391 | var H = Buffer.allocUnsafe(28) | ||
34392 | |||
34393 | H.writeInt32BE(this._a, 0) | ||
34394 | H.writeInt32BE(this._b, 4) | ||
34395 | H.writeInt32BE(this._c, 8) | ||
34396 | H.writeInt32BE(this._d, 12) | ||
34397 | H.writeInt32BE(this._e, 16) | ||
34398 | H.writeInt32BE(this._f, 20) | ||
34399 | H.writeInt32BE(this._g, 24) | ||
34400 | |||
34401 | return H | ||
34402 | } | ||
34403 | |||
34404 | module.exports = Sha224 | ||
34405 | |||
34406 | },{"./hash":394,"./sha256":399,"inherits":116,"safe-buffer":393}],399:[function(require,module,exports){ | ||
34407 | /** | ||
34408 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined | ||
34409 | * in FIPS 180-2 | ||
34410 | * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. | ||
34411 | * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet | ||
34412 | * | ||
34413 | */ | ||
34414 | |||
34415 | var inherits = require('inherits') | ||
34416 | var Hash = require('./hash') | ||
34417 | var Buffer = require('safe-buffer').Buffer | ||
34418 | |||
34419 | var K = [ | ||
34420 | 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, | ||
34421 | 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, | ||
34422 | 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, | ||
34423 | 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, | ||
34424 | 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, | ||
34425 | 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, | ||
34426 | 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, | ||
34427 | 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, | ||
34428 | 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, | ||
34429 | 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, | ||
34430 | 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, | ||
34431 | 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, | ||
34432 | 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, | ||
34433 | 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, | ||
34434 | 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, | ||
34435 | 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2 | ||
34436 | ] | ||
34437 | |||
34438 | var W = new Array(64) | ||
34439 | |||
34440 | function Sha256 () { | ||
34441 | this.init() | ||
34442 | |||
34443 | this._w = W // new Array(64) | ||
34444 | |||
34445 | Hash.call(this, 64, 56) | ||
34446 | } | ||
34447 | |||
34448 | inherits(Sha256, Hash) | ||
34449 | |||
34450 | Sha256.prototype.init = function () { | ||
34451 | this._a = 0x6a09e667 | ||
34452 | this._b = 0xbb67ae85 | ||
34453 | this._c = 0x3c6ef372 | ||
34454 | this._d = 0xa54ff53a | ||
34455 | this._e = 0x510e527f | ||
34456 | this._f = 0x9b05688c | ||
34457 | this._g = 0x1f83d9ab | ||
34458 | this._h = 0x5be0cd19 | ||
34459 | |||
34460 | return this | ||
34461 | } | ||
34462 | |||
34463 | function ch (x, y, z) { | ||
34464 | return z ^ (x & (y ^ z)) | ||
34465 | } | ||
34466 | |||
34467 | function maj (x, y, z) { | ||
34468 | return (x & y) | (z & (x | y)) | ||
34469 | } | ||
34470 | |||
34471 | function sigma0 (x) { | ||
34472 | return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10) | ||
34473 | } | ||
34474 | |||
34475 | function sigma1 (x) { | ||
34476 | return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7) | ||
34477 | } | ||
34478 | |||
34479 | function gamma0 (x) { | ||
34480 | return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3) | ||
34481 | } | ||
34482 | |||
34483 | function gamma1 (x) { | ||
34484 | return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10) | ||
34485 | } | ||
34486 | |||
34487 | Sha256.prototype._update = function (M) { | ||
34488 | var W = this._w | ||
34489 | |||
34490 | var a = this._a | 0 | ||
34491 | var b = this._b | 0 | ||
34492 | var c = this._c | 0 | ||
34493 | var d = this._d | 0 | ||
34494 | var e = this._e | 0 | ||
34495 | var f = this._f | 0 | ||
34496 | var g = this._g | 0 | ||
34497 | var h = this._h | 0 | ||
34498 | |||
34499 | for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) | ||
34500 | for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0 | ||
34501 | |||
34502 | for (var j = 0; j < 64; ++j) { | ||
34503 | var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0 | ||
34504 | var T2 = (sigma0(a) + maj(a, b, c)) | 0 | ||
34505 | |||
34506 | h = g | ||
34507 | g = f | ||
34508 | f = e | ||
34509 | e = (d + T1) | 0 | ||
34510 | d = c | ||
34511 | c = b | ||
34512 | b = a | ||
34513 | a = (T1 + T2) | 0 | ||
34514 | } | ||
34515 | |||
34516 | this._a = (a + this._a) | 0 | ||
34517 | this._b = (b + this._b) | 0 | ||
34518 | this._c = (c + this._c) | 0 | ||
34519 | this._d = (d + this._d) | 0 | ||
34520 | this._e = (e + this._e) | 0 | ||
34521 | this._f = (f + this._f) | 0 | ||
34522 | this._g = (g + this._g) | 0 | ||
34523 | this._h = (h + this._h) | 0 | ||
34524 | } | ||
34525 | |||
34526 | Sha256.prototype._hash = function () { | ||
34527 | var H = Buffer.allocUnsafe(32) | ||
34528 | |||
34529 | H.writeInt32BE(this._a, 0) | ||
34530 | H.writeInt32BE(this._b, 4) | ||
34531 | H.writeInt32BE(this._c, 8) | ||
34532 | H.writeInt32BE(this._d, 12) | ||
34533 | H.writeInt32BE(this._e, 16) | ||
34534 | H.writeInt32BE(this._f, 20) | ||
34535 | H.writeInt32BE(this._g, 24) | ||
34536 | H.writeInt32BE(this._h, 28) | ||
34537 | |||
34538 | return H | ||
34539 | } | ||
34540 | |||
34541 | module.exports = Sha256 | ||
34542 | |||
34543 | },{"./hash":394,"inherits":116,"safe-buffer":393}],400:[function(require,module,exports){ | ||
34544 | var inherits = require('inherits') | ||
34545 | var SHA512 = require('./sha512') | ||
34546 | var Hash = require('./hash') | ||
34547 | var Buffer = require('safe-buffer').Buffer | ||
34548 | |||
34549 | var W = new Array(160) | ||
34550 | |||
34551 | function Sha384 () { | ||
34552 | this.init() | ||
34553 | this._w = W | ||
34554 | |||
34555 | Hash.call(this, 128, 112) | ||
34556 | } | ||
34557 | |||
34558 | inherits(Sha384, SHA512) | ||
34559 | |||
34560 | Sha384.prototype.init = function () { | ||
34561 | this._ah = 0xcbbb9d5d | ||
34562 | this._bh = 0x629a292a | ||
34563 | this._ch = 0x9159015a | ||
34564 | this._dh = 0x152fecd8 | ||
34565 | this._eh = 0x67332667 | ||
34566 | this._fh = 0x8eb44a87 | ||
34567 | this._gh = 0xdb0c2e0d | ||
34568 | this._hh = 0x47b5481d | ||
34569 | |||
34570 | this._al = 0xc1059ed8 | ||
34571 | this._bl = 0x367cd507 | ||
34572 | this._cl = 0x3070dd17 | ||
34573 | this._dl = 0xf70e5939 | ||
34574 | this._el = 0xffc00b31 | ||
34575 | this._fl = 0x68581511 | ||
34576 | this._gl = 0x64f98fa7 | ||
34577 | this._hl = 0xbefa4fa4 | ||
34578 | |||
34579 | return this | ||
34580 | } | ||
34581 | |||
34582 | Sha384.prototype._hash = function () { | ||
34583 | var H = Buffer.allocUnsafe(48) | ||
34584 | |||
34585 | function writeInt64BE (h, l, offset) { | ||
34586 | H.writeInt32BE(h, offset) | ||
34587 | H.writeInt32BE(l, offset + 4) | ||
34588 | } | ||
34589 | |||
34590 | writeInt64BE(this._ah, this._al, 0) | ||
34591 | writeInt64BE(this._bh, this._bl, 8) | ||
34592 | writeInt64BE(this._ch, this._cl, 16) | ||
34593 | writeInt64BE(this._dh, this._dl, 24) | ||
34594 | writeInt64BE(this._eh, this._el, 32) | ||
34595 | writeInt64BE(this._fh, this._fl, 40) | ||
34596 | |||
34597 | return H | ||
34598 | } | ||
34599 | |||
34600 | module.exports = Sha384 | ||
34601 | |||
34602 | },{"./hash":394,"./sha512":401,"inherits":116,"safe-buffer":393}],401:[function(require,module,exports){ | ||
34603 | var inherits = require('inherits') | ||
34604 | var Hash = require('./hash') | ||
34605 | var Buffer = require('safe-buffer').Buffer | ||
34606 | |||
34607 | var K = [ | ||
34608 | 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, | ||
34609 | 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, | ||
34610 | 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, | ||
34611 | 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, | ||
34612 | 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, | ||
34613 | 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, | ||
34614 | 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, | ||
34615 | 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, | ||
34616 | 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, | ||
34617 | 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, | ||
34618 | 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, | ||
34619 | 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, | ||
34620 | 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, | ||
34621 | 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, | ||
34622 | 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, | ||
34623 | 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, | ||
34624 | 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, | ||
34625 | 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, | ||
34626 | 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, | ||
34627 | 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, | ||
34628 | 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, | ||
34629 | 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, | ||
34630 | 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, | ||
34631 | 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, | ||
34632 | 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, | ||
34633 | 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, | ||
34634 | 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, | ||
34635 | 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, | ||
34636 | 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, | ||
34637 | 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, | ||
34638 | 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, | ||
34639 | 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, | ||
34640 | 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, | ||
34641 | 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, | ||
34642 | 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, | ||
34643 | 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, | ||
34644 | 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, | ||
34645 | 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, | ||
34646 | 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, | ||
34647 | 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 | ||
34648 | ] | ||
34649 | |||
34650 | var W = new Array(160) | ||
34651 | |||
34652 | function Sha512 () { | ||
34653 | this.init() | ||
34654 | this._w = W | ||
34655 | |||
34656 | Hash.call(this, 128, 112) | ||
34657 | } | ||
34658 | |||
34659 | inherits(Sha512, Hash) | ||
34660 | |||
34661 | Sha512.prototype.init = function () { | ||
34662 | this._ah = 0x6a09e667 | ||
34663 | this._bh = 0xbb67ae85 | ||
34664 | this._ch = 0x3c6ef372 | ||
34665 | this._dh = 0xa54ff53a | ||
34666 | this._eh = 0x510e527f | ||
34667 | this._fh = 0x9b05688c | ||
34668 | this._gh = 0x1f83d9ab | ||
34669 | this._hh = 0x5be0cd19 | ||
34670 | |||
34671 | this._al = 0xf3bcc908 | ||
34672 | this._bl = 0x84caa73b | ||
34673 | this._cl = 0xfe94f82b | ||
34674 | this._dl = 0x5f1d36f1 | ||
34675 | this._el = 0xade682d1 | ||
34676 | this._fl = 0x2b3e6c1f | ||
34677 | this._gl = 0xfb41bd6b | ||
34678 | this._hl = 0x137e2179 | ||
34679 | |||
34680 | return this | ||
34681 | } | ||
34682 | |||
34683 | function Ch (x, y, z) { | ||
34684 | return z ^ (x & (y ^ z)) | ||
34685 | } | ||
34686 | |||
34687 | function maj (x, y, z) { | ||
34688 | return (x & y) | (z & (x | y)) | ||
34689 | } | ||
34690 | |||
34691 | function sigma0 (x, xl) { | ||
34692 | return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25) | ||
34693 | } | ||
34694 | |||
34695 | function sigma1 (x, xl) { | ||
34696 | return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23) | ||
34697 | } | ||
34698 | |||
34699 | function Gamma0 (x, xl) { | ||
34700 | return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7) | ||
34701 | } | ||
34702 | |||
34703 | function Gamma0l (x, xl) { | ||
34704 | return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25) | ||
34705 | } | ||
34706 | |||
34707 | function Gamma1 (x, xl) { | ||
34708 | return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6) | ||
34709 | } | ||
34710 | |||
34711 | function Gamma1l (x, xl) { | ||
34712 | return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26) | ||
34713 | } | ||
34714 | |||
34715 | function getCarry (a, b) { | ||
34716 | return (a >>> 0) < (b >>> 0) ? 1 : 0 | ||
34717 | } | ||
34718 | |||
34719 | Sha512.prototype._update = function (M) { | ||
34720 | var W = this._w | ||
34721 | |||
34722 | var ah = this._ah | 0 | ||
34723 | var bh = this._bh | 0 | ||
34724 | var ch = this._ch | 0 | ||
34725 | var dh = this._dh | 0 | ||
34726 | var eh = this._eh | 0 | ||
34727 | var fh = this._fh | 0 | ||
34728 | var gh = this._gh | 0 | ||
34729 | var hh = this._hh | 0 | ||
34730 | |||
34731 | var al = this._al | 0 | ||
34732 | var bl = this._bl | 0 | ||
34733 | var cl = this._cl | 0 | ||
34734 | var dl = this._dl | 0 | ||
34735 | var el = this._el | 0 | ||
34736 | var fl = this._fl | 0 | ||
34737 | var gl = this._gl | 0 | ||
34738 | var hl = this._hl | 0 | ||
34739 | |||
34740 | for (var i = 0; i < 32; i += 2) { | ||
34741 | W[i] = M.readInt32BE(i * 4) | ||
34742 | W[i + 1] = M.readInt32BE(i * 4 + 4) | ||
34743 | } | ||
34744 | for (; i < 160; i += 2) { | ||
34745 | var xh = W[i - 15 * 2] | ||
34746 | var xl = W[i - 15 * 2 + 1] | ||
34747 | var gamma0 = Gamma0(xh, xl) | ||
34748 | var gamma0l = Gamma0l(xl, xh) | ||
34749 | |||
34750 | xh = W[i - 2 * 2] | ||
34751 | xl = W[i - 2 * 2 + 1] | ||
34752 | var gamma1 = Gamma1(xh, xl) | ||
34753 | var gamma1l = Gamma1l(xl, xh) | ||
34754 | |||
34755 | // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] | ||
34756 | var Wi7h = W[i - 7 * 2] | ||
34757 | var Wi7l = W[i - 7 * 2 + 1] | ||
34758 | |||
34759 | var Wi16h = W[i - 16 * 2] | ||
34760 | var Wi16l = W[i - 16 * 2 + 1] | ||
34761 | |||
34762 | var Wil = (gamma0l + Wi7l) | 0 | ||
34763 | var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0 | ||
34764 | Wil = (Wil + gamma1l) | 0 | ||
34765 | Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0 | ||
34766 | Wil = (Wil + Wi16l) | 0 | ||
34767 | Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0 | ||
34768 | |||
34769 | W[i] = Wih | ||
34770 | W[i + 1] = Wil | ||
34771 | } | ||
34772 | |||
34773 | for (var j = 0; j < 160; j += 2) { | ||
34774 | Wih = W[j] | ||
34775 | Wil = W[j + 1] | ||
34776 | |||
34777 | var majh = maj(ah, bh, ch) | ||
34778 | var majl = maj(al, bl, cl) | ||
34779 | |||
34780 | var sigma0h = sigma0(ah, al) | ||
34781 | var sigma0l = sigma0(al, ah) | ||
34782 | var sigma1h = sigma1(eh, el) | ||
34783 | var sigma1l = sigma1(el, eh) | ||
34784 | |||
34785 | // t1 = h + sigma1 + ch + K[j] + W[j] | ||
34786 | var Kih = K[j] | ||
34787 | var Kil = K[j + 1] | ||
34788 | |||
34789 | var chh = Ch(eh, fh, gh) | ||
34790 | var chl = Ch(el, fl, gl) | ||
34791 | |||
34792 | var t1l = (hl + sigma1l) | 0 | ||
34793 | var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0 | ||
34794 | t1l = (t1l + chl) | 0 | ||
34795 | t1h = (t1h + chh + getCarry(t1l, chl)) | 0 | ||
34796 | t1l = (t1l + Kil) | 0 | ||
34797 | t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0 | ||
34798 | t1l = (t1l + Wil) | 0 | ||
34799 | t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0 | ||
34800 | |||
34801 | // t2 = sigma0 + maj | ||
34802 | var t2l = (sigma0l + majl) | 0 | ||
34803 | var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0 | ||
34804 | |||
34805 | hh = gh | ||
34806 | hl = gl | ||
34807 | gh = fh | ||
34808 | gl = fl | ||
34809 | fh = eh | ||
34810 | fl = el | ||
34811 | el = (dl + t1l) | 0 | ||
34812 | eh = (dh + t1h + getCarry(el, dl)) | 0 | ||
34813 | dh = ch | ||
34814 | dl = cl | ||
34815 | ch = bh | ||
34816 | cl = bl | ||
34817 | bh = ah | ||
34818 | bl = al | ||
34819 | al = (t1l + t2l) | 0 | ||
34820 | ah = (t1h + t2h + getCarry(al, t1l)) | 0 | ||
34821 | } | ||
34822 | |||
34823 | this._al = (this._al + al) | 0 | ||
34824 | this._bl = (this._bl + bl) | 0 | ||
34825 | this._cl = (this._cl + cl) | 0 | ||
34826 | this._dl = (this._dl + dl) | 0 | ||
34827 | this._el = (this._el + el) | 0 | ||
34828 | this._fl = (this._fl + fl) | 0 | ||
34829 | this._gl = (this._gl + gl) | 0 | ||
34830 | this._hl = (this._hl + hl) | 0 | ||
34831 | |||
34832 | this._ah = (this._ah + ah + getCarry(this._al, al)) | 0 | ||
34833 | this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0 | ||
34834 | this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0 | ||
34835 | this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0 | ||
34836 | this._eh = (this._eh + eh + getCarry(this._el, el)) | 0 | ||
34837 | this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0 | ||
34838 | this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0 | ||
34839 | this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0 | ||
34840 | } | ||
34841 | |||
34842 | Sha512.prototype._hash = function () { | ||
34843 | var H = Buffer.allocUnsafe(64) | ||
34844 | |||
34845 | function writeInt64BE (h, l, offset) { | ||
34846 | H.writeInt32BE(h, offset) | ||
34847 | H.writeInt32BE(l, offset + 4) | ||
34848 | } | ||
34849 | |||
34850 | writeInt64BE(this._ah, this._al, 0) | ||
34851 | writeInt64BE(this._bh, this._bl, 8) | ||
34852 | writeInt64BE(this._ch, this._cl, 16) | ||
34853 | writeInt64BE(this._dh, this._dl, 24) | ||
34854 | writeInt64BE(this._eh, this._el, 32) | ||
34855 | writeInt64BE(this._fh, this._fl, 40) | ||
34856 | writeInt64BE(this._gh, this._gl, 48) | ||
34857 | writeInt64BE(this._hh, this._hl, 56) | ||
34858 | |||
34859 | return H | ||
34860 | } | ||
34861 | |||
34862 | module.exports = Sha512 | ||
34863 | |||
34864 | },{"./hash":394,"inherits":116,"safe-buffer":393}],402:[function(require,module,exports){ | ||
34865 | "use strict"; | ||
34866 | |||
34867 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
34868 | |||
34869 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
34870 | |||
34871 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
34872 | |||
34873 | Object.defineProperty(exports, "__esModule", { | ||
34874 | value: true | ||
34875 | }); | ||
34876 | |||
34877 | var BigNumber = _interopRequire(require("bignumber.js")); | ||
34878 | |||
34879 | var isString = _interopRequire(require("lodash/isString")); | ||
34880 | |||
34881 | var Keypair = require("./keypair").Keypair; | ||
34882 | |||
34883 | var StrKey = require("./strkey").StrKey; | ||
34884 | |||
34885 | /** | ||
34886 | * Create a new Account object. | ||
34887 | * | ||
34888 | * `Account` represents a single account in Stellar network and its sequence number. | ||
34889 | * Account tracks the sequence number as it is used by {@link TransactionBuilder}. | ||
34890 | * See [Accounts](https://stellar.org/developers/learn/concepts/accounts.html) for more information about how | ||
34891 | * accounts work in Stellar. | ||
34892 | * @constructor | ||
34893 | * @param {string} accountId ID of the account (ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`) | ||
34894 | * @param {string} sequence current sequence number of the account | ||
34895 | */ | ||
34896 | |||
34897 | var Account = exports.Account = (function () { | ||
34898 | function Account(accountId, sequence) { | ||
34899 | _classCallCheck(this, Account); | ||
34900 | |||
34901 | if (!StrKey.isValidEd25519PublicKey(accountId)) { | ||
34902 | throw new Error("accountId is invalid"); | ||
34903 | } | ||
34904 | if (!isString(sequence)) { | ||
34905 | throw new Error("sequence must be of type string"); | ||
34906 | } | ||
34907 | this._accountId = accountId; | ||
34908 | this.sequence = new BigNumber(sequence); | ||
34909 | } | ||
34910 | |||
34911 | _createClass(Account, { | ||
34912 | accountId: { | ||
34913 | |||
34914 | /** | ||
34915 | * Returns Stellar account ID, ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA` | ||
34916 | * @returns {string} | ||
34917 | */ | ||
34918 | |||
34919 | value: function accountId() { | ||
34920 | return this._accountId; | ||
34921 | } | ||
34922 | }, | ||
34923 | sequenceNumber: { | ||
34924 | |||
34925 | /** | ||
34926 | * @returns {string} | ||
34927 | */ | ||
34928 | |||
34929 | value: function sequenceNumber() { | ||
34930 | return this.sequence.toString(); | ||
34931 | } | ||
34932 | }, | ||
34933 | incrementSequenceNumber: { | ||
34934 | |||
34935 | /** | ||
34936 | * Increments sequence number in this object by one. | ||
34937 | */ | ||
34938 | |||
34939 | value: function incrementSequenceNumber() { | ||
34940 | this.sequence = this.sequence.add(1); | ||
34941 | } | ||
34942 | } | ||
34943 | }); | ||
34944 | |||
34945 | return Account; | ||
34946 | })(); | ||
34947 | },{"./keypair":408,"./strkey":426,"bignumber.js":17,"lodash/isString":333}],403:[function(require,module,exports){ | ||
34948 | "use strict"; | ||
34949 | |||
34950 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
34951 | |||
34952 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
34953 | |||
34954 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
34955 | |||
34956 | Object.defineProperty(exports, "__esModule", { | ||
34957 | value: true | ||
34958 | }); | ||
34959 | |||
34960 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | ||
34961 | |||
34962 | var Keypair = require("./keypair").Keypair; | ||
34963 | |||
34964 | var StrKey = require("./strkey").StrKey; | ||
34965 | |||
34966 | var clone = _interopRequire(require("lodash/clone")); | ||
34967 | |||
34968 | var padEnd = _interopRequire(require("lodash/padEnd")); | ||
34969 | |||
34970 | var trimEnd = _interopRequire(require("lodash/trimEnd")); | ||
34971 | |||
34972 | /** | ||
34973 | * Asset class represents an asset, either the native asset (`XLM`) | ||
34974 | * or an asset code / issuer account ID pair. | ||
34975 | * | ||
34976 | * An asset code describes an asset code and issuer pair. In the case of the native | ||
34977 | * asset XLM, the issuer will be null. | ||
34978 | * | ||
34979 | * @constructor | ||
34980 | * @param {string} code - The asset code. | ||
34981 | * @param {string} issuer - The account ID of the issuer. | ||
34982 | */ | ||
34983 | |||
34984 | var Asset = exports.Asset = (function () { | ||
34985 | function Asset(code, issuer) { | ||
34986 | _classCallCheck(this, Asset); | ||
34987 | |||
34988 | if (!/^[a-zA-Z0-9]{1,12}$/.test(code)) { | ||
34989 | throw new Error("Asset code is invalid (maximum alphanumeric, 12 characters at max)"); | ||
34990 | } | ||
34991 | if (String(code).toLowerCase() !== "xlm" && !issuer) { | ||
34992 | throw new Error("Issuer cannot be null"); | ||
34993 | } | ||
34994 | if (issuer && !StrKey.isValidEd25519PublicKey(issuer)) { | ||
34995 | throw new Error("Issuer is invalid"); | ||
34996 | } | ||
34997 | |||
34998 | this.code = code; | ||
34999 | this.issuer = issuer; | ||
35000 | } | ||
35001 | |||
35002 | _createClass(Asset, { | ||
35003 | toXDRObject: { | ||
35004 | |||
35005 | /** | ||
35006 | * Returns the xdr object for this asset. | ||
35007 | * @returns {xdr.Asset} | ||
35008 | */ | ||
35009 | |||
35010 | value: function toXDRObject() { | ||
35011 | if (this.isNative()) { | ||
35012 | return xdr.Asset.assetTypeNative(); | ||
35013 | } | ||
35014 | |||
35015 | var xdrType = undefined, | ||
35016 | xdrTypeString = undefined; | ||
35017 | if (this.code.length <= 4) { | ||
35018 | xdrType = xdr.AssetAlphaNum4; | ||
35019 | xdrTypeString = "assetTypeCreditAlphanum4"; | ||
35020 | } else { | ||
35021 | xdrType = xdr.AssetAlphaNum12; | ||
35022 | xdrTypeString = "assetTypeCreditAlphanum12"; | ||
35023 | } | ||
35024 | |||
35025 | // pad code with null bytes if necessary | ||
35026 | var padLength = this.code.length <= 4 ? 4 : 12; | ||
35027 | var paddedCode = padEnd(this.code, padLength, "\u0000"); | ||
35028 | |||
35029 | var assetType = new xdrType({ | ||
35030 | assetCode: paddedCode, | ||
35031 | issuer: Keypair.fromPublicKey(this.issuer).xdrAccountId() | ||
35032 | }); | ||
35033 | |||
35034 | return new xdr.Asset(xdrTypeString, assetType); | ||
35035 | } | ||
35036 | }, | ||
35037 | getCode: { | ||
35038 | |||
35039 | /** | ||
35040 | * Return the asset code | ||
35041 | * @returns {string} | ||
35042 | */ | ||
35043 | |||
35044 | value: function getCode() { | ||
35045 | return clone(this.code); | ||
35046 | } | ||
35047 | }, | ||
35048 | getIssuer: { | ||
35049 | |||
35050 | /** | ||
35051 | * Return the asset issuer | ||
35052 | * @returns {string} | ||
35053 | */ | ||
35054 | |||
35055 | value: function getIssuer() { | ||
35056 | return clone(this.issuer); | ||
35057 | } | ||
35058 | }, | ||
35059 | getAssetType: { | ||
35060 | |||
35061 | /** | ||
35062 | * Return the asset type. Can be one of following types: | ||
35063 | * | ||
35064 | * * `native` | ||
35065 | * * `credit_alphanum4` | ||
35066 | * * `credit_alphanum12` | ||
35067 | * | ||
35068 | * @see [Assets concept](https://www.stellar.org/developers/learn/concepts/assets.html) | ||
35069 | * @returns {string} | ||
35070 | */ | ||
35071 | |||
35072 | value: function getAssetType() { | ||
35073 | if (this.isNative()) { | ||
35074 | return "native"; | ||
35075 | } | ||
35076 | if (this.code.length >= 1 && this.code.length <= 4) { | ||
35077 | return "credit_alphanum4"; | ||
35078 | } | ||
35079 | if (this.code.length >= 5 && this.code.length <= 12) { | ||
35080 | return "credit_alphanum12"; | ||
35081 | } | ||
35082 | } | ||
35083 | }, | ||
35084 | isNative: { | ||
35085 | |||
35086 | /** | ||
35087 | * Returns true if this asset object is the native asset. | ||
35088 | * @returns {boolean} | ||
35089 | */ | ||
35090 | |||
35091 | value: function isNative() { | ||
35092 | return !this.issuer; | ||
35093 | } | ||
35094 | }, | ||
35095 | equals: { | ||
35096 | |||
35097 | /** | ||
35098 | * Returns true if this asset equals the given asset. | ||
35099 | * @param {Asset} asset Asset to compare | ||
35100 | * @returns {boolean} | ||
35101 | */ | ||
35102 | |||
35103 | value: function equals(asset) { | ||
35104 | return this.code == asset.getCode() && this.issuer == asset.getIssuer(); | ||
35105 | } | ||
35106 | } | ||
35107 | }, { | ||
35108 | native: { | ||
35109 | |||
35110 | /** | ||
35111 | * Returns an asset object for the native asset. | ||
35112 | * @Return {Asset} | ||
35113 | */ | ||
35114 | |||
35115 | value: function native() { | ||
35116 | return new Asset("XLM"); | ||
35117 | } | ||
35118 | }, | ||
35119 | fromOperation: { | ||
35120 | |||
35121 | /** | ||
35122 | * Returns an asset object from its XDR object representation. | ||
35123 | * @param {xdr.Asset} assetXdr - The asset xdr object. | ||
35124 | * @returns {Asset} | ||
35125 | */ | ||
35126 | |||
35127 | value: function fromOperation(assetXdr) { | ||
35128 | var anum = undefined, | ||
35129 | code = undefined, | ||
35130 | issuer = undefined; | ||
35131 | switch (assetXdr["switch"]()) { | ||
35132 | case xdr.AssetType.assetTypeNative(): | ||
35133 | return this.native(); | ||
35134 | case xdr.AssetType.assetTypeCreditAlphanum4(): | ||
35135 | anum = assetXdr.alphaNum4(); | ||
35136 | /* falls through */ | ||
35137 | case xdr.AssetType.assetTypeCreditAlphanum12(): | ||
35138 | anum = anum || assetXdr.alphaNum12(); | ||
35139 | issuer = StrKey.encodeEd25519PublicKey(anum.issuer().ed25519()); | ||
35140 | code = trimEnd(anum.assetCode(), "\u0000"); | ||
35141 | return new this(code, issuer); | ||
35142 | default: | ||
35143 | throw new Error("Invalid asset type: " + assetXdr["switch"]().name); | ||
35144 | } | ||
35145 | } | ||
35146 | } | ||
35147 | }); | ||
35148 | |||
35149 | return Asset; | ||
35150 | })(); | ||
35151 | },{"./generated/stellar-xdr_generated":405,"./keypair":408,"./strkey":426,"lodash/clone":306,"lodash/padEnd":341,"lodash/trimEnd":351}],404:[function(require,module,exports){ | ||
35152 | (function (Buffer){ | ||
35153 | "use strict"; | ||
35154 | |||
35155 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
35156 | |||
35157 | exports.decodeBase58Check = decodeBase58Check; | ||
35158 | Object.defineProperty(exports, "__esModule", { | ||
35159 | value: true | ||
35160 | }); | ||
35161 | |||
35162 | var bs58 = _interopRequire(require("./vendor/bs58")); | ||
35163 | |||
35164 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
35165 | |||
35166 | var hash = require("./hashing").hash; | ||
35167 | |||
35168 | var verifyChecksum = require("./util/checksum").verifyChecksum; | ||
35169 | |||
35170 | var versionBytes = { | ||
35171 | accountId: 0, // decimal 0 | ||
35172 | none: 1, // decimal 1 | ||
35173 | seed: 33 }; | ||
35174 | |||
35175 | function decodeBase58Check(versionByteName, encoded) { | ||
35176 | var decoded = bs58.decode(encoded); | ||
35177 | var versionByte = decoded[0]; | ||
35178 | var payload = decoded.slice(0, decoded.length - 4); | ||
35179 | var data = payload.slice(1); | ||
35180 | var checksum = decoded.slice(decoded.length - 4); | ||
35181 | |||
35182 | var expectedVersion = versionBytes[versionByteName]; | ||
35183 | |||
35184 | if (isUndefined(expectedVersion)) { | ||
35185 | throw new Error("" + versionByteName + " is not a valid version byte name. expected one of \"accountId\", \"seed\", or \"none\""); | ||
35186 | } | ||
35187 | |||
35188 | if (versionByte !== expectedVersion) { | ||
35189 | throw new Error("invalid version byte. expected " + expectedVersion + ", got " + versionByte); | ||
35190 | } | ||
35191 | |||
35192 | var expectedChecksum = calculateChecksum(payload); | ||
35193 | |||
35194 | if (!verifyChecksum(expectedChecksum, checksum)) { | ||
35195 | throw new Error("invalid checksum"); | ||
35196 | } | ||
35197 | |||
35198 | if (versionByteName === "accountId" && decoded.length !== 37) { | ||
35199 | throw new Error("Decoded address length is invalid. Expected 37, got " + decoded.length); | ||
35200 | } | ||
35201 | |||
35202 | return Buffer.from(data); | ||
35203 | } | ||
35204 | |||
35205 | function calculateChecksum(payload) { | ||
35206 | var inner = hash(payload); | ||
35207 | var outer = hash(inner); | ||
35208 | return outer.slice(0, 4); | ||
35209 | } | ||
35210 | // decimal 33 | ||
35211 | }).call(this,require("buffer").Buffer) | ||
35212 | },{"./hashing":406,"./util/checksum":429,"./vendor/bs58":431,"buffer":49,"lodash/isUndefined":336}],405:[function(require,module,exports){ | ||
35213 | "use strict";var _interopRequireWildcard=function(obj){return obj && obj.__esModule?obj:{"default":obj};};var XDR=_interopRequireWildcard(require("js-xdr"));var types=XDR.config(function(xdr){xdr.typedef("Value", xdr.varOpaque());xdr.struct("ScpBallot", [["counter", xdr.lookup("Uint32")], ["value", xdr.lookup("Value")]]);xdr["enum"]("ScpStatementType", {scpStPrepare:0, scpStConfirm:1, scpStExternalize:2, scpStNominate:3});xdr.struct("ScpNomination", [["quorumSetHash", xdr.lookup("Hash")], ["votes", xdr.varArray(xdr.lookup("Value"), 2147483647)], ["accepted", xdr.varArray(xdr.lookup("Value"), 2147483647)]]);xdr.struct("ScpStatementPrepare", [["quorumSetHash", xdr.lookup("Hash")], ["ballot", xdr.lookup("ScpBallot")], ["prepared", xdr.option(xdr.lookup("ScpBallot"))], ["preparedPrime", xdr.option(xdr.lookup("ScpBallot"))], ["nC", xdr.lookup("Uint32")], ["nH", xdr.lookup("Uint32")]]);xdr.struct("ScpStatementConfirm", [["ballot", xdr.lookup("ScpBallot")], ["nPrepared", xdr.lookup("Uint32")], ["nCommit", xdr.lookup("Uint32")], ["nH", xdr.lookup("Uint32")], ["quorumSetHash", xdr.lookup("Hash")]]);xdr.struct("ScpStatementExternalize", [["commit", xdr.lookup("ScpBallot")], ["nH", xdr.lookup("Uint32")], ["commitQuorumSetHash", xdr.lookup("Hash")]]);xdr.union("ScpStatementPledges", {switchOn:xdr.lookup("ScpStatementType"), switchName:"type", switches:[["scpStPrepare", "prepare"], ["scpStConfirm", "confirm"], ["scpStExternalize", "externalize"], ["scpStNominate", "nominate"]], arms:{prepare:xdr.lookup("ScpStatementPrepare"), confirm:xdr.lookup("ScpStatementConfirm"), externalize:xdr.lookup("ScpStatementExternalize"), nominate:xdr.lookup("ScpNomination")}});xdr.struct("ScpStatement", [["nodeId", xdr.lookup("NodeId")], ["slotIndex", xdr.lookup("Uint64")], ["pledges", xdr.lookup("ScpStatementPledges")]]);xdr.struct("ScpEnvelope", [["statement", xdr.lookup("ScpStatement")], ["signature", xdr.lookup("Signature")]]);xdr.struct("ScpQuorumSet", [["threshold", xdr.lookup("Uint32")], ["validators", xdr.varArray(xdr.lookup("PublicKey"), 2147483647)], ["innerSets", xdr.varArray(xdr.lookup("ScpQuorumSet"), 2147483647)]]);xdr.typedef("AccountId", xdr.lookup("PublicKey"));xdr.typedef("Thresholds", xdr.opaque(4));xdr.typedef("String32", xdr.string(32));xdr.typedef("String64", xdr.string(64));xdr.typedef("SequenceNumber", xdr.lookup("Int64"));xdr.typedef("DataValue", xdr.varOpaque(64));xdr["enum"]("AssetType", {assetTypeNative:0, assetTypeCreditAlphanum4:1, assetTypeCreditAlphanum12:2});xdr.struct("AssetAlphaNum4", [["assetCode", xdr.opaque(4)], ["issuer", xdr.lookup("AccountId")]]);xdr.struct("AssetAlphaNum12", [["assetCode", xdr.opaque(12)], ["issuer", xdr.lookup("AccountId")]]);xdr.union("Asset", {switchOn:xdr.lookup("AssetType"), switchName:"type", switches:[["assetTypeNative", xdr["void"]()], ["assetTypeCreditAlphanum4", "alphaNum4"], ["assetTypeCreditAlphanum12", "alphaNum12"]], arms:{alphaNum4:xdr.lookup("AssetAlphaNum4"), alphaNum12:xdr.lookup("AssetAlphaNum12")}});xdr.struct("Price", [["n", xdr.lookup("Int32")], ["d", xdr.lookup("Int32")]]);xdr.struct("Liabilities", [["buying", xdr.lookup("Int64")], ["selling", xdr.lookup("Int64")]]);xdr["enum"]("ThresholdIndices", {thresholdMasterWeight:0, thresholdLow:1, thresholdMed:2, thresholdHigh:3});xdr["enum"]("LedgerEntryType", {account:0, trustline:1, offer:2, datum:3});xdr.struct("Signer", [["key", xdr.lookup("SignerKey")], ["weight", xdr.lookup("Uint32")]]);xdr["enum"]("AccountFlags", {authRequiredFlag:1, authRevocableFlag:2, authImmutableFlag:4});xdr["const"]("MASK_ACCOUNT_FLAGS", 7);xdr.union("AccountEntryV1Ext", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("AccountEntryV1", [["liabilities", xdr.lookup("Liabilities")], ["ext", xdr.lookup("AccountEntryV1Ext")]]);xdr.union("AccountEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()], [1, "v1"]], arms:{v1:xdr.lookup("AccountEntryV1")}});xdr.struct("AccountEntry", [["accountId", xdr.lookup("AccountId")], ["balance", xdr.lookup("Int64")], ["seqNum", xdr.lookup("SequenceNumber")], ["numSubEntries", xdr.lookup("Uint32")], ["inflationDest", xdr.option(xdr.lookup("AccountId"))], ["flags", xdr.lookup("Uint32")], ["homeDomain", xdr.lookup("String32")], ["thresholds", xdr.lookup("Thresholds")], ["signers", xdr.varArray(xdr.lookup("Signer"), 20)], ["ext", xdr.lookup("AccountEntryExt")]]);xdr["enum"]("TrustLineFlags", {authorizedFlag:1});xdr["const"]("MASK_TRUSTLINE_FLAGS", 1);xdr.union("TrustLineEntryV1Ext", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("TrustLineEntryV1", [["liabilities", xdr.lookup("Liabilities")], ["ext", xdr.lookup("TrustLineEntryV1Ext")]]);xdr.union("TrustLineEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()], [1, "v1"]], arms:{v1:xdr.lookup("TrustLineEntryV1")}});xdr.struct("TrustLineEntry", [["accountId", xdr.lookup("AccountId")], ["asset", xdr.lookup("Asset")], ["balance", xdr.lookup("Int64")], ["limit", xdr.lookup("Int64")], ["flags", xdr.lookup("Uint32")], ["ext", xdr.lookup("TrustLineEntryExt")]]);xdr["enum"]("OfferEntryFlags", {passiveFlag:1});xdr["const"]("MASK_OFFERENTRY_FLAGS", 1);xdr.union("OfferEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("OfferEntry", [["sellerId", xdr.lookup("AccountId")], ["offerId", xdr.lookup("Uint64")], ["selling", xdr.lookup("Asset")], ["buying", xdr.lookup("Asset")], ["amount", xdr.lookup("Int64")], ["price", xdr.lookup("Price")], ["flags", xdr.lookup("Uint32")], ["ext", xdr.lookup("OfferEntryExt")]]);xdr.union("DataEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("DataEntry", [["accountId", xdr.lookup("AccountId")], ["dataName", xdr.lookup("String64")], ["dataValue", xdr.lookup("DataValue")], ["ext", xdr.lookup("DataEntryExt")]]);xdr.union("LedgerEntryData", {switchOn:xdr.lookup("LedgerEntryType"), switchName:"type", switches:[["account", "account"], ["trustline", "trustLine"], ["offer", "offer"], ["datum", "data"]], arms:{account:xdr.lookup("AccountEntry"), trustLine:xdr.lookup("TrustLineEntry"), offer:xdr.lookup("OfferEntry"), data:xdr.lookup("DataEntry")}});xdr.union("LedgerEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("LedgerEntry", [["lastModifiedLedgerSeq", xdr.lookup("Uint32")], ["data", xdr.lookup("LedgerEntryData")], ["ext", xdr.lookup("LedgerEntryExt")]]);xdr["enum"]("EnvelopeType", {envelopeTypeScp:1, envelopeTypeTx:2, envelopeTypeAuth:3});xdr.typedef("UpgradeType", xdr.varOpaque(128));xdr.union("StellarValueExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("StellarValue", [["txSetHash", xdr.lookup("Hash")], ["closeTime", xdr.lookup("Uint64")], ["upgrades", xdr.varArray(xdr.lookup("UpgradeType"), 6)], ["ext", xdr.lookup("StellarValueExt")]]);xdr.union("LedgerHeaderExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("LedgerHeader", [["ledgerVersion", xdr.lookup("Uint32")], ["previousLedgerHash", xdr.lookup("Hash")], ["scpValue", xdr.lookup("StellarValue")], ["txSetResultHash", xdr.lookup("Hash")], ["bucketListHash", xdr.lookup("Hash")], ["ledgerSeq", xdr.lookup("Uint32")], ["totalCoins", xdr.lookup("Int64")], ["feePool", xdr.lookup("Int64")], ["inflationSeq", xdr.lookup("Uint32")], ["idPool", xdr.lookup("Uint64")], ["baseFee", xdr.lookup("Uint32")], ["baseReserve", xdr.lookup("Uint32")], ["maxTxSetSize", xdr.lookup("Uint32")], ["skipList", xdr.array(xdr.lookup("Hash"), 4)], ["ext", xdr.lookup("LedgerHeaderExt")]]);xdr["enum"]("LedgerUpgradeType", {ledgerUpgradeVersion:1, ledgerUpgradeBaseFee:2, ledgerUpgradeMaxTxSetSize:3, ledgerUpgradeBaseReserve:4});xdr.union("LedgerUpgrade", {switchOn:xdr.lookup("LedgerUpgradeType"), switchName:"type", switches:[["ledgerUpgradeVersion", "newLedgerVersion"], ["ledgerUpgradeBaseFee", "newBaseFee"], ["ledgerUpgradeMaxTxSetSize", "newMaxTxSetSize"], ["ledgerUpgradeBaseReserve", "newBaseReserve"]], arms:{newLedgerVersion:xdr.lookup("Uint32"), newBaseFee:xdr.lookup("Uint32"), newMaxTxSetSize:xdr.lookup("Uint32"), newBaseReserve:xdr.lookup("Uint32")}});xdr.struct("LedgerKeyAccount", [["accountId", xdr.lookup("AccountId")]]);xdr.struct("LedgerKeyTrustLine", [["accountId", xdr.lookup("AccountId")], ["asset", xdr.lookup("Asset")]]);xdr.struct("LedgerKeyOffer", [["sellerId", xdr.lookup("AccountId")], ["offerId", xdr.lookup("Uint64")]]);xdr.struct("LedgerKeyData", [["accountId", xdr.lookup("AccountId")], ["dataName", xdr.lookup("String64")]]);xdr.union("LedgerKey", {switchOn:xdr.lookup("LedgerEntryType"), switchName:"type", switches:[["account", "account"], ["trustline", "trustLine"], ["offer", "offer"], ["datum", "data"]], arms:{account:xdr.lookup("LedgerKeyAccount"), trustLine:xdr.lookup("LedgerKeyTrustLine"), offer:xdr.lookup("LedgerKeyOffer"), data:xdr.lookup("LedgerKeyData")}});xdr["enum"]("BucketEntryType", {liveentry:0, deadentry:1});xdr.union("BucketEntry", {switchOn:xdr.lookup("BucketEntryType"), switchName:"type", switches:[["liveentry", "liveEntry"], ["deadentry", "deadEntry"]], arms:{liveEntry:xdr.lookup("LedgerEntry"), deadEntry:xdr.lookup("LedgerKey")}});xdr.struct("TransactionSet", [["previousLedgerHash", xdr.lookup("Hash")], ["txes", xdr.varArray(xdr.lookup("TransactionEnvelope"), 2147483647)]]);xdr.struct("TransactionResultPair", [["transactionHash", xdr.lookup("Hash")], ["result", xdr.lookup("TransactionResult")]]);xdr.struct("TransactionResultSet", [["results", xdr.varArray(xdr.lookup("TransactionResultPair"), 2147483647)]]);xdr.union("TransactionHistoryEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("TransactionHistoryEntry", [["ledgerSeq", xdr.lookup("Uint32")], ["txSet", xdr.lookup("TransactionSet")], ["ext", xdr.lookup("TransactionHistoryEntryExt")]]);xdr.union("TransactionHistoryResultEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("TransactionHistoryResultEntry", [["ledgerSeq", xdr.lookup("Uint32")], ["txResultSet", xdr.lookup("TransactionResultSet")], ["ext", xdr.lookup("TransactionHistoryResultEntryExt")]]);xdr.union("LedgerHeaderHistoryEntryExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("LedgerHeaderHistoryEntry", [["hash", xdr.lookup("Hash")], ["header", xdr.lookup("LedgerHeader")], ["ext", xdr.lookup("LedgerHeaderHistoryEntryExt")]]);xdr.struct("LedgerScpMessages", [["ledgerSeq", xdr.lookup("Uint32")], ["messages", xdr.varArray(xdr.lookup("ScpEnvelope"), 2147483647)]]);xdr.struct("ScpHistoryEntryV0", [["quorumSets", xdr.varArray(xdr.lookup("ScpQuorumSet"), 2147483647)], ["ledgerMessages", xdr.lookup("LedgerScpMessages")]]);xdr.union("ScpHistoryEntry", {switchOn:xdr.int(), switchName:"v", switches:[[0, "v0"]], arms:{v0:xdr.lookup("ScpHistoryEntryV0")}});xdr["enum"]("LedgerEntryChangeType", {ledgerEntryCreated:0, ledgerEntryUpdated:1, ledgerEntryRemoved:2, ledgerEntryState:3});xdr.union("LedgerEntryChange", {switchOn:xdr.lookup("LedgerEntryChangeType"), switchName:"type", switches:[["ledgerEntryCreated", "created"], ["ledgerEntryUpdated", "updated"], ["ledgerEntryRemoved", "removed"], ["ledgerEntryState", "state"]], arms:{created:xdr.lookup("LedgerEntry"), updated:xdr.lookup("LedgerEntry"), removed:xdr.lookup("LedgerKey"), state:xdr.lookup("LedgerEntry")}});xdr.typedef("LedgerEntryChanges", xdr.varArray(xdr.lookup("LedgerEntryChange"), 2147483647));xdr.struct("OperationMeta", [["changes", xdr.lookup("LedgerEntryChanges")]]);xdr.struct("TransactionMetaV1", [["txChanges", xdr.lookup("LedgerEntryChanges")], ["operations", xdr.varArray(xdr.lookup("OperationMeta"), 2147483647)]]);xdr.union("TransactionMeta", {switchOn:xdr.int(), switchName:"v", switches:[[0, "operations"], [1, "v1"]], arms:{operations:xdr.varArray(xdr.lookup("OperationMeta"), 2147483647), v1:xdr.lookup("TransactionMetaV1")}});xdr["enum"]("ErrorCode", {errMisc:0, errDatum:1, errConf:2, errAuth:3, errLoad:4});xdr.struct("Error", [["code", xdr.lookup("ErrorCode")], ["msg", xdr.string(100)]]);xdr.struct("AuthCert", [["pubkey", xdr.lookup("Curve25519Public")], ["expiration", xdr.lookup("Uint64")], ["sig", xdr.lookup("Signature")]]);xdr.struct("Hello", [["ledgerVersion", xdr.lookup("Uint32")], ["overlayVersion", xdr.lookup("Uint32")], ["overlayMinVersion", xdr.lookup("Uint32")], ["networkId", xdr.lookup("Hash")], ["versionStr", xdr.string(100)], ["listeningPort", xdr.int()], ["peerId", xdr.lookup("NodeId")], ["cert", xdr.lookup("AuthCert")], ["nonce", xdr.lookup("Uint256")]]);xdr.struct("Auth", [["unused", xdr.int()]]);xdr["enum"]("IpAddrType", {iPv4:0, iPv6:1});xdr.union("PeerAddressIp", {switchOn:xdr.lookup("IpAddrType"), switchName:"type", switches:[["iPv4", "ipv4"], ["iPv6", "ipv6"]], arms:{ipv4:xdr.opaque(4), ipv6:xdr.opaque(16)}});xdr.struct("PeerAddress", [["ip", xdr.lookup("PeerAddressIp")], ["port", xdr.lookup("Uint32")], ["numFailures", xdr.lookup("Uint32")]]);xdr["enum"]("MessageType", {errorMsg:0, auth:2, dontHave:3, getPeer:4, peer:5, getTxSet:6, txSet:7, transaction:8, getScpQuorumset:9, scpQuorumset:10, scpMessage:11, getScpState:12, hello:13});xdr.struct("DontHave", [["type", xdr.lookup("MessageType")], ["reqHash", xdr.lookup("Uint256")]]);xdr.union("StellarMessage", {switchOn:xdr.lookup("MessageType"), switchName:"type", switches:[["errorMsg", "error"], ["hello", "hello"], ["auth", "auth"], ["dontHave", "dontHave"], ["getPeer", xdr["void"]()], ["peer", "peers"], ["getTxSet", "txSetHash"], ["txSet", "txSet"], ["transaction", "transaction"], ["getScpQuorumset", "qSetHash"], ["scpQuorumset", "qSet"], ["scpMessage", "envelope"], ["getScpState", "getScpLedgerSeq"]], arms:{error:xdr.lookup("Error"), hello:xdr.lookup("Hello"), auth:xdr.lookup("Auth"), dontHave:xdr.lookup("DontHave"), peers:xdr.varArray(xdr.lookup("PeerAddress"), 100), txSetHash:xdr.lookup("Uint256"), txSet:xdr.lookup("TransactionSet"), transaction:xdr.lookup("TransactionEnvelope"), qSetHash:xdr.lookup("Uint256"), qSet:xdr.lookup("ScpQuorumSet"), envelope:xdr.lookup("StellarMessage"), getScpLedgerSeq:xdr.lookup("Uint32")}});xdr.struct("AuthenticatedMessageV0", [["sequence", xdr.lookup("Uint64")], ["message", xdr.lookup("StellarMessage")], ["mac", xdr.lookup("HmacSha256Mac")]]);xdr.union("AuthenticatedMessage", {switchOn:xdr.lookup("Uint32"), switchName:"v", switches:[[0, "v0"]], arms:{v0:xdr.lookup("AuthenticatedMessageV0")}});xdr.struct("DecoratedSignature", [["hint", xdr.lookup("SignatureHint")], ["signature", xdr.lookup("Signature")]]);xdr["enum"]("OperationType", {createAccount:0, payment:1, pathPayment:2, manageOffer:3, createPassiveOffer:4, setOption:5, changeTrust:6, allowTrust:7, accountMerge:8, inflation:9, manageDatum:10, bumpSequence:11});xdr.struct("CreateAccountOp", [["destination", xdr.lookup("AccountId")], ["startingBalance", xdr.lookup("Int64")]]);xdr.struct("PaymentOp", [["destination", xdr.lookup("AccountId")], ["asset", xdr.lookup("Asset")], ["amount", xdr.lookup("Int64")]]);xdr.struct("PathPaymentOp", [["sendAsset", xdr.lookup("Asset")], ["sendMax", xdr.lookup("Int64")], ["destination", xdr.lookup("AccountId")], ["destAsset", xdr.lookup("Asset")], ["destAmount", xdr.lookup("Int64")], ["path", xdr.varArray(xdr.lookup("Asset"), 5)]]);xdr.struct("ManageOfferOp", [["selling", xdr.lookup("Asset")], ["buying", xdr.lookup("Asset")], ["amount", xdr.lookup("Int64")], ["price", xdr.lookup("Price")], ["offerId", xdr.lookup("Uint64")]]);xdr.struct("CreatePassiveOfferOp", [["selling", xdr.lookup("Asset")], ["buying", xdr.lookup("Asset")], ["amount", xdr.lookup("Int64")], ["price", xdr.lookup("Price")]]);xdr.struct("SetOptionsOp", [["inflationDest", xdr.option(xdr.lookup("AccountId"))], ["clearFlags", xdr.option(xdr.lookup("Uint32"))], ["setFlags", xdr.option(xdr.lookup("Uint32"))], ["masterWeight", xdr.option(xdr.lookup("Uint32"))], ["lowThreshold", xdr.option(xdr.lookup("Uint32"))], ["medThreshold", xdr.option(xdr.lookup("Uint32"))], ["highThreshold", xdr.option(xdr.lookup("Uint32"))], ["homeDomain", xdr.option(xdr.lookup("String32"))], ["signer", xdr.option(xdr.lookup("Signer"))]]);xdr.struct("ChangeTrustOp", [["line", xdr.lookup("Asset")], ["limit", xdr.lookup("Int64")]]);xdr.union("AllowTrustOpAsset", {switchOn:xdr.lookup("AssetType"), switchName:"type", switches:[["assetTypeCreditAlphanum4", "assetCode4"], ["assetTypeCreditAlphanum12", "assetCode12"]], arms:{assetCode4:xdr.opaque(4), assetCode12:xdr.opaque(12)}});xdr.struct("AllowTrustOp", [["trustor", xdr.lookup("AccountId")], ["asset", xdr.lookup("AllowTrustOpAsset")], ["authorize", xdr.bool()]]);xdr.struct("ManageDataOp", [["dataName", xdr.lookup("String64")], ["dataValue", xdr.option(xdr.lookup("DataValue"))]]);xdr.struct("BumpSequenceOp", [["bumpTo", xdr.lookup("SequenceNumber")]]);xdr.union("OperationBody", {switchOn:xdr.lookup("OperationType"), switchName:"type", switches:[["createAccount", "createAccountOp"], ["payment", "paymentOp"], ["pathPayment", "pathPaymentOp"], ["manageOffer", "manageOfferOp"], ["createPassiveOffer", "createPassiveOfferOp"], ["setOption", "setOptionsOp"], ["changeTrust", "changeTrustOp"], ["allowTrust", "allowTrustOp"], ["accountMerge", "destination"], ["inflation", xdr["void"]()], ["manageDatum", "manageDataOp"], ["bumpSequence", "bumpSequenceOp"]], arms:{createAccountOp:xdr.lookup("CreateAccountOp"), paymentOp:xdr.lookup("PaymentOp"), pathPaymentOp:xdr.lookup("PathPaymentOp"), manageOfferOp:xdr.lookup("ManageOfferOp"), createPassiveOfferOp:xdr.lookup("CreatePassiveOfferOp"), setOptionsOp:xdr.lookup("SetOptionsOp"), changeTrustOp:xdr.lookup("ChangeTrustOp"), allowTrustOp:xdr.lookup("AllowTrustOp"), destination:xdr.lookup("AccountId"), manageDataOp:xdr.lookup("ManageDataOp"), bumpSequenceOp:xdr.lookup("BumpSequenceOp")}});xdr.struct("Operation", [["sourceAccount", xdr.option(xdr.lookup("AccountId"))], ["body", xdr.lookup("OperationBody")]]);xdr["enum"]("MemoType", {memoNone:0, memoText:1, memoId:2, memoHash:3, memoReturn:4});xdr.union("Memo", {switchOn:xdr.lookup("MemoType"), switchName:"type", switches:[["memoNone", xdr["void"]()], ["memoText", "text"], ["memoId", "id"], ["memoHash", "hash"], ["memoReturn", "retHash"]], arms:{text:xdr.string(28), id:xdr.lookup("Uint64"), hash:xdr.lookup("Hash"), retHash:xdr.lookup("Hash")}});xdr.struct("TimeBounds", [["minTime", xdr.lookup("Uint64")], ["maxTime", xdr.lookup("Uint64")]]);xdr.union("TransactionExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("Transaction", [["sourceAccount", xdr.lookup("AccountId")], ["fee", xdr.lookup("Uint32")], ["seqNum", xdr.lookup("SequenceNumber")], ["timeBounds", xdr.option(xdr.lookup("TimeBounds"))], ["memo", xdr.lookup("Memo")], ["operations", xdr.varArray(xdr.lookup("Operation"), 100)], ["ext", xdr.lookup("TransactionExt")]]);xdr.union("TransactionSignaturePayloadTaggedTransaction", {switchOn:xdr.lookup("EnvelopeType"), switchName:"type", switches:[["envelopeTypeTx", "tx"]], arms:{tx:xdr.lookup("Transaction")}});xdr.struct("TransactionSignaturePayload", [["networkId", xdr.lookup("Hash")], ["taggedTransaction", xdr.lookup("TransactionSignaturePayloadTaggedTransaction")]]);xdr.struct("TransactionEnvelope", [["tx", xdr.lookup("Transaction")], ["signatures", xdr.varArray(xdr.lookup("DecoratedSignature"), 20)]]);xdr.struct("ClaimOfferAtom", [["sellerId", xdr.lookup("AccountId")], ["offerId", xdr.lookup("Uint64")], ["assetSold", xdr.lookup("Asset")], ["amountSold", xdr.lookup("Int64")], ["assetBought", xdr.lookup("Asset")], ["amountBought", xdr.lookup("Int64")]]);xdr["enum"]("CreateAccountResultCode", {createAccountSuccess:0, createAccountMalformed:-1, createAccountUnderfunded:-2, createAccountLowReserve:-3, createAccountAlreadyExist:-4});xdr.union("CreateAccountResult", {switchOn:xdr.lookup("CreateAccountResultCode"), switchName:"code", switches:[["createAccountSuccess", xdr["void"]()]], arms:{}, defaultArm:xdr["void"]()});xdr["enum"]("PaymentResultCode", {paymentSuccess:0, paymentMalformed:-1, paymentUnderfunded:-2, paymentSrcNoTrust:-3, paymentSrcNotAuthorized:-4, paymentNoDestination:-5, paymentNoTrust:-6, paymentNotAuthorized:-7, paymentLineFull:-8, paymentNoIssuer:-9});xdr.union("PaymentResult", {switchOn:xdr.lookup("PaymentResultCode"), switchName:"code", switches:[["paymentSuccess", xdr["void"]()]], arms:{}, defaultArm:xdr["void"]()});xdr["enum"]("PathPaymentResultCode", {pathPaymentSuccess:0, pathPaymentMalformed:-1, pathPaymentUnderfunded:-2, pathPaymentSrcNoTrust:-3, pathPaymentSrcNotAuthorized:-4, pathPaymentNoDestination:-5, pathPaymentNoTrust:-6, pathPaymentNotAuthorized:-7, pathPaymentLineFull:-8, pathPaymentNoIssuer:-9, pathPaymentTooFewOffer:-10, pathPaymentOfferCrossSelf:-11, pathPaymentOverSendmax:-12});xdr.struct("SimplePaymentResult", [["destination", xdr.lookup("AccountId")], ["asset", xdr.lookup("Asset")], ["amount", xdr.lookup("Int64")]]);xdr.struct("PathPaymentResultSuccess", [["offers", xdr.varArray(xdr.lookup("ClaimOfferAtom"), 2147483647)], ["last", xdr.lookup("SimplePaymentResult")]]);xdr.union("PathPaymentResult", {switchOn:xdr.lookup("PathPaymentResultCode"), switchName:"code", switches:[["pathPaymentSuccess", "success"], ["pathPaymentNoIssuer", "noIssuer"]], arms:{success:xdr.lookup("PathPaymentResultSuccess"), noIssuer:xdr.lookup("Asset")}, defaultArm:xdr["void"]()});xdr["enum"]("ManageOfferResultCode", {manageOfferSuccess:0, manageOfferMalformed:-1, manageOfferSellNoTrust:-2, manageOfferBuyNoTrust:-3, manageOfferSellNotAuthorized:-4, manageOfferBuyNotAuthorized:-5, manageOfferLineFull:-6, manageOfferUnderfunded:-7, manageOfferCrossSelf:-8, manageOfferSellNoIssuer:-9, manageOfferBuyNoIssuer:-10, manageOfferNotFound:-11, manageOfferLowReserve:-12});xdr["enum"]("ManageOfferEffect", {manageOfferCreated:0, manageOfferUpdated:1, manageOfferDeleted:2});xdr.union("ManageOfferSuccessResultOffer", {switchOn:xdr.lookup("ManageOfferEffect"), switchName:"effect", switches:[["manageOfferCreated", "offer"], ["manageOfferUpdated", "offer"]], arms:{offer:xdr.lookup("OfferEntry")}, defaultArm:xdr["void"]()});xdr.struct("ManageOfferSuccessResult", [["offersClaimed", xdr.varArray(xdr.lookup("ClaimOfferAtom"), 2147483647)], ["offer", xdr.lookup("ManageOfferSuccessResultOffer")]]);xdr.union("ManageOfferResult", {switchOn:xdr.lookup("ManageOfferResultCode"), switchName:"code", switches:[["manageOfferSuccess", "success"]], arms:{success:xdr.lookup("ManageOfferSuccessResult")}, defaultArm:xdr["void"]()});xdr["enum"]("SetOptionsResultCode", {setOptionsSuccess:0, setOptionsLowReserve:-1, setOptionsTooManySigner:-2, setOptionsBadFlag:-3, setOptionsInvalidInflation:-4, setOptionsCantChange:-5, setOptionsUnknownFlag:-6, setOptionsThresholdOutOfRange:-7, setOptionsBadSigner:-8, setOptionsInvalidHomeDomain:-9});xdr.union("SetOptionsResult", {switchOn:xdr.lookup("SetOptionsResultCode"), switchName:"code", switches:[["setOptionsSuccess", xdr["void"]()]], arms:{}, defaultArm:xdr["void"]()});xdr["enum"]("ChangeTrustResultCode", {changeTrustSuccess:0, changeTrustMalformed:-1, changeTrustNoIssuer:-2, changeTrustInvalidLimit:-3, changeTrustLowReserve:-4, changeTrustSelfNotAllowed:-5});xdr.union("ChangeTrustResult", {switchOn:xdr.lookup("ChangeTrustResultCode"), switchName:"code", switches:[["changeTrustSuccess", xdr["void"]()]], arms:{}, defaultArm:xdr["void"]()});xdr["enum"]("AllowTrustResultCode", {allowTrustSuccess:0, allowTrustMalformed:-1, allowTrustNoTrustLine:-2, allowTrustTrustNotRequired:-3, allowTrustCantRevoke:-4, allowTrustSelfNotAllowed:-5});xdr.union("AllowTrustResult", {switchOn:xdr.lookup("AllowTrustResultCode"), switchName:"code", switches:[["allowTrustSuccess", xdr["void"]()]], arms:{}, defaultArm:xdr["void"]()});xdr["enum"]("AccountMergeResultCode", {accountMergeSuccess:0, accountMergeMalformed:-1, accountMergeNoAccount:-2, accountMergeImmutableSet:-3, accountMergeHasSubEntry:-4, accountMergeSeqnumTooFar:-5, accountMergeDestFull:-6});xdr.union("AccountMergeResult", {switchOn:xdr.lookup("AccountMergeResultCode"), switchName:"code", switches:[["accountMergeSuccess", "sourceAccountBalance"]], arms:{sourceAccountBalance:xdr.lookup("Int64")}, defaultArm:xdr["void"]()});xdr["enum"]("InflationResultCode", {inflationSuccess:0, inflationNotTime:-1});xdr.struct("InflationPayout", [["destination", xdr.lookup("AccountId")], ["amount", xdr.lookup("Int64")]]);xdr.union("InflationResult", {switchOn:xdr.lookup("InflationResultCode"), switchName:"code", switches:[["inflationSuccess", "payouts"]], arms:{payouts:xdr.varArray(xdr.lookup("InflationPayout"), 2147483647)}, defaultArm:xdr["void"]()});xdr["enum"]("ManageDataResultCode", {manageDataSuccess:0, manageDataNotSupportedYet:-1, manageDataNameNotFound:-2, manageDataLowReserve:-3, manageDataInvalidName:-4});xdr.union("ManageDataResult", {switchOn:xdr.lookup("ManageDataResultCode"), switchName:"code", switches:[["manageDataSuccess", xdr["void"]()]], arms:{}, defaultArm:xdr["void"]()});xdr["enum"]("BumpSequenceResultCode", {bumpSequenceSuccess:0, bumpSequenceBadSeq:-1});xdr.union("BumpSequenceResult", {switchOn:xdr.lookup("BumpSequenceResultCode"), switchName:"code", switches:[["bumpSequenceSuccess", xdr["void"]()]], arms:{}, defaultArm:xdr["void"]()});xdr["enum"]("OperationResultCode", {opInner:0, opBadAuth:-1, opNoAccount:-2, opNotSupported:-3});xdr.union("OperationResultTr", {switchOn:xdr.lookup("OperationType"), switchName:"type", switches:[["createAccount", "createAccountResult"], ["payment", "paymentResult"], ["pathPayment", "pathPaymentResult"], ["manageOffer", "manageOfferResult"], ["createPassiveOffer", "createPassiveOfferResult"], ["setOption", "setOptionsResult"], ["changeTrust", "changeTrustResult"], ["allowTrust", "allowTrustResult"], ["accountMerge", "accountMergeResult"], ["inflation", "inflationResult"], ["manageDatum", "manageDataResult"], ["bumpSequence", "bumpSeqResult"]], arms:{createAccountResult:xdr.lookup("CreateAccountResult"), paymentResult:xdr.lookup("PaymentResult"), pathPaymentResult:xdr.lookup("PathPaymentResult"), manageOfferResult:xdr.lookup("ManageOfferResult"), createPassiveOfferResult:xdr.lookup("ManageOfferResult"), setOptionsResult:xdr.lookup("SetOptionsResult"), changeTrustResult:xdr.lookup("ChangeTrustResult"), allowTrustResult:xdr.lookup("AllowTrustResult"), accountMergeResult:xdr.lookup("AccountMergeResult"), inflationResult:xdr.lookup("InflationResult"), manageDataResult:xdr.lookup("ManageDataResult"), bumpSeqResult:xdr.lookup("BumpSequenceResult")}});xdr.union("OperationResult", {switchOn:xdr.lookup("OperationResultCode"), switchName:"code", switches:[["opInner", "tr"]], arms:{tr:xdr.lookup("OperationResultTr")}, defaultArm:xdr["void"]()});xdr["enum"]("TransactionResultCode", {txSuccess:0, txFailed:-1, txTooEarly:-2, txTooLate:-3, txMissingOperation:-4, txBadSeq:-5, txBadAuth:-6, txInsufficientBalance:-7, txNoAccount:-8, txInsufficientFee:-9, txBadAuthExtra:-10, txInternalError:-11});xdr.union("TransactionResultResult", {switchOn:xdr.lookup("TransactionResultCode"), switchName:"code", switches:[["txSuccess", "results"], ["txFailed", "results"]], arms:{results:xdr.varArray(xdr.lookup("OperationResult"), 2147483647)}, defaultArm:xdr["void"]()});xdr.union("TransactionResultExt", {switchOn:xdr.int(), switchName:"v", switches:[[0, xdr["void"]()]], arms:{}});xdr.struct("TransactionResult", [["feeCharged", xdr.lookup("Int64")], ["result", xdr.lookup("TransactionResultResult")], ["ext", xdr.lookup("TransactionResultExt")]]);xdr.typedef("Hash", xdr.opaque(32));xdr.typedef("Uint256", xdr.opaque(32));xdr.typedef("Uint32", xdr.uint());xdr.typedef("Int32", xdr.int());xdr.typedef("Uint64", xdr.uhyper());xdr.typedef("Int64", xdr.hyper());xdr["enum"]("CryptoKeyType", {keyTypeEd25519:0, keyTypePreAuthTx:1, keyTypeHashX:2});xdr["enum"]("PublicKeyType", {publicKeyTypeEd25519:0});xdr["enum"]("SignerKeyType", {signerKeyTypeEd25519:0, signerKeyTypePreAuthTx:1, signerKeyTypeHashX:2});xdr.union("PublicKey", {switchOn:xdr.lookup("PublicKeyType"), switchName:"type", switches:[["publicKeyTypeEd25519", "ed25519"]], arms:{ed25519:xdr.lookup("Uint256")}});xdr.union("SignerKey", {switchOn:xdr.lookup("SignerKeyType"), switchName:"type", switches:[["signerKeyTypeEd25519", "ed25519"], ["signerKeyTypePreAuthTx", "preAuthTx"], ["signerKeyTypeHashX", "hashX"]], arms:{ed25519:xdr.lookup("Uint256"), preAuthTx:xdr.lookup("Uint256"), hashX:xdr.lookup("Uint256")}});xdr.typedef("Signature", xdr.varOpaque(64));xdr.typedef("SignatureHint", xdr.opaque(4));xdr.typedef("NodeId", xdr.lookup("PublicKey"));xdr.struct("Curve25519Secret", [["key", xdr.opaque(32)]]);xdr.struct("Curve25519Public", [["key", xdr.opaque(32)]]);xdr.struct("HmacSha256Key", [["key", xdr.opaque(32)]]);xdr.struct("HmacSha256Mac", [["mac", xdr.opaque(32)]]);});module.exports = types; | ||
35214 | },{"js-xdr":127}],406:[function(require,module,exports){ | ||
35215 | "use strict"; | ||
35216 | |||
35217 | exports.hash = hash; | ||
35218 | Object.defineProperty(exports, "__esModule", { | ||
35219 | value: true | ||
35220 | }); | ||
35221 | |||
35222 | var sha256 = require("sha.js").sha256; | ||
35223 | |||
35224 | function hash(data) { | ||
35225 | var hasher = new sha256(); | ||
35226 | hasher.update(data, "utf8"); | ||
35227 | return hasher.digest(); | ||
35228 | } | ||
35229 | },{"sha.js":395}],407:[function(require,module,exports){ | ||
35230 | "use strict"; | ||
35231 | |||
35232 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | ||
35233 | |||
35234 | var _defaults = function (obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }; | ||
35235 | |||
35236 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
35237 | |||
35238 | Object.defineProperty(exports, "__esModule", { | ||
35239 | value: true | ||
35240 | }); | ||
35241 | |||
35242 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | ||
35243 | |||
35244 | exports.xdr = xdr; | ||
35245 | exports.hash = require("./hashing").hash; | ||
35246 | |||
35247 | var _signing = require("./signing"); | ||
35248 | |||
35249 | exports.sign = _signing.sign; | ||
35250 | exports.verify = _signing.verify; | ||
35251 | exports.FastSigning = _signing.FastSigning; | ||
35252 | exports.Keypair = require("./keypair").Keypair; | ||
35253 | |||
35254 | var _jsXdr = require("js-xdr"); | ||
35255 | |||
35256 | exports.UnsignedHyper = _jsXdr.UnsignedHyper; | ||
35257 | exports.Hyper = _jsXdr.Hyper; | ||
35258 | exports.Transaction = require("./transaction").Transaction; | ||
35259 | |||
35260 | var _transaction_builder = require("./transaction_builder"); | ||
35261 | |||
35262 | exports.TransactionBuilder = _transaction_builder.TransactionBuilder; | ||
35263 | exports.TimeoutInfinite = _transaction_builder.TimeoutInfinite; | ||
35264 | exports.Asset = require("./asset").Asset; | ||
35265 | |||
35266 | var _operation = require("./operation"); | ||
35267 | |||
35268 | exports.Operation = _operation.Operation; | ||
35269 | exports.AuthRequiredFlag = _operation.AuthRequiredFlag; | ||
35270 | exports.AuthRevocableFlag = _operation.AuthRevocableFlag; | ||
35271 | exports.AuthImmutableFlag = _operation.AuthImmutableFlag; | ||
35272 | |||
35273 | _defaults(exports, _interopRequireWildcard(require("./memo"))); | ||
35274 | |||
35275 | exports.Account = require("./account").Account; | ||
35276 | |||
35277 | var _network = require("./network"); | ||
35278 | |||
35279 | exports.Network = _network.Network; | ||
35280 | exports.Networks = _network.Networks; | ||
35281 | exports.StrKey = require("./strkey").StrKey; | ||
35282 | exports["default"] = module.exports; | ||
35283 | },{"./account":402,"./asset":403,"./generated/stellar-xdr_generated":405,"./hashing":406,"./keypair":408,"./memo":409,"./network":410,"./operation":411,"./signing":425,"./strkey":426,"./transaction":427,"./transaction_builder":428,"js-xdr":127}],408:[function(require,module,exports){ | ||
35284 | (function (Buffer){ | ||
35285 | "use strict"; | ||
35286 | |||
35287 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
35288 | |||
35289 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | ||
35290 | |||
35291 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
35292 | |||
35293 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
35294 | |||
35295 | Object.defineProperty(exports, "__esModule", { | ||
35296 | value: true | ||
35297 | }); | ||
35298 | |||
35299 | var Network = require("./network").Network; | ||
35300 | |||
35301 | var _signing = require("./signing"); | ||
35302 | |||
35303 | var sign = _signing.sign; | ||
35304 | var verify = _signing.verify; | ||
35305 | |||
35306 | var base58 = _interopRequireWildcard(require("./base58")); | ||
35307 | |||
35308 | var StrKey = require("./strkey").StrKey; | ||
35309 | |||
35310 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | ||
35311 | |||
35312 | var nacl = _interopRequire(require("tweetnacl")); | ||
35313 | |||
35314 | /** | ||
35315 | * `Keypair` represents public (and secret) keys of the account. | ||
35316 | * | ||
35317 | * Currently `Keypair` only supports ed25519 but in a future this class can be abstraction layer for other | ||
35318 | * public-key signature systems. | ||
35319 | * | ||
35320 | * Use more convenient methods to create `Keypair` object: | ||
35321 | * * `{@link Keypair.fromPublicKey}` | ||
35322 | * * `{@link Keypair.fromSecret}` | ||
35323 | * * `{@link Keypair.random}` | ||
35324 | * | ||
35325 | * @constructor | ||
35326 | * @param {object} keys At least one of keys must be provided. | ||
35327 | * @param {string} keys.type Public-key signature system name. (currently only `ed25519` keys are supported) | ||
35328 | * @param {Buffer} [keys.publicKey] Raw public key | ||
35329 | * @param {Buffer} [keys.secretKey] Raw secret key (32-byte secret seed in ed25519`) | ||
35330 | */ | ||
35331 | |||
35332 | var Keypair = exports.Keypair = (function () { | ||
35333 | function Keypair(keys) { | ||
35334 | _classCallCheck(this, Keypair); | ||
35335 | |||
35336 | if (keys.type != "ed25519") { | ||
35337 | throw new Error("Invalid keys type"); | ||
35338 | } | ||
35339 | |||
35340 | this.type = keys.type; | ||
35341 | |||
35342 | if (keys.secretKey) { | ||
35343 | keys.secretKey = Buffer.from(keys.secretKey); | ||
35344 | |||
35345 | if (keys.secretKey.length != 32) { | ||
35346 | throw new Error("secretKey length is invalid"); | ||
35347 | } | ||
35348 | |||
35349 | var secretKeyUint8 = new Uint8Array(keys.secretKey); | ||
35350 | var naclKeys = nacl.sign.keyPair.fromSeed(secretKeyUint8); | ||
35351 | |||
35352 | this._secretSeed = keys.secretKey; | ||
35353 | this._secretKey = Buffer.from(naclKeys.secretKey); | ||
35354 | this._publicKey = Buffer.from(naclKeys.publicKey); | ||
35355 | |||
35356 | if (keys.publicKey && !this._publicKey.equals(Buffer.from(keys.publicKey))) { | ||
35357 | throw new Error("secretKey does not match publicKey"); | ||
35358 | } | ||
35359 | } else { | ||
35360 | this._publicKey = Buffer.from(keys.publicKey); | ||
35361 | |||
35362 | if (this._publicKey.length != 32) { | ||
35363 | throw new Error("publicKey length is invalid"); | ||
35364 | } | ||
35365 | } | ||
35366 | } | ||
35367 | |||
35368 | _createClass(Keypair, { | ||
35369 | xdrAccountId: { | ||
35370 | value: function xdrAccountId() { | ||
35371 | return new xdr.AccountId.publicKeyTypeEd25519(this._publicKey); | ||
35372 | } | ||
35373 | }, | ||
35374 | xdrPublicKey: { | ||
35375 | value: function xdrPublicKey() { | ||
35376 | return new xdr.PublicKey.publicKeyTypeEd25519(this._publicKey); | ||
35377 | } | ||
35378 | }, | ||
35379 | rawPublicKey: { | ||
35380 | |||
35381 | /** | ||
35382 | * Returns raw public key | ||
35383 | * @returns {Buffer} | ||
35384 | */ | ||
35385 | |||
35386 | value: function rawPublicKey() { | ||
35387 | return this._publicKey; | ||
35388 | } | ||
35389 | }, | ||
35390 | signatureHint: { | ||
35391 | value: function signatureHint() { | ||
35392 | var a = this.xdrAccountId().toXDR(); | ||
35393 | |||
35394 | return a.slice(a.length - 4); | ||
35395 | } | ||
35396 | }, | ||
35397 | publicKey: { | ||
35398 | |||
35399 | /** | ||
35400 | * Returns public key associated with this `Keypair` object. | ||
35401 | * @returns {string} | ||
35402 | */ | ||
35403 | |||
35404 | value: function publicKey() { | ||
35405 | return StrKey.encodeEd25519PublicKey(this._publicKey); | ||
35406 | } | ||
35407 | }, | ||
35408 | secret: { | ||
35409 | |||
35410 | /** | ||
35411 | * Returns secret key associated with this `Keypair` object | ||
35412 | * @returns {string} | ||
35413 | */ | ||
35414 | |||
35415 | value: function secret() { | ||
35416 | if (!this._secretSeed) { | ||
35417 | throw new Error("no secret key available"); | ||
35418 | } | ||
35419 | |||
35420 | if (this.type == "ed25519") { | ||
35421 | return StrKey.encodeEd25519SecretSeed(this._secretSeed); | ||
35422 | } | ||
35423 | |||
35424 | throw new Error("Invalid Keypair type"); | ||
35425 | } | ||
35426 | }, | ||
35427 | rawSecretKey: { | ||
35428 | |||
35429 | /** | ||
35430 | * Returns raw secret key. | ||
35431 | * @returns {Buffer} | ||
35432 | */ | ||
35433 | |||
35434 | value: function rawSecretKey() { | ||
35435 | return this._secretSeed; | ||
35436 | } | ||
35437 | }, | ||
35438 | canSign: { | ||
35439 | |||
35440 | /** | ||
35441 | * Returns `true` if this `Keypair` object contains secret key and can sign. | ||
35442 | * @returns {boolean} | ||
35443 | */ | ||
35444 | |||
35445 | value: function canSign() { | ||
35446 | return !!this._secretKey; | ||
35447 | } | ||
35448 | }, | ||
35449 | sign: { | ||
35450 | |||
35451 | /** | ||
35452 | * Signs data. | ||
35453 | * @param {Buffer} data Data to sign | ||
35454 | * @returns {Buffer} | ||
35455 | */ | ||
35456 | |||
35457 | value: (function (_sign) { | ||
35458 | var _signWrapper = function sign(_x) { | ||
35459 | return _sign.apply(this, arguments); | ||
35460 | }; | ||
35461 | |||
35462 | _signWrapper.toString = function () { | ||
35463 | return _sign.toString(); | ||
35464 | }; | ||
35465 | |||
35466 | return _signWrapper; | ||
35467 | })(function (data) { | ||
35468 | if (!this.canSign()) { | ||
35469 | throw new Error("cannot sign: no secret key available"); | ||
35470 | } | ||
35471 | |||
35472 | return sign(data, this._secretKey); | ||
35473 | }) | ||
35474 | }, | ||
35475 | verify: { | ||
35476 | |||
35477 | /** | ||
35478 | * Verifies if `signature` for `data` is valid. | ||
35479 | * @param {Buffer} data Signed data | ||
35480 | * @param {Buffer} signature Signature | ||
35481 | * @returns {boolean} | ||
35482 | */ | ||
35483 | |||
35484 | value: (function (_verify) { | ||
35485 | var _verifyWrapper = function verify(_x2, _x3) { | ||
35486 | return _verify.apply(this, arguments); | ||
35487 | }; | ||
35488 | |||
35489 | _verifyWrapper.toString = function () { | ||
35490 | return _verify.toString(); | ||
35491 | }; | ||
35492 | |||
35493 | return _verifyWrapper; | ||
35494 | })(function (data, signature) { | ||
35495 | return verify(data, signature, this._publicKey); | ||
35496 | }) | ||
35497 | }, | ||
35498 | signDecorated: { | ||
35499 | value: function signDecorated(data) { | ||
35500 | var signature = this.sign(data); | ||
35501 | var hint = this.signatureHint(); | ||
35502 | |||
35503 | return new xdr.DecoratedSignature({ hint: hint, signature: signature }); | ||
35504 | } | ||
35505 | } | ||
35506 | }, { | ||
35507 | fromSecret: { | ||
35508 | |||
35509 | /** | ||
35510 | * Creates a new `Keypair` instance from secret. This can either be secret key or secret seed depending | ||
35511 | * on underlying public-key signature system. Currently `Keypair` only supports ed25519. | ||
35512 | * @param {string} secret secret key (ex. `SDAKFNYEIAORZKKCYRILFQKLLOCNPL5SWJ3YY5NM3ZH6GJSZGXHZEPQS`) | ||
35513 | * @returns {Keypair} | ||
35514 | */ | ||
35515 | |||
35516 | value: function fromSecret(secret) { | ||
35517 | var rawSecret = StrKey.decodeEd25519SecretSeed(secret); | ||
35518 | return this.fromRawEd25519Seed(rawSecret); | ||
35519 | } | ||
35520 | }, | ||
35521 | fromBase58Seed: { | ||
35522 | |||
35523 | /** | ||
35524 | * Base58 address encoding is **DEPRECATED**! Use this method only for transition to strkey encoding. | ||
35525 | * @param {string} seed Base58 secret seed | ||
35526 | * @deprecated Use {@link Keypair.fromSecret} | ||
35527 | * @returns {Keypair} | ||
35528 | */ | ||
35529 | |||
35530 | value: function fromBase58Seed(seed) { | ||
35531 | var rawSeed = base58.decodeBase58Check("seed", seed); | ||
35532 | return this.fromRawEd25519Seed(rawSeed); | ||
35533 | } | ||
35534 | }, | ||
35535 | fromRawEd25519Seed: { | ||
35536 | |||
35537 | /** | ||
35538 | * Creates a new `Keypair` object from ed25519 secret key seed raw bytes. | ||
35539 | * | ||
35540 | * @param {Buffer} rawSeed Raw 32-byte ed25519 secret key seed | ||
35541 | * @returns {Keypair} | ||
35542 | */ | ||
35543 | |||
35544 | value: function fromRawEd25519Seed(rawSeed) { | ||
35545 | return new this({ type: "ed25519", secretKey: rawSeed }); | ||
35546 | } | ||
35547 | }, | ||
35548 | master: { | ||
35549 | |||
35550 | /** | ||
35551 | * Returns `Keypair` object representing network master key. | ||
35552 | * @returns {Keypair} | ||
35553 | */ | ||
35554 | |||
35555 | value: function master() { | ||
35556 | if (Network.current() === null) { | ||
35557 | throw new Error("No network selected. Use `Network.use`, `Network.usePublicNetwork` or `Network.useTestNetwork` helper methods to select network."); | ||
35558 | } | ||
35559 | return this.fromRawEd25519Seed(Network.current().networkId()); | ||
35560 | } | ||
35561 | }, | ||
35562 | fromPublicKey: { | ||
35563 | |||
35564 | /** | ||
35565 | * Creates a new `Keypair` object from public key. | ||
35566 | * @param {string} publicKey public key (ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`) | ||
35567 | * @returns {Keypair} | ||
35568 | */ | ||
35569 | |||
35570 | value: function fromPublicKey(publicKey) { | ||
35571 | publicKey = StrKey.decodeEd25519PublicKey(publicKey); | ||
35572 | if (publicKey.length !== 32) { | ||
35573 | throw new Error("Invalid Stellar public key"); | ||
35574 | } | ||
35575 | return new this({ type: "ed25519", publicKey: publicKey }); | ||
35576 | } | ||
35577 | }, | ||
35578 | random: { | ||
35579 | |||
35580 | /** | ||
35581 | * Create a random `Keypair` object. | ||
35582 | * @returns {Keypair} | ||
35583 | */ | ||
35584 | |||
35585 | value: function random() { | ||
35586 | var secret = nacl.randomBytes(32); | ||
35587 | return this.fromRawEd25519Seed(secret); | ||
35588 | } | ||
35589 | } | ||
35590 | }); | ||
35591 | |||
35592 | return Keypair; | ||
35593 | })(); | ||
35594 | }).call(this,require("buffer").Buffer) | ||
35595 | },{"./base58":404,"./generated/stellar-xdr_generated":405,"./network":410,"./signing":425,"./strkey":426,"buffer":49,"tweetnacl":435}],409:[function(require,module,exports){ | ||
35596 | (function (Buffer){ | ||
35597 | "use strict"; | ||
35598 | |||
35599 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
35600 | |||
35601 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
35602 | |||
35603 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
35604 | |||
35605 | Object.defineProperty(exports, "__esModule", { | ||
35606 | value: true | ||
35607 | }); | ||
35608 | |||
35609 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | ||
35610 | |||
35611 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
35612 | |||
35613 | var isNull = _interopRequire(require("lodash/isNull")); | ||
35614 | |||
35615 | var isString = _interopRequire(require("lodash/isString")); | ||
35616 | |||
35617 | var clone = _interopRequire(require("lodash/clone")); | ||
35618 | |||
35619 | var UnsignedHyper = require("js-xdr").UnsignedHyper; | ||
35620 | |||
35621 | var BigNumber = _interopRequire(require("bignumber.js")); | ||
35622 | |||
35623 | /** | ||
35624 | * Type of {@link Memo}. | ||
35625 | */ | ||
35626 | var MemoNone = "none"; | ||
35627 | exports.MemoNone = MemoNone; | ||
35628 | /** | ||
35629 | * Type of {@link Memo}. | ||
35630 | */ | ||
35631 | var MemoID = "id"; | ||
35632 | exports.MemoID = MemoID; | ||
35633 | /** | ||
35634 | * Type of {@link Memo}. | ||
35635 | */ | ||
35636 | var MemoText = "text"; | ||
35637 | exports.MemoText = MemoText; | ||
35638 | /** | ||
35639 | * Type of {@link Memo}. | ||
35640 | */ | ||
35641 | var MemoHash = "hash"; | ||
35642 | exports.MemoHash = MemoHash; | ||
35643 | /** | ||
35644 | * Type of {@link Memo}. | ||
35645 | */ | ||
35646 | var MemoReturn = "return"; | ||
35647 | |||
35648 | exports.MemoReturn = MemoReturn; | ||
35649 | /** | ||
35650 | * `Memo` represents memos attached to transactions. | ||
35651 | * | ||
35652 | * @param {string} type - `MemoNone`, `MemoID`, `MemoText`, `MemoHash` or `MemoReturn` | ||
35653 | * @param {*} value - `string` for `MemoID`, `MemoText`, buffer of hex string for `MemoHash` or `MemoReturn` | ||
35654 | * @see [Transactions concept](https://www.stellar.org/developers/learn/concepts/transactions.html) | ||
35655 | * @class Memo | ||
35656 | */ | ||
35657 | |||
35658 | var Memo = exports.Memo = (function () { | ||
35659 | function Memo(type) { | ||
35660 | var value = arguments[1] === undefined ? null : arguments[1]; | ||
35661 | |||
35662 | _classCallCheck(this, Memo); | ||
35663 | |||
35664 | this._type = type; | ||
35665 | this._value = value; | ||
35666 | |||
35667 | switch (this._type) { | ||
35668 | case MemoNone: | ||
35669 | break; | ||
35670 | case MemoID: | ||
35671 | Memo._validateIdValue(value); | ||
35672 | break; | ||
35673 | case MemoText: | ||
35674 | Memo._validateTextValue(value); | ||
35675 | break; | ||
35676 | case MemoHash: | ||
35677 | case MemoReturn: | ||
35678 | Memo._validateHashValue(value); | ||
35679 | // We want MemoHash and MemoReturn to have Buffer as a value | ||
35680 | if (isString(value)) { | ||
35681 | this._value = Buffer.from(value, "hex"); | ||
35682 | } | ||
35683 | break; | ||
35684 | default: | ||
35685 | throw new Error("Invalid memo type"); | ||
35686 | } | ||
35687 | } | ||
35688 | |||
35689 | _createClass(Memo, { | ||
35690 | type: { | ||
35691 | |||
35692 | /** | ||
35693 | * Contains memo type: `MemoNone`, `MemoID`, `MemoText`, `MemoHash` or `MemoReturn` | ||
35694 | */ | ||
35695 | |||
35696 | get: function () { | ||
35697 | return clone(this._type); | ||
35698 | }, | ||
35699 | set: function (type) { | ||
35700 | throw new Error("Memo is immutable"); | ||
35701 | } | ||
35702 | }, | ||
35703 | value: { | ||
35704 | |||
35705 | /** | ||
35706 | * Contains memo value: | ||
35707 | * * `null` for `MemoNone`, | ||
35708 | * * `string` for `MemoID`, | ||
35709 | * * `Buffer` for `MemoText` after decoding using `fromXDRObject`, original value otherwise, | ||
35710 | * * `Buffer` for `MemoHash`, `MemoReturn`. | ||
35711 | */ | ||
35712 | |||
35713 | get: function () { | ||
35714 | switch (this._type) { | ||
35715 | case MemoNone: | ||
35716 | return null; | ||
35717 | case MemoID: | ||
35718 | case MemoText: | ||
35719 | return clone(this._value); | ||
35720 | case MemoHash: | ||
35721 | case MemoReturn: | ||
35722 | return Buffer.from(this._value); | ||
35723 | default: | ||
35724 | throw new Error("Invalid memo type"); | ||
35725 | } | ||
35726 | }, | ||
35727 | set: function (value) { | ||
35728 | throw new Error("Memo is immutable"); | ||
35729 | } | ||
35730 | }, | ||
35731 | toXDRObject: { | ||
35732 | |||
35733 | /** | ||
35734 | * Returns XDR memo object. | ||
35735 | * @returns {xdr.Memo} | ||
35736 | */ | ||
35737 | |||
35738 | value: function toXDRObject() { | ||
35739 | switch (this._type) { | ||
35740 | case MemoNone: | ||
35741 | return xdr.Memo.memoNone(); | ||
35742 | case MemoID: | ||
35743 | return xdr.Memo.memoId(UnsignedHyper.fromString(this._value)); | ||
35744 | case MemoText: | ||
35745 | return xdr.Memo.memoText(this._value); | ||
35746 | case MemoHash: | ||
35747 | return xdr.Memo.memoHash(this._value); | ||
35748 | case MemoReturn: | ||
35749 | return xdr.Memo.memoReturn(this._value); | ||
35750 | } | ||
35751 | } | ||
35752 | } | ||
35753 | }, { | ||
35754 | _validateIdValue: { | ||
35755 | value: function _validateIdValue(value) { | ||
35756 | var error = new Error("Expects a int64 as a string. Got " + value); | ||
35757 | |||
35758 | if (!isString(value)) { | ||
35759 | throw error; | ||
35760 | } | ||
35761 | |||
35762 | var number = undefined; | ||
35763 | try { | ||
35764 | number = new BigNumber(value); | ||
35765 | } catch (e) { | ||
35766 | throw error; | ||
35767 | } | ||
35768 | |||
35769 | // Infinity | ||
35770 | if (!number.isFinite()) { | ||
35771 | throw error; | ||
35772 | } | ||
35773 | |||
35774 | // NaN | ||
35775 | if (number.isNaN()) { | ||
35776 | throw error; | ||
35777 | } | ||
35778 | } | ||
35779 | }, | ||
35780 | _validateTextValue: { | ||
35781 | value: function _validateTextValue(value) { | ||
35782 | if (!xdr.Memo.armTypeForArm("text").isValid(value)) { | ||
35783 | throw new Error("Expects string, array or buffer, max 28 bytes"); | ||
35784 | } | ||
35785 | } | ||
35786 | }, | ||
35787 | _validateHashValue: { | ||
35788 | value: function _validateHashValue(value) { | ||
35789 | var error = new Error("Expects a 32 byte hash value or hex encoded string. Got " + value); | ||
35790 | |||
35791 | if (value === null || isUndefined(value)) { | ||
35792 | throw error; | ||
35793 | } | ||
35794 | |||
35795 | var valueBuffer = undefined; | ||
35796 | if (isString(value)) { | ||
35797 | if (!/^[0-9A-Fa-f]{64}$/g.test(value)) { | ||
35798 | throw error; | ||
35799 | } | ||
35800 | valueBuffer = Buffer.from(value, "hex"); | ||
35801 | } else if (Buffer.isBuffer(value)) { | ||
35802 | valueBuffer = Buffer.from(value); | ||
35803 | } else { | ||
35804 | throw error; | ||
35805 | } | ||
35806 | |||
35807 | if (!valueBuffer.length || valueBuffer.length != 32) { | ||
35808 | throw error; | ||
35809 | } | ||
35810 | } | ||
35811 | }, | ||
35812 | none: { | ||
35813 | |||
35814 | /** | ||
35815 | * Returns an empty memo (`MemoNone`). | ||
35816 | * @returns {Memo} | ||
35817 | */ | ||
35818 | |||
35819 | value: function none() { | ||
35820 | return new Memo(MemoNone); | ||
35821 | } | ||
35822 | }, | ||
35823 | text: { | ||
35824 | |||
35825 | /** | ||
35826 | * Creates and returns a `MemoText` memo. | ||
35827 | * @param {string} text - memo text | ||
35828 | * @returns {Memo} | ||
35829 | */ | ||
35830 | |||
35831 | value: (function (_text) { | ||
35832 | var _textWrapper = function text(_x) { | ||
35833 | return _text.apply(this, arguments); | ||
35834 | }; | ||
35835 | |||
35836 | _textWrapper.toString = function () { | ||
35837 | return _text.toString(); | ||
35838 | }; | ||
35839 | |||
35840 | return _textWrapper; | ||
35841 | })(function (text) { | ||
35842 | return new Memo(MemoText, text); | ||
35843 | }) | ||
35844 | }, | ||
35845 | id: { | ||
35846 | |||
35847 | /** | ||
35848 | * Creates and returns a `MemoID` memo. | ||
35849 | * @param {string} id - 64-bit number represented as a string | ||
35850 | * @returns {Memo} | ||
35851 | */ | ||
35852 | |||
35853 | value: (function (_id) { | ||
35854 | var _idWrapper = function id(_x2) { | ||
35855 | return _id.apply(this, arguments); | ||
35856 | }; | ||
35857 | |||
35858 | _idWrapper.toString = function () { | ||
35859 | return _id.toString(); | ||
35860 | }; | ||
35861 | |||
35862 | return _idWrapper; | ||
35863 | })(function (id) { | ||
35864 | return new Memo(MemoID, id); | ||
35865 | }) | ||
35866 | }, | ||
35867 | hash: { | ||
35868 | |||
35869 | /** | ||
35870 | * Creates and returns a `MemoHash` memo. | ||
35871 | * @param {array|string} hash - 32 byte hash or hex encoded string | ||
35872 | * @returns {Memo} | ||
35873 | */ | ||
35874 | |||
35875 | value: (function (_hash) { | ||
35876 | var _hashWrapper = function hash(_x3) { | ||
35877 | return _hash.apply(this, arguments); | ||
35878 | }; | ||
35879 | |||
35880 | _hashWrapper.toString = function () { | ||
35881 | return _hash.toString(); | ||
35882 | }; | ||
35883 | |||
35884 | return _hashWrapper; | ||
35885 | })(function (hash) { | ||
35886 | return new Memo(MemoHash, hash); | ||
35887 | }) | ||
35888 | }, | ||
35889 | "return": { | ||
35890 | |||
35891 | /** | ||
35892 | * Creates and returns a `MemoReturn` memo. | ||
35893 | * @param {array|string} hash - 32 byte hash or hex encoded string | ||
35894 | * @returns {Memo} | ||
35895 | */ | ||
35896 | |||
35897 | value: function _return(hash) { | ||
35898 | return new Memo(MemoReturn, hash); | ||
35899 | } | ||
35900 | }, | ||
35901 | fromXDRObject: { | ||
35902 | |||
35903 | /** | ||
35904 | * Returns {@link Memo} from XDR memo object. | ||
35905 | * @param {xdr.Memo} | ||
35906 | * @returns {Memo} | ||
35907 | */ | ||
35908 | |||
35909 | value: function fromXDRObject(object) { | ||
35910 | switch (object.arm()) { | ||
35911 | case "id": | ||
35912 | return Memo.id(object.value().toString()); | ||
35913 | case "text": | ||
35914 | return Memo.text(object.value()); | ||
35915 | case "hash": | ||
35916 | return Memo.hash(object.value()); | ||
35917 | case "retHash": | ||
35918 | return Memo["return"](object.value()); | ||
35919 | } | ||
35920 | |||
35921 | if (typeof object.value() === "undefined") { | ||
35922 | return Memo.none(); | ||
35923 | } | ||
35924 | |||
35925 | throw new Error("Unknown type"); | ||
35926 | } | ||
35927 | } | ||
35928 | }); | ||
35929 | |||
35930 | return Memo; | ||
35931 | })(); | ||
35932 | }).call(this,require("buffer").Buffer) | ||
35933 | },{"./generated/stellar-xdr_generated":405,"bignumber.js":17,"buffer":49,"js-xdr":127,"lodash/clone":306,"lodash/isNull":327,"lodash/isString":333,"lodash/isUndefined":336}],410:[function(require,module,exports){ | ||
35934 | "use strict"; | ||
35935 | |||
35936 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
35937 | |||
35938 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
35939 | |||
35940 | Object.defineProperty(exports, "__esModule", { | ||
35941 | value: true | ||
35942 | }); | ||
35943 | |||
35944 | var hash = require("./hashing").hash; | ||
35945 | |||
35946 | /** | ||
35947 | * Contains passphrases for common networks: | ||
35948 | * * `Networks.PUBLIC`: `Public Global Stellar Network ; September 2015` | ||
35949 | * * `Networks.TESTNET`: `Test SDF Network ; September 2015` | ||
35950 | * @type {{PUBLIC: string, TESTNET: string}} | ||
35951 | */ | ||
35952 | var Networks = { | ||
35953 | PUBLIC: "Public Global Stellar Network ; September 2015", | ||
35954 | TESTNET: "Test SDF Network ; September 2015" | ||
35955 | }; | ||
35956 | |||
35957 | exports.Networks = Networks; | ||
35958 | var current = null; | ||
35959 | |||
35960 | /** | ||
35961 | * The Network class provides helper methods to get the passphrase or id for different | ||
35962 | * stellar networks. It also provides the {@link Network.current} class method that returns the network | ||
35963 | * that will be used by this process for the purposes of generating signatures. | ||
35964 | * | ||
35965 | * You should select network your app will use before adding the first signature. You can use the `use`, | ||
35966 | * `usePublicNetwork` and `useTestNetwork` helper methods. | ||
35967 | * | ||
35968 | * Creates a new `Network` object. | ||
35969 | * @constructor | ||
35970 | * @param {string} networkPassphrase Network passphrase | ||
35971 | */ | ||
35972 | |||
35973 | var Network = exports.Network = (function () { | ||
35974 | function Network(networkPassphrase) { | ||
35975 | _classCallCheck(this, Network); | ||
35976 | |||
35977 | this._networkPassphrase = networkPassphrase; | ||
35978 | } | ||
35979 | |||
35980 | _createClass(Network, { | ||
35981 | networkPassphrase: { | ||
35982 | |||
35983 | /** | ||
35984 | * Returns network passphrase. | ||
35985 | * @returns {string} | ||
35986 | */ | ||
35987 | |||
35988 | value: function networkPassphrase() { | ||
35989 | return this._networkPassphrase; | ||
35990 | } | ||
35991 | }, | ||
35992 | networkId: { | ||
35993 | |||
35994 | /** | ||
35995 | * Returns Network ID. Network ID is SHA-256 hash of network passphrase. | ||
35996 | * @returns {string} | ||
35997 | */ | ||
35998 | |||
35999 | value: function networkId() { | ||
36000 | return hash(this.networkPassphrase()); | ||
36001 | } | ||
36002 | } | ||
36003 | }, { | ||
36004 | usePublicNetwork: { | ||
36005 | |||
36006 | /** | ||
36007 | * Use Stellar Public Network | ||
36008 | */ | ||
36009 | |||
36010 | value: function usePublicNetwork() { | ||
36011 | this.use(new Network(Networks.PUBLIC)); | ||
36012 | } | ||
36013 | }, | ||
36014 | useTestNetwork: { | ||
36015 | |||
36016 | /** | ||
36017 | * Use test network. | ||
36018 | */ | ||
36019 | |||
36020 | value: function useTestNetwork() { | ||
36021 | this.use(new Network(Networks.TESTNET)); | ||
36022 | } | ||
36023 | }, | ||
36024 | use: { | ||
36025 | |||
36026 | /** | ||
36027 | * Use network defined by Network object. | ||
36028 | * @param {Network} network Network to use | ||
36029 | */ | ||
36030 | |||
36031 | value: function use(network) { | ||
36032 | current = network; | ||
36033 | } | ||
36034 | }, | ||
36035 | current: { | ||
36036 | |||
36037 | /** | ||
36038 | * Returns currently selected network. | ||
36039 | * @returns {Network} | ||
36040 | */ | ||
36041 | |||
36042 | value: (function (_current) { | ||
36043 | var _currentWrapper = function current() { | ||
36044 | return _current.apply(this, arguments); | ||
36045 | }; | ||
36046 | |||
36047 | _currentWrapper.toString = function () { | ||
36048 | return _current.toString(); | ||
36049 | }; | ||
36050 | |||
36051 | return _currentWrapper; | ||
36052 | })(function () { | ||
36053 | return current; | ||
36054 | }) | ||
36055 | } | ||
36056 | }); | ||
36057 | |||
36058 | return Network; | ||
36059 | })(); | ||
36060 | },{"./hashing":406}],411:[function(require,module,exports){ | ||
36061 | "use strict"; | ||
36062 | |||
36063 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | ||
36064 | |||
36065 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36066 | |||
36067 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
36068 | |||
36069 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
36070 | |||
36071 | Object.defineProperty(exports, "__esModule", { | ||
36072 | value: true | ||
36073 | }); | ||
36074 | |||
36075 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | ||
36076 | |||
36077 | var Keypair = require("./keypair").Keypair; | ||
36078 | |||
36079 | var hash = require("./hashing").hash; | ||
36080 | |||
36081 | var StrKey = require("./strkey").StrKey; | ||
36082 | |||
36083 | var Hyper = require("js-xdr").Hyper; | ||
36084 | |||
36085 | var Asset = require("./asset").Asset; | ||
36086 | |||
36087 | var BigNumber = _interopRequire(require("bignumber.js")); | ||
36088 | |||
36089 | var best_r = require("./util/continued_fraction").best_r; | ||
36090 | |||
36091 | var trimEnd = _interopRequire(require("lodash/trimEnd")); | ||
36092 | |||
36093 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
36094 | |||
36095 | var isString = _interopRequire(require("lodash/isString")); | ||
36096 | |||
36097 | var isNumber = _interopRequire(require("lodash/isNumber")); | ||
36098 | |||
36099 | var isFinite = _interopRequire(require("lodash/isFinite")); | ||
36100 | |||
36101 | var ops = _interopRequireWildcard(require("./operations/index")); | ||
36102 | |||
36103 | var ONE = 10000000; | ||
36104 | var MAX_INT64 = "9223372036854775807"; | ||
36105 | |||
36106 | /** | ||
36107 | * When set using `{@link Operation.setOptions}` option, requires the issuing account to | ||
36108 | * give other accounts permission before they can hold the issuing account’s credit. | ||
36109 | * @constant | ||
36110 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | ||
36111 | */ | ||
36112 | var AuthRequiredFlag = 1 << 0; | ||
36113 | exports.AuthRequiredFlag = AuthRequiredFlag; | ||
36114 | /** | ||
36115 | * When set using `{@link Operation.setOptions}` option, allows the issuing account to | ||
36116 | * revoke its credit held by other accounts. | ||
36117 | * @constant | ||
36118 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | ||
36119 | */ | ||
36120 | var AuthRevocableFlag = 1 << 1; | ||
36121 | exports.AuthRevocableFlag = AuthRevocableFlag; | ||
36122 | /** | ||
36123 | * When set using `{@link Operation.setOptions}` option, then none of the authorization flags | ||
36124 | * can be set and the account can never be deleted. | ||
36125 | * @constant | ||
36126 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | ||
36127 | */ | ||
36128 | var AuthImmutableFlag = 1 << 2; | ||
36129 | |||
36130 | exports.AuthImmutableFlag = AuthImmutableFlag; | ||
36131 | /** | ||
36132 | * `Operation` class represents [operations](https://www.stellar.org/developers/learn/concepts/operations.html) in Stellar network. | ||
36133 | * Use one of static methods to create operations: | ||
36134 | * * `{@link Operation.createAccount}` | ||
36135 | * * `{@link Operation.payment}` | ||
36136 | * * `{@link Operation.pathPayment}` | ||
36137 | * * `{@link Operation.manageOffer}` | ||
36138 | * * `{@link Operation.createPassiveOffer}` | ||
36139 | * * `{@link Operation.setOptions}` | ||
36140 | * * `{@link Operation.changeTrust}` | ||
36141 | * * `{@link Operation.allowTrust}` | ||
36142 | * * `{@link Operation.accountMerge}` | ||
36143 | * * `{@link Operation.inflation}` | ||
36144 | * * `{@link Operation.manageData}` | ||
36145 | * * `{@link Operation.bumpSequence}` | ||
36146 | * | ||
36147 | * @class Operation | ||
36148 | */ | ||
36149 | |||
36150 | var Operation = exports.Operation = (function () { | ||
36151 | function Operation() { | ||
36152 | _classCallCheck(this, Operation); | ||
36153 | } | ||
36154 | |||
36155 | _createClass(Operation, null, { | ||
36156 | setSourceAccount: { | ||
36157 | value: function setSourceAccount(opAttributes, opts) { | ||
36158 | if (opts.source) { | ||
36159 | if (!StrKey.isValidEd25519PublicKey(opts.source)) { | ||
36160 | throw new Error("Source address is invalid"); | ||
36161 | } | ||
36162 | opAttributes.sourceAccount = Keypair.fromPublicKey(opts.source).xdrAccountId(); | ||
36163 | } | ||
36164 | } | ||
36165 | }, | ||
36166 | fromXDRObject: { | ||
36167 | |||
36168 | /** | ||
36169 | * Converts the XDR Operation object to the opts object used to create the XDR | ||
36170 | * operation. | ||
36171 | * @param {xdr.Operation} operation - An XDR Operation. | ||
36172 | * @return {Operation} | ||
36173 | */ | ||
36174 | |||
36175 | value: function fromXDRObject(operation) { | ||
36176 | function accountIdtoAddress(accountId) { | ||
36177 | return StrKey.encodeEd25519PublicKey(accountId.ed25519()); | ||
36178 | } | ||
36179 | |||
36180 | var result = {}; | ||
36181 | if (operation.sourceAccount()) { | ||
36182 | result.source = accountIdtoAddress(operation.sourceAccount()); | ||
36183 | } | ||
36184 | |||
36185 | var attrs = operation.body().value(); | ||
36186 | switch (operation.body()["switch"]().name) { | ||
36187 | case "createAccount": | ||
36188 | result.type = "createAccount"; | ||
36189 | result.destination = accountIdtoAddress(attrs.destination()); | ||
36190 | result.startingBalance = this._fromXDRAmount(attrs.startingBalance()); | ||
36191 | break; | ||
36192 | case "payment": | ||
36193 | result.type = "payment"; | ||
36194 | result.destination = accountIdtoAddress(attrs.destination()); | ||
36195 | result.asset = Asset.fromOperation(attrs.asset()); | ||
36196 | result.amount = this._fromXDRAmount(attrs.amount()); | ||
36197 | break; | ||
36198 | case "pathPayment": | ||
36199 | result.type = "pathPayment"; | ||
36200 | result.sendAsset = Asset.fromOperation(attrs.sendAsset()); | ||
36201 | result.sendMax = this._fromXDRAmount(attrs.sendMax()); | ||
36202 | result.destination = accountIdtoAddress(attrs.destination()); | ||
36203 | result.destAsset = Asset.fromOperation(attrs.destAsset()); | ||
36204 | result.destAmount = this._fromXDRAmount(attrs.destAmount()); | ||
36205 | var path = attrs.path(); | ||
36206 | result.path = []; | ||
36207 | for (var i in path) { | ||
36208 | result.path.push(Asset.fromOperation(path[i])); | ||
36209 | } | ||
36210 | break; | ||
36211 | case "changeTrust": | ||
36212 | result.type = "changeTrust"; | ||
36213 | result.line = Asset.fromOperation(attrs.line()); | ||
36214 | result.limit = this._fromXDRAmount(attrs.limit()); | ||
36215 | break; | ||
36216 | case "allowTrust": | ||
36217 | result.type = "allowTrust"; | ||
36218 | result.trustor = accountIdtoAddress(attrs.trustor()); | ||
36219 | result.assetCode = attrs.asset().value().toString(); | ||
36220 | result.assetCode = trimEnd(result.assetCode, "\u0000"); | ||
36221 | result.authorize = attrs.authorize(); | ||
36222 | break; | ||
36223 | case "setOption": | ||
36224 | result.type = "setOptions"; | ||
36225 | if (attrs.inflationDest()) { | ||
36226 | result.inflationDest = accountIdtoAddress(attrs.inflationDest()); | ||
36227 | } | ||
36228 | |||
36229 | result.clearFlags = attrs.clearFlags(); | ||
36230 | result.setFlags = attrs.setFlags(); | ||
36231 | result.masterWeight = attrs.masterWeight(); | ||
36232 | result.lowThreshold = attrs.lowThreshold(); | ||
36233 | result.medThreshold = attrs.medThreshold(); | ||
36234 | result.highThreshold = attrs.highThreshold(); | ||
36235 | // home_domain is checked by iscntrl in stellar-core | ||
36236 | result.homeDomain = attrs.homeDomain() !== undefined ? attrs.homeDomain().toString("ascii") : undefined; | ||
36237 | |||
36238 | if (attrs.signer()) { | ||
36239 | var signer = {}; | ||
36240 | var arm = attrs.signer().key().arm(); | ||
36241 | if (arm == "ed25519") { | ||
36242 | signer.ed25519PublicKey = accountIdtoAddress(attrs.signer().key()); | ||
36243 | } else if (arm == "preAuthTx") { | ||
36244 | signer.preAuthTx = attrs.signer().key().preAuthTx(); | ||
36245 | } else if (arm == "hashX") { | ||
36246 | signer.sha256Hash = attrs.signer().key().hashX(); | ||
36247 | } | ||
36248 | |||
36249 | signer.weight = attrs.signer().weight(); | ||
36250 | result.signer = signer; | ||
36251 | } | ||
36252 | break; | ||
36253 | case "manageOffer": | ||
36254 | result.type = "manageOffer"; | ||
36255 | result.selling = Asset.fromOperation(attrs.selling()); | ||
36256 | result.buying = Asset.fromOperation(attrs.buying()); | ||
36257 | result.amount = this._fromXDRAmount(attrs.amount()); | ||
36258 | result.price = this._fromXDRPrice(attrs.price()); | ||
36259 | result.offerId = attrs.offerId().toString(); | ||
36260 | break; | ||
36261 | case "createPassiveOffer": | ||
36262 | result.type = "createPassiveOffer"; | ||
36263 | result.selling = Asset.fromOperation(attrs.selling()); | ||
36264 | result.buying = Asset.fromOperation(attrs.buying()); | ||
36265 | result.amount = this._fromXDRAmount(attrs.amount()); | ||
36266 | result.price = this._fromXDRPrice(attrs.price()); | ||
36267 | break; | ||
36268 | case "accountMerge": | ||
36269 | result.type = "accountMerge"; | ||
36270 | result.destination = accountIdtoAddress(attrs); | ||
36271 | break; | ||
36272 | case "manageDatum": | ||
36273 | result.type = "manageData"; | ||
36274 | // manage_data.name is checked by iscntrl in stellar-core | ||
36275 | result.name = attrs.dataName().toString("ascii"); | ||
36276 | result.value = attrs.dataValue(); | ||
36277 | break; | ||
36278 | case "inflation": | ||
36279 | result.type = "inflation"; | ||
36280 | break; | ||
36281 | case "bumpSequence": | ||
36282 | result.type = "bumpSequence"; | ||
36283 | result.bumpTo = attrs.bumpTo().toString(); | ||
36284 | break; | ||
36285 | default: | ||
36286 | throw new Error("Unknown operation"); | ||
36287 | } | ||
36288 | return result; | ||
36289 | } | ||
36290 | }, | ||
36291 | isValidAmount: { | ||
36292 | value: function isValidAmount(value) { | ||
36293 | var allowZero = arguments[1] === undefined ? false : arguments[1]; | ||
36294 | |||
36295 | if (!isString(value)) { | ||
36296 | return false; | ||
36297 | } | ||
36298 | |||
36299 | var amount = undefined; | ||
36300 | try { | ||
36301 | amount = new BigNumber(value); | ||
36302 | } catch (e) { | ||
36303 | return false; | ||
36304 | } | ||
36305 | |||
36306 | switch (true) { | ||
36307 | // == 0 | ||
36308 | case !allowZero && amount.isZero(): | ||
36309 | // < 0 | ||
36310 | case amount.isNegative(): | ||
36311 | // > Max value | ||
36312 | case amount.times(ONE).greaterThan(new BigNumber(MAX_INT64).toString()): | ||
36313 | // Decimal places (max 7) | ||
36314 | case amount.decimalPlaces() > 7: | ||
36315 | // NaN or Infinity | ||
36316 | case amount.isNaN() || !amount.isFinite(): | ||
36317 | return false; | ||
36318 | default: | ||
36319 | return true; | ||
36320 | } | ||
36321 | } | ||
36322 | }, | ||
36323 | constructAmountRequirementsError: { | ||
36324 | value: function constructAmountRequirementsError(arg) { | ||
36325 | return "" + arg + " argument must be of type String, represent a positive number and have at most 7 digits after the decimal"; | ||
36326 | } | ||
36327 | }, | ||
36328 | _checkUnsignedIntValue: { | ||
36329 | |||
36330 | /** | ||
36331 | * Returns value converted to uint32 value or undefined. | ||
36332 | * If `value` is not `Number`, `String` or `Undefined` then throws an error. | ||
36333 | * Used in {@link Operation.setOptions}. | ||
36334 | * @private | ||
36335 | * @param {string} name Name of the property (used in error message only) | ||
36336 | * @param {*} value Value to check | ||
36337 | * @param {function(value, name)} isValidFunction Function to check other constraints (the argument will be a `Number`) | ||
36338 | * @returns {undefined|Number} | ||
36339 | * @private | ||
36340 | */ | ||
36341 | |||
36342 | value: function _checkUnsignedIntValue(name, value) { | ||
36343 | var isValidFunction = arguments[2] === undefined ? null : arguments[2]; | ||
36344 | |||
36345 | if (isUndefined(value)) { | ||
36346 | return undefined; | ||
36347 | } | ||
36348 | |||
36349 | if (isString(value)) { | ||
36350 | value = parseFloat(value); | ||
36351 | } | ||
36352 | |||
36353 | switch (true) { | ||
36354 | case !isNumber(value) || !isFinite(value) || value % 1 !== 0: | ||
36355 | throw new Error("" + name + " value is invalid"); | ||
36356 | case value < 0: | ||
36357 | throw new Error("" + name + " value must be unsigned"); | ||
36358 | case !isValidFunction || isValidFunction && isValidFunction(value, name): | ||
36359 | return value; | ||
36360 | default: | ||
36361 | throw new Error("" + name + " value is invalid"); | ||
36362 | } | ||
36363 | } | ||
36364 | }, | ||
36365 | _toXDRAmount: { | ||
36366 | |||
36367 | /** | ||
36368 | * @private | ||
36369 | */ | ||
36370 | |||
36371 | value: function _toXDRAmount(value) { | ||
36372 | var amount = new BigNumber(value).mul(ONE); | ||
36373 | return Hyper.fromString(amount.toString()); | ||
36374 | } | ||
36375 | }, | ||
36376 | _fromXDRAmount: { | ||
36377 | |||
36378 | /** | ||
36379 | * @private | ||
36380 | */ | ||
36381 | |||
36382 | value: function _fromXDRAmount(value) { | ||
36383 | return new BigNumber(value).div(ONE).toString(); | ||
36384 | } | ||
36385 | }, | ||
36386 | _fromXDRPrice: { | ||
36387 | |||
36388 | /** | ||
36389 | * @private | ||
36390 | */ | ||
36391 | |||
36392 | value: function _fromXDRPrice(price) { | ||
36393 | var n = new BigNumber(price.n()); | ||
36394 | return n.div(new BigNumber(price.d())).toString(); | ||
36395 | } | ||
36396 | }, | ||
36397 | _toXDRPrice: { | ||
36398 | |||
36399 | /** | ||
36400 | * @private | ||
36401 | */ | ||
36402 | |||
36403 | value: function _toXDRPrice(price) { | ||
36404 | var xdrObject = undefined; | ||
36405 | if (price.n && price.d) { | ||
36406 | xdrObject = new xdr.Price(price); | ||
36407 | } else { | ||
36408 | price = new BigNumber(price); | ||
36409 | var approx = best_r(price); | ||
36410 | xdrObject = new xdr.Price({ | ||
36411 | n: parseInt(approx[0]), | ||
36412 | d: parseInt(approx[1]) | ||
36413 | }); | ||
36414 | } | ||
36415 | |||
36416 | if (xdrObject.n() < 0 || xdrObject.d() < 0) { | ||
36417 | throw new Error("price must be positive"); | ||
36418 | } | ||
36419 | |||
36420 | return xdrObject; | ||
36421 | } | ||
36422 | } | ||
36423 | }); | ||
36424 | |||
36425 | return Operation; | ||
36426 | })(); | ||
36427 | |||
36428 | // Attach all imported operations as static methods on the Operation class | ||
36429 | Operation.accountMerge = ops.accountMerge; | ||
36430 | Operation.allowTrust = ops.allowTrust; | ||
36431 | Operation.bumpSequence = ops.bumpSequence; | ||
36432 | Operation.changeTrust = ops.changeTrust; | ||
36433 | Operation.createAccount = ops.createAccount; | ||
36434 | Operation.createPassiveOffer = ops.createPassiveOffer; | ||
36435 | Operation.inflation = ops.inflation; | ||
36436 | Operation.manageData = ops.manageData; | ||
36437 | Operation.manageOffer = ops.manageOffer; | ||
36438 | Operation.pathPayment = ops.pathPayment; | ||
36439 | Operation.payment = ops.payment; | ||
36440 | Operation.setOptions = ops.setOptions; | ||
36441 | },{"./asset":403,"./generated/stellar-xdr_generated":405,"./hashing":406,"./keypair":408,"./operations/index":418,"./strkey":426,"./util/continued_fraction":430,"bignumber.js":17,"js-xdr":127,"lodash/isFinite":323,"lodash/isNumber":328,"lodash/isString":333,"lodash/isUndefined":336,"lodash/trimEnd":351}],412:[function(require,module,exports){ | ||
36442 | "use strict"; | ||
36443 | |||
36444 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36445 | |||
36446 | Object.defineProperty(exports, "__esModule", { | ||
36447 | value: true | ||
36448 | }); | ||
36449 | |||
36450 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36451 | |||
36452 | var Keypair = require("../keypair").Keypair; | ||
36453 | |||
36454 | var StrKey = require("../strkey").StrKey; | ||
36455 | |||
36456 | /** | ||
36457 | * Transfers native balance to destination account. | ||
36458 | * @function | ||
36459 | * @alias Operation.accountMerge | ||
36460 | * @param {object} opts | ||
36461 | * @param {string} opts.destination - Destination to merge the source account into. | ||
36462 | * @param {string} [opts.source] - The source account (defaults to transaction source). | ||
36463 | * @returns {xdr.AccountMergeOp} | ||
36464 | */ | ||
36465 | var accountMerge = function accountMerge(opts) { | ||
36466 | var opAttributes = {}; | ||
36467 | if (!StrKey.isValidEd25519PublicKey(opts.destination)) { | ||
36468 | throw new Error("destination is invalid"); | ||
36469 | } | ||
36470 | opAttributes.body = xdr.OperationBody.accountMerge(Keypair.fromPublicKey(opts.destination).xdrAccountId()); | ||
36471 | this.setSourceAccount(opAttributes, opts); | ||
36472 | |||
36473 | return new xdr.Operation(opAttributes); | ||
36474 | }; | ||
36475 | exports.accountMerge = accountMerge; | ||
36476 | },{"../generated/stellar-xdr_generated":405,"../keypair":408,"../strkey":426}],413:[function(require,module,exports){ | ||
36477 | "use strict"; | ||
36478 | |||
36479 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36480 | |||
36481 | Object.defineProperty(exports, "__esModule", { | ||
36482 | value: true | ||
36483 | }); | ||
36484 | |||
36485 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36486 | |||
36487 | var Keypair = require("../keypair").Keypair; | ||
36488 | |||
36489 | var StrKey = require("../strkey").StrKey; | ||
36490 | |||
36491 | var padEnd = _interopRequire(require("lodash/padEnd")); | ||
36492 | |||
36493 | /** | ||
36494 | * Returns an XDR AllowTrustOp. An "allow trust" operation authorizes another | ||
36495 | * account to hold your account's credit for a given asset. | ||
36496 | * @function | ||
36497 | * @alias Operation.allowTrust | ||
36498 | * @param {object} opts | ||
36499 | * @param {string} opts.trustor - The trusting account (the one being authorized) | ||
36500 | * @param {string} opts.assetCode - The asset code being authorized. | ||
36501 | * @param {boolean} opts.authorize - True to authorize the line, false to deauthorize. | ||
36502 | * @param {string} [opts.source] - The source account (defaults to transaction source). | ||
36503 | * @returns {xdr.AllowTrustOp} | ||
36504 | */ | ||
36505 | var allowTrust = function allowTrust(opts) { | ||
36506 | if (!StrKey.isValidEd25519PublicKey(opts.trustor)) { | ||
36507 | throw new Error("trustor is invalid"); | ||
36508 | } | ||
36509 | var attributes = {}; | ||
36510 | attributes.trustor = Keypair.fromPublicKey(opts.trustor).xdrAccountId(); | ||
36511 | if (opts.assetCode.length <= 4) { | ||
36512 | var code = padEnd(opts.assetCode, 4, "\u0000"); | ||
36513 | attributes.asset = xdr.AllowTrustOpAsset.assetTypeCreditAlphanum4(code); | ||
36514 | } else if (opts.assetCode.length <= 12) { | ||
36515 | var code = padEnd(opts.assetCode, 12, "\u0000"); | ||
36516 | attributes.asset = xdr.AllowTrustOpAsset.assetTypeCreditAlphanum12(code); | ||
36517 | } else { | ||
36518 | throw new Error("Asset code must be 12 characters at max."); | ||
36519 | } | ||
36520 | attributes.authorize = opts.authorize; | ||
36521 | var allowTrustOp = new xdr.AllowTrustOp(attributes); | ||
36522 | |||
36523 | var opAttributes = {}; | ||
36524 | opAttributes.body = xdr.OperationBody.allowTrust(allowTrustOp); | ||
36525 | this.setSourceAccount(opAttributes, opts); | ||
36526 | |||
36527 | return new xdr.Operation(opAttributes); | ||
36528 | }; | ||
36529 | exports.allowTrust = allowTrust; | ||
36530 | },{"../generated/stellar-xdr_generated":405,"../keypair":408,"../strkey":426,"lodash/padEnd":341}],414:[function(require,module,exports){ | ||
36531 | "use strict"; | ||
36532 | |||
36533 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36534 | |||
36535 | Object.defineProperty(exports, "__esModule", { | ||
36536 | value: true | ||
36537 | }); | ||
36538 | |||
36539 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36540 | |||
36541 | var Hyper = require("js-xdr").Hyper; | ||
36542 | |||
36543 | var BigNumber = _interopRequire(require("bignumber.js")); | ||
36544 | |||
36545 | var isString = _interopRequire(require("lodash/isString")); | ||
36546 | |||
36547 | /** | ||
36548 | * This operation bumps sequence number. | ||
36549 | * @function | ||
36550 | * @alias Operation.bumpSequence | ||
36551 | * @param {object} opts | ||
36552 | * @param {string} opts.bumpTo - Sequence number to bump to. | ||
36553 | * @param {string} [opts.source] - The optional source account. | ||
36554 | * @returns {xdr.BumpSequenceOp} | ||
36555 | */ | ||
36556 | var bumpSequence = function bumpSequence(opts) { | ||
36557 | var attributes = {}; | ||
36558 | |||
36559 | if (!isString(opts.bumpTo)) { | ||
36560 | throw new Error("bumpTo must be a string"); | ||
36561 | } | ||
36562 | |||
36563 | try { | ||
36564 | new BigNumber(opts.bumpTo); | ||
36565 | } catch (e) { | ||
36566 | throw new Error("bumpTo must be a stringified number"); | ||
36567 | } | ||
36568 | |||
36569 | attributes.bumpTo = Hyper.fromString(opts.bumpTo); | ||
36570 | |||
36571 | var bumpSequenceOp = new xdr.BumpSequenceOp(attributes); | ||
36572 | |||
36573 | var opAttributes = {}; | ||
36574 | opAttributes.body = xdr.OperationBody.bumpSequence(bumpSequenceOp); | ||
36575 | this.setSourceAccount(opAttributes, opts); | ||
36576 | |||
36577 | return new xdr.Operation(opAttributes); | ||
36578 | }; | ||
36579 | exports.bumpSequence = bumpSequence; | ||
36580 | },{"../generated/stellar-xdr_generated":405,"bignumber.js":17,"js-xdr":127,"lodash/isString":333}],415:[function(require,module,exports){ | ||
36581 | "use strict"; | ||
36582 | |||
36583 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36584 | |||
36585 | Object.defineProperty(exports, "__esModule", { | ||
36586 | value: true | ||
36587 | }); | ||
36588 | |||
36589 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36590 | |||
36591 | var Keypair = require("../keypair").Keypair; | ||
36592 | |||
36593 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
36594 | |||
36595 | var Hyper = require("js-xdr").Hyper; | ||
36596 | |||
36597 | var BigNumber = _interopRequire(require("bignumber.js")); | ||
36598 | |||
36599 | var MAX_INT64 = "9223372036854775807"; | ||
36600 | |||
36601 | /** | ||
36602 | * Returns an XDR ChangeTrustOp. A "change trust" operation adds, removes, or updates a | ||
36603 | * trust line for a given asset from the source account to another. The issuer being | ||
36604 | * trusted and the asset code are in the given Asset object. | ||
36605 | * @function | ||
36606 | * @alias Operation.changeTrust | ||
36607 | * @param {object} opts | ||
36608 | * @param {Asset} opts.asset - The asset for the trust line. | ||
36609 | * @param {string} [opts.limit] - The limit for the asset, defaults to max int64. | ||
36610 | * If the limit is set to "0" it deletes the trustline. | ||
36611 | * @param {string} [opts.source] - The source account (defaults to transaction source). | ||
36612 | * @returns {xdr.ChangeTrustOp} | ||
36613 | */ | ||
36614 | var changeTrust = function changeTrust(opts) { | ||
36615 | var attributes = {}; | ||
36616 | attributes.line = opts.asset.toXDRObject(); | ||
36617 | if (!isUndefined(opts.limit) && !this.isValidAmount(opts.limit, true)) { | ||
36618 | throw new TypeError(this.constructAmountRequirementsError("limit")); | ||
36619 | } | ||
36620 | |||
36621 | if (opts.limit) { | ||
36622 | attributes.limit = this._toXDRAmount(opts.limit); | ||
36623 | } else { | ||
36624 | attributes.limit = Hyper.fromString(new BigNumber(MAX_INT64).toString()); | ||
36625 | } | ||
36626 | |||
36627 | if (opts.source) { | ||
36628 | attributes.source = opts.source.masterKeypair; | ||
36629 | } | ||
36630 | var changeTrustOP = new xdr.ChangeTrustOp(attributes); | ||
36631 | |||
36632 | var opAttributes = {}; | ||
36633 | opAttributes.body = xdr.OperationBody.changeTrust(changeTrustOP); | ||
36634 | this.setSourceAccount(opAttributes, opts); | ||
36635 | |||
36636 | return new xdr.Operation(opAttributes); | ||
36637 | }; | ||
36638 | exports.changeTrust = changeTrust; | ||
36639 | },{"../generated/stellar-xdr_generated":405,"../keypair":408,"bignumber.js":17,"js-xdr":127,"lodash/isUndefined":336}],416:[function(require,module,exports){ | ||
36640 | "use strict"; | ||
36641 | |||
36642 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36643 | |||
36644 | Object.defineProperty(exports, "__esModule", { | ||
36645 | value: true | ||
36646 | }); | ||
36647 | |||
36648 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36649 | |||
36650 | var Keypair = require("../keypair").Keypair; | ||
36651 | |||
36652 | var StrKey = require("../strkey").StrKey; | ||
36653 | |||
36654 | /** | ||
36655 | * Create and fund a non existent account. | ||
36656 | * @function | ||
36657 | * @alias Operation.createAccount | ||
36658 | * @param {object} opts | ||
36659 | * @param {string} opts.destination - Destination account ID to create an account for. | ||
36660 | * @param {string} opts.startingBalance - Amount in XLM the account should be funded for. Must be greater | ||
36661 | * than the [reserve balance amount](https://www.stellar.org/developers/learn/concepts/fees.html). | ||
36662 | * @param {string} [opts.source] - The source account for the payment. Defaults to the transaction's source account. | ||
36663 | * @returns {xdr.CreateAccountOp} | ||
36664 | */ | ||
36665 | var createAccount = (function (_createAccount) { | ||
36666 | var _createAccountWrapper = function createAccount(_x) { | ||
36667 | return _createAccount.apply(this, arguments); | ||
36668 | }; | ||
36669 | |||
36670 | _createAccountWrapper.toString = function () { | ||
36671 | return _createAccount.toString(); | ||
36672 | }; | ||
36673 | |||
36674 | return _createAccountWrapper; | ||
36675 | })(function (opts) { | ||
36676 | if (!StrKey.isValidEd25519PublicKey(opts.destination)) { | ||
36677 | throw new Error("destination is invalid"); | ||
36678 | } | ||
36679 | if (!this.isValidAmount(opts.startingBalance)) { | ||
36680 | throw new TypeError(this.constructAmountRequirementsError("startingBalance")); | ||
36681 | } | ||
36682 | var attributes = {}; | ||
36683 | attributes.destination = Keypair.fromPublicKey(opts.destination).xdrAccountId(); | ||
36684 | attributes.startingBalance = this._toXDRAmount(opts.startingBalance); | ||
36685 | var createAccount = new xdr.CreateAccountOp(attributes); | ||
36686 | |||
36687 | var opAttributes = {}; | ||
36688 | opAttributes.body = xdr.OperationBody.createAccount(createAccount); | ||
36689 | this.setSourceAccount(opAttributes, opts); | ||
36690 | |||
36691 | return new xdr.Operation(opAttributes); | ||
36692 | }); | ||
36693 | exports.createAccount = createAccount; | ||
36694 | },{"../generated/stellar-xdr_generated":405,"../keypair":408,"../strkey":426}],417:[function(require,module,exports){ | ||
36695 | "use strict"; | ||
36696 | |||
36697 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36698 | |||
36699 | Object.defineProperty(exports, "__esModule", { | ||
36700 | value: true | ||
36701 | }); | ||
36702 | |||
36703 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36704 | |||
36705 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
36706 | |||
36707 | /** | ||
36708 | * Returns a XDR CreatePasiveOfferOp. A "create passive offer" operation creates an | ||
36709 | * offer that won't consume a counter offer that exactly matches this offer. This is | ||
36710 | * useful for offers just used as 1:1 exchanges for path payments. Use manage offer | ||
36711 | * to manage this offer after using this operation to create it. | ||
36712 | * @function | ||
36713 | * @alias Operation.createPassiveOffer | ||
36714 | * @param {object} opts | ||
36715 | * @param {Asset} opts.selling - What you're selling. | ||
36716 | * @param {Asset} opts.buying - What you're buying. | ||
36717 | * @param {string} opts.amount - The total amount you're selling. If 0, deletes the offer. | ||
36718 | * @param {number|string|BigNumber|Object} opts.price - Price of 1 unit of `selling` in terms of `buying`. | ||
36719 | * @param {number} opts.price.n - If `opts.price` is an object: the price numerator | ||
36720 | * @param {number} opts.price.d - If `opts.price` is an object: the price denominator | ||
36721 | * @param {string} [opts.source] - The source account (defaults to transaction source). | ||
36722 | * @throws {Error} Throws `Error` when the best rational approximation of `price` cannot be found. | ||
36723 | * @returns {xdr.CreatePassiveOfferOp} | ||
36724 | */ | ||
36725 | var createPassiveOffer = function createPassiveOffer(opts) { | ||
36726 | var attributes = {}; | ||
36727 | attributes.selling = opts.selling.toXDRObject(); | ||
36728 | attributes.buying = opts.buying.toXDRObject(); | ||
36729 | if (!this.isValidAmount(opts.amount)) { | ||
36730 | throw new TypeError(this.constructAmountRequirementsError("amount")); | ||
36731 | } | ||
36732 | attributes.amount = this._toXDRAmount(opts.amount); | ||
36733 | if (isUndefined(opts.price)) { | ||
36734 | throw new TypeError("price argument is required"); | ||
36735 | } | ||
36736 | attributes.price = this._toXDRPrice(opts.price); | ||
36737 | var createPassiveOfferOp = new xdr.CreatePassiveOfferOp(attributes); | ||
36738 | |||
36739 | var opAttributes = {}; | ||
36740 | opAttributes.body = xdr.OperationBody.createPassiveOffer(createPassiveOfferOp); | ||
36741 | this.setSourceAccount(opAttributes, opts); | ||
36742 | |||
36743 | return new xdr.Operation(opAttributes); | ||
36744 | }; | ||
36745 | exports.createPassiveOffer = createPassiveOffer; | ||
36746 | },{"../generated/stellar-xdr_generated":405,"lodash/isUndefined":336}],418:[function(require,module,exports){ | ||
36747 | "use strict"; | ||
36748 | |||
36749 | Object.defineProperty(exports, "__esModule", { | ||
36750 | value: true | ||
36751 | }); | ||
36752 | exports.accountMerge = require("./account_merge").accountMerge; | ||
36753 | exports.allowTrust = require("./allow_trust").allowTrust; | ||
36754 | exports.bumpSequence = require("./bump_sequence").bumpSequence; | ||
36755 | exports.changeTrust = require("./change_trust").changeTrust; | ||
36756 | exports.createAccount = require("./create_account").createAccount; | ||
36757 | exports.createPassiveOffer = require("./create_passive_offer").createPassiveOffer; | ||
36758 | exports.inflation = require("./inflation").inflation; | ||
36759 | exports.manageData = require("./manage_data").manageData; | ||
36760 | exports.manageOffer = require("./manage_offer").manageOffer; | ||
36761 | exports.pathPayment = require("./path_payment").pathPayment; | ||
36762 | exports.payment = require("./payment").payment; | ||
36763 | exports.setOptions = require("./set_options").setOptions; | ||
36764 | },{"./account_merge":412,"./allow_trust":413,"./bump_sequence":414,"./change_trust":415,"./create_account":416,"./create_passive_offer":417,"./inflation":419,"./manage_data":420,"./manage_offer":421,"./path_payment":422,"./payment":423,"./set_options":424}],419:[function(require,module,exports){ | ||
36765 | "use strict"; | ||
36766 | |||
36767 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36768 | |||
36769 | Object.defineProperty(exports, "__esModule", { | ||
36770 | value: true | ||
36771 | }); | ||
36772 | |||
36773 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36774 | |||
36775 | /** | ||
36776 | * This operation generates the inflation. | ||
36777 | * @function | ||
36778 | * @alias Operation.inflation | ||
36779 | * @param {object} [opts] | ||
36780 | * @param {string} [opts.source] - The optional source account. | ||
36781 | * @returns {xdr.InflationOp} | ||
36782 | */ | ||
36783 | var inflation = function inflation() { | ||
36784 | var opts = arguments[0] === undefined ? {} : arguments[0]; | ||
36785 | |||
36786 | var opAttributes = {}; | ||
36787 | opAttributes.body = xdr.OperationBody.inflation(); | ||
36788 | this.setSourceAccount(opAttributes, opts); | ||
36789 | return new xdr.Operation(opAttributes); | ||
36790 | }; | ||
36791 | exports.inflation = inflation; | ||
36792 | },{"../generated/stellar-xdr_generated":405}],420:[function(require,module,exports){ | ||
36793 | (function (Buffer){ | ||
36794 | "use strict"; | ||
36795 | |||
36796 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36797 | |||
36798 | Object.defineProperty(exports, "__esModule", { | ||
36799 | value: true | ||
36800 | }); | ||
36801 | |||
36802 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36803 | |||
36804 | var isString = _interopRequire(require("lodash/isString")); | ||
36805 | |||
36806 | /** | ||
36807 | * This operation adds data entry to the ledger. | ||
36808 | * @function | ||
36809 | * @alias Operation.manageData | ||
36810 | * @param {object} opts | ||
36811 | * @param {string} opts.name - The name of the data entry. | ||
36812 | * @param {string|Buffer} opts.value - The value of the data entry. | ||
36813 | * @param {string} [opts.source] - The optional source account. | ||
36814 | * @returns {xdr.ManageDataOp} | ||
36815 | */ | ||
36816 | var manageData = function manageData(opts) { | ||
36817 | var attributes = {}; | ||
36818 | |||
36819 | if (!(isString(opts.name) && opts.name.length <= 64)) { | ||
36820 | throw new Error("name must be a string, up to 64 characters"); | ||
36821 | } | ||
36822 | attributes.dataName = opts.name; | ||
36823 | |||
36824 | if (!isString(opts.value) && !Buffer.isBuffer(opts.value) && opts.value !== null) { | ||
36825 | throw new Error("value must be a string, Buffer or null"); | ||
36826 | } | ||
36827 | |||
36828 | if (isString(opts.value)) { | ||
36829 | attributes.dataValue = Buffer.from(opts.value); | ||
36830 | } else { | ||
36831 | attributes.dataValue = opts.value; | ||
36832 | } | ||
36833 | |||
36834 | if (attributes.dataValue !== null && attributes.dataValue.length > 64) { | ||
36835 | throw new Error("value cannot be longer that 64 bytes"); | ||
36836 | } | ||
36837 | |||
36838 | var manageDataOp = new xdr.ManageDataOp(attributes); | ||
36839 | |||
36840 | var opAttributes = {}; | ||
36841 | opAttributes.body = xdr.OperationBody.manageDatum(manageDataOp); | ||
36842 | this.setSourceAccount(opAttributes, opts); | ||
36843 | |||
36844 | return new xdr.Operation(opAttributes); | ||
36845 | }; | ||
36846 | exports.manageData = manageData; | ||
36847 | }).call(this,require("buffer").Buffer) | ||
36848 | },{"../generated/stellar-xdr_generated":405,"buffer":49,"lodash/isString":333}],421:[function(require,module,exports){ | ||
36849 | "use strict"; | ||
36850 | |||
36851 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36852 | |||
36853 | Object.defineProperty(exports, "__esModule", { | ||
36854 | value: true | ||
36855 | }); | ||
36856 | |||
36857 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36858 | |||
36859 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
36860 | |||
36861 | var UnsignedHyper = require("js-xdr").UnsignedHyper; | ||
36862 | |||
36863 | /** | ||
36864 | * Returns a XDR ManageOfferOp. A "manage offer" operation creates, updates, or | ||
36865 | * deletes an offer. | ||
36866 | * @function | ||
36867 | * @alias Operation.manageOffer | ||
36868 | * @param {object} opts | ||
36869 | * @param {Asset} opts.selling - What you're selling. | ||
36870 | * @param {Asset} opts.buying - What you're buying. | ||
36871 | * @param {string} opts.amount - The total amount you're selling. If 0, deletes the offer. | ||
36872 | * @param {number|string|BigNumber|Object} opts.price - Price of 1 unit of `selling` in terms of `buying`. | ||
36873 | * @param {number} opts.price.n - If `opts.price` is an object: the price numerator | ||
36874 | * @param {number} opts.price.d - If `opts.price` is an object: the price denominator | ||
36875 | * @param {number|string} [opts.offerId ] - If `0`, will create a new offer (default). Otherwise, edits an exisiting offer. | ||
36876 | * @param {string} [opts.source] - The source account (defaults to transaction source). | ||
36877 | * @throws {Error} Throws `Error` when the best rational approximation of `price` cannot be found. | ||
36878 | * @returns {xdr.ManageOfferOp} | ||
36879 | */ | ||
36880 | var manageOffer = function manageOffer(opts) { | ||
36881 | var attributes = {}; | ||
36882 | attributes.selling = opts.selling.toXDRObject(); | ||
36883 | attributes.buying = opts.buying.toXDRObject(); | ||
36884 | if (!this.isValidAmount(opts.amount, true)) { | ||
36885 | throw new TypeError(this.constructAmountRequirementsError("amount")); | ||
36886 | } | ||
36887 | attributes.amount = this._toXDRAmount(opts.amount); | ||
36888 | if (isUndefined(opts.price)) { | ||
36889 | throw new TypeError("price argument is required"); | ||
36890 | } | ||
36891 | attributes.price = this._toXDRPrice(opts.price); | ||
36892 | |||
36893 | if (!isUndefined(opts.offerId)) { | ||
36894 | opts.offerId = opts.offerId.toString(); | ||
36895 | } else { | ||
36896 | opts.offerId = "0"; | ||
36897 | } | ||
36898 | attributes.offerId = UnsignedHyper.fromString(opts.offerId); | ||
36899 | var manageOfferOp = new xdr.ManageOfferOp(attributes); | ||
36900 | |||
36901 | var opAttributes = {}; | ||
36902 | opAttributes.body = xdr.OperationBody.manageOffer(manageOfferOp); | ||
36903 | this.setSourceAccount(opAttributes, opts); | ||
36904 | |||
36905 | return new xdr.Operation(opAttributes); | ||
36906 | }; | ||
36907 | exports.manageOffer = manageOffer; | ||
36908 | },{"../generated/stellar-xdr_generated":405,"js-xdr":127,"lodash/isUndefined":336}],422:[function(require,module,exports){ | ||
36909 | "use strict"; | ||
36910 | |||
36911 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36912 | |||
36913 | Object.defineProperty(exports, "__esModule", { | ||
36914 | value: true | ||
36915 | }); | ||
36916 | |||
36917 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36918 | |||
36919 | var Keypair = require("../keypair").Keypair; | ||
36920 | |||
36921 | var StrKey = require("../strkey").StrKey; | ||
36922 | |||
36923 | /** | ||
36924 | * Returns a XDR PaymentOp. A "payment" operation send the specified amount to the | ||
36925 | * destination account, optionally through a path. XLM payments create the destination | ||
36926 | * account if it does not exist. | ||
36927 | * @function | ||
36928 | * @alias Operation.pathPayment | ||
36929 | * @param {object} opts | ||
36930 | * @param {Asset} opts.sendAsset - The asset to pay with. | ||
36931 | * @param {string} opts.sendMax - The maximum amount of sendAsset to send. | ||
36932 | * @param {string} opts.destination - The destination account to send to. | ||
36933 | * @param {Asset} opts.destAsset - The asset the destination will receive. | ||
36934 | * @param {string} opts.destAmount - The amount the destination receives. | ||
36935 | * @param {Asset[]} opts.path - An array of Asset objects to use as the path. | ||
36936 | * @param {string} [opts.source] - The source account for the payment. Defaults to the transaction's source account. | ||
36937 | * @returns {xdr.PathPaymentOp} | ||
36938 | */ | ||
36939 | var pathPayment = function pathPayment(opts) { | ||
36940 | switch (true) { | ||
36941 | case !opts.sendAsset: | ||
36942 | throw new Error("Must specify a send asset"); | ||
36943 | case !this.isValidAmount(opts.sendMax): | ||
36944 | throw new TypeError(this.constructAmountRequirementsError("sendMax")); | ||
36945 | case !StrKey.isValidEd25519PublicKey(opts.destination): | ||
36946 | throw new Error("destination is invalid"); | ||
36947 | case !opts.destAsset: | ||
36948 | throw new Error("Must provide a destAsset for a payment operation"); | ||
36949 | case !this.isValidAmount(opts.destAmount): | ||
36950 | throw new TypeError(this.constructAmountRequirementsError("destAmount")); | ||
36951 | } | ||
36952 | |||
36953 | var attributes = {}; | ||
36954 | attributes.sendAsset = opts.sendAsset.toXDRObject(); | ||
36955 | attributes.sendMax = this._toXDRAmount(opts.sendMax); | ||
36956 | attributes.destination = Keypair.fromPublicKey(opts.destination).xdrAccountId(); | ||
36957 | attributes.destAsset = opts.destAsset.toXDRObject(); | ||
36958 | attributes.destAmount = this._toXDRAmount(opts.destAmount); | ||
36959 | |||
36960 | var path = opts.path ? opts.path : []; | ||
36961 | attributes.path = path.map(function (x) { | ||
36962 | return x.toXDRObject(); | ||
36963 | }); | ||
36964 | |||
36965 | var payment = new xdr.PathPaymentOp(attributes); | ||
36966 | |||
36967 | var opAttributes = {}; | ||
36968 | opAttributes.body = xdr.OperationBody.pathPayment(payment); | ||
36969 | this.setSourceAccount(opAttributes, opts); | ||
36970 | |||
36971 | return new xdr.Operation(opAttributes); | ||
36972 | }; | ||
36973 | exports.pathPayment = pathPayment; | ||
36974 | },{"../generated/stellar-xdr_generated":405,"../keypair":408,"../strkey":426}],423:[function(require,module,exports){ | ||
36975 | "use strict"; | ||
36976 | |||
36977 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
36978 | |||
36979 | Object.defineProperty(exports, "__esModule", { | ||
36980 | value: true | ||
36981 | }); | ||
36982 | |||
36983 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
36984 | |||
36985 | var Keypair = require("../keypair").Keypair; | ||
36986 | |||
36987 | var StrKey = require("../strkey").StrKey; | ||
36988 | |||
36989 | /** | ||
36990 | * Create a payment operation. | ||
36991 | * @function | ||
36992 | * @alias Operation.payment | ||
36993 | * @param {object} opts | ||
36994 | * @param {string} opts.destination - The destination account ID. | ||
36995 | * @param {Asset} opts.asset - The asset to send. | ||
36996 | * @param {string} opts.amount - The amount to send. | ||
36997 | * @param {string} [opts.source] - The source account for the payment. Defaults to the transaction's source account. | ||
36998 | * @returns {xdr.PaymentOp} | ||
36999 | */ | ||
37000 | var payment = (function (_payment) { | ||
37001 | var _paymentWrapper = function payment(_x) { | ||
37002 | return _payment.apply(this, arguments); | ||
37003 | }; | ||
37004 | |||
37005 | _paymentWrapper.toString = function () { | ||
37006 | return _payment.toString(); | ||
37007 | }; | ||
37008 | |||
37009 | return _paymentWrapper; | ||
37010 | })(function (opts) { | ||
37011 | if (!StrKey.isValidEd25519PublicKey(opts.destination)) { | ||
37012 | throw new Error("destination is invalid"); | ||
37013 | } | ||
37014 | if (!opts.asset) { | ||
37015 | throw new Error("Must provide an asset for a payment operation"); | ||
37016 | } | ||
37017 | if (!this.isValidAmount(opts.amount)) { | ||
37018 | throw new TypeError(this.constructAmountRequirementsError("amount")); | ||
37019 | } | ||
37020 | |||
37021 | var attributes = {}; | ||
37022 | attributes.destination = Keypair.fromPublicKey(opts.destination).xdrAccountId(); | ||
37023 | attributes.asset = opts.asset.toXDRObject(); | ||
37024 | attributes.amount = this._toXDRAmount(opts.amount); | ||
37025 | var payment = new xdr.PaymentOp(attributes); | ||
37026 | |||
37027 | var opAttributes = {}; | ||
37028 | opAttributes.body = xdr.OperationBody.payment(payment); | ||
37029 | this.setSourceAccount(opAttributes, opts); | ||
37030 | |||
37031 | return new xdr.Operation(opAttributes); | ||
37032 | }); | ||
37033 | exports.payment = payment; | ||
37034 | },{"../generated/stellar-xdr_generated":405,"../keypair":408,"../strkey":426}],424:[function(require,module,exports){ | ||
37035 | (function (Buffer){ | ||
37036 | "use strict"; | ||
37037 | |||
37038 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
37039 | |||
37040 | Object.defineProperty(exports, "__esModule", { | ||
37041 | value: true | ||
37042 | }); | ||
37043 | |||
37044 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | ||
37045 | |||
37046 | var Keypair = require("../keypair").Keypair; | ||
37047 | |||
37048 | var StrKey = require("../strkey").StrKey; | ||
37049 | |||
37050 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
37051 | |||
37052 | var isString = _interopRequire(require("lodash/isString")); | ||
37053 | |||
37054 | /** | ||
37055 | * Returns an XDR SetOptionsOp. A "set options" operations set or clear account flags, | ||
37056 | * set the account's inflation destination, and/or add new signers to the account. | ||
37057 | * The flags used in `opts.clearFlags` and `opts.setFlags` can be the following: | ||
37058 | * - `{@link AuthRequiredFlag}` | ||
37059 | * - `{@link AuthRevocableFlag}` | ||
37060 | * - `{@link AuthImmutableFlag}` | ||
37061 | * | ||
37062 | * It's possible to set/clear multiple flags at once using logical or. | ||
37063 | * @function | ||
37064 | * @alias Operation.setOptions | ||
37065 | * @param {object} opts | ||
37066 | * @param {string} [opts.inflationDest] - Set this account ID as the account's inflation destination. | ||
37067 | * @param {(number|string)} [opts.clearFlags] - Bitmap integer for which account flags to clear. | ||
37068 | * @param {(number|string)} [opts.setFlags] - Bitmap integer for which account flags to set. | ||
37069 | * @param {number|string} [opts.masterWeight] - The master key weight. | ||
37070 | * @param {number|string} [opts.lowThreshold] - The sum weight for the low threshold. | ||
37071 | * @param {number|string} [opts.medThreshold] - The sum weight for the medium threshold. | ||
37072 | * @param {number|string} [opts.highThreshold] - The sum weight for the high threshold. | ||
37073 | * @param {object} [opts.signer] - Add or remove a signer from the account. The signer is | ||
37074 | * deleted if the weight is 0. Only one of `ed25519PublicKey`, `sha256Hash`, `preAuthTx` should be defined. | ||
37075 | * @param {string} [opts.signer.ed25519PublicKey] - The ed25519 public key of the signer. | ||
37076 | * @param {Buffer|string} [opts.signer.sha256Hash] - sha256 hash (Buffer or hex string) of preimage that will unlock funds. Preimage should be used as signature of future transaction. | ||
37077 | * @param {Buffer|string} [opts.signer.preAuthTx] - Hash (Buffer or hex string) of transaction that will unlock funds. | ||
37078 | * @param {number|string} [opts.signer.weight] - The weight of the new signer (0 to delete or 1-255) | ||
37079 | * @param {string} [opts.homeDomain] - sets the home domain used for reverse federation lookup. | ||
37080 | * @param {string} [opts.source] - The source account (defaults to transaction source). | ||
37081 | * @returns {xdr.SetOptionsOp} | ||
37082 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | ||
37083 | */ | ||
37084 | var setOptions = function setOptions(opts) { | ||
37085 | var attributes = {}; | ||
37086 | |||
37087 | if (opts.inflationDest) { | ||
37088 | if (!StrKey.isValidEd25519PublicKey(opts.inflationDest)) { | ||
37089 | throw new Error("inflationDest is invalid"); | ||
37090 | } | ||
37091 | attributes.inflationDest = Keypair.fromPublicKey(opts.inflationDest).xdrAccountId(); | ||
37092 | } | ||
37093 | |||
37094 | var weightCheckFunction = function (value, name) { | ||
37095 | if (value >= 0 && value <= 255) { | ||
37096 | return true; | ||
37097 | } else { | ||
37098 | throw new Error("" + name + " value must be between 0 and 255"); | ||
37099 | } | ||
37100 | }; | ||
37101 | |||
37102 | attributes.clearFlags = this._checkUnsignedIntValue("clearFlags", opts.clearFlags); | ||
37103 | attributes.setFlags = this._checkUnsignedIntValue("setFlags", opts.setFlags); | ||
37104 | attributes.masterWeight = this._checkUnsignedIntValue("masterWeight", opts.masterWeight, weightCheckFunction); | ||
37105 | attributes.lowThreshold = this._checkUnsignedIntValue("lowThreshold", opts.lowThreshold, weightCheckFunction); | ||
37106 | attributes.medThreshold = this._checkUnsignedIntValue("medThreshold", opts.medThreshold, weightCheckFunction); | ||
37107 | attributes.highThreshold = this._checkUnsignedIntValue("highThreshold", opts.highThreshold, weightCheckFunction); | ||
37108 | |||
37109 | if (!isUndefined(opts.homeDomain) && !isString(opts.homeDomain)) { | ||
37110 | throw new TypeError("homeDomain argument must be of type String"); | ||
37111 | } | ||
37112 | attributes.homeDomain = opts.homeDomain; | ||
37113 | |||
37114 | if (opts.signer) { | ||
37115 | var weight = this._checkUnsignedIntValue("signer.weight", opts.signer.weight, weightCheckFunction); | ||
37116 | var key = undefined; | ||
37117 | |||
37118 | var setValues = 0; | ||
37119 | |||
37120 | if (opts.signer.ed25519PublicKey) { | ||
37121 | if (!StrKey.isValidEd25519PublicKey(opts.signer.ed25519PublicKey)) { | ||
37122 | throw new Error("signer.ed25519PublicKey is invalid."); | ||
37123 | } | ||
37124 | var rawKey = StrKey.decodeEd25519PublicKey(opts.signer.ed25519PublicKey); | ||
37125 | key = new xdr.SignerKey.signerKeyTypeEd25519(rawKey); | ||
37126 | setValues++; | ||
37127 | } | ||
37128 | |||
37129 | if (opts.signer.preAuthTx) { | ||
37130 | if (isString(opts.signer.preAuthTx)) { | ||
37131 | opts.signer.preAuthTx = Buffer.from(opts.signer.preAuthTx, "hex"); | ||
37132 | } | ||
37133 | |||
37134 | if (!(Buffer.isBuffer(opts.signer.preAuthTx) && opts.signer.preAuthTx.length == 32)) { | ||
37135 | throw new Error("signer.preAuthTx must be 32 bytes Buffer."); | ||
37136 | } | ||
37137 | key = new xdr.SignerKey.signerKeyTypePreAuthTx(opts.signer.preAuthTx); | ||
37138 | setValues++; | ||
37139 | } | ||
37140 | |||
37141 | if (opts.signer.sha256Hash) { | ||
37142 | if (isString(opts.signer.sha256Hash)) { | ||
37143 | opts.signer.sha256Hash = Buffer.from(opts.signer.sha256Hash, "hex"); | ||
37144 | } | ||
37145 | |||
37146 | if (!(Buffer.isBuffer(opts.signer.sha256Hash) && opts.signer.sha256Hash.length == 32)) { | ||
37147 | throw new Error("signer.sha256Hash must be 32 bytes Buffer."); | ||
37148 | } | ||
37149 | key = new xdr.SignerKey.signerKeyTypeHashX(opts.signer.sha256Hash); | ||
37150 | setValues++; | ||
37151 | } | ||
37152 | |||
37153 | if (setValues != 1) { | ||
37154 | throw new Error("Signer object must contain exactly one of signer.ed25519PublicKey, signer.sha256Hash, signer.preAuthTx."); | ||
37155 | } | ||
37156 | |||
37157 | attributes.signer = new xdr.Signer({ key: key, weight: weight }); | ||
37158 | } | ||
37159 | |||
37160 | var setOptionsOp = new xdr.SetOptionsOp(attributes); | ||
37161 | |||
37162 | var opAttributes = {}; | ||
37163 | opAttributes.body = xdr.OperationBody.setOption(setOptionsOp); | ||
37164 | this.setSourceAccount(opAttributes, opts); | ||
37165 | |||
37166 | return new xdr.Operation(opAttributes); | ||
37167 | }; | ||
37168 | exports.setOptions = setOptions; | ||
37169 | }).call(this,require("buffer").Buffer) | ||
37170 | },{"../generated/stellar-xdr_generated":405,"../keypair":408,"../strkey":426,"buffer":49,"lodash/isString":333,"lodash/isUndefined":336}],425:[function(require,module,exports){ | ||
37171 | (function (Buffer){ | ||
37172 | "use strict"; | ||
37173 | |||
37174 | exports.sign = sign; | ||
37175 | exports.verify = verify; | ||
37176 | Object.defineProperty(exports, "__esModule", { | ||
37177 | value: true | ||
37178 | }); | ||
37179 | // This module provides the signing functionality used by the stellar network | ||
37180 | // The code below may look a little strange... this is because we try to provide | ||
37181 | // the most efficient signing method possible. First, we try to load the | ||
37182 | // native ed25519 package for node.js environments, and if that fails we | ||
37183 | // fallback to tweetnacl.js | ||
37184 | |||
37185 | var actualMethods = {}; | ||
37186 | |||
37187 | /** | ||
37188 | * Use this flag to check if fast signing (provided by `ed25519` package) is available. | ||
37189 | * If your app is signing a large number of transaction or verifying a large number | ||
37190 | * of signatures make sure `ed25519` package is installed. | ||
37191 | */ | ||
37192 | var FastSigning = checkFastSigning(); | ||
37193 | |||
37194 | exports.FastSigning = FastSigning; | ||
37195 | |||
37196 | function sign(data, secretKey) { | ||
37197 | return actualMethods.sign(data, secretKey); | ||
37198 | } | ||
37199 | |||
37200 | function verify(data, signature, publicKey) { | ||
37201 | return actualMethods.verify(data, signature, publicKey); | ||
37202 | } | ||
37203 | |||
37204 | function checkFastSigning() { | ||
37205 | return typeof window === "undefined" ? checkFastSigningNode() : checkFastSigningBrowser(); | ||
37206 | } | ||
37207 | |||
37208 | function checkFastSigningNode() { | ||
37209 | // NOTE: we use commonjs style require here because es6 imports | ||
37210 | // can only occur at the top level. thanks, obama. | ||
37211 | var ed25519 = undefined; | ||
37212 | try { | ||
37213 | ed25519 = require("ed25519"); | ||
37214 | } catch (err) { | ||
37215 | return checkFastSigningBrowser(); | ||
37216 | } | ||
37217 | |||
37218 | actualMethods.sign = function (data, secretKey) { | ||
37219 | return ed25519.Sign(Buffer.from(data), secretKey); | ||
37220 | }; | ||
37221 | |||
37222 | actualMethods.verify = function (data, signature, publicKey) { | ||
37223 | data = Buffer.from(data); | ||
37224 | try { | ||
37225 | return ed25519.Verify(data, signature, publicKey); | ||
37226 | } catch (e) { | ||
37227 | return false; | ||
37228 | } | ||
37229 | }; | ||
37230 | |||
37231 | return true; | ||
37232 | } | ||
37233 | |||
37234 | function checkFastSigningBrowser() { | ||
37235 | // fallback to tweetnacl.js if we're in the browser or | ||
37236 | // if there was a failure installing ed25519 | ||
37237 | var nacl = require("tweetnacl"); | ||
37238 | |||
37239 | actualMethods.sign = function (data, secretKey) { | ||
37240 | data = Buffer.from(data); | ||
37241 | data = new Uint8Array(data.toJSON().data); | ||
37242 | secretKey = new Uint8Array(secretKey.toJSON().data); | ||
37243 | |||
37244 | var signature = nacl.sign.detached(data, secretKey); | ||
37245 | |||
37246 | return Buffer.from(signature); | ||
37247 | }; | ||
37248 | |||
37249 | actualMethods.verify = function (data, signature, publicKey) { | ||
37250 | data = Buffer.from(data); | ||
37251 | data = new Uint8Array(data.toJSON().data); | ||
37252 | signature = new Uint8Array(signature.toJSON().data); | ||
37253 | publicKey = new Uint8Array(publicKey.toJSON().data); | ||
37254 | |||
37255 | return nacl.sign.detached.verify(data, signature, publicKey); | ||
37256 | }; | ||
37257 | |||
37258 | return false; | ||
37259 | } | ||
37260 | }).call(this,require("buffer").Buffer) | ||
37261 | },{"buffer":49,"ed25519":20,"tweetnacl":435}],426:[function(require,module,exports){ | ||
37262 | (function (Buffer){ | ||
37263 | "use strict"; | ||
37264 | |||
37265 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
37266 | |||
37267 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
37268 | |||
37269 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
37270 | |||
37271 | exports.decodeCheck = decodeCheck; | ||
37272 | exports.encodeCheck = encodeCheck; | ||
37273 | Object.defineProperty(exports, "__esModule", { | ||
37274 | value: true | ||
37275 | }); | ||
37276 | |||
37277 | var base32 = _interopRequire(require("base32.js")); | ||
37278 | |||
37279 | var crc = _interopRequire(require("crc")); | ||
37280 | |||
37281 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
37282 | |||
37283 | var isNull = _interopRequire(require("lodash/isNull")); | ||
37284 | |||
37285 | var isString = _interopRequire(require("lodash/isString")); | ||
37286 | |||
37287 | var verifyChecksum = require("./util/checksum").verifyChecksum; | ||
37288 | |||
37289 | var versionBytes = { | ||
37290 | ed25519PublicKey: 6 << 3, // G | ||
37291 | ed25519SecretSeed: 18 << 3, // S | ||
37292 | preAuthTx: 19 << 3, // T | ||
37293 | sha256Hash: 23 << 3 // X | ||
37294 | }; | ||
37295 | |||
37296 | /** | ||
37297 | * StrKey is a helper class that allows encoding and decoding strkey. | ||
37298 | */ | ||
37299 | |||
37300 | var StrKey = exports.StrKey = (function () { | ||
37301 | function StrKey() { | ||
37302 | _classCallCheck(this, StrKey); | ||
37303 | } | ||
37304 | |||
37305 | _createClass(StrKey, null, { | ||
37306 | encodeEd25519PublicKey: { | ||
37307 | /** | ||
37308 | * Encodes data to strkey ed25519 public key. | ||
37309 | * @param {Buffer} data data to encode | ||
37310 | * @returns {string} | ||
37311 | */ | ||
37312 | |||
37313 | value: function encodeEd25519PublicKey(data) { | ||
37314 | return encodeCheck("ed25519PublicKey", data); | ||
37315 | } | ||
37316 | }, | ||
37317 | decodeEd25519PublicKey: { | ||
37318 | |||
37319 | /** | ||
37320 | * Decodes strkey ed25519 public key to raw data. | ||
37321 | * @param {string} data data to decode | ||
37322 | * @returns {Buffer} | ||
37323 | */ | ||
37324 | |||
37325 | value: function decodeEd25519PublicKey(data) { | ||
37326 | return decodeCheck("ed25519PublicKey", data); | ||
37327 | } | ||
37328 | }, | ||
37329 | isValidEd25519PublicKey: { | ||
37330 | |||
37331 | /** | ||
37332 | * Returns true if the given Stellar public key is a valid ed25519 public key. | ||
37333 | * @param {string} publicKey public key to check | ||
37334 | * @returns {boolean} | ||
37335 | */ | ||
37336 | |||
37337 | value: function isValidEd25519PublicKey(publicKey) { | ||
37338 | return isValid("ed25519PublicKey", publicKey); | ||
37339 | } | ||
37340 | }, | ||
37341 | encodeEd25519SecretSeed: { | ||
37342 | |||
37343 | /** | ||
37344 | * Encodes data to strkey ed25519 seed. | ||
37345 | * @param {Buffer} data data to encode | ||
37346 | * @returns {string} | ||
37347 | */ | ||
37348 | |||
37349 | value: function encodeEd25519SecretSeed(data) { | ||
37350 | return encodeCheck("ed25519SecretSeed", data); | ||
37351 | } | ||
37352 | }, | ||
37353 | decodeEd25519SecretSeed: { | ||
37354 | |||
37355 | /** | ||
37356 | * Decodes strkey ed25519 seed to raw data. | ||
37357 | * @param {string} data data to decode | ||
37358 | * @returns {Buffer} | ||
37359 | */ | ||
37360 | |||
37361 | value: function decodeEd25519SecretSeed(data) { | ||
37362 | return decodeCheck("ed25519SecretSeed", data); | ||
37363 | } | ||
37364 | }, | ||
37365 | isValidEd25519SecretSeed: { | ||
37366 | |||
37367 | /** | ||
37368 | * Returns true if the given Stellar secret key is a valid ed25519 secret seed. | ||
37369 | * @param {string} seed seed to check | ||
37370 | * @returns {boolean} | ||
37371 | */ | ||
37372 | |||
37373 | value: function isValidEd25519SecretSeed(seed) { | ||
37374 | return isValid("ed25519SecretSeed", seed); | ||
37375 | } | ||
37376 | }, | ||
37377 | encodePreAuthTx: { | ||
37378 | |||
37379 | /** | ||
37380 | * Encodes data to strkey preAuthTx. | ||
37381 | * @param {Buffer} data data to encode | ||
37382 | * @returns {string} | ||
37383 | */ | ||
37384 | |||
37385 | value: function encodePreAuthTx(data) { | ||
37386 | return encodeCheck("preAuthTx", data); | ||
37387 | } | ||
37388 | }, | ||
37389 | decodePreAuthTx: { | ||
37390 | |||
37391 | /** | ||
37392 | * Decodes strkey PreAuthTx to raw data. | ||
37393 | * @param {string} data data to decode | ||
37394 | * @returns {Buffer} | ||
37395 | */ | ||
37396 | |||
37397 | value: function decodePreAuthTx(data) { | ||
37398 | return decodeCheck("preAuthTx", data); | ||
37399 | } | ||
37400 | }, | ||
37401 | encodeSha256Hash: { | ||
37402 | |||
37403 | /** | ||
37404 | * Encodes data to strkey sha256 hash. | ||
37405 | * @param {Buffer} data data to encode | ||
37406 | * @returns {string} | ||
37407 | */ | ||
37408 | |||
37409 | value: function encodeSha256Hash(data) { | ||
37410 | return encodeCheck("sha256Hash", data); | ||
37411 | } | ||
37412 | }, | ||
37413 | decodeSha256Hash: { | ||
37414 | |||
37415 | /** | ||
37416 | * Decodes strkey sha256 hash to raw data. | ||
37417 | * @param {string} data data to decode | ||
37418 | * @returns {Buffer} | ||
37419 | */ | ||
37420 | |||
37421 | value: function decodeSha256Hash(data) { | ||
37422 | return decodeCheck("sha256Hash", data); | ||
37423 | } | ||
37424 | } | ||
37425 | }); | ||
37426 | |||
37427 | return StrKey; | ||
37428 | })(); | ||
37429 | |||
37430 | function isValid(versionByteName, encoded) { | ||
37431 | if (encoded && encoded.length != 56) { | ||
37432 | return false; | ||
37433 | } | ||
37434 | |||
37435 | try { | ||
37436 | var decoded = decodeCheck(versionByteName, encoded); | ||
37437 | if (decoded.length !== 32) { | ||
37438 | return false; | ||
37439 | } | ||
37440 | } catch (err) { | ||
37441 | return false; | ||
37442 | } | ||
37443 | return true; | ||
37444 | } | ||
37445 | |||
37446 | function decodeCheck(versionByteName, encoded) { | ||
37447 | if (!isString(encoded)) { | ||
37448 | throw new TypeError("encoded argument must be of type String"); | ||
37449 | } | ||
37450 | |||
37451 | var decoded = base32.decode(encoded); | ||
37452 | var versionByte = decoded[0]; | ||
37453 | var payload = decoded.slice(0, -2); | ||
37454 | var data = payload.slice(1); | ||
37455 | var checksum = decoded.slice(-2); | ||
37456 | |||
37457 | if (encoded != base32.encode(decoded)) { | ||
37458 | throw new Error("invalid encoded string"); | ||
37459 | } | ||
37460 | |||
37461 | var expectedVersion = versionBytes[versionByteName]; | ||
37462 | |||
37463 | if (isUndefined(expectedVersion)) { | ||
37464 | throw new Error("" + versionByteName + " is not a valid version byte name. expected one of \"accountId\" or \"seed\""); | ||
37465 | } | ||
37466 | |||
37467 | if (versionByte !== expectedVersion) { | ||
37468 | throw new Error("invalid version byte. expected " + expectedVersion + ", got " + versionByte); | ||
37469 | } | ||
37470 | |||
37471 | var expectedChecksum = calculateChecksum(payload); | ||
37472 | |||
37473 | if (!verifyChecksum(expectedChecksum, checksum)) { | ||
37474 | throw new Error("invalid checksum"); | ||
37475 | } | ||
37476 | |||
37477 | return Buffer.from(data); | ||
37478 | } | ||
37479 | |||
37480 | function encodeCheck(versionByteName, data) { | ||
37481 | if (isNull(data) || isUndefined(data)) { | ||
37482 | throw new Error("cannot encode null data"); | ||
37483 | } | ||
37484 | |||
37485 | var versionByte = versionBytes[versionByteName]; | ||
37486 | |||
37487 | if (isUndefined(versionByte)) { | ||
37488 | throw new Error("" + versionByteName + " is not a valid version byte name. expected one of \"ed25519PublicKey\", \"ed25519SecretSeed\", \"preAuthTx\", \"sha256Hash\""); | ||
37489 | } | ||
37490 | |||
37491 | data = Buffer.from(data); | ||
37492 | var versionBuffer = Buffer.from([versionByte]); | ||
37493 | var payload = Buffer.concat([versionBuffer, data]); | ||
37494 | var checksum = calculateChecksum(payload); | ||
37495 | var unencoded = Buffer.concat([payload, checksum]); | ||
37496 | |||
37497 | return base32.encode(unencoded); | ||
37498 | } | ||
37499 | |||
37500 | function calculateChecksum(payload) { | ||
37501 | // This code calculates CRC16-XModem checksum of payload | ||
37502 | // and returns it as Buffer in little-endian order. | ||
37503 | var checksum = Buffer.alloc(2); | ||
37504 | checksum.writeUInt16LE(crc.crc16xmodem(payload), 0); | ||
37505 | return checksum; | ||
37506 | } | ||
37507 | }).call(this,require("buffer").Buffer) | ||
37508 | },{"./util/checksum":429,"base32.js":15,"buffer":49,"crc":65,"lodash/isNull":327,"lodash/isString":333,"lodash/isUndefined":336}],427:[function(require,module,exports){ | ||
37509 | (function (Buffer){ | ||
37510 | "use strict"; | ||
37511 | |||
37512 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
37513 | |||
37514 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
37515 | |||
37516 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
37517 | |||
37518 | Object.defineProperty(exports, "__esModule", { | ||
37519 | value: true | ||
37520 | }); | ||
37521 | |||
37522 | var _index = require("./index"); | ||
37523 | |||
37524 | var xdr = _index.xdr; | ||
37525 | var hash = _index.hash; | ||
37526 | |||
37527 | var StrKey = require("./strkey").StrKey; | ||
37528 | |||
37529 | var Operation = require("./operation").Operation; | ||
37530 | |||
37531 | var Network = require("./network").Network; | ||
37532 | |||
37533 | var Memo = require("./memo").Memo; | ||
37534 | |||
37535 | var map = _interopRequire(require("lodash/map")); | ||
37536 | |||
37537 | var each = _interopRequire(require("lodash/each")); | ||
37538 | |||
37539 | var isString = _interopRequire(require("lodash/isString")); | ||
37540 | |||
37541 | var crypto = _interopRequire(require("crypto")); | ||
37542 | |||
37543 | /** | ||
37544 | * A new Transaction object is created from a transaction envelope or via {@link TransactionBuilder}. | ||
37545 | * Once a Transaction has been created from an envelope, its attributes and operations | ||
37546 | * should not be changed. You should only add signers (using {@link Transaction#sign}) to a Transaction object before | ||
37547 | * submitting to the network or forwarding on to additional signers. | ||
37548 | * @constructor | ||
37549 | * @param {string|xdr.TransactionEnvelope} envelope - The transaction envelope object or base64 encoded string. | ||
37550 | */ | ||
37551 | |||
37552 | var Transaction = exports.Transaction = (function () { | ||
37553 | function Transaction(envelope) { | ||
37554 | _classCallCheck(this, Transaction); | ||
37555 | |||
37556 | if (typeof envelope === "string") { | ||
37557 | var buffer = Buffer.from(envelope, "base64"); | ||
37558 | envelope = xdr.TransactionEnvelope.fromXDR(buffer); | ||
37559 | } | ||
37560 | // since this transaction is immutable, save the tx | ||
37561 | this.tx = envelope.tx(); | ||
37562 | this.source = StrKey.encodeEd25519PublicKey(envelope.tx().sourceAccount().ed25519()); | ||
37563 | this.fee = this.tx.fee(); | ||
37564 | this._memo = this.tx.memo(); | ||
37565 | this.sequence = this.tx.seqNum().toString(); | ||
37566 | |||
37567 | var timeBounds = this.tx.timeBounds(); | ||
37568 | if (timeBounds) { | ||
37569 | this.timeBounds = { | ||
37570 | minTime: timeBounds.minTime().toString(), | ||
37571 | maxTime: timeBounds.maxTime().toString() | ||
37572 | }; | ||
37573 | } | ||
37574 | |||
37575 | var operations = this.tx.operations() || []; | ||
37576 | this.operations = map(operations, function (op) { | ||
37577 | return Operation.fromXDRObject(op); | ||
37578 | }); | ||
37579 | |||
37580 | var signatures = envelope.signatures() || []; | ||
37581 | this.signatures = map(signatures, function (s) { | ||
37582 | return s; | ||
37583 | }); | ||
37584 | } | ||
37585 | |||
37586 | _createClass(Transaction, { | ||
37587 | memo: { | ||
37588 | get: function () { | ||
37589 | return Memo.fromXDRObject(this._memo); | ||
37590 | }, | ||
37591 | set: function (value) { | ||
37592 | throw new Error("Transaction is immutable"); | ||
37593 | } | ||
37594 | }, | ||
37595 | sign: { | ||
37596 | |||
37597 | /** | ||
37598 | * Signs the transaction with the given {@link Keypair}. | ||
37599 | * @param {...Keypair} keypairs Keypairs of signers | ||
37600 | * @returns {void} | ||
37601 | */ | ||
37602 | |||
37603 | value: function sign() { | ||
37604 | var _this = this; | ||
37605 | |||
37606 | for (var _len = arguments.length, keypairs = Array(_len), _key = 0; _key < _len; _key++) { | ||
37607 | keypairs[_key] = arguments[_key]; | ||
37608 | } | ||
37609 | |||
37610 | var txHash = this.hash(); | ||
37611 | var newSigs = each(keypairs, function (kp) { | ||
37612 | var sig = kp.signDecorated(txHash); | ||
37613 | _this.signatures.push(sig); | ||
37614 | }); | ||
37615 | } | ||
37616 | }, | ||
37617 | signHashX: { | ||
37618 | |||
37619 | /** | ||
37620 | * Add `hashX` signer preimage as signature. | ||
37621 | * @param {Buffer|String} preimage Preimage of hash used as signer | ||
37622 | * @returns {void} | ||
37623 | */ | ||
37624 | |||
37625 | value: function signHashX(preimage) { | ||
37626 | if (isString(preimage)) { | ||
37627 | preimage = Buffer.from(preimage, "hex"); | ||
37628 | } | ||
37629 | |||
37630 | if (preimage.length > 64) { | ||
37631 | throw new Error("preimage cannnot be longer than 64 bytes"); | ||
37632 | } | ||
37633 | |||
37634 | var signature = preimage; | ||
37635 | var hash = crypto.createHash("sha256").update(preimage).digest(); | ||
37636 | var hint = hash.slice(hash.length - 4); | ||
37637 | this.signatures.push(new xdr.DecoratedSignature({ hint: hint, signature: signature })); | ||
37638 | } | ||
37639 | }, | ||
37640 | hash: { | ||
37641 | |||
37642 | /** | ||
37643 | * Returns a hash for this transaction, suitable for signing. | ||
37644 | * @returns {Buffer} | ||
37645 | */ | ||
37646 | |||
37647 | value: (function (_hash) { | ||
37648 | var _hashWrapper = function hash() { | ||
37649 | return _hash.apply(this, arguments); | ||
37650 | }; | ||
37651 | |||
37652 | _hashWrapper.toString = function () { | ||
37653 | return _hash.toString(); | ||
37654 | }; | ||
37655 | |||
37656 | return _hashWrapper; | ||
37657 | })(function () { | ||
37658 | return hash(this.signatureBase()); | ||
37659 | }) | ||
37660 | }, | ||
37661 | signatureBase: { | ||
37662 | |||
37663 | /** | ||
37664 | * Returns the "signature base" of this transaction, which is the value | ||
37665 | * that, when hashed, should be signed to create a signature that | ||
37666 | * validators on the Stellar Network will accept. | ||
37667 | * | ||
37668 | * It is composed of a 4 prefix bytes followed by the xdr-encoded form | ||
37669 | * of this transaction. | ||
37670 | * @returns {Buffer} | ||
37671 | */ | ||
37672 | |||
37673 | value: function signatureBase() { | ||
37674 | if (Network.current() === null) { | ||
37675 | throw new Error("No network selected. Use `Network.use`, `Network.usePublicNetwork` or `Network.useTestNetwork` helper methods to select network."); | ||
37676 | } | ||
37677 | |||
37678 | return Buffer.concat([Network.current().networkId(), xdr.EnvelopeType.envelopeTypeTx().toXDR(), this.tx.toXDR()]); | ||
37679 | } | ||
37680 | }, | ||
37681 | toEnvelope: { | ||
37682 | |||
37683 | /** | ||
37684 | * To envelope returns a xdr.TransactionEnvelope which can be submitted to the network. | ||
37685 | * @returns {xdr.TransactionEnvelope} | ||
37686 | */ | ||
37687 | |||
37688 | value: function toEnvelope() { | ||
37689 | var tx = this.tx; | ||
37690 | var signatures = this.signatures; | ||
37691 | var envelope = new xdr.TransactionEnvelope({ tx: tx, signatures: signatures }); | ||
37692 | |||
37693 | return envelope; | ||
37694 | } | ||
37695 | } | ||
37696 | }); | ||
37697 | |||
37698 | return Transaction; | ||
37699 | })(); | ||
37700 | }).call(this,require("buffer").Buffer) | ||
37701 | },{"./index":407,"./memo":409,"./network":410,"./operation":411,"./strkey":426,"buffer":49,"crypto":71,"lodash/each":308,"lodash/isString":333,"lodash/map":339}],428:[function(require,module,exports){ | ||
37702 | "use strict"; | ||
37703 | |||
37704 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
37705 | |||
37706 | var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); | ||
37707 | |||
37708 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | ||
37709 | |||
37710 | Object.defineProperty(exports, "__esModule", { | ||
37711 | value: true | ||
37712 | }); | ||
37713 | |||
37714 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | ||
37715 | |||
37716 | var UnsignedHyper = require("js-xdr").UnsignedHyper; | ||
37717 | |||
37718 | var hash = require("./hashing").hash; | ||
37719 | |||
37720 | var Keypair = require("./keypair").Keypair; | ||
37721 | |||
37722 | var Account = require("./account").Account; | ||
37723 | |||
37724 | var Operation = require("./operation").Operation; | ||
37725 | |||
37726 | var Transaction = require("./transaction").Transaction; | ||
37727 | |||
37728 | var Memo = require("./memo").Memo; | ||
37729 | |||
37730 | var BigNumber = _interopRequire(require("bignumber.js")); | ||
37731 | |||
37732 | var clone = _interopRequire(require("lodash/clone")); | ||
37733 | |||
37734 | var map = _interopRequire(require("lodash/map")); | ||
37735 | |||
37736 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | ||
37737 | |||
37738 | var BASE_FEE = 100; // Stroops | ||
37739 | |||
37740 | /** | ||
37741 | * @constant | ||
37742 | * @see {@link TransactionBuilder#setTimeout} | ||
37743 | * @see [Timeout](https://www.stellar.org/developers/horizon/reference/endpoints/transactions-create.html#timeout) | ||
37744 | */ | ||
37745 | var TimeoutInfinite = 0; | ||
37746 | |||
37747 | exports.TimeoutInfinite = TimeoutInfinite; | ||
37748 | /** | ||
37749 | * <p>Transaction builder helps constructs a new `{@link Transaction}` using the given {@link Account} | ||
37750 | * as the transaction's "source account". The transaction will use the current sequence | ||
37751 | * number of the given account as its sequence number and increment the given account's | ||
37752 | * sequence number by one. The given source account must include a private key for signing | ||
37753 | * the transaction or an error will be thrown.</p> | ||
37754 | * | ||
37755 | * <p>Operations can be added to the transaction via their corresponding builder methods, and | ||
37756 | * each returns the TransactionBuilder object so they can be chained together. After adding | ||
37757 | * the desired operations, call the `build()` method on the `TransactionBuilder` to return a fully | ||
37758 | * constructed `{@link Transaction}` that can be signed. The returned transaction will contain the | ||
37759 | * sequence number of the source account and include the signature from the source account.</p> | ||
37760 | * | ||
37761 | * <p>The following code example creates a new transaction with {@link Operation.createAccount} and | ||
37762 | * {@link Operation.payment} operations. | ||
37763 | * The Transaction's source account first funds `destinationA`, then sends | ||
37764 | * a payment to `destinationB`. The built transaction is then signed by `sourceKeypair`.</p> | ||
37765 | * | ||
37766 | * ``` | ||
37767 | * var transaction = new TransactionBuilder(source) | ||
37768 | * .addOperation(Operation.createAccount({ | ||
37769 | destination: destinationA, | ||
37770 | startingBalance: "20" | ||
37771 | }) // <- funds and creates destinationA | ||
37772 | .addOperation(Operation.payment({ | ||
37773 | destination: destinationB, | ||
37774 | amount: "100" | ||
37775 | asset: Asset.native() | ||
37776 | }) // <- sends 100 XLM to destinationB | ||
37777 | * .setTimeout(30) | ||
37778 | * .build(); | ||
37779 | * | ||
37780 | * transaction.sign(sourceKeypair); | ||
37781 | * ``` | ||
37782 | * @constructor | ||
37783 | * @param {Account} sourceAccount - The source account for this transaction. | ||
37784 | * @param {object} [opts] | ||
37785 | * @param {number} [opts.fee] - The max fee willing to pay per operation in this transaction (**in stroops**). | ||
37786 | * @param {object} [opts.timebounds] - The timebounds for the validity of this transaction. | ||
37787 | * @param {number|string} [opts.timebounds.minTime] - 64 bit unix timestamp | ||
37788 | * @param {number|string} [opts.timebounds.maxTime] - 64 bit unix timestamp | ||
37789 | * @param {Memo} [opts.memo] - The memo for the transaction | ||
37790 | */ | ||
37791 | |||
37792 | var TransactionBuilder = exports.TransactionBuilder = (function () { | ||
37793 | function TransactionBuilder(sourceAccount) { | ||
37794 | var opts = arguments[1] === undefined ? {} : arguments[1]; | ||
37795 | |||
37796 | _classCallCheck(this, TransactionBuilder); | ||
37797 | |||
37798 | if (!sourceAccount) { | ||
37799 | throw new Error("must specify source account for the transaction"); | ||
37800 | } | ||
37801 | this.source = sourceAccount; | ||
37802 | this.operations = []; | ||
37803 | this.baseFee = isUndefined(opts.fee) ? BASE_FEE : opts.fee; | ||
37804 | this.timebounds = clone(opts.timebounds); | ||
37805 | this.memo = opts.memo || Memo.none(); | ||
37806 | this.timeoutSet = false; | ||
37807 | } | ||
37808 | |||
37809 | _createClass(TransactionBuilder, { | ||
37810 | addOperation: { | ||
37811 | |||
37812 | /** | ||
37813 | * Adds an operation to the transaction. | ||
37814 | * @param {xdr.Operation} operation The xdr operation object, use {@link Operation} static methods. | ||
37815 | * @returns {TransactionBuilder} | ||
37816 | */ | ||
37817 | |||
37818 | value: function addOperation(operation) { | ||
37819 | this.operations.push(operation); | ||
37820 | return this; | ||
37821 | } | ||
37822 | }, | ||
37823 | addMemo: { | ||
37824 | |||
37825 | /** | ||
37826 | * Adds a memo to the transaction. | ||
37827 | * @param {Memo} memo {@link Memo} object | ||
37828 | * @returns {TransactionBuilder} | ||
37829 | */ | ||
37830 | |||
37831 | value: function addMemo(memo) { | ||
37832 | this.memo = memo; | ||
37833 | return this; | ||
37834 | } | ||
37835 | }, | ||
37836 | setTimeout: { | ||
37837 | |||
37838 | /** | ||
37839 | * Because of the distributed nature of the Stellar network it is possible that the status of your transaction | ||
37840 | * will be determined after a long time if the network is highly congested. | ||
37841 | * If you want to be sure to receive the status of the transaction within a given period you should set the | ||
37842 | * {@link TimeBounds} with <code>maxTime</code> on the transaction (this is what <code>setTimeout</code> does | ||
37843 | * internally; if there's <code>minTime</code> set but no <code>maxTime</code> it will be added). | ||
37844 | * Call to <code>TransactionBuilder.setTimeout</code> is required if Transaction does not have <code>max_time</code> set. | ||
37845 | * If you don't want to set timeout, use <code>{@link TimeoutInfinite}</code>. In general you should set | ||
37846 | * <code>{@link TimeoutInfinite}</code> only in smart contracts. | ||
37847 | * | ||
37848 | * Please note that Horizon may still return <code>504 Gateway Timeout</code> error, even for short timeouts. | ||
37849 | * In such case you need to resubmit the same transaction again without making any changes to receive a status. | ||
37850 | * This method is using the machine system time (UTC), make sure it is set correctly. | ||
37851 | * @param {timeout} Timeout in seconds. | ||
37852 | * @return {TransactionBuilder} | ||
37853 | * @see TimeoutInfinite | ||
37854 | */ | ||
37855 | |||
37856 | value: function setTimeout(timeout) { | ||
37857 | if (this.timebounds != null && this.timebounds.maxTime > 0) { | ||
37858 | throw new Error("TimeBounds.max_time has been already set - setting timeout would overwrite it."); | ||
37859 | } | ||
37860 | |||
37861 | if (timeout < 0) { | ||
37862 | throw new Error("timeout cannot be negative"); | ||
37863 | } | ||
37864 | |||
37865 | this.timeoutSet = true; | ||
37866 | if (timeout > 0) { | ||
37867 | var timeoutTimestamp = Math.floor(Date.now() / 1000) + timeout; | ||
37868 | if (this.timebounds == null) { | ||
37869 | this.timebounds = { minTime: 0, maxTime: timeoutTimestamp }; | ||
37870 | } else { | ||
37871 | this.timebounds = { minTime: this.timebounds.minTime, maxTime: timeoutTimestamp }; | ||
37872 | } | ||
37873 | } | ||
37874 | |||
37875 | return this; | ||
37876 | } | ||
37877 | }, | ||
37878 | build: { | ||
37879 | |||
37880 | /** | ||
37881 | * This will build the transaction. | ||
37882 | * It will also increment the source account's sequence number by 1. | ||
37883 | * @returns {Transaction} This method will return the built {@link Transaction}. | ||
37884 | */ | ||
37885 | |||
37886 | value: function build() { | ||
37887 | // Ensure setTimeout called or maxTime is set | ||
37888 | if ((this.timebounds == null || this.timebounds != null && this.timebounds.maxTime == 0) && !this.timeoutSet) { | ||
37889 | throw new Error("TimeBounds has to be set or you must call setTimeout(TimeoutInfinite)."); | ||
37890 | } | ||
37891 | |||
37892 | var sequenceNumber = new BigNumber(this.source.sequenceNumber()).add(1); | ||
37893 | |||
37894 | var attrs = { | ||
37895 | sourceAccount: Keypair.fromPublicKey(this.source.accountId()).xdrAccountId(), | ||
37896 | fee: this.baseFee * this.operations.length, | ||
37897 | seqNum: xdr.SequenceNumber.fromString(sequenceNumber.toString()), | ||
37898 | memo: this.memo ? this.memo.toXDRObject() : null, | ||
37899 | ext: new xdr.TransactionExt(0) | ||
37900 | }; | ||
37901 | |||
37902 | if (this.timebounds) { | ||
37903 | this.timebounds.minTime = UnsignedHyper.fromString(this.timebounds.minTime.toString()); | ||
37904 | this.timebounds.maxTime = UnsignedHyper.fromString(this.timebounds.maxTime.toString()); | ||
37905 | attrs.timeBounds = new xdr.TimeBounds(this.timebounds); | ||
37906 | } | ||
37907 | |||
37908 | var xtx = new xdr.Transaction(attrs); | ||
37909 | xtx.operations(this.operations); | ||
37910 | |||
37911 | var xenv = new xdr.TransactionEnvelope({ tx: xtx }); | ||
37912 | var tx = new Transaction(xenv); | ||
37913 | |||
37914 | this.source.incrementSequenceNumber(); | ||
37915 | |||
37916 | return tx; | ||
37917 | } | ||
37918 | } | ||
37919 | }); | ||
37920 | |||
37921 | return TransactionBuilder; | ||
37922 | })(); | ||
37923 | },{"./account":402,"./generated/stellar-xdr_generated":405,"./hashing":406,"./keypair":408,"./memo":409,"./operation":411,"./transaction":427,"bignumber.js":17,"js-xdr":127,"lodash/clone":306,"lodash/isUndefined":336,"lodash/map":339}],429:[function(require,module,exports){ | ||
37924 | "use strict"; | ||
37925 | |||
37926 | exports.verifyChecksum = verifyChecksum; | ||
37927 | Object.defineProperty(exports, "__esModule", { | ||
37928 | value: true | ||
37929 | }); | ||
37930 | |||
37931 | function verifyChecksum(expected, actual) { | ||
37932 | if (expected.length !== actual.length) { | ||
37933 | return false; | ||
37934 | } | ||
37935 | |||
37936 | if (expected.length === 0) { | ||
37937 | return true; | ||
37938 | } | ||
37939 | |||
37940 | for (var i = 0; i < expected.length; i++) { | ||
37941 | if (expected[i] !== actual[i]) { | ||
37942 | return false; | ||
37943 | } | ||
37944 | } | ||
37945 | |||
37946 | return true; | ||
37947 | } | ||
37948 | },{}],430:[function(require,module,exports){ | ||
37949 | "use strict"; | ||
37950 | |||
37951 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | ||
37952 | |||
37953 | var _slicedToArray = function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; | ||
37954 | |||
37955 | /** | ||
37956 | * Calculates and returns the best rational approximation of the given real number. | ||
37957 | * @private | ||
37958 | * @param {string|number|BigNumber} number | ||
37959 | * @throws Error Throws `Error` when the best rational approximation cannot be found. | ||
37960 | * @returns {array} first element is n (numerator), second element is d (denominator) | ||
37961 | */ | ||
37962 | exports.best_r = best_r; | ||
37963 | Object.defineProperty(exports, "__esModule", { | ||
37964 | value: true | ||
37965 | }); | ||
37966 | |||
37967 | var BigNumber = _interopRequire(require("bignumber.js")); | ||
37968 | |||
37969 | var MAX_INT = (1 << 31 >>> 0) - 1; | ||
37970 | function best_r(number) { | ||
37971 | number = new BigNumber(number); | ||
37972 | var a; | ||
37973 | var f; | ||
37974 | var fractions = [[new BigNumber(0), new BigNumber(1)], [new BigNumber(1), new BigNumber(0)]]; | ||
37975 | var i = 2; | ||
37976 | while (true) { | ||
37977 | if (number.gt(MAX_INT)) { | ||
37978 | break; | ||
37979 | } | ||
37980 | a = number.floor(); | ||
37981 | f = number.sub(a); | ||
37982 | var h = a.mul(fractions[i - 1][0]).add(fractions[i - 2][0]); | ||
37983 | var k = a.mul(fractions[i - 1][1]).add(fractions[i - 2][1]); | ||
37984 | if (h.gt(MAX_INT) || k.gt(MAX_INT)) { | ||
37985 | break; | ||
37986 | } | ||
37987 | fractions.push([h, k]); | ||
37988 | if (f.eq(0)) { | ||
37989 | break; | ||
37990 | } | ||
37991 | number = new BigNumber(1).div(f); | ||
37992 | i++; | ||
37993 | } | ||
37994 | |||
37995 | var _fractions = _slicedToArray(fractions[fractions.length - 1], 2); | ||
37996 | |||
37997 | var n = _fractions[0]; | ||
37998 | var d = _fractions[1]; | ||
37999 | |||
38000 | if (n.isZero() || d.isZero()) { | ||
38001 | throw new Error("Couldn't find approximation"); | ||
38002 | } | ||
38003 | |||
38004 | return [n.toNumber(), d.toNumber()]; | ||
38005 | } | ||
38006 | },{"bignumber.js":17}],431:[function(require,module,exports){ | ||
38007 | // vendored from http://cryptocoinjs.com/modules/misc/bs58/ | ||
38008 | |||
38009 | // Base58 encoding/decoding | ||
38010 | // Originally written by Mike Hearn for BitcoinJ | ||
38011 | // Copyright (c) 2011 Google Inc | ||
38012 | // Ported to JavaScript by Stefan Thomas | ||
38013 | // Merged Buffer refactorings from base58-native by Stephen Pair | ||
38014 | // Copyright (c) 2013 BitPay Inc | ||
38015 | |||
38016 | "use strict"; | ||
38017 | |||
38018 | var ALPHABET = "gsphnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCr65jkm8oFqi1tuvAxyz"; | ||
38019 | var ALPHABET_MAP = {}; | ||
38020 | for (var i = 0; i < ALPHABET.length; ++i) { | ||
38021 | ALPHABET_MAP[ALPHABET.charAt(i)] = i; | ||
38022 | } | ||
38023 | var BASE = 58; | ||
38024 | |||
38025 | function decode(string) { | ||
38026 | if (string.length === 0) { | ||
38027 | return []; | ||
38028 | }var i, | ||
38029 | j, | ||
38030 | bytes = [0]; | ||
38031 | for (i = 0; i < string.length; ++i) { | ||
38032 | var c = string[i]; | ||
38033 | if (!(c in ALPHABET_MAP)) throw new Error("Non-base58 character"); | ||
38034 | |||
38035 | for (j = 0; j < bytes.length; ++j) bytes[j] *= BASE; | ||
38036 | bytes[0] += ALPHABET_MAP[c]; | ||
38037 | |||
38038 | var carry = 0; | ||
38039 | for (j = 0; j < bytes.length; ++j) { | ||
38040 | bytes[j] += carry; | ||
38041 | |||
38042 | carry = bytes[j] >> 8; | ||
38043 | bytes[j] &= 255; | ||
38044 | } | ||
38045 | |||
38046 | while (carry) { | ||
38047 | bytes.push(carry & 255); | ||
38048 | |||
38049 | carry >>= 8; | ||
38050 | } | ||
38051 | } | ||
38052 | |||
38053 | // deal with leading zeros | ||
38054 | for (i = 0; string[i] === "g" && i < string.length - 1; ++i) bytes.push(0); | ||
38055 | |||
38056 | return bytes.reverse(); | ||
38057 | } | ||
38058 | |||
38059 | module.exports = { decode: decode }; | ||
38060 | },{}],432:[function(require,module,exports){ | ||
38061 | // Copyright Joyent, Inc. and other Node contributors. | ||
38062 | // | ||
38063 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
38064 | // copy of this software and associated documentation files (the | ||
38065 | // "Software"), to deal in the Software without restriction, including | ||
38066 | // without limitation the rights to use, copy, modify, merge, publish, | ||
38067 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
38068 | // persons to whom the Software is furnished to do so, subject to the | ||
38069 | // following conditions: | ||
38070 | // | ||
38071 | // The above copyright notice and this permission notice shall be included | ||
38072 | // in all copies or substantial portions of the Software. | ||
38073 | // | ||
38074 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
38075 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
38076 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
38077 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
38078 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
38079 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
38080 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
38081 | |||
38082 | module.exports = Stream; | ||
38083 | |||
38084 | var EE = require('events').EventEmitter; | ||
38085 | var inherits = require('inherits'); | ||
38086 | |||
38087 | inherits(Stream, EE); | ||
38088 | Stream.Readable = require('readable-stream/readable.js'); | ||
38089 | Stream.Writable = require('readable-stream/writable.js'); | ||
38090 | Stream.Duplex = require('readable-stream/duplex.js'); | ||
38091 | Stream.Transform = require('readable-stream/transform.js'); | ||
38092 | Stream.PassThrough = require('readable-stream/passthrough.js'); | ||
38093 | |||
38094 | // Backwards-compat with node 0.4.x | ||
38095 | Stream.Stream = Stream; | ||
38096 | |||
38097 | |||
38098 | |||
38099 | // old-style streams. Note that the pipe method (the only relevant | ||
38100 | // part of this class) is overridden in the Readable class. | ||
38101 | |||
38102 | function Stream() { | ||
38103 | EE.call(this); | ||
38104 | } | ||
38105 | |||
38106 | Stream.prototype.pipe = function(dest, options) { | ||
38107 | var source = this; | ||
38108 | |||
38109 | function ondata(chunk) { | ||
38110 | if (dest.writable) { | ||
38111 | if (false === dest.write(chunk) && source.pause) { | ||
38112 | source.pause(); | ||
38113 | } | ||
38114 | } | ||
38115 | } | ||
38116 | |||
38117 | source.on('data', ondata); | ||
38118 | |||
38119 | function ondrain() { | ||
38120 | if (source.readable && source.resume) { | ||
38121 | source.resume(); | ||
38122 | } | ||
38123 | } | ||
38124 | |||
38125 | dest.on('drain', ondrain); | ||
38126 | |||
38127 | // If the 'end' option is not supplied, dest.end() will be called when | ||
38128 | // source gets the 'end' or 'close' events. Only dest.end() once. | ||
38129 | if (!dest._isStdio && (!options || options.end !== false)) { | ||
38130 | source.on('end', onend); | ||
38131 | source.on('close', onclose); | ||
38132 | } | ||
38133 | |||
38134 | var didOnEnd = false; | ||
38135 | function onend() { | ||
38136 | if (didOnEnd) return; | ||
38137 | didOnEnd = true; | ||
38138 | |||
38139 | dest.end(); | ||
38140 | } | ||
38141 | |||
38142 | |||
38143 | function onclose() { | ||
38144 | if (didOnEnd) return; | ||
38145 | didOnEnd = true; | ||
38146 | |||
38147 | if (typeof dest.destroy === 'function') dest.destroy(); | ||
38148 | } | ||
38149 | |||
38150 | // don't leave dangling pipes when there are errors. | ||
38151 | function onerror(er) { | ||
38152 | cleanup(); | ||
38153 | if (EE.listenerCount(this, 'error') === 0) { | ||
38154 | throw er; // Unhandled stream error in pipe. | ||
38155 | } | ||
38156 | } | ||
38157 | |||
38158 | source.on('error', onerror); | ||
38159 | dest.on('error', onerror); | ||
38160 | |||
38161 | // remove all the event listeners that were added. | ||
38162 | function cleanup() { | ||
38163 | source.removeListener('data', ondata); | ||
38164 | dest.removeListener('drain', ondrain); | ||
38165 | |||
38166 | source.removeListener('end', onend); | ||
38167 | source.removeListener('close', onclose); | ||
38168 | |||
38169 | source.removeListener('error', onerror); | ||
38170 | dest.removeListener('error', onerror); | ||
38171 | |||
38172 | source.removeListener('end', cleanup); | ||
38173 | source.removeListener('close', cleanup); | ||
38174 | |||
38175 | dest.removeListener('close', cleanup); | ||
38176 | } | ||
38177 | |||
38178 | source.on('end', cleanup); | ||
38179 | source.on('close', cleanup); | ||
38180 | |||
38181 | dest.on('close', cleanup); | ||
38182 | |||
38183 | dest.emit('pipe', source); | ||
38184 | |||
38185 | // Allow for unix-like usage: A.pipe(B).pipe(C) | ||
38186 | return dest; | ||
38187 | }; | ||
38188 | |||
38189 | },{"events":99,"inherits":116,"readable-stream/duplex.js":378,"readable-stream/passthrough.js":388,"readable-stream/readable.js":389,"readable-stream/transform.js":390,"readable-stream/writable.js":391}],433:[function(require,module,exports){ | ||
38190 | arguments[4][387][0].apply(exports,arguments) | ||
38191 | },{"dup":387,"safe-buffer":393}],434:[function(require,module,exports){ | ||
38192 | (function (setImmediate,clearImmediate){ | ||
38193 | var nextTick = require('process/browser.js').nextTick; | ||
38194 | var apply = Function.prototype.apply; | ||
38195 | var slice = Array.prototype.slice; | ||
38196 | var immediateIds = {}; | ||
38197 | var nextImmediateId = 0; | ||
38198 | |||
38199 | // DOM APIs, for completeness | ||
38200 | |||
38201 | exports.setTimeout = function() { | ||
38202 | return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout); | ||
38203 | }; | ||
38204 | exports.setInterval = function() { | ||
38205 | return new Timeout(apply.call(setInterval, window, arguments), clearInterval); | ||
38206 | }; | ||
38207 | exports.clearTimeout = | ||
38208 | exports.clearInterval = function(timeout) { timeout.close(); }; | ||
38209 | |||
38210 | function Timeout(id, clearFn) { | ||
38211 | this._id = id; | ||
38212 | this._clearFn = clearFn; | ||
38213 | } | ||
38214 | Timeout.prototype.unref = Timeout.prototype.ref = function() {}; | ||
38215 | Timeout.prototype.close = function() { | ||
38216 | this._clearFn.call(window, this._id); | ||
38217 | }; | ||
38218 | |||
38219 | // Does not start the time, just sets up the members needed. | ||
38220 | exports.enroll = function(item, msecs) { | ||
38221 | clearTimeout(item._idleTimeoutId); | ||
38222 | item._idleTimeout = msecs; | ||
38223 | }; | ||
38224 | |||
38225 | exports.unenroll = function(item) { | ||
38226 | clearTimeout(item._idleTimeoutId); | ||
38227 | item._idleTimeout = -1; | ||
38228 | }; | ||
38229 | |||
38230 | exports._unrefActive = exports.active = function(item) { | ||
38231 | clearTimeout(item._idleTimeoutId); | ||
38232 | |||
38233 | var msecs = item._idleTimeout; | ||
38234 | if (msecs >= 0) { | ||
38235 | item._idleTimeoutId = setTimeout(function onTimeout() { | ||
38236 | if (item._onTimeout) | ||
38237 | item._onTimeout(); | ||
38238 | }, msecs); | ||
38239 | } | ||
38240 | }; | ||
38241 | |||
38242 | // That's not how node.js implements it but the exposed api is the same. | ||
38243 | exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) { | ||
38244 | var id = nextImmediateId++; | ||
38245 | var args = arguments.length < 2 ? false : slice.call(arguments, 1); | ||
38246 | |||
38247 | immediateIds[id] = true; | ||
38248 | |||
38249 | nextTick(function onNextTick() { | ||
38250 | if (immediateIds[id]) { | ||
38251 | // fn.call() is faster so we optimize for the common use-case | ||
38252 | // @see http://jsperf.com/call-apply-segu | ||
38253 | if (args) { | ||
38254 | fn.apply(null, args); | ||
38255 | } else { | ||
38256 | fn.call(null); | ||
38257 | } | ||
38258 | // Prevent ids from leaking | ||
38259 | exports.clearImmediate(id); | ||
38260 | } | ||
38261 | }); | ||
38262 | |||
38263 | return id; | ||
38264 | }; | ||
38265 | |||
38266 | exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { | ||
38267 | delete immediateIds[id]; | ||
38268 | }; | ||
38269 | }).call(this,require("timers").setImmediate,require("timers").clearImmediate) | ||
38270 | },{"process/browser.js":369,"timers":434}],435:[function(require,module,exports){ | ||
38271 | (function(nacl) { | ||
38272 | 'use strict'; | ||
38273 | |||
38274 | // Ported in 2014 by Dmitry Chestnykh and Devi Mandiri. | ||
38275 | // Public domain. | ||
38276 | // | ||
38277 | // Implementation derived from TweetNaCl version 20140427. | ||
38278 | // See for details: http://tweetnacl.cr.yp.to/ | ||
38279 | |||
38280 | var gf = function(init) { | ||
38281 | var i, r = new Float64Array(16); | ||
38282 | if (init) for (i = 0; i < init.length; i++) r[i] = init[i]; | ||
38283 | return r; | ||
38284 | }; | ||
38285 | |||
38286 | // Pluggable, initialized in high-level API below. | ||
38287 | var randombytes = function(/* x, n */) { throw new Error('no PRNG'); }; | ||
38288 | |||
38289 | var _0 = new Uint8Array(16); | ||
38290 | var _9 = new Uint8Array(32); _9[0] = 9; | ||
38291 | |||
38292 | var gf0 = gf(), | ||
38293 | gf1 = gf([1]), | ||
38294 | _121665 = gf([0xdb41, 1]), | ||
38295 | D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]), | ||
38296 | D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]), | ||
38297 | X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]), | ||
38298 | Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]), | ||
38299 | I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]); | ||
38300 | |||
38301 | function ts64(x, i, h, l) { | ||
38302 | x[i] = (h >> 24) & 0xff; | ||
38303 | x[i+1] = (h >> 16) & 0xff; | ||
38304 | x[i+2] = (h >> 8) & 0xff; | ||
38305 | x[i+3] = h & 0xff; | ||
38306 | x[i+4] = (l >> 24) & 0xff; | ||
38307 | x[i+5] = (l >> 16) & 0xff; | ||
38308 | x[i+6] = (l >> 8) & 0xff; | ||
38309 | x[i+7] = l & 0xff; | ||
38310 | } | ||
38311 | |||
38312 | function vn(x, xi, y, yi, n) { | ||
38313 | var i,d = 0; | ||
38314 | for (i = 0; i < n; i++) d |= x[xi+i]^y[yi+i]; | ||
38315 | return (1 & ((d - 1) >>> 8)) - 1; | ||
38316 | } | ||
38317 | |||
38318 | function crypto_verify_16(x, xi, y, yi) { | ||
38319 | return vn(x,xi,y,yi,16); | ||
38320 | } | ||
38321 | |||
38322 | function crypto_verify_32(x, xi, y, yi) { | ||
38323 | return vn(x,xi,y,yi,32); | ||
38324 | } | ||
38325 | |||
38326 | function core_salsa20(o, p, k, c) { | ||
38327 | var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24, | ||
38328 | j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24, | ||
38329 | j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24, | ||
38330 | j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24, | ||
38331 | j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24, | ||
38332 | j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24, | ||
38333 | j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24, | ||
38334 | j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24, | ||
38335 | j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24, | ||
38336 | j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24, | ||
38337 | j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24, | ||
38338 | j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24, | ||
38339 | j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24, | ||
38340 | j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24, | ||
38341 | j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24, | ||
38342 | j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24; | ||
38343 | |||
38344 | var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, | ||
38345 | x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, | ||
38346 | x15 = j15, u; | ||
38347 | |||
38348 | for (var i = 0; i < 20; i += 2) { | ||
38349 | u = x0 + x12 | 0; | ||
38350 | x4 ^= u<<7 | u>>>(32-7); | ||
38351 | u = x4 + x0 | 0; | ||
38352 | x8 ^= u<<9 | u>>>(32-9); | ||
38353 | u = x8 + x4 | 0; | ||
38354 | x12 ^= u<<13 | u>>>(32-13); | ||
38355 | u = x12 + x8 | 0; | ||
38356 | x0 ^= u<<18 | u>>>(32-18); | ||
38357 | |||
38358 | u = x5 + x1 | 0; | ||
38359 | x9 ^= u<<7 | u>>>(32-7); | ||
38360 | u = x9 + x5 | 0; | ||
38361 | x13 ^= u<<9 | u>>>(32-9); | ||
38362 | u = x13 + x9 | 0; | ||
38363 | x1 ^= u<<13 | u>>>(32-13); | ||
38364 | u = x1 + x13 | 0; | ||
38365 | x5 ^= u<<18 | u>>>(32-18); | ||
38366 | |||
38367 | u = x10 + x6 | 0; | ||
38368 | x14 ^= u<<7 | u>>>(32-7); | ||
38369 | u = x14 + x10 | 0; | ||
38370 | x2 ^= u<<9 | u>>>(32-9); | ||
38371 | u = x2 + x14 | 0; | ||
38372 | x6 ^= u<<13 | u>>>(32-13); | ||
38373 | u = x6 + x2 | 0; | ||
38374 | x10 ^= u<<18 | u>>>(32-18); | ||
38375 | |||
38376 | u = x15 + x11 | 0; | ||
38377 | x3 ^= u<<7 | u>>>(32-7); | ||
38378 | u = x3 + x15 | 0; | ||
38379 | x7 ^= u<<9 | u>>>(32-9); | ||
38380 | u = x7 + x3 | 0; | ||
38381 | x11 ^= u<<13 | u>>>(32-13); | ||
38382 | u = x11 + x7 | 0; | ||
38383 | x15 ^= u<<18 | u>>>(32-18); | ||
38384 | |||
38385 | u = x0 + x3 | 0; | ||
38386 | x1 ^= u<<7 | u>>>(32-7); | ||
38387 | u = x1 + x0 | 0; | ||
38388 | x2 ^= u<<9 | u>>>(32-9); | ||
38389 | u = x2 + x1 | 0; | ||
38390 | x3 ^= u<<13 | u>>>(32-13); | ||
38391 | u = x3 + x2 | 0; | ||
38392 | x0 ^= u<<18 | u>>>(32-18); | ||
38393 | |||
38394 | u = x5 + x4 | 0; | ||
38395 | x6 ^= u<<7 | u>>>(32-7); | ||
38396 | u = x6 + x5 | 0; | ||
38397 | x7 ^= u<<9 | u>>>(32-9); | ||
38398 | u = x7 + x6 | 0; | ||
38399 | x4 ^= u<<13 | u>>>(32-13); | ||
38400 | u = x4 + x7 | 0; | ||
38401 | x5 ^= u<<18 | u>>>(32-18); | ||
38402 | |||
38403 | u = x10 + x9 | 0; | ||
38404 | x11 ^= u<<7 | u>>>(32-7); | ||
38405 | u = x11 + x10 | 0; | ||
38406 | x8 ^= u<<9 | u>>>(32-9); | ||
38407 | u = x8 + x11 | 0; | ||
38408 | x9 ^= u<<13 | u>>>(32-13); | ||
38409 | u = x9 + x8 | 0; | ||
38410 | x10 ^= u<<18 | u>>>(32-18); | ||
38411 | |||
38412 | u = x15 + x14 | 0; | ||
38413 | x12 ^= u<<7 | u>>>(32-7); | ||
38414 | u = x12 + x15 | 0; | ||
38415 | x13 ^= u<<9 | u>>>(32-9); | ||
38416 | u = x13 + x12 | 0; | ||
38417 | x14 ^= u<<13 | u>>>(32-13); | ||
38418 | u = x14 + x13 | 0; | ||
38419 | x15 ^= u<<18 | u>>>(32-18); | ||
38420 | } | ||
38421 | x0 = x0 + j0 | 0; | ||
38422 | x1 = x1 + j1 | 0; | ||
38423 | x2 = x2 + j2 | 0; | ||
38424 | x3 = x3 + j3 | 0; | ||
38425 | x4 = x4 + j4 | 0; | ||
38426 | x5 = x5 + j5 | 0; | ||
38427 | x6 = x6 + j6 | 0; | ||
38428 | x7 = x7 + j7 | 0; | ||
38429 | x8 = x8 + j8 | 0; | ||
38430 | x9 = x9 + j9 | 0; | ||
38431 | x10 = x10 + j10 | 0; | ||
38432 | x11 = x11 + j11 | 0; | ||
38433 | x12 = x12 + j12 | 0; | ||
38434 | x13 = x13 + j13 | 0; | ||
38435 | x14 = x14 + j14 | 0; | ||
38436 | x15 = x15 + j15 | 0; | ||
38437 | |||
38438 | o[ 0] = x0 >>> 0 & 0xff; | ||
38439 | o[ 1] = x0 >>> 8 & 0xff; | ||
38440 | o[ 2] = x0 >>> 16 & 0xff; | ||
38441 | o[ 3] = x0 >>> 24 & 0xff; | ||
38442 | |||
38443 | o[ 4] = x1 >>> 0 & 0xff; | ||
38444 | o[ 5] = x1 >>> 8 & 0xff; | ||
38445 | o[ 6] = x1 >>> 16 & 0xff; | ||
38446 | o[ 7] = x1 >>> 24 & 0xff; | ||
38447 | |||
38448 | o[ 8] = x2 >>> 0 & 0xff; | ||
38449 | o[ 9] = x2 >>> 8 & 0xff; | ||
38450 | o[10] = x2 >>> 16 & 0xff; | ||
38451 | o[11] = x2 >>> 24 & 0xff; | ||
38452 | |||
38453 | o[12] = x3 >>> 0 & 0xff; | ||
38454 | o[13] = x3 >>> 8 & 0xff; | ||
38455 | o[14] = x3 >>> 16 & 0xff; | ||
38456 | o[15] = x3 >>> 24 & 0xff; | ||
38457 | |||
38458 | o[16] = x4 >>> 0 & 0xff; | ||
38459 | o[17] = x4 >>> 8 & 0xff; | ||
38460 | o[18] = x4 >>> 16 & 0xff; | ||
38461 | o[19] = x4 >>> 24 & 0xff; | ||
38462 | |||
38463 | o[20] = x5 >>> 0 & 0xff; | ||
38464 | o[21] = x5 >>> 8 & 0xff; | ||
38465 | o[22] = x5 >>> 16 & 0xff; | ||
38466 | o[23] = x5 >>> 24 & 0xff; | ||
38467 | |||
38468 | o[24] = x6 >>> 0 & 0xff; | ||
38469 | o[25] = x6 >>> 8 & 0xff; | ||
38470 | o[26] = x6 >>> 16 & 0xff; | ||
38471 | o[27] = x6 >>> 24 & 0xff; | ||
38472 | |||
38473 | o[28] = x7 >>> 0 & 0xff; | ||
38474 | o[29] = x7 >>> 8 & 0xff; | ||
38475 | o[30] = x7 >>> 16 & 0xff; | ||
38476 | o[31] = x7 >>> 24 & 0xff; | ||
38477 | |||
38478 | o[32] = x8 >>> 0 & 0xff; | ||
38479 | o[33] = x8 >>> 8 & 0xff; | ||
38480 | o[34] = x8 >>> 16 & 0xff; | ||
38481 | o[35] = x8 >>> 24 & 0xff; | ||
38482 | |||
38483 | o[36] = x9 >>> 0 & 0xff; | ||
38484 | o[37] = x9 >>> 8 & 0xff; | ||
38485 | o[38] = x9 >>> 16 & 0xff; | ||
38486 | o[39] = x9 >>> 24 & 0xff; | ||
38487 | |||
38488 | o[40] = x10 >>> 0 & 0xff; | ||
38489 | o[41] = x10 >>> 8 & 0xff; | ||
38490 | o[42] = x10 >>> 16 & 0xff; | ||
38491 | o[43] = x10 >>> 24 & 0xff; | ||
38492 | |||
38493 | o[44] = x11 >>> 0 & 0xff; | ||
38494 | o[45] = x11 >>> 8 & 0xff; | ||
38495 | o[46] = x11 >>> 16 & 0xff; | ||
38496 | o[47] = x11 >>> 24 & 0xff; | ||
38497 | |||
38498 | o[48] = x12 >>> 0 & 0xff; | ||
38499 | o[49] = x12 >>> 8 & 0xff; | ||
38500 | o[50] = x12 >>> 16 & 0xff; | ||
38501 | o[51] = x12 >>> 24 & 0xff; | ||
38502 | |||
38503 | o[52] = x13 >>> 0 & 0xff; | ||
38504 | o[53] = x13 >>> 8 & 0xff; | ||
38505 | o[54] = x13 >>> 16 & 0xff; | ||
38506 | o[55] = x13 >>> 24 & 0xff; | ||
38507 | |||
38508 | o[56] = x14 >>> 0 & 0xff; | ||
38509 | o[57] = x14 >>> 8 & 0xff; | ||
38510 | o[58] = x14 >>> 16 & 0xff; | ||
38511 | o[59] = x14 >>> 24 & 0xff; | ||
38512 | |||
38513 | o[60] = x15 >>> 0 & 0xff; | ||
38514 | o[61] = x15 >>> 8 & 0xff; | ||
38515 | o[62] = x15 >>> 16 & 0xff; | ||
38516 | o[63] = x15 >>> 24 & 0xff; | ||
38517 | } | ||
38518 | |||
38519 | function core_hsalsa20(o,p,k,c) { | ||
38520 | var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24, | ||
38521 | j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24, | ||
38522 | j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24, | ||
38523 | j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24, | ||
38524 | j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24, | ||
38525 | j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24, | ||
38526 | j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24, | ||
38527 | j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24, | ||
38528 | j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24, | ||
38529 | j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24, | ||
38530 | j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24, | ||
38531 | j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24, | ||
38532 | j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24, | ||
38533 | j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24, | ||
38534 | j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24, | ||
38535 | j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24; | ||
38536 | |||
38537 | var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, | ||
38538 | x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, | ||
38539 | x15 = j15, u; | ||
38540 | |||
38541 | for (var i = 0; i < 20; i += 2) { | ||
38542 | u = x0 + x12 | 0; | ||
38543 | x4 ^= u<<7 | u>>>(32-7); | ||
38544 | u = x4 + x0 | 0; | ||
38545 | x8 ^= u<<9 | u>>>(32-9); | ||
38546 | u = x8 + x4 | 0; | ||
38547 | x12 ^= u<<13 | u>>>(32-13); | ||
38548 | u = x12 + x8 | 0; | ||
38549 | x0 ^= u<<18 | u>>>(32-18); | ||
38550 | |||
38551 | u = x5 + x1 | 0; | ||
38552 | x9 ^= u<<7 | u>>>(32-7); | ||
38553 | u = x9 + x5 | 0; | ||
38554 | x13 ^= u<<9 | u>>>(32-9); | ||
38555 | u = x13 + x9 | 0; | ||
38556 | x1 ^= u<<13 | u>>>(32-13); | ||
38557 | u = x1 + x13 | 0; | ||
38558 | x5 ^= u<<18 | u>>>(32-18); | ||
38559 | |||
38560 | u = x10 + x6 | 0; | ||
38561 | x14 ^= u<<7 | u>>>(32-7); | ||
38562 | u = x14 + x10 | 0; | ||
38563 | x2 ^= u<<9 | u>>>(32-9); | ||
38564 | u = x2 + x14 | 0; | ||
38565 | x6 ^= u<<13 | u>>>(32-13); | ||
38566 | u = x6 + x2 | 0; | ||
38567 | x10 ^= u<<18 | u>>>(32-18); | ||
38568 | |||
38569 | u = x15 + x11 | 0; | ||
38570 | x3 ^= u<<7 | u>>>(32-7); | ||
38571 | u = x3 + x15 | 0; | ||
38572 | x7 ^= u<<9 | u>>>(32-9); | ||
38573 | u = x7 + x3 | 0; | ||
38574 | x11 ^= u<<13 | u>>>(32-13); | ||
38575 | u = x11 + x7 | 0; | ||
38576 | x15 ^= u<<18 | u>>>(32-18); | ||
38577 | |||
38578 | u = x0 + x3 | 0; | ||
38579 | x1 ^= u<<7 | u>>>(32-7); | ||
38580 | u = x1 + x0 | 0; | ||
38581 | x2 ^= u<<9 | u>>>(32-9); | ||
38582 | u = x2 + x1 | 0; | ||
38583 | x3 ^= u<<13 | u>>>(32-13); | ||
38584 | u = x3 + x2 | 0; | ||
38585 | x0 ^= u<<18 | u>>>(32-18); | ||
38586 | |||
38587 | u = x5 + x4 | 0; | ||
38588 | x6 ^= u<<7 | u>>>(32-7); | ||
38589 | u = x6 + x5 | 0; | ||
38590 | x7 ^= u<<9 | u>>>(32-9); | ||
38591 | u = x7 + x6 | 0; | ||
38592 | x4 ^= u<<13 | u>>>(32-13); | ||
38593 | u = x4 + x7 | 0; | ||
38594 | x5 ^= u<<18 | u>>>(32-18); | ||
38595 | |||
38596 | u = x10 + x9 | 0; | ||
38597 | x11 ^= u<<7 | u>>>(32-7); | ||
38598 | u = x11 + x10 | 0; | ||
38599 | x8 ^= u<<9 | u>>>(32-9); | ||
38600 | u = x8 + x11 | 0; | ||
38601 | x9 ^= u<<13 | u>>>(32-13); | ||
38602 | u = x9 + x8 | 0; | ||
38603 | x10 ^= u<<18 | u>>>(32-18); | ||
38604 | |||
38605 | u = x15 + x14 | 0; | ||
38606 | x12 ^= u<<7 | u>>>(32-7); | ||
38607 | u = x12 + x15 | 0; | ||
38608 | x13 ^= u<<9 | u>>>(32-9); | ||
38609 | u = x13 + x12 | 0; | ||
38610 | x14 ^= u<<13 | u>>>(32-13); | ||
38611 | u = x14 + x13 | 0; | ||
38612 | x15 ^= u<<18 | u>>>(32-18); | ||
38613 | } | ||
38614 | |||
38615 | o[ 0] = x0 >>> 0 & 0xff; | ||
38616 | o[ 1] = x0 >>> 8 & 0xff; | ||
38617 | o[ 2] = x0 >>> 16 & 0xff; | ||
38618 | o[ 3] = x0 >>> 24 & 0xff; | ||
38619 | |||
38620 | o[ 4] = x5 >>> 0 & 0xff; | ||
38621 | o[ 5] = x5 >>> 8 & 0xff; | ||
38622 | o[ 6] = x5 >>> 16 & 0xff; | ||
38623 | o[ 7] = x5 >>> 24 & 0xff; | ||
38624 | |||
38625 | o[ 8] = x10 >>> 0 & 0xff; | ||
38626 | o[ 9] = x10 >>> 8 & 0xff; | ||
38627 | o[10] = x10 >>> 16 & 0xff; | ||
38628 | o[11] = x10 >>> 24 & 0xff; | ||
38629 | |||
38630 | o[12] = x15 >>> 0 & 0xff; | ||
38631 | o[13] = x15 >>> 8 & 0xff; | ||
38632 | o[14] = x15 >>> 16 & 0xff; | ||
38633 | o[15] = x15 >>> 24 & 0xff; | ||
38634 | |||
38635 | o[16] = x6 >>> 0 & 0xff; | ||
38636 | o[17] = x6 >>> 8 & 0xff; | ||
38637 | o[18] = x6 >>> 16 & 0xff; | ||
38638 | o[19] = x6 >>> 24 & 0xff; | ||
38639 | |||
38640 | o[20] = x7 >>> 0 & 0xff; | ||
38641 | o[21] = x7 >>> 8 & 0xff; | ||
38642 | o[22] = x7 >>> 16 & 0xff; | ||
38643 | o[23] = x7 >>> 24 & 0xff; | ||
38644 | |||
38645 | o[24] = x8 >>> 0 & 0xff; | ||
38646 | o[25] = x8 >>> 8 & 0xff; | ||
38647 | o[26] = x8 >>> 16 & 0xff; | ||
38648 | o[27] = x8 >>> 24 & 0xff; | ||
38649 | |||
38650 | o[28] = x9 >>> 0 & 0xff; | ||
38651 | o[29] = x9 >>> 8 & 0xff; | ||
38652 | o[30] = x9 >>> 16 & 0xff; | ||
38653 | o[31] = x9 >>> 24 & 0xff; | ||
38654 | } | ||
38655 | |||
38656 | function crypto_core_salsa20(out,inp,k,c) { | ||
38657 | core_salsa20(out,inp,k,c); | ||
38658 | } | ||
38659 | |||
38660 | function crypto_core_hsalsa20(out,inp,k,c) { | ||
38661 | core_hsalsa20(out,inp,k,c); | ||
38662 | } | ||
38663 | |||
38664 | var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]); | ||
38665 | // "expand 32-byte k" | ||
38666 | |||
38667 | function crypto_stream_salsa20_xor(c,cpos,m,mpos,b,n,k) { | ||
38668 | var z = new Uint8Array(16), x = new Uint8Array(64); | ||
38669 | var u, i; | ||
38670 | for (i = 0; i < 16; i++) z[i] = 0; | ||
38671 | for (i = 0; i < 8; i++) z[i] = n[i]; | ||
38672 | while (b >= 64) { | ||
38673 | crypto_core_salsa20(x,z,k,sigma); | ||
38674 | for (i = 0; i < 64; i++) c[cpos+i] = m[mpos+i] ^ x[i]; | ||
38675 | u = 1; | ||
38676 | for (i = 8; i < 16; i++) { | ||
38677 | u = u + (z[i] & 0xff) | 0; | ||
38678 | z[i] = u & 0xff; | ||
38679 | u >>>= 8; | ||
38680 | } | ||
38681 | b -= 64; | ||
38682 | cpos += 64; | ||
38683 | mpos += 64; | ||
38684 | } | ||
38685 | if (b > 0) { | ||
38686 | crypto_core_salsa20(x,z,k,sigma); | ||
38687 | for (i = 0; i < b; i++) c[cpos+i] = m[mpos+i] ^ x[i]; | ||
38688 | } | ||
38689 | return 0; | ||
38690 | } | ||
38691 | |||
38692 | function crypto_stream_salsa20(c,cpos,b,n,k) { | ||
38693 | var z = new Uint8Array(16), x = new Uint8Array(64); | ||
38694 | var u, i; | ||
38695 | for (i = 0; i < 16; i++) z[i] = 0; | ||
38696 | for (i = 0; i < 8; i++) z[i] = n[i]; | ||
38697 | while (b >= 64) { | ||
38698 | crypto_core_salsa20(x,z,k,sigma); | ||
38699 | for (i = 0; i < 64; i++) c[cpos+i] = x[i]; | ||
38700 | u = 1; | ||
38701 | for (i = 8; i < 16; i++) { | ||
38702 | u = u + (z[i] & 0xff) | 0; | ||
38703 | z[i] = u & 0xff; | ||
38704 | u >>>= 8; | ||
38705 | } | ||
38706 | b -= 64; | ||
38707 | cpos += 64; | ||
38708 | } | ||
38709 | if (b > 0) { | ||
38710 | crypto_core_salsa20(x,z,k,sigma); | ||
38711 | for (i = 0; i < b; i++) c[cpos+i] = x[i]; | ||
38712 | } | ||
38713 | return 0; | ||
38714 | } | ||
38715 | |||
38716 | function crypto_stream(c,cpos,d,n,k) { | ||
38717 | var s = new Uint8Array(32); | ||
38718 | crypto_core_hsalsa20(s,n,k,sigma); | ||
38719 | var sn = new Uint8Array(8); | ||
38720 | for (var i = 0; i < 8; i++) sn[i] = n[i+16]; | ||
38721 | return crypto_stream_salsa20(c,cpos,d,sn,s); | ||
38722 | } | ||
38723 | |||
38724 | function crypto_stream_xor(c,cpos,m,mpos,d,n,k) { | ||
38725 | var s = new Uint8Array(32); | ||
38726 | crypto_core_hsalsa20(s,n,k,sigma); | ||
38727 | var sn = new Uint8Array(8); | ||
38728 | for (var i = 0; i < 8; i++) sn[i] = n[i+16]; | ||
38729 | return crypto_stream_salsa20_xor(c,cpos,m,mpos,d,sn,s); | ||
38730 | } | ||
38731 | |||
38732 | /* | ||
38733 | * Port of Andrew Moon's Poly1305-donna-16. Public domain. | ||
38734 | * https://github.com/floodyberry/poly1305-donna | ||
38735 | */ | ||
38736 | |||
38737 | var poly1305 = function(key) { | ||
38738 | this.buffer = new Uint8Array(16); | ||
38739 | this.r = new Uint16Array(10); | ||
38740 | this.h = new Uint16Array(10); | ||
38741 | this.pad = new Uint16Array(8); | ||
38742 | this.leftover = 0; | ||
38743 | this.fin = 0; | ||
38744 | |||
38745 | var t0, t1, t2, t3, t4, t5, t6, t7; | ||
38746 | |||
38747 | t0 = key[ 0] & 0xff | (key[ 1] & 0xff) << 8; this.r[0] = ( t0 ) & 0x1fff; | ||
38748 | t1 = key[ 2] & 0xff | (key[ 3] & 0xff) << 8; this.r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff; | ||
38749 | t2 = key[ 4] & 0xff | (key[ 5] & 0xff) << 8; this.r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03; | ||
38750 | t3 = key[ 6] & 0xff | (key[ 7] & 0xff) << 8; this.r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff; | ||
38751 | t4 = key[ 8] & 0xff | (key[ 9] & 0xff) << 8; this.r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff; | ||
38752 | this.r[5] = ((t4 >>> 1)) & 0x1ffe; | ||
38753 | t5 = key[10] & 0xff | (key[11] & 0xff) << 8; this.r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff; | ||
38754 | t6 = key[12] & 0xff | (key[13] & 0xff) << 8; this.r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81; | ||
38755 | t7 = key[14] & 0xff | (key[15] & 0xff) << 8; this.r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff; | ||
38756 | this.r[9] = ((t7 >>> 5)) & 0x007f; | ||
38757 | |||
38758 | this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8; | ||
38759 | this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8; | ||
38760 | this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8; | ||
38761 | this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8; | ||
38762 | this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8; | ||
38763 | this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8; | ||
38764 | this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8; | ||
38765 | this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8; | ||
38766 | }; | ||
38767 | |||
38768 | poly1305.prototype.blocks = function(m, mpos, bytes) { | ||
38769 | var hibit = this.fin ? 0 : (1 << 11); | ||
38770 | var t0, t1, t2, t3, t4, t5, t6, t7, c; | ||
38771 | var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9; | ||
38772 | |||
38773 | var h0 = this.h[0], | ||
38774 | h1 = this.h[1], | ||
38775 | h2 = this.h[2], | ||
38776 | h3 = this.h[3], | ||
38777 | h4 = this.h[4], | ||
38778 | h5 = this.h[5], | ||
38779 | h6 = this.h[6], | ||
38780 | h7 = this.h[7], | ||
38781 | h8 = this.h[8], | ||
38782 | h9 = this.h[9]; | ||
38783 | |||
38784 | var r0 = this.r[0], | ||
38785 | r1 = this.r[1], | ||
38786 | r2 = this.r[2], | ||
38787 | r3 = this.r[3], | ||
38788 | r4 = this.r[4], | ||
38789 | r5 = this.r[5], | ||
38790 | r6 = this.r[6], | ||
38791 | r7 = this.r[7], | ||
38792 | r8 = this.r[8], | ||
38793 | r9 = this.r[9]; | ||
38794 | |||
38795 | while (bytes >= 16) { | ||
38796 | t0 = m[mpos+ 0] & 0xff | (m[mpos+ 1] & 0xff) << 8; h0 += ( t0 ) & 0x1fff; | ||
38797 | t1 = m[mpos+ 2] & 0xff | (m[mpos+ 3] & 0xff) << 8; h1 += ((t0 >>> 13) | (t1 << 3)) & 0x1fff; | ||
38798 | t2 = m[mpos+ 4] & 0xff | (m[mpos+ 5] & 0xff) << 8; h2 += ((t1 >>> 10) | (t2 << 6)) & 0x1fff; | ||
38799 | t3 = m[mpos+ 6] & 0xff | (m[mpos+ 7] & 0xff) << 8; h3 += ((t2 >>> 7) | (t3 << 9)) & 0x1fff; | ||
38800 | t4 = m[mpos+ 8] & 0xff | (m[mpos+ 9] & 0xff) << 8; h4 += ((t3 >>> 4) | (t4 << 12)) & 0x1fff; | ||
38801 | h5 += ((t4 >>> 1)) & 0x1fff; | ||
38802 | t5 = m[mpos+10] & 0xff | (m[mpos+11] & 0xff) << 8; h6 += ((t4 >>> 14) | (t5 << 2)) & 0x1fff; | ||
38803 | t6 = m[mpos+12] & 0xff | (m[mpos+13] & 0xff) << 8; h7 += ((t5 >>> 11) | (t6 << 5)) & 0x1fff; | ||
38804 | t7 = m[mpos+14] & 0xff | (m[mpos+15] & 0xff) << 8; h8 += ((t6 >>> 8) | (t7 << 8)) & 0x1fff; | ||
38805 | h9 += ((t7 >>> 5)) | hibit; | ||
38806 | |||
38807 | c = 0; | ||
38808 | |||
38809 | d0 = c; | ||
38810 | d0 += h0 * r0; | ||
38811 | d0 += h1 * (5 * r9); | ||
38812 | d0 += h2 * (5 * r8); | ||
38813 | d0 += h3 * (5 * r7); | ||
38814 | d0 += h4 * (5 * r6); | ||
38815 | c = (d0 >>> 13); d0 &= 0x1fff; | ||
38816 | d0 += h5 * (5 * r5); | ||
38817 | d0 += h6 * (5 * r4); | ||
38818 | d0 += h7 * (5 * r3); | ||
38819 | d0 += h8 * (5 * r2); | ||
38820 | d0 += h9 * (5 * r1); | ||
38821 | c += (d0 >>> 13); d0 &= 0x1fff; | ||
38822 | |||
38823 | d1 = c; | ||
38824 | d1 += h0 * r1; | ||
38825 | d1 += h1 * r0; | ||
38826 | d1 += h2 * (5 * r9); | ||
38827 | d1 += h3 * (5 * r8); | ||
38828 | d1 += h4 * (5 * r7); | ||
38829 | c = (d1 >>> 13); d1 &= 0x1fff; | ||
38830 | d1 += h5 * (5 * r6); | ||
38831 | d1 += h6 * (5 * r5); | ||
38832 | d1 += h7 * (5 * r4); | ||
38833 | d1 += h8 * (5 * r3); | ||
38834 | d1 += h9 * (5 * r2); | ||
38835 | c += (d1 >>> 13); d1 &= 0x1fff; | ||
38836 | |||
38837 | d2 = c; | ||
38838 | d2 += h0 * r2; | ||
38839 | d2 += h1 * r1; | ||
38840 | d2 += h2 * r0; | ||
38841 | d2 += h3 * (5 * r9); | ||
38842 | d2 += h4 * (5 * r8); | ||
38843 | c = (d2 >>> 13); d2 &= 0x1fff; | ||
38844 | d2 += h5 * (5 * r7); | ||
38845 | d2 += h6 * (5 * r6); | ||
38846 | d2 += h7 * (5 * r5); | ||
38847 | d2 += h8 * (5 * r4); | ||
38848 | d2 += h9 * (5 * r3); | ||
38849 | c += (d2 >>> 13); d2 &= 0x1fff; | ||
38850 | |||
38851 | d3 = c; | ||
38852 | d3 += h0 * r3; | ||
38853 | d3 += h1 * r2; | ||
38854 | d3 += h2 * r1; | ||
38855 | d3 += h3 * r0; | ||
38856 | d3 += h4 * (5 * r9); | ||
38857 | c = (d3 >>> 13); d3 &= 0x1fff; | ||
38858 | d3 += h5 * (5 * r8); | ||
38859 | d3 += h6 * (5 * r7); | ||
38860 | d3 += h7 * (5 * r6); | ||
38861 | d3 += h8 * (5 * r5); | ||
38862 | d3 += h9 * (5 * r4); | ||
38863 | c += (d3 >>> 13); d3 &= 0x1fff; | ||
38864 | |||
38865 | d4 = c; | ||
38866 | d4 += h0 * r4; | ||
38867 | d4 += h1 * r3; | ||
38868 | d4 += h2 * r2; | ||
38869 | d4 += h3 * r1; | ||
38870 | d4 += h4 * r0; | ||
38871 | c = (d4 >>> 13); d4 &= 0x1fff; | ||
38872 | d4 += h5 * (5 * r9); | ||
38873 | d4 += h6 * (5 * r8); | ||
38874 | d4 += h7 * (5 * r7); | ||
38875 | d4 += h8 * (5 * r6); | ||
38876 | d4 += h9 * (5 * r5); | ||
38877 | c += (d4 >>> 13); d4 &= 0x1fff; | ||
38878 | |||
38879 | d5 = c; | ||
38880 | d5 += h0 * r5; | ||
38881 | d5 += h1 * r4; | ||
38882 | d5 += h2 * r3; | ||
38883 | d5 += h3 * r2; | ||
38884 | d5 += h4 * r1; | ||
38885 | c = (d5 >>> 13); d5 &= 0x1fff; | ||
38886 | d5 += h5 * r0; | ||
38887 | d5 += h6 * (5 * r9); | ||
38888 | d5 += h7 * (5 * r8); | ||
38889 | d5 += h8 * (5 * r7); | ||
38890 | d5 += h9 * (5 * r6); | ||
38891 | c += (d5 >>> 13); d5 &= 0x1fff; | ||
38892 | |||
38893 | d6 = c; | ||
38894 | d6 += h0 * r6; | ||
38895 | d6 += h1 * r5; | ||
38896 | d6 += h2 * r4; | ||
38897 | d6 += h3 * r3; | ||
38898 | d6 += h4 * r2; | ||
38899 | c = (d6 >>> 13); d6 &= 0x1fff; | ||
38900 | d6 += h5 * r1; | ||
38901 | d6 += h6 * r0; | ||
38902 | d6 += h7 * (5 * r9); | ||
38903 | d6 += h8 * (5 * r8); | ||
38904 | d6 += h9 * (5 * r7); | ||
38905 | c += (d6 >>> 13); d6 &= 0x1fff; | ||
38906 | |||
38907 | d7 = c; | ||
38908 | d7 += h0 * r7; | ||
38909 | d7 += h1 * r6; | ||
38910 | d7 += h2 * r5; | ||
38911 | d7 += h3 * r4; | ||
38912 | d7 += h4 * r3; | ||
38913 | c = (d7 >>> 13); d7 &= 0x1fff; | ||
38914 | d7 += h5 * r2; | ||
38915 | d7 += h6 * r1; | ||
38916 | d7 += h7 * r0; | ||
38917 | d7 += h8 * (5 * r9); | ||
38918 | d7 += h9 * (5 * r8); | ||
38919 | c += (d7 >>> 13); d7 &= 0x1fff; | ||
38920 | |||
38921 | d8 = c; | ||
38922 | d8 += h0 * r8; | ||
38923 | d8 += h1 * r7; | ||
38924 | d8 += h2 * r6; | ||
38925 | d8 += h3 * r5; | ||
38926 | d8 += h4 * r4; | ||
38927 | c = (d8 >>> 13); d8 &= 0x1fff; | ||
38928 | d8 += h5 * r3; | ||
38929 | d8 += h6 * r2; | ||
38930 | d8 += h7 * r1; | ||
38931 | d8 += h8 * r0; | ||
38932 | d8 += h9 * (5 * r9); | ||
38933 | c += (d8 >>> 13); d8 &= 0x1fff; | ||
38934 | |||
38935 | d9 = c; | ||
38936 | d9 += h0 * r9; | ||
38937 | d9 += h1 * r8; | ||
38938 | d9 += h2 * r7; | ||
38939 | d9 += h3 * r6; | ||
38940 | d9 += h4 * r5; | ||
38941 | c = (d9 >>> 13); d9 &= 0x1fff; | ||
38942 | d9 += h5 * r4; | ||
38943 | d9 += h6 * r3; | ||
38944 | d9 += h7 * r2; | ||
38945 | d9 += h8 * r1; | ||
38946 | d9 += h9 * r0; | ||
38947 | c += (d9 >>> 13); d9 &= 0x1fff; | ||
38948 | |||
38949 | c = (((c << 2) + c)) | 0; | ||
38950 | c = (c + d0) | 0; | ||
38951 | d0 = c & 0x1fff; | ||
38952 | c = (c >>> 13); | ||
38953 | d1 += c; | ||
38954 | |||
38955 | h0 = d0; | ||
38956 | h1 = d1; | ||
38957 | h2 = d2; | ||
38958 | h3 = d3; | ||
38959 | h4 = d4; | ||
38960 | h5 = d5; | ||
38961 | h6 = d6; | ||
38962 | h7 = d7; | ||
38963 | h8 = d8; | ||
38964 | h9 = d9; | ||
38965 | |||
38966 | mpos += 16; | ||
38967 | bytes -= 16; | ||
38968 | } | ||
38969 | this.h[0] = h0; | ||
38970 | this.h[1] = h1; | ||
38971 | this.h[2] = h2; | ||
38972 | this.h[3] = h3; | ||
38973 | this.h[4] = h4; | ||
38974 | this.h[5] = h5; | ||
38975 | this.h[6] = h6; | ||
38976 | this.h[7] = h7; | ||
38977 | this.h[8] = h8; | ||
38978 | this.h[9] = h9; | ||
38979 | }; | ||
38980 | |||
38981 | poly1305.prototype.finish = function(mac, macpos) { | ||
38982 | var g = new Uint16Array(10); | ||
38983 | var c, mask, f, i; | ||
38984 | |||
38985 | if (this.leftover) { | ||
38986 | i = this.leftover; | ||
38987 | this.buffer[i++] = 1; | ||
38988 | for (; i < 16; i++) this.buffer[i] = 0; | ||
38989 | this.fin = 1; | ||
38990 | this.blocks(this.buffer, 0, 16); | ||
38991 | } | ||
38992 | |||
38993 | c = this.h[1] >>> 13; | ||
38994 | this.h[1] &= 0x1fff; | ||
38995 | for (i = 2; i < 10; i++) { | ||
38996 | this.h[i] += c; | ||
38997 | c = this.h[i] >>> 13; | ||
38998 | this.h[i] &= 0x1fff; | ||
38999 | } | ||
39000 | this.h[0] += (c * 5); | ||
39001 | c = this.h[0] >>> 13; | ||
39002 | this.h[0] &= 0x1fff; | ||
39003 | this.h[1] += c; | ||
39004 | c = this.h[1] >>> 13; | ||
39005 | this.h[1] &= 0x1fff; | ||
39006 | this.h[2] += c; | ||
39007 | |||
39008 | g[0] = this.h[0] + 5; | ||
39009 | c = g[0] >>> 13; | ||
39010 | g[0] &= 0x1fff; | ||
39011 | for (i = 1; i < 10; i++) { | ||
39012 | g[i] = this.h[i] + c; | ||
39013 | c = g[i] >>> 13; | ||
39014 | g[i] &= 0x1fff; | ||
39015 | } | ||
39016 | g[9] -= (1 << 13); | ||
39017 | |||
39018 | mask = (c ^ 1) - 1; | ||
39019 | for (i = 0; i < 10; i++) g[i] &= mask; | ||
39020 | mask = ~mask; | ||
39021 | for (i = 0; i < 10; i++) this.h[i] = (this.h[i] & mask) | g[i]; | ||
39022 | |||
39023 | this.h[0] = ((this.h[0] ) | (this.h[1] << 13) ) & 0xffff; | ||
39024 | this.h[1] = ((this.h[1] >>> 3) | (this.h[2] << 10) ) & 0xffff; | ||
39025 | this.h[2] = ((this.h[2] >>> 6) | (this.h[3] << 7) ) & 0xffff; | ||
39026 | this.h[3] = ((this.h[3] >>> 9) | (this.h[4] << 4) ) & 0xffff; | ||
39027 | this.h[4] = ((this.h[4] >>> 12) | (this.h[5] << 1) | (this.h[6] << 14)) & 0xffff; | ||
39028 | this.h[5] = ((this.h[6] >>> 2) | (this.h[7] << 11) ) & 0xffff; | ||
39029 | this.h[6] = ((this.h[7] >>> 5) | (this.h[8] << 8) ) & 0xffff; | ||
39030 | this.h[7] = ((this.h[8] >>> 8) | (this.h[9] << 5) ) & 0xffff; | ||
39031 | |||
39032 | f = this.h[0] + this.pad[0]; | ||
39033 | this.h[0] = f & 0xffff; | ||
39034 | for (i = 1; i < 8; i++) { | ||
39035 | f = (((this.h[i] + this.pad[i]) | 0) + (f >>> 16)) | 0; | ||
39036 | this.h[i] = f & 0xffff; | ||
39037 | } | ||
39038 | |||
39039 | mac[macpos+ 0] = (this.h[0] >>> 0) & 0xff; | ||
39040 | mac[macpos+ 1] = (this.h[0] >>> 8) & 0xff; | ||
39041 | mac[macpos+ 2] = (this.h[1] >>> 0) & 0xff; | ||
39042 | mac[macpos+ 3] = (this.h[1] >>> 8) & 0xff; | ||
39043 | mac[macpos+ 4] = (this.h[2] >>> 0) & 0xff; | ||
39044 | mac[macpos+ 5] = (this.h[2] >>> 8) & 0xff; | ||
39045 | mac[macpos+ 6] = (this.h[3] >>> 0) & 0xff; | ||
39046 | mac[macpos+ 7] = (this.h[3] >>> 8) & 0xff; | ||
39047 | mac[macpos+ 8] = (this.h[4] >>> 0) & 0xff; | ||
39048 | mac[macpos+ 9] = (this.h[4] >>> 8) & 0xff; | ||
39049 | mac[macpos+10] = (this.h[5] >>> 0) & 0xff; | ||
39050 | mac[macpos+11] = (this.h[5] >>> 8) & 0xff; | ||
39051 | mac[macpos+12] = (this.h[6] >>> 0) & 0xff; | ||
39052 | mac[macpos+13] = (this.h[6] >>> 8) & 0xff; | ||
39053 | mac[macpos+14] = (this.h[7] >>> 0) & 0xff; | ||
39054 | mac[macpos+15] = (this.h[7] >>> 8) & 0xff; | ||
39055 | }; | ||
39056 | |||
39057 | poly1305.prototype.update = function(m, mpos, bytes) { | ||
39058 | var i, want; | ||
39059 | |||
39060 | if (this.leftover) { | ||
39061 | want = (16 - this.leftover); | ||
39062 | if (want > bytes) | ||
39063 | want = bytes; | ||
39064 | for (i = 0; i < want; i++) | ||
39065 | this.buffer[this.leftover + i] = m[mpos+i]; | ||
39066 | bytes -= want; | ||
39067 | mpos += want; | ||
39068 | this.leftover += want; | ||
39069 | if (this.leftover < 16) | ||
39070 | return; | ||
39071 | this.blocks(this.buffer, 0, 16); | ||
39072 | this.leftover = 0; | ||
39073 | } | ||
39074 | |||
39075 | if (bytes >= 16) { | ||
39076 | want = bytes - (bytes % 16); | ||
39077 | this.blocks(m, mpos, want); | ||
39078 | mpos += want; | ||
39079 | bytes -= want; | ||
39080 | } | ||
39081 | |||
39082 | if (bytes) { | ||
39083 | for (i = 0; i < bytes; i++) | ||
39084 | this.buffer[this.leftover + i] = m[mpos+i]; | ||
39085 | this.leftover += bytes; | ||
39086 | } | ||
39087 | }; | ||
39088 | |||
39089 | function crypto_onetimeauth(out, outpos, m, mpos, n, k) { | ||
39090 | var s = new poly1305(k); | ||
39091 | s.update(m, mpos, n); | ||
39092 | s.finish(out, outpos); | ||
39093 | return 0; | ||
39094 | } | ||
39095 | |||
39096 | function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) { | ||
39097 | var x = new Uint8Array(16); | ||
39098 | crypto_onetimeauth(x,0,m,mpos,n,k); | ||
39099 | return crypto_verify_16(h,hpos,x,0); | ||
39100 | } | ||
39101 | |||
39102 | function crypto_secretbox(c,m,d,n,k) { | ||
39103 | var i; | ||
39104 | if (d < 32) return -1; | ||
39105 | crypto_stream_xor(c,0,m,0,d,n,k); | ||
39106 | crypto_onetimeauth(c, 16, c, 32, d - 32, c); | ||
39107 | for (i = 0; i < 16; i++) c[i] = 0; | ||
39108 | return 0; | ||
39109 | } | ||
39110 | |||
39111 | function crypto_secretbox_open(m,c,d,n,k) { | ||
39112 | var i; | ||
39113 | var x = new Uint8Array(32); | ||
39114 | if (d < 32) return -1; | ||
39115 | crypto_stream(x,0,32,n,k); | ||
39116 | if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1; | ||
39117 | crypto_stream_xor(m,0,c,0,d,n,k); | ||
39118 | for (i = 0; i < 32; i++) m[i] = 0; | ||
39119 | return 0; | ||
39120 | } | ||
39121 | |||
39122 | function set25519(r, a) { | ||
39123 | var i; | ||
39124 | for (i = 0; i < 16; i++) r[i] = a[i]|0; | ||
39125 | } | ||
39126 | |||
39127 | function car25519(o) { | ||
39128 | var i, v, c = 1; | ||
39129 | for (i = 0; i < 16; i++) { | ||
39130 | v = o[i] + c + 65535; | ||
39131 | c = Math.floor(v / 65536); | ||
39132 | o[i] = v - c * 65536; | ||
39133 | } | ||
39134 | o[0] += c-1 + 37 * (c-1); | ||
39135 | } | ||
39136 | |||
39137 | function sel25519(p, q, b) { | ||
39138 | var t, c = ~(b-1); | ||
39139 | for (var i = 0; i < 16; i++) { | ||
39140 | t = c & (p[i] ^ q[i]); | ||
39141 | p[i] ^= t; | ||
39142 | q[i] ^= t; | ||
39143 | } | ||
39144 | } | ||
39145 | |||
39146 | function pack25519(o, n) { | ||
39147 | var i, j, b; | ||
39148 | var m = gf(), t = gf(); | ||
39149 | for (i = 0; i < 16; i++) t[i] = n[i]; | ||
39150 | car25519(t); | ||
39151 | car25519(t); | ||
39152 | car25519(t); | ||
39153 | for (j = 0; j < 2; j++) { | ||
39154 | m[0] = t[0] - 0xffed; | ||
39155 | for (i = 1; i < 15; i++) { | ||
39156 | m[i] = t[i] - 0xffff - ((m[i-1]>>16) & 1); | ||
39157 | m[i-1] &= 0xffff; | ||
39158 | } | ||
39159 | m[15] = t[15] - 0x7fff - ((m[14]>>16) & 1); | ||
39160 | b = (m[15]>>16) & 1; | ||
39161 | m[14] &= 0xffff; | ||
39162 | sel25519(t, m, 1-b); | ||
39163 | } | ||
39164 | for (i = 0; i < 16; i++) { | ||
39165 | o[2*i] = t[i] & 0xff; | ||
39166 | o[2*i+1] = t[i]>>8; | ||
39167 | } | ||
39168 | } | ||
39169 | |||
39170 | function neq25519(a, b) { | ||
39171 | var c = new Uint8Array(32), d = new Uint8Array(32); | ||
39172 | pack25519(c, a); | ||
39173 | pack25519(d, b); | ||
39174 | return crypto_verify_32(c, 0, d, 0); | ||
39175 | } | ||
39176 | |||
39177 | function par25519(a) { | ||
39178 | var d = new Uint8Array(32); | ||
39179 | pack25519(d, a); | ||
39180 | return d[0] & 1; | ||
39181 | } | ||
39182 | |||
39183 | function unpack25519(o, n) { | ||
39184 | var i; | ||
39185 | for (i = 0; i < 16; i++) o[i] = n[2*i] + (n[2*i+1] << 8); | ||
39186 | o[15] &= 0x7fff; | ||
39187 | } | ||
39188 | |||
39189 | function A(o, a, b) { | ||
39190 | for (var i = 0; i < 16; i++) o[i] = a[i] + b[i]; | ||
39191 | } | ||
39192 | |||
39193 | function Z(o, a, b) { | ||
39194 | for (var i = 0; i < 16; i++) o[i] = a[i] - b[i]; | ||
39195 | } | ||
39196 | |||
39197 | function M(o, a, b) { | ||
39198 | var v, c, | ||
39199 | t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, | ||
39200 | t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, | ||
39201 | t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, | ||
39202 | t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, | ||
39203 | b0 = b[0], | ||
39204 | b1 = b[1], | ||
39205 | b2 = b[2], | ||
39206 | b3 = b[3], | ||
39207 | b4 = b[4], | ||
39208 | b5 = b[5], | ||
39209 | b6 = b[6], | ||
39210 | b7 = b[7], | ||
39211 | b8 = b[8], | ||
39212 | b9 = b[9], | ||
39213 | b10 = b[10], | ||
39214 | b11 = b[11], | ||
39215 | b12 = b[12], | ||
39216 | b13 = b[13], | ||
39217 | b14 = b[14], | ||
39218 | b15 = b[15]; | ||
39219 | |||
39220 | v = a[0]; | ||
39221 | t0 += v * b0; | ||
39222 | t1 += v * b1; | ||
39223 | t2 += v * b2; | ||
39224 | t3 += v * b3; | ||
39225 | t4 += v * b4; | ||
39226 | t5 += v * b5; | ||
39227 | t6 += v * b6; | ||
39228 | t7 += v * b7; | ||
39229 | t8 += v * b8; | ||
39230 | t9 += v * b9; | ||
39231 | t10 += v * b10; | ||
39232 | t11 += v * b11; | ||
39233 | t12 += v * b12; | ||
39234 | t13 += v * b13; | ||
39235 | t14 += v * b14; | ||
39236 | t15 += v * b15; | ||
39237 | v = a[1]; | ||
39238 | t1 += v * b0; | ||
39239 | t2 += v * b1; | ||
39240 | t3 += v * b2; | ||
39241 | t4 += v * b3; | ||
39242 | t5 += v * b4; | ||
39243 | t6 += v * b5; | ||
39244 | t7 += v * b6; | ||
39245 | t8 += v * b7; | ||
39246 | t9 += v * b8; | ||
39247 | t10 += v * b9; | ||
39248 | t11 += v * b10; | ||
39249 | t12 += v * b11; | ||
39250 | t13 += v * b12; | ||
39251 | t14 += v * b13; | ||
39252 | t15 += v * b14; | ||
39253 | t16 += v * b15; | ||
39254 | v = a[2]; | ||
39255 | t2 += v * b0; | ||
39256 | t3 += v * b1; | ||
39257 | t4 += v * b2; | ||
39258 | t5 += v * b3; | ||
39259 | t6 += v * b4; | ||
39260 | t7 += v * b5; | ||
39261 | t8 += v * b6; | ||
39262 | t9 += v * b7; | ||
39263 | t10 += v * b8; | ||
39264 | t11 += v * b9; | ||
39265 | t12 += v * b10; | ||
39266 | t13 += v * b11; | ||
39267 | t14 += v * b12; | ||
39268 | t15 += v * b13; | ||
39269 | t16 += v * b14; | ||
39270 | t17 += v * b15; | ||
39271 | v = a[3]; | ||
39272 | t3 += v * b0; | ||
39273 | t4 += v * b1; | ||
39274 | t5 += v * b2; | ||
39275 | t6 += v * b3; | ||
39276 | t7 += v * b4; | ||
39277 | t8 += v * b5; | ||
39278 | t9 += v * b6; | ||
39279 | t10 += v * b7; | ||
39280 | t11 += v * b8; | ||
39281 | t12 += v * b9; | ||
39282 | t13 += v * b10; | ||
39283 | t14 += v * b11; | ||
39284 | t15 += v * b12; | ||
39285 | t16 += v * b13; | ||
39286 | t17 += v * b14; | ||
39287 | t18 += v * b15; | ||
39288 | v = a[4]; | ||
39289 | t4 += v * b0; | ||
39290 | t5 += v * b1; | ||
39291 | t6 += v * b2; | ||
39292 | t7 += v * b3; | ||
39293 | t8 += v * b4; | ||
39294 | t9 += v * b5; | ||
39295 | t10 += v * b6; | ||
39296 | t11 += v * b7; | ||
39297 | t12 += v * b8; | ||
39298 | t13 += v * b9; | ||
39299 | t14 += v * b10; | ||
39300 | t15 += v * b11; | ||
39301 | t16 += v * b12; | ||
39302 | t17 += v * b13; | ||
39303 | t18 += v * b14; | ||
39304 | t19 += v * b15; | ||
39305 | v = a[5]; | ||
39306 | t5 += v * b0; | ||
39307 | t6 += v * b1; | ||
39308 | t7 += v * b2; | ||
39309 | t8 += v * b3; | ||
39310 | t9 += v * b4; | ||
39311 | t10 += v * b5; | ||
39312 | t11 += v * b6; | ||
39313 | t12 += v * b7; | ||
39314 | t13 += v * b8; | ||
39315 | t14 += v * b9; | ||
39316 | t15 += v * b10; | ||
39317 | t16 += v * b11; | ||
39318 | t17 += v * b12; | ||
39319 | t18 += v * b13; | ||
39320 | t19 += v * b14; | ||
39321 | t20 += v * b15; | ||
39322 | v = a[6]; | ||
39323 | t6 += v * b0; | ||
39324 | t7 += v * b1; | ||
39325 | t8 += v * b2; | ||
39326 | t9 += v * b3; | ||
39327 | t10 += v * b4; | ||
39328 | t11 += v * b5; | ||
39329 | t12 += v * b6; | ||
39330 | t13 += v * b7; | ||
39331 | t14 += v * b8; | ||
39332 | t15 += v * b9; | ||
39333 | t16 += v * b10; | ||
39334 | t17 += v * b11; | ||
39335 | t18 += v * b12; | ||
39336 | t19 += v * b13; | ||
39337 | t20 += v * b14; | ||
39338 | t21 += v * b15; | ||
39339 | v = a[7]; | ||
39340 | t7 += v * b0; | ||
39341 | t8 += v * b1; | ||
39342 | t9 += v * b2; | ||
39343 | t10 += v * b3; | ||
39344 | t11 += v * b4; | ||
39345 | t12 += v * b5; | ||
39346 | t13 += v * b6; | ||
39347 | t14 += v * b7; | ||
39348 | t15 += v * b8; | ||
39349 | t16 += v * b9; | ||
39350 | t17 += v * b10; | ||
39351 | t18 += v * b11; | ||
39352 | t19 += v * b12; | ||
39353 | t20 += v * b13; | ||
39354 | t21 += v * b14; | ||
39355 | t22 += v * b15; | ||
39356 | v = a[8]; | ||
39357 | t8 += v * b0; | ||
39358 | t9 += v * b1; | ||
39359 | t10 += v * b2; | ||
39360 | t11 += v * b3; | ||
39361 | t12 += v * b4; | ||
39362 | t13 += v * b5; | ||
39363 | t14 += v * b6; | ||
39364 | t15 += v * b7; | ||
39365 | t16 += v * b8; | ||
39366 | t17 += v * b9; | ||
39367 | t18 += v * b10; | ||
39368 | t19 += v * b11; | ||
39369 | t20 += v * b12; | ||
39370 | t21 += v * b13; | ||
39371 | t22 += v * b14; | ||
39372 | t23 += v * b15; | ||
39373 | v = a[9]; | ||
39374 | t9 += v * b0; | ||
39375 | t10 += v * b1; | ||
39376 | t11 += v * b2; | ||
39377 | t12 += v * b3; | ||
39378 | t13 += v * b4; | ||
39379 | t14 += v * b5; | ||
39380 | t15 += v * b6; | ||
39381 | t16 += v * b7; | ||
39382 | t17 += v * b8; | ||
39383 | t18 += v * b9; | ||
39384 | t19 += v * b10; | ||
39385 | t20 += v * b11; | ||
39386 | t21 += v * b12; | ||
39387 | t22 += v * b13; | ||
39388 | t23 += v * b14; | ||
39389 | t24 += v * b15; | ||
39390 | v = a[10]; | ||
39391 | t10 += v * b0; | ||
39392 | t11 += v * b1; | ||
39393 | t12 += v * b2; | ||
39394 | t13 += v * b3; | ||
39395 | t14 += v * b4; | ||
39396 | t15 += v * b5; | ||
39397 | t16 += v * b6; | ||
39398 | t17 += v * b7; | ||
39399 | t18 += v * b8; | ||
39400 | t19 += v * b9; | ||
39401 | t20 += v * b10; | ||
39402 | t21 += v * b11; | ||
39403 | t22 += v * b12; | ||
39404 | t23 += v * b13; | ||
39405 | t24 += v * b14; | ||
39406 | t25 += v * b15; | ||
39407 | v = a[11]; | ||
39408 | t11 += v * b0; | ||
39409 | t12 += v * b1; | ||
39410 | t13 += v * b2; | ||
39411 | t14 += v * b3; | ||
39412 | t15 += v * b4; | ||
39413 | t16 += v * b5; | ||
39414 | t17 += v * b6; | ||
39415 | t18 += v * b7; | ||
39416 | t19 += v * b8; | ||
39417 | t20 += v * b9; | ||
39418 | t21 += v * b10; | ||
39419 | t22 += v * b11; | ||
39420 | t23 += v * b12; | ||
39421 | t24 += v * b13; | ||
39422 | t25 += v * b14; | ||
39423 | t26 += v * b15; | ||
39424 | v = a[12]; | ||
39425 | t12 += v * b0; | ||
39426 | t13 += v * b1; | ||
39427 | t14 += v * b2; | ||
39428 | t15 += v * b3; | ||
39429 | t16 += v * b4; | ||
39430 | t17 += v * b5; | ||
39431 | t18 += v * b6; | ||
39432 | t19 += v * b7; | ||
39433 | t20 += v * b8; | ||
39434 | t21 += v * b9; | ||
39435 | t22 += v * b10; | ||
39436 | t23 += v * b11; | ||
39437 | t24 += v * b12; | ||
39438 | t25 += v * b13; | ||
39439 | t26 += v * b14; | ||
39440 | t27 += v * b15; | ||
39441 | v = a[13]; | ||
39442 | t13 += v * b0; | ||
39443 | t14 += v * b1; | ||
39444 | t15 += v * b2; | ||
39445 | t16 += v * b3; | ||
39446 | t17 += v * b4; | ||
39447 | t18 += v * b5; | ||
39448 | t19 += v * b6; | ||
39449 | t20 += v * b7; | ||
39450 | t21 += v * b8; | ||
39451 | t22 += v * b9; | ||
39452 | t23 += v * b10; | ||
39453 | t24 += v * b11; | ||
39454 | t25 += v * b12; | ||
39455 | t26 += v * b13; | ||
39456 | t27 += v * b14; | ||
39457 | t28 += v * b15; | ||
39458 | v = a[14]; | ||
39459 | t14 += v * b0; | ||
39460 | t15 += v * b1; | ||
39461 | t16 += v * b2; | ||
39462 | t17 += v * b3; | ||
39463 | t18 += v * b4; | ||
39464 | t19 += v * b5; | ||
39465 | t20 += v * b6; | ||
39466 | t21 += v * b7; | ||
39467 | t22 += v * b8; | ||
39468 | t23 += v * b9; | ||
39469 | t24 += v * b10; | ||
39470 | t25 += v * b11; | ||
39471 | t26 += v * b12; | ||
39472 | t27 += v * b13; | ||
39473 | t28 += v * b14; | ||
39474 | t29 += v * b15; | ||
39475 | v = a[15]; | ||
39476 | t15 += v * b0; | ||
39477 | t16 += v * b1; | ||
39478 | t17 += v * b2; | ||
39479 | t18 += v * b3; | ||
39480 | t19 += v * b4; | ||
39481 | t20 += v * b5; | ||
39482 | t21 += v * b6; | ||
39483 | t22 += v * b7; | ||
39484 | t23 += v * b8; | ||
39485 | t24 += v * b9; | ||
39486 | t25 += v * b10; | ||
39487 | t26 += v * b11; | ||
39488 | t27 += v * b12; | ||
39489 | t28 += v * b13; | ||
39490 | t29 += v * b14; | ||
39491 | t30 += v * b15; | ||
39492 | |||
39493 | t0 += 38 * t16; | ||
39494 | t1 += 38 * t17; | ||
39495 | t2 += 38 * t18; | ||
39496 | t3 += 38 * t19; | ||
39497 | t4 += 38 * t20; | ||
39498 | t5 += 38 * t21; | ||
39499 | t6 += 38 * t22; | ||
39500 | t7 += 38 * t23; | ||
39501 | t8 += 38 * t24; | ||
39502 | t9 += 38 * t25; | ||
39503 | t10 += 38 * t26; | ||
39504 | t11 += 38 * t27; | ||
39505 | t12 += 38 * t28; | ||
39506 | t13 += 38 * t29; | ||
39507 | t14 += 38 * t30; | ||
39508 | // t15 left as is | ||
39509 | |||
39510 | // first car | ||
39511 | c = 1; | ||
39512 | v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536; | ||
39513 | v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536; | ||
39514 | v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536; | ||
39515 | v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536; | ||
39516 | v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536; | ||
39517 | v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536; | ||
39518 | v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536; | ||
39519 | v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536; | ||
39520 | v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536; | ||
39521 | v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536; | ||
39522 | v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536; | ||
39523 | v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536; | ||
39524 | v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536; | ||
39525 | v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536; | ||
39526 | v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536; | ||
39527 | v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536; | ||
39528 | t0 += c-1 + 37 * (c-1); | ||
39529 | |||
39530 | // second car | ||
39531 | c = 1; | ||
39532 | v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536; | ||
39533 | v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536; | ||
39534 | v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536; | ||
39535 | v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536; | ||
39536 | v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536; | ||
39537 | v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536; | ||
39538 | v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536; | ||
39539 | v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536; | ||
39540 | v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536; | ||
39541 | v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536; | ||
39542 | v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536; | ||
39543 | v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536; | ||
39544 | v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536; | ||
39545 | v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536; | ||
39546 | v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536; | ||
39547 | v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536; | ||
39548 | t0 += c-1 + 37 * (c-1); | ||
39549 | |||
39550 | o[ 0] = t0; | ||
39551 | o[ 1] = t1; | ||
39552 | o[ 2] = t2; | ||
39553 | o[ 3] = t3; | ||
39554 | o[ 4] = t4; | ||
39555 | o[ 5] = t5; | ||
39556 | o[ 6] = t6; | ||
39557 | o[ 7] = t7; | ||
39558 | o[ 8] = t8; | ||
39559 | o[ 9] = t9; | ||
39560 | o[10] = t10; | ||
39561 | o[11] = t11; | ||
39562 | o[12] = t12; | ||
39563 | o[13] = t13; | ||
39564 | o[14] = t14; | ||
39565 | o[15] = t15; | ||
39566 | } | ||
39567 | |||
39568 | function S(o, a) { | ||
39569 | M(o, a, a); | ||
39570 | } | ||
39571 | |||
39572 | function inv25519(o, i) { | ||
39573 | var c = gf(); | ||
39574 | var a; | ||
39575 | for (a = 0; a < 16; a++) c[a] = i[a]; | ||
39576 | for (a = 253; a >= 0; a--) { | ||
39577 | S(c, c); | ||
39578 | if(a !== 2 && a !== 4) M(c, c, i); | ||
39579 | } | ||
39580 | for (a = 0; a < 16; a++) o[a] = c[a]; | ||
39581 | } | ||
39582 | |||
39583 | function pow2523(o, i) { | ||
39584 | var c = gf(); | ||
39585 | var a; | ||
39586 | for (a = 0; a < 16; a++) c[a] = i[a]; | ||
39587 | for (a = 250; a >= 0; a--) { | ||
39588 | S(c, c); | ||
39589 | if(a !== 1) M(c, c, i); | ||
39590 | } | ||
39591 | for (a = 0; a < 16; a++) o[a] = c[a]; | ||
39592 | } | ||
39593 | |||
39594 | function crypto_scalarmult(q, n, p) { | ||
39595 | var z = new Uint8Array(32); | ||
39596 | var x = new Float64Array(80), r, i; | ||
39597 | var a = gf(), b = gf(), c = gf(), | ||
39598 | d = gf(), e = gf(), f = gf(); | ||
39599 | for (i = 0; i < 31; i++) z[i] = n[i]; | ||
39600 | z[31]=(n[31]&127)|64; | ||
39601 | z[0]&=248; | ||
39602 | unpack25519(x,p); | ||
39603 | for (i = 0; i < 16; i++) { | ||
39604 | b[i]=x[i]; | ||
39605 | d[i]=a[i]=c[i]=0; | ||
39606 | } | ||
39607 | a[0]=d[0]=1; | ||
39608 | for (i=254; i>=0; --i) { | ||
39609 | r=(z[i>>>3]>>>(i&7))&1; | ||
39610 | sel25519(a,b,r); | ||
39611 | sel25519(c,d,r); | ||
39612 | A(e,a,c); | ||
39613 | Z(a,a,c); | ||
39614 | A(c,b,d); | ||
39615 | Z(b,b,d); | ||
39616 | S(d,e); | ||
39617 | S(f,a); | ||
39618 | M(a,c,a); | ||
39619 | M(c,b,e); | ||
39620 | A(e,a,c); | ||
39621 | Z(a,a,c); | ||
39622 | S(b,a); | ||
39623 | Z(c,d,f); | ||
39624 | M(a,c,_121665); | ||
39625 | A(a,a,d); | ||
39626 | M(c,c,a); | ||
39627 | M(a,d,f); | ||
39628 | M(d,b,x); | ||
39629 | S(b,e); | ||
39630 | sel25519(a,b,r); | ||
39631 | sel25519(c,d,r); | ||
39632 | } | ||
39633 | for (i = 0; i < 16; i++) { | ||
39634 | x[i+16]=a[i]; | ||
39635 | x[i+32]=c[i]; | ||
39636 | x[i+48]=b[i]; | ||
39637 | x[i+64]=d[i]; | ||
39638 | } | ||
39639 | var x32 = x.subarray(32); | ||
39640 | var x16 = x.subarray(16); | ||
39641 | inv25519(x32,x32); | ||
39642 | M(x16,x16,x32); | ||
39643 | pack25519(q,x16); | ||
39644 | return 0; | ||
39645 | } | ||
39646 | |||
39647 | function crypto_scalarmult_base(q, n) { | ||
39648 | return crypto_scalarmult(q, n, _9); | ||
39649 | } | ||
39650 | |||
39651 | function crypto_box_keypair(y, x) { | ||
39652 | randombytes(x, 32); | ||
39653 | return crypto_scalarmult_base(y, x); | ||
39654 | } | ||
39655 | |||
39656 | function crypto_box_beforenm(k, y, x) { | ||
39657 | var s = new Uint8Array(32); | ||
39658 | crypto_scalarmult(s, x, y); | ||
39659 | return crypto_core_hsalsa20(k, _0, s, sigma); | ||
39660 | } | ||
39661 | |||
39662 | var crypto_box_afternm = crypto_secretbox; | ||
39663 | var crypto_box_open_afternm = crypto_secretbox_open; | ||
39664 | |||
39665 | function crypto_box(c, m, d, n, y, x) { | ||
39666 | var k = new Uint8Array(32); | ||
39667 | crypto_box_beforenm(k, y, x); | ||
39668 | return crypto_box_afternm(c, m, d, n, k); | ||
39669 | } | ||
39670 | |||
39671 | function crypto_box_open(m, c, d, n, y, x) { | ||
39672 | var k = new Uint8Array(32); | ||
39673 | crypto_box_beforenm(k, y, x); | ||
39674 | return crypto_box_open_afternm(m, c, d, n, k); | ||
39675 | } | ||
39676 | |||
39677 | var K = [ | ||
39678 | 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, | ||
39679 | 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, | ||
39680 | 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, | ||
39681 | 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, | ||
39682 | 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, | ||
39683 | 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, | ||
39684 | 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, | ||
39685 | 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, | ||
39686 | 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, | ||
39687 | 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, | ||
39688 | 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, | ||
39689 | 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, | ||
39690 | 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, | ||
39691 | 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, | ||
39692 | 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, | ||
39693 | 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, | ||
39694 | 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, | ||
39695 | 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, | ||
39696 | 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, | ||
39697 | 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, | ||
39698 | 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, | ||
39699 | 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, | ||
39700 | 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, | ||
39701 | 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, | ||
39702 | 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, | ||
39703 | 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, | ||
39704 | 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, | ||
39705 | 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, | ||
39706 | 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, | ||
39707 | 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, | ||
39708 | 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, | ||
39709 | 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, | ||
39710 | 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, | ||
39711 | 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, | ||
39712 | 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, | ||
39713 | 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, | ||
39714 | 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, | ||
39715 | 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, | ||
39716 | 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, | ||
39717 | 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 | ||
39718 | ]; | ||
39719 | |||
39720 | function crypto_hashblocks_hl(hh, hl, m, n) { | ||
39721 | var wh = new Int32Array(16), wl = new Int32Array(16), | ||
39722 | bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7, | ||
39723 | bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7, | ||
39724 | th, tl, i, j, h, l, a, b, c, d; | ||
39725 | |||
39726 | var ah0 = hh[0], | ||
39727 | ah1 = hh[1], | ||
39728 | ah2 = hh[2], | ||
39729 | ah3 = hh[3], | ||
39730 | ah4 = hh[4], | ||
39731 | ah5 = hh[5], | ||
39732 | ah6 = hh[6], | ||
39733 | ah7 = hh[7], | ||
39734 | |||
39735 | al0 = hl[0], | ||
39736 | al1 = hl[1], | ||
39737 | al2 = hl[2], | ||
39738 | al3 = hl[3], | ||
39739 | al4 = hl[4], | ||
39740 | al5 = hl[5], | ||
39741 | al6 = hl[6], | ||
39742 | al7 = hl[7]; | ||
39743 | |||
39744 | var pos = 0; | ||
39745 | while (n >= 128) { | ||
39746 | for (i = 0; i < 16; i++) { | ||
39747 | j = 8 * i + pos; | ||
39748 | wh[i] = (m[j+0] << 24) | (m[j+1] << 16) | (m[j+2] << 8) | m[j+3]; | ||
39749 | wl[i] = (m[j+4] << 24) | (m[j+5] << 16) | (m[j+6] << 8) | m[j+7]; | ||
39750 | } | ||
39751 | for (i = 0; i < 80; i++) { | ||
39752 | bh0 = ah0; | ||
39753 | bh1 = ah1; | ||
39754 | bh2 = ah2; | ||
39755 | bh3 = ah3; | ||
39756 | bh4 = ah4; | ||
39757 | bh5 = ah5; | ||
39758 | bh6 = ah6; | ||
39759 | bh7 = ah7; | ||
39760 | |||
39761 | bl0 = al0; | ||
39762 | bl1 = al1; | ||
39763 | bl2 = al2; | ||
39764 | bl3 = al3; | ||
39765 | bl4 = al4; | ||
39766 | bl5 = al5; | ||
39767 | bl6 = al6; | ||
39768 | bl7 = al7; | ||
39769 | |||
39770 | // add | ||
39771 | h = ah7; | ||
39772 | l = al7; | ||
39773 | |||
39774 | a = l & 0xffff; b = l >>> 16; | ||
39775 | c = h & 0xffff; d = h >>> 16; | ||
39776 | |||
39777 | // Sigma1 | ||
39778 | h = ((ah4 >>> 14) | (al4 << (32-14))) ^ ((ah4 >>> 18) | (al4 << (32-18))) ^ ((al4 >>> (41-32)) | (ah4 << (32-(41-32)))); | ||
39779 | l = ((al4 >>> 14) | (ah4 << (32-14))) ^ ((al4 >>> 18) | (ah4 << (32-18))) ^ ((ah4 >>> (41-32)) | (al4 << (32-(41-32)))); | ||
39780 | |||
39781 | a += l & 0xffff; b += l >>> 16; | ||
39782 | c += h & 0xffff; d += h >>> 16; | ||
39783 | |||
39784 | // Ch | ||
39785 | h = (ah4 & ah5) ^ (~ah4 & ah6); | ||
39786 | l = (al4 & al5) ^ (~al4 & al6); | ||
39787 | |||
39788 | a += l & 0xffff; b += l >>> 16; | ||
39789 | c += h & 0xffff; d += h >>> 16; | ||
39790 | |||
39791 | // K | ||
39792 | h = K[i*2]; | ||
39793 | l = K[i*2+1]; | ||
39794 | |||
39795 | a += l & 0xffff; b += l >>> 16; | ||
39796 | c += h & 0xffff; d += h >>> 16; | ||
39797 | |||
39798 | // w | ||
39799 | h = wh[i%16]; | ||
39800 | l = wl[i%16]; | ||
39801 | |||
39802 | a += l & 0xffff; b += l >>> 16; | ||
39803 | c += h & 0xffff; d += h >>> 16; | ||
39804 | |||
39805 | b += a >>> 16; | ||
39806 | c += b >>> 16; | ||
39807 | d += c >>> 16; | ||
39808 | |||
39809 | th = c & 0xffff | d << 16; | ||
39810 | tl = a & 0xffff | b << 16; | ||
39811 | |||
39812 | // add | ||
39813 | h = th; | ||
39814 | l = tl; | ||
39815 | |||
39816 | a = l & 0xffff; b = l >>> 16; | ||
39817 | c = h & 0xffff; d = h >>> 16; | ||
39818 | |||
39819 | // Sigma0 | ||
39820 | h = ((ah0 >>> 28) | (al0 << (32-28))) ^ ((al0 >>> (34-32)) | (ah0 << (32-(34-32)))) ^ ((al0 >>> (39-32)) | (ah0 << (32-(39-32)))); | ||
39821 | l = ((al0 >>> 28) | (ah0 << (32-28))) ^ ((ah0 >>> (34-32)) | (al0 << (32-(34-32)))) ^ ((ah0 >>> (39-32)) | (al0 << (32-(39-32)))); | ||
39822 | |||
39823 | a += l & 0xffff; b += l >>> 16; | ||
39824 | c += h & 0xffff; d += h >>> 16; | ||
39825 | |||
39826 | // Maj | ||
39827 | h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2); | ||
39828 | l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2); | ||
39829 | |||
39830 | a += l & 0xffff; b += l >>> 16; | ||
39831 | c += h & 0xffff; d += h >>> 16; | ||
39832 | |||
39833 | b += a >>> 16; | ||
39834 | c += b >>> 16; | ||
39835 | d += c >>> 16; | ||
39836 | |||
39837 | bh7 = (c & 0xffff) | (d << 16); | ||
39838 | bl7 = (a & 0xffff) | (b << 16); | ||
39839 | |||
39840 | // add | ||
39841 | h = bh3; | ||
39842 | l = bl3; | ||
39843 | |||
39844 | a = l & 0xffff; b = l >>> 16; | ||
39845 | c = h & 0xffff; d = h >>> 16; | ||
39846 | |||
39847 | h = th; | ||
39848 | l = tl; | ||
39849 | |||
39850 | a += l & 0xffff; b += l >>> 16; | ||
39851 | c += h & 0xffff; d += h >>> 16; | ||
39852 | |||
39853 | b += a >>> 16; | ||
39854 | c += b >>> 16; | ||
39855 | d += c >>> 16; | ||
39856 | |||
39857 | bh3 = (c & 0xffff) | (d << 16); | ||
39858 | bl3 = (a & 0xffff) | (b << 16); | ||
39859 | |||
39860 | ah1 = bh0; | ||
39861 | ah2 = bh1; | ||
39862 | ah3 = bh2; | ||
39863 | ah4 = bh3; | ||
39864 | ah5 = bh4; | ||
39865 | ah6 = bh5; | ||
39866 | ah7 = bh6; | ||
39867 | ah0 = bh7; | ||
39868 | |||
39869 | al1 = bl0; | ||
39870 | al2 = bl1; | ||
39871 | al3 = bl2; | ||
39872 | al4 = bl3; | ||
39873 | al5 = bl4; | ||
39874 | al6 = bl5; | ||
39875 | al7 = bl6; | ||
39876 | al0 = bl7; | ||
39877 | |||
39878 | if (i%16 === 15) { | ||
39879 | for (j = 0; j < 16; j++) { | ||
39880 | // add | ||
39881 | h = wh[j]; | ||
39882 | l = wl[j]; | ||
39883 | |||
39884 | a = l & 0xffff; b = l >>> 16; | ||
39885 | c = h & 0xffff; d = h >>> 16; | ||
39886 | |||
39887 | h = wh[(j+9)%16]; | ||
39888 | l = wl[(j+9)%16]; | ||
39889 | |||
39890 | a += l & 0xffff; b += l >>> 16; | ||
39891 | c += h & 0xffff; d += h >>> 16; | ||
39892 | |||
39893 | // sigma0 | ||
39894 | th = wh[(j+1)%16]; | ||
39895 | tl = wl[(j+1)%16]; | ||
39896 | h = ((th >>> 1) | (tl << (32-1))) ^ ((th >>> 8) | (tl << (32-8))) ^ (th >>> 7); | ||
39897 | l = ((tl >>> 1) | (th << (32-1))) ^ ((tl >>> 8) | (th << (32-8))) ^ ((tl >>> 7) | (th << (32-7))); | ||
39898 | |||
39899 | a += l & 0xffff; b += l >>> 16; | ||
39900 | c += h & 0xffff; d += h >>> 16; | ||
39901 | |||
39902 | // sigma1 | ||
39903 | th = wh[(j+14)%16]; | ||
39904 | tl = wl[(j+14)%16]; | ||
39905 | h = ((th >>> 19) | (tl << (32-19))) ^ ((tl >>> (61-32)) | (th << (32-(61-32)))) ^ (th >>> 6); | ||
39906 | l = ((tl >>> 19) | (th << (32-19))) ^ ((th >>> (61-32)) | (tl << (32-(61-32)))) ^ ((tl >>> 6) | (th << (32-6))); | ||
39907 | |||
39908 | a += l & 0xffff; b += l >>> 16; | ||
39909 | c += h & 0xffff; d += h >>> 16; | ||
39910 | |||
39911 | b += a >>> 16; | ||
39912 | c += b >>> 16; | ||
39913 | d += c >>> 16; | ||
39914 | |||
39915 | wh[j] = (c & 0xffff) | (d << 16); | ||
39916 | wl[j] = (a & 0xffff) | (b << 16); | ||
39917 | } | ||
39918 | } | ||
39919 | } | ||
39920 | |||
39921 | // add | ||
39922 | h = ah0; | ||
39923 | l = al0; | ||
39924 | |||
39925 | a = l & 0xffff; b = l >>> 16; | ||
39926 | c = h & 0xffff; d = h >>> 16; | ||
39927 | |||
39928 | h = hh[0]; | ||
39929 | l = hl[0]; | ||
39930 | |||
39931 | a += l & 0xffff; b += l >>> 16; | ||
39932 | c += h & 0xffff; d += h >>> 16; | ||
39933 | |||
39934 | b += a >>> 16; | ||
39935 | c += b >>> 16; | ||
39936 | d += c >>> 16; | ||
39937 | |||
39938 | hh[0] = ah0 = (c & 0xffff) | (d << 16); | ||
39939 | hl[0] = al0 = (a & 0xffff) | (b << 16); | ||
39940 | |||
39941 | h = ah1; | ||
39942 | l = al1; | ||
39943 | |||
39944 | a = l & 0xffff; b = l >>> 16; | ||
39945 | c = h & 0xffff; d = h >>> 16; | ||
39946 | |||
39947 | h = hh[1]; | ||
39948 | l = hl[1]; | ||
39949 | |||
39950 | a += l & 0xffff; b += l >>> 16; | ||
39951 | c += h & 0xffff; d += h >>> 16; | ||
39952 | |||
39953 | b += a >>> 16; | ||
39954 | c += b >>> 16; | ||
39955 | d += c >>> 16; | ||
39956 | |||
39957 | hh[1] = ah1 = (c & 0xffff) | (d << 16); | ||
39958 | hl[1] = al1 = (a & 0xffff) | (b << 16); | ||
39959 | |||
39960 | h = ah2; | ||
39961 | l = al2; | ||
39962 | |||
39963 | a = l & 0xffff; b = l >>> 16; | ||
39964 | c = h & 0xffff; d = h >>> 16; | ||
39965 | |||
39966 | h = hh[2]; | ||
39967 | l = hl[2]; | ||
39968 | |||
39969 | a += l & 0xffff; b += l >>> 16; | ||
39970 | c += h & 0xffff; d += h >>> 16; | ||
39971 | |||
39972 | b += a >>> 16; | ||
39973 | c += b >>> 16; | ||
39974 | d += c >>> 16; | ||
39975 | |||
39976 | hh[2] = ah2 = (c & 0xffff) | (d << 16); | ||
39977 | hl[2] = al2 = (a & 0xffff) | (b << 16); | ||
39978 | |||
39979 | h = ah3; | ||
39980 | l = al3; | ||
39981 | |||
39982 | a = l & 0xffff; b = l >>> 16; | ||
39983 | c = h & 0xffff; d = h >>> 16; | ||
39984 | |||
39985 | h = hh[3]; | ||
39986 | l = hl[3]; | ||
39987 | |||
39988 | a += l & 0xffff; b += l >>> 16; | ||
39989 | c += h & 0xffff; d += h >>> 16; | ||
39990 | |||
39991 | b += a >>> 16; | ||
39992 | c += b >>> 16; | ||
39993 | d += c >>> 16; | ||
39994 | |||
39995 | hh[3] = ah3 = (c & 0xffff) | (d << 16); | ||
39996 | hl[3] = al3 = (a & 0xffff) | (b << 16); | ||
39997 | |||
39998 | h = ah4; | ||
39999 | l = al4; | ||
40000 | |||
40001 | a = l & 0xffff; b = l >>> 16; | ||
40002 | c = h & 0xffff; d = h >>> 16; | ||
40003 | |||
40004 | h = hh[4]; | ||
40005 | l = hl[4]; | ||
40006 | |||
40007 | a += l & 0xffff; b += l >>> 16; | ||
40008 | c += h & 0xffff; d += h >>> 16; | ||
40009 | |||
40010 | b += a >>> 16; | ||
40011 | c += b >>> 16; | ||
40012 | d += c >>> 16; | ||
40013 | |||
40014 | hh[4] = ah4 = (c & 0xffff) | (d << 16); | ||
40015 | hl[4] = al4 = (a & 0xffff) | (b << 16); | ||
40016 | |||
40017 | h = ah5; | ||
40018 | l = al5; | ||
40019 | |||
40020 | a = l & 0xffff; b = l >>> 16; | ||
40021 | c = h & 0xffff; d = h >>> 16; | ||
40022 | |||
40023 | h = hh[5]; | ||
40024 | l = hl[5]; | ||
40025 | |||
40026 | a += l & 0xffff; b += l >>> 16; | ||
40027 | c += h & 0xffff; d += h >>> 16; | ||
40028 | |||
40029 | b += a >>> 16; | ||
40030 | c += b >>> 16; | ||
40031 | d += c >>> 16; | ||
40032 | |||
40033 | hh[5] = ah5 = (c & 0xffff) | (d << 16); | ||
40034 | hl[5] = al5 = (a & 0xffff) | (b << 16); | ||
40035 | |||
40036 | h = ah6; | ||
40037 | l = al6; | ||
40038 | |||
40039 | a = l & 0xffff; b = l >>> 16; | ||
40040 | c = h & 0xffff; d = h >>> 16; | ||
40041 | |||
40042 | h = hh[6]; | ||
40043 | l = hl[6]; | ||
40044 | |||
40045 | a += l & 0xffff; b += l >>> 16; | ||
40046 | c += h & 0xffff; d += h >>> 16; | ||
40047 | |||
40048 | b += a >>> 16; | ||
40049 | c += b >>> 16; | ||
40050 | d += c >>> 16; | ||
40051 | |||
40052 | hh[6] = ah6 = (c & 0xffff) | (d << 16); | ||
40053 | hl[6] = al6 = (a & 0xffff) | (b << 16); | ||
40054 | |||
40055 | h = ah7; | ||
40056 | l = al7; | ||
40057 | |||
40058 | a = l & 0xffff; b = l >>> 16; | ||
40059 | c = h & 0xffff; d = h >>> 16; | ||
40060 | |||
40061 | h = hh[7]; | ||
40062 | l = hl[7]; | ||
40063 | |||
40064 | a += l & 0xffff; b += l >>> 16; | ||
40065 | c += h & 0xffff; d += h >>> 16; | ||
40066 | |||
40067 | b += a >>> 16; | ||
40068 | c += b >>> 16; | ||
40069 | d += c >>> 16; | ||
40070 | |||
40071 | hh[7] = ah7 = (c & 0xffff) | (d << 16); | ||
40072 | hl[7] = al7 = (a & 0xffff) | (b << 16); | ||
40073 | |||
40074 | pos += 128; | ||
40075 | n -= 128; | ||
40076 | } | ||
40077 | |||
40078 | return n; | ||
40079 | } | ||
40080 | |||
40081 | function crypto_hash(out, m, n) { | ||
40082 | var hh = new Int32Array(8), | ||
40083 | hl = new Int32Array(8), | ||
40084 | x = new Uint8Array(256), | ||
40085 | i, b = n; | ||
40086 | |||
40087 | hh[0] = 0x6a09e667; | ||
40088 | hh[1] = 0xbb67ae85; | ||
40089 | hh[2] = 0x3c6ef372; | ||
40090 | hh[3] = 0xa54ff53a; | ||
40091 | hh[4] = 0x510e527f; | ||
40092 | hh[5] = 0x9b05688c; | ||
40093 | hh[6] = 0x1f83d9ab; | ||
40094 | hh[7] = 0x5be0cd19; | ||
40095 | |||
40096 | hl[0] = 0xf3bcc908; | ||
40097 | hl[1] = 0x84caa73b; | ||
40098 | hl[2] = 0xfe94f82b; | ||
40099 | hl[3] = 0x5f1d36f1; | ||
40100 | hl[4] = 0xade682d1; | ||
40101 | hl[5] = 0x2b3e6c1f; | ||
40102 | hl[6] = 0xfb41bd6b; | ||
40103 | hl[7] = 0x137e2179; | ||
40104 | |||
40105 | crypto_hashblocks_hl(hh, hl, m, n); | ||
40106 | n %= 128; | ||
40107 | |||
40108 | for (i = 0; i < n; i++) x[i] = m[b-n+i]; | ||
40109 | x[n] = 128; | ||
40110 | |||
40111 | n = 256-128*(n<112?1:0); | ||
40112 | x[n-9] = 0; | ||
40113 | ts64(x, n-8, (b / 0x20000000) | 0, b << 3); | ||
40114 | crypto_hashblocks_hl(hh, hl, x, n); | ||
40115 | |||
40116 | for (i = 0; i < 8; i++) ts64(out, 8*i, hh[i], hl[i]); | ||
40117 | |||
40118 | return 0; | ||
40119 | } | ||
40120 | |||
40121 | function add(p, q) { | ||
40122 | var a = gf(), b = gf(), c = gf(), | ||
40123 | d = gf(), e = gf(), f = gf(), | ||
40124 | g = gf(), h = gf(), t = gf(); | ||
40125 | |||
40126 | Z(a, p[1], p[0]); | ||
40127 | Z(t, q[1], q[0]); | ||
40128 | M(a, a, t); | ||
40129 | A(b, p[0], p[1]); | ||
40130 | A(t, q[0], q[1]); | ||
40131 | M(b, b, t); | ||
40132 | M(c, p[3], q[3]); | ||
40133 | M(c, c, D2); | ||
40134 | M(d, p[2], q[2]); | ||
40135 | A(d, d, d); | ||
40136 | Z(e, b, a); | ||
40137 | Z(f, d, c); | ||
40138 | A(g, d, c); | ||
40139 | A(h, b, a); | ||
40140 | |||
40141 | M(p[0], e, f); | ||
40142 | M(p[1], h, g); | ||
40143 | M(p[2], g, f); | ||
40144 | M(p[3], e, h); | ||
40145 | } | ||
40146 | |||
40147 | function cswap(p, q, b) { | ||
40148 | var i; | ||
40149 | for (i = 0; i < 4; i++) { | ||
40150 | sel25519(p[i], q[i], b); | ||
40151 | } | ||
40152 | } | ||
40153 | |||
40154 | function pack(r, p) { | ||
40155 | var tx = gf(), ty = gf(), zi = gf(); | ||
40156 | inv25519(zi, p[2]); | ||
40157 | M(tx, p[0], zi); | ||
40158 | M(ty, p[1], zi); | ||
40159 | pack25519(r, ty); | ||
40160 | r[31] ^= par25519(tx) << 7; | ||
40161 | } | ||
40162 | |||
40163 | function scalarmult(p, q, s) { | ||
40164 | var b, i; | ||
40165 | set25519(p[0], gf0); | ||
40166 | set25519(p[1], gf1); | ||
40167 | set25519(p[2], gf1); | ||
40168 | set25519(p[3], gf0); | ||
40169 | for (i = 255; i >= 0; --i) { | ||
40170 | b = (s[(i/8)|0] >> (i&7)) & 1; | ||
40171 | cswap(p, q, b); | ||
40172 | add(q, p); | ||
40173 | add(p, p); | ||
40174 | cswap(p, q, b); | ||
40175 | } | ||
40176 | } | ||
40177 | |||
40178 | function scalarbase(p, s) { | ||
40179 | var q = [gf(), gf(), gf(), gf()]; | ||
40180 | set25519(q[0], X); | ||
40181 | set25519(q[1], Y); | ||
40182 | set25519(q[2], gf1); | ||
40183 | M(q[3], X, Y); | ||
40184 | scalarmult(p, q, s); | ||
40185 | } | ||
40186 | |||
40187 | function crypto_sign_keypair(pk, sk, seeded) { | ||
40188 | var d = new Uint8Array(64); | ||
40189 | var p = [gf(), gf(), gf(), gf()]; | ||
40190 | var i; | ||
40191 | |||
40192 | if (!seeded) randombytes(sk, 32); | ||
40193 | crypto_hash(d, sk, 32); | ||
40194 | d[0] &= 248; | ||
40195 | d[31] &= 127; | ||
40196 | d[31] |= 64; | ||
40197 | |||
40198 | scalarbase(p, d); | ||
40199 | pack(pk, p); | ||
40200 | |||
40201 | for (i = 0; i < 32; i++) sk[i+32] = pk[i]; | ||
40202 | return 0; | ||
40203 | } | ||
40204 | |||
40205 | var L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10]); | ||
40206 | |||
40207 | function modL(r, x) { | ||
40208 | var carry, i, j, k; | ||
40209 | for (i = 63; i >= 32; --i) { | ||
40210 | carry = 0; | ||
40211 | for (j = i - 32, k = i - 12; j < k; ++j) { | ||
40212 | x[j] += carry - 16 * x[i] * L[j - (i - 32)]; | ||
40213 | carry = (x[j] + 128) >> 8; | ||
40214 | x[j] -= carry * 256; | ||
40215 | } | ||
40216 | x[j] += carry; | ||
40217 | x[i] = 0; | ||
40218 | } | ||
40219 | carry = 0; | ||
40220 | for (j = 0; j < 32; j++) { | ||
40221 | x[j] += carry - (x[31] >> 4) * L[j]; | ||
40222 | carry = x[j] >> 8; | ||
40223 | x[j] &= 255; | ||
40224 | } | ||
40225 | for (j = 0; j < 32; j++) x[j] -= carry * L[j]; | ||
40226 | for (i = 0; i < 32; i++) { | ||
40227 | x[i+1] += x[i] >> 8; | ||
40228 | r[i] = x[i] & 255; | ||
40229 | } | ||
40230 | } | ||
40231 | |||
40232 | function reduce(r) { | ||
40233 | var x = new Float64Array(64), i; | ||
40234 | for (i = 0; i < 64; i++) x[i] = r[i]; | ||
40235 | for (i = 0; i < 64; i++) r[i] = 0; | ||
40236 | modL(r, x); | ||
40237 | } | ||
40238 | |||
40239 | // Note: difference from C - smlen returned, not passed as argument. | ||
40240 | function crypto_sign(sm, m, n, sk) { | ||
40241 | var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64); | ||
40242 | var i, j, x = new Float64Array(64); | ||
40243 | var p = [gf(), gf(), gf(), gf()]; | ||
40244 | |||
40245 | crypto_hash(d, sk, 32); | ||
40246 | d[0] &= 248; | ||
40247 | d[31] &= 127; | ||
40248 | d[31] |= 64; | ||
40249 | |||
40250 | var smlen = n + 64; | ||
40251 | for (i = 0; i < n; i++) sm[64 + i] = m[i]; | ||
40252 | for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i]; | ||
40253 | |||
40254 | crypto_hash(r, sm.subarray(32), n+32); | ||
40255 | reduce(r); | ||
40256 | scalarbase(p, r); | ||
40257 | pack(sm, p); | ||
40258 | |||
40259 | for (i = 32; i < 64; i++) sm[i] = sk[i]; | ||
40260 | crypto_hash(h, sm, n + 64); | ||
40261 | reduce(h); | ||
40262 | |||
40263 | for (i = 0; i < 64; i++) x[i] = 0; | ||
40264 | for (i = 0; i < 32; i++) x[i] = r[i]; | ||
40265 | for (i = 0; i < 32; i++) { | ||
40266 | for (j = 0; j < 32; j++) { | ||
40267 | x[i+j] += h[i] * d[j]; | ||
40268 | } | ||
40269 | } | ||
40270 | |||
40271 | modL(sm.subarray(32), x); | ||
40272 | return smlen; | ||
40273 | } | ||
40274 | |||
40275 | function unpackneg(r, p) { | ||
40276 | var t = gf(), chk = gf(), num = gf(), | ||
40277 | den = gf(), den2 = gf(), den4 = gf(), | ||
40278 | den6 = gf(); | ||
40279 | |||
40280 | set25519(r[2], gf1); | ||
40281 | unpack25519(r[1], p); | ||
40282 | S(num, r[1]); | ||
40283 | M(den, num, D); | ||
40284 | Z(num, num, r[2]); | ||
40285 | A(den, r[2], den); | ||
40286 | |||
40287 | S(den2, den); | ||
40288 | S(den4, den2); | ||
40289 | M(den6, den4, den2); | ||
40290 | M(t, den6, num); | ||
40291 | M(t, t, den); | ||
40292 | |||
40293 | pow2523(t, t); | ||
40294 | M(t, t, num); | ||
40295 | M(t, t, den); | ||
40296 | M(t, t, den); | ||
40297 | M(r[0], t, den); | ||
40298 | |||
40299 | S(chk, r[0]); | ||
40300 | M(chk, chk, den); | ||
40301 | if (neq25519(chk, num)) M(r[0], r[0], I); | ||
40302 | |||
40303 | S(chk, r[0]); | ||
40304 | M(chk, chk, den); | ||
40305 | if (neq25519(chk, num)) return -1; | ||
40306 | |||
40307 | if (par25519(r[0]) === (p[31]>>7)) Z(r[0], gf0, r[0]); | ||
40308 | |||
40309 | M(r[3], r[0], r[1]); | ||
40310 | return 0; | ||
40311 | } | ||
40312 | |||
40313 | function crypto_sign_open(m, sm, n, pk) { | ||
40314 | var i, mlen; | ||
40315 | var t = new Uint8Array(32), h = new Uint8Array(64); | ||
40316 | var p = [gf(), gf(), gf(), gf()], | ||
40317 | q = [gf(), gf(), gf(), gf()]; | ||
40318 | |||
40319 | mlen = -1; | ||
40320 | if (n < 64) return -1; | ||
40321 | |||
40322 | if (unpackneg(q, pk)) return -1; | ||
40323 | |||
40324 | for (i = 0; i < n; i++) m[i] = sm[i]; | ||
40325 | for (i = 0; i < 32; i++) m[i+32] = pk[i]; | ||
40326 | crypto_hash(h, m, n); | ||
40327 | reduce(h); | ||
40328 | scalarmult(p, q, h); | ||
40329 | |||
40330 | scalarbase(q, sm.subarray(32)); | ||
40331 | add(p, q); | ||
40332 | pack(t, p); | ||
40333 | |||
40334 | n -= 64; | ||
40335 | if (crypto_verify_32(sm, 0, t, 0)) { | ||
40336 | for (i = 0; i < n; i++) m[i] = 0; | ||
40337 | return -1; | ||
40338 | } | ||
40339 | |||
40340 | for (i = 0; i < n; i++) m[i] = sm[i + 64]; | ||
40341 | mlen = n; | ||
40342 | return mlen; | ||
40343 | } | ||
40344 | |||
40345 | var crypto_secretbox_KEYBYTES = 32, | ||
40346 | crypto_secretbox_NONCEBYTES = 24, | ||
40347 | crypto_secretbox_ZEROBYTES = 32, | ||
40348 | crypto_secretbox_BOXZEROBYTES = 16, | ||
40349 | crypto_scalarmult_BYTES = 32, | ||
40350 | crypto_scalarmult_SCALARBYTES = 32, | ||
40351 | crypto_box_PUBLICKEYBYTES = 32, | ||
40352 | crypto_box_SECRETKEYBYTES = 32, | ||
40353 | crypto_box_BEFORENMBYTES = 32, | ||
40354 | crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES, | ||
40355 | crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES, | ||
40356 | crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES, | ||
40357 | crypto_sign_BYTES = 64, | ||
40358 | crypto_sign_PUBLICKEYBYTES = 32, | ||
40359 | crypto_sign_SECRETKEYBYTES = 64, | ||
40360 | crypto_sign_SEEDBYTES = 32, | ||
40361 | crypto_hash_BYTES = 64; | ||
40362 | |||
40363 | nacl.lowlevel = { | ||
40364 | crypto_core_hsalsa20: crypto_core_hsalsa20, | ||
40365 | crypto_stream_xor: crypto_stream_xor, | ||
40366 | crypto_stream: crypto_stream, | ||
40367 | crypto_stream_salsa20_xor: crypto_stream_salsa20_xor, | ||
40368 | crypto_stream_salsa20: crypto_stream_salsa20, | ||
40369 | crypto_onetimeauth: crypto_onetimeauth, | ||
40370 | crypto_onetimeauth_verify: crypto_onetimeauth_verify, | ||
40371 | crypto_verify_16: crypto_verify_16, | ||
40372 | crypto_verify_32: crypto_verify_32, | ||
40373 | crypto_secretbox: crypto_secretbox, | ||
40374 | crypto_secretbox_open: crypto_secretbox_open, | ||
40375 | crypto_scalarmult: crypto_scalarmult, | ||
40376 | crypto_scalarmult_base: crypto_scalarmult_base, | ||
40377 | crypto_box_beforenm: crypto_box_beforenm, | ||
40378 | crypto_box_afternm: crypto_box_afternm, | ||
40379 | crypto_box: crypto_box, | ||
40380 | crypto_box_open: crypto_box_open, | ||
40381 | crypto_box_keypair: crypto_box_keypair, | ||
40382 | crypto_hash: crypto_hash, | ||
40383 | crypto_sign: crypto_sign, | ||
40384 | crypto_sign_keypair: crypto_sign_keypair, | ||
40385 | crypto_sign_open: crypto_sign_open, | ||
40386 | |||
40387 | crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES, | ||
40388 | crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES, | ||
40389 | crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES, | ||
40390 | crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES, | ||
40391 | crypto_scalarmult_BYTES: crypto_scalarmult_BYTES, | ||
40392 | crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES, | ||
40393 | crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES, | ||
40394 | crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES, | ||
40395 | crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES, | ||
40396 | crypto_box_NONCEBYTES: crypto_box_NONCEBYTES, | ||
40397 | crypto_box_ZEROBYTES: crypto_box_ZEROBYTES, | ||
40398 | crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES, | ||
40399 | crypto_sign_BYTES: crypto_sign_BYTES, | ||
40400 | crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES, | ||
40401 | crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES, | ||
40402 | crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES, | ||
40403 | crypto_hash_BYTES: crypto_hash_BYTES | ||
40404 | }; | ||
40405 | |||
40406 | /* High-level API */ | ||
40407 | |||
40408 | function checkLengths(k, n) { | ||
40409 | if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size'); | ||
40410 | if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size'); | ||
40411 | } | ||
40412 | |||
40413 | function checkBoxLengths(pk, sk) { | ||
40414 | if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error('bad public key size'); | ||
40415 | if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error('bad secret key size'); | ||
40416 | } | ||
40417 | |||
40418 | function checkArrayTypes() { | ||
40419 | for (var i = 0; i < arguments.length; i++) { | ||
40420 | if (!(arguments[i] instanceof Uint8Array)) | ||
40421 | throw new TypeError('unexpected type, use Uint8Array'); | ||
40422 | } | ||
40423 | } | ||
40424 | |||
40425 | function cleanup(arr) { | ||
40426 | for (var i = 0; i < arr.length; i++) arr[i] = 0; | ||
40427 | } | ||
40428 | |||
40429 | nacl.randomBytes = function(n) { | ||
40430 | var b = new Uint8Array(n); | ||
40431 | randombytes(b, n); | ||
40432 | return b; | ||
40433 | }; | ||
40434 | |||
40435 | nacl.secretbox = function(msg, nonce, key) { | ||
40436 | checkArrayTypes(msg, nonce, key); | ||
40437 | checkLengths(key, nonce); | ||
40438 | var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length); | ||
40439 | var c = new Uint8Array(m.length); | ||
40440 | for (var i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i]; | ||
40441 | crypto_secretbox(c, m, m.length, nonce, key); | ||
40442 | return c.subarray(crypto_secretbox_BOXZEROBYTES); | ||
40443 | }; | ||
40444 | |||
40445 | nacl.secretbox.open = function(box, nonce, key) { | ||
40446 | checkArrayTypes(box, nonce, key); | ||
40447 | checkLengths(key, nonce); | ||
40448 | var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length); | ||
40449 | var m = new Uint8Array(c.length); | ||
40450 | for (var i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i]; | ||
40451 | if (c.length < 32) return null; | ||
40452 | if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null; | ||
40453 | return m.subarray(crypto_secretbox_ZEROBYTES); | ||
40454 | }; | ||
40455 | |||
40456 | nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES; | ||
40457 | nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES; | ||
40458 | nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES; | ||
40459 | |||
40460 | nacl.scalarMult = function(n, p) { | ||
40461 | checkArrayTypes(n, p); | ||
40462 | if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size'); | ||
40463 | if (p.length !== crypto_scalarmult_BYTES) throw new Error('bad p size'); | ||
40464 | var q = new Uint8Array(crypto_scalarmult_BYTES); | ||
40465 | crypto_scalarmult(q, n, p); | ||
40466 | return q; | ||
40467 | }; | ||
40468 | |||
40469 | nacl.scalarMult.base = function(n) { | ||
40470 | checkArrayTypes(n); | ||
40471 | if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size'); | ||
40472 | var q = new Uint8Array(crypto_scalarmult_BYTES); | ||
40473 | crypto_scalarmult_base(q, n); | ||
40474 | return q; | ||
40475 | }; | ||
40476 | |||
40477 | nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES; | ||
40478 | nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES; | ||
40479 | |||
40480 | nacl.box = function(msg, nonce, publicKey, secretKey) { | ||
40481 | var k = nacl.box.before(publicKey, secretKey); | ||
40482 | return nacl.secretbox(msg, nonce, k); | ||
40483 | }; | ||
40484 | |||
40485 | nacl.box.before = function(publicKey, secretKey) { | ||
40486 | checkArrayTypes(publicKey, secretKey); | ||
40487 | checkBoxLengths(publicKey, secretKey); | ||
40488 | var k = new Uint8Array(crypto_box_BEFORENMBYTES); | ||
40489 | crypto_box_beforenm(k, publicKey, secretKey); | ||
40490 | return k; | ||
40491 | }; | ||
40492 | |||
40493 | nacl.box.after = nacl.secretbox; | ||
40494 | |||
40495 | nacl.box.open = function(msg, nonce, publicKey, secretKey) { | ||
40496 | var k = nacl.box.before(publicKey, secretKey); | ||
40497 | return nacl.secretbox.open(msg, nonce, k); | ||
40498 | }; | ||
40499 | |||
40500 | nacl.box.open.after = nacl.secretbox.open; | ||
40501 | |||
40502 | nacl.box.keyPair = function() { | ||
40503 | var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES); | ||
40504 | var sk = new Uint8Array(crypto_box_SECRETKEYBYTES); | ||
40505 | crypto_box_keypair(pk, sk); | ||
40506 | return {publicKey: pk, secretKey: sk}; | ||
40507 | }; | ||
40508 | |||
40509 | nacl.box.keyPair.fromSecretKey = function(secretKey) { | ||
40510 | checkArrayTypes(secretKey); | ||
40511 | if (secretKey.length !== crypto_box_SECRETKEYBYTES) | ||
40512 | throw new Error('bad secret key size'); | ||
40513 | var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES); | ||
40514 | crypto_scalarmult_base(pk, secretKey); | ||
40515 | return {publicKey: pk, secretKey: new Uint8Array(secretKey)}; | ||
40516 | }; | ||
40517 | |||
40518 | nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES; | ||
40519 | nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES; | ||
40520 | nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES; | ||
40521 | nacl.box.nonceLength = crypto_box_NONCEBYTES; | ||
40522 | nacl.box.overheadLength = nacl.secretbox.overheadLength; | ||
40523 | |||
40524 | nacl.sign = function(msg, secretKey) { | ||
40525 | checkArrayTypes(msg, secretKey); | ||
40526 | if (secretKey.length !== crypto_sign_SECRETKEYBYTES) | ||
40527 | throw new Error('bad secret key size'); | ||
40528 | var signedMsg = new Uint8Array(crypto_sign_BYTES+msg.length); | ||
40529 | crypto_sign(signedMsg, msg, msg.length, secretKey); | ||
40530 | return signedMsg; | ||
40531 | }; | ||
40532 | |||
40533 | nacl.sign.open = function(signedMsg, publicKey) { | ||
40534 | checkArrayTypes(signedMsg, publicKey); | ||
40535 | if (publicKey.length !== crypto_sign_PUBLICKEYBYTES) | ||
40536 | throw new Error('bad public key size'); | ||
40537 | var tmp = new Uint8Array(signedMsg.length); | ||
40538 | var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey); | ||
40539 | if (mlen < 0) return null; | ||
40540 | var m = new Uint8Array(mlen); | ||
40541 | for (var i = 0; i < m.length; i++) m[i] = tmp[i]; | ||
40542 | return m; | ||
40543 | }; | ||
40544 | |||
40545 | nacl.sign.detached = function(msg, secretKey) { | ||
40546 | var signedMsg = nacl.sign(msg, secretKey); | ||
40547 | var sig = new Uint8Array(crypto_sign_BYTES); | ||
40548 | for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i]; | ||
40549 | return sig; | ||
40550 | }; | ||
40551 | |||
40552 | nacl.sign.detached.verify = function(msg, sig, publicKey) { | ||
40553 | checkArrayTypes(msg, sig, publicKey); | ||
40554 | if (sig.length !== crypto_sign_BYTES) | ||
40555 | throw new Error('bad signature size'); | ||
40556 | if (publicKey.length !== crypto_sign_PUBLICKEYBYTES) | ||
40557 | throw new Error('bad public key size'); | ||
40558 | var sm = new Uint8Array(crypto_sign_BYTES + msg.length); | ||
40559 | var m = new Uint8Array(crypto_sign_BYTES + msg.length); | ||
40560 | var i; | ||
40561 | for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i]; | ||
40562 | for (i = 0; i < msg.length; i++) sm[i+crypto_sign_BYTES] = msg[i]; | ||
40563 | return (crypto_sign_open(m, sm, sm.length, publicKey) >= 0); | ||
40564 | }; | ||
40565 | |||
40566 | nacl.sign.keyPair = function() { | ||
40567 | var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES); | ||
40568 | var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES); | ||
40569 | crypto_sign_keypair(pk, sk); | ||
40570 | return {publicKey: pk, secretKey: sk}; | ||
40571 | }; | ||
40572 | |||
40573 | nacl.sign.keyPair.fromSecretKey = function(secretKey) { | ||
40574 | checkArrayTypes(secretKey); | ||
40575 | if (secretKey.length !== crypto_sign_SECRETKEYBYTES) | ||
40576 | throw new Error('bad secret key size'); | ||
40577 | var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES); | ||
40578 | for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32+i]; | ||
40579 | return {publicKey: pk, secretKey: new Uint8Array(secretKey)}; | ||
40580 | }; | ||
40581 | |||
40582 | nacl.sign.keyPair.fromSeed = function(seed) { | ||
40583 | checkArrayTypes(seed); | ||
40584 | if (seed.length !== crypto_sign_SEEDBYTES) | ||
40585 | throw new Error('bad seed size'); | ||
40586 | var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES); | ||
40587 | var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES); | ||
40588 | for (var i = 0; i < 32; i++) sk[i] = seed[i]; | ||
40589 | crypto_sign_keypair(pk, sk, true); | ||
40590 | return {publicKey: pk, secretKey: sk}; | ||
40591 | }; | ||
40592 | |||
40593 | nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES; | ||
40594 | nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES; | ||
40595 | nacl.sign.seedLength = crypto_sign_SEEDBYTES; | ||
40596 | nacl.sign.signatureLength = crypto_sign_BYTES; | ||
40597 | |||
40598 | nacl.hash = function(msg) { | ||
40599 | checkArrayTypes(msg); | ||
40600 | var h = new Uint8Array(crypto_hash_BYTES); | ||
40601 | crypto_hash(h, msg, msg.length); | ||
40602 | return h; | ||
40603 | }; | ||
40604 | |||
40605 | nacl.hash.hashLength = crypto_hash_BYTES; | ||
40606 | |||
40607 | nacl.verify = function(x, y) { | ||
40608 | checkArrayTypes(x, y); | ||
40609 | // Zero length arguments are considered not equal. | ||
40610 | if (x.length === 0 || y.length === 0) return false; | ||
40611 | if (x.length !== y.length) return false; | ||
40612 | return (vn(x, 0, y, 0, x.length) === 0) ? true : false; | ||
40613 | }; | ||
40614 | |||
40615 | nacl.setPRNG = function(fn) { | ||
40616 | randombytes = fn; | ||
40617 | }; | ||
40618 | |||
40619 | (function() { | ||
40620 | // Initialize PRNG if environment provides CSPRNG. | ||
40621 | // If not, methods calling randombytes will throw. | ||
40622 | var crypto = typeof self !== 'undefined' ? (self.crypto || self.msCrypto) : null; | ||
40623 | if (crypto && crypto.getRandomValues) { | ||
40624 | // Browsers. | ||
40625 | var QUOTA = 65536; | ||
40626 | nacl.setPRNG(function(x, n) { | ||
40627 | var i, v = new Uint8Array(n); | ||
40628 | for (i = 0; i < n; i += QUOTA) { | ||
40629 | crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA))); | ||
40630 | } | ||
40631 | for (i = 0; i < n; i++) x[i] = v[i]; | ||
40632 | cleanup(v); | ||
40633 | }); | ||
40634 | } else if (typeof require !== 'undefined') { | ||
40635 | // Node.js. | ||
40636 | crypto = require('crypto'); | ||
40637 | if (crypto && crypto.randomBytes) { | ||
40638 | nacl.setPRNG(function(x, n) { | ||
40639 | var i, v = crypto.randomBytes(n); | ||
40640 | for (i = 0; i < n; i++) x[i] = v[i]; | ||
40641 | cleanup(v); | ||
40642 | }); | ||
40643 | } | ||
40644 | } | ||
40645 | })(); | ||
40646 | |||
40647 | })(typeof module !== 'undefined' && module.exports ? module.exports : (self.nacl = self.nacl || {})); | ||
40648 | |||
40649 | },{"crypto":20}],436:[function(require,module,exports){ | ||
40650 | (function (global){ | ||
40651 | |||
40652 | /** | ||
40653 | * Module exports. | ||
40654 | */ | ||
40655 | |||
40656 | module.exports = deprecate; | ||
40657 | |||
40658 | /** | ||
40659 | * Mark that a method should not be used. | ||
40660 | * Returns a modified function which warns once by default. | ||
40661 | * | ||
40662 | * If `localStorage.noDeprecation = true` is set, then it is a no-op. | ||
40663 | * | ||
40664 | * If `localStorage.throwDeprecation = true` is set, then deprecated functions | ||
40665 | * will throw an Error when invoked. | ||
40666 | * | ||
40667 | * If `localStorage.traceDeprecation = true` is set, then deprecated functions | ||
40668 | * will invoke `console.trace()` instead of `console.error()`. | ||
40669 | * | ||
40670 | * @param {Function} fn - the function to deprecate | ||
40671 | * @param {String} msg - the string to print to the console when `fn` is invoked | ||
40672 | * @returns {Function} a new "deprecated" version of `fn` | ||
40673 | * @api public | ||
40674 | */ | ||
40675 | |||
40676 | function deprecate (fn, msg) { | ||
40677 | if (config('noDeprecation')) { | ||
40678 | return fn; | ||
40679 | } | ||
40680 | |||
40681 | var warned = false; | ||
40682 | function deprecated() { | ||
40683 | if (!warned) { | ||
40684 | if (config('throwDeprecation')) { | ||
40685 | throw new Error(msg); | ||
40686 | } else if (config('traceDeprecation')) { | ||
40687 | console.trace(msg); | ||
40688 | } else { | ||
40689 | console.warn(msg); | ||
40690 | } | ||
40691 | warned = true; | ||
40692 | } | ||
40693 | return fn.apply(this, arguments); | ||
40694 | } | ||
40695 | |||
40696 | return deprecated; | ||
40697 | } | ||
40698 | |||
40699 | /** | ||
40700 | * Checks `localStorage` for boolean values for the given `name`. | ||
40701 | * | ||
40702 | * @param {String} name | ||
40703 | * @returns {Boolean} | ||
40704 | * @api private | ||
40705 | */ | ||
40706 | |||
40707 | function config (name) { | ||
40708 | // accessing global.localStorage can trigger a DOMException in sandboxed iframes | ||
40709 | try { | ||
40710 | if (!global.localStorage) return false; | ||
40711 | } catch (_) { | ||
40712 | return false; | ||
40713 | } | ||
40714 | var val = global.localStorage[name]; | ||
40715 | if (null == val) return false; | ||
40716 | return String(val).toLowerCase() === 'true'; | ||
40717 | } | ||
40718 | |||
40719 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | ||
40720 | },{}],437:[function(require,module,exports){ | ||
40721 | module.exports = function isBuffer(arg) { | ||
40722 | return arg && typeof arg === 'object' | ||
40723 | && typeof arg.copy === 'function' | ||
40724 | && typeof arg.fill === 'function' | ||
40725 | && typeof arg.readUInt8 === 'function'; | ||
40726 | } | ||
40727 | },{}],438:[function(require,module,exports){ | ||
40728 | (function (process,global){ | ||
40729 | // Copyright Joyent, Inc. and other Node contributors. | ||
40730 | // | ||
40731 | // Permission is hereby granted, free of charge, to any person obtaining a | ||
40732 | // copy of this software and associated documentation files (the | ||
40733 | // "Software"), to deal in the Software without restriction, including | ||
40734 | // without limitation the rights to use, copy, modify, merge, publish, | ||
40735 | // distribute, sublicense, and/or sell copies of the Software, and to permit | ||
40736 | // persons to whom the Software is furnished to do so, subject to the | ||
40737 | // following conditions: | ||
40738 | // | ||
40739 | // The above copyright notice and this permission notice shall be included | ||
40740 | // in all copies or substantial portions of the Software. | ||
40741 | // | ||
40742 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
40743 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
40744 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | ||
40745 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | ||
40746 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | ||
40747 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | ||
40748 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
40749 | |||
40750 | var formatRegExp = /%[sdj%]/g; | ||
40751 | exports.format = function(f) { | ||
40752 | if (!isString(f)) { | ||
40753 | var objects = []; | ||
40754 | for (var i = 0; i < arguments.length; i++) { | ||
40755 | objects.push(inspect(arguments[i])); | ||
40756 | } | ||
40757 | return objects.join(' '); | ||
40758 | } | ||
40759 | |||
40760 | var i = 1; | ||
40761 | var args = arguments; | ||
40762 | var len = args.length; | ||
40763 | var str = String(f).replace(formatRegExp, function(x) { | ||
40764 | if (x === '%%') return '%'; | ||
40765 | if (i >= len) return x; | ||
40766 | switch (x) { | ||
40767 | case '%s': return String(args[i++]); | ||
40768 | case '%d': return Number(args[i++]); | ||
40769 | case '%j': | ||
40770 | try { | ||
40771 | return JSON.stringify(args[i++]); | ||
40772 | } catch (_) { | ||
40773 | return '[Circular]'; | ||
40774 | } | ||
40775 | default: | ||
40776 | return x; | ||
40777 | } | ||
40778 | }); | ||
40779 | for (var x = args[i]; i < len; x = args[++i]) { | ||
40780 | if (isNull(x) || !isObject(x)) { | ||
40781 | str += ' ' + x; | ||
40782 | } else { | ||
40783 | str += ' ' + inspect(x); | ||
40784 | } | ||
40785 | } | ||
40786 | return str; | ||
40787 | }; | ||
40788 | |||
40789 | |||
40790 | // Mark that a method should not be used. | ||
40791 | // Returns a modified function which warns once by default. | ||
40792 | // If --no-deprecation is set, then it is a no-op. | ||
40793 | exports.deprecate = function(fn, msg) { | ||
40794 | // Allow for deprecating things in the process of starting up. | ||
40795 | if (isUndefined(global.process)) { | ||
40796 | return function() { | ||
40797 | return exports.deprecate(fn, msg).apply(this, arguments); | ||
40798 | }; | ||
40799 | } | ||
40800 | |||
40801 | if (process.noDeprecation === true) { | ||
40802 | return fn; | ||
40803 | } | ||
40804 | |||
40805 | var warned = false; | ||
40806 | function deprecated() { | ||
40807 | if (!warned) { | ||
40808 | if (process.throwDeprecation) { | ||
40809 | throw new Error(msg); | ||
40810 | } else if (process.traceDeprecation) { | ||
40811 | console.trace(msg); | ||
40812 | } else { | ||
40813 | console.error(msg); | ||
40814 | } | ||
40815 | warned = true; | ||
40816 | } | ||
40817 | return fn.apply(this, arguments); | ||
40818 | } | ||
40819 | |||
40820 | return deprecated; | ||
40821 | }; | ||
40822 | |||
40823 | |||
40824 | var debugs = {}; | ||
40825 | var debugEnviron; | ||
40826 | exports.debuglog = function(set) { | ||
40827 | if (isUndefined(debugEnviron)) | ||
40828 | debugEnviron = process.env.NODE_DEBUG || ''; | ||
40829 | set = set.toUpperCase(); | ||
40830 | if (!debugs[set]) { | ||
40831 | if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { | ||
40832 | var pid = process.pid; | ||
40833 | debugs[set] = function() { | ||
40834 | var msg = exports.format.apply(exports, arguments); | ||
40835 | console.error('%s %d: %s', set, pid, msg); | ||
40836 | }; | ||
40837 | } else { | ||
40838 | debugs[set] = function() {}; | ||
40839 | } | ||
40840 | } | ||
40841 | return debugs[set]; | ||
40842 | }; | ||
40843 | |||
40844 | |||
40845 | /** | ||
40846 | * Echos the value of a value. Trys to print the value out | ||
40847 | * in the best way possible given the different types. | ||
40848 | * | ||
40849 | * @param {Object} obj The object to print out. | ||
40850 | * @param {Object} opts Optional options object that alters the output. | ||
40851 | */ | ||
40852 | /* legacy: obj, showHidden, depth, colors*/ | ||
40853 | function inspect(obj, opts) { | ||
40854 | // default options | ||
40855 | var ctx = { | ||
40856 | seen: [], | ||
40857 | stylize: stylizeNoColor | ||
40858 | }; | ||
40859 | // legacy... | ||
40860 | if (arguments.length >= 3) ctx.depth = arguments[2]; | ||
40861 | if (arguments.length >= 4) ctx.colors = arguments[3]; | ||
40862 | if (isBoolean(opts)) { | ||
40863 | // legacy... | ||
40864 | ctx.showHidden = opts; | ||
40865 | } else if (opts) { | ||
40866 | // got an "options" object | ||
40867 | exports._extend(ctx, opts); | ||
40868 | } | ||
40869 | // set default options | ||
40870 | if (isUndefined(ctx.showHidden)) ctx.showHidden = false; | ||
40871 | if (isUndefined(ctx.depth)) ctx.depth = 2; | ||
40872 | if (isUndefined(ctx.colors)) ctx.colors = false; | ||
40873 | if (isUndefined(ctx.customInspect)) ctx.customInspect = true; | ||
40874 | if (ctx.colors) ctx.stylize = stylizeWithColor; | ||
40875 | return formatValue(ctx, obj, ctx.depth); | ||
40876 | } | ||
40877 | exports.inspect = inspect; | ||
40878 | |||
40879 | |||
40880 | // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics | ||
40881 | inspect.colors = { | ||
40882 | 'bold' : [1, 22], | ||
40883 | 'italic' : [3, 23], | ||
40884 | 'underline' : [4, 24], | ||
40885 | 'inverse' : [7, 27], | ||
40886 | 'white' : [37, 39], | ||
40887 | 'grey' : [90, 39], | ||
40888 | 'black' : [30, 39], | ||
40889 | 'blue' : [34, 39], | ||
40890 | 'cyan' : [36, 39], | ||
40891 | 'green' : [32, 39], | ||
40892 | 'magenta' : [35, 39], | ||
40893 | 'red' : [31, 39], | ||
40894 | 'yellow' : [33, 39] | ||
40895 | }; | ||
40896 | |||
40897 | // Don't use 'blue' not visible on cmd.exe | ||
40898 | inspect.styles = { | ||
40899 | 'special': 'cyan', | ||
40900 | 'number': 'yellow', | ||
40901 | 'boolean': 'yellow', | ||
40902 | 'undefined': 'grey', | ||
40903 | 'null': 'bold', | ||
40904 | 'string': 'green', | ||
40905 | 'date': 'magenta', | ||
40906 | // "name": intentionally not styling | ||
40907 | 'regexp': 'red' | ||
40908 | }; | ||
40909 | |||
40910 | |||
40911 | function stylizeWithColor(str, styleType) { | ||
40912 | var style = inspect.styles[styleType]; | ||
40913 | |||
40914 | if (style) { | ||
40915 | return '\u001b[' + inspect.colors[style][0] + 'm' + str + | ||
40916 | '\u001b[' + inspect.colors[style][1] + 'm'; | ||
40917 | } else { | ||
40918 | return str; | ||
40919 | } | ||
40920 | } | ||
40921 | |||
40922 | |||
40923 | function stylizeNoColor(str, styleType) { | ||
40924 | return str; | ||
40925 | } | ||
40926 | |||
40927 | |||
40928 | function arrayToHash(array) { | ||
40929 | var hash = {}; | ||
40930 | |||
40931 | array.forEach(function(val, idx) { | ||
40932 | hash[val] = true; | ||
40933 | }); | ||
40934 | |||
40935 | return hash; | ||
40936 | } | ||
40937 | |||
40938 | |||
40939 | function formatValue(ctx, value, recurseTimes) { | ||
40940 | // Provide a hook for user-specified inspect functions. | ||
40941 | // Check that value is an object with an inspect function on it | ||
40942 | if (ctx.customInspect && | ||
40943 | value && | ||
40944 | isFunction(value.inspect) && | ||
40945 | // Filter out the util module, it's inspect function is special | ||
40946 | value.inspect !== exports.inspect && | ||
40947 | // Also filter out any prototype objects using the circular check. | ||
40948 | !(value.constructor && value.constructor.prototype === value)) { | ||
40949 | var ret = value.inspect(recurseTimes, ctx); | ||
40950 | if (!isString(ret)) { | ||
40951 | ret = formatValue(ctx, ret, recurseTimes); | ||
40952 | } | ||
40953 | return ret; | ||
40954 | } | ||
40955 | |||
40956 | // Primitive types cannot have properties | ||
40957 | var primitive = formatPrimitive(ctx, value); | ||
40958 | if (primitive) { | ||
40959 | return primitive; | ||
40960 | } | ||
40961 | |||
40962 | // Look up the keys of the object. | ||
40963 | var keys = Object.keys(value); | ||
40964 | var visibleKeys = arrayToHash(keys); | ||
40965 | |||
40966 | if (ctx.showHidden) { | ||
40967 | keys = Object.getOwnPropertyNames(value); | ||
40968 | } | ||
40969 | |||
40970 | // IE doesn't make error fields non-enumerable | ||
40971 | // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx | ||
40972 | if (isError(value) | ||
40973 | && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { | ||
40974 | return formatError(value); | ||
40975 | } | ||
40976 | |||
40977 | // Some type of object without properties can be shortcutted. | ||
40978 | if (keys.length === 0) { | ||
40979 | if (isFunction(value)) { | ||
40980 | var name = value.name ? ': ' + value.name : ''; | ||
40981 | return ctx.stylize('[Function' + name + ']', 'special'); | ||
40982 | } | ||
40983 | if (isRegExp(value)) { | ||
40984 | return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | ||
40985 | } | ||
40986 | if (isDate(value)) { | ||
40987 | return ctx.stylize(Date.prototype.toString.call(value), 'date'); | ||
40988 | } | ||
40989 | if (isError(value)) { | ||
40990 | return formatError(value); | ||
40991 | } | ||
40992 | } | ||
40993 | |||
40994 | var base = '', array = false, braces = ['{', '}']; | ||
40995 | |||
40996 | // Make Array say that they are Array | ||
40997 | if (isArray(value)) { | ||
40998 | array = true; | ||
40999 | braces = ['[', ']']; | ||
41000 | } | ||
41001 | |||
41002 | // Make functions say that they are functions | ||
41003 | if (isFunction(value)) { | ||
41004 | var n = value.name ? ': ' + value.name : ''; | ||
41005 | base = ' [Function' + n + ']'; | ||
41006 | } | ||
41007 | |||
41008 | // Make RegExps say that they are RegExps | ||
41009 | if (isRegExp(value)) { | ||
41010 | base = ' ' + RegExp.prototype.toString.call(value); | ||
41011 | } | ||
41012 | |||
41013 | // Make dates with properties first say the date | ||
41014 | if (isDate(value)) { | ||
41015 | base = ' ' + Date.prototype.toUTCString.call(value); | ||
41016 | } | ||
41017 | |||
41018 | // Make error with message first say the error | ||
41019 | if (isError(value)) { | ||
41020 | base = ' ' + formatError(value); | ||
41021 | } | ||
41022 | |||
41023 | if (keys.length === 0 && (!array || value.length == 0)) { | ||
41024 | return braces[0] + base + braces[1]; | ||
41025 | } | ||
41026 | |||
41027 | if (recurseTimes < 0) { | ||
41028 | if (isRegExp(value)) { | ||
41029 | return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | ||
41030 | } else { | ||
41031 | return ctx.stylize('[Object]', 'special'); | ||
41032 | } | ||
41033 | } | ||
41034 | |||
41035 | ctx.seen.push(value); | ||
41036 | |||
41037 | var output; | ||
41038 | if (array) { | ||
41039 | output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); | ||
41040 | } else { | ||
41041 | output = keys.map(function(key) { | ||
41042 | return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); | ||
41043 | }); | ||
41044 | } | ||
41045 | |||
41046 | ctx.seen.pop(); | ||
41047 | |||
41048 | return reduceToSingleString(output, base, braces); | ||
41049 | } | ||
41050 | |||
41051 | |||
41052 | function formatPrimitive(ctx, value) { | ||
41053 | if (isUndefined(value)) | ||
41054 | return ctx.stylize('undefined', 'undefined'); | ||
41055 | if (isString(value)) { | ||
41056 | var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') | ||
41057 | .replace(/'/g, "\\'") | ||
41058 | .replace(/\\"/g, '"') + '\''; | ||
41059 | return ctx.stylize(simple, 'string'); | ||
41060 | } | ||
41061 | if (isNumber(value)) | ||
41062 | return ctx.stylize('' + value, 'number'); | ||
41063 | if (isBoolean(value)) | ||
41064 | return ctx.stylize('' + value, 'boolean'); | ||
41065 | // For some reason typeof null is "object", so special case here. | ||
41066 | if (isNull(value)) | ||
41067 | return ctx.stylize('null', 'null'); | ||
41068 | } | ||
41069 | |||
41070 | |||
41071 | function formatError(value) { | ||
41072 | return '[' + Error.prototype.toString.call(value) + ']'; | ||
41073 | } | ||
41074 | |||
41075 | |||
41076 | function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { | ||
41077 | var output = []; | ||
41078 | for (var i = 0, l = value.length; i < l; ++i) { | ||
41079 | if (hasOwnProperty(value, String(i))) { | ||
41080 | output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | ||
41081 | String(i), true)); | ||
41082 | } else { | ||
41083 | output.push(''); | ||
41084 | } | ||
41085 | } | ||
41086 | keys.forEach(function(key) { | ||
41087 | if (!key.match(/^\d+$/)) { | ||
41088 | output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | ||
41089 | key, true)); | ||
41090 | } | ||
41091 | }); | ||
41092 | return output; | ||
41093 | } | ||
41094 | |||
41095 | |||
41096 | function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { | ||
41097 | var name, str, desc; | ||
41098 | desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; | ||
41099 | if (desc.get) { | ||
41100 | if (desc.set) { | ||
41101 | str = ctx.stylize('[Getter/Setter]', 'special'); | ||
41102 | } else { | ||
41103 | str = ctx.stylize('[Getter]', 'special'); | ||
41104 | } | ||
41105 | } else { | ||
41106 | if (desc.set) { | ||
41107 | str = ctx.stylize('[Setter]', 'special'); | ||
41108 | } | ||
41109 | } | ||
41110 | if (!hasOwnProperty(visibleKeys, key)) { | ||
41111 | name = '[' + key + ']'; | ||
41112 | } | ||
41113 | if (!str) { | ||
41114 | if (ctx.seen.indexOf(desc.value) < 0) { | ||
41115 | if (isNull(recurseTimes)) { | ||
41116 | str = formatValue(ctx, desc.value, null); | ||
41117 | } else { | ||
41118 | str = formatValue(ctx, desc.value, recurseTimes - 1); | ||
41119 | } | ||
41120 | if (str.indexOf('\n') > -1) { | ||
41121 | if (array) { | ||
41122 | str = str.split('\n').map(function(line) { | ||
41123 | return ' ' + line; | ||
41124 | }).join('\n').substr(2); | ||
41125 | } else { | ||
41126 | str = '\n' + str.split('\n').map(function(line) { | ||
41127 | return ' ' + line; | ||
41128 | }).join('\n'); | ||
41129 | } | ||
41130 | } | ||
41131 | } else { | ||
41132 | str = ctx.stylize('[Circular]', 'special'); | ||
41133 | } | ||
41134 | } | ||
41135 | if (isUndefined(name)) { | ||
41136 | if (array && key.match(/^\d+$/)) { | ||
41137 | return str; | ||
41138 | } | ||
41139 | name = JSON.stringify('' + key); | ||
41140 | if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { | ||
41141 | name = name.substr(1, name.length - 2); | ||
41142 | name = ctx.stylize(name, 'name'); | ||
41143 | } else { | ||
41144 | name = name.replace(/'/g, "\\'") | ||
41145 | .replace(/\\"/g, '"') | ||
41146 | .replace(/(^"|"$)/g, "'"); | ||
41147 | name = ctx.stylize(name, 'string'); | ||
41148 | } | ||
41149 | } | ||
41150 | |||
41151 | return name + ': ' + str; | ||
41152 | } | ||
41153 | |||
41154 | |||
41155 | function reduceToSingleString(output, base, braces) { | ||
41156 | var numLinesEst = 0; | ||
41157 | var length = output.reduce(function(prev, cur) { | ||
41158 | numLinesEst++; | ||
41159 | if (cur.indexOf('\n') >= 0) numLinesEst++; | ||
41160 | return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; | ||
41161 | }, 0); | ||
41162 | |||
41163 | if (length > 60) { | ||
41164 | return braces[0] + | ||
41165 | (base === '' ? '' : base + '\n ') + | ||
41166 | ' ' + | ||
41167 | output.join(',\n ') + | ||
41168 | ' ' + | ||
41169 | braces[1]; | ||
41170 | } | ||
41171 | |||
41172 | return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; | ||
41173 | } | ||
41174 | |||
41175 | |||
41176 | // NOTE: These type checking functions intentionally don't use `instanceof` | ||
41177 | // because it is fragile and can be easily faked with `Object.create()`. | ||
41178 | function isArray(ar) { | ||
41179 | return Array.isArray(ar); | ||
41180 | } | ||
41181 | exports.isArray = isArray; | ||
41182 | |||
41183 | function isBoolean(arg) { | ||
41184 | return typeof arg === 'boolean'; | ||
41185 | } | ||
41186 | exports.isBoolean = isBoolean; | ||
41187 | |||
41188 | function isNull(arg) { | ||
41189 | return arg === null; | ||
41190 | } | ||
41191 | exports.isNull = isNull; | ||
41192 | |||
41193 | function isNullOrUndefined(arg) { | ||
41194 | return arg == null; | ||
41195 | } | ||
41196 | exports.isNullOrUndefined = isNullOrUndefined; | ||
41197 | |||
41198 | function isNumber(arg) { | ||
41199 | return typeof arg === 'number'; | ||
41200 | } | ||
41201 | exports.isNumber = isNumber; | ||
41202 | |||
41203 | function isString(arg) { | ||
41204 | return typeof arg === 'string'; | ||
41205 | } | ||
41206 | exports.isString = isString; | ||
41207 | |||
41208 | function isSymbol(arg) { | ||
41209 | return typeof arg === 'symbol'; | ||
41210 | } | ||
41211 | exports.isSymbol = isSymbol; | ||
41212 | |||
41213 | function isUndefined(arg) { | ||
41214 | return arg === void 0; | ||
41215 | } | ||
41216 | exports.isUndefined = isUndefined; | ||
41217 | |||
41218 | function isRegExp(re) { | ||
41219 | return isObject(re) && objectToString(re) === '[object RegExp]'; | ||
41220 | } | ||
41221 | exports.isRegExp = isRegExp; | ||
41222 | |||
41223 | function isObject(arg) { | ||
41224 | return typeof arg === 'object' && arg !== null; | ||
41225 | } | ||
41226 | exports.isObject = isObject; | ||
41227 | |||
41228 | function isDate(d) { | ||
41229 | return isObject(d) && objectToString(d) === '[object Date]'; | ||
41230 | } | ||
41231 | exports.isDate = isDate; | ||
41232 | |||
41233 | function isError(e) { | ||
41234 | return isObject(e) && | ||
41235 | (objectToString(e) === '[object Error]' || e instanceof Error); | ||
41236 | } | ||
41237 | exports.isError = isError; | ||
41238 | |||
41239 | function isFunction(arg) { | ||
41240 | return typeof arg === 'function'; | ||
41241 | } | ||
41242 | exports.isFunction = isFunction; | ||
41243 | |||
41244 | function isPrimitive(arg) { | ||
41245 | return arg === null || | ||
41246 | typeof arg === 'boolean' || | ||
41247 | typeof arg === 'number' || | ||
41248 | typeof arg === 'string' || | ||
41249 | typeof arg === 'symbol' || // ES6 symbol | ||
41250 | typeof arg === 'undefined'; | ||
41251 | } | ||
41252 | exports.isPrimitive = isPrimitive; | ||
41253 | |||
41254 | exports.isBuffer = require('./support/isBuffer'); | ||
41255 | |||
41256 | function objectToString(o) { | ||
41257 | return Object.prototype.toString.call(o); | ||
41258 | } | ||
41259 | |||
41260 | |||
41261 | function pad(n) { | ||
41262 | return n < 10 ? '0' + n.toString(10) : n.toString(10); | ||
41263 | } | ||
41264 | |||
41265 | |||
41266 | var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', | ||
41267 | 'Oct', 'Nov', 'Dec']; | ||
41268 | |||
41269 | // 26 Feb 16:19:34 | ||
41270 | function timestamp() { | ||
41271 | var d = new Date(); | ||
41272 | var time = [pad(d.getHours()), | ||
41273 | pad(d.getMinutes()), | ||
41274 | pad(d.getSeconds())].join(':'); | ||
41275 | return [d.getDate(), months[d.getMonth()], time].join(' '); | ||
41276 | } | ||
41277 | |||
41278 | |||
41279 | // log is just a thin wrapper to console.log that prepends a timestamp | ||
41280 | exports.log = function() { | ||
41281 | console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); | ||
41282 | }; | ||
41283 | |||
41284 | |||
41285 | /** | ||
41286 | * Inherit the prototype methods from one constructor into another. | ||
41287 | * | ||
41288 | * The Function.prototype.inherits from lang.js rewritten as a standalone | ||
41289 | * function (not on Function.prototype). NOTE: If this file is to be loaded | ||
41290 | * during bootstrapping this function needs to be rewritten using some native | ||
41291 | * functions as prototype setup using normal JavaScript does not work as | ||
41292 | * expected during bootstrapping (see mirror.js in r114903). | ||
41293 | * | ||
41294 | * @param {function} ctor Constructor function which needs to inherit the | ||
41295 | * prototype. | ||
41296 | * @param {function} superCtor Constructor function to inherit prototype from. | ||
41297 | */ | ||
41298 | exports.inherits = require('inherits'); | ||
41299 | |||
41300 | exports._extend = function(origin, add) { | ||
41301 | // Don't do anything if add isn't an object | ||
41302 | if (!add || !isObject(add)) return origin; | ||
41303 | |||
41304 | var keys = Object.keys(add); | ||
41305 | var i = keys.length; | ||
41306 | while (i--) { | ||
41307 | origin[keys[i]] = add[keys[i]]; | ||
41308 | } | ||
41309 | return origin; | ||
41310 | }; | ||
41311 | |||
41312 | function hasOwnProperty(obj, prop) { | ||
41313 | return Object.prototype.hasOwnProperty.call(obj, prop); | ||
41314 | } | ||
41315 | |||
41316 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | ||
41317 | },{"./support/isBuffer":437,"_process":369,"inherits":116}],439:[function(require,module,exports){ | ||
41318 | var indexOf = function (xs, item) { | ||
41319 | if (xs.indexOf) return xs.indexOf(item); | ||
41320 | else for (var i = 0; i < xs.length; i++) { | ||
41321 | if (xs[i] === item) return i; | ||
41322 | } | ||
41323 | return -1; | ||
41324 | }; | ||
41325 | var Object_keys = function (obj) { | ||
41326 | if (Object.keys) return Object.keys(obj) | ||
41327 | else { | ||
41328 | var res = []; | ||
41329 | for (var key in obj) res.push(key) | ||
41330 | return res; | ||
41331 | } | ||
41332 | }; | ||
41333 | |||
41334 | var forEach = function (xs, fn) { | ||
41335 | if (xs.forEach) return xs.forEach(fn) | ||
41336 | else for (var i = 0; i < xs.length; i++) { | ||
41337 | fn(xs[i], i, xs); | ||
41338 | } | ||
41339 | }; | ||
41340 | |||
41341 | var defineProp = (function() { | ||
41342 | try { | ||
41343 | Object.defineProperty({}, '_', {}); | ||
41344 | return function(obj, name, value) { | ||
41345 | Object.defineProperty(obj, name, { | ||
41346 | writable: true, | ||
41347 | enumerable: false, | ||
41348 | configurable: true, | ||
41349 | value: value | ||
41350 | }) | ||
41351 | }; | ||
41352 | } catch(e) { | ||
41353 | return function(obj, name, value) { | ||
41354 | obj[name] = value; | ||
41355 | }; | ||
41356 | } | ||
41357 | }()); | ||
41358 | |||
41359 | var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function', | ||
41360 | 'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError', | ||
41361 | 'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError', | ||
41362 | 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', | ||
41363 | 'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape']; | ||
41364 | |||
41365 | function Context() {} | ||
41366 | Context.prototype = {}; | ||
41367 | |||
41368 | var Script = exports.Script = function NodeScript (code) { | ||
41369 | if (!(this instanceof Script)) return new Script(code); | ||
41370 | this.code = code; | ||
41371 | }; | ||
41372 | |||
41373 | Script.prototype.runInContext = function (context) { | ||
41374 | if (!(context instanceof Context)) { | ||
41375 | throw new TypeError("needs a 'context' argument."); | ||
41376 | } | ||
41377 | |||
41378 | var iframe = document.createElement('iframe'); | ||
41379 | if (!iframe.style) iframe.style = {}; | ||
41380 | iframe.style.display = 'none'; | ||
41381 | |||
41382 | document.body.appendChild(iframe); | ||
41383 | |||
41384 | var win = iframe.contentWindow; | ||
41385 | var wEval = win.eval, wExecScript = win.execScript; | ||
41386 | |||
41387 | if (!wEval && wExecScript) { | ||
41388 | // win.eval() magically appears when this is called in IE: | ||
41389 | wExecScript.call(win, 'null'); | ||
41390 | wEval = win.eval; | ||
41391 | } | ||
41392 | |||
41393 | forEach(Object_keys(context), function (key) { | ||
41394 | win[key] = context[key]; | ||
41395 | }); | ||
41396 | forEach(globals, function (key) { | ||
41397 | if (context[key]) { | ||
41398 | win[key] = context[key]; | ||
41399 | } | ||
41400 | }); | ||
41401 | |||
41402 | var winKeys = Object_keys(win); | ||
41403 | |||
41404 | var res = wEval.call(win, this.code); | ||
41405 | |||
41406 | forEach(Object_keys(win), function (key) { | ||
41407 | // Avoid copying circular objects like `top` and `window` by only | ||
41408 | // updating existing context properties or new properties in the `win` | ||
41409 | // that was only introduced after the eval. | ||
41410 | if (key in context || indexOf(winKeys, key) === -1) { | ||
41411 | context[key] = win[key]; | ||
41412 | } | ||
41413 | }); | ||
41414 | |||
41415 | forEach(globals, function (key) { | ||
41416 | if (!(key in context)) { | ||
41417 | defineProp(context, key, win[key]); | ||
41418 | } | ||
41419 | }); | ||
41420 | |||
41421 | document.body.removeChild(iframe); | ||
41422 | |||
41423 | return res; | ||
41424 | }; | ||
41425 | |||
41426 | Script.prototype.runInThisContext = function () { | ||
41427 | return eval(this.code); // maybe... | ||
41428 | }; | ||
41429 | |||
41430 | Script.prototype.runInNewContext = function (context) { | ||
41431 | var ctx = Script.createContext(context); | ||
41432 | var res = this.runInContext(ctx); | ||
41433 | |||
41434 | if (context) { | ||
41435 | forEach(Object_keys(ctx), function (key) { | ||
41436 | context[key] = ctx[key]; | ||
41437 | }); | ||
41438 | } | ||
41439 | |||
41440 | return res; | ||
41441 | }; | ||
41442 | |||
41443 | forEach(Object_keys(Script.prototype), function (name) { | ||
41444 | exports[name] = Script[name] = function (code) { | ||
41445 | var s = Script(code); | ||
41446 | return s[name].apply(s, [].slice.call(arguments, 1)); | ||
41447 | }; | ||
41448 | }); | ||
41449 | |||
41450 | exports.isContext = function (context) { | ||
41451 | return context instanceof Context; | ||
41452 | }; | ||
41453 | |||
41454 | exports.createScript = function (code) { | ||
41455 | return exports.Script(code); | ||
41456 | }; | ||
41457 | |||
41458 | exports.createContext = Script.createContext = function (context) { | ||
41459 | var copy = new Context(); | ||
41460 | if(typeof context === 'object') { | ||
41461 | forEach(Object_keys(context), function (key) { | ||
41462 | copy[key] = context[key]; | ||
41463 | }); | ||
41464 | } | ||
41465 | return copy; | ||
41466 | }; | ||
41467 | |||
41468 | },{}],440:[function(require,module,exports){ | ||
41469 | (function (Buffer){ | ||
41470 | const createHmac = require('create-hmac'); | ||
41471 | const StellarBase = require('stellar-base'); | ||
41472 | |||
41473 | window.stellarUtil = { | ||
41474 | |||
41475 | HARDENED_OFFSET: 0x80000000, | ||
41476 | ED25519_CURVE: 'ed25519 seed', | ||
41477 | |||
41478 | replaceDerive: (val) => val.replace("'", ''), | ||
41479 | |||
41480 | getMasterKeyFromSeed: function (seed) { | ||
41481 | const hmac = createHmac('sha512', this.ED25519_CURVE); | ||
41482 | const I = hmac.update(Buffer.from(seed, 'hex')).digest(); | ||
41483 | const IL = I.slice(0, 32); | ||
41484 | const IR = I.slice(32); | ||
41485 | return { | ||
41486 | key: IL, | ||
41487 | chainCode: IR, | ||
41488 | }; | ||
41489 | }, | ||
41490 | |||
41491 | CKDPriv: ({key, chainCode}, index) => { | ||
41492 | const indexBuffer = Buffer.allocUnsafe(4); | ||
41493 | indexBuffer.writeUInt32BE(index, 0); | ||
41494 | const data = Buffer.concat([Buffer.alloc(1, 0), key, indexBuffer]); | ||
41495 | const I = createHmac('sha512', chainCode) | ||
41496 | .update(data) | ||
41497 | .digest(); | ||
41498 | const IL = I.slice(0, 32); | ||
41499 | const IR = I.slice(32); | ||
41500 | return { | ||
41501 | key: IL, | ||
41502 | chainCode: IR, | ||
41503 | }; | ||
41504 | }, | ||
41505 | |||
41506 | derivePath: function (path, seed) { | ||
41507 | |||
41508 | const {key, chainCode} = this.getMasterKeyFromSeed(seed); | ||
41509 | const segments = path | ||
41510 | .split('/') | ||
41511 | .slice(1) | ||
41512 | .map(this.replaceDerive) | ||
41513 | .map(el => parseInt(el, 10)); | ||
41514 | const result = segments.reduce((parentKeys, segment) => this.CKDPriv(parentKeys, segment + this.HARDENED_OFFSET), {key, chainCode}); | ||
41515 | return StellarBase.Keypair.fromRawEd25519Seed(result.key); | ||
41516 | } | ||
41517 | } | ||
41518 | |||
41519 | }).call(this,require("buffer").Buffer) | ||
41520 | },{"buffer":49,"create-hmac":69,"stellar-base":407}]},{},[440]); | ||